1 /*
2 * Copyright (c) 2023 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 "AudioDeviceManager"
17 #endif
18
19 #include "audio_device_manager.h"
20
21 #include "audio_utils.h"
22 #include "audio_errors.h"
23 #include "audio_device_parser.h"
24 #include "audio_policy_utils.h"
25 #include "audio_bluetooth_manager.h"
26
27 namespace OHOS {
28 namespace AudioStandard {
29 using namespace std;
30 constexpr int32_t MS_PER_S = 1000;
31 constexpr int32_t NS_PER_MS = 1000000;
32 const int32_t ADDRESS_STR_LEN = 17;
33 const int32_t START_POS = 6;
34 const int32_t END_POS = 13;
35
36 // LCOV_EXCL_START
GetEncryptAddr(const std::string & addr)37 static std::string GetEncryptAddr(const std::string &addr)
38 {
39 if (addr.empty() || addr.length() != ADDRESS_STR_LEN) {
40 string macHead("card=");
41 if (addr.find(macHead, 0) == 0) {
42 auto pos = macHead.length();
43 auto end = addr.find(';', macHead.length());
44 auto num = end == string::npos ? addr.substr(pos) : addr.substr(pos, end - pos);
45 return string("c**") + num + "**";
46 }
47 return "";
48 }
49 std::string tmp = "**:**:**:**:**:**";
50 std::string out = addr;
51 for (int i = START_POS; i <= END_POS; i++) {
52 out[i] = tmp[i];
53 }
54 return out;
55 }
56
AudioDeviceManager()57 AudioDeviceManager::AudioDeviceManager()
58 {
59 }
60
GetCurrentTimeMS()61 static int64_t GetCurrentTimeMS()
62 {
63 timespec tm {};
64 clock_gettime(CLOCK_MONOTONIC, &tm);
65 return tm.tv_sec * MS_PER_S + (tm.tv_nsec / NS_PER_MS);
66 }
67
ParseDeviceXml()68 void AudioDeviceManager::ParseDeviceXml()
69 {
70 AUDIO_INFO_LOG("In");
71 unique_ptr<AudioDeviceParser> audioDeviceParser = make_unique<AudioDeviceParser>(this);
72 if (audioDeviceParser->LoadConfiguration()) {
73 AUDIO_INFO_LOG("Audio device manager load configuration successfully.");
74 }
75 AUDIO_INFO_LOG("Out");
76 }
77
OnXmlParsingCompleted(const unordered_map<AudioDevicePrivacyType,list<DevicePrivacyInfo>> & xmlData)78 void AudioDeviceManager::OnXmlParsingCompleted(
79 const unordered_map<AudioDevicePrivacyType, list<DevicePrivacyInfo>> &xmlData)
80 {
81 CHECK_AND_RETURN_LOG(!xmlData.empty(), "Failed to parse xml file.");
82
83 devicePrivacyMaps_ = xmlData;
84
85 auto privacyDevices = devicePrivacyMaps_.find(AudioDevicePrivacyType::TYPE_PRIVACY);
86 if (privacyDevices != devicePrivacyMaps_.end()) {
87 privacyDeviceList_ = privacyDevices->second;
88 }
89
90 auto publicDevices = devicePrivacyMaps_.find(AudioDevicePrivacyType::TYPE_PUBLIC);
91 if (publicDevices != devicePrivacyMaps_.end()) {
92 publicDeviceList_ = publicDevices->second;
93 }
94 }
95
DeviceAttrMatch(const shared_ptr<AudioDeviceDescriptor> & devDesc,AudioDevicePrivacyType & privacyType,DeviceRole & devRole,DeviceUsage & devUsage)96 bool AudioDeviceManager::DeviceAttrMatch(const shared_ptr<AudioDeviceDescriptor> &devDesc,
97 AudioDevicePrivacyType &privacyType, DeviceRole &devRole, DeviceUsage &devUsage)
98 {
99 list<DevicePrivacyInfo> deviceList;
100 if (privacyType == TYPE_PRIVACY) {
101 deviceList = privacyDeviceList_;
102 } else if (privacyType == TYPE_PUBLIC) {
103 deviceList = publicDeviceList_;
104 } else {
105 return false;
106 }
107
108 if (devDesc->connectState_ == VIRTUAL_CONNECTED) {
109 return false;
110 }
111
112 if (devDesc->deviceType_ == DEVICE_TYPE_BLUETOOTH_SCO &&
113 devUsage == MEDIA &&
114 devRole == OUTPUT_DEVICE) {
115 AUDIO_INFO_LOG("bluetooth sco not support in media output scene");
116 return false;
117 }
118
119 for (auto &devInfo : deviceList) {
120 if ((devInfo.deviceType == devDesc->deviceType_) &&
121 (devRole == devDesc->deviceRole_) &&
122 ((devInfo.deviceUsage & devUsage) != 0) &&
123 ((devInfo.deviceCategory == devDesc->deviceCategory_) ||
124 ((devInfo.deviceCategory & devDesc->deviceCategory_) != 0))) {
125 return true;
126 }
127 }
128
129 return false;
130 }
131
FillArrayWhenDeviceAttrMatch(const shared_ptr<AudioDeviceDescriptor> & devDesc,AudioDevicePrivacyType privacyType,DeviceRole devRole,DeviceUsage devUsage,string logName,vector<shared_ptr<AudioDeviceDescriptor>> & descArray)132 void AudioDeviceManager::FillArrayWhenDeviceAttrMatch(const shared_ptr<AudioDeviceDescriptor> &devDesc,
133 AudioDevicePrivacyType privacyType, DeviceRole devRole, DeviceUsage devUsage, string logName,
134 vector<shared_ptr<AudioDeviceDescriptor>> &descArray)
135 {
136 std::lock_guard<std::mutex> lock(descArrayMutex_);
137 bool result = DeviceAttrMatch(devDesc, privacyType, devRole, devUsage);
138 if (result) {
139 descArray.push_back(devDesc);
140 AUDIO_WARNING_LOG("Add to %{public}s list, and then %{public}s",
141 logName.c_str(), AudioPolicyUtils::GetInstance().GetDevicesStr(descArray).c_str());
142 }
143 }
144
AddRemoteRenderDev(const shared_ptr<AudioDeviceDescriptor> & devDesc)145 void AudioDeviceManager::AddRemoteRenderDev(const shared_ptr<AudioDeviceDescriptor> &devDesc)
146 {
147 if ((devDesc->networkId_ != LOCAL_NETWORK_ID || devDesc->deviceType_ == DEVICE_TYPE_REMOTE_CAST) &&
148 devDesc->deviceRole_ == DeviceRole::OUTPUT_DEVICE) {
149 remoteRenderDevices_.push_back(devDesc);
150 }
151 }
152
AddRemoteCaptureDev(const shared_ptr<AudioDeviceDescriptor> & devDesc)153 void AudioDeviceManager::AddRemoteCaptureDev(const shared_ptr<AudioDeviceDescriptor> &devDesc)
154 {
155 if (devDesc->networkId_ != LOCAL_NETWORK_ID && devDesc->deviceRole_ == DeviceRole::INPUT_DEVICE) {
156 remoteCaptureDevices_.push_back(devDesc);
157 }
158 }
159
MakePairedDeviceDescriptor(const shared_ptr<AudioDeviceDescriptor> & devDesc)160 void AudioDeviceManager::MakePairedDeviceDescriptor(const shared_ptr<AudioDeviceDescriptor> &devDesc)
161 {
162 auto isPresent = [&devDesc] (const shared_ptr<AudioDeviceDescriptor> &desc) {
163 return devDesc->IsPairedDeviceDesc(*desc);
164 };
165
166 if (devDesc->deviceRole_ == INPUT_DEVICE || devDesc->deviceRole_ == OUTPUT_DEVICE) {
167 auto it = find_if(connectedDevices_.begin(), connectedDevices_.end(), isPresent);
168 if (it != connectedDevices_.end()) {
169 devDesc->pairDeviceDescriptor_ = *it;
170 (*it)->pairDeviceDescriptor_ = devDesc;
171 }
172 if (devDesc->deviceRole_ == INPUT_DEVICE) {
173 MakePairedDefaultDeviceDescriptor(devDesc, OUTPUT_DEVICE);
174 } else {
175 MakePairedDefaultDeviceDescriptor(devDesc, INPUT_DEVICE);
176 }
177 }
178 }
179
MakePairedDefaultDeviceDescriptor(const shared_ptr<AudioDeviceDescriptor> & devDesc,DeviceRole devRole)180 void AudioDeviceManager::MakePairedDefaultDeviceDescriptor(const shared_ptr<AudioDeviceDescriptor> &devDesc,
181 DeviceRole devRole)
182 {
183 // EARPIECE -> MIC ; SPEAKER -> MIC ; MIC -> SPEAKER
184 auto isPresent = [&devDesc, &devRole] (const shared_ptr<AudioDeviceDescriptor> &desc) {
185 if ((devDesc->deviceType_ == DEVICE_TYPE_EARPIECE || devDesc->deviceType_ == DEVICE_TYPE_SPEAKER) &&
186 devRole == INPUT_DEVICE && desc->deviceType_ == DEVICE_TYPE_MIC &&
187 desc->networkId_ == devDesc->networkId_) {
188 return true;
189 } else if (devDesc->deviceType_ == DEVICE_TYPE_MIC && devRole == OUTPUT_DEVICE &&
190 desc->deviceType_ == DEVICE_TYPE_SPEAKER && desc->networkId_ == devDesc->networkId_) {
191 return true;
192 }
193 return false;
194 };
195
196 auto it = find_if(connectedDevices_.begin(), connectedDevices_.end(), isPresent);
197 if (it != connectedDevices_.end()) {
198 MakePairedDefaultDeviceImpl(devDesc, *it);
199 }
200 }
201
MakePairedDefaultDeviceImpl(const shared_ptr<AudioDeviceDescriptor> & devDesc,const shared_ptr<AudioDeviceDescriptor> & connectedDesc)202 void AudioDeviceManager::MakePairedDefaultDeviceImpl(const shared_ptr<AudioDeviceDescriptor> &devDesc,
203 const shared_ptr<AudioDeviceDescriptor> &connectedDesc)
204 {
205 devDesc->pairDeviceDescriptor_ = connectedDesc;
206 if (devDesc->deviceType_ == DEVICE_TYPE_EARPIECE && earpiece_ != NULL &&
207 earpiece_->networkId_ == connectedDesc->networkId_) {
208 earpiece_->pairDeviceDescriptor_ = connectedDesc;
209 } else if (devDesc->deviceType_ == DEVICE_TYPE_SPEAKER && speaker_ != NULL && defalutMic_ != NULL) {
210 if (speaker_->networkId_ == connectedDesc->networkId_) {
211 speaker_->pairDeviceDescriptor_ = connectedDesc;
212 }
213 if (defalutMic_->networkId_ == devDesc->networkId_) {
214 defalutMic_->pairDeviceDescriptor_ = devDesc;
215 }
216 connectedDesc->pairDeviceDescriptor_ = devDesc;
217 } else if (devDesc->deviceType_ == DEVICE_TYPE_MIC && defalutMic_ != NULL && speaker_ != NULL) {
218 if (defalutMic_->networkId_ == connectedDesc->networkId_) {
219 defalutMic_->pairDeviceDescriptor_ = connectedDesc;
220 }
221 if (speaker_->networkId_ == devDesc->networkId_) {
222 speaker_->pairDeviceDescriptor_ = devDesc;
223 }
224 connectedDesc->pairDeviceDescriptor_ = devDesc;
225 }
226 }
227
IsArmUsbDevice(const AudioDeviceDescriptor & desc)228 bool AudioDeviceManager::IsArmUsbDevice(const AudioDeviceDescriptor &desc)
229 {
230 auto isPresent = [&desc] (const auto &connDesc) {
231 return connDesc->deviceId_ == desc.deviceId_;
232 };
233 std::lock_guard<std::mutex> currentActiveDevicesLock(currentActiveDevicesMutex_);
234 auto itr = std::find_if(connectedDevices_.begin(), connectedDevices_.end(), isPresent);
235 if (itr == connectedDevices_.end()) {
236 return false;
237 }
238
239 return (*itr)->deviceType_ == DEVICE_TYPE_USB_ARM_HEADSET;
240 }
241
AddConnectedDevices(const shared_ptr<AudioDeviceDescriptor> & devDesc)242 void AudioDeviceManager::AddConnectedDevices(const shared_ptr<AudioDeviceDescriptor> &devDesc)
243 {
244 connectedDevices_.insert(connectedDevices_.begin(), devDesc);
245 AUDIO_INFO_LOG("Connected list %{public}s",
246 AudioPolicyUtils::GetInstance().GetDevicesStr(connectedDevices_).c_str());
247 }
248
RemoveConnectedDevices(const shared_ptr<AudioDeviceDescriptor> & devDesc)249 void AudioDeviceManager::RemoveConnectedDevices(const shared_ptr<AudioDeviceDescriptor> &devDesc)
250 {
251 Trace trace("AudioDeviceManager::RemoveConnectedDevices");
252 auto isPresent = [&devDesc](const shared_ptr<AudioDeviceDescriptor> &descriptor) {
253 if (descriptor->deviceType_ == devDesc->deviceType_ &&
254 descriptor->networkId_ == devDesc->networkId_) {
255 if (IsUsb(descriptor->deviceType_)) {
256 return descriptor->macAddress_ == devDesc->macAddress_ &&
257 descriptor->deviceRole_ == devDesc->deviceRole_;
258 }
259 // if the disconnecting device, need to compare mac address in addition.
260 return descriptor->macAddress_ == devDesc->macAddress_;
261 }
262 return false;
263 };
264
265 for (auto it = connectedDevices_.begin(); it != connectedDevices_.end();) {
266 Trace traceSec("AudioDeviceManager::RemoveConnectedDevices:erase");
267 it = find_if(it, connectedDevices_.end(), isPresent);
268 if (it != connectedDevices_.end()) {
269 if (devDesc->connectState_ != VIRTUAL_CONNECTED && IsVirtualDevicesExist(devDesc)) {
270 (*it)->connectState_ = VIRTUAL_CONNECTED;
271 ++it;
272 continue;
273 }
274 if ((*it)->pairDeviceDescriptor_ != nullptr) {
275 (*it)->pairDeviceDescriptor_->pairDeviceDescriptor_ = nullptr;
276 }
277 it = connectedDevices_.erase(it);
278 }
279 }
280 AUDIO_INFO_LOG("Connected list %{public}s",
281 AudioPolicyUtils::GetInstance().GetDevicesStr(connectedDevices_).c_str());
282 }
283
IsConnectedDevices(const std::shared_ptr<AudioDeviceDescriptor> & devDesc)284 bool AudioDeviceManager::IsConnectedDevices(const std::shared_ptr<AudioDeviceDescriptor> &devDesc)
285 {
286 CHECK_AND_RETURN_RET_LOG(devDesc != nullptr, false, "Invalid device descriptor");
287 auto isPresent = [&devDesc](const shared_ptr<AudioDeviceDescriptor> &desc) {
288 return desc->connectState_ != VIRTUAL_CONNECTED &&
289 desc->deviceType_ == devDesc->deviceType_ &&
290 desc->networkId_ == devDesc->networkId_ &&
291 desc->macAddress_ == devDesc->macAddress_;
292 };
293 bool isConnectedDevice = false;
294 auto itr = find_if(connectedDevices_.begin(), connectedDevices_.end(), isPresent);
295 if (itr != connectedDevices_.end()) {
296 isConnectedDevice = true;
297 }
298 AUDIO_INFO_LOG("isConnectedDevice %{public}d, connected list %{public}s", isConnectedDevice,
299 AudioPolicyUtils::GetInstance().GetDevicesStr(connectedDevices_).c_str());
300 return isConnectedDevice;
301 }
302
UpdateVirtualDevices(const std::shared_ptr<AudioDeviceDescriptor> & devDesc,bool isConnected)303 void AudioDeviceManager::UpdateVirtualDevices(const std::shared_ptr<AudioDeviceDescriptor> &devDesc, bool isConnected)
304 {
305 CHECK_AND_RETURN_LOG(devDesc != nullptr, "Invalid device descriptor");
306 auto isPresent = [&devDesc](const shared_ptr<AudioDeviceDescriptor> &desc) {
307 return desc->deviceType_ == devDesc->deviceType_ &&
308 desc->networkId_ == devDesc->networkId_ &&
309 desc->macAddress_ == devDesc->macAddress_;
310 };
311 if (isConnected) {
312 std::lock_guard<std::mutex> lock(virtualDevicesMutex_);
313 auto it = find_if(virtualDevices_.begin(), virtualDevices_.end(), isPresent);
314 if (it == virtualDevices_.end()) {
315 virtualDevices_.push_back(devDesc);
316 }
317 } else {
318 std::lock_guard<std::mutex> lock(virtualDevicesMutex_);
319 virtualDevices_.erase(std::remove_if(virtualDevices_.begin(), virtualDevices_.end(), isPresent),
320 virtualDevices_.end());
321 }
322 AUDIO_INFO_LOG("VirtualDevices list %{public}s",
323 AudioPolicyUtils::GetInstance().GetDevicesStr(virtualDevices_).c_str());
324 }
325
IsVirtualDevicesExist(const std::shared_ptr<AudioDeviceDescriptor> & devDesc)326 bool AudioDeviceManager::IsVirtualDevicesExist(const std::shared_ptr<AudioDeviceDescriptor> &devDesc)
327 {
328 CHECK_AND_RETURN_RET_LOG(devDesc != nullptr, false, "Invalid device descriptor");
329 auto isPresent = [&devDesc](const shared_ptr<AudioDeviceDescriptor> &desc) {
330 return desc->deviceType_ == devDesc->deviceType_ &&
331 desc->networkId_ == devDesc->networkId_ &&
332 desc->macAddress_ == devDesc->macAddress_;
333 };
334
335 std::lock_guard<std::mutex> lock(virtualDevicesMutex_);
336 auto it = find_if(virtualDevices_.begin(), virtualDevices_.end(), isPresent);
337 bool isExist = it != virtualDevices_.end();
338 AUDIO_INFO_LOG("isVirtualDevicesExist %{public}d, virtualDevices list %{public}s", isExist,
339 AudioPolicyUtils::GetInstance().GetDevicesStr(virtualDevices_).c_str());
340 return isExist;
341 }
342
AddDefaultDevices(const std::shared_ptr<AudioDeviceDescriptor> & devDesc)343 void AudioDeviceManager::AddDefaultDevices(const std::shared_ptr<AudioDeviceDescriptor> &devDesc)
344 {
345 DeviceType devType = devDesc->deviceType_;
346 if (devType == DEVICE_TYPE_EARPIECE) {
347 earpiece_ = devDesc;
348 } else if (devType == DEVICE_TYPE_SPEAKER) {
349 speaker_ = devDesc;
350 } else if (devType == DEVICE_TYPE_MIC) {
351 defalutMic_ = devDesc;
352 }
353 }
354
UpdateDeviceInfo(shared_ptr<AudioDeviceDescriptor> & deviceDesc)355 void AudioDeviceManager::UpdateDeviceInfo(shared_ptr<AudioDeviceDescriptor> &deviceDesc)
356 {
357 if (deviceDesc->connectTimeStamp_ == 0) {
358 deviceDesc->connectTimeStamp_ = GetCurrentTimeMS();
359 }
360 MakePairedDeviceDescriptor(deviceDesc);
361 }
362
AddCommunicationDevices(const shared_ptr<AudioDeviceDescriptor> & devDesc)363 void AudioDeviceManager::AddCommunicationDevices(const shared_ptr<AudioDeviceDescriptor> &devDesc)
364 {
365 FillArrayWhenDeviceAttrMatch(devDesc, TYPE_PRIVACY, OUTPUT_DEVICE, VOICE, "communication render privacy device",
366 commRenderPrivacyDevices_);
367 FillArrayWhenDeviceAttrMatch(devDesc, TYPE_PUBLIC, OUTPUT_DEVICE, VOICE, "communication render public device",
368 commRenderPublicDevices_);
369 FillArrayWhenDeviceAttrMatch(devDesc, TYPE_PRIVACY, INPUT_DEVICE, VOICE, "communication capture privacy device",
370 commCapturePrivacyDevices_);
371 FillArrayWhenDeviceAttrMatch(devDesc, TYPE_PUBLIC, INPUT_DEVICE, VOICE, "communication capture public device",
372 commCapturePublicDevices_);
373 }
374
AddMediaDevices(const shared_ptr<AudioDeviceDescriptor> & devDesc)375 void AudioDeviceManager::AddMediaDevices(const shared_ptr<AudioDeviceDescriptor> &devDesc)
376 {
377 FillArrayWhenDeviceAttrMatch(devDesc, TYPE_PRIVACY, OUTPUT_DEVICE, MEDIA, "media render privacy device",
378 mediaRenderPrivacyDevices_);
379 FillArrayWhenDeviceAttrMatch(devDesc, TYPE_PUBLIC, OUTPUT_DEVICE, MEDIA, "media render public device",
380 mediaRenderPublicDevices_);
381 FillArrayWhenDeviceAttrMatch(devDesc, TYPE_PRIVACY, INPUT_DEVICE, MEDIA, "media capture privacy device",
382 mediaCapturePrivacyDevices_);
383 FillArrayWhenDeviceAttrMatch(devDesc, TYPE_PUBLIC, INPUT_DEVICE, MEDIA, "media capture public device",
384 mediaCapturePublicDevices_);
385 }
386
AddCaptureDevices(const shared_ptr<AudioDeviceDescriptor> & devDesc)387 void AudioDeviceManager::AddCaptureDevices(const shared_ptr<AudioDeviceDescriptor> &devDesc)
388 {
389 FillArrayWhenDeviceAttrMatch(devDesc, TYPE_PRIVACY, INPUT_DEVICE, ALL_USAGE, "capture privacy device",
390 capturePrivacyDevices_);
391 FillArrayWhenDeviceAttrMatch(devDesc, TYPE_PUBLIC, INPUT_DEVICE, ALL_USAGE, "capture public device",
392 capturePublicDevices_);
393 if (devDesc->isVrSupported_ == true) {
394 AUDIO_INFO_LOG("Device supports recognition in");
395 FillArrayWhenDeviceAttrMatch(devDesc, TYPE_PRIVACY, INPUT_DEVICE, RECOGNITION,
396 "capture recognition privacy device", reconCapturePrivacyDevices_);
397 }
398 }
399
HandleScoWithDefaultCategory(const shared_ptr<AudioDeviceDescriptor> & devDesc)400 void AudioDeviceManager::HandleScoWithDefaultCategory(const shared_ptr<AudioDeviceDescriptor> &devDesc)
401 {
402 if (devDesc->connectState_ != VIRTUAL_CONNECTED &&
403 devDesc->deviceType_ == DEVICE_TYPE_BLUETOOTH_SCO &&
404 devDesc->deviceCategory_ == CATEGORY_DEFAULT &&
405 devDesc->isEnable_) {
406 if (devDesc->deviceRole_ == INPUT_DEVICE) {
407 commCapturePrivacyDevices_.push_back(devDesc);
408 } else if (devDesc->deviceRole_ == OUTPUT_DEVICE) {
409 commRenderPrivacyDevices_.push_back(devDesc);
410 }
411 }
412 }
413
UpdateExistDeviceDescriptor(const std::shared_ptr<AudioDeviceDescriptor> & deviceDescriptor)414 bool AudioDeviceManager::UpdateExistDeviceDescriptor(const std::shared_ptr<AudioDeviceDescriptor> &deviceDescriptor)
415 {
416 auto isPresent = [&deviceDescriptor](const shared_ptr<AudioDeviceDescriptor> &descriptor) {
417 if (descriptor->deviceType_ == deviceDescriptor->deviceType_ &&
418 descriptor->networkId_ == deviceDescriptor->networkId_ &&
419 descriptor->deviceRole_ == deviceDescriptor->deviceRole_) {
420 if (IsUsb(descriptor->deviceType_)) {
421 return descriptor->macAddress_ == deviceDescriptor->macAddress_;
422 }
423 if (descriptor->deviceType_ != DEVICE_TYPE_BLUETOOTH_A2DP &&
424 descriptor->deviceType_ != DEVICE_TYPE_BLUETOOTH_SCO &&
425 descriptor->deviceType_ != DEVICE_TYPE_NEARLINK &&
426 descriptor->deviceType_ != DEVICE_TYPE_NEARLINK_IN) {
427 return true;
428 } else {
429 // if the disconnecting device is A2DP, need to compare mac address in addition.
430 return descriptor->macAddress_ == deviceDescriptor->macAddress_;
431 }
432 }
433 return false;
434 };
435
436 auto iter = std::find_if(connectedDevices_.begin(), connectedDevices_.end(), isPresent);
437 if (iter != connectedDevices_.end()) {
438 **iter = deviceDescriptor;
439 UpdateDeviceInfo(*iter);
440 return true;
441 }
442 return false;
443 }
444
RemoveVirtualConnectedDevice(const shared_ptr<AudioDeviceDescriptor> & devDesc)445 void AudioDeviceManager::RemoveVirtualConnectedDevice(const shared_ptr<AudioDeviceDescriptor> &devDesc)
446 {
447 auto isPresent = [&devDesc](const shared_ptr<AudioDeviceDescriptor> &descriptor) {
448 return descriptor->deviceType_ == devDesc->deviceType_
449 && descriptor->deviceRole_ == devDesc->deviceRole_
450 && descriptor->networkId_ == devDesc->networkId_
451 && descriptor->macAddress_ == devDesc->macAddress_
452 && descriptor->connectState_ == VIRTUAL_CONNECTED;
453 };
454 connectedDevices_.erase(std::remove_if(connectedDevices_.begin(), connectedDevices_.end(), isPresent),
455 connectedDevices_.end());
456 }
457
AddNewDevice(const std::shared_ptr<AudioDeviceDescriptor> & deviceDescriptor)458 void AudioDeviceManager::AddNewDevice(const std::shared_ptr<AudioDeviceDescriptor> &deviceDescriptor)
459 {
460 shared_ptr<AudioDeviceDescriptor> devDesc = make_shared<AudioDeviceDescriptor>(deviceDescriptor);
461 CHECK_AND_RETURN_LOG(devDesc != nullptr, "Memory allocation failed");
462
463 int32_t audioId = deviceDescriptor->deviceId_;
464 AUDIO_INFO_LOG("add type:id %{public}d:%{public}d", deviceDescriptor->getType(), audioId);
465
466 std::lock_guard<std::mutex> currentActiveDevicesLock(currentActiveDevicesMutex_);
467 RemoveVirtualConnectedDevice(devDesc);
468 if (UpdateExistDeviceDescriptor(deviceDescriptor)) {
469 AUDIO_WARNING_LOG("The device has been added and will not be added again.");
470 return;
471 }
472 AddConnectedDevices(devDesc);
473
474 if (devDesc->networkId_ != LOCAL_NETWORK_ID || devDesc->deviceType_ == DEVICE_TYPE_REMOTE_CAST) {
475 AddRemoteRenderDev(devDesc);
476 AddRemoteCaptureDev(devDesc);
477 } else {
478 HandleScoWithDefaultCategory(devDesc);
479 AddDefaultDevices(deviceDescriptor);
480 AddCommunicationDevices(devDesc);
481 AddMediaDevices(devDesc);
482 AddCaptureDevices(devDesc);
483 }
484 UpdateDeviceInfo(devDesc);
485 }
486
GetConnDevicesStr()487 std::string AudioDeviceManager::GetConnDevicesStr()
488 {
489 std::lock_guard<std::mutex> currentActiveDevicesLock(currentActiveDevicesMutex_);
490 return AudioPolicyUtils::GetInstance().GetDevicesStr(connectedDevices_);
491 }
492
RemoveMatchDeviceInArray(const AudioDeviceDescriptor & devDesc,string logName,vector<shared_ptr<AudioDeviceDescriptor>> & descArray)493 void AudioDeviceManager::RemoveMatchDeviceInArray(const AudioDeviceDescriptor &devDesc, string logName,
494 vector<shared_ptr<AudioDeviceDescriptor>> &descArray)
495 {
496 std::lock_guard<std::mutex> lock(descArrayMutex_);
497 auto isPresent = [&devDesc] (const shared_ptr<AudioDeviceDescriptor> &desc) {
498 CHECK_AND_RETURN_RET_LOG(desc != nullptr, false, "Invalid device descriptor");
499 return devDesc.deviceType_ == desc->deviceType_ && devDesc.macAddress_ == desc->macAddress_ &&
500 devDesc.networkId_ == desc->networkId_ &&
501 (!IsUsb(desc->deviceType_) || devDesc.deviceRole_ == desc->deviceRole_);
502 };
503
504 auto removeBeginIt = std::remove_if(descArray.begin(), descArray.end(), isPresent);
505 size_t deleteNum = static_cast<uint32_t>(descArray.end() - removeBeginIt);
506 descArray.erase(removeBeginIt, descArray.end());
507
508 AUDIO_WARNING_LOG("Remove %{public}zu desc from %{public}s list, and then %{public}s", deleteNum,
509 logName.c_str(), AudioPolicyUtils::GetInstance().GetDevicesStr(descArray).c_str());
510 }
511
RemoveNewDevice(const std::shared_ptr<AudioDeviceDescriptor> & devDesc)512 void AudioDeviceManager::RemoveNewDevice(const std::shared_ptr<AudioDeviceDescriptor> &devDesc)
513 {
514 Trace trace("AudioDeviceManager::RemoveNewDevice");
515 int32_t audioId = devDesc->deviceId_;
516 AUDIO_INFO_LOG("remove type:id %{public}d:%{public}d ", devDesc->getType(), audioId);
517
518 std::lock_guard<std::mutex> currentActiveDevicesLock(currentActiveDevicesMutex_);
519 RemoveConnectedDevices(devDesc);
520 UpdateVirtualDevices(devDesc, false);
521 RemoveRemoteDevices(devDesc);
522 RemoveCommunicationDevices(devDesc);
523 RemoveMediaDevices(devDesc);
524 RemoveCaptureDevices(devDesc);
525 }
526
GetRemoteRenderDevices()527 vector<shared_ptr<AudioDeviceDescriptor>> AudioDeviceManager::GetRemoteRenderDevices()
528 {
529 std::lock_guard<std::mutex> lock(descArrayMutex_);
530 vector<shared_ptr<AudioDeviceDescriptor>> descs;
531 for (const auto &desc : remoteRenderDevices_) {
532 if (desc == nullptr) {
533 continue;
534 }
535 descs.push_back(make_shared<AudioDeviceDescriptor>(*desc));
536 }
537 return descs;
538 }
539
GetRemoteCaptureDevices()540 vector<shared_ptr<AudioDeviceDescriptor>> AudioDeviceManager::GetRemoteCaptureDevices()
541 {
542 std::lock_guard<std::mutex> lock(descArrayMutex_);
543 vector<shared_ptr<AudioDeviceDescriptor>> descs;
544 for (const auto &desc : remoteCaptureDevices_) {
545 if (desc == nullptr) {
546 continue;
547 }
548 descs.push_back(make_shared<AudioDeviceDescriptor>(*desc));
549 }
550 return descs;
551 }
552
GetCommRenderPrivacyDevices()553 vector<shared_ptr<AudioDeviceDescriptor>> AudioDeviceManager::GetCommRenderPrivacyDevices()
554 {
555 std::lock_guard<std::mutex> lock(descArrayMutex_);
556 vector<shared_ptr<AudioDeviceDescriptor>> descs;
557 for (const auto &desc : commRenderPrivacyDevices_) {
558 if (desc == nullptr) {
559 continue;
560 }
561 descs.push_back(make_shared<AudioDeviceDescriptor>(*desc));
562 }
563 return descs;
564 }
565
GetCommRenderPublicDevices()566 vector<shared_ptr<AudioDeviceDescriptor>> AudioDeviceManager::GetCommRenderPublicDevices()
567 {
568 std::lock_guard<std::mutex> lock(descArrayMutex_);
569 vector<shared_ptr<AudioDeviceDescriptor>> descs;
570 for (const auto &desc : commRenderPublicDevices_) {
571 if (desc == nullptr) {
572 continue;
573 }
574 descs.push_back(make_shared<AudioDeviceDescriptor>(*desc));
575 }
576 return descs;
577 }
578
GetCommRenderBTCarDevices()579 vector<shared_ptr<AudioDeviceDescriptor>> AudioDeviceManager::GetCommRenderBTCarDevices()
580 {
581 std::lock_guard<std::mutex> lock(descArrayMutex_);
582 vector<shared_ptr<AudioDeviceDescriptor>> carDescs;
583 for (const auto &desc : commRenderPublicDevices_) {
584 if (desc == nullptr || desc->deviceCategory_ != BT_CAR) {
585 continue;
586 }
587 carDescs.push_back(make_shared<AudioDeviceDescriptor>(*desc));
588 }
589 return carDescs;
590 }
591
GetCommCapturePrivacyDevices()592 vector<shared_ptr<AudioDeviceDescriptor>> AudioDeviceManager::GetCommCapturePrivacyDevices()
593 {
594 std::lock_guard<std::mutex> lock(descArrayMutex_);
595 vector<shared_ptr<AudioDeviceDescriptor>> descs;
596 for (const auto &desc : commCapturePrivacyDevices_) {
597 if (desc == nullptr) {
598 continue;
599 }
600 descs.push_back(make_shared<AudioDeviceDescriptor>(*desc));
601 }
602 return descs;
603 }
604
GetCommCapturePublicDevices()605 vector<shared_ptr<AudioDeviceDescriptor>> AudioDeviceManager::GetCommCapturePublicDevices()
606 {
607 std::lock_guard<std::mutex> lock(descArrayMutex_);
608 vector<shared_ptr<AudioDeviceDescriptor>> descs;
609 for (const auto &desc : commCapturePublicDevices_) {
610 if (desc == nullptr) {
611 continue;
612 }
613 descs.push_back(make_shared<AudioDeviceDescriptor>(*desc));
614 }
615 return descs;
616 }
617
GetMediaRenderPrivacyDevices()618 vector<shared_ptr<AudioDeviceDescriptor>> AudioDeviceManager::GetMediaRenderPrivacyDevices()
619 {
620 std::lock_guard<std::mutex> lock(descArrayMutex_);
621 vector<shared_ptr<AudioDeviceDescriptor>> descs;
622 for (const auto &desc : mediaRenderPrivacyDevices_) {
623 if (desc == nullptr) {
624 continue;
625 }
626 descs.push_back(make_shared<AudioDeviceDescriptor>(*desc));
627 }
628 return descs;
629 }
630
GetMediaRenderPublicDevices()631 vector<shared_ptr<AudioDeviceDescriptor>> AudioDeviceManager::GetMediaRenderPublicDevices()
632 {
633 std::lock_guard<std::mutex> lock(descArrayMutex_);
634 vector<shared_ptr<AudioDeviceDescriptor>> descs;
635 for (const auto &desc : mediaRenderPublicDevices_) {
636 if (desc == nullptr) {
637 continue;
638 }
639 descs.push_back(make_shared<AudioDeviceDescriptor>(*desc));
640 }
641 return descs;
642 }
643
GetMediaCapturePrivacyDevices()644 vector<shared_ptr<AudioDeviceDescriptor>> AudioDeviceManager::GetMediaCapturePrivacyDevices()
645 {
646 std::lock_guard<std::mutex> lock(descArrayMutex_);
647 vector<shared_ptr<AudioDeviceDescriptor>> descs;
648 for (const auto &desc : mediaCapturePrivacyDevices_) {
649 if (desc == nullptr) {
650 continue;
651 }
652 descs.push_back(make_shared<AudioDeviceDescriptor>(*desc));
653 }
654 return descs;
655 }
656
GetMediaCapturePublicDevices()657 vector<shared_ptr<AudioDeviceDescriptor>> AudioDeviceManager::GetMediaCapturePublicDevices()
658 {
659 std::lock_guard<std::mutex> lock(descArrayMutex_);
660 vector<shared_ptr<AudioDeviceDescriptor>> descs;
661 for (const auto &desc : mediaCapturePublicDevices_) {
662 if (desc == nullptr) {
663 continue;
664 }
665 descs.push_back(make_shared<AudioDeviceDescriptor>(*desc));
666 }
667 return descs;
668 }
669
GetCapturePrivacyDevices()670 vector<shared_ptr<AudioDeviceDescriptor>> AudioDeviceManager::GetCapturePrivacyDevices()
671 {
672 std::lock_guard<std::mutex> lock(descArrayMutex_);
673 vector<shared_ptr<AudioDeviceDescriptor>> descs;
674 for (const auto &desc : capturePrivacyDevices_) {
675 if (desc == nullptr) {
676 continue;
677 }
678 descs.push_back(make_shared<AudioDeviceDescriptor>(*desc));
679 }
680 return descs;
681 }
682
GetCapturePublicDevices()683 vector<shared_ptr<AudioDeviceDescriptor>> AudioDeviceManager::GetCapturePublicDevices()
684 {
685 std::lock_guard<std::mutex> lock(descArrayMutex_);
686 vector<shared_ptr<AudioDeviceDescriptor>> descs;
687 for (const auto &desc : capturePublicDevices_) {
688 if (desc == nullptr) {
689 continue;
690 }
691 descs.push_back(make_shared<AudioDeviceDescriptor>(*desc));
692 }
693 return descs;
694 }
695
GetRecongnitionCapturePrivacyDevices()696 vector<shared_ptr<AudioDeviceDescriptor>> AudioDeviceManager::GetRecongnitionCapturePrivacyDevices()
697 {
698 std::lock_guard<std::mutex> lock(descArrayMutex_);
699 vector<shared_ptr<AudioDeviceDescriptor>> descs;
700 for (const auto &desc : reconCapturePrivacyDevices_) {
701 if (desc == nullptr) {
702 continue;
703 }
704 descs.push_back(make_shared<AudioDeviceDescriptor>(*desc));
705 }
706 return descs;
707 }
708 // LCOV_EXCL_STOP
GetCommRenderDefaultDevice(StreamUsage streamUsage)709 shared_ptr<AudioDeviceDescriptor> AudioDeviceManager::GetCommRenderDefaultDevice(StreamUsage streamUsage)
710 {
711 if (streamUsage < STREAM_USAGE_UNKNOWN || streamUsage > STREAM_USAGE_VOICE_MODEM_COMMUNICATION) {
712 AUDIO_DEBUG_LOG("Invalid stream usage");
713 }
714
715 shared_ptr<AudioDeviceDescriptor> devDesc;
716 if (hasEarpiece_ && streamUsage != STREAM_USAGE_VIDEO_COMMUNICATION) {
717 devDesc = make_shared<AudioDeviceDescriptor>(earpiece_);
718 } else {
719 devDesc = make_shared<AudioDeviceDescriptor>(speaker_);
720 }
721 return devDesc;
722 }
723
GetRenderDefaultDevice()724 shared_ptr<AudioDeviceDescriptor> AudioDeviceManager::GetRenderDefaultDevice()
725 {
726 shared_ptr<AudioDeviceDescriptor> devDesc = make_shared<AudioDeviceDescriptor>(speaker_);
727 return devDesc;
728 }
729
GetCaptureDefaultDevice()730 shared_ptr<AudioDeviceDescriptor> AudioDeviceManager::GetCaptureDefaultDevice()
731 {
732 shared_ptr<AudioDeviceDescriptor> devDesc = make_shared<AudioDeviceDescriptor>(defalutMic_);
733 return devDesc;
734 }
735
FindConnectedDeviceById(const int32_t deviceId)736 shared_ptr<AudioDeviceDescriptor> AudioDeviceManager::FindConnectedDeviceById(const int32_t deviceId)
737 {
738 auto it = std::find_if(connectedDevices_.cbegin(), connectedDevices_.cend(), [deviceId](auto &item) {
739 return item->deviceId_ == deviceId;
740 });
741 return it == connectedDevices_.cend() ? nullptr : *it;
742 }
743
GetActiveScoDevice(std::string scoMac,DeviceRole role)744 shared_ptr<AudioDeviceDescriptor> AudioDeviceManager::GetActiveScoDevice(std::string scoMac, DeviceRole role)
745 {
746 std::lock_guard<std::mutex> currentActiveDevicesLock(currentActiveDevicesMutex_);
747 for (auto &dev : connectedDevices_) {
748 CHECK_AND_RETURN_RET_LOG(dev != nullptr, make_shared<AudioDeviceDescriptor>(),
749 "Device is nullptr");
750 if (dev->deviceType_ == DEVICE_TYPE_BLUETOOTH_SCO && dev->macAddress_ == scoMac
751 && dev->deviceRole_ == role) {
752 return dev;
753 }
754 }
755 return make_shared<AudioDeviceDescriptor>();
756 }
757
758
759 // LCOV_EXCL_START
AddAvailableDevicesByUsage(const AudioDeviceUsage usage,const DevicePrivacyInfo & deviceInfo,const std::shared_ptr<AudioDeviceDescriptor> & dev,std::vector<shared_ptr<AudioDeviceDescriptor>> & audioDeviceDescriptors)760 void AudioDeviceManager::AddAvailableDevicesByUsage(const AudioDeviceUsage usage,
761 const DevicePrivacyInfo &deviceInfo, const std::shared_ptr<AudioDeviceDescriptor> &dev,
762 std::vector<shared_ptr<AudioDeviceDescriptor>> &audioDeviceDescriptors)
763 {
764 CHECK_AND_RETURN_LOG(dev != nullptr, "nullptr dev");
765 switch (usage) {
766 case MEDIA_OUTPUT_DEVICES:
767 if ((static_cast<uint32_t>(dev->deviceRole_) & OUTPUT_DEVICE) &&
768 (static_cast<uint32_t>(deviceInfo.deviceUsage) & MEDIA) &&
769 (dev->deviceType_ != DEVICE_TYPE_BLUETOOTH_SCO)) {
770 audioDeviceDescriptors.push_back(make_shared<AudioDeviceDescriptor>(dev));
771 }
772 break;
773 case MEDIA_INPUT_DEVICES:
774 if ((static_cast<uint32_t>(dev->deviceRole_) & INPUT_DEVICE) &&
775 (static_cast<uint32_t>(deviceInfo.deviceUsage) & MEDIA)) {
776 audioDeviceDescriptors.push_back(make_shared<AudioDeviceDescriptor>(dev));
777 }
778 break;
779 case ALL_MEDIA_DEVICES:
780 if (static_cast<uint32_t>(deviceInfo.deviceUsage) & MEDIA) {
781 audioDeviceDescriptors.push_back(make_shared<AudioDeviceDescriptor>(dev));
782 }
783 break;
784 case CALL_OUTPUT_DEVICES:
785 if ((static_cast<uint32_t>(dev->deviceRole_) & OUTPUT_DEVICE) &&
786 (static_cast<uint32_t>(deviceInfo.deviceUsage) & VOICE)) {
787 audioDeviceDescriptors.push_back(make_shared<AudioDeviceDescriptor>(dev));
788 }
789 break;
790 case CALL_INPUT_DEVICES:
791 if ((static_cast<uint32_t>(dev->deviceRole_) & INPUT_DEVICE) &&
792 (static_cast<uint32_t>(deviceInfo.deviceUsage) & VOICE)) {
793 audioDeviceDescriptors.push_back(make_shared<AudioDeviceDescriptor>(dev));
794 }
795 break;
796 case ALL_CALL_DEVICES:
797 if (static_cast<uint32_t>(deviceInfo.deviceUsage) & VOICE) {
798 audioDeviceDescriptors.push_back(make_shared<AudioDeviceDescriptor>(dev));
799 }
800 break;
801 default:
802 break;
803 }
804 }
805
IsExistedDevice(const std::shared_ptr<AudioDeviceDescriptor> & device,const vector<shared_ptr<AudioDeviceDescriptor>> & audioDeviceDescriptors)806 bool AudioDeviceManager::IsExistedDevice(const std::shared_ptr<AudioDeviceDescriptor> &device,
807 const vector<shared_ptr<AudioDeviceDescriptor>> &audioDeviceDescriptors)
808 {
809 bool isExistedDev = false;
810 for (const auto &dev : audioDeviceDescriptors) {
811 if (device->deviceType_ == dev->deviceType_ &&
812 device->networkId_ == dev->networkId_ &&
813 device->deviceRole_ == dev->deviceRole_ &&
814 device->macAddress_ == dev->macAddress_) {
815 isExistedDev = true;
816 }
817 }
818 return isExistedDev;
819 }
820
GetAvailableDevicesWithUsage(const AudioDeviceUsage usage,const list<DevicePrivacyInfo> & deviceInfos,const std::shared_ptr<AudioDeviceDescriptor> & dev,vector<shared_ptr<AudioDeviceDescriptor>> & audioDeviceDescriptors)821 void AudioDeviceManager::GetAvailableDevicesWithUsage(const AudioDeviceUsage usage,
822 const list<DevicePrivacyInfo> &deviceInfos, const std::shared_ptr<AudioDeviceDescriptor> &dev,
823 vector<shared_ptr<AudioDeviceDescriptor>> &audioDeviceDescriptors)
824 {
825 for (auto &deviceInfo : deviceInfos) {
826 CHECK_AND_BREAK_LOG(dev != nullptr, "dev is nullptr");
827 if (dev->deviceType_ != deviceInfo.deviceType ||
828 IsExistedDevice(dev, audioDeviceDescriptors)) {
829 continue;
830 }
831 AddAvailableDevicesByUsage(usage, deviceInfo, dev, audioDeviceDescriptors);
832 }
833 }
834
GetDefaultAvailableDevicesByUsage(AudioDeviceUsage usage,vector<shared_ptr<AudioDeviceDescriptor>> & audioDeviceDescriptors)835 void AudioDeviceManager::GetDefaultAvailableDevicesByUsage(AudioDeviceUsage usage,
836 vector<shared_ptr<AudioDeviceDescriptor>> &audioDeviceDescriptors)
837 {
838 if (((usage & MEDIA_OUTPUT_DEVICES) != 0) || ((usage & CALL_OUTPUT_DEVICES) != 0)) {
839 if (speaker_ != nullptr) {
840 audioDeviceDescriptors.push_back(make_shared<AudioDeviceDescriptor>(speaker_));
841 }
842 for (const auto &desc : connectedDevices_) {
843 if (desc->deviceType_ == DEVICE_TYPE_SPEAKER && desc->networkId_ != LOCAL_NETWORK_ID) {
844 audioDeviceDescriptors.push_back(make_shared<AudioDeviceDescriptor>(*desc));
845 }
846 }
847 }
848
849 if (((usage & MEDIA_INPUT_DEVICES) != 0) || ((usage & CALL_INPUT_DEVICES) != 0)) {
850 if (defalutMic_ != nullptr) {
851 audioDeviceDescriptors.push_back(make_shared<AudioDeviceDescriptor>(defalutMic_));
852 }
853 for (const auto &desc : connectedDevices_) {
854 if (desc->deviceType_ == DEVICE_TYPE_MIC && desc->networkId_ != LOCAL_NETWORK_ID) {
855 audioDeviceDescriptors.push_back(make_shared<AudioDeviceDescriptor>(*desc));
856 }
857 }
858 }
859
860 if ((usage & CALL_OUTPUT_DEVICES) != 0) {
861 if (earpiece_ != nullptr) {
862 audioDeviceDescriptors.push_back(make_shared<AudioDeviceDescriptor>(earpiece_));
863 }
864 for (const auto &desc : connectedDevices_) {
865 if (desc->deviceType_ == DEVICE_TYPE_EARPIECE && desc->networkId_ != LOCAL_NETWORK_ID) {
866 audioDeviceDescriptors.push_back(make_shared<AudioDeviceDescriptor>(*desc));
867 }
868 }
869 }
870 }
871
872 // GetRemoteAvailableDevicesByUsage must be called with AudioDeviceManager::currentActiveDevicesMutex_lock
GetRemoteAvailableDevicesByUsage(AudioDeviceUsage usage,std::vector<std::shared_ptr<AudioDeviceDescriptor>> & audioDeviceDescriptor)873 void AudioDeviceManager::GetRemoteAvailableDevicesByUsage(AudioDeviceUsage usage,
874 std::vector<std::shared_ptr<AudioDeviceDescriptor>> &audioDeviceDescriptor)
875 {
876 if ((usage & MEDIA_OUTPUT_DEVICES) != 0) {
877 for (const auto &desc : connectedDevices_) {
878 if (desc->deviceType_ == DEVICE_TYPE_REMOTE_CAST && desc->networkId_ == LOCAL_NETWORK_ID) {
879 audioDeviceDescriptor.push_back(make_shared<AudioDeviceDescriptor>(*desc));
880 }
881 }
882 }
883 }
884
GetDeviceVolumeBehavior(const std::string & networkId,DeviceType deviceType)885 VolumeBehavior AudioDeviceManager::GetDeviceVolumeBehavior(const std::string &networkId, DeviceType deviceType)
886 {
887 AUDIO_INFO_LOG("GetDeviceVolumeBehavior: networkId [%{public}s], deviceType [%{public}d]",
888 networkId.c_str(), deviceType);
889 VolumeBehavior volumeBehavior;
890 for (auto &desc : connectedDevices_) {
891 if (desc->deviceType_ != deviceType || desc->networkId_ != networkId) {
892 continue;
893 }
894 // Find the target device.
895 if (desc->volumeBehavior_.isReady) {
896 volumeBehavior.isReady = true;
897 volumeBehavior.isVolumeControlDisabled = desc->volumeBehavior_.isVolumeControlDisabled;
898 volumeBehavior.databaseVolumeName = desc->volumeBehavior_.databaseVolumeName;
899 AUDIO_INFO_LOG("isVolumeControlDisabled [%{public}d], databaseVolumeName [%{public}s]",
900 volumeBehavior.isVolumeControlDisabled, volumeBehavior.databaseVolumeName.c_str());
901 } else {
902 AUDIO_WARNING_LOG("The target device is found. But the isReady is false!");
903 }
904 }
905 return volumeBehavior;
906 }
907
SetDeviceVolumeBehavior(const std::string & networkId,DeviceType deviceType,VolumeBehavior volumeBehavior)908 int32_t AudioDeviceManager::SetDeviceVolumeBehavior(const std::string &networkId, DeviceType deviceType,
909 VolumeBehavior volumeBehavior)
910 {
911 AUDIO_INFO_LOG("SetDeviceVolumeBehavior: networkId [%{public}s], deviceType [%{public}d]",
912 networkId.c_str(), deviceType);
913 remoteInfoNetworkId_ = networkId;
914 remoteInfoDeviceType_ = deviceType;
915 for (auto &desc : connectedDevices_) {
916 if (desc->deviceType_ != remoteInfoDeviceType_ || desc->networkId_ != remoteInfoNetworkId_) {
917 continue;
918 }
919 // Find the target device.
920 desc->volumeBehavior_.isReady = true;
921 desc->volumeBehavior_.isVolumeControlDisabled = volumeBehavior.isVolumeControlDisabled;
922 desc->volumeBehavior_.databaseVolumeName = volumeBehavior.databaseVolumeName;
923 AUDIO_INFO_LOG("isVolumeControlDisabled [%{public}d], databaseVolumeName [%{public}s]",
924 volumeBehavior.isVolumeControlDisabled, volumeBehavior.databaseVolumeName.c_str());
925 }
926 return SUCCESS;
927 }
928
GetAvailableDevicesByUsage(AudioDeviceUsage usage)929 std::vector<shared_ptr<AudioDeviceDescriptor>> AudioDeviceManager::GetAvailableDevicesByUsage(AudioDeviceUsage usage)
930 {
931 std::lock_guard<std::mutex> currentActiveDevicesLock(currentActiveDevicesMutex_);
932 std::vector<shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptors;
933 GetDefaultAvailableDevicesByUsage(usage, audioDeviceDescriptors);
934 GetRemoteAvailableDevicesByUsage(usage, audioDeviceDescriptors);
935 for (const auto &dev : connectedDevices_) {
936 if (dev == nullptr) {
937 AUDIO_INFO_LOG("dev is null from connectedDevices_");
938 continue;
939 }
940 for (const auto &devicePrivacy : devicePrivacyMaps_) {
941 list<DevicePrivacyInfo> deviceInfos = devicePrivacy.second;
942 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>(*dev);
943 GetAvailableDevicesWithUsage(usage, deviceInfos, desc, audioDeviceDescriptors);
944 }
945 }
946 // If there are distributed devices, place them at a higher priority in the sorting order.
947 if (remoteInfoNetworkId_ != "" && remoteInfoDeviceType_ != DEVICE_TYPE_DEFAULT) {
948 ReorderAudioDevices(audioDeviceDescriptors, remoteInfoNetworkId_, remoteInfoDeviceType_);
949 }
950 return audioDeviceDescriptors;
951 }
952
ReorderAudioDevices(std::vector<std::shared_ptr<AudioDeviceDescriptor>> & audioDeviceDescriptors,const std::string & remoteInfoNetworkId,DeviceType remoteInfoDeviceType)953 void AudioDeviceManager::ReorderAudioDevices(
954 std::vector<std::shared_ptr<AudioDeviceDescriptor>> &audioDeviceDescriptors,
955 const std::string &remoteInfoNetworkId, DeviceType remoteInfoDeviceType)
956 {
957 std::vector<std::shared_ptr<AudioDeviceDescriptor>> nonLocalSpeakerDevices;
958 for (auto &desc : audioDeviceDescriptors) {
959 if (desc->deviceType_ == DEVICE_TYPE_SPEAKER && desc->networkId_ != LOCAL_NETWORK_ID) {
960 nonLocalSpeakerDevices.push_back(std::move(desc));
961 }
962 }
963 audioDeviceDescriptors.erase(std::remove_if(audioDeviceDescriptors.begin(), audioDeviceDescriptors.end(),
964 [](const auto &device) {return device == nullptr;}), audioDeviceDescriptors.end());
965 std::sort(nonLocalSpeakerDevices.begin(), nonLocalSpeakerDevices.end(),
966 [](const auto &a, const auto &b) {return a->deviceId_ < b->deviceId_;});
967 audioDeviceDescriptors.insert(audioDeviceDescriptors.end(),
968 std::make_move_iterator(nonLocalSpeakerDevices.begin()),
969 std::make_move_iterator(nonLocalSpeakerDevices.end()));
970
971 if (remoteInfoNetworkId != "" && remoteInfoDeviceType == DEVICE_TYPE_REMOTE_CAST) {
972 std::vector<std::shared_ptr<AudioDeviceDescriptor>> remoteCastDevices;
973 for (auto &desc : audioDeviceDescriptors) {
974 if (desc->deviceType_ == DEVICE_TYPE_REMOTE_CAST) {
975 remoteCastDevices.push_back(std::move(desc));
976 }
977 }
978 audioDeviceDescriptors.erase(std::remove_if(audioDeviceDescriptors.begin(), audioDeviceDescriptors.end(),
979 [](const auto &device) {return device == nullptr;}), audioDeviceDescriptors.end());
980 std::sort(remoteCastDevices.begin(), remoteCastDevices.end(),
981 [](const auto &a, const auto &b) {return a->deviceId_ < b->deviceId_;});
982
983 audioDeviceDescriptors.insert(audioDeviceDescriptors.end(),
984 std::make_move_iterator(remoteCastDevices.begin()),
985 std::make_move_iterator(remoteCastDevices.end()));
986 }
987 }
988
GetDevicePrivacyMaps()989 unordered_map<AudioDevicePrivacyType, list<DevicePrivacyInfo>> AudioDeviceManager::GetDevicePrivacyMaps()
990 {
991 return devicePrivacyMaps_;
992 }
993
GetAvailableBluetoothDevice(DeviceType devType,const std::string & macAddress)994 std::vector<shared_ptr<AudioDeviceDescriptor>> AudioDeviceManager::GetAvailableBluetoothDevice(DeviceType devType,
995 const std::string &macAddress)
996 {
997 std::vector<shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptors;
998
999 std::lock_guard<std::mutex> currentActiveDevicesLock(currentActiveDevicesMutex_);
1000 for (const auto &desc : connectedDevices_) {
1001 if (desc->deviceType_ == devType && desc->macAddress_ == macAddress) {
1002 audioDeviceDescriptors.push_back(make_shared<AudioDeviceDescriptor>(*desc));
1003 }
1004 }
1005 return audioDeviceDescriptors;
1006 }
1007
GetScoState()1008 bool AudioDeviceManager::GetScoState()
1009 {
1010 std::lock_guard<std::mutex> currentActiveDevicesLock(currentActiveDevicesMutex_);
1011 bool isScoStateConnect = Bluetooth::AudioHfpManager::IsAudioScoStateConnect();
1012 for (const auto &desc : connectedDevices_) {
1013 CHECK_AND_CONTINUE_LOG(desc != nullptr, "Device is nullptr, continue");
1014 if (desc->deviceType_ == DEVICE_TYPE_BLUETOOTH_SCO && desc->connectState_ == CONNECTED &&
1015 isScoStateConnect) {
1016 return true;
1017 }
1018 }
1019 return false;
1020 }
1021
UpdateDevicesListInfo(const std::shared_ptr<AudioDeviceDescriptor> & devDesc,const DeviceInfoUpdateCommand updateCommand)1022 AudioStreamDeviceChangeReasonExt AudioDeviceManager::UpdateDevicesListInfo(
1023 const std::shared_ptr<AudioDeviceDescriptor> &devDesc, const DeviceInfoUpdateCommand updateCommand)
1024 {
1025 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
1026 CHECK_AND_RETURN_RET_LOG(devDesc != nullptr, reason, "desc is nullptr");
1027
1028 bool ret = false;
1029 std::lock_guard<std::mutex> currentActiveDevicesLock(currentActiveDevicesMutex_);
1030 switch (updateCommand) {
1031 case CATEGORY_UPDATE:
1032 ret = UpdateDeviceCategory(devDesc);
1033 break;
1034 case CONNECTSTATE_UPDATE:
1035 ret = UpdateConnectState(devDesc);
1036 break;
1037 case ENABLE_UPDATE:
1038 ret = UpdateEnableState(devDesc);
1039 break;
1040 case EXCEPTION_FLAG_UPDATE:
1041 ret = UpdateExceptionFlag(devDesc);
1042 break;
1043 case USAGE_UPDATE:
1044 reason = UpdateDeviceUsage(devDesc);
1045 break;
1046 default:
1047 break;
1048 }
1049 if (!ret) {
1050 int32_t audioId = devDesc->deviceId_;
1051 AUDIO_ERR_LOG("cant update type:id %{public}d:%{public}d mac:%{public}s networkid:%{public}s in connected list",
1052 devDesc->deviceType_, audioId, GetEncryptStr(devDesc->macAddress_).c_str(),
1053 GetEncryptStr(devDesc->networkId_).c_str());
1054 }
1055 return reason;
1056 }
1057
UpdateDeviceCategory(const std::shared_ptr<AudioDeviceDescriptor> & devDesc)1058 bool AudioDeviceManager::UpdateDeviceCategory(const std::shared_ptr<AudioDeviceDescriptor> &devDesc)
1059 {
1060 bool updateFlag = false;
1061
1062 for (auto &desc : connectedDevices_) {
1063 if (desc->deviceType_ == devDesc->deviceType_ &&
1064 desc->networkId_ == devDesc->networkId_ &&
1065 desc->macAddress_ == devDesc->macAddress_ &&
1066 desc->deviceCategory_ != devDesc->deviceCategory_) {
1067 desc->deviceCategory_ = devDesc->deviceCategory_;
1068 if (devDesc->deviceCategory_ == BT_UNWEAR_HEADPHONE) {
1069 RemoveBtFromOtherList(devDesc);
1070 } else {
1071 // Update connectTimeStamp_ when wearing headphones that support wear detection
1072 desc->connectTimeStamp_ = GetCurrentTimeMS();
1073 AddBtToOtherList(desc);
1074 }
1075 }
1076 updateFlag = true;
1077 }
1078 return updateFlag;
1079 }
1080
UpdateConnectState(const shared_ptr<AudioDeviceDescriptor> & devDesc)1081 bool AudioDeviceManager::UpdateConnectState(const shared_ptr<AudioDeviceDescriptor> &devDesc)
1082 {
1083 bool updateFlag = false;
1084 bool isScoDevice = devDesc->deviceType_ == DEVICE_TYPE_BLUETOOTH_SCO;
1085
1086 for (const auto &desc : connectedDevices_) {
1087 if (desc->networkId_ != devDesc->networkId_ ||
1088 desc->macAddress_ != devDesc->macAddress_) {
1089 continue;
1090 }
1091 if (desc->deviceType_ == devDesc->deviceType_) {
1092 desc->connectState_ = devDesc->connectState_;
1093 updateFlag = true;
1094 continue;
1095 }
1096 // a2dp connectState needs to be updated simultaneously when connectState of sco is updated
1097 if (isScoDevice) {
1098 if (desc->deviceType_ == DEVICE_TYPE_BLUETOOTH_A2DP &&
1099 desc->connectState_ != VIRTUAL_CONNECTED &&
1100 devDesc->connectState_ == CONNECTED) {
1101 // sco connected, suspend a2dp
1102 desc->connectState_ = SUSPEND_CONNECTED;
1103 updateFlag = true;
1104 AUDIO_WARNING_LOG("sco connectState is connected, update a2dp to suspend");
1105 } else if (desc->deviceType_ == DEVICE_TYPE_BLUETOOTH_A2DP &&
1106 desc->connectState_ == SUSPEND_CONNECTED &&
1107 (devDesc->connectState_ == DEACTIVE_CONNECTED || devDesc->connectState_ == SUSPEND_CONNECTED)) {
1108 // sco deactive or suspend, a2dp CONNECTED
1109 desc->connectState_ = CONNECTED;
1110 updateFlag = true;
1111 AUDIO_WARNING_LOG("sco connectState %{public}d, update a2dp to connected", devDesc->connectState_);
1112 }
1113 }
1114 }
1115 return updateFlag;
1116 }
1117
UpdateEnableState(const shared_ptr<AudioDeviceDescriptor> & devDesc)1118 bool AudioDeviceManager::UpdateEnableState(const shared_ptr<AudioDeviceDescriptor> &devDesc)
1119 {
1120 bool updateFlag = false;
1121 for (const auto &desc : connectedDevices_) {
1122 if (desc->deviceType_ == devDesc->deviceType_ &&
1123 desc->macAddress_ == devDesc->macAddress_ &&
1124 desc->networkId_ == devDesc->networkId_ &&
1125 desc->isEnable_ != devDesc->isEnable_) {
1126 desc->isEnable_ = devDesc->isEnable_;
1127 updateFlag = true;
1128 }
1129 }
1130 return updateFlag;
1131 }
1132
UpdateExceptionFlag(const shared_ptr<AudioDeviceDescriptor> & deviceDescriptor)1133 bool AudioDeviceManager::UpdateExceptionFlag(const shared_ptr<AudioDeviceDescriptor> &deviceDescriptor)
1134 {
1135 bool updateFlag = false;
1136 for (const auto &desc : connectedDevices_) {
1137 if (desc->deviceType_ == deviceDescriptor->deviceType_ &&
1138 desc->macAddress_ == deviceDescriptor->macAddress_ &&
1139 desc->networkId_ == deviceDescriptor->networkId_ &&
1140 desc->exceptionFlag_ != deviceDescriptor->exceptionFlag_) {
1141 desc->exceptionFlag_ = deviceDescriptor->exceptionFlag_;
1142 updateFlag = true;
1143 }
1144 }
1145 return updateFlag;
1146 }
1147
UpdateDeviceUsage(const shared_ptr<AudioDeviceDescriptor> & deviceDesc)1148 AudioStreamDeviceChangeReasonExt AudioDeviceManager::UpdateDeviceUsage(
1149 const shared_ptr<AudioDeviceDescriptor> &deviceDesc)
1150 {
1151 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
1152 CHECK_AND_RETURN_RET_LOG(deviceDesc != nullptr, reason, "device is nullptr");
1153 bool updateFlag = false;
1154 for (const auto &desc : connectedDevices_) {
1155 CHECK_AND_CONTINUE(desc != nullptr);
1156 if (desc->deviceType_ == deviceDesc->deviceType_ &&
1157 desc->macAddress_ == deviceDesc->macAddress_ &&
1158 desc->networkId_ == deviceDesc->networkId_ &&
1159 desc->deviceUsage_ != deviceDesc->deviceUsage_) {
1160 reason = (desc->deviceUsage_ > deviceDesc->deviceUsage_) ?
1161 AudioStreamDeviceChangeReason::OLD_DEVICE_UNAVALIABLE :
1162 AudioStreamDeviceChangeReason::NEW_DEVICE_AVAILABLE;
1163 desc->deviceUsage_ = deviceDesc->deviceUsage_;
1164 updateFlag = true;
1165 }
1166 }
1167 CHECK_AND_RETURN_RET_LOG(updateFlag == true, reason, "Update usage fails");
1168 return reason;
1169 }
1170
UpdateEarpieceStatus(const bool hasEarPiece)1171 void AudioDeviceManager::UpdateEarpieceStatus(const bool hasEarPiece)
1172 {
1173 hasEarpiece_ = hasEarPiece;
1174 }
1175
AddBtToOtherList(const shared_ptr<AudioDeviceDescriptor> & devDesc)1176 void AudioDeviceManager::AddBtToOtherList(const shared_ptr<AudioDeviceDescriptor> &devDesc)
1177 {
1178 if (devDesc->networkId_ != LOCAL_NETWORK_ID) {
1179 AddRemoteRenderDev(devDesc);
1180 AddRemoteCaptureDev(devDesc);
1181 } else {
1182 HandleScoWithDefaultCategory(devDesc);
1183 AddCommunicationDevices(devDesc);
1184 AddMediaDevices(devDesc);
1185 AddCaptureDevices(devDesc);
1186 }
1187 }
1188
RemoveBtFromOtherList(const AudioDeviceDescriptor & devDesc)1189 void AudioDeviceManager::RemoveBtFromOtherList(const AudioDeviceDescriptor &devDesc)
1190 {
1191 if (devDesc.networkId_ != LOCAL_NETWORK_ID) {
1192 RemoveRemoteDevices(devDesc);
1193 } else {
1194 RemoveCommunicationDevices(devDesc);
1195 RemoveMediaDevices(devDesc);
1196 RemoveCaptureDevices(devDesc);
1197 }
1198 }
1199
RemoveRemoteDevices(const AudioDeviceDescriptor & devDesc)1200 void AudioDeviceManager::RemoveRemoteDevices(const AudioDeviceDescriptor &devDesc)
1201 {
1202 RemoveMatchDeviceInArray(devDesc, "remote render device", remoteRenderDevices_);
1203 RemoveMatchDeviceInArray(devDesc, "remote capture device", remoteCaptureDevices_);
1204 }
1205
RemoveCommunicationDevices(const AudioDeviceDescriptor & devDesc)1206 void AudioDeviceManager::RemoveCommunicationDevices(const AudioDeviceDescriptor &devDesc)
1207 {
1208 RemoveMatchDeviceInArray(devDesc, "communication render privacy device", commRenderPrivacyDevices_);
1209 RemoveMatchDeviceInArray(devDesc, "communication render public device", commRenderPublicDevices_);
1210 RemoveMatchDeviceInArray(devDesc, "communication capture privacy device", commCapturePrivacyDevices_);
1211 RemoveMatchDeviceInArray(devDesc, "communication capture public device", commCapturePublicDevices_);
1212 }
1213
RemoveMediaDevices(const AudioDeviceDescriptor & devDesc)1214 void AudioDeviceManager::RemoveMediaDevices(const AudioDeviceDescriptor &devDesc)
1215 {
1216 RemoveMatchDeviceInArray(devDesc, "media render privacy device", mediaRenderPrivacyDevices_);
1217 RemoveMatchDeviceInArray(devDesc, "media render public device", mediaRenderPublicDevices_);
1218 RemoveMatchDeviceInArray(devDesc, "media capture privacy device", mediaCapturePrivacyDevices_);
1219 RemoveMatchDeviceInArray(devDesc, "media capture public device", mediaCapturePublicDevices_);
1220 }
1221
RemoveCaptureDevices(const AudioDeviceDescriptor & devDesc)1222 void AudioDeviceManager::RemoveCaptureDevices(const AudioDeviceDescriptor &devDesc)
1223 {
1224 RemoveMatchDeviceInArray(devDesc, "capture privacy device", capturePrivacyDevices_);
1225 RemoveMatchDeviceInArray(devDesc, "capture public device", capturePublicDevices_);
1226 RemoveMatchDeviceInArray(devDesc, "capture recognition privacy device", reconCapturePrivacyDevices_);
1227 }
1228
GetDevicesByFilter(DeviceType devType,DeviceRole devRole,const string & macAddress,const string & networkId,ConnectState connectState)1229 vector<shared_ptr<AudioDeviceDescriptor>> AudioDeviceManager::GetDevicesByFilter(DeviceType devType, DeviceRole devRole,
1230 const string &macAddress, const string &networkId, ConnectState connectState)
1231 {
1232 std::lock_guard<std::mutex> currentActiveDevicesLock(currentActiveDevicesMutex_);
1233 vector<shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptors;
1234 for (const auto &desc : connectedDevices_) {
1235 if ((devType == DEVICE_TYPE_NONE || devType == desc->deviceType_) &&
1236 (devRole == DEVICE_ROLE_NONE || devRole == desc->deviceRole_) &&
1237 (macAddress == "" || macAddress == desc->macAddress_) &&
1238 (networkId == "" || networkId == desc->networkId_) && (connectState == desc->connectState_)) {
1239 audioDeviceDescriptors.push_back(desc);
1240 }
1241 }
1242 AUDIO_DEBUG_LOG("Filter device size %{public}zu", audioDeviceDescriptors.size());
1243 return audioDeviceDescriptors;
1244 }
1245
GetDeviceUsage(const AudioDeviceDescriptor & desc)1246 DeviceUsage AudioDeviceManager::GetDeviceUsage(const AudioDeviceDescriptor &desc)
1247 {
1248 AUDIO_DEBUG_LOG("device type [%{public}d] category [%{public}d]", desc.deviceType_, desc.deviceCategory_);
1249 DeviceUsage usage = MEDIA;
1250 for (auto &devInfo : privacyDeviceList_) {
1251 if ((devInfo.deviceType == desc.deviceType_) &&
1252 ((devInfo.deviceCategory & desc.deviceCategory_) || devInfo.deviceCategory == 0)) {
1253 return devInfo.deviceUsage;
1254 }
1255 }
1256
1257 for (auto &devInfo : publicDeviceList_) {
1258 if ((devInfo.deviceType == desc.deviceType_) &&
1259 ((devInfo.deviceCategory & desc.deviceCategory_) || devInfo.deviceCategory == 0)) {
1260 return devInfo.deviceUsage;
1261 }
1262 }
1263
1264 if (DEVICE_TYPE_BLUETOOTH_A2DP == desc.deviceType_) {
1265 usage = MEDIA;
1266 }
1267
1268 if (DEVICE_TYPE_BLUETOOTH_SCO == desc.deviceType_) {
1269 usage = VOICE;
1270 }
1271
1272 return usage;
1273 }
1274
OnReceiveBluetoothEvent(const std::string macAddress,const std::string deviceName)1275 void AudioDeviceManager::OnReceiveBluetoothEvent(const std::string macAddress, const std::string deviceName)
1276 {
1277 std::lock_guard<std::mutex> currentActiveDevicesLock(currentActiveDevicesMutex_);
1278 for (auto device : connectedDevices_) {
1279 if (device->macAddress_ == macAddress) {
1280 device->deviceName_ = deviceName;
1281 }
1282 }
1283 }
1284
IsDeviceConnected(std::shared_ptr<AudioDeviceDescriptor> & audioDeviceDescriptors)1285 bool AudioDeviceManager::IsDeviceConnected(std::shared_ptr<AudioDeviceDescriptor> &audioDeviceDescriptors)
1286 {
1287 std::lock_guard<std::mutex> currentActiveDevicesLock(currentActiveDevicesMutex_);
1288 size_t connectedDevicesNum = connectedDevices_.size();
1289 for (size_t i = 0; i < connectedDevicesNum; i++) {
1290 if (connectedDevices_[i] != nullptr) {
1291 if (connectedDevices_[i]->deviceRole_ == audioDeviceDescriptors->deviceRole_
1292 && connectedDevices_[i]->deviceType_ == audioDeviceDescriptors->deviceType_
1293 && connectedDevices_[i]->networkId_ == audioDeviceDescriptors->networkId_
1294 && connectedDevices_[i]->macAddress_ == audioDeviceDescriptors->macAddress_
1295 && connectedDevices_[i]->volumeGroupId_ == audioDeviceDescriptors->volumeGroupId_) {
1296 return true;
1297 }
1298 }
1299 }
1300 AUDIO_WARNING_LOG("Role:%{public}d networkId:%{public}s Type:%{public}d macAddress:%{public}s device not found",
1301 audioDeviceDescriptors->deviceRole_, GetEncryptStr(audioDeviceDescriptors->networkId_).c_str(),
1302 audioDeviceDescriptors->deviceType_, GetEncryptAddr(audioDeviceDescriptors->macAddress_).c_str());
1303 return false;
1304 }
1305
IsVirtualConnectedDevice(const std::shared_ptr<AudioDeviceDescriptor> & selectedDesc)1306 bool AudioDeviceManager::IsVirtualConnectedDevice(const std::shared_ptr<AudioDeviceDescriptor> &selectedDesc)
1307 {
1308 CHECK_AND_RETURN_RET_LOG(selectedDesc != nullptr, false, "Invalid device descriptor");
1309 auto isVirtual = [&selectedDesc](const shared_ptr<AudioDeviceDescriptor>& desc) {
1310 return desc->connectState_ == VIRTUAL_CONNECTED
1311 && desc->deviceRole_ == selectedDesc->deviceRole_
1312 && desc->deviceType_ == selectedDesc->deviceType_
1313 && desc->networkId_ == selectedDesc->networkId_
1314 && desc->macAddress_ == selectedDesc->macAddress_;
1315 };
1316 bool isVirtualDevice = false;
1317 auto itr = std::find_if(connectedDevices_.begin(), connectedDevices_.end(), isVirtual);
1318 if (itr != connectedDevices_.end()) {
1319 isVirtualDevice = true;
1320 AUDIO_INFO_LOG("Device[%{public}s] is virtual connection",
1321 GetEncryptAddr(selectedDesc->macAddress_).c_str());
1322 }
1323 return isVirtualDevice;
1324 }
1325
UpdateDeviceDescDeviceId(std::shared_ptr<AudioDeviceDescriptor> & deviceDescriptor)1326 int32_t AudioDeviceManager::UpdateDeviceDescDeviceId(std::shared_ptr<AudioDeviceDescriptor> &deviceDescriptor)
1327 {
1328 CHECK_AND_RETURN_RET_LOG(deviceDescriptor != nullptr, ERROR, "Invalid device descriptor");
1329 auto isPresent = [&deviceDescriptor](const shared_ptr<AudioDeviceDescriptor> &desc) {
1330 return desc->deviceRole_ == deviceDescriptor->deviceRole_
1331 && desc->deviceType_ == deviceDescriptor->deviceType_
1332 && desc->networkId_ == deviceDescriptor->networkId_
1333 && desc->macAddress_ == deviceDescriptor->macAddress_;
1334 };
1335 auto itr = std::find_if(connectedDevices_.begin(), connectedDevices_.end(), isPresent);
1336 CHECK_AND_RETURN_RET_LOG(itr != connectedDevices_.end(), ERROR, "Device not found");
1337 deviceDescriptor->deviceId_ = (*itr)->deviceId_;
1338 return SUCCESS;
1339 }
1340
SetDefaultOutputDevice(const DeviceType deviceType,const uint32_t sessionID,const StreamUsage streamUsage,bool isRunning)1341 int32_t AudioDeviceManager::SetDefaultOutputDevice(const DeviceType deviceType, const uint32_t sessionID,
1342 const StreamUsage streamUsage, bool isRunning)
1343 {
1344 std::lock_guard<std::mutex> lock(selectDefaultOutputDeviceMutex_);
1345 selectedDefaultOutputDeviceInfo_[sessionID] = std::make_pair(deviceType, streamUsage);
1346 AUDIO_INFO_LOG("stream %{public}u with usage %{public}d selects output device %{public}d",
1347 sessionID, streamUsage, deviceType);
1348 if (!isRunning) {
1349 AUDIO_WARNING_LOG("current stream has not started");
1350 return SUCCESS;
1351 }
1352 if (streamUsage == STREAM_USAGE_VOICE_MESSAGE) {
1353 // select media default output device
1354 auto it = std::find_if(mediaDefaultOutputDevices_.begin(), mediaDefaultOutputDevices_.end(),
1355 [&sessionID](const std::pair<uint32_t, DeviceType> &mediaDefaultOutputDevice) {
1356 return mediaDefaultOutputDevice.first == sessionID;
1357 });
1358 if (it != mediaDefaultOutputDevices_.end()) {
1359 mediaDefaultOutputDevices_.erase(it);
1360 }
1361 mediaDefaultOutputDevices_.push_back(std::make_pair(sessionID, deviceType));
1362 if (selectedMediaDefaultOutputDevice_ != deviceType) {
1363 AUDIO_WARNING_LOG("media default output device changes from %{public}d to %{public}d",
1364 selectedMediaDefaultOutputDevice_, deviceType);
1365 selectedMediaDefaultOutputDevice_ = deviceType;
1366 return NEED_TO_FETCH;
1367 }
1368 } else if (streamUsage == STREAM_USAGE_VOICE_COMMUNICATION || streamUsage == STREAM_USAGE_VIDEO_COMMUNICATION ||
1369 streamUsage == STREAM_USAGE_VOICE_MODEM_COMMUNICATION) {
1370 // select call default output device
1371 auto it = std::find_if(callDefaultOutputDevices_.begin(), callDefaultOutputDevices_.end(),
1372 [&sessionID](const std::pair<uint32_t, DeviceType> &callDefaultOutputDevice) {
1373 return callDefaultOutputDevice.first == sessionID;
1374 });
1375 if (it != callDefaultOutputDevices_.end()) {
1376 callDefaultOutputDevices_.erase(it);
1377 }
1378 callDefaultOutputDevices_.push_back(std::make_pair(sessionID, deviceType));
1379 if (selectedCallDefaultOutputDevice_ != deviceType) {
1380 AUDIO_WARNING_LOG("call default output device changes from %{public}d to %{public}d",
1381 selectedCallDefaultOutputDevice_, deviceType);
1382 selectedCallDefaultOutputDevice_ = deviceType;
1383 return NEED_TO_FETCH;
1384 }
1385 } else {
1386 AUDIO_ERR_LOG("Invalid stream usage %{public}d", streamUsage);
1387 return ERROR;
1388 }
1389 return SUCCESS;
1390 }
1391
UpdateDefaultOutputDeviceWhenStarting(const uint32_t sessionID)1392 int32_t AudioDeviceManager::UpdateDefaultOutputDeviceWhenStarting(const uint32_t sessionID)
1393 {
1394 std::lock_guard<std::mutex> lock(selectDefaultOutputDeviceMutex_);
1395 if (!selectedDefaultOutputDeviceInfo_.count(sessionID)) {
1396 AUDIO_WARNING_LOG("no need to update default output device since current stream has not set");
1397 return SUCCESS;
1398 }
1399 DeviceType deviceType = selectedDefaultOutputDeviceInfo_[sessionID].first;
1400 StreamUsage streamUsage = selectedDefaultOutputDeviceInfo_[sessionID].second;
1401 if (streamUsage == STREAM_USAGE_VOICE_MESSAGE) {
1402 // select media default output device
1403 auto it = std::find_if(mediaDefaultOutputDevices_.begin(), mediaDefaultOutputDevices_.end(),
1404 [&sessionID](const std::pair<uint32_t, DeviceType> &mediaDefaultOutputDevice) {
1405 return mediaDefaultOutputDevice.first == sessionID;
1406 });
1407 if (it != mediaDefaultOutputDevices_.end()) {
1408 mediaDefaultOutputDevices_.erase(it);
1409 }
1410 mediaDefaultOutputDevices_.push_back(std::make_pair(sessionID, deviceType));
1411 AUDIO_WARNING_LOG("changes from %{public}d to %{public}d because media stream %{public}u starts",
1412 selectedMediaDefaultOutputDevice_, deviceType, sessionID);
1413 selectedMediaDefaultOutputDevice_ = deviceType;
1414 } else if (streamUsage == STREAM_USAGE_VOICE_COMMUNICATION || streamUsage == STREAM_USAGE_VIDEO_COMMUNICATION ||
1415 streamUsage == STREAM_USAGE_VOICE_MODEM_COMMUNICATION) {
1416 // select call default output device
1417 auto it = std::find_if(callDefaultOutputDevices_.begin(), callDefaultOutputDevices_.end(),
1418 [&sessionID](const std::pair<uint32_t, DeviceType> &callDefaultOutputDevice) {
1419 return callDefaultOutputDevice.first == sessionID;
1420 });
1421 if (it != callDefaultOutputDevices_.end()) {
1422 callDefaultOutputDevices_.erase(it);
1423 }
1424 callDefaultOutputDevices_.push_back(std::make_pair(sessionID, deviceType));
1425 AUDIO_WARNING_LOG("changes from %{public}d to %{public}d because call stream %{public}u starts",
1426 selectedCallDefaultOutputDevice_, deviceType, sessionID);
1427 selectedCallDefaultOutputDevice_ = deviceType;
1428 }
1429 return SUCCESS;
1430 }
1431
UpdateDefaultOutputDeviceWhenStopping(const uint32_t sessionID)1432 int32_t AudioDeviceManager::UpdateDefaultOutputDeviceWhenStopping(const uint32_t sessionID)
1433 {
1434 std::lock_guard<std::mutex> lock(selectDefaultOutputDeviceMutex_);
1435 if (!selectedDefaultOutputDeviceInfo_.count(sessionID)) {
1436 return SUCCESS;
1437 }
1438 StreamUsage streamUsage = selectedDefaultOutputDeviceInfo_[sessionID].second;
1439 if (streamUsage == STREAM_USAGE_VOICE_MESSAGE) {
1440 // select media default output device
1441 auto it = std::find_if(mediaDefaultOutputDevices_.begin(), mediaDefaultOutputDevices_.end(),
1442 [&sessionID](const std::pair<uint32_t, DeviceType> &mediaDefaultOutputDevice) {
1443 return mediaDefaultOutputDevice.first == sessionID;
1444 });
1445 if (it == mediaDefaultOutputDevices_.end()) {
1446 return SUCCESS;
1447 }
1448 mediaDefaultOutputDevices_.erase(it);
1449 DeviceType currDeviceType;
1450 if (mediaDefaultOutputDevices_.empty()) {
1451 currDeviceType = DEVICE_TYPE_DEFAULT;
1452 } else {
1453 currDeviceType = mediaDefaultOutputDevices_.back().second;
1454 }
1455 AUDIO_WARNING_LOG("changes from %{public}d to %{public}d because media stream %{public}u stops",
1456 selectedMediaDefaultOutputDevice_, currDeviceType, sessionID);
1457 selectedMediaDefaultOutputDevice_ = currDeviceType;
1458 } else if (streamUsage == STREAM_USAGE_VOICE_COMMUNICATION || streamUsage == STREAM_USAGE_VIDEO_COMMUNICATION ||
1459 streamUsage == STREAM_USAGE_VOICE_MODEM_COMMUNICATION) {
1460 // select call default output device
1461 auto it = std::find_if(callDefaultOutputDevices_.begin(), callDefaultOutputDevices_.end(),
1462 [&sessionID](const std::pair<uint32_t, DeviceType> &callDefaultOutputDevice) {
1463 return callDefaultOutputDevice.first == sessionID;
1464 });
1465 if (it == callDefaultOutputDevices_.end()) {
1466 return SUCCESS;
1467 }
1468 callDefaultOutputDevices_.erase(it);
1469 DeviceType currDeviceType;
1470 if (callDefaultOutputDevices_.empty()) {
1471 currDeviceType = DEVICE_TYPE_DEFAULT;
1472 } else {
1473 currDeviceType = callDefaultOutputDevices_.back().second;
1474 }
1475 AUDIO_WARNING_LOG("changes from %{public}d to %{public}d because call stream %{public}u stops",
1476 selectedCallDefaultOutputDevice_, currDeviceType, sessionID);
1477 selectedCallDefaultOutputDevice_ = currDeviceType;
1478 }
1479 return SUCCESS;
1480 }
1481
RemoveSelectedDefaultOutputDevice(const uint32_t sessionID)1482 int32_t AudioDeviceManager::RemoveSelectedDefaultOutputDevice(const uint32_t sessionID)
1483 {
1484 std::lock_guard<std::mutex> lock(selectDefaultOutputDeviceMutex_);
1485 selectedDefaultOutputDeviceInfo_.erase(sessionID);
1486 return SUCCESS;
1487 }
1488
GetSelectedMediaRenderDevice()1489 shared_ptr<AudioDeviceDescriptor> AudioDeviceManager::GetSelectedMediaRenderDevice()
1490 {
1491 std::lock_guard<std::mutex> lock(selectDefaultOutputDeviceMutex_);
1492 shared_ptr<AudioDeviceDescriptor> devDesc = nullptr;
1493 if (selectedMediaDefaultOutputDevice_ == DEVICE_TYPE_EARPIECE) {
1494 devDesc = make_shared<AudioDeviceDescriptor>(earpiece_);
1495 } else if (selectedMediaDefaultOutputDevice_ == DEVICE_TYPE_SPEAKER) {
1496 devDesc = make_shared<AudioDeviceDescriptor>(speaker_);
1497 }
1498 return devDesc;
1499 }
1500
GetSelectedCallRenderDevice()1501 shared_ptr<AudioDeviceDescriptor> AudioDeviceManager::GetSelectedCallRenderDevice()
1502 {
1503 std::lock_guard<std::mutex> lock(selectDefaultOutputDeviceMutex_);
1504 shared_ptr<AudioDeviceDescriptor> devDesc = nullptr;
1505 if (selectedCallDefaultOutputDevice_ == DEVICE_TYPE_EARPIECE) {
1506 devDesc = make_shared<AudioDeviceDescriptor>(earpiece_);
1507 } else if (selectedCallDefaultOutputDevice_ == DEVICE_TYPE_SPEAKER) {
1508 devDesc = make_shared<AudioDeviceDescriptor>(speaker_);
1509 }
1510 return devDesc;
1511 }
1512
SetInputDevice(const DeviceType deviceType,const uint32_t sessionID,const SourceType sourceType,bool isRunning)1513 int32_t AudioDeviceManager::SetInputDevice(const DeviceType deviceType, const uint32_t sessionID,
1514 const SourceType sourceType, bool isRunning)
1515 {
1516 std::lock_guard<std::mutex> lock(selectInputDeviceMutex_);
1517 selectedInputDeviceInfo_[sessionID] = std::make_pair(deviceType, sourceType);
1518 AUDIO_INFO_LOG("stream %{public}u run %{public}d with usage %{public}d selects input device %{public}d",
1519 sessionID, isRunning, sourceType, deviceType);
1520 return NEED_TO_FETCH;
1521 }
1522
RemoveSelectedInputDevice(const uint32_t sessionID)1523 int32_t AudioDeviceManager::RemoveSelectedInputDevice(const uint32_t sessionID)
1524 {
1525 AUDIO_INFO_LOG("AudioDeviceManager::RemoveSelectedInputDevice %{public}d", sessionID);
1526 std::lock_guard<std::mutex> lock(selectInputDeviceMutex_);
1527 selectedInputDeviceInfo_.erase(sessionID);
1528 return SUCCESS;
1529 }
1530
GetSelectedCaptureDevice(const uint32_t sessionID)1531 shared_ptr<AudioDeviceDescriptor> AudioDeviceManager::GetSelectedCaptureDevice(const uint32_t sessionID)
1532 {
1533 shared_ptr<AudioDeviceDescriptor> devDesc = nullptr;
1534 if (sessionID == 0 || !selectedInputDeviceInfo_.count(sessionID)) {
1535 return devDesc;
1536 }
1537 for (const auto &desc : connectedDevices_) {
1538 if (desc->deviceType_ == selectedInputDeviceInfo_[sessionID].first) {
1539 AUDIO_WARNING_LOG("sessionid %{public}d has selected device", sessionID);
1540 return make_shared<AudioDeviceDescriptor>(*desc);
1541 }
1542 }
1543 return devDesc;
1544 }
1545
Dump(std::string & dumpString)1546 void AudioDeviceManager::Dump(std::string &dumpString)
1547 {
1548 std::lock_guard<std::mutex> lock(selectDefaultOutputDeviceMutex_);
1549 AppendFormat(dumpString, " MediaDefaultOutputDevices:\n");
1550 for (auto it : mediaDefaultOutputDevices_) {
1551 AppendFormat(dumpString, " sessionId: %u, device type: %s\n", it.first,
1552 AudioInfoDumpUtils::GetDeviceTypeName(it.second).c_str());
1553 }
1554 AppendFormat(dumpString, "current media default output device: %s\n",
1555 AudioInfoDumpUtils::GetDeviceTypeName(selectedMediaDefaultOutputDevice_).c_str());
1556
1557 AppendFormat(dumpString, " CallDefaultOutputDevices:\n");
1558 for (auto it : callDefaultOutputDevices_) {
1559 AppendFormat(dumpString, " sessionId: %u, device type: %s\n", it.first,
1560 AudioInfoDumpUtils::GetDeviceTypeName(it.second).c_str());
1561 }
1562 AppendFormat(dumpString, "current call default output device: %s\n",
1563 AudioInfoDumpUtils::GetDeviceTypeName(selectedCallDefaultOutputDevice_).c_str());
1564 }
1565
GetAllConnectedDeviceByType(std::string networkId,DeviceType deviceType,std::string macAddress,DeviceRole deviceRole,std::vector<std::shared_ptr<AudioDeviceDescriptor>> & descForCb)1566 void AudioDeviceManager::GetAllConnectedDeviceByType(std::string networkId, DeviceType deviceType,
1567 std::string macAddress, DeviceRole deviceRole, std::vector<std::shared_ptr<AudioDeviceDescriptor>> &descForCb)
1568 {
1569 auto isPresent =
1570 [&networkId, &deviceType, &macAddress, &deviceRole](const shared_ptr<AudioDeviceDescriptor> &desc) {
1571 return networkId == desc->networkId_ && deviceType == desc->deviceType_ &&
1572 macAddress == desc->macAddress_ && (!IsUsb(deviceType) || deviceRole == desc->deviceRole_);
1573 };
1574 auto it = find_if(connectedDevices_.begin(), connectedDevices_.end(), isPresent);
1575 while (it != connectedDevices_.end()) {
1576 descForCb.push_back(*it);
1577 it = find_if(std::next(it), connectedDevices_.end(), isPresent);
1578 }
1579 return;
1580 }
1581
IsSessionSetDefaultDevice(uint32_t sessionId)1582 bool AudioDeviceManager::IsSessionSetDefaultDevice(uint32_t sessionId)
1583 {
1584 std::lock_guard<std::mutex> lock(selectDefaultOutputDeviceMutex_);
1585 return selectedDefaultOutputDeviceInfo_.find(sessionId) != selectedDefaultOutputDeviceInfo_.end();
1586 }
1587
ExistsByType(DeviceType devType) const1588 bool AudioDeviceManager::ExistsByType(DeviceType devType) const
1589 {
1590 auto it = find_if(connectedDevices_.cbegin(), connectedDevices_.cend(), [devType](auto &item) {
1591 return item->deviceType_ == devType;
1592 });
1593 return it != connectedDevices_.cend();
1594 }
1595
ExistsByTypeAndAddress(DeviceType devType,const string & address) const1596 bool AudioDeviceManager::ExistsByTypeAndAddress(DeviceType devType, const string &address) const
1597 {
1598 auto it = find_if(connectedDevices_.cbegin(), connectedDevices_.cend(), [devType, &address](auto &item) {
1599 return item->deviceType_ == devType && item->macAddress_ == address;
1600 });
1601 return it != connectedDevices_.cend();
1602 }
1603
ExistSameRemoteDeviceByMacAddress(std::shared_ptr<AudioDeviceDescriptor> desc)1604 bool AudioDeviceManager::ExistSameRemoteDeviceByMacAddress(std::shared_ptr<AudioDeviceDescriptor> desc)
1605 {
1606 std::lock_guard<std::mutex> currentActiveDevicesLock(currentActiveDevicesMutex_);
1607 std::vector<shared_ptr<AudioDeviceDescriptor>> descs;
1608 GetDefaultAvailableDevicesByUsage(MEDIA_OUTPUT_DEVICES, descs);
1609 for (const auto &ds : descs) {
1610 CHECK_AND_CONTINUE(ds->networkId_ != LOCAL_NETWORK_ID && !ds->macAddress_.empty());
1611 if (ds->macAddress_ == desc->macAddress_) {
1612 AUDIO_INFO_LOG("same mac remote hicar exist, skip a2dp");
1613 return true;
1614 }
1615 }
1616 return false;
1617 }
1618 }
1619 }
1620