1 /* 2 * Copyright (C) 2009 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 "AudioPolicyIntefaceImpl" 18 //#define LOG_NDEBUG 0 19 20 #include <utils/Log.h> 21 #include "AudioPolicyService.h" 22 #include "ServiceUtilities.h" 23 24 namespace android { 25 26 27 // ---------------------------------------------------------------------------- 28 29 status_t AudioPolicyService::setDeviceConnectionState(audio_devices_t device, 30 audio_policy_dev_state_t state, 31 const char *device_address, 32 const char *device_name) 33 { 34 if (mAudioPolicyManager == NULL) { 35 return NO_INIT; 36 } 37 if (!settingsAllowed()) { 38 return PERMISSION_DENIED; 39 } 40 if (!audio_is_output_device(device) && !audio_is_input_device(device)) { 41 return BAD_VALUE; 42 } 43 if (state != AUDIO_POLICY_DEVICE_STATE_AVAILABLE && 44 state != AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) { 45 return BAD_VALUE; 46 } 47 48 ALOGV("setDeviceConnectionState()"); 49 Mutex::Autolock _l(mLock); 50 return mAudioPolicyManager->setDeviceConnectionState(device, state, 51 device_address, device_name); 52 } 53 54 audio_policy_dev_state_t AudioPolicyService::getDeviceConnectionState( 55 audio_devices_t device, 56 const char *device_address) 57 { 58 if (mAudioPolicyManager == NULL) { 59 return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE; 60 } 61 return mAudioPolicyManager->getDeviceConnectionState(device, 62 device_address); 63 } 64 65 status_t AudioPolicyService::setPhoneState(audio_mode_t state) 66 { 67 if (mAudioPolicyManager == NULL) { 68 return NO_INIT; 69 } 70 if (!settingsAllowed()) { 71 return PERMISSION_DENIED; 72 } 73 if (uint32_t(state) >= AUDIO_MODE_CNT) { 74 return BAD_VALUE; 75 } 76 77 ALOGV("setPhoneState()"); 78 79 // acquire lock before calling setMode() so that setMode() + setPhoneState() are an atomic 80 // operation from policy manager standpoint (no other operation (e.g track start or stop) 81 // can be interleaved). 82 Mutex::Autolock _l(mLock); 83 84 // TODO: check if it is more appropriate to do it in platform specific policy manager 85 AudioSystem::setMode(state); 86 87 mAudioPolicyManager->setPhoneState(state); 88 mPhoneState = state; 89 return NO_ERROR; 90 } 91 92 audio_mode_t AudioPolicyService::getPhoneState() 93 { 94 Mutex::Autolock _l(mLock); 95 return mPhoneState; 96 } 97 98 status_t AudioPolicyService::setForceUse(audio_policy_force_use_t usage, 99 audio_policy_forced_cfg_t config) 100 { 101 if (mAudioPolicyManager == NULL) { 102 return NO_INIT; 103 } 104 if (!settingsAllowed()) { 105 return PERMISSION_DENIED; 106 } 107 if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) { 108 return BAD_VALUE; 109 } 110 if (config < 0 || config >= AUDIO_POLICY_FORCE_CFG_CNT) { 111 return BAD_VALUE; 112 } 113 ALOGV("setForceUse()"); 114 Mutex::Autolock _l(mLock); 115 mAudioPolicyManager->setForceUse(usage, config); 116 return NO_ERROR; 117 } 118 119 audio_policy_forced_cfg_t AudioPolicyService::getForceUse(audio_policy_force_use_t usage) 120 { 121 if (mAudioPolicyManager == NULL) { 122 return AUDIO_POLICY_FORCE_NONE; 123 } 124 if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) { 125 return AUDIO_POLICY_FORCE_NONE; 126 } 127 return mAudioPolicyManager->getForceUse(usage); 128 } 129 130 audio_io_handle_t AudioPolicyService::getOutput(audio_stream_type_t stream, 131 uint32_t samplingRate, 132 audio_format_t format, 133 audio_channel_mask_t channelMask, 134 audio_output_flags_t flags, 135 const audio_offload_info_t *offloadInfo) 136 { 137 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) { 138 return AUDIO_IO_HANDLE_NONE; 139 } 140 if (mAudioPolicyManager == NULL) { 141 return AUDIO_IO_HANDLE_NONE; 142 } 143 ALOGV("getOutput()"); 144 Mutex::Autolock _l(mLock); 145 return mAudioPolicyManager->getOutput(stream, samplingRate, 146 format, channelMask, flags, offloadInfo); 147 } 148 149 status_t AudioPolicyService::getOutputForAttr(const audio_attributes_t *attr, 150 audio_io_handle_t *output, 151 audio_session_t session, 152 audio_stream_type_t *stream, 153 uid_t uid, 154 uint32_t samplingRate, 155 audio_format_t format, 156 audio_channel_mask_t channelMask, 157 audio_output_flags_t flags, 158 audio_port_handle_t selectedDeviceId, 159 const audio_offload_info_t *offloadInfo) 160 { 161 if (mAudioPolicyManager == NULL) { 162 return NO_INIT; 163 } 164 ALOGV("getOutput()"); 165 Mutex::Autolock _l(mLock); 166 167 const uid_t callingUid = IPCThreadState::self()->getCallingUid(); 168 if (!isTrustedCallingUid(callingUid) || uid == (uid_t)-1) { 169 ALOGW_IF(uid != (uid_t)-1 && uid != callingUid, 170 "%s uid %d tried to pass itself off as %d", __FUNCTION__, callingUid, uid); 171 uid = callingUid; 172 } 173 return mAudioPolicyManager->getOutputForAttr(attr, output, session, stream, uid, samplingRate, 174 format, channelMask, flags, selectedDeviceId, offloadInfo); 175 } 176 177 status_t AudioPolicyService::startOutput(audio_io_handle_t output, 178 audio_stream_type_t stream, 179 audio_session_t session) 180 { 181 if (uint32_t(stream) >= AUDIO_STREAM_CNT) { 182 return BAD_VALUE; 183 } 184 if (mAudioPolicyManager == NULL) { 185 return NO_INIT; 186 } 187 ALOGV("startOutput()"); 188 sp<AudioPolicyEffects>audioPolicyEffects; 189 { 190 Mutex::Autolock _l(mLock); 191 audioPolicyEffects = mAudioPolicyEffects; 192 } 193 if (audioPolicyEffects != 0) { 194 // create audio processors according to stream 195 status_t status = audioPolicyEffects->addOutputSessionEffects(output, stream, session); 196 if (status != NO_ERROR && status != ALREADY_EXISTS) { 197 ALOGW("Failed to add effects on session %d", session); 198 } 199 } 200 Mutex::Autolock _l(mLock); 201 return mAudioPolicyManager->startOutput(output, stream, session); 202 } 203 204 status_t AudioPolicyService::stopOutput(audio_io_handle_t output, 205 audio_stream_type_t stream, 206 audio_session_t session) 207 { 208 if (uint32_t(stream) >= AUDIO_STREAM_CNT) { 209 return BAD_VALUE; 210 } 211 if (mAudioPolicyManager == NULL) { 212 return NO_INIT; 213 } 214 ALOGV("stopOutput()"); 215 mOutputCommandThread->stopOutputCommand(output, stream, session); 216 return NO_ERROR; 217 } 218 219 status_t AudioPolicyService::doStopOutput(audio_io_handle_t output, 220 audio_stream_type_t stream, 221 audio_session_t session) 222 { 223 ALOGV("doStopOutput from tid %d", gettid()); 224 sp<AudioPolicyEffects>audioPolicyEffects; 225 { 226 Mutex::Autolock _l(mLock); 227 audioPolicyEffects = mAudioPolicyEffects; 228 } 229 if (audioPolicyEffects != 0) { 230 // release audio processors from the stream 231 status_t status = audioPolicyEffects->releaseOutputSessionEffects(output, stream, session); 232 if (status != NO_ERROR && status != ALREADY_EXISTS) { 233 ALOGW("Failed to release effects on session %d", session); 234 } 235 } 236 Mutex::Autolock _l(mLock); 237 return mAudioPolicyManager->stopOutput(output, stream, session); 238 } 239 240 void AudioPolicyService::releaseOutput(audio_io_handle_t output, 241 audio_stream_type_t stream, 242 audio_session_t session) 243 { 244 if (mAudioPolicyManager == NULL) { 245 return; 246 } 247 ALOGV("releaseOutput()"); 248 mOutputCommandThread->releaseOutputCommand(output, stream, session); 249 } 250 251 void AudioPolicyService::doReleaseOutput(audio_io_handle_t output, 252 audio_stream_type_t stream, 253 audio_session_t session) 254 { 255 ALOGV("doReleaseOutput from tid %d", gettid()); 256 Mutex::Autolock _l(mLock); 257 mAudioPolicyManager->releaseOutput(output, stream, session); 258 } 259 260 status_t AudioPolicyService::getInputForAttr(const audio_attributes_t *attr, 261 audio_io_handle_t *input, 262 audio_session_t session, 263 pid_t pid, 264 uid_t uid, 265 uint32_t samplingRate, 266 audio_format_t format, 267 audio_channel_mask_t channelMask, 268 audio_input_flags_t flags, 269 audio_port_handle_t selectedDeviceId) 270 { 271 if (mAudioPolicyManager == NULL) { 272 return NO_INIT; 273 } 274 // already checked by client, but double-check in case the client wrapper is bypassed 275 if (attr->source >= AUDIO_SOURCE_CNT && attr->source != AUDIO_SOURCE_HOTWORD && 276 attr->source != AUDIO_SOURCE_FM_TUNER) { 277 return BAD_VALUE; 278 } 279 280 if ((attr->source == AUDIO_SOURCE_HOTWORD) && !captureHotwordAllowed()) { 281 return BAD_VALUE; 282 } 283 sp<AudioPolicyEffects>audioPolicyEffects; 284 status_t status; 285 AudioPolicyInterface::input_type_t inputType; 286 287 bool updatePid = (pid == -1); 288 const uid_t callingUid = IPCThreadState::self()->getCallingUid(); 289 if (!isTrustedCallingUid(callingUid)) { 290 ALOGW_IF(uid != (uid_t)-1 && uid != callingUid, 291 "%s uid %d tried to pass itself off as %d", __FUNCTION__, callingUid, uid); 292 uid = callingUid; 293 updatePid = true; 294 } 295 296 if (updatePid) { 297 const pid_t callingPid = IPCThreadState::self()->getCallingPid(); 298 ALOGW_IF(pid != (pid_t)-1 && pid != callingPid, 299 "%s uid %d pid %d tried to pass itself off as pid %d", 300 __func__, callingUid, callingPid, pid); 301 pid = callingPid; 302 } 303 304 { 305 Mutex::Autolock _l(mLock); 306 // the audio_in_acoustics_t parameter is ignored by get_input() 307 status = mAudioPolicyManager->getInputForAttr(attr, input, session, uid, 308 samplingRate, format, channelMask, 309 flags, selectedDeviceId, 310 &inputType); 311 audioPolicyEffects = mAudioPolicyEffects; 312 313 if (status == NO_ERROR) { 314 // enforce permission (if any) required for each type of input 315 switch (inputType) { 316 case AudioPolicyInterface::API_INPUT_LEGACY: 317 break; 318 case AudioPolicyInterface::API_INPUT_TELEPHONY_RX: 319 // FIXME: use the same permission as for remote submix for now. 320 case AudioPolicyInterface::API_INPUT_MIX_CAPTURE: 321 if (!captureAudioOutputAllowed(pid, uid)) { 322 ALOGE("getInputForAttr() permission denied: capture not allowed"); 323 status = PERMISSION_DENIED; 324 } 325 break; 326 case AudioPolicyInterface::API_INPUT_MIX_EXT_POLICY_REROUTE: 327 if (!modifyAudioRoutingAllowed()) { 328 ALOGE("getInputForAttr() permission denied: modify audio routing not allowed"); 329 status = PERMISSION_DENIED; 330 } 331 break; 332 case AudioPolicyInterface::API_INPUT_INVALID: 333 default: 334 LOG_ALWAYS_FATAL("getInputForAttr() encountered an invalid input type %d", 335 (int)inputType); 336 } 337 } 338 339 if (status != NO_ERROR) { 340 if (status == PERMISSION_DENIED) { 341 mAudioPolicyManager->releaseInput(*input, session); 342 } 343 return status; 344 } 345 } 346 347 if (audioPolicyEffects != 0) { 348 // create audio pre processors according to input source 349 status_t status = audioPolicyEffects->addInputEffects(*input, attr->source, session); 350 if (status != NO_ERROR && status != ALREADY_EXISTS) { 351 ALOGW("Failed to add effects on input %d", *input); 352 } 353 } 354 return NO_ERROR; 355 } 356 357 status_t AudioPolicyService::startInput(audio_io_handle_t input, 358 audio_session_t session) 359 { 360 if (mAudioPolicyManager == NULL) { 361 return NO_INIT; 362 } 363 Mutex::Autolock _l(mLock); 364 365 return mAudioPolicyManager->startInput(input, session); 366 } 367 368 status_t AudioPolicyService::stopInput(audio_io_handle_t input, 369 audio_session_t session) 370 { 371 if (mAudioPolicyManager == NULL) { 372 return NO_INIT; 373 } 374 Mutex::Autolock _l(mLock); 375 376 return mAudioPolicyManager->stopInput(input, session); 377 } 378 379 void AudioPolicyService::releaseInput(audio_io_handle_t input, 380 audio_session_t session) 381 { 382 if (mAudioPolicyManager == NULL) { 383 return; 384 } 385 sp<AudioPolicyEffects>audioPolicyEffects; 386 { 387 Mutex::Autolock _l(mLock); 388 mAudioPolicyManager->releaseInput(input, session); 389 audioPolicyEffects = mAudioPolicyEffects; 390 } 391 if (audioPolicyEffects != 0) { 392 // release audio processors from the input 393 status_t status = audioPolicyEffects->releaseInputEffects(input); 394 if(status != NO_ERROR) { 395 ALOGW("Failed to release effects on input %d", input); 396 } 397 } 398 } 399 400 status_t AudioPolicyService::initStreamVolume(audio_stream_type_t stream, 401 int indexMin, 402 int indexMax) 403 { 404 if (mAudioPolicyManager == NULL) { 405 return NO_INIT; 406 } 407 if (!settingsAllowed()) { 408 return PERMISSION_DENIED; 409 } 410 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) { 411 return BAD_VALUE; 412 } 413 Mutex::Autolock _l(mLock); 414 mAudioPolicyManager->initStreamVolume(stream, indexMin, indexMax); 415 return NO_ERROR; 416 } 417 418 status_t AudioPolicyService::setStreamVolumeIndex(audio_stream_type_t stream, 419 int index, 420 audio_devices_t device) 421 { 422 if (mAudioPolicyManager == NULL) { 423 return NO_INIT; 424 } 425 if (!settingsAllowed()) { 426 return PERMISSION_DENIED; 427 } 428 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) { 429 return BAD_VALUE; 430 } 431 Mutex::Autolock _l(mLock); 432 return mAudioPolicyManager->setStreamVolumeIndex(stream, 433 index, 434 device); 435 } 436 437 status_t AudioPolicyService::getStreamVolumeIndex(audio_stream_type_t stream, 438 int *index, 439 audio_devices_t device) 440 { 441 if (mAudioPolicyManager == NULL) { 442 return NO_INIT; 443 } 444 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) { 445 return BAD_VALUE; 446 } 447 Mutex::Autolock _l(mLock); 448 return mAudioPolicyManager->getStreamVolumeIndex(stream, 449 index, 450 device); 451 } 452 453 uint32_t AudioPolicyService::getStrategyForStream(audio_stream_type_t stream) 454 { 455 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) { 456 return 0; 457 } 458 if (mAudioPolicyManager == NULL) { 459 return 0; 460 } 461 return mAudioPolicyManager->getStrategyForStream(stream); 462 } 463 464 //audio policy: use audio_device_t appropriately 465 466 audio_devices_t AudioPolicyService::getDevicesForStream(audio_stream_type_t stream) 467 { 468 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) { 469 return AUDIO_DEVICE_NONE; 470 } 471 if (mAudioPolicyManager == NULL) { 472 return AUDIO_DEVICE_NONE; 473 } 474 Mutex::Autolock _l(mLock); 475 return mAudioPolicyManager->getDevicesForStream(stream); 476 } 477 478 audio_io_handle_t AudioPolicyService::getOutputForEffect(const effect_descriptor_t *desc) 479 { 480 // FIXME change return type to status_t, and return NO_INIT here 481 if (mAudioPolicyManager == NULL) { 482 return 0; 483 } 484 Mutex::Autolock _l(mLock); 485 return mAudioPolicyManager->getOutputForEffect(desc); 486 } 487 488 status_t AudioPolicyService::registerEffect(const effect_descriptor_t *desc, 489 audio_io_handle_t io, 490 uint32_t strategy, 491 audio_session_t session, 492 int id) 493 { 494 if (mAudioPolicyManager == NULL) { 495 return NO_INIT; 496 } 497 Mutex::Autolock _l(mEffectsLock); 498 return mAudioPolicyManager->registerEffect(desc, io, strategy, session, id); 499 } 500 501 status_t AudioPolicyService::unregisterEffect(int id) 502 { 503 if (mAudioPolicyManager == NULL) { 504 return NO_INIT; 505 } 506 Mutex::Autolock _l(mEffectsLock); 507 return mAudioPolicyManager->unregisterEffect(id); 508 } 509 510 status_t AudioPolicyService::setEffectEnabled(int id, bool enabled) 511 { 512 if (mAudioPolicyManager == NULL) { 513 return NO_INIT; 514 } 515 Mutex::Autolock _l(mEffectsLock); 516 return mAudioPolicyManager->setEffectEnabled(id, enabled); 517 } 518 519 bool AudioPolicyService::isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const 520 { 521 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) { 522 return false; 523 } 524 if (mAudioPolicyManager == NULL) { 525 return false; 526 } 527 Mutex::Autolock _l(mLock); 528 return mAudioPolicyManager->isStreamActive(stream, inPastMs); 529 } 530 531 bool AudioPolicyService::isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const 532 { 533 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) { 534 return false; 535 } 536 if (mAudioPolicyManager == NULL) { 537 return false; 538 } 539 Mutex::Autolock _l(mLock); 540 return mAudioPolicyManager->isStreamActiveRemotely(stream, inPastMs); 541 } 542 543 bool AudioPolicyService::isSourceActive(audio_source_t source) const 544 { 545 if (mAudioPolicyManager == NULL) { 546 return false; 547 } 548 Mutex::Autolock _l(mLock); 549 return mAudioPolicyManager->isSourceActive(source); 550 } 551 552 status_t AudioPolicyService::queryDefaultPreProcessing(audio_session_t audioSession, 553 effect_descriptor_t *descriptors, 554 uint32_t *count) 555 { 556 if (mAudioPolicyManager == NULL) { 557 *count = 0; 558 return NO_INIT; 559 } 560 sp<AudioPolicyEffects>audioPolicyEffects; 561 { 562 Mutex::Autolock _l(mLock); 563 audioPolicyEffects = mAudioPolicyEffects; 564 } 565 if (audioPolicyEffects == 0) { 566 *count = 0; 567 return NO_INIT; 568 } 569 return audioPolicyEffects->queryDefaultInputEffects(audioSession, descriptors, count); 570 } 571 572 bool AudioPolicyService::isOffloadSupported(const audio_offload_info_t& info) 573 { 574 if (mAudioPolicyManager == NULL) { 575 ALOGV("mAudioPolicyManager == NULL"); 576 return false; 577 } 578 Mutex::Autolock _l(mLock); 579 Mutex::Autolock _le(mEffectsLock); // isOffloadSupported queries for 580 // non-offloadable effects 581 return mAudioPolicyManager->isOffloadSupported(info); 582 } 583 584 status_t AudioPolicyService::listAudioPorts(audio_port_role_t role, 585 audio_port_type_t type, 586 unsigned int *num_ports, 587 struct audio_port *ports, 588 unsigned int *generation) 589 { 590 Mutex::Autolock _l(mLock); 591 if (mAudioPolicyManager == NULL) { 592 return NO_INIT; 593 } 594 595 return mAudioPolicyManager->listAudioPorts(role, type, num_ports, ports, generation); 596 } 597 598 status_t AudioPolicyService::getAudioPort(struct audio_port *port) 599 { 600 Mutex::Autolock _l(mLock); 601 if (mAudioPolicyManager == NULL) { 602 return NO_INIT; 603 } 604 605 return mAudioPolicyManager->getAudioPort(port); 606 } 607 608 status_t AudioPolicyService::createAudioPatch(const struct audio_patch *patch, 609 audio_patch_handle_t *handle) 610 { 611 Mutex::Autolock _l(mLock); 612 if(!modifyAudioRoutingAllowed()) { 613 return PERMISSION_DENIED; 614 } 615 if (mAudioPolicyManager == NULL) { 616 return NO_INIT; 617 } 618 return mAudioPolicyManager->createAudioPatch(patch, handle, 619 IPCThreadState::self()->getCallingUid()); 620 } 621 622 status_t AudioPolicyService::releaseAudioPatch(audio_patch_handle_t handle) 623 { 624 Mutex::Autolock _l(mLock); 625 if(!modifyAudioRoutingAllowed()) { 626 return PERMISSION_DENIED; 627 } 628 if (mAudioPolicyManager == NULL) { 629 return NO_INIT; 630 } 631 632 return mAudioPolicyManager->releaseAudioPatch(handle, 633 IPCThreadState::self()->getCallingUid()); 634 } 635 636 status_t AudioPolicyService::listAudioPatches(unsigned int *num_patches, 637 struct audio_patch *patches, 638 unsigned int *generation) 639 { 640 Mutex::Autolock _l(mLock); 641 if (mAudioPolicyManager == NULL) { 642 return NO_INIT; 643 } 644 645 return mAudioPolicyManager->listAudioPatches(num_patches, patches, generation); 646 } 647 648 status_t AudioPolicyService::setAudioPortConfig(const struct audio_port_config *config) 649 { 650 Mutex::Autolock _l(mLock); 651 if(!modifyAudioRoutingAllowed()) { 652 return PERMISSION_DENIED; 653 } 654 if (mAudioPolicyManager == NULL) { 655 return NO_INIT; 656 } 657 658 return mAudioPolicyManager->setAudioPortConfig(config); 659 } 660 661 status_t AudioPolicyService::acquireSoundTriggerSession(audio_session_t *session, 662 audio_io_handle_t *ioHandle, 663 audio_devices_t *device) 664 { 665 if (mAudioPolicyManager == NULL) { 666 return NO_INIT; 667 } 668 669 return mAudioPolicyManager->acquireSoundTriggerSession(session, ioHandle, device); 670 } 671 672 status_t AudioPolicyService::releaseSoundTriggerSession(audio_session_t session) 673 { 674 if (mAudioPolicyManager == NULL) { 675 return NO_INIT; 676 } 677 678 return mAudioPolicyManager->releaseSoundTriggerSession(session); 679 } 680 681 status_t AudioPolicyService::registerPolicyMixes(Vector<AudioMix> mixes, bool registration) 682 { 683 Mutex::Autolock _l(mLock); 684 if(!modifyAudioRoutingAllowed()) { 685 return PERMISSION_DENIED; 686 } 687 if (mAudioPolicyManager == NULL) { 688 return NO_INIT; 689 } 690 if (registration) { 691 return mAudioPolicyManager->registerPolicyMixes(mixes); 692 } else { 693 return mAudioPolicyManager->unregisterPolicyMixes(mixes); 694 } 695 } 696 697 status_t AudioPolicyService::startAudioSource(const struct audio_port_config *source, 698 const audio_attributes_t *attributes, 699 audio_io_handle_t *handle) 700 { 701 Mutex::Autolock _l(mLock); 702 if (mAudioPolicyManager == NULL) { 703 return NO_INIT; 704 } 705 706 return mAudioPolicyManager->startAudioSource(source, attributes, handle, 707 IPCThreadState::self()->getCallingUid()); 708 } 709 710 status_t AudioPolicyService::stopAudioSource(audio_io_handle_t handle) 711 { 712 Mutex::Autolock _l(mLock); 713 if (mAudioPolicyManager == NULL) { 714 return NO_INIT; 715 } 716 717 return mAudioPolicyManager->stopAudioSource(handle); 718 } 719 720 status_t AudioPolicyService::setMasterMono(bool mono) 721 { 722 if (mAudioPolicyManager == NULL) { 723 return NO_INIT; 724 } 725 if (!settingsAllowed()) { 726 return PERMISSION_DENIED; 727 } 728 Mutex::Autolock _l(mLock); 729 return mAudioPolicyManager->setMasterMono(mono); 730 } 731 732 status_t AudioPolicyService::getMasterMono(bool *mono) 733 { 734 if (mAudioPolicyManager == NULL) { 735 return NO_INIT; 736 } 737 Mutex::Autolock _l(mLock); 738 return mAudioPolicyManager->getMasterMono(mono); 739 } 740 741 }; // namespace android 742