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