AudioPolicyInterfaceImpl.cpp revision 5bd3f38638acab633d181359cc9ec27b80f84d43
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{ 33 if (mAudioPolicyManager == NULL) { 34 return NO_INIT; 35 } 36 if (!settingsAllowed()) { 37 return PERMISSION_DENIED; 38 } 39 if (!audio_is_output_device(device) && !audio_is_input_device(device)) { 40 return BAD_VALUE; 41 } 42 if (state != AUDIO_POLICY_DEVICE_STATE_AVAILABLE && 43 state != AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) { 44 return BAD_VALUE; 45 } 46 47 ALOGV("setDeviceConnectionState()"); 48 Mutex::Autolock _l(mLock); 49 return mAudioPolicyManager->setDeviceConnectionState(device, 50 state, device_address); 51} 52 53audio_policy_dev_state_t AudioPolicyService::getDeviceConnectionState( 54 audio_devices_t device, 55 const char *device_address) 56{ 57 if (mAudioPolicyManager == NULL) { 58 return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE; 59 } 60 return mAudioPolicyManager->getDeviceConnectionState(device, 61 device_address); 62} 63 64status_t AudioPolicyService::setPhoneState(audio_mode_t state) 65{ 66 if (mAudioPolicyManager == NULL) { 67 return NO_INIT; 68 } 69 if (!settingsAllowed()) { 70 return PERMISSION_DENIED; 71 } 72 if (uint32_t(state) >= AUDIO_MODE_CNT) { 73 return BAD_VALUE; 74 } 75 76 ALOGV("setPhoneState()"); 77 78 // TODO: check if it is more appropriate to do it in platform specific policy manager 79 AudioSystem::setMode(state); 80 81 Mutex::Autolock _l(mLock); 82 mAudioPolicyManager->setPhoneState(state); 83 return NO_ERROR; 84} 85 86status_t AudioPolicyService::setForceUse(audio_policy_force_use_t usage, 87 audio_policy_forced_cfg_t config) 88{ 89 if (mAudioPolicyManager == NULL) { 90 return NO_INIT; 91 } 92 if (!settingsAllowed()) { 93 return PERMISSION_DENIED; 94 } 95 if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) { 96 return BAD_VALUE; 97 } 98 if (config < 0 || config >= AUDIO_POLICY_FORCE_CFG_CNT) { 99 return BAD_VALUE; 100 } 101 ALOGV("setForceUse()"); 102 Mutex::Autolock _l(mLock); 103 mAudioPolicyManager->setForceUse(usage, config); 104 return NO_ERROR; 105} 106 107audio_policy_forced_cfg_t AudioPolicyService::getForceUse(audio_policy_force_use_t usage) 108{ 109 if (mAudioPolicyManager == NULL) { 110 return AUDIO_POLICY_FORCE_NONE; 111 } 112 if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) { 113 return AUDIO_POLICY_FORCE_NONE; 114 } 115 return mAudioPolicyManager->getForceUse(usage); 116} 117 118audio_io_handle_t AudioPolicyService::getOutput(audio_stream_type_t stream, 119 uint32_t samplingRate, 120 audio_format_t format, 121 audio_channel_mask_t channelMask, 122 audio_output_flags_t flags, 123 const audio_offload_info_t *offloadInfo) 124{ 125 if (mAudioPolicyManager == NULL) { 126 return 0; 127 } 128 ALOGV("getOutput()"); 129 Mutex::Autolock _l(mLock); 130 return mAudioPolicyManager->getOutput(stream, samplingRate, 131 format, channelMask, flags, offloadInfo); 132} 133 134audio_io_handle_t AudioPolicyService::getOutputForAttr(const audio_attributes_t *attr, 135 uint32_t samplingRate, 136 audio_format_t format, 137 audio_channel_mask_t channelMask, 138 audio_output_flags_t flags, 139 const audio_offload_info_t *offloadInfo) 140{ 141 if (mAudioPolicyManager == NULL) { 142 return 0; 143 } 144 ALOGV("getOutput()"); 145 Mutex::Autolock _l(mLock); 146 return mAudioPolicyManager->getOutputForAttr(attr, samplingRate, 147 format, channelMask, flags, offloadInfo); 148} 149 150status_t AudioPolicyService::startOutput(audio_io_handle_t output, 151 audio_stream_type_t stream, 152 int session) 153{ 154 if (mAudioPolicyManager == NULL) { 155 return NO_INIT; 156 } 157 ALOGV("startOutput()"); 158 Mutex::Autolock _l(mLock); 159 return mAudioPolicyManager->startOutput(output, stream, session); 160} 161 162status_t AudioPolicyService::stopOutput(audio_io_handle_t output, 163 audio_stream_type_t stream, 164 int session) 165{ 166 if (mAudioPolicyManager == NULL) { 167 return NO_INIT; 168 } 169 ALOGV("stopOutput()"); 170 mOutputCommandThread->stopOutputCommand(output, stream, session); 171 return NO_ERROR; 172} 173 174status_t AudioPolicyService::doStopOutput(audio_io_handle_t output, 175 audio_stream_type_t stream, 176 int session) 177{ 178 ALOGV("doStopOutput from tid %d", gettid()); 179 Mutex::Autolock _l(mLock); 180 return mAudioPolicyManager->stopOutput(output, stream, session); 181} 182 183void AudioPolicyService::releaseOutput(audio_io_handle_t output) 184{ 185 if (mAudioPolicyManager == NULL) { 186 return; 187 } 188 ALOGV("releaseOutput()"); 189 mOutputCommandThread->releaseOutputCommand(output); 190} 191 192void AudioPolicyService::doReleaseOutput(audio_io_handle_t output) 193{ 194 ALOGV("doReleaseOutput from tid %d", gettid()); 195 Mutex::Autolock _l(mLock); 196 mAudioPolicyManager->releaseOutput(output); 197} 198 199audio_io_handle_t AudioPolicyService::getInput(audio_source_t inputSource, 200 uint32_t samplingRate, 201 audio_format_t format, 202 audio_channel_mask_t channelMask, 203 int audioSession) 204{ 205 if (mAudioPolicyManager == NULL) { 206 return 0; 207 } 208 // already checked by client, but double-check in case the client wrapper is bypassed 209 if (inputSource >= AUDIO_SOURCE_CNT && inputSource != AUDIO_SOURCE_HOTWORD) { 210 return 0; 211 } 212 213 if ((inputSource == AUDIO_SOURCE_HOTWORD) && !captureHotwordAllowed()) { 214 return 0; 215 } 216 217 Mutex::Autolock _l(mLock); 218 // the audio_in_acoustics_t parameter is ignored by get_input() 219 audio_io_handle_t input = mAudioPolicyManager->getInput(inputSource, samplingRate, 220 format, channelMask, (audio_in_acoustics_t) 0); 221 222 if (input == 0) { 223 return input; 224 } 225 // create audio pre processors according to input source 226 audio_source_t aliasSource = (inputSource == AUDIO_SOURCE_HOTWORD) ? 227 AUDIO_SOURCE_VOICE_RECOGNITION : inputSource; 228 229 ssize_t index = mInputSources.indexOfKey(aliasSource); 230 if (index < 0) { 231 return input; 232 } 233 ssize_t idx = mInputs.indexOfKey(input); 234 InputDesc *inputDesc; 235 if (idx < 0) { 236 inputDesc = new InputDesc(audioSession); 237 mInputs.add(input, inputDesc); 238 } else { 239 inputDesc = mInputs.valueAt(idx); 240 } 241 242 Vector <EffectDesc *> effects = mInputSources.valueAt(index)->mEffects; 243 for (size_t i = 0; i < effects.size(); i++) { 244 EffectDesc *effect = effects[i]; 245 sp<AudioEffect> fx = new AudioEffect(NULL, &effect->mUuid, -1, 0, 0, audioSession, input); 246 status_t status = fx->initCheck(); 247 if (status != NO_ERROR && status != ALREADY_EXISTS) { 248 ALOGW("Failed to create Fx %s on input %d", effect->mName, input); 249 // fx goes out of scope and strong ref on AudioEffect is released 250 continue; 251 } 252 for (size_t j = 0; j < effect->mParams.size(); j++) { 253 fx->setParameter(effect->mParams[j]); 254 } 255 inputDesc->mEffects.add(fx); 256 } 257 setPreProcessorEnabled(inputDesc, true); 258 return input; 259} 260 261status_t AudioPolicyService::startInput(audio_io_handle_t input) 262{ 263 if (mAudioPolicyManager == NULL) { 264 return NO_INIT; 265 } 266 Mutex::Autolock _l(mLock); 267 268 return mAudioPolicyManager->startInput(input); 269} 270 271status_t AudioPolicyService::stopInput(audio_io_handle_t input) 272{ 273 if (mAudioPolicyManager == NULL) { 274 return NO_INIT; 275 } 276 Mutex::Autolock _l(mLock); 277 278 return mAudioPolicyManager->stopInput(input); 279} 280 281void AudioPolicyService::releaseInput(audio_io_handle_t input) 282{ 283 if (mAudioPolicyManager == NULL) { 284 return; 285 } 286 Mutex::Autolock _l(mLock); 287 mAudioPolicyManager->releaseInput(input); 288 289 ssize_t index = mInputs.indexOfKey(input); 290 if (index < 0) { 291 return; 292 } 293 InputDesc *inputDesc = mInputs.valueAt(index); 294 setPreProcessorEnabled(inputDesc, false); 295 delete inputDesc; 296 mInputs.removeItemsAt(index); 297} 298 299status_t AudioPolicyService::initStreamVolume(audio_stream_type_t stream, 300 int indexMin, 301 int indexMax) 302{ 303 if (mAudioPolicyManager == NULL) { 304 return NO_INIT; 305 } 306 if (!settingsAllowed()) { 307 return PERMISSION_DENIED; 308 } 309 if (uint32_t(stream) >= AUDIO_STREAM_CNT) { 310 return BAD_VALUE; 311 } 312 Mutex::Autolock _l(mLock); 313 mAudioPolicyManager->initStreamVolume(stream, indexMin, indexMax); 314 return NO_ERROR; 315} 316 317status_t AudioPolicyService::setStreamVolumeIndex(audio_stream_type_t stream, 318 int index, 319 audio_devices_t device) 320{ 321 if (mAudioPolicyManager == NULL) { 322 return NO_INIT; 323 } 324 if (!settingsAllowed()) { 325 return PERMISSION_DENIED; 326 } 327 if (uint32_t(stream) >= AUDIO_STREAM_CNT) { 328 return BAD_VALUE; 329 } 330 Mutex::Autolock _l(mLock); 331 return mAudioPolicyManager->setStreamVolumeIndex(stream, 332 index, 333 device); 334} 335 336status_t AudioPolicyService::getStreamVolumeIndex(audio_stream_type_t stream, 337 int *index, 338 audio_devices_t device) 339{ 340 if (mAudioPolicyManager == NULL) { 341 return NO_INIT; 342 } 343 if (uint32_t(stream) >= AUDIO_STREAM_CNT) { 344 return BAD_VALUE; 345 } 346 Mutex::Autolock _l(mLock); 347 return mAudioPolicyManager->getStreamVolumeIndex(stream, 348 index, 349 device); 350} 351 352uint32_t AudioPolicyService::getStrategyForStream(audio_stream_type_t stream) 353{ 354 if (mAudioPolicyManager == NULL) { 355 return 0; 356 } 357 return mAudioPolicyManager->getStrategyForStream(stream); 358} 359 360//audio policy: use audio_device_t appropriately 361 362audio_devices_t AudioPolicyService::getDevicesForStream(audio_stream_type_t stream) 363{ 364 if (mAudioPolicyManager == NULL) { 365 return (audio_devices_t)0; 366 } 367 return mAudioPolicyManager->getDevicesForStream(stream); 368} 369 370audio_io_handle_t AudioPolicyService::getOutputForEffect(const effect_descriptor_t *desc) 371{ 372 // FIXME change return type to status_t, and return NO_INIT here 373 if (mAudioPolicyManager == NULL) { 374 return 0; 375 } 376 Mutex::Autolock _l(mLock); 377 return mAudioPolicyManager->getOutputForEffect(desc); 378} 379 380status_t AudioPolicyService::registerEffect(const effect_descriptor_t *desc, 381 audio_io_handle_t io, 382 uint32_t strategy, 383 int session, 384 int id) 385{ 386 if (mAudioPolicyManager == NULL) { 387 return NO_INIT; 388 } 389 return mAudioPolicyManager->registerEffect(desc, io, strategy, session, id); 390} 391 392status_t AudioPolicyService::unregisterEffect(int id) 393{ 394 if (mAudioPolicyManager == NULL) { 395 return NO_INIT; 396 } 397 return mAudioPolicyManager->unregisterEffect(id); 398} 399 400status_t AudioPolicyService::setEffectEnabled(int id, bool enabled) 401{ 402 if (mAudioPolicyManager == NULL) { 403 return NO_INIT; 404 } 405 return mAudioPolicyManager->setEffectEnabled(id, enabled); 406} 407 408bool AudioPolicyService::isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const 409{ 410 if (mAudioPolicyManager == NULL) { 411 return 0; 412 } 413 Mutex::Autolock _l(mLock); 414 return mAudioPolicyManager->isStreamActive(stream, inPastMs); 415} 416 417bool AudioPolicyService::isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const 418{ 419 if (mAudioPolicyManager == NULL) { 420 return 0; 421 } 422 Mutex::Autolock _l(mLock); 423 return mAudioPolicyManager->isStreamActiveRemotely(stream, inPastMs); 424} 425 426bool AudioPolicyService::isSourceActive(audio_source_t source) const 427{ 428 if (mAudioPolicyManager == NULL) { 429 return false; 430 } 431 Mutex::Autolock _l(mLock); 432 return mAudioPolicyManager->isSourceActive(source); 433} 434 435status_t AudioPolicyService::queryDefaultPreProcessing(int audioSession, 436 effect_descriptor_t *descriptors, 437 uint32_t *count) 438{ 439 440 if (mAudioPolicyManager == NULL) { 441 *count = 0; 442 return NO_INIT; 443 } 444 Mutex::Autolock _l(mLock); 445 status_t status = NO_ERROR; 446 447 size_t index; 448 for (index = 0; index < mInputs.size(); index++) { 449 if (mInputs.valueAt(index)->mSessionId == audioSession) { 450 break; 451 } 452 } 453 if (index == mInputs.size()) { 454 *count = 0; 455 return BAD_VALUE; 456 } 457 Vector< sp<AudioEffect> > effects = mInputs.valueAt(index)->mEffects; 458 459 for (size_t i = 0; i < effects.size(); i++) { 460 effect_descriptor_t desc = effects[i]->descriptor(); 461 if (i < *count) { 462 descriptors[i] = desc; 463 } 464 } 465 if (effects.size() > *count) { 466 status = NO_MEMORY; 467 } 468 *count = effects.size(); 469 return status; 470} 471 472bool AudioPolicyService::isOffloadSupported(const audio_offload_info_t& info) 473{ 474 if (mAudioPolicyManager == NULL) { 475 ALOGV("mAudioPolicyManager == NULL"); 476 return false; 477 } 478 479 return mAudioPolicyManager->isOffloadSupported(info); 480} 481 482status_t AudioPolicyService::listAudioPorts(audio_port_role_t role, 483 audio_port_type_t type, 484 unsigned int *num_ports, 485 struct audio_port *ports, 486 unsigned int *generation) 487{ 488 Mutex::Autolock _l(mLock); 489 if(!modifyAudioRoutingAllowed()) { 490 return PERMISSION_DENIED; 491 } 492 if (mAudioPolicyManager == NULL) { 493 return NO_INIT; 494 } 495 496 return mAudioPolicyManager->listAudioPorts(role, type, num_ports, ports, generation); 497} 498 499status_t AudioPolicyService::getAudioPort(struct audio_port *port) 500{ 501 Mutex::Autolock _l(mLock); 502 if(!modifyAudioRoutingAllowed()) { 503 return PERMISSION_DENIED; 504 } 505 if (mAudioPolicyManager == NULL) { 506 return NO_INIT; 507 } 508 509 return mAudioPolicyManager->getAudioPort(port); 510} 511 512status_t AudioPolicyService::createAudioPatch(const struct audio_patch *patch, 513 audio_patch_handle_t *handle) 514{ 515 Mutex::Autolock _l(mLock); 516 if(!modifyAudioRoutingAllowed()) { 517 return PERMISSION_DENIED; 518 } 519 if (mAudioPolicyManager == NULL) { 520 return NO_INIT; 521 } 522 return mAudioPolicyManager->createAudioPatch(patch, handle, 523 IPCThreadState::self()->getCallingUid()); 524} 525 526status_t AudioPolicyService::releaseAudioPatch(audio_patch_handle_t handle) 527{ 528 Mutex::Autolock _l(mLock); 529 if(!modifyAudioRoutingAllowed()) { 530 return PERMISSION_DENIED; 531 } 532 if (mAudioPolicyManager == NULL) { 533 return NO_INIT; 534 } 535 536 return mAudioPolicyManager->releaseAudioPatch(handle, 537 IPCThreadState::self()->getCallingUid()); 538} 539 540status_t AudioPolicyService::listAudioPatches(unsigned int *num_patches, 541 struct audio_patch *patches, 542 unsigned int *generation) 543{ 544 Mutex::Autolock _l(mLock); 545 if(!modifyAudioRoutingAllowed()) { 546 return PERMISSION_DENIED; 547 } 548 if (mAudioPolicyManager == NULL) { 549 return NO_INIT; 550 } 551 552 return mAudioPolicyManager->listAudioPatches(num_patches, patches, generation); 553} 554 555status_t AudioPolicyService::setAudioPortConfig(const struct audio_port_config *config) 556{ 557 Mutex::Autolock _l(mLock); 558 if(!modifyAudioRoutingAllowed()) { 559 return PERMISSION_DENIED; 560 } 561 if (mAudioPolicyManager == NULL) { 562 return NO_INIT; 563 } 564 565 return mAudioPolicyManager->setAudioPortConfig(config); 566} 567 568}; // namespace android 569