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