AudioPolicyService.h revision f862bc6a7a35054e38cb50fa16ae7a07f683ee01
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#ifndef ANDROID_AUDIOPOLICYSERVICE_H 18#define ANDROID_AUDIOPOLICYSERVICE_H 19 20#include <cutils/misc.h> 21#include <cutils/config_utils.h> 22#include <cutils/compiler.h> 23#include <utils/String8.h> 24#include <utils/Vector.h> 25#include <utils/SortedVector.h> 26#include <binder/BinderService.h> 27#include <system/audio.h> 28#include <system/audio_policy.h> 29#include <hardware/audio_policy.h> 30#include <media/IAudioPolicyService.h> 31#include <media/ToneGenerator.h> 32#include <media/AudioEffect.h> 33#include <media/AudioPolicy.h> 34#ifdef USE_LEGACY_AUDIO_POLICY 35#include <hardware_legacy/AudioPolicyInterface.h> 36#endif 37#include "AudioPolicyEffects.h" 38#include "managerdefault/AudioPolicyManager.h" 39 40 41namespace android { 42 43// ---------------------------------------------------------------------------- 44 45class AudioPolicyService : 46 public BinderService<AudioPolicyService>, 47 public BnAudioPolicyService, 48 public IBinder::DeathRecipient 49{ 50 friend class BinderService<AudioPolicyService>; 51 52public: 53 // for BinderService 54 static const char *getServiceName() ANDROID_API { return "media.audio_policy"; } 55 56 virtual status_t dump(int fd, const Vector<String16>& args); 57 58 // 59 // BnAudioPolicyService (see AudioPolicyInterface for method descriptions) 60 // 61 62 virtual status_t setDeviceConnectionState(audio_devices_t device, 63 audio_policy_dev_state_t state, 64 const char *device_address, 65 const char *device_name); 66 virtual audio_policy_dev_state_t getDeviceConnectionState( 67 audio_devices_t device, 68 const char *device_address); 69 virtual status_t handleDeviceConfigChange(audio_devices_t device, 70 const char *device_address, 71 const char *device_name); 72 virtual status_t setPhoneState(audio_mode_t state); 73 virtual status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config); 74 virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage); 75 virtual audio_io_handle_t getOutput(audio_stream_type_t stream, 76 uint32_t samplingRate = 0, 77 audio_format_t format = AUDIO_FORMAT_DEFAULT, 78 audio_channel_mask_t channelMask = 0, 79 audio_output_flags_t flags = 80 AUDIO_OUTPUT_FLAG_NONE, 81 const audio_offload_info_t *offloadInfo = NULL); 82 virtual status_t getOutputForAttr(const audio_attributes_t *attr, 83 audio_io_handle_t *output, 84 audio_session_t session, 85 audio_stream_type_t *stream, 86 uid_t uid, 87 uint32_t samplingRate = 0, 88 audio_format_t format = AUDIO_FORMAT_DEFAULT, 89 audio_channel_mask_t channelMask = 0, 90 audio_output_flags_t flags = AUDIO_OUTPUT_FLAG_NONE, 91 audio_port_handle_t selectedDeviceId = AUDIO_PORT_HANDLE_NONE, 92 const audio_offload_info_t *offloadInfo = NULL); 93 virtual status_t startOutput(audio_io_handle_t output, 94 audio_stream_type_t stream, 95 audio_session_t session); 96 virtual status_t stopOutput(audio_io_handle_t output, 97 audio_stream_type_t stream, 98 audio_session_t session); 99 virtual void releaseOutput(audio_io_handle_t output, 100 audio_stream_type_t stream, 101 audio_session_t session); 102 virtual status_t getInputForAttr(const audio_attributes_t *attr, 103 audio_io_handle_t *input, 104 audio_session_t session, 105 pid_t pid, 106 uid_t uid, 107 uint32_t samplingRate, 108 audio_format_t format, 109 audio_channel_mask_t channelMask, 110 audio_input_flags_t flags, 111 audio_port_handle_t selectedDeviceId = AUDIO_PORT_HANDLE_NONE); 112 virtual status_t startInput(audio_io_handle_t input, 113 audio_session_t session); 114 virtual status_t stopInput(audio_io_handle_t input, 115 audio_session_t session); 116 virtual void releaseInput(audio_io_handle_t input, 117 audio_session_t session); 118 virtual status_t initStreamVolume(audio_stream_type_t stream, 119 int indexMin, 120 int indexMax); 121 virtual status_t setStreamVolumeIndex(audio_stream_type_t stream, 122 int index, 123 audio_devices_t device); 124 virtual status_t getStreamVolumeIndex(audio_stream_type_t stream, 125 int *index, 126 audio_devices_t device); 127 128 virtual uint32_t getStrategyForStream(audio_stream_type_t stream); 129 virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream); 130 131 virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc); 132 virtual status_t registerEffect(const effect_descriptor_t *desc, 133 audio_io_handle_t io, 134 uint32_t strategy, 135 audio_session_t session, 136 int id); 137 virtual status_t unregisterEffect(int id); 138 virtual status_t setEffectEnabled(int id, bool enabled); 139 virtual bool isStreamActive(audio_stream_type_t stream, uint32_t inPastMs = 0) const; 140 virtual bool isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs = 0) const; 141 virtual bool isSourceActive(audio_source_t source) const; 142 143 virtual status_t queryDefaultPreProcessing(audio_session_t audioSession, 144 effect_descriptor_t *descriptors, 145 uint32_t *count); 146 virtual status_t onTransact( 147 uint32_t code, 148 const Parcel& data, 149 Parcel* reply, 150 uint32_t flags); 151 152 // IBinder::DeathRecipient 153 virtual void binderDied(const wp<IBinder>& who); 154 155 // RefBase 156 virtual void onFirstRef(); 157 158 // 159 // Helpers for the struct audio_policy_service_ops implementation. 160 // This is used by the audio policy manager for certain operations that 161 // are implemented by the policy service. 162 // 163 virtual void setParameters(audio_io_handle_t ioHandle, 164 const char *keyValuePairs, 165 int delayMs); 166 167 virtual status_t setStreamVolume(audio_stream_type_t stream, 168 float volume, 169 audio_io_handle_t output, 170 int delayMs = 0); 171 virtual status_t startTone(audio_policy_tone_t tone, audio_stream_type_t stream); 172 virtual status_t stopTone(); 173 virtual status_t setVoiceVolume(float volume, int delayMs = 0); 174 virtual bool isOffloadSupported(const audio_offload_info_t &config); 175 176 virtual status_t listAudioPorts(audio_port_role_t role, 177 audio_port_type_t type, 178 unsigned int *num_ports, 179 struct audio_port *ports, 180 unsigned int *generation); 181 virtual status_t getAudioPort(struct audio_port *port); 182 virtual status_t createAudioPatch(const struct audio_patch *patch, 183 audio_patch_handle_t *handle); 184 virtual status_t releaseAudioPatch(audio_patch_handle_t handle); 185 virtual status_t listAudioPatches(unsigned int *num_patches, 186 struct audio_patch *patches, 187 unsigned int *generation); 188 virtual status_t setAudioPortConfig(const struct audio_port_config *config); 189 190 virtual void registerClient(const sp<IAudioPolicyServiceClient>& client); 191 192 virtual void setAudioPortCallbacksEnabled(bool enabled); 193 194 virtual status_t acquireSoundTriggerSession(audio_session_t *session, 195 audio_io_handle_t *ioHandle, 196 audio_devices_t *device); 197 198 virtual status_t releaseSoundTriggerSession(audio_session_t session); 199 200 virtual audio_mode_t getPhoneState(); 201 202 virtual status_t registerPolicyMixes(const Vector<AudioMix>& mixes, bool registration); 203 204 virtual status_t startAudioSource(const struct audio_port_config *source, 205 const audio_attributes_t *attributes, 206 audio_io_handle_t *handle); 207 virtual status_t stopAudioSource(audio_io_handle_t handle); 208 209 virtual status_t setMasterMono(bool mono); 210 virtual status_t getMasterMono(bool *mono); 211 212 status_t doStopOutput(audio_io_handle_t output, 213 audio_stream_type_t stream, 214 audio_session_t session); 215 void doReleaseOutput(audio_io_handle_t output, 216 audio_stream_type_t stream, 217 audio_session_t session); 218 219 status_t clientCreateAudioPatch(const struct audio_patch *patch, 220 audio_patch_handle_t *handle, 221 int delayMs); 222 status_t clientReleaseAudioPatch(audio_patch_handle_t handle, 223 int delayMs); 224 virtual status_t clientSetAudioPortConfig(const struct audio_port_config *config, 225 int delayMs); 226 227 void removeNotificationClient(uid_t uid); 228 void onAudioPortListUpdate(); 229 void doOnAudioPortListUpdate(); 230 void onAudioPatchListUpdate(); 231 void doOnAudioPatchListUpdate(); 232 233 void onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state); 234 void doOnDynamicPolicyMixStateUpdate(const String8& regId, int32_t state); 235 void onRecordingConfigurationUpdate(int event, audio_session_t session, 236 audio_source_t source, const audio_config_base_t *clientConfig, 237 const audio_config_base_t *deviceConfig, audio_patch_handle_t patchHandle); 238 void doOnRecordingConfigurationUpdate(int event, audio_session_t session, 239 audio_source_t source, const audio_config_base_t *clientConfig, 240 const audio_config_base_t *deviceConfig, audio_patch_handle_t patchHandle); 241 242private: 243 AudioPolicyService() ANDROID_API; 244 virtual ~AudioPolicyService(); 245 246 status_t dumpInternals(int fd); 247 248 // Thread used for tone playback and to send audio config commands to audio flinger 249 // For tone playback, using a separate thread is necessary to avoid deadlock with mLock because 250 // startTone() and stopTone() are normally called with mLock locked and requesting a tone start 251 // or stop will cause calls to AudioPolicyService and an attempt to lock mLock. 252 // For audio config commands, it is necessary because audio flinger requires that the calling 253 // process (user) has permission to modify audio settings. 254 class AudioCommandThread : public Thread { 255 class AudioCommand; 256 public: 257 258 // commands for tone AudioCommand 259 enum { 260 START_TONE, 261 STOP_TONE, 262 SET_VOLUME, 263 SET_PARAMETERS, 264 SET_VOICE_VOLUME, 265 STOP_OUTPUT, 266 RELEASE_OUTPUT, 267 CREATE_AUDIO_PATCH, 268 RELEASE_AUDIO_PATCH, 269 UPDATE_AUDIOPORT_LIST, 270 UPDATE_AUDIOPATCH_LIST, 271 SET_AUDIOPORT_CONFIG, 272 DYN_POLICY_MIX_STATE_UPDATE, 273 RECORDING_CONFIGURATION_UPDATE 274 }; 275 276 AudioCommandThread (String8 name, const wp<AudioPolicyService>& service); 277 virtual ~AudioCommandThread(); 278 279 status_t dump(int fd); 280 281 // Thread virtuals 282 virtual void onFirstRef(); 283 virtual bool threadLoop(); 284 285 void exit(); 286 void startToneCommand(ToneGenerator::tone_type type, 287 audio_stream_type_t stream); 288 void stopToneCommand(); 289 status_t volumeCommand(audio_stream_type_t stream, float volume, 290 audio_io_handle_t output, int delayMs = 0); 291 status_t parametersCommand(audio_io_handle_t ioHandle, 292 const char *keyValuePairs, int delayMs = 0); 293 status_t voiceVolumeCommand(float volume, int delayMs = 0); 294 void stopOutputCommand(audio_io_handle_t output, 295 audio_stream_type_t stream, 296 audio_session_t session); 297 void releaseOutputCommand(audio_io_handle_t output, 298 audio_stream_type_t stream, 299 audio_session_t session); 300 status_t sendCommand(sp<AudioCommand>& command, int delayMs = 0); 301 void insertCommand_l(sp<AudioCommand>& command, int delayMs = 0); 302 status_t createAudioPatchCommand(const struct audio_patch *patch, 303 audio_patch_handle_t *handle, 304 int delayMs); 305 status_t releaseAudioPatchCommand(audio_patch_handle_t handle, 306 int delayMs); 307 void updateAudioPortListCommand(); 308 void updateAudioPatchListCommand(); 309 status_t setAudioPortConfigCommand(const struct audio_port_config *config, 310 int delayMs); 311 void dynamicPolicyMixStateUpdateCommand(const String8& regId, int32_t state); 312 void recordingConfigurationUpdateCommand( 313 int event, audio_session_t session, 314 audio_source_t source, 315 const audio_config_base_t *clientConfig, 316 const audio_config_base_t *deviceConfig, 317 audio_patch_handle_t patchHandle); 318 void insertCommand_l(AudioCommand *command, int delayMs = 0); 319 320 private: 321 class AudioCommandData; 322 323 // descriptor for requested tone playback event 324 class AudioCommand: public RefBase { 325 326 public: 327 AudioCommand() 328 : mCommand(-1), mStatus(NO_ERROR), mWaitStatus(false) {} 329 330 void dump(char* buffer, size_t size); 331 332 int mCommand; // START_TONE, STOP_TONE ... 333 nsecs_t mTime; // time stamp 334 Mutex mLock; // mutex associated to mCond 335 Condition mCond; // condition for status return 336 status_t mStatus; // command status 337 bool mWaitStatus; // true if caller is waiting for status 338 sp<AudioCommandData> mParam; // command specific parameter data 339 }; 340 341 class AudioCommandData: public RefBase { 342 public: 343 virtual ~AudioCommandData() {} 344 protected: 345 AudioCommandData() {} 346 }; 347 348 class ToneData : public AudioCommandData { 349 public: 350 ToneGenerator::tone_type mType; // tone type (START_TONE only) 351 audio_stream_type_t mStream; // stream type (START_TONE only) 352 }; 353 354 class VolumeData : public AudioCommandData { 355 public: 356 audio_stream_type_t mStream; 357 float mVolume; 358 audio_io_handle_t mIO; 359 }; 360 361 class ParametersData : public AudioCommandData { 362 public: 363 audio_io_handle_t mIO; 364 String8 mKeyValuePairs; 365 }; 366 367 class VoiceVolumeData : public AudioCommandData { 368 public: 369 float mVolume; 370 }; 371 372 class StopOutputData : public AudioCommandData { 373 public: 374 audio_io_handle_t mIO; 375 audio_stream_type_t mStream; 376 audio_session_t mSession; 377 }; 378 379 class ReleaseOutputData : public AudioCommandData { 380 public: 381 audio_io_handle_t mIO; 382 audio_stream_type_t mStream; 383 audio_session_t mSession; 384 }; 385 386 class CreateAudioPatchData : public AudioCommandData { 387 public: 388 struct audio_patch mPatch; 389 audio_patch_handle_t mHandle; 390 }; 391 392 class ReleaseAudioPatchData : public AudioCommandData { 393 public: 394 audio_patch_handle_t mHandle; 395 }; 396 397 class SetAudioPortConfigData : public AudioCommandData { 398 public: 399 struct audio_port_config mConfig; 400 }; 401 402 class DynPolicyMixStateUpdateData : public AudioCommandData { 403 public: 404 String8 mRegId; 405 int32_t mState; 406 }; 407 408 class RecordingConfigurationUpdateData : public AudioCommandData { 409 public: 410 int mEvent; 411 audio_session_t mSession; 412 audio_source_t mSource; 413 struct audio_config_base mClientConfig; 414 struct audio_config_base mDeviceConfig; 415 audio_patch_handle_t mPatchHandle; 416 }; 417 418 Mutex mLock; 419 Condition mWaitWorkCV; 420 Vector < sp<AudioCommand> > mAudioCommands; // list of pending commands 421 ToneGenerator *mpToneGenerator; // the tone generator 422 sp<AudioCommand> mLastCommand; // last processed command (used by dump) 423 String8 mName; // string used by wake lock fo delayed commands 424 wp<AudioPolicyService> mService; 425 }; 426 427 class AudioPolicyClient : public AudioPolicyClientInterface 428 { 429 public: 430 explicit AudioPolicyClient(AudioPolicyService *service) : mAudioPolicyService(service) {} 431 virtual ~AudioPolicyClient() {} 432 433 // 434 // Audio HW module functions 435 // 436 437 // loads a HW module. 438 virtual audio_module_handle_t loadHwModule(const char *name); 439 440 // 441 // Audio output Control functions 442 // 443 444 // opens an audio output with the requested parameters. The parameter values can indicate to use the default values 445 // in case the audio policy manager has no specific requirements for the output being opened. 446 // When the function returns, the parameter values reflect the actual values used by the audio hardware output stream. 447 // The audio policy manager can check if the proposed parameters are suitable or not and act accordingly. 448 virtual status_t openOutput(audio_module_handle_t module, 449 audio_io_handle_t *output, 450 audio_config_t *config, 451 audio_devices_t *devices, 452 const String8& address, 453 uint32_t *latencyMs, 454 audio_output_flags_t flags); 455 // creates a special output that is duplicated to the two outputs passed as arguments. The duplication is performed by 456 // a special mixer thread in the AudioFlinger. 457 virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1, audio_io_handle_t output2); 458 // closes the output stream 459 virtual status_t closeOutput(audio_io_handle_t output); 460 // suspends the output. When an output is suspended, the corresponding audio hardware output stream is placed in 461 // standby and the AudioTracks attached to the mixer thread are still processed but the output mix is discarded. 462 virtual status_t suspendOutput(audio_io_handle_t output); 463 // restores a suspended output. 464 virtual status_t restoreOutput(audio_io_handle_t output); 465 466 // 467 // Audio input Control functions 468 // 469 470 // opens an audio input 471 virtual audio_io_handle_t openInput(audio_module_handle_t module, 472 audio_io_handle_t *input, 473 audio_config_t *config, 474 audio_devices_t *devices, 475 const String8& address, 476 audio_source_t source, 477 audio_input_flags_t flags); 478 // closes an audio input 479 virtual status_t closeInput(audio_io_handle_t input); 480 // 481 // misc control functions 482 // 483 484 // set a stream volume for a particular output. For the same user setting, a given stream type can have different volumes 485 // for each output (destination device) it is attached to. 486 virtual status_t setStreamVolume(audio_stream_type_t stream, float volume, audio_io_handle_t output, int delayMs = 0); 487 488 // invalidate a stream type, causing a reroute to an unspecified new output 489 virtual status_t invalidateStream(audio_stream_type_t stream); 490 491 // function enabling to send proprietary informations directly from audio policy manager to audio hardware interface. 492 virtual void setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs, int delayMs = 0); 493 // function enabling to receive proprietary informations directly from audio hardware interface to audio policy manager. 494 virtual String8 getParameters(audio_io_handle_t ioHandle, const String8& keys); 495 496 // request the playback of a tone on the specified stream: used for instance to replace notification sounds when playing 497 // over a telephony device during a phone call. 498 virtual status_t startTone(audio_policy_tone_t tone, audio_stream_type_t stream); 499 virtual status_t stopTone(); 500 501 // set down link audio volume. 502 virtual status_t setVoiceVolume(float volume, int delayMs = 0); 503 504 // move effect to the specified output 505 virtual status_t moveEffects(audio_session_t session, 506 audio_io_handle_t srcOutput, 507 audio_io_handle_t dstOutput); 508 509 /* Create a patch between several source and sink ports */ 510 virtual status_t createAudioPatch(const struct audio_patch *patch, 511 audio_patch_handle_t *handle, 512 int delayMs); 513 514 /* Release a patch */ 515 virtual status_t releaseAudioPatch(audio_patch_handle_t handle, 516 int delayMs); 517 518 /* Set audio port configuration */ 519 virtual status_t setAudioPortConfig(const struct audio_port_config *config, int delayMs); 520 521 virtual void onAudioPortListUpdate(); 522 virtual void onAudioPatchListUpdate(); 523 virtual void onDynamicPolicyMixStateUpdate(String8 regId, int32_t state); 524 virtual void onRecordingConfigurationUpdate(int event, 525 audio_session_t session, audio_source_t source, 526 const audio_config_base_t *clientConfig, 527 const audio_config_base_t *deviceConfig, audio_patch_handle_t patchHandle); 528 529 virtual audio_unique_id_t newAudioUniqueId(audio_unique_id_use_t use); 530 531 private: 532 AudioPolicyService *mAudioPolicyService; 533 }; 534 535 // --- Notification Client --- 536 class NotificationClient : public IBinder::DeathRecipient { 537 public: 538 NotificationClient(const sp<AudioPolicyService>& service, 539 const sp<IAudioPolicyServiceClient>& client, 540 uid_t uid); 541 virtual ~NotificationClient(); 542 543 void onAudioPortListUpdate(); 544 void onAudioPatchListUpdate(); 545 void onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state); 546 void onRecordingConfigurationUpdate( 547 int event, audio_session_t session, 548 audio_source_t source, 549 const audio_config_base_t *clientConfig, 550 const audio_config_base_t *deviceConfig, 551 audio_patch_handle_t patchHandle); 552 void setAudioPortCallbacksEnabled(bool enabled); 553 554 // IBinder::DeathRecipient 555 virtual void binderDied(const wp<IBinder>& who); 556 557 private: 558 NotificationClient(const NotificationClient&); 559 NotificationClient& operator = (const NotificationClient&); 560 561 const wp<AudioPolicyService> mService; 562 const uid_t mUid; 563 const sp<IAudioPolicyServiceClient> mAudioPolicyServiceClient; 564 bool mAudioPortCallbacksEnabled; 565 }; 566 567 // Internal dump utilities. 568 status_t dumpPermissionDenial(int fd); 569 570 571 mutable Mutex mLock; // prevents concurrent access to AudioPolicy manager functions changing 572 // device connection state or routing 573 mutable Mutex mEffectsLock; // serialize access to Effect state within APM. 574 // Note: lock acquisition order is always mLock > mEffectsLock: 575 // mLock protects AudioPolicyManager methods that can call into audio flinger 576 // and possibly back in to audio policy service and acquire mEffectsLock. 577 sp<AudioCommandThread> mAudioCommandThread; // audio commands thread 578 sp<AudioCommandThread> mTonePlaybackThread; // tone playback thread 579 sp<AudioCommandThread> mOutputCommandThread; // process stop and release output 580 struct audio_policy_device *mpAudioPolicyDev; 581 struct audio_policy *mpAudioPolicy; 582 AudioPolicyInterface *mAudioPolicyManager; 583 AudioPolicyClient *mAudioPolicyClient; 584 585 DefaultKeyedVector< uid_t, sp<NotificationClient> > mNotificationClients; 586 Mutex mNotificationClientsLock; // protects mNotificationClients 587 // Manage all effects configured in audio_effects.conf 588 sp<AudioPolicyEffects> mAudioPolicyEffects; 589 audio_mode_t mPhoneState; 590}; 591 592}; // namespace android 593 594#endif // ANDROID_AUDIOPOLICYSERVICE_H 595