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