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