1 /*
2 * Copyright (c) 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
16 #ifndef LOG_TAG
17 #define LOG_TAG "LocalDeviceManager"
18 #endif
19
20 #include "adapter/local_device_manager.h"
21 #include "audio_hdi_log.h"
22 #include "audio_errors.h"
23 #include "audio_utils.h"
24 #include "ipc_skeleton.h"
25
26 namespace OHOS {
27 namespace AudioStandard {
LoadAdapter(const std::string & adapterName)28 int32_t LocalDeviceManager::LoadAdapter(const std::string &adapterName)
29 {
30 CHECK_AND_RETURN_RET_LOG(adapters_.count(adapterName) == 0 || adapters_[adapterName] == nullptr, SUCCESS,
31 "adapter %{public}s already loaded", adapterName.c_str());
32
33 if (audioManager_ == nullptr) {
34 InitAudioManager();
35 }
36 CHECK_AND_RETURN_RET(audioManager_ != nullptr, ERR_INVALID_HANDLE);
37
38 struct AudioAdapterDescriptor descs[MAX_AUDIO_ADAPTER_NUM];
39 uint32_t size = MAX_AUDIO_ADAPTER_NUM;
40 int32_t ret = audioManager_->GetAllAdapters(audioManager_, (struct AudioAdapterDescriptor *)&descs, &size);
41 CHECK_AND_RETURN_RET_LOG(size <= MAX_AUDIO_ADAPTER_NUM && size != 0 && ret == SUCCESS, ERR_NOT_STARTED,
42 "get adapters fail");
43 int32_t index = SwitchAdapterDesc((struct AudioAdapterDescriptor *)&descs, adapterName, size);
44 CHECK_AND_RETURN_RET(index >= 0, ERR_NOT_STARTED);
45
46 struct IAudioAdapter *adapter = nullptr;
47 ret = audioManager_->LoadAdapter(audioManager_, &(descs[index]), &adapter);
48 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS && adapter != nullptr, ERR_NOT_STARTED, "load adapter fail");
49 ret = adapter->InitAllPorts(adapter);
50 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_NOT_STARTED, "init all ports fail");
51 std::lock_guard<std::mutex> lock(adapterMtx_);
52 adapters_[adapterName] = std::make_shared<LocalAdapterWrapper>();
53 adapters_[adapterName]->adapterDesc_ = descs[index];
54 adapters_[adapterName]->adapter_ = adapter;
55 // LCOV_EXCL_START
56 for (auto it = reSetParams_.begin(); it != reSetParams_.end();) {
57 if (it->adapterName_ == adapterName) {
58 SetAudioParameter(adapterName, it->key_, it->condition_, it->value_);
59 it = reSetParams_.erase(it);
60 continue;
61 }
62 ++it;
63 }
64 // LCOV_EXCL_STOP
65 AUDIO_INFO_LOG("load adapter %{public}s success", adapterName.c_str());
66 return SUCCESS;
67 }
68
UnloadAdapter(const std::string & adapterName,bool force)69 void LocalDeviceManager::UnloadAdapter(const std::string &adapterName, bool force)
70 {
71 CHECK_AND_RETURN_LOG(audioManager_ != nullptr, "audio manager is nullptr");
72
73 std::shared_ptr<LocalAdapterWrapper> wrapper = GetAdapter(adapterName);
74 CHECK_AND_RETURN_LOG(wrapper != nullptr && wrapper->adapter_ != nullptr, "adapter %{public}s is nullptr",
75 adapterName.c_str());
76 CHECK_AND_RETURN_LOG(force || (wrapper->hdiRenderIds_.size() == 0 && wrapper->hdiCaptureIds_.size() == 0),
77 "adapter %{public}s has some ports busy, renderNum: %{public}zu, captureNum: %{public}zu", adapterName.c_str(),
78 wrapper->hdiRenderIds_.size(), wrapper->hdiCaptureIds_.size());
79
80 if (wrapper->routeHandle_ != -1) {
81 wrapper->adapter_->ReleaseAudioRoute(wrapper->adapter_, wrapper->routeHandle_);
82 }
83 audioManager_->UnloadAdapter(audioManager_, wrapper->adapterDesc_.adapterName);
84 std::lock_guard<std::mutex> lock(adapterMtx_);
85 adapters_[adapterName].reset();
86 adapters_.erase(adapterName);
87 AUDIO_INFO_LOG("unload adapter %{public}s success", adapterName.c_str());
88 }
89
AllAdapterSetMicMute(bool isMute)90 void LocalDeviceManager::AllAdapterSetMicMute(bool isMute)
91 {
92 AUDIO_INFO_LOG("isMute: %{public}s", isMute ? "true" : "false");
93
94 std::lock_guard<std::mutex> lock(adapterMtx_);
95 for (auto &item : adapters_) {
96 std::shared_ptr<LocalAdapterWrapper> wrapper = item.second;
97 if (wrapper == nullptr || wrapper->adapter_ == nullptr) {
98 continue;
99 }
100 int32_t ret = wrapper->adapter_->SetMicMute(wrapper->adapter_, isMute);
101 if (ret != SUCCESS) {
102 AUDIO_WARNING_LOG("set mute fail, adapterName: %{public}s", item.first.c_str());
103 } else {
104 AUDIO_INFO_LOG("set mute success, adapterName: %{public}s", item.first.c_str());
105 }
106 }
107 }
108
SetAudioParameter(const std::string & adapterName,const AudioParamKey key,const std::string & condition,const std::string & value)109 void LocalDeviceManager::SetAudioParameter(const std::string &adapterName, const AudioParamKey key,
110 const std::string &condition, const std::string &value)
111 {
112 AUDIO_INFO_LOG("key: %{public}d, condition: %{public}s, value: %{public}s", key, condition.c_str(), value.c_str());
113
114 std::shared_ptr<LocalAdapterWrapper> wrapper = GetAdapter(adapterName);
115 // LCOV_EXCL_START
116 if (wrapper == nullptr || wrapper->adapter_ == nullptr) {
117 AUDIO_ERR_LOG("adapter %{public}s is nullptr", adapterName.c_str());
118 SaveSetParameter(adapterName, key, condition, value);
119 return;
120 }
121 // LCOV_EXCL_STOP
122 AudioExtParamKey hdiKey = AudioExtParamKey(key);
123 int32_t ret = wrapper->adapter_->SetExtraParams(wrapper->adapter_, hdiKey, condition.c_str(), value.c_str());
124 CHECK_AND_RETURN_LOG(ret == SUCCESS, "set param fail, error code: %{public}d", ret);
125 }
126
GetAudioParameter(const std::string & adapterName,const AudioParamKey key,const std::string & condition)127 std::string LocalDeviceManager::GetAudioParameter(const std::string &adapterName, const AudioParamKey key,
128 const std::string &condition)
129 {
130 AUDIO_INFO_LOG("key: %{public}d, condition: %{public}s", key, condition.c_str());
131
132 std::shared_ptr<LocalAdapterWrapper> wrapper = GetAdapter(adapterName);
133 CHECK_AND_RETURN_RET_LOG(wrapper != nullptr && wrapper->adapter_ != nullptr, "", "adapter %{public}s is nullptr",
134 adapterName.c_str());
135 AudioExtParamKey hdiKey = AudioExtParamKey(key);
136 char value[DumpFileUtil::PARAM_VALUE_LENTH];
137 int32_t ret = wrapper->adapter_->GetExtraParams(wrapper->adapter_, hdiKey, condition.c_str(), value,
138 DumpFileUtil::PARAM_VALUE_LENTH);
139 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, "", "get param fail, error code: %{public}d", ret);
140 return value;
141 }
142
SetVoiceVolume(const std::string & adapterName,float volume)143 int32_t LocalDeviceManager::SetVoiceVolume(const std::string &adapterName, float volume)
144 {
145 AUDIO_INFO_LOG("set modem call, volume: %{public}f", volume);
146
147 Trace trace("LocalDeviceManager::SetVoiceVolume");
148 std::shared_ptr<LocalAdapterWrapper> wrapper = GetAdapter(adapterName);
149 CHECK_AND_RETURN_RET_LOG(wrapper != nullptr && wrapper->adapter_ != nullptr, ERR_INVALID_HANDLE,
150 "adapter %{public}s is nullptr", adapterName.c_str());
151 return wrapper->adapter_->SetVoiceVolume(wrapper->adapter_, volume);
152 }
153
SetOutputRoute(const std::string & adapterName,const std::vector<DeviceType> & devices,int32_t streamId)154 int32_t LocalDeviceManager::SetOutputRoute(const std::string &adapterName, const std::vector<DeviceType> &devices,
155 int32_t streamId)
156 {
157 CHECK_AND_RETURN_RET_LOG(!devices.empty() && devices.size() <= AUDIO_CONCURRENT_ACTIVE_DEVICES_LIMIT,
158 ERR_INVALID_PARAM, "invalid audio devices");
159
160 Trace trace("LocalDeviceManager::SetOutputRoute device " + std::to_string(devices[0]));
161 AudioRouteNode source = {
162 .portId = 0,
163 .role = AUDIO_PORT_SOURCE_ROLE,
164 .type = AUDIO_PORT_MIX_TYPE,
165 .ext.mix.moduleId = 0,
166 .ext.mix.streamId = streamId,
167 .ext.device.desc = (char *)"",
168 };
169 AudioRouteNode sinks[devices.size()];
170 for (size_t i = 0; i < devices.size(); ++i) {
171 sinks[i] = {};
172 int32_t ret = SetOutputPortPin(devices[i], sinks[i]);
173 CHECK_AND_RETURN_RET(ret == SUCCESS, ret);
174 AUDIO_INFO_LOG("output[%{public}zu], pin: 0x%{public}X", i, sinks[i].ext.device.type);
175 sinks[i].portId = static_cast<int32_t>(GetPortId(adapterName, PORT_OUT));
176 sinks[i].role = AUDIO_PORT_SINK_ROLE;
177 sinks[i].type = AUDIO_PORT_DEVICE_TYPE;
178 sinks[i].ext.device.moduleId = 0;
179 sinks[i].ext.device.desc = (char *)"";
180 }
181 AudioRoute route = {
182 .sources = &source,
183 .sourcesLen = 1,
184 .sinks = sinks,
185 .sinksLen = devices.size(),
186 };
187
188 int64_t stamp = ClockTime::GetCurNano();
189 std::shared_ptr<LocalAdapterWrapper> wrapper = GetAdapter(adapterName);
190 CHECK_AND_RETURN_RET_LOG(wrapper != nullptr && wrapper->adapter_ != nullptr, ERR_INVALID_HANDLE,
191 "adapter %{public}s is nullptr", adapterName.c_str());
192 int32_t ret = wrapper->adapter_->UpdateAudioRoute(wrapper->adapter_, &route, &(wrapper->routeHandle_));
193 stamp = (ClockTime::GetCurNano() - stamp) / AUDIO_US_PER_SECOND;
194 AUDIO_INFO_LOG("update route, device: %{public}d, cost: [%{public}" PRId64 "]ms", devices[0], stamp);
195
196 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_OPERATION_FAILED, "update route fail");
197 return SUCCESS;
198 }
199
SetInputRoute(const std::string & adapterName,DeviceType device,int32_t streamId,int32_t inputType)200 int32_t LocalDeviceManager::SetInputRoute(const std::string &adapterName, DeviceType device, int32_t streamId,
201 int32_t inputType)
202 {
203 AudioRouteNode source = {};
204 int32_t ret = SetInputPortPin(device, source);
205 CHECK_AND_RETURN_RET(ret == SUCCESS, ret);
206 AUDIO_INFO_LOG("input, pin: 0x%{public}X", source.ext.device.type);
207 source.portId = static_cast<int32_t>(GetPortId(adapterName, PORT_IN));
208 source.role = AUDIO_PORT_SOURCE_ROLE;
209 source.type = AUDIO_PORT_DEVICE_TYPE;
210 source.ext.mix.moduleId = 0;
211 source.ext.device.desc = (char *)"";
212 AudioRouteNode sink = {
213 .portId = 0,
214 .role = AUDIO_PORT_SINK_ROLE,
215 .type = AUDIO_PORT_MIX_TYPE,
216 .ext.mix.moduleId = 0,
217 .ext.mix.streamId = streamId,
218 .ext.mix.source = inputType,
219 .ext.device.desc = (char *)"",
220 };
221 AudioRoute route = {
222 .sources = &source,
223 .sourcesLen = 1,
224 .sinks = &sink,
225 .sinksLen = 1,
226 };
227
228 int64_t stamp = ClockTime::GetCurNano();
229 std::shared_ptr<LocalAdapterWrapper> wrapper = GetAdapter(adapterName);
230 CHECK_AND_RETURN_RET_LOG(wrapper != nullptr && wrapper->adapter_ != nullptr, ERR_INVALID_HANDLE,
231 "adapter %{public}s is nullptr", adapterName.c_str());
232 ret = wrapper->adapter_->UpdateAudioRoute(wrapper->adapter_, &route, &(wrapper->routeHandle_));
233 stamp = (ClockTime::GetCurNano() - stamp) / AUDIO_US_PER_SECOND;
234 AUDIO_INFO_LOG("update route, device: %{public}d, cost: [%{public}" PRId64 "]ms", device, stamp);
235
236 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_OPERATION_FAILED, "update route fail");
237 return SUCCESS;
238 }
239
SetMicMute(const std::string & adapterName,bool isMute)240 void LocalDeviceManager::SetMicMute(const std::string &adapterName, bool isMute)
241 {
242 AUDIO_INFO_LOG("isMute: %{public}s", isMute ? "true" : "false");
243
244 std::shared_ptr<LocalAdapterWrapper> wrapper = GetAdapter(adapterName);
245 CHECK_AND_RETURN_LOG(wrapper != nullptr && wrapper->adapter_ != nullptr, "adapter %{public}s is nullptr",
246 adapterName.c_str());
247 int32_t ret = wrapper->adapter_->SetMicMute(wrapper->adapter_, isMute);
248 if (ret != SUCCESS) {
249 AUDIO_WARNING_LOG("set mute fail");
250 } else {
251 AUDIO_INFO_LOG("set mute success");
252 }
253 }
254
CreateRender(const std::string & adapterName,void * param,void * deviceDesc,uint32_t & hdiRenderId)255 void *LocalDeviceManager::CreateRender(const std::string &adapterName, void *param, void *deviceDesc,
256 uint32_t &hdiRenderId)
257 {
258 CHECK_AND_RETURN_RET_LOG(param != nullptr && deviceDesc != nullptr, nullptr, "param or deviceDesc is nullptr");
259 struct AudioSampleAttributes *localParam = static_cast<struct AudioSampleAttributes *>(param);
260 struct AudioDeviceDescriptor *localDeviceDesc = static_cast<struct AudioDeviceDescriptor *>(deviceDesc);
261
262 std::shared_ptr<LocalAdapterWrapper> wrapper = GetAdapter(adapterName, true);
263 CHECK_AND_RETURN_RET_LOG(wrapper != nullptr && wrapper->adapter_ != nullptr, nullptr,
264 "adapter %{public}s is nullptr", adapterName.c_str());
265 localDeviceDesc->portId = GetPortId(adapterName, PORT_OUT);
266
267 struct IAudioRender *render = nullptr;
268 int32_t ret = wrapper->adapter_->CreateRender(wrapper->adapter_, localDeviceDesc, localParam, &render,
269 &hdiRenderId);
270 if (ret != SUCCESS || render == nullptr) {
271 AUDIO_ERR_LOG("create render fail");
272 UnloadAdapter(adapterName);
273 return nullptr;
274 }
275 AUDIO_INFO_LOG("create render success, hdiRenderId: %{public}u, desc: %{public}s", hdiRenderId,
276 localDeviceDesc->desc);
277
278 std::lock_guard<std::mutex> lock(wrapper->renderMtx_);
279 wrapper->hdiRenderIds_.insert(hdiRenderId);
280 return render;
281 }
282
DestroyRender(const std::string & adapterName,uint32_t hdiRenderId)283 void LocalDeviceManager::DestroyRender(const std::string &adapterName, uint32_t hdiRenderId)
284 {
285 AUDIO_INFO_LOG("destroy render, hdiRenderId: %{public}u", hdiRenderId);
286
287 std::shared_ptr<LocalAdapterWrapper> wrapper = GetAdapter(adapterName);
288 CHECK_AND_RETURN_LOG(wrapper != nullptr && wrapper->adapter_ != nullptr, "adapter %{public}s is nullptr",
289 adapterName.c_str());
290 CHECK_AND_RETURN_LOG(wrapper->hdiRenderIds_.count(hdiRenderId) != 0, "render not exist");
291 wrapper->adapter_->DestroyRender(wrapper->adapter_, hdiRenderId);
292
293 std::lock_guard<std::mutex> lock(wrapper->renderMtx_);
294 wrapper->hdiRenderIds_.erase(hdiRenderId);
295 }
296
CreateCapture(const std::string & adapterName,void * param,void * deviceDesc,uint32_t & hdiCaptureId)297 void *LocalDeviceManager::CreateCapture(const std::string &adapterName, void *param, void *deviceDesc,
298 uint32_t &hdiCaptureId)
299 {
300 CHECK_AND_RETURN_RET_LOG(param != nullptr && deviceDesc != nullptr, nullptr, "param or deviceDesc is nullptr");
301 struct AudioSampleAttributes *localParam = static_cast<struct AudioSampleAttributes *>(param);
302 struct AudioDeviceDescriptor *localDeviceDesc = static_cast<struct AudioDeviceDescriptor *>(deviceDesc);
303
304 std::shared_ptr<LocalAdapterWrapper> wrapper = GetAdapter(adapterName, true);
305 CHECK_AND_RETURN_RET_LOG(wrapper != nullptr && wrapper->adapter_ != nullptr, nullptr,
306 "adapter %{public}s is nullptr", adapterName.c_str());
307 localDeviceDesc->portId = GetPortId(adapterName, PORT_IN);
308
309 struct IAudioCapture *capture = nullptr;
310 int32_t ret = wrapper->adapter_->CreateCapture(wrapper->adapter_, localDeviceDesc, localParam, &capture,
311 &hdiCaptureId);
312 if (ret != SUCCESS || capture == nullptr) {
313 AUDIO_ERR_LOG("create capture fail");
314 UnloadAdapter(adapterName);
315 return nullptr;
316 }
317 AUDIO_INFO_LOG("create capture success, hdiCaptureId: %{public}u, desc: %{public}s", hdiCaptureId,
318 localDeviceDesc->desc);
319
320 std::lock_guard<std::mutex> lock(wrapper->captureMtx_);
321 wrapper->hdiCaptureIds_.insert(hdiCaptureId);
322 return capture;
323 }
324
DestroyCapture(const std::string & adapterName,uint32_t hdiCaptureId)325 void LocalDeviceManager::DestroyCapture(const std::string &adapterName, uint32_t hdiCaptureId)
326 {
327 AUDIO_INFO_LOG("destroy capture, hdiCaptureId: %{public}u", hdiCaptureId);
328
329 std::shared_ptr<LocalAdapterWrapper> wrapper = GetAdapter(adapterName);
330 CHECK_AND_RETURN_LOG(wrapper != nullptr && wrapper->adapter_ != nullptr, "adapter %{public}s is nullptr",
331 adapterName.c_str());
332 CHECK_AND_RETURN_LOG(wrapper->hdiCaptureIds_.count(hdiCaptureId) != 0, "capture not exist");
333 wrapper->adapter_->DestroyCapture(wrapper->adapter_, hdiCaptureId);
334
335 std::lock_guard<std::mutex> lock(wrapper->captureMtx_);
336 wrapper->hdiCaptureIds_.erase(hdiCaptureId);
337 }
338
DumpInfo(std::string & dumpString)339 void LocalDeviceManager::DumpInfo(std::string &dumpString)
340 {
341 for (auto &item : adapters_) {
342 uint32_t renderNum = item.second == nullptr ? 0 : item.second->hdiRenderIds_.size();
343 uint32_t captureNum = item.second == nullptr ? 0 : item.second->hdiCaptureIds_.size();
344 dumpString += " - local/" + item.first + "\trenderNum: " + std::to_string(renderNum) + "\tcaptureNum: " +
345 std::to_string(captureNum) + "\n";
346 }
347 }
348
AudioHostOnRemoteDied(struct HdfDeathRecipient * recipent,struct HdfRemoteService * service)349 static void AudioHostOnRemoteDied(struct HdfDeathRecipient *recipent, struct HdfRemoteService *service)
350 {
351 CHECK_AND_RETURN_LOG(recipent != nullptr && service != nullptr, "receive die message but params are nullptr");
352 AUDIO_ERR_LOG("auto exit for audio host die");
353 _Exit(0);
354 }
355
InitAudioManager(void)356 void LocalDeviceManager::InitAudioManager(void)
357 {
358 CHECK_AND_RETURN_LOG(audioManager_ == nullptr, "audio manager already inited");
359 AUDIO_INFO_LOG("init audio manager");
360 audioManager_ = IAudioManagerGet(false);
361 CHECK_AND_RETURN_LOG(audioManager_ != nullptr, "get audio manager fail");
362
363 CHECK_AND_RETURN_LOG(hdfRemoteService_ == nullptr, "hdf remote service already inited");
364 hdfRemoteService_ = audioManager_->AsObject(audioManager_);
365 // Don't need to free, existing with process
366 hdfDeathRecipient_ = (struct HdfDeathRecipient *)calloc(1, sizeof(*hdfDeathRecipient_));
367 hdfDeathRecipient_->OnRemoteDied = AudioHostOnRemoteDied;
368 HdfRemoteServiceAddDeathRecipient(hdfRemoteService_, hdfDeathRecipient_);
369
370 AUDIO_INFO_LOG("init audio manager succ");
371 }
372
GetAdapter(const std::string & adapterName,bool tryCreate)373 std::shared_ptr<LocalAdapterWrapper> LocalDeviceManager::GetAdapter(const std::string &adapterName, bool tryCreate)
374 {
375 {
376 std::lock_guard<std::mutex> lock(adapterMtx_);
377 if (adapters_.count(adapterName) != 0 && adapters_[adapterName] != nullptr) {
378 return adapters_[adapterName];
379 }
380 }
381 if (!tryCreate) {
382 return nullptr;
383 }
384 LoadAdapter(adapterName);
385 std::lock_guard<std::mutex> lock(adapterMtx_);
386 return adapters_.count(adapterName) == 0 ? nullptr : adapters_[adapterName];
387 }
388
SwitchAdapterDesc(struct AudioAdapterDescriptor * descs,const std::string & adapterName,uint32_t size)389 int32_t LocalDeviceManager::SwitchAdapterDesc(struct AudioAdapterDescriptor *descs, const std::string &adapterName,
390 uint32_t size)
391 {
392 CHECK_AND_RETURN_RET(descs != nullptr, ERROR);
393
394 for (uint32_t index = 0; index < size; ++index) {
395 struct AudioAdapterDescriptor *desc = &descs[index];
396 if (desc == nullptr || desc->adapterName == nullptr) {
397 continue;
398 }
399 AUDIO_DEBUG_LOG("index: %{public}u, adapterName: %{public}s", index, desc->adapterName);
400 if (!strcmp(desc->adapterName, adapterName.c_str())) {
401 AUDIO_INFO_LOG("match adapter %{public}s", desc->adapterName);
402 return index;
403 }
404 }
405 AUDIO_ERR_LOG("switch adapter fail, adapterName: %{public}s", adapterName.c_str());
406 return ERR_INVALID_INDEX;
407 }
408
GetPortId(const std::string & adapterName,enum AudioPortDirection portFlag)409 uint32_t LocalDeviceManager::GetPortId(const std::string &adapterName, enum AudioPortDirection portFlag)
410 {
411 std::shared_ptr<LocalAdapterWrapper> wrapper = GetAdapter(adapterName);
412 CHECK_AND_RETURN_RET_LOG(wrapper != nullptr && wrapper->adapter_ != nullptr, 0,
413 "adapter %{public}s is nullptr", adapterName.c_str());
414 struct AudioAdapterDescriptor &desc = wrapper->adapterDesc_;
415 uint32_t portId = 0;
416 for (uint32_t port = 0; port < desc.portsLen; ++port) {
417 if (desc.ports[port].dir == portFlag) {
418 portId = desc.ports[port].portId;
419 break;
420 }
421 }
422 AUDIO_DEBUG_LOG("portId: %{public}u", portId);
423 return portId;
424 }
425
SetOutputPortPin(DeviceType outputDevice,AudioRouteNode & sink)426 int32_t LocalDeviceManager::SetOutputPortPin(DeviceType outputDevice, AudioRouteNode &sink)
427 {
428 int32_t ret = SUCCESS;
429
430 switch (outputDevice) {
431 case DEVICE_TYPE_EARPIECE:
432 sink.ext.device.type = PIN_OUT_EARPIECE;
433 sink.ext.device.desc = (char *)"pin_out_earpiece";
434 break;
435 case DEVICE_TYPE_SPEAKER:
436 sink.ext.device.type = PIN_OUT_SPEAKER;
437 sink.ext.device.desc = (char *)"pin_out_speaker";
438 break;
439 case DEVICE_TYPE_WIRED_HEADSET:
440 sink.ext.device.type = PIN_OUT_HEADSET;
441 sink.ext.device.desc = (char *)"pin_out_headset";
442 break;
443 case DEVICE_TYPE_USB_ARM_HEADSET:
444 sink.ext.device.type = PIN_OUT_USB_HEADSET;
445 sink.ext.device.desc = (char *)"pin_out_usb_headset";
446 break;
447 case DEVICE_TYPE_USB_HEADSET:
448 sink.ext.device.type = PIN_OUT_USB_EXT;
449 sink.ext.device.desc = (char *)"pin_out_usb_ext";
450 break;
451 case DEVICE_TYPE_BLUETOOTH_SCO:
452 sink.ext.device.type = PIN_OUT_BLUETOOTH_SCO;
453 sink.ext.device.desc = (char *)"pin_out_bluetooth_sco";
454 break;
455 case DEVICE_TYPE_BLUETOOTH_A2DP:
456 sink.ext.device.type = PIN_OUT_BLUETOOTH_A2DP;
457 sink.ext.device.desc = (char *)"pin_out_bluetooth_a2dp";
458 break;
459 case DEVICE_TYPE_NONE:
460 sink.ext.device.type = PIN_NONE;
461 sink.ext.device.desc = (char *)"pin_out_none";
462 break;
463 default:
464 ret = ERR_NOT_SUPPORTED;
465 break;
466 }
467
468 return ret;
469 }
470
SetInputPortPin(DeviceType inputDevice,AudioRouteNode & source)471 int32_t LocalDeviceManager::SetInputPortPin(DeviceType inputDevice, AudioRouteNode &source)
472 {
473 int32_t ret = SUCCESS;
474
475 switch (inputDevice) {
476 case DEVICE_TYPE_MIC:
477 case DEVICE_TYPE_EARPIECE:
478 case DEVICE_TYPE_SPEAKER:
479 case DEVICE_TYPE_BLUETOOTH_A2DP_IN:
480 source.ext.device.type = PIN_IN_MIC;
481 source.ext.device.desc = (char *)"pin_in_mic";
482 break;
483 case DEVICE_TYPE_WIRED_HEADSET:
484 source.ext.device.type = PIN_IN_HS_MIC;
485 source.ext.device.desc = (char *)"pin_in_hs_mic";
486 break;
487 case DEVICE_TYPE_USB_ARM_HEADSET:
488 source.ext.device.type = PIN_IN_USB_HEADSET;
489 source.ext.device.desc = (char *)"pin_in_usb_headset";
490 break;
491 case DEVICE_TYPE_USB_HEADSET:
492 source.ext.device.type = PIN_IN_USB_EXT;
493 source.ext.device.desc = (char *)"pin_in_usb_ext";
494 break;
495 case DEVICE_TYPE_BLUETOOTH_SCO:
496 source.ext.device.type = PIN_IN_BLUETOOTH_SCO_HEADSET;
497 source.ext.device.desc = (char *)"pin_in_bluetooth_sco_headset";
498 break;
499 default:
500 ret = ERR_NOT_SUPPORTED;
501 break;
502 }
503
504 return ret;
505 }
506
SaveSetParameter(const std::string & adapterName,const AudioParamKey key,const std::string & condition,const std::string & value)507 void LocalDeviceManager::SaveSetParameter(const std::string &adapterName, const AudioParamKey key,
508 const std::string &condition, const std::string &value)
509 {
510 // save set param
511 auto callerUid = IPCSkeleton::GetCallingUid();
512 AUDIO_INFO_LOG("save param when adapter is nullptr, callerUid is %{public}u", callerUid);
513 reSetParams_.push_back({ adapterName, key, condition, value });
514 }
515
516 } // namespace AudioStandard
517 } // namespace OHOS
518