AudioPolicyInterfaceImpl.cpp revision ab300c8cbf5df98fddca39e8d1698b0307432152
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 24namespace android { 25 26 27// ---------------------------------------------------------------------------- 28 29status_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 54audio_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 65status_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 // TODO: check if it is more appropriate to do it in platform specific policy manager 80 AudioSystem::setMode(state); 81 82 Mutex::Autolock _l(mLock); 83 mAudioPolicyManager->setPhoneState(state); 84 mPhoneState = state; 85 return NO_ERROR; 86} 87 88audio_mode_t AudioPolicyService::getPhoneState() 89{ 90 Mutex::Autolock _l(mLock); 91 return mPhoneState; 92} 93 94status_t AudioPolicyService::setForceUse(audio_policy_force_use_t usage, 95 audio_policy_forced_cfg_t config) 96{ 97 if (mAudioPolicyManager == NULL) { 98 return NO_INIT; 99 } 100 if (!settingsAllowed()) { 101 return PERMISSION_DENIED; 102 } 103 if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) { 104 return BAD_VALUE; 105 } 106 if (config < 0 || config >= AUDIO_POLICY_FORCE_CFG_CNT) { 107 return BAD_VALUE; 108 } 109 ALOGV("setForceUse()"); 110 Mutex::Autolock _l(mLock); 111 mAudioPolicyManager->setForceUse(usage, config); 112 return NO_ERROR; 113} 114 115audio_policy_forced_cfg_t AudioPolicyService::getForceUse(audio_policy_force_use_t usage) 116{ 117 if (mAudioPolicyManager == NULL) { 118 return AUDIO_POLICY_FORCE_NONE; 119 } 120 if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) { 121 return AUDIO_POLICY_FORCE_NONE; 122 } 123 return mAudioPolicyManager->getForceUse(usage); 124} 125 126audio_io_handle_t AudioPolicyService::getOutput(audio_stream_type_t stream, 127 uint32_t samplingRate, 128 audio_format_t format, 129 audio_channel_mask_t channelMask, 130 audio_output_flags_t flags, 131 const audio_offload_info_t *offloadInfo) 132{ 133 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) { 134 return AUDIO_IO_HANDLE_NONE; 135 } 136 if (mAudioPolicyManager == NULL) { 137 return AUDIO_IO_HANDLE_NONE; 138 } 139 ALOGV("getOutput()"); 140 Mutex::Autolock _l(mLock); 141 return mAudioPolicyManager->getOutput(stream, samplingRate, 142 format, channelMask, flags, offloadInfo); 143} 144 145status_t AudioPolicyService::getOutputForAttr(const audio_attributes_t *attr, 146 audio_io_handle_t *output, 147 audio_session_t session, 148 audio_stream_type_t *stream, 149 uint32_t samplingRate, 150 audio_format_t format, 151 audio_channel_mask_t channelMask, 152 audio_output_flags_t flags, 153 int mSelectedDeviceId, 154 const audio_offload_info_t *offloadInfo) 155{ 156 if (mAudioPolicyManager == NULL) { 157 return NO_INIT; 158 } 159 ALOGV("getOutput()"); 160 Mutex::Autolock _l(mLock); 161 return mAudioPolicyManager->getOutputForAttr(attr, output, session, stream, samplingRate, 162 format, channelMask, flags, mSelectedDeviceId, offloadInfo); 163} 164 165status_t AudioPolicyService::startOutput(audio_io_handle_t output, 166 audio_stream_type_t stream, 167 audio_session_t session) 168{ 169 if (uint32_t(stream) >= AUDIO_STREAM_CNT) { 170 return BAD_VALUE; 171 } 172 if (mAudioPolicyManager == NULL) { 173 return NO_INIT; 174 } 175 ALOGV("startOutput()"); 176 sp<AudioPolicyEffects>audioPolicyEffects; 177 { 178 Mutex::Autolock _l(mLock); 179 audioPolicyEffects = mAudioPolicyEffects; 180 } 181 if (audioPolicyEffects != 0) { 182 // create audio processors according to stream 183 status_t status = audioPolicyEffects->addOutputSessionEffects(output, stream, session); 184 if (status != NO_ERROR && status != ALREADY_EXISTS) { 185 ALOGW("Failed to add effects on session %d", session); 186 } 187 } 188 Mutex::Autolock _l(mLock); 189 return mAudioPolicyManager->startOutput(output, stream, session); 190} 191 192status_t AudioPolicyService::stopOutput(audio_io_handle_t output, 193 audio_stream_type_t stream, 194 audio_session_t session) 195{ 196 if (uint32_t(stream) >= AUDIO_STREAM_CNT) { 197 return BAD_VALUE; 198 } 199 if (mAudioPolicyManager == NULL) { 200 return NO_INIT; 201 } 202 ALOGV("stopOutput()"); 203 mOutputCommandThread->stopOutputCommand(output, stream, session); 204 return NO_ERROR; 205} 206 207status_t AudioPolicyService::doStopOutput(audio_io_handle_t output, 208 audio_stream_type_t stream, 209 audio_session_t session) 210{ 211 ALOGV("doStopOutput from tid %d", gettid()); 212 sp<AudioPolicyEffects>audioPolicyEffects; 213 { 214 Mutex::Autolock _l(mLock); 215 audioPolicyEffects = mAudioPolicyEffects; 216 } 217 if (audioPolicyEffects != 0) { 218 // release audio processors from the stream 219 status_t status = audioPolicyEffects->releaseOutputSessionEffects(output, stream, session); 220 if (status != NO_ERROR && status != ALREADY_EXISTS) { 221 ALOGW("Failed to release effects on session %d", session); 222 } 223 } 224 Mutex::Autolock _l(mLock); 225 return mAudioPolicyManager->stopOutput(output, stream, session); 226} 227 228void AudioPolicyService::releaseOutput(audio_io_handle_t output, 229 audio_stream_type_t stream, 230 audio_session_t session) 231{ 232 if (mAudioPolicyManager == NULL) { 233 return; 234 } 235 ALOGV("releaseOutput()"); 236 mOutputCommandThread->releaseOutputCommand(output, stream, session); 237} 238 239void AudioPolicyService::doReleaseOutput(audio_io_handle_t output, 240 audio_stream_type_t stream, 241 audio_session_t session) 242{ 243 ALOGV("doReleaseOutput from tid %d", gettid()); 244 Mutex::Autolock _l(mLock); 245 mAudioPolicyManager->releaseOutput(output, stream, session); 246} 247 248status_t AudioPolicyService::getInputForAttr(const audio_attributes_t *attr, 249 audio_io_handle_t *input, 250 audio_session_t session, 251 uint32_t samplingRate, 252 audio_format_t format, 253 audio_channel_mask_t channelMask, 254 audio_input_flags_t flags) 255{ 256 if (mAudioPolicyManager == NULL) { 257 return NO_INIT; 258 } 259 // already checked by client, but double-check in case the client wrapper is bypassed 260 if (attr->source >= AUDIO_SOURCE_CNT && attr->source != AUDIO_SOURCE_HOTWORD && 261 attr->source != AUDIO_SOURCE_FM_TUNER) { 262 return BAD_VALUE; 263 } 264 265 if ((attr->source == AUDIO_SOURCE_HOTWORD) && !captureHotwordAllowed()) { 266 return BAD_VALUE; 267 } 268 sp<AudioPolicyEffects>audioPolicyEffects; 269 status_t status; 270 AudioPolicyInterface::input_type_t inputType; 271 { 272 Mutex::Autolock _l(mLock); 273 // the audio_in_acoustics_t parameter is ignored by get_input() 274 status = mAudioPolicyManager->getInputForAttr(attr, input, session, 275 samplingRate, format, channelMask, 276 flags, &inputType); 277 audioPolicyEffects = mAudioPolicyEffects; 278 279 if (status == NO_ERROR) { 280 // enforce permission (if any) required for each type of input 281 switch (inputType) { 282 case AudioPolicyInterface::API_INPUT_LEGACY: 283 break; 284 case AudioPolicyInterface::API_INPUT_MIX_CAPTURE: 285 if (!captureAudioOutputAllowed()) { 286 ALOGE("getInputForAttr() permission denied: capture not allowed"); 287 status = PERMISSION_DENIED; 288 } 289 break; 290 case AudioPolicyInterface::API_INPUT_MIX_EXT_POLICY_REROUTE: 291 if (!modifyAudioRoutingAllowed()) { 292 ALOGE("getInputForAttr() permission denied: modify audio routing not allowed"); 293 status = PERMISSION_DENIED; 294 } 295 break; 296 case AudioPolicyInterface::API_INPUT_INVALID: 297 default: 298 LOG_ALWAYS_FATAL("getInputForAttr() encountered an invalid input type %d", 299 (int)inputType); 300 } 301 } 302 303 if (status != NO_ERROR) { 304 if (status == PERMISSION_DENIED) { 305 mAudioPolicyManager->releaseInput(*input, session); 306 } 307 return status; 308 } 309 } 310 311 if (audioPolicyEffects != 0) { 312 // create audio pre processors according to input source 313 status_t status = audioPolicyEffects->addInputEffects(*input, attr->source, session); 314 if (status != NO_ERROR && status != ALREADY_EXISTS) { 315 ALOGW("Failed to add effects on input %d", *input); 316 } 317 } 318 return NO_ERROR; 319} 320 321status_t AudioPolicyService::startInput(audio_io_handle_t input, 322 audio_session_t session) 323{ 324 if (mAudioPolicyManager == NULL) { 325 return NO_INIT; 326 } 327 Mutex::Autolock _l(mLock); 328 329 return mAudioPolicyManager->startInput(input, session); 330} 331 332status_t AudioPolicyService::stopInput(audio_io_handle_t input, 333 audio_session_t session) 334{ 335 if (mAudioPolicyManager == NULL) { 336 return NO_INIT; 337 } 338 Mutex::Autolock _l(mLock); 339 340 return mAudioPolicyManager->stopInput(input, session); 341} 342 343void AudioPolicyService::releaseInput(audio_io_handle_t input, 344 audio_session_t session) 345{ 346 if (mAudioPolicyManager == NULL) { 347 return; 348 } 349 sp<AudioPolicyEffects>audioPolicyEffects; 350 { 351 Mutex::Autolock _l(mLock); 352 mAudioPolicyManager->releaseInput(input, session); 353 audioPolicyEffects = mAudioPolicyEffects; 354 } 355 if (audioPolicyEffects != 0) { 356 // release audio processors from the input 357 status_t status = audioPolicyEffects->releaseInputEffects(input); 358 if(status != NO_ERROR) { 359 ALOGW("Failed to release effects on input %d", input); 360 } 361 } 362} 363 364status_t AudioPolicyService::initStreamVolume(audio_stream_type_t stream, 365 int indexMin, 366 int indexMax) 367{ 368 if (mAudioPolicyManager == NULL) { 369 return NO_INIT; 370 } 371 if (!settingsAllowed()) { 372 return PERMISSION_DENIED; 373 } 374 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) { 375 return BAD_VALUE; 376 } 377 Mutex::Autolock _l(mLock); 378 mAudioPolicyManager->initStreamVolume(stream, indexMin, indexMax); 379 return NO_ERROR; 380} 381 382status_t AudioPolicyService::setStreamVolumeIndex(audio_stream_type_t stream, 383 int index, 384 audio_devices_t device) 385{ 386 if (mAudioPolicyManager == NULL) { 387 return NO_INIT; 388 } 389 if (!settingsAllowed()) { 390 return PERMISSION_DENIED; 391 } 392 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) { 393 return BAD_VALUE; 394 } 395 Mutex::Autolock _l(mLock); 396 return mAudioPolicyManager->setStreamVolumeIndex(stream, 397 index, 398 device); 399} 400 401status_t AudioPolicyService::getStreamVolumeIndex(audio_stream_type_t stream, 402 int *index, 403 audio_devices_t device) 404{ 405 if (mAudioPolicyManager == NULL) { 406 return NO_INIT; 407 } 408 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) { 409 return BAD_VALUE; 410 } 411 Mutex::Autolock _l(mLock); 412 return mAudioPolicyManager->getStreamVolumeIndex(stream, 413 index, 414 device); 415} 416 417uint32_t AudioPolicyService::getStrategyForStream(audio_stream_type_t stream) 418{ 419 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) { 420 return 0; 421 } 422 if (mAudioPolicyManager == NULL) { 423 return 0; 424 } 425 return mAudioPolicyManager->getStrategyForStream(stream); 426} 427 428//audio policy: use audio_device_t appropriately 429 430audio_devices_t AudioPolicyService::getDevicesForStream(audio_stream_type_t stream) 431{ 432 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) { 433 return AUDIO_DEVICE_NONE; 434 } 435 if (mAudioPolicyManager == NULL) { 436 return AUDIO_DEVICE_NONE; 437 } 438 return mAudioPolicyManager->getDevicesForStream(stream); 439} 440 441audio_io_handle_t AudioPolicyService::getOutputForEffect(const effect_descriptor_t *desc) 442{ 443 // FIXME change return type to status_t, and return NO_INIT here 444 if (mAudioPolicyManager == NULL) { 445 return 0; 446 } 447 Mutex::Autolock _l(mLock); 448 return mAudioPolicyManager->getOutputForEffect(desc); 449} 450 451status_t AudioPolicyService::registerEffect(const effect_descriptor_t *desc, 452 audio_io_handle_t io, 453 uint32_t strategy, 454 int session, 455 int id) 456{ 457 if (mAudioPolicyManager == NULL) { 458 return NO_INIT; 459 } 460 return mAudioPolicyManager->registerEffect(desc, io, strategy, session, id); 461} 462 463status_t AudioPolicyService::unregisterEffect(int id) 464{ 465 if (mAudioPolicyManager == NULL) { 466 return NO_INIT; 467 } 468 return mAudioPolicyManager->unregisterEffect(id); 469} 470 471status_t AudioPolicyService::setEffectEnabled(int id, bool enabled) 472{ 473 if (mAudioPolicyManager == NULL) { 474 return NO_INIT; 475 } 476 return mAudioPolicyManager->setEffectEnabled(id, enabled); 477} 478 479bool AudioPolicyService::isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const 480{ 481 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) { 482 return false; 483 } 484 if (mAudioPolicyManager == NULL) { 485 return false; 486 } 487 Mutex::Autolock _l(mLock); 488 return mAudioPolicyManager->isStreamActive(stream, inPastMs); 489} 490 491bool AudioPolicyService::isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const 492{ 493 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) { 494 return false; 495 } 496 if (mAudioPolicyManager == NULL) { 497 return false; 498 } 499 Mutex::Autolock _l(mLock); 500 return mAudioPolicyManager->isStreamActiveRemotely(stream, inPastMs); 501} 502 503bool AudioPolicyService::isSourceActive(audio_source_t source) const 504{ 505 if (mAudioPolicyManager == NULL) { 506 return false; 507 } 508 Mutex::Autolock _l(mLock); 509 return mAudioPolicyManager->isSourceActive(source); 510} 511 512status_t AudioPolicyService::queryDefaultPreProcessing(int audioSession, 513 effect_descriptor_t *descriptors, 514 uint32_t *count) 515{ 516 if (mAudioPolicyManager == NULL) { 517 *count = 0; 518 return NO_INIT; 519 } 520 sp<AudioPolicyEffects>audioPolicyEffects; 521 { 522 Mutex::Autolock _l(mLock); 523 audioPolicyEffects = mAudioPolicyEffects; 524 } 525 if (audioPolicyEffects == 0) { 526 *count = 0; 527 return NO_INIT; 528 } 529 return audioPolicyEffects->queryDefaultInputEffects(audioSession, descriptors, count); 530} 531 532bool AudioPolicyService::isOffloadSupported(const audio_offload_info_t& info) 533{ 534 if (mAudioPolicyManager == NULL) { 535 ALOGV("mAudioPolicyManager == NULL"); 536 return false; 537 } 538 539 return mAudioPolicyManager->isOffloadSupported(info); 540} 541 542status_t AudioPolicyService::listAudioPorts(audio_port_role_t role, 543 audio_port_type_t type, 544 unsigned int *num_ports, 545 struct audio_port *ports, 546 unsigned int *generation) 547{ 548 Mutex::Autolock _l(mLock); 549 if(!modifyAudioRoutingAllowed()) { 550 return PERMISSION_DENIED; 551 } 552 if (mAudioPolicyManager == NULL) { 553 return NO_INIT; 554 } 555 556 return mAudioPolicyManager->listAudioPorts(role, type, num_ports, ports, generation); 557} 558 559status_t AudioPolicyService::getAudioPort(struct audio_port *port) 560{ 561 Mutex::Autolock _l(mLock); 562 if(!modifyAudioRoutingAllowed()) { 563 return PERMISSION_DENIED; 564 } 565 if (mAudioPolicyManager == NULL) { 566 return NO_INIT; 567 } 568 569 return mAudioPolicyManager->getAudioPort(port); 570} 571 572status_t AudioPolicyService::createAudioPatch(const struct audio_patch *patch, 573 audio_patch_handle_t *handle) 574{ 575 Mutex::Autolock _l(mLock); 576 if(!modifyAudioRoutingAllowed()) { 577 return PERMISSION_DENIED; 578 } 579 if (mAudioPolicyManager == NULL) { 580 return NO_INIT; 581 } 582 return mAudioPolicyManager->createAudioPatch(patch, handle, 583 IPCThreadState::self()->getCallingUid()); 584} 585 586status_t AudioPolicyService::releaseAudioPatch(audio_patch_handle_t handle) 587{ 588 Mutex::Autolock _l(mLock); 589 if(!modifyAudioRoutingAllowed()) { 590 return PERMISSION_DENIED; 591 } 592 if (mAudioPolicyManager == NULL) { 593 return NO_INIT; 594 } 595 596 return mAudioPolicyManager->releaseAudioPatch(handle, 597 IPCThreadState::self()->getCallingUid()); 598} 599 600status_t AudioPolicyService::listAudioPatches(unsigned int *num_patches, 601 struct audio_patch *patches, 602 unsigned int *generation) 603{ 604 Mutex::Autolock _l(mLock); 605 if(!modifyAudioRoutingAllowed()) { 606 return PERMISSION_DENIED; 607 } 608 if (mAudioPolicyManager == NULL) { 609 return NO_INIT; 610 } 611 612 return mAudioPolicyManager->listAudioPatches(num_patches, patches, generation); 613} 614 615status_t AudioPolicyService::setAudioPortConfig(const struct audio_port_config *config) 616{ 617 Mutex::Autolock _l(mLock); 618 if(!modifyAudioRoutingAllowed()) { 619 return PERMISSION_DENIED; 620 } 621 if (mAudioPolicyManager == NULL) { 622 return NO_INIT; 623 } 624 625 return mAudioPolicyManager->setAudioPortConfig(config); 626} 627 628status_t AudioPolicyService::acquireSoundTriggerSession(audio_session_t *session, 629 audio_io_handle_t *ioHandle, 630 audio_devices_t *device) 631{ 632 if (mAudioPolicyManager == NULL) { 633 return NO_INIT; 634 } 635 636 return mAudioPolicyManager->acquireSoundTriggerSession(session, ioHandle, device); 637} 638 639status_t AudioPolicyService::releaseSoundTriggerSession(audio_session_t session) 640{ 641 if (mAudioPolicyManager == NULL) { 642 return NO_INIT; 643 } 644 645 return mAudioPolicyManager->releaseSoundTriggerSession(session); 646} 647 648status_t AudioPolicyService::registerPolicyMixes(Vector<AudioMix> mixes, bool registration) 649{ 650 Mutex::Autolock _l(mLock); 651 if(!modifyAudioRoutingAllowed()) { 652 return PERMISSION_DENIED; 653 } 654 if (mAudioPolicyManager == NULL) { 655 return NO_INIT; 656 } 657 if (registration) { 658 return mAudioPolicyManager->registerPolicyMixes(mixes); 659 } else { 660 return mAudioPolicyManager->unregisterPolicyMixes(mixes); 661 } 662} 663 664}; // namespace android 665