AudioPolicyService.h revision b52c152d553556b2d227ffc943489de0c60b4b02
1d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro/* 2d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro * Copyright (C) 2009 The Android Open Source Project 3d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro * 4d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro * Licensed under the Apache License, Version 2.0 (the "License"); 5d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro * you may not use this file except in compliance with the License. 6d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro * You may obtain a copy of the License at 7d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro * 8d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro * http://www.apache.org/licenses/LICENSE-2.0 9d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro * 10d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro * Unless required by applicable law or agreed to in writing, software 11d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro * distributed under the License is distributed on an "AS IS" BASIS, 12d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro * See the License for the specific language governing permissions and 14d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro * limitations under the License. 15d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro */ 16d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro 17d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro#ifndef ANDROID_AUDIOPOLICYSERVICE_H 18d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro#define ANDROID_AUDIOPOLICYSERVICE_H 19d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro 20d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro#include <cutils/misc.h> 21d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro#include <cutils/config_utils.h> 22d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro#include <cutils/compiler.h> 23d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro#include <utils/String8.h> 24d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro#include <utils/Vector.h> 25d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro#include <utils/SortedVector.h> 26d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro#include <binder/BinderService.h> 27d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro#include <system/audio.h> 28d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro#include <system/audio_policy.h> 29d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro#include <hardware/audio_policy.h> 30d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro#include <media/IAudioPolicyService.h> 31d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro#include <media/ToneGenerator.h> 32d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro#include <media/AudioEffect.h> 33d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro#include <hardware_legacy/AudioPolicyInterface.h> 34d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro#include "AudioPolicyManager.h" 35d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro 36d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoronamespace android { 37d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro 38d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro// ---------------------------------------------------------------------------- 39d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro 40d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoroclass AudioPolicyService : 41d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro public BinderService<AudioPolicyService>, 422e07adb85194abf5b1264aad95b421558f41a5baDave Santoro public BnAudioPolicyService, 432e07adb85194abf5b1264aad95b421558f41a5baDave Santoro public IBinder::DeathRecipient 442e07adb85194abf5b1264aad95b421558f41a5baDave Santoro{ 452e07adb85194abf5b1264aad95b421558f41a5baDave Santoro friend class BinderService<AudioPolicyService>; 462e07adb85194abf5b1264aad95b421558f41a5baDave Santoro 472e07adb85194abf5b1264aad95b421558f41a5baDave Santoropublic: 482e07adb85194abf5b1264aad95b421558f41a5baDave Santoro // for BinderService 49d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro static const char *getServiceName() ANDROID_API { return "media.audio_policy"; } 50d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro 51d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro virtual status_t dump(int fd, const Vector<String16>& args); 52d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro 53d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro // 54d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro // BnAudioPolicyService (see AudioPolicyInterface for method descriptions) 55d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro // 56d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro 57d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro virtual status_t setDeviceConnectionState(audio_devices_t device, 58d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro audio_policy_dev_state_t state, 59d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro const char *device_address); 60d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro virtual audio_policy_dev_state_t getDeviceConnectionState( 61d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro audio_devices_t device, 62d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro const char *device_address); 63d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro virtual status_t setPhoneState(audio_mode_t state); 64d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro virtual status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config); 65d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage); 66d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro virtual audio_io_handle_t getOutput(audio_stream_type_t stream, 67d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro uint32_t samplingRate = 0, 68d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro audio_format_t format = AUDIO_FORMAT_DEFAULT, 69d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro audio_channel_mask_t channelMask = 0, 70d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro audio_output_flags_t flags = 71d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro AUDIO_OUTPUT_FLAG_NONE, 72d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro const audio_offload_info_t *offloadInfo = NULL); 73d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro virtual status_t startOutput(audio_io_handle_t output, 74d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro audio_stream_type_t stream, 75d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro int session = 0); 76d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro virtual status_t stopOutput(audio_io_handle_t output, 77d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro audio_stream_type_t stream, 78d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro int session = 0); 79d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro virtual void releaseOutput(audio_io_handle_t output); 80d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro virtual audio_io_handle_t getInput(audio_source_t inputSource, 81d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro uint32_t samplingRate = 0, 82d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro audio_format_t format = AUDIO_FORMAT_DEFAULT, 83d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro audio_channel_mask_t channelMask = 0, 84d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro int audioSession = 0); 85d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro virtual status_t startInput(audio_io_handle_t input); 86d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro virtual status_t stopInput(audio_io_handle_t input); 87d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro virtual void releaseInput(audio_io_handle_t input); 88d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro virtual status_t initStreamVolume(audio_stream_type_t stream, 89d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro int indexMin, 90d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro int indexMax); 91d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro virtual status_t setStreamVolumeIndex(audio_stream_type_t stream, 92d2fda1ec4db8d261bf0f5ca6dc43f8c204edbd87Dave Santoro 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 void removeNotificationClient(uid_t uid); 170 void onAudioPortListUpdate(); 171 void doOnAudioPortListUpdate(); 172 void onAudioPatchListUpdate(); 173 void doOnAudioPatchListUpdate(); 174 175private: 176 AudioPolicyService() ANDROID_API; 177 virtual ~AudioPolicyService(); 178 179 status_t dumpInternals(int fd); 180 181 // Thread used for tone playback and to send audio config commands to audio flinger 182 // For tone playback, using a separate thread is necessary to avoid deadlock with mLock because 183 // startTone() and stopTone() are normally called with mLock locked and requesting a tone start 184 // or stop will cause calls to AudioPolicyService and an attempt to lock mLock. 185 // For audio config commands, it is necessary because audio flinger requires that the calling 186 // process (user) has permission to modify audio settings. 187 class AudioCommandThread : public Thread { 188 class AudioCommand; 189 public: 190 191 // commands for tone AudioCommand 192 enum { 193 START_TONE, 194 STOP_TONE, 195 SET_VOLUME, 196 SET_PARAMETERS, 197 SET_VOICE_VOLUME, 198 STOP_OUTPUT, 199 RELEASE_OUTPUT, 200 CREATE_AUDIO_PATCH, 201 RELEASE_AUDIO_PATCH, 202 UPDATE_AUDIOPORT_LIST, 203 UPDATE_AUDIOPATCH_LIST 204 }; 205 206 AudioCommandThread (String8 name, const wp<AudioPolicyService>& service); 207 virtual ~AudioCommandThread(); 208 209 status_t dump(int fd); 210 211 // Thread virtuals 212 virtual void onFirstRef(); 213 virtual bool threadLoop(); 214 215 void exit(); 216 void startToneCommand(ToneGenerator::tone_type type, 217 audio_stream_type_t stream); 218 void stopToneCommand(); 219 status_t volumeCommand(audio_stream_type_t stream, float volume, 220 audio_io_handle_t output, int delayMs = 0); 221 status_t parametersCommand(audio_io_handle_t ioHandle, 222 const char *keyValuePairs, int delayMs = 0); 223 status_t voiceVolumeCommand(float volume, int delayMs = 0); 224 void stopOutputCommand(audio_io_handle_t output, 225 audio_stream_type_t stream, 226 int session); 227 void releaseOutputCommand(audio_io_handle_t output); 228 status_t sendCommand(sp<AudioCommand>& command, int delayMs = 0); 229 void insertCommand_l(sp<AudioCommand>& command, int delayMs = 0); 230 status_t createAudioPatchCommand(const struct audio_patch *patch, 231 audio_patch_handle_t *handle, 232 int delayMs); 233 status_t releaseAudioPatchCommand(audio_patch_handle_t handle, 234 int delayMs); 235 void updateAudioPortListCommand(); 236 void updateAudioPatchListCommand(); 237 238 void insertCommand_l(AudioCommand *command, int delayMs = 0); 239 240 private: 241 class AudioCommandData; 242 243 // descriptor for requested tone playback event 244 class AudioCommand: public RefBase { 245 246 public: 247 AudioCommand() 248 : mCommand(-1), mStatus(NO_ERROR), mWaitStatus(false) {} 249 250 void dump(char* buffer, size_t size); 251 252 int mCommand; // START_TONE, STOP_TONE ... 253 nsecs_t mTime; // time stamp 254 Mutex mLock; // mutex associated to mCond 255 Condition mCond; // condition for status return 256 status_t mStatus; // command status 257 bool mWaitStatus; // true if caller is waiting for status 258 sp<AudioCommandData> mParam; // command specific parameter data 259 }; 260 261 class AudioCommandData: public RefBase { 262 public: 263 virtual ~AudioCommandData() {} 264 protected: 265 AudioCommandData() {} 266 }; 267 268 class ToneData : public AudioCommandData { 269 public: 270 ToneGenerator::tone_type mType; // tone type (START_TONE only) 271 audio_stream_type_t mStream; // stream type (START_TONE only) 272 }; 273 274 class VolumeData : public AudioCommandData { 275 public: 276 audio_stream_type_t mStream; 277 float mVolume; 278 audio_io_handle_t mIO; 279 }; 280 281 class ParametersData : public AudioCommandData { 282 public: 283 audio_io_handle_t mIO; 284 String8 mKeyValuePairs; 285 }; 286 287 class VoiceVolumeData : public AudioCommandData { 288 public: 289 float mVolume; 290 }; 291 292 class StopOutputData : public AudioCommandData { 293 public: 294 audio_io_handle_t mIO; 295 audio_stream_type_t mStream; 296 int mSession; 297 }; 298 299 class ReleaseOutputData : public AudioCommandData { 300 public: 301 audio_io_handle_t mIO; 302 }; 303 304 class CreateAudioPatchData : public AudioCommandData { 305 public: 306 struct audio_patch mPatch; 307 audio_patch_handle_t mHandle; 308 }; 309 310 class ReleaseAudioPatchData : public AudioCommandData { 311 public: 312 audio_patch_handle_t mHandle; 313 }; 314 315 Mutex mLock; 316 Condition mWaitWorkCV; 317 Vector < sp<AudioCommand> > mAudioCommands; // list of pending commands 318 ToneGenerator *mpToneGenerator; // the tone generator 319 sp<AudioCommand> mLastCommand; // last processed command (used by dump) 320 String8 mName; // string used by wake lock fo delayed commands 321 wp<AudioPolicyService> mService; 322 }; 323 324 class EffectDesc { 325 public: 326 EffectDesc(const char *name, const effect_uuid_t& uuid) : 327 mName(strdup(name)), 328 mUuid(uuid) { } 329 EffectDesc(const EffectDesc& orig) : 330 mName(strdup(orig.mName)), 331 mUuid(orig.mUuid) { 332 // deep copy mParams 333 for (size_t k = 0; k < orig.mParams.size(); k++) { 334 effect_param_t *origParam = orig.mParams[k]; 335 // psize and vsize are rounded up to an int boundary for allocation 336 size_t origSize = sizeof(effect_param_t) + 337 ((origParam->psize + 3) & ~3) + 338 ((origParam->vsize + 3) & ~3); 339 effect_param_t *dupParam = (effect_param_t *) malloc(origSize); 340 memcpy(dupParam, origParam, origSize); 341 // This works because the param buffer allocation is also done by 342 // multiples of 4 bytes originally. In theory we should memcpy only 343 // the actual param size, that is without rounding vsize. 344 mParams.add(dupParam); 345 } 346 } 347 /*virtual*/ ~EffectDesc() { 348 free(mName); 349 for (size_t k = 0; k < mParams.size(); k++) { 350 free(mParams[k]); 351 } 352 } 353 char *mName; 354 effect_uuid_t mUuid; 355 Vector <effect_param_t *> mParams; 356 }; 357 358 class InputSourceDesc { 359 public: 360 InputSourceDesc() {} 361 /*virtual*/ ~InputSourceDesc() { 362 for (size_t j = 0; j < mEffects.size(); j++) { 363 delete mEffects[j]; 364 } 365 } 366 Vector <EffectDesc *> mEffects; 367 }; 368 369 370 class InputDesc { 371 public: 372 InputDesc(int session) : mSessionId(session) {} 373 /*virtual*/ ~InputDesc() {} 374 const int mSessionId; 375 Vector< sp<AudioEffect> >mEffects; 376 }; 377 378 class AudioPolicyClient : public AudioPolicyClientInterface 379 { 380 public: 381 AudioPolicyClient(AudioPolicyService *service) : mAudioPolicyService(service) {} 382 virtual ~AudioPolicyClient() {} 383 384 // 385 // Audio HW module functions 386 // 387 388 // loads a HW module. 389 virtual audio_module_handle_t loadHwModule(const char *name); 390 391 // 392 // Audio output Control functions 393 // 394 395 // opens an audio output with the requested parameters. The parameter values can indicate to use the default values 396 // in case the audio policy manager has no specific requirements for the output being opened. 397 // When the function returns, the parameter values reflect the actual values used by the audio hardware output stream. 398 // The audio policy manager can check if the proposed parameters are suitable or not and act accordingly. 399 virtual audio_io_handle_t openOutput(audio_module_handle_t module, 400 audio_devices_t *pDevices, 401 uint32_t *pSamplingRate, 402 audio_format_t *pFormat, 403 audio_channel_mask_t *pChannelMask, 404 uint32_t *pLatencyMs, 405 audio_output_flags_t flags, 406 const audio_offload_info_t *offloadInfo = NULL); 407 // creates a special output that is duplicated to the two outputs passed as arguments. The duplication is performed by 408 // a special mixer thread in the AudioFlinger. 409 virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1, audio_io_handle_t output2); 410 // closes the output stream 411 virtual status_t closeOutput(audio_io_handle_t output); 412 // suspends the output. When an output is suspended, the corresponding audio hardware output stream is placed in 413 // standby and the AudioTracks attached to the mixer thread are still processed but the output mix is discarded. 414 virtual status_t suspendOutput(audio_io_handle_t output); 415 // restores a suspended output. 416 virtual status_t restoreOutput(audio_io_handle_t output); 417 418 // 419 // Audio input Control functions 420 // 421 422 // opens an audio input 423 virtual audio_io_handle_t openInput(audio_module_handle_t module, 424 audio_devices_t *pDevices, 425 uint32_t *pSamplingRate, 426 audio_format_t *pFormat, 427 audio_channel_mask_t *pChannelMask); 428 // closes an audio input 429 virtual status_t closeInput(audio_io_handle_t input); 430 // 431 // misc control functions 432 // 433 434 // set a stream volume for a particular output. For the same user setting, a given stream type can have different volumes 435 // for each output (destination device) it is attached to. 436 virtual status_t setStreamVolume(audio_stream_type_t stream, float volume, audio_io_handle_t output, int delayMs = 0); 437 438 // invalidate a stream type, causing a reroute to an unspecified new output 439 virtual status_t invalidateStream(audio_stream_type_t stream); 440 441 // function enabling to send proprietary informations directly from audio policy manager to audio hardware interface. 442 virtual void setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs, int delayMs = 0); 443 // function enabling to receive proprietary informations directly from audio hardware interface to audio policy manager. 444 virtual String8 getParameters(audio_io_handle_t ioHandle, const String8& keys); 445 446 // request the playback of a tone on the specified stream: used for instance to replace notification sounds when playing 447 // over a telephony device during a phone call. 448 virtual status_t startTone(audio_policy_tone_t tone, audio_stream_type_t stream); 449 virtual status_t stopTone(); 450 451 // set down link audio volume. 452 virtual status_t setVoiceVolume(float volume, int delayMs = 0); 453 454 // move effect to the specified output 455 virtual status_t moveEffects(int session, 456 audio_io_handle_t srcOutput, 457 audio_io_handle_t dstOutput); 458 459 /* Create a patch between several source and sink ports */ 460 virtual status_t createAudioPatch(const struct audio_patch *patch, 461 audio_patch_handle_t *handle, 462 int delayMs); 463 464 /* Release a patch */ 465 virtual status_t releaseAudioPatch(audio_patch_handle_t handle, 466 int delayMs); 467 468 virtual void onAudioPortListUpdate(); 469 virtual void onAudioPatchListUpdate(); 470 471 private: 472 AudioPolicyService *mAudioPolicyService; 473 }; 474 475 // --- Notification Client --- 476 class NotificationClient : public IBinder::DeathRecipient { 477 public: 478 NotificationClient(const sp<AudioPolicyService>& service, 479 const sp<IAudioPolicyServiceClient>& client, 480 uid_t uid); 481 virtual ~NotificationClient(); 482 483 void onAudioPortListUpdate(); 484 void onAudioPatchListUpdate(); 485 486 // IBinder::DeathRecipient 487 virtual void binderDied(const wp<IBinder>& who); 488 489 private: 490 NotificationClient(const NotificationClient&); 491 NotificationClient& operator = (const NotificationClient&); 492 493 const wp<AudioPolicyService> mService; 494 const uid_t mUid; 495 const sp<IAudioPolicyServiceClient> mAudioPolicyServiceClient; 496 }; 497 498 static const char * const kInputSourceNames[AUDIO_SOURCE_CNT -1]; 499 500 void setPreProcessorEnabled(const InputDesc *inputDesc, bool enabled); 501 status_t loadPreProcessorConfig(const char *path); 502 status_t loadEffects(cnode *root, Vector <EffectDesc *>& effects); 503 EffectDesc *loadEffect(cnode *root); 504 status_t loadInputSources(cnode *root, const Vector <EffectDesc *>& effects); 505 audio_source_t inputSourceNameToEnum(const char *name); 506 InputSourceDesc *loadInputSource(cnode *root, const Vector <EffectDesc *>& effects); 507 void loadEffectParameters(cnode *root, Vector <effect_param_t *>& params); 508 effect_param_t *loadEffectParameter(cnode *root); 509 size_t readParamValue(cnode *node, 510 char *param, 511 size_t *curSize, 512 size_t *totSize); 513 size_t growParamSize(char *param, 514 size_t size, 515 size_t *curSize, 516 size_t *totSize); 517 518 // Internal dump utilities. 519 status_t dumpPermissionDenial(int fd); 520 521 522 mutable Mutex mLock; // prevents concurrent access to AudioPolicy manager functions changing 523 // device connection state or routing 524 sp<AudioCommandThread> mAudioCommandThread; // audio commands thread 525 sp<AudioCommandThread> mTonePlaybackThread; // tone playback thread 526 sp<AudioCommandThread> mOutputCommandThread; // process stop and release output 527 struct audio_policy_device *mpAudioPolicyDev; 528 struct audio_policy *mpAudioPolicy; 529 AudioPolicyManager *mAudioPolicyManager; 530 AudioPolicyClient *mAudioPolicyClient; 531 532 KeyedVector< audio_source_t, InputSourceDesc* > mInputSources; 533 KeyedVector< audio_io_handle_t, InputDesc* > mInputs; 534 535 DefaultKeyedVector< uid_t, sp<NotificationClient> > mNotificationClients; 536}; 537 538}; // namespace android 539 540#endif // ANDROID_AUDIOPOLICYSERVICE_H 541