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 50 namespace OHOS { 51 namespace AudioStandard { 52 53 constexpr uint64_t DSTATUS_SESSION_ID = 4294967296; 54 constexpr uint32_t DSTATUS_DEFAULT_RATE = 48000; 55 constexpr int32_t LOCAL_USER_ID = 100; 56 57 class AudioPolicyService; 58 class AudioInterruptService; 59 class AudioPolicyServerHandler; 60 class AudioSessionService; 61 class BluetoothEventSubscriber; 62 63 class AudioPolicyServer : public SystemAbility, 64 public AudioPolicyManagerStub, 65 public AudioStreamRemovedCallback { 66 DECLARE_SYSTEM_ABILITY(AudioPolicyServer); 67 68 public: 69 DISALLOW_COPY_AND_MOVE(AudioPolicyServer); 70 71 enum DeathRecipientId { 72 TRACKER_CLIENT = 0, 73 LISTENER_CLIENT 74 }; 75 76 const std::vector<AudioStreamType> GET_STREAM_ALL_VOLUME_TYPES { 77 STREAM_MUSIC, 78 STREAM_VOICE_CALL, 79 STREAM_RING, 80 STREAM_VOICE_ASSISTANT, 81 STREAM_ALARM, 82 STREAM_ACCESSIBILITY, 83 STREAM_ULTRASONIC 84 }; 85 86 explicit AudioPolicyServer(int32_t systemAbilityId, bool runOnCreate = true); 87 ~AudioPolicyServer()88 virtual ~AudioPolicyServer() 89 { 90 AUDIO_WARNING_LOG("dtor should not happen"); 91 }; 92 93 void OnDump() override; 94 void OnStart() override; 95 void OnStop() override; 96 97 int32_t GetMaxVolumeLevel(AudioVolumeType volumeType) override; 98 99 int32_t GetMinVolumeLevel(AudioVolumeType volumeType) override; 100 101 int32_t SetSystemVolumeLevelLegacy(AudioVolumeType volumeType, int32_t volumeLevel) override; 102 103 int32_t SetSystemVolumeLevel(AudioVolumeType volumeType, int32_t volumeLevel, int32_t volumeFlag = 0) override; 104 105 AudioStreamType GetSystemActiveVolumeType(const int32_t clientUid) override; 106 107 int32_t GetSystemVolumeLevel(AudioStreamType streamType) override; 108 109 int32_t SetLowPowerVolume(int32_t streamId, float volume) override; 110 111 float GetLowPowerVolume(int32_t streamId) override; 112 113 float GetSingleStreamVolume(int32_t streamId) override; 114 115 int32_t SetStreamMuteLegacy(AudioStreamType streamType, bool mute) override; 116 117 int32_t SetStreamMute(AudioStreamType streamType, bool mute) override; 118 119 bool GetStreamMute(AudioStreamType streamType) override; 120 121 bool IsStreamActive(AudioStreamType streamType) override; 122 123 bool IsVolumeUnadjustable() override; 124 125 int32_t AdjustVolumeByStep(VolumeAdjustType adjustType) override; 126 127 int32_t AdjustSystemVolumeByStep(AudioVolumeType volumeType, VolumeAdjustType adjustType) override; 128 129 float GetSystemVolumeInDb(AudioVolumeType volumeType, int32_t volumeLevel, DeviceType deviceType) override; 130 131 bool IsArmUsbDevice(const AudioDeviceDescriptor &desc) override; 132 133 int32_t SelectOutputDevice(sptr<AudioRendererFilter> audioRendererFilter, 134 std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) override; 135 136 std::string GetSelectedDeviceInfo(int32_t uid, int32_t pid, AudioStreamType streamType) override; 137 138 int32_t SelectInputDevice(sptr<AudioCapturerFilter> audioCapturerFilter, 139 std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) override; 140 141 std::vector<sptr<AudioDeviceDescriptor>> GetDevices(DeviceFlag deviceFlag) override; 142 143 std::vector<sptr<AudioDeviceDescriptor>> GetDevicesInner(DeviceFlag deviceFlag) override; 144 145 int32_t NotifyCapturerAdded(AudioCapturerInfo capturerInfo, AudioStreamInfo streamInfo, 146 uint32_t sessionId) override; 147 148 int32_t SetDeviceActive(InternalDeviceType deviceType, bool active) override; 149 150 bool IsDeviceActive(InternalDeviceType deviceType) override; 151 152 InternalDeviceType GetActiveOutputDevice() override; 153 154 InternalDeviceType GetActiveInputDevice() override; 155 156 int32_t SetRingerModeLegacy(AudioRingerMode ringMode) override; 157 158 int32_t SetRingerMode(AudioRingerMode ringMode) override; 159 160 #ifdef FEATURE_DTMF_TONE 161 std::vector<int32_t> GetSupportedTones() override; 162 163 std::shared_ptr<ToneInfo> GetToneConfig(int32_t ltonetype) override; 164 #endif 165 166 AudioRingerMode GetRingerMode() override; 167 168 int32_t SetAudioScene(AudioScene audioScene) override; 169 170 int32_t SetMicrophoneMuteCommon(bool isMute, bool isLegacy); 171 172 int32_t SetMicrophoneMute(bool isMute) override; 173 174 int32_t SetMicrophoneMuteAudioConfig(bool isMute) override; 175 176 int32_t SetMicrophoneMutePersistent(const bool isMute, const PolicyType type) override; 177 178 bool GetPersistentMicMuteState() override; 179 180 bool IsMicrophoneMuteLegacy() override; 181 182 bool IsMicrophoneMute() override; 183 184 AudioScene GetAudioScene() override; 185 186 int32_t ActivateAudioSession(const AudioSessionStrategy &strategy) override; 187 188 int32_t DeactivateAudioSession() override; 189 190 bool IsAudioSessionActivated() override; 191 192 int32_t SetAudioInterruptCallback(const uint32_t sessionID, 193 const sptr<IRemoteObject> &object, uint32_t clientUid, const int32_t zoneId = 0) override; 194 195 int32_t UnsetAudioInterruptCallback(const uint32_t sessionID, const int32_t zoneId = 0) override; 196 197 int32_t ActivateAudioInterrupt(const AudioInterrupt &audioInterrupt, const int32_t zoneId = 0, 198 const bool isUpdatedAudioStrategy = false) override; 199 200 int32_t DeactivateAudioInterrupt(const AudioInterrupt &audioInterrupt, const int32_t zoneId = 0) override; 201 202 int32_t SetAudioManagerInterruptCallback(const int32_t clientId, const sptr<IRemoteObject> &object) override; 203 204 int32_t UnsetAudioManagerInterruptCallback(const int32_t clientId) override; 205 206 int32_t SetQueryClientTypeCallback(const sptr<IRemoteObject> &object) override; 207 208 int32_t RequestAudioFocus(const int32_t clientId, const AudioInterrupt &audioInterrupt) override; 209 210 int32_t AbandonAudioFocus(const int32_t clientId, const AudioInterrupt &audioInterrupt) override; 211 212 AudioStreamType GetStreamInFocus(const int32_t zoneId = 0) override; 213 214 int32_t GetSessionInfoInFocus(AudioInterrupt &audioInterrupt, const int32_t zoneId = 0) override; 215 216 void OnAudioStreamRemoved(const uint64_t sessionID) override; 217 218 void ProcessSessionRemoved(const uint64_t sessionID, const int32_t zoneId = 0); 219 220 void ProcessSessionAdded(SessionEvent sessionEvent); 221 222 void ProcessorCloseWakeupSource(const uint64_t sessionID); 223 224 int32_t Dump(int32_t fd, const std::vector<std::u16string> &args) override; 225 226 bool CheckRecordingCreate(uint32_t appTokenId, uint64_t appFullTokenId, int32_t appUid, 227 SourceType sourceType = SOURCE_TYPE_MIC) override; 228 229 bool CheckRecordingStateChange(uint32_t appTokenId, uint64_t appFullTokenId, int32_t appUid, 230 AudioPermissionState state) override; 231 232 int32_t ReconfigureAudioChannel(const uint32_t &count, DeviceType deviceType) override; 233 234 int32_t GetAudioLatencyFromXml() override; 235 236 uint32_t GetSinkLatencyFromXml() override; 237 238 int32_t GetPreferredOutputStreamType(AudioRendererInfo &rendererInfo) override; 239 240 int32_t GetPreferredInputStreamType(AudioCapturerInfo &capturerInfo) override; 241 242 int32_t RegisterTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo, 243 const sptr<IRemoteObject> &object) override; 244 245 int32_t UpdateTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo) override; 246 247 int32_t GetCurrentRendererChangeInfos( 248 std::vector<std::unique_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos) override; 249 250 int32_t GetCurrentCapturerChangeInfos( 251 std::vector<std::unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos) override; 252 253 void RegisterClientDeathRecipient(const sptr<IRemoteObject> &object, DeathRecipientId id); 254 255 void RegisteredTrackerClientDied(int uid); 256 257 void RegisteredStreamListenerClientDied(int pid); 258 259 bool IsAudioRendererLowLatencySupported(const AudioStreamInfo &audioStreamInfo) override; 260 261 int32_t UpdateStreamState(const int32_t clientUid, StreamSetState streamSetState, 262 StreamUsage streamUsage) override; 263 264 int32_t GetVolumeGroupInfos(std::string networkId, std::vector<sptr<VolumeGroupInfo>> &infos) override; 265 266 int32_t GetNetworkIdByGroupId(int32_t groupId, std::string &networkId) override; 267 268 std::vector<sptr<AudioDeviceDescriptor>> GetPreferredOutputDeviceDescriptors( 269 AudioRendererInfo &rendererInfo) override; 270 271 std::vector<sptr<AudioDeviceDescriptor>> GetPreferredInputDeviceDescriptors( 272 AudioCapturerInfo &captureInfo) override; 273 274 int32_t SetClientCallbacksEnable(const CallbackChange &callbackchange, const bool &enable) override; 275 276 int32_t GetAudioFocusInfoList(std::list<std::pair<AudioInterrupt, AudioFocuState>> &focusInfoList, 277 const int32_t zoneId = 0) override; 278 279 int32_t SetSystemSoundUri(const std::string &key, const std::string &uri) override; 280 281 std::string GetSystemSoundUri(const std::string &key) override; 282 283 float GetMinStreamVolume(void) override; 284 285 float GetMaxStreamVolume(void) override; 286 287 int32_t CheckMaxRendererInstances() override; 288 289 void GetStreamVolumeInfoMap(StreamVolumeInfoMap& streamVolumeInfos); 290 291 int32_t QueryEffectSceneMode(SupportedEffectConfig &supportedEffectConfig) override; 292 293 int32_t SetPlaybackCapturerFilterInfos(const AudioPlaybackCaptureConfig &config, 294 uint32_t appTokenId) override; 295 296 int32_t SetCaptureSilentState(bool state) 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 MoveToNewPipe(const uint32_t sessionId, const AudioPipeType pipeType) override; 398 399 int32_t SetAudioConcurrencyCallback(const uint32_t sessionID, const sptr<IRemoteObject> &object) override; 400 401 int32_t UnsetAudioConcurrencyCallback(const uint32_t sessionID) override; 402 403 int32_t ActivateAudioConcurrency(const AudioPipeType &pipeType) override; 404 405 int32_t InjectInterruption(const std::string networkId, InterruptEvent &event) override; 406 407 int32_t LoadSplitModule(const std::string &splitArgs, const std::string &networkId) override; 408 409 int32_t SetVoiceRingtoneMute(bool isMute) override; 410 411 int32_t SetDefaultOutputDevice(const DeviceType deviceType, const uint32_t sessionID, 412 const StreamUsage streamUsage, bool isRunning) override; 413 414 class RemoteParameterCallback : public AudioParameterCallback { 415 public: 416 RemoteParameterCallback(sptr<AudioPolicyServer> server); 417 // AudioParameterCallback 418 void OnAudioParameterChange(const std::string networkId, const AudioParamKey key, const std::string& condition, 419 const std::string& value) override; 420 private: 421 sptr<AudioPolicyServer> server_; 422 void VolumeOnChange(const std::string networkId, const std::string& condition); 423 void InterruptOnChange(const std::string networkId, const std::string& condition); 424 void StateOnChange(const std::string networkId, const std::string& condition, const std::string& value); 425 }; 426 427 std::shared_ptr<RemoteParameterCallback> remoteParameterCallback_; 428 429 class PerStateChangeCbCustomizeCallback : public Security::AccessToken::PermStateChangeCallbackCustomize { 430 public: PerStateChangeCbCustomizeCallback(const Security::AccessToken::PermStateChangeScope & scopeInfo,sptr<AudioPolicyServer> server)431 explicit PerStateChangeCbCustomizeCallback(const Security::AccessToken::PermStateChangeScope &scopeInfo, 432 sptr<AudioPolicyServer> server) : PermStateChangeCallbackCustomize(scopeInfo), 433 ready_(false), server_(server) {} ~PerStateChangeCbCustomizeCallback()434 ~PerStateChangeCbCustomizeCallback() {} 435 436 void PermStateChangeCallback(Security::AccessToken::PermStateChangeInfo& result); 437 int32_t getUidByBundleName(std::string bundle_name, int user_id); 438 void UpdateMicPrivacyByCapturerState(bool targetMuteState, uint32_t targetTokenId, int32_t appUid); 439 440 bool ready_; 441 private: 442 sptr<AudioPolicyServer> server_; 443 }; 444 445 bool IsHighResolutionExist() override; 446 447 int32_t SetHighResolutionExist(bool highResExist) override; 448 449 void NotifyAccountsChanged(const int &id); 450 451 // for hidump 452 void AudioDevicesDump(std::string &dumpString); 453 void AudioModeDump(std::string &dumpString); 454 void AudioInterruptZoneDump(std::string &dumpString); 455 void AudioPolicyParserDump(std::string &dumpString); 456 void AudioVolumeDump(std::string &dumpString); 457 void AudioStreamDump(std::string &dumpString); 458 void OffloadStatusDump(std::string &dumpString); 459 void XmlParsedDataMapDump(std::string &dumpString); 460 void EffectManagerInfoDump(std::string &dumpString); 461 void MicrophoneMuteInfoDump(std::string &dumpString); 462 463 protected: 464 void OnAddSystemAbility(int32_t systemAbilityId, const std::string& deviceId) override; 465 466 void RegisterParamCallback(); 467 468 void OnRemoveSystemAbility(int32_t systemAbilityId, const std::string& deviceId) override; 469 470 private: 471 friend class AudioInterruptService; 472 473 static constexpr int32_t MAX_VOLUME_LEVEL = 15; 474 static constexpr int32_t MIN_VOLUME_LEVEL = 0; 475 static constexpr int32_t VOLUME_CHANGE_FACTOR = 1; 476 static constexpr int32_t VOLUME_KEY_DURATION = 0; 477 static constexpr int32_t VOLUME_MUTE_KEY_DURATION = 1; 478 static constexpr int32_t MEDIA_SERVICE_UID = 1013; 479 static constexpr int32_t EDM_SERVICE_UID = 3057; 480 static constexpr char DAUDIO_DEV_TYPE_SPK = '1'; 481 static constexpr char DAUDIO_DEV_TYPE_MIC = '2'; 482 static constexpr int32_t AUDIO_UID = 1041; 483 static constexpr uint32_t MICPHONE_CALLER = 0; 484 485 static const std::list<uid_t> RECORD_ALLOW_BACKGROUND_LIST; 486 static const std::list<uid_t> RECORD_PASS_APPINFO_LIST; 487 488 class AudioPolicyServerPowerStateCallback : public PowerMgr::PowerStateCallbackStub { 489 public: 490 AudioPolicyServerPowerStateCallback(AudioPolicyServer *policyServer); 491 void OnAsyncPowerStateChanged(PowerMgr::PowerState state) override; 492 493 private: 494 AudioPolicyServer *policyServer_; 495 }; 496 497 int32_t VerifyVoiceCallPermission(uint64_t fullTokenId, Security::AccessToken::AccessTokenID tokenId); 498 499 // offload session 500 void OffloadStreamCheck(int64_t activateSessionId, int64_t deactivateSessionId); 501 void CheckSubscribePowerStateChange(); 502 503 void CheckStreamMode(const int64_t activateSessionId); 504 bool CheckAudioSessionStrategy(const AudioSessionStrategy &sessionStrategy); 505 506 // for audio volume and mute status 507 int32_t SetRingerModeInternal(AudioRingerMode ringMode, bool hasUpdatedVolume = false); 508 int32_t SetSystemVolumeLevelInternal(AudioStreamType streamType, int32_t volumeLevel, bool isUpdateUi); 509 int32_t SetSingleStreamVolume(AudioStreamType streamType, int32_t volumeLevel, bool isUpdateUi); 510 AudioStreamType GetSystemActiveVolumeTypeInternal(const int32_t clientUid); 511 int32_t GetSystemVolumeLevelInternal(AudioStreamType streamType); 512 float GetSystemVolumeDb(AudioStreamType streamType); 513 int32_t SetStreamMuteInternal(AudioStreamType streamType, bool mute, bool isUpdateUi); 514 int32_t SetSingleStreamMute(AudioStreamType streamType, bool mute, bool isUpdateUi); 515 bool GetStreamMuteInternal(AudioStreamType streamType); 516 bool IsVolumeTypeValid(AudioStreamType streamType); 517 bool IsVolumeLevelValid(AudioStreamType streamType, int32_t volumeLevel); 518 519 // Permission and privacy 520 bool VerifyPermission(const std::string &permission, uint32_t tokenId = 0, bool isRecording = false); 521 bool VerifyBluetoothPermission(); 522 int32_t OffloadStopPlaying(const AudioInterrupt &audioInterrupt); 523 int32_t SetAudioSceneInternal(AudioScene audioScene); 524 525 AppExecFwk::BundleInfo GetBundleInfoFromUid(); 526 int32_t GetApiTargerVersion(); 527 528 // externel function call 529 #ifdef FEATURE_MULTIMODALINPUT_INPUT 530 bool MaxOrMinVolumeOption(const int32_t &volLevel, const int32_t keyType, const AudioStreamType &streamInFocus); 531 int32_t RegisterVolumeKeyEvents(const int32_t keyType); 532 int32_t RegisterVolumeKeyMuteEvents(); 533 void SubscribeVolumeKeyEvents(); 534 #endif 535 void AddAudioServiceOnStart(); 536 void SubscribeOsAccountChangeEvents(); 537 void SubscribePowerStateChangeEvents(); 538 void SubscribeCommonEvent(const std::string event); 539 void OnReceiveEvent(const EventFwk::CommonEventData &eventData); 540 void HandleKvDataShareEvent(); 541 void InitMicrophoneMute(); 542 void InitKVStore(); 543 void ConnectServiceAdapter(); 544 void LoadEffectLibrary(); 545 void RegisterBluetoothListener(); 546 void SubscribeAccessibilityConfigObserver(); 547 void RegisterDataObserver(); 548 void RegisterPowerStateListener(); 549 void UnRegisterPowerStateListener(); 550 void RegisterSyncHibernateListener(); 551 void UnRegisterSyncHibernateListener(); 552 void OnDistributedRoutingRoleChange(const sptr<AudioDeviceDescriptor> descriptor, const CastType type); 553 554 void InitPolicyDumpMap(); 555 void PolicyDataDump(std::string &dumpString); 556 void ArgInfoDump(std::string &dumpString, std::queue<std::u16string> &argQue); 557 void InfoDumpHelp(std::string &dumpString); 558 559 int32_t SetRingerModeInner(AudioRingerMode ringMode); 560 561 AudioPolicyService& audioPolicyService_; 562 std::shared_ptr<AudioInterruptService> interruptService_; 563 564 int32_t volumeStep_; 565 std::atomic<bool> isFirstAudioServiceStart_ = false; 566 std::atomic<bool> isInitMuteState_ = false; 567 #ifdef FEATURE_MULTIMODALINPUT_INPUT 568 std::atomic<bool> hasSubscribedVolumeKeyEvents_ = false; 569 #endif 570 std::vector<pid_t> clientDiedListenerState_; 571 sptr<PowerStateListener> powerStateListener_; 572 sptr<SyncHibernateListener> syncHibernateListener_; 573 bool powerStateCallbackRegister_; 574 575 std::mutex keyEventMutex_; 576 std::mutex micStateChangeMutex_; 577 std::mutex clientDiedListenerStateMutex_; 578 579 SessionProcessor sessionProcessor_{ 580 [this] (const uint64_t sessionID, const int32_t zoneID) { this->ProcessSessionRemoved(sessionID, zoneID); }, 581 [this] (SessionEvent sessionEvent) { this->ProcessSessionAdded(sessionEvent); }, 582 [this] (const uint64_t sessionID) {this->ProcessorCloseWakeupSource(sessionID); }}; 583 584 AudioSpatializationService& audioSpatializationService_; 585 std::shared_ptr<AudioPolicyServerHandler> audioPolicyServerHandler_; 586 bool volumeApplyToAll_ = false; 587 588 bool isHighResolutionExist_ = false; 589 std::mutex descLock_; 590 AudioRouterCenter &audioRouterCenter_; 591 using DumpFunc = void(AudioPolicyServer::*)(std::string &dumpString); 592 std::map<std::u16string, DumpFunc> dumpFuncMap; 593 pid_t lastMicMuteSettingPid_ = 0; 594 std::string GetBundleName(); 595 std::shared_ptr<AudioOsAccountInfo> accountObserver_ = nullptr; 596 }; 597 598 class AudioOsAccountInfo : public AccountSA::OsAccountSubscriber { 599 public: AudioOsAccountInfo(const AccountSA::OsAccountSubscribeInfo & subscribeInfo,AudioPolicyServer * audioPolicyServer)600 explicit AudioOsAccountInfo(const AccountSA::OsAccountSubscribeInfo &subscribeInfo, 601 AudioPolicyServer *audioPolicyServer) : AccountSA::OsAccountSubscriber(subscribeInfo), 602 audioPolicyServer_(audioPolicyServer) {} 603 ~AudioOsAccountInfo()604 ~AudioOsAccountInfo() 605 { 606 AUDIO_WARNING_LOG("Destructor AudioOsAccountInfo"); 607 } 608 OnAccountsChanged(const int & id)609 void OnAccountsChanged(const int &id) override 610 { 611 AUDIO_INFO_LOG("OnAccountsChanged received, id: %{public}d", id); 612 } 613 OnAccountsSwitch(const int & newId,const int & oldId)614 void OnAccountsSwitch(const int &newId, const int &oldId) override 615 { 616 CHECK_AND_RETURN_LOG(oldId >= LOCAL_USER_ID, "invalid id"); 617 AUDIO_INFO_LOG("OnAccountsSwitch received, newid: %{public}d, oldid: %{public}d", newId, oldId); 618 if (audioPolicyServer_ != nullptr) { 619 audioPolicyServer_->NotifyAccountsChanged(newId); 620 } 621 } 622 private: 623 AudioPolicyServer *audioPolicyServer_; 624 }; 625 626 class AudioCommonEventSubscriber : public EventFwk::CommonEventSubscriber { 627 public: AudioCommonEventSubscriber(const EventFwk::CommonEventSubscribeInfo & subscribeInfo,std::function<void (const EventFwk::CommonEventData &)> receiver)628 explicit AudioCommonEventSubscriber(const EventFwk::CommonEventSubscribeInfo &subscribeInfo, 629 std::function<void(const EventFwk::CommonEventData&)> receiver) 630 : EventFwk::CommonEventSubscriber(subscribeInfo), eventReceiver_(receiver) {} ~AudioCommonEventSubscriber()631 ~AudioCommonEventSubscriber() {} 632 void OnReceiveEvent(const EventFwk::CommonEventData &eventData) override; 633 private: 634 AudioCommonEventSubscriber() = default; 635 std::function<void(const EventFwk::CommonEventData&)> eventReceiver_; 636 }; 637 } // namespace AudioStandard 638 } // namespace OHOS 639 #endif // ST_AUDIO_POLICY_SERVER_H 640