1 /*
2  * Copyright (c) 2023-2024 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 "softbus_ble_gatt.h"
17 #include "softbus_adapter_bt_common.h"
18 #include "softbus_adapter_thread.h"
19 #include "softbus_adapter_mem.h"
20 #include "softbus_broadcast_type.h"
21 #include "softbus_error_code.h"
22 #include "softbus_ble_utils.h"
23 #include "disc_log.h"
24 #include <stdatomic.h>
25 #include <string.h>
26 
27 #define GATT_ADV_MAX_NUM       16
28 #define GATT_SCAN_MAX_NUM      2
29 #define LP_BT_UUID_BURST       "43d4a49f-604d-45b5-9302-4ddbbfd538fd"
30 #define LP_BT_UUID_HEARTBEAT   "43d4a49f-605d-45b5-9302-4ddbbfd538fd"
31 #define LP_DELIVERY_MODE_REPLY 0xF0
32 #define LP_ADV_DURATION_MS     0
33 #define SCAN_CHANNEL_0         0
34 #define SCAN_CHANNEL_1         1
35 
36 static atomic_bool g_init = false;
37 static atomic_bool g_bcCbReg = false;
38 static SoftBusMutex g_advLock = { 0 };
39 static SoftBusMutex g_scannerLock = { 0 };
40 static int32_t g_adapterBtStateListenerId = -1;
41 
42 typedef struct {
43     int32_t advId;
44     bool isUsed;
45     bool isAdvertising;
46     SoftbusBroadcastCallback *advCallback;
47 } AdvChannel;
48 
49 typedef struct {
50     int32_t scannerId;
51     bool isUsed;
52     bool isScanning;
53     SoftbusScanCallback *scanCallback;
54 } ScanChannel;
55 
56 static AdvChannel g_advChannel[GATT_ADV_MAX_NUM];
57 static ScanChannel g_scanChannel[GATT_SCAN_MAX_NUM];
58 
SoftbusGattInit(void)59 static int32_t SoftbusGattInit(void)
60 {
61     if (g_init) {
62         DISC_LOGI(DISC_BLE_ADAPTER, "already inited");
63         return SOFTBUS_OK;
64     }
65     g_init = true;
66     if (SoftBusMutexInit(&g_advLock, NULL) != SOFTBUS_OK) {
67         g_init = false;
68         DISC_LOGE(DISC_BLE_ADAPTER, "advLock init failed");
69         return SOFTBUS_NO_INIT;
70     }
71     if (SoftBusMutexInit(&g_scannerLock, NULL) != SOFTBUS_OK) {
72         SoftBusMutexDestroy(&g_advLock);
73         g_init = false;
74         DISC_LOGE(DISC_BLE_ADAPTER, "scannerLock init failed");
75         return SOFTBUS_NO_INIT;
76     }
77     DISC_LOGI(DISC_BLE_ADAPTER, "ble gatt init success");
78     return SOFTBUS_OK;
79 }
80 
SoftbusGattDeInit(void)81 static int32_t SoftbusGattDeInit(void)
82 {
83     if (!g_init) {
84         DISC_LOGI(DISC_BLE_ADAPTER, "already deinited");
85         return SOFTBUS_OK;
86     }
87     g_init = false;
88     SoftBusMutexDestroy(&g_advLock);
89     SoftBusMutexDestroy(&g_scannerLock);
90     DISC_LOGI(DISC_BLE_ADAPTER, "deinit success");
91     return SOFTBUS_OK;
92 }
93 
WrapperAdvEnableCb(int advId,int status)94 static void WrapperAdvEnableCb(int advId, int status)
95 {
96     int32_t ret = BtStatusToSoftBus((BtStatus)status);
97     for (uint8_t channelId = 0; channelId < GATT_ADV_MAX_NUM; channelId++) {
98         if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
99             DISC_LOGW(DISC_BLE_ADAPTER, "lock adv failed, advId=%{public}u, bt-advId=%{public}d", channelId, advId);
100             continue;
101         }
102         AdvChannel *advChannel = &g_advChannel[channelId];
103         if (advChannel->advId != advId || !advChannel->isUsed || advChannel->advCallback == NULL ||
104             advChannel->advCallback->OnStartBroadcastingCallback == NULL) {
105             SoftBusMutexUnlock(&g_advLock);
106             continue;
107         }
108         advChannel->isAdvertising = (ret == SOFTBUS_BC_STATUS_SUCCESS);
109         if (!advChannel->isAdvertising) {
110             advChannel->advId = -1;
111         }
112         DISC_LOGI(DISC_BLE_ADAPTER, "advId=%{public}u, bt-advId=%{public}d, status=%{public}d", channelId, advId, ret);
113         SoftbusBroadcastCallback callback = *(advChannel->advCallback);
114         SoftBusMutexUnlock(&g_advLock);
115         callback.OnStartBroadcastingCallback(channelId, ret);
116         break;
117     }
118 }
119 
WrapperAdvDisableCb(int advId,int status)120 static void WrapperAdvDisableCb(int advId, int status)
121 {
122     int32_t ret = BtStatusToSoftBus((BtStatus)status);
123     for (uint8_t channelId = 0; channelId < GATT_ADV_MAX_NUM; channelId++) {
124         if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
125             DISC_LOGW(DISC_BLE_ADAPTER, "lock adv failed, advId=%{public}u, bt-advId=%{public}d", channelId, advId);
126             continue;
127         }
128         AdvChannel *advChannel = &g_advChannel[channelId];
129         if (advChannel->advId != advId || !advChannel->isUsed || advChannel->advCallback == NULL ||
130             advChannel->advCallback->OnStopBroadcastingCallback == NULL) {
131             SoftBusMutexUnlock(&g_advLock);
132             continue;
133         }
134         advChannel->isAdvertising = false;
135         advChannel->advId = -1;
136         DISC_LOGI(DISC_BLE_ADAPTER, "advId=%{public}u, bt-advId=%{public}d, status=%{public}d", channelId, advId, ret);
137         SoftbusBroadcastCallback callback = *(advChannel->advCallback);
138         SoftBusMutexUnlock(&g_advLock);
139         callback.OnStopBroadcastingCallback(channelId, ret);
140         break;
141     }
142 }
143 
WrapperAdvSetDataCb(int advId,int status)144 static void WrapperAdvSetDataCb(int advId, int status)
145 {
146     int32_t ret = BtStatusToSoftBus((BtStatus)status);
147     for (uint32_t channelId = 0; channelId < GATT_ADV_MAX_NUM; channelId++) {
148         if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
149             DISC_LOGW(DISC_BLE_ADAPTER, "lock adv failed, advId=%{public}u, bt-advId=%{public}d", channelId, advId);
150             continue;
151         }
152         AdvChannel *advChannel = &g_advChannel[channelId];
153         if (advChannel->advId != advId || !advChannel->isUsed || advChannel->advCallback == NULL ||
154             advChannel->advCallback->OnSetBroadcastingCallback == NULL) {
155             SoftBusMutexUnlock(&g_advLock);
156             continue;
157         }
158         DISC_LOGI(DISC_BLE_ADAPTER, "advId=%{public}u, bt-advId=%{public}d, status=%{public}d", channelId, advId, ret);
159         SoftbusBroadcastCallback callback = *(advChannel->advCallback);
160         SoftBusMutexUnlock(&g_advLock);
161         callback.OnSetBroadcastingCallback(channelId, ret);
162         break;
163     }
164 }
165 
WrapperAdvUpdateDataCb(int advId,int status)166 static void WrapperAdvUpdateDataCb(int advId, int status)
167 {
168     int32_t ret = BtStatusToSoftBus((BtStatus)status);
169     for (uint32_t channelId = 0; channelId < GATT_ADV_MAX_NUM; channelId++) {
170         if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
171             DISC_LOGW(DISC_BLE_ADAPTER, "lock adv failed, advId=%{public}u, bt-advId=%{public}d", channelId, advId);
172             continue;
173         }
174         AdvChannel *advChannel = &g_advChannel[channelId];
175         if (advChannel->advId != advId || !advChannel->isUsed || advChannel->advCallback == NULL ||
176             advChannel->advCallback->OnUpdateBroadcastingCallback == NULL) {
177             SoftBusMutexUnlock(&g_advLock);
178             continue;
179         }
180         DISC_LOGI(DISC_BLE_ADAPTER, "advId=%{public}u, bt-advId=%{public}d, status=%{public}d", channelId, advId, ret);
181         SoftbusBroadcastCallback callback = *(advChannel->advCallback);
182         SoftBusMutexUnlock(&g_advLock);
183         callback.OnUpdateBroadcastingCallback(channelId, ret);
184         break;
185     }
186 }
187 
188 static BtGattCallbacks g_softbusGattCb = {
189     .advEnableCb = WrapperAdvEnableCb,
190     .advDisableCb = WrapperAdvDisableCb,
191     .advDataCb = WrapperAdvSetDataCb,
192     .advUpdateCb = WrapperAdvUpdateDataCb,
193 };
194 
SoftbusRegisterAdvCb(int32_t * advId,const SoftbusBroadcastCallback * cb)195 static int32_t SoftbusRegisterAdvCb(int32_t *advId, const SoftbusBroadcastCallback *cb)
196 {
197     if (advId == NULL || cb == NULL) {
198         DISC_LOGE(DISC_BLE_ADAPTER, "adv param is null");
199         return SOFTBUS_INVALID_PARAM;
200     }
201     if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
202         DISC_LOGE(DISC_BLE_ADAPTER, "lock failed");
203         return SOFTBUS_LOCK_ERR;
204     }
205     for (uint8_t channelId = 0; channelId < GATT_ADV_MAX_NUM; channelId++) {
206         if (g_advChannel[channelId].isUsed) {
207             continue;
208         }
209         if (!g_bcCbReg) {
210             int ret = BleGattRegisterCallbacks(&g_softbusGattCb);
211             if (ret != OHOS_BT_STATUS_SUCCESS) {
212                 DISC_LOGE(DISC_BLE_ADAPTER, "register failed, advId=%{public}u", channelId);
213                 SoftBusMutexUnlock(&g_advLock);
214                 return ret;
215             }
216             g_bcCbReg = true;
217         }
218         g_advChannel[channelId].advId = -1;
219         g_advChannel[channelId].isUsed = true;
220         g_advChannel[channelId].isAdvertising = false;
221         g_advChannel[channelId].advCallback = (SoftbusBroadcastCallback *)cb;
222         *advId = channelId;
223         DISC_LOGI(DISC_BLE_ADAPTER, "register success, advId=%{public}u", channelId);
224         SoftBusMutexUnlock(&g_advLock);
225         return SOFTBUS_OK;
226     }
227     DISC_LOGE(DISC_BLE_ADAPTER, "no available adv channel");
228     SoftBusMutexUnlock(&g_advLock);
229     return SOFTBUS_BC_ADAPTER_REGISTER_FAIL;
230 }
231 
SoftbusUnRegisterAdvCb(int32_t advId)232 static int32_t SoftbusUnRegisterAdvCb(int32_t advId)
233 {
234     if (advId < 0 || advId >= GATT_ADV_MAX_NUM) {
235         DISC_LOGE(DISC_BLE_ADAPTER, "invalid advId=%{public}d", advId);
236         return SOFTBUS_INVALID_PARAM;
237     }
238     if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
239         DISC_LOGE(DISC_BLE_ADAPTER, "lock failed, advId=%{public}d", advId);
240         return SOFTBUS_LOCK_ERR;
241     }
242     if (!g_advChannel[advId].isUsed) {
243         DISC_LOGI(DISC_BLE_ADAPTER, "already unregistered, advId=%{public}d, bt-advId=%{public}d", advId,
244             g_advChannel[advId].advId);
245         SoftBusMutexUnlock(&g_advLock);
246         return SOFTBUS_OK;
247     }
248     DISC_LOGI(DISC_BLE_ADAPTER, "advId=%{public}d, bt-advId=%{public}d", advId, g_advChannel[advId].advId);
249     g_advChannel[advId].advId = -1;
250     g_advChannel[advId].isUsed = false;
251     g_advChannel[advId].isAdvertising = false;
252     g_advChannel[advId].advCallback = NULL;
253     SoftBusMutexUnlock(&g_advLock);
254     return SOFTBUS_OK;
255 }
256 
WrapperScanResultCb(uint8_t channelId,BtScanResultData * data)257 static void WrapperScanResultCb(uint8_t channelId, BtScanResultData *data)
258 {
259     if (data == NULL) {
260         DISC_LOGE(DISC_BLE_ADAPTER, "scan result data is null, scannerId=%{public}u", channelId);
261         return;
262     }
263     if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
264         DISC_LOGE(DISC_BLE_ADAPTER, "lock failed, scannerId=%{public}u", channelId);
265         return;
266     }
267     ScanChannel *scanChannel = &g_scanChannel[channelId];
268     if (!scanChannel->isUsed || !scanChannel->isScanning) {
269         DISC_LOGE(DISC_BLE_ADAPTER, "scanner is not in used, scannerId=%{public}u, bt-scannerId=%{public}d", channelId,
270             scanChannel->scannerId);
271         SoftBusMutexUnlock(&g_scannerLock);
272         return;
273     }
274     SoftBusBcScanResult scanResult = {};
275     BtScanResultToSoftbus(data, &scanResult);
276 
277     if (ParseScanResult(data->advData, data->advLen, &scanResult) != SOFTBUS_OK) {
278         SoftBusFree(scanResult.data.bcData.payload);
279         SoftBusFree(scanResult.data.rspData.payload);
280         SoftBusMutexUnlock(&g_scannerLock);
281         return;
282     }
283     if (scanChannel->scanCallback == NULL || scanChannel->scanCallback->OnReportScanDataCallback == NULL) {
284         DISC_LOGE(DISC_BLE_ADAPTER, "scanner callback is null");
285         SoftBusMutexUnlock(&g_scannerLock);
286         return;
287     }
288     SoftbusScanCallback callback = *(scanChannel->scanCallback);
289     SoftBusMutexUnlock(&g_scannerLock);
290     callback.OnReportScanDataCallback(channelId, &scanResult);
291     SoftBusFree(scanResult.data.bcData.payload);
292     SoftBusFree(scanResult.data.rspData.payload);
293 }
294 
WrapperScanStateChangeCb(uint8_t channelId,int32_t resultCode,bool isStartScan)295 static void WrapperScanStateChangeCb(uint8_t channelId, int32_t resultCode, bool isStartScan)
296 {
297     if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
298         DISC_LOGE(DISC_BLE_ADAPTER, "lock failed, scannerId=%{public}u", channelId);
299         return;
300     }
301     ScanChannel *scanChannel = &g_scanChannel[channelId];
302     if (!scanChannel->isUsed) {
303         DISC_LOGE(DISC_BLE_ADAPTER, "scanner is not in used, scannerId=%{public}u, bt-scannerId=%{public}d", channelId,
304             scanChannel->scannerId);
305         SoftBusMutexUnlock(&g_scannerLock);
306         return;
307     }
308     DISC_LOGD(DISC_BLE_ADAPTER,
309         "scannerId=%{public}d, bt-scannerId=%{public}d, resultCode=%{public}d, isStartScan=%{public}d", channelId,
310         scanChannel->scannerId, resultCode, isStartScan);
311     if (scanChannel->scanCallback == NULL || scanChannel->scanCallback->OnScanStateChanged == NULL) {
312         DISC_LOGE(DISC_BLE_ADAPTER, "scanner callback is null");
313         SoftBusMutexUnlock(&g_scannerLock);
314         return;
315     }
316     SoftbusScanCallback callback = *(scanChannel->scanCallback);
317     SoftBusMutexUnlock(&g_scannerLock);
318     callback.OnScanStateChanged(resultCode, isStartScan);
319 }
320 
WrapperLpDeviceInfoCb(uint8_t channelId,BtUuid * uuid,int32_t type,uint8_t * data,uint32_t dataSize)321 static void WrapperLpDeviceInfoCb(uint8_t channelId, BtUuid *uuid, int32_t type, uint8_t *data, uint32_t dataSize)
322 {
323     if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
324         DISC_LOGE(DISC_BLE_ADAPTER, "lock failed, scannerId=%{public}u", channelId);
325         return;
326     }
327     ScanChannel *scanChannel = &g_scanChannel[channelId];
328     if (!scanChannel->isUsed) {
329         DISC_LOGE(DISC_BLE_ADAPTER, "scanner is not in used, scannerId=%{public}u, bt-scannerId=%{public}d", channelId,
330             scanChannel->scannerId);
331         SoftBusMutexUnlock(&g_scannerLock);
332         return;
333     }
334     if (scanChannel->scanCallback == NULL || scanChannel->scanCallback->OnLpDeviceInfoCallback == NULL) {
335         DISC_LOGE(DISC_BLE_ADAPTER, "scanner callback is null");
336         SoftBusMutexUnlock(&g_scannerLock);
337         return;
338     }
339     SoftbusScanCallback callback = *(scanChannel->scanCallback);
340     SoftBusMutexUnlock(&g_scannerLock);
341     SoftbusBroadcastUuid bcUuid;
342     bcUuid.uuid = (uint8_t *)uuid->uuid;
343     bcUuid.uuidLen = (uint8_t)uuid->uuidLen;
344     callback.OnLpDeviceInfoCallback(&bcUuid, type, data, dataSize);
345 }
346 
WrapperScanResultCb0(BtScanResultData * data)347 static void WrapperScanResultCb0(BtScanResultData *data)
348 {
349     WrapperScanResultCb(SCAN_CHANNEL_0, data);
350 }
351 
WrapperScanResultCb1(BtScanResultData * data)352 static void WrapperScanResultCb1(BtScanResultData *data)
353 {
354     WrapperScanResultCb(SCAN_CHANNEL_1, data);
355 }
356 
WrapperScanStateChangeCb0(int32_t resultCode,bool isStartScan)357 static void WrapperScanStateChangeCb0(int32_t resultCode, bool isStartScan)
358 {
359     WrapperScanStateChangeCb(SCAN_CHANNEL_0, resultCode, isStartScan);
360 }
361 
WrapperScanStateChangeCb1(int32_t resultCode,bool isStartScan)362 static void WrapperScanStateChangeCb1(int32_t resultCode, bool isStartScan)
363 {
364     WrapperScanStateChangeCb(SCAN_CHANNEL_1, resultCode, isStartScan);
365 }
366 
WrapperLpDeviceInfoCb0(BtUuid * uuid,int32_t type,uint8_t * data,uint32_t dataSize)367 static void WrapperLpDeviceInfoCb0(BtUuid *uuid, int32_t type, uint8_t *data, uint32_t dataSize)
368 {
369     WrapperLpDeviceInfoCb(SCAN_CHANNEL_0, uuid, type, data, dataSize);
370 }
371 
WrapperLpDeviceInfoCb1(BtUuid * uuid,int32_t type,uint8_t * data,uint32_t dataSize)372 static void WrapperLpDeviceInfoCb1(BtUuid *uuid, int32_t type, uint8_t *data, uint32_t dataSize)
373 {
374     WrapperLpDeviceInfoCb(SCAN_CHANNEL_1, uuid, type, data, dataSize);
375 }
376 
377 static BleScanCallbacks g_softbusBleScanCb[GATT_SCAN_MAX_NUM] = {
378     {
379         .scanResultCb = WrapperScanResultCb0,
380         .scanStateChangeCb = WrapperScanStateChangeCb0,
381         .lpDeviceInfoCb = WrapperLpDeviceInfoCb0,
382     },
383     {
384         .scanResultCb = WrapperScanResultCb1,
385         .scanStateChangeCb = WrapperScanStateChangeCb1,
386         .lpDeviceInfoCb = WrapperLpDeviceInfoCb1,
387     }
388 };
389 
GetAdapterScanCb(uint8_t channelId)390 static BleScanCallbacks *GetAdapterScanCb(uint8_t channelId)
391 {
392     return &g_softbusBleScanCb[channelId];
393 }
394 
SoftbusRegisterScanCb(int32_t * scannerId,const SoftbusScanCallback * cb)395 static int32_t SoftbusRegisterScanCb(int32_t *scannerId, const SoftbusScanCallback *cb)
396 {
397     if (scannerId == NULL || cb == NULL) {
398         DISC_LOGE(DISC_BLE_ADAPTER, "scan param is null");
399         return SOFTBUS_INVALID_PARAM;
400     }
401     if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
402         DISC_LOGE(DISC_BLE_ADAPTER, "lock failed");
403         return SOFTBUS_LOCK_ERR;
404     }
405     for (uint8_t channelId = 0; channelId < GATT_SCAN_MAX_NUM; channelId++) {
406         if (g_scanChannel[channelId].isUsed) {
407             continue;
408         }
409         int ret = BleRegisterScanCallbacks(GetAdapterScanCb(channelId), &g_scanChannel[channelId].scannerId);
410         if (ret != OHOS_BT_STATUS_SUCCESS) {
411             DISC_LOGE(DISC_BLE_ADAPTER, "register callback failed, scannerId=%{public}u", channelId);
412             SoftBusMutexUnlock(&g_scannerLock);
413             return ret;
414         }
415         g_scanChannel[channelId].isUsed = true;
416         g_scanChannel[channelId].isScanning = false;
417         g_scanChannel[channelId].scanCallback = (SoftbusScanCallback *)cb;
418         *scannerId = channelId;
419         DISC_LOGI(DISC_BLE_ADAPTER, "scannerId=%{public}u, bt-scannerId=%{public}d", channelId,
420             g_scanChannel[channelId].scannerId);
421         SoftBusMutexUnlock(&g_scannerLock);
422         return SOFTBUS_OK;
423     }
424     DISC_LOGE(DISC_BLE_ADAPTER, "no available scan channel");
425     SoftBusMutexUnlock(&g_scannerLock);
426     return SOFTBUS_BC_ADAPTER_REGISTER_FAIL;
427 }
428 
SoftbusUnRegisterScanCb(int32_t scannerId)429 static int32_t SoftbusUnRegisterScanCb(int32_t scannerId)
430 {
431     if (scannerId < 0 || scannerId >= GATT_SCAN_MAX_NUM) {
432         DISC_LOGE(DISC_BLE_ADAPTER, "scannerId is invalid=%{public}d", scannerId);
433         return SOFTBUS_INVALID_PARAM;
434     }
435     if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
436         DISC_LOGE(DISC_BLE_ADAPTER, "lock failed, scannerId=%{public}u", scannerId);
437         return SOFTBUS_LOCK_ERR;
438     }
439     if (!g_scanChannel[scannerId].isUsed) {
440         DISC_LOGI(DISC_BLE_ADAPTER, "already unregistered, scannerId=%{public}d, bt-scannerId=%{public}d", scannerId,
441             g_scanChannel[scannerId].scannerId);
442         SoftBusMutexUnlock(&g_scannerLock);
443         return SOFTBUS_OK;
444     }
445     int32_t ret = BleDeregisterScanCallbacks(g_scanChannel[scannerId].scannerId);
446     DISC_LOGI(DISC_BLE_ADAPTER, "scannerId=%{public}d, bt-scannerId=%{public}d, result=%{public}d",
447         scannerId, g_scanChannel[scannerId].scannerId, ret);
448     g_scanChannel[scannerId].scannerId = -1;
449     g_scanChannel[scannerId].isUsed = false;
450     g_scanChannel[scannerId].isScanning = false;
451     g_scanChannel[scannerId].scanCallback = NULL;
452     SoftBusMutexUnlock(&g_scannerLock);
453     return SOFTBUS_OK;
454 }
455 
CheckAdvChanInUsed(int32_t advId)456 static bool CheckAdvChanInUsed(int32_t advId)
457 {
458     if (advId < 0 || advId >= GATT_ADV_MAX_NUM) {
459         DISC_LOGE(DISC_BLE_ADAPTER, "invalid advId=%{public}d", advId);
460         return false;
461     }
462     if (!g_advChannel[advId].isUsed) {
463         DISC_LOGE(DISC_BLE_ADAPTER, "advId=%{public}d, bt-advId=%{public}d", advId, g_advChannel[advId].advId);
464         return false;
465     }
466     return true;
467 }
468 
StartBleAdv(int32_t advId,int32_t * btAdvId,const SoftbusBroadcastParam * param,const SoftbusBroadcastData * data)469 static int32_t StartBleAdv(int32_t advId, int32_t *btAdvId, const SoftbusBroadcastParam *param,
470     const SoftbusBroadcastData *data)
471 {
472     BleAdvParams advParam = {};
473     SoftbusAdvParamToBt(param, &advParam);
474     StartAdvRawData advRawData = {};
475     advRawData.advData = (unsigned char *)AssembleAdvData(data, (uint16_t *)&advRawData.advDataLen);
476     if (advRawData.advData == NULL) {
477         DISC_LOGE(DISC_BLE_ADAPTER, "assemble adv data failed, advId=%{public}d, bt-advId=%{public}d", advId, *btAdvId);
478         return SOFTBUS_BC_ADAPTER_ASSEMBLE_FAIL;
479     }
480     advRawData.rspDataLen = 0;
481     advRawData.rspData = NULL;
482     if (data->rspData.payloadLen > 0 && data->rspData.payload != NULL) {
483         advRawData.rspData = (unsigned char *)AssembleRspData(&data->rspData, (uint16_t *)&advRawData.rspDataLen);
484         if (advRawData.rspData == NULL) {
485             SoftBusFree(advRawData.advData);
486             DISC_LOGE(DISC_BLE_ADAPTER, "assemble rsp data failed, advId=%{public}d, bt-advId=%{public}d",
487                 advId, *btAdvId);
488             return SOFTBUS_BC_ADAPTER_ASSEMBLE_FAIL;
489         }
490     }
491     DumpSoftbusAdapterData("mgr pkg:", advRawData.advData, advRawData.advDataLen);
492     int32_t ret = BleStartAdvEx(btAdvId, advRawData, advParam);
493     SoftBusFree(advRawData.advData);
494     SoftBusFree(advRawData.rspData);
495     return (ret == OHOS_BT_STATUS_SUCCESS) ? SOFTBUS_OK : ret;
496 }
497 
SoftbusStartAdv(int32_t advId,const SoftbusBroadcastParam * param,const SoftbusBroadcastData * data)498 static int32_t SoftbusStartAdv(int32_t advId, const SoftbusBroadcastParam *param, const SoftbusBroadcastData *data)
499 {
500     if (param == NULL || data == NULL || data->bcData.payloadLen == 0 || data->bcData.payload == NULL) {
501         DISC_LOGE(DISC_BLE_ADAPTER, "invalid adv param, advId=%{public}d", advId);
502         return SOFTBUS_INVALID_PARAM;
503     }
504     if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
505         DISC_LOGE(DISC_BLE_ADAPTER, "lock failed, advId=%{public}d", advId);
506         return SOFTBUS_LOCK_ERR;
507     }
508     if (!CheckAdvChanInUsed(advId)) {
509         DISC_LOGE(DISC_BLE_ADAPTER, "adv is not in used, advId=%{public}d", advId);
510         SoftBusMutexUnlock(&g_advLock);
511         return SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL;
512     }
513     int32_t btAdvId = g_advChannel[advId].advId;
514     if (g_advChannel[advId].isAdvertising) {
515         DISC_LOGE(DISC_BLE_ADAPTER, "already started, advId=%{public}d, bt-advId=%{public}d", advId, btAdvId);
516         SoftBusMutexUnlock(&g_advLock);
517         return SOFTBUS_ALREADY_TRIGGERED;
518     }
519     g_advChannel[advId].isAdvertising = true;
520     SoftBusMutexUnlock(&g_advLock);
521     int32_t ret = StartBleAdv(advId, &btAdvId, param, data);
522     if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
523         DISC_LOGE(DISC_BLE_ADAPTER, "lock failed, advId=%{public}d, btAdvId=%{public}d", advId, btAdvId);
524         return SOFTBUS_LOCK_ERR;
525     }
526     g_advChannel[advId].advId = (ret == SOFTBUS_OK) ? btAdvId : -1;
527     g_advChannel[advId].isAdvertising = (ret == SOFTBUS_OK);
528     SoftBusMutexUnlock(&g_advLock);
529     if (ret != SOFTBUS_OK) {
530         DISC_LOGE(DISC_BLE_ADAPTER, "advId=%{public}d, bt-advId=%{public}d, ret=%{public}d", advId, btAdvId, ret);
531         return ret;
532     }
533     return SOFTBUS_OK;
534 }
535 
SoftbusStopAdv(int32_t advId)536 static int32_t SoftbusStopAdv(int32_t advId)
537 {
538     if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
539         DISC_LOGE(DISC_BLE_ADAPTER, "lock adv failed, advId=%{public}d", advId);
540         return SOFTBUS_LOCK_ERR;
541     }
542     if (!CheckAdvChanInUsed(advId)) {
543         DISC_LOGE(DISC_BLE_ADAPTER, "adv is not in used, advId=%{public}d", advId);
544         SoftBusMutexUnlock(&g_advLock);
545         return SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL;
546     }
547     int32_t btAdvId = g_advChannel[advId].advId;
548     if (!g_advChannel[advId].isAdvertising) {
549         DISC_LOGI(DISC_BLE_ADAPTER, "already stopped, advId=%{public}d, bt-advId=%{public}d", advId, btAdvId);
550         SoftBusMutexUnlock(&g_advLock);
551         return SOFTBUS_OK;
552     }
553     g_advChannel[advId].isAdvertising = false;
554     SoftBusMutexUnlock(&g_advLock);
555     int32_t ret = BleStopAdv(btAdvId);
556     if (ret != OHOS_BT_STATUS_SUCCESS) {
557         DISC_LOGE(DISC_BLE_ADAPTER, "advId=%{public}d, bt-advId=%{public}d, ret=%{public}d", advId, btAdvId, ret);
558         return ret;
559     }
560     return SOFTBUS_OK;
561 }
562 
SoftbusSetAdvData(int32_t advId,const SoftbusBroadcastData * data)563 static int32_t SoftbusSetAdvData(int32_t advId, const SoftbusBroadcastData *data)
564 {
565     if (data == NULL) {
566         DISC_LOGE(DISC_BLE_ADAPTER, "data is null, advId=%{public}d", advId);
567         return SOFTBUS_INVALID_PARAM;
568     }
569     if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
570         DISC_LOGE(DISC_BLE_ADAPTER, "lock adv failed, advId=%{public}d", advId);
571         return SOFTBUS_LOCK_ERR;
572     }
573     if (!CheckAdvChanInUsed(advId)) {
574         DISC_LOGE(DISC_BLE_ADAPTER, "adv is not in used, advId=%{public}d", advId);
575         SoftBusMutexUnlock(&g_advLock);
576         return SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL;
577     }
578     int32_t btAdvId = g_advChannel[advId].advId;
579     if (!g_advChannel[advId].isAdvertising) {
580         DISC_LOGE(DISC_BLE_ADAPTER, "adv is not advertising, advId=%{public}d, bt-advId=%{public}d",
581             advId, btAdvId);
582         SoftBusMutexUnlock(&g_advLock);
583         return SOFTBUS_ALREADY_TRIGGERED;
584     }
585     SoftBusMutexUnlock(&g_advLock);
586     StartAdvRawData advRawData = {};
587     advRawData.advData = (unsigned char *)AssembleAdvData(data, (uint16_t *)&advRawData.advDataLen);
588     if (advRawData.advData == NULL) {
589         DISC_LOGE(DISC_BLE_ADAPTER, "assemble adv data failed, advId=%{public}d, bt-advId=%{public}d",
590             advId, btAdvId);
591         return SOFTBUS_BC_ADAPTER_ASSEMBLE_FAIL;
592     }
593     advRawData.rspDataLen = 0;
594     advRawData.rspData = NULL;
595     if (data->rspData.payloadLen > 0 && data->rspData.payload != NULL) {
596         advRawData.rspData = (unsigned char *)AssembleRspData(&data->rspData, (uint16_t *)&advRawData.rspDataLen);
597         if (advRawData.rspData == NULL) {
598             SoftBusFree(advRawData.advData);
599             DISC_LOGE(DISC_BLE_ADAPTER, "assemble rsp data failed, advId=%{public}d, bt-advId=%{public}d",
600                 advId, btAdvId);
601             return SOFTBUS_BC_ADAPTER_ASSEMBLE_FAIL;
602         }
603     }
604     int32_t ret = BtStatusToSoftBus(BleSetAdvData(btAdvId, advRawData));
605     DISC_LOGI(DISC_BLE_ADAPTER, "advId=%{public}d, bt-advId=%{public}d, ret=%{public}d", advId, btAdvId, ret);
606     SoftBusFree(advRawData.advData);
607     SoftBusFree(advRawData.rspData);
608     return ret;
609 }
610 
SoftbusUpdateAdvData(int32_t advId,const SoftbusBroadcastParam * param,const SoftbusBroadcastData * data)611 static int32_t SoftbusUpdateAdvData(int32_t advId, const SoftbusBroadcastParam *param, const SoftbusBroadcastData *data)
612 {
613     int32_t ret = SoftbusStopAdv(advId);
614     if (ret != SOFTBUS_OK) {
615         DISC_LOGE(DISC_BLE_ADAPTER, "update adv data failed, advId=%{public}d", advId);
616         return ret;
617     }
618     DISC_LOGI(DISC_BLE_ADAPTER, "update adv data, advId=%{public}d", advId);
619     return SoftbusStartAdv(advId, param, data);
620 }
621 
CheckScanChannelInUsed(int32_t scannerId)622 static bool CheckScanChannelInUsed(int32_t scannerId)
623 {
624     if (scannerId < 0 || scannerId >= GATT_SCAN_MAX_NUM) {
625         DISC_LOGE(DISC_BLE_ADAPTER, "invalid scannerId=%{public}d", scannerId);
626         return false;
627     }
628     if (!g_scanChannel[scannerId].isUsed) {
629         DISC_LOGE(DISC_BLE_ADAPTER, "scannerId=%{public}d, bt-scannerId=%{public}d", scannerId,
630             g_scanChannel[scannerId].scannerId);
631         return false;
632     }
633     return true;
634 }
635 
SoftbusStartScan(int32_t scannerId,const SoftBusBcScanParams * param,const SoftBusBcScanFilter * scanFilter,int32_t filterSize)636 static int32_t SoftbusStartScan(int32_t scannerId, const SoftBusBcScanParams *param,
637     const SoftBusBcScanFilter *scanFilter, int32_t filterSize)
638 {
639     if (param == NULL || scanFilter == NULL || filterSize <= 0) {
640         DISC_LOGE(DISC_BLE_ADAPTER, "invalid param, scannerId=%{public}d", scannerId);
641         return SOFTBUS_INVALID_PARAM;
642     }
643     DISC_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&g_scannerLock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, DISC_BLE_ADAPTER,
644         "lock failed, scannerId=%{public}d", scannerId);
645     if (!CheckScanChannelInUsed(scannerId)) {
646         DISC_LOGE(DISC_BLE_ADAPTER, "scanner is not in used, scannerId=%{public}d", scannerId);
647         SoftBusMutexUnlock(&g_scannerLock);
648         return SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL;
649     }
650     int32_t btScannerId = g_scanChannel[scannerId].scannerId;
651     if (g_scanChannel[scannerId].isScanning) {
652         DISC_LOGE(DISC_BLE_ADAPTER, "already scanning, scannerId=%{public}d, bt-scannerId=%{public}d",
653             scannerId, btScannerId);
654         SoftBusMutexUnlock(&g_scannerLock);
655         return SOFTBUS_ALREADY_TRIGGERED;
656     }
657     g_scanChannel[scannerId].isScanning = true;
658     SoftBusMutexUnlock(&g_scannerLock);
659     BleScanNativeFilter *nativeFilter =
660         (BleScanNativeFilter *)SoftBusCalloc(sizeof(BleScanNativeFilter) * filterSize);
661     if (nativeFilter == NULL) {
662         DISC_LOGE(DISC_BLE_ADAPTER, "malloc filter failed, scannerId=%{public}d, bt-scannerId=%{public}d",
663             scannerId, btScannerId);
664         return SOFTBUS_MALLOC_ERR;
665     }
666     SoftbusFilterToBt(nativeFilter, scanFilter, filterSize);
667     DumpBleScanFilter(nativeFilter, filterSize);
668     BleScanConfigs scanConfig = {};
669     scanConfig.scanMode = GetBtScanMode(param->scanInterval, param->scanWindow);
670     scanConfig.phy = (int)param->scanPhy;
671     int32_t ret = BleStartScanEx(btScannerId, &scanConfig, nativeFilter, (uint32_t)filterSize);
672     FreeBtFilter(nativeFilter, filterSize);
673     DISC_LOGD(DISC_BLE_ADAPTER, "scannerId=%{public}d, bt-scannerId=%{public}d, ret=%{public}d",
674         scannerId, btScannerId, ret);
675     if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
676         DISC_LOGE(DISC_BLE_ADAPTER, "lock failed, scannerId=%{public}d, bt-scannerId=%{public}d",
677             scannerId, btScannerId);
678         return SOFTBUS_LOCK_ERR;
679     }
680     g_scanChannel[scannerId].isScanning = (ret == OHOS_BT_STATUS_SUCCESS);
681     SoftBusMutexUnlock(&g_scannerLock);
682     if (ret != OHOS_BT_STATUS_SUCCESS) {
683         return ret;
684     }
685     return SOFTBUS_OK;
686 }
687 
SoftbusStopScan(int32_t scannerId)688 static int32_t SoftbusStopScan(int32_t scannerId)
689 {
690     if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
691         DISC_LOGE(DISC_BLE_ADAPTER, "lock failed, scannerId=%{public}d", scannerId);
692         return SOFTBUS_LOCK_ERR;
693     }
694     if (!CheckScanChannelInUsed(scannerId)) {
695         DISC_LOGE(DISC_BLE_ADAPTER, "scanner is not in used=%{public}d", scannerId);
696         SoftBusMutexUnlock(&g_scannerLock);
697         return SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL;
698     }
699     int32_t btScannerId = g_scanChannel[scannerId].scannerId;
700     if (!g_scanChannel[scannerId].isScanning) {
701         DISC_LOGI(DISC_BLE_ADAPTER, "already stopped, scannerId=%{public}d, bt-scannerId=%{public}d",
702             scannerId, btScannerId);
703         SoftBusMutexUnlock(&g_scannerLock);
704         return SOFTBUS_ALREADY_TRIGGERED;
705     }
706     g_scanChannel[scannerId].isScanning = false;
707     SoftBusMutexUnlock(&g_scannerLock);
708     int32_t ret = BleStopScan(btScannerId);
709     DISC_LOGD(DISC_BLE_ADAPTER, "stop scan, scannerId=%{public}d, bt-scannerId=%{public}d, ret=%{public}d",
710         scannerId, btScannerId, ret);
711     if (ret != OHOS_BT_STATUS_SUCCESS) {
712         return ret;
713     }
714     return SOFTBUS_OK;
715 }
716 
IsLpAvailable(void)717 static bool IsLpAvailable(void)
718 {
719     bool ret = IsLpDeviceAvailable();
720     if (!ret) {
721         DISC_LOGW(DISC_BLE_ADAPTER, "lp available, ret=%{public}d", ret);
722     }
723     return ret;
724 }
725 
SetBtUuidByBroadCastType(LpServerType type,BtUuid * btUuid)726 static int32_t SetBtUuidByBroadCastType(LpServerType type, BtUuid *btUuid)
727 {
728     switch (type) {
729         case SOFTBUS_HEARTBEAT_TYPE:
730             btUuid->uuid = LP_BT_UUID_HEARTBEAT;
731             break;
732         case SOFTBUS_BURST_TYPE:
733             btUuid->uuid = LP_BT_UUID_BURST;
734             break;
735         default:
736             DISC_LOGE(DISC_BLE_ADAPTER, "invalid type, type=%{public}d", type);
737             return SOFTBUS_INVALID_PARAM;
738     }
739     btUuid->uuidLen = (unsigned char)strlen(btUuid->uuid);
740     return SOFTBUS_OK;
741 }
742 
FreeManufactureFilter(BleScanNativeFilter * nativeFilter,int32_t filterSize)743 static void FreeManufactureFilter(BleScanNativeFilter *nativeFilter, int32_t filterSize)
744 {
745     while (filterSize-- > 0) {
746         SoftBusFree((nativeFilter + filterSize)->manufactureData);
747         SoftBusFree((nativeFilter + filterSize)->manufactureDataMask);
748     }
749 }
750 
SoftbusSetLpParam(LpServerType type,const SoftBusLpBroadcastParam * bcParam,const SoftBusLpScanParam * scanParam)751 static bool SoftbusSetLpParam(LpServerType type,
752     const SoftBusLpBroadcastParam *bcParam, const SoftBusLpScanParam *scanParam)
753 {
754     BleScanConfigs scanConfig = {};
755     scanConfig.scanMode = GetBtScanMode(scanParam->scanParam.scanInterval, scanParam->scanParam.scanWindow);
756     BtLpDeviceParam lpParam = {};
757     lpParam.scanConfig = &scanConfig;
758     if (SetBtUuidByBroadCastType(type, &lpParam.uuid) != SOFTBUS_OK) {
759         DISC_LOGE(DISC_BLE_ADAPTER, "set bt uuid failed, advHandle=%{public}d", bcParam->advHandle);
760         return false;
761     }
762     lpParam.rawData.advData = (unsigned char *)AssembleAdvData(&bcParam->advData,
763         (uint16_t *)&lpParam.rawData.advDataLen);
764     DISC_CHECK_AND_RETURN_RET_LOGE(lpParam.rawData.advData != NULL, false, DISC_BLE_ADAPTER, "assemble advData failed");
765     if (bcParam->advData.rspData.payloadLen > 0 && bcParam->advData.rspData.payload != NULL) {
766         lpParam.rawData.rspData = (unsigned char *)AssembleRspData(&bcParam->advData.rspData,
767             (uint16_t *)&lpParam.rawData.rspDataLen);
768         if (lpParam.rawData.rspData == NULL) {
769             SoftBusFree(lpParam.rawData.advData);
770             DISC_LOGE(DISC_BLE_ADAPTER, "assemble rsp data failed, advHandle=%{public}d", bcParam->advHandle);
771             return false;
772         }
773     }
774     lpParam.filter = (BleScanNativeFilter *)SoftBusCalloc(sizeof(BleScanNativeFilter) * scanParam->filterSize);
775     if (lpParam.filter == NULL) {
776         SoftBusFree(lpParam.rawData.advData);
777         SoftBusFree(lpParam.rawData.rspData);
778         DISC_LOGE(DISC_BLE_ADAPTER, "malloc native filter failed, advHandle=%{public}d", bcParam->advHandle);
779         return false;
780     }
781     if (type == SOFTBUS_HEARTBEAT_TYPE) {
782         SoftbusSetManufactureFilter(lpParam.filter, scanParam->filterSize);
783     }
784     SoftbusFilterToBt(lpParam.filter, scanParam->filter, scanParam->filterSize);
785     lpParam.filterSize = (unsigned int)scanParam->filterSize;
786     SoftbusAdvParamToBt(&bcParam->advParam, &lpParam.advParam);
787     lpParam.activeDeviceInfo = NULL;
788     lpParam.activeDeviceSize = 0;
789     lpParam.deliveryMode = LP_DELIVERY_MODE_REPLY;
790     lpParam.advHandle = bcParam->advHandle;
791     lpParam.duration = LP_ADV_DURATION_MS;
792     int32_t ret = SetLpDeviceParam(&lpParam);
793     if (type == SOFTBUS_HEARTBEAT_TYPE) {
794         FreeManufactureFilter(lpParam.filter, scanParam->filterSize);
795     }
796     FreeBtFilter(lpParam.filter, scanParam->filterSize);
797     SoftBusFree(lpParam.rawData.advData);
798     SoftBusFree(lpParam.rawData.rspData);
799     DISC_LOGI(DISC_BLE_ADAPTER, "advHandle=%{public}d, ret=%{public}d", bcParam->advHandle, ret);
800     return (ret == OHOS_BT_STATUS_SUCCESS) ? true : false;
801 }
802 
SoftbusGetBroadcastHandle(int32_t advId,int32_t * bcHandle)803 static int32_t SoftbusGetBroadcastHandle(int32_t advId, int32_t *bcHandle)
804 {
805     if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
806         DISC_LOGE(DISC_BLE_ADAPTER, "lock adv failed, advId=%{public}d", advId);
807         return SOFTBUS_LOCK_ERR;
808     }
809     if (!CheckAdvChanInUsed(advId)) {
810         DISC_LOGE(DISC_BLE_ADAPTER, "adv is not in used=%{public}d", advId);
811         SoftBusMutexUnlock(&g_advLock);
812         return SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL;
813     }
814     int32_t btAdvId = g_advChannel[advId].advId;
815     SoftBusMutexUnlock(&g_advLock);
816     int32_t ret = GetAdvHandle(btAdvId, bcHandle);
817     if (ret != OHOS_BT_STATUS_SUCCESS) {
818         DISC_LOGW(DISC_BLE_ADAPTER, "get adv handle failed, advId=%{public}d, bt-advId=%{public}d, ret=%{public}d",
819             advId, btAdvId, ret);
820         return ret;
821     }
822     return SOFTBUS_OK;
823 }
824 
SoftbusEnableSyncDataToLp(void)825 static int32_t SoftbusEnableSyncDataToLp(void)
826 {
827     int32_t ret = EnableSyncDataToLpDevice();
828     if (ret != OHOS_BT_STATUS_SUCCESS) {
829         DISC_LOGW(DISC_BLE_ADAPTER, "enable failed, enable sync data to lp, ret=%{public}d", ret);
830         return ret;
831     }
832     return SOFTBUS_OK;
833 }
834 
SoftbusDisableSyncDataToLp(void)835 static int32_t SoftbusDisableSyncDataToLp(void)
836 {
837     int32_t ret = DisableSyncDataToLpDevice();
838     if (ret != OHOS_BT_STATUS_SUCCESS) {
839         DISC_LOGW(DISC_BLE_ADAPTER, "disable failed, disable sync data to lp, ret=%{public}d", ret);
840         return ret;
841     }
842     return SOFTBUS_OK;
843 }
844 
SoftbusSetScanReportChanToLp(int32_t scannerId,bool enable)845 static int32_t SoftbusSetScanReportChanToLp(int32_t scannerId, bool enable)
846 {
847     if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
848         DISC_LOGE(DISC_BLE_ADAPTER, "lock failed, scannerId=%{public}d", scannerId);
849         return SOFTBUS_LOCK_ERR;
850     }
851     if (!CheckScanChannelInUsed(scannerId)) {
852         DISC_LOGE(DISC_BLE_ADAPTER, "scanner is not in used=%{public}d", scannerId);
853         SoftBusMutexUnlock(&g_scannerLock);
854         return SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL;
855     }
856     int32_t btScannerId = g_scanChannel[scannerId].scannerId;
857     SoftBusMutexUnlock(&g_scannerLock);
858     int32_t ret = SetScanReportChannelToLpDevice(btScannerId, enable);
859     if (ret != OHOS_BT_STATUS_SUCCESS) {
860         DISC_LOGW(DISC_BLE_ADAPTER, "set channel failed, scannerId=%{public}d, bt-scannerId=%{public}d, ret=%{public}d",
861             scannerId, btScannerId, ret);
862         return ret;
863     }
864     return SOFTBUS_OK;
865 }
866 
SoftbusSetLpAdvParam(int32_t duration,int32_t maxExtAdvEvents,int32_t window,int32_t interval,int32_t bcHandle)867 static int32_t SoftbusSetLpAdvParam(int32_t duration, int32_t maxExtAdvEvents, int32_t window,
868     int32_t interval, int32_t bcHandle)
869 {
870     int32_t ret = SetLpDeviceAdvParam(duration, maxExtAdvEvents, window, interval, bcHandle);
871     if (ret != OHOS_BT_STATUS_SUCCESS) {
872         DISC_LOGW(DISC_BLE_ADAPTER, "set lp adv param failed, advHandle=%{public}d, ret=%{public}d", bcHandle, ret);
873         return ret;
874     }
875     return SOFTBUS_OK;
876 }
877 
BcAdapterBtStateChanged(int32_t listenerId,int32_t state)878 static void BcAdapterBtStateChanged(int32_t listenerId, int32_t state)
879 {
880     (void)listenerId;
881     if (state != SOFTBUS_BC_BT_STATE_TURN_OFF) {
882         return;
883     }
884     DISC_CHECK_AND_RETURN_LOGE(SoftBusMutexLock(&g_advLock) == SOFTBUS_OK, DISC_BLE_ADAPTER, "lock failed");
885     for (uint8_t channelId = 0; channelId < GATT_ADV_MAX_NUM; channelId++) {
886         AdvChannel *advChannel = &g_advChannel[channelId];
887         if (advChannel->advId < 0) {
888             continue;
889         }
890         advChannel->isAdvertising = false;
891         (void)BleStopAdv(advChannel->advId);
892         advChannel->advId = -1;
893     }
894     SoftBusMutexUnlock(&g_advLock);
895     DISC_LOGI(DISC_BLE_ADAPTER, "receive bt turn off event, reset gatt state success");
896 }
897 
898 static SoftBusBtStateListener g_softbusBcAdapterBtStateListener = {
899     .OnBtStateChanged = BcAdapterBtStateChanged,
900     .OnBtAclStateChanged = NULL,
901 };
902 
SoftbusBleAdapterInit(void)903 void SoftbusBleAdapterInit(void)
904 {
905     DISC_LOGI(DISC_BLE_ADAPTER, "enter");
906     static SoftbusBroadcastMediumInterface interface = {
907         .Init = SoftbusGattInit,
908         .DeInit = SoftbusGattDeInit,
909         .RegisterBroadcaster = SoftbusRegisterAdvCb,
910         .UnRegisterBroadcaster = SoftbusUnRegisterAdvCb,
911         .RegisterScanListener = SoftbusRegisterScanCb,
912         .UnRegisterScanListener = SoftbusUnRegisterScanCb,
913         .StartBroadcasting = SoftbusStartAdv,
914         .StopBroadcasting = SoftbusStopAdv,
915         .SetBroadcastingData = SoftbusSetAdvData,
916         .UpdateBroadcasting = SoftbusUpdateAdvData,
917         .StartScan = SoftbusStartScan,
918         .StopScan = SoftbusStopScan,
919         .IsLpDeviceAvailable = IsLpAvailable,
920         .SetAdvFilterParam = SoftbusSetLpParam,
921         .GetBroadcastHandle = SoftbusGetBroadcastHandle,
922         .EnableSyncDataToLpDevice = SoftbusEnableSyncDataToLp,
923         .DisableSyncDataToLpDevice = SoftbusDisableSyncDataToLp,
924         .SetScanReportChannelToLpDevice = SoftbusSetScanReportChanToLp,
925         .SetLpDeviceParam = SoftbusSetLpAdvParam,
926     };
927     if (RegisterBroadcastMediumFunction(BROADCAST_MEDIUM_TYPE_BLE, &interface) != 0) {
928         DISC_LOGE(DISC_BLE_ADAPTER, "register gatt interface failed");
929     }
930     int32_t ret = SoftBusAddBtStateListener(&g_softbusBcAdapterBtStateListener);
931     DISC_CHECK_AND_RETURN_LOGE(ret >= 0, DISC_BLE_ADAPTER, "add bt state listener failed.");
932     g_adapterBtStateListenerId = ret;
933     for (uint8_t channelId = 0; channelId < GATT_ADV_MAX_NUM; channelId++) {
934         g_advChannel[channelId].advId = -1;
935     }
936     for (uint8_t channelId = 0; channelId < GATT_SCAN_MAX_NUM; channelId++) {
937         g_scanChannel[channelId].scannerId = -1;
938     }
939 }
940 
SoftbusBleAdapterDeInit(void)941 void SoftbusBleAdapterDeInit(void)
942 {
943     if (g_adapterBtStateListenerId != -1) {
944         int32_t ret = SoftBusRemoveBtStateListener(g_adapterBtStateListenerId);
945         DISC_CHECK_AND_RETURN_LOGE(ret == SOFTBUS_OK, DISC_BLE_ADAPTER, "RemoveBtStateListener fail!");
946         g_adapterBtStateListenerId = -1;
947     }
948 }