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