1 /*
2 * Copyright (c) 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 #ifndef LOG_TAG
16 #define LOG_TAG "AudioServer"
17 #endif
18
19 #include "audio_server.h"
20
21 #include <unordered_map>
22 #include <vector>
23
24 #include "audio_errors.h"
25 #include "audio_common_log.h"
26 #include "audio_asr.h"
27 #include "audio_utils.h"
28 #include "policy_handler.h"
29 #include "common/hdi_adapter_info.h"
30 #include "manager/hdi_adapter_manager.h"
31 #include "sink/i_audio_render_sink.h"
32
33 using namespace std;
34
35 namespace OHOS {
36 namespace AudioStandard {
37
38 static const std::map<std::string, AsrAecMode> AEC_MODE_MAP = {
39 {"BYPASS", AsrAecMode::BYPASS},
40 {"STANDARD", AsrAecMode::STANDARD},
41 {"EXPAND", AsrAecMode::EXPAND},
42 {"FOLDED", AsrAecMode::FOLDED}
43 };
44
45 static const std::map<AsrAecMode, std::string> AEC_MODE_MAP_VERSE = {
46 {AsrAecMode::BYPASS, "BYPASS"},
47 {AsrAecMode::STANDARD, "STANDARD"},
48 {AsrAecMode::EXPAND, "EXPAND"},
49 {AsrAecMode::FOLDED, "FOLDED"}
50 };
51
52 static const std::map<std::string, AsrNoiseSuppressionMode> NS_MODE_MAP = {
53 {"BYPASS", AsrNoiseSuppressionMode::BYPASS},
54 {"STANDARD", AsrNoiseSuppressionMode::STANDARD},
55 {"NEAR_FIELD", AsrNoiseSuppressionMode::NEAR_FIELD},
56 {"FAR_FIELD", AsrNoiseSuppressionMode::FAR_FIELD},
57 {"FULL_DUPLEX_STANDARD", AsrNoiseSuppressionMode::FULL_DUPLEX_STANDARD},
58 {"FULL_DUPLEX_NEAR_FIELD", AsrNoiseSuppressionMode::FULL_DUPLEX_NEAR_FIELD},
59 {"ASR_WHISPER_MODE", AsrNoiseSuppressionMode::ASR_WHISPER_MODE}
60 };
61
62 static const std::map<AsrNoiseSuppressionMode, std::string> NS_MODE_MAP_VERSE = {
63 {AsrNoiseSuppressionMode::BYPASS, "BYPASS"},
64 {AsrNoiseSuppressionMode::STANDARD, "STANDARD"},
65 {AsrNoiseSuppressionMode::NEAR_FIELD, "NEAR_FIELD"},
66 {AsrNoiseSuppressionMode::FAR_FIELD, "FAR_FIELD"},
67 {AsrNoiseSuppressionMode::FULL_DUPLEX_STANDARD, "FULL_DUPLEX_STANDARD"},
68 {AsrNoiseSuppressionMode::FULL_DUPLEX_NEAR_FIELD, "FULL_DUPLEX_NEAR_FIELD"},
69 {AsrNoiseSuppressionMode::ASR_WHISPER_MODE, "ASR_WHISPER_MODE"}
70 };
71
72 static const std::map<std::string, AsrWhisperDetectionMode> WHISPER_DETECTION_MODE_MAP = {
73 {"BYPASS", AsrWhisperDetectionMode::BYPASS},
74 {"STANDARD", AsrWhisperDetectionMode::STANDARD},
75 };
76
77 static const std::map<AsrWhisperDetectionMode, std::string> WHISPER_DETECTION_MODE_MAP_VERSE = {
78 {AsrWhisperDetectionMode::BYPASS, "BYPASS"},
79 {AsrWhisperDetectionMode::STANDARD, "STANDARD"},
80 };
81
82 static const std::map<std::string, AsrVoiceControlMode> VC_MODE_MAP = {
83 {"audio2voicetx", AsrVoiceControlMode::AUDIO_2_VOICETX},
84 {"audiomix2voicetx", AsrVoiceControlMode::AUDIO_MIX_2_VOICETX},
85 {"audio2voicetxex", AsrVoiceControlMode::AUDIO_2_VOICE_TX_EX},
86 {"audiomix2voicetxex", AsrVoiceControlMode::AUDIO_MIX_2_VOICE_TX_EX},
87 };
88
89 static const std::map<AsrVoiceControlMode, std::string> VC_MODE_MAP_VERSE = {
90 {AsrVoiceControlMode::AUDIO_2_VOICETX, "audio2voicetx"},
91 {AsrVoiceControlMode::AUDIO_MIX_2_VOICETX, "audiomix2voicetx"},
92 {AsrVoiceControlMode::AUDIO_2_VOICE_TX_EX, "audio2voicetxex"},
93 {AsrVoiceControlMode::AUDIO_MIX_2_VOICE_TX_EX, "audiomix2voicetxex"},
94 };
95
96 static const std::string TTS_2_DEVICE_STRING = "TTS_2_DEVICE";
97 static const std::string TTS_2_MODEM_STRING = "TTS_2_MODEM";
98
99 static const std::map<AsrVoiceControlMode, std::vector<std::string>> VOICE_CALL_ASSISTANT_SUPPRESSION = {
100 {AsrVoiceControlMode::AUDIO_SUPPRESSION_OPPOSITE, {TTS_2_DEVICE_STRING, TTS_2_MODEM_STRING}},
101 {AsrVoiceControlMode::AUDIO_SUPPRESSION_LOCAL, {TTS_2_DEVICE_STRING, TTS_2_MODEM_STRING}},
102 {AsrVoiceControlMode::VOICE_TXRX_DECREASE, {"MIC_2_MODEM", "MODEM_2_DEVICE"}},
103 };
104
105 static const std::map<AsrVoiceControlMode, std::set<std::string>> VOICE_CALL_ASSISTANT_NEED_SUPPRESSION = {
106 {AsrVoiceControlMode::AUDIO_SUPPRESSION_OPPOSITE, {TTS_2_MODEM_STRING}},
107 {AsrVoiceControlMode::AUDIO_SUPPRESSION_LOCAL, {TTS_2_DEVICE_STRING}},
108 {AsrVoiceControlMode::VOICE_TXRX_DECREASE, {"MIC_2_MODEM", "MODEM_2_DEVICE"}},
109 };
110
111 static const std::string VOICE_CALL_SUPPRESSION_VOLUME = "2";
112 static const std::string VOICE_CALL_FULL_VOLUME = "32";
113
114 static const int32_t VOICE_CALL_MIN_VOLUME = 2;
115 static const int32_t VOICE_CALL_MAX_VOLUME = 32;
116
117 static const std::map<std::string, AsrVoiceMuteMode> VM_MODE_MAP = {
118 {"output_mute", AsrVoiceMuteMode::OUTPUT_MUTE},
119 {"input_mute", AsrVoiceMuteMode::INPUT_MUTE},
120 {"mute_tts", AsrVoiceMuteMode::TTS_MUTE},
121 {"mute_call", AsrVoiceMuteMode::CALL_MUTE},
122 {"ouput_mute_ex", AsrVoiceMuteMode::OUTPUT_MUTE_EX},
123 };
124
125 static const std::map<AsrVoiceMuteMode, std::string> VM_MODE_MAP_VERSE = {
126 {AsrVoiceMuteMode::OUTPUT_MUTE, "output_mute"},
127 {AsrVoiceMuteMode::INPUT_MUTE, "input_mute"},
128 {AsrVoiceMuteMode::TTS_MUTE, "mute_tts"},
129 {AsrVoiceMuteMode::CALL_MUTE, "mute_call"},
130 {AsrVoiceMuteMode::OUTPUT_MUTE_EX, "ouput_mute_ex"},
131 };
132
133 static const std::map<std::string, bool> RES_MAP = {
134 {"true", true},
135 {"false", false},
136 };
137
138 static const std::map<bool, std::string> RES_MAP_VERSE = {
139 {true, "true"},
140 {false, "false"},
141 };
142
splitString(const std::string & str,const std::string & pattern)143 std::vector<std::string> splitString(const std::string& str, const std::string& pattern)
144 {
145 std::vector<std::string> res;
146 if (str == "")
147 return res;
148 std::string strs = str + pattern;
149 size_t pos = strs.find(pattern);
150
151 while (pos != strs.npos) {
152 std::string temp = strs.substr(0, pos);
153 res.push_back(temp);
154 strs = strs.substr(pos + 1, strs.size());
155 pos = strs.find(pattern);
156 }
157 return res;
158 }
159
SetAsrAecMode(int32_t asrAecMode)160 int32_t AudioServer::SetAsrAecMode(int32_t asrAecMode)
161 {
162 CHECK_AND_RETURN_RET_LOG(PermissionUtil::VerifySystemPermission(), ERR_SYSTEM_PERMISSION_DENIED,
163 "Check playback permission failed, no system permission");
164 std::lock_guard<std::mutex> lockSet(audioParameterMutex_);
165 std::string key = "asr_aec_mode";
166 std::string value = key + "=";
167 std::string keyAec = "ASR_AEC";
168 std::string valueAec = "";
169
170 auto it = AEC_MODE_MAP_VERSE.find(static_cast<AsrAecMode>(asrAecMode));
171 if (it != AEC_MODE_MAP_VERSE.end()) {
172 value = key + "=" + it->second;
173 if (it->second == "STANDARD") {
174 valueAec = "ASR_AEC=ON";
175 } else {
176 valueAec = "ASR_AEC=OFF";
177 }
178 } else {
179 AUDIO_ERR_LOG("get value failed.");
180 return ERR_INVALID_PARAM;
181 }
182 AudioServer::audioParameters[key] = value;
183 AudioServer::audioParameters[keyAec] = valueAec;
184 AudioParamKey parmKey = AudioParamKey::NONE;
185 HdiAdapterManager &manager = HdiAdapterManager::GetInstance();
186 std::shared_ptr<IDeviceManager> deviceManager = manager.GetDeviceManager(HDI_DEVICE_MANAGER_TYPE_LOCAL);
187 CHECK_AND_RETURN_RET_LOG(deviceManager != nullptr, ERROR, "local device manager is nullptr!");
188 deviceManager->SetAudioParameter("primary", parmKey, "", value);
189 deviceManager->SetAudioParameter("primary", parmKey, "", valueAec);
190 return 0;
191 }
192
GetAsrAecMode(int32_t & asrAecMode)193 int32_t AudioServer::GetAsrAecMode(int32_t& asrAecMode)
194 {
195 CHECK_AND_RETURN_RET_LOG(PermissionUtil::VerifySystemPermission(), ERR_SYSTEM_PERMISSION_DENIED,
196 "Check playback permission failed, no system permission");
197 std::lock_guard<std::mutex> lockSet(audioParameterMutex_);
198 std::string key = "asr_aec_mode";
199 AudioParamKey parmKey = AudioParamKey::NONE;
200 HdiAdapterManager &manager = HdiAdapterManager::GetInstance();
201 std::shared_ptr<IDeviceManager> deviceManager = manager.GetDeviceManager(HDI_DEVICE_MANAGER_TYPE_LOCAL);
202 CHECK_AND_RETURN_RET_LOG(deviceManager != nullptr, ERROR, "local device manager is nullptr!");
203 std::string asrAecModeSink = deviceManager->GetAudioParameter("primary", parmKey, key);
204 auto it = AudioServer::audioParameters.find(key);
205 if (it != AudioServer::audioParameters.end()) {
206 asrAecModeSink = it->second;
207 } else {
208 // if asr_aec_mode null, return ASR_AEC.
209 // if asr_aec_mode null and ASR_AEC null, return err.
210 std::string keyAec = "ASR_AEC";
211 auto itAec = AudioServer::audioParameters.find(keyAec);
212 std::string asrAecSink = itAec->second;
213 if (asrAecSink == "ASR_AEC=ON") {
214 asrAecMode = static_cast<int>(AsrAecMode::STANDARD);
215 } else if (asrAecSink == "ASR_AEC=OFF") {
216 asrAecMode = static_cast<int>(AsrAecMode::BYPASS);
217 } else {
218 AUDIO_ERR_LOG("get value failed!");
219 return ERR_INVALID_PARAM;
220 }
221 return 0;
222 }
223
224 std::vector<std::string> resMode = splitString(asrAecModeSink, "=");
225 const int32_t resSize = 2;
226 if (resMode.size() == resSize) {
227 std::string modeString = "";
228 modeString = resMode[1];
229 auto itAecMode = AEC_MODE_MAP.find(modeString);
230 if (itAecMode != AEC_MODE_MAP.end()) {
231 asrAecMode = static_cast<int>(itAecMode->second);
232 } else {
233 AUDIO_ERR_LOG("get value failed!");
234 return ERR_INVALID_PARAM;
235 }
236 } else {
237 AUDIO_ERR_LOG("get value failed!");
238 return ERR_INVALID_PARAM;
239 }
240 return 0;
241 }
242
SetAsrNoiseSuppressionMode(int32_t asrNoiseSuppressionMode)243 int32_t AudioServer::SetAsrNoiseSuppressionMode(int32_t asrNoiseSuppressionMode)
244 {
245 CHECK_AND_RETURN_RET_LOG(PermissionUtil::VerifySystemPermission(), ERR_SYSTEM_PERMISSION_DENIED,
246 "Check playback permission failed, no system permission");
247 std::lock_guard<std::mutex> lockSet(audioParameterMutex_);
248 std::string key = "asr_ns_mode";
249 std::string value = key + "=";
250
251 auto it = NS_MODE_MAP_VERSE.find(static_cast<AsrNoiseSuppressionMode>(asrNoiseSuppressionMode));
252 if (it != NS_MODE_MAP_VERSE.end()) {
253 value = key + "=" + it->second;
254 } else {
255 AUDIO_ERR_LOG("get value failed.");
256 return ERR_INVALID_PARAM;
257 }
258 AudioServer::audioParameters[key] = value;
259 AudioParamKey parmKey = AudioParamKey::NONE;
260 HdiAdapterManager &manager = HdiAdapterManager::GetInstance();
261 std::shared_ptr<IDeviceManager> deviceManager = manager.GetDeviceManager(HDI_DEVICE_MANAGER_TYPE_LOCAL);
262 CHECK_AND_RETURN_RET_LOG(deviceManager != nullptr, ERROR, "local device manager is nullptr!");
263 deviceManager->SetAudioParameter("primary", parmKey, "", value);
264 return 0;
265 }
266
GetAsrNoiseSuppressionMode(int32_t & asrNoiseSuppressionMode)267 int32_t AudioServer::GetAsrNoiseSuppressionMode(int32_t& asrNoiseSuppressionMode)
268 {
269 CHECK_AND_RETURN_RET_LOG(PermissionUtil::VerifySystemPermission(), ERR_SYSTEM_PERMISSION_DENIED,
270 "Check playback permission failed, no system permission");
271 std::lock_guard<std::mutex> lockSet(audioParameterMutex_);
272 std::string key = "asr_ns_mode";
273 AudioParamKey parmKey = AudioParamKey::NONE;
274 HdiAdapterManager &manager = HdiAdapterManager::GetInstance();
275 std::shared_ptr<IDeviceManager> deviceManager = manager.GetDeviceManager(HDI_DEVICE_MANAGER_TYPE_LOCAL);
276 CHECK_AND_RETURN_RET_LOG(deviceManager != nullptr, ERROR, "local device manager is nullptr!");
277 std::string asrNoiseSuppressionModeSink = deviceManager->GetAudioParameter("primary", parmKey, key);
278 auto it = AudioServer::audioParameters.find(key);
279 if (it != AudioServer::audioParameters.end()) {
280 asrNoiseSuppressionModeSink = it->second;
281 } else {
282 AUDIO_ERR_LOG("get value failed.");
283 return ERR_INVALID_PARAM;
284 }
285
286 std::vector<std::string> resMode = splitString(asrNoiseSuppressionModeSink, "=");
287 const int32_t resSize = 2;
288 if (resMode.size() == resSize) {
289 std::string modeString = "";
290 modeString = resMode[1];
291 auto itNsMode = NS_MODE_MAP.find(modeString);
292 if (itNsMode != NS_MODE_MAP.end()) {
293 asrNoiseSuppressionMode = static_cast<int>(itNsMode->second);
294 } else {
295 AUDIO_ERR_LOG("get value failed.");
296 return ERR_INVALID_PARAM;
297 }
298 } else {
299 AUDIO_ERR_LOG("get value failed.");
300 return ERR_INVALID_PARAM;
301 }
302 return 0;
303 }
304
SetAsrWhisperDetectionMode(int32_t asrWhisperDetectionMode)305 int32_t AudioServer::SetAsrWhisperDetectionMode(int32_t asrWhisperDetectionMode)
306 {
307 CHECK_AND_RETURN_RET_LOG(PermissionUtil::VerifySystemPermission(), ERR_SYSTEM_PERMISSION_DENIED,
308 "Check playback permission failed, no system permission");
309 std::lock_guard<std::mutex> lockSet(audioParameterMutex_);
310 std::string key = "asr_wd_mode";
311 std::string value = key + "=";
312
313 auto it = WHISPER_DETECTION_MODE_MAP_VERSE.find(static_cast<AsrWhisperDetectionMode>(asrWhisperDetectionMode));
314 if (it != WHISPER_DETECTION_MODE_MAP_VERSE.end()) {
315 value = key + "=" + it->second;
316 } else {
317 AUDIO_ERR_LOG("get value failed.");
318 return ERR_INVALID_PARAM;
319 }
320 AudioServer::audioParameters[key] = value;
321 AudioParamKey parmKey = AudioParamKey::NONE;
322 HdiAdapterManager &manager = HdiAdapterManager::GetInstance();
323 std::shared_ptr<IDeviceManager> deviceManager = manager.GetDeviceManager(HDI_DEVICE_MANAGER_TYPE_LOCAL);
324 CHECK_AND_RETURN_RET_LOG(deviceManager != nullptr, ERROR, "local device manager is nullptr");
325 deviceManager->SetAudioParameter("primary", parmKey, "", value);
326 return 0;
327 }
328
GetAsrWhisperDetectionMode(int32_t & asrWhisperDetectionMode)329 int32_t AudioServer::GetAsrWhisperDetectionMode(int32_t& asrWhisperDetectionMode)
330 {
331 CHECK_AND_RETURN_RET_LOG(PermissionUtil::VerifySystemPermission(), ERR_SYSTEM_PERMISSION_DENIED,
332 "Check playback permission failed, no system permission");
333 std::lock_guard<std::mutex> lockSet(audioParameterMutex_);
334 std::string key = "asr_wd_mode";
335 AudioParamKey parmKey = AudioParamKey::NONE;
336 HdiAdapterManager &manager = HdiAdapterManager::GetInstance();
337 std::shared_ptr<IDeviceManager> deviceManager = manager.GetDeviceManager(HDI_DEVICE_MANAGER_TYPE_LOCAL);
338 CHECK_AND_RETURN_RET_LOG(deviceManager != nullptr, ERROR, "local device manager is nullptr");
339 std::string asrWhisperDetectionModeSink = deviceManager->GetAudioParameter("primary", parmKey, key);
340 auto it = AudioServer::audioParameters.find(key);
341 if (it != AudioServer::audioParameters.end()) {
342 asrWhisperDetectionModeSink = it->second;
343 } else {
344 AUDIO_ERR_LOG("get value failed.");
345 return ERR_INVALID_PARAM;
346 }
347
348 std::vector<std::string> resMode = splitString(asrWhisperDetectionModeSink, "=");
349 const int32_t resSize = 2;
350 if (resMode.size() == resSize) {
351 std::string modeString = "";
352 modeString = resMode[1];
353 auto itWhisper = WHISPER_DETECTION_MODE_MAP.find(modeString);
354 if (itWhisper != WHISPER_DETECTION_MODE_MAP.end()) {
355 asrWhisperDetectionMode = static_cast<int>(itWhisper->second);
356 } else {
357 AUDIO_ERR_LOG("get value failed.");
358 return ERR_INVALID_PARAM;
359 }
360 } else {
361 AUDIO_ERR_LOG("get value failed.");
362 return ERR_INVALID_PARAM;
363 }
364 return 0;
365 }
366 // LCOV_EXCL_STOP
367
SetAsrVoiceSuppressionControlMode(const AudioParamKey paramKey,AsrVoiceControlMode asrVoiceControlMode,bool on,int32_t modifyVolume)368 int32_t AudioServer::SetAsrVoiceSuppressionControlMode(
369 const AudioParamKey paramKey, AsrVoiceControlMode asrVoiceControlMode, bool on, int32_t modifyVolume)
370 {
371 HdiAdapterManager &manager = HdiAdapterManager::GetInstance();
372 std::shared_ptr<IDeviceManager> deviceManager = manager.GetDeviceManager(HDI_DEVICE_MANAGER_TYPE_LOCAL);
373 CHECK_AND_RETURN_RET_LOG(deviceManager != nullptr, ERROR, "local device manager is nullptr");
374 std::vector<std::string> modes = VOICE_CALL_ASSISTANT_SUPPRESSION.at(asrVoiceControlMode);
375 std::set<std::string> needSuppression = VOICE_CALL_ASSISTANT_NEED_SUPPRESSION.at(asrVoiceControlMode);
376 for (size_t i = 0; i < modes.size(); i++) {
377 if (needSuppression.contains(modes[i]) && on) {
378 deviceManager->SetAudioParameter("primary", paramKey, "", modes[i] + "=" + VOICE_CALL_SUPPRESSION_VOLUME);
379 continue;
380 }
381 if (modes[i] == TTS_2_MODEM_STRING || !on) {
382 deviceManager->SetAudioParameter("primary", paramKey, "", modes[i] + "=" + VOICE_CALL_FULL_VOLUME);
383 continue;
384 }
385 deviceManager->SetAudioParameter("primary", paramKey, "", modes[i] + "=" + std::to_string(modifyVolume));
386 }
387
388 return 0;
389 }
390
SetAsrVoiceControlMode(int32_t asrVoiceControlMode,bool on)391 int32_t AudioServer::SetAsrVoiceControlMode(int32_t asrVoiceControlMode, bool on)
392 {
393 CHECK_AND_RETURN_RET_LOG(PermissionUtil::VerifySystemPermission(), ERR_SYSTEM_PERMISSION_DENIED,
394 "Check playback permission failed, no system permission");
395 std::lock_guard<std::mutex> lockSet(audioParameterMutex_);
396 std::string key = "avcm";
397 std::string value = key + "=";
398
399 AsrVoiceControlMode asrVoiceControlModeTmp = static_cast<AsrVoiceControlMode>(asrVoiceControlMode);
400 auto itVerse = VC_MODE_MAP_VERSE.find(asrVoiceControlModeTmp);
401 auto itCallAssistant = VOICE_CALL_ASSISTANT_SUPPRESSION.find(asrVoiceControlModeTmp);
402 auto res = RES_MAP_VERSE.find(on);
403 if (itVerse == VC_MODE_MAP_VERSE.end() && itCallAssistant == VOICE_CALL_ASSISTANT_SUPPRESSION.end()) {
404 AUDIO_ERR_LOG("get value failed.");
405 return ERR_INVALID_PARAM;
406 }
407
408 AudioParamKey paramKey = AudioParamKey::NONE;
409 HdiAdapterManager &manager = HdiAdapterManager::GetInstance();
410 std::shared_ptr<IDeviceManager> deviceManager = manager.GetDeviceManager(HDI_DEVICE_MANAGER_TYPE_LOCAL);
411 CHECK_AND_RETURN_RET_LOG(deviceManager != nullptr, ERROR, "local device manager is nullptr");
412 if (itVerse != VC_MODE_MAP_VERSE.end()) {
413 value = itVerse->second + "=" + res->second;
414 AudioServer::audioParameters[key] = value;
415 deviceManager->SetAudioParameter("primary", paramKey, "", value);
416 return 0;
417 }
418 DeviceType deviceType = PolicyHandler::GetInstance().GetActiveOutPutDevice();
419 Volume vol = {false, 0.0f, 0};
420 PolicyHandler::GetInstance().GetSharedVolume(STREAM_VOICE_CALL, deviceType, vol);
421 float systemVol = vol.isMute ? 0.0f : vol.volumeFloat;
422 AUDIO_INFO_LOG("STREAM_VOICE_CALL = [%{public}f]", systemVol);
423 int32_t modifyVolume = std::floor(systemVol * VOICE_CALL_MAX_VOLUME);
424 modifyVolume = modifyVolume < VOICE_CALL_MIN_VOLUME ? VOICE_CALL_MIN_VOLUME : modifyVolume;
425 if ((itCallAssistant != VOICE_CALL_ASSISTANT_SUPPRESSION.end()) && (res != RES_MAP_VERSE.end())) {
426 return SetAsrVoiceSuppressionControlMode(paramKey, asrVoiceControlModeTmp, on, modifyVolume);
427 }
428
429 return 0;
430 }
431
SetAsrVoiceMuteMode(int32_t asrVoiceMuteMode,bool on)432 int32_t AudioServer::SetAsrVoiceMuteMode(int32_t asrVoiceMuteMode, bool on)
433 {
434 CHECK_AND_RETURN_RET_LOG(PermissionUtil::VerifySystemPermission(), ERR_SYSTEM_PERMISSION_DENIED,
435 "Check playback permission failed, no system permission");
436 std::lock_guard<std::mutex> lockSet(audioParameterMutex_);
437 std::string key = "avmm";
438 std::string value = key + "=";
439
440 auto it = VM_MODE_MAP_VERSE.find(static_cast<AsrVoiceMuteMode>(asrVoiceMuteMode));
441 auto res = RES_MAP_VERSE.find(on);
442 if ((it != VM_MODE_MAP_VERSE.end()) && (res != RES_MAP_VERSE.end())) {
443 value = it->second + "=" + res->second;
444 } else {
445 AUDIO_ERR_LOG("get value failed.");
446 return ERR_INVALID_PARAM;
447 }
448 AudioServer::audioParameters[key] = value;
449 AudioParamKey parmKey = AudioParamKey::NONE;
450 HdiAdapterManager &manager = HdiAdapterManager::GetInstance();
451 std::shared_ptr<IDeviceManager> deviceManager = manager.GetDeviceManager(HDI_DEVICE_MANAGER_TYPE_LOCAL);
452 CHECK_AND_RETURN_RET_LOG(deviceManager != nullptr, ERROR, "local device manager is nullptr");
453 deviceManager->SetAudioParameter("primary", parmKey, "", value);
454 return 0;
455 }
456
IsWhispering(int32_t & whisperRes)457 int32_t AudioServer::IsWhispering(int32_t& whisperRes)
458 {
459 whisperRes = 0;
460 CHECK_AND_RETURN_RET_LOG(PermissionUtil::VerifySystemPermission(), ERR_SYSTEM_PERMISSION_DENIED,
461 "Check playback permission failed, no system permission");
462 std::lock_guard<std::mutex> lockSet(audioParameterMutex_);
463 std::string key = "asr_is_whisper";
464 AudioParamKey parmKey = AudioParamKey::NONE;
465 HdiAdapterManager &manager = HdiAdapterManager::GetInstance();
466 std::shared_ptr<IDeviceManager> deviceManager = manager.GetDeviceManager(HDI_DEVICE_MANAGER_TYPE_LOCAL);
467 CHECK_AND_RETURN_RET_LOG(deviceManager != nullptr, ERROR, "local device manager is nullptr");
468 std::string isWhisperSink = deviceManager->GetAudioParameter("primary", parmKey, key);
469 if (isWhisperSink == "TRUE") {
470 whisperRes = 1;
471 }
472 return SUCCESS;
473 }
474 // LCOV_EXCL_STOP
475 } // namespace AudioStandard
476 } // namespace OHOS