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