1 /*
2 * Copyright (c) 2022 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 * miscservices under the License is miscservices on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "softbus_hisysevt_discreporter.h"
17
18 #include "securec.h"
19 #include "softbus_adapter_thread.h"
20 #include "softbus_adapter_mem.h"
21 #include "softbus_errcode.h"
22 #include "softbus_hisysevt_bus_center.h"
23 #include "softbus_hisysevt_common.h"
24 #include "softbus_log.h"
25 #include "softbus_utils.h"
26
27 #define MODULE_NAME_MAX_LEN 33
28
29 #define FIRST_DISC_DURATION_PARAM_NUM 10
30 #define SOFT_BUS_VERSION_KEY "SOFT_BUS_VERSION"
31 #define PACKAGE_VERSION_KEY "PACKAGE_VERSION"
32 #define LINK_TYPE_KEY "LINK_TYPE"
33 #define TOTAL_TIME_KEY "TOTAL_TIME"
34 #define TOTAL_COUNT_KEY "TOTAL_COUNT"
35 #define COUNT1_KEY "COUNT1"
36 #define COUNT2_KEY "COUNT2"
37 #define COUNT3_KEY "COUNT3"
38 #define COUNT4_KEY "COUNT4"
39 #define COUNT5_KEY "COUNT5"
40
41 #define DISCOVERY_DETAILS_PARAM_NUM 6
42 #define MODULE_KEY "MODULE"
43 #define DISC_TYPE_KEY "DISCTYPE"
44 #define DURATION_KEY "DURATION"
45 #define REPORT_TIMES_KEY "REPTIMES"
46 #define DEVICE_NUM_KEY "DEVNUM"
47 #define DISC_TIMES_KEY "DISCTIMES"
48
49 #define DISCOVERY_BLE_RSSI_PARAM_NUM 2
50 #define RANGE_ID_KEY "RANGEID"
51 #define RANGE_DATA_KEY "RANGEDATA"
52
53 #define BLE_RSSI_RANGE_SIZE 52
54 #define MAX_RANGE_ID 130
55 #define MIN_RANGE_ID (-130)
56 #define INTERVAL_OF_RSSI 5
57
58 typedef enum {
59 STANDARD_S = 500,
60 STANDARD_A = 1000,
61 STANDARD_B = 1500,
62 STANDARD_C = 2000,
63 STANDARD_D = 2500,
64 } DiscoveryThreshold;
65
66 typedef struct {
67 SoftBusMutex lock;
68 uint64_t mDiscTotalTime;
69 uint32_t mDiscTotalCount;
70 uint32_t mDiscCount1;
71 uint32_t mDiscCount2;
72 uint32_t mDiscCount3;
73 uint32_t mDiscCount4;
74 uint32_t mDiscCount5;
75 } FirstDiscTime;
76
77 typedef struct {
78 SoftBusEvtParamType paramType;
79 char paramName[SOFTBUS_HISYSEVT_NAME_LEN];
80 size_t paramSize;
81 } SoftBusEvtParamSize;
82
83 static SoftBusEvtParamSize g_firstDsicTimeParam[FIRST_DISC_DURATION_PARAM_NUM] = {
84 {SOFTBUS_EVT_PARAMTYPE_STRING, SOFT_BUS_VERSION_KEY},
85 {SOFTBUS_EVT_PARAMTYPE_STRING, PACKAGE_VERSION_KEY},
86 {SOFTBUS_EVT_PARAMTYPE_UINT32, LINK_TYPE_KEY},
87 {SOFTBUS_EVT_PARAMTYPE_UINT64, TOTAL_TIME_KEY},
88 {SOFTBUS_EVT_PARAMTYPE_UINT32, TOTAL_COUNT_KEY},
89 {SOFTBUS_EVT_PARAMTYPE_UINT32, COUNT1_KEY},
90 {SOFTBUS_EVT_PARAMTYPE_UINT32, COUNT2_KEY},
91 {SOFTBUS_EVT_PARAMTYPE_UINT32, COUNT3_KEY},
92 {SOFTBUS_EVT_PARAMTYPE_UINT32, COUNT4_KEY},
93 {SOFTBUS_EVT_PARAMTYPE_UINT32, COUNT5_KEY},
94 };
95
96 typedef struct {
97 ListNode node;
98 char moduleName[MODULE_NAME_MAX_LEN];
99 uint32_t discType;
100 uint64_t duration;
101 uint32_t repTimes;
102 uint32_t devNum;
103 uint32_t discTimes;
104 } DiscDetailNode;
105
106 static char g_softbusVersion[SOFTBUS_HISYSEVT_PARAM_LEN] = "default softbus version";
107 static char g_packageVersion[SOFTBUS_HISYSEVT_PARAM_LEN] = "default package version";
108 static FirstDiscTime g_firstDiscTime[SOFTBUS_HISYSEVT_DISC_MEDIUM_BUTT];
109
110 static SoftBusMutex g_discDetailLock = {0};
111 static ListNode g_discDetailList = {0};
112
113 static uint32_t g_bleRssiRangeId[BLE_RSSI_RANGE_SIZE] = {0};
114 static uint32_t g_bleRssiRangeData[BLE_RSSI_RANGE_SIZE] = {0};
115 static SoftBusMutex g_bleRssiRangeLock = {0};
116
ClearFirstDiscTime(void)117 static inline void ClearFirstDiscTime(void)
118 {
119 for (int32_t i = SOFTBUS_HISYSEVT_DISC_MEDIUM_BLE; i < SOFTBUS_HISYSEVT_DISC_MEDIUM_BUTT; i++) {
120 FirstDiscTime *record = &g_firstDiscTime[i];
121 record->mDiscTotalTime = 0;
122 record->mDiscTotalCount = 0;
123 record->mDiscCount1 = 0;
124 record->mDiscCount2 = 0;
125 record->mDiscCount3 = 0;
126 record->mDiscCount4 = 0;
127 record->mDiscCount5 = 0;
128 }
129 }
130
ClearBleRssi(void)131 static inline void ClearBleRssi(void)
132 {
133 for (size_t rangeId = 0; rangeId < BLE_RSSI_RANGE_SIZE; rangeId++) {
134 g_bleRssiRangeId[rangeId] = 0;
135 g_bleRssiRangeData[rangeId] = 0;
136 }
137 }
138
SetMsgParamNameAndType(SoftBusEvtReportMsg * msg,SoftBusEvtParamSize * paramSize)139 static int32_t SetMsgParamNameAndType(SoftBusEvtReportMsg *msg, SoftBusEvtParamSize *paramSize)
140 {
141 SoftBusEvtParam *param = NULL;
142 for (uint32_t i = SOFTBUS_EVT_PARAM_ZERO; i < msg->paramNum; i++) {
143 param = &msg->paramArray[i];
144 param->paramType = paramSize[i].paramType;
145 if (strcpy_s(param->paramName, SOFTBUS_HISYSEVT_PARAM_LEN, paramSize[i].paramName) != EOK) {
146 MLOGE("set msg strcpy_s param name %s fail", paramSize[i].paramName);
147 return SOFTBUS_ERR;
148 }
149 }
150 return SOFTBUS_OK;
151 }
152
SetDevFirstDiscMsgParamValve(SoftBusEvtReportMsg * msg,uint32_t medium)153 static int32_t SetDevFirstDiscMsgParamValve(SoftBusEvtReportMsg *msg, uint32_t medium)
154 {
155 SoftBusEvtParam *param = msg->paramArray;
156 errno_t ret = strcpy_s(param[SOFTBUS_EVT_PARAM_ZERO].paramValue.str, SOFTBUS_HISYSEVT_PARAM_LEN, g_softbusVersion);
157 COMM_CHECK_AND_RETURN_RET_LOG(ret == EOK, SOFTBUS_ERR, "strcpy softbus version fail");
158
159 ret = strcpy_s(param[SOFTBUS_EVT_PARAM_ONE].paramValue.str, SOFTBUS_HISYSEVT_PARAM_LEN, g_packageVersion);
160 COMM_CHECK_AND_RETURN_RET_LOG(ret == EOK, SOFTBUS_ERR, "strcpy package version fail");
161
162 param[SOFTBUS_EVT_PARAM_TWO].paramValue.u32v = medium;
163 FirstDiscTime *firstDisc = &g_firstDiscTime[medium];
164 param[SOFTBUS_EVT_PARAM_THREE].paramValue.u64v = firstDisc->mDiscTotalTime;
165 param[SOFTBUS_EVT_PARAM_FOUR].paramValue.u32v = firstDisc->mDiscTotalCount;
166 param[SOFTBUS_EVT_PARAM_FIVE].paramValue.u32v = firstDisc->mDiscCount1;
167 param[SOFTBUS_EVT_PARAM_SIX].paramValue.u32v = firstDisc->mDiscCount2;
168 param[SOFTBUS_EVT_PARAM_SEVEN].paramValue.u32v = firstDisc->mDiscCount3;
169 param[SOFTBUS_EVT_PARAM_EIGHT].paramValue.u32v = firstDisc->mDiscCount4;
170 param[SOFTBUS_EVT_PARAM_NINE].paramValue.u32v = firstDisc->mDiscCount5;
171 return SOFTBUS_OK;
172 }
173
SoftBusCreateFirstDiscDurMsg(SoftBusEvtReportMsg * msg,uint32_t medium)174 static int32_t SoftBusCreateFirstDiscDurMsg(SoftBusEvtReportMsg *msg, uint32_t medium)
175 {
176 errno_t errnoRet = strcpy_s(msg->evtName, SOFTBUS_HISYSEVT_NAME_LEN, STATISTIC_EVT_FIRST_DISC_DURATION);
177 if (errnoRet != EOK) {
178 MLOGE("strcpy evtname %s fail", STATISTIC_EVT_FIRST_DISC_DURATION);
179 return SOFTBUS_ERR;
180 }
181 msg->evtType = SOFTBUS_EVT_TYPE_STATISTIC;
182 msg->paramNum = FIRST_DISC_DURATION_PARAM_NUM;
183
184 if (SetMsgParamNameAndType(msg, g_firstDsicTimeParam) != SOFTBUS_OK) {
185 MLOGE("disc first time duration event msg set param name and type fail");
186 return SOFTBUS_ERR;
187 }
188 if (SetDevFirstDiscMsgParamValve(msg, medium) != SOFTBUS_OK) {
189 MLOGE("disc first time duration event msg set param valve fail");
190 return SOFTBUS_ERR;
191 }
192 return SOFTBUS_OK;
193 }
194
ClearDiscDetails()195 static inline void ClearDiscDetails()
196 {
197 DiscDetailNode *item = NULL;
198 DiscDetailNode *next = NULL;
199
200 LIST_FOR_EACH_ENTRY_SAFE(item, next, &(g_discDetailList), DiscDetailNode, node) {
201 ListDelete(&item->node);
202 SoftBusFree(item);
203 }
204 }
205
GetDiscDetailByModuleName(char * moduleName)206 static DiscDetailNode *GetDiscDetailByModuleName(char *moduleName)
207 {
208 DiscDetailNode *item = NULL;
209 DiscDetailNode *next = NULL;
210
211 LIST_FOR_EACH_ENTRY_SAFE(item, next, &(g_discDetailList), DiscDetailNode, node) {
212 if (strcmp(item->moduleName, moduleName) == 0) {
213 return item;
214 }
215 }
216 return NULL;
217 }
218
AddDiscDetailNode(DiscDetailNode ** discDetailNode,char * moduleName)219 static int32_t AddDiscDetailNode(DiscDetailNode **discDetailNode, char *moduleName)
220 {
221 DiscDetailNode *newNode = (DiscDetailNode *)SoftBusCalloc(sizeof(DiscDetailNode));
222 COMM_CHECK_AND_RETURN_RET_LOG(newNode != NULL, SOFTBUS_ERR, "malloc fail");
223 if (strcpy_s(newNode->moduleName, MODULE_NAME_MAX_LEN, moduleName) != EOK) {
224 MLOGE("strcpy module name %s fail", moduleName);
225 SoftBusFree(newNode);
226 return SOFTBUS_ERR;
227 }
228 newNode->discType = SOFTBUS_HISYSEVT_DISC_MEDIUM_BLE;
229 newNode->devNum = 0;
230 newNode->discTimes = 0;
231 newNode->duration = 0;
232 newNode->repTimes = 0;
233 ListAdd(&g_discDetailList, &newNode->node);
234 *discDetailNode = newNode;
235 return SOFTBUS_OK;
236 }
237
SoftBusCreateDiscDetailsMsg(SoftBusEvtReportMsg * msg,DiscDetailNode * discDetailItem)238 static int32_t SoftBusCreateDiscDetailsMsg(SoftBusEvtReportMsg *msg, DiscDetailNode *discDetailItem)
239 {
240 errno_t errnoRet = strcpy_s(msg->evtName, SOFTBUS_HISYSEVT_NAME_LEN, STATISTIC_EVT_DISCOVERY_DETAILS);
241 COMM_CHECK_AND_RETURN_RET_LOG(errnoRet == EOK, SOFTBUS_ERR, "strcpy evtName %s fail",
242 STATISTIC_EVT_DISCOVERY_DETAILS);
243 msg->evtType = SOFTBUS_EVT_TYPE_STATISTIC;
244 msg->paramNum = DISCOVERY_DETAILS_PARAM_NUM;
245
246 SoftBusEvtParam* param = &msg->paramArray[SOFTBUS_EVT_PARAM_ZERO];
247 param->paramType = SOFTBUS_EVT_PARAMTYPE_STRING;
248 errnoRet = strcpy_s(param->paramName, SOFTBUS_HISYSEVT_PARAM_LEN, MODULE_KEY);
249 COMM_CHECK_AND_RETURN_RET_LOG(errnoRet == EOK, SOFTBUS_ERR, "strcpy paramName %s fail", MODULE_KEY);
250 errnoRet = strcpy_s(param->paramValue.str, SOFTBUS_HISYSEVT_PARAM_LEN, discDetailItem->moduleName);
251 COMM_CHECK_AND_RETURN_RET_LOG(errnoRet == EOK, SOFTBUS_ERR, "strcpy moduleName %s fail", g_softbusVersion);
252
253 param = &msg->paramArray[SOFTBUS_EVT_PARAM_ONE];
254 param->paramType = SOFTBUS_EVT_PARAMTYPE_UINT32;
255 errnoRet = strcpy_s(param->paramName, SOFTBUS_HISYSEVT_PARAM_LEN, DISC_TYPE_KEY);
256 COMM_CHECK_AND_RETURN_RET_LOG(errnoRet == EOK, SOFTBUS_ERR, "strcpy paramName %s fail", DISC_TYPE_KEY);
257 param->paramValue.u32v = discDetailItem->discType;
258
259 param = &msg->paramArray[SOFTBUS_EVT_PARAM_TWO];
260 param->paramType = SOFTBUS_EVT_PARAMTYPE_UINT64;
261 errnoRet = strcpy_s(param->paramName, SOFTBUS_HISYSEVT_PARAM_LEN, DURATION_KEY);
262 COMM_CHECK_AND_RETURN_RET_LOG(errnoRet == EOK, SOFTBUS_ERR, "strcpy paramName %s fail", DURATION_KEY);
263 param->paramValue.u64v = discDetailItem->duration;
264
265 param = &msg->paramArray[SOFTBUS_EVT_PARAM_THREE];
266 param->paramType = SOFTBUS_EVT_PARAMTYPE_UINT32;
267 errnoRet = strcpy_s(param->paramName, SOFTBUS_HISYSEVT_PARAM_LEN, REPORT_TIMES_KEY);
268 COMM_CHECK_AND_RETURN_RET_LOG(errnoRet == EOK, SOFTBUS_ERR, "strcpy paramName %s fail", REPORT_TIMES_KEY);
269 param->paramValue.u32v = discDetailItem->repTimes;
270
271 param = &msg->paramArray[SOFTBUS_EVT_PARAM_FOUR];
272 param->paramType = SOFTBUS_EVT_PARAMTYPE_UINT32;
273 errnoRet = strcpy_s(param->paramName, SOFTBUS_HISYSEVT_PARAM_LEN, DEVICE_NUM_KEY);
274 COMM_CHECK_AND_RETURN_RET_LOG(errnoRet == EOK, SOFTBUS_ERR, "strcpy paramName %s fail", DEVICE_NUM_KEY);
275 param->paramValue.u32v = discDetailItem->devNum;
276
277 param = &msg->paramArray[SOFTBUS_EVT_PARAM_FIVE];
278 param->paramType = SOFTBUS_EVT_PARAMTYPE_UINT32;
279 errnoRet = strcpy_s(param->paramName, SOFTBUS_HISYSEVT_PARAM_LEN, DISC_TIMES_KEY);
280 COMM_CHECK_AND_RETURN_RET_LOG(errnoRet == EOK, SOFTBUS_ERR, "strcpy paramName %s fail", DISC_TIMES_KEY);
281 param->paramValue.u32v = discDetailItem->discTimes;
282 return SOFTBUS_OK;
283 }
284
SoftBusCreateDiscBleRssiMsg(SoftBusEvtReportMsg * msg)285 static int32_t SoftBusCreateDiscBleRssiMsg(SoftBusEvtReportMsg *msg)
286 {
287 errno_t errnoRet = strcpy_s(msg->evtName, SOFTBUS_HISYSEVT_NAME_LEN, STATISTIC_EVT_DISCOVERY_BLE_RSSI);
288 COMM_CHECK_AND_RETURN_RET_LOG(errnoRet == EOK, SOFTBUS_ERR, "strcpy evtname %s fail",
289 STATISTIC_EVT_DISCOVERY_BLE_RSSI);
290 msg->evtType = SOFTBUS_EVT_TYPE_STATISTIC;
291 msg->paramNum = DISCOVERY_BLE_RSSI_PARAM_NUM;
292
293 SoftBusEvtParam* param = &msg->paramArray[SOFTBUS_EVT_PARAM_ZERO];
294 param->paramType = SOFTBUS_EVT_PARAMTYPE_UINT32_ARRAY;
295 errnoRet = strcpy_s(param->paramName, SOFTBUS_HISYSEVT_PARAM_LEN, RANGE_ID_KEY);
296 COMM_CHECK_AND_RETURN_RET_LOG(errnoRet == EOK, SOFTBUS_ERR, "strcpy paramName %s fail", RANGE_ID_KEY);
297 for (int i = 0; i < SOFTBUS_HISYSEVT_PARAM_UINT32_ARRAY_SIZE; i++) {
298 param->paramValue.u32a[i] = g_bleRssiRangeId[i];
299 }
300
301 param = &msg->paramArray[SOFTBUS_EVT_PARAM_ONE];
302 param->paramType = SOFTBUS_EVT_PARAMTYPE_UINT32_ARRAY;
303 errnoRet = strcpy_s(param->paramName, SOFTBUS_HISYSEVT_PARAM_LEN, RANGE_DATA_KEY);
304 COMM_CHECK_AND_RETURN_RET_LOG(errnoRet == EOK, SOFTBUS_ERR, "strcpy paramName %s fail", RANGE_DATA_KEY);
305 for (int i = 0; i < SOFTBUS_HISYSEVT_PARAM_UINT32_ARRAY_SIZE; i++) {
306 param->paramValue.u32a[i] = g_bleRssiRangeData[i];
307 }
308 return SOFTBUS_OK;
309 }
310
SoftBusReportFirstDiscDurationEvt(void)311 static int32_t SoftBusReportFirstDiscDurationEvt(void)
312 {
313 MLOGI("report first disc duration event");
314 SoftBusEvtReportMsg *msg = SoftbusCreateEvtReportMsg(FIRST_DISC_DURATION_PARAM_NUM);
315 COMM_CHECK_AND_RETURN_RET_LOG(msg != NULL, SOFTBUS_ERR, "create reportMsg fail");
316 for (int32_t i = SOFTBUS_HISYSEVT_DISC_MEDIUM_BLE; i < SOFTBUS_HISYSEVT_DISC_MEDIUM_BUTT; i++) {
317 if (SoftBusMutexLock(&g_firstDiscTime[i].lock) != SOFTBUS_OK) {
318 SoftbusFreeEvtReporMsg(msg);
319 ClearFirstDiscTime();
320 MLOGE("lock first disc time fail");
321 return SOFTBUS_ERR;
322 }
323 if (g_firstDiscTime[i].mDiscTotalCount == 0) {
324 SoftBusMutexUnlock(&g_firstDiscTime[i].lock);
325 continue;
326 }
327 if (SoftBusCreateFirstDiscDurMsg(msg, i) != SOFTBUS_OK) {
328 SoftBusMutexUnlock(&g_firstDiscTime[i].lock);
329 SoftbusFreeEvtReporMsg(msg);
330 ClearFirstDiscTime();
331 MLOGE("create first disc duration reportMsg fail");
332 return SOFTBUS_ERR;
333 }
334 if (SoftbusWriteHisEvt(msg) != SOFTBUS_OK) {
335 SoftBusMutexUnlock(&g_firstDiscTime[i].lock);
336 SoftbusFreeEvtReporMsg(msg);
337 ClearFirstDiscTime();
338 MLOGE("write first disc duration reportMsg fail");
339 return SOFTBUS_ERR;
340 }
341 SoftBusMutexUnlock(&g_firstDiscTime[i].lock);
342 }
343 SoftbusFreeEvtReporMsg(msg);
344 ClearFirstDiscTime();
345 return SOFTBUS_OK;
346 }
347
FreeDiscDetailsMsg(SoftBusEvtReportMsg * msg)348 static inline void FreeDiscDetailsMsg(SoftBusEvtReportMsg *msg)
349 {
350 SoftbusFreeEvtReporMsg(msg);
351 ClearDiscDetails();
352 (void)SoftBusMutexUnlock(&g_discDetailLock);
353 }
354
SoftBusReportDiscDetailsEvt(void)355 static int32_t SoftBusReportDiscDetailsEvt(void)
356 {
357 MLOGI("report disc detail event");
358 int32_t ret = SoftBusMutexLock(&g_discDetailLock);
359 COMM_CHECK_AND_RETURN_RET_LOG(ret == SOFTBUS_OK, SOFTBUS_ERR, "disc detail lock fail");
360
361 SoftBusEvtReportMsg *msg = SoftbusCreateEvtReportMsg(DISCOVERY_DETAILS_PARAM_NUM);
362 if (msg == NULL) {
363 MLOGE("create disc details reportMsg fail");
364 ClearDiscDetails();
365 (void)SoftBusMutexUnlock(&g_discDetailLock);
366 return SOFTBUS_MEM_ERR;
367 }
368 DiscDetailNode *item = NULL;
369 DiscDetailNode *next = NULL;
370
371 LIST_FOR_EACH_ENTRY_SAFE(item, next, &(g_discDetailList), DiscDetailNode, node) {
372 if (SoftBusCreateDiscDetailsMsg(msg, item) != SOFTBUS_OK) {
373 FreeDiscDetailsMsg(msg);
374 MLOGE("create first disc detials reportMsg fail");
375 return SOFTBUS_ERR;
376 }
377 if (SoftbusWriteHisEvt(msg) != SOFTBUS_OK) {
378 MLOGE("write disc detail evt fail");
379 FreeDiscDetailsMsg(msg);
380 return SOFTBUS_ERR;
381 }
382 }
383 FreeDiscDetailsMsg(msg);
384 return SOFTBUS_OK;
385 }
386
FreeDiscBleRssiMsg(SoftBusEvtReportMsg * msg)387 static inline void FreeDiscBleRssiMsg(SoftBusEvtReportMsg *msg)
388 {
389 SoftbusFreeEvtReporMsg(msg);
390 ClearBleRssi();
391 (void)SoftBusMutexUnlock(&g_bleRssiRangeLock);
392 }
393
SoftBusReportDiscBleRssiEvt(void)394 static int32_t SoftBusReportDiscBleRssiEvt(void)
395 {
396 MLOGI("report disc ble rssi event");
397 int32_t ret = SoftBusMutexLock(&g_bleRssiRangeLock);
398 COMM_CHECK_AND_RETURN_RET_LOG(ret == SOFTBUS_OK, SOFTBUS_ERR, "ble rssi range lock fail");
399
400 SoftBusEvtReportMsg *msg = SoftbusCreateEvtReportMsg(DISCOVERY_BLE_RSSI_PARAM_NUM);
401 if (msg == NULL) {
402 MLOGE("create disc ble rssi reportMsg fail");
403 ClearBleRssi();
404 SoftBusMutexUnlock(&g_bleRssiRangeLock);
405 return SOFTBUS_MEM_ERR;
406 }
407 if (SoftBusCreateDiscBleRssiMsg(msg) != SOFTBUS_OK) {
408 FreeDiscBleRssiMsg(msg);
409 MLOGE("create disc ble rssi reportMsg fail");
410 return SOFTBUS_ERR;
411 }
412 if (SoftbusWriteHisEvt(msg) != SOFTBUS_OK) {
413 MLOGE("write disc ble rssi evt fail");
414 FreeDiscBleRssiMsg(msg);
415 return SOFTBUS_ERR;
416 }
417 FreeDiscBleRssiMsg(msg);
418 return SOFTBUS_OK;
419 }
420
SoftbusRecordFirstDiscTime(SoftBusDiscMedium medium,uint64_t costTime)421 int32_t SoftbusRecordFirstDiscTime(SoftBusDiscMedium medium, uint64_t costTime)
422 {
423 MLOGI("record first disc time start");
424 if (medium >= SOFTBUS_HISYSEVT_DISC_MEDIUM_BUTT || medium < SOFTBUS_HISYSEVT_DISC_MEDIUM_BLE) {
425 MLOGE("medium is invalid");
426 return SOFTBUS_INVALID_PARAM;
427 }
428 if (SoftBusMutexLock(&g_firstDiscTime[medium].lock) != SOFTBUS_OK) {
429 MLOGE("first disc time lock fail");
430 return SOFTBUS_ERR;
431 }
432 FirstDiscTime *record = &g_firstDiscTime[medium];
433 record->mDiscTotalTime += costTime;
434 record->mDiscTotalCount++;
435 if (costTime > STANDARD_S) {
436 record->mDiscCount1++;
437 }
438 if (costTime > STANDARD_A) {
439 record->mDiscCount2++;
440 }
441 if (costTime > STANDARD_B) {
442 record->mDiscCount3++;
443 }
444 if (costTime > STANDARD_C) {
445 record->mDiscCount4++;
446 }
447 if (costTime > STANDARD_D) {
448 record->mDiscCount5++;
449 }
450 if (SoftBusMutexUnlock(&record->lock) != SOFTBUS_OK) {
451 MLOGE("record first disc time unlock fail");
452 return SOFTBUS_ERR;
453 }
454 return SOFTBUS_OK;
455 }
456
SoftbusRecordBleDiscDetails(char * moduleName,uint64_t duration,uint32_t repTimes,uint32_t devNum,uint32_t discTimes)457 int32_t SoftbusRecordBleDiscDetails(char *moduleName, uint64_t duration, uint32_t repTimes, uint32_t devNum,
458 uint32_t discTimes)
459 {
460 MLOGI("record ble disc detail");
461 COMM_CHECK_AND_RETURN_RET_LOG(IsValidString(moduleName, MODULE_NAME_MAX_LEN), SOFTBUS_ERR, "invalid param!");
462 int32_t ret = SoftBusMutexLock(&g_discDetailLock);
463 COMM_CHECK_AND_RETURN_RET_LOG(ret == SOFTBUS_OK, SOFTBUS_ERR, "disc detail lock fail");
464 DiscDetailNode *discDetailNode = GetDiscDetailByModuleName(moduleName);
465 if (discDetailNode == NULL) {
466 ret = AddDiscDetailNode(&discDetailNode, moduleName);
467 if (ret != SOFTBUS_OK) {
468 MLOGE("add disc detail node fail");
469 SoftBusMutexUnlock(&g_discDetailLock);
470 return SOFTBUS_ERR;
471 }
472 }
473 discDetailNode->devNum += devNum;
474 discDetailNode->discTimes += discTimes;
475 discDetailNode->duration += duration;
476 discDetailNode->repTimes += repTimes;
477 (void)SoftBusMutexUnlock(&g_discDetailLock);
478 return SOFTBUS_OK;
479 }
480
SoftbusRecordDiscBleRssi(int32_t rssi)481 int32_t SoftbusRecordDiscBleRssi(int32_t rssi)
482 {
483 MLOGI("record disc ble rssi");
484 if (rssi > MAX_RANGE_ID || rssi <= MIN_RANGE_ID) {
485 MLOGE("invalid param");
486 return SOFTBUS_INVALID_PARAM;
487 }
488 COMM_CHECK_AND_RETURN_RET_LOG(SoftBusMutexLock(&g_bleRssiRangeLock) == SOFTBUS_OK, SOFTBUS_ERR,
489 "ble rssi range lock fail");
490
491 size_t rangeId = (MAX_RANGE_ID - rssi) / INTERVAL_OF_RSSI;
492 g_bleRssiRangeId[rangeId] = rangeId;
493 g_bleRssiRangeData[rangeId] += 1;
494 (void)SoftBusMutexUnlock(&g_bleRssiRangeLock);
495 return SOFTBUS_OK;
496 }
497
InitDiscItemMutexLock(uint32_t index,SoftBusMutexAttr * mutexAttr)498 static int32_t InitDiscItemMutexLock(uint32_t index, SoftBusMutexAttr *mutexAttr)
499 {
500 if (SoftBusMutexInit(&g_firstDiscTime[index].lock, mutexAttr) != SOFTBUS_OK) {
501 MLOGE("init first disc time lock fail");
502 return SOFTBUS_ERR;
503 }
504 return SOFTBUS_OK;
505 }
506
InitDiscEvtMutexLock(void)507 static int32_t InitDiscEvtMutexLock(void)
508 {
509 SoftBusMutexAttr mutexAttr = {SOFTBUS_MUTEX_RECURSIVE};
510 COMM_CHECK_AND_RETURN_RET_LOG(SoftBusMutexInit(&g_discDetailLock, &mutexAttr) == SOFTBUS_OK, SOFTBUS_ERR,
511 "init disc detail lock fail");
512 int32_t nRet = SoftBusMutexInit(&g_bleRssiRangeLock, &mutexAttr);
513 if (nRet != SOFTBUS_OK) {
514 MLOGE("init ble rssi range lock fail");
515 (void)SoftBusMutexDestroy(&g_discDetailLock);
516 }
517 for (int32_t i = SOFTBUS_HISYSEVT_DISC_MEDIUM_BLE; i < SOFTBUS_HISYSEVT_DISC_MEDIUM_BUTT; i++) {
518 nRet = InitDiscItemMutexLock(i, &mutexAttr);
519 }
520 if (nRet != SOFTBUS_OK) {
521 MLOGE("init disc first time lock fail");
522 (void)SoftBusMutexDestroy(&g_discDetailLock);
523 (void)SoftBusMutexDestroy(&g_bleRssiRangeLock);
524 }
525 return nRet;
526 }
527
SoftbusReportDiscFault(SoftBusDiscMedium medium,int32_t errCode)528 int32_t SoftbusReportDiscFault(SoftBusDiscMedium medium, int32_t errCode)
529 {
530 MLOGI("report disc fault event");
531 if (medium >= SOFTBUS_HISYSEVT_DISC_MEDIUM_BUTT || medium < SOFTBUS_HISYSEVT_DISC_MEDIUM_BLE) {
532 MLOGE("medium is invalid");
533 return SOFTBUS_INVALID_PARAM;
534 }
535 SoftBusFaultEvtInfo discFaultInfo;
536 (void)memset_s(&discFaultInfo, sizeof(SoftBusFaultEvtInfo), 0, sizeof(SoftBusFaultEvtInfo));
537 discFaultInfo.moduleType = MODULE_TYPE_DISCOVERY;
538 discFaultInfo.linkType = medium;
539 discFaultInfo.errorCode = errCode;
540 if (SoftBusReportBusCenterFaultEvt(&discFaultInfo) != SOFTBUS_OK) {
541 MLOGE("report disc fault evt fail");
542 return SOFTBUS_ERR;
543 }
544 return SOFTBUS_OK;
545 }
546
InitDiscStatisticSysEvt(void)547 int32_t InitDiscStatisticSysEvt(void)
548 {
549 ListInit(&g_discDetailList);
550 if (InitDiscEvtMutexLock() != SOFTBUS_OK) {
551 MLOGE("disc Statistic Evt Lock Init Fail!");
552 return SOFTBUS_ERR;
553 }
554 ClearDiscDetails();
555 ClearBleRssi();
556 ClearFirstDiscTime();
557
558 SetStatisticEvtReportFunc(SOFTBUS_STATISTIC_EVT_DISC_BLE_RSSI, SoftBusReportDiscBleRssiEvt);
559 SetStatisticEvtReportFunc(SOFTBUS_STATISTIC_EVT_DISC_DETAILS, SoftBusReportDiscDetailsEvt);
560 SetStatisticEvtReportFunc(SOFTBUS_STATISTIC_EVT_FIRST_DISC_DURATION, SoftBusReportFirstDiscDurationEvt);
561 return SOFTBUS_OK;
562 }
DestroyMutex()563 static void DestroyMutex()
564 {
565 SoftBusMutexDestroy(&g_discDetailLock);
566 SoftBusMutexDestroy(&g_bleRssiRangeLock);
567 for (int32_t i = SOFTBUS_HISYSEVT_DISC_MEDIUM_BLE; i < SOFTBUS_HISYSEVT_DISC_MEDIUM_BUTT; i++) {
568 SoftBusMutexDestroy(&g_firstDiscTime[i].lock);
569 }
570 }
571
DeinitDiscStatisticSysEvt(void)572 void DeinitDiscStatisticSysEvt(void)
573 {
574 ClearDiscDetails();
575 DestroyMutex();
576 }