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