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 GetNetworkIdByGroupId(int32_t groupId, std::string &networkId) override; 268 269 std::vector<sptr<AudioDeviceDescriptor>> GetPreferredOutputDeviceDescriptors( 270 AudioRendererInfo &rendererInfo) override; 271 272 std::vector<sptr<AudioDeviceDescriptor>> GetPreferredInputDeviceDescriptors( 273 AudioCapturerInfo &captureInfo) override; 274 275 int32_t SetClientCallbacksEnable(const CallbackChange &callbackchange, const bool &enable) override; 276 277 int32_t GetAudioFocusInfoList(std::list<std::pair<AudioInterrupt, AudioFocuState>> &focusInfoList, 278 const int32_t zoneId = 0) override; 279 280 int32_t SetSystemSoundUri(const std::string &key, const std::string &uri) override; 281 282 std::string GetSystemSoundUri(const std::string &key) override; 283 284 float GetMinStreamVolume(void) override; 285 286 float GetMaxStreamVolume(void) override; 287 288 int32_t CheckMaxRendererInstances() override; 289 290 void GetStreamVolumeInfoMap(StreamVolumeInfoMap& streamVolumeInfos); 291 292 int32_t QueryEffectSceneMode(SupportedEffectConfig &supportedEffectConfig) override; 293 294 int32_t SetPlaybackCapturerFilterInfos(const AudioPlaybackCaptureConfig &config, 295 uint32_t appTokenId) override; 296 297 int32_t SetCaptureSilentState(bool state) override; 298 299 int32_t GetHardwareOutputSamplingRate(const sptr<AudioDeviceDescriptor> &desc) override; 300 301 std::vector<sptr<MicrophoneDescriptor>> GetAudioCapturerMicrophoneDescriptors(int32_t sessionId) override; 302 303 std::vector<sptr<MicrophoneDescriptor>> GetAvailableMicrophones() override; 304 305 int32_t SetDeviceAbsVolumeSupported(const std::string &macAddress, const bool support) override; 306 307 bool IsAbsVolumeScene() override; 308 309 bool IsVgsVolumeSupported() override; 310 311 int32_t SetA2dpDeviceVolume(const std::string &macAddress, const int32_t volume, const bool updateUi) override; 312 313 std::vector<std::unique_ptr<AudioDeviceDescriptor>> GetAvailableDevices(AudioDeviceUsage usage) override; 314 315 int32_t SetAvailableDeviceChangeCallback(const int32_t /*clientId*/, const AudioDeviceUsage usage, 316 const sptr<IRemoteObject> &object) override; 317 318 int32_t UnsetAvailableDeviceChangeCallback(const int32_t clientId, AudioDeviceUsage usage) override; 319 320 bool IsSpatializationEnabled() override; 321 322 bool IsSpatializationEnabled(const std::string address) override; 323 324 int32_t SetSpatializationEnabled(const bool enable) override; 325 326 int32_t SetSpatializationEnabled(const sptr<AudioDeviceDescriptor> &selectedAudioDevice, 327 const bool enable) override; 328 329 bool IsHeadTrackingEnabled() override; 330 331 bool IsHeadTrackingEnabled(const std::string address) override; 332 333 int32_t SetHeadTrackingEnabled(const bool enable) override; 334 335 int32_t SetHeadTrackingEnabled(const sptr<AudioDeviceDescriptor> &selectedAudioDevice, const bool enable) override; 336 337 AudioSpatializationState GetSpatializationState(const StreamUsage streamUsage) override; 338 339 bool IsSpatializationSupported() override; 340 341 bool IsSpatializationSupportedForDevice(const std::string address) override; 342 343 bool IsHeadTrackingSupported() override; 344 345 bool IsHeadTrackingSupportedForDevice(const std::string address) override; 346 347 int32_t UpdateSpatialDeviceState(const AudioSpatialDeviceState audioSpatialDeviceState) override; 348 349 int32_t RegisterSpatializationStateEventListener(const uint32_t sessionID, const StreamUsage streamUsage, 350 const sptr<IRemoteObject> &object) override; 351 352 int32_t ConfigDistributedRoutingRole(const sptr<AudioDeviceDescriptor> descriptor, CastType type) override; 353 354 int32_t SetDistributedRoutingRoleCallback(const sptr<IRemoteObject> &object) override; 355 356 int32_t UnsetDistributedRoutingRoleCallback() override; 357 358 int32_t UnregisterSpatializationStateEventListener(const uint32_t sessionID) override; 359 360 int32_t RegisterPolicyCallbackClient(const sptr<IRemoteObject> &object, const int32_t zoneId = 0) override; 361 362 int32_t CreateAudioInterruptZone(const std::set<int32_t> &pids, const int32_t zoneId) override; 363 364 int32_t AddAudioInterruptZonePids(const std::set<int32_t> &pids, const int32_t zoneId) override; 365 366 int32_t RemoveAudioInterruptZonePids(const std::set<int32_t> &pids, const int32_t zoneId) override; 367 368 int32_t ReleaseAudioInterruptZone(const int32_t zoneId) override; 369 370 int32_t SetCallDeviceActive(InternalDeviceType deviceType, bool active, std::string address) override; 371 372 std::unique_ptr<AudioDeviceDescriptor> GetActiveBluetoothDevice() override; 373 374 void FetchOutputDeviceForTrack(AudioStreamChangeInfo &streamChangeInfo, 375 const AudioStreamDeviceChangeReasonExt reason) override; 376 377 void FetchInputDeviceForTrack(AudioStreamChangeInfo &streamChangeInfo) override; 378 379 ConverterConfig GetConverterConfig() override; 380 381 AudioSpatializationSceneType GetSpatializationSceneType() override; 382 383 int32_t SetSpatializationSceneType(const AudioSpatializationSceneType spatializationSceneType) override; 384 385 float GetMaxAmplitude(const int32_t deviceId) override; 386 387 int32_t DisableSafeMediaVolume() override; 388 389 bool IsHeadTrackingDataRequested(const std::string &macAddress) override; 390 391 int32_t SetAudioDeviceRefinerCallback(const sptr<IRemoteObject> &object) override; 392 393 int32_t UnsetAudioDeviceRefinerCallback() override; 394 395 int32_t TriggerFetchDevice( 396 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN) override; 397 398 int32_t SetPreferredDevice(const PreferredType preferredType, 399 const sptr<AudioDeviceDescriptor> &desc) override; 400 401 void SaveRemoteInfo(const std::string &networkId, DeviceType deviceType) override; 402 403 int32_t MoveToNewPipe(const uint32_t sessionId, const AudioPipeType pipeType) override; 404 405 int32_t SetAudioConcurrencyCallback(const uint32_t sessionID, const sptr<IRemoteObject> &object) override; 406 407 int32_t UnsetAudioConcurrencyCallback(const uint32_t sessionID) override; 408 409 int32_t ActivateAudioConcurrency(const AudioPipeType &pipeType) override; 410 411 int32_t InjectInterruption(const std::string networkId, InterruptEvent &event) override; 412 413 int32_t LoadSplitModule(const std::string &splitArgs, const std::string &networkId) override; 414 415 int32_t SetVoiceRingtoneMute(bool isMute) override; 416 417 int32_t SetDefaultOutputDevice(const DeviceType deviceType, const uint32_t sessionID, 418 const StreamUsage streamUsage, bool isRunning) override; 419 420 void ProcessRemoteInterrupt(std::set<int32_t> sessionIds, InterruptEventInternal interruptEvent); 421 422 class RemoteParameterCallback : public AudioParameterCallback { 423 public: 424 RemoteParameterCallback(sptr<AudioPolicyServer> server); 425 // AudioParameterCallback 426 void OnAudioParameterChange(const std::string networkId, const AudioParamKey key, const std::string& condition, 427 const std::string& value) override; 428 private: 429 sptr<AudioPolicyServer> server_; 430 void VolumeOnChange(const std::string networkId, const std::string& condition); 431 void InterruptOnChange(const std::string networkId, const std::string& condition); 432 void StateOnChange(const std::string networkId, const std::string& condition, const std::string& value); 433 }; 434 435 std::shared_ptr<RemoteParameterCallback> remoteParameterCallback_; 436 437 class PerStateChangeCbCustomizeCallback : public Security::AccessToken::PermStateChangeCallbackCustomize { 438 public: PerStateChangeCbCustomizeCallback(const Security::AccessToken::PermStateChangeScope & scopeInfo,sptr<AudioPolicyServer> server)439 explicit PerStateChangeCbCustomizeCallback(const Security::AccessToken::PermStateChangeScope &scopeInfo, 440 sptr<AudioPolicyServer> server) : PermStateChangeCallbackCustomize(scopeInfo), 441 ready_(false), server_(server) {} ~PerStateChangeCbCustomizeCallback()442 ~PerStateChangeCbCustomizeCallback() {} 443 444 void PermStateChangeCallback(Security::AccessToken::PermStateChangeInfo& result); 445 int32_t getUidByBundleName(std::string bundle_name, int user_id); 446 void UpdateMicPrivacyByCapturerState(bool targetMuteState, uint32_t targetTokenId, int32_t appUid); 447 448 bool ready_; 449 private: 450 sptr<AudioPolicyServer> server_; 451 }; 452 453 bool IsHighResolutionExist() override; 454 455 int32_t SetHighResolutionExist(bool highResExist) override; 456 457 void NotifyAccountsChanged(const int &id); 458 459 // for hidump 460 void AudioDevicesDump(std::string &dumpString); 461 void AudioModeDump(std::string &dumpString); 462 void AudioInterruptZoneDump(std::string &dumpString); 463 void AudioPolicyParserDump(std::string &dumpString); 464 void AudioVolumeDump(std::string &dumpString); 465 void AudioStreamDump(std::string &dumpString); 466 void OffloadStatusDump(std::string &dumpString); 467 void XmlParsedDataMapDump(std::string &dumpString); 468 void EffectManagerInfoDump(std::string &dumpString); 469 void MicrophoneMuteInfoDump(std::string &dumpString); 470 471 protected: 472 void OnAddSystemAbility(int32_t systemAbilityId, const std::string& deviceId) override; 473 474 void RegisterParamCallback(); 475 476 void OnRemoveSystemAbility(int32_t systemAbilityId, const std::string& deviceId) override; 477 478 private: 479 friend class AudioInterruptService; 480 481 static constexpr int32_t MAX_VOLUME_LEVEL = 15; 482 static constexpr int32_t MIN_VOLUME_LEVEL = 0; 483 static constexpr int32_t VOLUME_CHANGE_FACTOR = 1; 484 static constexpr int32_t VOLUME_KEY_DURATION = 0; 485 static constexpr int32_t VOLUME_MUTE_KEY_DURATION = 1; 486 static constexpr int32_t MEDIA_SERVICE_UID = 1013; 487 static constexpr int32_t EDM_SERVICE_UID = 3057; 488 static constexpr char DAUDIO_DEV_TYPE_SPK = '1'; 489 static constexpr char DAUDIO_DEV_TYPE_MIC = '2'; 490 static constexpr int32_t AUDIO_UID = 1041; 491 static constexpr uint32_t MICPHONE_CALLER = 0; 492 493 static const std::list<uid_t> RECORD_ALLOW_BACKGROUND_LIST; 494 static const std::list<uid_t> RECORD_PASS_APPINFO_LIST; 495 496 class AudioPolicyServerPowerStateCallback : public PowerMgr::PowerStateCallbackStub { 497 public: 498 AudioPolicyServerPowerStateCallback(AudioPolicyServer *policyServer); 499 void OnAsyncPowerStateChanged(PowerMgr::PowerState state) override; 500 501 private: 502 AudioPolicyServer *policyServer_; 503 }; 504 505 int32_t VerifyVoiceCallPermission(uint64_t fullTokenId, Security::AccessToken::AccessTokenID tokenId); 506 507 // offload session 508 void OffloadStreamCheck(int64_t activateSessionId, int64_t deactivateSessionId); 509 void CheckSubscribePowerStateChange(); 510 511 void CheckStreamMode(const int64_t activateSessionId); 512 bool CheckAudioSessionStrategy(const AudioSessionStrategy &sessionStrategy); 513 514 // for audio volume and mute status 515 int32_t SetRingerModeInternal(AudioRingerMode ringMode, bool hasUpdatedVolume = false); 516 int32_t SetSystemVolumeLevelInternal(AudioStreamType streamType, int32_t volumeLevel, bool isUpdateUi); 517 int32_t SetSingleStreamVolume(AudioStreamType streamType, int32_t volumeLevel, bool isUpdateUi, bool mute); 518 AudioStreamType GetSystemActiveVolumeTypeInternal(const int32_t clientUid); 519 int32_t GetSystemVolumeLevelInternal(AudioStreamType streamType); 520 float GetSystemVolumeDb(AudioStreamType streamType); 521 int32_t SetStreamMuteInternal(AudioStreamType streamType, bool mute, bool isUpdateUi); 522 int32_t SetSingleStreamMute(AudioStreamType streamType, bool mute, bool isUpdateUi); 523 bool GetStreamMuteInternal(AudioStreamType streamType); 524 bool IsVolumeTypeValid(AudioStreamType streamType); 525 bool IsVolumeLevelValid(AudioStreamType streamType, int32_t volumeLevel); 526 527 // Permission and privacy 528 bool VerifyPermission(const std::string &permission, uint32_t tokenId = 0, bool isRecording = false); 529 bool VerifyBluetoothPermission(); 530 int32_t OffloadStopPlaying(const AudioInterrupt &audioInterrupt); 531 int32_t SetAudioSceneInternal(AudioScene audioScene); 532 533 AppExecFwk::BundleInfo GetBundleInfoFromUid(); 534 int32_t GetApiTargerVersion(); 535 536 // externel function call 537 #ifdef FEATURE_MULTIMODALINPUT_INPUT 538 bool MaxOrMinVolumeOption(const int32_t &volLevel, const int32_t keyType, const AudioStreamType &streamInFocus); 539 int32_t RegisterVolumeKeyEvents(const int32_t keyType); 540 int32_t RegisterVolumeKeyMuteEvents(); 541 void SubscribeVolumeKeyEvents(); 542 #endif 543 void AddAudioServiceOnStart(); 544 void SubscribeOsAccountChangeEvents(); 545 void SubscribePowerStateChangeEvents(); 546 void SubscribeCommonEvent(const std::string event); 547 void OnReceiveEvent(const EventFwk::CommonEventData &eventData); 548 void HandleKvDataShareEvent(); 549 void InitMicrophoneMute(); 550 void InitKVStore(); 551 void ConnectServiceAdapter(); 552 void LoadEffectLibrary(); 553 void RegisterBluetoothListener(); 554 void SubscribeAccessibilityConfigObserver(); 555 void RegisterDataObserver(); 556 void RegisterPowerStateListener(); 557 void UnRegisterPowerStateListener(); 558 void RegisterSyncHibernateListener(); 559 void UnRegisterSyncHibernateListener(); 560 void OnDistributedRoutingRoleChange(const sptr<AudioDeviceDescriptor> descriptor, const CastType type); 561 562 void InitPolicyDumpMap(); 563 void PolicyDataDump(std::string &dumpString); 564 void ArgInfoDump(std::string &dumpString, std::queue<std::u16string> &argQue); 565 void InfoDumpHelp(std::string &dumpString); 566 567 int32_t SetRingerModeInner(AudioRingerMode ringMode); 568 569 // for updating default device selection state when game audio stream is muted 570 void UpdateDefaultOutputDeviceWhenStarting(const uint32_t sessionID); 571 void UpdateDefaultOutputDeviceWhenStopping(const uint32_t sessionID); 572 573 AudioPolicyService& audioPolicyService_; 574 AudioDeviceManager &audioDeviceManager_; 575 std::shared_ptr<AudioInterruptService> interruptService_; 576 577 int32_t volumeStep_; 578 std::atomic<bool> isFirstAudioServiceStart_ = false; 579 std::atomic<bool> isInitMuteState_ = false; 580 #ifdef FEATURE_MULTIMODALINPUT_INPUT 581 std::atomic<bool> hasSubscribedVolumeKeyEvents_ = false; 582 #endif 583 std::vector<pid_t> clientDiedListenerState_; 584 sptr<PowerStateListener> powerStateListener_; 585 sptr<SyncHibernateListener> syncHibernateListener_; 586 bool powerStateCallbackRegister_; 587 588 std::mutex keyEventMutex_; 589 std::mutex micStateChangeMutex_; 590 std::mutex clientDiedListenerStateMutex_; 591 592 SessionProcessor sessionProcessor_{ 593 [this] (const uint64_t sessionID, const int32_t zoneID) { this->ProcessSessionRemoved(sessionID, zoneID); }, 594 [this] (SessionEvent sessionEvent) { this->ProcessSessionAdded(sessionEvent); }, 595 [this] (const uint64_t sessionID) {this->ProcessorCloseWakeupSource(sessionID); }}; 596 597 AudioSpatializationService& audioSpatializationService_; 598 std::shared_ptr<AudioPolicyServerHandler> audioPolicyServerHandler_; 599 bool volumeApplyToAll_ = false; 600 601 bool isHighResolutionExist_ = false; 602 std::mutex descLock_; 603 AudioRouterCenter &audioRouterCenter_; 604 using DumpFunc = void(AudioPolicyServer::*)(std::string &dumpString); 605 std::map<std::u16string, DumpFunc> dumpFuncMap; 606 pid_t lastMicMuteSettingPid_ = 0; 607 std::string GetBundleName(); 608 std::shared_ptr<AudioOsAccountInfo> accountObserver_ = nullptr; 609 int32_t sessionIdByRemote_ = -1; 610 }; 611 612 class AudioOsAccountInfo : public AccountSA::OsAccountSubscriber { 613 public: AudioOsAccountInfo(const AccountSA::OsAccountSubscribeInfo & subscribeInfo,AudioPolicyServer * audioPolicyServer)614 explicit AudioOsAccountInfo(const AccountSA::OsAccountSubscribeInfo &subscribeInfo, 615 AudioPolicyServer *audioPolicyServer) : AccountSA::OsAccountSubscriber(subscribeInfo), 616 audioPolicyServer_(audioPolicyServer) {} 617 ~AudioOsAccountInfo()618 ~AudioOsAccountInfo() 619 { 620 AUDIO_WARNING_LOG("Destructor AudioOsAccountInfo"); 621 } 622 OnAccountsChanged(const int & id)623 void OnAccountsChanged(const int &id) override 624 { 625 AUDIO_INFO_LOG("OnAccountsChanged received, id: %{public}d", id); 626 } 627 OnAccountsSwitch(const int & newId,const int & oldId)628 void OnAccountsSwitch(const int &newId, const int &oldId) override 629 { 630 CHECK_AND_RETURN_LOG(oldId >= LOCAL_USER_ID, "invalid id"); 631 AUDIO_INFO_LOG("OnAccountsSwitch received, newid: %{public}d, oldid: %{public}d", newId, oldId); 632 if (audioPolicyServer_ != nullptr) { 633 audioPolicyServer_->NotifyAccountsChanged(newId); 634 } 635 } 636 private: 637 AudioPolicyServer *audioPolicyServer_; 638 }; 639 640 class AudioCommonEventSubscriber : public EventFwk::CommonEventSubscriber { 641 public: AudioCommonEventSubscriber(const EventFwk::CommonEventSubscribeInfo & subscribeInfo,std::function<void (const EventFwk::CommonEventData &)> receiver)642 explicit AudioCommonEventSubscriber(const EventFwk::CommonEventSubscribeInfo &subscribeInfo, 643 std::function<void(const EventFwk::CommonEventData&)> receiver) 644 : EventFwk::CommonEventSubscriber(subscribeInfo), eventReceiver_(receiver) {} ~AudioCommonEventSubscriber()645 ~AudioCommonEventSubscriber() {} 646 void OnReceiveEvent(const EventFwk::CommonEventData &eventData) override; 647 private: 648 AudioCommonEventSubscriber() = default; 649 std::function<void(const EventFwk::CommonEventData&)> eventReceiver_; 650 }; 651 } // namespace AudioStandard 652 } // namespace OHOS 653 #endif // ST_AUDIO_POLICY_SERVER_H 654