1 /* 2 * Copyright (c) 2021-2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #ifndef ST_AUDIO_POLICY_SERVER_H 17 #define ST_AUDIO_POLICY_SERVER_H 18 19 #include <mutex> 20 #include <pthread.h> 21 22 #include "singleton.h" 23 #include "system_ability_definition.h" 24 #include "ipc_skeleton.h" 25 #include "system_ability.h" 26 #include "iservice_registry.h" 27 28 #include "accesstoken_kit.h" 29 #include "perm_state_change_callback_customize.h" 30 #include "power_state_callback_stub.h" 31 #include "power_state_listener.h" 32 #include "common_event_subscriber.h" 33 #include "common_event_support.h" 34 35 #include "bundle_mgr_interface.h" 36 #include "bundle_mgr_proxy.h" 37 38 #include "audio_info.h" 39 #include "audio_policy_service.h" 40 #include "audio_stream_removed_callback.h" 41 #include "audio_interrupt_callback.h" 42 #include "audio_policy_manager_stub.h" 43 #include "audio_policy_client_proxy.h" 44 #include "audio_server_death_recipient.h" 45 #include "session_processor.h" 46 #include "audio_spatialization_service.h" 47 #include "audio_policy_server_handler.h" 48 #include "audio_interrupt_service.h" 49 #include "audio_device_manager.h" 50 51 namespace OHOS { 52 namespace AudioStandard { 53 54 constexpr uint64_t DSTATUS_SESSION_ID = 4294967296; 55 constexpr uint32_t DSTATUS_DEFAULT_RATE = 48000; 56 constexpr int32_t LOCAL_USER_ID = 100; 57 58 class AudioPolicyService; 59 class AudioInterruptService; 60 class AudioPolicyServerHandler; 61 class AudioSessionService; 62 class BluetoothEventSubscriber; 63 64 class AudioPolicyServer : public SystemAbility, 65 public AudioPolicyManagerStub, 66 public AudioStreamRemovedCallback { 67 DECLARE_SYSTEM_ABILITY(AudioPolicyServer); 68 69 public: 70 DISALLOW_COPY_AND_MOVE(AudioPolicyServer); 71 72 enum DeathRecipientId { 73 TRACKER_CLIENT = 0, 74 LISTENER_CLIENT 75 }; 76 77 const std::vector<AudioStreamType> GET_STREAM_ALL_VOLUME_TYPES { 78 STREAM_MUSIC, 79 STREAM_VOICE_CALL, 80 STREAM_RING, 81 STREAM_VOICE_ASSISTANT, 82 STREAM_ALARM, 83 STREAM_ACCESSIBILITY, 84 STREAM_ULTRASONIC 85 }; 86 87 explicit AudioPolicyServer(int32_t systemAbilityId, bool runOnCreate = true); 88 ~AudioPolicyServer()89 virtual ~AudioPolicyServer() 90 { 91 AUDIO_WARNING_LOG("dtor should not happen"); 92 }; 93 94 void OnDump() override; 95 void OnStart() override; 96 void OnStop() override; 97 98 int32_t GetMaxVolumeLevel(AudioVolumeType volumeType) override; 99 100 int32_t GetMinVolumeLevel(AudioVolumeType volumeType) override; 101 102 int32_t SetSystemVolumeLevelLegacy(AudioVolumeType volumeType, int32_t volumeLevel) override; 103 104 int32_t SetSystemVolumeLevel(AudioVolumeType volumeType, int32_t volumeLevel, int32_t volumeFlag = 0) override; 105 106 AudioStreamType GetSystemActiveVolumeType(const int32_t clientUid) override; 107 108 int32_t GetSystemVolumeLevel(AudioStreamType streamType) override; 109 110 int32_t SetLowPowerVolume(int32_t streamId, float volume) override; 111 112 float GetLowPowerVolume(int32_t streamId) override; 113 114 float GetSingleStreamVolume(int32_t streamId) override; 115 116 int32_t SetStreamMuteLegacy(AudioStreamType streamType, bool mute) override; 117 118 int32_t SetStreamMute(AudioStreamType streamType, bool mute) override; 119 120 bool GetStreamMute(AudioStreamType streamType) override; 121 122 bool IsStreamActive(AudioStreamType streamType) override; 123 124 bool IsVolumeUnadjustable() override; 125 126 int32_t AdjustVolumeByStep(VolumeAdjustType adjustType) override; 127 128 int32_t AdjustSystemVolumeByStep(AudioVolumeType volumeType, VolumeAdjustType adjustType) override; 129 130 float GetSystemVolumeInDb(AudioVolumeType volumeType, int32_t volumeLevel, DeviceType deviceType) override; 131 132 bool IsArmUsbDevice(const AudioDeviceDescriptor &desc) override; 133 134 int32_t SelectOutputDevice(sptr<AudioRendererFilter> audioRendererFilter, 135 std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) override; 136 137 std::string GetSelectedDeviceInfo(int32_t uid, int32_t pid, AudioStreamType streamType) override; 138 139 int32_t SelectInputDevice(sptr<AudioCapturerFilter> audioCapturerFilter, 140 std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) override; 141 142 std::vector<sptr<AudioDeviceDescriptor>> GetDevices(DeviceFlag deviceFlag) override; 143 144 std::vector<sptr<AudioDeviceDescriptor>> GetDevicesInner(DeviceFlag deviceFlag) override; 145 146 int32_t NotifyCapturerAdded(AudioCapturerInfo capturerInfo, AudioStreamInfo streamInfo, 147 uint32_t sessionId) override; 148 149 int32_t SetDeviceActive(InternalDeviceType deviceType, bool active) override; 150 151 bool IsDeviceActive(InternalDeviceType deviceType) override; 152 153 InternalDeviceType GetActiveOutputDevice() override; 154 155 InternalDeviceType GetActiveInputDevice() override; 156 157 int32_t SetRingerModeLegacy(AudioRingerMode ringMode) override; 158 159 int32_t SetRingerMode(AudioRingerMode ringMode) override; 160 161 #ifdef FEATURE_DTMF_TONE 162 std::vector<int32_t> GetSupportedTones() override; 163 164 std::shared_ptr<ToneInfo> GetToneConfig(int32_t ltonetype) override; 165 #endif 166 167 AudioRingerMode GetRingerMode() override; 168 169 int32_t SetAudioScene(AudioScene audioScene) override; 170 171 int32_t SetMicrophoneMuteCommon(bool isMute, bool isLegacy); 172 173 int32_t SetMicrophoneMute(bool isMute) override; 174 175 int32_t SetMicrophoneMuteAudioConfig(bool isMute) override; 176 177 int32_t SetMicrophoneMutePersistent(const bool isMute, const PolicyType type) override; 178 179 bool GetPersistentMicMuteState() override; 180 181 bool IsMicrophoneMuteLegacy() override; 182 183 bool IsMicrophoneMute() override; 184 185 AudioScene GetAudioScene() override; 186 187 int32_t ActivateAudioSession(const AudioSessionStrategy &strategy) override; 188 189 int32_t DeactivateAudioSession() override; 190 191 bool IsAudioSessionActivated() override; 192 193 int32_t SetAudioInterruptCallback(const uint32_t sessionID, 194 const sptr<IRemoteObject> &object, uint32_t clientUid, const int32_t zoneId = 0) override; 195 196 int32_t UnsetAudioInterruptCallback(const uint32_t sessionID, const int32_t zoneId = 0) override; 197 198 int32_t ActivateAudioInterrupt(const AudioInterrupt &audioInterrupt, const int32_t zoneId = 0, 199 const bool isUpdatedAudioStrategy = false) override; 200 201 int32_t DeactivateAudioInterrupt(const AudioInterrupt &audioInterrupt, const int32_t zoneId = 0) override; 202 203 int32_t SetAudioManagerInterruptCallback(const int32_t clientId, const sptr<IRemoteObject> &object) override; 204 205 int32_t UnsetAudioManagerInterruptCallback(const int32_t clientId) override; 206 207 int32_t SetQueryClientTypeCallback(const sptr<IRemoteObject> &object) override; 208 209 int32_t RequestAudioFocus(const int32_t clientId, const AudioInterrupt &audioInterrupt) override; 210 211 int32_t AbandonAudioFocus(const int32_t clientId, const AudioInterrupt &audioInterrupt) override; 212 213 AudioStreamType GetStreamInFocus(const int32_t zoneId = 0) override; 214 215 int32_t GetSessionInfoInFocus(AudioInterrupt &audioInterrupt, const int32_t zoneId = 0) override; 216 217 void OnAudioStreamRemoved(const uint64_t sessionID) override; 218 219 void ProcessSessionRemoved(const uint64_t sessionID, const int32_t zoneId = 0); 220 221 void ProcessSessionAdded(SessionEvent sessionEvent); 222 223 void ProcessorCloseWakeupSource(const uint64_t sessionID); 224 225 int32_t Dump(int32_t fd, const std::vector<std::u16string> &args) override; 226 227 bool CheckRecordingCreate(uint32_t appTokenId, uint64_t appFullTokenId, int32_t appUid, 228 SourceType sourceType = SOURCE_TYPE_MIC) override; 229 230 bool CheckRecordingStateChange(uint32_t appTokenId, uint64_t appFullTokenId, int32_t appUid, 231 AudioPermissionState state) override; 232 233 int32_t ReconfigureAudioChannel(const uint32_t &count, DeviceType deviceType) override; 234 235 int32_t GetAudioLatencyFromXml() override; 236 237 uint32_t GetSinkLatencyFromXml() override; 238 239 int32_t GetPreferredOutputStreamType(AudioRendererInfo &rendererInfo) override; 240 241 int32_t GetPreferredInputStreamType(AudioCapturerInfo &capturerInfo) override; 242 243 int32_t RegisterTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo, 244 const sptr<IRemoteObject> &object) override; 245 246 int32_t UpdateTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo) override; 247 248 int32_t GetCurrentRendererChangeInfos( 249 std::vector<std::unique_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos) override; 250 251 int32_t GetCurrentCapturerChangeInfos( 252 std::vector<std::unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos) override; 253 254 void RegisterClientDeathRecipient(const sptr<IRemoteObject> &object, DeathRecipientId id); 255 256 void RegisteredTrackerClientDied(int uid); 257 258 void RegisteredStreamListenerClientDied(int pid); 259 260 bool IsAudioRendererLowLatencySupported(const AudioStreamInfo &audioStreamInfo) override; 261 262 int32_t UpdateStreamState(const int32_t clientUid, StreamSetState streamSetState, 263 StreamUsage streamUsage) override; 264 265 int32_t GetVolumeGroupInfos(std::string networkId, std::vector<sptr<VolumeGroupInfo>> &infos) override; 266 267 int32_t GetSupportedAudioEffectProperty(AudioEffectPropertyArrayV3 &propertyArray) override; 268 int32_t SetAudioEffectProperty(const AudioEffectPropertyArrayV3 &propertyArray) override; 269 int32_t GetAudioEffectProperty(AudioEffectPropertyArrayV3 &propertyArray) override; 270 271 int32_t GetNetworkIdByGroupId(int32_t groupId, std::string &networkId) override; 272 273 std::vector<sptr<AudioDeviceDescriptor>> GetPreferredOutputDeviceDescriptors( 274 AudioRendererInfo &rendererInfo) override; 275 276 std::vector<sptr<AudioDeviceDescriptor>> GetPreferredInputDeviceDescriptors( 277 AudioCapturerInfo &captureInfo) override; 278 279 int32_t SetClientCallbacksEnable(const CallbackChange &callbackchange, const bool &enable) override; 280 281 int32_t GetAudioFocusInfoList(std::list<std::pair<AudioInterrupt, AudioFocuState>> &focusInfoList, 282 const int32_t zoneId = 0) override; 283 284 int32_t SetSystemSoundUri(const std::string &key, const std::string &uri) override; 285 286 std::string GetSystemSoundUri(const std::string &key) override; 287 288 float GetMinStreamVolume(void) override; 289 290 float GetMaxStreamVolume(void) override; 291 292 int32_t CheckMaxRendererInstances() override; 293 294 void GetStreamVolumeInfoMap(StreamVolumeInfoMap& streamVolumeInfos); 295 296 int32_t QueryEffectSceneMode(SupportedEffectConfig &supportedEffectConfig) override; 297 298 int32_t GetHardwareOutputSamplingRate(const sptr<AudioDeviceDescriptor> &desc) override; 299 300 std::vector<sptr<MicrophoneDescriptor>> GetAudioCapturerMicrophoneDescriptors(int32_t sessionId) override; 301 302 std::vector<sptr<MicrophoneDescriptor>> GetAvailableMicrophones() override; 303 304 int32_t SetDeviceAbsVolumeSupported(const std::string &macAddress, const bool support) override; 305 306 bool IsAbsVolumeScene() override; 307 308 bool IsVgsVolumeSupported() override; 309 310 int32_t SetA2dpDeviceVolume(const std::string &macAddress, const int32_t volume, const bool updateUi) override; 311 312 std::vector<std::unique_ptr<AudioDeviceDescriptor>> GetAvailableDevices(AudioDeviceUsage usage) override; 313 314 int32_t SetAvailableDeviceChangeCallback(const int32_t /*clientId*/, const AudioDeviceUsage usage, 315 const sptr<IRemoteObject> &object) override; 316 317 int32_t UnsetAvailableDeviceChangeCallback(const int32_t clientId, AudioDeviceUsage usage) override; 318 319 bool IsSpatializationEnabled() override; 320 321 bool IsSpatializationEnabled(const std::string address) override; 322 323 int32_t SetSpatializationEnabled(const bool enable) override; 324 325 int32_t SetSpatializationEnabled(const sptr<AudioDeviceDescriptor> &selectedAudioDevice, 326 const bool enable) override; 327 328 bool IsHeadTrackingEnabled() override; 329 330 bool IsHeadTrackingEnabled(const std::string address) override; 331 332 int32_t SetHeadTrackingEnabled(const bool enable) override; 333 334 int32_t SetHeadTrackingEnabled(const sptr<AudioDeviceDescriptor> &selectedAudioDevice, const bool enable) override; 335 336 AudioSpatializationState GetSpatializationState(const StreamUsage streamUsage) override; 337 338 bool IsSpatializationSupported() override; 339 340 bool IsSpatializationSupportedForDevice(const std::string address) override; 341 342 bool IsHeadTrackingSupported() override; 343 344 bool IsHeadTrackingSupportedForDevice(const std::string address) override; 345 346 int32_t UpdateSpatialDeviceState(const AudioSpatialDeviceState audioSpatialDeviceState) override; 347 348 int32_t RegisterSpatializationStateEventListener(const uint32_t sessionID, const StreamUsage streamUsage, 349 const sptr<IRemoteObject> &object) override; 350 351 int32_t ConfigDistributedRoutingRole(const sptr<AudioDeviceDescriptor> descriptor, CastType type) override; 352 353 int32_t SetDistributedRoutingRoleCallback(const sptr<IRemoteObject> &object) override; 354 355 int32_t UnsetDistributedRoutingRoleCallback() override; 356 357 int32_t UnregisterSpatializationStateEventListener(const uint32_t sessionID) override; 358 359 int32_t RegisterPolicyCallbackClient(const sptr<IRemoteObject> &object, const int32_t zoneId = 0) override; 360 361 int32_t CreateAudioInterruptZone(const std::set<int32_t> &pids, const int32_t zoneId) override; 362 363 int32_t AddAudioInterruptZonePids(const std::set<int32_t> &pids, const int32_t zoneId) override; 364 365 int32_t RemoveAudioInterruptZonePids(const std::set<int32_t> &pids, const int32_t zoneId) override; 366 367 int32_t ReleaseAudioInterruptZone(const int32_t zoneId) override; 368 369 int32_t SetCallDeviceActive(InternalDeviceType deviceType, bool active, std::string address) override; 370 371 std::unique_ptr<AudioDeviceDescriptor> GetActiveBluetoothDevice() override; 372 373 void FetchOutputDeviceForTrack(AudioStreamChangeInfo &streamChangeInfo, 374 const AudioStreamDeviceChangeReasonExt reason) override; 375 376 void FetchInputDeviceForTrack(AudioStreamChangeInfo &streamChangeInfo) override; 377 378 ConverterConfig GetConverterConfig() override; 379 380 AudioSpatializationSceneType GetSpatializationSceneType() override; 381 382 int32_t SetSpatializationSceneType(const AudioSpatializationSceneType spatializationSceneType) override; 383 384 float GetMaxAmplitude(const int32_t deviceId) override; 385 386 int32_t DisableSafeMediaVolume() override; 387 388 bool IsHeadTrackingDataRequested(const std::string &macAddress) override; 389 390 int32_t SetAudioDeviceRefinerCallback(const sptr<IRemoteObject> &object) override; 391 392 int32_t UnsetAudioDeviceRefinerCallback() override; 393 394 int32_t TriggerFetchDevice( 395 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN) override; 396 397 int32_t SetPreferredDevice(const PreferredType preferredType, 398 const sptr<AudioDeviceDescriptor> &desc) override; 399 400 void SaveRemoteInfo(const std::string &networkId, DeviceType deviceType) override; 401 402 int32_t MoveToNewPipe(const uint32_t sessionId, const AudioPipeType pipeType) override; 403 404 int32_t SetAudioConcurrencyCallback(const uint32_t sessionID, const sptr<IRemoteObject> &object) override; 405 406 int32_t UnsetAudioConcurrencyCallback(const uint32_t sessionID) override; 407 408 int32_t ActivateAudioConcurrency(const AudioPipeType &pipeType) override; 409 410 int32_t InjectInterruption(const std::string networkId, InterruptEvent &event) override; 411 412 int32_t LoadSplitModule(const std::string &splitArgs, const std::string &networkId) override; 413 414 int32_t SetVoiceRingtoneMute(bool isMute) override; 415 416 int32_t SetDefaultOutputDevice(const DeviceType deviceType, const uint32_t sessionID, 417 const StreamUsage streamUsage, bool isRunning) override; 418 419 void ProcessRemoteInterrupt(std::set<int32_t> sessionIds, InterruptEventInternal interruptEvent); 420 421 class RemoteParameterCallback : public AudioParameterCallback { 422 public: 423 RemoteParameterCallback(sptr<AudioPolicyServer> server); 424 // AudioParameterCallback 425 void OnAudioParameterChange(const std::string networkId, const AudioParamKey key, const std::string& condition, 426 const std::string& value) override; 427 private: 428 sptr<AudioPolicyServer> server_; 429 void VolumeOnChange(const std::string networkId, const std::string& condition); 430 void InterruptOnChange(const std::string networkId, const std::string& condition); 431 void StateOnChange(const std::string networkId, const std::string& condition, const std::string& value); 432 }; 433 434 std::shared_ptr<RemoteParameterCallback> remoteParameterCallback_; 435 436 class PerStateChangeCbCustomizeCallback : public Security::AccessToken::PermStateChangeCallbackCustomize { 437 public: PerStateChangeCbCustomizeCallback(const Security::AccessToken::PermStateChangeScope & scopeInfo,sptr<AudioPolicyServer> server)438 explicit PerStateChangeCbCustomizeCallback(const Security::AccessToken::PermStateChangeScope &scopeInfo, 439 sptr<AudioPolicyServer> server) : PermStateChangeCallbackCustomize(scopeInfo), 440 ready_(false), server_(server) {} ~PerStateChangeCbCustomizeCallback()441 ~PerStateChangeCbCustomizeCallback() {} 442 443 void PermStateChangeCallback(Security::AccessToken::PermStateChangeInfo& result); 444 int32_t getUidByBundleName(std::string bundle_name, int user_id); 445 void UpdateMicPrivacyByCapturerState(bool targetMuteState, uint32_t targetTokenId, int32_t appUid); 446 447 bool ready_; 448 private: 449 sptr<AudioPolicyServer> server_; 450 }; 451 452 bool IsHighResolutionExist() override; 453 454 int32_t SetHighResolutionExist(bool highResExist) override; 455 456 void NotifyAccountsChanged(const int &id); 457 458 // for hidump 459 void AudioDevicesDump(std::string &dumpString); 460 void AudioModeDump(std::string &dumpString); 461 void AudioInterruptZoneDump(std::string &dumpString); 462 void AudioPolicyParserDump(std::string &dumpString); 463 void AudioVolumeDump(std::string &dumpString); 464 void AudioStreamDump(std::string &dumpString); 465 void OffloadStatusDump(std::string &dumpString); 466 void XmlParsedDataMapDump(std::string &dumpString); 467 void EffectManagerInfoDump(std::string &dumpString); 468 void MicrophoneMuteInfoDump(std::string &dumpString); 469 470 protected: 471 void OnAddSystemAbility(int32_t systemAbilityId, const std::string& deviceId) override; 472 473 void RegisterParamCallback(); 474 475 void OnRemoveSystemAbility(int32_t systemAbilityId, const std::string& deviceId) override; 476 477 private: 478 friend class AudioInterruptService; 479 480 static constexpr int32_t MAX_VOLUME_LEVEL = 15; 481 static constexpr int32_t MIN_VOLUME_LEVEL = 0; 482 static constexpr int32_t VOLUME_CHANGE_FACTOR = 1; 483 static constexpr int32_t VOLUME_KEY_DURATION = 0; 484 static constexpr int32_t VOLUME_MUTE_KEY_DURATION = 1; 485 static constexpr int32_t MEDIA_SERVICE_UID = 1013; 486 static constexpr int32_t EDM_SERVICE_UID = 3057; 487 static constexpr char DAUDIO_DEV_TYPE_SPK = '1'; 488 static constexpr char DAUDIO_DEV_TYPE_MIC = '2'; 489 static constexpr int32_t AUDIO_UID = 1041; 490 static constexpr uint32_t MICPHONE_CALLER = 0; 491 492 static const std::list<uid_t> RECORD_ALLOW_BACKGROUND_LIST; 493 static const std::list<uid_t> RECORD_PASS_APPINFO_LIST; 494 495 class AudioPolicyServerPowerStateCallback : public PowerMgr::PowerStateCallbackStub { 496 public: 497 AudioPolicyServerPowerStateCallback(AudioPolicyServer *policyServer); 498 void OnAsyncPowerStateChanged(PowerMgr::PowerState state) override; 499 500 private: 501 AudioPolicyServer *policyServer_; 502 }; 503 504 int32_t VerifyVoiceCallPermission(uint64_t fullTokenId, Security::AccessToken::AccessTokenID tokenId); 505 506 // offload session 507 void OffloadStreamCheck(int64_t activateSessionId, int64_t deactivateSessionId); 508 void CheckSubscribePowerStateChange(); 509 510 void CheckStreamMode(const int64_t activateSessionId); 511 bool CheckAudioSessionStrategy(const AudioSessionStrategy &sessionStrategy); 512 513 // for audio volume and mute status 514 int32_t SetRingerModeInternal(AudioRingerMode ringMode, bool hasUpdatedVolume = false); 515 int32_t SetSystemVolumeLevelInternal(AudioStreamType streamType, int32_t volumeLevel, bool isUpdateUi); 516 int32_t SetSingleStreamVolume(AudioStreamType streamType, int32_t volumeLevel, bool isUpdateUi, bool mute); 517 AudioStreamType GetSystemActiveVolumeTypeInternal(const int32_t clientUid); 518 int32_t GetSystemVolumeLevelInternal(AudioStreamType streamType); 519 float GetSystemVolumeDb(AudioStreamType streamType); 520 int32_t SetStreamMuteInternal(AudioStreamType streamType, bool mute, bool isUpdateUi); 521 int32_t SetSingleStreamMute(AudioStreamType streamType, bool mute, bool isUpdateUi); 522 bool GetStreamMuteInternal(AudioStreamType streamType); 523 bool IsVolumeTypeValid(AudioStreamType streamType); 524 bool IsVolumeLevelValid(AudioStreamType streamType, int32_t volumeLevel); 525 526 // Permission and privacy 527 bool VerifyPermission(const std::string &permission, uint32_t tokenId = 0, bool isRecording = false); 528 bool VerifyBluetoothPermission(); 529 int32_t OffloadStopPlaying(const AudioInterrupt &audioInterrupt); 530 int32_t SetAudioSceneInternal(AudioScene audioScene); 531 532 AppExecFwk::BundleInfo GetBundleInfoFromUid(); 533 int32_t GetApiTargerVersion(); 534 535 // externel function call 536 #ifdef FEATURE_MULTIMODALINPUT_INPUT 537 bool MaxOrMinVolumeOption(const int32_t &volLevel, const int32_t keyType, const AudioStreamType &streamInFocus); 538 int32_t RegisterVolumeKeyEvents(const int32_t keyType); 539 int32_t RegisterVolumeKeyMuteEvents(); 540 void SubscribeVolumeKeyEvents(); 541 #endif 542 void AddAudioServiceOnStart(); 543 void SubscribeOsAccountChangeEvents(); 544 void SubscribePowerStateChangeEvents(); 545 void SubscribeCommonEvent(const std::string event); 546 void OnReceiveEvent(const EventFwk::CommonEventData &eventData); 547 void HandleKvDataShareEvent(); 548 void InitMicrophoneMute(); 549 void InitKVStore(); 550 void ConnectServiceAdapter(); 551 void LoadEffectLibrary(); 552 void RegisterBluetoothListener(); 553 void SubscribeAccessibilityConfigObserver(); 554 void RegisterDataObserver(); 555 void RegisterPowerStateListener(); 556 void UnRegisterPowerStateListener(); 557 void RegisterSyncHibernateListener(); 558 void UnRegisterSyncHibernateListener(); 559 void OnDistributedRoutingRoleChange(const sptr<AudioDeviceDescriptor> descriptor, const CastType type); 560 561 void InitPolicyDumpMap(); 562 void PolicyDataDump(std::string &dumpString); 563 void ArgInfoDump(std::string &dumpString, std::queue<std::u16string> &argQue); 564 void InfoDumpHelp(std::string &dumpString); 565 566 int32_t SetRingerModeInner(AudioRingerMode ringMode); 567 568 // for updating default device selection state when game audio stream is muted 569 void UpdateDefaultOutputDeviceWhenStarting(const uint32_t sessionID); 570 void UpdateDefaultOutputDeviceWhenStopping(const uint32_t sessionID); 571 572 AudioPolicyService& audioPolicyService_; 573 AudioDeviceManager &audioDeviceManager_; 574 std::shared_ptr<AudioInterruptService> interruptService_; 575 576 int32_t volumeStep_; 577 std::atomic<bool> isFirstAudioServiceStart_ = false; 578 std::atomic<bool> isInitMuteState_ = false; 579 #ifdef FEATURE_MULTIMODALINPUT_INPUT 580 std::atomic<bool> hasSubscribedVolumeKeyEvents_ = false; 581 #endif 582 std::vector<pid_t> clientDiedListenerState_; 583 sptr<PowerStateListener> powerStateListener_; 584 sptr<SyncHibernateListener> syncHibernateListener_; 585 bool powerStateCallbackRegister_; 586 587 std::mutex keyEventMutex_; 588 std::mutex micStateChangeMutex_; 589 std::mutex clientDiedListenerStateMutex_; 590 591 SessionProcessor sessionProcessor_{ 592 [this] (const uint64_t sessionID, const int32_t zoneID) { this->ProcessSessionRemoved(sessionID, zoneID); }, 593 [this] (SessionEvent sessionEvent) { this->ProcessSessionAdded(sessionEvent); }, 594 [this] (const uint64_t sessionID) {this->ProcessorCloseWakeupSource(sessionID); }}; 595 596 AudioSpatializationService& audioSpatializationService_; 597 std::shared_ptr<AudioPolicyServerHandler> audioPolicyServerHandler_; 598 bool volumeApplyToAll_ = false; 599 600 bool isHighResolutionExist_ = false; 601 std::mutex descLock_; 602 AudioRouterCenter &audioRouterCenter_; 603 using DumpFunc = void(AudioPolicyServer::*)(std::string &dumpString); 604 std::map<std::u16string, DumpFunc> dumpFuncMap; 605 pid_t lastMicMuteSettingPid_ = 0; 606 std::string GetBundleName(); 607 std::shared_ptr<AudioOsAccountInfo> accountObserver_ = nullptr; 608 int32_t sessionIdByRemote_ = -1; 609 }; 610 611 class AudioOsAccountInfo : public AccountSA::OsAccountSubscriber { 612 public: AudioOsAccountInfo(const AccountSA::OsAccountSubscribeInfo & subscribeInfo,AudioPolicyServer * audioPolicyServer)613 explicit AudioOsAccountInfo(const AccountSA::OsAccountSubscribeInfo &subscribeInfo, 614 AudioPolicyServer *audioPolicyServer) : AccountSA::OsAccountSubscriber(subscribeInfo), 615 audioPolicyServer_(audioPolicyServer) {} 616 ~AudioOsAccountInfo()617 ~AudioOsAccountInfo() 618 { 619 AUDIO_WARNING_LOG("Destructor AudioOsAccountInfo"); 620 } 621 OnAccountsChanged(const int & id)622 void OnAccountsChanged(const int &id) override 623 { 624 AUDIO_INFO_LOG("OnAccountsChanged received, id: %{public}d", id); 625 } 626 OnAccountsSwitch(const int & newId,const int & oldId)627 void OnAccountsSwitch(const int &newId, const int &oldId) override 628 { 629 CHECK_AND_RETURN_LOG(oldId >= LOCAL_USER_ID, "invalid id"); 630 AUDIO_INFO_LOG("OnAccountsSwitch received, newid: %{public}d, oldid: %{public}d", newId, oldId); 631 if (audioPolicyServer_ != nullptr) { 632 audioPolicyServer_->NotifyAccountsChanged(newId); 633 } 634 } 635 private: 636 AudioPolicyServer *audioPolicyServer_; 637 }; 638 639 class AudioCommonEventSubscriber : public EventFwk::CommonEventSubscriber { 640 public: AudioCommonEventSubscriber(const EventFwk::CommonEventSubscribeInfo & subscribeInfo,std::function<void (const EventFwk::CommonEventData &)> receiver)641 explicit AudioCommonEventSubscriber(const EventFwk::CommonEventSubscribeInfo &subscribeInfo, 642 std::function<void(const EventFwk::CommonEventData&)> receiver) 643 : EventFwk::CommonEventSubscriber(subscribeInfo), eventReceiver_(receiver) {} ~AudioCommonEventSubscriber()644 ~AudioCommonEventSubscriber() {} 645 void OnReceiveEvent(const EventFwk::CommonEventData &eventData) override; 646 private: 647 AudioCommonEventSubscriber() = default; 648 std::function<void(const EventFwk::CommonEventData&)> eventReceiver_; 649 }; 650 } // namespace AudioStandard 651 } // namespace OHOS 652 #endif // ST_AUDIO_POLICY_SERVER_H 653