1 2 /* 3 * Copyright (C) 2009 The Android Open Source Project 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18 #ifndef ANDROID_AUDIOPOLICYSERVICE_H 19 #define ANDROID_AUDIOPOLICYSERVICE_H 20 21 #include <android/media/BnAudioPolicyService.h> 22 #include <android-base/thread_annotations.h> 23 #include <cutils/misc.h> 24 #include <cutils/config_utils.h> 25 #include <cutils/compiler.h> 26 #include <utils/String8.h> 27 #include <utils/Vector.h> 28 #include <utils/SortedVector.h> 29 #include <binder/ActivityManager.h> 30 #include <binder/AppOpsManager.h> 31 #include <binder/BinderService.h> 32 #include <binder/IUidObserver.h> 33 #include <system/audio.h> 34 #include <system/audio_policy.h> 35 #include <media/ToneGenerator.h> 36 #include <media/AudioEffect.h> 37 #include <media/AudioPolicy.h> 38 #include <mediautils/ServiceUtilities.h> 39 #include "AudioPolicyEffects.h" 40 #include "CaptureStateNotifier.h" 41 #include <AudioPolicyInterface.h> 42 #include <android/hardware/BnSensorPrivacyListener.h> 43 #include <android/content/AttributionSourceState.h> 44 45 #include <unordered_map> 46 47 namespace android { 48 49 using content::AttributionSourceState; 50 51 // ---------------------------------------------------------------------------- 52 53 class AudioPolicyService : 54 public BinderService<AudioPolicyService>, 55 public media::BnAudioPolicyService, 56 public IBinder::DeathRecipient 57 { 58 friend class BinderService<AudioPolicyService>; 59 60 public: 61 // for BinderService getServiceName()62 static const char *getServiceName() ANDROID_API { return "media.audio_policy"; } 63 64 virtual status_t dump(int fd, const Vector<String16>& args); 65 66 // 67 // BnAudioPolicyService (see AudioPolicyInterface for method descriptions) 68 // 69 binder::Status onNewAudioModulesAvailable() override; 70 binder::Status setDeviceConnectionState( 71 const media::AudioDevice& device, 72 media::AudioPolicyDeviceState state, 73 const std::string& deviceName, 74 media::audio::common::AudioFormat encodedFormat) override; 75 binder::Status getDeviceConnectionState(const media::AudioDevice& device, 76 media::AudioPolicyDeviceState* _aidl_return) override; 77 binder::Status handleDeviceConfigChange( 78 const media::AudioDevice& device, 79 const std::string& deviceName, 80 media::audio::common::AudioFormat encodedFormat) override; 81 binder::Status setPhoneState(media::AudioMode state, int32_t uid) override; 82 binder::Status setForceUse(media::AudioPolicyForceUse usage, 83 media::AudioPolicyForcedConfig config) override; 84 binder::Status getForceUse(media::AudioPolicyForceUse usage, 85 media::AudioPolicyForcedConfig* _aidl_return) override; 86 binder::Status getOutput(media::AudioStreamType stream, int32_t* _aidl_return) override; 87 binder::Status getOutputForAttr(const media::AudioAttributesInternal& attr, int32_t session, 88 const AttributionSourceState &attributionSource, 89 const media::AudioConfig& config, 90 int32_t flags, int32_t selectedDeviceId, 91 media::GetOutputForAttrResponse* _aidl_return) override; 92 binder::Status startOutput(int32_t portId) override; 93 binder::Status stopOutput(int32_t portId) override; 94 binder::Status releaseOutput(int32_t portId) override; 95 binder::Status getInputForAttr(const media::AudioAttributesInternal& attr, int32_t input, 96 int32_t riid, int32_t session, 97 const AttributionSourceState &attributionSource, 98 const media::AudioConfigBase& config, int32_t flags, 99 int32_t selectedDeviceId, 100 media::GetInputForAttrResponse* _aidl_return) override; 101 binder::Status startInput(int32_t portId) override; 102 binder::Status stopInput(int32_t portId) override; 103 binder::Status releaseInput(int32_t portId) override; 104 binder::Status initStreamVolume(media::AudioStreamType stream, int32_t indexMin, 105 int32_t indexMax) override; 106 binder::Status setStreamVolumeIndex(media::AudioStreamType stream, int32_t device, 107 int32_t index) override; 108 binder::Status getStreamVolumeIndex(media::AudioStreamType stream, int32_t device, 109 int32_t* _aidl_return) override; 110 binder::Status setVolumeIndexForAttributes(const media::AudioAttributesInternal& attr, 111 int32_t device, int32_t index) override; 112 binder::Status getVolumeIndexForAttributes(const media::AudioAttributesInternal& attr, 113 int32_t device, int32_t* _aidl_return) override; 114 binder::Status getMaxVolumeIndexForAttributes(const media::AudioAttributesInternal& attr, 115 int32_t* _aidl_return) override; 116 binder::Status getMinVolumeIndexForAttributes(const media::AudioAttributesInternal& attr, 117 int32_t* _aidl_return) override; 118 binder::Status getStrategyForStream(media::AudioStreamType stream, 119 int32_t* _aidl_return) override; 120 binder::Status getDevicesForStream(media::AudioStreamType stream, 121 int32_t* _aidl_return) override; 122 binder::Status getDevicesForAttributes(const media::AudioAttributesEx& attr, 123 std::vector<media::AudioDevice>* _aidl_return) override; 124 binder::Status getOutputForEffect(const media::EffectDescriptor& desc, 125 int32_t* _aidl_return) override; 126 binder::Status registerEffect(const media::EffectDescriptor& desc, int32_t io, int32_t strategy, 127 int32_t session, int32_t id) override; 128 binder::Status unregisterEffect(int32_t id) override; 129 binder::Status setEffectEnabled(int32_t id, bool enabled) override; 130 binder::Status moveEffectsToIo(const std::vector<int32_t>& ids, int32_t io) override; 131 binder::Status isStreamActive(media::AudioStreamType stream, int32_t inPastMs, 132 bool* _aidl_return) override; 133 binder::Status isStreamActiveRemotely(media::AudioStreamType stream, int32_t inPastMs, 134 bool* _aidl_return) override; 135 binder::Status isSourceActive(media::AudioSourceType source, bool* _aidl_return) override; 136 binder::Status queryDefaultPreProcessing( 137 int32_t audioSession, media::Int* count, 138 std::vector<media::EffectDescriptor>* _aidl_return) override; 139 binder::Status addSourceDefaultEffect(const media::AudioUuid& type, 140 const std::string& opPackageName, 141 const media::AudioUuid& uuid, int32_t priority, 142 media::AudioSourceType source, 143 int32_t* _aidl_return) override; 144 binder::Status addStreamDefaultEffect(const media::AudioUuid& type, 145 const std::string& opPackageName, 146 const media::AudioUuid& uuid, int32_t priority, 147 media::AudioUsage usage, int32_t* _aidl_return) override; 148 binder::Status removeSourceDefaultEffect(int32_t id) override; 149 binder::Status removeStreamDefaultEffect(int32_t id) override; 150 binder::Status setSupportedSystemUsages( 151 const std::vector<media::AudioUsage>& systemUsages) override; 152 binder::Status setAllowedCapturePolicy(int32_t uid, int32_t capturePolicy) override; 153 binder::Status getOffloadSupport(const media::AudioOffloadInfo& info, 154 media::AudioOffloadMode* _aidl_return) override; 155 binder::Status isDirectOutputSupported(const media::AudioConfigBase& config, 156 const media::AudioAttributesInternal& attributes, 157 bool* _aidl_return) override; 158 binder::Status listAudioPorts(media::AudioPortRole role, media::AudioPortType type, 159 media::Int* count, std::vector<media::AudioPort>* ports, 160 int32_t* _aidl_return) override; 161 binder::Status getAudioPort(const media::AudioPort& port, 162 media::AudioPort* _aidl_return) override; 163 binder::Status createAudioPatch(const media::AudioPatch& patch, int32_t handle, 164 int32_t* _aidl_return) override; 165 binder::Status releaseAudioPatch(int32_t handle) override; 166 binder::Status listAudioPatches(media::Int* count, std::vector<media::AudioPatch>* patches, 167 int32_t* _aidl_return) override; 168 binder::Status setAudioPortConfig(const media::AudioPortConfig& config) override; 169 binder::Status registerClient(const sp<media::IAudioPolicyServiceClient>& client) override; 170 binder::Status setAudioPortCallbacksEnabled(bool enabled) override; 171 binder::Status setAudioVolumeGroupCallbacksEnabled(bool enabled) override; 172 binder::Status acquireSoundTriggerSession(media::SoundTriggerSession* _aidl_return) override; 173 binder::Status releaseSoundTriggerSession(int32_t session) override; 174 binder::Status getPhoneState(media::AudioMode* _aidl_return) override; 175 binder::Status registerPolicyMixes(const std::vector<media::AudioMix>& mixes, 176 bool registration) override; 177 binder::Status setUidDeviceAffinities(int32_t uid, 178 const std::vector<media::AudioDevice>& devices) override; 179 binder::Status removeUidDeviceAffinities(int32_t uid) override; 180 binder::Status setUserIdDeviceAffinities( 181 int32_t userId, 182 const std::vector<media::AudioDevice>& devices) override; 183 binder::Status removeUserIdDeviceAffinities(int32_t userId) override; 184 binder::Status startAudioSource(const media::AudioPortConfig& source, 185 const media::AudioAttributesInternal& attributes, 186 int32_t* _aidl_return) override; 187 binder::Status stopAudioSource(int32_t portId) override; 188 binder::Status setMasterMono(bool mono) override; 189 binder::Status getMasterMono(bool* _aidl_return) override; 190 binder::Status getStreamVolumeDB(media::AudioStreamType stream, int32_t index, int32_t device, 191 float* _aidl_return) override; 192 binder::Status getSurroundFormats(media::Int* count, 193 std::vector<media::audio::common::AudioFormat>* formats, 194 std::vector<bool>* formatsEnabled) override; 195 binder::Status getReportedSurroundFormats( 196 media::Int* count, std::vector<media::audio::common::AudioFormat>* formats) override; 197 binder::Status getHwOffloadEncodingFormatsSupportedForA2DP( 198 std::vector<media::audio::common::AudioFormat>* _aidl_return) override; 199 binder::Status setSurroundFormatEnabled(media::audio::common::AudioFormat audioFormat, 200 bool enabled) override; 201 binder::Status setAssistantUid(int32_t uid) override; 202 binder::Status setHotwordDetectionServiceUid(int32_t uid) override; 203 binder::Status setA11yServicesUids(const std::vector<int32_t>& uids) override; 204 binder::Status setCurrentImeUid(int32_t uid) override; 205 binder::Status isHapticPlaybackSupported(bool* _aidl_return) override; 206 binder::Status listAudioProductStrategies( 207 std::vector<media::AudioProductStrategy>* _aidl_return) override; 208 binder::Status getProductStrategyFromAudioAttributes(const media::AudioAttributesEx& aa, 209 bool fallbackOnDefault, 210 int32_t* _aidl_return) override; 211 binder::Status listAudioVolumeGroups( 212 std::vector<media::AudioVolumeGroup>* _aidl_return) override; 213 binder::Status getVolumeGroupFromAudioAttributes(const media::AudioAttributesEx& aa, 214 bool fallbackOnDefault, 215 int32_t* _aidl_return) override; 216 binder::Status setRttEnabled(bool enabled) override; 217 binder::Status isCallScreenModeSupported(bool* _aidl_return) override; 218 binder::Status setDevicesRoleForStrategy( 219 int32_t strategy, media::DeviceRole role, 220 const std::vector<media::AudioDevice>& devices) override; 221 binder::Status removeDevicesRoleForStrategy(int32_t strategy, media::DeviceRole role) override; 222 binder::Status getDevicesForRoleAndStrategy( 223 int32_t strategy, media::DeviceRole role, 224 std::vector<media::AudioDevice>* _aidl_return) override; 225 binder::Status setDevicesRoleForCapturePreset( 226 media::AudioSourceType audioSource, 227 media::DeviceRole role, 228 const std::vector<media::AudioDevice>& devices) override; 229 binder::Status addDevicesRoleForCapturePreset( 230 media::AudioSourceType audioSource, 231 media::DeviceRole role, 232 const std::vector<media::AudioDevice>& devices) override; 233 binder::Status removeDevicesRoleForCapturePreset( 234 media::AudioSourceType audioSource, 235 media::DeviceRole role, 236 const std::vector<media::AudioDevice>& devices) override; 237 binder::Status clearDevicesRoleForCapturePreset(media::AudioSourceType audioSource, 238 media::DeviceRole role) override; 239 binder::Status getDevicesForRoleAndCapturePreset( 240 media::AudioSourceType audioSource, 241 media::DeviceRole role, 242 std::vector<media::AudioDevice>* _aidl_return) override; 243 binder::Status registerSoundTriggerCaptureStateListener( 244 const sp<media::ICaptureStateListener>& listener, bool* _aidl_return) override; 245 246 virtual status_t onTransact( 247 uint32_t code, 248 const Parcel& data, 249 Parcel* reply, 250 uint32_t flags); 251 252 // IBinder::DeathRecipient 253 virtual void binderDied(const wp<IBinder>& who); 254 255 // RefBase 256 virtual void onFirstRef(); 257 258 // 259 // Helpers for the struct audio_policy_service_ops implementation. 260 // This is used by the audio policy manager for certain operations that 261 // are implemented by the policy service. 262 // 263 virtual void setParameters(audio_io_handle_t ioHandle, 264 const char *keyValuePairs, 265 int delayMs); 266 267 virtual status_t setStreamVolume(audio_stream_type_t stream, 268 float volume, 269 audio_io_handle_t output, 270 int delayMs = 0); 271 virtual status_t setVoiceVolume(float volume, int delayMs = 0); 272 273 void doOnNewAudioModulesAvailable(); 274 status_t doStopOutput(audio_port_handle_t portId); 275 void doReleaseOutput(audio_port_handle_t portId); 276 277 status_t clientCreateAudioPatch(const struct audio_patch *patch, 278 audio_patch_handle_t *handle, 279 int delayMs); 280 status_t clientReleaseAudioPatch(audio_patch_handle_t handle, 281 int delayMs); 282 virtual status_t clientSetAudioPortConfig(const struct audio_port_config *config, 283 int delayMs); 284 285 void removeNotificationClient(uid_t uid, pid_t pid); 286 void onAudioPortListUpdate(); 287 void doOnAudioPortListUpdate(); 288 void onAudioPatchListUpdate(); 289 void doOnAudioPatchListUpdate(); 290 291 void onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state); 292 void doOnDynamicPolicyMixStateUpdate(const String8& regId, int32_t state); 293 void onRecordingConfigurationUpdate(int event, 294 const record_client_info_t *clientInfo, 295 const audio_config_base_t *clientConfig, 296 std::vector<effect_descriptor_t> clientEffects, 297 const audio_config_base_t *deviceConfig, 298 std::vector<effect_descriptor_t> effects, 299 audio_patch_handle_t patchHandle, 300 audio_source_t source); 301 void doOnRecordingConfigurationUpdate(int event, 302 const record_client_info_t *clientInfo, 303 const audio_config_base_t *clientConfig, 304 std::vector<effect_descriptor_t> clientEffects, 305 const audio_config_base_t *deviceConfig, 306 std::vector<effect_descriptor_t> effects, 307 audio_patch_handle_t patchHandle, 308 audio_source_t source); 309 310 void onAudioVolumeGroupChanged(volume_group_t group, int flags); 311 void doOnAudioVolumeGroupChanged(volume_group_t group, int flags); 312 313 void onRoutingUpdated(); 314 void doOnRoutingUpdated(); 315 316 void setEffectSuspended(int effectId, 317 audio_session_t sessionId, 318 bool suspended); 319 320 private: 321 AudioPolicyService() ANDROID_API; 322 virtual ~AudioPolicyService(); 323 324 status_t dumpInternals(int fd) REQUIRES(mLock); 325 326 // Handles binder shell commands 327 virtual status_t shellCommand(int in, int out, int err, Vector<String16>& args); 328 329 class AudioRecordClient; 330 331 // Sets whether the given UID records only silence 332 virtual void setAppState_l(sp<AudioRecordClient> client, app_state_t state) REQUIRES(mLock); 333 334 // Overrides the UID state as if it is idle 335 status_t handleSetUidState(Vector<String16>& args, int err); 336 337 // Clears the override for the UID state 338 status_t handleResetUidState(Vector<String16>& args, int err); 339 340 // Gets the UID state 341 status_t handleGetUidState(Vector<String16>& args, int out, int err); 342 343 // Prints the shell command help 344 status_t printHelp(int out); 345 346 std::string getDeviceTypeStrForPortId(audio_port_handle_t portId); 347 348 status_t getAudioPolicyEffects(sp<AudioPolicyEffects>& audioPolicyEffects); 349 350 app_state_t apmStatFromAmState(int amState); 351 352 bool isSupportedSystemUsage(audio_usage_t usage); 353 status_t validateUsage(audio_usage_t usage); 354 status_t validateUsage(audio_usage_t usage, const AttributionSourceState& attributionSource); 355 356 void updateUidStates(); 357 void updateUidStates_l() REQUIRES(mLock); 358 359 void silenceAllRecordings_l() REQUIRES(mLock); 360 361 static bool isVirtualSource(audio_source_t source); 362 363 /** returns true if the audio source must be silenced when the corresponding app op is denied. 364 * false if the audio source does not actually capture from the microphone while still 365 * being mapped to app op OP_RECORD_AUDIO and not a specialized op tracked separately. 366 * See getOpForSource(). 367 */ 368 static bool isAppOpSource(audio_source_t source); 369 370 // If recording we need to make sure the UID is allowed to do that. If the UID is idle 371 // then it cannot record and gets buffers with zeros - silence. As soon as the UID 372 // transitions to an active state we will start reporting buffers with data. This approach 373 // transparently handles recording while the UID transitions between idle/active state 374 // avoiding to get stuck in a state receiving non-empty buffers while idle or in a state 375 // receiving empty buffers while active. 376 class UidPolicy : public BnUidObserver, public virtual IBinder::DeathRecipient { 377 public: UidPolicy(wp<AudioPolicyService> service)378 explicit UidPolicy(wp<AudioPolicyService> service) 379 : mService(service), mObserverRegistered(false), 380 mAssistantUid(0), mHotwordDetectionServiceUid(0), mCurrentImeUid(0), 381 mRttEnabled(false) {} 382 383 void registerSelf(); 384 void unregisterSelf(); 385 386 // IBinder::DeathRecipient implementation 387 void binderDied(const wp<IBinder> &who) override; 388 389 bool isUidActive(uid_t uid); 390 int getUidState(uid_t uid); setAssistantUid(uid_t uid)391 void setAssistantUid(uid_t uid) { mAssistantUid = uid; }; setHotwordDetectionServiceUid(uid_t uid)392 void setHotwordDetectionServiceUid(uid_t uid) { mHotwordDetectionServiceUid = uid; } isAssistantUid(uid_t uid)393 bool isAssistantUid(uid_t uid) const { 394 // The HotwordDetectionService is part of the Assistant package but runs with a separate 395 // (isolated) uid, so we check for either uid here. 396 return uid == mAssistantUid || uid == mHotwordDetectionServiceUid; 397 } setA11yUids(const std::vector<uid_t> & uids)398 void setA11yUids(const std::vector<uid_t>& uids) { mA11yUids.clear(); mA11yUids = uids; } 399 bool isA11yUid(uid_t uid); 400 bool isA11yOnTop(); setCurrentImeUid(uid_t uid)401 void setCurrentImeUid(uid_t uid) { mCurrentImeUid = uid; } isCurrentImeUid(uid_t uid)402 bool isCurrentImeUid(uid_t uid) { return uid == mCurrentImeUid; } setRttEnabled(bool enabled)403 void setRttEnabled(bool enabled) { mRttEnabled = enabled; } isRttEnabled()404 bool isRttEnabled() { return mRttEnabled; } 405 406 // BnUidObserver implementation 407 void onUidActive(uid_t uid) override; 408 void onUidGone(uid_t uid, bool disabled) override; 409 void onUidIdle(uid_t uid, bool disabled) override; 410 void onUidStateChanged(uid_t uid, int32_t procState, int64_t procStateSeq, 411 int32_t capability); 412 addOverrideUid(uid_t uid,bool active)413 void addOverrideUid(uid_t uid, bool active) { updateOverrideUid(uid, active, true); } removeOverrideUid(uid_t uid)414 void removeOverrideUid(uid_t uid) { updateOverrideUid(uid, false, false); } 415 416 void updateUid(std::unordered_map<uid_t, std::pair<bool, int>> *uids, 417 uid_t uid, bool active, int state, bool insert); 418 419 private: 420 void notifyService(); 421 void updateOverrideUid(uid_t uid, bool active, bool insert); 422 void updateUidLocked(std::unordered_map<uid_t, std::pair<bool, int>> *uids, 423 uid_t uid, bool active, int state, bool insert); 424 void checkRegistered(); 425 426 wp<AudioPolicyService> mService; 427 Mutex mLock; 428 ActivityManager mAm; 429 bool mObserverRegistered = false; 430 std::unordered_map<uid_t, std::pair<bool, int>> mOverrideUids; 431 std::unordered_map<uid_t, std::pair<bool, int>> mCachedUids; 432 uid_t mAssistantUid = -1; 433 uid_t mHotwordDetectionServiceUid = -1; 434 std::vector<uid_t> mA11yUids; 435 uid_t mCurrentImeUid = -1; 436 bool mRttEnabled = false; 437 }; 438 439 // If sensor privacy is enabled then all apps, including those that are active, should be 440 // prevented from recording. This is handled similar to idle UIDs, any app that attempts 441 // to record while sensor privacy is enabled will receive buffers with zeros. As soon as 442 // sensor privacy is disabled active apps will receive the expected data when recording. 443 class SensorPrivacyPolicy : public hardware::BnSensorPrivacyListener { 444 public: SensorPrivacyPolicy(wp<AudioPolicyService> service)445 explicit SensorPrivacyPolicy(wp<AudioPolicyService> service) 446 : mService(service) {} 447 448 void registerSelf(); 449 void registerSelfForMicrophoneOnly(int userId); 450 void unregisterSelf(); 451 452 bool isSensorPrivacyEnabled(); 453 454 binder::Status onSensorPrivacyChanged(bool enabled); 455 456 private: 457 wp<AudioPolicyService> mService; 458 std::atomic_bool mSensorPrivacyEnabled = false; 459 }; 460 461 // Thread used to send audio config commands to audio flinger 462 // For audio config commands, it is necessary because audio flinger requires that the calling 463 // process (user) has permission to modify audio settings. 464 class AudioCommandThread : public Thread { 465 class AudioCommand; 466 public: 467 468 // commands for tone AudioCommand 469 enum { 470 SET_VOLUME, 471 SET_PARAMETERS, 472 SET_VOICE_VOLUME, 473 STOP_OUTPUT, 474 RELEASE_OUTPUT, 475 CREATE_AUDIO_PATCH, 476 RELEASE_AUDIO_PATCH, 477 UPDATE_AUDIOPORT_LIST, 478 UPDATE_AUDIOPATCH_LIST, 479 CHANGED_AUDIOVOLUMEGROUP, 480 SET_AUDIOPORT_CONFIG, 481 DYN_POLICY_MIX_STATE_UPDATE, 482 RECORDING_CONFIGURATION_UPDATE, 483 SET_EFFECT_SUSPENDED, 484 AUDIO_MODULES_UPDATE, 485 ROUTING_UPDATED, 486 UPDATE_UID_STATES 487 }; 488 489 AudioCommandThread (String8 name, const wp<AudioPolicyService>& service); 490 virtual ~AudioCommandThread(); 491 492 status_t dump(int fd); 493 494 // Thread virtuals 495 virtual void onFirstRef(); 496 virtual bool threadLoop(); 497 498 void exit(); 499 status_t volumeCommand(audio_stream_type_t stream, float volume, 500 audio_io_handle_t output, int delayMs = 0); 501 status_t parametersCommand(audio_io_handle_t ioHandle, 502 const char *keyValuePairs, int delayMs = 0); 503 status_t voiceVolumeCommand(float volume, int delayMs = 0); 504 void stopOutputCommand(audio_port_handle_t portId); 505 void releaseOutputCommand(audio_port_handle_t portId); 506 status_t sendCommand(sp<AudioCommand>& command, int delayMs = 0); 507 void insertCommand_l(sp<AudioCommand>& command, int delayMs = 0); 508 status_t createAudioPatchCommand(const struct audio_patch *patch, 509 audio_patch_handle_t *handle, 510 int delayMs); 511 status_t releaseAudioPatchCommand(audio_patch_handle_t handle, 512 int delayMs); 513 void updateAudioPortListCommand(); 514 void updateAudioPatchListCommand(); 515 void changeAudioVolumeGroupCommand(volume_group_t group, int flags); 516 status_t setAudioPortConfigCommand(const struct audio_port_config *config, 517 int delayMs); 518 void dynamicPolicyMixStateUpdateCommand(const String8& regId, 519 int32_t state); 520 void recordingConfigurationUpdateCommand( 521 int event, 522 const record_client_info_t *clientInfo, 523 const audio_config_base_t *clientConfig, 524 std::vector<effect_descriptor_t> clientEffects, 525 const audio_config_base_t *deviceConfig, 526 std::vector<effect_descriptor_t> effects, 527 audio_patch_handle_t patchHandle, 528 audio_source_t source); 529 void setEffectSuspendedCommand(int effectId, 530 audio_session_t sessionId, 531 bool suspended); 532 void audioModulesUpdateCommand(); 533 void routingChangedCommand(); 534 void updateUidStatesCommand(); 535 void insertCommand_l(AudioCommand *command, int delayMs = 0); 536 private: 537 class AudioCommandData; 538 539 // descriptor for requested tone playback event 540 class AudioCommand: public RefBase { 541 542 public: AudioCommand()543 AudioCommand() 544 : mCommand(-1), mStatus(NO_ERROR), mWaitStatus(false) {} 545 546 void dump(char* buffer, size_t size); 547 548 int mCommand; // SET_VOLUME, SET_PARAMETERS... 549 nsecs_t mTime; // time stamp 550 Mutex mLock; // mutex associated to mCond 551 Condition mCond; // condition for status return 552 status_t mStatus; // command status 553 bool mWaitStatus; // true if caller is waiting for status 554 sp<AudioCommandData> mParam; // command specific parameter data 555 }; 556 557 class AudioCommandData: public RefBase { 558 public: ~AudioCommandData()559 virtual ~AudioCommandData() {} 560 protected: AudioCommandData()561 AudioCommandData() {} 562 }; 563 564 class VolumeData : public AudioCommandData { 565 public: 566 audio_stream_type_t mStream; 567 float mVolume; 568 audio_io_handle_t mIO; 569 }; 570 571 class ParametersData : public AudioCommandData { 572 public: 573 audio_io_handle_t mIO; 574 String8 mKeyValuePairs; 575 }; 576 577 class VoiceVolumeData : public AudioCommandData { 578 public: 579 float mVolume; 580 }; 581 582 class StopOutputData : public AudioCommandData { 583 public: 584 audio_port_handle_t mPortId; 585 }; 586 587 class ReleaseOutputData : public AudioCommandData { 588 public: 589 audio_port_handle_t mPortId; 590 }; 591 592 class CreateAudioPatchData : public AudioCommandData { 593 public: 594 struct audio_patch mPatch; 595 audio_patch_handle_t mHandle; 596 }; 597 598 class ReleaseAudioPatchData : public AudioCommandData { 599 public: 600 audio_patch_handle_t mHandle; 601 }; 602 603 class AudioVolumeGroupData : public AudioCommandData { 604 public: 605 volume_group_t mGroup; 606 int mFlags; 607 }; 608 609 class SetAudioPortConfigData : public AudioCommandData { 610 public: 611 struct audio_port_config mConfig; 612 }; 613 614 class DynPolicyMixStateUpdateData : public AudioCommandData { 615 public: 616 String8 mRegId; 617 int32_t mState; 618 }; 619 620 class RecordingConfigurationUpdateData : public AudioCommandData { 621 public: 622 int mEvent; 623 record_client_info_t mClientInfo; 624 struct audio_config_base mClientConfig; 625 std::vector<effect_descriptor_t> mClientEffects; 626 struct audio_config_base mDeviceConfig; 627 std::vector<effect_descriptor_t> mEffects; 628 audio_patch_handle_t mPatchHandle; 629 audio_source_t mSource; 630 }; 631 632 class SetEffectSuspendedData : public AudioCommandData { 633 public: 634 int mEffectId; 635 audio_session_t mSessionId; 636 bool mSuspended; 637 }; 638 639 Mutex mLock; 640 Condition mWaitWorkCV; 641 Vector < sp<AudioCommand> > mAudioCommands; // list of pending commands 642 sp<AudioCommand> mLastCommand; // last processed command (used by dump) 643 String8 mName; // string used by wake lock fo delayed commands 644 wp<AudioPolicyService> mService; 645 }; 646 647 class AudioPolicyClient : public AudioPolicyClientInterface 648 { 649 public: AudioPolicyClient(AudioPolicyService * service)650 explicit AudioPolicyClient(AudioPolicyService *service) : mAudioPolicyService(service) {} ~AudioPolicyClient()651 virtual ~AudioPolicyClient() {} 652 653 // 654 // Audio HW module functions 655 // 656 657 // loads a HW module. 658 virtual audio_module_handle_t loadHwModule(const char *name); 659 660 // 661 // Audio output Control functions 662 // 663 664 // opens an audio output with the requested parameters. The parameter values can indicate to use the default values 665 // in case the audio policy manager has no specific requirements for the output being opened. 666 // When the function returns, the parameter values reflect the actual values used by the audio hardware output stream. 667 // The audio policy manager can check if the proposed parameters are suitable or not and act accordingly. 668 virtual status_t openOutput(audio_module_handle_t module, 669 audio_io_handle_t *output, 670 audio_config_t *config, 671 const sp<DeviceDescriptorBase>& device, 672 uint32_t *latencyMs, 673 audio_output_flags_t flags); 674 // creates a special output that is duplicated to the two outputs passed as arguments. The duplication is performed by 675 // a special mixer thread in the AudioFlinger. 676 virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1, audio_io_handle_t output2); 677 // closes the output stream 678 virtual status_t closeOutput(audio_io_handle_t output); 679 // suspends the output. When an output is suspended, the corresponding audio hardware output stream is placed in 680 // standby and the AudioTracks attached to the mixer thread are still processed but the output mix is discarded. 681 virtual status_t suspendOutput(audio_io_handle_t output); 682 // restores a suspended output. 683 virtual status_t restoreOutput(audio_io_handle_t output); 684 685 // 686 // Audio input Control functions 687 // 688 689 // opens an audio input 690 virtual audio_io_handle_t openInput(audio_module_handle_t module, 691 audio_io_handle_t *input, 692 audio_config_t *config, 693 audio_devices_t *devices, 694 const String8& address, 695 audio_source_t source, 696 audio_input_flags_t flags); 697 // closes an audio input 698 virtual status_t closeInput(audio_io_handle_t input); 699 // 700 // misc control functions 701 // 702 703 // set a stream volume for a particular output. For the same user setting, a given stream type can have different volumes 704 // for each output (destination device) it is attached to. 705 virtual status_t setStreamVolume(audio_stream_type_t stream, float volume, audio_io_handle_t output, int delayMs = 0); 706 707 // invalidate a stream type, causing a reroute to an unspecified new output 708 virtual status_t invalidateStream(audio_stream_type_t stream); 709 710 // function enabling to send proprietary informations directly from audio policy manager to audio hardware interface. 711 virtual void setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs, int delayMs = 0); 712 // function enabling to receive proprietary informations directly from audio hardware interface to audio policy manager. 713 virtual String8 getParameters(audio_io_handle_t ioHandle, const String8& keys); 714 715 // set down link audio volume. 716 virtual status_t setVoiceVolume(float volume, int delayMs = 0); 717 718 // move effect to the specified output 719 virtual status_t moveEffects(audio_session_t session, 720 audio_io_handle_t srcOutput, 721 audio_io_handle_t dstOutput); 722 723 void setEffectSuspended(int effectId, 724 audio_session_t sessionId, 725 bool suspended) override; 726 727 /* Create a patch between several source and sink ports */ 728 virtual status_t createAudioPatch(const struct audio_patch *patch, 729 audio_patch_handle_t *handle, 730 int delayMs); 731 732 /* Release a patch */ 733 virtual status_t releaseAudioPatch(audio_patch_handle_t handle, 734 int delayMs); 735 736 /* Set audio port configuration */ 737 virtual status_t setAudioPortConfig(const struct audio_port_config *config, int delayMs); 738 739 virtual void onAudioPortListUpdate(); 740 virtual void onAudioPatchListUpdate(); 741 virtual void onDynamicPolicyMixStateUpdate(String8 regId, int32_t state); 742 virtual void onRecordingConfigurationUpdate(int event, 743 const record_client_info_t *clientInfo, 744 const audio_config_base_t *clientConfig, 745 std::vector<effect_descriptor_t> clientEffects, 746 const audio_config_base_t *deviceConfig, 747 std::vector<effect_descriptor_t> effects, 748 audio_patch_handle_t patchHandle, 749 audio_source_t source); 750 751 virtual void onAudioVolumeGroupChanged(volume_group_t group, int flags); 752 753 virtual void onRoutingUpdated(); 754 755 virtual audio_unique_id_t newAudioUniqueId(audio_unique_id_use_t use); 756 757 void setSoundTriggerCaptureState(bool active) override; 758 759 status_t getAudioPort(struct audio_port_v7 *port) override; 760 761 status_t updateSecondaryOutputs( 762 const TrackSecondaryOutputsMap& trackSecondaryOutputs) override; 763 764 private: 765 AudioPolicyService *mAudioPolicyService; 766 }; 767 768 // --- Notification Client --- 769 class NotificationClient : public IBinder::DeathRecipient { 770 public: 771 NotificationClient(const sp<AudioPolicyService>& service, 772 const sp<media::IAudioPolicyServiceClient>& client, 773 uid_t uid, pid_t pid); 774 virtual ~NotificationClient(); 775 776 void onAudioPortListUpdate(); 777 void onAudioPatchListUpdate(); 778 void onDynamicPolicyMixStateUpdate(const String8& regId, 779 int32_t state); 780 void onAudioVolumeGroupChanged(volume_group_t group, int flags); 781 void onRecordingConfigurationUpdate( 782 int event, 783 const record_client_info_t *clientInfo, 784 const audio_config_base_t *clientConfig, 785 std::vector<effect_descriptor_t> clientEffects, 786 const audio_config_base_t *deviceConfig, 787 std::vector<effect_descriptor_t> effects, 788 audio_patch_handle_t patchHandle, 789 audio_source_t source); 790 void onRoutingUpdated(); 791 void setAudioPortCallbacksEnabled(bool enabled); 792 void setAudioVolumeGroupCallbacksEnabled(bool enabled); 793 uid()794 uid_t uid() { 795 return mUid; 796 } 797 798 // IBinder::DeathRecipient 799 virtual void binderDied(const wp<IBinder>& who); 800 801 private: 802 NotificationClient(const NotificationClient&); 803 NotificationClient& operator = (const NotificationClient&); 804 805 const wp<AudioPolicyService> mService; 806 const uid_t mUid; 807 const pid_t mPid; 808 const sp<media::IAudioPolicyServiceClient> mAudioPolicyServiceClient; 809 bool mAudioPortCallbacksEnabled; 810 bool mAudioVolumeGroupCallbacksEnabled; 811 }; 812 813 class AudioClient : public virtual RefBase { 814 public: AudioClient(const audio_attributes_t attributes,const audio_io_handle_t io,const AttributionSourceState & attributionSource,const audio_session_t session,audio_port_handle_t portId,const audio_port_handle_t deviceId)815 AudioClient(const audio_attributes_t attributes, 816 const audio_io_handle_t io, 817 const AttributionSourceState& attributionSource, 818 const audio_session_t session, audio_port_handle_t portId, 819 const audio_port_handle_t deviceId) : 820 attributes(attributes), io(io), attributionSource( 821 attributionSource), session(session), portId(portId), 822 deviceId(deviceId), active(false) {} 823 ~AudioClient() override = default; 824 825 826 const audio_attributes_t attributes; // source, flags ... 827 const audio_io_handle_t io; // audio HAL stream IO handle 828 const AttributionSourceState& attributionSource; //client attributionsource 829 const audio_session_t session; // audio session ID 830 const audio_port_handle_t portId; 831 const audio_port_handle_t deviceId; // selected input device port ID 832 bool active; // Playback/Capture is active or inactive 833 }; 834 835 // Checks and monitors app ops for AudioRecordClient 836 class OpRecordAudioMonitor : public RefBase { 837 public: 838 ~OpRecordAudioMonitor() override; 839 bool hasOp() const; getOp()840 int32_t getOp() const { return mAppOp; } 841 842 static sp<OpRecordAudioMonitor> createIfNeeded( 843 const AttributionSourceState& attributionSource, 844 const audio_attributes_t& attr, wp<AudioCommandThread> commandThread); 845 846 private: 847 OpRecordAudioMonitor(const AttributionSourceState& attributionSource, int32_t appOp, 848 wp<AudioCommandThread> commandThread); 849 850 void onFirstRef() override; 851 852 AppOpsManager mAppOpsManager; 853 854 class RecordAudioOpCallback : public BnAppOpsCallback { 855 public: 856 explicit RecordAudioOpCallback(const wp<OpRecordAudioMonitor>& monitor); 857 void opChanged(int32_t op, const String16& packageName) override; 858 859 private: 860 const wp<OpRecordAudioMonitor> mMonitor; 861 }; 862 863 sp<RecordAudioOpCallback> mOpCallback; 864 // called by RecordAudioOpCallback when the app op for this OpRecordAudioMonitor is updated 865 // in AppOp callback and in onFirstRef() 866 // updateUidStates is true when the silenced state of active AudioRecordClients must be 867 // re-evaluated 868 void checkOp(bool updateUidStates = false); 869 870 std::atomic_bool mHasOp; 871 const AttributionSourceState mAttributionSource; 872 const int32_t mAppOp; 873 wp<AudioCommandThread> mCommandThread; 874 }; 875 876 // --- AudioRecordClient --- 877 // Information about each registered AudioRecord client 878 // (between calls to getInputForAttr() and releaseInput()) 879 class AudioRecordClient : public AudioClient { 880 public: AudioRecordClient(const audio_attributes_t attributes,const audio_io_handle_t io,const audio_session_t session,audio_port_handle_t portId,const audio_port_handle_t deviceId,const AttributionSourceState & attributionSource,bool canCaptureOutput,bool canCaptureHotword,wp<AudioCommandThread> commandThread)881 AudioRecordClient(const audio_attributes_t attributes, 882 const audio_io_handle_t io, 883 const audio_session_t session, audio_port_handle_t portId, 884 const audio_port_handle_t deviceId, 885 const AttributionSourceState& attributionSource, 886 bool canCaptureOutput, bool canCaptureHotword, 887 wp<AudioCommandThread> commandThread) : 888 AudioClient(attributes, io, attributionSource, 889 session, portId, deviceId), attributionSource(attributionSource), 890 startTimeNs(0), canCaptureOutput(canCaptureOutput), 891 canCaptureHotword(canCaptureHotword), silenced(false), 892 mOpRecordAudioMonitor( 893 OpRecordAudioMonitor::createIfNeeded(attributionSource, 894 attributes, commandThread)) {} 895 ~AudioRecordClient() override = default; 896 hasOp()897 bool hasOp() const { 898 return mOpRecordAudioMonitor ? mOpRecordAudioMonitor->hasOp() : true; 899 } 900 901 const AttributionSourceState attributionSource; // attribution source of client 902 nsecs_t startTimeNs; 903 const bool canCaptureOutput; 904 const bool canCaptureHotword; 905 bool silenced; 906 907 private: 908 sp<OpRecordAudioMonitor> mOpRecordAudioMonitor; 909 }; 910 911 912 // --- AudioPlaybackClient --- 913 // Information about each registered AudioTrack client 914 // (between calls to getOutputForAttr() and releaseOutput()) 915 class AudioPlaybackClient : public AudioClient { 916 public: AudioPlaybackClient(const audio_attributes_t attributes,const audio_io_handle_t io,AttributionSourceState attributionSource,const audio_session_t session,audio_port_handle_t portId,audio_port_handle_t deviceId,audio_stream_type_t stream)917 AudioPlaybackClient(const audio_attributes_t attributes, 918 const audio_io_handle_t io, AttributionSourceState attributionSource, 919 const audio_session_t session, audio_port_handle_t portId, 920 audio_port_handle_t deviceId, audio_stream_type_t stream) : 921 AudioClient(attributes, io, attributionSource, session, portId, 922 deviceId), stream(stream) {} 923 ~AudioPlaybackClient() override = default; 924 925 const audio_stream_type_t stream; 926 }; 927 928 void getPlaybackClientAndEffects(audio_port_handle_t portId, 929 sp<AudioPlaybackClient>& client, 930 sp<AudioPolicyEffects>& effects, 931 const char *context); 932 933 934 // A class automatically clearing and restoring binder caller identity inside 935 // a code block (scoped variable) 936 // Declare one systematically before calling AudioPolicyManager methods so that they are 937 // executed with the same level of privilege as audioserver process. 938 class AutoCallerClear { 939 public: AutoCallerClear()940 AutoCallerClear() : 941 mToken(IPCThreadState::self()->clearCallingIdentity()) {} ~AutoCallerClear()942 ~AutoCallerClear() { 943 IPCThreadState::self()->restoreCallingIdentity(mToken); 944 } 945 946 private: 947 const int64_t mToken; 948 }; 949 950 // Internal dump utilities. 951 status_t dumpPermissionDenial(int fd); 952 void loadAudioPolicyManager(); 953 void unloadAudioPolicyManager(); 954 955 mutable Mutex mLock; // prevents concurrent access to AudioPolicy manager functions changing 956 // device connection state or routing 957 // Note: lock acquisition order is always mLock > mEffectsLock: 958 // mLock protects AudioPolicyManager methods that can call into audio flinger 959 // and possibly back in to audio policy service and acquire mEffectsLock. 960 sp<AudioCommandThread> mAudioCommandThread; // audio commands thread 961 sp<AudioCommandThread> mOutputCommandThread; // process stop and release output 962 AudioPolicyInterface *mAudioPolicyManager; 963 AudioPolicyClient *mAudioPolicyClient; 964 std::vector<audio_usage_t> mSupportedSystemUsages; 965 966 Mutex mNotificationClientsLock; 967 DefaultKeyedVector<int64_t, sp<NotificationClient>> mNotificationClients 968 GUARDED_BY(mNotificationClientsLock); 969 // Manage all effects configured in audio_effects.conf 970 // never hold AudioPolicyService::mLock when calling AudioPolicyEffects methods as 971 // those can call back into AudioPolicyService methods and try to acquire the mutex 972 sp<AudioPolicyEffects> mAudioPolicyEffects GUARDED_BY(mLock); 973 audio_mode_t mPhoneState GUARDED_BY(mLock); 974 uid_t mPhoneStateOwnerUid GUARDED_BY(mLock); 975 976 sp<UidPolicy> mUidPolicy GUARDED_BY(mLock); 977 sp<SensorPrivacyPolicy> mSensorPrivacyPolicy GUARDED_BY(mLock); 978 979 DefaultKeyedVector<audio_port_handle_t, sp<AudioRecordClient>> mAudioRecordClients 980 GUARDED_BY(mLock); 981 DefaultKeyedVector<audio_port_handle_t, sp<AudioPlaybackClient>> mAudioPlaybackClients 982 GUARDED_BY(mLock); 983 984 MediaPackageManager mPackageManager; // To check allowPlaybackCapture 985 986 CaptureStateNotifier mCaptureStateNotifier; 987 988 void *mLibraryHandle = nullptr; 989 CreateAudioPolicyManagerInstance mCreateAudioPolicyManager; 990 DestroyAudioPolicyManagerInstance mDestroyAudioPolicyManager; 991 }; 992 993 } // namespace android 994 995 #endif // ANDROID_AUDIOPOLICYSERVICE_H 996