• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2021-2022 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_MANAGER_H
17 #define ST_AUDIO_POLICY_MANAGER_H
18 
19 #include <cstdint>
20 #include "audio_client_tracker_callback_stub.h"
21 #include "audio_effect.h"
22 #include "audio_interrupt_callback.h"
23 #include "audio_policy_base.h"
24 #include "audio_policy_manager_listener_stub.h"
25 #include "audio_policy_client_stub_impl.h"
26 #include "audio_routing_manager.h"
27 #include "audio_routing_manager_listener_stub.h"
28 #include "audio_system_manager.h"
29 #include "audio_system_manager.h"
30 #include "i_standard_client_tracker.h"
31 #include "audio_log.h"
32 #include "microphone_descriptor.h"
33 #include "audio_spatialization_manager.h"
34 #include "audio_spatialization_state_change_listener_stub.h"
35 #include "i_standard_spatialization_state_change_listener.h"
36 
37 namespace OHOS {
38 namespace AudioStandard {
39 using InternalDeviceType = DeviceType;
40 using InternalAudioCapturerOptions = AudioCapturerOptions;
41 
42 class AudioPolicyManager {
43 public:
GetInstance()44     static AudioPolicyManager& GetInstance()
45     {
46         static AudioPolicyManager policyManager;
47         return policyManager;
48     }
49 
50     int32_t GetMaxVolumeLevel(AudioVolumeType volumeType);
51 
52     int32_t GetMinVolumeLevel(AudioVolumeType volumeType);
53 
54     int32_t SetSystemVolumeLevel(AudioVolumeType volumeType, int32_t volumeLevel, API_VERSION api_v = API_9);
55 
56     int32_t GetSystemVolumeLevel(AudioVolumeType volumeType);
57 
58     int32_t SetLowPowerVolume(int32_t streamId, float volume);
59 
60     float GetLowPowerVolume(int32_t streamId);
61 
62     float GetSingleStreamVolume(int32_t streamId);
63 
64     int32_t SetStreamMute(AudioVolumeType volumeType, bool mute, API_VERSION api_v = API_9);
65 
66     bool GetStreamMute(AudioVolumeType volumeType);
67 
68     bool IsStreamActive(AudioVolumeType volumeType);
69 
70     int32_t SelectOutputDevice(sptr<AudioRendererFilter> audioRendererFilter,
71         std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors);
72 
73     std::string GetSelectedDeviceInfo(int32_t uid, int32_t pid, AudioStreamType streamType);
74 
75     int32_t SelectInputDevice(sptr<AudioCapturerFilter> audioCapturerFilter,
76         std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors);
77 
78     std::vector<sptr<AudioDeviceDescriptor>> GetDevices(DeviceFlag deviceFlag);
79 
80     int32_t SetDeviceActive(InternalDeviceType deviceType, bool active);
81 
82     bool IsDeviceActive(InternalDeviceType deviceType);
83 
84     DeviceType GetActiveOutputDevice();
85 
86     DeviceType GetActiveInputDevice();
87 
88     int32_t SetRingerMode(AudioRingerMode ringMode, API_VERSION api_v = API_9);
89 
90 #ifdef FEATURE_DTMF_TONE
91     std::vector<int32_t> GetSupportedTones();
92 
93     std::shared_ptr<ToneInfo> GetToneConfig(int32_t ltonetype);
94 #endif
95 
96     AudioRingerMode GetRingerMode();
97 
98     int32_t SetAudioScene(AudioScene scene);
99 
100     int32_t SetMicrophoneMute(bool isMute);
101 
102     int32_t SetMicrophoneMuteAudioConfig(bool isMute);
103 
104     bool IsMicrophoneMute(API_VERSION api_v = API_9);
105 
106     AudioScene GetAudioScene();
107 
108     int32_t SetDeviceChangeCallback(const int32_t clientId, const DeviceFlag flag,
109         const std::shared_ptr<AudioManagerDeviceChangeCallback> &callback);
110 
111     int32_t UnsetDeviceChangeCallback(const int32_t clientId, DeviceFlag flag);
112 
113     int32_t SetRingerModeCallback(const int32_t clientId,
114         const std::shared_ptr<AudioRingerModeCallback> &callback, API_VERSION api_v = API_9);
115 
116     int32_t UnsetRingerModeCallback(const int32_t clientId);
117 
118     int32_t UnsetRingerModeCallback(const int32_t clientId,
119         const std::shared_ptr<AudioRingerModeCallback> &callback);
120 
121     int32_t SetMicStateChangeCallback(const int32_t clientId,
122         const std::shared_ptr<AudioManagerMicStateChangeCallback> &callback);
123 
124     int32_t SetAudioInterruptCallback(const uint32_t sessionID,
125         const std::shared_ptr<AudioInterruptCallback> &callback, const int32_t zoneID = 0);
126 
127     int32_t UnsetAudioInterruptCallback(const uint32_t sessionID, const int32_t zoneID = 0);
128 
129     int32_t ActivateAudioInterrupt(const AudioInterrupt &audioInterrupt, const int32_t zoneID = 0);
130 
131     int32_t DeactivateAudioInterrupt(const AudioInterrupt &audioInterrupt, const int32_t zoneID = 0);
132 
133     int32_t SetAudioManagerInterruptCallback(const int32_t clientId,
134         const std::shared_ptr<AudioInterruptCallback> &callback);
135 
136     int32_t UnsetAudioManagerInterruptCallback(const int32_t clientId);
137 
138     int32_t RequestAudioFocus(const int32_t clientId, const AudioInterrupt &audioInterrupt);
139 
140     int32_t AbandonAudioFocus(const int32_t clientId, const AudioInterrupt &audioInterrupt);
141 
142     AudioStreamType GetStreamInFocus(const int32_t zoneID = 0);
143 
144     int32_t GetSessionInfoInFocus(AudioInterrupt &audioInterrupt, const int32_t zoneID = 0);
145 
146     int32_t SetVolumeKeyEventCallback(const int32_t clientPid,
147         const std::shared_ptr<VolumeKeyEventCallback> &callback, API_VERSION api_v = API_9);
148 
149     int32_t UnsetVolumeKeyEventCallback(const int32_t clientPid);
150 
151     bool CheckRecordingCreate(uint32_t appTokenId, uint64_t appFullTokenId, int32_t appUid,
152         SourceType sourceType = SOURCE_TYPE_MIC);
153 
154     bool CheckRecordingStateChange(uint32_t appTokenId, uint64_t appFullTokenId, int32_t appUid,
155         AudioPermissionState state);
156 
157     int32_t ReconfigureAudioChannel(const uint32_t &count, DeviceType deviceType);
158 
159     int32_t GetAudioLatencyFromXml();
160 
161     uint32_t GetSinkLatencyFromXml();
162 
163     int32_t RegisterAudioRendererEventListener(const int32_t clientPid,
164         const std::shared_ptr<AudioRendererStateChangeCallback> &callback);
165 
166     int32_t UnregisterAudioRendererEventListener(const int32_t clientPid);
167 
168     int32_t RegisterAudioCapturerEventListener(const int32_t clientPid,
169         const std::shared_ptr<AudioCapturerStateChangeCallback> &callback);
170 
171     int32_t UnregisterAudioCapturerEventListener(const int32_t clientPid);
172 
173     int32_t RegisterOutputDeviceChangeWithInfoCallback(
174         const uint32_t sessionID, const std::shared_ptr<OutputDeviceChangeWithInfoCallback> &callback);
175 
176     int32_t UnregisterOutputDeviceChangeWithInfoCallback(const uint32_t sessionID);
177 
178     int32_t RegisterTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo,
179         const std::shared_ptr<AudioClientTracker> &clientTrackerObj);
180 
181     int32_t UpdateTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo);
182 
183     int32_t GetCurrentRendererChangeInfos(
184         std::vector<std::unique_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos);
185 
186     int32_t GetCurrentCapturerChangeInfos(
187         std::vector<std::unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos);
188 
189     int32_t UpdateStreamState(const int32_t clientUid, StreamSetState streamSetState,
190                                     AudioStreamType audioStreamType);
191 
192     int32_t GetVolumeGroupInfos(std::string networkId, std::vector<sptr<VolumeGroupInfo>> &infos);
193 
194     int32_t GetNetworkIdByGroupId(int32_t groupId, std::string &networkId);
195 
196     bool IsAudioRendererLowLatencySupported(const AudioStreamInfo &audioStreamInfo);
197 
198     std::vector<sptr<AudioDeviceDescriptor>> GetPreferredOutputDeviceDescriptors(AudioRendererInfo &rendererInfo);
199 
200     std::vector<sptr<AudioDeviceDescriptor>> GetPreferredInputDeviceDescriptors(AudioCapturerInfo &captureInfo);
201 
202     int32_t SetPreferredOutputDeviceChangeCallback(const int32_t clientId,
203         const std::shared_ptr<AudioPreferredOutputDeviceChangeCallback> &callback);
204 
205     int32_t SetPreferredInputDeviceChangeCallback(
206         const std::shared_ptr<AudioPreferredInputDeviceChangeCallback> &callback);
207 
208     int32_t UnsetPreferredOutputDeviceChangeCallback(const int32_t clientId);
209 
210     int32_t UnsetPreferredInputDeviceChangeCallback();
211 
212     int32_t GetAudioFocusInfoList(std::list<std::pair<AudioInterrupt, AudioFocuState>> &focusInfoList,
213         const int32_t zoneID = 0);
214 
215     int32_t RegisterFocusInfoChangeCallback(const int32_t clientId,
216         const std::shared_ptr<AudioFocusInfoChangeCallback> &callback);
217 
218     int32_t UnregisterFocusInfoChangeCallback(const int32_t clientId);
219 
220     static void AudioPolicyServerDied(pid_t pid);
221 
222     int32_t SetSystemSoundUri(const std::string &key, const std::string &uri);
223 
224     std::string GetSystemSoundUri(const std::string &key);
225 
226     float GetMinStreamVolume(void);
227 
228     float GetMaxStreamVolume(void);
229     int32_t RegisterAudioPolicyServerDiedCb(const int32_t clientPid,
230         const std::weak_ptr<AudioRendererPolicyServiceDiedCallback> &callback);
231     int32_t UnregisterAudioPolicyServerDiedCb(const int32_t clientPid);
232 
233     int32_t RegisterAudioStreamPolicyServerDiedCb(
234         const std::shared_ptr<AudioStreamPolicyServiceDiedCallback> &callback);
235     int32_t UnregisterAudioStreamPolicyServerDiedCb(
236         const std::shared_ptr<AudioStreamPolicyServiceDiedCallback> &callback);
237 
238     bool IsVolumeUnadjustable();
239 
240     int32_t AdjustVolumeByStep(VolumeAdjustType adjustType);
241 
242     int32_t AdjustSystemVolumeByStep(AudioVolumeType volumeType, VolumeAdjustType adjustType);
243 
244     float GetSystemVolumeInDb(AudioVolumeType volumeType, int32_t volumeLevel, DeviceType deviceType);
245 
246     int32_t GetMaxRendererInstances();
247 
248     int32_t QueryEffectSceneMode(SupportedEffectConfig &supportedEffectConfig);
249 
250     int32_t SetPlaybackCapturerFilterInfos(const AudioPlaybackCaptureConfig &config, uint32_t appTokenId);
251 
252     int32_t SetCaptureSilentState(bool state);
253 
254     int32_t GetHardwareOutputSamplingRate(const sptr<AudioDeviceDescriptor> &desc);
255 
256     static void RecoverAudioPolicyCallbackClient();
257 
258     std::vector<sptr<MicrophoneDescriptor>> GetAudioCapturerMicrophoneDescriptors(int32_t sessionID);
259 
260     std::vector<sptr<MicrophoneDescriptor>> GetAvailableMicrophones();
261 
262     int32_t SetDeviceAbsVolumeSupported(const std::string &macAddress, const bool support);
263 
264     bool IsAbsVolumeScene();
265 
266     int32_t SetA2dpDeviceVolume(const std::string &macAddress, const int32_t volume, const bool updateUi);
267 
268     std::vector<std::unique_ptr<AudioDeviceDescriptor>> GetAvailableDevices(AudioDeviceUsage usage);
269 
270     int32_t SetAvailableDeviceChangeCallback(const int32_t clientId, const AudioDeviceUsage usage,
271         const std::shared_ptr<AudioManagerAvailableDeviceChangeCallback>& callback);
272 
273     int32_t UnsetAvailableDeviceChangeCallback(const int32_t clientId, AudioDeviceUsage usage);
274 
275     bool IsSpatializationEnabled();
276 
277     int32_t SetSpatializationEnabled(const bool enable);
278 
279     bool IsHeadTrackingEnabled();
280 
281     int32_t SetHeadTrackingEnabled(const bool enable);
282 
283     int32_t RegisterSpatializationEnabledEventListener(
284         const std::shared_ptr<AudioSpatializationEnabledChangeCallback> &callback);
285 
286     int32_t RegisterHeadTrackingEnabledEventListener(
287         const std::shared_ptr<AudioHeadTrackingEnabledChangeCallback> &callback);
288 
289     int32_t UnregisterSpatializationEnabledEventListener();
290 
291     int32_t UnregisterHeadTrackingEnabledEventListener();
292 
293     AudioSpatializationState GetSpatializationState(const StreamUsage streamUsage);
294 
295     bool IsSpatializationSupported();
296 
297     bool IsSpatializationSupportedForDevice(const std::string address);
298 
299     bool IsHeadTrackingSupported();
300 
301     bool IsHeadTrackingSupportedForDevice(const std::string address);
302 
303     int32_t UpdateSpatialDeviceState(const AudioSpatialDeviceState audioSpatialDeviceState);
304 
305     int32_t RegisterSpatializationStateEventListener(const uint32_t sessionID, const StreamUsage streamUsage,
306         const std::shared_ptr<AudioSpatializationStateChangeCallback> &callback);
307 
308     int32_t ConfigDistributedRoutingRole(sptr<AudioDeviceDescriptor> descriptor, CastType type);
309 
310     int32_t SetDistributedRoutingRoleCallback(const std::shared_ptr<AudioDistributedRoutingRoleCallback> &callback);
311 
312     int32_t UnsetDistributedRoutingRoleCallback();
313 
314     int32_t UnregisterSpatializationStateEventListener(const uint32_t sessionID);
315 
316     int32_t CreateAudioInterruptZone(const std::set<int32_t> pids, const int32_t zoneID);
317 
318     int32_t AddAudioInterruptZonePids(const std::set<int32_t> pids, const int32_t zoneID);
319 
320     int32_t RemoveAudioInterruptZonePids(const std::set<int32_t> pids, const int32_t zoneID);
321 
322     int32_t ReleaseAudioInterruptZone(const int32_t zoneID);
323 
324     int32_t SetCallDeviceActive(InternalDeviceType deviceType, bool active, std::string address);
325 
326     std::unique_ptr<AudioDeviceDescriptor> GetActiveBluetoothDevice();
327 
328     int32_t NotifyCapturerAdded(AudioCapturerInfo capturerInfo, AudioStreamInfo streamInfo, uint32_t sessionId);
329 
330 private:
AudioPolicyManager()331     AudioPolicyManager()
332     {
333         AUDIO_INFO_LOG("Enter AudioPolicyManager::AudioPolicyManager");
334     }
~AudioPolicyManager()335     ~AudioPolicyManager() {}
336 
337     int32_t RegisterPolicyCallbackClientFunc(const sptr<IAudioPolicy> &gsp);
338 
339     std::mutex listenerStubMutex_;
340     std::mutex registerCallbackMutex_;
341     std::mutex stateChangelistenerStubMutex_;
342     std::mutex clientTrackerStubMutex_;
343     sptr<AudioPolicyClientStubImpl> audioPolicyClientStubCB_;
344     static std::unordered_map<int32_t, std::weak_ptr<AudioRendererPolicyServiceDiedCallback>> rendererCBMap_;
345     static sptr<AudioPolicyClientStubImpl> audioStaticPolicyClientStubCB_;
346     static std::vector<std::shared_ptr<AudioStreamPolicyServiceDiedCallback>> audioStreamCBMap_;
347 
348     bool isAudioRendererEventListenerRegistered = false;
349     bool isAudioCapturerEventListenerRegistered = false;
350 };
351 } // namespce AudioStandard
352 } // namespace OHOS
353 
354 #endif // ST_AUDIO_POLICY_MANAGER_H
355