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 <android/media/BnAudioPolicyService.h> 21 #include <android/media/GetSpatializerResponse.h> 22 #include <android-base/thread_annotations.h> 23 #include <audio_utils/mutex.h> 24 #include <com/android/media/permission/INativePermissionController.h> 25 #include <cutils/misc.h> 26 #include <cutils/config_utils.h> 27 #include <cutils/compiler.h> 28 #include <utils/String8.h> 29 #include <utils/Vector.h> 30 #include <utils/SortedVector.h> 31 #include <binder/ActivityManager.h> 32 #include <binder/BinderService.h> 33 #include <binder/IUidObserver.h> 34 #include <system/audio.h> 35 #include <system/audio_policy.h> 36 #include <media/ToneGenerator.h> 37 #include <media/AudioEffect.h> 38 #include <media/AudioPolicy.h> 39 #include <media/IAudioPolicyServiceLocal.h> 40 #include <media/NativePermissionController.h> 41 #include <media/UsecaseValidator.h> 42 #include <mediautils/ServiceUtilities.h> 43 #include "AudioPolicyEffects.h" 44 #include "CaptureStateNotifier.h" 45 #include "Spatializer.h" 46 #include <AudioPolicyInterface.h> 47 #include <android/hardware/BnSensorPrivacyListener.h> 48 #include <android/content/AttributionSourceState.h> 49 50 #include <numeric> 51 #include <unordered_map> 52 53 namespace android { 54 55 using content::AttributionSourceState; 56 using media::audio::common::AudioConfig; 57 using media::audio::common::AudioConfigBase; 58 using media::audio::common::AudioDevice; 59 using media::audio::common::AudioDeviceDescription; 60 using media::audio::common::AudioFormatDescription; 61 using media::audio::common::AudioMMapPolicyInfo; 62 using media::audio::common::AudioMMapPolicyType; 63 using media::audio::common::AudioMode; 64 using media::audio::common::AudioSource; 65 using media::audio::common::AudioStreamType; 66 using media::audio::common::AudioUsage; 67 using media::audio::common::AudioUuid; 68 using media::audio::common::Int; 69 70 // ---------------------------------------------------------------------------- 71 72 namespace media::audiopolicy { 73 class AudioRecordClient; 74 } 75 76 using ::android::media::audiopolicy::AudioRecordClient; 77 using ::com::android::media::permission::INativePermissionController; 78 using ::com::android::media::permission::NativePermissionController; 79 using ::com::android::media::permission::IPermissionProvider; 80 81 class AudioPolicyService : 82 public BinderService<AudioPolicyService>, 83 public media::BnAudioPolicyService, 84 public IBinder::DeathRecipient, 85 public SpatializerPolicyCallback, 86 public media::IAudioPolicyServiceLocal 87 { 88 friend class sp<AudioPolicyService>; 89 90 public: 91 // for BinderService getServiceName()92 static const char *getServiceName() ANDROID_API { return "media.audio_policy"; } 93 94 virtual status_t dump(int fd, const Vector<String16>& args); 95 96 // 97 // BnAudioPolicyService (see AudioPolicyInterface for method descriptions) 98 // 99 binder::Status onNewAudioModulesAvailable() override; 100 binder::Status setDeviceConnectionState( 101 media::AudioPolicyDeviceState state, 102 const android::media::audio::common::AudioPort& port, 103 const AudioFormatDescription& encodedFormat) override; 104 binder::Status getDeviceConnectionState(const AudioDevice& device, 105 media::AudioPolicyDeviceState* _aidl_return) override; 106 binder::Status handleDeviceConfigChange( 107 const AudioDevice& device, 108 const std::string& deviceName, 109 const AudioFormatDescription& encodedFormat) override; 110 binder::Status setPhoneState(AudioMode state, int32_t uid) override; 111 binder::Status setForceUse(media::AudioPolicyForceUse usage, 112 media::AudioPolicyForcedConfig config) override; 113 binder::Status getForceUse(media::AudioPolicyForceUse usage, 114 media::AudioPolicyForcedConfig* _aidl_return) override; 115 binder::Status getOutput(AudioStreamType stream, int32_t* _aidl_return) override; 116 binder::Status getOutputForAttr(const media::audio::common::AudioAttributes& attr, 117 int32_t session, 118 const AttributionSourceState &attributionSource, 119 const AudioConfig& config, 120 int32_t flags, const std::vector<int32_t>& selectedDeviceIds, 121 media::GetOutputForAttrResponse* _aidl_return) override; 122 binder::Status startOutput(int32_t portId) override; 123 binder::Status stopOutput(int32_t portId) override; 124 binder::Status releaseOutput(int32_t portId) override; 125 binder::Status getInputForAttr(const media::audio::common::AudioAttributes& attr, int32_t input, 126 int32_t riid, int32_t session, 127 const AttributionSourceState &attributionSource, 128 const AudioConfigBase& config, int32_t flags, 129 int32_t selectedDeviceId, 130 media::GetInputForAttrResponse* _aidl_return) override; 131 binder::Status startInput(int32_t portId) override; 132 binder::Status stopInput(int32_t portId) override; 133 binder::Status releaseInput(int32_t portId) override; 134 binder::Status setDeviceAbsoluteVolumeEnabled(const AudioDevice& device, 135 bool enabled, 136 AudioStreamType streamToDriveAbs) override; 137 binder::Status initStreamVolume(AudioStreamType stream, int32_t indexMin, 138 int32_t indexMax) override; 139 binder::Status setStreamVolumeIndex(AudioStreamType stream, 140 const AudioDeviceDescription& device, 141 int32_t index, bool muted) override; 142 binder::Status getStreamVolumeIndex(AudioStreamType stream, 143 const AudioDeviceDescription& device, 144 int32_t* _aidl_return) override; 145 binder::Status setVolumeIndexForAttributes(const media::audio::common::AudioAttributes& attr, 146 const AudioDeviceDescription& device, 147 int32_t index, bool muted) override; 148 binder::Status getVolumeIndexForAttributes(const media::audio::common::AudioAttributes& attr, 149 const AudioDeviceDescription& device, 150 int32_t* _aidl_return) override; 151 binder::Status getMaxVolumeIndexForAttributes(const media::audio::common::AudioAttributes& attr, 152 int32_t* _aidl_return) override; 153 binder::Status getMinVolumeIndexForAttributes(const media::audio::common::AudioAttributes& attr, 154 int32_t* _aidl_return) override; 155 binder::Status getStrategyForStream(AudioStreamType stream, 156 int32_t* _aidl_return) override; 157 binder::Status getDevicesForAttributes(const media::audio::common::AudioAttributes& attr, 158 bool forVolume, 159 std::vector<AudioDevice>* _aidl_return) override; 160 binder::Status getOutputForEffect(const media::EffectDescriptor& desc, 161 int32_t* _aidl_return) override; 162 binder::Status registerEffect(const media::EffectDescriptor& desc, int32_t io, int32_t strategy, 163 int32_t session, int32_t id) override; 164 binder::Status unregisterEffect(int32_t id) override; 165 binder::Status setEffectEnabled(int32_t id, bool enabled) override; 166 binder::Status moveEffectsToIo(const std::vector<int32_t>& ids, int32_t io) override; 167 binder::Status isStreamActive(AudioStreamType stream, int32_t inPastMs, 168 bool* _aidl_return) override; 169 binder::Status isStreamActiveRemotely(AudioStreamType stream, int32_t inPastMs, 170 bool* _aidl_return) override; 171 binder::Status isSourceActive(AudioSource source, bool* _aidl_return) override; 172 binder::Status queryDefaultPreProcessing( 173 int32_t audioSession, Int* count, 174 std::vector<media::EffectDescriptor>* _aidl_return) override; 175 binder::Status addSourceDefaultEffect(const AudioUuid& type, 176 const std::string& opPackageName, 177 const AudioUuid& uuid, int32_t priority, 178 AudioSource source, 179 int32_t* _aidl_return) override; 180 binder::Status addStreamDefaultEffect(const AudioUuid& type, 181 const std::string& opPackageName, 182 const AudioUuid& uuid, int32_t priority, 183 AudioUsage usage, int32_t* _aidl_return) override; 184 binder::Status removeSourceDefaultEffect(int32_t id) override; 185 binder::Status removeStreamDefaultEffect(int32_t id) override; 186 binder::Status setSupportedSystemUsages( 187 const std::vector<AudioUsage>& systemUsages) override; 188 binder::Status setAllowedCapturePolicy(int32_t uid, int32_t capturePolicy) override; 189 binder::Status getOffloadSupport(const media::audio::common::AudioOffloadInfo& info, 190 media::AudioOffloadMode* _aidl_return) override; 191 binder::Status isDirectOutputSupported(const AudioConfigBase& config, 192 const media::audio::common::AudioAttributes& attributes, 193 bool* _aidl_return) override; 194 binder::Status listAudioPorts(media::AudioPortRole role, media::AudioPortType type, 195 Int* count, std::vector<media::AudioPortFw>* ports, 196 int32_t* _aidl_return) override; 197 binder::Status listDeclaredDevicePorts(media::AudioPortRole role, 198 std::vector<media::AudioPortFw>* _aidl_return) override; 199 binder::Status getAudioPort(int portId, 200 media::AudioPortFw* _aidl_return) override; 201 binder::Status createAudioPatch(const media::AudioPatchFw& patch, int32_t handle, 202 int32_t* _aidl_return) override; 203 binder::Status releaseAudioPatch(int32_t handle) override; 204 binder::Status listAudioPatches(Int* count, std::vector<media::AudioPatchFw>* patches, 205 int32_t* _aidl_return) override; 206 binder::Status setAudioPortConfig(const media::AudioPortConfigFw& config) override; 207 binder::Status registerClient(const sp<media::IAudioPolicyServiceClient>& client) override; 208 binder::Status setAudioPortCallbacksEnabled(bool enabled) override; 209 binder::Status setAudioVolumeGroupCallbacksEnabled(bool enabled) override; 210 binder::Status acquireSoundTriggerSession(media::SoundTriggerSession* _aidl_return) override; 211 binder::Status releaseSoundTriggerSession(int32_t session) override; 212 binder::Status getPhoneState(AudioMode* _aidl_return) override; 213 binder::Status registerPolicyMixes(const std::vector<media::AudioMix>& mixes, 214 bool registration) override; 215 binder::Status updatePolicyMixes( 216 const ::std::vector<::android::media::AudioMixUpdate>& updates) override; 217 binder::Status setUidDeviceAffinities(int32_t uid, 218 const std::vector<AudioDevice>& devices) override; 219 binder::Status removeUidDeviceAffinities(int32_t uid) override; 220 binder::Status setUserIdDeviceAffinities( 221 int32_t userId, 222 const std::vector<AudioDevice>& devices) override; 223 binder::Status removeUserIdDeviceAffinities(int32_t userId) override; 224 binder::Status startAudioSource(const media::AudioPortConfigFw& source, 225 const media::audio::common::AudioAttributes& attributes, 226 int32_t* _aidl_return) override; 227 binder::Status stopAudioSource(int32_t portId) override; 228 binder::Status setMasterMono(bool mono) override; 229 binder::Status getMasterMono(bool* _aidl_return) override; 230 binder::Status getStreamVolumeDB(AudioStreamType stream, int32_t index, 231 const AudioDeviceDescription& device, 232 float* _aidl_return) override; 233 binder::Status getSurroundFormats(Int* count, 234 std::vector<AudioFormatDescription>* formats, 235 std::vector<bool>* formatsEnabled) override; 236 binder::Status getReportedSurroundFormats( 237 Int* count, std::vector<AudioFormatDescription>* formats) override; 238 binder::Status getHwOffloadFormatsSupportedForBluetoothMedia( 239 const AudioDeviceDescription& device, 240 std::vector<AudioFormatDescription>* _aidl_return) override; 241 binder::Status setSurroundFormatEnabled(const AudioFormatDescription& audioFormat, 242 bool enabled) override; 243 binder::Status setAssistantServicesUids(const std::vector<int32_t>& uids) override; 244 binder::Status setActiveAssistantServicesUids(const std::vector<int32_t>& activeUids) override; 245 binder::Status setA11yServicesUids(const std::vector<int32_t>& uids) override; 246 binder::Status setCurrentImeUid(int32_t uid) override; 247 binder::Status isHapticPlaybackSupported(bool* _aidl_return) override; 248 binder::Status isUltrasoundSupported(bool* _aidl_return) override; 249 binder::Status isHotwordStreamSupported(bool lookbackAudio, bool* _aidl_return) override; 250 binder::Status listAudioProductStrategies( 251 std::vector<media::AudioProductStrategy>* _aidl_return) override; 252 binder::Status getProductStrategyFromAudioAttributes( 253 const media::audio::common::AudioAttributes& aa, 254 bool fallbackOnDefault, 255 int32_t* _aidl_return) override; 256 binder::Status listAudioVolumeGroups( 257 std::vector<media::AudioVolumeGroup>* _aidl_return) override; 258 binder::Status getVolumeGroupFromAudioAttributes( 259 const media::audio::common::AudioAttributes& aa, 260 bool fallbackOnDefault, 261 int32_t* _aidl_return) override; 262 binder::Status setRttEnabled(bool enabled) override; 263 binder::Status isCallScreenModeSupported(bool* _aidl_return) override; 264 binder::Status setDevicesRoleForStrategy( 265 int32_t strategy, media::DeviceRole role, 266 const std::vector<AudioDevice>& devices) override; 267 binder::Status removeDevicesRoleForStrategy( 268 int32_t strategy, media::DeviceRole role, 269 const std::vector<AudioDevice>& devices) override; 270 binder::Status clearDevicesRoleForStrategy( 271 int32_t strategy, 272 media::DeviceRole role) override; 273 binder::Status getDevicesForRoleAndStrategy( 274 int32_t strategy, media::DeviceRole role, 275 std::vector<AudioDevice>* _aidl_return) override; 276 binder::Status setDevicesRoleForCapturePreset( 277 AudioSource audioSource, 278 media::DeviceRole role, 279 const std::vector<AudioDevice>& devices) override; 280 binder::Status addDevicesRoleForCapturePreset( 281 AudioSource audioSource, 282 media::DeviceRole role, 283 const std::vector<AudioDevice>& devices) override; 284 binder::Status removeDevicesRoleForCapturePreset( 285 AudioSource audioSource, 286 media::DeviceRole role, 287 const std::vector<AudioDevice>& devices) override; 288 binder::Status clearDevicesRoleForCapturePreset(AudioSource audioSource, 289 media::DeviceRole role) override; 290 binder::Status getDevicesForRoleAndCapturePreset( 291 AudioSource audioSource, 292 media::DeviceRole role, 293 std::vector<AudioDevice>* _aidl_return) override; 294 binder::Status registerSoundTriggerCaptureStateListener( 295 const sp<media::ICaptureStateListener>& listener, bool* _aidl_return) override; 296 297 binder::Status getSpatializer(const sp<media::INativeSpatializerCallback>& callback, 298 media::GetSpatializerResponse* _aidl_return) override; 299 binder::Status canBeSpatialized( 300 const std::optional<media::audio::common::AudioAttributes>& attr, 301 const std::optional<AudioConfig>& config, 302 const std::vector<AudioDevice>& devices, 303 bool* _aidl_return) override; 304 305 binder::Status getDirectPlaybackSupport(const media::audio::common::AudioAttributes& attr, 306 const AudioConfig& config, 307 media::AudioDirectMode* _aidl_return) override; 308 309 binder::Status getDirectProfilesForAttributes(const media::audio::common::AudioAttributes& attr, 310 std::vector<media::audio::common::AudioProfile>* _aidl_return) override; 311 312 binder::Status getSupportedMixerAttributes( 313 int32_t portId, 314 std::vector<media::AudioMixerAttributesInternal>* _aidl_return) override; 315 binder::Status setPreferredMixerAttributes( 316 const media::audio::common::AudioAttributes& attr, 317 int32_t portId, 318 int32_t uid, 319 const media::AudioMixerAttributesInternal& mixerAttr) override; 320 binder::Status getPreferredMixerAttributes( 321 const media::audio::common::AudioAttributes& attr, 322 int32_t portId, 323 std::optional<media::AudioMixerAttributesInternal>* _aidl_return) override; 324 binder::Status clearPreferredMixerAttributes(const media::audio::common::AudioAttributes& attr, 325 int32_t portId, 326 int32_t uid) override; 327 binder::Status getRegisteredPolicyMixes( 328 std::vector <::android::media::AudioMix>* mixes) override; 329 330 // Should only be called by AudioService to push permission data down to audioserver 331 binder::Status getPermissionController(sp<INativePermissionController>* out) override; 332 333 binder::Status getMmapPolicyInfos( 334 AudioMMapPolicyType policyType, 335 std::vector<AudioMMapPolicyInfo>* _aidl_return) override; 336 binder::Status getMmapPolicyForDevice( 337 AudioMMapPolicyType policyType, 338 AudioMMapPolicyInfo* policyInfo) override; 339 340 status_t onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) override; 341 342 // -- IAudioPolicyLocal methods 343 const IPermissionProvider& getPermissionProvider() const override; 344 345 // IBinder::DeathRecipient 346 virtual void binderDied(const wp<IBinder>& who); 347 348 // RefBase 349 virtual void onFirstRef(); 350 351 // Commence initialization when AudioSystem is ready. 352 void onAudioSystemReady(); 353 354 // 355 // Helpers for the struct audio_policy_service_ops implementation. 356 // This is used by the audio policy manager for certain operations that 357 // are implemented by the policy service. 358 // 359 virtual void setParameters(audio_io_handle_t ioHandle, 360 const char *keyValuePairs, 361 int delayMs); 362 363 virtual status_t setStreamVolume(audio_stream_type_t stream, 364 float volume, 365 bool muted, 366 audio_io_handle_t output, 367 int delayMs = 0); 368 369 /** 370 * Set a volume on AudioTrack port id(s) for a particular output. 371 * For the same user setting, a volume group (and associated given port of the 372 * client's track) can have different volumes for each output destination device 373 * it is attached to. 374 * 375 * @param ports to consider 376 * @param volume to set 377 * @param muted to set 378 * @param output to consider 379 * @param delayMs to use 380 * @return NO_ERROR if successful 381 */ 382 virtual status_t setPortsVolume(const std::vector<audio_port_handle_t> &ports, float volume, 383 bool muted, audio_io_handle_t output, int delayMs = 0); 384 virtual status_t setVoiceVolume(float volume, int delayMs = 0); 385 386 void doOnNewAudioModulesAvailable(); 387 status_t doStopOutput(audio_port_handle_t portId); 388 void doReleaseOutput(audio_port_handle_t portId); 389 390 status_t clientCreateAudioPatch(const struct audio_patch *patch, 391 audio_patch_handle_t *handle, 392 int delayMs); 393 status_t clientReleaseAudioPatch(audio_patch_handle_t handle, 394 int delayMs); 395 virtual status_t clientSetAudioPortConfig(const struct audio_port_config *config, 396 int delayMs); 397 398 void removeNotificationClient(uid_t uid, pid_t pid); 399 void onAudioPortListUpdate(); 400 void doOnAudioPortListUpdate(); 401 void onAudioPatchListUpdate(); 402 void doOnAudioPatchListUpdate(); 403 404 void onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state); 405 void doOnDynamicPolicyMixStateUpdate(const String8& regId, int32_t state); 406 void onRecordingConfigurationUpdate(int event, 407 const record_client_info_t *clientInfo, 408 const audio_config_base_t *clientConfig, 409 std::vector<effect_descriptor_t> clientEffects, 410 const audio_config_base_t *deviceConfig, 411 std::vector<effect_descriptor_t> effects, 412 audio_patch_handle_t patchHandle, 413 audio_source_t source); 414 void doOnRecordingConfigurationUpdate(int event, 415 const record_client_info_t *clientInfo, 416 const audio_config_base_t *clientConfig, 417 std::vector<effect_descriptor_t> clientEffects, 418 const audio_config_base_t *deviceConfig, 419 std::vector<effect_descriptor_t> effects, 420 audio_patch_handle_t patchHandle, 421 audio_source_t source); 422 423 void onAudioVolumeGroupChanged(volume_group_t group, int flags); 424 void doOnAudioVolumeGroupChanged(volume_group_t group, int flags); 425 426 void onRoutingUpdated(); 427 void doOnRoutingUpdated(); 428 429 void onVolumeRangeInitRequest(); 430 void doOnVolumeRangeInitRequest(); 431 432 /** 433 * Spatializer SpatializerPolicyCallback implementation. 434 * onCheckSpatializer() sends an event on mOutputCommandThread which executes 435 * doOnCheckSpatializer() to check if a Spatializer output must be opened or closed 436 * by audio policy manager and attach/detach the spatializer effect accordingly. 437 */ 438 void onCheckSpatializer() override; 439 void onCheckSpatializer_l() REQUIRES(mMutex); 440 void doOnCheckSpatializer(); 441 442 void onUpdateActiveSpatializerTracks_l() REQUIRES(mMutex); 443 void doOnUpdateActiveSpatializerTracks(); 444 445 446 void setEffectSuspended(int effectId, 447 audio_session_t sessionId, 448 bool suspended); 449 450 private: 451 AudioPolicyService() ANDROID_API; 452 virtual ~AudioPolicyService(); 453 454 status_t dumpInternals(int fd) REQUIRES(mMutex); 455 456 // Handles binder shell commands 457 virtual status_t shellCommand(int in, int out, int err, Vector<String16>& args); 458 459 460 // Sets whether the given UID records only silence 461 virtual void setAppState_l(sp<AudioRecordClient> client, app_state_t state) REQUIRES(mMutex); 462 463 // Overrides the UID state as if it is idle 464 status_t handleSetUidState(Vector<String16>& args, int err); 465 466 // Clears the override for the UID state 467 status_t handleResetUidState(Vector<String16>& args, int err); 468 469 // Gets the UID state 470 status_t handleGetUidState(Vector<String16>& args, int out, int err); 471 472 // Prints the shell command help 473 status_t printHelp(int out); 474 475 std::string getDeviceTypeStrForPortId(audio_port_handle_t portId); 476 477 std::string getDeviceTypeStrForPortIds(DeviceIdVector portIds); 478 479 status_t getAudioPolicyEffects(sp<AudioPolicyEffects>& audioPolicyEffects); 480 481 app_state_t apmStatFromAmState(int amState); 482 483 bool isSupportedSystemUsage(audio_usage_t usage); 484 binder::Status validateUsage(const audio_attributes_t& attr); 485 binder::Status validateUsage(const audio_attributes_t& attr, 486 const AttributionSourceState& attributionSource); 487 488 void updateUidStates(); 489 void updateUidStates_l() REQUIRES(mMutex); 490 491 void silenceAllRecordings_l() REQUIRES(mMutex); 492 493 static bool isVirtualSource(audio_source_t source); 494 495 /** returns true if the audio source must be silenced when the corresponding app op is denied. 496 * false if the audio source does not actually capture from the microphone while still 497 * being mapped to app op OP_RECORD_AUDIO and not a specialized op tracked separately. 498 * See getOpForSource(). 499 */ 500 static bool isAppOpSource(audio_source_t source); 501 502 status_t registerOutput(audio_io_handle_t output, 503 const audio_config_base_t& config, 504 const audio_output_flags_t flags); 505 status_t unregisterOutput(audio_io_handle_t output); 506 507 // If recording we need to make sure the UID is allowed to do that. If the UID is idle 508 // then it cannot record and gets buffers with zeros - silence. As soon as the UID 509 // transitions to an active state we will start reporting buffers with data. This approach 510 // transparently handles recording while the UID transitions between idle/active state 511 // avoiding to get stuck in a state receiving non-empty buffers while idle or in a state 512 // receiving empty buffers while active. 513 class UidPolicy : public BnUidObserver, public virtual IBinder::DeathRecipient { 514 public: UidPolicy(wp<AudioPolicyService> service)515 explicit UidPolicy(wp<AudioPolicyService> service) 516 : mService(service), mObserverRegistered(false), 517 mCurrentImeUid(0), 518 mRttEnabled(false) {} 519 520 void registerSelf(); 521 void unregisterSelf(); 522 523 // IBinder::DeathRecipient implementation 524 void binderDied(const wp<IBinder> &who) override; 525 526 bool isUidActive(uid_t uid); 527 int getUidState(uid_t uid); 528 void setAssistantUids(const std::vector<uid_t>& uids); 529 bool isAssistantUid(uid_t uid); 530 void setActiveAssistantUids(const std::vector<uid_t>& activeUids); 531 bool isActiveAssistantUid(uid_t uid); setA11yUids(const std::vector<uid_t> & uids)532 void setA11yUids(const std::vector<uid_t>& uids) { mA11yUids.clear(); mA11yUids = uids; } 533 bool isA11yUid(uid_t uid); 534 bool isA11yOnTop(); setCurrentImeUid(uid_t uid)535 void setCurrentImeUid(uid_t uid) { mCurrentImeUid = uid; } isCurrentImeUid(uid_t uid)536 bool isCurrentImeUid(uid_t uid) { return uid == mCurrentImeUid; } setRttEnabled(bool enabled)537 void setRttEnabled(bool enabled) { mRttEnabled = enabled; } isRttEnabled()538 bool isRttEnabled() { return mRttEnabled; } 539 540 // BnUidObserver implementation 541 void onUidActive(uid_t uid) override; 542 void onUidGone(uid_t uid, bool disabled) override; 543 void onUidIdle(uid_t uid, bool disabled) override; 544 void onUidStateChanged(uid_t uid, int32_t procState, int64_t procStateSeq, 545 int32_t capability) override; 546 void onUidProcAdjChanged(uid_t uid, int32_t adj) override; 547 548 549 void updateUid(std::unordered_map<uid_t, std::pair<bool, int>> *uids, 550 uid_t uid, bool active, int state, bool insert); 551 552 void dumpInternals(int fd); 553 554 private: 555 void notifyService(); 556 void updateUidLocked(std::unordered_map<uid_t, std::pair<bool, int>> *uids, 557 uid_t uid, bool active, int state, bool insert); 558 void checkRegistered(); 559 560 wp<AudioPolicyService> mService; 561 audio_utils::mutex mMutex{audio_utils::MutexOrder::kUidPolicy_Mutex}; 562 ActivityManager mAm; 563 bool mObserverRegistered = false; 564 std::unordered_map<uid_t, std::pair<bool, int>> mCachedUids GUARDED_BY(mMutex); 565 std::vector<uid_t> mAssistantUids; 566 std::vector<uid_t> mActiveAssistantUids; 567 std::vector<uid_t> mA11yUids; 568 uid_t mCurrentImeUid = -1; 569 bool mRttEnabled = false; 570 }; 571 572 // If sensor privacy is enabled then all apps, including those that are active, should be 573 // prevented from recording. This is handled similar to idle UIDs, any app that attempts 574 // to record while sensor privacy is enabled will receive buffers with zeros. As soon as 575 // sensor privacy is disabled active apps will receive the expected data when recording. 576 class SensorPrivacyPolicy : public hardware::BnSensorPrivacyListener { 577 public: SensorPrivacyPolicy(wp<AudioPolicyService> service)578 explicit SensorPrivacyPolicy(wp<AudioPolicyService> service) 579 : mService(service) {} 580 581 void registerSelf(); 582 void unregisterSelf(); 583 584 bool isSensorPrivacyEnabled(); 585 586 binder::Status onSensorPrivacyChanged(int toggleType, int sensor, 587 bool enabled); 588 onSensorPrivacyStateChanged(int,int,int)589 binder::Status onSensorPrivacyStateChanged(int, int, int) { 590 return binder::Status::ok(); 591 } 592 593 private: 594 wp<AudioPolicyService> mService; 595 std::atomic_bool mSensorPrivacyEnabled = false; 596 }; 597 598 // Thread used to send audio config commands to audio flinger 599 // For audio config commands, it is necessary because audio flinger requires that the calling 600 // process (user) has permission to modify audio settings. 601 public: 602 class AudioCommandThread : public Thread { 603 class AudioCommand; 604 public: 605 606 // commands for tone AudioCommand 607 enum { 608 SET_VOLUME, 609 SET_PORTS_VOLUME, 610 SET_PARAMETERS, 611 SET_VOICE_VOLUME, 612 STOP_OUTPUT, 613 RELEASE_OUTPUT, 614 CREATE_AUDIO_PATCH, 615 RELEASE_AUDIO_PATCH, 616 UPDATE_AUDIOPORT_LIST, 617 UPDATE_AUDIOPATCH_LIST, 618 CHANGED_AUDIOVOLUMEGROUP, 619 SET_AUDIOPORT_CONFIG, 620 DYN_POLICY_MIX_STATE_UPDATE, 621 RECORDING_CONFIGURATION_UPDATE, 622 SET_EFFECT_SUSPENDED, 623 AUDIO_MODULES_UPDATE, 624 ROUTING_UPDATED, 625 UPDATE_UID_STATES, 626 CHECK_SPATIALIZER_OUTPUT, // verify if spatializer effect should be created or moved 627 UPDATE_ACTIVE_SPATIALIZER_TRACKS, // Update active track counts on spalializer output 628 VOL_RANGE_INIT_REQUEST, // request to reset the volume range indices 629 }; 630 631 AudioCommandThread (String8 name, const wp<AudioPolicyService>& service); 632 virtual ~AudioCommandThread(); 633 634 status_t dump(int fd); 635 636 // Thread virtuals 637 virtual void onFirstRef(); 638 virtual bool threadLoop(); 639 640 void exit(); 641 status_t volumeCommand(audio_stream_type_t stream, float volume, bool muted, 642 audio_io_handle_t output, int delayMs = 0); 643 status_t volumePortsCommand(const std::vector<audio_port_handle_t> &ports, 644 float volume, bool muted, audio_io_handle_t output, int delayMs = 0); 645 status_t parametersCommand(audio_io_handle_t ioHandle, 646 const char *keyValuePairs, int delayMs = 0); 647 status_t voiceVolumeCommand(float volume, int delayMs = 0); 648 void stopOutputCommand(audio_port_handle_t portId); 649 void releaseOutputCommand(audio_port_handle_t portId); 650 status_t sendCommand(sp<AudioCommand>& command, int delayMs = 0); 651 void insertCommand_l(sp<AudioCommand>& command, int delayMs = 0); 652 status_t createAudioPatchCommand(const struct audio_patch *patch, 653 audio_patch_handle_t *handle, 654 int delayMs); 655 status_t releaseAudioPatchCommand(audio_patch_handle_t handle, 656 int delayMs); 657 void updateAudioPortListCommand(); 658 void updateAudioPatchListCommand(); 659 void changeAudioVolumeGroupCommand(volume_group_t group, int flags); 660 status_t setAudioPortConfigCommand(const struct audio_port_config *config, 661 int delayMs); 662 void dynamicPolicyMixStateUpdateCommand(const String8& regId, 663 int32_t state); 664 void recordingConfigurationUpdateCommand( 665 int event, 666 const record_client_info_t *clientInfo, 667 const audio_config_base_t *clientConfig, 668 std::vector<effect_descriptor_t> clientEffects, 669 const audio_config_base_t *deviceConfig, 670 std::vector<effect_descriptor_t> effects, 671 audio_patch_handle_t patchHandle, 672 audio_source_t source); 673 void setEffectSuspendedCommand(int effectId, 674 audio_session_t sessionId, 675 bool suspended); 676 void audioModulesUpdateCommand(); 677 void routingChangedCommand(); 678 void updateUidStatesCommand(); 679 void checkSpatializerCommand(); 680 void updateActiveSpatializerTracksCommand(); 681 void volRangeInitReqCommand(); 682 683 void insertCommand_l(AudioCommand *command, int delayMs = 0); 684 private: 685 class AudioCommandData; 686 687 // descriptor for requested tone playback event 688 class AudioCommand: public RefBase { 689 690 public: AudioCommand()691 AudioCommand() 692 : mCommand(-1), mStatus(NO_ERROR), mWaitStatus(false) {} 693 694 void dump(char* buffer, size_t size); 695 696 int mCommand; // SET_VOLUME, SET_PARAMETERS... 697 nsecs_t mTime; // time stamp 698 audio_utils::mutex mMutex{audio_utils::MutexOrder::kAudioCommand_Mutex}; 699 audio_utils::condition_variable mCond; // condition for status return 700 status_t mStatus; // command status 701 bool mWaitStatus; // true if caller is waiting for status 702 sp<AudioCommandData> mParam; // command specific parameter data 703 }; 704 705 class AudioCommandData: public RefBase { 706 public: ~AudioCommandData()707 virtual ~AudioCommandData() {} 708 protected: AudioCommandData()709 AudioCommandData() {} 710 }; 711 712 class VolumeData : public AudioCommandData { 713 public: 714 audio_stream_type_t mStream; 715 float mVolume; 716 bool mIsMuted; 717 audio_io_handle_t mIO; 718 }; 719 720 class VolumePortsData : public AudioCommandData { 721 public: 722 std::vector<audio_port_handle_t> mPorts; 723 float mVolume; 724 bool mMuted; 725 audio_io_handle_t mIO; dumpPorts()726 std::string dumpPorts() { 727 return std::string("volume ") + std::to_string(mVolume) + std::string("muted ") + 728 std::to_string(mMuted) + " on IO " + std::to_string(mIO) + " and ports " + 729 std::accumulate(std::begin(mPorts), std::end(mPorts), std::string{}, 730 [](const std::string &ls, int rs) { 731 return ls + std::to_string(rs) + " "; 732 }); 733 } 734 }; 735 736 class ParametersData : public AudioCommandData { 737 public: 738 audio_io_handle_t mIO; 739 String8 mKeyValuePairs; 740 }; 741 742 class VoiceVolumeData : public AudioCommandData { 743 public: 744 float mVolume; 745 }; 746 747 class StopOutputData : public AudioCommandData { 748 public: 749 audio_port_handle_t mPortId; 750 }; 751 752 class ReleaseOutputData : public AudioCommandData { 753 public: 754 audio_port_handle_t mPortId; 755 }; 756 757 class CreateAudioPatchData : public AudioCommandData { 758 public: 759 struct audio_patch mPatch; 760 audio_patch_handle_t mHandle; 761 }; 762 763 class ReleaseAudioPatchData : public AudioCommandData { 764 public: 765 audio_patch_handle_t mHandle; 766 }; 767 768 class AudioVolumeGroupData : public AudioCommandData { 769 public: 770 volume_group_t mGroup; 771 int mFlags; 772 }; 773 774 class SetAudioPortConfigData : public AudioCommandData { 775 public: 776 struct audio_port_config mConfig; 777 }; 778 779 class DynPolicyMixStateUpdateData : public AudioCommandData { 780 public: 781 String8 mRegId; 782 int32_t mState; 783 }; 784 785 class RecordingConfigurationUpdateData : public AudioCommandData { 786 public: 787 int mEvent; 788 record_client_info_t mClientInfo; 789 struct audio_config_base mClientConfig; 790 std::vector<effect_descriptor_t> mClientEffects; 791 struct audio_config_base mDeviceConfig; 792 std::vector<effect_descriptor_t> mEffects; 793 audio_patch_handle_t mPatchHandle; 794 audio_source_t mSource; 795 }; 796 797 class SetEffectSuspendedData : public AudioCommandData { 798 public: 799 int mEffectId; 800 audio_session_t mSessionId; 801 bool mSuspended; 802 }; 803 804 mutable audio_utils::mutex mMutex{audio_utils::MutexOrder::kCommandThread_Mutex}; 805 audio_utils::condition_variable mWaitWorkCV; 806 Vector < sp<AudioCommand> > mAudioCommands; // list of pending commands 807 sp<AudioCommand> mLastCommand; // last processed command (used by dump) 808 String8 mName; // string used by wake lock fo delayed commands 809 wp<AudioPolicyService> mService; 810 }; 811 812 private: 813 class AudioPolicyClient : public AudioPolicyClientInterface 814 { 815 public: AudioPolicyClient(AudioPolicyService * service)816 explicit AudioPolicyClient(AudioPolicyService *service) : mAudioPolicyService(service) {} ~AudioPolicyClient()817 virtual ~AudioPolicyClient() {} 818 819 virtual status_t getAudioPolicyConfig(media::AudioPolicyConfig *config); 820 821 // 822 // Audio HW module functions 823 // 824 825 // loads a HW module. 826 virtual audio_module_handle_t loadHwModule(const char *name); 827 828 // 829 // Audio output Control functions 830 // 831 832 // opens an audio output with the requested parameters. The parameter values can indicate to use the default values 833 // in case the audio policy manager has no specific requirements for the output being opened. 834 // When the function returns, the parameter values reflect the actual values used by the audio hardware output stream. 835 // The audio policy manager can check if the proposed parameters are suitable or not and act accordingly. 836 virtual status_t openOutput(audio_module_handle_t module, 837 audio_io_handle_t *output, 838 audio_config_t *halConfig, 839 audio_config_base_t *mixerConfig, 840 const sp<DeviceDescriptorBase>& device, 841 uint32_t *latencyMs, 842 audio_output_flags_t *flags, 843 audio_attributes_t attributes); 844 // creates a special output that is duplicated to the two outputs passed as arguments. The duplication is performed by 845 // a special mixer thread in the AudioFlinger. 846 virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1, audio_io_handle_t output2); 847 // closes the output stream 848 virtual status_t closeOutput(audio_io_handle_t output); 849 // suspends the output. When an output is suspended, the corresponding audio hardware output stream is placed in 850 // standby and the AudioTracks attached to the mixer thread are still processed but the output mix is discarded. 851 virtual status_t suspendOutput(audio_io_handle_t output); 852 // restores a suspended output. 853 virtual status_t restoreOutput(audio_io_handle_t output); 854 855 // 856 // Audio input Control functions 857 // 858 859 // opens an audio input 860 virtual audio_io_handle_t openInput(audio_module_handle_t module, 861 audio_io_handle_t *input, 862 audio_config_t *config, 863 audio_devices_t *devices, 864 const String8& address, 865 audio_source_t source, 866 audio_input_flags_t flags); 867 // closes an audio input 868 virtual status_t closeInput(audio_io_handle_t input); 869 // 870 // misc control functions 871 // 872 873 // set a stream volume for a particular output. For the same user setting, a given stream 874 // type can have different volumes for each output (destination device) it is attached to. 875 virtual status_t setStreamVolume(audio_stream_type_t stream, float volume, bool muted, 876 audio_io_handle_t output, int delayMs = 0); 877 /** 878 * Set a volume on port(s) for a particular output. For the same user setting, a volume 879 * group (and associated given port of the client's track) can have different volumes for 880 * each output (destination device) it is attached to. 881 * 882 * @param ports to consider 883 * @param volume to set 884 * @param muted to set 885 * @param output to consider 886 * @param delayMs to use 887 * @return NO_ERROR if successful 888 */ 889 status_t setPortsVolume(const std::vector<audio_port_handle_t> &ports, float volume, 890 bool muted, audio_io_handle_t output, int delayMs = 0) override; 891 892 // function enabling to send proprietary informations directly from audio policy manager to audio hardware interface. 893 virtual void setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs, int delayMs = 0); 894 // function enabling to receive proprietary informations directly from audio hardware interface to audio policy manager. 895 virtual String8 getParameters(audio_io_handle_t ioHandle, const String8& keys); 896 897 // set down link audio volume. 898 virtual status_t setVoiceVolume(float volume, int delayMs = 0); 899 900 // move effect to the specified output 901 virtual status_t moveEffects(audio_session_t session, 902 audio_io_handle_t srcOutput, 903 audio_io_handle_t dstOutput); 904 905 void setEffectSuspended(int effectId, 906 audio_session_t sessionId, 907 bool suspended) override; 908 909 /* Create a patch between several source and sink ports */ 910 virtual status_t createAudioPatch(const struct audio_patch *patch, 911 audio_patch_handle_t *handle, 912 int delayMs); 913 914 /* Release a patch */ 915 virtual status_t releaseAudioPatch(audio_patch_handle_t handle, 916 int delayMs); 917 918 /* Set audio port configuration */ 919 virtual status_t setAudioPortConfig(const struct audio_port_config *config, int delayMs); 920 921 virtual void onAudioPortListUpdate(); 922 virtual void onAudioPatchListUpdate(); 923 virtual void onDynamicPolicyMixStateUpdate(String8 regId, int32_t state); 924 virtual void onRecordingConfigurationUpdate(int event, 925 const record_client_info_t *clientInfo, 926 const audio_config_base_t *clientConfig, 927 std::vector<effect_descriptor_t> clientEffects, 928 const audio_config_base_t *deviceConfig, 929 std::vector<effect_descriptor_t> effects, 930 audio_patch_handle_t patchHandle, 931 audio_source_t source); 932 933 virtual void onAudioVolumeGroupChanged(volume_group_t group, int flags); 934 935 virtual void onRoutingUpdated(); 936 937 virtual void onVolumeRangeInitRequest(); 938 939 virtual audio_unique_id_t newAudioUniqueId(audio_unique_id_use_t use); 940 941 void setSoundTriggerCaptureState(bool active) override; 942 943 status_t getAudioPort(struct audio_port_v7 *port) override; 944 945 status_t updateSecondaryOutputs( 946 const TrackSecondaryOutputsMap& trackSecondaryOutputs) override; 947 948 status_t setDeviceConnectedState( 949 const struct audio_port_v7 *port, media::DeviceConnectedState state) override; 950 951 status_t invalidateTracks(const std::vector<audio_port_handle_t>& portIds) override; 952 953 status_t getAudioMixPort(const struct audio_port_v7 *devicePort, 954 struct audio_port_v7 *port) override; 955 956 status_t setTracksInternalMute( 957 const std::vector<media::TrackInternalMuteInfo>& tracksInternalMute) override; 958 959 status_t getMmapPolicyInfos( 960 media::audio::common::AudioMMapPolicyType policyType, 961 std::vector<media::audio::common::AudioMMapPolicyInfo> *policyInfos) override; 962 963 error::BinderResult<bool> checkPermissionForInput(const AttributionSourceState& attr, 964 const PermissionReqs& req) override; 965 966 private: 967 AudioPolicyService *mAudioPolicyService; 968 }; 969 970 // --- Notification Client --- 971 class NotificationClient : public IBinder::DeathRecipient { 972 public: 973 NotificationClient(const sp<AudioPolicyService>& service, 974 const sp<media::IAudioPolicyServiceClient>& client, 975 uid_t uid, pid_t pid); 976 virtual ~NotificationClient(); 977 978 void onAudioPortListUpdate(); 979 void onAudioPatchListUpdate(); 980 void onDynamicPolicyMixStateUpdate(const String8& regId, 981 int32_t state); 982 void onAudioVolumeGroupChanged(volume_group_t group, int flags); 983 void onRecordingConfigurationUpdate( 984 int event, 985 const record_client_info_t *clientInfo, 986 const audio_config_base_t *clientConfig, 987 std::vector<effect_descriptor_t> clientEffects, 988 const audio_config_base_t *deviceConfig, 989 std::vector<effect_descriptor_t> effects, 990 audio_patch_handle_t patchHandle, 991 audio_source_t source); 992 void onRoutingUpdated(); 993 void onVolumeRangeInitRequest(); 994 void setAudioPortCallbacksEnabled(bool enabled); 995 void setAudioVolumeGroupCallbacksEnabled(bool enabled); 996 uid()997 uid_t uid() { 998 return mUid; 999 } 1000 1001 // IBinder::DeathRecipient 1002 virtual void binderDied(const wp<IBinder>& who); 1003 1004 private: 1005 NotificationClient(const NotificationClient&); 1006 NotificationClient& operator = (const NotificationClient&); 1007 1008 const wp<AudioPolicyService> mService; 1009 const uid_t mUid; 1010 const pid_t mPid; 1011 const sp<media::IAudioPolicyServiceClient> mAudioPolicyServiceClient; 1012 bool mAudioPortCallbacksEnabled; 1013 bool mAudioVolumeGroupCallbacksEnabled; 1014 }; 1015 1016 public: 1017 class AudioClient : public virtual RefBase { 1018 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 DeviceIdVector deviceIds)1019 AudioClient(const audio_attributes_t attributes, 1020 const audio_io_handle_t io, 1021 const AttributionSourceState& attributionSource, 1022 const audio_session_t session, audio_port_handle_t portId, 1023 const DeviceIdVector deviceIds) : 1024 attributes(attributes), io(io), attributionSource( 1025 attributionSource), session(session), portId(portId), 1026 deviceIds(deviceIds), active(false) {} 1027 ~AudioClient() override = default; 1028 1029 1030 const audio_attributes_t attributes; // source, flags ... 1031 const audio_io_handle_t io; // audio HAL stream IO handle 1032 const AttributionSourceState attributionSource; //client attributionsource 1033 const audio_session_t session; // audio session ID 1034 const audio_port_handle_t portId; 1035 const DeviceIdVector deviceIds; // selected input device port IDs 1036 bool active; // Playback/Capture is active or inactive 1037 }; 1038 private: 1039 1040 1041 1042 // --- AudioPlaybackClient --- 1043 // Information about each registered AudioTrack client 1044 // (between calls to getOutputForAttr() and releaseOutput()) 1045 class AudioPlaybackClient : public AudioClient { 1046 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,DeviceIdVector deviceIds,audio_stream_type_t stream,bool isSpatialized,audio_channel_mask_t channelMask)1047 AudioPlaybackClient(const audio_attributes_t attributes, 1048 const audio_io_handle_t io, AttributionSourceState attributionSource, 1049 const audio_session_t session, audio_port_handle_t portId, 1050 DeviceIdVector deviceIds, audio_stream_type_t stream, 1051 bool isSpatialized, audio_channel_mask_t channelMask) : 1052 AudioClient(attributes, io, attributionSource, session, portId, 1053 deviceIds), stream(stream), isSpatialized(isSpatialized), 1054 channelMask(channelMask) {} 1055 ~AudioPlaybackClient() override = default; 1056 1057 const audio_stream_type_t stream; 1058 const bool isSpatialized; 1059 const audio_channel_mask_t channelMask; 1060 }; 1061 1062 void getPlaybackClientAndEffects(audio_port_handle_t portId, 1063 sp<AudioPlaybackClient>& client, 1064 sp<AudioPolicyEffects>& effects, 1065 const char *context); 1066 1067 1068 // A class automatically clearing and restoring binder caller identity inside 1069 // a code block (scoped variable) 1070 // Declare one systematically before calling AudioPolicyManager methods so that they are 1071 // executed with the same level of privilege as audioserver process. 1072 class AutoCallerClear { 1073 public: AutoCallerClear()1074 AutoCallerClear() : 1075 mToken(IPCThreadState::self()->clearCallingIdentity()) {} ~AutoCallerClear()1076 ~AutoCallerClear() { 1077 IPCThreadState::self()->restoreCallingIdentity(mToken); 1078 } 1079 1080 private: 1081 const int64_t mToken; 1082 }; 1083 1084 // Internal dump utilities. 1085 status_t dumpPermissionDenial(int fd); 1086 void loadAudioPolicyManager(); 1087 void unloadAudioPolicyManager(); 1088 1089 /** 1090 * Returns the channel masks for active audio tracks on the specified output mixer. 1091 * The query can be specified to only include spatialized audio tracks or consider 1092 * all tracks. 1093 * @param output the I/O handle of the output mixer to consider 1094 * @param spatializedOnly true if only spatialized tracks should be considered 1095 * @return a list of channel masks for all active tracks matching the condition. 1096 */ 1097 std::vector<audio_channel_mask_t> getActiveTracksMasks_l( 1098 audio_io_handle_t output, bool spatializedOnly = true) REQUIRES(mMutex); 1099 1100 mutable audio_utils::mutex mMutex{audio_utils::MutexOrder::kAudioPolicyService_Mutex}; 1101 // prevents concurrent access to AudioPolicy manager functions changing 1102 // device connection state or routing. 1103 // mMutex protects AudioPolicyManager methods that can call into audio flinger 1104 // and possibly back in to audio policy service and acquire mEffectsLock. 1105 sp<AudioCommandThread> mAudioCommandThread; // audio commands thread 1106 sp<AudioCommandThread> mOutputCommandThread; // process stop and release output 1107 AudioPolicyInterface *mAudioPolicyManager; 1108 AudioPolicyClient *mAudioPolicyClient; 1109 std::vector<audio_usage_t> mSupportedSystemUsages; 1110 1111 mutable audio_utils::mutex mNotificationClientsMutex{ 1112 audio_utils::MutexOrder::kAudioPolicyService_NotificationClientsMutex}; 1113 DefaultKeyedVector<int64_t, sp<NotificationClient>> mNotificationClients 1114 GUARDED_BY(mNotificationClientsMutex); 1115 // Manage all effects configured in audio_effects.conf 1116 // never hold AudioPolicyService::mMutex when calling AudioPolicyEffects methods as 1117 // those can call back into AudioPolicyService methods and try to acquire the mutex 1118 sp<AudioPolicyEffects> mAudioPolicyEffects GUARDED_BY(mMutex); 1119 audio_mode_t mPhoneState GUARDED_BY(mMutex); 1120 uid_t mPhoneStateOwnerUid GUARDED_BY(mMutex); 1121 1122 sp<UidPolicy> mUidPolicy GUARDED_BY(mMutex); 1123 sp<SensorPrivacyPolicy> mSensorPrivacyPolicy GUARDED_BY(mMutex); 1124 1125 DefaultKeyedVector<audio_port_handle_t, sp<AudioRecordClient>> mAudioRecordClients 1126 GUARDED_BY(mMutex); 1127 DefaultKeyedVector<audio_port_handle_t, sp<AudioPlaybackClient>> mAudioPlaybackClients 1128 GUARDED_BY(mMutex); 1129 1130 MediaPackageManager mPackageManager; // To check allowPlaybackCapture 1131 1132 CaptureStateNotifier mCaptureStateNotifier; 1133 1134 // created in onFirstRef() and never cleared: does not need to be guarded by mMutex 1135 sp<Spatializer> mSpatializer; 1136 1137 void *mLibraryHandle = nullptr; 1138 CreateAudioPolicyManagerInstance mCreateAudioPolicyManager; 1139 DestroyAudioPolicyManagerInstance mDestroyAudioPolicyManager; 1140 std::unique_ptr<media::UsecaseValidator> mUsecaseValidator; 1141 const sp<NativePermissionController> mPermissionController; 1142 }; 1143 1144 } // namespace android 1145 1146 #endif // ANDROID_AUDIOPOLICYSERVICE_H 1147