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_central_manager_impl.h"
17
18 #include <dlfcn.h>
19
20 #include "ble_adapter.h"
21 #include "ble_feature.h"
22 #include "ble_properties.h"
23 #include "ble_utils.h"
24 #include "common/adapter_manager.h"
25 #include "hisysevent.h"
26 #include "ble_scan_filter/include/ble_scan_filter_lsf.h"
27 #include "securec.h"
28
29 namespace OHOS {
30 namespace bluetooth {
31 constexpr char BLE_SCAN_FILTER_LIB_NAME[] = "libble_scan_filter.z.so";
32
33 struct BleCentralManagerImpl::impl {
34 /**
35 * @brief register scan callback to gap
36 *
37 * @return @c status.
38 */
39 int RegisterCallbackToGap();
40 /**
41 * @brief register extend scan callback to gap
42 *
43 * @return @c status.
44 */
45 int RegisterExScanCallbackToGap();
46 /**
47 * @brief Set report delay.
48 *
49 * @return @c status
50 */
51 void StartReportDelay();
52
53 std::recursive_mutex mutex_ {};
54 /// callback type
55 CALLBACK_TYPE callBackType_ = CALLBACK_TYPE_FIRST_MATCH;
56 /// scan status
57 int scanStatus_ = SCAN_NOT_STARTED;
58 // stop scan type
59 STOP_SCAN_TYPE stopScanType_ = STOP_SCAN_TYPE_NOR;
60 /// scan result list
61 std::vector<BleScanResultImpl> bleScanResult_ {};
62 /// Is stop scan
63 bool isStopScan_ = false;
64 /// scan settings
65 BleScanSettingsImpl settings_ {};
66 /// scan parameters
67 BleScanParams scanParams_ {};
68 /// Report delay timer
69 std::unique_ptr<utility::Timer> timer_ = nullptr;
70 std::map<std::string, std::vector<uint8_t>> incompleteData_ {};
71 BleCentralManagerImpl *bleCentralManagerImpl_ = nullptr;
72
73 std::map<uint8_t, BleScanFilterImpl> filters_;
74 std::list<uint8_t> releaseFiltIndex_;
75 std::queue<BleScanFilterImpl> waitFilters_;
76 uint8_t currentFiltIndex_ = 0;
77 uint8_t venderMaxFilterNumber_ = 0;
78 int filterStatus_ = BLE_SCAN_FILTER_STATUS_IDLE;
79
80 /// Adv data cache
81 class BleAdvertisingDataCache {
82 public:
83 // Set the adv data to cache by device address
SetAdvData(uint8_t addrType,const RawAddress & address,std::vector<uint8_t> advData)84 const std::vector<uint8_t> &SetAdvData(
85 uint8_t addrType, const RawAddress &address, std::vector<uint8_t> advData)
86 {
87 auto it = SearchByAddress(addrType, address);
88 if (it != itemDatas_.end()) {
89 it->advData_ = std::move(advData);
90 return it->advData_;
91 }
92
93 if (itemDatas_.size() > MAX_CACHE) {
94 itemDatas_.pop_back();
95 }
96
97 itemDatas_.emplace_front(addrType, address, std::move(advData));
98 return itemDatas_.front().advData_;
99 }
100
101 // Append adv data for device address
AppendAdvData(uint8_t addrType,const RawAddress & address,std::vector<uint8_t> advData)102 const std::vector<uint8_t> &AppendAdvData(
103 uint8_t addrType, const RawAddress &address, std::vector<uint8_t> advData)
104 {
105 auto it = SearchByAddress(addrType, address);
106 if (it != itemDatas_.end()) {
107 it->advData_.insert(it->advData_.end(), advData.begin(), advData.end());
108 return it->advData_;
109 }
110
111 if (itemDatas_.size() > MAX_CACHE) {
112 itemDatas_.pop_back();
113 }
114
115 itemDatas_.emplace_front(addrType, address, std::move(advData));
116 return itemDatas_.front().advData_;
117 }
118
119 // Clear adv data by device addr
ClearAdvData(uint8_t addrType,const RawAddress & address)120 void ClearAdvData(uint8_t addrType, const RawAddress &address)
121 {
122 auto it = SearchByAddress(addrType, address);
123 if (it != itemDatas_.end()) {
124 itemDatas_.erase(it);
125 }
126 }
127
128 // Clear all data
ClearAllData()129 void ClearAllData()
130 {
131 for (auto item : itemDatas_) {
132 item.advData_.clear();
133 }
134 }
135
136 private:
137 struct ItemData {
138 uint8_t addrType_;
139 RawAddress address_;
140 std::vector<uint8_t> advData_;
141
ItemDataOHOS::bluetooth::BleCentralManagerImpl::impl::BleAdvertisingDataCache::ItemData142 ItemData(uint8_t addrType, const RawAddress &address, std::vector<uint8_t> advData)
143 : addrType_(addrType), address_(address), advData_(advData)
144 {}
145 };
146
SearchByAddress(uint8_t addrType,const RawAddress & address)147 std::list<ItemData>::iterator SearchByAddress(uint8_t addrType, const RawAddress &address)
148 {
149 for (auto it = itemDatas_.begin(); it != itemDatas_.end(); it++) {
150 if (it->addrType_ == addrType && it->address_ == address) {
151 return it;
152 }
153 }
154 return itemDatas_.end();
155 }
156
157 // Keep max 7 devices address in the cache
158 const size_t MAX_CACHE = 7;
159 std::list<ItemData> itemDatas_ {};
160 };
161
162 BleAdvertisingDataCache advDataCache_ {};
163 };
164
BleCentralManagerImpl(IBleCentralManagerCallback & callback,IAdapterBle & bleAdapter,utility::Dispatcher & dispatch)165 BleCentralManagerImpl::BleCentralManagerImpl(
166 IBleCentralManagerCallback &callback, IAdapterBle &bleAdapter, utility::Dispatcher &dispatch)
167 : centralManagerCallbacks_(&callback),
168 bleAdapter_(&bleAdapter),
169 dispatcher_(&dispatch),
170 pimpl(std::make_unique<BleCentralManagerImpl::impl>())
171 {
172 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
173
174 pimpl->bleCentralManagerImpl_ = this;
175 pimpl->scanParams_.ownAddrType = BLE_ADDR_TYPE_PUBLIC;
176 pimpl->scanParams_.scanFilterPolicy = BLE_SCAN_FILTER_ALLOW_ALL;
177 SetActiveScan(true);
178
179 #ifdef LSF_ENABLE
180 bleScanFilter_ = new BleScanFilterLsf();
181 #else
182 LoadBleScanFilterLib();
183 #endif
184 }
185
~BleCentralManagerImpl()186 BleCentralManagerImpl::~BleCentralManagerImpl()
187 {
188 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
189
190 if (pimpl->timer_ != nullptr) {
191 pimpl->timer_->Stop();
192 pimpl->timer_ = nullptr;
193 }
194
195 #ifdef LSF_ENABLE
196 if (bleScanFilter_ != nullptr) {
197 delete bleScanFilter_;
198 }
199 #else
200 UnloadBleScanFilterLib();
201 #endif
202 }
203
RegisterCallbackToGap()204 int BleCentralManagerImpl::impl::RegisterCallbackToGap()
205 {
206 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
207
208 GapScanCallback scanCallbacks{};
209 scanCallbacks.advertisingReport = &BleCentralManagerImpl::AdvertisingReport;
210 scanCallbacks.scanSetParamResult = &BleCentralManagerImpl::ScanSetParamResult;
211 scanCallbacks.scanSetEnableResult = &BleCentralManagerImpl::ScanSetEnableResult;
212 return GAPIF_RegisterScanCallback(&scanCallbacks, bleCentralManagerImpl_);
213 }
214
RegisterExScanCallbackToGap()215 int BleCentralManagerImpl::impl::RegisterExScanCallbackToGap()
216 {
217 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
218
219 GapExScanCallback exScanCallbacks{};
220 exScanCallbacks.exAdvertisingReport = &BleCentralManagerImpl::ExAdvertisingReport;
221 exScanCallbacks.scanExSetParamResult = &BleCentralManagerImpl::ScanExSetParamResult;
222 exScanCallbacks.scanExSetEnableResult = &BleCentralManagerImpl::ScanExSetEnableResult;
223 exScanCallbacks.directedAdvertisingReport = &BleCentralManagerImpl::DirectedAdvertisingReport;
224 exScanCallbacks.scanTimeoutEvent = &BleCentralManagerImpl::ScanTimeoutEvent;
225 return GAPIF_RegisterExScanCallback(&exScanCallbacks, bleCentralManagerImpl_);
226 }
227
DeregisterCallbackToGap() const228 int BleCentralManagerImpl::DeregisterCallbackToGap() const
229 {
230 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
231 int ret;
232 if (BleFeature::GetInstance().IsLeExtendedAdvertisingSupported()) {
233 ret = GAPIF_DeregisterExScanCallback();
234 } else {
235 ret = GAPIF_DeregisterScanCallback();
236 }
237 return ret;
238 }
239
AdvertisingReport(uint8_t advType,const BtAddr * peerAddr,GapAdvReportParam reportParam,const BtAddr * currentAddr,void * context)240 void BleCentralManagerImpl::AdvertisingReport(
241 uint8_t advType, const BtAddr *peerAddr, GapAdvReportParam reportParam, const BtAddr *currentAddr, void *context)
242 {
243 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
244
245 auto *centralManager = static_cast<BleCentralManagerImpl *>(context);
246 if ((centralManager != nullptr) && (centralManager->dispatcher_ != nullptr)) {
247 bool isScannable = (advType == SCAN_ADV_IND || advType == SCAN_ADV_SCAN_IND);
248 bool isScanResp = (advType == SCAN_SCAN_RSP);
249 bool isStart = isScannable && !isScanResp;
250
251 RawAddress rawAddress(RawAddress::ConvertToString(peerAddr->addr));
252 std::vector<uint8_t> datas(reportParam.data, reportParam.data + reportParam.dataLen);
253 std::vector<uint8_t> const &advData =
254 isStart ? centralManager->pimpl->advDataCache_.SetAdvData(peerAddr->type, rawAddress, std::move(datas))
255 : centralManager->pimpl->advDataCache_.AppendAdvData(peerAddr->type, rawAddress, std::move(datas));
256
257 if (isScannable && !isScanResp) {
258 return;
259 }
260
261 std::vector<uint8_t> mergeData(advData);
262 centralManager->pimpl->advDataCache_.ClearAdvData(peerAddr->type, rawAddress);
263
264 BtAddr addr;
265 (void)memset_s(&addr, sizeof(addr), 0x00, sizeof(addr));
266 addr.type = peerAddr->type;
267 (void)memcpy_s(addr.addr, BT_ADDRESS_SIZE, peerAddr->addr, BT_ADDRESS_SIZE);
268 LOG_INFO("AdvertisingReport Data=%{public}s", BleUtils::ConvertIntToHexString(mergeData).c_str());
269 centralManager->dispatcher_->PostTask(std::bind(
270 &BleCentralManagerImpl::AdvertisingReportTask, centralManager, advType, addr, mergeData, reportParam.rssi));
271 }
272 }
273
ExAdvertisingReport(uint8_t advType,const BtAddr * addr,GapExAdvReportParam reportParam,const BtAddr * currentAddr,void * context)274 void BleCentralManagerImpl::ExAdvertisingReport(
275 uint8_t advType, const BtAddr *addr, GapExAdvReportParam reportParam, const BtAddr *currentAddr, void *context)
276 {
277 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
278
279 auto *pCentralManager = static_cast<BleCentralManagerImpl *>(context);
280 if ((pCentralManager != nullptr) && (pCentralManager->dispatcher_)) {
281 bool isLegacy = (advType & (1 << BLE_ADV_EVT_LEGACY_BIT));
282 std::vector<uint8_t> mergeData(reportParam.data, reportParam.data + reportParam.dataLen);
283 if (isLegacy) {
284 bool isScannable = (advType & (1 << BLE_LEGACY_ADV_SCAN_IND));
285 bool isScanResp = (advType & (1 << BLE_LEGACY_SCAN_RESPONSE));
286 bool isStart = isScannable && !isScanResp;
287
288 RawAddress rawAddress(RawAddress::ConvertToString(addr->addr));
289 std::vector<uint8_t> datas(reportParam.data, reportParam.data + reportParam.dataLen);
290 std::vector<uint8_t> const &advData =
291 isStart ? pCentralManager->pimpl->advDataCache_.SetAdvData(addr->type, rawAddress, std::move(datas))
292 : pCentralManager->pimpl->advDataCache_.AppendAdvData(addr->type, rawAddress, std::move(datas));
293
294 if (isScannable && !isScanResp) {
295 LOG_DEBUG("[BleCentralManagerImpl] Waiting for scan response");
296 return;
297 }
298
299 mergeData = advData;
300 pCentralManager->pimpl->advDataCache_.ClearAdvData(addr->type, rawAddress);
301 }
302
303 BtAddr peerAddr;
304 peerAddr.type = addr->type;
305 (void)memcpy_s(peerAddr.addr, BT_ADDRESS_SIZE, addr->addr, BT_ADDRESS_SIZE);
306
307 BtAddr peerCurrentAddr;
308 if (currentAddr != nullptr) {
309 peerCurrentAddr.type = currentAddr->type;
310 (void)memcpy_s(peerCurrentAddr.addr, BT_ADDRESS_SIZE, currentAddr->addr, BT_ADDRESS_SIZE);
311 } else {
312 peerCurrentAddr = peerAddr;
313 }
314
315 LOG_INFO("ExAdvertisingReport Data=%{public}s", BleUtils::ConvertIntToHexString(mergeData).c_str());
316 pCentralManager->dispatcher_->PostTask(std::bind(&BleCentralManagerImpl::ExAdvertisingReportTask,
317 pCentralManager,
318 advType,
319 peerAddr,
320 mergeData,
321 reportParam.rssi,
322 peerCurrentAddr));
323 }
324 }
325
AdvertisingReportTask(uint8_t advType,const BtAddr & peerAddr,const std::vector<uint8_t> & data,int8_t rssi) const326 void BleCentralManagerImpl::AdvertisingReportTask(
327 uint8_t advType, const BtAddr &peerAddr, const std::vector<uint8_t> &data, int8_t rssi) const
328 {
329 HILOGI("Data = %{public}s", BleUtils::ConvertIntToHexString(data).c_str());
330
331 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
332 RawAddress advertisedAddress(RawAddress::ConvertToString(peerAddr.addr));
333 bool ret = false;
334 BlePeripheralDevice device;
335 if (FindDevice(advertisedAddress.GetAddress(), device)) {
336 ret = AddPeripheralDevice(advType, peerAddr, data, rssi, device);
337 if (ret) { /// LE General Discoverable Mode LE Limited Discoverable Mode
338 return;
339 }
340 HandleGapEvent(BLE_GAP_SCAN_RESULT_EVT, 0);
341 return;
342 }
343
344 ret = AddPeripheralDevice(advType, peerAddr, data, rssi, device);
345 if (ret) { /// LE General Discoverable Mode LE Limited Discoverable Mode
346 return;
347 }
348 HandleGapEvent(BLE_GAP_SCAN_RESULT_EVT, 0);
349 }
350
ExtractIncompleteData(uint8_t advType,const std::string & advertisedAddress,const std::vector<uint8_t> & data,std::vector<uint8_t> & completeData) const351 bool BleCentralManagerImpl::ExtractIncompleteData(uint8_t advType, const std::string &advertisedAddress,
352 const std::vector<uint8_t> &data, std::vector<uint8_t> &completeData) const
353 {
354 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
355
356 if ((advType & BLE_EX_SCAN_DATE_STATUS_INCOMPLETE_MORE) == BLE_EX_SCAN_DATE_STATUS_INCOMPLETE_MORE) {
357 auto iter = pimpl->incompleteData_.find(advertisedAddress);
358 if (iter == pimpl->incompleteData_.end()) {
359 pimpl->incompleteData_.insert(std::make_pair(advertisedAddress, data));
360 } else {
361 iter->second.insert(iter->second.end(), data.begin(), data.end());
362 }
363 return true;
364 } else if ((advType & BLE_EX_SCAN_DATE_STATUS_INCOMPLETE_NO_MORE) == 0 &&
365 (advType & BLE_EX_SCAN_DATE_STATUS_INCOMPLETE_MORE) == 0) {
366 auto iter = pimpl->incompleteData_.find(advertisedAddress);
367 if (iter != pimpl->incompleteData_.end()) {
368 iter->second.insert(iter->second.end(), data.begin(), data.end());
369 completeData = iter->second;
370 }
371 } else if ((advType & BLE_EX_SCAN_DATE_STATUS_INCOMPLETE_NO_MORE) == BLE_EX_SCAN_DATE_STATUS_INCOMPLETE_NO_MORE) {
372 auto iter = pimpl->incompleteData_.find(advertisedAddress);
373 if (iter != pimpl->incompleteData_.end()) {
374 iter->second.insert(iter->second.end(), data.begin(), data.end());
375 completeData = iter->second;
376 }
377 }
378 return false;
379 }
380
ExAdvertisingReportTask(uint8_t advType,const BtAddr & peerAddr,const std::vector<uint8_t> & data,int8_t rssi,const BtAddr & peerCurrentAddr) const381 void BleCentralManagerImpl::ExAdvertisingReportTask(uint8_t advType, const BtAddr &peerAddr,
382 const std::vector<uint8_t> &data, int8_t rssi, const BtAddr &peerCurrentAddr) const
383 {
384 HILOGI("Data = %{public}s", BleUtils::ConvertIntToHexString(data).c_str());
385
386 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
387 RawAddress advAddress(RawAddress::ConvertToString(peerAddr.addr));
388 /// Set whether only legacy advertisments should be returned in scan results.
389 if (pimpl->settings_.GetLegacy()) {
390 if ((advType & BLE_LEGACY_ADV_NONCONN_IND_WITH_EX_ADV) == 0) {
391 HILOGI("Excepted addr: %{public}s, advType = %{public}d",
392 GetEncryptAddr(advAddress.GetAddress()).c_str(), advType);
393 return;
394 }
395 }
396
397 /// incomplete data
398 RawAddress advCurrentAddress(RawAddress::ConvertToString(peerCurrentAddr.addr));
399 HILOGI("peerAddr: %{public}s, peerCurrentAddr: %{public}s", GetEncryptAddr(advAddress.GetAddress()).c_str(),
400 GetEncryptAddr(advCurrentAddress.GetAddress()).c_str());
401 std::vector<uint8_t> incompleteData(data.begin(), data.end());
402 if (ExtractIncompleteData(advType, advCurrentAddress.GetAddress(), data, incompleteData)) {
403 return;
404 }
405
406 bool ret = false;
407 BlePeripheralDevice device;
408 if (FindDevice(advAddress.GetAddress(), device)) {
409 ret = AddPeripheralDevice(advType, peerAddr, incompleteData, rssi, device);
410 if (ret) { /// not discovery
411 pimpl->incompleteData_.clear();
412 return;
413 }
414 HandleGapExScanEvent(BLE_GAP_EX_SCAN_RESULT_EVT, 0);
415 pimpl->incompleteData_.clear();
416 return;
417 }
418
419 ret = AddPeripheralDevice(advType, peerAddr, incompleteData, rssi, device);
420 if (ret) { /// not discovery
421 pimpl->incompleteData_.clear();
422 return;
423 }
424 pimpl->incompleteData_.clear();
425 HandleGapExScanEvent(BLE_GAP_EX_SCAN_RESULT_EVT, 0);
426 }
427
AddPeripheralDevice(uint8_t advType,const BtAddr & peerAddr,const std::vector<uint8_t> & data,int8_t rssi,const BlePeripheralDevice & dev) const428 bool BleCentralManagerImpl::AddPeripheralDevice(uint8_t advType, const BtAddr &peerAddr,
429 const std::vector<uint8_t> &data, int8_t rssi, const BlePeripheralDevice &dev) const
430 {
431 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
432
433 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
434 BlePeripheralDevice device = dev;
435 RawAddress advertisedAddress(RawAddress::ConvertToString(peerAddr.addr));
436 device.SetAddress(advertisedAddress);
437 device.SetManufacturerData("");
438 device.SetRSSI(rssi);
439 if (data.size() > 0) {
440 BlePeripheralDeviceParseAdvData parseAdvData = {
441 .payload = const_cast<uint8_t *>(data.data()),
442 .length = data.size(),
443 };
444 device.ParseAdvertiserment(parseAdvData);
445 uint8_t falg = device.GetAdFlag();
446 if (CheckBleScanMode(falg)) {
447 return true;
448 }
449 } else {
450 uint8_t falg = device.GetAdFlag();
451 if (CheckBleScanMode(falg)) {
452 return true;
453 }
454 }
455 device.SetAddressType(peerAddr.type);
456 if ((advType == SCAN_ADV_SCAN_IND) || (advType == SCAN_ADV_NONCONN_IND)) {
457 device.SetConnectable(false);
458 } else if ((advType == SCAN_ADV_IND) || (advType == SCAN_ADV_DIRECT_IND)) {
459 device.SetConnectable(true);
460 }
461
462 BleScanResultImpl result;
463 result.SetPeripheralDevice(device);
464 pimpl->bleScanResult_.push_back(result);
465
466 return false;
467 }
468
CheckBleScanMode(uint8_t falg)469 bool BleCentralManagerImpl::CheckBleScanMode(uint8_t falg)
470 {
471 LOG_DEBUG("[BleCentralManagerImpl] %{public}s:adv flag = %u", __func__, falg);
472
473 switch (BleConfig::GetInstance().GetBleScanMode()) {
474 case BLE_SCAN_MODE_NON_DISC:
475 if (falg == BLE_ADV_FLAG_NON_LIMIT_DISC) {
476 return false;
477 }
478 break;
479 case BLE_SCAN_MODE_GENERAL:
480 if ((falg & BLE_ADV_FLAG_LIMIT_DISC) == BLE_ADV_FLAG_LIMIT_DISC ||
481 (falg & BLE_ADV_FLAG_GEN_DISC) == BLE_ADV_FLAG_GEN_DISC) {
482 return false;
483 }
484 break;
485 case BLE_SCAN_MODE_LIMITED:
486 if ((falg & BLE_ADV_FLAG_LIMIT_DISC) == BLE_ADV_FLAG_LIMIT_DISC) {
487 return false;
488 }
489 break;
490 case BLE_SCAN_MODE_ALL:
491 default:
492 return false;
493 }
494 return true;
495 }
496
AddBleScanFilterResult(uint8_t result,void * context)497 void BleCentralManagerImpl::AddBleScanFilterResult(uint8_t result, void *context)
498 {
499 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
500 auto *centralManager = static_cast<BleCentralManagerImpl *>(context);
501 if ((centralManager != nullptr) && (centralManager->dispatcher_ != nullptr)) {
502 centralManager->dispatcher_->PostTask(std::bind(
503 &BleCentralManagerImpl::HandleAddBleScanFilterResult, centralManager, result));
504 }
505 }
506
DeleteBleScanFilterResult(uint8_t result,void * context)507 void BleCentralManagerImpl::DeleteBleScanFilterResult(uint8_t result, void *context)
508 {
509 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
510 auto *centralManager = static_cast<BleCentralManagerImpl *>(context);
511 if ((centralManager != nullptr) && (centralManager->dispatcher_ != nullptr)) {
512 centralManager->dispatcher_->PostTask(std::bind(
513 &BleCentralManagerImpl::HandleDeleteBleScanFilterResult, centralManager, result));
514 }
515 }
516
StartBleScanFilterResult(uint8_t result,void * context)517 void BleCentralManagerImpl::StartBleScanFilterResult(uint8_t result, void *context)
518 {
519 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
520 auto *centralManager = static_cast<BleCentralManagerImpl *>(context);
521 if ((centralManager != nullptr) && (centralManager->dispatcher_ != nullptr)) {
522 centralManager->dispatcher_->PostTask(std::bind(
523 &BleCentralManagerImpl::HandleStartBleScanFilterResult, centralManager, result));
524 }
525 }
526
StopBleScanFilterResult(uint8_t result,void * context)527 void BleCentralManagerImpl::StopBleScanFilterResult(uint8_t result, void *context)
528 {
529 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
530 auto *centralManager = static_cast<BleCentralManagerImpl *>(context);
531 if ((centralManager != nullptr) && (centralManager->dispatcher_ != nullptr)) {
532 centralManager->dispatcher_->PostTask(std::bind(
533 &BleCentralManagerImpl::HandleStopBleScanFilterResult, centralManager, result));
534 }
535 }
536
HandleAddBleScanFilterResult(uint8_t result)537 void BleCentralManagerImpl::HandleAddBleScanFilterResult(uint8_t result)
538 {
539 LOG_DEBUG("[BleCentralManagerImpl] %{public}s:", __func__);
540 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
541 if (result != BLE_SCAN_FILTER_FINISHED) {
542 LOG_ERROR("[BleCentralManagerImpl] %{public}s result is faild.", __func__);
543 DoFilterStatusBad();
544 return;
545 }
546 HandleWaitFilters();
547 }
548
HandleDeleteBleScanFilterResult(uint8_t result)549 void BleCentralManagerImpl::HandleDeleteBleScanFilterResult(uint8_t result)
550 {
551 LOG_DEBUG("[BleCentralManagerImpl] %{public}s:", __func__);
552 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
553 if (result != BLE_SCAN_FILTER_FINISHED) {
554 LOG_ERROR("[BleCentralManagerImpl] %{public}s result is faild.", __func__);
555 DoFilterStatusBad();
556 return;
557 }
558 HandleWaitFilters();
559 }
560
HandleStartBleScanFilterResult(uint8_t result)561 void BleCentralManagerImpl::HandleStartBleScanFilterResult(uint8_t result)
562 {
563 LOG_DEBUG("[BleCentralManagerImpl] %{public}s:", __func__);
564 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
565 if (result != BLE_SCAN_FILTER_FINISHED) {
566 LOG_ERROR("[BleCentralManagerImpl] %{public}s result is faild.", __func__);
567 DoFilterStatusBad();
568 return;
569 }
570 HandleWaitFilters();
571 }
572
HandleStopBleScanFilterResult(uint8_t result)573 void BleCentralManagerImpl::HandleStopBleScanFilterResult(uint8_t result)
574 {
575 LOG_DEBUG("[BleCentralManagerImpl] %{public}s:", __func__);
576 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
577 if (result != BLE_SCAN_FILTER_FINISHED) {
578 LOG_ERROR("[BleCentralManagerImpl] %{public}s result is faild.", __func__);
579
580 if (pimpl->filterStatus_ == BLE_SCAN_FILTER_STATUS_BAD) {
581 LOG_ERROR("[BleCentralManagerImpl] %{public}s result is faild.", __func__);
582 return;
583 }
584 DoFilterStatusBad();
585 }
586
587 HandleWaitFilters();
588 }
589
ScanSetParamResult(uint8_t status,void * context)590 void BleCentralManagerImpl::ScanSetParamResult(uint8_t status, void *context)
591 {
592 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
593
594 auto *centralManager = static_cast<BleCentralManagerImpl *>(context);
595 if ((centralManager != nullptr) && (centralManager->dispatcher_ != nullptr)) {
596 centralManager->dispatcher_->PostTask(std::bind(
597 &BleCentralManagerImpl::HandleGapEvent, centralManager, BLE_GAP_SCAN_PARAM_SET_COMPLETE_EVT, status));
598 }
599 }
600
ScanExSetParamResult(uint8_t status,void * context)601 void BleCentralManagerImpl::ScanExSetParamResult(uint8_t status, void *context)
602 {
603 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
604
605 auto *centralManager = static_cast<BleCentralManagerImpl *>(context);
606 if ((centralManager != nullptr) && (centralManager->dispatcher_ != nullptr)) {
607 centralManager->dispatcher_->PostTask(std::bind(&BleCentralManagerImpl::HandleGapExScanEvent,
608 centralManager,
609 BLE_GAP_EX_SCAN_PARAM_SET_COMPLETE_EVT,
610 status));
611 }
612 }
613
ScanSetEnableResult(uint8_t status,void * context)614 void BleCentralManagerImpl::ScanSetEnableResult(uint8_t status, void *context)
615 {
616 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
617
618 auto *centralManager = static_cast<BleCentralManagerImpl *>(context);
619 if ((centralManager != nullptr) && (centralManager->dispatcher_ != nullptr)) {
620 centralManager->dispatcher_->PostTask(
621 std::bind(&BleCentralManagerImpl::ScanSetEnableResultTask, centralManager, status));
622 (static_cast<BleAdapter *>(centralManager->bleAdapter_))->NotifyAllWaitContinue();
623 }
624 }
625
ScanSetEnableResultTask(uint8_t status) const626 void BleCentralManagerImpl::ScanSetEnableResultTask(uint8_t status) const
627 {
628 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
629 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
630 if (pimpl->isStopScan_) {
631 if (pimpl->stopScanType_ == STOP_SCAN_TYPE_RESOLVING_LIST) {
632 HandleGapEvent(BLE_GAP_RESOLVING_LIST_ADV_SCAN_STOP_COMPLETE_EVT, status);
633 } else {
634 HandleGapEvent(BLE_GAP_SCAN_STOP_COMPLETE_EVT, status);
635 }
636 } else {
637 if (pimpl->stopScanType_ == STOP_SCAN_TYPE_RESOLVING_LIST) {
638 HandleGapEvent(BLE_GAP_RESOLVING_LIST_ADV_SCAN_START_COMPLETE_EVT, status);
639 } else {
640 HandleGapEvent(BLE_GAP_SCAN_START_COMPLETE_EVT, status);
641 }
642 }
643 }
644
ScanExSetEnableResult(uint8_t status,void * context)645 void BleCentralManagerImpl::ScanExSetEnableResult(uint8_t status, void *context)
646 {
647 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
648
649 auto *centralManager = static_cast<BleCentralManagerImpl *>(context);
650 if ((centralManager != nullptr) && (centralManager->dispatcher_ != nullptr)) {
651 centralManager->dispatcher_->PostTask(
652 std::bind(&BleCentralManagerImpl::ScanExSetEnableResultTask, centralManager, status));
653 (static_cast<BleAdapter *>(centralManager->bleAdapter_))->NotifyAllWaitContinue();
654 }
655 }
656
ScanExSetEnableResultTask(uint8_t status) const657 void BleCentralManagerImpl::ScanExSetEnableResultTask(uint8_t status) const
658 {
659 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
660
661 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
662 if (pimpl->isStopScan_) {
663 if (pimpl->stopScanType_ == STOP_SCAN_TYPE_RESOLVING_LIST) {
664 HandleGapExScanEvent(BLE_GAP_EX_RESOLVING_LIST_ADV_SCAN_STOP_COMPLETE_EVT, status);
665 } else {
666 HandleGapExScanEvent(BLE_GAP_EX_SCAN_STOP_COMPLETE_EVT, status);
667 }
668 } else {
669 if (pimpl->stopScanType_ == STOP_SCAN_TYPE_RESOLVING_LIST) {
670 HandleGapExScanEvent(BLE_GAP_EX_RESOLVING_LIST_ADV_SCAN_START_COMPLETE_EVT, status);
671 } else {
672 HandleGapExScanEvent(BLE_GAP_EX_SCAN_START_COMPLETE_EVT, status);
673 }
674 }
675 }
676
StartScan() const677 void BleCentralManagerImpl::StartScan() const
678 {
679 LOG_DEBUG("[BleCentralManagerImpl] %{public}s:<-- Start scan start", __func__);
680
681 int status = AdapterManager::GetInstance()->GetState(BTTransport::ADAPTER_BLE);
682 if (status != BTStateID::STATE_TURN_ON) {
683 LOG_ERROR("[BleCentralManagerImpl] %{public}s:%{public}s", __func__, "Bluetooth adapter is invalid.");
684 pimpl->scanStatus_ = SCAN_NOT_STARTED;
685 centralManagerCallbacks_->OnStartOrStopScanEvent(SCAN_NOT_STARTED, true);
686 return;
687 }
688
689 uint16_t interval = BLE_SCAN_MODE_LOW_POWER_INTERVAL_MS;
690 SetInterval(interval);
691 uint16_t window = BLE_SCAN_MODE_LOW_POWER_WINDOW_MS;
692 SetWindow(window);
693 pimpl->callBackType_ = CALLBACK_TYPE_FIRST_MATCH;
694 Start(false);
695
696 LOG_DEBUG("[BleCentralManagerImpl] %{public}s:<-- Start scan end", __func__);
697 }
698
StartScan(const BleScanSettingsImpl & setting) const699 void BleCentralManagerImpl::StartScan(const BleScanSettingsImpl &setting) const
700 {
701 LOG_DEBUG("[BleCentralManagerImpl] %{public}s:<-- Start scan start", __func__);
702
703 int status = AdapterManager::GetInstance()->GetState(BTTransport::ADAPTER_BLE);
704 if (status != BTStateID::STATE_TURN_ON) {
705 LOG_ERROR("[BleCentralManagerImpl] %{public}s:%{public}s", __func__, "Bluetooth adapter is invalid.");
706 pimpl->scanStatus_ = SCAN_NOT_STARTED;
707 centralManagerCallbacks_->OnStartOrStopScanEvent(SCAN_NOT_STARTED, true);
708 return;
709 }
710
711 pimpl->settings_ = setting;
712 int matchingMode;
713 if (setting.GetReportDelayMillisValue() > 0) {
714 matchingMode = CALLBACK_TYPE_ALL_MATCHES;
715 } else {
716 matchingMode = CALLBACK_TYPE_FIRST_MATCH;
717 }
718 SetScanModeDuration(setting.GetScanMode(), matchingMode);
719 if (matchingMode == CALLBACK_TYPE_FIRST_MATCH) {
720 pimpl->callBackType_ = CALLBACK_TYPE_FIRST_MATCH;
721 } else {
722 pimpl->callBackType_ = CALLBACK_TYPE_ALL_MATCHES;
723 }
724 Start(false);
725
726 LOG_DEBUG("[BleCentralManagerImpl] %{public}s:<-- Start scan end", __func__);
727 }
728
StopScan() const729 void BleCentralManagerImpl::StopScan() const
730 {
731 LOG_DEBUG("[BleCentralManagerImpl] %{public}s:-> Stop scan start", __func__);
732
733 if (pimpl->scanStatus_ == SCAN_NOT_STARTED) {
734 centralManagerCallbacks_->OnStartOrStopScanEvent(SCAN_NOT_STARTED, false);
735 return;
736 }
737
738 Stop();
739
740 LOG_DEBUG("[BleCentralManagerImpl] %{public}s:-> Stop scan end", __func__);
741 }
742
StartOrStopScan(const STOP_SCAN_TYPE & scanType,bool isStartScan) const743 void BleCentralManagerImpl::StartOrStopScan(const STOP_SCAN_TYPE &scanType, bool isStartScan) const
744 {
745 LOG_DEBUG("[BleCentralManagerImpl] %{public}s:-> StartOrStopScan scan start", __func__);
746
747 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
748 int ret;
749 if (BleFeature::GetInstance().IsExtendedScanSupported()) {
750 ret = SetExScanEnable(isStartScan);
751 } else {
752 ret = SetScanEnable(isStartScan);
753 }
754
755 if (ret != BT_SUCCESS) {
756 LOG_ERROR("stop or start extend scan: err: %{public}d isScan : %{public}d", ret, isStartScan);
757 return;
758 }
759 pimpl->stopScanType_ = scanType;
760 pimpl->isStopScan_ = !isStartScan;
761 if (isStartScan) {
762 pimpl->scanStatus_ = SCAN_FAILED_ALREADY_STARTED;
763 LOG_DEBUG("start extend scan successful");
764 } else {
765 if (scanType != STOP_SCAN_TYPE_RESOLVING_LIST) {
766 pimpl->scanStatus_ = SCAN_NOT_STARTED;
767 } else {
768 pimpl->scanStatus_ = SCAN_FAILED_ALREADY_STARTED;
769 }
770 LOG_DEBUG("stop extend scan successful");
771 }
772 }
773
SetActiveScan(bool active) const774 void BleCentralManagerImpl::SetActiveScan(bool active) const
775 {
776 HILOGI("active: %{public}d", active);
777
778 if (active) {
779 pimpl->scanParams_.scanType = BLE_SCAN_TYPE_ACTIVE;
780 } else {
781 pimpl->scanParams_.scanType = BLE_SCAN_TYPE_PASSIVE;
782 }
783 }
784
SetInterval(uint16_t intervalMSecs) const785 void BleCentralManagerImpl::SetInterval(uint16_t intervalMSecs) const
786 {
787 HILOGI("intervalMSecs: %{public}hu", intervalMSecs);
788
789 pimpl->scanParams_.scanInterval = intervalMSecs / BLE_SCAN_UNIT_TIME;
790 }
791
SetWindow(uint16_t windowMSecs) const792 void BleCentralManagerImpl::SetWindow(uint16_t windowMSecs) const
793 {
794 HILOGI("windowMSecs: %{public}hu", windowMSecs);
795
796 pimpl->scanParams_.scanWindow = windowMSecs / BLE_SCAN_UNIT_TIME;
797 }
798
ClearResults() const799 void BleCentralManagerImpl::ClearResults() const
800 {
801 HILOGI("enter");
802
803 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
804 pimpl->bleScanResult_.clear();
805 }
806
SetScanModeDuration(int scanMode,int type) const807 void BleCentralManagerImpl::SetScanModeDuration(int scanMode, int type) const
808 {
809 HILOGI("scanMode: %{public}d, type: %{public}d", scanMode, type);
810
811 switch (scanMode) {
812 case SCAN_MODE_LOW_POWER:
813 SetLowPowerDuration(type);
814 break;
815 case SCAN_MODE_BALANCED:
816 SetBalancedDuration(type);
817 break;
818 case SCAN_MODE_LOW_LATENCY:
819 SetLowLatencyDuration(type);
820 break;
821 case SCAN_MODE_OP_P2_60_3000:
822 SetDutyCycle2Duration(type);
823 break;
824 case SCAN_MODE_OP_P10_60_600:
825 SetDutyCycle10Duration(type);
826 break;
827 case SCAN_MODE_OP_P25_60_240:
828 SetDutyCycle25Duration(type);
829 break;
830 case SCAN_MODE_OP_P100_1000_1000:
831 SetDutyCycle100Duration(type);
832 break;
833 default:
834 break;
835 }
836 HiSysEventWrite(OHOS::HiviewDFX::HiSysEvent::Domain::BT_SERVICE, "BLE_SCAN_DUTY_CYCLE",
837 OHOS::HiviewDFX::HiSysEvent::EventType::STATISTIC, "WINDOW", pimpl->scanParams_.scanWindow,
838 "INTERVAL", pimpl->scanParams_.scanInterval, "TYPE", pimpl->callBackType_);
839 }
840
SetLowPowerDuration(int type) const841 void BleCentralManagerImpl::SetLowPowerDuration(int type) const
842 {
843 if (type == CALLBACK_TYPE_ALL_MATCHES) {
844 uint16_t interval = BLE_SCAN_MODE_BATCH_LOW_POWER_INTERVAL_MS;
845 SetInterval(interval);
846 uint16_t window = BLE_SCAN_MODE_BATCH_LOW_POWER_WINDOW_MS;
847 SetWindow(window);
848 } else {
849 uint16_t interval = BLE_SCAN_MODE_LOW_POWER_INTERVAL_MS;
850 SetInterval(interval);
851 uint16_t window = BLE_SCAN_MODE_LOW_POWER_WINDOW_MS;
852 SetWindow(window);
853 }
854 }
855
SetBalancedDuration(int type) const856 void BleCentralManagerImpl::SetBalancedDuration(int type) const
857 {
858 if (type == CALLBACK_TYPE_ALL_MATCHES) {
859 uint16_t interval = BLE_SCAN_MODE_BATCH_BALANCED_INTERVAL_MS;
860 SetInterval(interval);
861 uint16_t window = BLE_SCAN_MODE_BATCH_BALANCED_WINDOW_MS;
862 SetWindow(window);
863 } else {
864 uint16_t interval = BLE_SCAN_MODE_BALANCED_INTERVAL_MS;
865 SetInterval(interval);
866 uint16_t window = BLE_SCAN_MODE_BALANCED_WINDOW_MS;
867 SetWindow(window);
868 }
869 }
870
SetLowLatencyDuration(int type) const871 void BleCentralManagerImpl::SetLowLatencyDuration(int type) const
872 {
873 if (type == CALLBACK_TYPE_ALL_MATCHES) {
874 uint16_t interval = BLE_SCAN_MODE_BATCH_LOW_LATENCY_INTERVAL_MS;
875 SetInterval(interval);
876 uint16_t window = BLE_SCAN_MODE_BATCH_LOW_LATENCY_WINDOW_MS;
877 SetWindow(window);
878 } else {
879 uint16_t interval = BLE_SCAN_MODE_LOW_LATENCY_INTERVAL_MS;
880 SetInterval(interval);
881 uint16_t window = BLE_SCAN_MODE_LOW_LATENCY_WINDOW_MS;
882 SetWindow(window);
883 }
884 }
885
SetDutyCycle2Duration(int type) const886 void BleCentralManagerImpl::SetDutyCycle2Duration(int type) const
887 {
888 if (type == CALLBACK_TYPE_ALL_MATCHES) {
889 uint16_t interval = BLE_SCAN_MODE_BATCH_OP_P2_60_3000_INTERVAL_MS;
890 SetInterval(interval);
891 uint16_t window = BLE_SCAN_MODE_BATCH_OP_P2_60_3000_WINDOW_MS;
892 SetWindow(window);
893 } else {
894 uint16_t interval = BLE_SCAN_MODE_OP_P2_60_3000_INTERVAL_MS;
895 SetInterval(interval);
896 uint16_t window = BLE_SCAN_MODE_OP_P2_60_3000_WINDOW_MS;
897 SetWindow(window);
898 }
899 }
900
SetDutyCycle10Duration(int type) const901 void BleCentralManagerImpl::SetDutyCycle10Duration(int type) const
902 {
903 if (type == CALLBACK_TYPE_ALL_MATCHES) {
904 uint16_t interval = BLE_SCAN_MODE_BATCH_OP_P10_60_600_INTERVAL_MS;
905 SetInterval(interval);
906 uint16_t window = BLE_SCAN_MODE_BATCH_OP_P10_60_600_WINDOW_MS;
907 SetWindow(window);
908 } else {
909 uint16_t interval = BLE_SCAN_MODE_OP_P10_60_600_INTERVAL_MS;
910 SetInterval(interval);
911 uint16_t window = BLE_SCAN_MODE_OP_P10_60_600_WINDOW_MS;
912 SetWindow(window);
913 }
914 }
915
SetDutyCycle25Duration(int type) const916 void BleCentralManagerImpl::SetDutyCycle25Duration(int type) const
917 {
918 if (type == CALLBACK_TYPE_ALL_MATCHES) {
919 uint16_t interval = BLE_SCAN_MODE_BATCH_OP_P25_60_240_INTERVAL_MS;
920 SetInterval(interval);
921 uint16_t window = BLE_SCAN_MODE_BATCH_OP_P25_60_240_WINDOW_MS;
922 SetWindow(window);
923 } else {
924 uint16_t interval = BLE_SCAN_MODE_OP_P25_60_240_INTERVAL_MS;
925 SetInterval(interval);
926 uint16_t window = BLE_SCAN_MODE_OP_P25_60_240_WINDOW_MS;
927 SetWindow(window);
928 }
929 }
930
SetDutyCycle100Duration(int type) const931 void BleCentralManagerImpl::SetDutyCycle100Duration(int type) const
932 {
933 if (type == CALLBACK_TYPE_ALL_MATCHES) {
934 uint16_t interval = BLE_SCAN_MODE_BATCH_OP_P100_1000_1000_INTERVAL_MS;
935 SetInterval(interval);
936 uint16_t window = BLE_SCAN_MODE_BATCH_OP_P100_1000_1000_WINDOW_MS;
937 SetWindow(window);
938 } else {
939 uint16_t interval = BLE_SCAN_MODE_OP_P100_1000_1000_INTERVAL_MS;
940 SetInterval(interval);
941 uint16_t window = BLE_SCAN_MODE_OP_P100_1000_1000_WINDOW_MS;
942 SetWindow(window);
943 }
944 }
945
TimerCallback(void * context)946 void BleCentralManagerImpl::TimerCallback(void *context)
947 {
948 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
949
950 auto *centralManager = static_cast<BleCentralManagerImpl *>(context);
951 if ((centralManager != nullptr) && (centralManager->dispatcher_ != nullptr)) {
952 centralManager->dispatcher_->PostTask(
953 std::bind(&BleCentralManagerImpl::HandleGapEvent, centralManager, BLE_GAP_SCAN_DELAY_REPORT_RESULT_EVT, 0));
954 centralManager->dispatcher_->PostTask(std::bind(&BleCentralManagerImpl::StopScan, centralManager));
955 }
956 }
957
SetScanParamToGap() const958 int BleCentralManagerImpl::SetScanParamToGap() const
959 {
960 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
961
962 GapLeScanParam param;
963 param.scanType = pimpl->scanParams_.scanType;
964 param.param.scanInterval = pimpl->scanParams_.scanInterval;
965 param.param.scanWindow = pimpl->scanParams_.scanWindow;
966 return GAPIF_LeScanSetParam(param, pimpl->scanParams_.scanFilterPolicy);
967 }
968
SetExScanParamToGap() const969 int BleCentralManagerImpl::SetExScanParamToGap() const
970 {
971 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
972
973 std::vector<GapLeScanParam> params;
974 uint8_t scanPhys = GAP_EX_SCAN_PHY_1M;
975 if (pimpl->settings_.GetLegacy()) {
976 GapLeScanParam param;
977 param.scanType = pimpl->scanParams_.scanType;
978 param.param.scanInterval = pimpl->scanParams_.scanInterval;
979 param.param.scanWindow = pimpl->scanParams_.scanWindow;
980 params.push_back(param);
981 } else {
982 switch (pimpl->settings_.GetPhy()) {
983 case PHY_LE_CODED:
984 scanPhys = GAP_EX_SCAN_PHY_CODED;
985 GapLeScanParam paramCoded;
986 paramCoded.scanType = pimpl->scanParams_.scanType;
987 paramCoded.param.scanInterval = pimpl->scanParams_.scanInterval;
988 paramCoded.param.scanWindow = pimpl->scanParams_.scanWindow;
989 params.push_back(paramCoded);
990 break;
991 case PHY_LE_ALL_SUPPORTED:
992 scanPhys = GAP_EX_SCAN_PHY_1M | GAP_EX_SCAN_PHY_CODED;
993 GapLeScanParam param1M;
994 param1M.scanType = pimpl->scanParams_.scanType;
995 param1M.param.scanInterval = pimpl->scanParams_.scanInterval;
996 param1M.param.scanWindow = pimpl->scanParams_.scanWindow;
997 params.push_back(param1M);
998
999 GapLeScanParam paramCodedAll;
1000 paramCodedAll.scanType = pimpl->scanParams_.scanType;
1001 paramCodedAll.param.scanInterval = pimpl->scanParams_.scanInterval;
1002 paramCodedAll.param.scanWindow = pimpl->scanParams_.scanWindow;
1003 params.push_back(paramCodedAll);
1004 break;
1005 case PHY_LE_1M:
1006 default:
1007 scanPhys = GAP_EX_SCAN_PHY_1M;
1008 GapLeScanParam param;
1009 param.scanType = pimpl->scanParams_.scanType;
1010 param.param.scanInterval = pimpl->scanParams_.scanInterval;
1011 param.param.scanWindow = pimpl->scanParams_.scanWindow;
1012 params.push_back(param);
1013 break;
1014 }
1015 }
1016 return GAPIF_LeExScanSetParam(pimpl->scanParams_.scanFilterPolicy, scanPhys, ¶ms[0]);
1017 }
1018
SetScanEnable(bool enable) const1019 int BleCentralManagerImpl::SetScanEnable(bool enable) const
1020 {
1021 LOG_DEBUG("[BleCentralManagerImpl] %{public}s:%{public}d", __func__, enable);
1022
1023 return GAPIF_LeScanSetEnable(enable, isDuplicates_);
1024 }
1025
SetExScanEnable(bool enable) const1026 int BleCentralManagerImpl::SetExScanEnable(bool enable) const
1027 {
1028 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1029
1030 return GAPIF_LeExScanSetEnable(enable, isDuplicates_, 0, 0);
1031 }
1032
StartReportDelay()1033 void BleCentralManagerImpl::impl::StartReportDelay()
1034 {
1035 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1036
1037 if ((settings_.GetReportDelayMillisValue() > 0) && (callBackType_ == CALLBACK_TYPE_ALL_MATCHES)) {
1038 if (timer_ == nullptr) {
1039 timer_ = std::make_unique<utility::Timer>(std::bind(&TimerCallback, bleCentralManagerImpl_));
1040 }
1041 timer_->Start(settings_.GetReportDelayMillisValue());
1042 }
1043 }
1044
SetLegacyScanParamToGap() const1045 bool BleCentralManagerImpl::SetLegacyScanParamToGap() const
1046 {
1047 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1048
1049 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1050 bool ret = true;
1051 ret = pimpl->RegisterCallbackToGap();
1052 if (ret != BT_SUCCESS) {
1053 LOG_ERROR("[BleCentralManagerImpl] %{public}s:RegisterCallbackToGap failed.", __func__);
1054 pimpl->scanStatus_ = SCAN_NOT_STARTED;
1055 centralManagerCallbacks_->OnStartOrStopScanEvent(SCAN_FAILED_INTERNAL_ERROR, true);
1056 return false;
1057 }
1058
1059 pimpl->isStopScan_ = false;
1060 ret = SetScanParamToGap();
1061 if (ret != BT_SUCCESS) {
1062 LOG_ERROR("[BleCentralManagerImpl] %{public}s:SetScanParamToGap failed.", __func__);
1063 pimpl->scanStatus_ = SCAN_NOT_STARTED;
1064 centralManagerCallbacks_->OnStartOrStopScanEvent(SCAN_FAILED_INTERNAL_ERROR, true);
1065 return false;
1066 }
1067 return ret;
1068 }
1069
SetExtendScanParamToGap() const1070 bool BleCentralManagerImpl::SetExtendScanParamToGap() const
1071 {
1072 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1073
1074 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1075 bool ret = true;
1076 ret = pimpl->RegisterExScanCallbackToGap();
1077 if (ret != BT_SUCCESS) {
1078 LOG_ERROR("[BleCentralManagerImpl] %{public}s:RegisterExScanCallbackToGap failed.", __func__);
1079 pimpl->scanStatus_ = SCAN_NOT_STARTED;
1080 centralManagerCallbacks_->OnStartOrStopScanEvent(SCAN_FAILED_INTERNAL_ERROR, true);
1081 return false;
1082 }
1083
1084 pimpl->isStopScan_ = false;
1085 ret = SetExScanParamToGap();
1086 if (ret != BT_SUCCESS) {
1087 LOG_ERROR("[BleCentralManagerImpl] %{public}s:SetExScanParamToGap failed.", __func__);
1088 pimpl->scanStatus_ = SCAN_NOT_STARTED;
1089 centralManagerCallbacks_->OnStartOrStopScanEvent(SCAN_FAILED_INTERNAL_ERROR, true);
1090 return false;
1091 }
1092 return ret;
1093 }
1094
SetScanParamOrExScanParamToGap() const1095 bool BleCentralManagerImpl::SetScanParamOrExScanParamToGap() const
1096 {
1097 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1098
1099 bool ret = true;
1100 if (BleFeature::GetInstance().IsExtendedScanSupported()) {
1101 ret = SetExtendScanParamToGap();
1102 } else {
1103 ret = SetLegacyScanParamToGap();
1104 }
1105 return ret;
1106 }
1107
LoadBleScanFilterLib()1108 NO_SANITIZE("cfi") void BleCentralManagerImpl::LoadBleScanFilterLib()
1109 {
1110 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1111
1112 if (bleScanFilterLib_ == nullptr) {
1113 bleScanFilterLib_ = dlopen(BLE_SCAN_FILTER_LIB_NAME, RTLD_LAZY | RTLD_NODELETE);
1114 }
1115 if (bleScanFilterLib_ == nullptr) {
1116 LOG_ERROR("[BleCentralManagerImpl] %{public}s Load lib failed", __func__);
1117 return;
1118 }
1119 if (bleScanFilter_ != nullptr) {
1120 LOG_DEBUG("[BleCentralManagerImpl] %{public}s bleScanFilter_ is not null.", __func__);
1121 return;
1122 }
1123 createBleScanFilter createBleScanFilterFunc =
1124 (createBleScanFilter)dlsym(bleScanFilterLib_, "CreateBleScanFilter");
1125 if (createBleScanFilterFunc == nullptr) {
1126 LOG_ERROR("[BleCentralManagerImpl] %{public}s Load symbol CreateBleScanFilter failed", __func__);
1127 if (bleScanFilterLib_ != nullptr) {
1128 dlclose(bleScanFilterLib_);
1129 bleScanFilterLib_ = nullptr;
1130 }
1131 return;
1132 }
1133 bleScanFilter_ = createBleScanFilterFunc();
1134 if (bleScanFilter_ == nullptr) {
1135 LOG_ERROR("[BleCentralManagerImpl] %{public}s Load bleScanFilter failed", __func__);
1136 if (bleScanFilterLib_ != nullptr) {
1137 dlclose(bleScanFilterLib_);
1138 bleScanFilterLib_ = nullptr;
1139 }
1140 }
1141 }
1142
UnloadBleScanFilterLib()1143 void BleCentralManagerImpl::UnloadBleScanFilterLib()
1144 {
1145 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1146
1147 if (bleScanFilterLib_ != nullptr) {
1148 destroyBleScanFilter destroyBleScanFilterFunc =
1149 (destroyBleScanFilter)dlsym(bleScanFilterLib_, "DestroyBleScanFilter");
1150 if (destroyBleScanFilterFunc == nullptr) {
1151 LOG_ERROR("[BleCentralManagerImpl] %{public}s Load symbol DestroyBleScanFilter failed", __func__);
1152 } else if (bleScanFilter_ != nullptr) {
1153 destroyBleScanFilterFunc(bleScanFilter_);
1154 }
1155 dlclose(bleScanFilterLib_);
1156 bleScanFilterLib_ = nullptr;
1157 }
1158 bleScanFilter_ = nullptr;
1159 }
1160
ConfigScanFilter(int32_t scannerId,const std::vector<BleScanFilterImpl> & filters)1161 int BleCentralManagerImpl::ConfigScanFilter(int32_t scannerId, const std::vector<BleScanFilterImpl> &filters)
1162 {
1163 LOG_DEBUG("[BleCentralManagerImpl] %{public}s:-> Config scan filter filterStatus_=%{public}d",
1164 __func__, pimpl->filterStatus_);
1165 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1166 if (!CheckScanFilterConfig(filters)) {
1167 return 0;
1168 }
1169
1170 if (filters.empty()) {
1171 BleScanFilterImpl filter;
1172 PushFilterToWaitList(filter, scannerId, FILTER_ACTION_ADD);
1173 } else {
1174 for (auto filter : filters) {
1175 PushFilterToWaitList(filter, scannerId, FILTER_ACTION_ADD);
1176 }
1177 }
1178 PushStartOrStopAction(scannerId, FILTER_ACTION_START);
1179
1180 if ((pimpl->filterStatus_ == BLE_SCAN_FILTER_STATUS_BAD) &&
1181 (pimpl->filters_.size() <= pimpl->venderMaxFilterNumber_)) {
1182 TryConfigScanFilter(scannerId);
1183 }
1184
1185 if (pimpl->filterStatus_ == BLE_SCAN_FILTER_STATUS_IDLE) {
1186 HandleWaitFilters();
1187 }
1188 return 0;
1189 }
1190
CheckScanFilterConfig(const std::vector<BleScanFilterImpl> & filters)1191 bool BleCentralManagerImpl::CheckScanFilterConfig(const std::vector<BleScanFilterImpl> &filters)
1192 {
1193 if (bleScanFilter_ == nullptr) {
1194 return false;
1195 }
1196
1197 int status = AdapterManager::GetInstance()->GetState(BTTransport::ADAPTER_BLE);
1198 if (status != BTStateID::STATE_TURN_ON) {
1199 LOG_ERROR("[BleCentralManagerImpl] %{public}s:%{public}s", __func__, "Bluetooth adapter is invalid.");
1200 return false;
1201 }
1202
1203 uint8_t filterSize;
1204 if (filters.empty()) {
1205 filterSize = 1;
1206 } else {
1207 filterSize = filters.size();
1208 }
1209
1210 if ((filterSize + pimpl->filters_.size()) >= UCHAR_MAX) {
1211 LOG_ERROR("[BleCentralManagerImpl] %{public}s:%{public}s", __func__, "filter array is full.");
1212 return false;
1213 }
1214 if (pimpl->venderMaxFilterNumber_ == 0) {
1215 pimpl->venderMaxFilterNumber_ = bleScanFilter_->GetMaxFilterNumber();
1216 LOG_DEBUG("[BleCentralManagerImpl] %{public}s:-> vender max filter number_ is %{public}d",
1217 __func__, pimpl->venderMaxFilterNumber_);
1218 }
1219
1220 if (pimpl->venderMaxFilterNumber_ <= 0) {
1221 return false;
1222 }
1223
1224 return true;
1225 }
1226
PushFilterToWaitList(BleScanFilterImpl filter,int scannerId,uint8_t action)1227 void BleCentralManagerImpl::PushFilterToWaitList(BleScanFilterImpl filter, int scannerId, uint8_t action)
1228 {
1229 filter.SetFilterAction(action);
1230 if (action == FILTER_ACTION_ADD) {
1231 filter.SetClientId(scannerId);
1232 if (pimpl->releaseFiltIndex_.empty()) {
1233 filter.SetFiltIndex(pimpl->currentFiltIndex_++);
1234 } else {
1235 filter.SetFiltIndex(*pimpl->releaseFiltIndex_.begin());
1236 pimpl->releaseFiltIndex_.remove(filter.GetFiltIndex());
1237 }
1238
1239 pimpl->filters_[filter.GetFiltIndex()] = filter;
1240 }
1241
1242 if (pimpl->filterStatus_ != BLE_SCAN_FILTER_STATUS_BAD) {
1243 pimpl->waitFilters_.push(filter);
1244 }
1245 }
1246
PushStartOrStopAction(const int scannerId,uint8_t action)1247 void BleCentralManagerImpl::PushStartOrStopAction(const int scannerId, uint8_t action)
1248 {
1249 BleScanFilterImpl filterImpl;
1250 PushFilterToWaitList(filterImpl, scannerId, action);
1251 }
1252
HandleWaitFilters()1253 void BleCentralManagerImpl::HandleWaitFilters()
1254 {
1255 if (pimpl->waitFilters_.empty()) {
1256 LOG_ERROR("[BleCentralManagerImpl] %{public}s:%{public}s", __func__, "there is no wait action.");
1257 pimpl->filterStatus_ = BLE_SCAN_FILTER_STATUS_IDLE;
1258 return;
1259 }
1260
1261 BleScanFilterImpl waitFilter = pimpl->waitFilters_.front();
1262 pimpl->waitFilters_.pop();
1263
1264 uint8_t action = waitFilter.GetFilterAction();
1265 LOG_ERROR("[BleCentralManagerImpl] %{public}s: wait action %{public}d", __func__, action);
1266 switch (action) {
1267 case FILTER_ACTION_ADD:
1268 AddBleScanFilter(waitFilter);
1269 break;
1270 case FILTER_ACTION_DELETE:
1271 DeleteBleScanFilter(waitFilter);
1272 break;
1273 case FILTER_ACTION_START:
1274 StartBleScanFilter();
1275 break;
1276 case FILTER_ACTION_STOP:
1277 if (pimpl->waitFilters_.empty() && pimpl->filters_.empty()) {
1278 StopBleScanFilter();
1279 }
1280 break;
1281 default: {
1282 LOG_ERROR("[BleCentralManagerImpl] %{public}s: error action %{public}d", __func__, action);
1283 }
1284 }
1285 }
1286
TryConfigScanFilter(int scannerId)1287 void BleCentralManagerImpl::TryConfigScanFilter(int scannerId)
1288 {
1289 LOG_ERROR("[BleCentralManagerImpl] %{public}s: ", __func__);
1290 pimpl->filterStatus_ = BLE_SCAN_FILTER_STATUS_IDLE;
1291
1292 pimpl->currentFiltIndex_ = 0;
1293 pimpl->releaseFiltIndex_.clear();
1294 std::map<uint8_t, BleScanFilterImpl> filters;
1295
1296 for (auto it = pimpl->filters_.begin(); it != pimpl->filters_.end(); it++) {
1297 BleScanFilterImpl filter = it->second;
1298 filter.SetFiltIndex(pimpl->currentFiltIndex_++);
1299 pimpl->waitFilters_.push(filter);
1300 filters[filter.GetFiltIndex()] = filter;
1301 }
1302 pimpl->filters_ = filters;
1303
1304 PushStartOrStopAction(scannerId, FILTER_ACTION_START);
1305 }
1306
RemoveScanFilter(int32_t scannerId)1307 void BleCentralManagerImpl::RemoveScanFilter(int32_t scannerId)
1308 {
1309 LOG_DEBUG("[BleCentralManagerImpl] %{public}s:-> Remove scan filter", __func__);
1310 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1311
1312 if (bleScanFilter_ == nullptr) {
1313 return;
1314 }
1315
1316 for (auto it = pimpl->filters_.begin(); it != pimpl->filters_.end();) {
1317 if (it->second.GetClientId() == scannerId) {
1318 PushFilterToWaitList(it->second, scannerId, FILTER_ACTION_DELETE);
1319 pimpl->releaseFiltIndex_.push_back(it->first);
1320 pimpl->filters_.erase(it++);
1321 } else {
1322 it++;
1323 }
1324 }
1325 pimpl->releaseFiltIndex_.sort();
1326 PushStartOrStopAction(scannerId, FILTER_ACTION_STOP);
1327
1328 if (pimpl->filterStatus_ == BLE_SCAN_FILTER_STATUS_IDLE) {
1329 HandleWaitFilters();
1330 }
1331 }
1332
AllocScannerId()1333 int32_t BleCentralManagerImpl::AllocScannerId()
1334 {
1335 int32_t scannerId = 0;
1336 for (int32_t i = 1; i < BLE_SCAN_MAX_NUM; i++) {
1337 if (scannerIds_.find(i) == scannerIds_.end()) {
1338 scannerId = i;
1339 scannerIds_.insert(scannerId);
1340 break;
1341 }
1342 }
1343 LOG_DEBUG("[BleCentralManagerImpl] AllocScannerId scannerId: %{public}d", scannerId);
1344 return scannerId;
1345 }
1346
RemoveScannerId(int32_t scannerId)1347 void BleCentralManagerImpl::RemoveScannerId(int32_t scannerId)
1348 {
1349 LOG_DEBUG("[BleCentralManagerImpl] RemoveScannerId scannerId: %{public}d", scannerId);
1350 scannerIds_.erase(scannerId);
1351 }
1352
ClearScannerIds()1353 void BleCentralManagerImpl::ClearScannerIds()
1354 {
1355 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1356 scannerIds_.clear();
1357 }
1358
AddBleScanFilter(BleScanFilterImpl filter)1359 void BleCentralManagerImpl::AddBleScanFilter(BleScanFilterImpl filter)
1360 {
1361 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1362 if (bleScanFilter_ == nullptr) {
1363 LOG_ERROR("[BleCentralManagerImpl] %{public}s bleScanFilter_ is null.", __func__);
1364 DoFilterStatusBad();
1365 return;
1366 }
1367
1368 pimpl->filterStatus_ = BLE_SCAN_FILTER_STATUS_WORKING;
1369
1370 BleScanFilterParam filterParam;
1371 filterParam.filtIndex = filter.GetFiltIndex();
1372 BleScanFilterParamAddDeviceAddress(filterParam, filter);
1373 BleScanFilterParamAddName(filterParam, filter);
1374 BleScanFilterParamAddServiceUuid(filterParam, filter);
1375 BleScanFilterParamAddSolicitationUuid(filterParam, filter);
1376 BleScanFilterParamAddServiceData(filterParam, filter);
1377 BleScanFilterParamAddManufactureData(filterParam, filter);
1378
1379 BleScanFilterCallback filterCallback;
1380 filterCallback.addBleScanFilterResult = &AddBleScanFilterResult;
1381 filterCallback.deleteBleScanFilterResult = nullptr;
1382 filterCallback.startBleScanFilterResult = nullptr;
1383 filterCallback.stopBleScanFilterResult = nullptr;
1384 filterCallback.context = pimpl->bleCentralManagerImpl_;
1385 bleScanFilter_->AddBleScanFilter(filterParam, filterCallback);
1386 }
1387
DeleteBleScanFilter(BleScanFilterImpl filter)1388 void BleCentralManagerImpl::DeleteBleScanFilter(BleScanFilterImpl filter)
1389 {
1390 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1391 if (bleScanFilter_ == nullptr) {
1392 LOG_ERROR("[BleCentralManagerImpl] %{public}s bleScanFilter_ is null.", __func__);
1393 DoFilterStatusBad();
1394 return;
1395 }
1396
1397 pimpl->filterStatus_ = BLE_SCAN_FILTER_STATUS_WORKING;
1398
1399 BleScanFilterParam filterParam;
1400 filterParam.filtIndex = filter.GetFiltIndex();
1401
1402 BleScanFilterCallback filterCallback;
1403 filterCallback.addBleScanFilterResult = nullptr;
1404 filterCallback.deleteBleScanFilterResult = &DeleteBleScanFilterResult;
1405 filterCallback.startBleScanFilterResult = nullptr;
1406 filterCallback.stopBleScanFilterResult = nullptr;
1407 filterCallback.context = pimpl->bleCentralManagerImpl_;
1408 bleScanFilter_->DeleteBleScanFilter(filterParam, filterCallback);
1409 }
1410
BleScanFilterParamAddDeviceAddress(BleScanFilterParam & filterParam,BleScanFilterImpl filter)1411 void BleCentralManagerImpl::BleScanFilterParamAddDeviceAddress(
1412 BleScanFilterParam &filterParam, BleScanFilterImpl filter)
1413 {
1414 std::string deviceId = filter.GetDeviceId();
1415 if (!deviceId.empty()) {
1416 BtAddr btAddr;
1417 RawAddress(deviceId).ConvertToUint8(btAddr.addr);
1418 btAddr.type = BT_DEVICE_ADDRESS_TYPE_ALL;
1419 filterParam.address = btAddr;
1420 filterParam.filterFlag |= FILTER_FLAG_ADDRESS;
1421 }
1422 }
1423
BleScanFilterParamAddName(BleScanFilterParam & filterParam,BleScanFilterImpl filter)1424 void BleCentralManagerImpl::BleScanFilterParamAddName(
1425 BleScanFilterParam &filterParam, BleScanFilterImpl filter)
1426 {
1427 std::string name = filter.GetName();
1428 if (!name.empty()) {
1429 filterParam.name = name;
1430 filterParam.filterFlag |= FILTER_FLAG_NAME;
1431 }
1432 }
1433
BleScanFilterParamAddServiceUuid(BleScanFilterParam & filterParam,BleScanFilterImpl filter)1434 void BleCentralManagerImpl::BleScanFilterParamAddServiceUuid(
1435 BleScanFilterParam &filterParam, BleScanFilterImpl filter)
1436 {
1437 if (filter.HasServiceUuid()) {
1438 filterParam.serviceUuid = filter.GetServiceUuid();
1439 if (filter.HasServiceUuidMask()) {
1440 filterParam.serviceUuidMask = filter.GetServiceUuidMask();
1441 } else {
1442 filterParam.serviceUuidMask = Uuid::ConvertFrom128Bits(DEFAULT_UUID_MASK);
1443 }
1444 filterParam.filterFlag |= FILTER_FLAG_SERVICE_UUID;
1445 }
1446 }
1447
BleScanFilterParamAddSolicitationUuid(BleScanFilterParam & filterParam,BleScanFilterImpl filter)1448 void BleCentralManagerImpl::BleScanFilterParamAddSolicitationUuid(
1449 BleScanFilterParam &filterParam, BleScanFilterImpl filter)
1450 {
1451 if (filter.HasSolicitationUuid()) {
1452 filterParam.solicitationUuid = filter.GetServiceSolicitationUuid();
1453 if (filter.HasSolicitationUuidMask()) {
1454 filterParam.solicitationUuidMask = filter.GetServiceSolicitationUuidMask();
1455 } else {
1456 filterParam.solicitationUuidMask = Uuid::ConvertFrom128Bits(DEFAULT_UUID_MASK);
1457 }
1458 filterParam.filterFlag |= FILTER_FLAG_SOLICIT_UUID;
1459 }
1460 }
1461
BleScanFilterParamAddServiceData(BleScanFilterParam & filterParam,BleScanFilterImpl filter)1462 void BleCentralManagerImpl::BleScanFilterParamAddServiceData(
1463 BleScanFilterParam &filterParam, BleScanFilterImpl filter)
1464 {
1465 std::vector<uint8_t> serviceData = filter.GetServiceData();
1466 std::vector<uint8_t> serviceDataMask = filter.GetServiceDataMask();
1467 if (!serviceData.empty()) {
1468 if (serviceData.size() != serviceDataMask.size()) {
1469 LOG_ERROR("[BleCentralManagerImpl] %{public}s:serviceDataMask size is different with serviceData",
1470 __func__);
1471 serviceDataMask.clear();
1472 for (size_t i = 0; i < serviceData.size(); i++) {
1473 serviceDataMask.push_back(0xFF);
1474 }
1475 }
1476 filterParam.serviceData = serviceData;
1477 filterParam.serviceDataMask = serviceDataMask;
1478 filterParam.filterFlag |= FILTER_FLAG_SERVICE_DATA;
1479 }
1480 }
1481
BleScanFilterParamAddManufactureData(BleScanFilterParam & filterParam,BleScanFilterImpl filter)1482 void BleCentralManagerImpl::BleScanFilterParamAddManufactureData(
1483 BleScanFilterParam &filterParam, BleScanFilterImpl filter)
1484 {
1485 uint16_t manufacturerId = filter.GetManufacturerId();
1486 std::vector<uint8_t> manufactureData = filter.GetManufactureData();
1487 std::vector<uint8_t> manufactureDataMask = filter.GetManufactureDataMask();
1488 if (!manufactureData.empty()) {
1489 if (manufactureData.size() != manufactureDataMask.size()) {
1490 LOG_ERROR("[BleCentralManagerImpl] %{public}s:manufactureDataMask size is different with manufactureData",
1491 __func__);
1492 manufactureDataMask.clear();
1493 for (size_t i = 0; i < manufactureData.size(); i++) {
1494 manufactureDataMask.push_back(0xFF);
1495 }
1496 }
1497 filterParam.manufacturerId = manufacturerId;
1498 filterParam.manufacturerIdMask = 0xFFFF;
1499 filterParam.manufacturerData = manufactureData;
1500 filterParam.manufacturerDataMask = manufactureDataMask;
1501 filterParam.filterFlag |= FILTER_FLAG_MANUFACTURER_DATA;
1502 }
1503 }
1504
StartBleScanFilter()1505 void BleCentralManagerImpl::StartBleScanFilter()
1506 {
1507 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1508
1509 if (bleScanFilter_ == nullptr) {
1510 LOG_ERROR("[BleCentralManagerImpl] %{public}s bleScanFilter_ is null.", __func__);
1511 DoFilterStatusBad();
1512 return;
1513 }
1514
1515 pimpl->filterStatus_ = BLE_SCAN_FILTER_STATUS_WORKING;
1516 BleScanFilterCallback filterCallback {};
1517 filterCallback.addBleScanFilterResult = nullptr;
1518 filterCallback.deleteBleScanFilterResult = nullptr;
1519 filterCallback.startBleScanFilterResult = &StartBleScanFilterResult;
1520 filterCallback.stopBleScanFilterResult = nullptr;
1521 filterCallback.context = pimpl->bleCentralManagerImpl_;
1522 bleScanFilter_->StartBleScanFilter(filterCallback);
1523 }
1524
StopBleScanFilter()1525 void BleCentralManagerImpl::StopBleScanFilter()
1526 {
1527 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1528
1529 if (bleScanFilter_ == nullptr) {
1530 if (pimpl->filterStatus_ == BLE_SCAN_FILTER_STATUS_BAD) {
1531 return;
1532 }
1533 LOG_ERROR("[BleCentralManagerImpl] %{public}s bleScanFilter_ is null.", __func__);
1534 DoFilterStatusBad();
1535 return;
1536 }
1537
1538 if (pimpl->filterStatus_ != BLE_SCAN_FILTER_STATUS_BAD) {
1539 pimpl->filterStatus_ = BLE_SCAN_FILTER_STATUS_WORKING;
1540 }
1541
1542 BleScanFilterCallback filterCallback {};
1543 filterCallback.addBleScanFilterResult = nullptr;
1544 filterCallback.deleteBleScanFilterResult = nullptr;
1545 filterCallback.startBleScanFilterResult = nullptr;
1546 filterCallback.stopBleScanFilterResult = &StopBleScanFilterResult;
1547 filterCallback.context = pimpl->bleCentralManagerImpl_;
1548 bleScanFilter_->StopBleScanFilter(filterCallback);
1549 }
1550
DoFilterStatusBad()1551 void BleCentralManagerImpl::DoFilterStatusBad()
1552 {
1553 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1554 pimpl->filterStatus_ = BLE_SCAN_FILTER_STATUS_BAD;
1555 pimpl->waitFilters_ = std::queue<BleScanFilterImpl>();
1556 StopBleScanFilter();
1557 }
1558
Start(bool isContinue) const1559 bool BleCentralManagerImpl::Start(bool isContinue) const
1560 {
1561 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1562
1563 if (pimpl->scanStatus_ == SCAN_FAILED_ALREADY_STARTED) {
1564 LOG_ERROR("[BleCentralManagerImpl] %{public}s:%{public}s", __func__, "Scan already started.");
1565 centralManagerCallbacks_->OnStartOrStopScanEvent(SCAN_FAILED_ALREADY_STARTED, true);
1566 return true;
1567 }
1568
1569 pimpl->scanStatus_ = SCAN_FAILED_ALREADY_STARTED;
1570 pimpl->stopScanType_ = STOP_SCAN_TYPE_NOR;
1571
1572 if (!isContinue) {
1573 ClearResults();
1574 }
1575 return SetScanParamOrExScanParamToGap();
1576 }
1577
Stop() const1578 void BleCentralManagerImpl::Stop() const
1579 {
1580 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1581
1582 int ret;
1583 if (BleFeature::GetInstance().IsExtendedScanSupported()) {
1584 ret = SetExScanEnable(false);
1585 } else {
1586 ret = SetScanEnable(false);
1587 }
1588 if (ret != BT_SUCCESS) {
1589 LOG_ERROR("stop scanning: err: %{public}d", ret);
1590 pimpl->scanStatus_ = SCAN_FAILED_ALREADY_STARTED;
1591 centralManagerCallbacks_->OnStartOrStopScanEvent(SCAN_FAILED_INTERNAL_ERROR, false);
1592 return;
1593 } else {
1594 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1595 pimpl->stopScanType_ = STOP_SCAN_TYPE_NOR;
1596 pimpl->isStopScan_ = true;
1597 pimpl->settings_.SetReportDelay(0);
1598 }
1599 }
1600
GetDeviceType(const std::string & address) const1601 int BleCentralManagerImpl::GetDeviceType(const std::string &address) const
1602 {
1603 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1604
1605 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1606 for (auto value : pimpl->bleScanResult_) {
1607 if (!address.compare(value.GetPeripheralDevice().GetRawAddress().GetAddress())) {
1608 return value.GetPeripheralDevice().GetDeviceType();
1609 }
1610 }
1611 return BLE_BT_DEVICE_TYPE_UNKNOWN;
1612 }
1613
GetDeviceAddrType(const std::string & address) const1614 int BleCentralManagerImpl::GetDeviceAddrType(const std::string &address) const
1615 {
1616 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1617
1618 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1619 for (auto value : pimpl->bleScanResult_) {
1620 if (!address.compare(value.GetPeripheralDevice().GetRawAddress().GetAddress())) {
1621 return value.GetPeripheralDevice().GetAddressType();
1622 }
1623 }
1624 return BLE_ADDR_TYPE_UNKNOWN;
1625 }
1626
GetDeviceName(const std::string & address) const1627 std::string BleCentralManagerImpl::GetDeviceName(const std::string &address) const
1628 {
1629 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1630
1631 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1632 for (auto value : pimpl->bleScanResult_) {
1633 if (!address.compare(value.GetPeripheralDevice().GetRawAddress().GetAddress())) {
1634 return value.GetPeripheralDevice().GetName();
1635 }
1636 }
1637 return std::string("");
1638 }
1639
FindDevice(const std::string & address,BlePeripheralDevice & dev) const1640 bool BleCentralManagerImpl::FindDevice(const std::string &address, BlePeripheralDevice &dev) const
1641 {
1642 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1643
1644 for (auto it = pimpl->bleScanResult_.begin(); it != pimpl->bleScanResult_.end(); it++) {
1645 if (!address.compare(it->GetPeripheralDevice().GetRawAddress().GetAddress())) {
1646 dev = it->GetPeripheralDevice();
1647 pimpl->bleScanResult_.erase(it);
1648 return true;
1649 }
1650 }
1651 return false;
1652 }
1653
GetScanStatus() const1654 int BleCentralManagerImpl::GetScanStatus() const
1655 {
1656 LOG_DEBUG("[BleCentralManagerImpl] %{public}s status:%{public}d", __func__, pimpl->scanStatus_);
1657
1658 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1659 return pimpl->scanStatus_;
1660 }
1661
DirectedAdvertisingReport(uint8_t advType,const BtAddr * addr,GapDirectedAdvReportParam reportParam,const BtAddr * currentAddr,void * context)1662 void BleCentralManagerImpl::DirectedAdvertisingReport(uint8_t advType, const BtAddr *addr,
1663 GapDirectedAdvReportParam reportParam, const BtAddr *currentAddr, void *context)
1664 {
1665 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1666 }
1667
ScanTimeoutEvent(void * context)1668 void BleCentralManagerImpl::ScanTimeoutEvent(void *context)
1669 {
1670 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1671 }
1672
GapScanParamSetCompleteEvt(int status) const1673 void BleCentralManagerImpl::GapScanParamSetCompleteEvt(int status) const
1674 {
1675 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1676
1677 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1678 if (status != BT_SUCCESS) {
1679 pimpl->scanStatus_ = SCAN_NOT_STARTED;
1680 centralManagerCallbacks_->OnStartOrStopScanEvent(SCAN_FAILED_INTERNAL_ERROR, true);
1681 LOG_ERROR("[BleCentralManagerImpl] %{public}s:Set scan param failed! %{public}d.", __func__, status);
1682 return;
1683 }
1684
1685 pimpl->StartReportDelay();
1686 if (pimpl->isStopScan_) {
1687 return;
1688 }
1689 int ret = SetScanEnable(true);
1690 if (ret != BT_SUCCESS) {
1691 LOG_ERROR("[BleCentralManagerImpl] %{public}s:SetScanEnable param failed! %{public}d.", __func__, ret);
1692 pimpl->scanStatus_ = SCAN_NOT_STARTED;
1693 centralManagerCallbacks_->OnStartOrStopScanEvent(SCAN_FAILED_INTERNAL_ERROR, true);
1694 return;
1695 }
1696 }
1697
GapScanResultEvt() const1698 void BleCentralManagerImpl::GapScanResultEvt() const
1699 {
1700 LOG_DEBUG("[BleCentralManagerImpl] %{public}s:Scan result", __func__);
1701
1702 if ((centralManagerCallbacks_ != nullptr) && (pimpl->callBackType_ == CALLBACK_TYPE_FIRST_MATCH)) {
1703 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1704 centralManagerCallbacks_->OnScanCallback(pimpl->bleScanResult_.back());
1705 }
1706 }
1707
GapScanDelayReportResultEvt() const1708 void BleCentralManagerImpl::GapScanDelayReportResultEvt() const
1709 {
1710 LOG_DEBUG("[BleCentralManagerImpl] %{public}s:Scan batch results", __func__);
1711
1712 if ((centralManagerCallbacks_ != nullptr) && (pimpl->callBackType_ == CALLBACK_TYPE_ALL_MATCHES)) {
1713 if (pimpl->timer_ != nullptr) {
1714 pimpl->timer_->Stop();
1715 }
1716 std::lock_guard<std::recursive_mutex> legacyLock(pimpl->mutex_);
1717 centralManagerCallbacks_->OnBleBatchScanResultsEvent(pimpl->bleScanResult_);
1718 }
1719 }
1720
GapScanStartCompleteEvt(int status) const1721 void BleCentralManagerImpl::GapScanStartCompleteEvt(int status) const
1722 {
1723 LOG_DEBUG("[BleCentralManagerImpl] %{public}s:Start scan", __func__);
1724
1725 if (status != BT_SUCCESS) {
1726 pimpl->scanStatus_ = SCAN_NOT_STARTED;
1727 LOG_ERROR("[BleCentralManagerImpl] %{public}s:Start scan failed! %{public}d.", __func__, status);
1728 }
1729 int tmpStatus = (status != BT_SUCCESS ? SCAN_FAILED_INTERNAL_ERROR : SCAN_SUCCESS);
1730 centralManagerCallbacks_->OnStartOrStopScanEvent(tmpStatus, true);
1731 }
1732
GapScanStopCompleteEvt(int status) const1733 void BleCentralManagerImpl::GapScanStopCompleteEvt(int status) const
1734 {
1735 LOG_DEBUG("[BleCentralManagerImpl] %{public}s:Stop scan", __func__);
1736
1737 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1738 if (status != BT_SUCCESS) {
1739 LOG_ERROR("[BleCentralManagerImpl] %{public}s:Stop scan failed! %{public}d.", __func__, status);
1740 }
1741 pimpl->advDataCache_.ClearAllData();
1742 pimpl->scanStatus_ = SCAN_NOT_STARTED;
1743 int tmpStatus = (status != BT_SUCCESS ? SCAN_FAILED_INTERNAL_ERROR : SCAN_SUCCESS);
1744 centralManagerCallbacks_->OnStartOrStopScanEvent(tmpStatus, false);
1745 }
1746
GapScanResolvingCompletEvt(int status,bool isStart) const1747 void BleCentralManagerImpl::GapScanResolvingCompletEvt(int status, bool isStart) const
1748 {
1749 LOG_DEBUG("[BleCentralManagerImpl] %{public}s: ", __func__);
1750
1751 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1752 if (status != BT_SUCCESS) {
1753 pimpl->scanStatus_ = isStart ? SCAN_NOT_STARTED : SCAN_FAILED_ALREADY_STARTED;
1754 LOG_ERROR("[BleCentralManagerImpl] %{public}s:Resovling stop scan failed! %{public}d.", __func__, status);
1755 }
1756 }
1757
HandleGapEvent(const BLE_GAP_CB_EVENT & event,int status) const1758 void BleCentralManagerImpl::HandleGapEvent(const BLE_GAP_CB_EVENT &event, int status) const
1759 {
1760 LOG_DEBUG("[BleCentralManagerImpl] %{public}s:[event no: %{public}d]", __func__, static_cast<int>(event));
1761
1762 switch (event) {
1763 case BLE_GAP_SCAN_PARAM_SET_COMPLETE_EVT:
1764 GapScanParamSetCompleteEvt(status);
1765 break;
1766 case BLE_GAP_SCAN_RESULT_EVT:
1767 GapScanResultEvt();
1768 break;
1769 case BLE_GAP_SCAN_DELAY_REPORT_RESULT_EVT:
1770 GapScanDelayReportResultEvt();
1771 break;
1772 case BLE_GAP_SCAN_START_COMPLETE_EVT:
1773 GapScanStartCompleteEvt(status);
1774 break;
1775 case BLE_GAP_RESOLVING_LIST_ADV_SCAN_START_COMPLETE_EVT:
1776 GapScanResolvingCompletEvt(status, true);
1777 break;
1778 case BLE_GAP_SCAN_STOP_COMPLETE_EVT:
1779 GapScanStopCompleteEvt(status);
1780 break;
1781 case BLE_GAP_RESOLVING_LIST_ADV_SCAN_STOP_COMPLETE_EVT:
1782 GapScanResolvingCompletEvt(status, false);
1783 break;
1784 default: {
1785 LOG_ERROR("[BleCentralManagerImpl] %{public}s:Invalid event! %{public}d.", __func__, event);
1786 break;
1787 }
1788 }
1789 }
1790
GapExScanParamSetCompleteEvt(int status) const1791 void BleCentralManagerImpl::GapExScanParamSetCompleteEvt(int status) const
1792 {
1793 LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1794
1795 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1796 if (status != BT_SUCCESS) {
1797 pimpl->scanStatus_ = SCAN_NOT_STARTED;
1798 LOG_ERROR("[BleCentralManagerImpl] %{public}s:Set scan param failed! %{public}d.", __func__, status);
1799 centralManagerCallbacks_->OnStartOrStopScanEvent(SCAN_FAILED_INTERNAL_ERROR, true);
1800 return;
1801 }
1802 pimpl->StartReportDelay();
1803 if (pimpl->isStopScan_) {
1804 return;
1805 }
1806 int ret = SetExScanEnable(true);
1807 if (ret != BT_SUCCESS) {
1808 LOG_ERROR("[BleCentralManagerImpl] %{public}s:SetExScanEnable param failed! %{public}d.", __func__, ret);
1809 pimpl->scanStatus_ = SCAN_NOT_STARTED;
1810 centralManagerCallbacks_->OnStartOrStopScanEvent(SCAN_FAILED_INTERNAL_ERROR, true);
1811 return;
1812 }
1813 }
1814
GapExScanResultEvt() const1815 void BleCentralManagerImpl::GapExScanResultEvt() const
1816 {
1817 LOG_DEBUG("[BleCentralManagerImpl] %{public}s:Scan result", __func__);
1818
1819 if ((centralManagerCallbacks_ != nullptr) && (pimpl->callBackType_ == CALLBACK_TYPE_FIRST_MATCH)) {
1820 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1821 centralManagerCallbacks_->OnScanCallback(pimpl->bleScanResult_.back());
1822 }
1823 }
1824
GapExScanDelayReportResultEvt() const1825 void BleCentralManagerImpl::GapExScanDelayReportResultEvt() const
1826 {
1827 LOG_DEBUG("[BleCentralManagerImpl] %{public}s:Scan batch results", __func__);
1828
1829 if ((centralManagerCallbacks_ != nullptr) && (pimpl->callBackType_ == CALLBACK_TYPE_ALL_MATCHES)) {
1830 if (pimpl->timer_ != nullptr) {
1831 pimpl->timer_->Stop();
1832 }
1833 std::lock_guard<std::recursive_mutex> exAdvLock(pimpl->mutex_);
1834 centralManagerCallbacks_->OnBleBatchScanResultsEvent(pimpl->bleScanResult_);
1835 }
1836 }
1837
GapExScanStartCompleteEvt(int status) const1838 void BleCentralManagerImpl::GapExScanStartCompleteEvt(int status) const
1839 {
1840 LOG_DEBUG("[BleCentralManagerImpl] %{public}s:Start scan", __func__);
1841
1842 if (status != BT_SUCCESS) {
1843 pimpl->scanStatus_ = SCAN_NOT_STARTED;
1844 LOG_ERROR("[BleCentralManagerImpl] %{public}s:Start scan failed! %{public}d.", __func__, status);
1845 }
1846 int tmpStatus = (status != BT_SUCCESS ? SCAN_FAILED_INTERNAL_ERROR : SCAN_SUCCESS);
1847 centralManagerCallbacks_->OnStartOrStopScanEvent(tmpStatus, true);
1848 }
1849
GapExScanStopCompleteEvt(int status) const1850 void BleCentralManagerImpl::GapExScanStopCompleteEvt(int status) const
1851 {
1852 LOG_DEBUG("[BleCentralManagerImpl] %{public}s:Stop scan", __func__);
1853
1854 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1855 if (status != BT_SUCCESS) {
1856 LOG_ERROR("[BleCentralManagerImpl] %{public}s:Stop scan failed! %{public}d.", __func__, status);
1857 }
1858 pimpl->scanStatus_ = SCAN_NOT_STARTED;
1859 pimpl->advDataCache_.ClearAllData();
1860 int tmpStatus = (status != BT_SUCCESS ? SCAN_FAILED_INTERNAL_ERROR : SCAN_SUCCESS);
1861 centralManagerCallbacks_->OnStartOrStopScanEvent(tmpStatus, false);
1862 }
1863
GapExScanResolvingCompletEvt(int status,bool isStart) const1864 void BleCentralManagerImpl::GapExScanResolvingCompletEvt(int status, bool isStart) const
1865 {
1866 LOG_DEBUG("[BleCentralManagerImpl] %{public}s:", __func__);
1867 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1868 if (status != BT_SUCCESS) {
1869 pimpl->scanStatus_ = isStart ? SCAN_NOT_STARTED : SCAN_FAILED_ALREADY_STARTED;
1870 LOG_ERROR("[BleCentralManagerImpl] %{public}s:Resolving stop scan failed! %{public}d.", __func__, status);
1871 }
1872 }
1873
HandleGapExScanEvent(const BLE_GAP_CB_EVENT & event,int status) const1874 void BleCentralManagerImpl::HandleGapExScanEvent(const BLE_GAP_CB_EVENT &event, int status) const
1875 {
1876 LOG_DEBUG("[BleCentralManagerImpl] %{public}s:[event no: %{public}d]", __func__, static_cast<int>(event));
1877
1878 switch (event) {
1879 case BLE_GAP_EX_SCAN_PARAM_SET_COMPLETE_EVT:
1880 GapExScanParamSetCompleteEvt(status);
1881 break;
1882 case BLE_GAP_EX_SCAN_RESULT_EVT:
1883 GapExScanResultEvt();
1884 break;
1885 case BLE_GAP_EX_SCAN_DELAY_REPORT_RESULT_EVT:
1886 GapExScanDelayReportResultEvt();
1887 break;
1888 case BLE_GAP_EX_SCAN_START_COMPLETE_EVT:
1889 GapExScanStartCompleteEvt(status);
1890 break;
1891 case BLE_GAP_EX_RESOLVING_LIST_ADV_SCAN_START_COMPLETE_EVT:
1892 GapExScanResolvingCompletEvt(status, true);
1893 break;
1894 case BLE_GAP_EX_SCAN_STOP_COMPLETE_EVT:
1895 GapExScanStopCompleteEvt(status);
1896 break;
1897 case BLE_GAP_EX_RESOLVING_LIST_ADV_SCAN_STOP_COMPLETE_EVT:
1898 GapExScanResolvingCompletEvt(status, false);
1899 break;
1900 default: {
1901 LOG_ERROR("[BleCentralManagerImpl] %{public}s:Invalid event! %{public}d.", __func__, event);
1902 break;
1903 }
1904 }
1905 }
1906 } // namespace bluetooth
1907 } // namespace OHOS
1908