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