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 "AudioPolicyUtils"
17 #endif
18
19 #include "audio_policy_utils.h"
20 #include <ability_manager_client.h>
21 #include "iservice_registry.h"
22 #include "parameter.h"
23 #include "parameters.h"
24 #include "audio_policy_log.h"
25 #include "audio_manager_listener_stub.h"
26 #include "audio_inner_call.h"
27 #include "media_monitor_manager.h"
28 #include "data_share_observer_callback.h"
29 #include "audio_policy_manager_factory.h"
30 #include "device_init_callback.h"
31 #include "audio_recovery_device.h"
32 #include "audio_config_manager.h"
33
34 #include "audio_server_proxy.h"
35
36 namespace OHOS {
37 namespace AudioStandard {
38
39 static constexpr int32_t NS_PER_MS = 1000000;
40 static constexpr int32_t MS_PER_S = 1000;
41 static const char* SETTINGS_DATA_FIELD_VALUE = "VALUE";
42 static const char* SETTINGS_DATA_FIELD_KEYWORD = "KEYWORD";
43 static const char* PREDICATES_STRING = "settings.general.device_name";
44 static const char* SETTINGS_DATA_BASE_URI =
45 "datashare:///com.ohos.settingsdata/entry/settingsdata/SETTINGSDATA?Proxy=true";
46 static const char* SETTINGS_DATA_EXT_URI = "datashare:///com.ohos.settingsdata.DataAbility";
47 static const char* AUDIO_SERVICE_PKG = "audio_manager_service";
48
49 std::map<std::string, ClassType> AudioPolicyUtils::portStrToEnum = {
50 {PRIMARY_SPEAKER, TYPE_PRIMARY},
51 {PRIMARY_MIC, TYPE_PRIMARY},
52 {PRIMARY_WAKEUP_MIC, TYPE_PRIMARY},
53 {BLUETOOTH_SPEAKER, TYPE_A2DP},
54 {BLUETOOTH_MIC, TYPE_A2DP},
55 {USB_SPEAKER, TYPE_USB},
56 {USB_MIC, TYPE_USB},
57 {DP_SINK, TYPE_DP},
58 {FILE_SINK, TYPE_FILE_IO},
59 {FILE_SOURCE, TYPE_FILE_IO},
60 {REMOTE_CLASS, TYPE_REMOTE_AUDIO},
61 };
62
GetEncryptAddr(const std::string & addr)63 static std::string GetEncryptAddr(const std::string &addr)
64 {
65 const int32_t START_POS = 6;
66 const int32_t END_POS = 13;
67 const int32_t ADDRESS_STR_LEN = 17;
68 if (addr.empty() || addr.length() != ADDRESS_STR_LEN) {
69 return std::string("");
70 }
71 std::string tmp = "**:**:**:**:**:**";
72 std::string out = addr;
73 for (int i = START_POS; i <= END_POS; i++) {
74 out[i] = tmp[i];
75 }
76 return out;
77 }
78
79 int32_t AudioPolicyUtils::startDeviceId = 1;
80
WriteServiceStartupError(std::string reason)81 void AudioPolicyUtils::WriteServiceStartupError(std::string reason)
82 {
83 std::shared_ptr<Media::MediaMonitor::EventBean> bean = std::make_shared<Media::MediaMonitor::EventBean>(
84 Media::MediaMonitor::ModuleId::AUDIO, Media::MediaMonitor::EventId::AUDIO_SERVICE_STARTUP_ERROR,
85 Media::MediaMonitor::EventType::FAULT_EVENT);
86 bean->Add("SERVICE_ID", static_cast<int32_t>(Media::MediaMonitor::AUDIO_POLICY_SERVICE_ID));
87 bean->Add("ERROR_CODE", static_cast<int32_t>(Media::MediaMonitor::AUDIO_POLICY_SERVER));
88 Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteLogMsg(bean);
89 }
90
GetRemoteModuleName(std::string networkId,DeviceRole role)91 std::string AudioPolicyUtils::GetRemoteModuleName(std::string networkId, DeviceRole role)
92 {
93 return networkId + (role == DeviceRole::OUTPUT_DEVICE ? "_out" : "_in");
94 }
95
GetAvailableDevicesInner(AudioDeviceUsage usage)96 std::vector<std::shared_ptr<AudioDeviceDescriptor>> AudioPolicyUtils::GetAvailableDevicesInner(AudioDeviceUsage usage)
97 {
98 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptors;
99
100 audioDeviceDescriptors = audioDeviceManager_.GetAvailableDevicesByUsage(usage);
101 return audioDeviceDescriptors;
102 }
103
SetPreferredDevice(const PreferredType preferredType,const std::shared_ptr<AudioDeviceDescriptor> & desc,const int32_t uid,const std::string caller)104 int32_t AudioPolicyUtils::SetPreferredDevice(const PreferredType preferredType,
105 const std::shared_ptr<AudioDeviceDescriptor> &desc, const int32_t uid, const std::string caller)
106 {
107 if (desc == nullptr) {
108 AUDIO_ERR_LOG("desc is null");
109 return ERR_INVALID_PARAM;
110 }
111 int32_t ret = SUCCESS;
112 switch (preferredType) {
113 case AUDIO_MEDIA_RENDER:
114 audioStateManager_.SetPreferredMediaRenderDevice(desc);
115 break;
116 case AUDIO_CALL_RENDER:
117 audioStateManager_.SetPreferredCallRenderDevice(desc, uid, caller);
118 break;
119 case AUDIO_CALL_CAPTURE:
120 audioStateManager_.SetPreferredCallCaptureDevice(desc);
121 break;
122 case AUDIO_RECORD_CAPTURE:
123 audioStateManager_.SetPreferredRecordCaptureDevice(desc);
124 break;
125 case AUDIO_RING_RENDER:
126 case AUDIO_TONE_RENDER:
127 AUDIO_WARNING_LOG("preferredType:%{public}d, not supported", preferredType);
128 ret = ERR_INVALID_PARAM;
129 break;
130 default:
131 AUDIO_ERR_LOG("invalid preferredType: %{public}d", preferredType);
132 ret = ERR_INVALID_PARAM;
133 break;
134 }
135 if (desc->deviceType_ == DEVICE_TYPE_NONE) {
136 ErasePreferredDeviceByType(preferredType);
137 }
138 if (ret != SUCCESS) {
139 AUDIO_ERR_LOG("Set preferredType %{public}d failed, ret: %{public}d", preferredType, ret);
140 }
141 return ret;
142 }
143
ErasePreferredDeviceByType(const PreferredType preferredType)144 int32_t AudioPolicyUtils::ErasePreferredDeviceByType(const PreferredType preferredType)
145 {
146 if (isBTReconnecting_) {
147 return SUCCESS;
148 }
149 auto type = static_cast<Media::MediaMonitor::PreferredType>(preferredType);
150 int32_t ret = Media::MediaMonitor::MediaMonitorManager::GetInstance().ErasePreferredDeviceByType(type);
151 if (ret != SUCCESS) {
152 AUDIO_ERR_LOG("Erase preferredType %{public}d failed, ret: %{public}d", preferredType, ret);
153 return ERROR;
154 }
155 return SUCCESS;
156 }
157
SetBtConnecting(bool flag)158 void AudioPolicyUtils::SetBtConnecting(bool flag)
159 {
160 isBTReconnecting_ = flag;
161 }
162
ClearScoDeviceSuspendState(std::string macAddress)163 void AudioPolicyUtils::ClearScoDeviceSuspendState(std::string macAddress)
164 {
165 AUDIO_DEBUG_LOG("Clear sco suspend state %{public}s", GetEncryptAddr(macAddress).c_str());
166 std::vector<std::shared_ptr<AudioDeviceDescriptor>> descs = audioDeviceManager_.GetDevicesByFilter(
167 DEVICE_TYPE_BLUETOOTH_SCO, DEVICE_ROLE_NONE, macAddress, "", SUSPEND_CONNECTED);
168 for (const auto &desc : descs) {
169 desc->connectState_ = DEACTIVE_CONNECTED;
170 }
171 }
172
GetCurrentTimeMS()173 int64_t AudioPolicyUtils::GetCurrentTimeMS()
174 {
175 timespec tm {};
176 clock_gettime(CLOCK_MONOTONIC, &tm);
177 return tm.tv_sec * MS_PER_S + (tm.tv_nsec / NS_PER_MS);
178 }
179
PcmFormatToBytes(AudioSampleFormat format)180 uint32_t AudioPolicyUtils::PcmFormatToBytes(AudioSampleFormat format)
181 {
182 // AudioSampleFormat / PCM_8_BIT
183 switch (format) {
184 case SAMPLE_U8:
185 return 1; // 1 byte
186 case SAMPLE_S16LE:
187 return 2; // 2 byte
188 case SAMPLE_S24LE:
189 return 3; // 3 byte
190 case SAMPLE_S32LE:
191 return 4; // 4 byte
192 case SAMPLE_F32LE:
193 return 4; // 4 byte
194 default:
195 return 2; // 2 byte
196 }
197 }
198
GetNewSinkPortName(DeviceType deviceType)199 std::string AudioPolicyUtils::GetNewSinkPortName(DeviceType deviceType)
200 {
201 std::string portName = PORT_NONE;
202 switch (deviceType) {
203 case DeviceType::DEVICE_TYPE_USB_ARM_HEADSET:
204 portName = USB_SPEAKER;
205 break;
206 case DeviceType::DEVICE_TYPE_DP:
207 portName = DP_SINK;
208 break;
209 case DeviceType::DEVICE_TYPE_FILE_SINK:
210 portName = FILE_SINK;
211 break;
212 case DeviceType::DEVICE_TYPE_REMOTE_CAST:
213 portName = REMOTE_CAST_INNER_CAPTURER_SINK_NAME;
214 break;
215 default:
216 portName = PORT_NONE;
217 break;
218 }
219 return portName;
220 }
221
GetSinkPortName(DeviceType deviceType,AudioPipeType pipeType)222 std::string AudioPolicyUtils::GetSinkPortName(DeviceType deviceType, AudioPipeType pipeType)
223 {
224 std::string portName = PORT_NONE;
225 switch (deviceType) {
226 case DeviceType::DEVICE_TYPE_BLUETOOTH_A2DP:
227 // BTH tells us that a2dpoffload is OK
228 if (audioA2dpOffloadFlag_.GetA2dpOffloadFlag() == A2DP_OFFLOAD) {
229 if (pipeType == PIPE_TYPE_OFFLOAD) {
230 portName = OFFLOAD_PRIMARY_SPEAKER;
231 } else if (pipeType == PIPE_TYPE_MULTICHANNEL) {
232 portName = MCH_PRIMARY_SPEAKER;
233 } else {
234 portName = PRIMARY_SPEAKER;
235 }
236 } else {
237 portName = BLUETOOTH_SPEAKER;
238 }
239 break;
240 case DeviceType::DEVICE_TYPE_EARPIECE:
241 case DeviceType::DEVICE_TYPE_SPEAKER:
242 case DeviceType::DEVICE_TYPE_WIRED_HEADSET:
243 case DeviceType::DEVICE_TYPE_WIRED_HEADPHONES:
244 case DeviceType::DEVICE_TYPE_USB_HEADSET:
245 case DeviceType::DEVICE_TYPE_BLUETOOTH_SCO:
246 if (pipeType == PIPE_TYPE_OFFLOAD) {
247 portName = OFFLOAD_PRIMARY_SPEAKER;
248 } else if (pipeType == PIPE_TYPE_MULTICHANNEL) {
249 portName = MCH_PRIMARY_SPEAKER;
250 } else if (pipeType == PIPE_TYPE_CALL_OUT) {
251 bool normalVoipFlag = audioConfigManager_.GetNormalVoipFlag();
252 portName = (normalVoipFlag ? PRIMARY_SPEAKER : PRIMARY_DIRECT_VOIP);
253 } else {
254 portName = PRIMARY_SPEAKER;
255 }
256 break;
257 case DeviceType::DEVICE_TYPE_HDMI:
258 case DeviceType::DEVICE_TYPE_LINE_DIGITAL:
259 portName = AudioConfigManager::GetInstance().GetDefaultAdapterEnable() ? DP_SINK : PRIMARY_SPEAKER;
260 break;
261 default:
262 portName = GetNewSinkPortName(deviceType);
263 break;
264 }
265
266 return portName;
267 }
268
ConvertToHDIAudioFormat(AudioSampleFormat sampleFormat)269 string AudioPolicyUtils::ConvertToHDIAudioFormat(AudioSampleFormat sampleFormat)
270 {
271 switch (sampleFormat) {
272 case SAMPLE_U8:
273 return "u8";
274 case SAMPLE_S16LE:
275 return "s16le";
276 case SAMPLE_S24LE:
277 return "s24le";
278 case SAMPLE_S32LE:
279 return "s32le";
280 default:
281 return "";
282 }
283 }
284
GetSinkName(const AudioDeviceDescriptor & desc,int32_t sessionId)285 std::string AudioPolicyUtils::GetSinkName(const AudioDeviceDescriptor &desc, int32_t sessionId)
286 {
287 if (desc.networkId_ == LOCAL_NETWORK_ID) {
288 AudioPipeType pipeType = PIPE_TYPE_UNKNOWN;
289 streamCollector_.GetPipeType(sessionId, pipeType);
290 return GetSinkPortName(desc.deviceType_, pipeType);
291 } else {
292 return GetRemoteModuleName(desc.networkId_, desc.deviceRole_);
293 }
294 }
295
GetSourcePortName(DeviceType deviceType)296 std::string AudioPolicyUtils::GetSourcePortName(DeviceType deviceType)
297 {
298 std::string portName = PORT_NONE;
299 switch (deviceType) {
300 case InternalDeviceType::DEVICE_TYPE_MIC:
301 portName = PRIMARY_MIC;
302 break;
303 case InternalDeviceType::DEVICE_TYPE_USB_ARM_HEADSET:
304 portName = USB_MIC;
305 break;
306 case InternalDeviceType::DEVICE_TYPE_WAKEUP:
307 portName = PRIMARY_WAKEUP;
308 break;
309 case InternalDeviceType::DEVICE_TYPE_FILE_SOURCE:
310 portName = FILE_SOURCE;
311 break;
312 case InternalDeviceType::DEVICE_TYPE_BLUETOOTH_A2DP_IN:
313 portName = BLUETOOTH_MIC;
314 break;
315 default:
316 portName = PORT_NONE;
317 break;
318 }
319
320 return portName;
321 }
322
GetOutputDeviceClassBySinkPortName(std::string sinkPortName)323 std::string AudioPolicyUtils::GetOutputDeviceClassBySinkPortName(std::string sinkPortName)
324 {
325 std::map<std::string, std::string> sinkPortStrToClassStrMap_ = {
326 {PRIMARY_SPEAKER, PRIMARY_CLASS},
327 {OFFLOAD_PRIMARY_SPEAKER, OFFLOAD_CLASS},
328 {BLUETOOTH_SPEAKER, A2DP_CLASS},
329 {USB_SPEAKER, USB_CLASS},
330 {PRIMARY_DIRECT_VOIP, DIRECT_VOIP_CLASS},
331 {DP_SINK, DP_CLASS},
332 {FILE_SINK, FILE_CLASS},
333 {REMOTE_CAST_INNER_CAPTURER_SINK_NAME, REMOTE_CLASS},
334 {MCH_PRIMARY_SPEAKER, MCH_CLASS},
335 {PORT_NONE, INVALID_CLASS}
336 };
337 std::string deviceClass = INVALID_CLASS;
338 if (sinkPortStrToClassStrMap_.count(sinkPortName) > 0) {
339 deviceClass = sinkPortStrToClassStrMap_.at(sinkPortName);
340 }
341 return deviceClass;
342 }
343
GetInputDeviceClassBySourcePortName(std::string sourcePortName)344 std::string AudioPolicyUtils::GetInputDeviceClassBySourcePortName(std::string sourcePortName)
345 {
346 std::map<std::string, std::string> sourcePortStrToClassStrMap_ = {
347 {PRIMARY_MIC, PRIMARY_CLASS},
348 {USB_MIC, USB_CLASS},
349 {PRIMARY_WAKEUP, PRIMARY_CLASS},
350 {FILE_SOURCE, FILE_CLASS},
351 {BLUETOOTH_MIC, A2DP_CLASS},
352 {PORT_NONE, INVALID_CLASS}
353 };
354 std::string deviceClass = INVALID_CLASS;
355 if (sourcePortStrToClassStrMap_.count(sourcePortName) > 0) {
356 deviceClass = sourcePortStrToClassStrMap_.at(sourcePortName);
357 }
358 return deviceClass;
359 }
360
CreateDataShareHelperInstance()361 std::shared_ptr<DataShare::DataShareHelper> AudioPolicyUtils::CreateDataShareHelperInstance()
362 {
363 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
364 CHECK_AND_RETURN_RET_LOG(samgr != nullptr, nullptr, "[Policy Service] Get samgr failed.");
365
366 sptr<IRemoteObject> remoteObject = samgr->GetSystemAbility(AUDIO_POLICY_SERVICE_ID);
367 CHECK_AND_RETURN_RET_LOG(remoteObject != nullptr, nullptr, "[Policy Service] audio service remote object is NULL.");
368
369 int64_t startTime = ClockTime::GetCurNano();
370 sptr<IRemoteObject> dataSharedServer = samgr->CheckSystemAbility(DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID);
371 int64_t cost = ClockTime::GetCurNano() - startTime;
372 if (cost > CALL_IPC_COST_TIME_MS) {
373 AUDIO_WARNING_LOG("Call get DataShare server cost too long: %{public}" PRId64"ms.", cost / AUDIO_US_PER_SECOND);
374 }
375
376 CHECK_AND_RETURN_RET_LOG(dataSharedServer != nullptr, nullptr, "DataShare server is not started!");
377
378 WatchTimeout guard("DataShare::DataShareHelper::Create", CALL_IPC_COST_TIME_MS);
379 std::pair<int, std::shared_ptr<DataShare::DataShareHelper>> res = DataShare::DataShareHelper::Create(remoteObject,
380 SETTINGS_DATA_BASE_URI, SETTINGS_DATA_EXT_URI);
381 guard.CheckCurrTimeout();
382 if (res.first == DataShare::E_DATA_SHARE_NOT_READY) {
383 AUDIO_WARNING_LOG("DataShareHelper::Create failed: E_DATA_SHARE_NOT_READY");
384 return nullptr;
385 }
386 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = res.second;
387 CHECK_AND_RETURN_RET_LOG(res.first == DataShare::E_OK && dataShareHelper != nullptr, nullptr, "fail:%{public}d",
388 res.first);
389 return dataShareHelper;
390 }
391
GetDeviceNameFromDataShareHelper(std::string & deviceName)392 int32_t AudioPolicyUtils::GetDeviceNameFromDataShareHelper(std::string &deviceName)
393 {
394 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelperInstance();
395 CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, ERROR, "GetDeviceNameFromDataShareHelper NULL");
396
397 std::shared_ptr<Uri> uri = std::make_shared<Uri>(SETTINGS_DATA_BASE_URI);
398 std::vector<std::string> columns;
399 columns.emplace_back(SETTINGS_DATA_FIELD_VALUE);
400 DataShare::DataSharePredicates predicates;
401 predicates.EqualTo(SETTINGS_DATA_FIELD_KEYWORD, PREDICATES_STRING);
402
403 WatchTimeout guard("dataShareHelper->Query:DefaultDeviceName");
404 auto resultSet = dataShareHelper->Query(*uri, predicates, columns);
405 if (resultSet == nullptr) {
406 AUDIO_ERR_LOG("Failed to query device name from dataShareHelper!");
407 dataShareHelper->Release();
408 return ERROR;
409 }
410 guard.CheckCurrTimeout();
411
412 int32_t numRows = 0;
413 resultSet->GetRowCount(numRows);
414 if (numRows <= 0) {
415 AUDIO_ERR_LOG("The result of querying is zero row!");
416 resultSet->Close();
417 dataShareHelper->Release();
418 return ERROR;
419 }
420
421 int columnIndex;
422 resultSet->GoToFirstRow();
423 resultSet->GetColumnIndex(SETTINGS_DATA_FIELD_VALUE, columnIndex);
424 resultSet->GetString(columnIndex, deviceName);
425 AUDIO_INFO_LOG("GetDeviceNameFromDataShareHelper deviceName[%{public}s]", deviceName.c_str());
426
427 resultSet->Close();
428 dataShareHelper->Release();
429 return SUCCESS;
430 }
431
432
UpdateDisplayName(std::shared_ptr<AudioDeviceDescriptor> deviceDescriptor)433 void AudioPolicyUtils::UpdateDisplayName(std::shared_ptr<AudioDeviceDescriptor> deviceDescriptor)
434 {
435 if (deviceDescriptor->networkId_ == LOCAL_NETWORK_ID) {
436 std::string devicesName = "";
437 int32_t ret = GetDeviceNameFromDataShareHelper(devicesName);
438 CHECK_AND_RETURN_LOG(ret == SUCCESS, "Local UpdateDisplayName init device failed");
439 deviceDescriptor->displayName_ = devicesName;
440 } else {
441 UpdateDisplayNameForRemote(deviceDescriptor);
442 }
443 }
444
UpdateDisplayNameForRemote(std::shared_ptr<AudioDeviceDescriptor> & desc)445 void AudioPolicyUtils::UpdateDisplayNameForRemote(std::shared_ptr<AudioDeviceDescriptor> &desc)
446 {
447 #ifdef FEATURE_DEVICE_MANAGER
448 std::shared_ptr<DistributedHardware::DmInitCallback> callback = std::make_shared<DeviceInitCallBack>();
449 int32_t ret = DistributedHardware::DeviceManager::GetInstance().InitDeviceManager(AUDIO_SERVICE_PKG, callback);
450 CHECK_AND_RETURN_LOG(ret == SUCCESS, "init device failed");
451 std::vector<DistributedHardware::DmDeviceInfo> deviceList;
452 if (DistributedHardware::DeviceManager::GetInstance()
453 .GetTrustedDeviceList(AUDIO_SERVICE_PKG, "", deviceList) == SUCCESS) {
454 for (auto deviceInfo : deviceList) {
455 std::string strNetworkId(deviceInfo.networkId);
456 if (strNetworkId == desc->networkId_) {
457 AUDIO_INFO_LOG("remote name [%{public}s]", deviceInfo.deviceName);
458 desc->displayName_ = deviceInfo.deviceName;
459 break;
460 }
461 }
462 };
463 #endif
464 }
465
UpdateEffectDefaultSink(DeviceType deviceType)466 void AudioPolicyUtils::UpdateEffectDefaultSink(DeviceType deviceType)
467 {
468 Trace trace("AudioPolicyUtils::UpdateEffectDefaultSink:" + std::to_string(deviceType));
469 effectActiveDevice_ = deviceType;
470 switch (deviceType) {
471 case DeviceType::DEVICE_TYPE_EARPIECE:
472 case DeviceType::DEVICE_TYPE_SPEAKER:
473 case DeviceType::DEVICE_TYPE_FILE_SINK:
474 case DeviceType::DEVICE_TYPE_WIRED_HEADSET:
475 case DeviceType::DEVICE_TYPE_USB_HEADSET:
476 case DeviceType::DEVICE_TYPE_DP:
477 case DeviceType::DEVICE_TYPE_USB_ARM_HEADSET:
478 case DeviceType::DEVICE_TYPE_BLUETOOTH_A2DP:
479 case DeviceType::DEVICE_TYPE_BLUETOOTH_SCO:
480 case DeviceType::DEVICE_TYPE_HDMI: {
481 std::string sinkName = AudioPolicyUtils::GetInstance().GetSinkPortName(deviceType);
482 AudioServerProxy::GetInstance().SetOutputDeviceSinkProxy(deviceType, sinkName);
483 break;
484 }
485 default:
486 break;
487 }
488 }
489
ConstructRemoteAudioModuleInfo(std::string networkId,DeviceRole deviceRole,DeviceType deviceType)490 AudioModuleInfo AudioPolicyUtils::ConstructRemoteAudioModuleInfo(std::string networkId, DeviceRole deviceRole,
491 DeviceType deviceType)
492 {
493 AudioModuleInfo audioModuleInfo = {};
494 if (deviceRole == DeviceRole::OUTPUT_DEVICE) {
495 audioModuleInfo.lib = "libmodule-hdi-sink.z.so";
496 audioModuleInfo.format = "s16le"; // 16bit little endian
497 audioModuleInfo.fixedLatency = "1"; // here we need to set latency fixed for a fixed buffer size.
498 audioModuleInfo.renderInIdleState = "1";
499 } else if (deviceRole == DeviceRole::INPUT_DEVICE) {
500 audioModuleInfo.lib = "libmodule-hdi-source.z.so";
501 audioModuleInfo.format = "s16le"; // we assume it is bigger endian
502 } else {
503 AUDIO_WARNING_LOG("Invalid flag provided %{public}d", static_cast<int32_t>(deviceType));
504 }
505
506 // used as "sink_name" in hdi_sink.c, hope we could use name to find target sink.
507 audioModuleInfo.name = GetRemoteModuleName(networkId, deviceRole);
508 audioModuleInfo.networkId = networkId;
509
510 std::stringstream typeValue;
511 typeValue << static_cast<int32_t>(deviceType);
512 audioModuleInfo.deviceType = typeValue.str();
513
514 audioModuleInfo.adapterName = "remote";
515 audioModuleInfo.className = "remote"; // used in renderer_sink_adapter.c
516 audioModuleInfo.fileName = "remote_dump_file";
517
518 audioModuleInfo.channels = "2";
519 audioModuleInfo.rate = "48000";
520 audioModuleInfo.bufferSize = "3840";
521
522 return audioModuleInfo;
523 }
524
GetDeviceRole(DeviceType deviceType) const525 DeviceRole AudioPolicyUtils::GetDeviceRole(DeviceType deviceType) const
526 {
527 switch (deviceType) {
528 case DeviceType::DEVICE_TYPE_EARPIECE:
529 case DeviceType::DEVICE_TYPE_SPEAKER:
530 case DeviceType::DEVICE_TYPE_BLUETOOTH_SCO:
531 case DeviceType::DEVICE_TYPE_BLUETOOTH_A2DP:
532 case DeviceType::DEVICE_TYPE_WIRED_HEADSET:
533 case DeviceType::DEVICE_TYPE_WIRED_HEADPHONES:
534 case DeviceType::DEVICE_TYPE_USB_HEADSET:
535 case DeviceType::DEVICE_TYPE_DP:
536 case DeviceType::DEVICE_TYPE_USB_ARM_HEADSET:
537 case DeviceType::DEVICE_TYPE_REMOTE_CAST:
538 case DeviceType::DEVICE_TYPE_HDMI:
539 return DeviceRole::OUTPUT_DEVICE;
540 case DeviceType::DEVICE_TYPE_MIC:
541 case DeviceType::DEVICE_TYPE_WAKEUP:
542 return DeviceRole::INPUT_DEVICE;
543 default:
544 return DeviceRole::DEVICE_ROLE_NONE;
545 }
546 }
547
GetDeviceRole(const std::string & role)548 DeviceRole AudioPolicyUtils::GetDeviceRole(const std::string &role)
549 {
550 if (role == ROLE_SINK) {
551 return DeviceRole::OUTPUT_DEVICE;
552 } else if (role == ROLE_SOURCE) {
553 return DeviceRole::INPUT_DEVICE;
554 } else {
555 return DeviceRole::DEVICE_ROLE_NONE;
556 }
557 }
558
GetDeviceRole(AudioPin pin) const559 DeviceRole AudioPolicyUtils::GetDeviceRole(AudioPin pin) const
560 {
561 switch (pin) {
562 case OHOS::AudioStandard::AUDIO_PIN_NONE:
563 return DeviceRole::DEVICE_ROLE_NONE;
564 case OHOS::AudioStandard::AUDIO_PIN_OUT_SPEAKER:
565 case OHOS::AudioStandard::AUDIO_PIN_OUT_HEADSET:
566 case OHOS::AudioStandard::AUDIO_PIN_OUT_LINEOUT:
567 case OHOS::AudioStandard::AUDIO_PIN_OUT_HDMI:
568 case OHOS::AudioStandard::AUDIO_PIN_OUT_USB:
569 case OHOS::AudioStandard::AUDIO_PIN_OUT_USB_EXT:
570 case OHOS::AudioStandard::AUDIO_PIN_OUT_DAUDIO_DEFAULT:
571 return DeviceRole::OUTPUT_DEVICE;
572 case OHOS::AudioStandard::AUDIO_PIN_IN_MIC:
573 case OHOS::AudioStandard::AUDIO_PIN_IN_HS_MIC:
574 case OHOS::AudioStandard::AUDIO_PIN_IN_LINEIN:
575 case OHOS::AudioStandard::AUDIO_PIN_IN_USB_EXT:
576 case OHOS::AudioStandard::AUDIO_PIN_IN_DAUDIO_DEFAULT:
577 return DeviceRole::INPUT_DEVICE;
578 default:
579 return DeviceRole::DEVICE_ROLE_NONE;
580 }
581 }
582
GetDeviceType(const std::string & deviceName)583 DeviceType AudioPolicyUtils::GetDeviceType(const std::string &deviceName)
584 {
585 DeviceType devType = DeviceType::DEVICE_TYPE_NONE;
586 if (deviceName == "Speaker") {
587 devType = DeviceType::DEVICE_TYPE_SPEAKER;
588 } else if (deviceName == "Built_in_mic") {
589 devType = DeviceType::DEVICE_TYPE_MIC;
590 } else if (deviceName == "Built_in_wakeup") {
591 devType = DeviceType::DEVICE_TYPE_WAKEUP;
592 } else if (deviceName == "fifo_output" || deviceName == "fifo_input") {
593 devType = DEVICE_TYPE_BLUETOOTH_SCO;
594 } else if (deviceName == "file_sink") {
595 devType = DEVICE_TYPE_FILE_SINK;
596 } else if (deviceName == "file_source") {
597 devType = DEVICE_TYPE_FILE_SOURCE;
598 }
599 return devType;
600 }
601
GetDevicesStr(const vector<shared_ptr<AudioDeviceDescriptor>> & descs)602 std::string AudioPolicyUtils::GetDevicesStr(const vector<shared_ptr<AudioDeviceDescriptor>> &descs)
603 {
604 std::string devices;
605 devices.append("device type:id:(category:constate) ");
606 for (auto iter : descs) {
607 CHECK_AND_CONTINUE_LOG(iter != nullptr, "iter is nullptr");
608 devices.append(std::to_string(static_cast<uint32_t>(iter->getType())));
609 devices.append(":" + std::to_string(static_cast<uint32_t>(iter->deviceId_)));
610 if (iter->getType() == DEVICE_TYPE_BLUETOOTH_A2DP ||
611 iter->getType() == DEVICE_TYPE_BLUETOOTH_SCO) {
612 devices.append(":" + std::to_string(static_cast<uint32_t>(iter->deviceCategory_)));
613 devices.append(":" + std::to_string(static_cast<uint32_t>(iter->connectState_)));
614 } else if (IsUsb(iter->getType())) {
615 devices.append(":" + GetEncryptAddr(iter->macAddress_));
616 }
617 devices.append(" ");
618 }
619 return devices;
620 }
621
GetAudioDeviceUsageByStreamUsage(StreamUsage streamUsage)622 AudioDeviceUsage AudioPolicyUtils::GetAudioDeviceUsageByStreamUsage(StreamUsage streamUsage)
623 {
624 switch (streamUsage) {
625 case StreamUsage::STREAM_USAGE_VOICE_COMMUNICATION:
626 case StreamUsage::STREAM_USAGE_VOICE_MODEM_COMMUNICATION:
627 case StreamUsage::STREAM_USAGE_VIDEO_COMMUNICATION:
628 return CALL_OUTPUT_DEVICES;
629 default:
630 return MEDIA_OUTPUT_DEVICES;
631 }
632 }
633
GetPreferredTypeByStreamUsage(StreamUsage streamUsage)634 PreferredType AudioPolicyUtils::GetPreferredTypeByStreamUsage(StreamUsage streamUsage)
635 {
636 switch (streamUsage) {
637 case StreamUsage::STREAM_USAGE_VOICE_COMMUNICATION:
638 case StreamUsage::STREAM_USAGE_VOICE_MODEM_COMMUNICATION:
639 case StreamUsage::STREAM_USAGE_VIDEO_COMMUNICATION:
640 return AUDIO_CALL_RENDER;
641 default:
642 return AUDIO_MEDIA_RENDER;
643 }
644 }
645
UnexcludeOutputDevices(std::vector<std::shared_ptr<AudioDeviceDescriptor>> & descs)646 int32_t AudioPolicyUtils::UnexcludeOutputDevices(std::vector<std::shared_ptr<AudioDeviceDescriptor>> &descs)
647 {
648 if (isBTReconnecting_) {
649 return SUCCESS;
650 }
651
652 AudioRecoveryDevice::GetInstance().UnexcludeOutputDevicesInner(MEDIA_OUTPUT_DEVICES, descs);
653 AudioRecoveryDevice::GetInstance().UnexcludeOutputDevicesInner(CALL_OUTPUT_DEVICES, descs);
654
655 return SUCCESS;
656 }
657
SetScoExcluded(bool scoExcluded)658 void AudioPolicyUtils::SetScoExcluded(bool scoExcluded)
659 {
660 isScoExcluded_ = scoExcluded;
661 }
662
GetScoExcluded()663 bool AudioPolicyUtils::GetScoExcluded()
664 {
665 return isScoExcluded_;
666 }
667
668 } // namespace AudioStandard
669 } // namespace OHOS