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