AudioPolicyService.h revision 8670c31fddbeadcf9627aa970c69a823f13939ff
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 status_t doStopOutput(audio_io_handle_t output, 158 audio_stream_type_t stream, 159 int session = 0); 160 void doReleaseOutput(audio_io_handle_t output); 161 162 status_t clientCreateAudioPatch(const struct audio_patch *patch, 163 audio_patch_handle_t *handle, 164 int delayMs); 165 status_t clientReleaseAudioPatch(audio_patch_handle_t handle, 166 int delayMs); 167 168private: 169 AudioPolicyService() ANDROID_API; 170 virtual ~AudioPolicyService(); 171 172 status_t dumpInternals(int fd); 173 174 // Thread used for tone playback and to send audio config commands to audio flinger 175 // For tone playback, using a separate thread is necessary to avoid deadlock with mLock because 176 // startTone() and stopTone() are normally called with mLock locked and requesting a tone start 177 // or stop will cause calls to AudioPolicyService and an attempt to lock mLock. 178 // For audio config commands, it is necessary because audio flinger requires that the calling 179 // process (user) has permission to modify audio settings. 180 class AudioCommandThread : public Thread { 181 class AudioCommand; 182 public: 183 184 // commands for tone AudioCommand 185 enum { 186 START_TONE, 187 STOP_TONE, 188 SET_VOLUME, 189 SET_PARAMETERS, 190 SET_VOICE_VOLUME, 191 STOP_OUTPUT, 192 RELEASE_OUTPUT, 193 CREATE_AUDIO_PATCH, 194 RELEASE_AUDIO_PATCH, 195 }; 196 197 AudioCommandThread (String8 name, const wp<AudioPolicyService>& service); 198 virtual ~AudioCommandThread(); 199 200 status_t dump(int fd); 201 202 // Thread virtuals 203 virtual void onFirstRef(); 204 virtual bool threadLoop(); 205 206 void exit(); 207 void startToneCommand(ToneGenerator::tone_type type, 208 audio_stream_type_t stream); 209 void stopToneCommand(); 210 status_t volumeCommand(audio_stream_type_t stream, float volume, 211 audio_io_handle_t output, int delayMs = 0); 212 status_t parametersCommand(audio_io_handle_t ioHandle, 213 const char *keyValuePairs, int delayMs = 0); 214 status_t voiceVolumeCommand(float volume, int delayMs = 0); 215 void stopOutputCommand(audio_io_handle_t output, 216 audio_stream_type_t stream, 217 int session); 218 void releaseOutputCommand(audio_io_handle_t output); 219 status_t sendCommand(sp<AudioCommand>& command, int delayMs = 0); 220 void insertCommand_l(sp<AudioCommand>& command, int delayMs = 0); 221 status_t createAudioPatchCommand(const struct audio_patch *patch, 222 audio_patch_handle_t *handle, 223 int delayMs); 224 status_t releaseAudioPatchCommand(audio_patch_handle_t handle, 225 int delayMs); 226 227 void insertCommand_l(AudioCommand *command, int delayMs = 0); 228 229 private: 230 class AudioCommandData; 231 232 // descriptor for requested tone playback event 233 class AudioCommand: public RefBase { 234 235 public: 236 AudioCommand() 237 : mCommand(-1), mStatus(NO_ERROR), mWaitStatus(false) {} 238 239 void dump(char* buffer, size_t size); 240 241 int mCommand; // START_TONE, STOP_TONE ... 242 nsecs_t mTime; // time stamp 243 Mutex mLock; // mutex associated to mCond 244 Condition mCond; // condition for status return 245 status_t mStatus; // command status 246 bool mWaitStatus; // true if caller is waiting for status 247 sp<AudioCommandData> mParam; // command specific parameter data 248 }; 249 250 class AudioCommandData: public RefBase { 251 public: 252 virtual ~AudioCommandData() {} 253 protected: 254 AudioCommandData() {} 255 }; 256 257 class ToneData : public AudioCommandData { 258 public: 259 ToneGenerator::tone_type mType; // tone type (START_TONE only) 260 audio_stream_type_t mStream; // stream type (START_TONE only) 261 }; 262 263 class VolumeData : public AudioCommandData { 264 public: 265 audio_stream_type_t mStream; 266 float mVolume; 267 audio_io_handle_t mIO; 268 }; 269 270 class ParametersData : public AudioCommandData { 271 public: 272 audio_io_handle_t mIO; 273 String8 mKeyValuePairs; 274 }; 275 276 class VoiceVolumeData : public AudioCommandData { 277 public: 278 float mVolume; 279 }; 280 281 class StopOutputData : public AudioCommandData { 282 public: 283 audio_io_handle_t mIO; 284 audio_stream_type_t mStream; 285 int mSession; 286 }; 287 288 class ReleaseOutputData : public AudioCommandData { 289 public: 290 audio_io_handle_t mIO; 291 }; 292 293 class CreateAudioPatchData : public AudioCommandData { 294 public: 295 struct audio_patch mPatch; 296 audio_patch_handle_t mHandle; 297 }; 298 299 class ReleaseAudioPatchData : public AudioCommandData { 300 public: 301 audio_patch_handle_t mHandle; 302 }; 303 304 Mutex mLock; 305 Condition mWaitWorkCV; 306 Vector < sp<AudioCommand> > mAudioCommands; // list of pending commands 307 ToneGenerator *mpToneGenerator; // the tone generator 308 sp<AudioCommand> mLastCommand; // last processed command (used by dump) 309 String8 mName; // string used by wake lock fo delayed commands 310 wp<AudioPolicyService> mService; 311 }; 312 313 class EffectDesc { 314 public: 315 EffectDesc(const char *name, const effect_uuid_t& uuid) : 316 mName(strdup(name)), 317 mUuid(uuid) { } 318 EffectDesc(const EffectDesc& orig) : 319 mName(strdup(orig.mName)), 320 mUuid(orig.mUuid) { 321 // deep copy mParams 322 for (size_t k = 0; k < orig.mParams.size(); k++) { 323 effect_param_t *origParam = orig.mParams[k]; 324 // psize and vsize are rounded up to an int boundary for allocation 325 size_t origSize = sizeof(effect_param_t) + 326 ((origParam->psize + 3) & ~3) + 327 ((origParam->vsize + 3) & ~3); 328 effect_param_t *dupParam = (effect_param_t *) malloc(origSize); 329 memcpy(dupParam, origParam, origSize); 330 // This works because the param buffer allocation is also done by 331 // multiples of 4 bytes originally. In theory we should memcpy only 332 // the actual param size, that is without rounding vsize. 333 mParams.add(dupParam); 334 } 335 } 336 /*virtual*/ ~EffectDesc() { 337 free(mName); 338 for (size_t k = 0; k < mParams.size(); k++) { 339 free(mParams[k]); 340 } 341 } 342 char *mName; 343 effect_uuid_t mUuid; 344 Vector <effect_param_t *> mParams; 345 }; 346 347 class InputSourceDesc { 348 public: 349 InputSourceDesc() {} 350 /*virtual*/ ~InputSourceDesc() { 351 for (size_t j = 0; j < mEffects.size(); j++) { 352 delete mEffects[j]; 353 } 354 } 355 Vector <EffectDesc *> mEffects; 356 }; 357 358 359 class InputDesc { 360 public: 361 InputDesc(int session) : mSessionId(session) {} 362 /*virtual*/ ~InputDesc() {} 363 const int mSessionId; 364 Vector< sp<AudioEffect> >mEffects; 365 }; 366 367 class AudioPolicyClient : public AudioPolicyClientInterface 368 { 369 public: 370 AudioPolicyClient(AudioPolicyService *service) : mAudioPolicyService(service) {} 371 virtual ~AudioPolicyClient() {} 372 373 // 374 // Audio HW module functions 375 // 376 377 // loads a HW module. 378 virtual audio_module_handle_t loadHwModule(const char *name); 379 380 // 381 // Audio output Control functions 382 // 383 384 // opens an audio output with the requested parameters. The parameter values can indicate to use the default values 385 // in case the audio policy manager has no specific requirements for the output being opened. 386 // When the function returns, the parameter values reflect the actual values used by the audio hardware output stream. 387 // The audio policy manager can check if the proposed parameters are suitable or not and act accordingly. 388 virtual audio_io_handle_t openOutput(audio_module_handle_t module, 389 audio_devices_t *pDevices, 390 uint32_t *pSamplingRate, 391 audio_format_t *pFormat, 392 audio_channel_mask_t *pChannelMask, 393 uint32_t *pLatencyMs, 394 audio_output_flags_t flags, 395 const audio_offload_info_t *offloadInfo = NULL); 396 // creates a special output that is duplicated to the two outputs passed as arguments. The duplication is performed by 397 // a special mixer thread in the AudioFlinger. 398 virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1, audio_io_handle_t output2); 399 // closes the output stream 400 virtual status_t closeOutput(audio_io_handle_t output); 401 // suspends the output. When an output is suspended, the corresponding audio hardware output stream is placed in 402 // standby and the AudioTracks attached to the mixer thread are still processed but the output mix is discarded. 403 virtual status_t suspendOutput(audio_io_handle_t output); 404 // restores a suspended output. 405 virtual status_t restoreOutput(audio_io_handle_t output); 406 407 // 408 // Audio input Control functions 409 // 410 411 // opens an audio input 412 virtual audio_io_handle_t openInput(audio_module_handle_t module, 413 audio_devices_t *pDevices, 414 uint32_t *pSamplingRate, 415 audio_format_t *pFormat, 416 audio_channel_mask_t *pChannelMask); 417 // closes an audio input 418 virtual status_t closeInput(audio_io_handle_t input); 419 // 420 // misc control functions 421 // 422 423 // set a stream volume for a particular output. For the same user setting, a given stream type can have different volumes 424 // for each output (destination device) it is attached to. 425 virtual status_t setStreamVolume(audio_stream_type_t stream, float volume, audio_io_handle_t output, int delayMs = 0); 426 427 // invalidate a stream type, causing a reroute to an unspecified new output 428 virtual status_t invalidateStream(audio_stream_type_t stream); 429 430 // function enabling to send proprietary informations directly from audio policy manager to audio hardware interface. 431 virtual void setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs, int delayMs = 0); 432 // function enabling to receive proprietary informations directly from audio hardware interface to audio policy manager. 433 virtual String8 getParameters(audio_io_handle_t ioHandle, const String8& keys); 434 435 // request the playback of a tone on the specified stream: used for instance to replace notification sounds when playing 436 // over a telephony device during a phone call. 437 virtual status_t startTone(audio_policy_tone_t tone, audio_stream_type_t stream); 438 virtual status_t stopTone(); 439 440 // set down link audio volume. 441 virtual status_t setVoiceVolume(float volume, int delayMs = 0); 442 443 // move effect to the specified output 444 virtual status_t moveEffects(int session, 445 audio_io_handle_t srcOutput, 446 audio_io_handle_t dstOutput); 447 448 /* Create a patch between several source and sink ports */ 449 virtual status_t createAudioPatch(const struct audio_patch *patch, 450 audio_patch_handle_t *handle, 451 int delayMs); 452 453 /* Release a patch */ 454 virtual status_t releaseAudioPatch(audio_patch_handle_t handle, 455 int delayMs); 456 457 private: 458 AudioPolicyService *mAudioPolicyService; 459 }; 460 461 static const char * const kInputSourceNames[AUDIO_SOURCE_CNT -1]; 462 463 void setPreProcessorEnabled(const InputDesc *inputDesc, bool enabled); 464 status_t loadPreProcessorConfig(const char *path); 465 status_t loadEffects(cnode *root, Vector <EffectDesc *>& effects); 466 EffectDesc *loadEffect(cnode *root); 467 status_t loadInputSources(cnode *root, const Vector <EffectDesc *>& effects); 468 audio_source_t inputSourceNameToEnum(const char *name); 469 InputSourceDesc *loadInputSource(cnode *root, const Vector <EffectDesc *>& effects); 470 void loadEffectParameters(cnode *root, Vector <effect_param_t *>& params); 471 effect_param_t *loadEffectParameter(cnode *root); 472 size_t readParamValue(cnode *node, 473 char *param, 474 size_t *curSize, 475 size_t *totSize); 476 size_t growParamSize(char *param, 477 size_t size, 478 size_t *curSize, 479 size_t *totSize); 480 481 // Internal dump utilities. 482 status_t dumpPermissionDenial(int fd); 483 484 485 mutable Mutex mLock; // prevents concurrent access to AudioPolicy manager functions changing 486 // device connection state or routing 487 sp<AudioCommandThread> mAudioCommandThread; // audio commands thread 488 sp<AudioCommandThread> mTonePlaybackThread; // tone playback thread 489 sp<AudioCommandThread> mOutputCommandThread; // process stop and release output 490 struct audio_policy_device *mpAudioPolicyDev; 491 struct audio_policy *mpAudioPolicy; 492 AudioPolicyManager *mAudioPolicyManager; 493 AudioPolicyClient *mAudioPolicyClient; 494 495 KeyedVector< audio_source_t, InputSourceDesc* > mInputSources; 496 KeyedVector< audio_io_handle_t, InputDesc* > mInputs; 497}; 498 499}; // namespace android 500 501#endif // ANDROID_AUDIOPOLICYSERVICE_H 502