1 /*
2 * Copyright (c) 2021-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 #ifndef LOG_TAG
16 #define LOG_TAG "AudioStreamManager"
17 #endif
18
19 #include "audio_stream_manager.h"
20
21 #include "audio_errors.h"
22 #include "audio_common_log.h"
23 #include "audio_manager_util.h"
24 #include "audio_policy_manager.h"
25 #include "audio_utils.h"
26 #include "i_audio_stream.h"
27
28 namespace OHOS {
29 namespace AudioStandard {
30 using namespace std;
31 static const std::map<std::string, AudioEffectMode> effectModeMap = {
32 {"EFFECT_NONE", EFFECT_NONE},
33 {"EFFECT_DEFAULT", EFFECT_DEFAULT}
34 };
GetInstance()35 AudioStreamManager *AudioStreamManager::GetInstance()
36 {
37 static AudioStreamManager audioStreamManager;
38 return &audioStreamManager;
39 }
40
RegisterAudioRendererEventListener(const int32_t clientPid,const std::shared_ptr<AudioRendererStateChangeCallback> & callback)41 int32_t AudioStreamManager::RegisterAudioRendererEventListener(const int32_t clientPid,
42 const std::shared_ptr<AudioRendererStateChangeCallback> &callback)
43 {
44 AUDIO_INFO_LOG("client id: %{public}d", clientPid);
45 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM, "callback is null");
46
47 std::lock_guard<std::mutex> lock(rendererStateChangeCallbacksMutex_);
48 int32_t ret = AudioPolicyManager::GetInstance().RegisterAudioRendererEventListener(callback);
49 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_INVALID_PARAM, "ret: %{public}d", ret);
50
51 rendererStateChangeCallbacks_.push_back(callback);
52 return ret;
53 }
54
UnregisterAudioRendererEventListener(const int32_t clientPid)55 int32_t AudioStreamManager::UnregisterAudioRendererEventListener(const int32_t clientPid)
56 {
57 AUDIO_INFO_LOG("client id: %{public}d", clientPid);
58
59 std::lock_guard<std::mutex> lock(rendererStateChangeCallbacksMutex_);
60 int32_t ret = AudioPolicyManager::GetInstance().UnregisterAudioRendererEventListener(
61 rendererStateChangeCallbacks_);
62 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_INVALID_PARAM, "ret: %{public}d", ret);
63
64 rendererStateChangeCallbacks_.clear();
65 return ret;
66 }
67
RegisterAudioRendererEventListener(const std::shared_ptr<AudioRendererStateChangeCallback> & callback)68 int32_t AudioStreamManager::RegisterAudioRendererEventListener(
69 const std::shared_ptr<AudioRendererStateChangeCallback> &callback)
70 {
71 AUDIO_INFO_LOG("in");
72 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM, "callback is null");
73
74 int32_t ret = AudioPolicyManager::GetInstance().RegisterAudioRendererEventListener(callback);
75 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_INVALID_PARAM, "ret: %{public}d", ret);
76
77 return ret;
78 }
79
UnregisterAudioRendererEventListener(const std::shared_ptr<AudioRendererStateChangeCallback> & callback)80 int32_t AudioStreamManager::UnregisterAudioRendererEventListener(
81 const std::shared_ptr<AudioRendererStateChangeCallback> &callback)
82 {
83 AUDIO_INFO_LOG("in");
84
85 int32_t ret = AudioPolicyManager::GetInstance().UnregisterAudioRendererEventListener(callback);
86 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_INVALID_PARAM, "ret: %{public}d", ret);
87
88 return ret;
89 }
90
RegisterAudioCapturerEventListener(const int32_t clientPid,const std::shared_ptr<AudioCapturerStateChangeCallback> & callback)91 int32_t AudioStreamManager::RegisterAudioCapturerEventListener(const int32_t clientPid,
92 const std::shared_ptr<AudioCapturerStateChangeCallback> &callback)
93 {
94 AUDIO_INFO_LOG("client id: %{public}d", clientPid);
95 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM, "callback is null");
96 return AudioPolicyManager::GetInstance().RegisterAudioCapturerEventListener(clientPid, callback);
97 }
98
UnregisterAudioCapturerEventListener(const int32_t clientPid)99 int32_t AudioStreamManager::UnregisterAudioCapturerEventListener(const int32_t clientPid)
100 {
101 AUDIO_INFO_LOG("client id: %{public}d", clientPid);
102 return AudioPolicyManager::GetInstance().UnregisterAudioCapturerEventListener(clientPid);
103 }
104
GetCurrentRendererChangeInfos(vector<shared_ptr<AudioRendererChangeInfo>> & audioRendererChangeInfos)105 int32_t AudioStreamManager::GetCurrentRendererChangeInfos(
106 vector<shared_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos)
107 {
108 AUDIO_DEBUG_LOG("GetCurrentRendererChangeInfos");
109 return AudioPolicyManager::GetInstance().GetCurrentRendererChangeInfos(audioRendererChangeInfos);
110 }
111
GetCurrentCapturerChangeInfos(vector<shared_ptr<AudioCapturerChangeInfo>> & audioCapturerChangeInfos)112 int32_t AudioStreamManager::GetCurrentCapturerChangeInfos(
113 vector<shared_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos)
114 {
115 AUDIO_DEBUG_LOG("GetCurrentCapturerChangeInfos");
116 return AudioPolicyManager::GetInstance().GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
117 }
118
UpdateEffectInfoArray(SupportedEffectConfig & supportedEffectConfig,int32_t i,AudioSceneEffectInfo & audioSceneEffectInfo)119 static void UpdateEffectInfoArray(SupportedEffectConfig &supportedEffectConfig,
120 int32_t i, AudioSceneEffectInfo &audioSceneEffectInfo)
121 {
122 uint32_t j;
123 AudioEffectMode audioEffectMode;
124 for (j = 0; j < supportedEffectConfig.postProcessNew.stream[i].streamEffectMode.size(); j++) {
125 audioEffectMode = effectModeMap.at(supportedEffectConfig.postProcessNew.stream[i].streamEffectMode[j].mode);
126 audioSceneEffectInfo.mode.push_back(audioEffectMode);
127 }
128 auto index = std::find(audioSceneEffectInfo.mode.begin(), audioSceneEffectInfo.mode.end(), 0);
129 if (index == audioSceneEffectInfo.mode.end()) {
130 audioEffectMode = effectModeMap.at("EFFECT_NONE");
131 audioSceneEffectInfo.mode.push_back(audioEffectMode);
132 }
133 index = std::find(audioSceneEffectInfo.mode.begin(), audioSceneEffectInfo.mode.end(), 1);
134 if (index == audioSceneEffectInfo.mode.end()) {
135 audioEffectMode = effectModeMap.at("EFFECT_DEFAULT");
136 audioSceneEffectInfo.mode.push_back(audioEffectMode);
137 }
138 std::sort(audioSceneEffectInfo.mode.begin(), audioSceneEffectInfo.mode.end());
139 }
140
GetEffectInfoArray(AudioSceneEffectInfo & audioSceneEffectInfo,StreamUsage streamUsage)141 int32_t AudioStreamManager::GetEffectInfoArray(AudioSceneEffectInfo &audioSceneEffectInfo, StreamUsage streamUsage)
142 {
143 std::string effectScene = AudioManagerUtil::GetEffectSceneName(streamUsage);
144 SupportedEffectConfig supportedEffectConfig;
145 int32_t ret = AudioPolicyManager::GetInstance().QueryEffectSceneMode(supportedEffectConfig);
146 uint32_t streamNum = supportedEffectConfig.postProcessNew.stream.size();
147 if (streamNum >= 0) {
148 int32_t sceneFlag = 0;
149 for (uint32_t i = 0; i < streamNum; i++) {
150 if (effectScene == supportedEffectConfig.postProcessNew.stream[i].scene) {
151 UpdateEffectInfoArray(supportedEffectConfig, i, audioSceneEffectInfo);
152 sceneFlag = 1;
153 break;
154 }
155 }
156 if (sceneFlag == 0) {
157 AudioEffectMode audioEffectMode = effectModeMap.at("EFFECT_NONE");
158 audioSceneEffectInfo.mode.push_back(audioEffectMode);
159 audioEffectMode = effectModeMap.at("EFFECT_DEFAULT");
160 audioSceneEffectInfo.mode.push_back(audioEffectMode);
161 }
162 }
163 return ret;
164 }
165
IsStreamActive(AudioVolumeType volumeType) const166 bool AudioStreamManager::IsStreamActive(AudioVolumeType volumeType) const
167 {
168 switch (volumeType) {
169 case STREAM_MUSIC:
170 case STREAM_RING:
171 case STREAM_NOTIFICATION:
172 case STREAM_VOICE_CALL:
173 case STREAM_VOICE_COMMUNICATION:
174 case STREAM_VOICE_ASSISTANT:
175 case STREAM_ALARM:
176 case STREAM_SYSTEM:
177 case STREAM_ACCESSIBILITY:
178 case STREAM_VOICE_RING:
179 case STREAM_CAMCORDER:
180 break;
181 case STREAM_ULTRASONIC:{
182 bool ret = PermissionUtil::VerifySelfPermission();
183 CHECK_AND_RETURN_RET_LOG(ret, false, "volumeType=%{public}d. No system permission", volumeType);
184 break;
185 }
186 case STREAM_ALL:
187 default:
188 AUDIO_ERR_LOG("IsStreamActive: volumeType=%{public}d not supported", volumeType);
189 return false;
190 }
191
192 return AudioPolicyManager::GetInstance().IsStreamActive(volumeType);
193 }
194
GetHardwareOutputSamplingRate(std::shared_ptr<AudioDeviceDescriptor> & desc)195 int32_t AudioStreamManager::GetHardwareOutputSamplingRate(std::shared_ptr<AudioDeviceDescriptor> &desc)
196 {
197 int32_t result = 0;
198
199 if (desc == nullptr) {
200 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
201 desc->deviceType_ = DEVICE_TYPE_SPEAKER;
202 desc->deviceRole_ = OUTPUT_DEVICE;
203 }
204
205 result = AudioPolicyManager::GetInstance().GetHardwareOutputSamplingRate(desc);
206 return result;
207 }
208
GetSupportedAudioEffectProperty(AudioEffectPropertyArray & propertyArray)209 int32_t AudioStreamManager::GetSupportedAudioEffectProperty(AudioEffectPropertyArray &propertyArray)
210 {
211 return AudioPolicyManager::GetInstance().GetSupportedAudioEffectProperty(propertyArray);
212 }
213
GetSupportedAudioEnhanceProperty(AudioEnhancePropertyArray & propertyArray)214 int32_t AudioStreamManager::GetSupportedAudioEnhanceProperty(AudioEnhancePropertyArray &propertyArray)
215 {
216 return AudioPolicyManager::GetInstance().GetSupportedAudioEnhanceProperty(propertyArray);
217 }
218
SetAudioEffectProperty(const AudioEffectPropertyArray & propertyArray)219 int32_t AudioStreamManager::SetAudioEffectProperty(const AudioEffectPropertyArray &propertyArray)
220 {
221 return AudioPolicyManager::GetInstance().SetAudioEffectProperty(propertyArray);
222 }
223
GetAudioEffectProperty(AudioEffectPropertyArray & propertyArray)224 int32_t AudioStreamManager::GetAudioEffectProperty(AudioEffectPropertyArray &propertyArray)
225 {
226 return AudioPolicyManager::GetInstance().GetAudioEffectProperty(propertyArray);
227 }
228
SetAudioEnhanceProperty(const AudioEnhancePropertyArray & propertyArray)229 int32_t AudioStreamManager::SetAudioEnhanceProperty(const AudioEnhancePropertyArray &propertyArray)
230 {
231 return AudioPolicyManager::GetInstance().SetAudioEnhanceProperty(propertyArray);
232 }
233
GetAudioEnhanceProperty(AudioEnhancePropertyArray & propertyArray)234 int32_t AudioStreamManager::GetAudioEnhanceProperty(AudioEnhancePropertyArray &propertyArray)
235 {
236 return AudioPolicyManager::GetInstance().GetAudioEnhanceProperty(propertyArray);
237 }
238 } // namespace AudioStandard
239 } // namespace OHOS
240