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