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