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