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