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 "securec.h"
17 #include <unistd.h>
18
19 #include "disc_log.h"
20 #include "softbus_adapter_bt_common.h"
21 #include "softbus_adapter_mem.h"
22 #include "softbus_adapter_thread.h"
23 #include "softbus_ble_gatt.h"
24 #include "softbus_broadcast_adapter_interface.h"
25 #include "softbus_broadcast_manager.h"
26 #include "softbus_broadcast_utils.h"
27 #include "softbus_errcode.h"
28 #include "softbus_hidumper_bc_mgr.h"
29 #include "softbus_utils.h"
30
31 #define BC_WAIT_TIME_MS 50
32 #define BC_WAIT_TIME_SEC 1
33 #define MGR_TIME_THOUSAND_MULTIPLIER 1000LL
34 #define BC_WAIT_TIME_MICROSEC (BC_WAIT_TIME_MS * MGR_TIME_THOUSAND_MULTIPLIER)
35
36 static volatile bool g_mgrInit = false;
37 static volatile bool g_mgrLockInit = false;
38 static SoftBusMutex g_bcLock = {0};
39 static SoftBusMutex g_scanLock = {0};
40
41 static int32_t g_adapterScannerId = -1;
42 static int32_t g_adapterLpScannerId = -1;
43 static int32_t g_btStateListenerId = -1;
44 static volatile bool g_isScanCbReg = false;
45 static volatile bool g_isLpScanCbReg = false;
46
47 #define REGISTER_INFO_MANAGER "registerInfoMgr"
48 static int32_t RegisterInfoDump(int fd);
49
50 typedef struct {
51 BaseServiceType srvType;
52 int32_t adapterBcId;
53 bool isUsed;
54 bool isAdvertising;
55 bool isStarted;
56 int64_t time;
57 SoftBusCond cond;
58 BroadcastCallback *bcCallback;
59 } BroadcastManager;
60
61 typedef enum {
62 SCAN_FREQ_LOW_POWER,
63 SCAN_FREQ_P2_60_3000,
64 SCAN_FREQ_P2_30_1500,
65 SCAN_FREQ_P10_30_300,
66 SCAN_FREQ_P25_60_240,
67 SCAN_FREQ_P50_30_60,
68 SCAN_FREQ_P75_30_40,
69 SCAN_FREQ_P100_1000_1000,
70 SCAN_FREQ_BUTT,
71 } ScanFreq;
72
73 typedef struct {
74 BaseServiceType srvType;
75 int32_t adapterScanId;
76 bool isUsed;
77 bool isNeedReset;
78 bool isScanning;
79 BcScanParams param;
80 ScanFreq freq;
81 BcScanFilter *filter;
82 uint8_t filterSize;
83 ScanCallback *scanCallback;
84 } ScanManager;
85
86 static BroadcastManager g_bcManager[BC_NUM_MAX];
87 static ScanManager g_scanManager[SCAN_NUM_MAX];
88
89 // Global variable for specifying an interface type {@link SoftbusMediumType}.
90 static uint32_t g_interfaceId = BROADCAST_MEDIUM_TYPE_BLE;
91 static SoftbusBroadcastMediumInterface *g_interface[MEDIUM_NUM_MAX];
92
CheckMediumIsValid(SoftbusMediumType interfaceId)93 static inline bool CheckMediumIsValid(SoftbusMediumType interfaceId)
94 {
95 return interfaceId >= 0 && interfaceId < BROADCAST_MEDIUM_TYPE_BUTT;
96 }
97
RegisterBroadcastMediumFunction(SoftbusMediumType type,const SoftbusBroadcastMediumInterface * interface)98 int32_t RegisterBroadcastMediumFunction(SoftbusMediumType type, const SoftbusBroadcastMediumInterface *interface)
99 {
100 DISC_LOGI(DISC_BROADCAST, "register type=%{public}d", type);
101 DISC_CHECK_AND_RETURN_RET_LOGE(type >= 0 && type < BROADCAST_MEDIUM_TYPE_BUTT, SOFTBUS_INVALID_PARAM,
102 DISC_BROADCAST, "type is invalid!");
103 DISC_CHECK_AND_RETURN_RET_LOGE(interface != NULL, SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "interface is nullptr");
104
105 g_interface[type] = (SoftbusBroadcastMediumInterface *)interface;
106 return SOFTBUS_OK;
107 }
108
BcBtStateChanged(int32_t listenerId,int32_t state)109 static void BcBtStateChanged(int32_t listenerId, int32_t state)
110 {
111 DISC_CHECK_AND_RETURN_LOGE(CheckMediumIsValid(g_interfaceId), DISC_BROADCAST, "bad id");
112 (void)listenerId;
113 if (state != SOFTBUS_BC_BT_STATE_TURN_OFF) {
114 return;
115 }
116 DISC_LOGI(DISC_BROADCAST, "receive bt turn off event, start reset broadcast mgr state..");
117
118 for (uint32_t managerId = 0; managerId < BC_NUM_MAX; managerId++) {
119 DISC_CHECK_AND_RETURN_LOGE(SoftBusMutexLock(&g_bcLock) == SOFTBUS_OK, DISC_BROADCAST, "bcLock mutex error");
120
121 BroadcastManager *bcManager = &g_bcManager[managerId];
122 if (!bcManager->isUsed || bcManager->adapterBcId == -1 || bcManager->bcCallback == NULL ||
123 bcManager->bcCallback->OnStopBroadcastingCallback == NULL) {
124 SoftBusMutexUnlock(&g_bcLock);
125 continue;
126 }
127 SoftBusMutexUnlock(&g_bcLock);
128 (void)g_interface[g_interfaceId]->StopBroadcasting(bcManager->adapterBcId);
129 DISC_CHECK_AND_RETURN_LOGE(SoftBusMutexLock(&g_bcLock) == SOFTBUS_OK, DISC_BROADCAST, "bcLock mutex error");
130 bcManager->isAdvertising = false;
131 bcManager->isStarted = false;
132 bcManager->time = 0;
133 SoftBusCondBroadcast(&bcManager->cond);
134 BroadcastCallback callback = *(bcManager->bcCallback);
135 SoftBusMutexUnlock(&g_bcLock);
136 callback.OnStopBroadcastingCallback((int32_t)managerId, (int32_t)SOFTBUS_BC_STATUS_SUCCESS);
137 }
138
139 for (uint32_t managerId = 0; managerId < SCAN_NUM_MAX; managerId++) {
140 DISC_CHECK_AND_RETURN_LOGE(SoftBusMutexLock(&g_scanLock) == SOFTBUS_OK, DISC_BROADCAST, "scanLock mutex error");
141
142 ScanManager *scanManager = &g_scanManager[managerId];
143 if (!scanManager->isUsed || scanManager->adapterScanId == -1 || !scanManager->isScanning ||
144 scanManager->scanCallback == NULL || scanManager->scanCallback->OnStopScanCallback == NULL) {
145 SoftBusMutexUnlock(&g_scanLock);
146 continue;
147 }
148 (void)g_interface[g_interfaceId]->StopScan(scanManager->adapterScanId);
149 scanManager->isScanning = false;
150 ScanCallback callback = *(scanManager->scanCallback);
151 SoftBusMutexUnlock(&g_scanLock);
152 callback.OnStopScanCallback((int32_t)managerId, (int32_t)SOFTBUS_BC_STATUS_SUCCESS);
153 }
154 }
155
156 static SoftBusBtStateListener g_softbusBcBtStateLister = {
157 .OnBtStateChanged = BcBtStateChanged,
158 .OnBtAclStateChanged = NULL,
159 };
160
BcManagerLockInit(void)161 static int32_t BcManagerLockInit(void)
162 {
163 DISC_LOGI(DISC_BROADCAST, "init enter");
164 if (g_mgrLockInit) {
165 return SOFTBUS_OK;
166 }
167 if (SoftBusMutexInit(&g_bcLock, NULL) != SOFTBUS_OK) {
168 DISC_LOGE(DISC_BROADCAST, "bcLock init failed");
169 return SOFTBUS_NO_INIT;
170 }
171 if (SoftBusMutexInit(&g_scanLock, NULL) != SOFTBUS_OK) {
172 DISC_LOGE(DISC_BROADCAST, "scanLock init failed");
173 (void)SoftBusMutexDestroy(&g_bcLock);
174 return SOFTBUS_NO_INIT;
175 }
176 g_mgrLockInit = true;
177 return SOFTBUS_OK;
178 }
179
InitBroadcastMgr(void)180 int32_t InitBroadcastMgr(void)
181 {
182 DISC_LOGI(DISC_BROADCAST, "init enter");
183 if (g_mgrInit) {
184 DISC_LOGD(DISC_BROADCAST, "mgr already inited");
185 return SOFTBUS_OK;
186 }
187 int32_t ret = BcManagerLockInit();
188 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, DISC_BROADCAST, "lock init failed");
189
190 SoftbusBleAdapterInit();
191 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "bad id");
192 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId] != NULL, SOFTBUS_BC_MGR_NO_FUNC_REGISTERED,
193 DISC_BROADCAST, "interface is nullptr");
194 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId]->Init != NULL,
195 SOFTBUS_BC_MGR_FUNC_NULL, DISC_BROADCAST, "function is nullptr");
196
197 ret = g_interface[g_interfaceId]->Init();
198 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, DISC_BROADCAST, "call from adapter failed");
199
200 ret = SoftBusAddBtStateListener(&g_softbusBcBtStateLister);
201 DISC_CHECK_AND_RETURN_RET_LOGE(ret >= 0, ret, DISC_BROADCAST, "add bt state listener failed");
202 g_btStateListenerId = ret;
203 g_mgrInit = true;
204
205 SoftBusRegBcMgrVarDump((char *)REGISTER_INFO_MANAGER, &RegisterInfoDump);
206 return SOFTBUS_OK;
207 }
208
CheckLockIsInit(SoftBusMutex * lock)209 static bool CheckLockIsInit(SoftBusMutex *lock)
210 {
211 if (SoftBusMutexLock(lock) != SOFTBUS_OK) {
212 return false;
213 }
214 SoftBusMutexUnlock(lock);
215 return true;
216 }
217
CheckBroadcastingParam(const BroadcastParam * param,const BroadcastPacket * packet)218 static int32_t CheckBroadcastingParam(const BroadcastParam *param, const BroadcastPacket *packet)
219 {
220 DISC_CHECK_AND_RETURN_RET_LOGE(param != NULL, SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "invalid param!");
221 DISC_CHECK_AND_RETURN_RET_LOGE(packet != NULL, SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "invalid param packet");
222 DISC_CHECK_AND_RETURN_RET_LOGE(packet->bcData.payload != NULL, SOFTBUS_INVALID_PARAM, DISC_BROADCAST,
223 "invalid param payload");
224 return SOFTBUS_OK;
225 }
226
DeInitBroadcastMgr(void)227 int32_t DeInitBroadcastMgr(void)
228 {
229 DISC_LOGI(DISC_BROADCAST, "deinit enter");
230 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "bad id");
231 DISC_CHECK_AND_RETURN_RET_LOGW(g_interface[g_interfaceId] != NULL, SOFTBUS_OK, DISC_BROADCAST, "already deinit");
232 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId]->DeInit != NULL,
233 SOFTBUS_BC_MGR_FUNC_NULL, DISC_BROADCAST, "function is nullptr");
234
235 if (CheckLockIsInit(&g_bcLock)) {
236 (void)SoftBusMutexDestroy(&g_bcLock);
237 }
238 if (CheckLockIsInit(&g_scanLock)) {
239 (void)SoftBusMutexDestroy(&g_scanLock);
240 }
241 g_mgrLockInit = false;
242 g_mgrInit = false;
243 SoftbusBleAdapterDeInit();
244 int32_t ret;
245 if (g_btStateListenerId != -1) {
246 ret = SoftBusRemoveBtStateListener(g_btStateListenerId);
247 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, DISC_BROADCAST, "RemoveBtStateListener failed");
248 g_btStateListenerId = -1;
249 }
250
251 ret = g_interface[g_interfaceId]->DeInit();
252 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, DISC_BROADCAST, "call from adapter failed");
253 g_interface[g_interfaceId] = NULL;
254 return SOFTBUS_OK;
255 }
256
GetSrvType(BaseServiceType srvType)257 static char *GetSrvType(BaseServiceType srvType)
258 {
259 if ((int32_t)srvType < 0 || (int32_t)srvType >= (int32_t)(sizeof(g_srvTypeMap)/sizeof(SrvTypeMap))) {
260 return (char *)"invalid service";
261 }
262 return g_srvTypeMap[srvType].service;
263 }
264
BcStartBroadcastingCallback(int32_t adapterBcId,int32_t status)265 static void BcStartBroadcastingCallback(int32_t adapterBcId, int32_t status)
266 {
267 static uint32_t callCount = 0;
268 for (uint32_t managerId = 0; managerId < BC_NUM_MAX; managerId++) {
269 int32_t ret = SoftBusMutexLock(&g_bcLock);
270 DISC_CHECK_AND_RETURN_LOGE(ret == SOFTBUS_OK,
271 DISC_BROADCAST, "mutex error, adapterBcId=%{public}d", adapterBcId);
272
273 BroadcastManager *bcManager = &g_bcManager[managerId];
274 if (bcManager->adapterBcId != adapterBcId) {
275 SoftBusMutexUnlock(&g_bcLock);
276 continue;
277 }
278 if (!bcManager->isUsed || bcManager->bcCallback == NULL ||
279 bcManager->bcCallback->OnStartBroadcastingCallback == NULL) {
280 SoftBusMutexUnlock(&g_bcLock);
281 DISC_LOGE(DISC_BROADCAST, "bcManager not available, adapterBcId=%{public}d, managerId=%{public}u",
282 adapterBcId, managerId);
283 continue;
284 }
285 DISC_LOGI(DISC_BROADCAST, "srvType=%{public}s, managerId=%{public}u, adapterBcId=%{public}d, status=%{public}d,"
286 "callCount=%{public}u", GetSrvType(bcManager->srvType), managerId, adapterBcId, status, callCount++);
287 if (status == SOFTBUS_BC_STATUS_SUCCESS) {
288 bcManager->isAdvertising = true;
289 SoftBusCondSignal(&bcManager->cond);
290 }
291 BroadcastCallback callback = *(bcManager->bcCallback);
292 SoftBusMutexUnlock(&g_bcLock);
293 callback.OnStartBroadcastingCallback((int32_t)managerId, status);
294 break; // The broadcast channel cannot be multiplexed.
295 }
296 }
297
BcStopBroadcastingCallback(int32_t adapterBcId,int32_t status)298 static void BcStopBroadcastingCallback(int32_t adapterBcId, int32_t status)
299 {
300 for (uint32_t managerId = 0; managerId < BC_NUM_MAX; managerId++) {
301 int32_t ret = SoftBusMutexLock(&g_bcLock);
302 DISC_CHECK_AND_RETURN_LOGE(ret == SOFTBUS_OK,
303 DISC_BROADCAST, "mutex error, adapterBcId=%{public}d", adapterBcId);
304
305 BroadcastManager *bcManager = &g_bcManager[managerId];
306 if (bcManager->adapterBcId != adapterBcId) {
307 SoftBusMutexUnlock(&g_bcLock);
308 continue;
309 }
310 if (!bcManager->isUsed || bcManager->bcCallback == NULL ||
311 bcManager->bcCallback->OnStopBroadcastingCallback == NULL) {
312 SoftBusMutexUnlock(&g_bcLock);
313 DISC_LOGE(DISC_BROADCAST, "bcManager not available, adapterBcId=%{public}d, managerId=%{public}u",
314 adapterBcId, managerId);
315 continue;
316 }
317 DISC_LOGI(DISC_BROADCAST, "srvType=%{public}s, managerId=%{public}u, adapterBcId=%{public}d, status=%{public}d",
318 GetSrvType(bcManager->srvType), managerId, adapterBcId, status);
319 if (status == SOFTBUS_BC_STATUS_SUCCESS) {
320 bcManager->isAdvertising = false;
321 bcManager->time = 0;
322 SoftBusCondSignal(&bcManager->cond);
323 }
324 BroadcastCallback callback = *(bcManager->bcCallback);
325 SoftBusMutexUnlock(&g_bcLock);
326 callback.OnStopBroadcastingCallback((int32_t)managerId, status);
327 break; // The broadcast channel cannot be multiplexed.
328 }
329 }
330
BcUpdateBroadcastingCallback(int32_t adapterBcId,int32_t status)331 static void BcUpdateBroadcastingCallback(int32_t adapterBcId, int32_t status)
332 {
333 DISC_LOGD(DISC_BROADCAST, "enter update bc cb enter");
334 for (uint32_t managerId = 0; managerId < BC_NUM_MAX; managerId++) {
335 int32_t ret = SoftBusMutexLock(&g_bcLock);
336 DISC_CHECK_AND_RETURN_LOGE(ret == SOFTBUS_OK, DISC_BROADCAST, "mutex error");
337
338 BroadcastManager *bcManager = &g_bcManager[managerId];
339 if (bcManager->adapterBcId != adapterBcId || !bcManager->isUsed || bcManager->bcCallback == NULL ||
340 bcManager->bcCallback->OnUpdateBroadcastingCallback == NULL) {
341 SoftBusMutexUnlock(&g_bcLock);
342 continue;
343 }
344 DISC_LOGI(DISC_BROADCAST, "srvType=%{public}s, managerId=%{public}u, adapterBcId=%{public}d, status=%{public}d",
345 GetSrvType(bcManager->srvType), managerId, adapterBcId, status);
346 BroadcastCallback callback = *(bcManager->bcCallback);
347 SoftBusMutexUnlock(&g_bcLock);
348 callback.OnUpdateBroadcastingCallback((int32_t)managerId, status);
349 break; // The broadcast channel cannot be multiplexed.
350 }
351 }
352
BcSetBroadcastingCallback(int32_t adapterBcId,int32_t status)353 static void BcSetBroadcastingCallback(int32_t adapterBcId, int32_t status)
354 {
355 DISC_LOGD(DISC_BROADCAST, "enter set bc cb");
356 for (uint32_t managerId = 0; managerId < BC_NUM_MAX; managerId++) {
357 int32_t ret = SoftBusMutexLock(&g_bcLock);
358 DISC_CHECK_AND_RETURN_LOGE(ret == SOFTBUS_OK, DISC_BROADCAST, "mutex error");
359
360 BroadcastManager *bcManager = &g_bcManager[managerId];
361 if (bcManager->adapterBcId != adapterBcId || !bcManager->isUsed || bcManager->bcCallback == NULL ||
362 bcManager->bcCallback->OnSetBroadcastingCallback == NULL) {
363 SoftBusMutexUnlock(&g_bcLock);
364 continue;
365 }
366 static uint32_t callCount = 0;
367 DISC_LOGI(DISC_BROADCAST, "srvType=%{public}s, managerId=%{public}u, adapterBcId=%{public}d, status=%{public}d,"
368 "callCount=%{public}u", GetSrvType(bcManager->srvType), managerId, adapterBcId, status, callCount++);
369 BroadcastCallback callback = *(bcManager->bcCallback);
370 SoftBusMutexUnlock(&g_bcLock);
371 callback.OnSetBroadcastingCallback((int32_t)managerId, status);
372 break; // The broadcast channel cannot be multiplexed.
373 }
374 }
375
376 static SoftbusBroadcastCallback g_softbusBcBleCb = {
377 .OnStartBroadcastingCallback = BcStartBroadcastingCallback,
378 .OnStopBroadcastingCallback = BcStopBroadcastingCallback,
379 .OnUpdateBroadcastingCallback = BcUpdateBroadcastingCallback,
380 .OnSetBroadcastingCallback = BcSetBroadcastingCallback,
381 };
382
BcOnStartScanCallback(int32_t adapterScanId,int32_t status)383 static void BcOnStartScanCallback(int32_t adapterScanId, int32_t status)
384 {
385 DISC_LOGD(DISC_BROADCAST, "enter on start scan cb");
386 for (uint32_t managerId = 0; managerId < SCAN_NUM_MAX; managerId++) {
387 ScanManager *scanManager = &g_scanManager[managerId];
388 if (scanManager->adapterScanId != adapterScanId || !scanManager->isUsed || scanManager->scanCallback == NULL ||
389 scanManager->scanCallback->OnStartScanCallback == NULL) {
390 continue;
391 }
392 DISC_LOGI(DISC_BROADCAST, "srvType=%{public}s, managerId=%{public}u, adapterScanId=%{public}d, "
393 "status=%{public}d", GetSrvType(scanManager->srvType), managerId, adapterScanId, status);
394 if (status == SOFTBUS_BC_STATUS_SUCCESS) {
395 scanManager->isScanning = true;
396 }
397
398 scanManager->scanCallback->OnStartScanCallback((int32_t)managerId, status);
399 }
400 }
401
BcStopScanCallback(int32_t adapterScanId,int32_t status)402 static void BcStopScanCallback(int32_t adapterScanId, int32_t status)
403 {
404 DISC_LOGD(DISC_BROADCAST, "enter stop scan cb");
405 for (uint32_t managerId = 0; managerId < SCAN_NUM_MAX; managerId++) {
406 ScanManager *scanManager = &g_scanManager[managerId];
407 if (scanManager->adapterScanId != adapterScanId || !scanManager->isUsed || scanManager->scanCallback == NULL ||
408 scanManager->scanCallback->OnStopScanCallback == NULL) {
409 continue;
410 }
411 DISC_LOGI(DISC_BROADCAST, "srvType=%{public}s, managerId=%{public}u, adapterScanId=%{public}d, "
412 "status=%{public}d", GetSrvType(scanManager->srvType), managerId, adapterScanId, status);
413 if (status == SOFTBUS_BC_STATUS_SUCCESS) {
414 scanManager->isScanning = false;
415 }
416
417 scanManager->scanCallback->OnStopScanCallback((int32_t)managerId, status);
418 }
419 }
420
BuildBcInfoCommon(const SoftBusBcScanResult * reportData,BroadcastReportInfo * bcInfo)421 static int32_t BuildBcInfoCommon(const SoftBusBcScanResult *reportData, BroadcastReportInfo *bcInfo)
422 {
423 bcInfo->eventType = reportData->eventType;
424 bcInfo->dataStatus = reportData->dataStatus;
425 bcInfo->primaryPhy = reportData->primaryPhy;
426 bcInfo->secondaryPhy = reportData->secondaryPhy;
427 bcInfo->advSid = reportData->advSid;
428 bcInfo->txPower = reportData->txPower;
429 bcInfo->rssi = reportData->rssi;
430 bcInfo->addrType = reportData->addrType;
431
432 int32_t ret = memcpy_s(bcInfo->addr.addr, BC_ADDR_MAC_LEN, reportData->addr.addr, SOFTBUS_ADDR_MAC_LEN);
433 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_MEM_ERR, DISC_BROADCAST, "memcpy addr failed");
434
435 ret = memcpy_s(bcInfo->localName, BC_LOCAL_NAME_LEN_MAX, reportData->localName, SOFTBUS_LOCAL_NAME_LEN_MAX);
436 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_MEM_ERR, DISC_BROADCAST, "memcpy localName failed");
437
438 return SOFTBUS_OK;
439 }
440
CheckManufactureIsMatch(const BcScanFilter * filter,const BroadcastPayload * bcData)441 static bool CheckManufactureIsMatch(const BcScanFilter *filter, const BroadcastPayload *bcData)
442 {
443 uint8_t dataLen = bcData->payloadLen;
444 uint32_t filterLen = filter->manufactureDataLength;
445 if ((uint32_t)dataLen < filterLen) {
446 DISC_LOGD(DISC_BROADCAST, "payload is too short");
447 return false;
448 }
449 if (filter->manufactureId != bcData->id) {
450 DISC_LOGD(DISC_BROADCAST, "manufacture id not match");
451 return false;
452 }
453 for (uint32_t i = 0; i < filterLen; i++) {
454 if ((filter->manufactureData[i] & filter->manufactureDataMask[i]) !=
455 (bcData->payload[i] & filter->manufactureDataMask[i])) {
456 return false;
457 }
458 }
459 return true;
460 }
461
CheckServiceIsMatch(const BcScanFilter * filter,const BroadcastPayload * bcData)462 static bool CheckServiceIsMatch(const BcScanFilter *filter, const BroadcastPayload *bcData)
463 {
464 uint8_t dataLen = bcData->payloadLen;
465 uint32_t filterLen = filter->serviceDataLength;
466 if ((uint32_t)dataLen < filterLen) {
467 DISC_LOGD(DISC_BROADCAST, "payload is too short");
468 return false;
469 }
470 if (filter->serviceUuid != bcData->id) {
471 DISC_LOGD(DISC_BROADCAST, "serviceUuid not match");
472 return false;
473 }
474 for (uint32_t i = 0; i < filterLen; i++) {
475 if ((filter->serviceData[i] & filter->serviceDataMask[i]) !=
476 (bcData->payload[i] & filter->serviceDataMask[i])) {
477 return false;
478 }
479 }
480 return true;
481 }
482
CheckScanResultDataIsMatch(const uint32_t managerId,BroadcastPayload * bcData)483 static bool CheckScanResultDataIsMatch(const uint32_t managerId, BroadcastPayload *bcData)
484 {
485 if (bcData->type != BC_DATA_TYPE_SERVICE && bcData->type != BC_DATA_TYPE_MANUFACTURER) {
486 DISC_LOGE(DISC_BROADCAST, "not support type, type=%{public}d", bcData->type);
487 return false;
488 }
489
490 uint8_t filterSize = g_scanManager[managerId].filterSize;
491 for (uint8_t i = 0; i < filterSize; i++) {
492 BcScanFilter filter = g_scanManager[managerId].filter[i];
493 if (bcData->type == BC_DATA_TYPE_SERVICE && CheckServiceIsMatch(&filter, bcData)) {
494 return true;
495 }
496 if (bcData->type == BC_DATA_TYPE_MANUFACTURER && CheckManufactureIsMatch(&filter, bcData)) {
497 return true;
498 }
499 }
500 return false;
501 }
502
DumpSoftbusData(const char * description,uint16_t len,const uint8_t * data)503 static void DumpSoftbusData(const char *description, uint16_t len, const uint8_t *data)
504 {
505 DISC_CHECK_AND_RETURN_LOGE(description != NULL, DISC_BROADCAST, "description is nullptr");
506 DISC_CHECK_AND_RETURN_LOGD(len != 0, DISC_BROADCAST, "description=%{public}s, len is 0", description);
507 DISC_CHECK_AND_RETURN_LOGE(data != NULL, DISC_BROADCAST, "description=%{public}s, data is nullptr", description);
508
509 int32_t hexLen = HEXIFY_LEN(len);
510 char *softbusData = (char *)SoftBusCalloc(sizeof(char) * hexLen);
511 DISC_CHECK_AND_RETURN_LOGE(softbusData != NULL, DISC_BROADCAST, "desc=%{public}s, malloc failed", description);
512
513 (void)ConvertBytesToHexString(softbusData, hexLen, data, len);
514 DISC_LOGD(DISC_BROADCAST, "description=%{public}s, softbusData=%{public}s", description, softbusData);
515
516 SoftBusFree(softbusData);
517 }
518
ReleaseBroadcastReportInfo(BroadcastReportInfo * bcInfo)519 static void ReleaseBroadcastReportInfo(BroadcastReportInfo *bcInfo)
520 {
521 SoftBusFree(bcInfo->packet.bcData.payload);
522 SoftBusFree(bcInfo->packet.rspData.payload);
523 }
524
BuildBcPayload(int32_t maxPayloadLen,const SoftbusBroadcastPayload * srcData,BroadcastPayload * dstData)525 static int32_t BuildBcPayload(int32_t maxPayloadLen, const SoftbusBroadcastPayload *srcData, BroadcastPayload *dstData)
526 {
527 DISC_CHECK_AND_RETURN_RET_LOGE(srcData->payload != NULL, SOFTBUS_INVALID_PARAM, DISC_BROADCAST,
528 "broadcast payload is nullptr");
529
530 dstData->type = (BroadcastDataType)srcData->type;
531 dstData->id = srcData->id;
532
533 if (srcData->payloadLen > maxPayloadLen) {
534 DISC_LOGW(DISC_BROADCAST, "payloadLen=%{public}d is too long", srcData->payloadLen);
535 }
536 int32_t bcDataLen = (srcData->payloadLen > maxPayloadLen) ? maxPayloadLen : srcData->payloadLen;
537 dstData->payload = (uint8_t *)SoftBusCalloc(bcDataLen);
538 DISC_CHECK_AND_RETURN_RET_LOGE(dstData->payload != NULL, SOFTBUS_MALLOC_ERR, DISC_BROADCAST, "malloc failed");
539
540 if (memcpy_s(dstData->payload, bcDataLen, srcData->payload, bcDataLen) != EOK) {
541 DISC_LOGE(DISC_BROADCAST, "memcpy payload failed");
542 SoftBusFree(dstData->payload);
543 return SOFTBUS_MEM_ERR;
544 }
545 dstData->payloadLen = bcDataLen;
546
547 return SOFTBUS_OK;
548 }
549
BuildBroadcastPacket(const SoftbusBroadcastData * softbusBcData,BroadcastPacket * packet)550 static int32_t BuildBroadcastPacket(const SoftbusBroadcastData *softbusBcData, BroadcastPacket *packet)
551 {
552 packet->isSupportFlag = softbusBcData->isSupportFlag;
553 packet->flag = softbusBcData->flag;
554
555 // 2.1. Build broadcast payload.
556 int32_t maxPayloadLen = (softbusBcData->isSupportFlag) ? BC_DATA_MAX_LEN : (BC_DATA_MAX_LEN + BC_FLAG_LEN);
557
558 int32_t ret = BuildBcPayload(maxPayloadLen, &(softbusBcData->bcData), &(packet->bcData));
559 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_BC_MGR_BUILD_ADV_PACKT_FAIL,
560 DISC_BROADCAST, "build broadcast payload failed");
561
562 DumpSoftbusData("scan result bcData", softbusBcData->bcData.payloadLen, softbusBcData->bcData.payload);
563
564 // 2.2. Build broadcast response payload.
565 if (softbusBcData->rspData.payload == NULL) {
566 packet->rspData.payload = NULL;
567 DISC_LOGD(DISC_BROADCAST, "no rspData");
568 } else {
569 maxPayloadLen = RSP_DATA_MAX_LEN;
570 ret = BuildBcPayload(maxPayloadLen, &(softbusBcData->rspData), &(packet->rspData));
571 if (ret != SOFTBUS_OK) {
572 SoftBusFree(packet->bcData.payload);
573 DISC_LOGE(DISC_BROADCAST, "build broadcast rsp payload failed");
574 return SOFTBUS_BC_MGR_BUILD_RSP_PACKT_FAIL;
575 }
576 DumpSoftbusData("scan result rspData", softbusBcData->rspData.payloadLen, softbusBcData->rspData.payload);
577 }
578 return SOFTBUS_OK;
579 }
580
BuildBroadcastReportInfo(const SoftBusBcScanResult * reportData,BroadcastReportInfo * bcInfo)581 static int32_t BuildBroadcastReportInfo(const SoftBusBcScanResult *reportData, BroadcastReportInfo *bcInfo)
582 {
583 // 1. Build BroadcastReportInfo from SoftBusBcScanResult except BroadcastPacket.
584 int32_t ret = BuildBcInfoCommon(reportData, bcInfo);
585 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, DISC_BROADCAST, "build broadcast common info failed");
586
587 // 2. Build BroadcastPacket.
588 ret = BuildBroadcastPacket(&(reportData->data), &(bcInfo->packet));
589 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, DISC_BROADCAST, "build broadcast packet failed");
590
591 return SOFTBUS_OK;
592 }
593
CheckScanResultDataIsMatchApproach(const uint32_t managerId,BroadcastPayload * bcData)594 static bool CheckScanResultDataIsMatchApproach(const uint32_t managerId, BroadcastPayload *bcData)
595 {
596 if (bcData->payload == NULL) {
597 return false;
598 }
599 DISC_CHECK_AND_RETURN_RET_LOGD(bcData->type == BC_DATA_TYPE_SERVICE, false, DISC_BROADCAST,
600 "type dismatch, type=%{public}d", bcData->type);
601
602 uint8_t filterSize = g_scanManager[managerId].filterSize;
603 for (uint8_t i = 0; i < filterSize; i++) {
604 BcScanFilter filter = g_scanManager[managerId].filter[i];
605 if (CheckServiceIsMatch(&filter, bcData)) {
606 return true;
607 }
608 }
609 return false;
610 }
611
BcReportScanDataCallback(int32_t adapterScanId,const SoftBusBcScanResult * reportData)612 static void BcReportScanDataCallback(int32_t adapterScanId, const SoftBusBcScanResult *reportData)
613 {
614 DISC_LOGD(DISC_BROADCAST, "enter report scan cb");
615 DISC_CHECK_AND_RETURN_LOGE(reportData != NULL, DISC_BROADCAST, "reportData is nullptr");
616
617 BroadcastReportInfo bcInfo;
618 int32_t ret = BuildBroadcastReportInfo(reportData, &bcInfo);
619 DISC_CHECK_AND_RETURN_LOGE(ret == SOFTBUS_OK, DISC_BROADCAST, "build bc report info failed");
620
621 for (uint32_t managerId = 0; managerId < SCAN_NUM_MAX; managerId++) {
622 if (SoftBusMutexLock(&g_scanLock) != 0) {
623 ReleaseBroadcastReportInfo(&bcInfo);
624 return;
625 }
626 ScanManager *scanManager = &g_scanManager[managerId];
627 if (!scanManager->isUsed || !scanManager->isScanning || scanManager->filter == NULL ||
628 scanManager->scanCallback == NULL || scanManager->scanCallback->OnReportScanDataCallback == NULL ||
629 scanManager->adapterScanId != adapterScanId ||
630 !(CheckScanResultDataIsMatch(managerId, &(bcInfo.packet.bcData)) ||
631 (scanManager->srvType == SRV_TYPE_APPROACH &&
632 CheckScanResultDataIsMatchApproach(managerId, &(bcInfo.packet.rspData))))) {
633 SoftBusMutexUnlock(&g_scanLock);
634 continue;
635 }
636
637 DISC_LOGD(DISC_BROADCAST, "srvType=%{public}s, managerId=%{public}u, adapterScanId=%{public}d",
638 GetSrvType(scanManager->srvType), managerId, adapterScanId);
639 ScanCallback callback = *(scanManager->scanCallback);
640 SoftBusMutexUnlock(&g_scanLock);
641 callback.OnReportScanDataCallback((int32_t)managerId, &bcInfo);
642 }
643 ReleaseBroadcastReportInfo(&bcInfo);
644 }
645
BcScanStateChanged(int32_t resultCode,bool isStartScan)646 static void BcScanStateChanged(int32_t resultCode, bool isStartScan)
647 {
648 DISC_LOGD(DISC_BROADCAST, "enter scan state change");
649 for (uint32_t managerId = 0; managerId < SCAN_NUM_MAX; managerId++) {
650 int32_t ret = SoftBusMutexLock(&g_scanLock);
651 DISC_CHECK_AND_RETURN_LOGE(ret == SOFTBUS_OK, DISC_BROADCAST, "mutex error");
652
653 ScanManager *scanManager = &g_scanManager[managerId];
654 if (!scanManager->isUsed || !scanManager->isScanning || scanManager->scanCallback == NULL ||
655 scanManager->scanCallback->OnScanStateChanged == NULL) {
656 SoftBusMutexUnlock(&g_scanLock);
657 continue;
658 }
659 DISC_LOGD(DISC_BROADCAST,
660 "srvType=%{public}s, managerId=%{public}u, adapterScanId=%{public}d, isStartScan=%{public}d",
661 GetSrvType(scanManager->srvType), managerId, scanManager->adapterScanId, isStartScan);
662 ScanCallback callback = *(scanManager->scanCallback);
663 SoftBusMutexUnlock(&g_scanLock);
664 callback.OnScanStateChanged(resultCode, isStartScan);
665 }
666 }
667
ConvertBroadcastUuid(const SoftbusBroadcastUuid * uuid,BroadcastUuid * bcUuid)668 static int32_t ConvertBroadcastUuid(const SoftbusBroadcastUuid *uuid, BroadcastUuid *bcUuid)
669 {
670 bcUuid->uuidLen = uuid->uuidLen;
671 bcUuid->uuid = (int8_t *)SoftBusCalloc(bcUuid->uuidLen);
672 DISC_CHECK_AND_RETURN_RET_LOGE(bcUuid->uuid != NULL, SOFTBUS_MALLOC_ERR, DISC_BROADCAST, "malloc failed");
673 if (memcpy_s(bcUuid->uuid, bcUuid->uuidLen, uuid->uuid, uuid->uuidLen) != EOK) {
674 DISC_LOGE(DISC_BROADCAST, "memcpy error");
675 SoftBusFree(bcUuid->uuid);
676 return SOFTBUS_MEM_ERR;
677 }
678 return SOFTBUS_OK;
679 }
680
BcLpDeviceInfoCallback(const SoftbusBroadcastUuid * uuid,int32_t type,uint8_t * data,uint32_t dataSize)681 static void BcLpDeviceInfoCallback(const SoftbusBroadcastUuid *uuid, int32_t type, uint8_t *data, uint32_t dataSize)
682 {
683 DISC_LOGD(DISC_BROADCAST, "enter lp cb");
684 BroadcastUuid bcUuid = {0};
685 int32_t ret = ConvertBroadcastUuid(uuid, &bcUuid);
686 DISC_CHECK_AND_RETURN_LOGE(ret == SOFTBUS_OK, DISC_BROADCAST, "convert broadcast Uuid failed");
687
688 for (uint32_t managerId = 0; managerId < SCAN_NUM_MAX; managerId++) {
689 ScanManager *scanManager = &g_scanManager[managerId];
690 if (!scanManager->isUsed || scanManager->scanCallback == NULL ||
691 scanManager->scanCallback->OnLpDeviceInfoCallback == NULL) {
692 continue;
693 }
694
695 scanManager->scanCallback->OnLpDeviceInfoCallback(&bcUuid, type, data, dataSize);
696 break;
697 }
698 SoftBusFree(bcUuid.uuid);
699 }
700
701 static SoftbusScanCallback g_softbusBcBleScanCb = {
702 .OnStartScanCallback = BcOnStartScanCallback,
703 .OnStopScanCallback = BcStopScanCallback,
704 .OnReportScanDataCallback = BcReportScanDataCallback,
705 .OnScanStateChanged = BcScanStateChanged,
706 .OnLpDeviceInfoCallback = BcLpDeviceInfoCallback,
707 };
708
IsSrvTypeValid(BaseServiceType srvType)709 static bool IsSrvTypeValid(BaseServiceType srvType)
710 {
711 return srvType >= 0 && srvType < SRV_TYPE_BUTT;
712 }
713
RegisterBroadcaster(BaseServiceType srvType,int32_t * bcId,const BroadcastCallback * cb)714 int32_t RegisterBroadcaster(BaseServiceType srvType, int32_t *bcId, const BroadcastCallback *cb)
715 {
716 static uint32_t callCount = 0;
717 DISC_LOGI(DISC_BROADCAST, "enter register bc, callCount=%{public}u", callCount++);
718 int32_t ret = SOFTBUS_OK;
719 int32_t adapterBcId = -1;
720 DISC_CHECK_AND_RETURN_RET_LOGE(IsSrvTypeValid(srvType), SOFTBUS_BC_MGR_INVALID_SRV, DISC_BROADCAST, "bad srvType");
721 DISC_CHECK_AND_RETURN_RET_LOGE(bcId != NULL, SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "invalid param bcId");
722 DISC_CHECK_AND_RETURN_RET_LOGE(cb != NULL, SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "invalid param cb!");
723 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "bad id");
724 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId] != NULL, SOFTBUS_BC_MGR_NO_FUNC_REGISTERED,
725 DISC_BROADCAST, "interface is nullptr");
726 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId]->RegisterBroadcaster != NULL,
727 SOFTBUS_BC_MGR_FUNC_NULL, DISC_BROADCAST, "function is nullptr");
728 ret = SoftBusMutexLock(&g_bcLock);
729 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, DISC_BROADCAST, "mutex error");
730 ret = g_interface[g_interfaceId]->RegisterBroadcaster(&adapterBcId, &g_softbusBcBleCb);
731 if (ret != SOFTBUS_OK) {
732 DISC_LOGE(DISC_BROADCAST, "call from adapter failed");
733 SoftBusMutexUnlock(&g_bcLock);
734 return ret;
735 }
736
737 int32_t managerId;
738 for (managerId = 0; managerId < BC_NUM_MAX; managerId++) {
739 if (!g_bcManager[managerId].isUsed) {
740 break;
741 }
742 }
743 if (managerId == BC_NUM_MAX) {
744 DISC_LOGE(DISC_BROADCAST, "no available adv manager");
745 SoftBusMutexUnlock(&g_bcLock);
746 return SOFTBUS_BC_MGR_REG_NO_AVAILABLE_BC_ID;
747 }
748 DISC_LOGI(DISC_BROADCAST,
749 "srvType=%{public}s, bcId=%{public}d, adapterBcId=%{public}d", GetSrvType(srvType), managerId, adapterBcId);
750
751 *bcId = managerId;
752 ret = SoftBusCondInit(&g_bcManager[managerId].cond);
753 if (ret != SOFTBUS_OK) {
754 DISC_LOGE(DISC_BROADCAST, "cond Init failed");
755 SoftBusMutexUnlock(&g_bcLock);
756 return ret;
757 }
758 g_bcManager[managerId].srvType = srvType;
759 g_bcManager[managerId].adapterBcId = adapterBcId;
760 g_bcManager[managerId].isUsed = true;
761 g_bcManager[managerId].isAdvertising = false;
762 g_bcManager[managerId].time = 0;
763 g_bcManager[managerId].bcCallback = (BroadcastCallback *)cb;
764 SoftBusMutexUnlock(&g_bcLock);
765 return SOFTBUS_OK;
766 }
767
CheckBcIdIsValid(int32_t bcId)768 static bool CheckBcIdIsValid(int32_t bcId)
769 {
770 if (bcId < 0 || bcId >= BC_NUM_MAX || !g_bcManager[bcId].isUsed) {
771 DISC_LOGE(DISC_BROADCAST, "invalid param bcId=%{public}d", bcId);
772 return false;
773 }
774 return true;
775 }
776
UnRegisterBroadcaster(int32_t bcId)777 int32_t UnRegisterBroadcaster(int32_t bcId)
778 {
779 DISC_LOGI(DISC_BROADCAST, "enter unRegister bc");
780 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "bad id");
781 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId] != NULL, SOFTBUS_BC_MGR_NO_FUNC_REGISTERED,
782 DISC_BROADCAST, "interface is nullptr");
783 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId]->UnRegisterBroadcaster != NULL,
784 SOFTBUS_BC_MGR_FUNC_NULL, DISC_BROADCAST, "function is nullptr");
785
786 int32_t ret = SoftBusMutexLock(&g_bcLock);
787 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, DISC_BROADCAST, "mutex error");
788
789 if (!CheckBcIdIsValid(bcId)) {
790 DISC_LOGE(DISC_BROADCAST, "bcId is invalid");
791 SoftBusMutexUnlock(&g_bcLock);
792 return SOFTBUS_INVALID_PARAM;
793 }
794
795 if (g_bcManager[bcId].isAdvertising) {
796 SoftBusMutexUnlock(&g_bcLock);
797 (void)g_interface[g_interfaceId]->StopBroadcasting(g_bcManager[bcId].adapterBcId);
798 SoftBusMutexLock(&g_bcLock);
799 }
800 ret = g_interface[g_interfaceId]->UnRegisterBroadcaster(g_bcManager[bcId].adapterBcId);
801 if (ret != SOFTBUS_OK) {
802 DISC_LOGE(DISC_BROADCAST, "call from adapter failed");
803 SoftBusMutexUnlock(&g_bcLock);
804 return ret;
805 }
806
807 g_bcManager[bcId].srvType = -1;
808 g_bcManager[bcId].adapterBcId = -1;
809 g_bcManager[bcId].isUsed = false;
810 g_bcManager[bcId].isAdvertising = false;
811 g_bcManager[bcId].time = 0;
812 SoftBusCondDestroy(&g_bcManager[bcId].cond);
813 g_bcManager[bcId].bcCallback = NULL;
814
815 SoftBusMutexUnlock(&g_bcLock);
816 return SOFTBUS_OK;
817 }
818
RegisterScanListenerSub(BaseServiceType srvType,int32_t * adapterScanId,const ScanCallback * cb)819 static int32_t RegisterScanListenerSub(BaseServiceType srvType, int32_t *adapterScanId, const ScanCallback *cb)
820 {
821 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "bad id");
822 int32_t ret;
823
824 if (srvType == SRV_TYPE_LP_BURST || srvType == SRV_TYPE_LP_HB) {
825 if (g_isLpScanCbReg) {
826 *adapterScanId = g_adapterLpScannerId;
827 DISC_LOGE(DISC_BROADCAST, "service is already registered. srvType=%{public}s", GetSrvType(srvType));
828 return SOFTBUS_OK;
829 }
830 ret = g_interface[g_interfaceId]->RegisterScanListener(adapterScanId, &g_softbusBcBleScanCb);
831 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, DISC_BROADCAST, "call from adapter failed");
832
833 g_isLpScanCbReg = true;
834 g_adapterLpScannerId = *adapterScanId;
835 return SOFTBUS_OK;
836 }
837
838 if (g_isScanCbReg) {
839 *adapterScanId = g_adapterScannerId;
840 return SOFTBUS_OK;
841 }
842 DISC_LOGD(DISC_BROADCAST, "register scan listener");
843 ret = g_interface[g_interfaceId]->RegisterScanListener(adapterScanId, &g_softbusBcBleScanCb);
844 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, DISC_BROADCAST, "call from adapter failed");
845
846 g_isScanCbReg = true;
847 g_adapterScannerId = *adapterScanId;
848 return SOFTBUS_OK;
849 }
850
CheckSrvRegistered(BaseServiceType srvType)851 static bool CheckSrvRegistered(BaseServiceType srvType)
852 {
853 for (int32_t managerId = 0; managerId < SCAN_NUM_MAX; managerId++) {
854 if (!g_scanManager[managerId].isUsed) {
855 continue;
856 }
857 if (g_scanManager[managerId].srvType == srvType) {
858 DISC_LOGE(DISC_BROADCAST, "service is registered, srvType=%{public}s", GetSrvType(srvType));
859 return true;
860 }
861 }
862 return false;
863 }
864
RegisterScanListener(BaseServiceType srvType,int32_t * listenerId,const ScanCallback * cb)865 int32_t RegisterScanListener(BaseServiceType srvType, int32_t *listenerId, const ScanCallback *cb)
866 {
867 static uint32_t callCount = 0;
868 DISC_LOGD(DISC_BROADCAST, "enter callCount=%{public}u", callCount++);
869 int32_t ret = SOFTBUS_OK;
870 int32_t adapterScanId = -1;
871 DISC_CHECK_AND_RETURN_RET_LOGE(IsSrvTypeValid(srvType), SOFTBUS_BC_MGR_INVALID_SRV, DISC_BROADCAST, "bad srvType");
872 DISC_CHECK_AND_RETURN_RET_LOGE(listenerId != NULL, SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "invalid listenerId");
873 DISC_CHECK_AND_RETURN_RET_LOGE(cb != NULL, SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "invalid param cb");
874 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "bad id");
875 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId] != NULL, SOFTBUS_BC_MGR_NO_FUNC_REGISTERED,
876 DISC_BROADCAST, "interface is nullptr");
877 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId]->RegisterScanListener != NULL,
878 SOFTBUS_BC_MGR_FUNC_NULL, DISC_BROADCAST, "function is nullptr");
879 DISC_CHECK_AND_RETURN_RET_LOGE(!CheckSrvRegistered(srvType), SOFTBUS_BC_MGR_REG_DUP,
880 DISC_BROADCAST, "already registered");
881 ret = SoftBusMutexLock(&g_scanLock);
882 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, DISC_BROADCAST, "mutex error");
883
884 ret = RegisterScanListenerSub(srvType, &adapterScanId, cb);
885 if (ret != SOFTBUS_OK) {
886 SoftBusMutexUnlock(&g_scanLock);
887 DISC_LOGE(DISC_BROADCAST, "register listerner failed");
888 return ret;
889 }
890
891 int32_t managerId;
892 for (managerId = 0; managerId < SCAN_NUM_MAX; managerId++) {
893 if (!g_scanManager[managerId].isUsed) {
894 break;
895 }
896 }
897 if (managerId == SCAN_NUM_MAX) {
898 DISC_LOGE(DISC_BROADCAST, "no available scanner");
899 SoftBusMutexUnlock(&g_scanLock);
900 return SOFTBUS_BC_MGR_REG_NO_AVAILABLE_LISN_ID;
901 }
902 DISC_LOGI(DISC_BROADCAST, "srvType=%{public}s, listenerId=%{public}d, adapterScanId=%{public}d",
903 GetSrvType(srvType), managerId, adapterScanId);
904 *listenerId = managerId;
905 g_scanManager[managerId].srvType = srvType;
906 g_scanManager[managerId].adapterScanId = adapterScanId;
907 g_scanManager[managerId].isUsed = true;
908 g_scanManager[managerId].isNeedReset = true;
909 g_scanManager[managerId].isScanning = false;
910 g_scanManager[managerId].freq = SCAN_FREQ_LOW_POWER;
911 g_scanManager[managerId].scanCallback = (ScanCallback *)cb;
912
913 SoftBusMutexUnlock(&g_scanLock);
914 return SOFTBUS_OK;
915 }
916
CheckScanIdIsValid(int32_t listenerId)917 static bool CheckScanIdIsValid(int32_t listenerId)
918 {
919 if (listenerId < 0 || listenerId >= SCAN_NUM_MAX || !g_scanManager[listenerId].isUsed) {
920 DISC_LOGE(DISC_BROADCAST, "invalid param listenerId=%{public}d", listenerId);
921 return false;
922 }
923 return true;
924 }
925
ReleaseBcScanFilter(int listenerId)926 static void ReleaseBcScanFilter(int listenerId)
927 {
928 DISC_LOGD(DISC_BROADCAST, "enter release scan filter");
929 BcScanFilter *filter = g_scanManager[listenerId].filter;
930 if (filter == NULL) {
931 return;
932 }
933 uint8_t filterSize = g_scanManager[listenerId].filterSize;
934 while (filterSize-- > 0) {
935 SoftBusFree((filter + filterSize)->address);
936 SoftBusFree((filter + filterSize)->deviceName);
937 SoftBusFree((filter + filterSize)->serviceData);
938 SoftBusFree((filter + filterSize)->serviceDataMask);
939 SoftBusFree((filter + filterSize)->manufactureData);
940 SoftBusFree((filter + filterSize)->manufactureDataMask);
941 }
942 SoftBusFree(filter);
943 g_scanManager[listenerId].filterSize = 0;
944 g_scanManager[listenerId].filter = NULL;
945 }
946
CheckNeedUnRegisterScanListener(int32_t listenerId)947 static bool CheckNeedUnRegisterScanListener(int32_t listenerId)
948 {
949 int32_t adapterScanId = g_scanManager[listenerId].adapterScanId;
950 for (int32_t managerId = 0; managerId < SCAN_NUM_MAX; managerId++) {
951 if (managerId != listenerId && g_scanManager[managerId].adapterScanId == adapterScanId &&
952 g_scanManager[managerId].isScanning) {
953 return false;
954 }
955 }
956 return true;
957 }
958
CheckNeedUpdateScan(int32_t listenerId,int32_t * liveListenerId)959 static bool CheckNeedUpdateScan(int32_t listenerId, int32_t *liveListenerId)
960 {
961 int32_t adapterScanId = g_scanManager[listenerId].adapterScanId;
962 for (int32_t managerId = 0; managerId < SCAN_NUM_MAX; managerId++) {
963 if (managerId != listenerId && g_scanManager[managerId].adapterScanId == adapterScanId &&
964 g_scanManager[managerId].isScanning) {
965 *liveListenerId = managerId;
966 return true;
967 }
968 }
969 return false;
970 }
971
CopySoftBusBcScanFilter(const BcScanFilter * srcFilter,SoftBusBcScanFilter * dstFilter)972 static int32_t CopySoftBusBcScanFilter(const BcScanFilter *srcFilter, SoftBusBcScanFilter *dstFilter)
973 {
974 if (srcFilter->address != NULL) {
975 uint32_t addressLength = strlen((char *)srcFilter->address) + 1;
976 dstFilter->address = (int8_t *)SoftBusCalloc(addressLength);
977 DISC_CHECK_AND_RETURN_RET_LOGE(dstFilter->address != NULL &&
978 memcpy_s(dstFilter->address, addressLength, srcFilter->address, addressLength) == EOK,
979 SOFTBUS_MEM_ERR, DISC_BROADCAST, "copy filter address failed");
980 }
981
982 if (srcFilter->deviceName != NULL) {
983 uint32_t deviceNameLength = strlen((char *)srcFilter->deviceName) + 1;
984 dstFilter->deviceName = (int8_t *)SoftBusCalloc(deviceNameLength);
985 DISC_CHECK_AND_RETURN_RET_LOGE(dstFilter->deviceName != NULL &&
986 memcpy_s(dstFilter->deviceName, deviceNameLength, srcFilter->deviceName, deviceNameLength) == EOK,
987 SOFTBUS_MEM_ERR, DISC_BROADCAST, "copy filter deviceName failed");
988 }
989
990 dstFilter->serviceUuid = srcFilter->serviceUuid;
991 dstFilter->serviceDataLength = srcFilter->serviceDataLength;
992 if (srcFilter->serviceData != NULL && srcFilter->serviceDataLength > 0) {
993 dstFilter->serviceData = (uint8_t *)SoftBusCalloc(dstFilter->serviceDataLength);
994 DISC_CHECK_AND_RETURN_RET_LOGE(dstFilter->serviceData != NULL &&
995 memcpy_s(dstFilter->serviceData, dstFilter->serviceDataLength,
996 srcFilter->serviceData, srcFilter->serviceDataLength) == EOK,
997 SOFTBUS_MEM_ERR, DISC_BROADCAST, "copy filter serviceData failed");
998 }
999 if (srcFilter->serviceDataMask != NULL && srcFilter->serviceDataLength > 0) {
1000 dstFilter->serviceDataMask = (uint8_t *)SoftBusCalloc(dstFilter->serviceDataLength);
1001 DISC_CHECK_AND_RETURN_RET_LOGE(dstFilter->serviceDataMask != NULL &&
1002 memcpy_s(dstFilter->serviceDataMask, dstFilter->serviceDataLength,
1003 srcFilter->serviceDataMask, srcFilter->serviceDataLength) == EOK,
1004 SOFTBUS_MEM_ERR, DISC_BROADCAST, "copy filter serviceDataMask failed");
1005 }
1006
1007 dstFilter->manufactureId = srcFilter->manufactureId;
1008 dstFilter->manufactureDataLength = srcFilter->manufactureDataLength;
1009 if (srcFilter->manufactureData != NULL && srcFilter->manufactureDataLength > 0) {
1010 dstFilter->manufactureData = (uint8_t *)SoftBusCalloc(dstFilter->manufactureDataLength);
1011 DISC_CHECK_AND_RETURN_RET_LOGE(dstFilter->manufactureData != NULL &&
1012 memcpy_s(dstFilter->manufactureData, dstFilter->manufactureDataLength,
1013 srcFilter->manufactureData, srcFilter->manufactureDataLength) == EOK,
1014 SOFTBUS_MEM_ERR, DISC_BROADCAST, "copy filter manufactureData failed");
1015 }
1016 if (srcFilter->manufactureDataMask != NULL && srcFilter->manufactureDataLength > 0) {
1017 dstFilter->manufactureDataMask = (uint8_t *)SoftBusCalloc(dstFilter->manufactureDataLength);
1018 DISC_CHECK_AND_RETURN_RET_LOGE(dstFilter->manufactureDataMask != NULL &&
1019 memcpy_s(dstFilter->manufactureDataMask, dstFilter->manufactureDataLength,
1020 srcFilter->manufactureDataMask, srcFilter->manufactureDataLength) == EOK,
1021 SOFTBUS_MEM_ERR, DISC_BROADCAST, "copy filter manufactureDataMask failed");
1022 }
1023
1024 dstFilter->advIndReport = srcFilter->advIndReport;
1025 return SOFTBUS_OK;
1026 }
1027
CovertSoftBusBcScanFilters(const BcScanFilter * filter,uint8_t size,SoftBusBcScanFilter * adapterFilter)1028 static int32_t CovertSoftBusBcScanFilters(const BcScanFilter *filter, uint8_t size, SoftBusBcScanFilter *adapterFilter)
1029 {
1030 while (size-- > 0) {
1031 int32_t ret = CopySoftBusBcScanFilter(filter + size, adapterFilter + size);
1032 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, DISC_BROADCAST, "copy filter failed");
1033 }
1034 return SOFTBUS_OK;
1035 }
1036
ReleaseSoftBusBcScanFilter(SoftBusBcScanFilter * filter,int32_t size)1037 static void ReleaseSoftBusBcScanFilter(SoftBusBcScanFilter *filter, int32_t size)
1038 {
1039 if (filter != NULL) {
1040 while (size-- > 0) {
1041 if ((filter + size)->address != NULL) {
1042 SoftBusFree((filter + size)->address);
1043 }
1044 if ((filter + size)->deviceName != NULL) {
1045 SoftBusFree((filter + size)->deviceName);
1046 }
1047 if ((filter + size)->serviceData != NULL) {
1048 SoftBusFree((filter + size)->serviceData);
1049 }
1050 if ((filter + size)->serviceDataMask != NULL) {
1051 SoftBusFree((filter + size)->serviceDataMask);
1052 }
1053 if ((filter + size)->manufactureData != NULL) {
1054 SoftBusFree((filter + size)->manufactureData);
1055 }
1056 if ((filter + size)->manufactureDataMask != NULL) {
1057 SoftBusFree((filter + size)->manufactureDataMask);
1058 }
1059 }
1060 SoftBusFree(filter);
1061 }
1062 }
1063
CombineSoftbusBcScanFilters(int32_t listenerId,SoftBusBcScanFilter ** adapterFilter,int32_t * filterSize)1064 static int32_t CombineSoftbusBcScanFilters(int32_t listenerId, SoftBusBcScanFilter **adapterFilter, int32_t *filterSize)
1065 {
1066 DISC_LOGD(DISC_BROADCAST, "enter combine scan filters");
1067 uint8_t size = 0;
1068 for (int32_t managerId = 0; managerId < SCAN_NUM_MAX; managerId++) {
1069 ScanManager *scanManager = &g_scanManager[managerId];
1070 if (!scanManager->isUsed || (!scanManager->isScanning && managerId != listenerId) ||
1071 scanManager->adapterScanId != g_scanManager[listenerId].adapterScanId) {
1072 continue;
1073 }
1074
1075 size += scanManager->filterSize;
1076 }
1077 *adapterFilter = (SoftBusBcScanFilter *)SoftBusCalloc(sizeof(SoftBusBcScanFilter) * size);
1078 DISC_CHECK_AND_RETURN_RET_LOGE(*adapterFilter != NULL, SOFTBUS_MALLOC_ERR, DISC_BROADCAST, "malloc failed");
1079 *filterSize = size;
1080
1081 for (int32_t managerId = 0; managerId < SCAN_NUM_MAX; managerId++) {
1082 ScanManager *scanManager = &g_scanManager[managerId];
1083 if (!scanManager->isUsed || (!scanManager->isScanning && managerId != listenerId) ||
1084 scanManager->adapterScanId != g_scanManager[listenerId].adapterScanId) {
1085 continue;
1086 }
1087
1088 uint8_t currentSize = g_scanManager[managerId].filterSize;
1089 BcScanFilter *filter = g_scanManager[managerId].filter;
1090 size = size - currentSize;
1091 int32_t ret = CovertSoftBusBcScanFilters(filter, currentSize, *adapterFilter + size);
1092 if (ret != SOFTBUS_OK) {
1093 ReleaseSoftBusBcScanFilter(*adapterFilter, size);
1094 DISC_LOGE(DISC_BROADCAST, "convert bc scan filters failed");
1095 return ret;
1096 }
1097 }
1098 return SOFTBUS_OK;
1099 }
1100
GetBcScanFilters(int32_t listenerId,SoftBusBcScanFilter ** adapterFilter,int32_t * filterSize)1101 static int32_t GetBcScanFilters(int32_t listenerId, SoftBusBcScanFilter **adapterFilter, int32_t *filterSize)
1102 {
1103 return CombineSoftbusBcScanFilters(listenerId, adapterFilter, filterSize);
1104 }
1105
DumpBcScanFilter(const SoftBusBcScanFilter * nativeFilter,uint8_t filterSize)1106 static void DumpBcScanFilter(const SoftBusBcScanFilter *nativeFilter, uint8_t filterSize)
1107 {
1108 DISC_CHECK_AND_RETURN_LOGE(nativeFilter != NULL, DISC_BROADCAST, "invalid param nativeFilter");
1109 DISC_CHECK_AND_RETURN_LOGE(filterSize != 0, DISC_BROADCAST, "filterSize is 0");
1110
1111 while (filterSize-- > 0) {
1112 int32_t len = (nativeFilter + filterSize)->serviceDataLength;
1113 if (len > 0) {
1114 DumpSoftbusData("service data", len, (nativeFilter + filterSize)->serviceData);
1115 DumpSoftbusData("service dataMask", len, (nativeFilter + filterSize)->serviceDataMask);
1116 } else {
1117 len = (nativeFilter + filterSize)->manufactureDataLength;
1118 if (len <= 0) {
1119 continue;
1120 }
1121 DumpSoftbusData("manufacture data", len, (nativeFilter + filterSize)->manufactureData);
1122 DumpSoftbusData("manufacture dataMask", len, (nativeFilter + filterSize)->manufactureDataMask);
1123 }
1124 }
1125 }
1126
BuildSoftBusBcScanParams(const BcScanParams * param,SoftBusBcScanParams * adapterParam)1127 static void BuildSoftBusBcScanParams(const BcScanParams *param, SoftBusBcScanParams *adapterParam)
1128 {
1129 DISC_LOGD(DISC_BROADCAST, "enter scan param");
1130 (void)memset_s(adapterParam, sizeof(SoftBusBcScanParams), 0x0, sizeof(SoftBusBcScanParams));
1131
1132 // convert params
1133 adapterParam->scanInterval = param->scanInterval;
1134 adapterParam->scanWindow = param->scanWindow;
1135 adapterParam->scanType = param->scanType;
1136 adapterParam->scanPhy = param->scanPhy;
1137 adapterParam->scanFilterPolicy = param->scanFilterPolicy;
1138 }
1139
GetScanIntervalAndWindow(int32_t freq,SoftBusBcScanParams * adapterParam)1140 static void GetScanIntervalAndWindow(int32_t freq, SoftBusBcScanParams *adapterParam)
1141 {
1142 if (freq == SCAN_FREQ_P2_60_3000) {
1143 adapterParam->scanInterval = SOFTBUS_BC_SCAN_INTERVAL_P2;
1144 adapterParam->scanWindow = SOFTBUS_BC_SCAN_WINDOW_P2;
1145 }
1146 if (freq == SCAN_FREQ_P2_30_1500) {
1147 adapterParam->scanInterval = SOFTBUS_BC_SCAN_INTERVAL_P2_FAST;
1148 adapterParam->scanWindow = SOFTBUS_BC_SCAN_WINDOW_P2_FAST;
1149 }
1150 if (freq == SCAN_FREQ_P10_30_300) {
1151 adapterParam->scanInterval = SOFTBUS_BC_SCAN_INTERVAL_P10;
1152 adapterParam->scanWindow = SOFTBUS_BC_SCAN_WINDOW_P10;
1153 }
1154 if (freq == SCAN_FREQ_P25_60_240) {
1155 adapterParam->scanInterval = SOFTBUS_BC_SCAN_INTERVAL_P25;
1156 adapterParam->scanWindow = SOFTBUS_BC_SCAN_WINDOW_P25;
1157 }
1158 if (freq == SCAN_FREQ_P50_30_60) {
1159 adapterParam->scanInterval = SOFTBUS_BC_SCAN_INTERVAL_P50;
1160 adapterParam->scanWindow = SOFTBUS_BC_SCAN_WINDOW_P50;
1161 }
1162 if (freq == SCAN_FREQ_P75_30_40) {
1163 adapterParam->scanInterval = SOFTBUS_BC_SCAN_INTERVAL_P75;
1164 adapterParam->scanWindow = SOFTBUS_BC_SCAN_WINDOW_P75;
1165 }
1166 if (freq == SCAN_FREQ_P100_1000_1000) {
1167 adapterParam->scanInterval = SOFTBUS_BC_SCAN_INTERVAL_P100;
1168 adapterParam->scanWindow = SOFTBUS_BC_SCAN_WINDOW_P100;
1169 }
1170 }
1171
CheckScanFreq(int32_t listenerId,SoftBusBcScanParams * adapterParam)1172 static void CheckScanFreq(int32_t listenerId, SoftBusBcScanParams *adapterParam)
1173 {
1174 static int32_t scanFreq = SCAN_FREQ_LOW_POWER;
1175 static int32_t scanLpFreq = SCAN_FREQ_LOW_POWER;
1176
1177 int32_t adapterScanId = g_scanManager[listenerId].adapterScanId;
1178 int32_t maxFreq = g_scanManager[listenerId].freq;
1179
1180 if (adapterScanId == g_adapterLpScannerId) {
1181 if (maxFreq != scanLpFreq) {
1182 DISC_LOGD(DISC_BROADCAST, "lp freq need to update");
1183 scanLpFreq = maxFreq;
1184 // Need to reset scanner when frequency changed.
1185 g_scanManager[listenerId].isNeedReset = true;
1186 }
1187 return;
1188 }
1189
1190 for (uint32_t managerId = 0; managerId < SCAN_NUM_MAX; managerId++) {
1191 ScanManager *scanManager = &g_scanManager[managerId];
1192 if (!scanManager->isUsed || !scanManager->isScanning || scanManager->adapterScanId != adapterScanId) {
1193 continue;
1194 }
1195 maxFreq = (maxFreq > (int32_t)(scanManager->freq)) ? maxFreq : (int32_t)(scanManager->freq);
1196 }
1197 if (scanFreq != maxFreq) {
1198 // Need to reset scanner when frequency changed.
1199 g_scanManager[listenerId].isNeedReset = true;
1200 scanFreq = maxFreq;
1201 DISC_LOGD(DISC_BROADCAST, "need to update");
1202 }
1203 GetScanIntervalAndWindow(scanFreq, adapterParam);
1204 }
1205
CheckAndStopScan(int32_t listenerId)1206 static int32_t CheckAndStopScan(int32_t listenerId)
1207 {
1208 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "bad id");
1209 int32_t liveListenerId = -1;
1210 int32_t ret;
1211 bool needUpdate = CheckNeedUpdateScan(listenerId, &liveListenerId);
1212 if (!needUpdate) {
1213 DISC_LOGI(DISC_BROADCAST, "call stop scan, adapterId=%{public}d", g_scanManager[listenerId].adapterScanId);
1214 ret = g_interface[g_interfaceId]->StopScan(g_scanManager[listenerId].adapterScanId);
1215 if (ret != SOFTBUS_OK) {
1216 g_scanManager[listenerId].scanCallback->OnStopScanCallback(listenerId, (int32_t)SOFTBUS_BC_STATUS_FAIL);
1217 DISC_LOGE(DISC_BROADCAST, "call from adapter failed");
1218 return ret;
1219 }
1220 } else {
1221 int32_t filterSize = 0;
1222 SoftBusBcScanFilter *adapterFilter = NULL;
1223 g_scanManager[listenerId].isScanning = false;
1224 ret = GetBcScanFilters(liveListenerId, &adapterFilter, &filterSize);
1225 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, DISC_BROADCAST, "get bc scan filters failed");
1226 DumpBcScanFilter(adapterFilter, filterSize);
1227 SoftBusBcScanParams adapterParam;
1228 BuildSoftBusBcScanParams(&(g_scanManager[listenerId].param), &adapterParam);
1229 CheckScanFreq(liveListenerId, &adapterParam);
1230 ret = g_interface[g_interfaceId]->StopScan(g_scanManager[listenerId].adapterScanId);
1231 if (ret != SOFTBUS_OK) {
1232 g_scanManager[listenerId].scanCallback->OnStopScanCallback(listenerId, (int32_t)SOFTBUS_BC_STATUS_FAIL);
1233 DISC_LOGE(DISC_BROADCAST, "call from adapter failed");
1234 ReleaseSoftBusBcScanFilter(adapterFilter, filterSize);
1235 return ret;
1236 }
1237 DISC_LOGI(DISC_BROADCAST, "start scan adapterId=%{public}d, interval=%{public}hu, window=%{public}hu",
1238 g_scanManager[listenerId].adapterScanId, adapterParam.scanInterval, adapterParam.scanWindow);
1239 ret = g_interface[g_interfaceId]->StartScan(g_scanManager[listenerId].adapterScanId, &adapterParam,
1240 adapterFilter, filterSize);
1241 ReleaseSoftBusBcScanFilter(adapterFilter, filterSize);
1242 if (ret != SOFTBUS_OK) {
1243 g_scanManager[listenerId].scanCallback->OnStartScanCallback(listenerId, (int32_t)SOFTBUS_BC_STATUS_FAIL);
1244 DISC_LOGE(DISC_BROADCAST, "call from adapter failed");
1245 return ret;
1246 }
1247 }
1248 return SOFTBUS_OK;
1249 }
1250
UnRegisterScanListener(int32_t listenerId)1251 int32_t UnRegisterScanListener(int32_t listenerId)
1252 {
1253 DISC_LOGI(DISC_BROADCAST, "enter unregister scan, listenerId=%{public}d", listenerId);
1254 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "bad id");
1255 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId] != NULL, SOFTBUS_BC_MGR_NO_FUNC_REGISTERED,
1256 DISC_BROADCAST, "interface is nullptr");
1257 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId]->UnRegisterScanListener != NULL,
1258 SOFTBUS_BC_MGR_FUNC_NULL, DISC_BROADCAST, "function is nullptr");
1259 int32_t ret = SoftBusMutexLock(&g_scanLock);
1260 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, DISC_BROADCAST, "mutex error");
1261 if (!CheckScanIdIsValid(listenerId)) {
1262 SoftBusMutexUnlock(&g_scanLock);
1263 return SOFTBUS_INVALID_PARAM;
1264 }
1265 int32_t adapterScanId = g_scanManager[listenerId].adapterScanId;
1266 if (g_scanManager[listenerId].isScanning) {
1267 ret = CheckAndStopScan(listenerId);
1268 if (ret != SOFTBUS_OK) {
1269 DISC_LOGE(DISC_BROADCAST, "stop scan failed");
1270 SoftBusMutexUnlock(&g_scanLock);
1271 return ret;
1272 }
1273 }
1274 if (CheckNeedUnRegisterScanListener(listenerId)) {
1275 if (adapterScanId == g_adapterLpScannerId) {
1276 g_isLpScanCbReg = false;
1277 g_adapterLpScannerId = -1;
1278 }
1279 if (adapterScanId == g_adapterScannerId) {
1280 g_isScanCbReg = false;
1281 g_adapterScannerId = -1;
1282 }
1283 ret = g_interface[g_interfaceId]->UnRegisterScanListener(adapterScanId);
1284 if (ret != SOFTBUS_OK) {
1285 DISC_LOGE(DISC_BROADCAST, "call from adapter failed");
1286 SoftBusMutexUnlock(&g_scanLock);
1287 return ret;
1288 }
1289 }
1290 DISC_LOGD(DISC_BROADCAST, "srvType=%{public}s", GetSrvType(g_scanManager[listenerId].srvType));
1291 ReleaseBcScanFilter(listenerId);
1292 g_scanManager[listenerId].srvType = -1;
1293 g_scanManager[listenerId].adapterScanId = -1;
1294 g_scanManager[listenerId].isUsed = false;
1295 g_scanManager[listenerId].isNeedReset = true;
1296 g_scanManager[listenerId].freq = SCAN_FREQ_LOW_POWER;
1297 g_scanManager[listenerId].scanCallback = NULL;
1298 g_scanManager[listenerId].isScanning = false;
1299 SoftBusMutexUnlock(&g_scanLock);
1300 return SOFTBUS_OK;
1301 }
1302
ConvertBcParams(const BroadcastParam * srcParam,SoftbusBroadcastParam * dstParam)1303 static void ConvertBcParams(const BroadcastParam *srcParam, SoftbusBroadcastParam *dstParam)
1304 {
1305 DISC_LOGD(DISC_BROADCAST, "enter covert bc param");
1306 dstParam->minInterval = srcParam->minInterval;
1307 dstParam->maxInterval = srcParam->maxInterval;
1308 dstParam->advType = srcParam->advType;
1309 dstParam->advFilterPolicy = srcParam->advFilterPolicy;
1310 dstParam->ownAddrType = srcParam->ownAddrType;
1311 dstParam->peerAddrType = srcParam->peerAddrType;
1312 if (memcpy_s(dstParam->peerAddr.addr, SOFTBUS_ADDR_MAC_LEN, srcParam->peerAddr.addr, BC_ADDR_MAC_LEN) != EOK) {
1313 DISC_LOGE(DISC_BROADCAST, "memcpy peerAddr failed");
1314 return;
1315 }
1316 dstParam->channelMap = srcParam->channelMap;
1317 dstParam->duration = srcParam->duration;
1318 dstParam->txPower = srcParam->txPower;
1319 dstParam->isSupportRpa = srcParam->isSupportRpa;
1320 if (memcpy_s(dstParam->ownIrk, SOFTBUS_IRK_LEN, srcParam->ownIrk, BC_IRK_LEN) != EOK) {
1321 DISC_LOGE(DISC_BROADCAST, "memcpy ownIrk failed");
1322 return;
1323 }
1324 if (memcpy_s(dstParam->ownUdidHash, SOFTBUS_UDID_HASH_LEN, srcParam->ownUdidHash, BC_UDID_HASH_LEN) != EOK) {
1325 DISC_LOGE(DISC_BROADCAST, "memcpy ownUdidHash failed");
1326 return;
1327 }
1328 if (memcpy_s(dstParam->localAddr.addr, BC_ADDR_MAC_LEN, srcParam->localAddr.addr,
1329 BC_ADDR_MAC_LEN) != EOK) {
1330 DISC_LOGE(DISC_BROADCAST, "memcpy localAddr failed");
1331 return;
1332 }
1333 }
1334
DumpBroadcastPacket(const BroadcastPayload * bcData,const BroadcastPayload * rspData)1335 static void DumpBroadcastPacket(const BroadcastPayload *bcData, const BroadcastPayload *rspData)
1336 {
1337 DumpSoftbusData("BroadcastPayload bcData", bcData->payloadLen, bcData->payload);
1338 DumpSoftbusData("BroadcastPayload rspData", rspData->payloadLen, rspData->payload);
1339 }
1340
SoftBusCondWaitSec(int64_t sec,int32_t bcId,SoftBusMutex * mutex)1341 static int32_t SoftBusCondWaitSec(int64_t sec, int32_t bcId, SoftBusMutex *mutex)
1342 {
1343 SoftBusSysTime absTime = {0};
1344 int32_t ret = SoftBusGetTime(&absTime);
1345 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, DISC_BROADCAST, "softbus get time failed");
1346
1347 absTime.sec += sec;
1348 if (SoftBusCondWait(&g_bcManager[bcId].cond, mutex, &absTime) != SOFTBUS_OK) {
1349 DISC_LOGE(DISC_BROADCAST, "wait timeout");
1350 return SOFTBUS_TIMOUT;
1351 }
1352 return SOFTBUS_OK;
1353 }
1354
BuildSoftbusBcPayload(int32_t maxPayloadLen,const BroadcastPayload * srcData,SoftbusBroadcastPayload * dstData)1355 static int32_t BuildSoftbusBcPayload(int32_t maxPayloadLen, const BroadcastPayload *srcData,
1356 SoftbusBroadcastPayload *dstData)
1357 {
1358 dstData->type = (SoftbusBcDataType)srcData->type;
1359 dstData->id = srcData->id;
1360 dstData->payloadLen = srcData->payloadLen;
1361 if (srcData->payloadLen > maxPayloadLen) {
1362 DISC_LOGW(DISC_BROADCAST, "payloadLen is too long! payloadLen=%{public}d", srcData->payloadLen);
1363 }
1364 int32_t bcDataLen = (srcData->payloadLen > maxPayloadLen) ? maxPayloadLen : srcData->payloadLen;
1365
1366 dstData->payload = (uint8_t *)SoftBusCalloc(bcDataLen);
1367 DISC_CHECK_AND_RETURN_RET_LOGE(dstData->payload != NULL, SOFTBUS_MALLOC_ERR, DISC_BROADCAST, "malloc failed");
1368
1369 if (memcpy_s(dstData->payload, bcDataLen, srcData->payload, bcDataLen) != EOK) {
1370 DISC_LOGE(DISC_BROADCAST, "memcpy_s error");
1371 SoftBusFree(dstData->payload);
1372 return SOFTBUS_MEM_ERR;
1373 }
1374 return SOFTBUS_OK;
1375 }
1376
ReleaseSoftbusBroadcastData(SoftbusBroadcastData * softbusBcData)1377 static void ReleaseSoftbusBroadcastData(SoftbusBroadcastData *softbusBcData)
1378 {
1379 DISC_LOGD(DISC_BROADCAST, "enter release bc data");
1380 SoftBusFree(softbusBcData->bcData.payload);
1381 SoftBusFree(softbusBcData->rspData.payload);
1382 }
1383
BuildSoftbusBroadcastData(const BroadcastPacket * packet,SoftbusBroadcastData * softbusBcData)1384 static int32_t BuildSoftbusBroadcastData(const BroadcastPacket *packet, SoftbusBroadcastData *softbusBcData)
1385 {
1386 softbusBcData->isSupportFlag = packet->isSupportFlag;
1387 softbusBcData->flag = packet->flag;
1388
1389 // 1. Build broadcast paylod.
1390 int32_t maxPayloadLen = (packet->isSupportFlag) ? BC_DATA_MAX_LEN : (BC_DATA_MAX_LEN + BC_FLAG_LEN);
1391 int32_t ret = BuildSoftbusBcPayload(maxPayloadLen, &(packet->bcData), &(softbusBcData->bcData));
1392 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, DISC_BROADCAST, "BuildSoftbusBcPayload failed");
1393
1394 // 2. Build response broadcast paylod.
1395 if (packet->rspData.payload != NULL) {
1396 maxPayloadLen = RSP_DATA_MAX_LEN;
1397 ret = BuildSoftbusBcPayload(maxPayloadLen, &(packet->rspData), &(softbusBcData->rspData));
1398 if (ret != SOFTBUS_OK) {
1399 DISC_LOGE(DISC_BROADCAST, "convert rspData failed");
1400 SoftBusFree(softbusBcData->bcData.payload);
1401 return ret;
1402 }
1403 } else {
1404 softbusBcData->rspData.payload = NULL;
1405 softbusBcData->rspData.payloadLen = 0;
1406 }
1407 return SOFTBUS_OK;
1408 }
1409
MgrGetSysTime(void)1410 static int64_t MgrGetSysTime(void)
1411 {
1412 SoftBusSysTime absTime = {0};
1413 SoftBusGetTime(&absTime);
1414 int64_t time = absTime.sec * MGR_TIME_THOUSAND_MULTIPLIER * MGR_TIME_THOUSAND_MULTIPLIER + absTime.usec;
1415 return time;
1416 }
1417
StartBroadcastingWaitSignal(int32_t bcId,SoftBusMutex * mutex)1418 static void StartBroadcastingWaitSignal(int32_t bcId, SoftBusMutex *mutex)
1419 {
1420 DISC_CHECK_AND_RETURN_LOGE(mutex != NULL, DISC_BROADCAST, "invalid param");
1421 DISC_CHECK_AND_RETURN_LOGE(CheckMediumIsValid(g_interfaceId), DISC_BROADCAST, "bad id");
1422 if (SoftBusCondWaitSec(BC_WAIT_TIME_SEC, bcId, mutex) == SOFTBUS_OK) {
1423 return;
1424 }
1425 DISC_LOGW(DISC_BROADCAST, "wait signal failed, srvType=%{public}s, bcId=%{public}d, adapterId=%{public}d,"
1426 "call StopBroadcast", GetSrvType(g_bcManager[bcId].srvType), bcId, g_bcManager[bcId].adapterBcId);
1427 SoftBusMutexUnlock(mutex);
1428 int32_t ret = g_interface[g_interfaceId]->StopBroadcasting(g_bcManager[bcId].adapterBcId);
1429 DISC_LOGW(DISC_BROADCAST, "StopBroadcasting ret=%{public}d", ret);
1430 DISC_CHECK_AND_RETURN_LOGE(SoftBusMutexLock(mutex) == SOFTBUS_OK, DISC_BROADCAST, "bcLock mutex error");
1431 ret = SoftBusCondWaitSec(BC_WAIT_TIME_SEC, bcId, mutex);
1432 DISC_LOGW(DISC_BROADCAST, "wait signal ret=%{public}d", ret);
1433 g_bcManager[bcId].isAdvertising = false;
1434 }
1435
CheckInterface(bool isStart)1436 static int32_t CheckInterface(bool isStart)
1437 {
1438 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "bad id");
1439 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId] != NULL, SOFTBUS_BC_MGR_NO_FUNC_REGISTERED,
1440 DISC_BROADCAST, "interface is nullptr");
1441 if (isStart) {
1442 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId]->StartBroadcasting != NULL,
1443 SOFTBUS_BC_MGR_FUNC_NULL, DISC_BROADCAST, "function is nullptr");
1444 } else {
1445 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId]->StopBroadcasting != NULL,
1446 SOFTBUS_BC_MGR_FUNC_NULL, DISC_BROADCAST, "function is nullptr");
1447 }
1448 return SOFTBUS_OK;
1449 }
1450
StartBroadcasting(int32_t bcId,const BroadcastParam * param,const BroadcastPacket * packet)1451 int32_t StartBroadcasting(int32_t bcId, const BroadcastParam *param, const BroadcastPacket *packet)
1452 {
1453 static uint32_t callCount = 0;
1454 int32_t ret = CheckInterface(true);
1455 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
1456 DISC_BROADCAST, "interface check failed, bcId=%{public}d", bcId);
1457 ret = CheckBroadcastingParam(param, packet);
1458 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, DISC_BROADCAST, "check param failed");
1459 ret = SoftBusMutexLock(&g_bcLock);
1460 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, DISC_BROADCAST,
1461 "mutex error, bcId=%{public}d", bcId);
1462 if (!CheckBcIdIsValid(bcId) || g_bcManager[bcId].bcCallback == NULL ||
1463 g_bcManager[bcId].bcCallback->OnStartBroadcastingCallback == NULL) {
1464 SoftBusMutexUnlock(&g_bcLock);
1465 DISC_LOGE(DISC_BROADCAST, "invalid bcId, bcId=%{public}d", bcId);
1466 return SOFTBUS_BC_MGR_INVALID_BC_ID;
1467 }
1468 if (g_bcManager[bcId].isAdvertising && !g_bcManager[bcId].isStarted) {
1469 DISC_LOGW(DISC_BROADCAST, "wait condition managerId=%{public}d", bcId);
1470 StartBroadcastingWaitSignal(bcId, &g_bcLock);
1471 }
1472
1473 DumpBroadcastPacket(&(packet->bcData), &(packet->rspData));
1474 SoftbusBroadcastData softbusBcData = {0};
1475 ret = BuildSoftbusBroadcastData(packet, &softbusBcData);
1476 if (ret != SOFTBUS_OK) {
1477 DISC_LOGE(DISC_BROADCAST, "build SoftbusBroadcastData failed, bcId=%{public}d", bcId);
1478 SoftBusMutexUnlock(&g_bcLock);
1479 return ret;
1480 }
1481 SoftbusBroadcastParam adapterParam;
1482 ConvertBcParams(param, &adapterParam);
1483 DISC_LOGI(DISC_BROADCAST, "start service srvType=%{public}s, bcId=%{public}d, adapterId=%{public}d,"
1484 "callCount=%{public}u", GetSrvType(g_bcManager[bcId].srvType), bcId,
1485 g_bcManager[bcId].adapterBcId, callCount++);
1486 BroadcastCallback callback = *(g_bcManager[bcId].bcCallback);
1487 SoftBusMutexUnlock(&g_bcLock);
1488 ret = g_interface[g_interfaceId]->StartBroadcasting(g_bcManager[bcId].adapterBcId, &adapterParam, &softbusBcData);
1489 g_bcManager[bcId].time = MgrGetSysTime();
1490 if (ret != SOFTBUS_OK) {
1491 callback.OnStartBroadcastingCallback(bcId, (int32_t)SOFTBUS_BC_STATUS_FAIL);
1492 DISC_LOGE(DISC_BROADCAST, "call from adapter failed");
1493 ReleaseSoftbusBroadcastData(&softbusBcData);
1494 return ret;
1495 }
1496
1497 ret = SoftBusMutexLock(&g_bcLock);
1498 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, DISC_BROADCAST, "lock failed");
1499 g_bcManager[bcId].isStarted = true;
1500 SoftBusMutexUnlock(&g_bcLock);
1501 ReleaseSoftbusBroadcastData(&softbusBcData);
1502 return SOFTBUS_OK;
1503 }
1504
UpdateBroadcasting(int32_t bcId,const BroadcastParam * param,const BroadcastPacket * packet)1505 int32_t UpdateBroadcasting(int32_t bcId, const BroadcastParam *param, const BroadcastPacket *packet)
1506 {
1507 DISC_LOGI(DISC_BROADCAST, "enter update bc");
1508 DISC_CHECK_AND_RETURN_RET_LOGE(param != NULL, SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "invald param");
1509 DISC_CHECK_AND_RETURN_RET_LOGE(packet != NULL, SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "invald param packet");
1510
1511 int ret = StopBroadcasting(bcId);
1512 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, DISC_BROADCAST, "StopBroadcasting failed");
1513
1514 return StartBroadcasting(bcId, param, packet);
1515 }
1516
SetBroadcastingData(int32_t bcId,const BroadcastPacket * packet)1517 int32_t SetBroadcastingData(int32_t bcId, const BroadcastPacket *packet)
1518 {
1519 static uint32_t callCount = 0;
1520 DISC_LOGI(DISC_BROADCAST, "enter set bc data, bcId=%{public}d, callCount=%{public}u", bcId, callCount++);
1521 DISC_CHECK_AND_RETURN_RET_LOGE(packet != NULL, SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "invalid param packet");
1522 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "bad id");
1523 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId] != NULL, SOFTBUS_BC_MGR_NO_FUNC_REGISTERED,
1524 DISC_BROADCAST, "interface is nullptr");
1525 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId]->SetBroadcastingData != NULL,
1526 SOFTBUS_BC_MGR_FUNC_NULL, DISC_BROADCAST, "function is nullptr");
1527
1528 int32_t ret = SoftBusMutexLock(&g_bcLock);
1529 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, DISC_BROADCAST, "mutex error");
1530
1531 if (!CheckBcIdIsValid(bcId) || g_bcManager[bcId].bcCallback == NULL ||
1532 g_bcManager[bcId].bcCallback->OnSetBroadcastingCallback == NULL) {
1533 SoftBusMutexUnlock(&g_bcLock);
1534 return SOFTBUS_BC_MGR_INVALID_BC_ID;
1535 }
1536
1537 if (!g_bcManager[bcId].isAdvertising) {
1538 DISC_LOGW(DISC_BROADCAST, "bcId=%{public}d is not advertising", bcId);
1539 SoftBusMutexUnlock(&g_bcLock);
1540 return SOFTBUS_BC_MGR_NOT_BROADCASTING;
1541 }
1542 DISC_LOGI(DISC_BROADCAST, "replace BroadcastPacket srvType=%{public}s, bcId=%{public}d, adapterId=%{public}d,"
1543 "callCount=%{public}u", GetSrvType(g_bcManager[bcId].srvType), bcId, g_bcManager[bcId].adapterBcId,
1544 callCount++);
1545 SoftbusBroadcastData softbusBcData = {0};
1546 ret = BuildSoftbusBroadcastData(packet, &softbusBcData);
1547 if (ret != SOFTBUS_OK) {
1548 DISC_LOGE(DISC_BROADCAST, "build SoftbusBroadcastData failed");
1549 SoftBusMutexUnlock(&g_bcLock);
1550 return ret;
1551 }
1552 BroadcastCallback callback = *(g_bcManager[bcId].bcCallback);
1553 SoftBusMutexUnlock(&g_bcLock);
1554 ret = g_interface[g_interfaceId]->SetBroadcastingData(g_bcManager[bcId].adapterBcId, &softbusBcData);
1555 if (ret != SOFTBUS_OK) {
1556 callback.OnSetBroadcastingCallback(bcId, (int32_t)SOFTBUS_BC_STATUS_FAIL);
1557 DISC_LOGE(DISC_BROADCAST, "call from adapter failed");
1558 ReleaseSoftbusBroadcastData(&softbusBcData);
1559 return ret;
1560 }
1561
1562 ReleaseSoftbusBroadcastData(&softbusBcData);
1563 return SOFTBUS_OK;
1564 }
1565
StopBroadcasting(int32_t bcId)1566 int32_t StopBroadcasting(int32_t bcId)
1567 {
1568 int32_t ret = CheckInterface(false);
1569 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
1570 DISC_BROADCAST, "interface check failed, bcId=%{public}d", bcId);
1571 DISC_CHECK_AND_RETURN_RET_LOGE(CheckBcIdIsValid(bcId), SOFTBUS_BC_MGR_INVALID_BC_ID,
1572 DISC_BROADCAST, "bad bcId, bcId=%{public}d", bcId);
1573
1574 int64_t time = MgrGetSysTime();
1575 if (time - g_bcManager[bcId].time < BC_WAIT_TIME_MICROSEC) {
1576 int64_t diffTime = g_bcManager[bcId].time + BC_WAIT_TIME_MICROSEC - time;
1577 DISC_LOGW(DISC_BROADCAST, "wait %{public}d us", (int32_t)diffTime);
1578 usleep(diffTime);
1579 }
1580
1581 ret = SoftBusMutexLock(&g_bcLock);
1582 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR,
1583 DISC_BROADCAST, "mutex error, bcId=%{public}d", bcId);
1584
1585 if (!g_bcManager[bcId].isStarted) {
1586 DISC_LOGW(DISC_BROADCAST, "bcId is not start, bcId=%{public}d", bcId);
1587 SoftBusMutexUnlock(&g_bcLock);
1588 return SOFTBUS_OK;
1589 }
1590 if (g_bcManager[bcId].bcCallback == NULL || g_bcManager[bcId].bcCallback->OnStopBroadcastingCallback == NULL) {
1591 DISC_LOGE(DISC_BROADCAST, "bc callback is null, bcId=%{public}d", bcId);
1592 SoftBusMutexUnlock(&g_bcLock);
1593 return SOFTBUS_BC_MGR_INVALID_BC_ID;
1594 }
1595
1596 DISC_LOGI(DISC_BROADCAST, "stop service srvType=%{public}s, bcId=%{public}d, adapterId=%{public}d",
1597 GetSrvType(g_bcManager[bcId].srvType), bcId, g_bcManager[bcId].adapterBcId);
1598 BroadcastCallback callback = *(g_bcManager[bcId].bcCallback);
1599 SoftBusMutexUnlock(&g_bcLock);
1600 ret = g_interface[g_interfaceId]->StopBroadcasting(g_bcManager[bcId].adapterBcId);
1601 if (ret != SOFTBUS_OK) {
1602 callback.OnStopBroadcastingCallback(bcId, (int32_t)SOFTBUS_BC_STATUS_FAIL);
1603 DISC_LOGE(DISC_BROADCAST, "call from adapter failed");
1604 return ret;
1605 }
1606 DISC_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&g_bcLock) == SOFTBUS_OK,
1607 SOFTBUS_LOCK_ERR, DISC_BROADCAST, "lock failed");
1608 g_bcManager[bcId].isStarted = false;
1609 SoftBusMutexUnlock(&g_bcLock);
1610 callback.OnStopBroadcastingCallback(bcId, (int32_t)SOFTBUS_BC_STATUS_SUCCESS);
1611 return SOFTBUS_OK;
1612 }
1613
GetScanFreq(uint16_t scanInterval,uint16_t scanWindow)1614 static int32_t GetScanFreq(uint16_t scanInterval, uint16_t scanWindow)
1615 {
1616 if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P2 && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P2) {
1617 return SCAN_FREQ_P2_60_3000;
1618 }
1619 if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P2_FAST && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P2_FAST) {
1620 return SCAN_FREQ_P2_30_1500;
1621 }
1622 if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P10 && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P10) {
1623 return SCAN_FREQ_P10_30_300;
1624 }
1625 if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P25 && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P25) {
1626 return SCAN_FREQ_P25_60_240;
1627 }
1628 if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P50 && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P50) {
1629 return SCAN_FREQ_P50_30_60;
1630 }
1631 if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P75 && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P75) {
1632 return SCAN_FREQ_P75_30_40;
1633 }
1634 if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P100 && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P100) {
1635 return SCAN_FREQ_P100_1000_1000;
1636 }
1637 return SCAN_FREQ_LOW_POWER;
1638 }
1639
NeedUpdateScan(int32_t listenerId)1640 static bool NeedUpdateScan(int32_t listenerId)
1641 {
1642 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), false, DISC_BROADCAST, "bad id");
1643 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId] != NULL, false, DISC_BROADCAST, "interface is nullptr");
1644 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId]->StopScan != NULL, false, DISC_BROADCAST, "bad function");
1645
1646 // Check whether the scanner is scanning.
1647 bool isScanning = false;
1648 int32_t adapterScanId = g_scanManager[listenerId].adapterScanId;
1649
1650 for (int32_t managerId = 0; managerId < SCAN_NUM_MAX; managerId++) {
1651 if (g_scanManager[managerId].adapterScanId != adapterScanId) {
1652 continue;
1653 }
1654 if (g_scanManager[managerId].isScanning) {
1655 isScanning = true;
1656 break;
1657 }
1658 }
1659
1660 // Need to reset scanner when the listenerId is not added in scanner.
1661 if (!g_scanManager[listenerId].isScanning) {
1662 g_scanManager[listenerId].isNeedReset = true;
1663 }
1664
1665 if (g_scanManager[listenerId].isNeedReset) {
1666 goto NEED_RESET;
1667 }
1668 DISC_LOGD(DISC_BROADCAST, "no need reset");
1669 return false;
1670
1671 NEED_RESET:
1672 if (isScanning) {
1673 int32_t ret = g_interface[g_interfaceId]->StopScan(adapterScanId);
1674 if (ret != SOFTBUS_OK) {
1675 DISC_LOGE(DISC_BROADCAST, "call from adapter failed, ret=%{public}d", ret);
1676 }
1677 return true;
1678 }
1679 DISC_LOGI(DISC_BROADCAST, "just start scan");
1680 return true;
1681 }
1682
StartScanSub(int32_t listenerId)1683 static int32_t StartScanSub(int32_t listenerId)
1684 {
1685 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "bad id");
1686 static uint32_t callCount = 0;
1687 SoftBusBcScanParams adapterParam;
1688 BuildSoftBusBcScanParams(&g_scanManager[listenerId].param, &adapterParam);
1689
1690 CheckScanFreq(listenerId, &adapterParam);
1691
1692 int32_t filterSize = 0;
1693 SoftBusBcScanFilter *adapterFilter = NULL;
1694
1695 if (!NeedUpdateScan(listenerId)) {
1696 DISC_LOGI(DISC_BROADCAST, "no need update scan, listenerId=%{public}d, srvType=%{public}s, "
1697 "callCount=%{public}u", listenerId, GetSrvType(g_scanManager[listenerId].srvType), callCount);
1698 return SOFTBUS_OK;
1699 }
1700
1701 int32_t ret = GetBcScanFilters(listenerId, &adapterFilter, &filterSize);
1702 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK && filterSize > 0, SOFTBUS_BC_MGR_START_SCAN_NO_FILTER,
1703 DISC_BROADCAST, "no filter");
1704 DumpBcScanFilter(adapterFilter, filterSize);
1705
1706 DISC_LOGI(DISC_BROADCAST, "start service srvType=%{public}s, listenerId=%{public}d, adapterId=%{public}d, "
1707 "interval=%{public}hu, window=%{public}hu, callCount=%{public}u",
1708 GetSrvType(g_scanManager[listenerId].srvType), listenerId,
1709 g_scanManager[listenerId].adapterScanId, adapterParam.scanInterval, adapterParam.scanWindow, callCount++);
1710 ret = g_interface[g_interfaceId]->StartScan(g_scanManager[listenerId].adapterScanId, &adapterParam,
1711 adapterFilter, filterSize);
1712 g_scanManager[listenerId].isNeedReset = false;
1713 ReleaseSoftBusBcScanFilter(adapterFilter, filterSize);
1714 if (ret != SOFTBUS_OK) {
1715 g_scanManager[listenerId].scanCallback->OnStartScanCallback(listenerId, (int32_t)SOFTBUS_BC_STATUS_FAIL);
1716 DISC_LOGE(DISC_BROADCAST, "call from adapter failed");
1717 return ret;
1718 }
1719
1720 return SOFTBUS_OK;
1721 }
1722
StartScan(int32_t listenerId,const BcScanParams * param)1723 int32_t StartScan(int32_t listenerId, const BcScanParams *param)
1724 {
1725 static uint32_t callCount = 0;
1726 DISC_LOGI(DISC_BROADCAST, "enter start scan, listenerId=%{public}d, callCount=%{public}u", listenerId, callCount++);
1727 DISC_CHECK_AND_RETURN_RET_LOGE(param != NULL, SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "invalid param!");
1728 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "bad id");
1729 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId] != NULL, SOFTBUS_BC_MGR_NO_FUNC_REGISTERED,
1730 DISC_BROADCAST, "interface is nullptr");
1731 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId]->StartScan != NULL,
1732 SOFTBUS_BC_MGR_FUNC_NULL, DISC_BROADCAST, "function is nullptr");
1733
1734 int32_t ret = SoftBusMutexLock(&g_scanLock);
1735 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, DISC_BROADCAST, "mutex error");
1736
1737 if (!CheckScanIdIsValid(listenerId)) {
1738 DISC_LOGE(DISC_BROADCAST, "invalid param listenerId, listenerId=%{public}d", listenerId);
1739 SoftBusMutexUnlock(&g_scanLock);
1740 return SOFTBUS_BC_MGR_INVALID_LISN_ID;
1741 }
1742
1743 g_scanManager[listenerId].param = *param;
1744 g_scanManager[listenerId].freq = GetScanFreq(param->scanInterval, param->scanWindow);
1745
1746 ret = StartScanSub(listenerId);
1747 if (ret != SOFTBUS_OK) {
1748 SoftBusMutexUnlock(&g_scanLock);
1749 return ret;
1750 }
1751
1752 g_scanManager[listenerId].isScanning = true;
1753 g_scanManager[listenerId].scanCallback->OnStartScanCallback(listenerId, (int32_t)SOFTBUS_BC_STATUS_SUCCESS);
1754
1755 SoftBusMutexUnlock(&g_scanLock);
1756 return SOFTBUS_OK;
1757 }
1758
StopScan(int32_t listenerId)1759 int32_t StopScan(int32_t listenerId)
1760 {
1761 static uint32_t callCount = 0;
1762 DISC_LOGI(DISC_BROADCAST, "enter stop scan, listenerId=%{public}d, callCount=%{public}u", listenerId, callCount++);
1763 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "bad id");
1764 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId] != NULL, SOFTBUS_BC_MGR_NO_FUNC_REGISTERED,
1765 DISC_BROADCAST, "interface is nullptr");
1766 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId]->StopScan != NULL,
1767 SOFTBUS_BC_MGR_FUNC_NULL, DISC_BROADCAST, "function is nullptr");
1768
1769 int32_t ret = SoftBusMutexLock(&g_scanLock);
1770 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, DISC_BROADCAST, "mutex error");
1771
1772 if (!CheckScanIdIsValid(listenerId)) {
1773 DISC_LOGE(DISC_BROADCAST, "invalid param listenerId, listenerId=%{public}d", listenerId);
1774 SoftBusMutexUnlock(&g_scanLock);
1775 return SOFTBUS_BC_MGR_INVALID_LISN_ID;
1776 }
1777 DISC_LOGI(DISC_BROADCAST, "srvType=%{public}s, listenerId=%{public}d, adapterId=%{public}d, callCount=%{public}u",
1778 GetSrvType(g_scanManager[listenerId].srvType), listenerId, g_scanManager[listenerId].adapterScanId, callCount);
1779 if (!g_scanManager[listenerId].isScanning) {
1780 DISC_LOGI(DISC_BROADCAST, "listenerId is not scanning. listenerId=%{public}d", listenerId);
1781 SoftBusMutexUnlock(&g_scanLock);
1782 return SOFTBUS_OK;
1783 }
1784
1785 ret = CheckAndStopScan(listenerId);
1786 if (ret != SOFTBUS_OK) {
1787 SoftBusMutexUnlock(&g_scanLock);
1788 return ret;
1789 }
1790
1791 g_scanManager[listenerId].isScanning = false;
1792 g_scanManager[listenerId].scanCallback->OnStopScanCallback(listenerId, (int32_t)SOFTBUS_BC_STATUS_SUCCESS);
1793
1794 SoftBusMutexUnlock(&g_scanLock);
1795 return SOFTBUS_OK;
1796 }
1797
SetScanFilter(int32_t listenerId,const BcScanFilter * scanFilter,uint8_t filterNum)1798 int32_t SetScanFilter(int32_t listenerId, const BcScanFilter *scanFilter, uint8_t filterNum)
1799 {
1800 DISC_LOGD(DISC_BROADCAST, "enter set scan filter");
1801 DISC_CHECK_AND_RETURN_RET_LOGE(scanFilter != NULL, SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "param is nullptr");
1802 DISC_CHECK_AND_RETURN_RET_LOGE(filterNum != 0, SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "filterNum is 0");
1803 int32_t ret = SoftBusMutexLock(&g_scanLock);
1804 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, DISC_BROADCAST, "mutex error");
1805
1806 if (!CheckScanIdIsValid(listenerId)) {
1807 DISC_LOGE(DISC_BROADCAST, "invalid param listenerId. listenerId=%{public}d", listenerId);
1808 SoftBusMutexUnlock(&g_scanLock);
1809 return SOFTBUS_BC_MGR_INVALID_LISN_ID;
1810 }
1811
1812 ReleaseBcScanFilter(listenerId);
1813 g_scanManager[listenerId].filter = (BcScanFilter *)scanFilter;
1814 g_scanManager[listenerId].filterSize = filterNum;
1815 // Need to reset scanner when filter changed.
1816 g_scanManager[listenerId].isNeedReset = true;
1817 DISC_LOGI(DISC_BROADCAST, "srvType=%{public}s, listenerId=%{public}d, adapterId=%{public}d",
1818 GetSrvType(g_scanManager[listenerId].srvType), listenerId, g_scanManager[listenerId].adapterScanId);
1819 SoftBusMutexUnlock(&g_scanLock);
1820 return SOFTBUS_OK;
1821 }
1822
GetScanFilter(int32_t listenerId,BcScanFilter ** scanFilter,uint8_t * filterNum)1823 int32_t GetScanFilter(int32_t listenerId, BcScanFilter **scanFilter, uint8_t *filterNum)
1824 {
1825 DISC_LOGD(DISC_BROADCAST, "enter get scan filter");
1826 DISC_CHECK_AND_RETURN_RET_LOGE(scanFilter != NULL, SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "invalid scanFilter");
1827 DISC_CHECK_AND_RETURN_RET_LOGE(filterNum != NULL, SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "invalid filterNum");
1828
1829 int32_t ret = SoftBusMutexLock(&g_scanLock);
1830 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, DISC_BROADCAST, "mutex error");
1831
1832 if (!CheckScanIdIsValid(listenerId)) {
1833 DISC_LOGE(DISC_BROADCAST, "invalid param listenerId. listenerId=%{public}d", listenerId);
1834 SoftBusMutexUnlock(&g_scanLock);
1835 return SOFTBUS_BC_MGR_INVALID_LISN_ID;
1836 }
1837
1838 *scanFilter = g_scanManager[listenerId].filter;
1839 *filterNum = g_scanManager[listenerId].filterSize;
1840 SoftBusMutexUnlock(&g_scanLock);
1841 return SOFTBUS_OK;
1842 }
1843
QueryBroadcastStatus(int32_t bcId,int32_t * status)1844 int32_t QueryBroadcastStatus(int32_t bcId, int32_t *status)
1845 {
1846 DISC_LOGI(DISC_BROADCAST, "enter query bc status");
1847 (void)bcId;
1848 (void)status;
1849 return SOFTBUS_OK;
1850 }
1851
BroadcastIsLpDeviceAvailable(void)1852 bool BroadcastIsLpDeviceAvailable(void)
1853 {
1854 DISC_LOGI(DISC_BROADCAST, "enter lp available");
1855 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), false, DISC_BROADCAST, "bad id");
1856 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId] != NULL, false, DISC_BROADCAST, "interface is nullptr");
1857 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId]->IsLpDeviceAvailable != NULL,
1858 false, DISC_BROADCAST, "function is nullptr");
1859
1860 return g_interface[g_interfaceId]->IsLpDeviceAvailable();
1861 }
1862
BroadcastSetAdvDeviceParam(LpServerType type,const LpBroadcastParam * bcParam,const LpScanParam * scanParam)1863 bool BroadcastSetAdvDeviceParam(LpServerType type, const LpBroadcastParam *bcParam,
1864 const LpScanParam *scanParam)
1865 {
1866 DISC_LOGD(DISC_BROADCAST, "enter set adv dev param");
1867 DISC_CHECK_AND_RETURN_RET_LOGE(bcParam != NULL, false, DISC_BROADCAST, "invalid param bcParam");
1868 DISC_CHECK_AND_RETURN_RET_LOGE(scanParam != NULL, false, DISC_BROADCAST, "invalid param scanParam");
1869 DISC_CHECK_AND_RETURN_RET_LOGE(type < SOFTBUS_UNKNOW_TYPE && type >= SOFTBUS_HEARTBEAT_TYPE,
1870 false, DISC_BROADCAST, "invalid app type");
1871 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), false, DISC_BROADCAST, "bad id");
1872 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId] != NULL, false, DISC_BROADCAST, "interface is nullptr");
1873 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId]->SetAdvFilterParam != NULL,
1874 false, DISC_BROADCAST, "function is nullptr");
1875
1876 SoftBusLpBroadcastParam bcDstParam = {0};
1877 SoftBusLpScanParam scanDstParam = {0};
1878
1879 bcDstParam.advHandle = bcParam->bcHandle;
1880 ConvertBcParams(&bcParam->bcParam, &bcDstParam.advParam);
1881
1882 int32_t ret = BuildSoftbusBroadcastData(&bcParam->packet, &bcDstParam.advData);
1883 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, false, DISC_BROADCAST, "build SoftbusBroadcastData failed");
1884
1885 BuildSoftBusBcScanParams(&scanParam->scanParam, &scanDstParam.scanParam);
1886 BcScanFilter *scanFilter = NULL;
1887 uint8_t filterNum = 0;
1888 ret = GetScanFilter(scanParam->listenerId, &scanFilter, &filterNum);
1889 if (ret != SOFTBUS_OK || scanFilter == NULL || filterNum == 0) {
1890 DISC_LOGE(DISC_BROADCAST, "get listenerId filters failed, listenerId=%{public}d", scanParam->listenerId);
1891 ReleaseSoftbusBroadcastData(&bcDstParam.advData);
1892 return false;
1893 }
1894 scanDstParam.filter = (SoftBusBcScanFilter *)SoftBusCalloc(sizeof(SoftBusBcScanFilter) * (filterNum));
1895 if (scanDstParam.filter == NULL) {
1896 ReleaseSoftbusBroadcastData(&bcDstParam.advData);
1897 return false;
1898 }
1899 scanDstParam.filterSize = filterNum;
1900 ret = CovertSoftBusBcScanFilters(scanFilter, filterNum, scanDstParam.filter);
1901 if (ret != SOFTBUS_OK) {
1902 DISC_LOGE(DISC_BROADCAST, "convert bc scan filters failed");
1903 ReleaseSoftbusBroadcastData(&bcDstParam.advData);
1904 ReleaseSoftBusBcScanFilter(scanDstParam.filter, filterNum);
1905 return false;
1906 }
1907
1908 ret = g_interface[g_interfaceId]->SetAdvFilterParam(type, &bcDstParam, &scanDstParam);
1909 ReleaseSoftbusBroadcastData(&bcDstParam.advData);
1910 ReleaseSoftBusBcScanFilter(scanDstParam.filter, filterNum);
1911 DISC_CHECK_AND_RETURN_RET_LOGE(ret, false, DISC_BROADCAST, "call from adapter failed");
1912 return true;
1913 }
1914
BroadcastGetBroadcastHandle(int32_t bcId,int32_t * bcHandle)1915 int32_t BroadcastGetBroadcastHandle(int32_t bcId, int32_t *bcHandle)
1916 {
1917 DISC_LOGD(DISC_BROADCAST, "enter get bc handle");
1918 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "bad id");
1919 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId] != NULL, SOFTBUS_BC_MGR_NO_FUNC_REGISTERED,
1920 DISC_BROADCAST, "interface is nullptr");
1921 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId]->GetBroadcastHandle != NULL,
1922 SOFTBUS_BC_MGR_FUNC_NULL, DISC_BROADCAST, "function is nullptr");
1923 DISC_CHECK_AND_RETURN_RET_LOGE(CheckBcIdIsValid(bcId), SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "bcId is invalid");
1924
1925 int32_t ret = g_interface[g_interfaceId]->GetBroadcastHandle(g_bcManager[bcId].adapterBcId, bcHandle);
1926 if (ret != SOFTBUS_OK) {
1927 DISC_LOGE(DISC_BROADCAST, "call from adapter failed");
1928 return ret;
1929 }
1930 return SOFTBUS_OK;
1931 }
1932
BroadcastEnableSyncDataToLpDevice(void)1933 int32_t BroadcastEnableSyncDataToLpDevice(void)
1934 {
1935 DISC_LOGI(DISC_BROADCAST, "enter enable sync");
1936 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "bad id");
1937 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId] != NULL, SOFTBUS_BC_MGR_NO_FUNC_REGISTERED,
1938 DISC_BROADCAST, "interface is nullptr");
1939 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId]->EnableSyncDataToLpDevice != NULL,
1940 SOFTBUS_BC_MGR_FUNC_NULL, DISC_BROADCAST, "function is nullptr");
1941
1942 int32_t ret = g_interface[g_interfaceId]->EnableSyncDataToLpDevice();
1943 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, DISC_BROADCAST, "call from adapter failed");
1944
1945 return SOFTBUS_OK;
1946 }
1947
BroadcastDisableSyncDataToLpDevice(void)1948 int32_t BroadcastDisableSyncDataToLpDevice(void)
1949 {
1950 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "bad id");
1951 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId] != NULL, SOFTBUS_BC_MGR_NO_FUNC_REGISTERED,
1952 DISC_BROADCAST, "interface is nullptr");
1953 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId]->DisableSyncDataToLpDevice != NULL,
1954 SOFTBUS_BC_MGR_FUNC_NULL, DISC_BROADCAST, "function is nullptr");
1955
1956 int32_t ret = g_interface[g_interfaceId]->DisableSyncDataToLpDevice();
1957 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, DISC_BROADCAST, "call from adapter failed");
1958
1959 return SOFTBUS_OK;
1960 }
1961
BroadcastSetScanReportChannelToLpDevice(int32_t listenerId,bool enable)1962 int32_t BroadcastSetScanReportChannelToLpDevice(int32_t listenerId, bool enable)
1963 {
1964 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "bad id");
1965 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId] != NULL, SOFTBUS_BC_MGR_NO_FUNC_REGISTERED,
1966 DISC_BROADCAST, "interface is nullptr");
1967 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId]->SetScanReportChannelToLpDevice != NULL,
1968 SOFTBUS_BC_MGR_FUNC_NULL, DISC_BROADCAST, "function is nullptr");
1969
1970 int32_t ret = SoftBusMutexLock(&g_scanLock);
1971 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, DISC_BROADCAST, "mutex error");
1972
1973 if (!CheckScanIdIsValid(listenerId)) {
1974 DISC_LOGE(DISC_BROADCAST, "invalid param listenerId. listenerId=%{public}d", listenerId);
1975 SoftBusMutexUnlock(&g_scanLock);
1976 return SOFTBUS_BC_MGR_INVALID_LISN_ID;
1977 }
1978
1979 ret = g_interface[g_interfaceId]->SetScanReportChannelToLpDevice(g_scanManager[listenerId].adapterScanId, enable);
1980 if (ret != SOFTBUS_OK) {
1981 DISC_LOGE(DISC_BROADCAST, "call from adapter failed");
1982 SoftBusMutexUnlock(&g_scanLock);
1983 return ret;
1984 }
1985 SoftBusMutexUnlock(&g_scanLock);
1986 return SOFTBUS_OK;
1987 }
1988
BroadcastSetLpAdvParam(int32_t duration,int32_t maxExtAdvEvents,int32_t window,int32_t interval,int32_t bcHandle)1989 int32_t BroadcastSetLpAdvParam(int32_t duration, int32_t maxExtAdvEvents, int32_t window,
1990 int32_t interval, int32_t bcHandle)
1991 {
1992 DISC_LOGI(DISC_BROADCAST, "enter set lp adv param");
1993 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "bad id");
1994 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId] != NULL, SOFTBUS_BC_MGR_NO_FUNC_REGISTERED,
1995 DISC_BROADCAST, "interface is nullptr");
1996 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId]->SetLpDeviceParam != NULL,
1997 SOFTBUS_BC_MGR_FUNC_NULL, DISC_BROADCAST, "function is nullptr");
1998
1999 int32_t ret = g_interface[g_interfaceId]->SetLpDeviceParam(duration, maxExtAdvEvents, window, interval, bcHandle);
2000 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, DISC_BROADCAST, "call from adapter failed");
2001
2002 return SOFTBUS_OK;
2003 }
2004
RegisterInfoDump(int fd)2005 static int32_t RegisterInfoDump(int fd)
2006 {
2007 SOFTBUS_DPRINTF(fd, "\n---------------------------Register Broadcaster Info-------------------------\n");
2008 SOFTBUS_DPRINTF(fd, "max broadcaster num : %d\n", BC_NUM_MAX);
2009 SOFTBUS_DPRINTF(fd, "isAdvertising : 0 - false, 1 - true\n\n");
2010 int32_t managerId;
2011 for (managerId = 0; managerId < BC_NUM_MAX; managerId++) {
2012 if (!g_bcManager[managerId].isUsed) {
2013 continue;
2014 }
2015 BroadcastManager *bcManager = &g_bcManager[managerId];
2016 SOFTBUS_DPRINTF(fd, "managerId : %d, ", managerId);
2017 SOFTBUS_DPRINTF(fd, "adapterBcId : %d, ", bcManager->adapterBcId);
2018 SOFTBUS_DPRINTF(fd, "isAdvertising : %d, ", bcManager->isAdvertising);
2019 SOFTBUS_DPRINTF(fd, "serviceType : %s\n", GetSrvType(bcManager->srvType));
2020 }
2021
2022 SOFTBUS_DPRINTF(fd, "\n---------------------------Register Listener Info----------------------------\n");
2023 SOFTBUS_DPRINTF(fd, "max listener num : %d\n", SCAN_NUM_MAX);
2024 SOFTBUS_DPRINTF(fd, "freq : 0 - low power, 1 - 60/3000, 2 - 30/1500, 3 - 30/300, 4 - 60/240, 5 - 1000/1000\n");
2025 SOFTBUS_DPRINTF(fd, "isNeedReset/isScanning : 0 - false, 1 - true\n\n");
2026 for (managerId = 0; managerId < SCAN_NUM_MAX; managerId++) {
2027 if (!g_scanManager[managerId].isUsed) {
2028 continue;
2029 }
2030 ScanManager *scanManager = &g_scanManager[managerId];
2031 SOFTBUS_DPRINTF(fd, "managerId : %d, ", managerId);
2032 SOFTBUS_DPRINTF(fd, "adapterScanId : %d, ", scanManager->adapterScanId);
2033 SOFTBUS_DPRINTF(fd, "isNeedReset : %d, ", scanManager->isNeedReset);
2034 SOFTBUS_DPRINTF(fd, "isScanning : %d, ", scanManager->isScanning);
2035 SOFTBUS_DPRINTF(fd, "scan freq: %d, ", scanManager->freq);
2036 SOFTBUS_DPRINTF(fd, "serviceType : %s\n", GetSrvType(scanManager->srvType));
2037 }
2038 return SOFTBUS_OK;
2039 }
2040