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     if (data.size() == 0) {
386         return;
387     }
388 
389     std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
390     RawAddress advAddress(RawAddress::ConvertToString(peerAddr.addr));
391     /// Set whether only legacy advertisments should be returned in scan results.
392     if (pimpl->settings_.GetLegacy()) {
393         if ((advType & BLE_LEGACY_ADV_NONCONN_IND_WITH_EX_ADV) == 0) {
394             HILOGI("Excepted addr: %{public}s, advType = %{public}d",
395                 GetEncryptAddr(advAddress.GetAddress()).c_str(), advType);
396             return;
397         }
398     }
399 
400     /// incomplete data
401     RawAddress advCurrentAddress(RawAddress::ConvertToString(peerCurrentAddr.addr));
402     HILOGI("peerAddr: %{public}s, peerCurrentAddr: %{public}s", GetEncryptAddr(advAddress.GetAddress()).c_str(),
403         GetEncryptAddr(advCurrentAddress.GetAddress()).c_str());
404     std::vector<uint8_t> incompleteData(data.begin(), data.end());
405     if (ExtractIncompleteData(advType, advCurrentAddress.GetAddress(), data, incompleteData)) {
406         return;
407     }
408 
409     bool ret = false;
410     BlePeripheralDevice device;
411     if (FindDevice(advAddress.GetAddress(), device)) {
412         ret = AddPeripheralDevice(advType, peerAddr, incompleteData, rssi, device);
413         if (ret) {  /// not discovery
414             pimpl->incompleteData_.clear();
415             return;
416         }
417         HandleGapExScanEvent(BLE_GAP_EX_SCAN_RESULT_EVT, 0);
418         pimpl->incompleteData_.clear();
419         return;
420     }
421 
422     ret = AddPeripheralDevice(advType, peerAddr, incompleteData, rssi, device);
423     if (ret) {  /// not discovery
424         pimpl->incompleteData_.clear();
425         return;
426     }
427     pimpl->incompleteData_.clear();
428     HandleGapExScanEvent(BLE_GAP_EX_SCAN_RESULT_EVT, 0);
429 }
430 
AddPeripheralDevice(uint8_t advType,const BtAddr & peerAddr,const std::vector<uint8_t> & data,int8_t rssi,const BlePeripheralDevice & dev) const431 bool BleCentralManagerImpl::AddPeripheralDevice(uint8_t advType, const BtAddr &peerAddr,
432     const std::vector<uint8_t> &data, int8_t rssi, const BlePeripheralDevice &dev) const
433 {
434     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
435 
436     std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
437     BlePeripheralDevice device = dev;
438     RawAddress advertisedAddress(RawAddress::ConvertToString(peerAddr.addr));
439     device.SetAddress(advertisedAddress);
440     device.SetManufacturerData("");
441     device.SetRSSI(rssi);
442     if (data.size() > 0) {
443         BlePeripheralDeviceParseAdvData parseAdvData = {
444             .payload = const_cast<uint8_t *>(data.data()),
445             .length = data.size(),
446         };
447         device.ParseAdvertiserment(parseAdvData);
448         uint8_t falg = device.GetAdFlag();
449         if (CheckBleScanMode(falg)) {
450             return true;
451         }
452     } else {
453         uint8_t falg = device.GetAdFlag();
454         if (CheckBleScanMode(falg)) {
455             return true;
456         }
457     }
458     device.SetAddressType(peerAddr.type);
459     if ((advType == SCAN_ADV_SCAN_IND) || (advType == SCAN_ADV_NONCONN_IND)) {
460         device.SetConnectable(false);
461     } else if ((advType == SCAN_ADV_IND) || (advType == SCAN_ADV_DIRECT_IND)) {
462         device.SetConnectable(true);
463     }
464 
465     BleScanResultImpl result;
466     result.SetPeripheralDevice(device);
467     pimpl->bleScanResult_.push_back(result);
468 
469     return false;
470 }
471 
CheckBleScanMode(uint8_t falg)472 bool BleCentralManagerImpl::CheckBleScanMode(uint8_t falg)
473 {
474     LOG_DEBUG("[BleCentralManagerImpl] %{public}s:adv flag = %u", __func__, falg);
475 
476     switch (BleConfig::GetInstance().GetBleScanMode()) {
477         case BLE_SCAN_MODE_NON_DISC:
478             if (falg == BLE_ADV_FLAG_NON_LIMIT_DISC) {
479                 return false;
480             }
481             break;
482         case BLE_SCAN_MODE_GENERAL:
483             if ((falg & BLE_ADV_FLAG_LIMIT_DISC) == BLE_ADV_FLAG_LIMIT_DISC ||
484                 (falg & BLE_ADV_FLAG_GEN_DISC) == BLE_ADV_FLAG_GEN_DISC) {
485                 return false;
486             }
487             break;
488         case BLE_SCAN_MODE_LIMITED:
489             if ((falg & BLE_ADV_FLAG_LIMIT_DISC) == BLE_ADV_FLAG_LIMIT_DISC) {
490                 return false;
491             }
492             break;
493         case BLE_SCAN_MODE_ALL:
494         default:
495             return false;
496     }
497     return true;
498 }
499 
AddBleScanFilterResult(uint8_t result,void * context)500 void BleCentralManagerImpl::AddBleScanFilterResult(uint8_t result, void *context)
501 {
502     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
503     auto *centralManager = static_cast<BleCentralManagerImpl *>(context);
504     if ((centralManager != nullptr) && (centralManager->dispatcher_ != nullptr)) {
505         centralManager->dispatcher_->PostTask(std::bind(
506             &BleCentralManagerImpl::HandleAddBleScanFilterResult, centralManager, result));
507     }
508 }
509 
DeleteBleScanFilterResult(uint8_t result,void * context)510 void BleCentralManagerImpl::DeleteBleScanFilterResult(uint8_t result, void *context)
511 {
512     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
513     auto *centralManager = static_cast<BleCentralManagerImpl *>(context);
514     if ((centralManager != nullptr) && (centralManager->dispatcher_ != nullptr)) {
515         centralManager->dispatcher_->PostTask(std::bind(
516             &BleCentralManagerImpl::HandleDeleteBleScanFilterResult, centralManager, result));
517     }
518 }
519 
StartBleScanFilterResult(uint8_t result,void * context)520 void BleCentralManagerImpl::StartBleScanFilterResult(uint8_t result, void *context)
521 {
522     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
523     auto *centralManager = static_cast<BleCentralManagerImpl *>(context);
524     if ((centralManager != nullptr) && (centralManager->dispatcher_ != nullptr)) {
525         centralManager->dispatcher_->PostTask(std::bind(
526             &BleCentralManagerImpl::HandleStartBleScanFilterResult, centralManager, result));
527     }
528 }
529 
StopBleScanFilterResult(uint8_t result,void * context)530 void BleCentralManagerImpl::StopBleScanFilterResult(uint8_t result, void *context)
531 {
532     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
533     auto *centralManager = static_cast<BleCentralManagerImpl *>(context);
534     if ((centralManager != nullptr) && (centralManager->dispatcher_ != nullptr)) {
535         centralManager->dispatcher_->PostTask(std::bind(
536             &BleCentralManagerImpl::HandleStopBleScanFilterResult, centralManager, result));
537     }
538 }
539 
HandleAddBleScanFilterResult(uint8_t result)540 void BleCentralManagerImpl::HandleAddBleScanFilterResult(uint8_t result)
541 {
542     LOG_DEBUG("[BleCentralManagerImpl] %{public}s:", __func__);
543     std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
544     if (result != BLE_SCAN_FILTER_FINISHED) {
545         LOG_ERROR("[BleCentralManagerImpl] %{public}s result is faild.", __func__);
546         DoFilterStatusBad();
547         return;
548     }
549     HandleWaitFilters();
550 }
551 
HandleDeleteBleScanFilterResult(uint8_t result)552 void BleCentralManagerImpl::HandleDeleteBleScanFilterResult(uint8_t result)
553 {
554     LOG_DEBUG("[BleCentralManagerImpl] %{public}s:", __func__);
555     std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
556     if (result != BLE_SCAN_FILTER_FINISHED) {
557         LOG_ERROR("[BleCentralManagerImpl] %{public}s result is faild.", __func__);
558         DoFilterStatusBad();
559         return;
560     }
561     HandleWaitFilters();
562 }
563 
HandleStartBleScanFilterResult(uint8_t result)564 void BleCentralManagerImpl::HandleStartBleScanFilterResult(uint8_t result)
565 {
566     LOG_DEBUG("[BleCentralManagerImpl] %{public}s:", __func__);
567     std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
568     if (result != BLE_SCAN_FILTER_FINISHED) {
569         LOG_ERROR("[BleCentralManagerImpl] %{public}s result is faild.", __func__);
570         DoFilterStatusBad();
571         return;
572     }
573     HandleWaitFilters();
574 }
575 
HandleStopBleScanFilterResult(uint8_t result)576 void BleCentralManagerImpl::HandleStopBleScanFilterResult(uint8_t result)
577 {
578     LOG_DEBUG("[BleCentralManagerImpl] %{public}s:", __func__);
579     std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
580     if (result != BLE_SCAN_FILTER_FINISHED) {
581         LOG_ERROR("[BleCentralManagerImpl] %{public}s result is faild.", __func__);
582 
583         if (pimpl->filterStatus_ == BLE_SCAN_FILTER_STATUS_BAD) {
584             LOG_ERROR("[BleCentralManagerImpl] %{public}s result is faild.", __func__);
585             return;
586         }
587         DoFilterStatusBad();
588     }
589 
590     HandleWaitFilters();
591 }
592 
ScanSetParamResult(uint8_t status,void * context)593 void BleCentralManagerImpl::ScanSetParamResult(uint8_t status, void *context)
594 {
595     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
596 
597     auto *centralManager = static_cast<BleCentralManagerImpl *>(context);
598     if ((centralManager != nullptr) && (centralManager->dispatcher_ != nullptr)) {
599         centralManager->dispatcher_->PostTask(std::bind(
600             &BleCentralManagerImpl::HandleGapEvent, centralManager, BLE_GAP_SCAN_PARAM_SET_COMPLETE_EVT, status));
601     }
602 }
603 
ScanExSetParamResult(uint8_t status,void * context)604 void BleCentralManagerImpl::ScanExSetParamResult(uint8_t status, void *context)
605 {
606     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
607 
608     auto *centralManager = static_cast<BleCentralManagerImpl *>(context);
609     if ((centralManager != nullptr) && (centralManager->dispatcher_ != nullptr)) {
610         centralManager->dispatcher_->PostTask(std::bind(&BleCentralManagerImpl::HandleGapExScanEvent,
611             centralManager,
612             BLE_GAP_EX_SCAN_PARAM_SET_COMPLETE_EVT,
613             status));
614     }
615 }
616 
ScanSetEnableResult(uint8_t status,void * context)617 void BleCentralManagerImpl::ScanSetEnableResult(uint8_t status, void *context)
618 {
619     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
620 
621     auto *centralManager = static_cast<BleCentralManagerImpl *>(context);
622     if ((centralManager != nullptr) && (centralManager->dispatcher_ != nullptr)) {
623         centralManager->dispatcher_->PostTask(
624             std::bind(&BleCentralManagerImpl::ScanSetEnableResultTask, centralManager, status));
625         (static_cast<BleAdapter *>(centralManager->bleAdapter_))->NotifyAllWaitContinue();
626     }
627 }
628 
ScanSetEnableResultTask(uint8_t status) const629 void BleCentralManagerImpl::ScanSetEnableResultTask(uint8_t status) const
630 {
631     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
632     std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
633     if (pimpl->isStopScan_) {
634         if (pimpl->stopScanType_ == STOP_SCAN_TYPE_RESOLVING_LIST) {
635             HandleGapEvent(BLE_GAP_RESOLVING_LIST_ADV_SCAN_STOP_COMPLETE_EVT, status);
636         } else {
637             HandleGapEvent(BLE_GAP_SCAN_STOP_COMPLETE_EVT, status);
638         }
639     } else {
640         if (pimpl->stopScanType_ == STOP_SCAN_TYPE_RESOLVING_LIST) {
641             HandleGapEvent(BLE_GAP_RESOLVING_LIST_ADV_SCAN_START_COMPLETE_EVT, status);
642         } else {
643             HandleGapEvent(BLE_GAP_SCAN_START_COMPLETE_EVT, status);
644         }
645     }
646 }
647 
ScanExSetEnableResult(uint8_t status,void * context)648 void BleCentralManagerImpl::ScanExSetEnableResult(uint8_t status, void *context)
649 {
650     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
651 
652     auto *centralManager = static_cast<BleCentralManagerImpl *>(context);
653     if ((centralManager != nullptr) && (centralManager->dispatcher_ != nullptr)) {
654         centralManager->dispatcher_->PostTask(
655             std::bind(&BleCentralManagerImpl::ScanExSetEnableResultTask, centralManager, status));
656         (static_cast<BleAdapter *>(centralManager->bleAdapter_))->NotifyAllWaitContinue();
657     }
658 }
659 
ScanExSetEnableResultTask(uint8_t status) const660 void BleCentralManagerImpl::ScanExSetEnableResultTask(uint8_t status) const
661 {
662     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
663 
664     std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
665     if (pimpl->isStopScan_) {
666         if (pimpl->stopScanType_ == STOP_SCAN_TYPE_RESOLVING_LIST) {
667             HandleGapExScanEvent(BLE_GAP_EX_RESOLVING_LIST_ADV_SCAN_STOP_COMPLETE_EVT, status);
668         } else {
669             HandleGapExScanEvent(BLE_GAP_EX_SCAN_STOP_COMPLETE_EVT, status);
670         }
671     } else {
672         if (pimpl->stopScanType_ == STOP_SCAN_TYPE_RESOLVING_LIST) {
673             HandleGapExScanEvent(BLE_GAP_EX_RESOLVING_LIST_ADV_SCAN_START_COMPLETE_EVT, status);
674         } else {
675             HandleGapExScanEvent(BLE_GAP_EX_SCAN_START_COMPLETE_EVT, status);
676         }
677     }
678 }
679 
StartScan(const BleScanSettingsImpl & setting) const680 void BleCentralManagerImpl::StartScan(const BleScanSettingsImpl &setting) const
681 {
682     LOG_DEBUG("[BleCentralManagerImpl] %{public}s:<-- Start scan start", __func__);
683 
684     int status = AdapterManager::GetInstance()->GetState(BTTransport::ADAPTER_BLE);
685     if (status != BTStateID::STATE_TURN_ON) {
686         LOG_ERROR("[BleCentralManagerImpl] %{public}s:%{public}s", __func__, "Bluetooth adapter is invalid.");
687         pimpl->scanStatus_ = SCAN_NOT_STARTED;
688         centralManagerCallbacks_->OnStartOrStopScanEvent(SCAN_NOT_STARTED, true);
689         return;
690     }
691 
692     pimpl->settings_ = setting;
693     int matchingMode;
694     if (setting.GetReportDelayMillisValue() > 0) {
695         matchingMode = CALLBACK_TYPE_ALL_MATCHES;
696     } else {
697         matchingMode = CALLBACK_TYPE_FIRST_MATCH;
698     }
699     SetScanModeDuration(setting.GetScanMode(), matchingMode);
700     if (matchingMode == CALLBACK_TYPE_FIRST_MATCH) {
701         pimpl->callBackType_ = CALLBACK_TYPE_FIRST_MATCH;
702     } else {
703         pimpl->callBackType_ = CALLBACK_TYPE_ALL_MATCHES;
704     }
705     Start(false);
706 
707     LOG_DEBUG("[BleCentralManagerImpl] %{public}s:<-- Start scan end", __func__);
708 }
709 
StopScan() const710 void BleCentralManagerImpl::StopScan() const
711 {
712     LOG_DEBUG("[BleCentralManagerImpl] %{public}s:-> Stop scan start", __func__);
713 
714     if (pimpl->scanStatus_ == SCAN_NOT_STARTED) {
715         centralManagerCallbacks_->OnStartOrStopScanEvent(SCAN_NOT_STARTED, false);
716         return;
717     }
718 
719     Stop();
720 
721     LOG_DEBUG("[BleCentralManagerImpl] %{public}s:-> Stop scan end", __func__);
722 }
723 
StartOrStopScan(const STOP_SCAN_TYPE & scanType,bool isStartScan) const724 void BleCentralManagerImpl::StartOrStopScan(const STOP_SCAN_TYPE &scanType, bool isStartScan) const
725 {
726     LOG_DEBUG("[BleCentralManagerImpl] %{public}s:-> StartOrStopScan scan start", __func__);
727 
728     std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
729     int ret;
730     if (BleFeature::GetInstance().IsExtendedScanSupported()) {
731         ret = SetExScanEnable(isStartScan);
732     } else {
733         ret = SetScanEnable(isStartScan);
734     }
735 
736     if (ret != BT_SUCCESS) {
737         LOG_ERROR("stop or start extend scan: err: %{public}d isScan : %{public}d", ret, isStartScan);
738         return;
739     }
740     pimpl->stopScanType_ = scanType;
741     pimpl->isStopScan_ = !isStartScan;
742     if (isStartScan) {
743         pimpl->scanStatus_ = SCAN_FAILED_ALREADY_STARTED;
744         LOG_DEBUG("start extend scan successful");
745     } else {
746         if (scanType != STOP_SCAN_TYPE_RESOLVING_LIST) {
747             pimpl->scanStatus_ = SCAN_NOT_STARTED;
748         } else {
749             pimpl->scanStatus_ = SCAN_FAILED_ALREADY_STARTED;
750         }
751         LOG_DEBUG("stop extend scan successful");
752     }
753 }
754 
SetActiveScan(bool active) const755 void BleCentralManagerImpl::SetActiveScan(bool active) const
756 {
757     HILOGI("active: %{public}d", active);
758 
759     if (active) {
760         pimpl->scanParams_.scanType = BLE_SCAN_TYPE_ACTIVE;
761     } else {
762         pimpl->scanParams_.scanType = BLE_SCAN_TYPE_PASSIVE;
763     }
764 }
765 
SetInterval(uint16_t intervalMSecs) const766 void BleCentralManagerImpl::SetInterval(uint16_t intervalMSecs) const
767 {
768     HILOGI("intervalMSecs: %{public}hu", intervalMSecs);
769 
770     pimpl->scanParams_.scanInterval = intervalMSecs / BLE_SCAN_UNIT_TIME;
771 }
772 
SetWindow(uint16_t windowMSecs) const773 void BleCentralManagerImpl::SetWindow(uint16_t windowMSecs) const
774 {
775     HILOGI("windowMSecs: %{public}hu", windowMSecs);
776 
777     pimpl->scanParams_.scanWindow = windowMSecs / BLE_SCAN_UNIT_TIME;
778 }
779 
ClearResults() const780 void BleCentralManagerImpl::ClearResults() const
781 {
782     HILOGI("enter");
783 
784     std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
785     pimpl->bleScanResult_.clear();
786 }
787 
SetScanModeDuration(int scanMode,int type) const788 void BleCentralManagerImpl::SetScanModeDuration(int scanMode, int type) const
789 {
790     HILOGI("scanMode: %{public}d, type: %{public}d", scanMode, type);
791 
792     switch (scanMode) {
793         case SCAN_MODE_LOW_POWER:
794             SetLowPowerDuration(type);
795             break;
796         case SCAN_MODE_BALANCED:
797             SetBalancedDuration(type);
798             break;
799         case SCAN_MODE_LOW_LATENCY:
800             SetLowLatencyDuration(type);
801             break;
802         case SCAN_MODE_OP_P2_60_3000:
803             SetDutyCycle2Duration(type);
804             break;
805         case SCAN_MODE_OP_P10_60_600:
806             SetDutyCycle10Duration(type);
807             break;
808         case SCAN_MODE_OP_P25_60_240:
809             SetDutyCycle25Duration(type);
810             break;
811         case SCAN_MODE_OP_P100_1000_1000:
812             SetDutyCycle100Duration(type);
813             break;
814         case SCAN_MODE_OP_P50_100_200:
815             SetDutyCycle50Duration(type);
816             break;
817         case SCAN_MODE_OP_P10_30_300:
818             SetDutyCycle1030Duration(type);
819             break;
820         case SCAN_MODE_OP_P2_30_1500:
821             SetDutyCycle230Duration(type);
822             break;
823         case SCAN_MODE_OP_P75_30_40:
824             SetDutyCycle75Duration(type);
825             break;
826         case SCAN_MODE_OP_P50_30_60:
827             SetDutyCycle5030Duration(type);
828             break;
829         default:
830             break;
831     }
832     HiSysEventWrite(OHOS::HiviewDFX::HiSysEvent::Domain::BT_SERVICE, "BLE_SCAN_DUTY_CYCLE",
833         OHOS::HiviewDFX::HiSysEvent::EventType::STATISTIC, "WINDOW", pimpl->scanParams_.scanWindow,
834         "INTERVAL", pimpl->scanParams_.scanInterval, "TYPE", pimpl->callBackType_);
835 }
836 
SetLowPowerDuration(int type) const837 void BleCentralManagerImpl::SetLowPowerDuration(int type) const
838 {
839     if (type == CALLBACK_TYPE_ALL_MATCHES) {
840         uint16_t interval = BLE_SCAN_MODE_BATCH_LOW_POWER_INTERVAL_MS;
841         SetInterval(interval);
842         uint16_t window = BLE_SCAN_MODE_BATCH_LOW_POWER_WINDOW_MS;
843         SetWindow(window);
844     } else {
845         uint16_t interval = BLE_SCAN_MODE_LOW_POWER_INTERVAL_MS;
846         SetInterval(interval);
847         uint16_t window = BLE_SCAN_MODE_LOW_POWER_WINDOW_MS;
848         SetWindow(window);
849     }
850 }
851 
SetBalancedDuration(int type) const852 void BleCentralManagerImpl::SetBalancedDuration(int type) const
853 {
854     if (type == CALLBACK_TYPE_ALL_MATCHES) {
855         uint16_t interval = BLE_SCAN_MODE_BATCH_BALANCED_INTERVAL_MS;
856         SetInterval(interval);
857         uint16_t window = BLE_SCAN_MODE_BATCH_BALANCED_WINDOW_MS;
858         SetWindow(window);
859     } else {
860         uint16_t interval = BLE_SCAN_MODE_BALANCED_INTERVAL_MS;
861         SetInterval(interval);
862         uint16_t window = BLE_SCAN_MODE_BALANCED_WINDOW_MS;
863         SetWindow(window);
864     }
865 }
866 
SetLowLatencyDuration(int type) const867 void BleCentralManagerImpl::SetLowLatencyDuration(int type) const
868 {
869     if (type == CALLBACK_TYPE_ALL_MATCHES) {
870         uint16_t interval = BLE_SCAN_MODE_BATCH_LOW_LATENCY_INTERVAL_MS;
871         SetInterval(interval);
872         uint16_t window = BLE_SCAN_MODE_BATCH_LOW_LATENCY_WINDOW_MS;
873         SetWindow(window);
874     } else {
875         uint16_t interval = BLE_SCAN_MODE_LOW_LATENCY_INTERVAL_MS;
876         SetInterval(interval);
877         uint16_t window = BLE_SCAN_MODE_LOW_LATENCY_WINDOW_MS;
878         SetWindow(window);
879     }
880 }
881 
SetDutyCycle2Duration(int type) const882 void BleCentralManagerImpl::SetDutyCycle2Duration(int type) const
883 {
884     if (type == CALLBACK_TYPE_ALL_MATCHES) {
885         uint16_t interval = BLE_SCAN_MODE_BATCH_OP_P2_60_3000_INTERVAL_MS;
886         SetInterval(interval);
887         uint16_t window = BLE_SCAN_MODE_BATCH_OP_P2_60_3000_WINDOW_MS;
888         SetWindow(window);
889     } else {
890         uint16_t interval = BLE_SCAN_MODE_OP_P2_60_3000_INTERVAL_MS;
891         SetInterval(interval);
892         uint16_t window = BLE_SCAN_MODE_OP_P2_60_3000_WINDOW_MS;
893         SetWindow(window);
894     }
895 }
896 
SetDutyCycle10Duration(int type) const897 void BleCentralManagerImpl::SetDutyCycle10Duration(int type) const
898 {
899     if (type == CALLBACK_TYPE_ALL_MATCHES) {
900         uint16_t interval = BLE_SCAN_MODE_BATCH_OP_P10_60_600_INTERVAL_MS;
901         SetInterval(interval);
902         uint16_t window = BLE_SCAN_MODE_BATCH_OP_P10_60_600_WINDOW_MS;
903         SetWindow(window);
904     } else {
905         uint16_t interval = BLE_SCAN_MODE_OP_P10_60_600_INTERVAL_MS;
906         SetInterval(interval);
907         uint16_t window = BLE_SCAN_MODE_OP_P10_60_600_WINDOW_MS;
908         SetWindow(window);
909     }
910 }
911 
SetDutyCycle25Duration(int type) const912 void BleCentralManagerImpl::SetDutyCycle25Duration(int type) const
913 {
914     if (type == CALLBACK_TYPE_ALL_MATCHES) {
915         uint16_t interval = BLE_SCAN_MODE_BATCH_OP_P25_60_240_INTERVAL_MS;
916         SetInterval(interval);
917         uint16_t window = BLE_SCAN_MODE_BATCH_OP_P25_60_240_WINDOW_MS;
918         SetWindow(window);
919     } else {
920         uint16_t interval = BLE_SCAN_MODE_OP_P25_60_240_INTERVAL_MS;
921         SetInterval(interval);
922         uint16_t window = BLE_SCAN_MODE_OP_P25_60_240_WINDOW_MS;
923         SetWindow(window);
924     }
925 }
926 
SetDutyCycle100Duration(int type) const927 void BleCentralManagerImpl::SetDutyCycle100Duration(int type) const
928 {
929     if (type == CALLBACK_TYPE_ALL_MATCHES) {
930         uint16_t interval = BLE_SCAN_MODE_BATCH_OP_P100_1000_1000_INTERVAL_MS;
931         SetInterval(interval);
932         uint16_t window = BLE_SCAN_MODE_BATCH_OP_P100_1000_1000_WINDOW_MS;
933         SetWindow(window);
934     } else {
935         uint16_t interval = BLE_SCAN_MODE_OP_P100_1000_1000_INTERVAL_MS;
936         SetInterval(interval);
937         uint16_t window = BLE_SCAN_MODE_OP_P100_1000_1000_WINDOW_MS;
938         SetWindow(window);
939     }
940 }
941 
SetDutyCycle50Duration(int type) const942 void BleCentralManagerImpl::SetDutyCycle50Duration(int type) const
943 {
944     if (type == CALLBACK_TYPE_ALL_MATCHES) {
945         uint16_t interval = BLE_SCAN_MODE_BATCH_OP_P50_100_200_INTERVAL_MS;
946         SetInterval(interval);
947         uint16_t window = BLE_SCAN_MODE_BATCH_OP_P50_100_200_WINDOW_MS;
948         SetWindow(window);
949     } else {
950         uint16_t interval = BLE_SCAN_MODE_OP_P50_100_200_INTERVAL_MS;
951         SetInterval(interval);
952         uint16_t window = BLE_SCAN_MODE_OP_P50_100_200_WINDOW_MS;
953         SetWindow(window);
954     }
955 }
956 
SetDutyCycle1030Duration(int type) const957 void BleCentralManagerImpl::SetDutyCycle1030Duration(int type) const
958 {
959     if (type == CALLBACK_TYPE_ALL_MATCHES) {
960         uint16_t interval = BLE_SCAN_MODE_BATCH_OP_P10_30_300_INTERVAL_MS;
961         SetInterval(interval);
962         uint16_t window = BLE_SCAN_MODE_BATCH_OP_P10_30_300_WINDOW_MS;
963         SetWindow(window);
964     } else {
965         uint16_t interval = BLE_SCAN_MODE_OP_P10_30_300_INTERVAL_MS;
966         SetInterval(interval);
967         uint16_t window = BLE_SCAN_MODE_OP_P10_30_300_WINDOW_MS;
968         SetWindow(window);
969     }
970 }
971 
SetDutyCycle230Duration(int type) const972 void BleCentralManagerImpl::SetDutyCycle230Duration(int type) const
973 {
974     if (type == CALLBACK_TYPE_ALL_MATCHES) {
975         uint16_t interval = BLE_SCAN_MODE_BATCH_OP_P2_30_1500_INTERVAL_MS;
976         SetInterval(interval);
977         uint16_t window = BLE_SCAN_MODE_BATCH_OP_P2_30_1500_WINDOW_MS;
978         SetWindow(window);
979     } else {
980         uint16_t interval = BLE_SCAN_MODE_OP_P2_30_1500_INTERVAL_MS;
981         SetInterval(interval);
982         uint16_t window = BLE_SCAN_MODE_OP_P2_30_1500_WINDOW_MS;
983         SetWindow(window);
984     }
985 }
986 
SetDutyCycle75Duration(int type) const987 void BleCentralManagerImpl::SetDutyCycle75Duration(int type) const
988 {
989     if (type == CALLBACK_TYPE_ALL_MATCHES) {
990         uint16_t interval = BLE_SCAN_MODE_BATCH_OP_P75_30_40_INTERVAL_MS;
991         SetInterval(interval);
992         uint16_t window = BLE_SCAN_MODE_BATCH_OP_P75_30_40_WINDOW_MS;
993         SetWindow(window);
994     } else {
995         uint16_t interval = BLE_SCAN_MODE_OP_P75_30_40_INTERVAL_MS;
996         SetInterval(interval);
997         uint16_t window = BLE_SCAN_MODE_OP_P75_30_40_WINDOW_MS;
998         SetWindow(window);
999     }
1000 }
1001 
SetDutyCycle5030Duration(int type) const1002 void BleCentralManagerImpl::SetDutyCycle5030Duration(int type) const
1003 {
1004     if (type == CALLBACK_TYPE_ALL_MATCHES) {
1005         uint16_t interval = BLE_SCAN_MODE_BATCH_OP_P50_30_60_INTERVAL_MS;
1006         SetInterval(interval);
1007         uint16_t window = BLE_SCAN_MODE_BATCH_OP_P50_30_60_WINDOW_MS;
1008         SetWindow(window);
1009     } else {
1010         uint16_t interval = BLE_SCAN_MODE_OP_P50_30_60_INTERVAL_MS;
1011         SetInterval(interval);
1012         uint16_t window = BLE_SCAN_MODE_OP_P50_30_60_WINDOW_MS;
1013         SetWindow(window);
1014     }
1015 }
1016 
TimerCallback(void * context)1017 void BleCentralManagerImpl::TimerCallback(void *context)
1018 {
1019     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1020 
1021     auto *centralManager = static_cast<BleCentralManagerImpl *>(context);
1022     if ((centralManager != nullptr) && (centralManager->dispatcher_ != nullptr)) {
1023         centralManager->dispatcher_->PostTask(
1024             std::bind(&BleCentralManagerImpl::HandleGapEvent, centralManager, BLE_GAP_SCAN_DELAY_REPORT_RESULT_EVT, 0));
1025         centralManager->dispatcher_->PostTask(std::bind(&BleCentralManagerImpl::StopScan, centralManager));
1026     }
1027 }
1028 
SetScanParamToGap() const1029 int BleCentralManagerImpl::SetScanParamToGap() const
1030 {
1031     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1032 
1033     GapLeScanParam param;
1034     param.scanType = pimpl->scanParams_.scanType;
1035     param.param.scanInterval = pimpl->scanParams_.scanInterval;
1036     param.param.scanWindow = pimpl->scanParams_.scanWindow;
1037     return GAPIF_LeScanSetParam(param, pimpl->scanParams_.scanFilterPolicy);
1038 }
1039 
SetExScanParamToGap() const1040 int BleCentralManagerImpl::SetExScanParamToGap() const
1041 {
1042     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1043 
1044     std::vector<GapLeScanParam> params;
1045     uint8_t scanPhys = GAP_EX_SCAN_PHY_1M;
1046     if (pimpl->settings_.GetLegacy()) {
1047         GapLeScanParam param;
1048         param.scanType = pimpl->scanParams_.scanType;
1049         param.param.scanInterval = pimpl->scanParams_.scanInterval;
1050         param.param.scanWindow = pimpl->scanParams_.scanWindow;
1051         params.push_back(param);
1052     } else {
1053         switch (pimpl->settings_.GetPhy()) {
1054             case PHY_LE_CODED:
1055                 scanPhys = GAP_EX_SCAN_PHY_CODED;
1056                 GapLeScanParam paramCoded;
1057                 paramCoded.scanType = pimpl->scanParams_.scanType;
1058                 paramCoded.param.scanInterval = pimpl->scanParams_.scanInterval;
1059                 paramCoded.param.scanWindow = pimpl->scanParams_.scanWindow;
1060                 params.push_back(paramCoded);
1061                 break;
1062             case PHY_LE_ALL_SUPPORTED:
1063                 scanPhys = GAP_EX_SCAN_PHY_1M | GAP_EX_SCAN_PHY_CODED;
1064                 GapLeScanParam param1M;
1065                 param1M.scanType = pimpl->scanParams_.scanType;
1066                 param1M.param.scanInterval = pimpl->scanParams_.scanInterval;
1067                 param1M.param.scanWindow = pimpl->scanParams_.scanWindow;
1068                 params.push_back(param1M);
1069 
1070                 GapLeScanParam paramCodedAll;
1071                 paramCodedAll.scanType = pimpl->scanParams_.scanType;
1072                 paramCodedAll.param.scanInterval = pimpl->scanParams_.scanInterval;
1073                 paramCodedAll.param.scanWindow = pimpl->scanParams_.scanWindow;
1074                 params.push_back(paramCodedAll);
1075                 break;
1076             case PHY_LE_1M:
1077             default:
1078                 scanPhys = GAP_EX_SCAN_PHY_1M;
1079                 GapLeScanParam param;
1080                 param.scanType = pimpl->scanParams_.scanType;
1081                 param.param.scanInterval = pimpl->scanParams_.scanInterval;
1082                 param.param.scanWindow = pimpl->scanParams_.scanWindow;
1083                 params.push_back(param);
1084                 break;
1085         }
1086     }
1087     return GAPIF_LeExScanSetParam(pimpl->scanParams_.scanFilterPolicy, scanPhys, &params[0]);
1088 }
1089 
SetScanEnable(bool enable) const1090 int BleCentralManagerImpl::SetScanEnable(bool enable) const
1091 {
1092     LOG_DEBUG("[BleCentralManagerImpl] %{public}s:%{public}d", __func__, enable);
1093 
1094     return GAPIF_LeScanSetEnable(enable, isDuplicates_);
1095 }
1096 
SetExScanEnable(bool enable) const1097 int BleCentralManagerImpl::SetExScanEnable(bool enable) const
1098 {
1099     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1100 
1101     return GAPIF_LeExScanSetEnable(enable, isDuplicates_, 0, 0);
1102 }
1103 
StartReportDelay()1104 void BleCentralManagerImpl::impl::StartReportDelay()
1105 {
1106     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1107 
1108     if ((settings_.GetReportDelayMillisValue() > 0) && (callBackType_ == CALLBACK_TYPE_ALL_MATCHES)) {
1109         if (timer_ == nullptr) {
1110             timer_ = std::make_unique<utility::Timer>(std::bind(&TimerCallback, bleCentralManagerImpl_));
1111         }
1112         timer_->Start(settings_.GetReportDelayMillisValue());
1113     }
1114 }
1115 
SetLegacyScanParamToGap() const1116 bool BleCentralManagerImpl::SetLegacyScanParamToGap() const
1117 {
1118     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1119 
1120     std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1121     bool ret = true;
1122     ret = pimpl->RegisterCallbackToGap();
1123     if (ret != BT_SUCCESS) {
1124         LOG_ERROR("[BleCentralManagerImpl] %{public}s:RegisterCallbackToGap failed.", __func__);
1125         pimpl->scanStatus_ = SCAN_NOT_STARTED;
1126         centralManagerCallbacks_->OnStartOrStopScanEvent(SCAN_FAILED_INTERNAL_ERROR, true);
1127         return false;
1128     }
1129 
1130     pimpl->isStopScan_ = false;
1131     ret = SetScanParamToGap();
1132     if (ret != BT_SUCCESS) {
1133         LOG_ERROR("[BleCentralManagerImpl] %{public}s:SetScanParamToGap failed.", __func__);
1134         pimpl->scanStatus_ = SCAN_NOT_STARTED;
1135         centralManagerCallbacks_->OnStartOrStopScanEvent(SCAN_FAILED_INTERNAL_ERROR, true);
1136         return false;
1137     }
1138     return ret;
1139 }
1140 
SetExtendScanParamToGap() const1141 bool BleCentralManagerImpl::SetExtendScanParamToGap() const
1142 {
1143     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1144 
1145     std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1146     bool ret = true;
1147     ret = pimpl->RegisterExScanCallbackToGap();
1148     if (ret != BT_SUCCESS) {
1149         LOG_ERROR("[BleCentralManagerImpl] %{public}s:RegisterExScanCallbackToGap failed.", __func__);
1150         pimpl->scanStatus_ = SCAN_NOT_STARTED;
1151         centralManagerCallbacks_->OnStartOrStopScanEvent(SCAN_FAILED_INTERNAL_ERROR, true);
1152         return false;
1153     }
1154 
1155     pimpl->isStopScan_ = false;
1156     ret = SetExScanParamToGap();
1157     if (ret != BT_SUCCESS) {
1158         LOG_ERROR("[BleCentralManagerImpl] %{public}s:SetExScanParamToGap failed.", __func__);
1159         pimpl->scanStatus_ = SCAN_NOT_STARTED;
1160         centralManagerCallbacks_->OnStartOrStopScanEvent(SCAN_FAILED_INTERNAL_ERROR, true);
1161         return false;
1162     }
1163     return ret;
1164 }
1165 
SetScanParamOrExScanParamToGap() const1166 bool BleCentralManagerImpl::SetScanParamOrExScanParamToGap() const
1167 {
1168     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1169 
1170     bool ret = true;
1171     if (BleFeature::GetInstance().IsExtendedScanSupported()) {
1172         ret = SetExtendScanParamToGap();
1173     } else {
1174         ret = SetLegacyScanParamToGap();
1175     }
1176     return ret;
1177 }
1178 
LoadBleScanFilterLib()1179 NO_SANITIZE("cfi") void BleCentralManagerImpl::LoadBleScanFilterLib()
1180 {
1181     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1182 
1183     if (bleScanFilterLib_ == nullptr) {
1184         bleScanFilterLib_ = dlopen(BLE_SCAN_FILTER_LIB_NAME, RTLD_LAZY | RTLD_NODELETE);
1185     }
1186     if (bleScanFilterLib_ == nullptr) {
1187         LOG_ERROR("[BleCentralManagerImpl] %{public}s Load lib failed", __func__);
1188         return;
1189     }
1190     if (bleScanFilter_ != nullptr) {
1191         LOG_DEBUG("[BleCentralManagerImpl] %{public}s bleScanFilter_ is not null.", __func__);
1192         return;
1193     }
1194     createBleScanFilter createBleScanFilterFunc =
1195         (createBleScanFilter)dlsym(bleScanFilterLib_, "CreateBleScanFilter");
1196     if (createBleScanFilterFunc == nullptr) {
1197         LOG_ERROR("[BleCentralManagerImpl] %{public}s Load symbol CreateBleScanFilter failed", __func__);
1198         if (bleScanFilterLib_ != nullptr) {
1199             dlclose(bleScanFilterLib_);
1200             bleScanFilterLib_ = nullptr;
1201         }
1202         return;
1203     }
1204     bleScanFilter_ = createBleScanFilterFunc();
1205     if (bleScanFilter_ == nullptr) {
1206         LOG_ERROR("[BleCentralManagerImpl] %{public}s Load bleScanFilter failed", __func__);
1207         if (bleScanFilterLib_ != nullptr) {
1208             dlclose(bleScanFilterLib_);
1209             bleScanFilterLib_ = nullptr;
1210         }
1211     }
1212 }
1213 
UnloadBleScanFilterLib()1214 void BleCentralManagerImpl::UnloadBleScanFilterLib()
1215 {
1216     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1217 
1218     if (bleScanFilterLib_ != nullptr) {
1219         destroyBleScanFilter destroyBleScanFilterFunc =
1220             (destroyBleScanFilter)dlsym(bleScanFilterLib_, "DestroyBleScanFilter");
1221         if (destroyBleScanFilterFunc == nullptr) {
1222             LOG_ERROR("[BleCentralManagerImpl] %{public}s Load symbol DestroyBleScanFilter failed", __func__);
1223         } else if (bleScanFilter_ != nullptr) {
1224             destroyBleScanFilterFunc(bleScanFilter_);
1225         }
1226         dlclose(bleScanFilterLib_);
1227         bleScanFilterLib_ = nullptr;
1228     }
1229     bleScanFilter_ = nullptr;
1230 }
1231 
ConfigScanFilter(int32_t scannerId,const std::vector<BleScanFilterImpl> & filters)1232 int BleCentralManagerImpl::ConfigScanFilter(int32_t scannerId, const std::vector<BleScanFilterImpl> &filters)
1233 {
1234     LOG_DEBUG("[BleCentralManagerImpl] %{public}s:-> Config scan filter filterStatus_=%{public}d",
1235         __func__, pimpl->filterStatus_);
1236     std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1237     if (!CheckScanFilterConfig(filters)) {
1238         return 0;
1239     }
1240 
1241     if (filters.empty()) {
1242         BleScanFilterImpl filter;
1243         PushFilterToWaitList(filter, scannerId, FILTER_ACTION_ADD);
1244     } else {
1245         for (auto filter : filters) {
1246             PushFilterToWaitList(filter, scannerId, FILTER_ACTION_ADD);
1247         }
1248     }
1249     PushStartOrStopAction(scannerId, FILTER_ACTION_START);
1250 
1251     if ((pimpl->filterStatus_ == BLE_SCAN_FILTER_STATUS_BAD) &&
1252         (pimpl->filters_.size() <= pimpl->venderMaxFilterNumber_)) {
1253         TryConfigScanFilter(scannerId);
1254     }
1255 
1256     if (pimpl->filterStatus_ == BLE_SCAN_FILTER_STATUS_IDLE) {
1257         HandleWaitFilters();
1258     }
1259     return 0;
1260 }
1261 
CheckScanFilterConfig(const std::vector<BleScanFilterImpl> & filters)1262 bool BleCentralManagerImpl::CheckScanFilterConfig(const std::vector<BleScanFilterImpl> &filters)
1263 {
1264     if (bleScanFilter_ == nullptr) {
1265         return false;
1266     }
1267 
1268     int status = AdapterManager::GetInstance()->GetState(BTTransport::ADAPTER_BLE);
1269     if (status != BTStateID::STATE_TURN_ON) {
1270         LOG_ERROR("[BleCentralManagerImpl] %{public}s:%{public}s", __func__, "Bluetooth adapter is invalid.");
1271         return false;
1272     }
1273 
1274     uint8_t filterSize;
1275     if (filters.empty()) {
1276         filterSize = 1;
1277     } else {
1278         filterSize = filters.size();
1279     }
1280 
1281     if ((filterSize + pimpl->filters_.size()) >= UCHAR_MAX) {
1282         LOG_ERROR("[BleCentralManagerImpl] %{public}s:%{public}s", __func__, "filter array is full.");
1283         return false;
1284     }
1285     if (pimpl->venderMaxFilterNumber_ == 0) {
1286         pimpl->venderMaxFilterNumber_ = bleScanFilter_->GetMaxFilterNumber();
1287         LOG_DEBUG("[BleCentralManagerImpl] %{public}s:-> vender max filter number_ is %{public}d",
1288             __func__, pimpl->venderMaxFilterNumber_);
1289     }
1290 
1291     if (pimpl->venderMaxFilterNumber_ <= 0) {
1292         return false;
1293     }
1294 
1295     return true;
1296 }
1297 
PushFilterToWaitList(BleScanFilterImpl filter,int scannerId,uint8_t action)1298 void BleCentralManagerImpl::PushFilterToWaitList(BleScanFilterImpl filter, int scannerId, uint8_t action)
1299 {
1300     filter.SetFilterAction(action);
1301     if (action == FILTER_ACTION_ADD) {
1302         filter.SetClientId(scannerId);
1303         if (pimpl->releaseFiltIndex_.empty()) {
1304             filter.SetFiltIndex(pimpl->currentFiltIndex_++);
1305         } else {
1306             filter.SetFiltIndex(*pimpl->releaseFiltIndex_.begin());
1307             pimpl->releaseFiltIndex_.remove(filter.GetFiltIndex());
1308         }
1309 
1310         pimpl->filters_[filter.GetFiltIndex()] = filter;
1311     }
1312 
1313     if (pimpl->filterStatus_ != BLE_SCAN_FILTER_STATUS_BAD) {
1314         pimpl->waitFilters_.push(filter);
1315     }
1316 }
1317 
PushStartOrStopAction(const int scannerId,uint8_t action)1318 void BleCentralManagerImpl::PushStartOrStopAction(const int scannerId, uint8_t action)
1319 {
1320     BleScanFilterImpl filterImpl;
1321     PushFilterToWaitList(filterImpl, scannerId, action);
1322 }
1323 
HandleWaitFilters()1324 void BleCentralManagerImpl::HandleWaitFilters()
1325 {
1326     if (pimpl->waitFilters_.empty()) {
1327         LOG_ERROR("[BleCentralManagerImpl] %{public}s:%{public}s", __func__, "there is no wait action.");
1328         pimpl->filterStatus_ = BLE_SCAN_FILTER_STATUS_IDLE;
1329         return;
1330     }
1331 
1332     BleScanFilterImpl waitFilter = pimpl->waitFilters_.front();
1333     pimpl->waitFilters_.pop();
1334 
1335     uint8_t action = waitFilter.GetFilterAction();
1336     LOG_ERROR("[BleCentralManagerImpl] %{public}s: wait action %{public}d", __func__, action);
1337     switch (action) {
1338         case FILTER_ACTION_ADD:
1339             AddBleScanFilter(waitFilter);
1340             break;
1341         case FILTER_ACTION_DELETE:
1342             DeleteBleScanFilter(waitFilter);
1343             break;
1344         case FILTER_ACTION_START:
1345             StartBleScanFilter();
1346             break;
1347         case FILTER_ACTION_STOP:
1348             if (pimpl->waitFilters_.empty() && pimpl->filters_.empty()) {
1349                 StopBleScanFilter();
1350             }
1351             break;
1352         default: {
1353             LOG_ERROR("[BleCentralManagerImpl] %{public}s: error action %{public}d", __func__, action);
1354         }
1355     }
1356 }
1357 
TryConfigScanFilter(int scannerId)1358 void BleCentralManagerImpl::TryConfigScanFilter(int scannerId)
1359 {
1360     LOG_ERROR("[BleCentralManagerImpl] %{public}s: ", __func__);
1361     pimpl->filterStatus_ = BLE_SCAN_FILTER_STATUS_IDLE;
1362 
1363     pimpl->currentFiltIndex_ = 0;
1364     pimpl->releaseFiltIndex_.clear();
1365     std::map<uint8_t, BleScanFilterImpl> filters;
1366 
1367     for (auto it = pimpl->filters_.begin(); it != pimpl->filters_.end(); it++) {
1368         BleScanFilterImpl filter = it->second;
1369         filter.SetFiltIndex(pimpl->currentFiltIndex_++);
1370         pimpl->waitFilters_.push(filter);
1371         filters[filter.GetFiltIndex()] = filter;
1372     }
1373     pimpl->filters_ = filters;
1374 
1375     PushStartOrStopAction(scannerId, FILTER_ACTION_START);
1376 }
1377 
RemoveScanFilter(int32_t scannerId)1378 void BleCentralManagerImpl::RemoveScanFilter(int32_t scannerId)
1379 {
1380     LOG_DEBUG("[BleCentralManagerImpl] %{public}s:-> Remove scan filter", __func__);
1381     std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1382 
1383     if (bleScanFilter_ == nullptr) {
1384         return;
1385     }
1386 
1387     for (auto it = pimpl->filters_.begin(); it != pimpl->filters_.end();) {
1388         if (it->second.GetClientId() == scannerId) {
1389             PushFilterToWaitList(it->second, scannerId, FILTER_ACTION_DELETE);
1390             pimpl->releaseFiltIndex_.push_back(it->first);
1391             pimpl->filters_.erase(it++);
1392         } else {
1393             it++;
1394         }
1395     }
1396     pimpl->releaseFiltIndex_.sort();
1397     PushStartOrStopAction(scannerId, FILTER_ACTION_STOP);
1398 
1399     if (pimpl->filterStatus_ == BLE_SCAN_FILTER_STATUS_IDLE) {
1400         HandleWaitFilters();
1401     }
1402 }
1403 
AllocScannerId()1404 int32_t BleCentralManagerImpl::AllocScannerId()
1405 {
1406     int32_t scannerId = 0;
1407     for (int32_t i = 1; i < BLE_SCAN_MAX_NUM; i++) {
1408         if (scannerIds_.find(i) == scannerIds_.end()) {
1409             scannerId = i;
1410             scannerIds_.insert(scannerId);
1411             break;
1412         }
1413     }
1414     LOG_DEBUG("[BleCentralManagerImpl] AllocScannerId scannerId: %{public}d", scannerId);
1415     return scannerId;
1416 }
1417 
RemoveScannerId(int32_t scannerId)1418 void BleCentralManagerImpl::RemoveScannerId(int32_t scannerId)
1419 {
1420     LOG_DEBUG("[BleCentralManagerImpl] RemoveScannerId scannerId: %{public}d", scannerId);
1421     scannerIds_.erase(scannerId);
1422 }
1423 
ClearScannerIds()1424 void BleCentralManagerImpl::ClearScannerIds()
1425 {
1426     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1427     scannerIds_.clear();
1428 }
1429 
AddBleScanFilter(BleScanFilterImpl filter)1430 void BleCentralManagerImpl::AddBleScanFilter(BleScanFilterImpl filter)
1431 {
1432     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1433     if (bleScanFilter_ == nullptr) {
1434         LOG_ERROR("[BleCentralManagerImpl] %{public}s bleScanFilter_ is null.", __func__);
1435         DoFilterStatusBad();
1436         return;
1437     }
1438 
1439     pimpl->filterStatus_ = BLE_SCAN_FILTER_STATUS_WORKING;
1440 
1441     BleScanFilterParam filterParam;
1442     filterParam.filtIndex = filter.GetFiltIndex();
1443     BleScanFilterParamAddDeviceAddress(filterParam, filter);
1444     BleScanFilterParamAddName(filterParam, filter);
1445     BleScanFilterParamAddServiceUuid(filterParam, filter);
1446     BleScanFilterParamAddSolicitationUuid(filterParam, filter);
1447     BleScanFilterParamAddServiceData(filterParam, filter);
1448     BleScanFilterParamAddManufactureData(filterParam, filter);
1449 
1450     BleScanFilterCallback filterCallback;
1451     filterCallback.addBleScanFilterResult = &AddBleScanFilterResult;
1452     filterCallback.deleteBleScanFilterResult = nullptr;
1453     filterCallback.startBleScanFilterResult = nullptr;
1454     filterCallback.stopBleScanFilterResult = nullptr;
1455     filterCallback.context = pimpl->bleCentralManagerImpl_;
1456     bleScanFilter_->AddBleScanFilter(filterParam, filterCallback);
1457 }
1458 
DeleteBleScanFilter(BleScanFilterImpl filter)1459 void BleCentralManagerImpl::DeleteBleScanFilter(BleScanFilterImpl filter)
1460 {
1461     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1462     if (bleScanFilter_ == nullptr) {
1463         LOG_ERROR("[BleCentralManagerImpl] %{public}s bleScanFilter_ is null.", __func__);
1464         DoFilterStatusBad();
1465         return;
1466     }
1467 
1468     pimpl->filterStatus_ = BLE_SCAN_FILTER_STATUS_WORKING;
1469 
1470     BleScanFilterParam filterParam;
1471     filterParam.filtIndex = filter.GetFiltIndex();
1472 
1473     BleScanFilterCallback filterCallback;
1474     filterCallback.addBleScanFilterResult = nullptr;
1475     filterCallback.deleteBleScanFilterResult = &DeleteBleScanFilterResult;
1476     filterCallback.startBleScanFilterResult = nullptr;
1477     filterCallback.stopBleScanFilterResult = nullptr;
1478     filterCallback.context = pimpl->bleCentralManagerImpl_;
1479     bleScanFilter_->DeleteBleScanFilter(filterParam, filterCallback);
1480 }
1481 
BleScanFilterParamAddDeviceAddress(BleScanFilterParam & filterParam,BleScanFilterImpl filter)1482 void BleCentralManagerImpl::BleScanFilterParamAddDeviceAddress(
1483     BleScanFilterParam &filterParam, BleScanFilterImpl filter)
1484 {
1485     std::string deviceId = filter.GetDeviceId();
1486     if (!deviceId.empty()) {
1487         BtAddr btAddr;
1488         RawAddress(deviceId).ConvertToUint8(btAddr.addr);
1489         btAddr.type = BT_DEVICE_ADDRESS_TYPE_ALL;
1490         filterParam.address = btAddr;
1491         filterParam.filterFlag |= FILTER_FLAG_ADDRESS;
1492     }
1493 }
1494 
BleScanFilterParamAddName(BleScanFilterParam & filterParam,BleScanFilterImpl filter)1495 void BleCentralManagerImpl::BleScanFilterParamAddName(
1496     BleScanFilterParam &filterParam, BleScanFilterImpl filter)
1497 {
1498     std::string name = filter.GetName();
1499     if (!name.empty()) {
1500         filterParam.name = name;
1501         filterParam.filterFlag |= FILTER_FLAG_NAME;
1502     }
1503 }
1504 
BleScanFilterParamAddServiceUuid(BleScanFilterParam & filterParam,BleScanFilterImpl filter)1505 void BleCentralManagerImpl::BleScanFilterParamAddServiceUuid(
1506     BleScanFilterParam &filterParam, BleScanFilterImpl filter)
1507 {
1508     if (filter.HasServiceUuid()) {
1509         filterParam.serviceUuid = filter.GetServiceUuid();
1510         if (filter.HasServiceUuidMask()) {
1511             filterParam.serviceUuidMask = filter.GetServiceUuidMask();
1512         } else {
1513             filterParam.serviceUuidMask = Uuid::ConvertFrom128Bits(DEFAULT_UUID_MASK);
1514         }
1515         filterParam.filterFlag |= FILTER_FLAG_SERVICE_UUID;
1516     }
1517 }
1518 
BleScanFilterParamAddSolicitationUuid(BleScanFilterParam & filterParam,BleScanFilterImpl filter)1519 void BleCentralManagerImpl::BleScanFilterParamAddSolicitationUuid(
1520     BleScanFilterParam &filterParam, BleScanFilterImpl filter)
1521 {
1522     if (filter.HasSolicitationUuid()) {
1523         filterParam.solicitationUuid = filter.GetServiceSolicitationUuid();
1524         if (filter.HasSolicitationUuidMask()) {
1525             filterParam.solicitationUuidMask = filter.GetServiceSolicitationUuidMask();
1526         } else {
1527             filterParam.solicitationUuidMask = Uuid::ConvertFrom128Bits(DEFAULT_UUID_MASK);
1528         }
1529         filterParam.filterFlag |= FILTER_FLAG_SOLICIT_UUID;
1530     }
1531 }
1532 
BleScanFilterParamAddServiceData(BleScanFilterParam & filterParam,BleScanFilterImpl filter)1533 void BleCentralManagerImpl::BleScanFilterParamAddServiceData(
1534     BleScanFilterParam &filterParam, BleScanFilterImpl filter)
1535 {
1536     std::vector<uint8_t> serviceData = filter.GetServiceData();
1537     std::vector<uint8_t> serviceDataMask = filter.GetServiceDataMask();
1538     if (!serviceData.empty()) {
1539         if (serviceData.size() != serviceDataMask.size()) {
1540             LOG_ERROR("[BleCentralManagerImpl] %{public}s:serviceDataMask size is different with serviceData",
1541                 __func__);
1542             serviceDataMask.clear();
1543             for (size_t i = 0; i < serviceData.size(); i++) {
1544                 serviceDataMask.push_back(0xFF);
1545             }
1546         }
1547         filterParam.serviceData = serviceData;
1548         filterParam.serviceDataMask = serviceDataMask;
1549         filterParam.filterFlag |= FILTER_FLAG_SERVICE_DATA;
1550     }
1551 }
1552 
BleScanFilterParamAddManufactureData(BleScanFilterParam & filterParam,BleScanFilterImpl filter)1553 void BleCentralManagerImpl::BleScanFilterParamAddManufactureData(
1554     BleScanFilterParam &filterParam, BleScanFilterImpl filter)
1555 {
1556     uint16_t manufacturerId = filter.GetManufacturerId();
1557     std::vector<uint8_t> manufactureData = filter.GetManufactureData();
1558     std::vector<uint8_t> manufactureDataMask = filter.GetManufactureDataMask();
1559     if (!manufactureData.empty()) {
1560         if (manufactureData.size() != manufactureDataMask.size()) {
1561             LOG_ERROR("[BleCentralManagerImpl] %{public}s:manufactureDataMask size is different with manufactureData",
1562                 __func__);
1563             manufactureDataMask.clear();
1564             for (size_t i = 0; i < manufactureData.size(); i++) {
1565                 manufactureDataMask.push_back(0xFF);
1566             }
1567         }
1568         filterParam.manufacturerId = manufacturerId;
1569         filterParam.manufacturerIdMask = 0xFFFF;
1570         filterParam.manufacturerData = manufactureData;
1571         filterParam.manufacturerDataMask = manufactureDataMask;
1572         filterParam.filterFlag |= FILTER_FLAG_MANUFACTURER_DATA;
1573     }
1574 }
1575 
StartBleScanFilter()1576 void BleCentralManagerImpl::StartBleScanFilter()
1577 {
1578     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1579 
1580     if (bleScanFilter_ == nullptr) {
1581         LOG_ERROR("[BleCentralManagerImpl] %{public}s bleScanFilter_ is null.", __func__);
1582         DoFilterStatusBad();
1583         return;
1584     }
1585 
1586     pimpl->filterStatus_ = BLE_SCAN_FILTER_STATUS_WORKING;
1587     BleScanFilterCallback filterCallback {};
1588     filterCallback.addBleScanFilterResult = nullptr;
1589     filterCallback.deleteBleScanFilterResult = nullptr;
1590     filterCallback.startBleScanFilterResult = &StartBleScanFilterResult;
1591     filterCallback.stopBleScanFilterResult = nullptr;
1592     filterCallback.context = pimpl->bleCentralManagerImpl_;
1593     bleScanFilter_->StartBleScanFilter(filterCallback);
1594 }
1595 
StopBleScanFilter()1596 void BleCentralManagerImpl::StopBleScanFilter()
1597 {
1598     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1599 
1600     if (bleScanFilter_ == nullptr) {
1601         if (pimpl->filterStatus_ == BLE_SCAN_FILTER_STATUS_BAD) {
1602             return;
1603         }
1604         LOG_ERROR("[BleCentralManagerImpl] %{public}s bleScanFilter_ is null.", __func__);
1605         DoFilterStatusBad();
1606         return;
1607     }
1608 
1609     if (pimpl->filterStatus_ != BLE_SCAN_FILTER_STATUS_BAD) {
1610         pimpl->filterStatus_ = BLE_SCAN_FILTER_STATUS_WORKING;
1611     }
1612 
1613     BleScanFilterCallback filterCallback {};
1614     filterCallback.addBleScanFilterResult = nullptr;
1615     filterCallback.deleteBleScanFilterResult = nullptr;
1616     filterCallback.startBleScanFilterResult = nullptr;
1617     filterCallback.stopBleScanFilterResult = &StopBleScanFilterResult;
1618     filterCallback.context = pimpl->bleCentralManagerImpl_;
1619     bleScanFilter_->StopBleScanFilter(filterCallback);
1620 }
1621 
DoFilterStatusBad()1622 void BleCentralManagerImpl::DoFilterStatusBad()
1623 {
1624     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1625     pimpl->filterStatus_ = BLE_SCAN_FILTER_STATUS_BAD;
1626     pimpl->waitFilters_ = std::queue<BleScanFilterImpl>();
1627     StopBleScanFilter();
1628 }
1629 
Start(bool isContinue) const1630 bool BleCentralManagerImpl::Start(bool isContinue) const
1631 {
1632     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1633 
1634     if (pimpl->scanStatus_ == SCAN_FAILED_ALREADY_STARTED) {
1635         LOG_ERROR("[BleCentralManagerImpl] %{public}s:%{public}s", __func__, "Scan already started.");
1636         centralManagerCallbacks_->OnStartOrStopScanEvent(SCAN_FAILED_ALREADY_STARTED, true);
1637         return true;
1638     }
1639 
1640     pimpl->scanStatus_ = SCAN_FAILED_ALREADY_STARTED;
1641     pimpl->stopScanType_ = STOP_SCAN_TYPE_NOR;
1642 
1643     if (!isContinue) {
1644         ClearResults();
1645     }
1646     return SetScanParamOrExScanParamToGap();
1647 }
1648 
Stop() const1649 void BleCentralManagerImpl::Stop() const
1650 {
1651     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1652 
1653     int ret;
1654     if (BleFeature::GetInstance().IsExtendedScanSupported()) {
1655         ret = SetExScanEnable(false);
1656     } else {
1657         ret = SetScanEnable(false);
1658     }
1659     if (ret != BT_SUCCESS) {
1660         LOG_ERROR("stop scanning: err: %{public}d", ret);
1661         pimpl->scanStatus_ = SCAN_FAILED_ALREADY_STARTED;
1662         centralManagerCallbacks_->OnStartOrStopScanEvent(SCAN_FAILED_INTERNAL_ERROR, false);
1663         return;
1664     } else {
1665         std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1666         pimpl->stopScanType_ = STOP_SCAN_TYPE_NOR;
1667         pimpl->isStopScan_ = true;
1668         pimpl->settings_.SetReportDelay(0);
1669     }
1670 }
1671 
GetDeviceType(const std::string & address) const1672 int BleCentralManagerImpl::GetDeviceType(const std::string &address) const
1673 {
1674     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1675 
1676     std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1677     for (auto value : pimpl->bleScanResult_) {
1678         if (!address.compare(value.GetPeripheralDevice().GetRawAddress().GetAddress())) {
1679             return value.GetPeripheralDevice().GetDeviceType();
1680         }
1681     }
1682     return BLE_BT_DEVICE_TYPE_UNKNOWN;
1683 }
1684 
GetDeviceAddrType(const std::string & address) const1685 int BleCentralManagerImpl::GetDeviceAddrType(const std::string &address) const
1686 {
1687     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1688 
1689     std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1690     for (auto value : pimpl->bleScanResult_) {
1691         if (!address.compare(value.GetPeripheralDevice().GetRawAddress().GetAddress())) {
1692             return value.GetPeripheralDevice().GetAddressType();
1693         }
1694     }
1695     return BLE_ADDR_TYPE_UNKNOWN;
1696 }
1697 
GetDeviceName(const std::string & address) const1698 std::string BleCentralManagerImpl::GetDeviceName(const std::string &address) const
1699 {
1700     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1701 
1702     std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1703     for (auto value : pimpl->bleScanResult_) {
1704         if (!address.compare(value.GetPeripheralDevice().GetRawAddress().GetAddress())) {
1705             return value.GetPeripheralDevice().GetName();
1706         }
1707     }
1708     return std::string("");
1709 }
1710 
FindDevice(const std::string & address,BlePeripheralDevice & dev) const1711 bool BleCentralManagerImpl::FindDevice(const std::string &address, BlePeripheralDevice &dev) const
1712 {
1713     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1714 
1715     for (auto it = pimpl->bleScanResult_.begin(); it != pimpl->bleScanResult_.end(); it++) {
1716         if (!address.compare(it->GetPeripheralDevice().GetRawAddress().GetAddress())) {
1717             dev = it->GetPeripheralDevice();
1718             pimpl->bleScanResult_.erase(it);
1719             return true;
1720         }
1721     }
1722     return false;
1723 }
1724 
GetScanStatus() const1725 int BleCentralManagerImpl::GetScanStatus() const
1726 {
1727     LOG_DEBUG("[BleCentralManagerImpl] %{public}s status:%{public}d", __func__, pimpl->scanStatus_);
1728 
1729     std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1730     return pimpl->scanStatus_;
1731 }
1732 
DirectedAdvertisingReport(uint8_t advType,const BtAddr * addr,GapDirectedAdvReportParam reportParam,const BtAddr * currentAddr,void * context)1733 void BleCentralManagerImpl::DirectedAdvertisingReport(uint8_t advType, const BtAddr *addr,
1734     GapDirectedAdvReportParam reportParam, const BtAddr *currentAddr, void *context)
1735 {
1736     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1737 }
1738 
ScanTimeoutEvent(void * context)1739 void BleCentralManagerImpl::ScanTimeoutEvent(void *context)
1740 {
1741     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1742 }
1743 
GapScanParamSetCompleteEvt(int status) const1744 void BleCentralManagerImpl::GapScanParamSetCompleteEvt(int status) const
1745 {
1746     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1747 
1748     std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1749     if (status != BT_SUCCESS) {
1750         pimpl->scanStatus_ = SCAN_NOT_STARTED;
1751         centralManagerCallbacks_->OnStartOrStopScanEvent(SCAN_FAILED_INTERNAL_ERROR, true);
1752         LOG_ERROR("[BleCentralManagerImpl] %{public}s:Set scan param failed! %{public}d.", __func__, status);
1753         return;
1754     }
1755 
1756     pimpl->StartReportDelay();
1757     if (pimpl->isStopScan_) {
1758         return;
1759     }
1760     int ret = SetScanEnable(true);
1761     if (ret != BT_SUCCESS) {
1762         LOG_ERROR("[BleCentralManagerImpl] %{public}s:SetScanEnable param failed! %{public}d.", __func__, ret);
1763         pimpl->scanStatus_ = SCAN_NOT_STARTED;
1764         centralManagerCallbacks_->OnStartOrStopScanEvent(SCAN_FAILED_INTERNAL_ERROR, true);
1765         return;
1766     }
1767 }
1768 
GapScanResultEvt() const1769 void BleCentralManagerImpl::GapScanResultEvt() const
1770 {
1771     LOG_DEBUG("[BleCentralManagerImpl] %{public}s:Scan result", __func__);
1772 
1773     if ((centralManagerCallbacks_ != nullptr) && (pimpl->callBackType_ == CALLBACK_TYPE_FIRST_MATCH)) {
1774         std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1775         centralManagerCallbacks_->OnScanCallback(pimpl->bleScanResult_.back());
1776     }
1777 }
1778 
GapScanDelayReportResultEvt() const1779 void BleCentralManagerImpl::GapScanDelayReportResultEvt() const
1780 {
1781     LOG_DEBUG("[BleCentralManagerImpl] %{public}s:Scan batch results", __func__);
1782 
1783     if ((centralManagerCallbacks_ != nullptr) && (pimpl->callBackType_ == CALLBACK_TYPE_ALL_MATCHES)) {
1784         if (pimpl->timer_ != nullptr) {
1785             pimpl->timer_->Stop();
1786         }
1787         std::lock_guard<std::recursive_mutex> legacyLock(pimpl->mutex_);
1788         centralManagerCallbacks_->OnBleBatchScanResultsEvent(pimpl->bleScanResult_);
1789     }
1790 }
1791 
GapScanStartCompleteEvt(int status) const1792 void BleCentralManagerImpl::GapScanStartCompleteEvt(int status) const
1793 {
1794     LOG_DEBUG("[BleCentralManagerImpl] %{public}s:Start scan", __func__);
1795 
1796     if (status != BT_SUCCESS) {
1797         pimpl->scanStatus_ = SCAN_NOT_STARTED;
1798         LOG_ERROR("[BleCentralManagerImpl] %{public}s:Start scan failed! %{public}d.", __func__, status);
1799     }
1800     int tmpStatus = (status != BT_SUCCESS ? SCAN_FAILED_INTERNAL_ERROR : SCAN_SUCCESS);
1801     centralManagerCallbacks_->OnStartOrStopScanEvent(tmpStatus, true);
1802 }
1803 
GapScanStopCompleteEvt(int status) const1804 void BleCentralManagerImpl::GapScanStopCompleteEvt(int status) const
1805 {
1806     LOG_DEBUG("[BleCentralManagerImpl] %{public}s:Stop scan", __func__);
1807 
1808     std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1809     if (status != BT_SUCCESS) {
1810         LOG_ERROR("[BleCentralManagerImpl] %{public}s:Stop scan failed! %{public}d.", __func__, status);
1811     }
1812     pimpl->advDataCache_.ClearAllData();
1813     pimpl->scanStatus_ = SCAN_NOT_STARTED;
1814     int tmpStatus = (status != BT_SUCCESS ? SCAN_FAILED_INTERNAL_ERROR : SCAN_SUCCESS);
1815     centralManagerCallbacks_->OnStartOrStopScanEvent(tmpStatus, false);
1816 }
1817 
GapScanResolvingCompletEvt(int status,bool isStart) const1818 void BleCentralManagerImpl::GapScanResolvingCompletEvt(int status, bool isStart) const
1819 {
1820     LOG_DEBUG("[BleCentralManagerImpl] %{public}s: ", __func__);
1821 
1822     std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1823     if (status != BT_SUCCESS) {
1824         pimpl->scanStatus_ = isStart ? SCAN_NOT_STARTED : SCAN_FAILED_ALREADY_STARTED;
1825         LOG_ERROR("[BleCentralManagerImpl] %{public}s:Resovling stop scan failed! %{public}d.", __func__, status);
1826     }
1827 }
1828 
HandleGapEvent(const BLE_GAP_CB_EVENT & event,int status) const1829 void BleCentralManagerImpl::HandleGapEvent(const BLE_GAP_CB_EVENT &event, int status) const
1830 {
1831     LOG_DEBUG("[BleCentralManagerImpl] %{public}s:[event no: %{public}d]", __func__, static_cast<int>(event));
1832 
1833     switch (event) {
1834         case BLE_GAP_SCAN_PARAM_SET_COMPLETE_EVT:
1835             GapScanParamSetCompleteEvt(status);
1836             break;
1837         case BLE_GAP_SCAN_RESULT_EVT:
1838             GapScanResultEvt();
1839             break;
1840         case BLE_GAP_SCAN_DELAY_REPORT_RESULT_EVT:
1841             GapScanDelayReportResultEvt();
1842             break;
1843         case BLE_GAP_SCAN_START_COMPLETE_EVT:
1844             GapScanStartCompleteEvt(status);
1845             break;
1846         case BLE_GAP_RESOLVING_LIST_ADV_SCAN_START_COMPLETE_EVT:
1847             GapScanResolvingCompletEvt(status, true);
1848             break;
1849         case BLE_GAP_SCAN_STOP_COMPLETE_EVT:
1850             GapScanStopCompleteEvt(status);
1851             break;
1852         case BLE_GAP_RESOLVING_LIST_ADV_SCAN_STOP_COMPLETE_EVT:
1853             GapScanResolvingCompletEvt(status, false);
1854             break;
1855         default: {
1856             LOG_ERROR("[BleCentralManagerImpl] %{public}s:Invalid event! %{public}d.", __func__, event);
1857             break;
1858         }
1859     }
1860 }
1861 
GapExScanParamSetCompleteEvt(int status) const1862 void BleCentralManagerImpl::GapExScanParamSetCompleteEvt(int status) const
1863 {
1864     LOG_DEBUG("[BleCentralManagerImpl] %{public}s", __func__);
1865 
1866     std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1867     if (status != BT_SUCCESS) {
1868         pimpl->scanStatus_ = SCAN_NOT_STARTED;
1869         LOG_ERROR("[BleCentralManagerImpl] %{public}s:Set scan param failed! %{public}d.", __func__, status);
1870         centralManagerCallbacks_->OnStartOrStopScanEvent(SCAN_FAILED_INTERNAL_ERROR, true);
1871         return;
1872     }
1873     pimpl->StartReportDelay();
1874     if (pimpl->isStopScan_) {
1875         return;
1876     }
1877     int ret = SetExScanEnable(true);
1878     if (ret != BT_SUCCESS) {
1879         LOG_ERROR("[BleCentralManagerImpl] %{public}s:SetExScanEnable param failed! %{public}d.", __func__, ret);
1880         pimpl->scanStatus_ = SCAN_NOT_STARTED;
1881         centralManagerCallbacks_->OnStartOrStopScanEvent(SCAN_FAILED_INTERNAL_ERROR, true);
1882         return;
1883     }
1884 }
1885 
GapExScanResultEvt() const1886 void BleCentralManagerImpl::GapExScanResultEvt() const
1887 {
1888     LOG_DEBUG("[BleCentralManagerImpl] %{public}s:Scan result", __func__);
1889 
1890     if ((centralManagerCallbacks_ != nullptr) && (pimpl->callBackType_ == CALLBACK_TYPE_FIRST_MATCH)) {
1891         std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1892         centralManagerCallbacks_->OnScanCallback(pimpl->bleScanResult_.back());
1893     }
1894 }
1895 
GapExScanDelayReportResultEvt() const1896 void BleCentralManagerImpl::GapExScanDelayReportResultEvt() const
1897 {
1898     LOG_DEBUG("[BleCentralManagerImpl] %{public}s:Scan batch results", __func__);
1899 
1900     if ((centralManagerCallbacks_ != nullptr) && (pimpl->callBackType_ == CALLBACK_TYPE_ALL_MATCHES)) {
1901         if (pimpl->timer_ != nullptr) {
1902             pimpl->timer_->Stop();
1903         }
1904         std::lock_guard<std::recursive_mutex> exAdvLock(pimpl->mutex_);
1905         centralManagerCallbacks_->OnBleBatchScanResultsEvent(pimpl->bleScanResult_);
1906     }
1907 }
1908 
GapExScanStartCompleteEvt(int status) const1909 void BleCentralManagerImpl::GapExScanStartCompleteEvt(int status) const
1910 {
1911     LOG_DEBUG("[BleCentralManagerImpl] %{public}s:Start scan", __func__);
1912 
1913     if (status != BT_SUCCESS) {
1914         pimpl->scanStatus_ = SCAN_NOT_STARTED;
1915         LOG_ERROR("[BleCentralManagerImpl] %{public}s:Start scan failed! %{public}d.", __func__, status);
1916     }
1917     int tmpStatus = (status != BT_SUCCESS ? SCAN_FAILED_INTERNAL_ERROR : SCAN_SUCCESS);
1918     centralManagerCallbacks_->OnStartOrStopScanEvent(tmpStatus, true);
1919 }
1920 
GapExScanStopCompleteEvt(int status) const1921 void BleCentralManagerImpl::GapExScanStopCompleteEvt(int status) const
1922 {
1923     LOG_DEBUG("[BleCentralManagerImpl] %{public}s:Stop scan", __func__);
1924 
1925     std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1926     if (status != BT_SUCCESS) {
1927         LOG_ERROR("[BleCentralManagerImpl] %{public}s:Stop scan failed! %{public}d.", __func__, status);
1928     }
1929     pimpl->scanStatus_ = SCAN_NOT_STARTED;
1930     pimpl->advDataCache_.ClearAllData();
1931     int tmpStatus = (status != BT_SUCCESS ? SCAN_FAILED_INTERNAL_ERROR : SCAN_SUCCESS);
1932     centralManagerCallbacks_->OnStartOrStopScanEvent(tmpStatus, false);
1933 }
1934 
GapExScanResolvingCompletEvt(int status,bool isStart) const1935 void BleCentralManagerImpl::GapExScanResolvingCompletEvt(int status, bool isStart) const
1936 {
1937     LOG_DEBUG("[BleCentralManagerImpl] %{public}s:", __func__);
1938     std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1939     if (status != BT_SUCCESS) {
1940         pimpl->scanStatus_ = isStart ? SCAN_NOT_STARTED : SCAN_FAILED_ALREADY_STARTED;
1941         LOG_ERROR("[BleCentralManagerImpl] %{public}s:Resolving stop scan failed! %{public}d.", __func__, status);
1942     }
1943 }
1944 
HandleGapExScanEvent(const BLE_GAP_CB_EVENT & event,int status) const1945 void BleCentralManagerImpl::HandleGapExScanEvent(const BLE_GAP_CB_EVENT &event, int status) const
1946 {
1947     LOG_DEBUG("[BleCentralManagerImpl] %{public}s:[event no: %{public}d]", __func__, static_cast<int>(event));
1948 
1949     switch (event) {
1950         case BLE_GAP_EX_SCAN_PARAM_SET_COMPLETE_EVT:
1951             GapExScanParamSetCompleteEvt(status);
1952             break;
1953         case BLE_GAP_EX_SCAN_RESULT_EVT:
1954             GapExScanResultEvt();
1955             break;
1956         case BLE_GAP_EX_SCAN_DELAY_REPORT_RESULT_EVT:
1957             GapExScanDelayReportResultEvt();
1958             break;
1959         case BLE_GAP_EX_SCAN_START_COMPLETE_EVT:
1960             GapExScanStartCompleteEvt(status);
1961             break;
1962         case BLE_GAP_EX_RESOLVING_LIST_ADV_SCAN_START_COMPLETE_EVT:
1963             GapExScanResolvingCompletEvt(status, true);
1964             break;
1965         case BLE_GAP_EX_SCAN_STOP_COMPLETE_EVT:
1966             GapExScanStopCompleteEvt(status);
1967             break;
1968         case BLE_GAP_EX_RESOLVING_LIST_ADV_SCAN_STOP_COMPLETE_EVT:
1969             GapExScanResolvingCompletEvt(status, false);
1970             break;
1971         default: {
1972             LOG_ERROR("[BleCentralManagerImpl] %{public}s:Invalid event! %{public}d.", __func__, event);
1973             break;
1974         }
1975     }
1976 }
1977 }  // namespace bluetooth
1978 }  // namespace OHOS
1979