1 /* 2 * Copyright (c) 2023-2025 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_SPATIALIZATION_SERVICE_H 17 #define ST_AUDIO_SPATIALIZATION_SERVICE_H 18 19 #include <bitset> 20 #include <list> 21 #include <string> 22 #include <unordered_map> 23 #include <unordered_set> 24 #include <mutex> 25 #include <shared_mutex> 26 #include <openssl/sha.h> 27 #include "audio_group_handle.h" 28 #include "audio_manager_base.h" 29 #include "audio_policy_manager_factory.h" 30 #include "ipc_skeleton.h" 31 32 #include "iaudio_policy_interface.h" 33 #include "audio_policy_server_handler.h" 34 #include "istandard_audio_service.h" 35 36 namespace OHOS { 37 namespace AudioStandard { 38 class AudioSpatializationService { 39 public: GetAudioSpatializationService()40 static AudioSpatializationService& GetAudioSpatializationService() 41 { 42 static AudioSpatializationService audioSpatializationService; 43 return audioSpatializationService; 44 } 45 46 void Init(const std::vector<EffectChain> &effectChains); 47 void Deinit(void); 48 49 const sptr<IStandardAudioService> GetAudioServerProxy(); 50 bool IsSpatializationEnabled(); 51 bool IsSpatializationEnabled(const std::string address); 52 bool IsSpatializationEnabledForCurrentDevice(); 53 int32_t SetSpatializationEnabled(const bool enable); 54 int32_t SetSpatializationEnabled( 55 const std::shared_ptr<AudioDeviceDescriptor> &selectedAudioDevice, const bool enable); 56 bool IsHeadTrackingEnabled(); 57 bool IsHeadTrackingEnabled(const std::string address); 58 int32_t SetHeadTrackingEnabled(const bool enable); 59 int32_t SetHeadTrackingEnabled( 60 const std::shared_ptr<AudioDeviceDescriptor> &selectedAudioDevice, const bool enable); 61 void HandleSpatializationEnabledChange(const bool &enabled); 62 void HandleSpatializationEnabledChange( 63 const std::shared_ptr<AudioDeviceDescriptor> &selectedAudioDevice, const bool &enabled); 64 void HandleSpatializationEnabledChangeForCurrentDevice(const bool &enabled); 65 void HandleHeadTrackingEnabledChange(const bool &enabled); 66 void HandleHeadTrackingEnabledChange( 67 const std::shared_ptr<AudioDeviceDescriptor> &selectedAudioDevice, const bool &enabled); 68 AudioSpatializationState GetSpatializationState( 69 const StreamUsage streamUsage = StreamUsage::STREAM_USAGE_UNKNOWN); 70 bool IsSpatializationSupported(); 71 bool IsSpatializationSupportedForDevice(const std::string address); 72 bool IsHeadTrackingSupported(); 73 bool IsHeadTrackingSupportedForDevice(const std::string address); 74 int32_t UpdateSpatialDeviceState(const AudioSpatialDeviceState audioSpatialDeviceState); 75 int32_t RegisterSpatializationStateEventListener(const uint32_t sessionID, const StreamUsage streamUsage, 76 const sptr<IRemoteObject> &object); 77 int32_t UnregisterSpatializationStateEventListener(const uint32_t sessionID); 78 void UpdateCurrentDevice(const std::string macAddress); 79 AudioSpatializationSceneType GetSpatializationSceneType(); 80 int32_t SetSpatializationSceneType(const AudioSpatializationSceneType spatializationSceneType); 81 bool IsHeadTrackingDataRequested(const std::string &macAddress); 82 void UpdateRendererInfo(const std::vector<std::shared_ptr<AudioRendererChangeInfo>> &rendererChangeInfo); 83 void InitSpatializationState(); 84 std::string GetCurrentDeviceAddress() const; 85 void UpdateSpatializationSupported(const std::string encryptedAddress); 86 private: AudioSpatializationService()87 AudioSpatializationService() 88 :audioPolicyServerHandler_(DelayedSingleton<AudioPolicyServerHandler>::GetInstance()) 89 {} 90 91 ~AudioSpatializationService(); 92 93 enum WriteToDbOperation { 94 WRITE_SPATIALIZATION_STATE = 0, 95 WRITE_SPATIALIZATION_SCENE = 1, 96 WRITE_DEVICESPATIAL_INFO = 2, 97 }; 98 static constexpr uint32_t MAX_DEVICE_NUM = 10; 99 int32_t UpdateSpatializationStateReal(bool outputDeviceChange, std::string preDeviceAddress = ""); 100 int32_t UpdateSpatializationState(); 101 int32_t UpdateSpatializationSceneType(); 102 void UpdateSpatialDeviceType(AudioSpatialDeviceType audioSpatialDeviceType); 103 void HandleSpatializationStateChange(bool outputDeviceChange); 104 void WriteSpatializationStateToDb(WriteToDbOperation operation, std::string address = ""); 105 bool IsHeadTrackingDataRequestedForCurrentDevice(); 106 void UpdateHeadTrackingDeviceState(bool outputDeviceChange, std::string preDeviceAddress = ""); 107 void HandleHeadTrackingDeviceChange(const std::unordered_map<std::string, bool> &changeInfo); 108 void UpdateDeviceSpatialInfo(const uint32_t deviceID, const std::string deviceSpatialInfo); 109 void UpdateDeviceSpatialMapInfo(const std::string address, const std::string deviceSpatialInfo); 110 std::string RemoveOldestDevice(); 111 std::string GetCurrTimestamp(); 112 std::string EncapsulateDeviceInfo(const std::string address); 113 std::string ExtractTimestamp(const std::string deviceSpatialInfo); 114 std::string GetSha256EncryptAddress(const std::string& address); 115 int32_t InitSpatializationScene(); 116 std::map<std::string, std::string> addressToDeviceSpatialInfoMap_; 117 std::map<std::string, uint32_t> addressToDeviceIDMap_; 118 std::shared_ptr<AudioPolicyServerHandler> audioPolicyServerHandler_; 119 std::string currentDeviceAddress_ = ""; 120 std::string preSettingSpatialAddress_ = "NO_PREVIOUS_SET_DEVICE"; 121 bool isSpatializationSupported_ = false; 122 bool isHeadTrackingSupported_ = false; 123 bool spatializationEnabledReal_ = false; 124 bool headTrackingEnabledReal_ = false; 125 bool isHeadTrackingDataRequested_ = false; 126 bool isLoadedfromDb_ = false; 127 AudioSpatializationState spatializationStateFlag_ = {}; 128 std::unordered_map<std::string, AudioSpatializationState> addressToSpatialEnabledMap_; 129 AudioSpatializationSceneType spatializationSceneType_ = SPATIALIZATION_SCENE_TYPE_MUSIC; 130 AudioSpatialDeviceType currSpatialDeviceType_{ EARPHONE_TYPE_OTHERS }; 131 std::vector<AudioRendererInfoForSpatialization> spatializationRendererInfoList_; 132 std::mutex spatializationServiceMutex_; 133 std::mutex spatializationSupportedMutex_; 134 std::mutex spatializationStateChangeListnerMutex_; 135 std::mutex rendererInfoChangingMutex_; 136 std::unordered_map<uint32_t, std::pair<std::shared_ptr<AudioSpatializationStateChangeCallback>, StreamUsage>> 137 spatializationStateCBMap_; 138 std::map<std::string, AudioSpatialDeviceState> addressToSpatialDeviceStateMap_; 139 }; 140 } // namespace AudioStandard 141 } // namespace OHOS 142 143 #endif // ST_AUDIO_SPATIALIZATION_SERVICE_H 144