1 /*
2 * Copyright (c) 2021 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 #include "softbus_adapter_ble_gatt.h"
16
17 #include "adapter_bt_utils.h"
18 #include "c_header/ohos_bt_def.h"
19 #include "c_header/ohos_bt_gap.h"
20 #include "c_header/ohos_bt_gatt.h"
21 #include "securec.h"
22 #include "softbus_adapter_bt_common.h"
23 #include "softbus_adapter_mem.h"
24 #include "softbus_adapter_thread.h"
25 #include "softbus_def.h"
26 #include "softbus_errcode.h"
27 #include "softbus_log.h"
28 #include "softbus_utils.h"
29
30 #define BT_UUID "43d4a49f-604d-45b5-9302-4ddbbfd538fd"
31 #define DELIVERY_MODE_REPLY 0xF0 // Lpdevice delivery mode: reply adv when filter matched
32 #define ADV_DURATION_MS 0
33 #define ADV_WAIT_TIME_SEC 2
34 static int32_t g_scannerId = -1;
35 typedef struct {
36 int advId;
37 bool isUsed;
38 bool isAdvertising;
39 SoftBusCond cond;
40 SoftBusBleAdvData advData;
41 SoftBusAdvCallback *advCallback;
42 } AdvChannel;
43
44 typedef struct {
45 bool isUsed;
46 bool isNeedReset;
47 bool isScanning;
48 SoftBusBleScanParams param;
49 SoftBusBleScanFilter *filter;
50 uint8_t filterSize;
51 SoftBusScanListener *listener;
52 int32_t scannerId;
53 } ScanListener;
54
55 static AdvChannel g_advChannel[ADV_MAX_NUM];
56 static ScanListener g_scanListener[SCAN_MAX_NUM];
57
58 static volatile bool g_lockInit = false;
59 static SoftBusMutex g_advLock = {0};
60 static SoftBusMutex g_scanerLock = {0};
61
62 static volatile bool g_isRegCb = false;
63 static volatile bool g_isLpDeviceRegCb = false;
64
OnBtStateChanged(int32_t listenerId,int32_t state)65 NO_SANITIZE("cfi") static void OnBtStateChanged(int32_t listenerId, int32_t state)
66 {
67 (void)listenerId;
68 if (state != SOFTBUS_BT_STATE_TURN_OFF) {
69 return;
70 }
71
72 CLOGI("receive bt turn off event, start reset bt adapter state...");
73 if (SoftBusMutexLock(&g_advLock) != 0) {
74 CLOGE("ATTENTION, try to get adv lock failed, something unexpected happened");
75 return;
76 }
77 for (uint32_t index = 0; index < ADV_MAX_NUM; index++) {
78 AdvChannel *advChannel = &g_advChannel[index];
79 if (advChannel->isUsed && advChannel->advId != -1) {
80 // ignore status code explicitedly, just to notify bt cleanup resources associated with this advertisement
81 (void)BleStopAdv(advChannel->advId);
82 advChannel->advId = -1;
83 advChannel->isAdvertising = false;
84 SoftBusCondBroadcast(&advChannel->cond);
85 advChannel->advCallback->AdvDisableCallback(index, SOFTBUS_BT_STATUS_SUCCESS);
86 }
87 }
88 (void)SoftBusMutexUnlock(&g_advLock);
89
90 if (SoftBusMutexLock(&g_scanerLock) != 0) {
91 CLOGE("ATTENTION, try to get scan lock failed, something unexpected happened");
92 return;
93 }
94 for (int index = 0; index < SCAN_MAX_NUM; index++) {
95 ScanListener *scanListener = &g_scanListener[index];
96 if (scanListener->isUsed && scanListener->isScanning) {
97 scanListener->isScanning = false;
98 scanListener->listener->OnScanStop(index, SOFTBUS_BT_STATUS_SUCCESS);
99 (void)BleStopScan(scanListener->scannerId);
100 }
101 }
102 (void)SoftBusMutexUnlock(&g_scanerLock);
103 }
104
BleGattLockInit(void)105 NO_SANITIZE("cfi") int BleGattLockInit(void)
106 {
107 if (g_lockInit) {
108 return SOFTBUS_OK;
109 }
110 if (SoftBusMutexInit(&g_advLock, NULL) != SOFTBUS_OK) {
111 CLOGE("g_advLock init failed");
112 return SOFTBUS_ERR;
113 }
114 if (SoftBusMutexInit(&g_scanerLock, NULL) != SOFTBUS_OK) {
115 CLOGE("g_scanerLock init failed");
116 return SOFTBUS_ERR;
117 }
118 g_lockInit = true;
119 return SOFTBUS_OK;
120 }
121
ConvertScanEventType(unsigned char eventType)122 static unsigned char ConvertScanEventType(unsigned char eventType)
123 {
124 switch (eventType) {
125 case OHOS_BLE_EVT_NON_CONNECTABLE_NON_SCANNABLE:
126 return SOFTBUS_BLE_EVT_NON_CONNECTABLE_NON_SCANNABLE;
127 case OHOS_BLE_EVT_NON_CONNECTABLE_NON_SCANNABLE_DIRECTED:
128 return SOFTBUS_BLE_EVT_NON_CONNECTABLE_NON_SCANNABLE_DIRECTED;
129 case OHOS_BLE_EVT_CONNECTABLE:
130 return SOFTBUS_BLE_EVT_CONNECTABLE;
131 case OHOS_BLE_EVT_CONNECTABLE_DIRECTED:
132 return SOFTBUS_BLE_EVT_CONNECTABLE_DIRECTED;
133 case OHOS_BLE_EVT_SCANNABLE:
134 return SOFTBUS_BLE_EVT_SCANNABLE;
135 case OHOS_BLE_EVT_SCANNABLE_DIRECTED:
136 return SOFTBUS_BLE_EVT_SCANNABLE_DIRECTED;
137 case OHOS_BLE_EVT_LEGACY_NON_CONNECTABLE:
138 return SOFTBUS_BLE_EVT_LEGACY_NON_CONNECTABLE;
139 case OHOS_BLE_EVT_LEGACY_SCANNABLE:
140 return SOFTBUS_BLE_EVT_LEGACY_SCANNABLE;
141 case OHOS_BLE_EVT_LEGACY_CONNECTABLE:
142 return SOFTBUS_BLE_EVT_LEGACY_CONNECTABLE;
143 case OHOS_BLE_EVT_LEGACY_CONNECTABLE_DIRECTED:
144 return SOFTBUS_BLE_EVT_LEGACY_CONNECTABLE_DIRECTED;
145 case OHOS_BLE_EVT_LEGACY_SCAN_RSP_TO_ADV_SCAN:
146 return SOFTBUS_BLE_EVT_LEGACY_SCAN_RSP_TO_ADV_SCAN;
147 case OHOS_BLE_EVT_LEGACY_SCAN_RSP_TO_ADV:
148 return SOFTBUS_BLE_EVT_LEGACY_SCAN_RSP_TO_ADV;
149 default:
150 return SOFTBUS_BLE_EVT_NON_CONNECTABLE_NON_SCANNABLE;
151 }
152 }
153
ConvertScanPhyType(unsigned char phyType)154 static unsigned char ConvertScanPhyType(unsigned char phyType)
155 {
156 switch (phyType) {
157 case OHOS_BLE_SCAN_PHY_NO_PACKET:
158 return SOFTBUS_BLE_SCAN_PHY_NO_PACKET;
159 case OHOS_BLE_SCAN_PHY_1M:
160 return SOFTBUS_BLE_SCAN_PHY_1M;
161 case OHOS_BLE_SCAN_PHY_2M:
162 return SOFTBUS_BLE_SCAN_PHY_2M;
163 case OHOS_BLE_SCAN_PHY_CODED:
164 return SOFTBUS_BLE_SCAN_PHY_CODED;
165 default:
166 return SOFTBUS_BLE_SCAN_PHY_NO_PACKET;
167 }
168 }
169
ConvertScanDataStatus(unsigned char dataStatus)170 static unsigned char ConvertScanDataStatus(unsigned char dataStatus)
171 {
172 switch (dataStatus) {
173 case OHOS_BLE_DATA_COMPLETE:
174 return SOFTBUS_BLE_DATA_COMPLETE;
175 case OHOS_BLE_DATA_INCOMPLETE_MORE_TO_COME:
176 return SOFTBUS_BLE_DATA_INCOMPLETE_MORE_TO_COME;
177 case OHOS_BLE_DATA_INCOMPLETE_TRUNCATED:
178 return SOFTBUS_BLE_DATA_INCOMPLETE_TRUNCATED;
179 default:
180 return SOFTBUS_BLE_DATA_INCOMPLETE_TRUNCATED;
181 }
182 }
183
ConvertScanAddrType(unsigned char addrType)184 static unsigned char ConvertScanAddrType(unsigned char addrType)
185 {
186 switch (addrType) {
187 case OHOS_BLE_PUBLIC_DEVICE_ADDRESS:
188 return SOFTBUS_BLE_PUBLIC_DEVICE_ADDRESS;
189 case OHOS_BLE_RANDOM_DEVICE_ADDRESS:
190 return SOFTBUS_BLE_RANDOM_DEVICE_ADDRESS;
191 case OHOS_BLE_PUBLIC_IDENTITY_ADDRESS:
192 return SOFTBUS_BLE_PUBLIC_IDENTITY_ADDRESS;
193 case OHOS_BLE_RANDOM_STATIC_IDENTITY_ADDRESS:
194 return SOFTBUS_BLE_RANDOM_STATIC_IDENTITY_ADDRESS;
195 case OHOS_BLE_UNRESOLVABLE_RANDOM_DEVICE_ADDRESS:
196 return SOFTBUS_BLE_UNRESOLVABLE_RANDOM_DEVICE_ADDRESS;
197 case OHOS_BLE_NO_ADDRESS:
198 return SOFTBUS_BLE_NO_ADDRESS;
199 default:
200 return SOFTBUS_BLE_NO_ADDRESS;
201 }
202 }
203
ConvertScanMode(unsigned short scanInterval,unsigned short scanWindow)204 static int ConvertScanMode(unsigned short scanInterval, unsigned short scanWindow)
205 {
206 if (scanInterval == SOFTBUS_BLE_SCAN_INTERVAL_P2 && scanWindow == SOFTBUS_BLE_SCAN_WINDOW_P2) {
207 return OHOS_BLE_SCAN_MODE_OP_P2_60_3000;
208 }
209 if (scanInterval == SOFTBUS_BLE_SCAN_INTERVAL_P10 && scanWindow == SOFTBUS_BLE_SCAN_WINDOW_P10) {
210 return OHOS_BLE_SCAN_MODE_OP_P10_60_600;
211 }
212 if (scanInterval == SOFTBUS_BLE_SCAN_INTERVAL_P25 && scanWindow == SOFTBUS_BLE_SCAN_WINDOW_P25) {
213 return OHOS_BLE_SCAN_MODE_OP_P25_60_240;
214 }
215 if (scanInterval == SOFTBUS_BLE_SCAN_INTERVAL_P100 && scanWindow == SOFTBUS_BLE_SCAN_WINDOW_P100) {
216 return OHOS_BLE_SCAN_MODE_OP_P100_1000_1000;
217 }
218 return OHOS_BLE_SCAN_MODE_LOW_POWER;
219 }
220
SetAndGetSuitableScanConfig(int listenerId,const SoftBusBleScanParams * params,BleScanConfigs * configs)221 static void SetAndGetSuitableScanConfig(int listenerId, const SoftBusBleScanParams *params, BleScanConfigs *configs)
222 {
223 static int lastScanMode = OHOS_BLE_SCAN_MODE_LOW_POWER;
224 (void)memset_s(configs, sizeof(BleScanConfigs), 0x0, sizeof(BleScanConfigs));
225 g_scanListener[listenerId].param = *params;
226 for (int index = 0; index < SCAN_MAX_NUM; index++) {
227 if (!g_scanListener[index].isUsed || (!g_scanListener[index].isScanning && index != listenerId)) {
228 continue;
229 }
230 int scanMode = ConvertScanMode(g_scanListener[index].param.scanInterval,
231 g_scanListener[index].param.scanWindow);
232 if (scanMode > configs->scanMode) {
233 configs->scanMode = scanMode;
234 }
235 }
236 if (lastScanMode != configs->scanMode) {
237 g_scanListener[listenerId].isNeedReset = true;
238 lastScanMode = configs->scanMode;
239 }
240 }
241
DumpBleScanFilter(BleScanNativeFilter * nativeFilter,uint8_t filterSize)242 static void DumpBleScanFilter(BleScanNativeFilter *nativeFilter, uint8_t filterSize)
243 {
244 while (filterSize-- > 0) {
245 int32_t len = (nativeFilter + filterSize)->serviceDataLength;
246 if (len <= 0) {
247 continue;
248 }
249 int32_t hexLen = HEXIFY_LEN(len);
250 char *serviceData = (char *)SoftBusCalloc(sizeof(char) * hexLen);
251 char *serviceDataMask = (char *)SoftBusCalloc(sizeof(char) * hexLen);
252 if (serviceData == NULL || serviceDataMask == NULL) {
253 SoftBusFree(serviceData);
254 SoftBusFree(serviceDataMask);
255 continue;
256 }
257 (void)ConvertBytesToHexString(serviceData, hexLen, (nativeFilter + filterSize)->serviceData, len);
258 (void)ConvertBytesToHexString(serviceDataMask, hexLen, (nativeFilter + filterSize)->serviceDataMask, len);
259 CLOGI("BLE Scan Filter id:%d [serviceData:%s, serviceDataMask:%s]",
260 filterSize, serviceData, serviceDataMask);
261 SoftBusFree(serviceData);
262 SoftBusFree(serviceDataMask);
263 }
264 }
265
GetAllNativeScanFilter(int thisListenerId,BleScanNativeFilter ** nativeFilter,uint8_t * filterSize)266 static void GetAllNativeScanFilter(int thisListenerId, BleScanNativeFilter **nativeFilter, uint8_t *filterSize)
267 {
268 uint8_t nativeSize = 0;
269 for (int index = 0; index < SCAN_MAX_NUM; index++) {
270 if (!g_scanListener[index].isUsed || (!g_scanListener[index].isScanning && index != thisListenerId) ||
271 g_scanListener[index].scannerId != g_scannerId) {
272 g_scanListener[index].isNeedReset = false;
273 continue;
274 }
275 g_scanListener[index].isNeedReset = true;
276 nativeSize += g_scanListener[index].filterSize;
277 }
278 *nativeFilter = (BleScanNativeFilter *)SoftBusCalloc(sizeof(BleScanNativeFilter) * nativeSize);
279 if (*nativeFilter == NULL) {
280 return;
281 }
282 *filterSize = nativeSize;
283 for (int index = 0; index < SCAN_MAX_NUM; index++) {
284 if (!g_scanListener[index].isNeedReset) {
285 continue;
286 }
287 uint8_t size = g_scanListener[index].filterSize;
288 const SoftBusBleScanFilter *filter = g_scanListener[index].filter;
289 while (size-- > 0) {
290 nativeSize--;
291 (*nativeFilter + nativeSize)->address = (filter + size)->address;
292 (*nativeFilter + nativeSize)->deviceName = (filter + size)->deviceName;
293 (*nativeFilter + nativeSize)->manufactureData = (filter + size)->manufactureData;
294 (*nativeFilter + nativeSize)->manufactureDataLength = (filter + size)->manufactureDataLength;
295 (*nativeFilter + nativeSize)->manufactureDataMask = (filter + size)->manufactureDataMask;
296 (*nativeFilter + nativeSize)->manufactureId = (filter + size)->manufactureId;
297 (*nativeFilter + nativeSize)->serviceData = (filter + size)->serviceData;
298 (*nativeFilter + nativeSize)->serviceDataLength = (filter + size)->serviceDataLength;
299 (*nativeFilter + nativeSize)->serviceDataMask = (filter + size)->serviceDataMask;
300 (*nativeFilter + nativeSize)->serviceUuid = (filter + size)->serviceUuid;
301 (*nativeFilter + nativeSize)->serviceUuidLength = (filter + size)->serviceUuidLength;
302 (*nativeFilter + nativeSize)->serviceUuidMask = (filter + size)->serviceUuidMask;
303 }
304 }
305 }
306
SoftBusGetBurstScanFilter(int thisListenerId,BleScanNativeFilter ** nativeFilter,uint8_t * filterSize)307 static void SoftBusGetBurstScanFilter(int thisListenerId, BleScanNativeFilter **nativeFilter, uint8_t *filterSize)
308 {
309 uint8_t size = g_scanListener[thisListenerId].filterSize;
310 *nativeFilter = (BleScanNativeFilter *)SoftBusCalloc(sizeof(BleScanNativeFilter) * size);
311 if (*nativeFilter == NULL) {
312 return;
313 }
314 const SoftBusBleScanFilter *filter = g_scanListener[thisListenerId].filter;
315 while (size-- > 0) {
316 (*nativeFilter + size)->address = (filter + size)->address;
317 (*nativeFilter + size)->deviceName = (filter + size)->deviceName;
318 (*nativeFilter + size)->manufactureData = (filter + size)->manufactureData;
319 (*nativeFilter + size)->manufactureDataLength = (filter + size)->manufactureDataLength;
320 (*nativeFilter + size)->manufactureDataMask = (filter + size)->manufactureDataMask;
321 (*nativeFilter + size)->manufactureId = (filter + size)->manufactureId;
322 (*nativeFilter + size)->serviceData = (filter + size)->serviceData;
323 (*nativeFilter + size)->serviceDataLength = (filter + size)->serviceDataLength;
324 (*nativeFilter + size)->serviceDataMask = (filter + size)->serviceDataMask;
325 (*nativeFilter + size)->serviceUuid = (filter + size)->serviceUuid;
326 (*nativeFilter + size)->serviceUuidLength = (filter + size)->serviceUuidLength;
327 (*nativeFilter + size)->serviceUuidMask = (filter + size)->serviceUuidMask;
328 }
329 *filterSize = g_scanListener[thisListenerId].filterSize;
330 }
331
ConvertScanResult(const BtScanResultData * src,SoftBusBleScanResult * dst)332 static void ConvertScanResult(const BtScanResultData *src, SoftBusBleScanResult *dst)
333 {
334 dst->eventType = ConvertScanEventType(src->eventType);
335 dst->dataStatus = ConvertScanDataStatus(src->dataStatus);
336 dst->addrType = ConvertScanAddrType(src->addrType);
337 if (memcpy_s(dst->addr.addr, BT_ADDR_LEN, src->addr.addr, BT_ADDR_LEN) != EOK) {
338 CLOGE("ConvertScanResult memcpy addr fail");
339 return;
340 }
341 dst->primaryPhy = ConvertScanPhyType(src->primaryPhy);
342 dst->secondaryPhy = ConvertScanPhyType(src->secondaryPhy);
343 dst->advSid = src->advSid;
344 dst->txPower = src->txPower;
345 dst->rssi = src->rssi;
346 dst->periodicAdvInterval = src->periodicAdvInterval;
347 dst->directAddrType = ConvertScanAddrType(src->directAddrType);
348 if (memcpy_s(dst->directAddr.addr, BT_ADDR_LEN, src->directAddr.addr, BT_ADDR_LEN) != EOK) {
349 CLOGE("ConvertScanResult memcpy directAddr fail");
350 return;
351 }
352 dst->advLen = src->advLen;
353 dst->advData = src->advData;
354 }
355
ConvertAdvType(unsigned char advType)356 static unsigned char ConvertAdvType(unsigned char advType)
357 {
358 switch (advType) {
359 case SOFTBUS_BLE_ADV_IND:
360 return OHOS_BLE_ADV_IND;
361 case SOFTBUS_BLE_ADV_DIRECT_IND_HIGH:
362 return OHOS_BLE_ADV_DIRECT_IND_HIGH;
363 case SOFTBUS_BLE_ADV_SCAN_IND:
364 return OHOS_BLE_ADV_SCAN_IND;
365 case SOFTBUS_BLE_ADV_NONCONN_IND:
366 return OHOS_BLE_ADV_NONCONN_IND;
367 case SOFTBUS_BLE_ADV_DIRECT_IND_LOW:
368 return OHOS_BLE_ADV_DIRECT_IND_LOW;
369 default:
370 return OHOS_BLE_ADV_IND;
371 }
372 }
373
ConvertAdvFilter(unsigned char advFilter)374 static unsigned char ConvertAdvFilter(unsigned char advFilter)
375 {
376 switch (advFilter) {
377 case SOFTBUS_BLE_ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY:
378 return OHOS_BLE_ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY;
379 case SOFTBUS_BLE_ADV_FILTER_ALLOW_SCAN_WLST_CON_ANY:
380 return OHOS_BLE_ADV_FILTER_ALLOW_SCAN_WLST_CON_ANY;
381 case SOFTBUS_BLE_ADV_FILTER_ALLOW_SCAN_ANY_CON_WLST:
382 return OHOS_BLE_ADV_FILTER_ALLOW_SCAN_ANY_CON_WLST;
383 case SOFTBUS_BLE_ADV_FILTER_ALLOW_SCAN_WLST_CON_WLST:
384 return OHOS_BLE_ADV_FILTER_ALLOW_SCAN_WLST_CON_WLST;
385 default:
386 return OHOS_BLE_ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY;
387 }
388 }
389
ConvertAdvData(const SoftBusBleAdvData * src,StartAdvRawData * dst)390 static void ConvertAdvData(const SoftBusBleAdvData *src, StartAdvRawData *dst)
391 {
392 dst->advDataLen = src->advLength;
393 dst->advData = (unsigned char *)src->advData;
394 dst->rspDataLen = src->scanRspLength;
395 dst->rspData = (unsigned char *)src->scanRspData;
396 }
397
ConvertAdvParam(const SoftBusBleAdvParams * src,BleAdvParams * dst)398 static void ConvertAdvParam(const SoftBusBleAdvParams *src, BleAdvParams *dst)
399 {
400 dst->minInterval = src->minInterval;
401 dst->maxInterval = src->maxInterval;
402 dst->advType = ConvertAdvType(src->advType);
403 dst->ownAddrType = 0x00;
404 dst->peerAddrType = 0x00;
405 if (memcpy_s(dst->peerAddr.addr, BT_ADDR_LEN, src->peerAddr.addr, BT_ADDR_LEN) != EOK) {
406 CLOGE("ConvertAdvParam memcpy directAddr fail");
407 return;
408 }
409 dst->channelMap = src->channelMap;
410 dst->advFilterPolicy = ConvertAdvFilter(src->advFilterPolicy);
411 dst->txPower = src->txPower;
412 dst->duration = src->duration;
413 }
414
WrapperAdvEnableCallback(int advId,int status)415 NO_SANITIZE("cfi") static void WrapperAdvEnableCallback(int advId, int status)
416 {
417 int32_t st = BleOhosStatusToSoftBus((BtStatus)status);
418 for (uint32_t index = 0; index < ADV_MAX_NUM; index++) {
419 AdvChannel *advChannel = &g_advChannel[index];
420 if (advChannel->advId != advId ||
421 advChannel->isUsed == false ||
422 advChannel->advCallback == NULL ||
423 advChannel->advCallback->AdvEnableCallback == NULL) {
424 continue;
425 }
426 CLOGI("WrapperAdvEnableCallback, inner-advId: %d, bt-advId: %d, "
427 "status: %d", index, advId, st);
428 if (st == SOFTBUS_BT_STATUS_SUCCESS) {
429 advChannel->isAdvertising = true;
430 SoftBusCondSignal(&advChannel->cond);
431 }
432 advChannel->advCallback->AdvEnableCallback(index, st);
433 break;
434 }
435 }
436
WrapperAdvDisableCallback(int advId,int status)437 NO_SANITIZE("cfi") static void WrapperAdvDisableCallback(int advId, int status)
438 {
439 int32_t st = BleOhosStatusToSoftBus((BtStatus)status);
440 for (uint32_t index = 0; index < ADV_MAX_NUM; index++) {
441 AdvChannel *advChannel = &g_advChannel[index];
442 if (advChannel->advId != advId ||
443 advChannel->isUsed == false ||
444 advChannel->advCallback == NULL ||
445 advChannel->advCallback->AdvDisableCallback == NULL) {
446 continue;
447 }
448 CLOGI("WrapperAdvDisableCallback, inner-advId: %d, bt-advId: %d, "
449 "status: %d", index, advId, st);
450 if (st == SOFTBUS_BT_STATUS_SUCCESS) {
451 advChannel->advId = -1;
452 advChannel->isAdvertising = false;
453 SoftBusCondSignal(&advChannel->cond);
454 }
455 advChannel->advCallback->AdvDisableCallback(index, st);
456 break;
457 }
458 }
459
WrapperAdvDataCallback(int advId,int status)460 NO_SANITIZE("cfi") static void WrapperAdvDataCallback(int advId, int status)
461 {
462 int32_t st = BleOhosStatusToSoftBus((BtStatus)status);
463 for (uint32_t index = 0; index < ADV_MAX_NUM; index++) {
464 AdvChannel *advChannel = &g_advChannel[index];
465 if (advChannel->advId != advId ||
466 advChannel->isUsed == false ||
467 advChannel->advCallback == NULL ||
468 advChannel->advCallback->AdvDataCallback == NULL) {
469 continue;
470 }
471 CLOGI("WrapperAdvDataCallback, inner-advId: %d, bt-advId: %d, "
472 "status: %d", index, advId, st);
473 advChannel->advCallback->AdvDataCallback(index, st);
474 break;
475 }
476 }
477
WrapperAdvUpdateCallback(int advId,int status)478 NO_SANITIZE("cfi") static void WrapperAdvUpdateCallback(int advId, int status)
479 {
480 int32_t st = BleOhosStatusToSoftBus((BtStatus)status);
481 for (uint32_t index = 0; index < ADV_MAX_NUM; index++) {
482 AdvChannel *advChannel = &g_advChannel[index];
483 if (advChannel->advId != advId ||
484 advChannel->isUsed == false ||
485 advChannel->advCallback == NULL ||
486 advChannel->advCallback->AdvUpdateCallback == NULL) {
487 continue;
488 }
489 CLOGI("WrapperAdvUpdateCallback, inner-advId: %d, bt-advId: %d, "
490 "status: %d", index, advId, st);
491 advChannel->advCallback->AdvUpdateCallback(index, st);
492 break;
493 }
494 }
495
WrapperSecurityRespondCallback(const BdAddr * bdAddr)496 NO_SANITIZE("cfi") static void WrapperSecurityRespondCallback(const BdAddr *bdAddr)
497 {
498 (void)bdAddr;
499 CLOGI("WrapperSecurityRespondCallback");
500 }
501
WrapperScanResultCallback(BtScanResultData * scanResultdata)502 NO_SANITIZE("cfi") static void WrapperScanResultCallback(BtScanResultData *scanResultdata)
503 {
504 if (scanResultdata == NULL) {
505 return;
506 }
507 int listenerId;
508 SoftBusBleScanResult sr;
509 ConvertScanResult(scanResultdata, &sr);
510 for (listenerId = 0; listenerId < SCAN_MAX_NUM; listenerId++) {
511 SoftBusMutexLock(&g_scanerLock);
512 ScanListener *scanListener = &g_scanListener[listenerId];
513 if (!scanListener->isUsed || scanListener->listener == NULL || !scanListener->isScanning ||
514 scanListener->listener->OnScanResult == NULL) {
515 SoftBusMutexUnlock(&g_scanerLock);
516 continue;
517 }
518 SoftBusMutexUnlock(&g_scanerLock);
519 scanListener->listener->OnScanResult(listenerId, &sr);
520 }
521 }
522
WrapperLpDeviceInfoCallback(BtUuid * uuid,int32_t type,uint8_t * data,uint32_t dataSize)523 static void WrapperLpDeviceInfoCallback(BtUuid *uuid, int32_t type, uint8_t *data, uint32_t dataSize)
524 {
525 for (uint32_t index = 0; index < ADV_MAX_NUM; index++) {
526 AdvChannel *advChannel = &g_advChannel[index];
527 if (advChannel->isUsed == false || advChannel->advCallback == NULL ||
528 advChannel->advCallback->LpDeviceInfoCallback == NULL) {
529 continue;
530 }
531 advChannel->advCallback->LpDeviceInfoCallback((SoftBusBtUuid *)uuid, type, data, dataSize);
532 break;
533 }
534 }
535
WrapperScanStateChangeCallback(int32_t resultCode,bool isStartScan)536 static void WrapperScanStateChangeCallback(int32_t resultCode, bool isStartScan)
537 {
538 int32_t listenerId;
539 for (listenerId = 0; listenerId < SCAN_MAX_NUM; listenerId++) {
540 SoftBusMutexLock(&g_scanerLock);
541 ScanListener *scanListener = &g_scanListener[listenerId];
542 if (!scanListener->isUsed || scanListener->listener == NULL || !scanListener->isScanning ||
543 scanListener->listener->OnScanStateChanged == NULL) {
544 SoftBusMutexUnlock(&g_scanerLock);
545 continue;
546 }
547 SoftBusMutexUnlock(&g_scanerLock);
548 scanListener->listener->OnScanStateChanged(resultCode, isStartScan);
549 }
550 }
551
552 static BtGattCallbacks g_softbusGattCb = {
553 .advEnableCb = WrapperAdvEnableCallback,
554 .advDisableCb = WrapperAdvDisableCallback,
555 .advDataCb = WrapperAdvDataCallback,
556 .advUpdateCb = WrapperAdvUpdateCallback,
557 .securityRespondCb = WrapperSecurityRespondCallback,
558 };
559
560 static BleScanCallbacks g_softbusBleScanCb = {
561 .scanResultCb = WrapperScanResultCallback,
562 .scanStateChangeCb = WrapperScanStateChangeCallback,
563 .lpDeviceInfoCb = WrapperLpDeviceInfoCallback,
564 };
565
566 static SoftBusBtStateListener g_btStateLister = {
567 .OnBtStateChanged = OnBtStateChanged,
568 .OnBtAclStateChanged = NULL,
569 };
570
RegisterBleGattCallback(int32_t * scannerId,bool isLpDeviceScan)571 static int RegisterBleGattCallback(int32_t *scannerId, bool isLpDeviceScan)
572 {
573 if (!g_isRegCb && !g_isLpDeviceRegCb) {
574 if (BleGattRegisterCallbacks(&g_softbusGattCb) != 0) {
575 return SOFTBUS_ERR;
576 }
577 if (SoftBusAddBtStateListener(&g_btStateLister) < 0) {
578 return SOFTBUS_ERR;
579 }
580 }
581 if (!isLpDeviceScan) {
582 if (g_isRegCb) {
583 *scannerId = g_scannerId;
584 return SOFTBUS_OK;
585 }
586 if (BleRegisterScanCallbacks(&g_softbusBleScanCb, scannerId) != 0) {
587 CLOGE("SH register ble scan callback failed");
588 return SOFTBUS_ERR;
589 }
590 g_scannerId = *scannerId;
591 g_isRegCb = true;
592 return SOFTBUS_OK;
593 } else {
594 if (g_isLpDeviceRegCb) {
595 return SOFTBUS_OK;
596 }
597 if (BleRegisterScanCallbacks(&g_softbusBleScanCb, scannerId) != 0) {
598 CLOGE("SH register sh scan callback failed");
599 return SOFTBUS_ERR;
600 }
601 g_isLpDeviceRegCb = true;
602 return SOFTBUS_OK;
603 }
604 }
605
CheckAdvChannelInUsed(int advId)606 static bool CheckAdvChannelInUsed(int advId)
607 {
608 if (advId < 0 || advId >= ADV_MAX_NUM) {
609 return false;
610 }
611 if (!g_advChannel[advId].isUsed) {
612 CLOGE("advId %d is ready released", advId);
613 return false;
614 }
615 return true;
616 }
617
CheckScanChannelInUsed(int listenerId)618 static bool CheckScanChannelInUsed(int listenerId)
619 {
620 if (listenerId < 0 || listenerId >= SCAN_MAX_NUM) {
621 return false;
622 }
623 if (!g_scanListener[listenerId].isUsed) {
624 CLOGE("listenerId %d is ready released", listenerId);
625 return false;
626 }
627 return true;
628 }
629
SetAdvData(int advId,const SoftBusBleAdvData * data)630 static int SetAdvData(int advId, const SoftBusBleAdvData *data)
631 {
632 g_advChannel[advId].advData.advLength = data->advLength;
633 g_advChannel[advId].advData.scanRspLength = data->scanRspLength;
634 SoftBusFree(g_advChannel[advId].advData.advData);
635 g_advChannel[advId].advData.advData = NULL;
636 SoftBusFree(g_advChannel[advId].advData.scanRspData);
637 g_advChannel[advId].advData.scanRspData = NULL;
638
639 if (data->advLength != 0) {
640 g_advChannel[advId].advData.advData = SoftBusCalloc(data->advLength);
641 if (g_advChannel[advId].advData.advData == NULL) {
642 CLOGE("SetAdvData calloc advData failed");
643 return SOFTBUS_MALLOC_ERR;
644 }
645 if (memcpy_s(g_advChannel[advId].advData.advData, data->advLength,
646 data->advData, data->advLength) != EOK) {
647 CLOGE("SetAdvData memcpy advData failed");
648 SoftBusFree(g_advChannel[advId].advData.advData);
649 g_advChannel[advId].advData.advData = NULL;
650 return SOFTBUS_MEM_ERR;
651 }
652 }
653 if (data->scanRspLength != 0) {
654 g_advChannel[advId].advData.scanRspData = SoftBusCalloc(data->scanRspLength);
655 if (g_advChannel[advId].advData.scanRspData == NULL) {
656 CLOGE("SetAdvData calloc scanRspData failed");
657 SoftBusFree(g_advChannel[advId].advData.advData);
658 g_advChannel[advId].advData.advData = NULL;
659 return SOFTBUS_MALLOC_ERR;
660 }
661 if (memcpy_s(g_advChannel[advId].advData.scanRspData, data->scanRspLength,
662 data->scanRspData, data->scanRspLength) != EOK) {
663 CLOGE("SetAdvData memcpy scanRspData failed");
664 SoftBusFree(g_advChannel[advId].advData.advData);
665 SoftBusFree(g_advChannel[advId].advData.scanRspData);
666 g_advChannel[advId].advData.advData = NULL;
667 g_advChannel[advId].advData.scanRspData = NULL;
668 return SOFTBUS_MEM_ERR;
669 }
670 }
671 return SOFTBUS_OK;
672 }
673
ClearAdvData(int advId)674 static void ClearAdvData(int advId)
675 {
676 g_advChannel[advId].advData.advLength = 0;
677 g_advChannel[advId].advData.scanRspLength = 0;
678 SoftBusFree(g_advChannel[advId].advData.advData);
679 SoftBusFree(g_advChannel[advId].advData.scanRspData);
680 g_advChannel[advId].advData.advData = NULL;
681 g_advChannel[advId].advData.scanRspData = NULL;
682 }
683
SoftBusGetAdvChannel(const SoftBusAdvCallback * callback,int * scannerId,bool isLpDeviceScan)684 NO_SANITIZE("cfi") int SoftBusGetAdvChannel(const SoftBusAdvCallback *callback, int *scannerId, bool isLpDeviceScan)
685 {
686 if (callback == NULL) {
687 return SOFTBUS_INVALID_PARAM;
688 }
689 if (SoftBusMutexLock(&g_advLock) != 0) {
690 return SOFTBUS_LOCK_ERR;
691 }
692 if (RegisterBleGattCallback(scannerId, isLpDeviceScan) != SOFTBUS_OK) {
693 SoftBusMutexUnlock(&g_advLock);
694 return SOFTBUS_ERR;
695 }
696 int freeAdvId;
697 for (freeAdvId = 0; freeAdvId < ADV_MAX_NUM; freeAdvId++) {
698 if (!g_advChannel[freeAdvId].isUsed) {
699 break;
700 }
701 }
702 if (freeAdvId == ADV_MAX_NUM) {
703 CLOGE("no available adv channel");
704 SoftBusMutexUnlock(&g_advLock);
705 return SOFTBUS_ERR;
706 }
707 g_advChannel[freeAdvId].advId = -1;
708 g_advChannel[freeAdvId].isUsed = true;
709 g_advChannel[freeAdvId].isAdvertising = false;
710 SoftBusCondInit(&g_advChannel[freeAdvId].cond);
711 g_advChannel[freeAdvId].advCallback = (SoftBusAdvCallback *)callback;
712 SoftBusMutexUnlock(&g_advLock);
713 return freeAdvId;
714 }
715
SoftBusReleaseAdvChannel(int advId)716 NO_SANITIZE("cfi") int SoftBusReleaseAdvChannel(int advId)
717 {
718 if (SoftBusMutexLock(&g_advLock) != 0) {
719 return SOFTBUS_LOCK_ERR;
720 }
721 if (!CheckAdvChannelInUsed(advId)) {
722 SoftBusMutexUnlock(&g_advLock);
723 return SOFTBUS_ERR;
724 }
725 ClearAdvData(advId);
726 g_advChannel[advId].advId = -1;
727 g_advChannel[advId].isUsed = false;
728 g_advChannel[advId].isAdvertising = false;
729 SoftBusCondDestroy(&g_advChannel[advId].cond);
730 g_advChannel[advId].advCallback = NULL;
731 SoftBusMutexUnlock(&g_advLock);
732 return SOFTBUS_OK;
733 }
734
SoftBusSetAdvData(int advId,const SoftBusBleAdvData * data)735 NO_SANITIZE("cfi") int SoftBusSetAdvData(int advId, const SoftBusBleAdvData *data)
736 {
737 if (data == NULL) {
738 return SOFTBUS_INVALID_PARAM;
739 }
740 if (SoftBusMutexLock(&g_advLock) != 0) {
741 return SOFTBUS_LOCK_ERR;
742 }
743 if (!CheckAdvChannelInUsed(advId)) {
744 SoftBusMutexUnlock(&g_advLock);
745 return SOFTBUS_ERR;
746 }
747 int ret = SetAdvData(advId, data);
748 if (ret == SOFTBUS_OK) {
749 g_advChannel[advId].advCallback->AdvDataCallback(advId, SOFTBUS_BT_STATUS_SUCCESS);
750 } else {
751 g_advChannel[advId].advCallback->AdvDataCallback(advId, SOFTBUS_BT_STATUS_FAIL);
752 }
753 SoftBusMutexUnlock(&g_advLock);
754 return ret;
755 }
756
SoftBusStartAdv(int advId,const SoftBusBleAdvParams * param)757 NO_SANITIZE("cfi") int SoftBusStartAdv(int advId, const SoftBusBleAdvParams *param)
758 {
759 if (param == NULL) {
760 return SOFTBUS_INVALID_PARAM;
761 }
762 if (SoftBusMutexLock(&g_advLock) != 0) {
763 return SOFTBUS_LOCK_ERR;
764 }
765 if (!CheckAdvChannelInUsed(advId)) {
766 SoftBusMutexUnlock(&g_advLock);
767 return SOFTBUS_ERR;
768 }
769 if (g_advChannel[advId].isAdvertising) {
770 CLOGW("SoftBusStartAdv, wait condition inner-advId: %d", advId);
771 SoftBusSysTime absTime = {0};
772 if (SoftBusGetTime(&absTime) != SOFTBUS_OK) {
773 CLOGE("Softbus get time failed");
774 SoftBusMutexUnlock(&g_advLock);
775 return SOFTBUS_ERR;
776 }
777
778 absTime.sec += ADV_WAIT_TIME_SEC;
779 if (SoftBusCondWait(&g_advChannel[advId].cond, &g_advLock, &absTime) != SOFTBUS_OK) {
780 CLOGE("SoftBusStartAdv, wait timeout");
781 SoftBusMutexUnlock(&g_advLock);
782 return SOFTBUS_ERR;
783 }
784 }
785 int btAdvId = -1;
786 BleAdvParams dstParam;
787 StartAdvRawData advData;
788 ConvertAdvParam(param, &dstParam);
789 ConvertAdvData(&g_advChannel[advId].advData, &advData);
790 int ret = BleStartAdvEx(&btAdvId, advData, dstParam);
791 g_advChannel[advId].advId = btAdvId;
792 CLOGI("BleStartAdvEx, inner-advId: %d, bt-advId: %d, "
793 "ret: %d", advId, btAdvId, ret);
794 if (ret != OHOS_BT_STATUS_SUCCESS) {
795 g_advChannel[advId].advCallback->AdvEnableCallback(advId, SOFTBUS_BT_STATUS_FAIL);
796 SoftBusMutexUnlock(&g_advLock);
797 return SOFTBUS_ERR;
798 }
799 SoftBusMutexUnlock(&g_advLock);
800 return SOFTBUS_OK;
801 }
802
SoftBusStopAdv(int advId)803 NO_SANITIZE("cfi") int SoftBusStopAdv(int advId)
804 {
805 if (SoftBusMutexLock(&g_advLock) != 0) {
806 return SOFTBUS_LOCK_ERR;
807 }
808 if (!CheckAdvChannelInUsed(advId)) {
809 SoftBusMutexUnlock(&g_advLock);
810 return SOFTBUS_ERR;
811 }
812 if (!g_advChannel[advId].isAdvertising) {
813 CLOGI("SoftBusStopAdv, adv %d is not advertising", advId);
814 SoftBusMutexUnlock(&g_advLock);
815 return SOFTBUS_OK;
816 }
817 int ret = BleStopAdv(g_advChannel[advId].advId);
818 CLOGI("SoftBusStopAdv, inner-advId: %d, "
819 "bt-advId: %d, ret: %d", advId, g_advChannel[advId].advId, ret);
820 if (ret != OHOS_BT_STATUS_SUCCESS) {
821 g_advChannel[advId].advCallback->AdvDisableCallback(advId, SOFTBUS_BT_STATUS_FAIL);
822 SoftBusMutexUnlock(&g_advLock);
823 return SOFTBUS_ERR;
824 }
825 ClearAdvData(advId);
826 g_advChannel[advId].advCallback->AdvDisableCallback(advId, SOFTBUS_BT_STATUS_SUCCESS);
827 SoftBusMutexUnlock(&g_advLock);
828 return SOFTBUS_OK;
829 }
830
SoftBusUpdateAdv(int advId,const SoftBusBleAdvData * data,const SoftBusBleAdvParams * param)831 NO_SANITIZE("cfi") int SoftBusUpdateAdv(int advId, const SoftBusBleAdvData *data, const SoftBusBleAdvParams *param)
832 {
833 if (param == NULL || data == NULL) {
834 return SOFTBUS_INVALID_PARAM;
835 }
836 int ret = SoftBusStopAdv(advId);
837 if (ret != SOFTBUS_OK) {
838 return ret;
839 }
840 ret = SetAdvData(advId, data);
841 if (ret != SOFTBUS_OK) {
842 return ret;
843 }
844 return SoftBusStartAdv(advId, param);
845 }
846
SoftBusAddScanListener(const SoftBusScanListener * listener,int * scannerId,bool isLpDeviceScan)847 NO_SANITIZE("cfi") int SoftBusAddScanListener(const SoftBusScanListener *listener, int *scannerId, bool isLpDeviceScan)
848 {
849 if (listener == NULL) {
850 return SOFTBUS_ERR;
851 }
852 if (SoftBusMutexLock(&g_scanerLock) != 0) {
853 return SOFTBUS_LOCK_ERR;
854 }
855 if (RegisterBleGattCallback(scannerId, isLpDeviceScan) != SOFTBUS_OK) {
856 SoftBusMutexUnlock(&g_scanerLock);
857 return SOFTBUS_ERR;
858 }
859 for (int index = 0; index < SCAN_MAX_NUM; index++) {
860 if (!g_scanListener[index].isUsed) {
861 (void)memset_s(g_scanListener + index, sizeof(ScanListener), 0x0, sizeof(ScanListener));
862 g_scanListener[index].isUsed = true;
863 g_scanListener[index].isNeedReset = true;
864 g_scanListener[index].isScanning = false;
865 g_scanListener[index].scannerId = *scannerId;
866 g_scanListener[index].listener = (SoftBusScanListener *)listener;
867 SoftBusMutexUnlock(&g_scanerLock);
868 return index;
869 }
870 }
871 SoftBusMutexUnlock(&g_scanerLock);
872 return SOFTBUS_ERR;
873 }
874
FreeScanFilter(int listenerId)875 static void FreeScanFilter(int listenerId)
876 {
877 uint8_t filterSize = g_scanListener[listenerId].filterSize;
878 SoftBusBleScanFilter *filter = g_scanListener[listenerId].filter;
879 while (filterSize-- > 0) {
880 SoftBusFree((filter + filterSize)->address);
881 SoftBusFree((filter + filterSize)->deviceName);
882 SoftBusFree((filter + filterSize)->serviceUuid);
883 SoftBusFree((filter + filterSize)->serviceUuidMask);
884 SoftBusFree((filter + filterSize)->serviceData);
885 SoftBusFree((filter + filterSize)->serviceDataMask);
886 SoftBusFree((filter + filterSize)->manufactureData);
887 SoftBusFree((filter + filterSize)->manufactureDataMask);
888 }
889 SoftBusFree(filter);
890 g_scanListener[listenerId].filterSize = 0;
891 g_scanListener[listenerId].filter = NULL;
892 }
893
SoftBusRemoveScanListener(int listenerId)894 NO_SANITIZE("cfi") int SoftBusRemoveScanListener(int listenerId)
895 {
896 if (listenerId < 0 || listenerId >= SCAN_MAX_NUM) {
897 return SOFTBUS_INVALID_PARAM;
898 }
899 if (SoftBusMutexLock(&g_scanerLock) != 0) {
900 return SOFTBUS_LOCK_ERR;
901 }
902 g_scanListener[listenerId].isUsed = false;
903 g_scanListener[listenerId].isNeedReset = true;
904 g_scanListener[listenerId].isScanning = false;
905 g_scanListener[listenerId].listener = NULL;
906 FreeScanFilter(listenerId);
907 SoftBusMutexUnlock(&g_scanerLock);
908 return SOFTBUS_OK;
909 }
910
CheckNeedReStartScan(int scannerId)911 static bool CheckNeedReStartScan(int scannerId)
912 {
913 bool isNeedReset = false;
914 bool isScanning = false;
915 for (int listenerId = 0; listenerId < SCAN_MAX_NUM; listenerId++) {
916 if (g_scanListener[listenerId].isNeedReset) {
917 isNeedReset = true;
918 }
919 if (g_scanListener[listenerId].isScanning) {
920 isScanning = true;
921 }
922 }
923 if (isNeedReset && isScanning) {
924 if (BleOhosStatusToSoftBus(BleStopScan(scannerId)) != SOFTBUS_BT_STATUS_SUCCESS) {
925 CLOGE("ble stop scan failed");
926 return false;
927 }
928 return true;
929 }
930 if (!isNeedReset && isScanning) {
931 return false;
932 }
933 return true;
934 }
935
CheckNeedStopScan(int listenerId)936 static bool CheckNeedStopScan(int listenerId)
937 {
938 for (int index = 0; index < SCAN_MAX_NUM; index++) {
939 if (index == listenerId && !g_scanListener[index].isScanning) {
940 return false;
941 }
942 if (index != listenerId && g_scanListener[index].isScanning) {
943 return false;
944 }
945 }
946 return true;
947 }
948
SoftBusSetScanFilter(int listenerId,SoftBusBleScanFilter * filter,uint8_t filterSize)949 NO_SANITIZE("cfi") int SoftBusSetScanFilter(int listenerId, SoftBusBleScanFilter *filter, uint8_t filterSize)
950 {
951 if (filter == NULL || filterSize == 0) {
952 return SOFTBUS_INVALID_PARAM;
953 }
954 if (SoftBusMutexLock(&g_scanerLock) != 0) {
955 return SOFTBUS_LOCK_ERR;
956 }
957 if (!CheckScanChannelInUsed(listenerId)) {
958 CLOGE("ScanListener id:%d is not in use", listenerId);
959 SoftBusMutexUnlock(&g_scanerLock);
960 return SOFTBUS_ERR;
961 }
962 FreeScanFilter(listenerId);
963 g_scanListener[listenerId].filter = (SoftBusBleScanFilter *)filter;
964 g_scanListener[listenerId].filterSize = filterSize;
965 g_scanListener[listenerId].isNeedReset = true;
966 SoftBusMutexUnlock(&g_scanerLock);
967 return SOFTBUS_OK;
968 }
969
SoftBusStartScan(int listenerId,int scannerId,const SoftBusBleScanParams * param)970 NO_SANITIZE("cfi") int SoftBusStartScan(int listenerId, int scannerId, const SoftBusBleScanParams *param)
971 {
972 if (param == NULL) {
973 return SOFTBUS_INVALID_PARAM;
974 }
975 if (SoftBusMutexLock(&g_scanerLock) != 0) {
976 return SOFTBUS_LOCK_ERR;
977 }
978 if (!CheckScanChannelInUsed(listenerId)) {
979 CLOGE("ScanListener id:%d is not in use", listenerId);
980 SoftBusMutexUnlock(&g_scanerLock);
981 return SOFTBUS_ERR;
982 }
983 BleScanConfigs scanConfig;
984 SetAndGetSuitableScanConfig(listenerId, param, &scanConfig);
985 int32_t status = SOFTBUS_BT_STATUS_SUCCESS;
986 if (CheckNeedReStartScan(scannerId)) {
987 uint8_t filterSize = 0;
988 BleScanNativeFilter *nativeFilter = NULL;
989 if (scannerId == g_scannerId) {
990 GetAllNativeScanFilter(listenerId, &nativeFilter, &filterSize);
991 } else {
992 SoftBusGetBurstScanFilter(listenerId, &nativeFilter, &filterSize);
993 }
994 DumpBleScanFilter(nativeFilter, filterSize);
995 status = BleOhosStatusToSoftBus(BleStartScanEx(scannerId, &scanConfig, nativeFilter, filterSize));
996 SoftBusFree(nativeFilter);
997 }
998 if (status != SOFTBUS_BT_STATUS_SUCCESS) {
999 SoftBusMutexUnlock(&g_scanerLock);
1000 return SOFTBUS_ERR;
1001 }
1002 g_scanListener[listenerId].isScanning = true;
1003 if (g_scanListener[listenerId].listener != NULL &&
1004 g_scanListener[listenerId].listener->OnScanStart != NULL) {
1005 g_scanListener[listenerId].listener->OnScanStart(listenerId, SOFTBUS_BT_STATUS_SUCCESS);
1006 }
1007 SoftBusMutexUnlock(&g_scanerLock);
1008 if (status == SOFTBUS_BT_STATUS_SUCCESS) {
1009 return SOFTBUS_OK;
1010 }
1011 return SOFTBUS_ERR;
1012 }
1013
SoftBusStopScan(int listenerId,int scannerId)1014 NO_SANITIZE("cfi") int SoftBusStopScan(int listenerId, int scannerId)
1015 {
1016 if (SoftBusMutexLock(&g_scanerLock) != 0) {
1017 return SOFTBUS_LOCK_ERR;
1018 }
1019 if (!CheckScanChannelInUsed(listenerId)) {
1020 SoftBusMutexUnlock(&g_scanerLock);
1021 return SOFTBUS_ERR;
1022 }
1023 if (!g_scanListener[listenerId].isScanning) {
1024 SoftBusMutexUnlock(&g_scanerLock);
1025 return SOFTBUS_OK;
1026 }
1027 int32_t status = SOFTBUS_BT_STATUS_SUCCESS;
1028 if (CheckNeedStopScan(listenerId)) {
1029 status = BleOhosStatusToSoftBus(BleStopScan(scannerId));
1030 }
1031 if (status != SOFTBUS_BT_STATUS_SUCCESS) {
1032 SoftBusMutexUnlock(&g_scanerLock);
1033 return SOFTBUS_ERR;
1034 }
1035 g_scanListener[listenerId].isScanning = false;
1036 if (g_scanListener[listenerId].listener != NULL &&
1037 g_scanListener[listenerId].listener->OnScanStop != NULL) {
1038 g_scanListener[listenerId].listener->OnScanStop(listenerId, status);
1039 }
1040 SoftBusMutexUnlock(&g_scanerLock);
1041 if (status == SOFTBUS_BT_STATUS_SUCCESS) {
1042 return SOFTBUS_OK;
1043 }
1044 return SOFTBUS_ERR;
1045 }
1046
SoftBusReplaceAdvertisingAdv(int advId,const SoftBusBleAdvData * data)1047 int SoftBusReplaceAdvertisingAdv(int advId, const SoftBusBleAdvData *data)
1048 {
1049 if (data == NULL) {
1050 return SOFTBUS_INVALID_PARAM;
1051 }
1052 if (SoftBusMutexLock(&g_advLock) != 0) {
1053 return SOFTBUS_LOCK_ERR;
1054 }
1055 if (!CheckAdvChannelInUsed(advId)) {
1056 SoftBusMutexUnlock(&g_advLock);
1057 return SOFTBUS_ERR;
1058 }
1059 if (!g_advChannel[advId].isAdvertising) {
1060 SoftBusMutexUnlock(&g_advLock);
1061 CLOGE("adv %d is not advertising", advId);
1062 return SOFTBUS_ERR;
1063 }
1064 int btAdvId = g_advChannel[advId].advId;
1065 int ret = SetAdvData(advId, data);
1066 SoftBusMutexUnlock(&g_advLock);
1067 if (ret != SOFTBUS_OK) {
1068 CLOGE("SetAdvData failed, advId: %d, btadvId: %d", advId, btAdvId);
1069 return SOFTBUS_ERR;
1070 }
1071 CLOGI("BleSetAdvData, advId: %d, btadvId: %d", advId, btAdvId);
1072 StartAdvRawData advData = {0};
1073 ConvertAdvData(data, &advData);
1074 ret = BleOhosStatusToSoftBus(BleSetAdvData(btAdvId, advData));
1075 return ret;
1076 }
1077
SoftBusIsLpDeviceAvailable(void)1078 NO_SANITIZE("cfi") bool SoftBusIsLpDeviceAvailable(void)
1079 {
1080 return IsLpDeviceAvailable();
1081 }
1082
SoftBusSetAdvFilterParam(int advHandle,int advId,SoftBusBleAdvParams * advParam,int listenerId,SoftBusBleScanParams * scanParam)1083 NO_SANITIZE("cfi") bool SoftBusSetAdvFilterParam(int advHandle, int advId, SoftBusBleAdvParams *advParam,
1084 int listenerId, SoftBusBleScanParams *scanParam)
1085 {
1086 BleScanConfigs scanConfig;
1087 SetAndGetSuitableScanConfig(listenerId, scanParam, &scanConfig);
1088 BleScanNativeFilter *filter = NULL;
1089 uint8_t filterSize = 0;
1090 SoftBusGetBurstScanFilter(listenerId, &filter, &filterSize);
1091 DumpBleScanFilter(filter, filterSize);
1092 BleAdvParams btAdvParam;
1093 StartAdvRawData rawData;
1094 ConvertAdvParam(advParam, &btAdvParam);
1095 ConvertAdvData(&g_advChannel[advId].advData, &rawData);
1096 BtUuid btUuid;
1097 btUuid.uuid = BT_UUID;
1098 btUuid.uuidLen = strlen(BT_UUID);
1099 BtLpDeviceParam btLpDeviceParam;
1100 btLpDeviceParam.scanConfig = &scanConfig;
1101 btLpDeviceParam.filter = filter;
1102 btLpDeviceParam.filterSize = filterSize;
1103 btLpDeviceParam.advParam = btAdvParam;
1104 btLpDeviceParam.rawData = rawData;
1105 btLpDeviceParam.uuid = btUuid;
1106 btLpDeviceParam.activeDeviceInfo = NULL;
1107 btLpDeviceParam.activeDeviceSize = 0;
1108 btLpDeviceParam.deliveryMode = DELIVERY_MODE_REPLY;
1109 btLpDeviceParam.advHandle = advHandle;
1110 btLpDeviceParam.duration = ADV_DURATION_MS;
1111 if (SetLpDeviceParam(&btLpDeviceParam) != SOFTBUS_OK) {
1112 CLOGE("SH SetLpDeviceParam failed");
1113 return false;
1114 }
1115 SoftBusFree(filter);
1116 return true;
1117 }
1118
SoftBusGetAdvHandle(int32_t advId,int32_t * advHandle)1119 NO_SANITIZE("cfi") int32_t SoftBusGetAdvHandle(int32_t advId, int32_t *advHandle)
1120 {
1121 return GetAdvHandle(g_advChannel[advId].advId, advHandle);
1122 }
1123
SoftBusEnableSyncDataToLpDevice(void)1124 NO_SANITIZE("cfi") int32_t SoftBusEnableSyncDataToLpDevice(void)
1125 {
1126 return EnableSyncDataToLpDevice();
1127 }
1128
SoftBusDisableSyncDataToLpDevice(void)1129 NO_SANITIZE("cfi") int32_t SoftBusDisableSyncDataToLpDevice(void)
1130 {
1131 return DisableSyncDataToLpDevice();
1132 }
1133
SoftBusDeregisterScanCallbacks(int32_t scannerId)1134 NO_SANITIZE("cfi") int32_t SoftBusDeregisterScanCallbacks(int32_t scannerId)
1135 {
1136 return BleDeregisterScanCallbacks(scannerId);
1137 }
1138
SoftBusSetScanReportChannelToLpDevice(int scannerId,bool enable)1139 NO_SANITIZE("cfi") int32_t SoftBusSetScanReportChannelToLpDevice(int scannerId, bool enable)
1140 {
1141 return SetScanReportChannelToLpDevice(scannerId, enable);
1142 }
1143
SoftBusSetLpDeviceParam(int duration,int maxExtAdvEvents,int window,int interval,int advHandle)1144 NO_SANITIZE("cfi") int32_t SoftBusSetLpDeviceParam(int duration, int maxExtAdvEvents, int window,
1145 int interval, int advHandle)
1146 {
1147 return SetLpDeviceAdvParam(duration, maxExtAdvEvents, window, interval, advHandle);
1148 }