1/* 2 * Copyright (C) 2006-2007 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#define LOG_TAG "AudioSystem" 18//#define LOG_NDEBUG 0 19 20#include <utils/Log.h> 21#include <binder/IServiceManager.h> 22#include <media/AudioSystem.h> 23#include <media/IAudioFlinger.h> 24#include <media/IAudioPolicyService.h> 25#include <math.h> 26 27#include <system/audio.h> 28 29// ---------------------------------------------------------------------------- 30 31namespace android { 32 33// client singleton for AudioFlinger binder interface 34Mutex AudioSystem::gLock; 35Mutex AudioSystem::gLockAPS; 36sp<IAudioFlinger> AudioSystem::gAudioFlinger; 37sp<AudioSystem::AudioFlingerClient> AudioSystem::gAudioFlingerClient; 38audio_error_callback AudioSystem::gAudioErrorCallback = NULL; 39dynamic_policy_callback AudioSystem::gDynPolicyCallback = NULL; 40 41 42// establish binder interface to AudioFlinger service 43const sp<IAudioFlinger> AudioSystem::get_audio_flinger() 44{ 45 sp<IAudioFlinger> af; 46 sp<AudioFlingerClient> afc; 47 { 48 Mutex::Autolock _l(gLock); 49 if (gAudioFlinger == 0) { 50 sp<IServiceManager> sm = defaultServiceManager(); 51 sp<IBinder> binder; 52 do { 53 binder = sm->getService(String16("media.audio_flinger")); 54 if (binder != 0) 55 break; 56 ALOGW("AudioFlinger not published, waiting..."); 57 usleep(500000); // 0.5 s 58 } while (true); 59 if (gAudioFlingerClient == NULL) { 60 gAudioFlingerClient = new AudioFlingerClient(); 61 } else { 62 if (gAudioErrorCallback) { 63 gAudioErrorCallback(NO_ERROR); 64 } 65 } 66 binder->linkToDeath(gAudioFlingerClient); 67 gAudioFlinger = interface_cast<IAudioFlinger>(binder); 68 LOG_ALWAYS_FATAL_IF(gAudioFlinger == 0); 69 afc = gAudioFlingerClient; 70 } 71 af = gAudioFlinger; 72 } 73 if (afc != 0) { 74 af->registerClient(afc); 75 } 76 return af; 77} 78 79const sp<AudioSystem::AudioFlingerClient> AudioSystem::getAudioFlingerClient() 80{ 81 // calling get_audio_flinger() will initialize gAudioFlingerClient if needed 82 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 83 if (af == 0) return 0; 84 Mutex::Autolock _l(gLock); 85 return gAudioFlingerClient; 86} 87 88sp<AudioIoDescriptor> AudioSystem::getIoDescriptor(audio_io_handle_t ioHandle) 89{ 90 sp<AudioIoDescriptor> desc; 91 const sp<AudioFlingerClient> afc = getAudioFlingerClient(); 92 if (afc != 0) { 93 desc = afc->getIoDescriptor(ioHandle); 94 } 95 return desc; 96} 97 98/* static */ status_t AudioSystem::checkAudioFlinger() 99{ 100 if (defaultServiceManager()->checkService(String16("media.audio_flinger")) != 0) { 101 return NO_ERROR; 102 } 103 return DEAD_OBJECT; 104} 105 106status_t AudioSystem::muteMicrophone(bool state) 107{ 108 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 109 if (af == 0) return PERMISSION_DENIED; 110 return af->setMicMute(state); 111} 112 113status_t AudioSystem::isMicrophoneMuted(bool* state) 114{ 115 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 116 if (af == 0) return PERMISSION_DENIED; 117 *state = af->getMicMute(); 118 return NO_ERROR; 119} 120 121status_t AudioSystem::setMasterVolume(float value) 122{ 123 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 124 if (af == 0) return PERMISSION_DENIED; 125 af->setMasterVolume(value); 126 return NO_ERROR; 127} 128 129status_t AudioSystem::setMasterMute(bool mute) 130{ 131 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 132 if (af == 0) return PERMISSION_DENIED; 133 af->setMasterMute(mute); 134 return NO_ERROR; 135} 136 137status_t AudioSystem::getMasterVolume(float* volume) 138{ 139 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 140 if (af == 0) return PERMISSION_DENIED; 141 *volume = af->masterVolume(); 142 return NO_ERROR; 143} 144 145status_t AudioSystem::getMasterMute(bool* mute) 146{ 147 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 148 if (af == 0) return PERMISSION_DENIED; 149 *mute = af->masterMute(); 150 return NO_ERROR; 151} 152 153status_t AudioSystem::setStreamVolume(audio_stream_type_t stream, float value, 154 audio_io_handle_t output) 155{ 156 if (uint32_t(stream) >= AUDIO_STREAM_CNT) return BAD_VALUE; 157 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 158 if (af == 0) return PERMISSION_DENIED; 159 af->setStreamVolume(stream, value, output); 160 return NO_ERROR; 161} 162 163status_t AudioSystem::setStreamMute(audio_stream_type_t stream, bool mute) 164{ 165 if (uint32_t(stream) >= AUDIO_STREAM_CNT) return BAD_VALUE; 166 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 167 if (af == 0) return PERMISSION_DENIED; 168 af->setStreamMute(stream, mute); 169 return NO_ERROR; 170} 171 172status_t AudioSystem::getStreamVolume(audio_stream_type_t stream, float* volume, 173 audio_io_handle_t output) 174{ 175 if (uint32_t(stream) >= AUDIO_STREAM_CNT) return BAD_VALUE; 176 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 177 if (af == 0) return PERMISSION_DENIED; 178 *volume = af->streamVolume(stream, output); 179 return NO_ERROR; 180} 181 182status_t AudioSystem::getStreamMute(audio_stream_type_t stream, bool* mute) 183{ 184 if (uint32_t(stream) >= AUDIO_STREAM_CNT) return BAD_VALUE; 185 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 186 if (af == 0) return PERMISSION_DENIED; 187 *mute = af->streamMute(stream); 188 return NO_ERROR; 189} 190 191status_t AudioSystem::setMode(audio_mode_t mode) 192{ 193 if (uint32_t(mode) >= AUDIO_MODE_CNT) return BAD_VALUE; 194 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 195 if (af == 0) return PERMISSION_DENIED; 196 return af->setMode(mode); 197} 198 199status_t AudioSystem::setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs) 200{ 201 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 202 if (af == 0) return PERMISSION_DENIED; 203 return af->setParameters(ioHandle, keyValuePairs); 204} 205 206String8 AudioSystem::getParameters(audio_io_handle_t ioHandle, const String8& keys) 207{ 208 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 209 String8 result = String8(""); 210 if (af == 0) return result; 211 212 result = af->getParameters(ioHandle, keys); 213 return result; 214} 215 216status_t AudioSystem::setParameters(const String8& keyValuePairs) 217{ 218 return setParameters(AUDIO_IO_HANDLE_NONE, keyValuePairs); 219} 220 221String8 AudioSystem::getParameters(const String8& keys) 222{ 223 return getParameters(AUDIO_IO_HANDLE_NONE, keys); 224} 225 226// convert volume steps to natural log scale 227 228// change this value to change volume scaling 229static const float dBPerStep = 0.5f; 230// shouldn't need to touch these 231static const float dBConvert = -dBPerStep * 2.302585093f / 20.0f; 232static const float dBConvertInverse = 1.0f / dBConvert; 233 234float AudioSystem::linearToLog(int volume) 235{ 236 // float v = volume ? exp(float(100 - volume) * dBConvert) : 0; 237 // ALOGD("linearToLog(%d)=%f", volume, v); 238 // return v; 239 return volume ? exp(float(100 - volume) * dBConvert) : 0; 240} 241 242int AudioSystem::logToLinear(float volume) 243{ 244 // int v = volume ? 100 - int(dBConvertInverse * log(volume) + 0.5) : 0; 245 // ALOGD("logTolinear(%d)=%f", v, volume); 246 // return v; 247 return volume ? 100 - int(dBConvertInverse * log(volume) + 0.5) : 0; 248} 249 250status_t AudioSystem::getOutputSamplingRate(uint32_t* samplingRate, audio_stream_type_t streamType) 251{ 252 audio_io_handle_t output; 253 254 if (streamType == AUDIO_STREAM_DEFAULT) { 255 streamType = AUDIO_STREAM_MUSIC; 256 } 257 258 output = getOutput(streamType); 259 if (output == 0) { 260 return PERMISSION_DENIED; 261 } 262 263 return getSamplingRate(output, samplingRate); 264} 265 266status_t AudioSystem::getSamplingRate(audio_io_handle_t output, 267 uint32_t* samplingRate) 268{ 269 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 270 if (af == 0) return PERMISSION_DENIED; 271 sp<AudioIoDescriptor> outputDesc = getIoDescriptor(output); 272 if (outputDesc == 0) { 273 ALOGV("getOutputSamplingRate() no output descriptor for output %d in gOutputs", output); 274 *samplingRate = af->sampleRate(output); 275 } else { 276 ALOGV("getOutputSamplingRate() reading from output desc"); 277 *samplingRate = outputDesc->mSamplingRate; 278 } 279 if (*samplingRate == 0) { 280 ALOGE("AudioSystem::getSamplingRate failed for output %d", output); 281 return BAD_VALUE; 282 } 283 284 ALOGV("getSamplingRate() output %d, sampling rate %u", output, *samplingRate); 285 286 return NO_ERROR; 287} 288 289status_t AudioSystem::getOutputFrameCount(size_t* frameCount, audio_stream_type_t streamType) 290{ 291 audio_io_handle_t output; 292 293 if (streamType == AUDIO_STREAM_DEFAULT) { 294 streamType = AUDIO_STREAM_MUSIC; 295 } 296 297 output = getOutput(streamType); 298 if (output == AUDIO_IO_HANDLE_NONE) { 299 return PERMISSION_DENIED; 300 } 301 302 return getFrameCount(output, frameCount); 303} 304 305status_t AudioSystem::getFrameCount(audio_io_handle_t output, 306 size_t* frameCount) 307{ 308 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 309 if (af == 0) return PERMISSION_DENIED; 310 sp<AudioIoDescriptor> outputDesc = getIoDescriptor(output); 311 if (outputDesc == 0) { 312 *frameCount = af->frameCount(output); 313 } else { 314 *frameCount = outputDesc->mFrameCount; 315 } 316 if (*frameCount == 0) { 317 ALOGE("AudioSystem::getFrameCount failed for output %d", output); 318 return BAD_VALUE; 319 } 320 321 ALOGV("getFrameCount() output %d, frameCount %zu", output, *frameCount); 322 323 return NO_ERROR; 324} 325 326status_t AudioSystem::getOutputLatency(uint32_t* latency, audio_stream_type_t streamType) 327{ 328 audio_io_handle_t output; 329 330 if (streamType == AUDIO_STREAM_DEFAULT) { 331 streamType = AUDIO_STREAM_MUSIC; 332 } 333 334 output = getOutput(streamType); 335 if (output == AUDIO_IO_HANDLE_NONE) { 336 return PERMISSION_DENIED; 337 } 338 339 return getLatency(output, latency); 340} 341 342status_t AudioSystem::getLatency(audio_io_handle_t output, 343 uint32_t* latency) 344{ 345 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 346 if (af == 0) return PERMISSION_DENIED; 347 sp<AudioIoDescriptor> outputDesc = getIoDescriptor(output); 348 if (outputDesc == 0) { 349 *latency = af->latency(output); 350 } else { 351 *latency = outputDesc->mLatency; 352 } 353 354 ALOGV("getLatency() output %d, latency %d", output, *latency); 355 356 return NO_ERROR; 357} 358 359status_t AudioSystem::getInputBufferSize(uint32_t sampleRate, audio_format_t format, 360 audio_channel_mask_t channelMask, size_t* buffSize) 361{ 362 const sp<AudioFlingerClient> afc = getAudioFlingerClient(); 363 if (afc == 0) { 364 return NO_INIT; 365 } 366 return afc->getInputBufferSize(sampleRate, format, channelMask, buffSize); 367} 368 369status_t AudioSystem::setVoiceVolume(float value) 370{ 371 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 372 if (af == 0) return PERMISSION_DENIED; 373 return af->setVoiceVolume(value); 374} 375 376status_t AudioSystem::getRenderPosition(audio_io_handle_t output, uint32_t *halFrames, 377 uint32_t *dspFrames) 378{ 379 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 380 if (af == 0) return PERMISSION_DENIED; 381 382 return af->getRenderPosition(halFrames, dspFrames, output); 383} 384 385uint32_t AudioSystem::getInputFramesLost(audio_io_handle_t ioHandle) 386{ 387 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 388 uint32_t result = 0; 389 if (af == 0) return result; 390 if (ioHandle == AUDIO_IO_HANDLE_NONE) return result; 391 392 result = af->getInputFramesLost(ioHandle); 393 return result; 394} 395 396audio_unique_id_t AudioSystem::newAudioUniqueId() 397{ 398 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 399 if (af == 0) return AUDIO_UNIQUE_ID_ALLOCATE; 400 return af->newAudioUniqueId(); 401} 402 403void AudioSystem::acquireAudioSessionId(int audioSession, pid_t pid) 404{ 405 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 406 if (af != 0) { 407 af->acquireAudioSessionId(audioSession, pid); 408 } 409} 410 411void AudioSystem::releaseAudioSessionId(int audioSession, pid_t pid) 412{ 413 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 414 if (af != 0) { 415 af->releaseAudioSessionId(audioSession, pid); 416 } 417} 418 419audio_hw_sync_t AudioSystem::getAudioHwSyncForSession(audio_session_t sessionId) 420{ 421 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 422 if (af == 0) return AUDIO_HW_SYNC_INVALID; 423 return af->getAudioHwSyncForSession(sessionId); 424} 425 426status_t AudioSystem::systemReady() 427{ 428 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 429 if (af == 0) return NO_INIT; 430 return af->systemReady(); 431} 432 433// --------------------------------------------------------------------------- 434 435 436void AudioSystem::AudioFlingerClient::clearIoCache() 437{ 438 Mutex::Autolock _l(mLock); 439 mIoDescriptors.clear(); 440 mInBuffSize = 0; 441 mInSamplingRate = 0; 442 mInFormat = AUDIO_FORMAT_DEFAULT; 443 mInChannelMask = AUDIO_CHANNEL_NONE; 444} 445 446void AudioSystem::AudioFlingerClient::binderDied(const wp<IBinder>& who __unused) 447{ 448 audio_error_callback cb = NULL; 449 { 450 Mutex::Autolock _l(AudioSystem::gLock); 451 AudioSystem::gAudioFlinger.clear(); 452 cb = gAudioErrorCallback; 453 } 454 455 // clear output handles and stream to output map caches 456 clearIoCache(); 457 458 if (cb) { 459 cb(DEAD_OBJECT); 460 } 461 ALOGW("AudioFlinger server died!"); 462} 463 464void AudioSystem::AudioFlingerClient::ioConfigChanged(audio_io_config_event event, 465 const sp<AudioIoDescriptor>& ioDesc) { 466 ALOGV("ioConfigChanged() event %d", event); 467 468 if (ioDesc == 0 || ioDesc->mIoHandle == AUDIO_IO_HANDLE_NONE) return; 469 470 audio_port_handle_t deviceId = AUDIO_PORT_HANDLE_NONE; 471 Vector < sp<AudioDeviceCallback> > callbacks; 472 473 { 474 Mutex::Autolock _l(mLock); 475 476 switch (event) { 477 case AUDIO_OUTPUT_OPENED: 478 case AUDIO_INPUT_OPENED: { 479 sp<AudioIoDescriptor> oldDesc = getIoDescriptor_l(ioDesc->mIoHandle); 480 if (oldDesc == 0) { 481 mIoDescriptors.add(ioDesc->mIoHandle, ioDesc); 482 } else { 483 deviceId = oldDesc->getDeviceId(); 484 mIoDescriptors.replaceValueFor(ioDesc->mIoHandle, ioDesc); 485 } 486 487 if (ioDesc->getDeviceId() != AUDIO_PORT_HANDLE_NONE) { 488 deviceId = ioDesc->getDeviceId(); 489 ssize_t ioIndex = mAudioDeviceCallbacks.indexOfKey(ioDesc->mIoHandle); 490 if (ioIndex >= 0) { 491 callbacks = mAudioDeviceCallbacks.valueAt(ioIndex); 492 } 493 } 494 ALOGV("ioConfigChanged() new %s opened %d samplingRate %u, format %#x channel mask %#x " 495 "frameCount %zu deviceId %d", event == AUDIO_OUTPUT_OPENED ? "output" : "input", 496 ioDesc->mIoHandle, ioDesc->mSamplingRate, ioDesc->mFormat, ioDesc->mChannelMask, 497 ioDesc->mFrameCount, ioDesc->getDeviceId()); 498 } break; 499 case AUDIO_OUTPUT_CLOSED: 500 case AUDIO_INPUT_CLOSED: { 501 if (getIoDescriptor_l(ioDesc->mIoHandle) == 0) { 502 ALOGW("ioConfigChanged() closing unknown %s %d", 503 event == AUDIO_OUTPUT_CLOSED ? "output" : "input", ioDesc->mIoHandle); 504 break; 505 } 506 ALOGV("ioConfigChanged() %s %d closed", 507 event == AUDIO_OUTPUT_CLOSED ? "output" : "input", ioDesc->mIoHandle); 508 509 mIoDescriptors.removeItem(ioDesc->mIoHandle); 510 mAudioDeviceCallbacks.removeItem(ioDesc->mIoHandle); 511 } break; 512 513 case AUDIO_OUTPUT_CONFIG_CHANGED: 514 case AUDIO_INPUT_CONFIG_CHANGED: { 515 sp<AudioIoDescriptor> oldDesc = getIoDescriptor_l(ioDesc->mIoHandle); 516 if (oldDesc == 0) { 517 ALOGW("ioConfigChanged() modifying unknown output! %d", ioDesc->mIoHandle); 518 break; 519 } 520 521 deviceId = oldDesc->getDeviceId(); 522 mIoDescriptors.replaceValueFor(ioDesc->mIoHandle, ioDesc); 523 524 if (deviceId != ioDesc->getDeviceId()) { 525 deviceId = ioDesc->getDeviceId(); 526 ssize_t ioIndex = mAudioDeviceCallbacks.indexOfKey(ioDesc->mIoHandle); 527 if (ioIndex >= 0) { 528 callbacks = mAudioDeviceCallbacks.valueAt(ioIndex); 529 } 530 } 531 ALOGV("ioConfigChanged() new config for %s %d samplingRate %u, format %#x " 532 "channel mask %#x frameCount %zu deviceId %d", 533 event == AUDIO_OUTPUT_CONFIG_CHANGED ? "output" : "input", 534 ioDesc->mIoHandle, ioDesc->mSamplingRate, ioDesc->mFormat, 535 ioDesc->mChannelMask, ioDesc->mFrameCount, ioDesc->getDeviceId()); 536 537 } break; 538 } 539 } 540 // callbacks.size() != 0 => ioDesc->mIoHandle and deviceId are valid 541 for (size_t i = 0; i < callbacks.size(); i++) { 542 callbacks[i]->onAudioDeviceUpdate(ioDesc->mIoHandle, deviceId); 543 } 544} 545 546status_t AudioSystem::AudioFlingerClient::getInputBufferSize( 547 uint32_t sampleRate, audio_format_t format, 548 audio_channel_mask_t channelMask, size_t* buffSize) 549{ 550 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 551 if (af == 0) { 552 return PERMISSION_DENIED; 553 } 554 Mutex::Autolock _l(mLock); 555 // Do we have a stale mInBuffSize or are we requesting the input buffer size for new values 556 if ((mInBuffSize == 0) || (sampleRate != mInSamplingRate) || (format != mInFormat) 557 || (channelMask != mInChannelMask)) { 558 size_t inBuffSize = af->getInputBufferSize(sampleRate, format, channelMask); 559 if (inBuffSize == 0) { 560 ALOGE("AudioSystem::getInputBufferSize failed sampleRate %d format %#x channelMask %x", 561 sampleRate, format, channelMask); 562 return BAD_VALUE; 563 } 564 // A benign race is possible here: we could overwrite a fresher cache entry 565 // save the request params 566 mInSamplingRate = sampleRate; 567 mInFormat = format; 568 mInChannelMask = channelMask; 569 570 mInBuffSize = inBuffSize; 571 } 572 573 *buffSize = mInBuffSize; 574 575 return NO_ERROR; 576} 577 578sp<AudioIoDescriptor> AudioSystem::AudioFlingerClient::getIoDescriptor_l(audio_io_handle_t ioHandle) 579{ 580 sp<AudioIoDescriptor> desc; 581 ssize_t index = mIoDescriptors.indexOfKey(ioHandle); 582 if (index >= 0) { 583 desc = mIoDescriptors.valueAt(index); 584 } 585 return desc; 586} 587 588sp<AudioIoDescriptor> AudioSystem::AudioFlingerClient::getIoDescriptor(audio_io_handle_t ioHandle) 589{ 590 Mutex::Autolock _l(mLock); 591 return getIoDescriptor_l(ioHandle); 592} 593 594status_t AudioSystem::AudioFlingerClient::addAudioDeviceCallback( 595 const sp<AudioDeviceCallback>& callback, audio_io_handle_t audioIo) 596{ 597 Mutex::Autolock _l(mLock); 598 Vector < sp<AudioDeviceCallback> > callbacks; 599 ssize_t ioIndex = mAudioDeviceCallbacks.indexOfKey(audioIo); 600 if (ioIndex >= 0) { 601 callbacks = mAudioDeviceCallbacks.valueAt(ioIndex); 602 } 603 604 for (size_t cbIndex = 0; cbIndex < callbacks.size(); cbIndex++) { 605 if (callbacks[cbIndex] == callback) { 606 return INVALID_OPERATION; 607 } 608 } 609 callbacks.add(callback); 610 611 mAudioDeviceCallbacks.replaceValueFor(audioIo, callbacks); 612 return NO_ERROR; 613} 614 615status_t AudioSystem::AudioFlingerClient::removeAudioDeviceCallback( 616 const sp<AudioDeviceCallback>& callback, audio_io_handle_t audioIo) 617{ 618 Mutex::Autolock _l(mLock); 619 ssize_t ioIndex = mAudioDeviceCallbacks.indexOfKey(audioIo); 620 if (ioIndex < 0) { 621 return INVALID_OPERATION; 622 } 623 Vector < sp<AudioDeviceCallback> > callbacks = mAudioDeviceCallbacks.valueAt(ioIndex); 624 625 size_t cbIndex; 626 for (cbIndex = 0; cbIndex < callbacks.size(); cbIndex++) { 627 if (callbacks[cbIndex] == callback) { 628 break; 629 } 630 } 631 if (cbIndex == callbacks.size()) { 632 return INVALID_OPERATION; 633 } 634 callbacks.removeAt(cbIndex); 635 if (callbacks.size() != 0) { 636 mAudioDeviceCallbacks.replaceValueFor(audioIo, callbacks); 637 } else { 638 mAudioDeviceCallbacks.removeItem(audioIo); 639 } 640 return NO_ERROR; 641} 642 643/* static */ void AudioSystem::setErrorCallback(audio_error_callback cb) 644{ 645 Mutex::Autolock _l(gLock); 646 gAudioErrorCallback = cb; 647} 648 649/*static*/ void AudioSystem::setDynPolicyCallback(dynamic_policy_callback cb) 650{ 651 Mutex::Autolock _l(gLock); 652 gDynPolicyCallback = cb; 653} 654 655// client singleton for AudioPolicyService binder interface 656// protected by gLockAPS 657sp<IAudioPolicyService> AudioSystem::gAudioPolicyService; 658sp<AudioSystem::AudioPolicyServiceClient> AudioSystem::gAudioPolicyServiceClient; 659 660 661// establish binder interface to AudioPolicy service 662const sp<IAudioPolicyService> AudioSystem::get_audio_policy_service() 663{ 664 sp<IAudioPolicyService> ap; 665 sp<AudioPolicyServiceClient> apc; 666 { 667 Mutex::Autolock _l(gLockAPS); 668 if (gAudioPolicyService == 0) { 669 sp<IServiceManager> sm = defaultServiceManager(); 670 sp<IBinder> binder; 671 do { 672 binder = sm->getService(String16("media.audio_policy")); 673 if (binder != 0) 674 break; 675 ALOGW("AudioPolicyService not published, waiting..."); 676 usleep(500000); // 0.5 s 677 } while (true); 678 if (gAudioPolicyServiceClient == NULL) { 679 gAudioPolicyServiceClient = new AudioPolicyServiceClient(); 680 } 681 binder->linkToDeath(gAudioPolicyServiceClient); 682 gAudioPolicyService = interface_cast<IAudioPolicyService>(binder); 683 LOG_ALWAYS_FATAL_IF(gAudioPolicyService == 0); 684 apc = gAudioPolicyServiceClient; 685 } 686 ap = gAudioPolicyService; 687 } 688 if (apc != 0) { 689 ap->registerClient(apc); 690 } 691 692 return ap; 693} 694 695// --------------------------------------------------------------------------- 696 697status_t AudioSystem::setDeviceConnectionState(audio_devices_t device, 698 audio_policy_dev_state_t state, 699 const char *device_address, 700 const char *device_name) 701{ 702 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 703 const char *address = ""; 704 const char *name = ""; 705 706 if (aps == 0) return PERMISSION_DENIED; 707 708 if (device_address != NULL) { 709 address = device_address; 710 } 711 if (device_name != NULL) { 712 name = device_name; 713 } 714 return aps->setDeviceConnectionState(device, state, address, name); 715} 716 717audio_policy_dev_state_t AudioSystem::getDeviceConnectionState(audio_devices_t device, 718 const char *device_address) 719{ 720 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 721 if (aps == 0) return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE; 722 723 return aps->getDeviceConnectionState(device, device_address); 724} 725 726status_t AudioSystem::setPhoneState(audio_mode_t state) 727{ 728 if (uint32_t(state) >= AUDIO_MODE_CNT) return BAD_VALUE; 729 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 730 if (aps == 0) return PERMISSION_DENIED; 731 732 return aps->setPhoneState(state); 733} 734 735status_t AudioSystem::setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config) 736{ 737 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 738 if (aps == 0) return PERMISSION_DENIED; 739 return aps->setForceUse(usage, config); 740} 741 742audio_policy_forced_cfg_t AudioSystem::getForceUse(audio_policy_force_use_t usage) 743{ 744 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 745 if (aps == 0) return AUDIO_POLICY_FORCE_NONE; 746 return aps->getForceUse(usage); 747} 748 749 750audio_io_handle_t AudioSystem::getOutput(audio_stream_type_t stream, 751 uint32_t samplingRate, 752 audio_format_t format, 753 audio_channel_mask_t channelMask, 754 audio_output_flags_t flags, 755 const audio_offload_info_t *offloadInfo) 756{ 757 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 758 if (aps == 0) return 0; 759 return aps->getOutput(stream, samplingRate, format, channelMask, flags, offloadInfo); 760} 761 762status_t AudioSystem::getOutputForAttr(const audio_attributes_t *attr, 763 audio_io_handle_t *output, 764 audio_session_t session, 765 audio_stream_type_t *stream, 766 uid_t uid, 767 uint32_t samplingRate, 768 audio_format_t format, 769 audio_channel_mask_t channelMask, 770 audio_output_flags_t flags, 771 audio_port_handle_t selectedDeviceId, 772 const audio_offload_info_t *offloadInfo) 773{ 774 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 775 if (aps == 0) return NO_INIT; 776 return aps->getOutputForAttr(attr, output, session, stream, uid, 777 samplingRate, format, channelMask, 778 flags, selectedDeviceId, offloadInfo); 779} 780 781status_t AudioSystem::startOutput(audio_io_handle_t output, 782 audio_stream_type_t stream, 783 audio_session_t session) 784{ 785 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 786 if (aps == 0) return PERMISSION_DENIED; 787 return aps->startOutput(output, stream, session); 788} 789 790status_t AudioSystem::stopOutput(audio_io_handle_t output, 791 audio_stream_type_t stream, 792 audio_session_t session) 793{ 794 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 795 if (aps == 0) return PERMISSION_DENIED; 796 return aps->stopOutput(output, stream, session); 797} 798 799void AudioSystem::releaseOutput(audio_io_handle_t output, 800 audio_stream_type_t stream, 801 audio_session_t session) 802{ 803 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 804 if (aps == 0) return; 805 aps->releaseOutput(output, stream, session); 806} 807 808status_t AudioSystem::getInputForAttr(const audio_attributes_t *attr, 809 audio_io_handle_t *input, 810 audio_session_t session, 811 uid_t uid, 812 uint32_t samplingRate, 813 audio_format_t format, 814 audio_channel_mask_t channelMask, 815 audio_input_flags_t flags, 816 audio_port_handle_t selectedDeviceId) 817{ 818 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 819 if (aps == 0) return NO_INIT; 820 return aps->getInputForAttr( 821 attr, input, session, uid, samplingRate, format, channelMask, flags, selectedDeviceId); 822} 823 824status_t AudioSystem::startInput(audio_io_handle_t input, 825 audio_session_t session) 826{ 827 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 828 if (aps == 0) return PERMISSION_DENIED; 829 return aps->startInput(input, session); 830} 831 832status_t AudioSystem::stopInput(audio_io_handle_t input, 833 audio_session_t session) 834{ 835 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 836 if (aps == 0) return PERMISSION_DENIED; 837 return aps->stopInput(input, session); 838} 839 840void AudioSystem::releaseInput(audio_io_handle_t input, 841 audio_session_t session) 842{ 843 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 844 if (aps == 0) return; 845 aps->releaseInput(input, session); 846} 847 848status_t AudioSystem::initStreamVolume(audio_stream_type_t stream, 849 int indexMin, 850 int indexMax) 851{ 852 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 853 if (aps == 0) return PERMISSION_DENIED; 854 return aps->initStreamVolume(stream, indexMin, indexMax); 855} 856 857status_t AudioSystem::setStreamVolumeIndex(audio_stream_type_t stream, 858 int index, 859 audio_devices_t device) 860{ 861 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 862 if (aps == 0) return PERMISSION_DENIED; 863 return aps->setStreamVolumeIndex(stream, index, device); 864} 865 866status_t AudioSystem::getStreamVolumeIndex(audio_stream_type_t stream, 867 int *index, 868 audio_devices_t device) 869{ 870 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 871 if (aps == 0) return PERMISSION_DENIED; 872 return aps->getStreamVolumeIndex(stream, index, device); 873} 874 875uint32_t AudioSystem::getStrategyForStream(audio_stream_type_t stream) 876{ 877 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 878 if (aps == 0) return 0; 879 return aps->getStrategyForStream(stream); 880} 881 882audio_devices_t AudioSystem::getDevicesForStream(audio_stream_type_t stream) 883{ 884 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 885 if (aps == 0) return AUDIO_DEVICE_NONE; 886 return aps->getDevicesForStream(stream); 887} 888 889audio_io_handle_t AudioSystem::getOutputForEffect(const effect_descriptor_t *desc) 890{ 891 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 892 // FIXME change return type to status_t, and return PERMISSION_DENIED here 893 if (aps == 0) return AUDIO_IO_HANDLE_NONE; 894 return aps->getOutputForEffect(desc); 895} 896 897status_t AudioSystem::registerEffect(const effect_descriptor_t *desc, 898 audio_io_handle_t io, 899 uint32_t strategy, 900 int session, 901 int id) 902{ 903 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 904 if (aps == 0) return PERMISSION_DENIED; 905 return aps->registerEffect(desc, io, strategy, session, id); 906} 907 908status_t AudioSystem::unregisterEffect(int id) 909{ 910 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 911 if (aps == 0) return PERMISSION_DENIED; 912 return aps->unregisterEffect(id); 913} 914 915status_t AudioSystem::setEffectEnabled(int id, bool enabled) 916{ 917 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 918 if (aps == 0) return PERMISSION_DENIED; 919 return aps->setEffectEnabled(id, enabled); 920} 921 922status_t AudioSystem::isStreamActive(audio_stream_type_t stream, bool* state, uint32_t inPastMs) 923{ 924 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 925 if (aps == 0) return PERMISSION_DENIED; 926 if (state == NULL) return BAD_VALUE; 927 *state = aps->isStreamActive(stream, inPastMs); 928 return NO_ERROR; 929} 930 931status_t AudioSystem::isStreamActiveRemotely(audio_stream_type_t stream, bool* state, 932 uint32_t inPastMs) 933{ 934 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 935 if (aps == 0) return PERMISSION_DENIED; 936 if (state == NULL) return BAD_VALUE; 937 *state = aps->isStreamActiveRemotely(stream, inPastMs); 938 return NO_ERROR; 939} 940 941status_t AudioSystem::isSourceActive(audio_source_t stream, bool* state) 942{ 943 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 944 if (aps == 0) return PERMISSION_DENIED; 945 if (state == NULL) return BAD_VALUE; 946 *state = aps->isSourceActive(stream); 947 return NO_ERROR; 948} 949 950uint32_t AudioSystem::getPrimaryOutputSamplingRate() 951{ 952 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 953 if (af == 0) return 0; 954 return af->getPrimaryOutputSamplingRate(); 955} 956 957size_t AudioSystem::getPrimaryOutputFrameCount() 958{ 959 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 960 if (af == 0) return 0; 961 return af->getPrimaryOutputFrameCount(); 962} 963 964status_t AudioSystem::setLowRamDevice(bool isLowRamDevice) 965{ 966 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 967 if (af == 0) return PERMISSION_DENIED; 968 return af->setLowRamDevice(isLowRamDevice); 969} 970 971void AudioSystem::clearAudioConfigCache() 972{ 973 // called by restoreTrack_l(), which needs new IAudioFlinger and IAudioPolicyService instances 974 ALOGV("clearAudioConfigCache()"); 975 { 976 Mutex::Autolock _l(gLock); 977 if (gAudioFlingerClient != 0) { 978 gAudioFlingerClient->clearIoCache(); 979 } 980 gAudioFlinger.clear(); 981 } 982 { 983 Mutex::Autolock _l(gLockAPS); 984 gAudioPolicyService.clear(); 985 } 986} 987 988bool AudioSystem::isOffloadSupported(const audio_offload_info_t& info) 989{ 990 ALOGV("isOffloadSupported()"); 991 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 992 if (aps == 0) return false; 993 return aps->isOffloadSupported(info); 994} 995 996status_t AudioSystem::listAudioPorts(audio_port_role_t role, 997 audio_port_type_t type, 998 unsigned int *num_ports, 999 struct audio_port *ports, 1000 unsigned int *generation) 1001{ 1002 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 1003 if (aps == 0) return PERMISSION_DENIED; 1004 return aps->listAudioPorts(role, type, num_ports, ports, generation); 1005} 1006 1007status_t AudioSystem::getAudioPort(struct audio_port *port) 1008{ 1009 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 1010 if (aps == 0) return PERMISSION_DENIED; 1011 return aps->getAudioPort(port); 1012} 1013 1014status_t AudioSystem::createAudioPatch(const struct audio_patch *patch, 1015 audio_patch_handle_t *handle) 1016{ 1017 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 1018 if (aps == 0) return PERMISSION_DENIED; 1019 return aps->createAudioPatch(patch, handle); 1020} 1021 1022status_t AudioSystem::releaseAudioPatch(audio_patch_handle_t handle) 1023{ 1024 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 1025 if (aps == 0) return PERMISSION_DENIED; 1026 return aps->releaseAudioPatch(handle); 1027} 1028 1029status_t AudioSystem::listAudioPatches(unsigned int *num_patches, 1030 struct audio_patch *patches, 1031 unsigned int *generation) 1032{ 1033 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 1034 if (aps == 0) return PERMISSION_DENIED; 1035 return aps->listAudioPatches(num_patches, patches, generation); 1036} 1037 1038status_t AudioSystem::setAudioPortConfig(const struct audio_port_config *config) 1039{ 1040 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 1041 if (aps == 0) return PERMISSION_DENIED; 1042 return aps->setAudioPortConfig(config); 1043} 1044 1045status_t AudioSystem::addAudioPortCallback(const sp<AudioPortCallback>& callback) 1046{ 1047 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 1048 if (aps == 0) return PERMISSION_DENIED; 1049 1050 Mutex::Autolock _l(gLockAPS); 1051 if (gAudioPolicyServiceClient == 0) { 1052 return NO_INIT; 1053 } 1054 int ret = gAudioPolicyServiceClient->addAudioPortCallback(callback); 1055 if (ret == 1) { 1056 aps->setAudioPortCallbacksEnabled(true); 1057 } 1058 return (ret < 0) ? INVALID_OPERATION : NO_ERROR; 1059} 1060 1061/*static*/ 1062status_t AudioSystem::removeAudioPortCallback(const sp<AudioPortCallback>& callback) 1063{ 1064 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 1065 if (aps == 0) return PERMISSION_DENIED; 1066 1067 Mutex::Autolock _l(gLockAPS); 1068 if (gAudioPolicyServiceClient == 0) { 1069 return NO_INIT; 1070 } 1071 int ret = gAudioPolicyServiceClient->removeAudioPortCallback(callback); 1072 if (ret == 0) { 1073 aps->setAudioPortCallbacksEnabled(false); 1074 } 1075 return (ret < 0) ? INVALID_OPERATION : NO_ERROR; 1076} 1077 1078status_t AudioSystem::addAudioDeviceCallback( 1079 const sp<AudioDeviceCallback>& callback, audio_io_handle_t audioIo) 1080{ 1081 const sp<AudioFlingerClient> afc = getAudioFlingerClient(); 1082 if (afc == 0) { 1083 return NO_INIT; 1084 } 1085 status_t status = afc->addAudioDeviceCallback(callback, audioIo); 1086 if (status == NO_ERROR) { 1087 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 1088 if (af != 0) { 1089 af->registerClient(afc); 1090 } 1091 } 1092 return status; 1093} 1094 1095status_t AudioSystem::removeAudioDeviceCallback( 1096 const sp<AudioDeviceCallback>& callback, audio_io_handle_t audioIo) 1097{ 1098 const sp<AudioFlingerClient> afc = getAudioFlingerClient(); 1099 if (afc == 0) { 1100 return NO_INIT; 1101 } 1102 return afc->removeAudioDeviceCallback(callback, audioIo); 1103} 1104 1105audio_port_handle_t AudioSystem::getDeviceIdForIo(audio_io_handle_t audioIo) 1106{ 1107 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); 1108 if (af == 0) return PERMISSION_DENIED; 1109 const sp<AudioIoDescriptor> desc = getIoDescriptor(audioIo); 1110 if (desc == 0) { 1111 return AUDIO_PORT_HANDLE_NONE; 1112 } 1113 return desc->getDeviceId(); 1114} 1115 1116status_t AudioSystem::acquireSoundTriggerSession(audio_session_t *session, 1117 audio_io_handle_t *ioHandle, 1118 audio_devices_t *device) 1119{ 1120 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 1121 if (aps == 0) return PERMISSION_DENIED; 1122 return aps->acquireSoundTriggerSession(session, ioHandle, device); 1123} 1124 1125status_t AudioSystem::releaseSoundTriggerSession(audio_session_t session) 1126{ 1127 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 1128 if (aps == 0) return PERMISSION_DENIED; 1129 return aps->releaseSoundTriggerSession(session); 1130} 1131 1132audio_mode_t AudioSystem::getPhoneState() 1133{ 1134 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 1135 if (aps == 0) return AUDIO_MODE_INVALID; 1136 return aps->getPhoneState(); 1137} 1138 1139status_t AudioSystem::registerPolicyMixes(Vector<AudioMix> mixes, bool registration) 1140{ 1141 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 1142 if (aps == 0) return PERMISSION_DENIED; 1143 return aps->registerPolicyMixes(mixes, registration); 1144} 1145 1146status_t AudioSystem::startAudioSource(const struct audio_port_config *source, 1147 const audio_attributes_t *attributes, 1148 audio_io_handle_t *handle) 1149{ 1150 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 1151 if (aps == 0) return PERMISSION_DENIED; 1152 return aps->startAudioSource(source, attributes, handle); 1153} 1154 1155status_t AudioSystem::stopAudioSource(audio_io_handle_t handle) 1156{ 1157 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 1158 if (aps == 0) return PERMISSION_DENIED; 1159 return aps->stopAudioSource(handle); 1160} 1161 1162// --------------------------------------------------------------------------- 1163 1164int AudioSystem::AudioPolicyServiceClient::addAudioPortCallback( 1165 const sp<AudioPortCallback>& callback) 1166{ 1167 Mutex::Autolock _l(mLock); 1168 for (size_t i = 0; i < mAudioPortCallbacks.size(); i++) { 1169 if (mAudioPortCallbacks[i] == callback) { 1170 return -1; 1171 } 1172 } 1173 mAudioPortCallbacks.add(callback); 1174 return mAudioPortCallbacks.size(); 1175} 1176 1177int AudioSystem::AudioPolicyServiceClient::removeAudioPortCallback( 1178 const sp<AudioPortCallback>& callback) 1179{ 1180 Mutex::Autolock _l(mLock); 1181 size_t i; 1182 for (i = 0; i < mAudioPortCallbacks.size(); i++) { 1183 if (mAudioPortCallbacks[i] == callback) { 1184 break; 1185 } 1186 } 1187 if (i == mAudioPortCallbacks.size()) { 1188 return -1; 1189 } 1190 mAudioPortCallbacks.removeAt(i); 1191 return mAudioPortCallbacks.size(); 1192} 1193 1194 1195void AudioSystem::AudioPolicyServiceClient::onAudioPortListUpdate() 1196{ 1197 Mutex::Autolock _l(mLock); 1198 for (size_t i = 0; i < mAudioPortCallbacks.size(); i++) { 1199 mAudioPortCallbacks[i]->onAudioPortListUpdate(); 1200 } 1201} 1202 1203void AudioSystem::AudioPolicyServiceClient::onAudioPatchListUpdate() 1204{ 1205 Mutex::Autolock _l(mLock); 1206 for (size_t i = 0; i < mAudioPortCallbacks.size(); i++) { 1207 mAudioPortCallbacks[i]->onAudioPatchListUpdate(); 1208 } 1209} 1210 1211void AudioSystem::AudioPolicyServiceClient::onDynamicPolicyMixStateUpdate( 1212 String8 regId, int32_t state) 1213{ 1214 ALOGV("AudioPolicyServiceClient::onDynamicPolicyMixStateUpdate(%s, %d)", regId.string(), state); 1215 dynamic_policy_callback cb = NULL; 1216 { 1217 Mutex::Autolock _l(AudioSystem::gLock); 1218 cb = gDynPolicyCallback; 1219 } 1220 1221 if (cb != NULL) { 1222 cb(DYNAMIC_POLICY_EVENT_MIX_STATE_UPDATE, regId, state); 1223 } 1224} 1225 1226void AudioSystem::AudioPolicyServiceClient::binderDied(const wp<IBinder>& who __unused) 1227{ 1228 { 1229 Mutex::Autolock _l(mLock); 1230 for (size_t i = 0; i < mAudioPortCallbacks.size(); i++) { 1231 mAudioPortCallbacks[i]->onServiceDied(); 1232 } 1233 } 1234 { 1235 Mutex::Autolock _l(gLockAPS); 1236 AudioSystem::gAudioPolicyService.clear(); 1237 } 1238 1239 ALOGW("AudioPolicyService server died!"); 1240} 1241 1242} // namespace android 1243