1 /*
2  * Copyright (c) 2023 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 "audio_group_handle.h"
27 #include "audio_info.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 "iport_observer.h"
34 #include "audio_policy_server_handler.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     int32_t SetSpatializationEnabled(const bool enable);
53     int32_t SetSpatializationEnabled(const sptr<AudioDeviceDescriptor> &selectedAudioDevice, const bool enable);
54     bool IsHeadTrackingEnabled();
55     bool IsHeadTrackingEnabled(const std::string address);
56     int32_t SetHeadTrackingEnabled(const bool enable);
57     int32_t SetHeadTrackingEnabled(const sptr<AudioDeviceDescriptor> &selectedAudioDevice, const bool enable);
58     void HandleSpatializationEnabledChange(const bool &enabled);
59     void HandleSpatializationEnabledChange(const sptr<AudioDeviceDescriptor> &selectedAudioDevice, const bool &enabled);
60     void HandleHeadTrackingEnabledChange(const bool &enabled);
61     void HandleHeadTrackingEnabledChange(const sptr<AudioDeviceDescriptor> &selectedAudioDevice, const bool &enabled);
62     AudioSpatializationState GetSpatializationState(const StreamUsage streamUsage = StreamUsage::STREAM_USAGE_UNKNOWN);
63     bool IsSpatializationSupported();
64     bool IsSpatializationSupportedForDevice(const std::string address);
65     bool IsHeadTrackingSupported();
66     bool IsHeadTrackingSupportedForDevice(const std::string address);
67     int32_t UpdateSpatialDeviceState(const AudioSpatialDeviceState audioSpatialDeviceState);
68     int32_t RegisterSpatializationStateEventListener(const uint32_t sessionID, const StreamUsage streamUsage,
69         const sptr<IRemoteObject> &object);
70     int32_t UnregisterSpatializationStateEventListener(const uint32_t sessionID);
71     void UpdateCurrentDevice(const std::string macAddress);
72     AudioSpatializationSceneType GetSpatializationSceneType();
73     int32_t SetSpatializationSceneType(const AudioSpatializationSceneType spatializationSceneType);
74     bool IsHeadTrackingDataRequested(const std::string &macAddress);
75     void UpdateRendererInfo(const std::vector<std::unique_ptr<AudioRendererChangeInfo>> &rendererChangeInfo);
76     void InitSpatializationState();
77     std::string GetCurrentDeviceAddress() const;
78 private:
AudioSpatializationService()79     AudioSpatializationService()
80         :audioPolicyServerHandler_(DelayedSingleton<AudioPolicyServerHandler>::GetInstance())
81     {}
82 
83     ~AudioSpatializationService();
84 
85     enum WriteToDbOperation {
86         WRITE_SPATIALIZATION_STATE = 0,
87         WRITE_SPATIALIZATION_SCENE = 1,
88         WRITE_DEVICESPATIAL_INFO = 2,
89     };
90     static constexpr uint32_t MAX_DEVICE_NUM = 10;
91     int32_t UpdateSpatializationStateReal(bool outputDeviceChange, std::string preDeviceAddress = "");
92     int32_t UpdateSpatializationState();
93     int32_t UpdateSpatializationSceneType();
94     void UpdateSpatialDeviceType(AudioSpatialDeviceType audioSpatialDeviceType);
95     void HandleSpatializationStateChange(bool outputDeviceChange);
96     void WriteSpatializationStateToDb(WriteToDbOperation operation, std::string address = "");
97     bool IsHeadTrackingDataRequestedForCurrentDevice();
98     void UpdateHeadTrackingDeviceState(bool outputDeviceChange, std::string preDeviceAddress = "");
99     void HandleHeadTrackingDeviceChange(const std::unordered_map<std::string, bool> &changeInfo);
100     void UpdateDeviceSpatialInfo(const uint32_t deviceID, const std::string deviceSpatialInfo);
101     void UpdateDeviceSpatialMapInfo(const std::string address, const std::string deviceSpatialInfo);
102     std::string RemoveOldestDevice();
103     std::string GetCurrTimestamp();
104     std::string EncapsulateDeviceInfo(const std::string address);
105     std::string ExtractTimestamp(const std::string deviceSpatialInfo);
106     std::string GetSha256EncryptAddress(const std::string& address);
107     std::map<std::string, std::string> addressToDeviceSpatialInfoMap_;
108     std::map<std::string, uint32_t> addressToDeviceIDMap_;
109     std::shared_ptr<AudioPolicyServerHandler> audioPolicyServerHandler_;
110     std::string currentDeviceAddress_ = "";
111     std::string preSettingSpatialAddress_ = "NO_PREVIOUS_SET_DEVICE";
112     bool isSpatializationSupported_ = false;
113     bool isHeadTrackingSupported_ = false;
114     bool spatializationEnabledReal_ = false;
115     bool headTrackingEnabledReal_ = false;
116     bool isHeadTrackingDataRequested_ = false;
117     bool isLoadedfromDb_ = false;
118     AudioSpatializationState spatializationStateFlag_ = {false};
119     std::unordered_map<std::string, AudioSpatializationState> addressToSpatialEnabledMap_;
120     AudioSpatializationSceneType spatializationSceneType_ = SPATIALIZATION_SCENE_TYPE_DEFAULT;
121     AudioSpatialDeviceType currSpatialDeviceType_{ EARPHONE_TYPE_OTHERS };
122     std::vector<AudioRendererInfoForSpatialization> spatializationRendererInfoList_;
123     std::mutex spatializationServiceMutex_;
124     std::mutex spatializationSupportedMutex_;
125     std::mutex spatializationStateChangeListnerMutex_;
126     std::mutex rendererInfoChangingMutex_;
127     std::unordered_map<uint32_t, std::pair<std::shared_ptr<AudioSpatializationStateChangeCallback>, StreamUsage>>
128         spatializationStateCBMap_;
129     std::map<std::string, AudioSpatialDeviceState> addressToSpatialDeviceStateMap_;
130 };
131 } // namespace AudioStandard
132 } // namespace OHOS
133 
134 #endif // ST_AUDIO_SPATIALIZATION_SERVICE_H
135