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 <binder/IUidObserver.h> 28#include <system/audio.h> 29#include <system/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 "AudioPolicyEffects.h" 35#include "managerdefault/AudioPolicyManager.h" 36 37#include <unordered_map> 38 39namespace android { 40 41using namespace std; 42 43// ---------------------------------------------------------------------------- 44 45class AudioPolicyService : 46 public BinderService<AudioPolicyService>, 47 public BnAudioPolicyService, 48 public IBinder::DeathRecipient 49{ 50 friend class BinderService<AudioPolicyService>; 51 52public: 53 // for BinderService 54 static const char *getServiceName() ANDROID_API { return "media.audio_policy"; } 55 56 virtual status_t dump(int fd, const Vector<String16>& args); 57 58 // 59 // BnAudioPolicyService (see AudioPolicyInterface for method descriptions) 60 // 61 62 virtual status_t setDeviceConnectionState(audio_devices_t device, 63 audio_policy_dev_state_t state, 64 const char *device_address, 65 const char *device_name); 66 virtual audio_policy_dev_state_t getDeviceConnectionState( 67 audio_devices_t device, 68 const char *device_address); 69 virtual status_t handleDeviceConfigChange(audio_devices_t device, 70 const char *device_address, 71 const char *device_name); 72 virtual status_t setPhoneState(audio_mode_t state); 73 virtual status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config); 74 virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage); 75 virtual audio_io_handle_t getOutput(audio_stream_type_t stream); 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 pid_t pid, 81 uid_t uid, 82 const audio_config_t *config, 83 audio_output_flags_t flags, 84 audio_port_handle_t *selectedDeviceId, 85 audio_port_handle_t *portId); 86 virtual status_t startOutput(audio_io_handle_t output, 87 audio_stream_type_t stream, 88 audio_session_t session); 89 virtual status_t stopOutput(audio_io_handle_t output, 90 audio_stream_type_t stream, 91 audio_session_t session); 92 virtual void releaseOutput(audio_io_handle_t output, 93 audio_stream_type_t stream, 94 audio_session_t session); 95 virtual status_t getInputForAttr(const audio_attributes_t *attr, 96 audio_io_handle_t *input, 97 audio_session_t session, 98 pid_t pid, 99 uid_t uid, 100 const String16& opPackageName, 101 const audio_config_base_t *config, 102 audio_input_flags_t flags, 103 audio_port_handle_t *selectedDeviceId = NULL, 104 audio_port_handle_t *portId = NULL); 105 virtual status_t startInput(audio_port_handle_t portId, 106 bool *silenced); 107 virtual status_t stopInput(audio_port_handle_t portId); 108 virtual void releaseInput(audio_port_handle_t portId); 109 virtual status_t initStreamVolume(audio_stream_type_t stream, 110 int indexMin, 111 int indexMax); 112 virtual status_t setStreamVolumeIndex(audio_stream_type_t stream, 113 int index, 114 audio_devices_t device); 115 virtual status_t getStreamVolumeIndex(audio_stream_type_t stream, 116 int *index, 117 audio_devices_t device); 118 119 virtual uint32_t getStrategyForStream(audio_stream_type_t stream); 120 virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream); 121 122 virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc); 123 virtual status_t registerEffect(const effect_descriptor_t *desc, 124 audio_io_handle_t io, 125 uint32_t strategy, 126 audio_session_t session, 127 int id); 128 virtual status_t unregisterEffect(int id); 129 virtual status_t setEffectEnabled(int id, bool enabled); 130 virtual bool isStreamActive(audio_stream_type_t stream, uint32_t inPastMs = 0) const; 131 virtual bool isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs = 0) const; 132 virtual bool isSourceActive(audio_source_t source) const; 133 134 virtual status_t queryDefaultPreProcessing(audio_session_t audioSession, 135 effect_descriptor_t *descriptors, 136 uint32_t *count); 137 virtual status_t onTransact( 138 uint32_t code, 139 const Parcel& data, 140 Parcel* reply, 141 uint32_t flags); 142 143 // IBinder::DeathRecipient 144 virtual void binderDied(const wp<IBinder>& who); 145 146 // RefBase 147 virtual void onFirstRef(); 148 149 // 150 // Helpers for the struct audio_policy_service_ops implementation. 151 // This is used by the audio policy manager for certain operations that 152 // are implemented by the policy service. 153 // 154 virtual void setParameters(audio_io_handle_t ioHandle, 155 const char *keyValuePairs, 156 int delayMs); 157 158 virtual status_t setStreamVolume(audio_stream_type_t stream, 159 float volume, 160 audio_io_handle_t output, 161 int delayMs = 0); 162 virtual status_t startTone(audio_policy_tone_t tone, audio_stream_type_t stream); 163 virtual status_t stopTone(); 164 virtual status_t setVoiceVolume(float volume, int delayMs = 0); 165 virtual bool isOffloadSupported(const audio_offload_info_t &config); 166 167 virtual status_t listAudioPorts(audio_port_role_t role, 168 audio_port_type_t type, 169 unsigned int *num_ports, 170 struct audio_port *ports, 171 unsigned int *generation); 172 virtual status_t getAudioPort(struct audio_port *port); 173 virtual status_t createAudioPatch(const struct audio_patch *patch, 174 audio_patch_handle_t *handle); 175 virtual status_t releaseAudioPatch(audio_patch_handle_t handle); 176 virtual status_t listAudioPatches(unsigned int *num_patches, 177 struct audio_patch *patches, 178 unsigned int *generation); 179 virtual status_t setAudioPortConfig(const struct audio_port_config *config); 180 181 virtual void registerClient(const sp<IAudioPolicyServiceClient>& client); 182 183 virtual void setAudioPortCallbacksEnabled(bool enabled); 184 185 virtual status_t acquireSoundTriggerSession(audio_session_t *session, 186 audio_io_handle_t *ioHandle, 187 audio_devices_t *device); 188 189 virtual status_t releaseSoundTriggerSession(audio_session_t session); 190 191 virtual audio_mode_t getPhoneState(); 192 193 virtual status_t registerPolicyMixes(const Vector<AudioMix>& mixes, bool registration); 194 195 virtual status_t startAudioSource(const struct audio_port_config *source, 196 const audio_attributes_t *attributes, 197 audio_patch_handle_t *handle); 198 virtual status_t stopAudioSource(audio_patch_handle_t handle); 199 200 virtual status_t setMasterMono(bool mono); 201 virtual status_t getMasterMono(bool *mono); 202 203 virtual float getStreamVolumeDB( 204 audio_stream_type_t stream, int index, audio_devices_t device); 205 206 virtual status_t getSurroundFormats(unsigned int *numSurroundFormats, 207 audio_format_t *surroundFormats, 208 bool *surroundFormatsEnabled, 209 bool reported); 210 virtual status_t setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled); 211 212 status_t doStopOutput(audio_io_handle_t output, 213 audio_stream_type_t stream, 214 audio_session_t session); 215 void doReleaseOutput(audio_io_handle_t output, 216 audio_stream_type_t stream, 217 audio_session_t session); 218 219 status_t clientCreateAudioPatch(const struct audio_patch *patch, 220 audio_patch_handle_t *handle, 221 int delayMs); 222 status_t clientReleaseAudioPatch(audio_patch_handle_t handle, 223 int delayMs); 224 virtual status_t clientSetAudioPortConfig(const struct audio_port_config *config, 225 int delayMs); 226 227 void removeNotificationClient(uid_t uid); 228 void onAudioPortListUpdate(); 229 void doOnAudioPortListUpdate(); 230 void onAudioPatchListUpdate(); 231 void doOnAudioPatchListUpdate(); 232 233 void onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state); 234 void doOnDynamicPolicyMixStateUpdate(const String8& regId, int32_t state); 235 void onRecordingConfigurationUpdate(int event, const record_client_info_t *clientInfo, 236 const audio_config_base_t *clientConfig, 237 const audio_config_base_t *deviceConfig, audio_patch_handle_t patchHandle); 238 void doOnRecordingConfigurationUpdate(int event, const record_client_info_t *clientInfo, 239 const audio_config_base_t *clientConfig, 240 const audio_config_base_t *deviceConfig, audio_patch_handle_t patchHandle); 241 242private: 243 AudioPolicyService() ANDROID_API; 244 virtual ~AudioPolicyService(); 245 246 status_t dumpInternals(int fd); 247 248 // Handles binder shell commands 249 virtual status_t shellCommand(int in, int out, int err, Vector<String16>& args); 250 251 // Sets whether the given UID records only silence 252 virtual void setRecordSilenced(uid_t uid, bool silenced); 253 254 // Overrides the UID state as if it is idle 255 status_t handleSetUidState(Vector<String16>& args, int err); 256 257 // Clears the override for the UID state 258 status_t handleResetUidState(Vector<String16>& args, int err); 259 260 // Gets the UID state 261 status_t handleGetUidState(Vector<String16>& args, int out, int err); 262 263 // Prints the shell command help 264 status_t printHelp(int out); 265 266 std::string getDeviceTypeStrForPortId(audio_port_handle_t portId); 267 268 // If recording we need to make sure the UID is allowed to do that. If the UID is idle 269 // then it cannot record and gets buffers with zeros - silence. As soon as the UID 270 // transitions to an active state we will start reporting buffers with data. This approach 271 // transparently handles recording while the UID transitions between idle/active state 272 // avoiding to get stuck in a state receiving non-empty buffers while idle or in a state 273 // receiving empty buffers while active. 274 class UidPolicy : public BnUidObserver, public virtual IBinder::DeathRecipient { 275 public: 276 explicit UidPolicy(wp<AudioPolicyService> service) 277 : mService(service), mObserverRegistered(false) {} 278 279 void registerSelf(); 280 void unregisterSelf(); 281 282 // IBinder::DeathRecipient implementation 283 void binderDied(const wp<IBinder> &who) override; 284 285 bool isUidActive(uid_t uid); 286 287 // BnUidObserver implementation 288 void onUidActive(uid_t uid) override; 289 void onUidGone(uid_t uid, bool disabled) override; 290 void onUidIdle(uid_t uid, bool disabled) override; 291 292 void addOverrideUid(uid_t uid, bool active) { updateOverrideUid(uid, active, true); } 293 void removeOverrideUid(uid_t uid) { updateOverrideUid(uid, false, false); } 294 295 private: 296 bool isServiceUid(uid_t uid) const; 297 void notifyService(uid_t uid, bool active); 298 void updateOverrideUid(uid_t uid, bool active, bool insert); 299 void updateUidCache(uid_t uid, bool active, bool insert); 300 void updateUidLocked(std::unordered_map<uid_t, bool> *uids, 301 uid_t uid, bool active, bool insert, bool *wasThere, bool *wasActive); 302 303 wp<AudioPolicyService> mService; 304 Mutex mLock; 305 bool mObserverRegistered; 306 std::unordered_map<uid_t, bool> mOverrideUids; 307 std::unordered_map<uid_t, bool> mCachedUids; 308 }; 309 310 // Thread used for tone playback and to send audio config commands to audio flinger 311 // For tone playback, using a separate thread is necessary to avoid deadlock with mLock because 312 // startTone() and stopTone() are normally called with mLock locked and requesting a tone start 313 // or stop will cause calls to AudioPolicyService and an attempt to lock mLock. 314 // For audio config commands, it is necessary because audio flinger requires that the calling 315 // process (user) has permission to modify audio settings. 316 class AudioCommandThread : public Thread { 317 class AudioCommand; 318 public: 319 320 // commands for tone AudioCommand 321 enum { 322 START_TONE, 323 STOP_TONE, 324 SET_VOLUME, 325 SET_PARAMETERS, 326 SET_VOICE_VOLUME, 327 STOP_OUTPUT, 328 RELEASE_OUTPUT, 329 CREATE_AUDIO_PATCH, 330 RELEASE_AUDIO_PATCH, 331 UPDATE_AUDIOPORT_LIST, 332 UPDATE_AUDIOPATCH_LIST, 333 SET_AUDIOPORT_CONFIG, 334 DYN_POLICY_MIX_STATE_UPDATE, 335 RECORDING_CONFIGURATION_UPDATE 336 }; 337 338 AudioCommandThread (String8 name, const wp<AudioPolicyService>& service); 339 virtual ~AudioCommandThread(); 340 341 status_t dump(int fd); 342 343 // Thread virtuals 344 virtual void onFirstRef(); 345 virtual bool threadLoop(); 346 347 void exit(); 348 void startToneCommand(ToneGenerator::tone_type type, 349 audio_stream_type_t stream); 350 void stopToneCommand(); 351 status_t volumeCommand(audio_stream_type_t stream, float volume, 352 audio_io_handle_t output, int delayMs = 0); 353 status_t parametersCommand(audio_io_handle_t ioHandle, 354 const char *keyValuePairs, int delayMs = 0); 355 status_t voiceVolumeCommand(float volume, int delayMs = 0); 356 void stopOutputCommand(audio_io_handle_t output, 357 audio_stream_type_t stream, 358 audio_session_t session); 359 void releaseOutputCommand(audio_io_handle_t output, 360 audio_stream_type_t stream, 361 audio_session_t session); 362 status_t sendCommand(sp<AudioCommand>& command, int delayMs = 0); 363 void insertCommand_l(sp<AudioCommand>& command, int delayMs = 0); 364 status_t createAudioPatchCommand(const struct audio_patch *patch, 365 audio_patch_handle_t *handle, 366 int delayMs); 367 status_t releaseAudioPatchCommand(audio_patch_handle_t handle, 368 int delayMs); 369 void updateAudioPortListCommand(); 370 void updateAudioPatchListCommand(); 371 status_t setAudioPortConfigCommand(const struct audio_port_config *config, 372 int delayMs); 373 void dynamicPolicyMixStateUpdateCommand(const String8& regId, int32_t state); 374 void recordingConfigurationUpdateCommand( 375 int event, 376 const record_client_info_t *clientInfo, 377 const audio_config_base_t *clientConfig, 378 const audio_config_base_t *deviceConfig, 379 audio_patch_handle_t patchHandle); 380 void insertCommand_l(AudioCommand *command, int delayMs = 0); 381 private: 382 class AudioCommandData; 383 384 // descriptor for requested tone playback event 385 class AudioCommand: public RefBase { 386 387 public: 388 AudioCommand() 389 : mCommand(-1), mStatus(NO_ERROR), mWaitStatus(false) {} 390 391 void dump(char* buffer, size_t size); 392 393 int mCommand; // START_TONE, STOP_TONE ... 394 nsecs_t mTime; // time stamp 395 Mutex mLock; // mutex associated to mCond 396 Condition mCond; // condition for status return 397 status_t mStatus; // command status 398 bool mWaitStatus; // true if caller is waiting for status 399 sp<AudioCommandData> mParam; // command specific parameter data 400 }; 401 402 class AudioCommandData: public RefBase { 403 public: 404 virtual ~AudioCommandData() {} 405 protected: 406 AudioCommandData() {} 407 }; 408 409 class ToneData : public AudioCommandData { 410 public: 411 ToneGenerator::tone_type mType; // tone type (START_TONE only) 412 audio_stream_type_t mStream; // stream type (START_TONE only) 413 }; 414 415 class VolumeData : public AudioCommandData { 416 public: 417 audio_stream_type_t mStream; 418 float mVolume; 419 audio_io_handle_t mIO; 420 }; 421 422 class ParametersData : public AudioCommandData { 423 public: 424 audio_io_handle_t mIO; 425 String8 mKeyValuePairs; 426 }; 427 428 class VoiceVolumeData : public AudioCommandData { 429 public: 430 float mVolume; 431 }; 432 433 class StopOutputData : public AudioCommandData { 434 public: 435 audio_io_handle_t mIO; 436 audio_stream_type_t mStream; 437 audio_session_t mSession; 438 }; 439 440 class ReleaseOutputData : public AudioCommandData { 441 public: 442 audio_io_handle_t mIO; 443 audio_stream_type_t mStream; 444 audio_session_t mSession; 445 }; 446 447 class CreateAudioPatchData : public AudioCommandData { 448 public: 449 struct audio_patch mPatch; 450 audio_patch_handle_t mHandle; 451 }; 452 453 class ReleaseAudioPatchData : public AudioCommandData { 454 public: 455 audio_patch_handle_t mHandle; 456 }; 457 458 class SetAudioPortConfigData : public AudioCommandData { 459 public: 460 struct audio_port_config mConfig; 461 }; 462 463 class DynPolicyMixStateUpdateData : public AudioCommandData { 464 public: 465 String8 mRegId; 466 int32_t mState; 467 }; 468 469 class RecordingConfigurationUpdateData : public AudioCommandData { 470 public: 471 int mEvent; 472 record_client_info_t mClientInfo; 473 struct audio_config_base mClientConfig; 474 struct audio_config_base mDeviceConfig; 475 audio_patch_handle_t mPatchHandle; 476 }; 477 478 Mutex mLock; 479 Condition mWaitWorkCV; 480 Vector < sp<AudioCommand> > mAudioCommands; // list of pending commands 481 ToneGenerator *mpToneGenerator; // the tone generator 482 sp<AudioCommand> mLastCommand; // last processed command (used by dump) 483 String8 mName; // string used by wake lock fo delayed commands 484 wp<AudioPolicyService> mService; 485 }; 486 487 class AudioPolicyClient : public AudioPolicyClientInterface 488 { 489 public: 490 explicit AudioPolicyClient(AudioPolicyService *service) : mAudioPolicyService(service) {} 491 virtual ~AudioPolicyClient() {} 492 493 // 494 // Audio HW module functions 495 // 496 497 // loads a HW module. 498 virtual audio_module_handle_t loadHwModule(const char *name); 499 500 // 501 // Audio output Control functions 502 // 503 504 // opens an audio output with the requested parameters. The parameter values can indicate to use the default values 505 // in case the audio policy manager has no specific requirements for the output being opened. 506 // When the function returns, the parameter values reflect the actual values used by the audio hardware output stream. 507 // The audio policy manager can check if the proposed parameters are suitable or not and act accordingly. 508 virtual status_t openOutput(audio_module_handle_t module, 509 audio_io_handle_t *output, 510 audio_config_t *config, 511 audio_devices_t *devices, 512 const String8& address, 513 uint32_t *latencyMs, 514 audio_output_flags_t flags); 515 // creates a special output that is duplicated to the two outputs passed as arguments. The duplication is performed by 516 // a special mixer thread in the AudioFlinger. 517 virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1, audio_io_handle_t output2); 518 // closes the output stream 519 virtual status_t closeOutput(audio_io_handle_t output); 520 // suspends the output. When an output is suspended, the corresponding audio hardware output stream is placed in 521 // standby and the AudioTracks attached to the mixer thread are still processed but the output mix is discarded. 522 virtual status_t suspendOutput(audio_io_handle_t output); 523 // restores a suspended output. 524 virtual status_t restoreOutput(audio_io_handle_t output); 525 526 // 527 // Audio input Control functions 528 // 529 530 // opens an audio input 531 virtual audio_io_handle_t openInput(audio_module_handle_t module, 532 audio_io_handle_t *input, 533 audio_config_t *config, 534 audio_devices_t *devices, 535 const String8& address, 536 audio_source_t source, 537 audio_input_flags_t flags); 538 // closes an audio input 539 virtual status_t closeInput(audio_io_handle_t input); 540 // 541 // misc control functions 542 // 543 544 // set a stream volume for a particular output. For the same user setting, a given stream type can have different volumes 545 // for each output (destination device) it is attached to. 546 virtual status_t setStreamVolume(audio_stream_type_t stream, float volume, audio_io_handle_t output, int delayMs = 0); 547 548 // invalidate a stream type, causing a reroute to an unspecified new output 549 virtual status_t invalidateStream(audio_stream_type_t stream); 550 551 // function enabling to send proprietary informations directly from audio policy manager to audio hardware interface. 552 virtual void setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs, int delayMs = 0); 553 // function enabling to receive proprietary informations directly from audio hardware interface to audio policy manager. 554 virtual String8 getParameters(audio_io_handle_t ioHandle, const String8& keys); 555 556 // request the playback of a tone on the specified stream: used for instance to replace notification sounds when playing 557 // over a telephony device during a phone call. 558 virtual status_t startTone(audio_policy_tone_t tone, audio_stream_type_t stream); 559 virtual status_t stopTone(); 560 561 // set down link audio volume. 562 virtual status_t setVoiceVolume(float volume, int delayMs = 0); 563 564 // move effect to the specified output 565 virtual status_t moveEffects(audio_session_t session, 566 audio_io_handle_t srcOutput, 567 audio_io_handle_t dstOutput); 568 569 /* Create a patch between several source and sink ports */ 570 virtual status_t createAudioPatch(const struct audio_patch *patch, 571 audio_patch_handle_t *handle, 572 int delayMs); 573 574 /* Release a patch */ 575 virtual status_t releaseAudioPatch(audio_patch_handle_t handle, 576 int delayMs); 577 578 /* Set audio port configuration */ 579 virtual status_t setAudioPortConfig(const struct audio_port_config *config, int delayMs); 580 581 virtual void onAudioPortListUpdate(); 582 virtual void onAudioPatchListUpdate(); 583 virtual void onDynamicPolicyMixStateUpdate(String8 regId, int32_t state); 584 virtual void onRecordingConfigurationUpdate(int event, 585 const record_client_info_t *clientInfo, 586 const audio_config_base_t *clientConfig, 587 const audio_config_base_t *deviceConfig, audio_patch_handle_t patchHandle); 588 589 virtual audio_unique_id_t newAudioUniqueId(audio_unique_id_use_t use); 590 591 private: 592 AudioPolicyService *mAudioPolicyService; 593 }; 594 595 // --- Notification Client --- 596 class NotificationClient : public IBinder::DeathRecipient { 597 public: 598 NotificationClient(const sp<AudioPolicyService>& service, 599 const sp<IAudioPolicyServiceClient>& client, 600 uid_t uid); 601 virtual ~NotificationClient(); 602 603 void onAudioPortListUpdate(); 604 void onAudioPatchListUpdate(); 605 void onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state); 606 void onRecordingConfigurationUpdate( 607 int event, const record_client_info_t *clientInfo, 608 const audio_config_base_t *clientConfig, 609 const audio_config_base_t *deviceConfig, 610 audio_patch_handle_t patchHandle); 611 void setAudioPortCallbacksEnabled(bool enabled); 612 613 // IBinder::DeathRecipient 614 virtual void binderDied(const wp<IBinder>& who); 615 616 private: 617 NotificationClient(const NotificationClient&); 618 NotificationClient& operator = (const NotificationClient&); 619 620 const wp<AudioPolicyService> mService; 621 const uid_t mUid; 622 const sp<IAudioPolicyServiceClient> mAudioPolicyServiceClient; 623 bool mAudioPortCallbacksEnabled; 624 }; 625 626 // --- AudioRecordClient --- 627 // Information about each registered AudioRecord client 628 // (between calls to getInputForAttr() and releaseInput()) 629 class AudioRecordClient : public RefBase { 630 public: 631 AudioRecordClient(const audio_attributes_t attributes, 632 const audio_io_handle_t input, uid_t uid, pid_t pid, 633 const String16& opPackageName, const audio_session_t session) : 634 attributes(attributes), 635 input(input), uid(uid), pid(pid), 636 opPackageName(opPackageName), session(session), 637 active(false), isConcurrent(false), isVirtualDevice(false) {} 638 virtual ~AudioRecordClient() {} 639 640 const audio_attributes_t attributes; // source, flags ... 641 const audio_io_handle_t input; // audio HAL input IO handle 642 const uid_t uid; // client UID 643 const pid_t pid; // client PID 644 const String16 opPackageName; // client package name 645 const audio_session_t session; // audio session ID 646 bool active; // Capture is active or inactive 647 bool isConcurrent; // is allowed to concurrent capture 648 bool isVirtualDevice; // uses virtual device: updated by APM::getInputForAttr() 649 audio_port_handle_t deviceId; // selected input device port ID 650 }; 651 652 // A class automatically clearing and restoring binder caller identity inside 653 // a code block (scoped variable) 654 // Declare one systematically before calling AudioPolicyManager methods so that they are 655 // executed with the same level of privilege as audioserver process. 656 class AutoCallerClear { 657 public: 658 AutoCallerClear() : 659 mToken(IPCThreadState::self()->clearCallingIdentity()) {} 660 ~AutoCallerClear() { 661 IPCThreadState::self()->restoreCallingIdentity(mToken); 662 } 663 664 private: 665 const int64_t mToken; 666 }; 667 668 // Internal dump utilities. 669 status_t dumpPermissionDenial(int fd); 670 671 672 mutable Mutex mLock; // prevents concurrent access to AudioPolicy manager functions changing 673 // device connection state or routing 674 mutable Mutex mEffectsLock; // serialize access to Effect state within APM. 675 // Note: lock acquisition order is always mLock > mEffectsLock: 676 // mLock protects AudioPolicyManager methods that can call into audio flinger 677 // and possibly back in to audio policy service and acquire mEffectsLock. 678 sp<AudioCommandThread> mAudioCommandThread; // audio commands thread 679 sp<AudioCommandThread> mTonePlaybackThread; // tone playback thread 680 sp<AudioCommandThread> mOutputCommandThread; // process stop and release output 681 struct audio_policy_device *mpAudioPolicyDev; 682 struct audio_policy *mpAudioPolicy; 683 AudioPolicyInterface *mAudioPolicyManager; 684 AudioPolicyClient *mAudioPolicyClient; 685 686 DefaultKeyedVector< uid_t, sp<NotificationClient> > mNotificationClients; 687 Mutex mNotificationClientsLock; // protects mNotificationClients 688 // Manage all effects configured in audio_effects.conf 689 sp<AudioPolicyEffects> mAudioPolicyEffects; 690 audio_mode_t mPhoneState; 691 692 sp<UidPolicy> mUidPolicy; 693 DefaultKeyedVector< audio_port_handle_t, sp<AudioRecordClient> > mAudioRecordClients; 694}; 695 696} // namespace android 697 698#endif // ANDROID_AUDIOPOLICYSERVICE_H 699