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