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