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