AudioPolicyInterfaceImpl.cpp revision b3b1660ecb67f61f9da54efced8677fa3a6f4863
193c65e6e661eda75711363bdd5ca15909920e1f0Joerg Sonnenberger/* 293c65e6e661eda75711363bdd5ca15909920e1f0Joerg Sonnenberger * Copyright (C) 2009 The Android Open Source Project 393c65e6e661eda75711363bdd5ca15909920e1f0Joerg Sonnenberger * 493c65e6e661eda75711363bdd5ca15909920e1f0Joerg Sonnenberger * Licensed under the Apache License, Version 2.0 (the "License"); 593c65e6e661eda75711363bdd5ca15909920e1f0Joerg Sonnenberger * you may not use this file except in compliance with the License. 693c65e6e661eda75711363bdd5ca15909920e1f0Joerg Sonnenberger * You may obtain a copy of the License at 793c65e6e661eda75711363bdd5ca15909920e1f0Joerg Sonnenberger * 893c65e6e661eda75711363bdd5ca15909920e1f0Joerg Sonnenberger * http://www.apache.org/licenses/LICENSE-2.0 993c65e6e661eda75711363bdd5ca15909920e1f0Joerg Sonnenberger * 1093c65e6e661eda75711363bdd5ca15909920e1f0Joerg Sonnenberger * Unless required by applicable law or agreed to in writing, software 1193c65e6e661eda75711363bdd5ca15909920e1f0Joerg Sonnenberger * distributed under the License is distributed on an "AS IS" BASIS, 1293c65e6e661eda75711363bdd5ca15909920e1f0Joerg Sonnenberger * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 1393c65e6e661eda75711363bdd5ca15909920e1f0Joerg Sonnenberger * See the License for the specific language governing permissions and 1493c65e6e661eda75711363bdd5ca15909920e1f0Joerg Sonnenberger * limitations under the License. 1593c65e6e661eda75711363bdd5ca15909920e1f0Joerg Sonnenberger */ 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 160 // create audio processors according to stream 161 status_t status = mAudioPolicyEffects->addOutputSessionEffects(output, stream, session); 162 if (status != NO_ERROR && status != ALREADY_EXISTS) { 163 ALOGW("Failed to add effects on session %d", session); 164 } 165 166 return mAudioPolicyManager->startOutput(output, stream, session); 167} 168 169status_t AudioPolicyService::stopOutput(audio_io_handle_t output, 170 audio_stream_type_t stream, 171 int session) 172{ 173 if (mAudioPolicyManager == NULL) { 174 return NO_INIT; 175 } 176 ALOGV("stopOutput()"); 177 mOutputCommandThread->stopOutputCommand(output, stream, session); 178 return NO_ERROR; 179} 180 181status_t AudioPolicyService::doStopOutput(audio_io_handle_t output, 182 audio_stream_type_t stream, 183 int session) 184{ 185 ALOGV("doStopOutput from tid %d", gettid()); 186 Mutex::Autolock _l(mLock); 187 188 // release audio processors from the stream 189 status_t status = mAudioPolicyEffects->releaseOutputSessionEffects(output, stream, session); 190 if (status != NO_ERROR && status != ALREADY_EXISTS) { 191 ALOGW("Failed to release effects on session %d", session); 192 } 193 194 return mAudioPolicyManager->stopOutput(output, stream, session); 195} 196 197void AudioPolicyService::releaseOutput(audio_io_handle_t output) 198{ 199 if (mAudioPolicyManager == NULL) { 200 return; 201 } 202 ALOGV("releaseOutput()"); 203 mOutputCommandThread->releaseOutputCommand(output); 204} 205 206void AudioPolicyService::doReleaseOutput(audio_io_handle_t output) 207{ 208 ALOGV("doReleaseOutput from tid %d", gettid()); 209 Mutex::Autolock _l(mLock); 210 mAudioPolicyManager->releaseOutput(output); 211} 212 213audio_io_handle_t AudioPolicyService::getInput(audio_source_t inputSource, 214 uint32_t samplingRate, 215 audio_format_t format, 216 audio_channel_mask_t channelMask, 217 int audioSession, 218 audio_input_flags_t flags __unused) 219{ 220 if (mAudioPolicyManager == NULL) { 221 return 0; 222 } 223 // already checked by client, but double-check in case the client wrapper is bypassed 224 if (inputSource >= AUDIO_SOURCE_CNT && inputSource != AUDIO_SOURCE_HOTWORD) { 225 return 0; 226 } 227 228 if ((inputSource == AUDIO_SOURCE_HOTWORD) && !captureHotwordAllowed()) { 229 return 0; 230 } 231 232 Mutex::Autolock _l(mLock); 233 // the audio_in_acoustics_t parameter is ignored by get_input() 234 audio_io_handle_t input = mAudioPolicyManager->getInput(inputSource, samplingRate, 235 format, channelMask, (audio_in_acoustics_t) 0); 236 237 if (input == 0) { 238 return input; 239 } 240 241 // create audio pre processors according to input source 242 status_t status = mAudioPolicyEffects->addInputEffects(input, inputSource, audioSession); 243 if (status != NO_ERROR && status != ALREADY_EXISTS) { 244 ALOGW("Failed to add effects on input %d", input); 245 } 246 247 return input; 248} 249 250status_t AudioPolicyService::startInput(audio_io_handle_t input) 251{ 252 if (mAudioPolicyManager == NULL) { 253 return NO_INIT; 254 } 255 Mutex::Autolock _l(mLock); 256 257 return mAudioPolicyManager->startInput(input); 258} 259 260status_t AudioPolicyService::stopInput(audio_io_handle_t input) 261{ 262 if (mAudioPolicyManager == NULL) { 263 return NO_INIT; 264 } 265 Mutex::Autolock _l(mLock); 266 267 return mAudioPolicyManager->stopInput(input); 268} 269 270void AudioPolicyService::releaseInput(audio_io_handle_t input) 271{ 272 if (mAudioPolicyManager == NULL) { 273 return; 274 } 275 Mutex::Autolock _l(mLock); 276 mAudioPolicyManager->releaseInput(input); 277 278 // release audio processors from the input 279 status_t status = mAudioPolicyEffects->releaseInputEffects(input); 280 if(status != NO_ERROR) { 281 ALOGW("Failed to release effects on input %d", input); 282 } 283} 284 285status_t AudioPolicyService::initStreamVolume(audio_stream_type_t stream, 286 int indexMin, 287 int indexMax) 288{ 289 if (mAudioPolicyManager == NULL) { 290 return NO_INIT; 291 } 292 if (!settingsAllowed()) { 293 return PERMISSION_DENIED; 294 } 295 if (uint32_t(stream) >= AUDIO_STREAM_CNT) { 296 return BAD_VALUE; 297 } 298 Mutex::Autolock _l(mLock); 299 mAudioPolicyManager->initStreamVolume(stream, indexMin, indexMax); 300 return NO_ERROR; 301} 302 303status_t AudioPolicyService::setStreamVolumeIndex(audio_stream_type_t stream, 304 int index, 305 audio_devices_t device) 306{ 307 if (mAudioPolicyManager == NULL) { 308 return NO_INIT; 309 } 310 if (!settingsAllowed()) { 311 return PERMISSION_DENIED; 312 } 313 if (uint32_t(stream) >= AUDIO_STREAM_CNT) { 314 return BAD_VALUE; 315 } 316 Mutex::Autolock _l(mLock); 317 return mAudioPolicyManager->setStreamVolumeIndex(stream, 318 index, 319 device); 320} 321 322status_t AudioPolicyService::getStreamVolumeIndex(audio_stream_type_t stream, 323 int *index, 324 audio_devices_t device) 325{ 326 if (mAudioPolicyManager == NULL) { 327 return NO_INIT; 328 } 329 if (uint32_t(stream) >= AUDIO_STREAM_CNT) { 330 return BAD_VALUE; 331 } 332 Mutex::Autolock _l(mLock); 333 return mAudioPolicyManager->getStreamVolumeIndex(stream, 334 index, 335 device); 336} 337 338uint32_t AudioPolicyService::getStrategyForStream(audio_stream_type_t stream) 339{ 340 if (mAudioPolicyManager == NULL) { 341 return 0; 342 } 343 return mAudioPolicyManager->getStrategyForStream(stream); 344} 345 346//audio policy: use audio_device_t appropriately 347 348audio_devices_t AudioPolicyService::getDevicesForStream(audio_stream_type_t stream) 349{ 350 if (mAudioPolicyManager == NULL) { 351 return (audio_devices_t)0; 352 } 353 return mAudioPolicyManager->getDevicesForStream(stream); 354} 355 356audio_io_handle_t AudioPolicyService::getOutputForEffect(const effect_descriptor_t *desc) 357{ 358 // FIXME change return type to status_t, and return NO_INIT here 359 if (mAudioPolicyManager == NULL) { 360 return 0; 361 } 362 Mutex::Autolock _l(mLock); 363 return mAudioPolicyManager->getOutputForEffect(desc); 364} 365 366status_t AudioPolicyService::registerEffect(const effect_descriptor_t *desc, 367 audio_io_handle_t io, 368 uint32_t strategy, 369 int session, 370 int id) 371{ 372 if (mAudioPolicyManager == NULL) { 373 return NO_INIT; 374 } 375 return mAudioPolicyManager->registerEffect(desc, io, strategy, session, id); 376} 377 378status_t AudioPolicyService::unregisterEffect(int id) 379{ 380 if (mAudioPolicyManager == NULL) { 381 return NO_INIT; 382 } 383 return mAudioPolicyManager->unregisterEffect(id); 384} 385 386status_t AudioPolicyService::setEffectEnabled(int id, bool enabled) 387{ 388 if (mAudioPolicyManager == NULL) { 389 return NO_INIT; 390 } 391 return mAudioPolicyManager->setEffectEnabled(id, enabled); 392} 393 394bool AudioPolicyService::isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const 395{ 396 if (mAudioPolicyManager == NULL) { 397 return 0; 398 } 399 Mutex::Autolock _l(mLock); 400 return mAudioPolicyManager->isStreamActive(stream, inPastMs); 401} 402 403bool AudioPolicyService::isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const 404{ 405 if (mAudioPolicyManager == NULL) { 406 return 0; 407 } 408 Mutex::Autolock _l(mLock); 409 return mAudioPolicyManager->isStreamActiveRemotely(stream, inPastMs); 410} 411 412bool AudioPolicyService::isSourceActive(audio_source_t source) const 413{ 414 if (mAudioPolicyManager == NULL) { 415 return false; 416 } 417 Mutex::Autolock _l(mLock); 418 return mAudioPolicyManager->isSourceActive(source); 419} 420 421status_t AudioPolicyService::queryDefaultPreProcessing(int audioSession, 422 effect_descriptor_t *descriptors, 423 uint32_t *count) 424{ 425 if (mAudioPolicyManager == NULL) { 426 *count = 0; 427 return NO_INIT; 428 } 429 Mutex::Autolock _l(mLock); 430 431 return mAudioPolicyEffects->queryDefaultInputEffects(audioSession, descriptors, count); 432} 433 434bool AudioPolicyService::isOffloadSupported(const audio_offload_info_t& info) 435{ 436 if (mAudioPolicyManager == NULL) { 437 ALOGV("mAudioPolicyManager == NULL"); 438 return false; 439 } 440 441 return mAudioPolicyManager->isOffloadSupported(info); 442} 443 444status_t AudioPolicyService::listAudioPorts(audio_port_role_t role, 445 audio_port_type_t type, 446 unsigned int *num_ports, 447 struct audio_port *ports, 448 unsigned int *generation) 449{ 450 Mutex::Autolock _l(mLock); 451 if(!modifyAudioRoutingAllowed()) { 452 return PERMISSION_DENIED; 453 } 454 if (mAudioPolicyManager == NULL) { 455 return NO_INIT; 456 } 457 458 return mAudioPolicyManager->listAudioPorts(role, type, num_ports, ports, generation); 459} 460 461status_t AudioPolicyService::getAudioPort(struct audio_port *port) 462{ 463 Mutex::Autolock _l(mLock); 464 if(!modifyAudioRoutingAllowed()) { 465 return PERMISSION_DENIED; 466 } 467 if (mAudioPolicyManager == NULL) { 468 return NO_INIT; 469 } 470 471 return mAudioPolicyManager->getAudioPort(port); 472} 473 474status_t AudioPolicyService::createAudioPatch(const struct audio_patch *patch, 475 audio_patch_handle_t *handle) 476{ 477 Mutex::Autolock _l(mLock); 478 if(!modifyAudioRoutingAllowed()) { 479 return PERMISSION_DENIED; 480 } 481 if (mAudioPolicyManager == NULL) { 482 return NO_INIT; 483 } 484 return mAudioPolicyManager->createAudioPatch(patch, handle, 485 IPCThreadState::self()->getCallingUid()); 486} 487 488status_t AudioPolicyService::releaseAudioPatch(audio_patch_handle_t handle) 489{ 490 Mutex::Autolock _l(mLock); 491 if(!modifyAudioRoutingAllowed()) { 492 return PERMISSION_DENIED; 493 } 494 if (mAudioPolicyManager == NULL) { 495 return NO_INIT; 496 } 497 498 return mAudioPolicyManager->releaseAudioPatch(handle, 499 IPCThreadState::self()->getCallingUid()); 500} 501 502status_t AudioPolicyService::listAudioPatches(unsigned int *num_patches, 503 struct audio_patch *patches, 504 unsigned int *generation) 505{ 506 Mutex::Autolock _l(mLock); 507 if(!modifyAudioRoutingAllowed()) { 508 return PERMISSION_DENIED; 509 } 510 if (mAudioPolicyManager == NULL) { 511 return NO_INIT; 512 } 513 514 return mAudioPolicyManager->listAudioPatches(num_patches, patches, generation); 515} 516 517status_t AudioPolicyService::setAudioPortConfig(const struct audio_port_config *config) 518{ 519 Mutex::Autolock _l(mLock); 520 if(!modifyAudioRoutingAllowed()) { 521 return PERMISSION_DENIED; 522 } 523 if (mAudioPolicyManager == NULL) { 524 return NO_INIT; 525 } 526 527 return mAudioPolicyManager->setAudioPortConfig(config); 528} 529 530}; // namespace android 531