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
CovertSoftBusBcScanFilters(const BcScanFilter * filter,uint8_t size,SoftBusBcScanFilter * adapterFilter)972 static void CovertSoftBusBcScanFilters(const BcScanFilter *filter, uint8_t size, SoftBusBcScanFilter *adapterFilter)
973 {
974 while (size-- > 0) {
975 (adapterFilter + size)->address = (filter + size)->address;
976 (adapterFilter + size)->deviceName = (filter + size)->deviceName;
977 (adapterFilter + size)->serviceUuid = (filter + size)->serviceUuid;
978 (adapterFilter + size)->serviceDataLength = (filter + size)->serviceDataLength;
979 (adapterFilter + size)->serviceData = (filter + size)->serviceData;
980 (adapterFilter + size)->serviceDataMask = (filter + size)->serviceDataMask;
981 (adapterFilter + size)->manufactureId = (filter + size)->manufactureId;
982 (adapterFilter + size)->manufactureDataLength = (filter + size)->manufactureDataLength;
983 (adapterFilter + size)->manufactureData = (filter + size)->manufactureData;
984 (adapterFilter + size)->manufactureDataMask = (filter + size)->manufactureDataMask;
985 (adapterFilter + size)->advIndReport = (filter + size)->advIndReport;
986 }
987 }
988
CombineSoftbusBcScanFilters(int32_t listenerId,SoftBusBcScanFilter ** adapterFilter,int32_t * filterSize)989 static void CombineSoftbusBcScanFilters(int32_t listenerId, SoftBusBcScanFilter **adapterFilter, int32_t *filterSize)
990 {
991 DISC_LOGD(DISC_BROADCAST, "enter combine scan filters");
992 uint8_t size = 0;
993 for (int32_t managerId = 0; managerId < SCAN_NUM_MAX; managerId++) {
994 ScanManager *scanManager = &g_scanManager[managerId];
995 if (!scanManager->isUsed || (!scanManager->isScanning && managerId != listenerId) ||
996 scanManager->adapterScanId != g_scanManager[listenerId].adapterScanId) {
997 continue;
998 }
999
1000 size += scanManager->filterSize;
1001 }
1002 *adapterFilter = (SoftBusBcScanFilter *)SoftBusCalloc(sizeof(SoftBusBcScanFilter) * size);
1003 if (*adapterFilter == NULL) {
1004 DISC_LOGE(DISC_BROADCAST, "malloc failed");
1005 return;
1006 }
1007 *filterSize = size;
1008
1009 for (int32_t managerId = 0; managerId < SCAN_NUM_MAX; managerId++) {
1010 ScanManager *scanManager = &g_scanManager[managerId];
1011 if (!scanManager->isUsed || (!scanManager->isScanning && managerId != listenerId) ||
1012 scanManager->adapterScanId != g_scanManager[listenerId].adapterScanId) {
1013 continue;
1014 }
1015
1016 uint8_t currentSize = g_scanManager[managerId].filterSize;
1017 BcScanFilter *filter = g_scanManager[managerId].filter;
1018 size = size - currentSize;
1019 CovertSoftBusBcScanFilters(filter, currentSize, *adapterFilter + size);
1020 }
1021 }
1022
GetBcScanFilters(int32_t listenerId,SoftBusBcScanFilter ** adapterFilter,int32_t * filterSize)1023 static void GetBcScanFilters(int32_t listenerId, SoftBusBcScanFilter **adapterFilter, int32_t *filterSize)
1024 {
1025 CombineSoftbusBcScanFilters(listenerId, adapterFilter, filterSize);
1026 }
1027
DumpBcScanFilter(const SoftBusBcScanFilter * nativeFilter,uint8_t filterSize)1028 static void DumpBcScanFilter(const SoftBusBcScanFilter *nativeFilter, uint8_t filterSize)
1029 {
1030 DISC_CHECK_AND_RETURN_LOGE(nativeFilter != NULL, DISC_BROADCAST, "invalid param nativeFilter");
1031 DISC_CHECK_AND_RETURN_LOGE(filterSize != 0, DISC_BROADCAST, "filterSize is 0");
1032
1033 while (filterSize-- > 0) {
1034 int32_t len = (nativeFilter + filterSize)->serviceDataLength;
1035 if (len > 0) {
1036 DumpSoftbusData("service data", len, (nativeFilter + filterSize)->serviceData);
1037 DumpSoftbusData("service dataMask", len, (nativeFilter + filterSize)->serviceDataMask);
1038 } else {
1039 len = (nativeFilter + filterSize)->manufactureDataLength;
1040 if (len <= 0) {
1041 continue;
1042 }
1043 DumpSoftbusData("manufacture data", len, (nativeFilter + filterSize)->manufactureData);
1044 DumpSoftbusData("manufacture dataMask", len, (nativeFilter + filterSize)->manufactureDataMask);
1045 }
1046 }
1047 }
1048
BuildSoftBusBcScanParams(const BcScanParams * param,SoftBusBcScanParams * adapterParam)1049 static void BuildSoftBusBcScanParams(const BcScanParams *param, SoftBusBcScanParams *adapterParam)
1050 {
1051 DISC_LOGD(DISC_BROADCAST, "enter scan param");
1052 (void)memset_s(adapterParam, sizeof(SoftBusBcScanParams), 0x0, sizeof(SoftBusBcScanParams));
1053
1054 // convert params
1055 adapterParam->scanInterval = param->scanInterval;
1056 adapterParam->scanWindow = param->scanWindow;
1057 adapterParam->scanType = param->scanType;
1058 adapterParam->scanPhy = param->scanPhy;
1059 adapterParam->scanFilterPolicy = param->scanFilterPolicy;
1060 }
1061
GetScanIntervalAndWindow(int32_t freq,SoftBusBcScanParams * adapterParam)1062 static void GetScanIntervalAndWindow(int32_t freq, SoftBusBcScanParams *adapterParam)
1063 {
1064 if (freq == SCAN_FREQ_P2_60_3000) {
1065 adapterParam->scanInterval = SOFTBUS_BC_SCAN_INTERVAL_P2;
1066 adapterParam->scanWindow = SOFTBUS_BC_SCAN_WINDOW_P2;
1067 }
1068 if (freq == SCAN_FREQ_P2_30_1500) {
1069 adapterParam->scanInterval = SOFTBUS_BC_SCAN_INTERVAL_P2_FAST;
1070 adapterParam->scanWindow = SOFTBUS_BC_SCAN_WINDOW_P2_FAST;
1071 }
1072 if (freq == SCAN_FREQ_P10_30_300) {
1073 adapterParam->scanInterval = SOFTBUS_BC_SCAN_INTERVAL_P10;
1074 adapterParam->scanWindow = SOFTBUS_BC_SCAN_WINDOW_P10;
1075 }
1076 if (freq == SCAN_FREQ_P25_60_240) {
1077 adapterParam->scanInterval = SOFTBUS_BC_SCAN_INTERVAL_P25;
1078 adapterParam->scanWindow = SOFTBUS_BC_SCAN_WINDOW_P25;
1079 }
1080 if (freq == SCAN_FREQ_P50_30_60) {
1081 adapterParam->scanInterval = SOFTBUS_BC_SCAN_INTERVAL_P50;
1082 adapterParam->scanWindow = SOFTBUS_BC_SCAN_WINDOW_P50;
1083 }
1084 if (freq == SCAN_FREQ_P75_30_40) {
1085 adapterParam->scanInterval = SOFTBUS_BC_SCAN_INTERVAL_P75;
1086 adapterParam->scanWindow = SOFTBUS_BC_SCAN_WINDOW_P75;
1087 }
1088 if (freq == SCAN_FREQ_P100_1000_1000) {
1089 adapterParam->scanInterval = SOFTBUS_BC_SCAN_INTERVAL_P100;
1090 adapterParam->scanWindow = SOFTBUS_BC_SCAN_WINDOW_P100;
1091 }
1092 }
1093
CheckScanFreq(int32_t listenerId,SoftBusBcScanParams * adapterParam)1094 static void CheckScanFreq(int32_t listenerId, SoftBusBcScanParams *adapterParam)
1095 {
1096 static int32_t scanFreq = SCAN_FREQ_LOW_POWER;
1097 static int32_t scanLpFreq = SCAN_FREQ_LOW_POWER;
1098
1099 int32_t adapterScanId = g_scanManager[listenerId].adapterScanId;
1100 int32_t maxFreq = g_scanManager[listenerId].freq;
1101
1102 if (adapterScanId == g_adapterLpScannerId) {
1103 if (maxFreq != scanLpFreq) {
1104 DISC_LOGD(DISC_BROADCAST, "lp freq need to update");
1105 scanLpFreq = maxFreq;
1106 // Need to reset scanner when frequency changed.
1107 g_scanManager[listenerId].isNeedReset = true;
1108 }
1109 return;
1110 }
1111
1112 for (uint32_t managerId = 0; managerId < SCAN_NUM_MAX; managerId++) {
1113 ScanManager *scanManager = &g_scanManager[managerId];
1114 if (!scanManager->isUsed || !scanManager->isScanning || scanManager->adapterScanId != adapterScanId) {
1115 continue;
1116 }
1117 maxFreq = (maxFreq > (int32_t)(scanManager->freq)) ? maxFreq : (int32_t)(scanManager->freq);
1118 }
1119 if (scanFreq != maxFreq) {
1120 // Need to reset scanner when frequency changed.
1121 g_scanManager[listenerId].isNeedReset = true;
1122 scanFreq = maxFreq;
1123 DISC_LOGD(DISC_BROADCAST, "need to update");
1124 }
1125 GetScanIntervalAndWindow(scanFreq, adapterParam);
1126 }
1127
CheckAndStopScan(int32_t listenerId)1128 static int32_t CheckAndStopScan(int32_t listenerId)
1129 {
1130 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "bad id");
1131 int32_t liveListenerId = -1;
1132 int32_t ret;
1133 bool needUpdate = CheckNeedUpdateScan(listenerId, &liveListenerId);
1134 if (!needUpdate) {
1135 DISC_LOGI(DISC_BROADCAST, "call stop scan, adapterId=%{public}d", g_scanManager[listenerId].adapterScanId);
1136 ret = g_interface[g_interfaceId]->StopScan(g_scanManager[listenerId].adapterScanId);
1137 if (ret != SOFTBUS_OK) {
1138 g_scanManager[listenerId].scanCallback->OnStopScanCallback(listenerId, (int32_t)SOFTBUS_BC_STATUS_FAIL);
1139 DISC_LOGE(DISC_BROADCAST, "call from adapter failed");
1140 return ret;
1141 }
1142 } else {
1143 int32_t filterSize = 0;
1144 SoftBusBcScanFilter *adapterFilter = NULL;
1145 g_scanManager[listenerId].isScanning = false;
1146 GetBcScanFilters(liveListenerId, &adapterFilter, &filterSize);
1147 DumpBcScanFilter(adapterFilter, filterSize);
1148 SoftBusBcScanParams adapterParam;
1149 BuildSoftBusBcScanParams(&(g_scanManager[listenerId].param), &adapterParam);
1150 CheckScanFreq(liveListenerId, &adapterParam);
1151 ret = g_interface[g_interfaceId]->StopScan(g_scanManager[listenerId].adapterScanId);
1152 if (ret != SOFTBUS_OK) {
1153 g_scanManager[listenerId].scanCallback->OnStopScanCallback(listenerId, (int32_t)SOFTBUS_BC_STATUS_FAIL);
1154 DISC_LOGE(DISC_BROADCAST, "call from adapter failed");
1155 SoftBusFree(adapterFilter);
1156 return ret;
1157 }
1158 DISC_LOGI(DISC_BROADCAST, "start scan adapterId=%{public}d, interval=%{public}hu, window=%{public}hu",
1159 g_scanManager[listenerId].adapterScanId, adapterParam.scanInterval, adapterParam.scanWindow);
1160 ret = g_interface[g_interfaceId]->StartScan(g_scanManager[listenerId].adapterScanId, &adapterParam,
1161 adapterFilter, filterSize);
1162 SoftBusFree(adapterFilter);
1163 if (ret != SOFTBUS_OK) {
1164 g_scanManager[listenerId].scanCallback->OnStartScanCallback(listenerId, (int32_t)SOFTBUS_BC_STATUS_FAIL);
1165 DISC_LOGE(DISC_BROADCAST, "call from adapter failed");
1166 return ret;
1167 }
1168 }
1169 return SOFTBUS_OK;
1170 }
1171
UnRegisterScanListener(int32_t listenerId)1172 int32_t UnRegisterScanListener(int32_t listenerId)
1173 {
1174 DISC_LOGI(DISC_BROADCAST, "enter unregister scan, listenerId=%{public}d", listenerId);
1175 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "bad id");
1176 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId] != NULL, SOFTBUS_BC_MGR_NO_FUNC_REGISTERED,
1177 DISC_BROADCAST, "interface is nullptr");
1178 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId]->UnRegisterScanListener != NULL,
1179 SOFTBUS_BC_MGR_FUNC_NULL, DISC_BROADCAST, "function is nullptr");
1180 int32_t ret = SoftBusMutexLock(&g_scanLock);
1181 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, DISC_BROADCAST, "mutex error");
1182 if (!CheckScanIdIsValid(listenerId)) {
1183 SoftBusMutexUnlock(&g_scanLock);
1184 return SOFTBUS_INVALID_PARAM;
1185 }
1186 int32_t adapterScanId = g_scanManager[listenerId].adapterScanId;
1187 if (g_scanManager[listenerId].isScanning) {
1188 ret = CheckAndStopScan(listenerId);
1189 if (ret != SOFTBUS_OK) {
1190 DISC_LOGE(DISC_BROADCAST, "stop scan failed");
1191 SoftBusMutexUnlock(&g_scanLock);
1192 return ret;
1193 }
1194 }
1195 if (CheckNeedUnRegisterScanListener(listenerId)) {
1196 if (adapterScanId == g_adapterLpScannerId) {
1197 g_isLpScanCbReg = false;
1198 g_adapterLpScannerId = -1;
1199 }
1200 if (adapterScanId == g_adapterScannerId) {
1201 g_isScanCbReg = false;
1202 g_adapterScannerId = -1;
1203 }
1204 ret = g_interface[g_interfaceId]->UnRegisterScanListener(adapterScanId);
1205 if (ret != SOFTBUS_OK) {
1206 DISC_LOGE(DISC_BROADCAST, "call from adapter failed");
1207 SoftBusMutexUnlock(&g_scanLock);
1208 return ret;
1209 }
1210 }
1211 DISC_LOGD(DISC_BROADCAST, "srvType=%{public}s", GetSrvType(g_scanManager[listenerId].srvType));
1212 ReleaseBcScanFilter(listenerId);
1213 g_scanManager[listenerId].srvType = -1;
1214 g_scanManager[listenerId].adapterScanId = -1;
1215 g_scanManager[listenerId].isUsed = false;
1216 g_scanManager[listenerId].isNeedReset = true;
1217 g_scanManager[listenerId].freq = SCAN_FREQ_LOW_POWER;
1218 g_scanManager[listenerId].scanCallback = NULL;
1219 g_scanManager[listenerId].isScanning = false;
1220 SoftBusMutexUnlock(&g_scanLock);
1221 return SOFTBUS_OK;
1222 }
1223
ConvertBcParams(const BroadcastParam * srcParam,SoftbusBroadcastParam * dstParam)1224 static void ConvertBcParams(const BroadcastParam *srcParam, SoftbusBroadcastParam *dstParam)
1225 {
1226 DISC_LOGD(DISC_BROADCAST, "enter covert bc param");
1227 dstParam->minInterval = srcParam->minInterval;
1228 dstParam->maxInterval = srcParam->maxInterval;
1229 dstParam->advType = srcParam->advType;
1230 dstParam->advFilterPolicy = srcParam->advFilterPolicy;
1231 dstParam->ownAddrType = srcParam->ownAddrType;
1232 dstParam->peerAddrType = srcParam->peerAddrType;
1233 if (memcpy_s(dstParam->peerAddr.addr, SOFTBUS_ADDR_MAC_LEN, srcParam->peerAddr.addr, BC_ADDR_MAC_LEN) != EOK) {
1234 DISC_LOGE(DISC_BROADCAST, "memcpy peerAddr failed");
1235 return;
1236 }
1237 dstParam->channelMap = srcParam->channelMap;
1238 dstParam->duration = srcParam->duration;
1239 dstParam->txPower = srcParam->txPower;
1240 dstParam->isSupportRpa = srcParam->isSupportRpa;
1241 if (memcpy_s(dstParam->ownIrk, SOFTBUS_IRK_LEN, srcParam->ownIrk, BC_IRK_LEN) != EOK) {
1242 DISC_LOGE(DISC_BROADCAST, "memcpy ownIrk failed");
1243 return;
1244 }
1245 if (memcpy_s(dstParam->ownUdidHash, SOFTBUS_UDID_HASH_LEN, srcParam->ownUdidHash, BC_UDID_HASH_LEN) != EOK) {
1246 DISC_LOGE(DISC_BROADCAST, "memcpy ownUdidHash failed");
1247 return;
1248 }
1249 if (memcpy_s(dstParam->localAddr.addr, BC_ADDR_MAC_LEN, srcParam->localAddr.addr,
1250 BC_ADDR_MAC_LEN) != EOK) {
1251 DISC_LOGE(DISC_BROADCAST, "memcpy localAddr failed");
1252 return;
1253 }
1254 }
1255
DumpBroadcastPacket(const BroadcastPayload * bcData,const BroadcastPayload * rspData)1256 static void DumpBroadcastPacket(const BroadcastPayload *bcData, const BroadcastPayload *rspData)
1257 {
1258 DumpSoftbusData("BroadcastPayload bcData", bcData->payloadLen, bcData->payload);
1259 DumpSoftbusData("BroadcastPayload rspData", rspData->payloadLen, rspData->payload);
1260 }
1261
SoftBusCondWaitSec(int64_t sec,int32_t bcId,SoftBusMutex * mutex)1262 static int32_t SoftBusCondWaitSec(int64_t sec, int32_t bcId, SoftBusMutex *mutex)
1263 {
1264 SoftBusSysTime absTime = {0};
1265 int32_t ret = SoftBusGetTime(&absTime);
1266 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, DISC_BROADCAST, "softbus get time failed");
1267
1268 absTime.sec += sec;
1269 if (SoftBusCondWait(&g_bcManager[bcId].cond, mutex, &absTime) != SOFTBUS_OK) {
1270 DISC_LOGE(DISC_BROADCAST, "wait timeout");
1271 return SOFTBUS_TIMOUT;
1272 }
1273 return SOFTBUS_OK;
1274 }
1275
BuildSoftbusBcPayload(int32_t maxPayloadLen,const BroadcastPayload * srcData,SoftbusBroadcastPayload * dstData)1276 static int32_t BuildSoftbusBcPayload(int32_t maxPayloadLen, const BroadcastPayload *srcData,
1277 SoftbusBroadcastPayload *dstData)
1278 {
1279 dstData->type = (SoftbusBcDataType)srcData->type;
1280 dstData->id = srcData->id;
1281 dstData->payloadLen = srcData->payloadLen;
1282 if (srcData->payloadLen > maxPayloadLen) {
1283 DISC_LOGW(DISC_BROADCAST, "payloadLen is too long! payloadLen=%{public}d", srcData->payloadLen);
1284 }
1285 int32_t bcDataLen = (srcData->payloadLen > maxPayloadLen) ? maxPayloadLen : srcData->payloadLen;
1286
1287 dstData->payload = (uint8_t *)SoftBusCalloc(bcDataLen);
1288 DISC_CHECK_AND_RETURN_RET_LOGE(dstData->payload != NULL, SOFTBUS_MALLOC_ERR, DISC_BROADCAST, "malloc failed");
1289
1290 if (memcpy_s(dstData->payload, bcDataLen, srcData->payload, bcDataLen) != EOK) {
1291 DISC_LOGE(DISC_BROADCAST, "memcpy_s error");
1292 SoftBusFree(dstData->payload);
1293 return SOFTBUS_MEM_ERR;
1294 }
1295 return SOFTBUS_OK;
1296 }
1297
ReleaseSoftbusBroadcastData(SoftbusBroadcastData * softbusBcData)1298 static void ReleaseSoftbusBroadcastData(SoftbusBroadcastData *softbusBcData)
1299 {
1300 DISC_LOGD(DISC_BROADCAST, "enter release bc data");
1301 SoftBusFree(softbusBcData->bcData.payload);
1302 SoftBusFree(softbusBcData->rspData.payload);
1303 }
1304
BuildSoftbusBroadcastData(const BroadcastPacket * packet,SoftbusBroadcastData * softbusBcData)1305 static int32_t BuildSoftbusBroadcastData(const BroadcastPacket *packet, SoftbusBroadcastData *softbusBcData)
1306 {
1307 softbusBcData->isSupportFlag = packet->isSupportFlag;
1308 softbusBcData->flag = packet->flag;
1309
1310 // 1. Build broadcast paylod.
1311 int32_t maxPayloadLen = (packet->isSupportFlag) ? BC_DATA_MAX_LEN : (BC_DATA_MAX_LEN + BC_FLAG_LEN);
1312 int32_t ret = BuildSoftbusBcPayload(maxPayloadLen, &(packet->bcData), &(softbusBcData->bcData));
1313 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, DISC_BROADCAST, "BuildSoftbusBcPayload failed");
1314
1315 // 2. Build response broadcast paylod.
1316 if (packet->rspData.payload != NULL) {
1317 maxPayloadLen = RSP_DATA_MAX_LEN;
1318 ret = BuildSoftbusBcPayload(maxPayloadLen, &(packet->rspData), &(softbusBcData->rspData));
1319 if (ret != SOFTBUS_OK) {
1320 DISC_LOGE(DISC_BROADCAST, "convert rspData failed");
1321 SoftBusFree(softbusBcData->bcData.payload);
1322 return ret;
1323 }
1324 } else {
1325 softbusBcData->rspData.payload = NULL;
1326 softbusBcData->rspData.payloadLen = 0;
1327 }
1328 return SOFTBUS_OK;
1329 }
1330
MgrGetSysTime(void)1331 static int64_t MgrGetSysTime(void)
1332 {
1333 SoftBusSysTime absTime = {0};
1334 SoftBusGetTime(&absTime);
1335 int64_t time = absTime.sec * MGR_TIME_THOUSAND_MULTIPLIER * MGR_TIME_THOUSAND_MULTIPLIER + absTime.usec;
1336 return time;
1337 }
1338
StartBroadcastingWaitSignal(int32_t bcId,SoftBusMutex * mutex)1339 static void StartBroadcastingWaitSignal(int32_t bcId, SoftBusMutex *mutex)
1340 {
1341 DISC_CHECK_AND_RETURN_LOGE(mutex != NULL, DISC_BROADCAST, "invalid param");
1342 DISC_CHECK_AND_RETURN_LOGE(CheckMediumIsValid(g_interfaceId), DISC_BROADCAST, "bad id");
1343 if (SoftBusCondWaitSec(BC_WAIT_TIME_SEC, bcId, mutex) == SOFTBUS_OK) {
1344 return;
1345 }
1346 DISC_LOGW(DISC_BROADCAST, "wait signal failed, srvType=%{public}s, bcId=%{public}d, adapterId=%{public}d,"
1347 "call StopBroadcast", GetSrvType(g_bcManager[bcId].srvType), bcId, g_bcManager[bcId].adapterBcId);
1348 SoftBusMutexUnlock(mutex);
1349 int32_t ret = g_interface[g_interfaceId]->StopBroadcasting(g_bcManager[bcId].adapterBcId);
1350 DISC_LOGW(DISC_BROADCAST, "StopBroadcasting ret=%{public}d", ret);
1351 DISC_CHECK_AND_RETURN_LOGE(SoftBusMutexLock(mutex) == SOFTBUS_OK, DISC_BROADCAST, "bcLock mutex error");
1352 ret = SoftBusCondWaitSec(BC_WAIT_TIME_SEC, bcId, mutex);
1353 DISC_LOGW(DISC_BROADCAST, "wait signal ret=%{public}d", ret);
1354 g_bcManager[bcId].isAdvertising = false;
1355 }
1356
CheckInterface(bool isStart)1357 static int32_t CheckInterface(bool isStart)
1358 {
1359 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "bad id");
1360 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId] != NULL, SOFTBUS_BC_MGR_NO_FUNC_REGISTERED,
1361 DISC_BROADCAST, "interface is nullptr");
1362 if (isStart) {
1363 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId]->StartBroadcasting != NULL,
1364 SOFTBUS_BC_MGR_FUNC_NULL, DISC_BROADCAST, "function is nullptr");
1365 } else {
1366 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId]->StopBroadcasting != NULL,
1367 SOFTBUS_BC_MGR_FUNC_NULL, DISC_BROADCAST, "function is nullptr");
1368 }
1369 return SOFTBUS_OK;
1370 }
1371
StartBroadcasting(int32_t bcId,const BroadcastParam * param,const BroadcastPacket * packet)1372 int32_t StartBroadcasting(int32_t bcId, const BroadcastParam *param, const BroadcastPacket *packet)
1373 {
1374 static uint32_t callCount = 0;
1375 int32_t ret = CheckInterface(true);
1376 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
1377 DISC_BROADCAST, "interface check failed, bcId=%{public}d", bcId);
1378 ret = CheckBroadcastingParam(param, packet);
1379 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, DISC_BROADCAST, "check param failed");
1380 ret = SoftBusMutexLock(&g_bcLock);
1381 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, DISC_BROADCAST,
1382 "mutex error, bcId=%{public}d", bcId);
1383 if (!CheckBcIdIsValid(bcId) || g_bcManager[bcId].bcCallback == NULL ||
1384 g_bcManager[bcId].bcCallback->OnStartBroadcastingCallback == NULL) {
1385 SoftBusMutexUnlock(&g_bcLock);
1386 DISC_LOGE(DISC_BROADCAST, "invalid bcId, bcId=%{public}d", bcId);
1387 return SOFTBUS_BC_MGR_INVALID_BC_ID;
1388 }
1389 if (g_bcManager[bcId].isAdvertising && !g_bcManager[bcId].isStarted) {
1390 DISC_LOGW(DISC_BROADCAST, "wait condition managerId=%{public}d", bcId);
1391 StartBroadcastingWaitSignal(bcId, &g_bcLock);
1392 }
1393
1394 DumpBroadcastPacket(&(packet->bcData), &(packet->rspData));
1395 SoftbusBroadcastData softbusBcData = {0};
1396 ret = BuildSoftbusBroadcastData(packet, &softbusBcData);
1397 if (ret != SOFTBUS_OK) {
1398 DISC_LOGE(DISC_BROADCAST, "build SoftbusBroadcastData failed, bcId=%{public}d", bcId);
1399 SoftBusMutexUnlock(&g_bcLock);
1400 return ret;
1401 }
1402 SoftbusBroadcastParam adapterParam;
1403 ConvertBcParams(param, &adapterParam);
1404 DISC_LOGI(DISC_BROADCAST, "start service srvType=%{public}s, bcId=%{public}d, adapterId=%{public}d,"
1405 "callCount=%{public}u", GetSrvType(g_bcManager[bcId].srvType), bcId,
1406 g_bcManager[bcId].adapterBcId, callCount++);
1407 BroadcastCallback callback = *(g_bcManager[bcId].bcCallback);
1408 SoftBusMutexUnlock(&g_bcLock);
1409 ret = g_interface[g_interfaceId]->StartBroadcasting(g_bcManager[bcId].adapterBcId, &adapterParam, &softbusBcData);
1410 g_bcManager[bcId].time = MgrGetSysTime();
1411 if (ret != SOFTBUS_OK) {
1412 callback.OnStartBroadcastingCallback(bcId, (int32_t)SOFTBUS_BC_STATUS_FAIL);
1413 DISC_LOGE(DISC_BROADCAST, "call from adapter failed");
1414 ReleaseSoftbusBroadcastData(&softbusBcData);
1415 return ret;
1416 }
1417
1418 ret = SoftBusMutexLock(&g_bcLock);
1419 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, DISC_BROADCAST, "lock failed");
1420 g_bcManager[bcId].isStarted = true;
1421 SoftBusMutexUnlock(&g_bcLock);
1422 ReleaseSoftbusBroadcastData(&softbusBcData);
1423 return SOFTBUS_OK;
1424 }
1425
UpdateBroadcasting(int32_t bcId,const BroadcastParam * param,const BroadcastPacket * packet)1426 int32_t UpdateBroadcasting(int32_t bcId, const BroadcastParam *param, const BroadcastPacket *packet)
1427 {
1428 DISC_LOGI(DISC_BROADCAST, "enter update bc");
1429 DISC_CHECK_AND_RETURN_RET_LOGE(param != NULL, SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "invald param");
1430 DISC_CHECK_AND_RETURN_RET_LOGE(packet != NULL, SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "invald param packet");
1431
1432 int ret = StopBroadcasting(bcId);
1433 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, DISC_BROADCAST, "StopBroadcasting failed");
1434
1435 return StartBroadcasting(bcId, param, packet);
1436 }
1437
SetBroadcastingData(int32_t bcId,const BroadcastPacket * packet)1438 int32_t SetBroadcastingData(int32_t bcId, const BroadcastPacket *packet)
1439 {
1440 static uint32_t callCount = 0;
1441 DISC_LOGI(DISC_BROADCAST, "enter set bc data, bcId=%{public}d, callCount=%{public}u", bcId, callCount++);
1442 DISC_CHECK_AND_RETURN_RET_LOGE(packet != NULL, SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "invalid param packet");
1443 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "bad id");
1444 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId] != NULL, SOFTBUS_BC_MGR_NO_FUNC_REGISTERED,
1445 DISC_BROADCAST, "interface is nullptr");
1446 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId]->SetBroadcastingData != NULL,
1447 SOFTBUS_BC_MGR_FUNC_NULL, DISC_BROADCAST, "function is nullptr");
1448
1449 int32_t ret = SoftBusMutexLock(&g_bcLock);
1450 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, DISC_BROADCAST, "mutex error");
1451
1452 if (!CheckBcIdIsValid(bcId) || g_bcManager[bcId].bcCallback == NULL ||
1453 g_bcManager[bcId].bcCallback->OnSetBroadcastingCallback == NULL) {
1454 SoftBusMutexUnlock(&g_bcLock);
1455 return SOFTBUS_BC_MGR_INVALID_BC_ID;
1456 }
1457
1458 if (!g_bcManager[bcId].isAdvertising) {
1459 DISC_LOGW(DISC_BROADCAST, "bcId=%{public}d is not advertising", bcId);
1460 SoftBusMutexUnlock(&g_bcLock);
1461 return SOFTBUS_BC_MGR_NOT_BROADCASTING;
1462 }
1463 DISC_LOGI(DISC_BROADCAST, "replace BroadcastPacket srvType=%{public}s, bcId=%{public}d, adapterId=%{public}d,"
1464 "callCount=%{public}u", GetSrvType(g_bcManager[bcId].srvType), bcId, g_bcManager[bcId].adapterBcId,
1465 callCount++);
1466 SoftbusBroadcastData softbusBcData = {0};
1467 ret = BuildSoftbusBroadcastData(packet, &softbusBcData);
1468 if (ret != SOFTBUS_OK) {
1469 DISC_LOGE(DISC_BROADCAST, "build SoftbusBroadcastData failed");
1470 SoftBusMutexUnlock(&g_bcLock);
1471 return ret;
1472 }
1473 BroadcastCallback callback = *(g_bcManager[bcId].bcCallback);
1474 SoftBusMutexUnlock(&g_bcLock);
1475 ret = g_interface[g_interfaceId]->SetBroadcastingData(g_bcManager[bcId].adapterBcId, &softbusBcData);
1476 if (ret != SOFTBUS_OK) {
1477 callback.OnSetBroadcastingCallback(bcId, (int32_t)SOFTBUS_BC_STATUS_FAIL);
1478 DISC_LOGE(DISC_BROADCAST, "call from adapter failed");
1479 ReleaseSoftbusBroadcastData(&softbusBcData);
1480 return ret;
1481 }
1482
1483 ReleaseSoftbusBroadcastData(&softbusBcData);
1484 return SOFTBUS_OK;
1485 }
1486
StopBroadcasting(int32_t bcId)1487 int32_t StopBroadcasting(int32_t bcId)
1488 {
1489 int32_t ret = CheckInterface(false);
1490 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
1491 DISC_BROADCAST, "interface check failed, bcId=%{public}d", bcId);
1492 DISC_CHECK_AND_RETURN_RET_LOGE(CheckBcIdIsValid(bcId), SOFTBUS_BC_MGR_INVALID_BC_ID,
1493 DISC_BROADCAST, "bad bcId, bcId=%{public}d", bcId);
1494
1495 int64_t time = MgrGetSysTime();
1496 if (time - g_bcManager[bcId].time < BC_WAIT_TIME_MICROSEC) {
1497 int64_t diffTime = g_bcManager[bcId].time + BC_WAIT_TIME_MICROSEC - time;
1498 DISC_LOGW(DISC_BROADCAST, "wait %{public}d us", (int32_t)diffTime);
1499 usleep(diffTime);
1500 }
1501
1502 ret = SoftBusMutexLock(&g_bcLock);
1503 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR,
1504 DISC_BROADCAST, "mutex error, bcId=%{public}d", bcId);
1505
1506 if (!g_bcManager[bcId].isStarted) {
1507 DISC_LOGW(DISC_BROADCAST, "bcId is not start, bcId=%{public}d", bcId);
1508 SoftBusMutexUnlock(&g_bcLock);
1509 return SOFTBUS_OK;
1510 }
1511 if (g_bcManager[bcId].bcCallback == NULL || g_bcManager[bcId].bcCallback->OnStopBroadcastingCallback == NULL) {
1512 DISC_LOGE(DISC_BROADCAST, "bc callback is null, bcId=%{public}d", bcId);
1513 SoftBusMutexUnlock(&g_bcLock);
1514 return SOFTBUS_BC_MGR_INVALID_BC_ID;
1515 }
1516
1517 DISC_LOGI(DISC_BROADCAST, "stop service srvType=%{public}s, bcId=%{public}d, adapterId=%{public}d",
1518 GetSrvType(g_bcManager[bcId].srvType), bcId, g_bcManager[bcId].adapterBcId);
1519 BroadcastCallback callback = *(g_bcManager[bcId].bcCallback);
1520 SoftBusMutexUnlock(&g_bcLock);
1521 ret = g_interface[g_interfaceId]->StopBroadcasting(g_bcManager[bcId].adapterBcId);
1522 if (ret != SOFTBUS_OK) {
1523 callback.OnStopBroadcastingCallback(bcId, (int32_t)SOFTBUS_BC_STATUS_FAIL);
1524 DISC_LOGE(DISC_BROADCAST, "call from adapter failed");
1525 return ret;
1526 }
1527 DISC_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&g_bcLock) == SOFTBUS_OK,
1528 SOFTBUS_LOCK_ERR, DISC_BROADCAST, "lock failed");
1529 g_bcManager[bcId].isStarted = false;
1530 SoftBusMutexUnlock(&g_bcLock);
1531 callback.OnStopBroadcastingCallback(bcId, (int32_t)SOFTBUS_BC_STATUS_SUCCESS);
1532 return SOFTBUS_OK;
1533 }
1534
GetScanFreq(uint16_t scanInterval,uint16_t scanWindow)1535 static int32_t GetScanFreq(uint16_t scanInterval, uint16_t scanWindow)
1536 {
1537 if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P2 && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P2) {
1538 return SCAN_FREQ_P2_60_3000;
1539 }
1540 if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P2_FAST && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P2_FAST) {
1541 return SCAN_FREQ_P2_30_1500;
1542 }
1543 if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P10 && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P10) {
1544 return SCAN_FREQ_P10_30_300;
1545 }
1546 if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P25 && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P25) {
1547 return SCAN_FREQ_P25_60_240;
1548 }
1549 if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P50 && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P50) {
1550 return SCAN_FREQ_P50_30_60;
1551 }
1552 if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P75 && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P75) {
1553 return SCAN_FREQ_P75_30_40;
1554 }
1555 if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P100 && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P100) {
1556 return SCAN_FREQ_P100_1000_1000;
1557 }
1558 return SCAN_FREQ_LOW_POWER;
1559 }
1560
NeedUpdateScan(int32_t listenerId)1561 static bool NeedUpdateScan(int32_t listenerId)
1562 {
1563 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), false, DISC_BROADCAST, "bad id");
1564 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId] != NULL, false, DISC_BROADCAST, "interface is nullptr");
1565 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId]->StopScan != NULL, false, DISC_BROADCAST, "bad function");
1566
1567 // Check whether the scanner is scanning.
1568 bool isScanning = false;
1569 int32_t adapterScanId = g_scanManager[listenerId].adapterScanId;
1570
1571 for (int32_t managerId = 0; managerId < SCAN_NUM_MAX; managerId++) {
1572 if (g_scanManager[managerId].adapterScanId != adapterScanId) {
1573 continue;
1574 }
1575 if (g_scanManager[managerId].isScanning) {
1576 isScanning = true;
1577 break;
1578 }
1579 }
1580
1581 // Need to reset scanner when the listenerId is not added in scanner.
1582 if (!g_scanManager[listenerId].isScanning) {
1583 g_scanManager[listenerId].isNeedReset = true;
1584 }
1585
1586 if (g_scanManager[listenerId].isNeedReset) {
1587 goto NEED_RESET;
1588 }
1589 DISC_LOGD(DISC_BROADCAST, "no need reset");
1590 return false;
1591
1592 NEED_RESET:
1593 if (isScanning) {
1594 int32_t ret = g_interface[g_interfaceId]->StopScan(adapterScanId);
1595 if (ret != SOFTBUS_OK) {
1596 DISC_LOGE(DISC_BROADCAST, "call from adapter failed, ret=%{public}d", ret);
1597 }
1598 return true;
1599 }
1600 DISC_LOGI(DISC_BROADCAST, "just start scan");
1601 return true;
1602 }
1603
StartScanSub(int32_t listenerId)1604 static int32_t StartScanSub(int32_t listenerId)
1605 {
1606 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "bad id");
1607 static uint32_t callCount = 0;
1608 SoftBusBcScanParams adapterParam;
1609 BuildSoftBusBcScanParams(&g_scanManager[listenerId].param, &adapterParam);
1610
1611 CheckScanFreq(listenerId, &adapterParam);
1612
1613 int32_t filterSize = 0;
1614 SoftBusBcScanFilter *adapterFilter = NULL;
1615
1616 if (!NeedUpdateScan(listenerId)) {
1617 DISC_LOGI(DISC_BROADCAST, "no need update scan, listenerId=%{public}d, srvType=%{public}s, "
1618 "callCount=%{public}u", listenerId, GetSrvType(g_scanManager[listenerId].srvType), callCount);
1619 return SOFTBUS_OK;
1620 }
1621
1622 GetBcScanFilters(listenerId, &adapterFilter, &filterSize);
1623 DISC_CHECK_AND_RETURN_RET_LOGE(filterSize > 0, SOFTBUS_BC_MGR_START_SCAN_NO_FILTER, DISC_BROADCAST, "bad size");
1624 DumpBcScanFilter(adapterFilter, filterSize);
1625
1626 DISC_LOGI(DISC_BROADCAST, "start service srvType=%{public}s, listenerId=%{public}d, adapterId=%{public}d,"
1627 "interval=%{public}hu, window=%{public}hu, callCount=%{public}u",
1628 GetSrvType(g_scanManager[listenerId].srvType), listenerId, g_scanManager[listenerId].adapterScanId,
1629 adapterParam.scanInterval, adapterParam.scanWindow, callCount++);
1630 int32_t ret = g_interface[g_interfaceId]->StartScan(g_scanManager[listenerId].adapterScanId, &adapterParam,
1631 adapterFilter, filterSize);
1632 g_scanManager[listenerId].isNeedReset = false;
1633 SoftBusFree(adapterFilter);
1634 if (ret != SOFTBUS_OK) {
1635 g_scanManager[listenerId].scanCallback->OnStartScanCallback(listenerId, (int32_t)SOFTBUS_BC_STATUS_FAIL);
1636 DISC_LOGE(DISC_BROADCAST, "call from adapter failed");
1637 return ret;
1638 }
1639
1640 return SOFTBUS_OK;
1641 }
1642
StartScan(int32_t listenerId,const BcScanParams * param)1643 int32_t StartScan(int32_t listenerId, const BcScanParams *param)
1644 {
1645 static uint32_t callCount = 0;
1646 DISC_LOGI(DISC_BROADCAST, "enter start scan, listenerId=%{public}d, callCount=%{public}u", listenerId, callCount++);
1647 DISC_CHECK_AND_RETURN_RET_LOGE(param != NULL, SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "invalid param!");
1648 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "bad id");
1649 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId] != NULL, SOFTBUS_BC_MGR_NO_FUNC_REGISTERED,
1650 DISC_BROADCAST, "interface is nullptr");
1651 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId]->StartScan != NULL,
1652 SOFTBUS_BC_MGR_FUNC_NULL, DISC_BROADCAST, "function is nullptr");
1653
1654 int32_t ret = SoftBusMutexLock(&g_scanLock);
1655 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, DISC_BROADCAST, "mutex error");
1656
1657 if (!CheckScanIdIsValid(listenerId)) {
1658 DISC_LOGE(DISC_BROADCAST, "invalid param listenerId, listenerId=%{public}d", listenerId);
1659 SoftBusMutexUnlock(&g_scanLock);
1660 return SOFTBUS_BC_MGR_INVALID_LISN_ID;
1661 }
1662
1663 g_scanManager[listenerId].param = *param;
1664 g_scanManager[listenerId].freq = GetScanFreq(param->scanInterval, param->scanWindow);
1665
1666 ret = StartScanSub(listenerId);
1667 if (ret != SOFTBUS_OK) {
1668 SoftBusMutexUnlock(&g_scanLock);
1669 return ret;
1670 }
1671
1672 g_scanManager[listenerId].isScanning = true;
1673 g_scanManager[listenerId].scanCallback->OnStartScanCallback(listenerId, (int32_t)SOFTBUS_BC_STATUS_SUCCESS);
1674
1675 SoftBusMutexUnlock(&g_scanLock);
1676 return SOFTBUS_OK;
1677 }
1678
StopScan(int32_t listenerId)1679 int32_t StopScan(int32_t listenerId)
1680 {
1681 static uint32_t callCount = 0;
1682 DISC_LOGI(DISC_BROADCAST, "enter stop scan, listenerId=%{public}d, callCount=%{public}u", listenerId, callCount++);
1683 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "bad id");
1684 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId] != NULL, SOFTBUS_BC_MGR_NO_FUNC_REGISTERED,
1685 DISC_BROADCAST, "interface is nullptr");
1686 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId]->StopScan != NULL,
1687 SOFTBUS_BC_MGR_FUNC_NULL, DISC_BROADCAST, "function is nullptr");
1688
1689 int32_t ret = SoftBusMutexLock(&g_scanLock);
1690 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, DISC_BROADCAST, "mutex error");
1691
1692 if (!CheckScanIdIsValid(listenerId)) {
1693 DISC_LOGE(DISC_BROADCAST, "invalid param listenerId, listenerId=%{public}d", listenerId);
1694 SoftBusMutexUnlock(&g_scanLock);
1695 return SOFTBUS_BC_MGR_INVALID_LISN_ID;
1696 }
1697 DISC_LOGI(DISC_BROADCAST, "srvType=%{public}s, listenerId=%{public}d, adapterId=%{public}d, callCount=%{public}u",
1698 GetSrvType(g_scanManager[listenerId].srvType), listenerId, g_scanManager[listenerId].adapterScanId, callCount);
1699 if (!g_scanManager[listenerId].isScanning) {
1700 DISC_LOGI(DISC_BROADCAST, "listenerId is not scanning. listenerId=%{public}d", listenerId);
1701 SoftBusMutexUnlock(&g_scanLock);
1702 return SOFTBUS_OK;
1703 }
1704
1705 ret = CheckAndStopScan(listenerId);
1706 if (ret != SOFTBUS_OK) {
1707 SoftBusMutexUnlock(&g_scanLock);
1708 return ret;
1709 }
1710
1711 g_scanManager[listenerId].isScanning = false;
1712 g_scanManager[listenerId].scanCallback->OnStopScanCallback(listenerId, (int32_t)SOFTBUS_BC_STATUS_SUCCESS);
1713
1714 SoftBusMutexUnlock(&g_scanLock);
1715 return SOFTBUS_OK;
1716 }
1717
SetScanFilter(int32_t listenerId,const BcScanFilter * scanFilter,uint8_t filterNum)1718 int32_t SetScanFilter(int32_t listenerId, const BcScanFilter *scanFilter, uint8_t filterNum)
1719 {
1720 DISC_LOGD(DISC_BROADCAST, "enter set scan filter");
1721 DISC_CHECK_AND_RETURN_RET_LOGE(scanFilter != NULL, SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "param is nullptr");
1722 DISC_CHECK_AND_RETURN_RET_LOGE(filterNum != 0, SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "filterNum is 0");
1723 int32_t ret = SoftBusMutexLock(&g_scanLock);
1724 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, DISC_BROADCAST, "mutex error");
1725
1726 if (!CheckScanIdIsValid(listenerId)) {
1727 DISC_LOGE(DISC_BROADCAST, "invalid param listenerId. listenerId=%{public}d", listenerId);
1728 SoftBusMutexUnlock(&g_scanLock);
1729 return SOFTBUS_BC_MGR_INVALID_LISN_ID;
1730 }
1731
1732 ReleaseBcScanFilter(listenerId);
1733 g_scanManager[listenerId].filter = (BcScanFilter *)scanFilter;
1734 g_scanManager[listenerId].filterSize = filterNum;
1735 // Need to reset scanner when filter changed.
1736 g_scanManager[listenerId].isNeedReset = true;
1737 DISC_LOGI(DISC_BROADCAST, "srvType=%{public}s, listenerId=%{public}d, adapterId=%{public}d",
1738 GetSrvType(g_scanManager[listenerId].srvType), listenerId, g_scanManager[listenerId].adapterScanId);
1739 SoftBusMutexUnlock(&g_scanLock);
1740 return SOFTBUS_OK;
1741 }
1742
GetScanFilter(int32_t listenerId,BcScanFilter ** scanFilter,uint8_t * filterNum)1743 int32_t GetScanFilter(int32_t listenerId, BcScanFilter **scanFilter, uint8_t *filterNum)
1744 {
1745 DISC_LOGD(DISC_BROADCAST, "enter get scan filter");
1746 DISC_CHECK_AND_RETURN_RET_LOGE(scanFilter != NULL, SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "invalid scanFilter");
1747 DISC_CHECK_AND_RETURN_RET_LOGE(filterNum != NULL, SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "invalid filterNum");
1748
1749 int32_t ret = SoftBusMutexLock(&g_scanLock);
1750 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, DISC_BROADCAST, "mutex error");
1751
1752 if (!CheckScanIdIsValid(listenerId)) {
1753 DISC_LOGE(DISC_BROADCAST, "invalid param listenerId. listenerId=%{public}d", listenerId);
1754 SoftBusMutexUnlock(&g_scanLock);
1755 return SOFTBUS_BC_MGR_INVALID_LISN_ID;
1756 }
1757
1758 *scanFilter = g_scanManager[listenerId].filter;
1759 *filterNum = g_scanManager[listenerId].filterSize;
1760 SoftBusMutexUnlock(&g_scanLock);
1761 return SOFTBUS_OK;
1762 }
1763
QueryBroadcastStatus(int32_t bcId,int32_t * status)1764 int32_t QueryBroadcastStatus(int32_t bcId, int32_t *status)
1765 {
1766 DISC_LOGI(DISC_BROADCAST, "enter query bc status");
1767 (void)bcId;
1768 (void)status;
1769 return SOFTBUS_OK;
1770 }
1771
BroadcastIsLpDeviceAvailable(void)1772 bool BroadcastIsLpDeviceAvailable(void)
1773 {
1774 DISC_LOGI(DISC_BROADCAST, "enter lp available");
1775 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), false, DISC_BROADCAST, "bad id");
1776 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId] != NULL, false, DISC_BROADCAST, "interface is nullptr");
1777 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId]->IsLpDeviceAvailable != NULL,
1778 false, DISC_BROADCAST, "function is nullptr");
1779
1780 return g_interface[g_interfaceId]->IsLpDeviceAvailable();
1781 }
1782
BroadcastSetAdvDeviceParam(LpServerType type,const LpBroadcastParam * bcParam,const LpScanParam * scanParam)1783 bool BroadcastSetAdvDeviceParam(LpServerType type, const LpBroadcastParam *bcParam,
1784 const LpScanParam *scanParam)
1785 {
1786 DISC_LOGD(DISC_BROADCAST, "enter set adv dev param");
1787 DISC_CHECK_AND_RETURN_RET_LOGE(bcParam != NULL, false, DISC_BROADCAST, "invalid param bcParam");
1788 DISC_CHECK_AND_RETURN_RET_LOGE(scanParam != NULL, false, DISC_BROADCAST, "invalid param scanParam");
1789 DISC_CHECK_AND_RETURN_RET_LOGE(type < SOFTBUS_UNKNOW_TYPE && type >= SOFTBUS_HEARTBEAT_TYPE,
1790 false, DISC_BROADCAST, "invalid app type");
1791 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), false, DISC_BROADCAST, "bad id");
1792 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId] != NULL, false, DISC_BROADCAST, "interface is nullptr");
1793 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId]->SetAdvFilterParam != NULL,
1794 false, DISC_BROADCAST, "function is nullptr");
1795
1796 SoftBusLpBroadcastParam bcDstParam = {0};
1797 SoftBusLpScanParam scanDstParam = {0};
1798
1799 bcDstParam.advHandle = bcParam->bcHandle;
1800 ConvertBcParams(&bcParam->bcParam, &bcDstParam.advParam);
1801
1802 int32_t ret = BuildSoftbusBroadcastData(&bcParam->packet, &bcDstParam.advData);
1803 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, false, DISC_BROADCAST, "build SoftbusBroadcastData failed");
1804
1805 BuildSoftBusBcScanParams(&scanParam->scanParam, &scanDstParam.scanParam);
1806 BcScanFilter *scanFilter = NULL;
1807 uint8_t filterNum = 0;
1808 ret = GetScanFilter(scanParam->listenerId, &scanFilter, &filterNum);
1809 if (ret != SOFTBUS_OK || scanFilter == NULL || filterNum == 0) {
1810 DISC_LOGE(DISC_BROADCAST, "get listenerId filters failed, listenerId=%{public}d", scanParam->listenerId);
1811 ReleaseSoftbusBroadcastData(&bcDstParam.advData);
1812 return false;
1813 }
1814 scanDstParam.filter = (SoftBusBcScanFilter *)SoftBusCalloc(sizeof(SoftBusBcScanFilter) * (filterNum));
1815 if (scanDstParam.filter == NULL) {
1816 ReleaseSoftbusBroadcastData(&bcDstParam.advData);
1817 return false;
1818 }
1819 scanDstParam.filterSize = filterNum;
1820 CovertSoftBusBcScanFilters(scanFilter, filterNum, scanDstParam.filter);
1821
1822 ret = g_interface[g_interfaceId]->SetAdvFilterParam(type, &bcDstParam, &scanDstParam);
1823 if (!ret) {
1824 DISC_LOGE(DISC_BROADCAST, "call from adapter failed");
1825 SoftBusFree(scanDstParam.filter);
1826 ReleaseSoftbusBroadcastData(&bcDstParam.advData);
1827 return false;
1828 }
1829 ReleaseSoftbusBroadcastData(&bcDstParam.advData);
1830 SoftBusFree(scanDstParam.filter);
1831 return true;
1832 }
1833
BroadcastGetBroadcastHandle(int32_t bcId,int32_t * bcHandle)1834 int32_t BroadcastGetBroadcastHandle(int32_t bcId, int32_t *bcHandle)
1835 {
1836 DISC_LOGD(DISC_BROADCAST, "enter get bc handle");
1837 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "bad id");
1838 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId] != NULL, SOFTBUS_BC_MGR_NO_FUNC_REGISTERED,
1839 DISC_BROADCAST, "interface is nullptr");
1840 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId]->GetBroadcastHandle != NULL,
1841 SOFTBUS_BC_MGR_FUNC_NULL, DISC_BROADCAST, "function is nullptr");
1842 DISC_CHECK_AND_RETURN_RET_LOGE(CheckBcIdIsValid(bcId), SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "bcId is invalid");
1843
1844 int32_t ret = g_interface[g_interfaceId]->GetBroadcastHandle(g_bcManager[bcId].adapterBcId, bcHandle);
1845 if (ret != SOFTBUS_OK) {
1846 DISC_LOGE(DISC_BROADCAST, "call from adapter failed");
1847 return ret;
1848 }
1849 return SOFTBUS_OK;
1850 }
1851
BroadcastEnableSyncDataToLpDevice(void)1852 int32_t BroadcastEnableSyncDataToLpDevice(void)
1853 {
1854 DISC_LOGI(DISC_BROADCAST, "enter enable sync");
1855 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "bad id");
1856 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId] != NULL, SOFTBUS_BC_MGR_NO_FUNC_REGISTERED,
1857 DISC_BROADCAST, "interface is nullptr");
1858 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId]->EnableSyncDataToLpDevice != NULL,
1859 SOFTBUS_BC_MGR_FUNC_NULL, DISC_BROADCAST, "function is nullptr");
1860
1861 int32_t ret = g_interface[g_interfaceId]->EnableSyncDataToLpDevice();
1862 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, DISC_BROADCAST, "call from adapter failed");
1863
1864 return SOFTBUS_OK;
1865 }
1866
BroadcastDisableSyncDataToLpDevice(void)1867 int32_t BroadcastDisableSyncDataToLpDevice(void)
1868 {
1869 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "bad id");
1870 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId] != NULL, SOFTBUS_BC_MGR_NO_FUNC_REGISTERED,
1871 DISC_BROADCAST, "interface is nullptr");
1872 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId]->DisableSyncDataToLpDevice != NULL,
1873 SOFTBUS_BC_MGR_FUNC_NULL, DISC_BROADCAST, "function is nullptr");
1874
1875 int32_t ret = g_interface[g_interfaceId]->DisableSyncDataToLpDevice();
1876 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, DISC_BROADCAST, "call from adapter failed");
1877
1878 return SOFTBUS_OK;
1879 }
1880
BroadcastSetScanReportChannelToLpDevice(int32_t listenerId,bool enable)1881 int32_t BroadcastSetScanReportChannelToLpDevice(int32_t listenerId, bool enable)
1882 {
1883 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "bad id");
1884 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId] != NULL, SOFTBUS_BC_MGR_NO_FUNC_REGISTERED,
1885 DISC_BROADCAST, "interface is nullptr");
1886 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId]->SetScanReportChannelToLpDevice != NULL,
1887 SOFTBUS_BC_MGR_FUNC_NULL, DISC_BROADCAST, "function is nullptr");
1888
1889 int32_t ret = SoftBusMutexLock(&g_scanLock);
1890 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, DISC_BROADCAST, "mutex error");
1891
1892 if (!CheckScanIdIsValid(listenerId)) {
1893 DISC_LOGE(DISC_BROADCAST, "invalid param listenerId. listenerId=%{public}d", listenerId);
1894 SoftBusMutexUnlock(&g_scanLock);
1895 return SOFTBUS_BC_MGR_INVALID_LISN_ID;
1896 }
1897
1898 ret = g_interface[g_interfaceId]->SetScanReportChannelToLpDevice(g_scanManager[listenerId].adapterScanId, enable);
1899 if (ret != SOFTBUS_OK) {
1900 DISC_LOGE(DISC_BROADCAST, "call from adapter failed");
1901 SoftBusMutexUnlock(&g_scanLock);
1902 return ret;
1903 }
1904 SoftBusMutexUnlock(&g_scanLock);
1905 return SOFTBUS_OK;
1906 }
1907
BroadcastSetLpAdvParam(int32_t duration,int32_t maxExtAdvEvents,int32_t window,int32_t interval,int32_t bcHandle)1908 int32_t BroadcastSetLpAdvParam(int32_t duration, int32_t maxExtAdvEvents, int32_t window,
1909 int32_t interval, int32_t bcHandle)
1910 {
1911 DISC_LOGI(DISC_BROADCAST, "enter set lp adv param");
1912 DISC_CHECK_AND_RETURN_RET_LOGE(CheckMediumIsValid(g_interfaceId), SOFTBUS_INVALID_PARAM, DISC_BROADCAST, "bad id");
1913 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId] != NULL, SOFTBUS_BC_MGR_NO_FUNC_REGISTERED,
1914 DISC_BROADCAST, "interface is nullptr");
1915 DISC_CHECK_AND_RETURN_RET_LOGE(g_interface[g_interfaceId]->SetLpDeviceParam != NULL,
1916 SOFTBUS_BC_MGR_FUNC_NULL, DISC_BROADCAST, "function is nullptr");
1917
1918 int32_t ret = g_interface[g_interfaceId]->SetLpDeviceParam(duration, maxExtAdvEvents, window, interval, bcHandle);
1919 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, DISC_BROADCAST, "call from adapter failed");
1920
1921 return SOFTBUS_OK;
1922 }
1923
RegisterInfoDump(int fd)1924 static int32_t RegisterInfoDump(int fd)
1925 {
1926 SOFTBUS_DPRINTF(fd, "\n---------------------------Register Broadcaster Info-------------------------\n");
1927 SOFTBUS_DPRINTF(fd, "max broadcaster num : %d\n", BC_NUM_MAX);
1928 SOFTBUS_DPRINTF(fd, "isAdvertising : 0 - false, 1 - true\n\n");
1929 int32_t managerId;
1930 for (managerId = 0; managerId < BC_NUM_MAX; managerId++) {
1931 if (!g_bcManager[managerId].isUsed) {
1932 continue;
1933 }
1934 BroadcastManager *bcManager = &g_bcManager[managerId];
1935 SOFTBUS_DPRINTF(fd, "managerId : %d, ", managerId);
1936 SOFTBUS_DPRINTF(fd, "adapterBcId : %d, ", bcManager->adapterBcId);
1937 SOFTBUS_DPRINTF(fd, "isAdvertising : %d, ", bcManager->isAdvertising);
1938 SOFTBUS_DPRINTF(fd, "serviceType : %s\n", GetSrvType(bcManager->srvType));
1939 }
1940
1941 SOFTBUS_DPRINTF(fd, "\n---------------------------Register Listener Info----------------------------\n");
1942 SOFTBUS_DPRINTF(fd, "max listener num : %d\n", SCAN_NUM_MAX);
1943 SOFTBUS_DPRINTF(fd, "freq : 0 - low power, 1 - 60/3000, 2 - 30/1500, 3 - 30/300, 4 - 60/240, 5 - 1000/1000\n");
1944 SOFTBUS_DPRINTF(fd, "isNeedReset/isScanning : 0 - false, 1 - true\n\n");
1945 for (managerId = 0; managerId < SCAN_NUM_MAX; managerId++) {
1946 if (!g_scanManager[managerId].isUsed) {
1947 continue;
1948 }
1949 ScanManager *scanManager = &g_scanManager[managerId];
1950 SOFTBUS_DPRINTF(fd, "managerId : %d, ", managerId);
1951 SOFTBUS_DPRINTF(fd, "adapterScanId : %d, ", scanManager->adapterScanId);
1952 SOFTBUS_DPRINTF(fd, "isNeedReset : %d, ", scanManager->isNeedReset);
1953 SOFTBUS_DPRINTF(fd, "isScanning : %d, ", scanManager->isScanning);
1954 SOFTBUS_DPRINTF(fd, "scan freq: %d, ", scanManager->freq);
1955 SOFTBUS_DPRINTF(fd, "serviceType : %s\n", GetSrvType(scanManager->srvType));
1956 }
1957 return SOFTBUS_OK;
1958 }
1959