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