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