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