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 "AudioPolicyService.h" 21 #include "TypeConverter.h" 22 #include <media/MediaAnalyticsItem.h> 23 #include <media/AudioPolicy.h> 24 #include <utils/Log.h> 25 26 namespace android { 27 28 29 // ---------------------------------------------------------------------------- 30 31 status_t AudioPolicyService::setDeviceConnectionState(audio_devices_t device, 32 audio_policy_dev_state_t state, 33 const char *device_address, 34 const char *device_name, 35 audio_format_t encodedFormat) 36 { 37 if (mAudioPolicyManager == NULL) { 38 return NO_INIT; 39 } 40 if (!settingsAllowed()) { 41 return PERMISSION_DENIED; 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 AutoCallerClear acc; 51 return mAudioPolicyManager->setDeviceConnectionState(device, state, 52 device_address, device_name, encodedFormat); 53 } 54 55 audio_policy_dev_state_t AudioPolicyService::getDeviceConnectionState( 56 audio_devices_t device, 57 const char *device_address) 58 { 59 if (mAudioPolicyManager == NULL) { 60 return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE; 61 } 62 AutoCallerClear acc; 63 return mAudioPolicyManager->getDeviceConnectionState(device, 64 device_address); 65 } 66 67 status_t AudioPolicyService::handleDeviceConfigChange(audio_devices_t device, 68 const char *device_address, 69 const char *device_name, 70 audio_format_t encodedFormat) 71 { 72 if (mAudioPolicyManager == NULL) { 73 return NO_INIT; 74 } 75 if (!settingsAllowed()) { 76 return PERMISSION_DENIED; 77 } 78 79 ALOGV("handleDeviceConfigChange()"); 80 Mutex::Autolock _l(mLock); 81 AutoCallerClear acc; 82 return mAudioPolicyManager->handleDeviceConfigChange(device, device_address, 83 device_name, encodedFormat); 84 } 85 86 status_t AudioPolicyService::setPhoneState(audio_mode_t state) 87 { 88 if (mAudioPolicyManager == NULL) { 89 return NO_INIT; 90 } 91 if (!settingsAllowed()) { 92 return PERMISSION_DENIED; 93 } 94 if (uint32_t(state) >= AUDIO_MODE_CNT) { 95 return BAD_VALUE; 96 } 97 98 ALOGV("setPhoneState()"); 99 100 // acquire lock before calling setMode() so that setMode() + setPhoneState() are an atomic 101 // operation from policy manager standpoint (no other operation (e.g track start or stop) 102 // can be interleaved). 103 Mutex::Autolock _l(mLock); 104 // TODO: check if it is more appropriate to do it in platform specific policy manager 105 AudioSystem::setMode(state); 106 107 AutoCallerClear acc; 108 mAudioPolicyManager->setPhoneState(state); 109 mPhoneState = state; 110 return NO_ERROR; 111 } 112 113 audio_mode_t AudioPolicyService::getPhoneState() 114 { 115 Mutex::Autolock _l(mLock); 116 return mPhoneState; 117 } 118 119 status_t AudioPolicyService::setForceUse(audio_policy_force_use_t usage, 120 audio_policy_forced_cfg_t config) 121 { 122 if (mAudioPolicyManager == NULL) { 123 return NO_INIT; 124 } 125 126 if (!modifyAudioRoutingAllowed()) { 127 return PERMISSION_DENIED; 128 } 129 130 if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) { 131 return BAD_VALUE; 132 } 133 if (config < 0 || config >= AUDIO_POLICY_FORCE_CFG_CNT) { 134 return BAD_VALUE; 135 } 136 ALOGV("setForceUse()"); 137 Mutex::Autolock _l(mLock); 138 AutoCallerClear acc; 139 mAudioPolicyManager->setForceUse(usage, config); 140 return NO_ERROR; 141 } 142 143 audio_policy_forced_cfg_t AudioPolicyService::getForceUse(audio_policy_force_use_t usage) 144 { 145 if (mAudioPolicyManager == NULL) { 146 return AUDIO_POLICY_FORCE_NONE; 147 } 148 if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) { 149 return AUDIO_POLICY_FORCE_NONE; 150 } 151 AutoCallerClear acc; 152 return mAudioPolicyManager->getForceUse(usage); 153 } 154 155 audio_io_handle_t AudioPolicyService::getOutput(audio_stream_type_t stream) 156 { 157 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) { 158 return AUDIO_IO_HANDLE_NONE; 159 } 160 if (mAudioPolicyManager == NULL) { 161 return AUDIO_IO_HANDLE_NONE; 162 } 163 ALOGV("getOutput()"); 164 Mutex::Autolock _l(mLock); 165 AutoCallerClear acc; 166 return mAudioPolicyManager->getOutput(stream); 167 } 168 169 status_t AudioPolicyService::getOutputForAttr(audio_attributes_t *attr, 170 audio_io_handle_t *output, 171 audio_session_t session, 172 audio_stream_type_t *stream, 173 pid_t pid, 174 uid_t uid, 175 const audio_config_t *config, 176 audio_output_flags_t flags, 177 audio_port_handle_t *selectedDeviceId, 178 audio_port_handle_t *portId, 179 std::vector<audio_io_handle_t> *secondaryOutputs) 180 { 181 if (mAudioPolicyManager == NULL) { 182 return NO_INIT; 183 } 184 ALOGV("getOutputForAttr()"); 185 Mutex::Autolock _l(mLock); 186 187 const uid_t callingUid = IPCThreadState::self()->getCallingUid(); 188 if (!isAudioServerOrMediaServerUid(callingUid) || uid == (uid_t)-1) { 189 ALOGW_IF(uid != (uid_t)-1 && uid != callingUid, 190 "%s uid %d tried to pass itself off as %d", __FUNCTION__, callingUid, uid); 191 uid = callingUid; 192 } 193 if (!mPackageManager.allowPlaybackCapture(uid)) { 194 attr->flags |= AUDIO_FLAG_NO_MEDIA_PROJECTION; 195 } 196 if (((attr->flags & (AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY|AUDIO_FLAG_BYPASS_MUTE)) != 0) 197 && !bypassInterruptionPolicyAllowed(pid, uid)) { 198 attr->flags &= ~(AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY|AUDIO_FLAG_BYPASS_MUTE); 199 } 200 audio_output_flags_t originalFlags = flags; 201 AutoCallerClear acc; 202 status_t result = mAudioPolicyManager->getOutputForAttr(attr, output, session, stream, uid, 203 config, 204 &flags, selectedDeviceId, portId, 205 secondaryOutputs); 206 207 // FIXME: Introduce a way to check for the the telephony device before opening the output 208 if ((result == NO_ERROR) && 209 (flags & AUDIO_OUTPUT_FLAG_INCALL_MUSIC) && 210 !modifyPhoneStateAllowed(pid, uid)) { 211 // If the app tries to play music through the telephony device and doesn't have permission 212 // the fallback to the default output device. 213 mAudioPolicyManager->releaseOutput(*portId); 214 flags = originalFlags; 215 *selectedDeviceId = AUDIO_PORT_HANDLE_NONE; 216 *portId = AUDIO_PORT_HANDLE_NONE; 217 secondaryOutputs->clear(); 218 result = mAudioPolicyManager->getOutputForAttr(attr, output, session, stream, uid, config, 219 &flags, selectedDeviceId, portId, 220 secondaryOutputs); 221 } 222 223 if (result == NO_ERROR) { 224 sp <AudioPlaybackClient> client = 225 new AudioPlaybackClient(*attr, *output, uid, pid, session, *selectedDeviceId, *stream); 226 mAudioPlaybackClients.add(*portId, client); 227 } 228 return result; 229 } 230 231 void AudioPolicyService::getPlaybackClientAndEffects(audio_port_handle_t portId, 232 sp<AudioPlaybackClient>& client, 233 sp<AudioPolicyEffects>& effects, 234 const char *context) 235 { 236 Mutex::Autolock _l(mLock); 237 const ssize_t index = mAudioPlaybackClients.indexOfKey(portId); 238 if (index < 0) { 239 ALOGE("%s AudioTrack client not found for portId %d", context, portId); 240 return; 241 } 242 client = mAudioPlaybackClients.valueAt(index); 243 effects = mAudioPolicyEffects; 244 } 245 246 status_t AudioPolicyService::startOutput(audio_port_handle_t portId) 247 { 248 if (mAudioPolicyManager == NULL) { 249 return NO_INIT; 250 } 251 ALOGV("startOutput()"); 252 sp<AudioPlaybackClient> client; 253 sp<AudioPolicyEffects>audioPolicyEffects; 254 255 getPlaybackClientAndEffects(portId, client, audioPolicyEffects, __func__); 256 257 if (audioPolicyEffects != 0) { 258 // create audio processors according to stream 259 status_t status = audioPolicyEffects->addOutputSessionEffects( 260 client->io, client->stream, client->session); 261 if (status != NO_ERROR && status != ALREADY_EXISTS) { 262 ALOGW("Failed to add effects on session %d", client->session); 263 } 264 } 265 Mutex::Autolock _l(mLock); 266 AutoCallerClear acc; 267 status_t status = mAudioPolicyManager->startOutput(portId); 268 if (status == NO_ERROR) { 269 client->active = true; 270 } 271 return status; 272 } 273 274 status_t AudioPolicyService::stopOutput(audio_port_handle_t portId) 275 { 276 if (mAudioPolicyManager == NULL) { 277 return NO_INIT; 278 } 279 ALOGV("stopOutput()"); 280 mOutputCommandThread->stopOutputCommand(portId); 281 return NO_ERROR; 282 } 283 284 status_t AudioPolicyService::doStopOutput(audio_port_handle_t portId) 285 { 286 ALOGV("doStopOutput"); 287 sp<AudioPlaybackClient> client; 288 sp<AudioPolicyEffects>audioPolicyEffects; 289 290 getPlaybackClientAndEffects(portId, client, audioPolicyEffects, __func__); 291 292 if (audioPolicyEffects != 0) { 293 // release audio processors from the stream 294 status_t status = audioPolicyEffects->releaseOutputSessionEffects( 295 client->io, client->stream, client->session); 296 if (status != NO_ERROR && status != ALREADY_EXISTS) { 297 ALOGW("Failed to release effects on session %d", client->session); 298 } 299 } 300 Mutex::Autolock _l(mLock); 301 AutoCallerClear acc; 302 status_t status = mAudioPolicyManager->stopOutput(portId); 303 if (status == NO_ERROR) { 304 client->active = false; 305 } 306 return status; 307 } 308 309 void AudioPolicyService::releaseOutput(audio_port_handle_t portId) 310 { 311 if (mAudioPolicyManager == NULL) { 312 return; 313 } 314 ALOGV("releaseOutput()"); 315 mOutputCommandThread->releaseOutputCommand(portId); 316 } 317 318 void AudioPolicyService::doReleaseOutput(audio_port_handle_t portId) 319 { 320 ALOGV("doReleaseOutput from tid %d", gettid()); 321 sp<AudioPlaybackClient> client; 322 sp<AudioPolicyEffects> audioPolicyEffects; 323 324 getPlaybackClientAndEffects(portId, client, audioPolicyEffects, __func__); 325 326 if (audioPolicyEffects != 0 && client->active) { 327 // clean up effects if output was not stopped before being released 328 audioPolicyEffects->releaseOutputSessionEffects( 329 client->io, client->stream, client->session); 330 } 331 Mutex::Autolock _l(mLock); 332 mAudioPlaybackClients.removeItem(portId); 333 334 // called from internal thread: no need to clear caller identity 335 mAudioPolicyManager->releaseOutput(portId); 336 } 337 338 status_t AudioPolicyService::getInputForAttr(const audio_attributes_t *attr, 339 audio_io_handle_t *input, 340 audio_unique_id_t riid, 341 audio_session_t session, 342 pid_t pid, 343 uid_t uid, 344 const String16& opPackageName, 345 const audio_config_base_t *config, 346 audio_input_flags_t flags, 347 audio_port_handle_t *selectedDeviceId, 348 audio_port_handle_t *portId) 349 { 350 if (mAudioPolicyManager == NULL) { 351 return NO_INIT; 352 } 353 354 // already checked by client, but double-check in case the client wrapper is bypassed 355 if ((attr->source < AUDIO_SOURCE_DEFAULT) 356 || (attr->source >= AUDIO_SOURCE_CNT 357 && attr->source != AUDIO_SOURCE_HOTWORD 358 && attr->source != AUDIO_SOURCE_FM_TUNER 359 && attr->source != AUDIO_SOURCE_ECHO_REFERENCE)) { 360 return BAD_VALUE; 361 } 362 363 bool updatePid = (pid == -1); 364 const uid_t callingUid = IPCThreadState::self()->getCallingUid(); 365 if (!isAudioServerOrMediaServerUid(callingUid)) { 366 ALOGW_IF(uid != (uid_t)-1 && uid != callingUid, 367 "%s uid %d tried to pass itself off as %d", __FUNCTION__, callingUid, uid); 368 uid = callingUid; 369 updatePid = true; 370 } 371 372 if (updatePid) { 373 const pid_t callingPid = IPCThreadState::self()->getCallingPid(); 374 ALOGW_IF(pid != (pid_t)-1 && pid != callingPid, 375 "%s uid %d pid %d tried to pass itself off as pid %d", 376 __func__, callingUid, callingPid, pid); 377 pid = callingPid; 378 } 379 380 // check calling permissions 381 if (!recordingAllowed(opPackageName, pid, uid)) { 382 ALOGE("%s permission denied: recording not allowed for uid %d pid %d", 383 __func__, uid, pid); 384 return PERMISSION_DENIED; 385 } 386 387 bool canCaptureOutput = captureAudioOutputAllowed(pid, uid); 388 if ((attr->source == AUDIO_SOURCE_VOICE_UPLINK || 389 attr->source == AUDIO_SOURCE_VOICE_DOWNLINK || 390 attr->source == AUDIO_SOURCE_VOICE_CALL || 391 attr->source == AUDIO_SOURCE_ECHO_REFERENCE) && 392 !canCaptureOutput) { 393 return PERMISSION_DENIED; 394 } 395 396 bool canCaptureHotword = captureHotwordAllowed(opPackageName, pid, uid); 397 if ((attr->source == AUDIO_SOURCE_HOTWORD) && !canCaptureHotword) { 398 return BAD_VALUE; 399 } 400 401 sp<AudioPolicyEffects>audioPolicyEffects; 402 { 403 status_t status; 404 AudioPolicyInterface::input_type_t inputType; 405 406 Mutex::Autolock _l(mLock); 407 { 408 AutoCallerClear acc; 409 // the audio_in_acoustics_t parameter is ignored by get_input() 410 status = mAudioPolicyManager->getInputForAttr(attr, input, riid, session, uid, 411 config, 412 flags, selectedDeviceId, 413 &inputType, portId); 414 } 415 audioPolicyEffects = mAudioPolicyEffects; 416 417 if (status == NO_ERROR) { 418 // enforce permission (if any) required for each type of input 419 switch (inputType) { 420 case AudioPolicyInterface::API_INPUT_MIX_PUBLIC_CAPTURE_PLAYBACK: 421 // this use case has been validated in audio service with a MediaProjection token, 422 // and doesn't rely on regular permissions 423 case AudioPolicyInterface::API_INPUT_LEGACY: 424 break; 425 case AudioPolicyInterface::API_INPUT_TELEPHONY_RX: 426 // FIXME: use the same permission as for remote submix for now. 427 case AudioPolicyInterface::API_INPUT_MIX_CAPTURE: 428 if (!canCaptureOutput) { 429 ALOGE("getInputForAttr() permission denied: capture not allowed"); 430 status = PERMISSION_DENIED; 431 } 432 break; 433 case AudioPolicyInterface::API_INPUT_MIX_EXT_POLICY_REROUTE: 434 if (!modifyAudioRoutingAllowed()) { 435 ALOGE("getInputForAttr() permission denied: modify audio routing not allowed"); 436 status = PERMISSION_DENIED; 437 } 438 break; 439 case AudioPolicyInterface::API_INPUT_INVALID: 440 default: 441 LOG_ALWAYS_FATAL("getInputForAttr() encountered an invalid input type %d", 442 (int)inputType); 443 } 444 } 445 446 if (status != NO_ERROR) { 447 if (status == PERMISSION_DENIED) { 448 AutoCallerClear acc; 449 mAudioPolicyManager->releaseInput(*portId); 450 } 451 return status; 452 } 453 454 sp<AudioRecordClient> client = new AudioRecordClient(*attr, *input, uid, pid, session, 455 *selectedDeviceId, opPackageName, 456 canCaptureOutput, canCaptureHotword); 457 mAudioRecordClients.add(*portId, client); 458 } 459 460 if (audioPolicyEffects != 0) { 461 // create audio pre processors according to input source 462 status_t status = audioPolicyEffects->addInputEffects(*input, attr->source, session); 463 if (status != NO_ERROR && status != ALREADY_EXISTS) { 464 ALOGW("Failed to add effects on input %d", *input); 465 } 466 } 467 return NO_ERROR; 468 } 469 470 std::string AudioPolicyService::getDeviceTypeStrForPortId(audio_port_handle_t portId) { 471 struct audio_port port = {}; 472 port.id = portId; 473 status_t status = mAudioPolicyManager->getAudioPort(&port); 474 if (status == NO_ERROR && port.type == AUDIO_PORT_TYPE_DEVICE) { 475 return toString(port.ext.device.type); 476 } 477 return {}; 478 } 479 480 status_t AudioPolicyService::startInput(audio_port_handle_t portId) 481 { 482 if (mAudioPolicyManager == NULL) { 483 return NO_INIT; 484 } 485 sp<AudioRecordClient> client; 486 { 487 Mutex::Autolock _l(mLock); 488 489 ssize_t index = mAudioRecordClients.indexOfKey(portId); 490 if (index < 0) { 491 return INVALID_OPERATION; 492 } 493 client = mAudioRecordClients.valueAt(index); 494 } 495 496 // check calling permissions 497 if (!startRecording(client->opPackageName, client->pid, client->uid)) { 498 ALOGE("%s permission denied: recording not allowed for uid %d pid %d", 499 __func__, client->uid, client->pid); 500 return PERMISSION_DENIED; 501 } 502 503 Mutex::Autolock _l(mLock); 504 505 client->active = true; 506 client->startTimeNs = systemTime(); 507 updateUidStates_l(); 508 509 status_t status; 510 { 511 AutoCallerClear acc; 512 status = mAudioPolicyManager->startInput(portId); 513 514 } 515 516 // including successes gets very verbose 517 // but once we cut over to westworld, log them all. 518 if (status != NO_ERROR) { 519 520 static constexpr char kAudioPolicy[] = "audiopolicy"; 521 522 static constexpr char kAudioPolicyStatus[] = "android.media.audiopolicy.status"; 523 static constexpr char kAudioPolicyRqstSrc[] = "android.media.audiopolicy.rqst.src"; 524 static constexpr char kAudioPolicyRqstPkg[] = "android.media.audiopolicy.rqst.pkg"; 525 static constexpr char kAudioPolicyRqstSession[] = "android.media.audiopolicy.rqst.session"; 526 static constexpr char kAudioPolicyRqstDevice[] = 527 "android.media.audiopolicy.rqst.device"; 528 static constexpr char kAudioPolicyActiveSrc[] = "android.media.audiopolicy.active.src"; 529 static constexpr char kAudioPolicyActivePkg[] = "android.media.audiopolicy.active.pkg"; 530 static constexpr char kAudioPolicyActiveSession[] = 531 "android.media.audiopolicy.active.session"; 532 static constexpr char kAudioPolicyActiveDevice[] = 533 "android.media.audiopolicy.active.device"; 534 535 MediaAnalyticsItem *item = MediaAnalyticsItem::create(kAudioPolicy); 536 if (item != NULL) { 537 538 item->setInt32(kAudioPolicyStatus, status); 539 540 item->setCString(kAudioPolicyRqstSrc, 541 toString(client->attributes.source).c_str()); 542 item->setInt32(kAudioPolicyRqstSession, client->session); 543 if (client->opPackageName.size() != 0) { 544 item->setCString(kAudioPolicyRqstPkg, 545 std::string(String8(client->opPackageName).string()).c_str()); 546 } else { 547 item->setCString(kAudioPolicyRqstPkg, std::to_string(client->uid).c_str()); 548 } 549 item->setCString( 550 kAudioPolicyRqstDevice, getDeviceTypeStrForPortId(client->deviceId).c_str()); 551 552 int count = mAudioRecordClients.size(); 553 for (int i = 0; i < count ; i++) { 554 if (portId == mAudioRecordClients.keyAt(i)) { 555 continue; 556 } 557 sp<AudioRecordClient> other = mAudioRecordClients.valueAt(i); 558 if (other->active) { 559 // keeps the last of the clients marked active 560 item->setCString(kAudioPolicyActiveSrc, 561 toString(other->attributes.source).c_str()); 562 item->setInt32(kAudioPolicyActiveSession, other->session); 563 if (other->opPackageName.size() != 0) { 564 item->setCString(kAudioPolicyActivePkg, 565 std::string(String8(other->opPackageName).string()).c_str()); 566 } else { 567 item->setCString(kAudioPolicyRqstPkg, 568 std::to_string(other->uid).c_str()); 569 } 570 item->setCString(kAudioPolicyActiveDevice, 571 getDeviceTypeStrForPortId(other->deviceId).c_str()); 572 } 573 } 574 item->selfrecord(); 575 delete item; 576 item = NULL; 577 } 578 } 579 580 if (status != NO_ERROR) { 581 client->active = false; 582 client->startTimeNs = 0; 583 updateUidStates_l(); 584 finishRecording(client->opPackageName, client->uid); 585 } 586 587 return status; 588 } 589 590 status_t AudioPolicyService::stopInput(audio_port_handle_t portId) 591 { 592 if (mAudioPolicyManager == NULL) { 593 return NO_INIT; 594 } 595 596 Mutex::Autolock _l(mLock); 597 598 ssize_t index = mAudioRecordClients.indexOfKey(portId); 599 if (index < 0) { 600 return INVALID_OPERATION; 601 } 602 sp<AudioRecordClient> client = mAudioRecordClients.valueAt(index); 603 604 client->active = false; 605 client->startTimeNs = 0; 606 607 updateUidStates_l(); 608 609 // finish the recording app op 610 finishRecording(client->opPackageName, client->uid); 611 AutoCallerClear acc; 612 return mAudioPolicyManager->stopInput(portId); 613 } 614 615 void AudioPolicyService::releaseInput(audio_port_handle_t portId) 616 { 617 if (mAudioPolicyManager == NULL) { 618 return; 619 } 620 sp<AudioPolicyEffects>audioPolicyEffects; 621 sp<AudioRecordClient> client; 622 { 623 Mutex::Autolock _l(mLock); 624 audioPolicyEffects = mAudioPolicyEffects; 625 ssize_t index = mAudioRecordClients.indexOfKey(portId); 626 if (index < 0) { 627 return; 628 } 629 client = mAudioRecordClients.valueAt(index); 630 631 if (client->active) { 632 ALOGW("%s releasing active client portId %d", __FUNCTION__, portId); 633 client->active = false; 634 client->startTimeNs = 0; 635 updateUidStates_l(); 636 } 637 638 mAudioRecordClients.removeItem(portId); 639 } 640 if (client == 0) { 641 return; 642 } 643 if (audioPolicyEffects != 0) { 644 // release audio processors from the input 645 status_t status = audioPolicyEffects->releaseInputEffects(client->io, client->session); 646 if(status != NO_ERROR) { 647 ALOGW("Failed to release effects on input %d", client->io); 648 } 649 } 650 { 651 Mutex::Autolock _l(mLock); 652 AutoCallerClear acc; 653 mAudioPolicyManager->releaseInput(portId); 654 } 655 } 656 657 status_t AudioPolicyService::initStreamVolume(audio_stream_type_t stream, 658 int indexMin, 659 int indexMax) 660 { 661 if (mAudioPolicyManager == NULL) { 662 return NO_INIT; 663 } 664 if (!settingsAllowed()) { 665 return PERMISSION_DENIED; 666 } 667 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) { 668 return BAD_VALUE; 669 } 670 Mutex::Autolock _l(mLock); 671 AutoCallerClear acc; 672 mAudioPolicyManager->initStreamVolume(stream, indexMin, indexMax); 673 return NO_ERROR; 674 } 675 676 status_t AudioPolicyService::setStreamVolumeIndex(audio_stream_type_t stream, 677 int index, 678 audio_devices_t device) 679 { 680 if (mAudioPolicyManager == NULL) { 681 return NO_INIT; 682 } 683 if (!settingsAllowed()) { 684 return PERMISSION_DENIED; 685 } 686 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) { 687 return BAD_VALUE; 688 } 689 Mutex::Autolock _l(mLock); 690 AutoCallerClear acc; 691 return mAudioPolicyManager->setStreamVolumeIndex(stream, 692 index, 693 device); 694 } 695 696 status_t AudioPolicyService::getStreamVolumeIndex(audio_stream_type_t stream, 697 int *index, 698 audio_devices_t device) 699 { 700 if (mAudioPolicyManager == NULL) { 701 return NO_INIT; 702 } 703 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) { 704 return BAD_VALUE; 705 } 706 Mutex::Autolock _l(mLock); 707 AutoCallerClear acc; 708 return mAudioPolicyManager->getStreamVolumeIndex(stream, 709 index, 710 device); 711 } 712 713 status_t AudioPolicyService::setVolumeIndexForAttributes(const audio_attributes_t &attributes, 714 int index, audio_devices_t device) 715 { 716 if (mAudioPolicyManager == NULL) { 717 return NO_INIT; 718 } 719 if (!settingsAllowed()) { 720 return PERMISSION_DENIED; 721 } 722 Mutex::Autolock _l(mLock); 723 AutoCallerClear acc; 724 return mAudioPolicyManager->setVolumeIndexForAttributes(attributes, index, device); 725 } 726 727 status_t AudioPolicyService::getVolumeIndexForAttributes(const audio_attributes_t &attributes, 728 int &index, audio_devices_t device) 729 { 730 if (mAudioPolicyManager == NULL) { 731 return NO_INIT; 732 } 733 Mutex::Autolock _l(mLock); 734 AutoCallerClear acc; 735 return mAudioPolicyManager->getVolumeIndexForAttributes(attributes, index, device); 736 } 737 738 status_t AudioPolicyService::getMinVolumeIndexForAttributes(const audio_attributes_t &attributes, 739 int &index) 740 { 741 if (mAudioPolicyManager == NULL) { 742 return NO_INIT; 743 } 744 Mutex::Autolock _l(mLock); 745 AutoCallerClear acc; 746 return mAudioPolicyManager->getMinVolumeIndexForAttributes(attributes, index); 747 } 748 749 status_t AudioPolicyService::getMaxVolumeIndexForAttributes(const audio_attributes_t &attributes, 750 int &index) 751 { 752 if (mAudioPolicyManager == NULL) { 753 return NO_INIT; 754 } 755 Mutex::Autolock _l(mLock); 756 AutoCallerClear acc; 757 return mAudioPolicyManager->getMaxVolumeIndexForAttributes(attributes, index); 758 } 759 760 uint32_t AudioPolicyService::getStrategyForStream(audio_stream_type_t stream) 761 { 762 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) { 763 return PRODUCT_STRATEGY_NONE; 764 } 765 if (mAudioPolicyManager == NULL) { 766 return PRODUCT_STRATEGY_NONE; 767 } 768 // DO NOT LOCK, may be called from AudioFlinger with lock held, reaching deadlock 769 AutoCallerClear acc; 770 return mAudioPolicyManager->getStrategyForStream(stream); 771 } 772 773 //audio policy: use audio_device_t appropriately 774 775 audio_devices_t AudioPolicyService::getDevicesForStream(audio_stream_type_t stream) 776 { 777 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) { 778 return AUDIO_DEVICE_NONE; 779 } 780 if (mAudioPolicyManager == NULL) { 781 return AUDIO_DEVICE_NONE; 782 } 783 Mutex::Autolock _l(mLock); 784 AutoCallerClear acc; 785 return mAudioPolicyManager->getDevicesForStream(stream); 786 } 787 788 audio_io_handle_t AudioPolicyService::getOutputForEffect(const effect_descriptor_t *desc) 789 { 790 // FIXME change return type to status_t, and return NO_INIT here 791 if (mAudioPolicyManager == NULL) { 792 return 0; 793 } 794 Mutex::Autolock _l(mLock); 795 AutoCallerClear acc; 796 return mAudioPolicyManager->getOutputForEffect(desc); 797 } 798 799 status_t AudioPolicyService::registerEffect(const effect_descriptor_t *desc, 800 audio_io_handle_t io, 801 uint32_t strategy, 802 audio_session_t session, 803 int id) 804 { 805 if (mAudioPolicyManager == NULL) { 806 return NO_INIT; 807 } 808 Mutex::Autolock _l(mLock); 809 AutoCallerClear acc; 810 return mAudioPolicyManager->registerEffect(desc, io, strategy, session, id); 811 } 812 813 status_t AudioPolicyService::unregisterEffect(int id) 814 { 815 if (mAudioPolicyManager == NULL) { 816 return NO_INIT; 817 } 818 Mutex::Autolock _l(mLock); 819 AutoCallerClear acc; 820 return mAudioPolicyManager->unregisterEffect(id); 821 } 822 823 status_t AudioPolicyService::setEffectEnabled(int id, bool enabled) 824 { 825 if (mAudioPolicyManager == NULL) { 826 return NO_INIT; 827 } 828 Mutex::Autolock _l(mLock); 829 AutoCallerClear acc; 830 return mAudioPolicyManager->setEffectEnabled(id, enabled); 831 } 832 833 status_t AudioPolicyService::moveEffectsToIo(const std::vector<int>& ids, audio_io_handle_t io) 834 { 835 if (mAudioPolicyManager == NULL) { 836 return NO_INIT; 837 } 838 Mutex::Autolock _l(mLock); 839 AutoCallerClear acc; 840 return mAudioPolicyManager->moveEffectsToIo(ids, io); 841 } 842 843 bool AudioPolicyService::isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const 844 { 845 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) { 846 return false; 847 } 848 if (mAudioPolicyManager == NULL) { 849 return false; 850 } 851 Mutex::Autolock _l(mLock); 852 AutoCallerClear acc; 853 return mAudioPolicyManager->isStreamActive(stream, inPastMs); 854 } 855 856 bool AudioPolicyService::isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const 857 { 858 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) { 859 return false; 860 } 861 if (mAudioPolicyManager == NULL) { 862 return false; 863 } 864 Mutex::Autolock _l(mLock); 865 AutoCallerClear acc; 866 return mAudioPolicyManager->isStreamActiveRemotely(stream, inPastMs); 867 } 868 869 bool AudioPolicyService::isSourceActive(audio_source_t source) const 870 { 871 if (mAudioPolicyManager == NULL) { 872 return false; 873 } 874 Mutex::Autolock _l(mLock); 875 AutoCallerClear acc; 876 return mAudioPolicyManager->isSourceActive(source); 877 } 878 879 status_t AudioPolicyService::getAudioPolicyEffects(sp<AudioPolicyEffects>& audioPolicyEffects) 880 { 881 if (mAudioPolicyManager == NULL) { 882 return NO_INIT; 883 } 884 { 885 Mutex::Autolock _l(mLock); 886 audioPolicyEffects = mAudioPolicyEffects; 887 } 888 if (audioPolicyEffects == 0) { 889 return NO_INIT; 890 } 891 892 return OK; 893 } 894 895 status_t AudioPolicyService::queryDefaultPreProcessing(audio_session_t audioSession, 896 effect_descriptor_t *descriptors, 897 uint32_t *count) 898 { 899 sp<AudioPolicyEffects>audioPolicyEffects; 900 status_t status = getAudioPolicyEffects(audioPolicyEffects); 901 if (status != OK) { 902 *count = 0; 903 return status; 904 } 905 return audioPolicyEffects->queryDefaultInputEffects( 906 (audio_session_t)audioSession, descriptors, count); 907 } 908 909 status_t AudioPolicyService::addSourceDefaultEffect(const effect_uuid_t *type, 910 const String16& opPackageName, 911 const effect_uuid_t *uuid, 912 int32_t priority, 913 audio_source_t source, 914 audio_unique_id_t* id) 915 { 916 sp<AudioPolicyEffects>audioPolicyEffects; 917 status_t status = getAudioPolicyEffects(audioPolicyEffects); 918 if (status != OK) { 919 return status; 920 } 921 if (!modifyDefaultAudioEffectsAllowed()) { 922 return PERMISSION_DENIED; 923 } 924 return audioPolicyEffects->addSourceDefaultEffect( 925 type, opPackageName, uuid, priority, source, id); 926 } 927 928 status_t AudioPolicyService::addStreamDefaultEffect(const effect_uuid_t *type, 929 const String16& opPackageName, 930 const effect_uuid_t *uuid, 931 int32_t priority, 932 audio_usage_t usage, 933 audio_unique_id_t* id) 934 { 935 sp<AudioPolicyEffects>audioPolicyEffects; 936 status_t status = getAudioPolicyEffects(audioPolicyEffects); 937 if (status != OK) { 938 return status; 939 } 940 if (!modifyDefaultAudioEffectsAllowed()) { 941 return PERMISSION_DENIED; 942 } 943 return audioPolicyEffects->addStreamDefaultEffect( 944 type, opPackageName, uuid, priority, usage, id); 945 } 946 947 status_t AudioPolicyService::removeSourceDefaultEffect(audio_unique_id_t id) 948 { 949 sp<AudioPolicyEffects>audioPolicyEffects; 950 status_t status = getAudioPolicyEffects(audioPolicyEffects); 951 if (status != OK) { 952 return status; 953 } 954 if (!modifyDefaultAudioEffectsAllowed()) { 955 return PERMISSION_DENIED; 956 } 957 return audioPolicyEffects->removeSourceDefaultEffect(id); 958 } 959 960 status_t AudioPolicyService::removeStreamDefaultEffect(audio_unique_id_t id) 961 { 962 sp<AudioPolicyEffects>audioPolicyEffects; 963 status_t status = getAudioPolicyEffects(audioPolicyEffects); 964 if (status != OK) { 965 return status; 966 } 967 if (!modifyDefaultAudioEffectsAllowed()) { 968 return PERMISSION_DENIED; 969 } 970 return audioPolicyEffects->removeStreamDefaultEffect(id); 971 } 972 973 status_t AudioPolicyService::setAllowedCapturePolicy(uid_t uid, audio_flags_mask_t capturePolicy) { 974 Mutex::Autolock _l(mLock); 975 if (mAudioPolicyManager == NULL) { 976 ALOGV("%s() mAudioPolicyManager == NULL", __func__); 977 return NO_INIT; 978 } 979 uint_t callingUid = IPCThreadState::self()->getCallingUid(); 980 if (uid != callingUid) { 981 ALOGD("%s() uid invalid %d != %d", __func__, uid, callingUid); 982 return PERMISSION_DENIED; 983 } 984 return mAudioPolicyManager->setAllowedCapturePolicy(uid, capturePolicy); 985 } 986 987 bool AudioPolicyService::isOffloadSupported(const audio_offload_info_t& info) 988 { 989 if (mAudioPolicyManager == NULL) { 990 ALOGV("mAudioPolicyManager == NULL"); 991 return false; 992 } 993 Mutex::Autolock _l(mLock); 994 AutoCallerClear acc; 995 return mAudioPolicyManager->isOffloadSupported(info); 996 } 997 998 bool AudioPolicyService::isDirectOutputSupported(const audio_config_base_t& config, 999 const audio_attributes_t& attributes) { 1000 if (mAudioPolicyManager == NULL) { 1001 ALOGV("mAudioPolicyManager == NULL"); 1002 return false; 1003 } 1004 Mutex::Autolock _l(mLock); 1005 return mAudioPolicyManager->isDirectOutputSupported(config, attributes); 1006 } 1007 1008 1009 status_t AudioPolicyService::listAudioPorts(audio_port_role_t role, 1010 audio_port_type_t type, 1011 unsigned int *num_ports, 1012 struct audio_port *ports, 1013 unsigned int *generation) 1014 { 1015 Mutex::Autolock _l(mLock); 1016 if (mAudioPolicyManager == NULL) { 1017 return NO_INIT; 1018 } 1019 AutoCallerClear acc; 1020 return mAudioPolicyManager->listAudioPorts(role, type, num_ports, ports, generation); 1021 } 1022 1023 status_t AudioPolicyService::getAudioPort(struct audio_port *port) 1024 { 1025 Mutex::Autolock _l(mLock); 1026 if (mAudioPolicyManager == NULL) { 1027 return NO_INIT; 1028 } 1029 AutoCallerClear acc; 1030 return mAudioPolicyManager->getAudioPort(port); 1031 } 1032 1033 status_t AudioPolicyService::createAudioPatch(const struct audio_patch *patch, 1034 audio_patch_handle_t *handle) 1035 { 1036 Mutex::Autolock _l(mLock); 1037 if(!modifyAudioRoutingAllowed()) { 1038 return PERMISSION_DENIED; 1039 } 1040 if (mAudioPolicyManager == NULL) { 1041 return NO_INIT; 1042 } 1043 AutoCallerClear acc; 1044 return mAudioPolicyManager->createAudioPatch(patch, handle, 1045 IPCThreadState::self()->getCallingUid()); 1046 } 1047 1048 status_t AudioPolicyService::releaseAudioPatch(audio_patch_handle_t handle) 1049 { 1050 Mutex::Autolock _l(mLock); 1051 if(!modifyAudioRoutingAllowed()) { 1052 return PERMISSION_DENIED; 1053 } 1054 if (mAudioPolicyManager == NULL) { 1055 return NO_INIT; 1056 } 1057 AutoCallerClear acc; 1058 return mAudioPolicyManager->releaseAudioPatch(handle, 1059 IPCThreadState::self()->getCallingUid()); 1060 } 1061 1062 status_t AudioPolicyService::listAudioPatches(unsigned int *num_patches, 1063 struct audio_patch *patches, 1064 unsigned int *generation) 1065 { 1066 Mutex::Autolock _l(mLock); 1067 if (mAudioPolicyManager == NULL) { 1068 return NO_INIT; 1069 } 1070 AutoCallerClear acc; 1071 return mAudioPolicyManager->listAudioPatches(num_patches, patches, generation); 1072 } 1073 1074 status_t AudioPolicyService::setAudioPortConfig(const struct audio_port_config *config) 1075 { 1076 Mutex::Autolock _l(mLock); 1077 if(!modifyAudioRoutingAllowed()) { 1078 return PERMISSION_DENIED; 1079 } 1080 if (mAudioPolicyManager == NULL) { 1081 return NO_INIT; 1082 } 1083 AutoCallerClear acc; 1084 return mAudioPolicyManager->setAudioPortConfig(config); 1085 } 1086 1087 status_t AudioPolicyService::acquireSoundTriggerSession(audio_session_t *session, 1088 audio_io_handle_t *ioHandle, 1089 audio_devices_t *device) 1090 { 1091 Mutex::Autolock _l(mLock); 1092 if (mAudioPolicyManager == NULL) { 1093 return NO_INIT; 1094 } 1095 AutoCallerClear acc; 1096 return mAudioPolicyManager->acquireSoundTriggerSession(session, ioHandle, device); 1097 } 1098 1099 status_t AudioPolicyService::releaseSoundTriggerSession(audio_session_t session) 1100 { 1101 Mutex::Autolock _l(mLock); 1102 if (mAudioPolicyManager == NULL) { 1103 return NO_INIT; 1104 } 1105 AutoCallerClear acc; 1106 return mAudioPolicyManager->releaseSoundTriggerSession(session); 1107 } 1108 1109 status_t AudioPolicyService::registerPolicyMixes(const Vector<AudioMix>& mixes, bool registration) 1110 { 1111 Mutex::Autolock _l(mLock); 1112 1113 // loopback|render only need a MediaProjection (checked in caller AudioService.java) 1114 bool needModifyAudioRouting = std::any_of(mixes.begin(), mixes.end(), [](auto& mix) { 1115 return !is_mix_loopback_render(mix.mRouteFlags); }); 1116 if (needModifyAudioRouting && !modifyAudioRoutingAllowed()) { 1117 return PERMISSION_DENIED; 1118 } 1119 1120 bool needCaptureMediaOutput = std::any_of(mixes.begin(), mixes.end(), [](auto& mix) { 1121 return mix.mAllowPrivilegedPlaybackCapture; }); 1122 const uid_t callingUid = IPCThreadState::self()->getCallingUid(); 1123 const pid_t callingPid = IPCThreadState::self()->getCallingPid(); 1124 if (needCaptureMediaOutput && !captureMediaOutputAllowed(callingPid, callingUid)) { 1125 return PERMISSION_DENIED; 1126 } 1127 1128 if (mAudioPolicyManager == NULL) { 1129 return NO_INIT; 1130 } 1131 AutoCallerClear acc; 1132 if (registration) { 1133 return mAudioPolicyManager->registerPolicyMixes(mixes); 1134 } else { 1135 return mAudioPolicyManager->unregisterPolicyMixes(mixes); 1136 } 1137 } 1138 1139 status_t AudioPolicyService::setUidDeviceAffinities(uid_t uid, 1140 const Vector<AudioDeviceTypeAddr>& devices) { 1141 Mutex::Autolock _l(mLock); 1142 if(!modifyAudioRoutingAllowed()) { 1143 return PERMISSION_DENIED; 1144 } 1145 if (mAudioPolicyManager == NULL) { 1146 return NO_INIT; 1147 } 1148 AutoCallerClear acc; 1149 return mAudioPolicyManager->setUidDeviceAffinities(uid, devices); 1150 } 1151 1152 status_t AudioPolicyService::removeUidDeviceAffinities(uid_t uid) { 1153 Mutex::Autolock _l(mLock); 1154 if(!modifyAudioRoutingAllowed()) { 1155 return PERMISSION_DENIED; 1156 } 1157 if (mAudioPolicyManager == NULL) { 1158 return NO_INIT; 1159 } 1160 AutoCallerClear acc; 1161 return mAudioPolicyManager->removeUidDeviceAffinities(uid); 1162 } 1163 1164 status_t AudioPolicyService::startAudioSource(const struct audio_port_config *source, 1165 const audio_attributes_t *attributes, 1166 audio_port_handle_t *portId) 1167 { 1168 Mutex::Autolock _l(mLock); 1169 if (mAudioPolicyManager == NULL) { 1170 return NO_INIT; 1171 } 1172 // startAudioSource should be created as the calling uid 1173 const uid_t callingUid = IPCThreadState::self()->getCallingUid(); 1174 AutoCallerClear acc; 1175 return mAudioPolicyManager->startAudioSource(source, attributes, portId, callingUid); 1176 } 1177 1178 status_t AudioPolicyService::stopAudioSource(audio_port_handle_t portId) 1179 { 1180 Mutex::Autolock _l(mLock); 1181 if (mAudioPolicyManager == NULL) { 1182 return NO_INIT; 1183 } 1184 AutoCallerClear acc; 1185 return mAudioPolicyManager->stopAudioSource(portId); 1186 } 1187 1188 status_t AudioPolicyService::setMasterMono(bool mono) 1189 { 1190 if (mAudioPolicyManager == NULL) { 1191 return NO_INIT; 1192 } 1193 if (!settingsAllowed()) { 1194 return PERMISSION_DENIED; 1195 } 1196 Mutex::Autolock _l(mLock); 1197 AutoCallerClear acc; 1198 return mAudioPolicyManager->setMasterMono(mono); 1199 } 1200 1201 status_t AudioPolicyService::getMasterMono(bool *mono) 1202 { 1203 if (mAudioPolicyManager == NULL) { 1204 return NO_INIT; 1205 } 1206 Mutex::Autolock _l(mLock); 1207 AutoCallerClear acc; 1208 return mAudioPolicyManager->getMasterMono(mono); 1209 } 1210 1211 1212 float AudioPolicyService::getStreamVolumeDB( 1213 audio_stream_type_t stream, int index, audio_devices_t device) 1214 { 1215 if (mAudioPolicyManager == NULL) { 1216 return NAN; 1217 } 1218 Mutex::Autolock _l(mLock); 1219 AutoCallerClear acc; 1220 return mAudioPolicyManager->getStreamVolumeDB(stream, index, device); 1221 } 1222 1223 status_t AudioPolicyService::getSurroundFormats(unsigned int *numSurroundFormats, 1224 audio_format_t *surroundFormats, 1225 bool *surroundFormatsEnabled, 1226 bool reported) 1227 { 1228 if (mAudioPolicyManager == NULL) { 1229 return NO_INIT; 1230 } 1231 Mutex::Autolock _l(mLock); 1232 AutoCallerClear acc; 1233 return mAudioPolicyManager->getSurroundFormats(numSurroundFormats, surroundFormats, 1234 surroundFormatsEnabled, reported); 1235 } 1236 1237 status_t AudioPolicyService::getHwOffloadEncodingFormatsSupportedForA2DP( 1238 std::vector<audio_format_t> *formats) 1239 { 1240 if (mAudioPolicyManager == NULL) { 1241 return NO_INIT; 1242 } 1243 Mutex::Autolock _l(mLock); 1244 AutoCallerClear acc; 1245 return mAudioPolicyManager->getHwOffloadEncodingFormatsSupportedForA2DP(formats); 1246 } 1247 1248 status_t AudioPolicyService::setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled) 1249 { 1250 if (mAudioPolicyManager == NULL) { 1251 return NO_INIT; 1252 } 1253 Mutex::Autolock _l(mLock); 1254 AutoCallerClear acc; 1255 return mAudioPolicyManager->setSurroundFormatEnabled(audioFormat, enabled); 1256 } 1257 1258 status_t AudioPolicyService::setAssistantUid(uid_t uid) 1259 { 1260 Mutex::Autolock _l(mLock); 1261 mUidPolicy->setAssistantUid(uid); 1262 return NO_ERROR; 1263 } 1264 1265 status_t AudioPolicyService::setA11yServicesUids(const std::vector<uid_t>& uids) 1266 { 1267 Mutex::Autolock _l(mLock); 1268 mUidPolicy->setA11yUids(uids); 1269 return NO_ERROR; 1270 } 1271 1272 bool AudioPolicyService::isHapticPlaybackSupported() 1273 { 1274 if (mAudioPolicyManager == NULL) { 1275 ALOGW("%s, mAudioPolicyManager == NULL", __func__); 1276 return false; 1277 } 1278 Mutex::Autolock _l(mLock); 1279 AutoCallerClear acc; 1280 return mAudioPolicyManager->isHapticPlaybackSupported(); 1281 } 1282 1283 status_t AudioPolicyService::listAudioProductStrategies(AudioProductStrategyVector &strategies) 1284 { 1285 if (mAudioPolicyManager == NULL) { 1286 return NO_INIT; 1287 } 1288 Mutex::Autolock _l(mLock); 1289 return mAudioPolicyManager->listAudioProductStrategies(strategies); 1290 } 1291 1292 status_t AudioPolicyService::getProductStrategyFromAudioAttributes( 1293 const AudioAttributes &aa, product_strategy_t &productStrategy) 1294 { 1295 if (mAudioPolicyManager == NULL) { 1296 return NO_INIT; 1297 } 1298 Mutex::Autolock _l(mLock); 1299 return mAudioPolicyManager->getProductStrategyFromAudioAttributes(aa, productStrategy); 1300 } 1301 1302 status_t AudioPolicyService::listAudioVolumeGroups(AudioVolumeGroupVector &groups) 1303 { 1304 if (mAudioPolicyManager == NULL) { 1305 return NO_INIT; 1306 } 1307 Mutex::Autolock _l(mLock); 1308 return mAudioPolicyManager->listAudioVolumeGroups(groups); 1309 } 1310 1311 status_t AudioPolicyService::getVolumeGroupFromAudioAttributes(const AudioAttributes &aa, 1312 volume_group_t &volumeGroup) 1313 { 1314 if (mAudioPolicyManager == NULL) { 1315 return NO_INIT; 1316 } 1317 Mutex::Autolock _l(mLock); 1318 return mAudioPolicyManager->getVolumeGroupFromAudioAttributes(aa, volumeGroup); 1319 } 1320 1321 status_t AudioPolicyService::setRttEnabled(bool enabled) 1322 { 1323 Mutex::Autolock _l(mLock); 1324 mUidPolicy->setRttEnabled(enabled); 1325 return NO_ERROR; 1326 } 1327 1328 } // namespace android 1329
