1 /*
2  * Copyright (C) 2021-2022 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 
16 #include "ble_adapter.h"
17 
18 #include <algorithm>
19 #include <chrono>
20 #include <condition_variable>
21 #include <map>
22 #include <mutex>
23 
24 #include "adapter_manager.h"
25 #include "base_observer_list.h"
26 #include "ble_feature.h"
27 #include "ble_utils.h"
28 #include "btm.h"
29 #include "btstack.h"
30 #include "class_creator.h"
31 #include "compat.h"
32 #include "interface_profile_gatt_client.h"
33 #include "interface_profile_manager.h"
34 #include "log.h"
35 #include "log_util.h"
36 #include "securec.h"
37 
38 namespace OHOS {
39 namespace bluetooth {
40 struct BleAdapter::impl {
41     class GattClientCallback : public IGattClientCallback {
42     public:
GattClientCallback(BleAdapter & bleAdapter)43         explicit GattClientCallback(BleAdapter &bleAdapter) : bleAdapter_(bleAdapter)
44         {}
~GattClientCallback()45         ~GattClientCallback()
46         {}
OnConnectionStateChanged(int state,int newState)47         void OnConnectionStateChanged(int state, int newState) override
48         {
49             LOG_DEBUG("%{public}s:%{public}d:%{public}s state:%{public}d", __FILE__, __LINE__, __FUNCTION__, newState);
50         }
51 
OnServicesChanged(const std::vector<Service> & services)52         void OnServicesChanged(const std::vector<Service> &services) override
53         {
54             LOG_DEBUG("%{public}s:%{public}d:%{public}s", __FILE__, __LINE__, __FUNCTION__);
55         }
56 
OnCharacteristicRead(int ret,const Characteristic & characteristic)57         void OnCharacteristicRead(int ret, const Characteristic &characteristic) override
58         {
59             LOG_DEBUG("%{public}s:%{public}d:%{public}s ret : %{public}d", __FILE__, __LINE__, __FUNCTION__, ret);
60             std::lock_guard<std::mutex> lock(bleAdapter_.pimpl->mutexRemoteName_);
61             if (GattStatus::GATT_SUCCESS == ret) {
62                 std::string name(characteristic.value_.get(), characteristic.value_.get() + characteristic.length_);
63                 bleAdapter_.pimpl->remoteDeviceName_ = name;
64                 bleAdapter_.pimpl->readCharacteristicFlag_ = true;
65             } else {
66                 bleAdapter_.pimpl->readCharacteristicFlag_ = false;
67             }
68             bleAdapter_.pimpl->cvfull_.notify_all();
69         }
70 
OnCharacteristicWrite(int ret,const Characteristic & characteristic)71         void OnCharacteristicWrite(int ret, const Characteristic &characteristic) override
72         {
73             LOG_DEBUG("%{public}s:%{public}d:%{public}s", __FILE__, __LINE__, __FUNCTION__);
74         }
75 
OnCharacteristicChanged(const Characteristic & characteristic)76         void OnCharacteristicChanged(const Characteristic &characteristic) override
77         {
78             LOG_DEBUG("%{public}s:%{public}d:%{public}s", __FILE__, __LINE__, __FUNCTION__);
79         }
80 
OnDescriptorRead(int ret,const Descriptor & descriptor)81         void OnDescriptorRead(int ret, const Descriptor &descriptor) override
82         {
83             LOG_DEBUG("%{public}s:%{public}d:%{public}s", __FILE__, __LINE__, __FUNCTION__);
84         }
85 
OnDescriptorWrite(int ret,const Descriptor & descriptor)86         void OnDescriptorWrite(int ret, const Descriptor &descriptor) override
87         {
88             LOG_DEBUG("%{public}s:%{public}d:%{public}s", __FILE__, __LINE__, __FUNCTION__);
89         }
90 
OnMtuChanged(int state,int mtu)91         void OnMtuChanged(int state, int mtu) override
92         {
93             LOG_DEBUG("%{public}s:%{public}d:%{public}s", __FILE__, __LINE__, __FUNCTION__);
94         }
95 
OnConnectionParameterChanged(int interval,int latency,int timeout,int status)96         void OnConnectionParameterChanged(int interval, int latency, int timeout, int status) override
97         {
98             LOG_DEBUG("%{public}s:%{public}d:%{public}s", __FILE__, __LINE__, __FUNCTION__);
99         }
100 
OnServicesDiscovered(int status)101         void OnServicesDiscovered(int status) override
102         {
103             LOG_DEBUG("%{public}s:%{public}d:%{public}s", __FILE__, __LINE__, __FUNCTION__);
104         }
105 
OnReadRemoteRssiValue(const RawAddress & addr,int rssi,int status)106         void OnReadRemoteRssiValue(const RawAddress &addr, int rssi, int status) override
107         {
108             LOG_DEBUG("%{public}s:%{public}d:%{public}s", __FILE__, __LINE__, __FUNCTION__);
109         }
110 
111     private:
112         BleAdapter &bleAdapter_;
113     };
114     impl(BleAdapter &bleAdapter);
115     impl(const impl &);
116     impl &operator=(const impl &);
117     ~impl();
118 
119     std::recursive_mutex syncMutex_ {};
120     std::unique_ptr<BaseObserverList<IAdapterBleObserver>> observer_ =
121         std::make_unique<BaseObserverList<IAdapterBleObserver>>();
122     std::unique_ptr<BaseObserverList<IBlePeripheralCallback>> blePeripheralCallback_ =
123         std::make_unique<BaseObserverList<IBlePeripheralCallback>>();
124 
125     std::mutex mutexRpa_ {};
126     std::mutex mutexAdvAdnScan_ {};
127     std::mutex mutexRemoteName_ {};
128     std::condition_variable cvfull_ {};
129 
130     std::unique_ptr<GattClientCallback> gattClientcallback_ {};
131     IProfileGattClient *gattClientService_ {};
132     std::string remoteDeviceName_ {};
133     std::recursive_mutex peerDevlistMutex_ {};
134     std::recursive_mutex bleAdvMutex_ {};
135     std::recursive_mutex bleCenMutex_ {};
136     std::map<std::string, BlePeripheralDevice> peerConnDeviceList_ {};
137     bool btmEnableFlag_ = false;
138     bool readCharacteristicFlag_ = false;
139 
140     std::unique_ptr<BleAdvertiserImpl> bleAdvertiser_ = nullptr;
141     std::unique_ptr<BleCentralManagerImpl> bleCentralManager_ = nullptr;
142     std::unique_ptr<BleSecurity> bleSecurity_ = nullptr;
143     BtmAclCallbacks btmAclCb_ {};
144 };
145 
impl(BleAdapter & bleAdapter)146 BleAdapter::impl::impl(BleAdapter &bleAdapter) : gattClientcallback_(std::make_unique<GattClientCallback>(bleAdapter))
147 {}
148 
~impl()149 BleAdapter::impl::~impl()
150 {}
151 
BleAdapter()152 BleAdapter::BleAdapter() : utility::Context(ADAPTER_NAME_BLE, "5.0"), pimpl(std::make_unique<BleAdapter::impl>(*this))
153 {
154     LOG_DEBUG("[BleAdapter] %{public}s:Create", Name().c_str());
155 }
156 
~BleAdapter()157 BleAdapter::~BleAdapter()
158 {
159     LOG_DEBUG("[BleAdapter] %{public}s:Destroy", Name().c_str());
160 
161     pimpl->bleAdvertiser_ = nullptr;
162     pimpl->bleCentralManager_ = nullptr;
163     pimpl->bleSecurity_ = nullptr;
164 }
165 
Enable()166 void BleAdapter::Enable()
167 {
168     LOG_DEBUG("[BleAdapter] %{public}s:%{public}s", __func__, Name().c_str());
169 
170     GetDispatcher()->PostTask(std::bind(&BleAdapter::EnableTask, this));
171 }
172 
EnableTask()173 bool BleAdapter::EnableTask()
174 {
175     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
176 
177     std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
178     bool ret = (BTM_Enable(LE_CONTROLLER) == BT_SUCCESS);
179     if (!ret) {
180         pimpl->btmEnableFlag_ = false;
181         LOG_ERROR("[BleAdapter] %{public}s:BTM enable failed!", __func__);
182     } else {
183         pimpl->btmEnableFlag_ = true;
184         LoadConfig();
185         ret = (InitBtmAndGap() == BT_SUCCESS);
186         LOG_DEBUG("[BleAdapter] %{public}s:BTM enable successfully!", __func__);
187     }
188 
189     GetContext()->OnEnable(ADAPTER_NAME_BLE, ret);
190 
191     return ret;
192 }
193 
InitBtmAndGap()194 int BleAdapter::InitBtmAndGap()
195 {
196     int ret = RegisterCallbackToBtm();
197     if (ret != BT_SUCCESS) {
198         LOG_ERROR("[BleAdapter] %{public}s:RegisterCallbackToBtm failed!", __func__);
199     }
200 
201     ret = SetLocalIrkAndIdentityAddrToBtm();
202     if (ret != BT_SUCCESS) {
203         LOG_ERROR("[BleAdapter] %{public}s:SetLocalIrkAndIdentityAddrToBtm failed!", __func__);
204     }
205 
206     ret = SetRpaAddrAndTypeToBtm();
207     if (ret != BT_SUCCESS) {
208         LOG_ERROR("[BleAdapter] %{public}s:SetRpaAddrAndTypeToBtm failed!", __func__);
209     }
210 
211     GAP_LeSecMode1Level level1 = static_cast<GAP_LeSecMode1Level>(BleConfig::GetInstance().GetBleModel1Level());
212     GAP_LeSecMode2Level level2 = static_cast<GAP_LeSecMode2Level>(BleConfig::GetInstance().GetBleModel2Level());
213     ret = GAPIF_LeSetSecurityMode(level1, level2);
214     if (ret == BT_NOT_SUPPORT) {
215         ret = GAPIF_LeSetSecurityMode(LE_MODE_1_LEVEL_3, level2);
216         if (ret != BT_SUCCESS) {
217             LOG_ERROR("[BleAdapter] %{public}s:GAP_LeSetSecurityMode failed!", __func__);
218         }
219     }
220 
221     RegisterBleSecurityCallback(*pimpl->observer_.get());
222 
223     ret = GAPIF_LeSetMinEncKeySize(GAP_ENC_KEY_MIN_SIZE);
224     if (ret != BT_SUCCESS) {
225         LOG_ERROR("[BleAdapter] %{public}s:GAP_LeSetMinEncKeySize failed!", __func__);
226     }
227 
228     ret = BleProperties::GetInstance().SetBondableMode(GAP_BONDABLE_MODE);
229     if (ret != BT_SUCCESS) {
230         LOG_ERROR("[BleAdapter] %{public}s:SetBondableMode failed!", __func__);
231     }
232 
233     /// Save all peer paired devices to BTM
234     std::vector<std::string> pairedAddrList = BleConfig::GetInstance().GetPairedAddrList();
235     ReadPeerDeviceInfoFromConf(pairedAddrList);
236     SavePeerDevices2BTM(pimpl->peerConnDeviceList_);
237     return ret;
238 }
239 
Disable()240 void BleAdapter::Disable()
241 {
242     LOG_DEBUG("[BleAdapter] %{public}s:%{public}s", __func__, Name().c_str());
243 
244     GetDispatcher()->PostTask(std::bind(&BleAdapter::DisableTask, this));
245 }
246 
DisableTask()247 bool BleAdapter::DisableTask()
248 {
249     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
250 
251     std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
252     if (!pimpl->btmEnableFlag_) {
253         GetContext()->OnDisable(ADAPTER_NAME_BLE, pimpl->btmEnableFlag_);
254         return false;
255     }
256 
257     SavePeerDeviceInfoToConf(pimpl->peerConnDeviceList_);
258     ClearPeerDeviceInfo();
259     int ret = BleProperties::GetInstance().SetBondableMode(GAP_BONDABLE_MODE_NON);
260     if (ret != BT_SUCCESS) {
261         LOG_ERROR("[BleAdapter] %{public}s:SetBondableMode failed!", __func__);
262     }
263 
264     StartOrStopAdvAndScan(STOP_ADV_TYPE_ALL, STOP_SCAN_TYPE_NOR);
265     if (BleFeature::GetInstance().IsLeExtendedAdvertisingSupported()) {
266         ExAdvClearHandle();
267     }
268     ClearScanResultInfo();
269     DeregisterAllCallback();
270     ClearScannerIdInfo();
271 
272     ret = (BTM_Disable(LE_CONTROLLER) == BT_SUCCESS);
273     if (!ret) {
274         LOG_ERROR("[BleAdapter] %{public}s:BTM Disable failed!", __func__);
275     } else {
276         LOG_DEBUG("[BleAdapter] %{public}s:BTM Disable successfully!", __func__);
277     }
278     GetContext()->OnDisable(ADAPTER_NAME_BLE, ret);
279     return ret;
280 }
281 
NotifyAllWaitContinue() const282 void BleAdapter::NotifyAllWaitContinue() const
283 {
284     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
285 
286     pimpl->cvfull_.notify_all();
287 }
288 
PostEnable()289 void BleAdapter::PostEnable()
290 {
291     LOG_DEBUG("[BleAdapter] %{public}s:%{public}s", __func__, Name().c_str());
292 
293     if (!pimpl->btmEnableFlag_) {
294         GetDispatcher()->PostTask(std::bind(&BleAdapter::PostEnableTask, this));
295         return;
296     }
297 
298     int ret = SetBleRoles();
299     if (ret != BT_SUCCESS) {
300         LOG_ERROR("[BleAdvertiserImpl] %{public}s:Set ble roles failed!.", __func__);
301     }
302 
303     GetDispatcher()->PostTask(std::bind(&BleAdapter::PostEnableTask, this));
304 }
305 
PostEnableTask() const306 bool BleAdapter::PostEnableTask() const
307 {
308     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
309 
310     return true;
311 }
312 
StartOrStopAdvAndScan(const STOP_ALL_ADV_TYPE & stopAllAdvType,const STOP_SCAN_TYPE & scanType,bool isStartAdvAndScan) const313 void BleAdapter::StartOrStopAdvAndScan(
314     const STOP_ALL_ADV_TYPE &stopAllAdvType, const STOP_SCAN_TYPE &scanType, bool isStartAdvAndScan) const
315 {
316     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
317     std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
318     std::unique_lock<std::recursive_mutex> bleAdvlk(pimpl->bleAdvMutex_);
319     if ((pimpl->bleAdvertiser_ != nullptr) &&
320         (pimpl->bleAdvertiser_->GetAdvertisingStatus() == ADVERTISE_FAILED_ALREADY_STARTED)) {
321         std::unique_lock<std::mutex> lock(pimpl->mutexAdvAdnScan_);
322         pimpl->bleAdvertiser_->StartOrStopAllAdvertising(stopAllAdvType, isStartAdvAndScan);
323         if (pimpl->cvfull_.wait_for(lock, std::chrono::seconds(BLE_THREAD_WAIT_TIMEOUT)) == std::cv_status::timeout) {
324             LOG_ERROR("[BleAdapter] %{public}s:StartOrStopAdvAndScan timeout!", __func__);
325         }
326     }
327     bleAdvlk.unlock();
328 
329     std::unique_lock<std::recursive_mutex> bleCenlk(pimpl->bleCenMutex_);
330     if (pimpl->bleCentralManager_ != nullptr) {
331         if (pimpl->bleCentralManager_->GetScanStatus() == SCAN_FAILED_ALREADY_STARTED) {
332             std::unique_lock<std::mutex> lock(pimpl->mutexAdvAdnScan_);
333             pimpl->bleCentralManager_->StartOrStopScan(scanType, isStartAdvAndScan);
334             if (pimpl->cvfull_.wait_for(lock, std::chrono::seconds(BLE_THREAD_WAIT_TIMEOUT)) ==
335                 std::cv_status::timeout) {
336                 LOG_ERROR("[BleAdapter] %{public}s:StartOrStopAdvAndScan timeout!", __func__);
337             }
338         }
339     }
340     bleCenlk.unlock();
341 }
342 
ExAdvClearHandle() const343 void BleAdapter::ExAdvClearHandle() const
344 {
345     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
346 
347     std::unique_lock<std::mutex> lock(pimpl->mutexAdvAdnScan_);
348     if (pimpl->bleAdvertiser_ != nullptr) {
349         pimpl->bleAdvertiser_->GAPExAdvClearHandle();
350         if (pimpl->cvfull_.wait_for(lock, std::chrono::seconds(BLE_THREAD_WAIT_TIMEOUT)) == std::cv_status::timeout) {
351             LOG_ERROR("[BleAdapter] %{public}s:ExAdvClearHandle timeout!", __func__);
352         }
353     }
354 }
355 
LoadConfig() const356 void BleAdapter::LoadConfig() const
357 {
358     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
359 
360     bool ret = BleProperties::GetInstance().LoadBleConfigInfo();
361     if (!ret) {
362         LOG_ERROR("[BleAdapter] %{public}s:LoadBleConfigInfo File failed!", __func__);
363     } else {
364         LOG_DEBUG("[BleAdapter] %{public}s:LoadBleConfigInfo File success!", __func__);
365     }
366 
367     ret &= BleProperties::GetInstance().ConfigBleProperties();
368     ret &= BleProperties::GetInstance().GetAddrFromController();
369     if (ret) {
370         BTM_SetOwnAddressType(BLE_ADDR_TYPE::BLE_ADDR_TYPE_PUBLIC);
371     }
372 
373     if (!ret) {
374         LOG_ERROR("[BleAdapter] %{public}s:ConfigBleProperties File failed!", __func__);
375         BleProperties::GetInstance().SaveDefaultValues();
376     } else {
377         LOG_DEBUG("[BleAdapter] %{public}s:ConfigBleProperties File success!", __func__);
378     }
379 }
380 
DeregisterAllCallback() const381 int BleAdapter::DeregisterAllCallback() const
382 {
383     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
384 
385     DeregisterBleSecurityCallback();
386     DeregisterBleAdvertiserCallback();
387     DeregisterBleCentralManagerCallback();
388     return DeregisterCallbackToBtm();
389 }
390 
GenResPriAddrResult(uint8_t result,const uint8_t addr[BT_ADDRESS_SIZE],void * context)391 void BleAdapter::GenResPriAddrResult(uint8_t result, const uint8_t addr[BT_ADDRESS_SIZE], void *context)
392 {
393     HILOGI("ResPriAddr: %{public}s", GetEncryptAddr(RawAddress::ConvertToString(addr).GetAddress()).c_str());
394 
395     auto *adapter = static_cast<BleAdapter *>(context);
396     std::unique_lock<std::mutex> lock(adapter->pimpl->mutexRpa_);
397     BtAddr btAddr;
398     (void)memcpy_s(&btAddr.addr, BT_ADDRESS_SIZE, addr, BT_ADDRESS_SIZE);
399     btAddr.type = BLE_ADDR_TYPE_RANDOM;
400     int ret = BTM_SetLeRandomAddress(&btAddr);
401     if (ret != BT_SUCCESS) {
402         LOG_ERROR("[BleAdapter] %{public}s:GenResPriAddrResult failed!", __func__);
403     }
404     BTM_SetOwnAddressType(BLE_ADDR_TYPE_RANDOM);
405 
406     adapter->pimpl->cvfull_.notify_all();
407 }
408 
SetRpaAddrAndTypeToBtm()409 int BleAdapter::SetRpaAddrAndTypeToBtm()
410 {
411     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
412 
413     /// btm set address type and rpa address
414     int ret = BT_SUCCESS;
415     switch (BleConfig::GetInstance().GetBleAddrType()) {
416         case BLE_ADDR_TYPE_RPA: {
417             std::unique_lock<std::mutex> lock(pimpl->mutexRpa_);
418             ret = GAPIF_LeGenResPriAddr(&BleAdapter::GenResPriAddrResult, this);
419             if (ret != BT_SUCCESS) {
420                 LOG_ERROR("[BleAdapter] %{public}s:GAP_LeGenResPriAddrAsync failed!", __func__);
421             }
422             if (pimpl->cvfull_.wait_for(lock, std::chrono::seconds(BLE_THREAD_WAIT_TIMEOUT)) ==
423                 std::cv_status::timeout) {
424                 LOG_ERROR("[BleAdapter] %{public}s:GAP_LeGenResPriAddrAsync timeout!", __func__);
425             }
426             break;
427         }
428         case BLE_ADDR_TYPE_PUBLIC:
429         default:
430             BTM_SetOwnAddressType(BleConfig::GetInstance().GetBleLocalAddrType());
431             break;
432     }
433     return ret;
434 }
435 
SetLocalIrkAndIdentityAddrToBtm() const436 int BleAdapter::SetLocalIrkAndIdentityAddrToBtm() const
437 {
438     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
439 
440     std::string irk = BleConfig::GetInstance().GetLocalIrk();
441     if (irk.empty()) {
442         std::vector<uint8_t> key;
443         BleUtils::Rand16hex(key);
444         BleConfig::GetInstance().SetLocalIrk(BleUtils::ConvertIntToHexString(key));
445         irk = BleUtils::ConvertIntToHexString(key);
446     }
447     std::vector<uint8_t> vec;
448     BleUtils::ConvertHexStringToInt(irk, vec);
449     BtmKey btmKey;
450     if (memcpy_s(btmKey.key, KEY_SIZE, &vec[0], vec.size()) != EOK) {
451         LOG_DEBUG("[BleAdapter] %{public}s:memcpy_s btmKey failed!", __func__);
452         return BT_OPERATION_FAILED;
453     }
454     BTM_SetLocalIdentityResolvingKey(&btmKey);
455     /// check public address
456     std::string addr = BleConfig::GetInstance().GetLocalAddress();
457     int ret = BT_SUCCESS;
458     if ((addr.empty()) || (INVALID_MAC_ADDRESS.compare(addr) == 0)) {
459         std::vector<uint8_t>().swap(vec);
460         BleUtils::GetRandomAddress(vec, false);
461         addr = RawAddress::ConvertToString(&vec[0]).GetAddress();
462         BleConfig::GetInstance().SetBleLocalAddrType(BLE_ADDR_TYPE::BLE_ADDR_TYPE_RANDOM);
463         BTM_SetOwnAddressType(BLE_ADDR_TYPE::BLE_ADDR_TYPE_RANDOM);
464         HILOGI("GAP_LeSetStaticIdentityAddr random addr = %{public}s!", GetEncryptAddr(addr).c_str());
465         ret = GAPIF_LeSetStaticIdentityAddr(&vec[0]);
466         if (ret != BT_SUCCESS) {
467             LOG_DEBUG("[BleAdapter] %{public}s:GAP_LeSetStaticIdentityAddr failed!", __func__);
468         }
469     }
470 
471     if (!BleConfig::GetInstance().SetLocalIdentityAddr(addr)) {
472         LOG_DEBUG("[BleAdapter] %{public}s:SetLocalIdentityAddr failed!", __func__);
473     }
474     return ret;
475 }
476 
GetLocalAddress() const477 std::string BleAdapter::GetLocalAddress() const
478 {
479     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
480 
481     std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
482     return BleProperties::GetInstance().GetLocalAddress();
483 }
484 
GetLocalName() const485 std::string BleAdapter::GetLocalName() const
486 {
487     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
488 
489     std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
490     return BleProperties::GetInstance().GetLocalName();
491 }
492 
SetLocalName(const std::string & name) const493 bool BleAdapter::SetLocalName(const std::string &name) const
494 {
495     LOG_DEBUG("[BleAdapter] %{public}s:SetLocalName %{public}s", __func__, name.c_str());
496 
497     std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
498     return BleProperties::GetInstance().SetLocalName(name);
499 }
500 
GetDeviceName(const RawAddress & device) const501 std::string BleAdapter::GetDeviceName(const RawAddress &device) const
502 {
503     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
504 
505     std::string remoteName = "";
506 
507     if (!Compat::CompatCheck(CompatType::COMPAT_REJECT_NAME_REQUEST, device.GetAddress())) {
508         int appID = RegisterGattClientApplication(device);
509         remoteName = ReadRemoteDeviceNameByGatt(device, appID);
510         DeregisterGattClientApplication(appID);
511     }
512 
513     if (!remoteName.empty()) {
514         return remoteName;
515     }
516 
517     if (pimpl->bleCentralManager_ != nullptr) {
518         remoteName = pimpl->bleCentralManager_->GetDeviceName(device.GetAddress());
519     }
520 
521     if (remoteName.empty()) {
522         std::lock_guard<std::recursive_mutex> lk(pimpl->peerDevlistMutex_);
523         auto it = pimpl->peerConnDeviceList_.find(device.GetAddress());
524         if (it != pimpl->peerConnDeviceList_.end()) {
525             remoteName = it->second.GetName();
526         }
527     }
528     return remoteName;
529 }
530 
RegisterGattClientApplication(const RawAddress & addr) const531 int BleAdapter::RegisterGattClientApplication(const RawAddress &addr) const
532 {
533     pimpl->gattClientService_ =
534         static_cast<IProfileGattClient *>(IProfileManager::GetInstance()->GetProfileService(PROFILE_NAME_GATT_CLIENT));
535     if (pimpl->gattClientService_ != nullptr) {
536         return pimpl->gattClientService_->RegisterSharedApplication(
537             *pimpl->gattClientcallback_, addr, BTTransport::ADAPTER_BLE);
538     }
539 
540     return RET_NO_SUPPORT;
541 }
542 
DeregisterGattClientApplication(int appID) const543 void BleAdapter::DeregisterGattClientApplication(int appID) const
544 {
545     pimpl->gattClientService_ =
546         static_cast<IProfileGattClient *>(IProfileManager::GetInstance()->GetProfileService(PROFILE_NAME_GATT_CLIENT));
547     if (pimpl->gattClientService_ == nullptr) {
548         return;
549     }
550     pimpl->gattClientService_->DeregisterApplication(appID);
551 }
552 
ReadRemoteDeviceNameByGatt(const RawAddress & addr,int appID) const553 std::string BleAdapter::ReadRemoteDeviceNameByGatt(const RawAddress &addr, int appID) const
554 {
555     std::string name = "";
556     pimpl->gattClientService_ =
557         static_cast<IProfileGattClient *>(IProfileManager::GetInstance()->GetProfileService(PROFILE_NAME_GATT_CLIENT));
558     if (pimpl->gattClientService_ == nullptr) {
559         return name;
560     }
561 
562     std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
563     bool isAclConnect = false;
564 
565     std::unique_lock<std::recursive_mutex> peerlk(pimpl->peerDevlistMutex_);
566     auto it = pimpl->peerConnDeviceList_.find(addr.GetAddress());
567     if (it != pimpl->peerConnDeviceList_.end()) {
568         isAclConnect = it->second.IsAclConnected();
569         LOG_DEBUG("[BleAdapter] isAclConnect %{public}d ", isAclConnect);
570     }
571     peerlk.unlock();
572 
573     if (isAclConnect) {
574         std::unique_lock<std::mutex> lock(pimpl->mutexRemoteName_);
575         // Device name
576         LOG_DEBUG("Get device name from gatt. %{public}d", appID);
577         Uuid uuid = Uuid::ConvertFrom16Bits(GATT_UUID_GAP_DEVICE_NAME);
578         pimpl->gattClientService_->Connect(appID, true);
579         pimpl->gattClientService_->ReadCharacteristicByUuid(appID, uuid);
580         if (pimpl->cvfull_.wait_for(lock, std::chrono::seconds(BLE_THREAD_WAIT_TIMEOUT)) ==
581             std::cv_status::timeout) {
582             LOG_ERROR("[BleAdapter] %{public}s:ReadRemoteDeviceNameByGatt timeout!", __func__);
583             pimpl->gattClientService_->Disconnect(appID);
584             return name;
585         }
586         if (pimpl->readCharacteristicFlag_) {
587             pimpl->gattClientService_->Disconnect(appID);
588         }
589         return pimpl->remoteDeviceName_;
590     }
591     return name;
592 }
593 
GetDeviceUuids(const RawAddress & device) const594 std::vector<Uuid> BleAdapter::GetDeviceUuids(const RawAddress &device) const
595 {
596     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
597 
598     std::lock_guard<std::recursive_mutex> lk(pimpl->peerDevlistMutex_);
599     std::vector<Uuid> uuids;
600     auto it = pimpl->peerConnDeviceList_.find(device.GetAddress());
601     if (it != pimpl->peerConnDeviceList_.end()) {
602         uuids = it->second.GetServiceUUID();
603     }
604     return uuids;
605 }
606 
GetPairedDevices() const607 std::vector<RawAddress> BleAdapter::GetPairedDevices() const
608 {
609     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
610 
611     std::lock_guard<std::recursive_mutex> lk(pimpl->peerDevlistMutex_);
612     std::vector<RawAddress> pairedList;
613     for (auto it = pimpl->peerConnDeviceList_.begin(); it != pimpl->peerConnDeviceList_.end(); it++) {
614         if (BLE_PAIR_PAIRED == it->second.GetPairedStatus()) {
615             RawAddress rawAddr(it->second.GetRawAddress());
616             pairedList.push_back(rawAddr);
617         }
618     }
619     return pairedList;
620 }
621 
GetConnectedDevices() const622 std::vector<RawAddress> BleAdapter::GetConnectedDevices() const
623 {
624     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
625 
626     std::lock_guard<std::recursive_mutex> lk(pimpl->peerDevlistMutex_);
627     std::vector<RawAddress> pairedList;
628     for (auto it = pimpl->peerConnDeviceList_.begin(); it != pimpl->peerConnDeviceList_.end(); it++) {
629         RawAddress rawAddr(it->second.GetRawAddress());
630         pairedList.push_back(rawAddr);
631     }
632     return pairedList;
633 }
634 
StartPair(const RawAddress & device)635 bool BleAdapter::StartPair(const RawAddress &device)
636 {
637     HILOGI("addr: %{public}s", GetEncryptAddr(device.GetAddress()).c_str());
638 
639     std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
640     if (pimpl->bleSecurity_ == nullptr) {
641         LOG_ERROR("[BleAdapter] %{public}s:failed", __func__);
642         return false;
643     }
644 
645     uint8_t peerAddrType = GetPeerDeviceAddrType(RawAddress(device.GetAddress()));
646     std::unique_lock<std::recursive_mutex> peerlk(pimpl->peerDevlistMutex_);
647     auto it = pimpl->peerConnDeviceList_.find(device.GetAddress());
648     if (it != pimpl->peerConnDeviceList_.end()) {
649         peerAddrType = it->second.GetAddressType();
650         if (BLE_PAIR_PAIRING == it->second.GetPairedStatus()) {
651             LOG_ERROR("[BleAdapter] %{public}s:StartPair failed, because of PAIR_NONE or PAIRING!", __func__);
652             return false;
653         }
654     }
655     peerlk.unlock();
656 
657     int ret = pimpl->bleSecurity_->StartPair(device, peerAddrType);
658     if (!ret) {
659         LOG_ERROR("[BleAdapter] %{public}s:failed", __func__);
660         return false;
661     }
662     LePairingStatus(device);
663     return true;
664 }
665 
CancelPairing(const RawAddress & device)666 bool BleAdapter::CancelPairing(const RawAddress &device)
667 {
668     HILOGI("addr: %{public}s", GetEncryptAddr(device.GetAddress()).c_str());
669 
670     std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
671     std::unique_lock<std::recursive_mutex> peerlk(pimpl->peerDevlistMutex_);
672     auto it = pimpl->peerConnDeviceList_.find(device.GetAddress());
673     if (it != pimpl->peerConnDeviceList_.end()) {
674         int pairState = it->second.GetPairedStatus();
675         peerlk.unlock();
676         if ((BLE_PAIR_PAIRED == pairState) || (BLE_PAIR_CANCELING == pairState) || (BLE_PAIR_NONE == pairState)) {
677             HILOGE("CancelPairing failed, because of BLE_PAIR_NONE, PAIR_PAIRED or PAIR_CANCELING! %{public}d",
678                 pairState);
679             return false;
680         }
681 
682         if (pimpl->bleSecurity_ == nullptr) {
683             return false;
684         }
685 
686         if (BT_SUCCESS == pimpl->bleSecurity_->CancelPairing(device)) {
687             peerlk.lock();
688             it->second.SetPairedStatus(BLE_PAIR_CANCELING);
689             peerlk.unlock();
690         } else {
691             LOG_ERROR("[BleAdapter] %{public}s:CancelPairing failed, because of gap cancel pair failed!", __func__);
692             return false;
693         }
694     } else {
695         LOG_ERROR("[BleAdapter] %{public}s:CancelPairing failed, because of not find the remote device!", __func__);
696         return false;
697     }
698 
699     return true;
700 }
701 
RemovePairWithDisConnect(const RawAddress & device,bool isDisconnect) const702 bool BleAdapter::RemovePairWithDisConnect(const RawAddress &device, bool isDisconnect) const
703 {
704     std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
705     std::unique_lock<std::recursive_mutex> peerlk(pimpl->peerDevlistMutex_);
706     auto it = pimpl->peerConnDeviceList_.find(device.GetAddress());
707     bool isAclConnect = it->second.IsAclConnected();
708     int connectionHandle = it->second.GetConnectionHandle();
709     int addrType = it->second.GetAddressType();
710     if ((it == pimpl->peerConnDeviceList_.end()) || (it->second.GetPairedStatus() != BLE_PAIR_PAIRED)) {
711         LOG_ERROR("[BleAdapter] %{public}s:RemovePair failed, because of not find the paired device!", __func__);
712         return false;
713     }
714     peerlk.unlock();
715 
716     BleConfig::GetInstance().RemovePairedDevice(device.GetAddress());
717 
718     if (isAclConnect && isDisconnect) {
719         int ret = BTM_AclDisconnect(connectionHandle, BTM_ACL_DISCONNECT_REASON);
720         if (ret != BT_SUCCESS) {
721             LOG_ERROR("[BleAdapter] %{public}s:BTM_AclDisconnect failed!", __func__);
722         }
723     }
724 
725     // Del pair device from BTM
726     StartOrStopAdvAndScan(STOP_ADV_TYPE_RESOLVING_LIST, STOP_SCAN_TYPE_RESOLVING_LIST);
727     BtAddr btAddr;
728     (void)memset_s(&btAddr, sizeof(btAddr), 0x00, sizeof(btAddr));
729     btAddr.type = addrType;
730     device.ConvertToUint8(btAddr.addr);
731     BTM_RemoveLePairedDevice(&btAddr);
732     StartOrStopAdvAndScan(STOP_ADV_TYPE_RESOLVING_LIST, STOP_SCAN_TYPE_RESOLVING_LIST, true);
733 
734     if (isDisconnect) {
735         peerlk.lock();
736         pimpl->peerConnDeviceList_.erase(device.GetAddress());
737         peerlk.unlock();
738     }
739     BleConfig::GetInstance().Save();
740 
741     std::vector<RawAddress> removeDevices;
742     removeDevices.push_back(device);
743     AdapterManager::GetInstance()->OnPairDevicesRemoved(BTTransport::ADAPTER_BLE, removeDevices);
744 
745     if (pimpl->blePeripheralCallback_ != nullptr) {
746         pimpl->blePeripheralCallback_->ForEach([device](IBlePeripheralCallback &observer) {
747             observer.OnPairStatusChanged(ADAPTER_BLE, device, BLE_PAIR_NONE);
748         });
749     }
750     return true;
751 }
752 
RemovePair(const RawAddress & device)753 bool BleAdapter::RemovePair(const RawAddress &device)
754 {
755     HILOGI("addr: %{public}s", GetEncryptAddr(device.GetAddress()).c_str());
756 
757     return RemovePairWithDisConnect(device);
758 }
759 
RemoveAllPairs()760 bool BleAdapter::RemoveAllPairs()
761 {
762     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
763 
764     std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
765     std::unique_lock<std::recursive_mutex> peerlk(pimpl->peerDevlistMutex_);
766     std::vector<RawAddress> removeDevices;
767     auto it = pimpl->peerConnDeviceList_.begin();
768     while (it != pimpl->peerConnDeviceList_.end()) {
769         if (it->second.GetPairedStatus() != BLE_PAIR_PAIRED) {
770             it++;
771             continue;
772         }
773 
774         std::string addr = it->second.GetRawAddress().GetAddress();
775         BleConfig::GetInstance().RemovePairedDevice(addr);
776         removeDevices.push_back(it->second.GetRawAddress());
777 
778         int ret = BT_SUCCESS;
779         if (it->second.IsAclConnected()) {
780             ret = BTM_AclDisconnect(it->second.GetConnectionHandle(), BTM_ACL_DISCONNECT_REASON);
781         }
782         if (ret != BT_SUCCESS) {
783             LOG_ERROR("[BleAdapter] %{public}s:BTM_AclDisconnect failed!", __func__);
784         }
785         pimpl->peerConnDeviceList_.erase(it++);
786     }
787     peerlk.unlock();
788 
789     // Del all paired devices from BTM
790     StartOrStopAdvAndScan(STOP_ADV_TYPE_RESOLVING_LIST, STOP_SCAN_TYPE_RESOLVING_LIST);
791     BTM_SetLePairedDevices(nullptr, 0);
792     StartOrStopAdvAndScan(STOP_ADV_TYPE_RESOLVING_LIST, STOP_SCAN_TYPE_RESOLVING_LIST, true);
793 
794     if (!removeDevices.empty()) {
795         BleConfig::GetInstance().Save();
796         AdapterManager::GetInstance()->OnPairDevicesRemoved(BTTransport::ADAPTER_BLE, removeDevices);
797     }
798     return true;
799 }
800 
IsRemovePairedDevice(const RawAddress & device) const801 bool BleAdapter::IsRemovePairedDevice(const RawAddress &device) const
802 {
803     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
804 
805     std::lock_guard<std::recursive_mutex> lk(pimpl->peerDevlistMutex_);
806     auto it = pimpl->peerConnDeviceList_.find(device.GetAddress());
807     if (it != pimpl->peerConnDeviceList_.end()) {
808         return false;
809     }
810     return true;
811 }
812 
IsBondedFromLocal(const RawAddress & device) const813 bool BleAdapter::IsBondedFromLocal(const RawAddress &device) const
814 {
815     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
816 
817     std::lock_guard<std::recursive_mutex> lk(pimpl->peerDevlistMutex_);
818     bool isBondedFromLocal = false;
819     auto it = pimpl->peerConnDeviceList_.find(device.GetAddress());
820     if (it != pimpl->peerConnDeviceList_.end()) {
821         isBondedFromLocal = it->second.IsAclEncrypted();
822     }
823     return isBondedFromLocal;
824 }
825 
SetDevicePasskey(const RawAddress & device,int passkey,bool accept) const826 bool BleAdapter::SetDevicePasskey(const RawAddress &device, int passkey, bool accept) const
827 {
828     LOG_DEBUG("[BleAdapter] %{public}s:%{public}d %{public}d", __func__, passkey, accept);
829 
830     std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
831     std::unique_lock<std::recursive_mutex> peerlk(pimpl->peerDevlistMutex_);
832     if (pimpl->bleSecurity_ == nullptr) {
833         LOG_ERROR("[BleAdapter] %{public}s:SetDevicePasskey failed!", __func__);
834         return false;
835     }
836 
837     if (!BLE_INVALID_MAC_ADDRESS.compare(device.GetAddress())) {
838         LOG_ERROR("[BleAdapter] %{public}s:SetDevicePasskey failed, because of invalid bt address!", __func__);
839         return false;
840     }
841 
842     auto it = pimpl->peerConnDeviceList_.find(device.GetAddress());
843     if (it == pimpl->peerConnDeviceList_.end()) {
844         LOG_ERROR("[BleAdapter] %{public}s:SetDevicePasskey failed, because of address not exist!", __func__);
845         return false;
846     }
847     int pairStatus = it->second.GetPairedStatus();
848     peerlk.unlock();
849 
850     int ret;
851     if ((BLE_PAIR_CANCELING == pairStatus) || (!accept)) {
852         ret = pimpl->bleSecurity_->SetDevicePasskey(device, passkey, GAP_NOT_ACCEPT);
853     } else {
854         ret = pimpl->bleSecurity_->SetDevicePasskey(device, passkey, GAP_ACCEPT);
855     }
856     if (BT_SUCCESS != ret) {
857         LOG_ERROR("[BleAdapter] %{public}s:SetDevicePasskey failed!", __func__);
858         return false;
859     }
860     return true;
861 }
862 
PairRequestReply(const RawAddress & device,bool accept) const863 bool BleAdapter::PairRequestReply(const RawAddress &device, bool accept) const
864 {
865     LOG_DEBUG("[BleAdapter] %{public}s:%{public}d", __func__, accept);
866 
867     if (pimpl->bleSecurity_ != nullptr) {
868         int addrType = GetPeerDeviceAddrType(device);
869         return pimpl->bleSecurity_->PairRequestReply(device, addrType, accept);
870     }
871     return false;
872 }
873 
IsAclConnected(const RawAddress & device) const874 bool BleAdapter::IsAclConnected(const RawAddress &device) const
875 {
876     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
877 
878     std::lock_guard<std::recursive_mutex> lk(pimpl->peerDevlistMutex_);
879     bool isAclConnected = false;
880     auto it = pimpl->peerConnDeviceList_.find(device.GetAddress());
881     if (it != pimpl->peerConnDeviceList_.end()) {
882         isAclConnected = it->second.IsAclConnected();
883     }
884     return isAclConnected;
885 }
886 
IsAclEncrypted(const RawAddress & device) const887 bool BleAdapter::IsAclEncrypted(const RawAddress &device) const
888 {
889     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
890 
891     std::lock_guard<std::recursive_mutex> lk(pimpl->peerDevlistMutex_);
892     bool isAclEncrypted = false;
893     auto it = pimpl->peerConnDeviceList_.find(device.GetAddress());
894     if (it != pimpl->peerConnDeviceList_.end()) {
895         isAclEncrypted = it->second.IsAclEncrypted();
896     }
897     return isAclEncrypted;
898 }
899 
GetContext()900 utility::Context *BleAdapter::GetContext()
901 {
902     return this;
903 }
904 
GetPairState(const RawAddress & device) const905 int BleAdapter::GetPairState(const RawAddress &device) const
906 {
907     HILOGI("addr: %{public}s", GetEncryptAddr(device.GetAddress()).c_str());
908 
909     std::lock_guard<std::recursive_mutex> lk(pimpl->peerDevlistMutex_);
910     int pairState = BLE_PAIR_NONE;
911     auto it = pimpl->peerConnDeviceList_.find(device.GetAddress());
912     if (it == pimpl->peerConnDeviceList_.end()) {
913         return pairState;
914     } else {
915         pairState = it->second.GetPairedStatus();
916     }
917     return pairState;
918 }
919 
GetBondableMode() const920 int BleAdapter::GetBondableMode() const
921 {
922     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
923 
924     std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
925     return BleProperties::GetInstance().GetBondableMode();
926 }
927 
SetBondableMode(int mode) const928 bool BleAdapter::SetBondableMode(int mode) const
929 {
930     LOG_DEBUG("[BleAdapter] %{public}s:%{public}d", __func__, mode);
931 
932     std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
933     return (BleProperties::GetInstance().SetBondableMode(mode) == BT_SUCCESS);
934 }
935 
SetDevicePairingConfirmation(const RawAddress & device,bool accept) const936 bool BleAdapter::SetDevicePairingConfirmation(const RawAddress &device, bool accept) const
937 {
938     HILOGI("addr: %{public}s, accept: %{public}d", GetEncryptAddr(device.GetAddress()).c_str(), accept);
939 
940     std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
941     if (pimpl->bleSecurity_ == nullptr) {
942         LOG_ERROR("[BleAdapter] %{public}s:failed", __func__);
943         return false;
944     }
945 
946     if (BLE_INVALID_MAC_ADDRESS == device.GetAddress()) {
947         LOG_ERROR("[BleAdapter] %{public}s:failed, because of invalid bt address!", __func__);
948         return false;
949     }
950 
951     std::unique_lock<std::recursive_mutex> peerlk(pimpl->peerDevlistMutex_);
952     auto it = pimpl->peerConnDeviceList_.find(device.GetAddress());
953     if (it == pimpl->peerConnDeviceList_.end()) {
954         LOG_ERROR("[BleAdapter] %{public}s:failed, because of address not exist!", __func__);
955         return false;
956     }
957     int pairStatus = it->second.GetPairedStatus();
958     peerlk.unlock();
959 
960     int ret;
961     if ((BLE_PAIR_CANCELING == pairStatus) || (!accept)) {
962         ret = pimpl->bleSecurity_->SetUserConfirm(device, GAP_NOT_ACCEPT);
963     } else {
964         ret = pimpl->bleSecurity_->SetUserConfirm(device, GAP_ACCEPT);
965     }
966     if (BT_SUCCESS != ret) {
967         LOG_ERROR("[BleAdapter] %{public}s:failed!", __func__);
968         return false;
969     }
970     return true;
971 }
972 
GetBleMaxAdvertisingDataLength() const973 int BleAdapter::GetBleMaxAdvertisingDataLength() const
974 {
975     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
976 
977     std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
978     return BleFeature::GetInstance().GetBleMaximumAdvertisingDataLength();
979 }
980 
GetIoCapability() const981 int BleAdapter::GetIoCapability() const
982 {
983     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
984 
985     std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
986     return BleProperties::GetInstance().GetIoCapability();
987 }
988 
SetIoCapability(int ioCapability) const989 bool BleAdapter::SetIoCapability(int ioCapability) const
990 {
991     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
992 
993     std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
994     return BleProperties::GetInstance().SetIoCapability(ioCapability);
995 }
996 
IsBleEnabled() const997 bool BleAdapter::IsBleEnabled() const
998 {
999     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1000 
1001     std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1002     int status = AdapterManager::GetInstance()->GetState(BTTransport::ADAPTER_BLE);
1003     return (status == BTStateID::STATE_TURN_ON);
1004 }
1005 
IsBtDiscovering() const1006 bool BleAdapter::IsBtDiscovering() const
1007 {
1008     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1009 
1010     std::lock_guard<std::recursive_mutex> lk(pimpl->bleCenMutex_);
1011     if (pimpl->bleCentralManager_ != nullptr) {
1012         return (SCAN_FAILED_ALREADY_STARTED == pimpl->bleCentralManager_->GetScanStatus());
1013     }
1014     return false;
1015 }
1016 
RegisterBleAdvertiserCallback(IBleAdvertiserCallback & callback)1017 void BleAdapter::RegisterBleAdvertiserCallback(IBleAdvertiserCallback &callback)
1018 {
1019     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1020 
1021     std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1022     if (pimpl->bleAdvertiser_ == nullptr) {
1023         pimpl->bleAdvertiser_ = std::make_unique<BleAdvertiserImpl>(callback, *this, *GetDispatcher());
1024     }
1025 }
1026 
DeregisterBleAdvertiserCallback() const1027 void BleAdapter::DeregisterBleAdvertiserCallback() const
1028 {
1029     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1030 
1031     if (pimpl->bleAdvertiser_ != nullptr) {
1032         pimpl->bleAdvertiser_->DeregisterCallbackToGap();
1033     }
1034 }
1035 
RegisterBleCentralManagerCallback(IBleCentralManagerCallback & callback)1036 void BleAdapter::RegisterBleCentralManagerCallback(IBleCentralManagerCallback &callback)
1037 {
1038     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1039 
1040     std::lock_guard<std::recursive_mutex> lk(pimpl->bleCenMutex_);
1041     if (pimpl->bleCentralManager_ == nullptr) {
1042         pimpl->bleCentralManager_ = std::make_unique<BleCentralManagerImpl>(callback, *this, *GetDispatcher());
1043     }
1044 }
1045 
DeregisterBleCentralManagerCallback() const1046 void BleAdapter::DeregisterBleCentralManagerCallback() const
1047 {
1048     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1049 
1050     if (pimpl->bleCentralManager_ != nullptr) {
1051         pimpl->bleCentralManager_->DeregisterCallbackToGap();
1052     }
1053 }
1054 
RegisterBlePeripheralCallback(IBlePeripheralCallback & callback) const1055 void BleAdapter::RegisterBlePeripheralCallback(IBlePeripheralCallback &callback) const
1056 {
1057     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1058 
1059     if (pimpl->blePeripheralCallback_ != nullptr) {
1060         pimpl->blePeripheralCallback_->Register(callback);
1061     }
1062 }
1063 
DeregisterBlePeripheralCallback(IBlePeripheralCallback & callback) const1064 void BleAdapter::DeregisterBlePeripheralCallback(IBlePeripheralCallback &callback) const
1065 {
1066     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1067 
1068     if (pimpl->blePeripheralCallback_ != nullptr) {
1069         pimpl->blePeripheralCallback_->Deregister(callback);
1070     }
1071 }
1072 
RegisterBleSecurityCallback(BaseObserverList<IAdapterBleObserver> & callback)1073 void BleAdapter::RegisterBleSecurityCallback(BaseObserverList<IAdapterBleObserver> &callback)
1074 {
1075     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1076 
1077     if (pimpl->bleSecurity_ == nullptr) {
1078         pimpl->bleSecurity_ = std::make_unique<BleSecurity>(*this, *GetDispatcher(), callback);
1079     } else {
1080         pimpl->bleSecurity_->RegisterCallbackToGap();
1081     }
1082 }
1083 
DeregisterBleSecurityCallback() const1084 void BleAdapter::DeregisterBleSecurityCallback() const
1085 {
1086     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1087 
1088     if (pimpl->bleSecurity_ != nullptr) {
1089         pimpl->bleSecurity_->DeregisterCallbackToGap();
1090     }
1091 }
1092 
RegisterBleAdapterObserver(IAdapterBleObserver & observer) const1093 bool BleAdapter::RegisterBleAdapterObserver(IAdapterBleObserver &observer) const
1094 {
1095     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1096 
1097     std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1098     if (pimpl->observer_ != nullptr) {
1099         pimpl->observer_->Register(observer);
1100     }
1101     BleProperties::GetInstance().RegisterBleAdapterObserver(*pimpl->observer_.get());
1102     return true;
1103 }
1104 
DeregisterBleAdapterObserver(IAdapterBleObserver & observer) const1105 bool BleAdapter::DeregisterBleAdapterObserver(IAdapterBleObserver &observer) const
1106 {
1107     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1108 
1109     std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1110     BleProperties::GetInstance().DeregisterBleAdapterObserver(observer);
1111     return true;
1112 }
1113 
GetPeerDeviceAddrType(const RawAddress & device) const1114 int BleAdapter::GetPeerDeviceAddrType(const RawAddress &device) const
1115 {
1116     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1117 
1118     int type = BLE_ADDR_TYPE_UNKNOWN;
1119     if (pimpl->bleCentralManager_ != nullptr) {
1120         type = pimpl->bleCentralManager_->GetDeviceAddrType(device.GetAddress());
1121     }
1122     if (type == BLE_ADDR_TYPE_UNKNOWN) {
1123         std::lock_guard<std::recursive_mutex> lk(pimpl->peerDevlistMutex_);
1124         type = BLE_ADDR_TYPE_RANDOM;
1125         auto it = pimpl->peerConnDeviceList_.find(device.GetAddress());
1126         if (it != pimpl->peerConnDeviceList_.end()) {
1127             type = it->second.GetAddressType();
1128         }
1129     }
1130     return type;
1131 }
1132 
ReadPeerDeviceInfoFromConf(const std::vector<std::string> & pairedAddrList) const1133 void BleAdapter::ReadPeerDeviceInfoFromConf(const std::vector<std::string> &pairedAddrList) const
1134 {
1135     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1136 
1137     for (auto addr : pairedAddrList) {
1138         RawAddress rawAddr(addr);
1139         if ((!INVALID_MAC_ADDRESS.compare(rawAddr.GetAddress())) || (rawAddr.GetAddress().empty())) {
1140             continue;
1141         }
1142         BlePeripheralDevice remote;
1143         remote.SetAddress(rawAddr);
1144         remote.SetAddressType(BleConfig::GetInstance().GetPeerAddressType(addr));
1145 
1146         std::string name = BleConfig::GetInstance().GetPeerName(addr);
1147         remote.SetName(name);
1148 
1149         int io = BleConfig::GetInstance().GetPeerDeviceIoCapability(addr);
1150         remote.SetIoCapability(io);
1151 
1152         remote.SetPairedStatus(BLE_PAIR_PAIRED);
1153 
1154         std::lock_guard<std::recursive_mutex> lk(pimpl->peerDevlistMutex_);
1155         pimpl->peerConnDeviceList_.insert(std::make_pair(addr, remote));
1156     }
1157 }
1158 
SavePeerDeviceInfoToConf(const std::map<std::string,BlePeripheralDevice> & peerConnDeviceList) const1159 bool BleAdapter::SavePeerDeviceInfoToConf(const std::map<std::string, BlePeripheralDevice> &peerConnDeviceList) const
1160 {
1161     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1162 
1163     std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1164     bool ret = false;
1165     for (auto it = peerConnDeviceList.begin(); it != peerConnDeviceList.end(); it++) {
1166         if (it->second.GetPairedStatus() != BLE_PAIR_PAIRED) {
1167             continue;
1168         }
1169         RawAddress rawAddr(it->second.GetRawAddress());
1170 
1171         int addrType = it->second.GetAddressType();
1172         ret = BleConfig::GetInstance().SetPeerAddressType(rawAddr.GetAddress(), addrType);
1173 
1174         ret &= BleConfig::GetInstance().SetPeerName(rawAddr.GetAddress(), it->second.GetName());
1175 
1176         int deviceType = it->second.GetDeviceType();
1177         ret &= BleConfig::GetInstance().SetPeerDeviceType(rawAddr.GetAddress(), deviceType);
1178     }
1179 
1180     BleConfig::GetInstance().Save();
1181     return ret;
1182 }
1183 
ClearPeerDeviceInfo() const1184 void BleAdapter::ClearPeerDeviceInfo() const
1185 {
1186     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1187 
1188     std::lock_guard<std::recursive_mutex> lk(pimpl->peerDevlistMutex_);
1189     pimpl->peerConnDeviceList_.clear();
1190 }
1191 
ClearScanResultInfo() const1192 void BleAdapter::ClearScanResultInfo() const
1193 {
1194     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1195 
1196     std::lock_guard<std::recursive_mutex> lk(pimpl->bleCenMutex_);
1197     if (pimpl->bleCentralManager_ != nullptr) {
1198         pimpl->bleCentralManager_->ClearResults();
1199     }
1200 }
1201 
ClearScannerIdInfo() const1202 void BleAdapter::ClearScannerIdInfo() const
1203 {
1204     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1205 
1206     std::lock_guard<std::recursive_mutex> lk(pimpl->bleCenMutex_);
1207     if (pimpl->bleCentralManager_ != nullptr) {
1208         pimpl->bleCentralManager_->ClearScannerIds();
1209     }
1210 }
1211 
SavePeerDevices2BTM(const std::map<std::string,BlePeripheralDevice> & peerConnDeviceList) const1212 void BleAdapter::SavePeerDevices2BTM(const std::map<std::string, BlePeripheralDevice> &peerConnDeviceList) const
1213 {
1214     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1215 
1216     std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1217     // Add pair device to BTM
1218     std::vector<BtmLePairedDevice> devices;
1219     for (auto it = peerConnDeviceList.begin(); it != peerConnDeviceList.end(); it++) {
1220         BtAddr btAddr;
1221         (void)memset_s(&btAddr, sizeof(btAddr), 0x00, sizeof(btAddr));
1222         RawAddress device(it->second.GetRawAddress());
1223         device.ConvertToUint8(btAddr.addr);
1224 
1225         if ((INVALID_MAC_ADDRESS.compare(device.GetAddress()) == 0) || (device.GetAddress().empty()) ||
1226             (BleConfig::GetInstance().GetPeerIrk(device.GetAddress()).empty()) ||
1227             (BleConfig::GetInstance().GetPeerIdentityAddr(device.GetAddress()).empty())) {
1228             continue;
1229         }
1230 
1231         BtmLePairedDevice pairedDevice;
1232         (void)memset_s(&pairedDevice, sizeof(pairedDevice), 0x00, sizeof(pairedDevice));
1233         btAddr.type = it->second.GetAddressType();
1234         pairedDevice.addr = btAddr;
1235 
1236         // Peer Identity Addr
1237         BtAddr peerAddr;
1238         (void)memset_s(&btAddr, sizeof(btAddr), 0x00, sizeof(btAddr));
1239         std::string addr = BleConfig::GetInstance().GetPeerIdentityAddr(device.GetAddress());
1240         RawAddress peerDevice(addr);
1241         peerAddr.type = BleConfig::GetInstance().GetPeerAddressType(device.GetAddress());
1242         peerDevice.ConvertToUint8(peerAddr.addr);
1243         pairedDevice.remoteIdentityAddress = peerAddr;
1244 
1245         // IRK
1246         std::string irk = BleConfig::GetInstance().GetPeerIrk(device.GetAddress());
1247         if (!irk.empty()) {
1248             std::vector<uint8_t> vec;
1249             BleUtils::ConvertHexStringToInt(irk, vec);
1250             if (memcpy_s(pairedDevice.remoteIdentityResolvingKey.key, KEY_SIZE, &vec[0], vec.size()) != EOK) {
1251                 LOG_ERROR("[BleAdapter] %{public}s:SavePeerDevices2BTM memcpy_s failed!", __func__);
1252                 return;
1253             }
1254         }
1255         devices.push_back(pairedDevice);
1256     }
1257     if (!devices.empty()) {
1258         BTM_SetLePairedDevices(&devices[0], devices.size());
1259         devices.clear();
1260     }
1261 }
1262 
RegisterCallbackToBtm()1263 int BleAdapter::RegisterCallbackToBtm()
1264 {
1265     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1266 
1267     pimpl->btmAclCb_.leConnectionComplete = &BleAdapter::LeConnectionComplete;
1268     pimpl->btmAclCb_.leDisconnectionComplete = &BleAdapter::LeDisconnectionComplete;
1269     pimpl->btmAclCb_.readRssiComplete = &BleAdapter::OnReadRemoteRssiEvent;
1270 
1271     int ret = BTM_RegisterAclCallbacks(&pimpl->btmAclCb_, this);
1272     if (ret != BT_SUCCESS) {
1273         LOG_ERROR("[BleAdapter] %{public}s:BTM_RegisterAclCallbacks failed!", __func__);
1274     }
1275     return ret;
1276 }
1277 
DeregisterCallbackToBtm() const1278 int BleAdapter::DeregisterCallbackToBtm() const
1279 {
1280     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1281 
1282     if (!pimpl->btmEnableFlag_) {
1283         return BT_OPERATION_FAILED;
1284     }
1285 
1286     int ret = BTM_DeregisterAclCallbacks(&pimpl->btmAclCb_);
1287     if (ret != BT_SUCCESS) {
1288         LOG_ERROR("[BleAdapter] %{public}s:DeregisterCallbackToBtm failed!", __func__);
1289     }
1290     return ret;
1291 }
1292 
LeConnectionComplete(uint8_t status,uint16_t connectionHandle,const BtAddr * addr,uint8_t role,void * context)1293 void BleAdapter::LeConnectionComplete(
1294     uint8_t status, uint16_t connectionHandle, const BtAddr *addr, uint8_t role, void *context)
1295 {
1296     HILOGI("status: %{public}u", status);
1297 
1298     if (status != BT_SUCCESS) {
1299         HILOGI("status: %{public}u", status);
1300         return;
1301     }
1302 
1303     auto *adapter = static_cast<BleAdapter *>(context);
1304     BtAddr address;
1305     (void)memcpy_s(&address, sizeof(BtAddr), addr, sizeof(BtAddr));
1306     adapter->GetDispatcher()->PostTask(
1307         std::bind(&BleAdapter::LeConnectionCompleteTask, adapter, status, connectionHandle, address, role));
1308 }
1309 
LeConnectionCompleteTask(uint8_t status,uint16_t connectionHandle,const BtAddr & addr,uint8_t role) const1310 void BleAdapter::LeConnectionCompleteTask(
1311     uint8_t status, uint16_t connectionHandle, const BtAddr &addr, uint8_t role) const
1312 {
1313     LOG_DEBUG("[BleAdapter] %{public}s, handle is %{public}d", __func__, connectionHandle);
1314 
1315     std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1316     std::unique_lock<std::recursive_mutex> bleAdvlk(pimpl->bleAdvMutex_);
1317     if ((pimpl->bleAdvertiser_ != nullptr) && (!BleFeature::GetInstance().IsLeExtendedAdvertisingSupported()) &&
1318         (role == LE_CONNECTION_ROLE_SLAVE)) {
1319         pimpl->bleAdvertiser_->ReStartLegacyAdvertising();
1320     }
1321     bleAdvlk.unlock();
1322 
1323     RawAddress peerAddr = RawAddress::ConvertToString(addr.addr);
1324 
1325     std::unique_lock<std::recursive_mutex> peerlk(pimpl->peerDevlistMutex_);
1326     auto it = pimpl->peerConnDeviceList_.find(peerAddr.GetAddress());
1327     if (it != pimpl->peerConnDeviceList_.end()) {
1328         it->second.SetConnectionHandle(connectionHandle);
1329         it->second.SetRoles(role);
1330         it->second.SetAddressType(addr.type);
1331         if (pimpl->bleCentralManager_ != nullptr) {
1332             it->second.SetName(pimpl->bleCentralManager_->GetDeviceName(peerAddr.GetAddress()));
1333         }
1334         it->second.SetAclConnectState(BLE_CONNECTION_STATE_CONNECTED);
1335 
1336         if ((it->second.GetPairedStatus() == BLE_PAIR_PAIRED) && (pimpl->bleSecurity_ != nullptr)) {
1337             pimpl->bleSecurity_->GapLeRequestSecurity(connectionHandle, addr, role);
1338         }
1339     } else {
1340         BlePeripheralDevice peerDevice;
1341         peerDevice.SetAddress(peerAddr);
1342         peerDevice.SetAddressType(addr.type);
1343         if (pimpl->bleCentralManager_ != nullptr) {
1344             peerDevice.SetName(pimpl->bleCentralManager_->GetDeviceName(peerAddr.GetAddress()));
1345         }
1346         peerDevice.SetRoles(role);
1347         peerDevice.SetConnectionHandle(connectionHandle);
1348         peerDevice.SetAclConnectState(BLE_CONNECTION_STATE_CONNECTED);
1349         pimpl->peerConnDeviceList_.insert(std::make_pair(peerAddr.GetAddress(), peerDevice));
1350     }
1351 }
1352 
LeDisconnectionComplete(uint8_t status,uint16_t connectionHandle,uint8_t reason,void * context)1353 void BleAdapter::LeDisconnectionComplete(uint8_t status, uint16_t connectionHandle, uint8_t reason, void *context)
1354 {
1355     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1356 
1357     if (status != BT_SUCCESS) {
1358         LOG_DEBUG("[BleAdapter] %{public}s:%u", __func__, status);
1359         return;
1360     }
1361 
1362     auto *adapter = static_cast<BleAdapter *>(context);
1363     adapter->GetDispatcher()->PostTask(
1364         std::bind(&BleAdapter::LeDisconnectionCompleteTask, adapter, status, connectionHandle, reason));
1365 }
1366 
LeDisconnectionCompleteTask(uint8_t status,uint16_t connectionHandle,uint8_t reason) const1367 void BleAdapter::LeDisconnectionCompleteTask(uint8_t status, uint16_t connectionHandle, uint8_t reason) const
1368 {
1369     LOG_DEBUG("[BleAdapter] %{public}s, handle is %{public}d", __func__, connectionHandle);
1370 
1371     std::lock_guard<std::recursive_mutex> lk(pimpl->peerDevlistMutex_);
1372     for (auto it = pimpl->peerConnDeviceList_.begin(); it != pimpl->peerConnDeviceList_.end(); it++) {
1373         if (connectionHandle == it->second.GetConnectionHandle()) {
1374             LOG_DEBUG("[BleAdapter] handle is %{public}d disconnect ", connectionHandle);
1375             it->second.SetAclConnectState(BLE_CONNECTION_STATE_DISCONNECTED);
1376             break;
1377         }
1378     }
1379 }
1380 
LePairComplete(const RawAddress & device,const int status) const1381 void BleAdapter::LePairComplete(const RawAddress &device, const int status) const
1382 {
1383     LOG_DEBUG("[BleAdapter] %{public}s:result %{public}d.", __func__, status);
1384     std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1385     std::unique_lock<std::recursive_mutex> peerlk(pimpl->peerDevlistMutex_);
1386     auto it = pimpl->peerConnDeviceList_.find(device.GetAddress());
1387     if (it == pimpl->peerConnDeviceList_.end()) {
1388         HILOGI("addr %{public}s.", GetEncryptAddr(device.GetAddress()).c_str());
1389         return;
1390     }
1391     int pairState = BLE_PAIR_NONE;
1392     if (status == BT_SUCCESS) {
1393         it->second.SetPairedStatus(BLE_PAIR_PAIRED);
1394         /// Peer Identity Addr
1395         BtAddr btAddr;
1396         (void)memset_s(&btAddr, sizeof(btAddr), 0x00, sizeof(btAddr));
1397         device.ConvertToUint8(btAddr.addr);
1398         btAddr.type = it->second.GetAddressType();
1399         peerlk.unlock();
1400         RawAddress peerDevice(BleConfig::GetInstance().GetPeerIdentityAddr(device.GetAddress()));
1401         BtAddr peerAddr;
1402         (void)memset_s(&peerAddr, sizeof(peerAddr), 0x00, sizeof(peerAddr));
1403         peerAddr.type = BleConfig::GetInstance().GetPeerDeviceType(device.GetAddress());
1404         peerDevice.ConvertToUint8(peerAddr.addr);
1405         BtmLePairedDevice pairedDevice;
1406         (void)memset_s(&pairedDevice, sizeof(pairedDevice), 0x00, sizeof(pairedDevice));
1407         (void)memcpy_s(&pairedDevice.addr, sizeof(BtAddr), &btAddr, sizeof(BtAddr));
1408         (void)memcpy_s(&pairedDevice.remoteIdentityAddress, sizeof(BtAddr), &peerAddr, sizeof(BtAddr));
1409         /// IRK
1410         std::string irk = BleConfig::GetInstance().GetPeerIrk(device.GetAddress());
1411         if (!irk.empty()) {
1412             std::vector<uint8_t> vec;
1413             BleUtils::ConvertHexStringToInt(irk, vec);
1414             /// Add paired device to btm
1415             (void)memcpy_s(pairedDevice.remoteIdentityResolvingKey.key, KEY_SIZE, &vec[0], vec.size());
1416         }
1417         StartOrStopAdvAndScan(STOP_ADV_TYPE_RESOLVING_LIST, STOP_SCAN_TYPE_RESOLVING_LIST);
1418         BTM_AddLePairedDevice(&pairedDevice);
1419         StartOrStopAdvAndScan(STOP_ADV_TYPE_RESOLVING_LIST, STOP_SCAN_TYPE_RESOLVING_LIST, true);
1420         pairState = BLE_PAIR_PAIRED;
1421     } else {
1422         it->second.SetPairedStatus(BLE_PAIR_NONE);
1423         peerlk.unlock();
1424     }
1425     if (pimpl->blePeripheralCallback_ != nullptr) {
1426         pimpl->blePeripheralCallback_->ForEach([device, pairState](IBlePeripheralCallback &observer) {
1427             observer.OnPairStatusChanged(ADAPTER_BLE, device, pairState);
1428         });
1429     }
1430 }
1431 
LePairingStatus(const RawAddress & device) const1432 void BleAdapter::LePairingStatus(const RawAddress &device) const
1433 {
1434     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1435 
1436     std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1437     std::unique_lock<std::recursive_mutex> peerlk(pimpl->peerDevlistMutex_);
1438     auto it = pimpl->peerConnDeviceList_.find(device.GetAddress());
1439     if (it != pimpl->peerConnDeviceList_.end()) {
1440         it->second.SetPairedStatus(BLE_PAIR_PAIRING);
1441     } else {
1442         LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1443         BlePeripheralDevice peerDevice;
1444         peerDevice.SetAddress(device);
1445         peerDevice.SetPairedStatus(BLE_PAIR_PAIRING);
1446         pimpl->peerConnDeviceList_.insert(std::make_pair(device.GetAddress(), peerDevice));
1447     }
1448     peerlk.unlock();
1449 
1450     if (pimpl->blePeripheralCallback_ != nullptr) {
1451         pimpl->blePeripheralCallback_->ForEach([device](IBlePeripheralCallback &observer) {
1452             observer.OnPairStatusChanged(ADAPTER_BLE, device, BLE_PAIR_PAIRING);
1453         });
1454     }
1455 }
1456 
EncryptionComplete(const RawAddress & device) const1457 void BleAdapter::EncryptionComplete(const RawAddress &device) const
1458 {
1459     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1460 
1461     std::lock_guard<std::recursive_mutex> lk(pimpl->peerDevlistMutex_);
1462     auto it = pimpl->peerConnDeviceList_.find(device.GetAddress());
1463     if (it != pimpl->peerConnDeviceList_.end()) {
1464         it->second.SetAclConnectState(BLE_CONNECTION_STATE_ENCRYPTED_LE);
1465     }
1466 }
1467 
OnReadRemoteRssiEvent(uint8_t status,const BtAddr * addr,int8_t rssi,void * context)1468 void BleAdapter::OnReadRemoteRssiEvent(uint8_t status, const BtAddr *addr, int8_t rssi, void *context)
1469 {
1470     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1471 
1472     auto *adapter = static_cast<BleAdapter *>(context);
1473     BtAddr address;
1474     (void)memcpy_s(&address, sizeof(BtAddr), addr, sizeof(BtAddr));
1475     adapter->GetDispatcher()->PostTask(
1476         std::bind(&BleAdapter::OnReadRemoteRssiEventTask, adapter, status, address, rssi));
1477 }
1478 
OnReadRemoteRssiEventTask(uint8_t status,const BtAddr & addr,int8_t rssi) const1479 void BleAdapter::OnReadRemoteRssiEventTask(uint8_t status, const BtAddr &addr, int8_t rssi) const
1480 {
1481     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1482 
1483     RawAddress device = RawAddress::ConvertToString(addr.addr);
1484     if (pimpl->blePeripheralCallback_ != nullptr) {
1485         pimpl->blePeripheralCallback_->ForEach([device, rssi, status](IBlePeripheralCallback &observer) {
1486             observer.OnReadRemoteRssiEvent(device, rssi, status);
1487         });
1488     }
1489 }
1490 
ReadRemoteRssiValue(const RawAddress & device) const1491 bool BleAdapter::ReadRemoteRssiValue(const RawAddress &device) const
1492 {
1493     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1494 
1495     std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1496     BtAddr addr;
1497     (void)memset_s(&addr, sizeof(addr), 0x00, sizeof(addr));
1498     addr.type = GetPeerDeviceAddrType(device);
1499     device.ConvertToUint8(addr.addr);
1500     return (BTM_ReadRssi(&addr) == BT_SUCCESS);
1501 }
1502 
GetDeviceType(const RawAddress & device) const1503 int BleAdapter::GetDeviceType(const RawAddress &device) const
1504 {
1505     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1506 
1507     std::lock_guard<std::recursive_mutex> lk(pimpl->bleCenMutex_);
1508     if (pimpl->bleCentralManager_ != nullptr) {
1509         return pimpl->bleCentralManager_->GetDeviceType(device.GetAddress());
1510     }
1511     return BLE_BT_DEVICE_TYPE_UNKNOWN;
1512 }
1513 
GetAdvertiserHandle() const1514 uint8_t BleAdapter::GetAdvertiserHandle() const
1515 {
1516     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1517 
1518     std::lock_guard<std::recursive_mutex> lk(pimpl->bleAdvMutex_);
1519     if (pimpl->bleAdvertiser_ != nullptr) {
1520         return pimpl->bleAdvertiser_->CreateAdvertiserSetHandle();
1521     }
1522     return BLE_INVALID_ADVERTISING_HANDLE;
1523 }
1524 
StartAdvertising(const BleAdvertiserSettingsImpl & settings,const BleAdvertiserDataImpl & advData,const BleAdvertiserDataImpl & scanResponse,uint8_t advHandle) const1525 void BleAdapter::StartAdvertising(const BleAdvertiserSettingsImpl &settings, const BleAdvertiserDataImpl &advData,
1526     const BleAdvertiserDataImpl &scanResponse, uint8_t advHandle) const
1527 {
1528     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1529 
1530     std::lock_guard<std::recursive_mutex> lk(pimpl->bleAdvMutex_);
1531     if (pimpl->bleAdvertiser_ != nullptr) {
1532         pimpl->bleAdvertiser_->StartAdvertising(settings, advData, scanResponse, advHandle);
1533     }
1534 }
1535 
StopAdvertising(uint8_t advHandle) const1536 void BleAdapter::StopAdvertising(uint8_t advHandle) const
1537 {
1538     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1539 
1540     std::lock_guard<std::recursive_mutex> lk(pimpl->bleAdvMutex_);
1541     if (pimpl->bleAdvertiser_ != nullptr) {
1542         pimpl->bleAdvertiser_->StopAdvertising(advHandle);
1543     }
1544 }
1545 
Close(uint8_t advHandle) const1546 void BleAdapter::Close(uint8_t advHandle) const
1547 {
1548     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1549 
1550     std::lock_guard<std::recursive_mutex> lk(pimpl->bleAdvMutex_);
1551     if (pimpl->bleAdvertiser_ != nullptr) {
1552         pimpl->bleAdvertiser_->Close(advHandle);
1553     }
1554 }
1555 
StartScan(const BleScanSettingsImpl & setting) const1556 void BleAdapter::StartScan(const BleScanSettingsImpl &setting) const
1557 {
1558     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1559 
1560     std::lock_guard<std::recursive_mutex> lk(pimpl->bleCenMutex_);
1561     if (pimpl->bleCentralManager_ != nullptr) {
1562         pimpl->bleCentralManager_->StartScan(setting);
1563     }
1564 }
1565 
StopScan() const1566 void BleAdapter::StopScan() const
1567 {
1568     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1569 
1570     std::lock_guard<std::recursive_mutex> lk(pimpl->bleCenMutex_);
1571     if (pimpl->bleCentralManager_ != nullptr) {
1572         pimpl->bleCentralManager_->StopScan();
1573     }
1574 }
1575 
ConfigScanFilter(int32_t scannerId,const std::vector<BleScanFilterImpl> & filters)1576 int BleAdapter::ConfigScanFilter(int32_t scannerId, const std::vector<BleScanFilterImpl> &filters)
1577 {
1578     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1579 
1580     std::lock_guard<std::recursive_mutex> lk(pimpl->bleCenMutex_);
1581     if (pimpl->bleCentralManager_ != nullptr) {
1582         return pimpl->bleCentralManager_->ConfigScanFilter(scannerId, filters);
1583     }
1584     return 0;
1585 }
1586 
RemoveScanFilter(int32_t scannerId)1587 void BleAdapter::RemoveScanFilter(int32_t scannerId)
1588 {
1589     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1590 
1591     std::lock_guard<std::recursive_mutex> lk(pimpl->bleCenMutex_);
1592     if (pimpl->bleCentralManager_ != nullptr) {
1593         pimpl->bleCentralManager_->RemoveScanFilter(scannerId);
1594     }
1595 }
1596 
AllocScannerId()1597 int32_t BleAdapter::AllocScannerId()
1598 {
1599     std::lock_guard<std::recursive_mutex> lk(pimpl->bleCenMutex_);
1600     if (pimpl->bleCentralManager_ == nullptr) {
1601         LOG_DEBUG("[BleAdapter] bleCentralManager is null.");
1602         return 0;
1603     }
1604     return pimpl->bleCentralManager_->AllocScannerId();
1605 }
1606 
RemoveScannerId(int32_t scannerId)1607 void BleAdapter::RemoveScannerId(int32_t scannerId)
1608 {
1609     std::lock_guard<std::recursive_mutex> lk(pimpl->bleCenMutex_);
1610     if (pimpl->bleCentralManager_ == nullptr) {
1611         LOG_DEBUG("[BleAdapter] bleCentralManager is null.");
1612         return;
1613     }
1614     return pimpl->bleCentralManager_->RemoveScannerId(scannerId);
1615 }
1616 
OnStartAdvertisingEvt() const1617 void BleAdapter::OnStartAdvertisingEvt() const
1618 {
1619     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1620 
1621     if (pimpl->observer_ != nullptr) {
1622         int status = BLE_ADV_STATE_ADVERTISING;
1623         pimpl->observer_->ForEach(
1624             [status](IAdapterBleObserver &observer) { observer.OnAdvertisingStateChanged(status); });
1625     }
1626 }
1627 
OnStopAdvertisingEvt() const1628 void BleAdapter::OnStopAdvertisingEvt() const
1629 {
1630     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1631 
1632     if (pimpl->observer_ != nullptr) {
1633         int status = BLE_ADV_STATE_IDLE;
1634         pimpl->observer_->ForEach(
1635             [status](IAdapterBleObserver &observer) { observer.OnAdvertisingStateChanged(status); });
1636     }
1637 }
1638 
GetAdvertisingStatus() const1639 int BleAdapter::GetAdvertisingStatus() const
1640 {
1641     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1642 
1643     std::lock_guard<std::recursive_mutex> lk(pimpl->bleAdvMutex_);
1644     if (pimpl->bleAdvertiser_ != nullptr) {
1645         if (pimpl->bleAdvertiser_->GetAdvertisingStatus() == ADVERTISE_FAILED_ALREADY_STARTED) {
1646             return BLE_ADV_STATE_ADVERTISING;
1647         } else {
1648             return BLE_ADV_STATE_IDLE;
1649         }
1650     }
1651     return BLE_ADV_STATE_IDLE;
1652 }
1653 
IsLlPrivacySupported() const1654 bool BleAdapter::IsLlPrivacySupported() const
1655 {
1656     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1657 
1658     return BleFeature::GetInstance().IsPrivacySupported();
1659 }
1660 
AddCharacteristicValue(uint8_t adtype,const std::string & data) const1661 void BleAdapter::AddCharacteristicValue(uint8_t adtype, const std::string &data) const
1662 {
1663     LOG_DEBUG("[BleAdapter] %{public}s", __func__);
1664 
1665     std::lock_guard<std::recursive_mutex> lk(pimpl->bleAdvMutex_);
1666     if (pimpl->bleAdvertiser_ != nullptr) {
1667         pimpl->bleAdvertiser_->AddCharacteristicValue(adtype, data);
1668     }
1669 }
1670 
SetBleRoles() const1671 int BleAdapter::SetBleRoles() const
1672 {
1673     int roles = BleProperties::GetInstance().GetBleRoles();
1674 
1675     LOG_DEBUG("[BleAdapter] %{public}s:%{public}d", __func__, roles);
1676 
1677     if (roles > (GAP_LE_ROLE_BROADCASTER | GAP_LE_ROLE_OBSERVER | GAP_LE_ROLE_PREIPHERAL | GAP_LE_ROLE_CENTRAL) ||
1678         roles < GAP_LE_ROLE_BROADCASTER) {
1679         LOG_ERROR("[BleAdapter] %{public}s:Roles is invalid.", __func__);
1680         roles = (GAP_LE_ROLE_BROADCASTER | GAP_LE_ROLE_OBSERVER | GAP_LE_ROLE_PREIPHERAL | GAP_LE_ROLE_CENTRAL);
1681     }
1682     return GAPIF_LeSetRole(roles);
1683 }
1684 
1685 REGISTER_CLASS_CREATOR(BleAdapter);
1686 }  // namespace bluetooth
1687 }  // namespace OHOS
1688