1 /*
2  * Copyright (c) 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 #include "audio_system_manager_adapter_impl.h"
17 #include "audio_device_desc_adapter_impl.h"
18 
19 #include <unordered_map>
20 
21 #include "audio_errors.h"
22 #include "audio_renderer_adapter_impl.h"
23 #include "nweb_log.h"
24 
25 namespace OHOS::NWeb {
26 const std::unordered_map<AudioAdapterStreamType, AudioStreamType> STREAM_TYPE_MAP = {
27     { AudioAdapterStreamType::STREAM_DEFAULT, AudioStreamType::STREAM_DEFAULT },
28     { AudioAdapterStreamType::STREAM_VOICE_CALL, AudioStreamType::STREAM_VOICE_CALL },
29     { AudioAdapterStreamType::STREAM_MUSIC, AudioStreamType::STREAM_MUSIC },
30     { AudioAdapterStreamType::STREAM_RING, AudioStreamType::STREAM_RING },
31     { AudioAdapterStreamType::STREAM_MEDIA, AudioStreamType::STREAM_MEDIA },
32     { AudioAdapterStreamType::STREAM_VOICE_ASSISTANT, AudioStreamType::STREAM_VOICE_ASSISTANT },
33     { AudioAdapterStreamType::STREAM_SYSTEM, AudioStreamType::STREAM_SYSTEM },
34     { AudioAdapterStreamType::STREAM_ALARM, AudioStreamType::STREAM_ALARM },
35     { AudioAdapterStreamType::STREAM_NOTIFICATION, AudioStreamType::STREAM_NOTIFICATION },
36     { AudioAdapterStreamType::STREAM_BLUETOOTH_SCO, AudioStreamType::STREAM_BLUETOOTH_SCO },
37     { AudioAdapterStreamType::STREAM_ENFORCED_AUDIBLE, AudioStreamType::STREAM_ENFORCED_AUDIBLE },
38     { AudioAdapterStreamType::STREAM_DTMF, AudioStreamType::STREAM_DTMF },
39     { AudioAdapterStreamType::STREAM_TTS, AudioStreamType::STREAM_TTS },
40     { AudioAdapterStreamType::STREAM_ACCESSIBILITY, AudioStreamType::STREAM_ACCESSIBILITY },
41     { AudioAdapterStreamType::STREAM_RECORDING, AudioStreamType::STREAM_RECORDING },
42     { AudioAdapterStreamType::STREAM_ALL, AudioStreamType::STREAM_ALL },
43 };
44 
45 const std::string DEVICE_TYPE_NONE = "device/none";
46 const std::string DEVICE_TYPE_INVALID = "device/invalid";
47 const std::string DEVICE_TYPE_EARPIECE = "device/earpiece";
48 const std::string DEVICE_TYPE_SPEAKER = "device/speaker";
49 const std::string DEVICE_TYPE_WIRED_HEADSET = "device/wired_headset";
50 const std::string DEVICE_TYPE_WIRED_HEADPHONES = "device/wired_headphones";
51 const std::string DEVICE_TYPE_BLUETOOTH_SCO = "device/bluetooth_sco";
52 const std::string DEVICE_TYPE_BLUETOOTH_A2DP = "device/bluetooth_a2dp";
53 const std::string DEVICE_TYPE_MIC = "device/mic";
54 const std::string DEVICE_TYPE_USB_HEADSET = "device/usb_headset";
55 const std::string DEVICE_TYPE_FILE_SINK = "device/file_sink";
56 const std::string DEVICE_TYPE_FILE_SOURCE = "device/file_source";
57 const std::string DEVICE_TYPE_MAX = "device/max";
58 
59 const std::string DEVICE_TYPE_NONE_ZH_CN = "无";
60 const std::string DEVICE_TYPE_INVALID_ZH_CN = "未知设备";
61 const std::string DEVICE_TYPE_EARPIECE_ZH_CN = "耳机";
62 const std::string DEVICE_TYPE_SPEAKER_ZH_CN = "扬声器";
63 const std::string DEVICE_TYPE_WIRED_HEADSET_ZH_CN = "有线耳麦";
64 const std::string DEVICE_TYPE_WIRED_HEADPHONES_ZH_CN = "头戴式耳机";
65 const std::string DEVICE_TYPE_BLUETOOTH_SCO_ZH_CN = "未知耳机";
66 const std::string DEVICE_TYPE_BLUETOOTH_A2DP_ZH_CN = "未知耳机";
67 const std::string DEVICE_TYPE_MIC_ZH_CN = "麦克风";
68 const std::string DEVICE_TYPE_USB_HEADSET_ZH_CN = "USB 耳机";
69 const std::string DEVICE_TYPE_FILE_SINK_ZH_CN = "device/file_sink";
70 const std::string DEVICE_TYPE_FILE_SOURCE_ZH_CN = "device/file_source";
71 const std::string DEVICE_TYPE_MAX_ZH_CN = "device/max";
72 
73 const std::unordered_map<DeviceType, std::string> DEVICE_TYPE_NAME_ZH_CN_MAP = {
74     { DeviceType::DEVICE_TYPE_NONE, DEVICE_TYPE_NONE_ZH_CN},
75     { DeviceType::DEVICE_TYPE_INVALID, DEVICE_TYPE_INVALID_ZH_CN},
76     { DeviceType::DEVICE_TYPE_EARPIECE, DEVICE_TYPE_EARPIECE_ZH_CN},
77     { DeviceType::DEVICE_TYPE_SPEAKER, DEVICE_TYPE_SPEAKER_ZH_CN},
78     { DeviceType::DEVICE_TYPE_WIRED_HEADSET, DEVICE_TYPE_WIRED_HEADSET_ZH_CN},
79     { DeviceType::DEVICE_TYPE_WIRED_HEADPHONES, DEVICE_TYPE_WIRED_HEADPHONES_ZH_CN},
80     { DeviceType::DEVICE_TYPE_BLUETOOTH_SCO, DEVICE_TYPE_BLUETOOTH_SCO_ZH_CN},
81     { DeviceType::DEVICE_TYPE_BLUETOOTH_A2DP, DEVICE_TYPE_BLUETOOTH_A2DP_ZH_CN},
82     { DeviceType::DEVICE_TYPE_MIC, DEVICE_TYPE_MIC_ZH_CN},
83     { DeviceType::DEVICE_TYPE_USB_HEADSET, DEVICE_TYPE_USB_HEADSET_ZH_CN},
84     { DeviceType::DEVICE_TYPE_FILE_SINK, DEVICE_TYPE_FILE_SINK_ZH_CN},
85     { DeviceType::DEVICE_TYPE_FILE_SOURCE, DEVICE_TYPE_FILE_SOURCE_ZH_CN},
86     { DeviceType::DEVICE_TYPE_MAX, DEVICE_TYPE_MAX_ZH_CN},
87 };
88 
89 const std::unordered_map<DeviceType, std::string> DEVICE_TYPE_MAP = {
90     { DeviceType::DEVICE_TYPE_NONE, DEVICE_TYPE_NONE },
91     { DeviceType::DEVICE_TYPE_INVALID, DEVICE_TYPE_INVALID },
92     { DeviceType::DEVICE_TYPE_EARPIECE, DEVICE_TYPE_EARPIECE },
93     { DeviceType::DEVICE_TYPE_SPEAKER, DEVICE_TYPE_SPEAKER },
94     { DeviceType::DEVICE_TYPE_WIRED_HEADSET, DEVICE_TYPE_WIRED_HEADSET },
95     { DeviceType::DEVICE_TYPE_WIRED_HEADPHONES, DEVICE_TYPE_WIRED_HEADPHONES },
96     { DeviceType::DEVICE_TYPE_BLUETOOTH_SCO, DEVICE_TYPE_BLUETOOTH_SCO },
97     { DeviceType::DEVICE_TYPE_BLUETOOTH_A2DP, DEVICE_TYPE_BLUETOOTH_A2DP },
98     { DeviceType::DEVICE_TYPE_MIC, DEVICE_TYPE_MIC },
99     { DeviceType::DEVICE_TYPE_USB_HEADSET, DEVICE_TYPE_USB_HEADSET },
100     { DeviceType::DEVICE_TYPE_FILE_SINK, DEVICE_TYPE_FILE_SINK },
101     { DeviceType::DEVICE_TYPE_FILE_SOURCE, DEVICE_TYPE_FILE_SOURCE },
102     { DeviceType::DEVICE_TYPE_MAX, DEVICE_TYPE_MAX },
103 };
104 
105 const int32_t ADAPTER_AUDIO_DEFAULT_DEVICE_ID = 1000000;
106 const int32_t ADAPTER_AUDIO_UNDEFINED_DEVICE_ID = 1000001;
107 const char* ADAPTER_AUDIO_DEFAULT_DEVICE_NAME = "(default)";
108 const char* ADAPTER_AUDIO_UNDEFINED_DEVICE_NAME = "(undefined)";
109 
AudioManagerCallbackAdapterImpl(std::shared_ptr<AudioManagerCallbackAdapter> cb)110 AudioManagerCallbackAdapterImpl::AudioManagerCallbackAdapterImpl(std::shared_ptr<AudioManagerCallbackAdapter> cb)
111     : cb_(cb) {};
112 
OnInterrupt(const InterruptAction & interruptAction)113 void AudioManagerCallbackAdapterImpl::OnInterrupt(const InterruptAction& interruptAction)
114 {
115     if (!cb_) {
116         return;
117     }
118     switch (interruptAction.interruptHint) {
119         case InterruptHint::INTERRUPT_HINT_PAUSE:
120         case InterruptHint::INTERRUPT_HINT_STOP:
121             cb_->OnSuspend();
122             break;
123         case InterruptHint::INTERRUPT_HINT_RESUME:
124             cb_->OnResume();
125             break;
126         default:
127             WVLOG_E("audio manager interrupt hint not foud, code: %{public}d", interruptAction.interruptHint);
128             break;
129     }
130 }
131 
AudioManagerDeviceChangeCallbackAdapterImpl(std::shared_ptr<AudioManagerDeviceChangeCallbackAdapter> cb)132 AudioManagerDeviceChangeCallbackAdapterImpl::AudioManagerDeviceChangeCallbackAdapterImpl(
133     std::shared_ptr<AudioManagerDeviceChangeCallbackAdapter> cb)
134     : cb_(cb) {};
135 
OnDeviceChange(const DeviceChangeAction & deviceChangeAction)136 void AudioManagerDeviceChangeCallbackAdapterImpl::OnDeviceChange(const DeviceChangeAction& deviceChangeAction)
137 {
138     if (!cb_) {
139         return;
140     }
141     cb_->OnDeviceChange();
142 }
143 
GetInstance()144 AudioSystemManagerAdapterImpl& AudioSystemManagerAdapterImpl::GetInstance()
145 {
146     static AudioSystemManagerAdapterImpl instance;
147     return instance;
148 }
149 
HasAudioOutputDevices()150 bool AudioSystemManagerAdapterImpl::HasAudioOutputDevices()
151 {
152     DeviceType outputDeviceType = AudioSystemManager::GetInstance()->GetActiveOutputDevice();
153     if (outputDeviceType == DeviceType::DEVICE_TYPE_NONE || outputDeviceType == DeviceType::DEVICE_TYPE_INVALID) {
154         return false;
155     }
156     return true;
157 }
158 
HasAudioInputDevices()159 bool AudioSystemManagerAdapterImpl::HasAudioInputDevices()
160 {
161     DeviceType inputDeviceType = AudioSystemManager::GetInstance()->GetActiveInputDevice();
162     if (inputDeviceType == DeviceType::DEVICE_TYPE_NONE || inputDeviceType == DeviceType::DEVICE_TYPE_INVALID) {
163         return false;
164     }
165     return true;
166 }
167 
RequestAudioFocus(const std::shared_ptr<AudioInterruptAdapter> audioInterrupt)168 int32_t AudioSystemManagerAdapterImpl::RequestAudioFocus(const std::shared_ptr<AudioInterruptAdapter> audioInterrupt)
169 {
170     if (!audioInterrupt) {
171         WVLOG_E("audio request audio focus failed, audioInterrupt is null");
172         return AUDIO_ERROR;
173     }
174 
175     AudioInterrupt interruptParams;
176     interruptParams.streamUsage = AudioRendererAdapterImpl::GetAudioStreamUsage(audioInterrupt->GetStreamUsage());
177     interruptParams.contentType = AudioRendererAdapterImpl::GetAudioContentType(audioInterrupt->GetContentType());
178     interruptParams.audioFocusType.streamType = GetStreamType(audioInterrupt->GetStreamType());
179 
180     int32_t ret = AudioSystemManager::GetInstance()->RequestAudioFocus(interruptParams);
181     if (ret != AudioStandard::SUCCESS) {
182         WVLOG_E("audio request audio focus failed, code: %{public}d", ret);
183         return AUDIO_ERROR;
184     }
185     return AUDIO_OK;
186 }
187 
AbandonAudioFocus(const std::shared_ptr<AudioInterruptAdapter> audioInterrupt)188 int32_t AudioSystemManagerAdapterImpl::AbandonAudioFocus(const std::shared_ptr<AudioInterruptAdapter> audioInterrupt)
189 {
190     if (!audioInterrupt) {
191         WVLOG_E("audio abandon audio focus failed, audioInterrupt is null");
192         return AUDIO_ERROR;
193     }
194 
195     AudioInterrupt interruptParams;
196     interruptParams.streamUsage = AudioRendererAdapterImpl::GetAudioStreamUsage(audioInterrupt->GetStreamUsage());
197     interruptParams.contentType = AudioRendererAdapterImpl::GetAudioContentType(audioInterrupt->GetContentType());
198     interruptParams.audioFocusType.streamType = GetStreamType(audioInterrupt->GetStreamType());
199 
200     int32_t ret = AudioSystemManager::GetInstance()->AbandonAudioFocus(interruptParams);
201     if (ret != AudioStandard::SUCCESS) {
202         WVLOG_E("audio abandon audio focus failed, code: %{public}d", ret);
203         return AUDIO_ERROR;
204     }
205     return AUDIO_OK;
206 }
207 
SetAudioManagerInterruptCallback(std::shared_ptr<AudioManagerCallbackAdapter> callback)208 int32_t AudioSystemManagerAdapterImpl::SetAudioManagerInterruptCallback(
209     std::shared_ptr<AudioManagerCallbackAdapter> callback)
210 {
211     if (callback == nullptr) {
212         WVLOG_E("set audio manager interrupt callback is nullptr");
213         return AUDIO_NULL_ERROR;
214     }
215     callback_ = std::make_shared<AudioManagerCallbackAdapterImpl>(callback);
216 
217     int32_t ret = AudioSystemManager::GetInstance()->SetAudioManagerInterruptCallback(callback_);
218     if (ret != AudioStandard::SUCCESS) {
219         WVLOG_E("audio manager set interrupt callback failed, code: %{public}d", ret);
220         return AUDIO_ERROR;
221     }
222     return AUDIO_OK;
223 }
224 
UnsetAudioManagerInterruptCallback()225 int32_t AudioSystemManagerAdapterImpl::UnsetAudioManagerInterruptCallback()
226 {
227     int32_t ret = AudioSystemManager::GetInstance()->UnsetAudioManagerInterruptCallback();
228     if (ret != AudioStandard::SUCCESS) {
229         WVLOG_E("audio manager unset interrupt callback failed, code: %{public}d", ret);
230         return AUDIO_ERROR;
231     }
232     callback_ = nullptr;
233     return AUDIO_OK;
234 }
235 
GetDeviceName(DeviceType deviceType)236 std::string AudioSystemManagerAdapterImpl::GetDeviceName(DeviceType deviceType)
237 {
238     WVLOG_I("GetDeviceName language: %{public}s", language_.c_str());
239     if (language_ == "zh") {
240         auto deviceTypeKey = DEVICE_TYPE_NAME_ZH_CN_MAP.find(deviceType);
241         if (deviceTypeKey != DEVICE_TYPE_NAME_ZH_CN_MAP.end()) {
242             return deviceTypeKey->second;
243         }
244         return DEVICE_TYPE_NONE_ZH_CN;
245     } else {
246         auto deviceTypeKey = DEVICE_TYPE_MAP.find(deviceType);
247         if (deviceTypeKey != DEVICE_TYPE_MAP.end()) {
248             return deviceTypeKey->second;
249         }
250         return DEVICE_TYPE_NONE;
251     }
252 }
253 
GetDevices(AdapterDeviceFlag flag)254 std::vector<std::shared_ptr<AudioDeviceDescAdapter>> AudioSystemManagerAdapterImpl::GetDevices(AdapterDeviceFlag flag)
255 {
256     bool isCallDevice = false;
257     auto audioScene = AudioSystemManager::GetInstance()->GetAudioScene();
258     if (audioScene == AudioStandard::AudioScene::AUDIO_SCENE_PHONE_CALL ||
259         audioScene == AudioStandard::AudioScene::AUDIO_SCENE_PHONE_CHAT) {
260         isCallDevice = true;
261     }
262     std::vector<std::unique_ptr<AudioDeviceDescriptor>> audioDeviceList;
263     if (flag == AdapterDeviceFlag::OUTPUT_DEVICES_FLAG) {
264         audioDeviceList = AudioRoutingManager::GetInstance()->GetAvailableDevices(
265             isCallDevice ? AudioDeviceUsage::CALL_OUTPUT_DEVICES : AudioDeviceUsage::MEDIA_OUTPUT_DEVICES);
266     } else if (flag == AdapterDeviceFlag::INPUT_DEVICES_FLAG) {
267         audioDeviceList = AudioRoutingManager::GetInstance()->GetAvailableDevices(AudioDeviceUsage::CALL_INPUT_DEVICES);
268     } else if (flag == AdapterDeviceFlag::ALL_DEVICES_FLAG) {
269         audioDeviceList = AudioRoutingManager::GetInstance()->GetAvailableDevices(
270             isCallDevice ? AudioDeviceUsage::ALL_CALL_DEVICES : AudioDeviceUsage::ALL_MEDIA_DEVICES);
271     }
272 
273     std::vector<std::shared_ptr<AudioDeviceDescAdapter>> audioDeviceAdapterList;
274     for (auto& audioDevice : audioDeviceList) {
275         std::shared_ptr<AudioDeviceDescAdapterImpl> desc = std::make_shared<AudioDeviceDescAdapterImpl>();
276         if (!desc) {
277             WVLOG_E("AudioSystemManagerAdapterImpl::GetDevices create desc failed");
278             return audioDeviceAdapterList;
279         }
280 
281         desc->SetDeviceId(audioDevice->deviceId_);
282         if (audioDevice->deviceName_.empty()) {
283             desc->SetDeviceName(GetDeviceName(audioDevice->deviceType_));
284         } else {
285             desc->SetDeviceName(audioDevice->deviceName_);
286         }
287         audioDeviceAdapterList.emplace_back(desc);
288     }
289     return audioDeviceAdapterList;
290 }
291 
SelectAudioOutputDevice(bool isCallDevice,const std::vector<sptr<AudioDeviceDescriptor>> & device) const292 int32_t AudioSystemManagerAdapterImpl::SelectAudioOutputDevice(
293     bool isCallDevice, const std::vector<sptr<AudioDeviceDescriptor>>& device) const
294 {
295     if (isCallDevice) {
296         sptr<AudioRendererFilter> filter = new (std::nothrow) AudioRendererFilter;
297         if (!filter) {
298             WVLOG_E("AudioSystemManagerAdapterImpl::SelectAudioOutputDevice new filter failed");
299             return AUDIO_ERROR;
300         }
301         filter->rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_VOICE_COMMUNICATION;
302         filter->rendererInfo.rendererFlags = 0;
303         return AudioSystemManager::GetInstance()->SelectOutputDevice(filter, device);
304     }
305     return AudioSystemManager::GetInstance()->SelectOutputDevice(device);
306 }
307 
SelectAudioDeviceById(int32_t deviceId,bool isInput)308 int32_t AudioSystemManagerAdapterImpl::SelectAudioDeviceById(int32_t deviceId, bool isInput)
309 {
310     WVLOG_I("AudioSystemManagerAdapterImpl::SelectAudioDevice isInput: %{public}s", isInput ? "true" : "false");
311     if (deviceId == ADAPTER_AUDIO_UNDEFINED_DEVICE_ID) {
312         WVLOG_E("Cannot select undefined audio device.");
313         return AUDIO_ERROR;
314     }
315     bool isCallDevice = false;
316     auto audioScene = AudioSystemManager::GetInstance()->GetAudioScene();
317     if (audioScene == AudioStandard::AudioScene::AUDIO_SCENE_PHONE_CALL ||
318         audioScene == AudioStandard::AudioScene::AUDIO_SCENE_PHONE_CHAT) {
319         isCallDevice = true;
320     }
321     if (!isInput && deviceId == ADAPTER_AUDIO_DEFAULT_DEVICE_ID) {
322         WVLOG_I("Select default audio output Device.");
323         AudioRendererInfo rendererInfo;
324         rendererInfo.contentType = ContentType::CONTENT_TYPE_SPEECH;
325         rendererInfo.streamUsage =
326             isCallDevice ? StreamUsage::STREAM_USAGE_VOICE_COMMUNICATION : StreamUsage::STREAM_USAGE_MUSIC;
327         rendererInfo.rendererFlags = 0;
328         std::vector<sptr<AudioDeviceDescriptor>> defaultOutputDevice;
329         AudioRoutingManager::GetInstance()->GetPreferredOutputDeviceForRendererInfo(rendererInfo, defaultOutputDevice);
330         return SelectAudioOutputDevice(isCallDevice, defaultOutputDevice);
331     }
332     if (isInput && deviceId == ADAPTER_AUDIO_DEFAULT_DEVICE_ID) {
333         WVLOG_I("Select default audio input Device.");
334         AudioCapturerInfo capturerInfo;
335         capturerInfo.sourceType = AudioStandard::SourceType::SOURCE_TYPE_VOICE_COMMUNICATION;
336         capturerInfo.capturerFlags = 0;
337         std::vector<sptr<AudioDeviceDescriptor>> defaultInputDevice;
338         AudioRoutingManager::GetInstance()->GetPreferredInputDeviceForCapturerInfo(capturerInfo, defaultInputDevice);
339         return AudioSystemManager::GetInstance()->SelectInputDevice(defaultInputDevice);
340     }
341 
342     std::vector<std::unique_ptr<AudioDeviceDescriptor>> audioDeviceList;
343     if (isCallDevice) {
344         audioDeviceList = AudioRoutingManager::GetInstance()->GetAvailableDevices(
345             isInput ? AudioDeviceUsage::CALL_INPUT_DEVICES : AudioDeviceUsage::CALL_OUTPUT_DEVICES);
346     } else {
347         audioDeviceList = AudioRoutingManager::GetInstance()->GetAvailableDevices(
348             isInput ? AudioDeviceUsage::CALL_INPUT_DEVICES : AudioDeviceUsage::MEDIA_OUTPUT_DEVICES);
349     }
350     for (auto& device : audioDeviceList) {
351         if (device->deviceId_ == deviceId) {
352             std::vector<sptr<AudioDeviceDescriptor>> selectedAudioDevice { device.release() };
353             return isInput ? AudioSystemManager::GetInstance()->SelectInputDevice(selectedAudioDevice)
354                            : SelectAudioOutputDevice(isCallDevice, selectedAudioDevice);
355         }
356     }
357     WVLOG_E("can't find any device by audio device id");
358     return AUDIO_ERROR;
359 }
360 
GetDefaultOutputDevice()361 std::shared_ptr<AudioDeviceDescAdapter> AudioSystemManagerAdapterImpl::GetDefaultOutputDevice()
362 {
363     bool isCallDevice = false;
364     auto audioScene = AudioSystemManager::GetInstance()->GetAudioScene();
365     if (audioScene == AudioStandard::AudioScene::AUDIO_SCENE_PHONE_CALL ||
366         audioScene == AudioStandard::AudioScene::AUDIO_SCENE_PHONE_CHAT) {
367         isCallDevice = true;
368     }
369     AudioRendererInfo rendererInfo;
370     rendererInfo.contentType = ContentType::CONTENT_TYPE_SPEECH;
371     rendererInfo.streamUsage =
372         isCallDevice ? StreamUsage::STREAM_USAGE_VOICE_COMMUNICATION : StreamUsage::STREAM_USAGE_MUSIC;
373     rendererInfo.rendererFlags = 0;
374     std::vector<sptr<AudioDeviceDescriptor>> defaultOutputDevice;
375     AudioRoutingManager::GetInstance()->GetPreferredOutputDeviceForRendererInfo(rendererInfo, defaultOutputDevice);
376 
377     if (defaultOutputDevice.empty() || !defaultOutputDevice[0]) {
378         WVLOG_E("AudioSystemManagerAdapterImpl::GetDefaultOutputDevice failed.");
379         return nullptr;
380     }
381     auto defaultDevice = defaultOutputDevice[0];
382 
383     std::shared_ptr<AudioDeviceDescAdapterImpl> desc = std::make_shared<AudioDeviceDescAdapterImpl>();
384     if (!desc) {
385         WVLOG_E("AudioSystemManagerAdapterImpl::GetDefaultOutputDevice create desc failed");
386         return nullptr;
387     }
388 
389     desc->SetDeviceId(defaultDevice->deviceId_);
390     if (defaultDevice->deviceName_.empty()) {
391         desc->SetDeviceName(GetDeviceName(defaultDevice->deviceType_));
392     } else {
393         desc->SetDeviceName(defaultDevice->deviceName_);
394     }
395     return desc;
396 }
397 
GetDefaultInputDevice()398 std::shared_ptr<AudioDeviceDescAdapter> AudioSystemManagerAdapterImpl::GetDefaultInputDevice()
399 {
400     AudioCapturerInfo capturerInfo;
401     capturerInfo.sourceType = AudioStandard::SourceType::SOURCE_TYPE_VOICE_COMMUNICATION;
402     capturerInfo.capturerFlags = 0;
403     std::vector<sptr<AudioDeviceDescriptor>> defaultInputDevice;
404     AudioRoutingManager::GetInstance()->GetPreferredInputDeviceForCapturerInfo(capturerInfo, defaultInputDevice);
405     if (defaultInputDevice.empty() || !defaultInputDevice[0]) {
406         WVLOG_E("AudioSystemManagerAdapterImpl::GetDefaultInputDevice failed.");
407         return nullptr;
408     }
409     auto defaultDevice = defaultInputDevice[0];
410 
411     std::shared_ptr<AudioDeviceDescAdapterImpl> desc = std::make_shared<AudioDeviceDescAdapterImpl>();
412     if (!desc) {
413         WVLOG_E("AudioSystemManagerAdapterImpl::GetDefaultOutputDevice create desc failed");
414         return nullptr;
415     }
416 
417     desc->SetDeviceId(defaultDevice->deviceId_);
418     if (defaultDevice->deviceName_.empty()) {
419         desc->SetDeviceName(GetDeviceName(defaultDevice->deviceType_));
420     } else {
421         desc->SetDeviceName(defaultDevice->deviceName_);
422     }
423     return desc;
424 }
425 
SetLanguage(const std::string & language)426 bool AudioSystemManagerAdapterImpl::SetLanguage(const std::string& language)
427 {
428     if (language.empty()) {
429         WVLOG_E("SetLanguage language is nullptr");
430         return false;
431     }
432     language_ = language;
433     return true;
434 }
435 
SetDeviceChangeCallback(std::shared_ptr<AudioManagerDeviceChangeCallbackAdapter> callback)436 int32_t AudioSystemManagerAdapterImpl::SetDeviceChangeCallback(
437     std::shared_ptr<AudioManagerDeviceChangeCallbackAdapter> callback)
438 {
439     if (callback == nullptr) {
440         WVLOG_E("audio device change callback is nullptr");
441         return AUDIO_NULL_ERROR;
442     }
443     DeviceFlag deviceFlag = DeviceFlag::OUTPUT_DEVICES_FLAG;
444     deviceChangeCallback_ = std::make_shared<AudioManagerDeviceChangeCallbackAdapterImpl>(callback);
445     if (deviceChangeCallback_ == nullptr) {
446         WVLOG_E("audio device change callback impl is nullptr");
447         return AUDIO_NULL_ERROR;
448     }
449     int32_t ret = AudioSystemManager::GetInstance()->SetDeviceChangeCallback(deviceFlag, deviceChangeCallback_);
450     if (ret != AudioStandard::SUCCESS) {
451         WVLOG_E("audio manager set audio device change callback failed, code: %{public}d", ret);
452         return AUDIO_ERROR;
453     }
454     return AUDIO_OK;
455 }
456 
UnsetDeviceChangeCallback()457 int32_t AudioSystemManagerAdapterImpl::UnsetDeviceChangeCallback()
458 {
459     int32_t ret = AudioSystemManager::GetInstance()->UnsetDeviceChangeCallback();
460     return ret;
461 }
462 
GetStreamType(AudioAdapterStreamType streamType)463 AudioStreamType AudioSystemManagerAdapterImpl::GetStreamType(AudioAdapterStreamType streamType)
464 {
465     auto item = STREAM_TYPE_MAP.find(streamType);
466     if (item == STREAM_TYPE_MAP.end()) {
467         WVLOG_E("audio stream type not found");
468         return AudioStreamType::STREAM_DEFAULT;
469     }
470     return item->second;
471 }
472 } // namespace OHOS::NWeb
473