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