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