1 /*
2  * Copyright (c) 2022-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  * 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_bus_center.h"
17 
18 #include "comm_log.h"
19 #include "securec.h"
20 #include "softbus_adapter_hisysevent.h"
21 #include "softbus_adapter_mem.h"
22 #include "softbus_def.h"
23 #include "softbus_error_code.h"
24 #include "softbus_hisysevt_common.h"
25 
26 #define BUS_CENTER_PARAM_TOTAL_TIME "TOTAL_TIME"
27 #define BUS_CENTER_PARAM_TOTAL_COUNT "TOTAL_COUNT"
28 #define BUS_CENTER_PARAM_COUNT1 "COUNT1"
29 #define BUS_CENTER_PARAM_COUNT2 "COUNT2"
30 #define BUS_CENTER_PARAM_COUNT3 "COUNT3"
31 #define BUS_CENTER_PARAM_COUNT4 "COUNT4"
32 #define BUS_CENTER_PARAM_COUNT5 "COUNT5"
33 #define BUS_CENTER_PARAM_SOFT_BUS_VERSION "SOFT_BUS_VERSION"
34 #define BUS_CENTER_PARAM_LINK_TYPE "LINK_TYPE"
35 #define BUS_CENTER_PARAM_PACKAGE_VERSION "PACKAGE_VERSION"
36 
37 #define BUS_CENTER_PARAM_FAIL_TOTAL_COUNT "FAIL_TOTAL_COUNT"
38 #define BUS_CENTER_PARAM_FAIL_TOTAL_TIME "FAIL_TOTAL_TIME"
39 #define BUS_CENTER_PARAM_CONNECT_FAIL_TOTAL_COUNT "CONNECT_FAIL_TOTAL_COUNT"
40 #define BUS_CENTER_PARAM_AUTH_FAIL_TOTAL_COUNT "AUTH_FAIL_TOTAL_COUNT"
41 #define BUS_CENTER_PARAM_EXCHANGE_FAIL_TOTAL_COUNT "EXCHANGE_FAIL_TOTAL_COUNT"
42 
43 #define BUS_CENTER_ONLINE_DEVICE_NUM "ONLINE_DEVICE_NUM"
44 #define BUS_CENTER_BT_ONLINE_DEVICE_NUM "BT_ONLINE_DEVICE_NUM"
45 #define BUS_CENTER_WIFI_ONLINE_DEVICE_NUM "WIFI_ONLINE_DEVICE_NUM"
46 #define BUS_CENTER_PEER_DEVICE_TYPE "PEER_DEVICE_TYPE"
47 #define BUS_CENTER_PEER_SOFT_BUS_VERSION "PEER_SOFT_BUS_VERSION"
48 #define BUS_CENTER_PEER_DEVICE_NAME "PEER_DEVICE_NAME"
49 #define BUS_CENTER_INSERT_PROFILE_RESULT "INSERT_PROFILE_RESULT"
50 #define BUS_CENTER_PEER_PACKAGE_VERSION "PEER_PACKAGE_VERSION"
51 
52 #define FAULT_EVT_PARAM_MODULE_TYPE "MODULE_TYPE"
53 #define FAULT_EVT_PARAM_BUSUNINESS_NAME "BUSUNINESS_NAME"
54 #define FAULT_EVT_PARAM_ERROR_CODE "ERROR_CODE"
55 #define FAULT_EVT_PARAM_CALLER_PACKAGE_NAME "CALLER_PACKAGE_NAME"
56 #define FAULT_EVT_PARAM_REMOTE_BIZ_TRUNCATED_UUID "REMOTE_BIZ_TRUNCATED_UUID"
57 #define FAULT_EVT_PARAM_CHANNEL_QUALITY "CHANNEL_QUALITY"
58 #define FAULT_EVT_PARAM_CONNECTION_NUM "CONNECTION_NUM"
59 #define FAULT_EVT_PARAM_NIGHT_MODE "NIGHT_MODE"
60 #define FAULT_EVT_PARAM_WIFI_STATUS "WIFI_STATUS"
61 #define FAULT_EVT_PARAM_BLUETOOTH_STATUS "BLUETOOTH_STATUS"
62 #define FAULT_EVT_PARAM_CALLER_APP_MODE "CALLER_APP_MODE"
63 #define FAULT_EVT_PARAM_SUB_ERROR_CODE "SUB_ERROR_CODE"
64 #define FAULT_EVT_PARAM_CONN_BR_NUM "CONN_BR_NUM"
65 #define FAULT_EVT_PARAM_CONN_BLE_NUM "CONN_BLE_NUM"
66 #define FAULT_EVT_PARAM_BLE_BROADCAST_STATUS "BLUETOOTH_BROADCAST_STATUS"
67 #define FAULT_EVT_PARAM_BLE_SCAN_STATUS "BLUETOOTH_SCAN_STATUS"
68 
69 #define BUS_CENTER_START_DISCOVERY_COUNT "START_DISCOVERY_COUNT"
70 #define BUS_CENTER_SEND_BROADCAST_COUNT "SEND_BROADCAST_COUNT"
71 #define BUS_CENTER_RECEIVER_BROADCAST_COUNT "RECEIVE_BROADCAST_COUNT"
72 #define BUS_CENTER_DEVICE_FOUND_COUNT "DEVICE_FOUND_COUNT"
73 #define BUS_CENTER_BUSINESS_DISCOVERY_COUNT "BUSINESS_DISCOVERY_COUNT"
74 #define BUS_CENTER_BUSINESS_DISCOVERY_DETAIL "BUSINESS_DISCOVERY_DETAIL"
75 
76 #define BUS_CENTER_APP_NAME "APP_NAME"
77 #define BUS_CENTER_APP_DISCOVERY_COUNT "APP_DISCOVERY_COUNT"
78 
79 #define BUS_CENTER_DURATION_PARAM_NUM 10
80 #define ONLINE_DURATION_STATISTIC_PARAM_NUM 9
81 #define AUTH_RESULT_STATISTIC_PARAM_NUM 15
82 #define ONLINE_INFO_STATISTIC_PARAM_NUM 10
83 #define SOFTBUS_FAULT_EVT_PARAM_NUM 21
84 #define DEV_DISCOVERY_STATISTIC_PARAM_NUM 8
85 #define APP_DISCOVERY_STATISTIC_PARAM_NUM 2
86 
87 #define SECOND_TO_MSENC 1000
88 #define MILLISECOND_TO_MICRO 1000
89 
90 typedef enum {
91     LNN_TIME_STANDARD_S = 800, // ms
92     LNN_TIME_STANDARD_A = 1000,
93     LNN_TIME_STANDARD_B = 1200,
94     LNN_TIME_STANDARD_C = 1500,
95     LNN_TIME_STANDARD_D = 1800,
96 } BusCenterThreshold;
97 
98 typedef enum {
99     ONLINE_TIME_STANDARD_S = 10, // s
100     ONLINE_TIME_STANDARD_A = 30,
101     ONLINE_TIME_STANDARD_B = 300,
102     ONLINE_TIME_STANDARD_C = 600,
103     ONLINE_TIME_STANDARD_D = 900,
104 } OnlineThreshold;
105 
106 typedef enum {
107     AUTH_TIME_STANDARD_S = 2000, // ms
108     AUTH_TIME_STANDARD_A = 2500,
109     AUTH_TIME_STANDARD_B = 3000,
110     AUTH_TIME_STANDARD_C = 3500,
111     AUTH_TIME_STANDARD_D = 4000,
112 } AuthThreshold;
113 
114 typedef struct {
115     SoftBusMutex lock;
116     uint8_t linkType;
117     uint64_t totalTime;
118     uint32_t totalCount;
119     uint32_t count1;
120     uint32_t count2;
121     uint32_t count3;
122     uint32_t count4;
123     uint32_t count5;
124     char softBusVer[SOFTBUS_HISYSEVT_NAME_LEN];
125     char packName[SOFTBUS_HISYSEVT_NAME_LEN];
126 } BusCenterDuraRecord;
127 
128 typedef struct {
129     SoftBusMutex lock;
130     uint64_t totalTime;
131     uint32_t totalCount;
132     uint32_t count1;
133     uint32_t count2;
134     uint32_t count3;
135     uint32_t count4;
136     uint32_t count5;
137     char softBusVer[SOFTBUS_HISYSEVT_NAME_LEN];
138     char packName[SOFTBUS_HISYSEVT_NAME_LEN];
139 } DevOnlineDurRecord;
140 
141 typedef struct {
142     SoftBusMutex lock;
143     uint8_t linkType;
144     uint64_t authTotalTime;
145     uint32_t authTotalCount;
146     uint32_t authCount1;
147     uint32_t authCount2;
148     uint32_t authCount3;
149     uint32_t authCount4;
150     uint32_t authCount5;
151     uint64_t failTotalTime;
152     uint32_t failTotalCount;
153     uint32_t connFailTotalCount;
154     uint32_t authFailTotalCount;
155     uint32_t exchangeFailTotalCount;
156     char softBusVer[SOFTBUS_HISYSEVT_NAME_LEN];
157     char packName[SOFTBUS_HISYSEVT_NAME_LEN];
158 } AuthResultRecord;
159 
160 typedef struct {
161     SoftBusEvtParamType paramType;
162     char paramName[SOFTBUS_HISYSEVT_NAME_LEN];
163 } SoftBusEvtParamSize;
164 
165 typedef struct {
166     char udid[UDID_BUF_LEN];
167     uint32_t onlineDevNum;
168     uint32_t btOnlineDevNum;
169     uint32_t wifiOnlineDevNum;
170     ListNode node;
171 } DevUdidNode;
172 
173 typedef struct {
174     SoftBusMutex lock;
175     uint64_t startDiscoveryCnt;
176     uint64_t sendBroadCastCnt;
177     uint64_t recvBroadCastCnt;
178     uint64_t devFoundCnt;
179     uint64_t businessDiscoveryCnt;
180     char businessDiscoveryDetail[SOFTBUS_HISYSEVT_NAME_LEN];
181     char softBusVer[SOFTBUS_HISYSEVT_NAME_LEN];
182     char packName[SOFTBUS_HISYSEVT_NAME_LEN];
183 } DevDiscoveryRecord;
184 
185 static SoftBusEvtParamSize g_busCenterDurStaticParam[BUS_CENTER_DURATION_PARAM_NUM] = {
186     {SOFTBUS_EVT_PARAMTYPE_UINT32, BUS_CENTER_PARAM_LINK_TYPE},
187     {SOFTBUS_EVT_PARAMTYPE_UINT64, BUS_CENTER_PARAM_TOTAL_TIME},
188     {SOFTBUS_EVT_PARAMTYPE_UINT32, BUS_CENTER_PARAM_TOTAL_COUNT},
189     {SOFTBUS_EVT_PARAMTYPE_UINT32, BUS_CENTER_PARAM_COUNT1},
190     {SOFTBUS_EVT_PARAMTYPE_UINT32, BUS_CENTER_PARAM_COUNT2},
191     {SOFTBUS_EVT_PARAMTYPE_UINT32, BUS_CENTER_PARAM_COUNT3},
192     {SOFTBUS_EVT_PARAMTYPE_UINT32, BUS_CENTER_PARAM_COUNT4},
193     {SOFTBUS_EVT_PARAMTYPE_UINT32, BUS_CENTER_PARAM_COUNT5},
194     {SOFTBUS_EVT_PARAMTYPE_STRING, BUS_CENTER_PARAM_SOFT_BUS_VERSION},
195     {SOFTBUS_EVT_PARAMTYPE_STRING, BUS_CENTER_PARAM_PACKAGE_VERSION},
196 };
197 
198 static SoftBusEvtParamSize g_authResultParam[AUTH_RESULT_STATISTIC_PARAM_NUM] = {
199     {SOFTBUS_EVT_PARAMTYPE_UINT32, BUS_CENTER_PARAM_LINK_TYPE},
200     {SOFTBUS_EVT_PARAMTYPE_UINT64, BUS_CENTER_PARAM_TOTAL_TIME},
201     {SOFTBUS_EVT_PARAMTYPE_UINT32, BUS_CENTER_PARAM_TOTAL_COUNT},
202     {SOFTBUS_EVT_PARAMTYPE_UINT32, BUS_CENTER_PARAM_COUNT1},
203     {SOFTBUS_EVT_PARAMTYPE_UINT32, BUS_CENTER_PARAM_COUNT2},
204     {SOFTBUS_EVT_PARAMTYPE_UINT32, BUS_CENTER_PARAM_COUNT3},
205     {SOFTBUS_EVT_PARAMTYPE_UINT32, BUS_CENTER_PARAM_COUNT4},
206     {SOFTBUS_EVT_PARAMTYPE_UINT32, BUS_CENTER_PARAM_COUNT5},
207     {SOFTBUS_EVT_PARAMTYPE_UINT32, BUS_CENTER_PARAM_FAIL_TOTAL_COUNT},
208     {SOFTBUS_EVT_PARAMTYPE_UINT64, BUS_CENTER_PARAM_FAIL_TOTAL_TIME},
209     {SOFTBUS_EVT_PARAMTYPE_UINT32, BUS_CENTER_PARAM_CONNECT_FAIL_TOTAL_COUNT},
210     {SOFTBUS_EVT_PARAMTYPE_UINT32, BUS_CENTER_PARAM_AUTH_FAIL_TOTAL_COUNT},
211     {SOFTBUS_EVT_PARAMTYPE_UINT32, BUS_CENTER_PARAM_EXCHANGE_FAIL_TOTAL_COUNT},
212     {SOFTBUS_EVT_PARAMTYPE_STRING, BUS_CENTER_PARAM_SOFT_BUS_VERSION},
213     {SOFTBUS_EVT_PARAMTYPE_STRING, BUS_CENTER_PARAM_PACKAGE_VERSION},
214 };
215 
216 static SoftBusEvtParamSize g_onlineInfoStaticParam[ONLINE_INFO_STATISTIC_PARAM_NUM] = {
217     {SOFTBUS_EVT_PARAMTYPE_UINT32, BUS_CENTER_ONLINE_DEVICE_NUM},
218     {SOFTBUS_EVT_PARAMTYPE_UINT32, BUS_CENTER_BT_ONLINE_DEVICE_NUM},
219     {SOFTBUS_EVT_PARAMTYPE_UINT32, BUS_CENTER_WIFI_ONLINE_DEVICE_NUM},
220     {SOFTBUS_EVT_PARAMTYPE_UINT32, BUS_CENTER_PEER_DEVICE_TYPE},
221     {SOFTBUS_EVT_PARAMTYPE_UINT32, BUS_CENTER_INSERT_PROFILE_RESULT},
222     {SOFTBUS_EVT_PARAMTYPE_STRING, BUS_CENTER_PEER_SOFT_BUS_VERSION},
223     {SOFTBUS_EVT_PARAMTYPE_STRING, BUS_CENTER_PEER_DEVICE_NAME},
224     {SOFTBUS_EVT_PARAMTYPE_STRING, BUS_CENTER_PARAM_SOFT_BUS_VERSION},
225     {SOFTBUS_EVT_PARAMTYPE_STRING, BUS_CENTER_PEER_PACKAGE_VERSION},
226     {SOFTBUS_EVT_PARAMTYPE_STRING, BUS_CENTER_PARAM_PACKAGE_VERSION},
227 };
228 
229 static SoftBusEvtParamSize g_softBusFailEvtParam[SOFTBUS_FAULT_EVT_PARAM_NUM] = {
230     {SOFTBUS_EVT_PARAMTYPE_UINT32, FAULT_EVT_PARAM_MODULE_TYPE},
231     {SOFTBUS_EVT_PARAMTYPE_UINT32, BUS_CENTER_PARAM_LINK_TYPE},
232     {SOFTBUS_EVT_PARAMTYPE_FLOAT, FAULT_EVT_PARAM_CHANNEL_QUALITY},
233     {SOFTBUS_EVT_PARAMTYPE_INT32, FAULT_EVT_PARAM_ERROR_CODE},
234     {SOFTBUS_EVT_PARAMTYPE_INT32, BUS_CENTER_PEER_DEVICE_TYPE},
235     {SOFTBUS_EVT_PARAMTYPE_INT32, BUS_CENTER_ONLINE_DEVICE_NUM},
236     {SOFTBUS_EVT_PARAMTYPE_INT32, FAULT_EVT_PARAM_CONNECTION_NUM},
237     {SOFTBUS_EVT_PARAMTYPE_INT32, FAULT_EVT_PARAM_NIGHT_MODE},
238     {SOFTBUS_EVT_PARAMTYPE_INT32, FAULT_EVT_PARAM_WIFI_STATUS},
239     {SOFTBUS_EVT_PARAMTYPE_INT32, FAULT_EVT_PARAM_BLUETOOTH_STATUS},
240     {SOFTBUS_EVT_PARAMTYPE_INT32, FAULT_EVT_PARAM_CALLER_APP_MODE},
241     {SOFTBUS_EVT_PARAMTYPE_INT32, FAULT_EVT_PARAM_SUB_ERROR_CODE},
242     {SOFTBUS_EVT_PARAMTYPE_INT32, FAULT_EVT_PARAM_CONN_BR_NUM},
243     {SOFTBUS_EVT_PARAMTYPE_INT32, FAULT_EVT_PARAM_CONN_BLE_NUM},
244     {SOFTBUS_EVT_PARAMTYPE_INT32, FAULT_EVT_PARAM_BLE_BROADCAST_STATUS},
245     {SOFTBUS_EVT_PARAMTYPE_INT32, FAULT_EVT_PARAM_BLE_SCAN_STATUS},
246     {SOFTBUS_EVT_PARAMTYPE_STRING, FAULT_EVT_PARAM_BUSUNINESS_NAME},
247     {SOFTBUS_EVT_PARAMTYPE_STRING, FAULT_EVT_PARAM_CALLER_PACKAGE_NAME},
248     {SOFTBUS_EVT_PARAMTYPE_STRING, FAULT_EVT_PARAM_REMOTE_BIZ_TRUNCATED_UUID},
249     {SOFTBUS_EVT_PARAMTYPE_STRING, BUS_CENTER_PARAM_SOFT_BUS_VERSION},
250     {SOFTBUS_EVT_PARAMTYPE_STRING, BUS_CENTER_PARAM_PACKAGE_VERSION},
251 };
252 
253 static SoftBusEvtParamSize g_devDiscoveryStaticParam[DEV_DISCOVERY_STATISTIC_PARAM_NUM] = {
254     {SOFTBUS_EVT_PARAMTYPE_UINT64, BUS_CENTER_START_DISCOVERY_COUNT},
255     {SOFTBUS_EVT_PARAMTYPE_UINT64, BUS_CENTER_SEND_BROADCAST_COUNT},
256     {SOFTBUS_EVT_PARAMTYPE_UINT64, BUS_CENTER_RECEIVER_BROADCAST_COUNT},
257     {SOFTBUS_EVT_PARAMTYPE_UINT64, BUS_CENTER_DEVICE_FOUND_COUNT},
258     {SOFTBUS_EVT_PARAMTYPE_UINT64, BUS_CENTER_BUSINESS_DISCOVERY_COUNT},
259     {SOFTBUS_EVT_PARAMTYPE_STRING, BUS_CENTER_BUSINESS_DISCOVERY_DETAIL},
260     {SOFTBUS_EVT_PARAMTYPE_STRING, BUS_CENTER_PARAM_SOFT_BUS_VERSION},
261     {SOFTBUS_EVT_PARAMTYPE_STRING, BUS_CENTER_PARAM_PACKAGE_VERSION},
262 };
263 
264 static SoftBusEvtParamSize g_appDiscoveryStaticParam[APP_DISCOVERY_STATISTIC_PARAM_NUM] = {
265     {SOFTBUS_EVT_PARAMTYPE_STRING, BUS_CENTER_APP_NAME},
266     {SOFTBUS_EVT_PARAMTYPE_UINT32, BUS_CENTER_APP_DISCOVERY_COUNT},
267 };
268 
269 static bool g_isBusCenterDfxInit = false;
270 static char *g_packageVersion = "PackageVersion";
271 static char *g_softbusVersion = "hm.1.0.0";
272 static char *g_discoveryDetail = "DiscoveryDetail";
273 static char *g_busuninessName = "DefaultBusName";
274 static char *g_callerPkgName = "DefaultPkgName";
275 static char *g_remoteBizUuid = "DefaultBizUuid";
276 static char *g_deviceName = "DefaultDevName";
277 
278 static SoftBusMutex g_devUdidLock;
279 static SoftBusMutex g_appDiscLock;
280 static LIST_HEAD(g_devUdidList);
281 static LIST_HEAD(g_appDiscList);
282 BusCenterDuraRecord g_busCenterRecord[SOFTBUS_HISYSEVT_LINK_TYPE_BUTT];
283 AuthResultRecord g_authResultRecord[SOFTBUS_HISYSEVT_LINK_TYPE_BUTT];
284 DevOnlineDurRecord g_devOnlineDurRecord;
285 DevDiscoveryRecord g_devDiscoveryRecord;
286 
LnnUpTimeMs(void)287 int64_t LnnUpTimeMs(void)
288 {
289     SoftBusSysTime t;
290     t.sec = 0;
291     t.usec = 0;
292     SoftBusGetTime(&t);
293     int64_t when = t.sec * SECOND_TO_MSENC + t.usec / MILLISECOND_TO_MICRO;
294     return when;
295 }
296 
AddUdidInfoNodeToList(OnlineDeviceInfo * info,const char * udid)297 static int32_t AddUdidInfoNodeToList(OnlineDeviceInfo *info, const char *udid)
298 {
299     if (udid == NULL || info == NULL) {
300         COMM_LOGE(COMM_EVENT, "invalid param");
301         return SOFTBUS_INVALID_PARAM;
302     }
303     DevUdidNode *udidNode = SoftBusCalloc(sizeof(DevUdidNode));
304     if (udidNode == NULL) {
305         COMM_LOGE(COMM_EVENT, "malloc udid info node fail");
306         return SOFTBUS_MALLOC_ERR;
307     }
308     if (strcpy_s(udidNode->udid, UDID_BUF_LEN, udid) != EOK) {
309         COMM_LOGE(COMM_EVENT, "strcpy_s udid fail");
310         SoftBusFree(udidNode);
311         return SOFTBUS_STRCPY_ERR;
312     }
313     udidNode->onlineDevNum = info->onlineDevNum;
314     udidNode->btOnlineDevNum = info->btOnlineDevNum;
315     udidNode->wifiOnlineDevNum = info->wifiOnlineDevNum;
316     if (SoftBusMutexLock(&g_devUdidLock) != SOFTBUS_OK) {
317         SoftBusFree(udidNode);
318         COMM_LOGE(COMM_EVENT, "device udid list lock fail");
319         return false;
320     }
321     ListTailInsert(&g_devUdidList, &udidNode->node);
322     (void)SoftBusMutexUnlock(&g_devUdidLock);
323     return SOFTBUS_OK;
324 }
325 
ReleaseDevUdidInfoNode(void)326 static void ReleaseDevUdidInfoNode(void)
327 {
328     if (SoftBusMutexLock(&g_devUdidLock) != SOFTBUS_OK) {
329         COMM_LOGE(COMM_EVENT, "device udid list lock fail");
330         return;
331     }
332     DevUdidNode *item = NULL;
333     DevUdidNode *nextItem = NULL;
334     if (g_devUdidList.prev == NULL && g_devUdidList.next == NULL) {
335         COMM_LOGE(COMM_EVENT, "g_devUdidList is NULL");
336         ListInit(&g_devUdidList);
337         (void)SoftBusMutexUnlock(&g_devUdidLock);
338         return;
339     }
340     LIST_FOR_EACH_ENTRY_SAFE(item, nextItem, &g_devUdidList, DevUdidNode, node) {
341         ListDelete(&item->node);
342         SoftBusFree(item);
343     }
344     ListInit(&g_devUdidList);
345     (void)SoftBusMutexUnlock(&g_devUdidLock);
346 }
347 
IsUdidAlreadyReported(OnlineDeviceInfo * info,const char * udid)348 static bool IsUdidAlreadyReported(OnlineDeviceInfo *info, const char *udid)
349 {
350     if (SoftBusMutexLock(&g_devUdidLock) != SOFTBUS_OK) {
351         COMM_LOGE(COMM_EVENT, "device udid list lock fail");
352         return false;
353     }
354     DevUdidNode *item = NULL;
355     LIST_FOR_EACH_ENTRY(item, &g_devUdidList, DevUdidNode, node) {
356         if (strcmp(item->udid, udid) == 0 && item->onlineDevNum == info->onlineDevNum &&
357             item->btOnlineDevNum == info->btOnlineDevNum && item->wifiOnlineDevNum == info->wifiOnlineDevNum) {
358             (void)SoftBusMutexUnlock(&g_devUdidLock);
359             return true;
360         }
361     }
362     (void)SoftBusMutexUnlock(&g_devUdidLock);
363     return false;
364 }
365 
InitDevDiscoveryEvtMutexLock(void)366 static int32_t InitDevDiscoveryEvtMutexLock(void)
367 {
368     SoftBusMutexAttr mutexAttr = {SOFTBUS_MUTEX_RECURSIVE};
369     if (SoftBusMutexInit(&(g_devDiscoveryRecord.lock), &mutexAttr) != SOFTBUS_OK) {
370         COMM_LOGE(COMM_EVENT, "mutex init fail");
371         return SOFTBUS_LOCK_ERR;
372     }
373     return SOFTBUS_OK;
374 }
375 
CleanDevDiscoveryRecord(void)376 static void CleanDevDiscoveryRecord(void)
377 {
378     if (SoftBusMutexLock(&(g_devDiscoveryRecord.lock)) != SOFTBUS_OK) {
379         COMM_LOGE(COMM_EVENT, "lock fail");
380         return;
381     }
382     g_devDiscoveryRecord.startDiscoveryCnt = 0;
383     g_devDiscoveryRecord.sendBroadCastCnt = 0;
384     g_devDiscoveryRecord.recvBroadCastCnt = 0;
385     g_devDiscoveryRecord.devFoundCnt = 0;
386     g_devDiscoveryRecord.businessDiscoveryCnt = 0;
387     (void)SoftBusMutexUnlock(&(g_devDiscoveryRecord.lock));
388 }
389 
SetDevDiscStaticMsgParamName(SoftBusEvtReportMsg * msg)390 static int32_t SetDevDiscStaticMsgParamName(SoftBusEvtReportMsg *msg)
391 {
392     SoftBusEvtParam *param = NULL;
393     for (int i = SOFTBUS_EVT_PARAM_ZERO; i < DEV_DISCOVERY_STATISTIC_PARAM_NUM; i++) {
394         param = &msg->paramArray[i];
395         param->paramType = g_devDiscoveryStaticParam[i].paramType;
396         if (strcpy_s(param->paramName, SOFTBUS_HISYSEVT_PARAM_LEN, g_devDiscoveryStaticParam[i].paramName) != EOK) {
397             COMM_LOGE(COMM_EVENT, "copy param fail. paramName=%{public}s", g_devDiscoveryStaticParam[i].paramName);
398             return SOFTBUS_STRCPY_ERR;
399         }
400     }
401     return SOFTBUS_OK;
402 }
403 
SetDevDiscStaticMsgParamValve(SoftBusEvtReportMsg * msg,DevDiscoveryRecord * record)404 static int32_t SetDevDiscStaticMsgParamValve(SoftBusEvtReportMsg *msg, DevDiscoveryRecord *record)
405 {
406     msg->paramArray[SOFTBUS_EVT_PARAM_ZERO].paramValue.u64v = record->startDiscoveryCnt;
407     msg->paramArray[SOFTBUS_EVT_PARAM_ONE].paramValue.u64v = record->sendBroadCastCnt;
408     msg->paramArray[SOFTBUS_EVT_PARAM_TWO].paramValue.u64v = record->recvBroadCastCnt;
409     msg->paramArray[SOFTBUS_EVT_PARAM_THREE].paramValue.u64v = record->devFoundCnt;
410     msg->paramArray[SOFTBUS_EVT_PARAM_FOUR].paramValue.u64v = record->businessDiscoveryCnt;
411     if (strcpy_s(msg->paramArray[SOFTBUS_EVT_PARAM_FIVE].paramValue.str, SOFTBUS_HISYSEVT_NAME_LEN,
412         g_discoveryDetail) != EOK) {
413         COMM_LOGE(COMM_EVENT, "copy discoveryDetail fail");
414         return SOFTBUS_STRCPY_ERR;
415     }
416     if (strcpy_s(msg->paramArray[SOFTBUS_EVT_PARAM_SIX].paramValue.str, SOFTBUS_HISYSEVT_NAME_LEN,
417         g_softbusVersion) != EOK) {
418         COMM_LOGE(COMM_EVENT, "copy softbus version fail");
419         return SOFTBUS_STRCPY_ERR;
420     }
421     if (strcpy_s(msg->paramArray[SOFTBUS_EVT_PARAM_SEVEN].paramValue.str, SOFTBUS_HISYSEVT_NAME_LEN,
422         g_packageVersion) != EOK) {
423         COMM_LOGE(COMM_EVENT, "copy package ver fail");
424         return SOFTBUS_STRCPY_ERR;
425     }
426     return SOFTBUS_OK;
427 }
428 
SoftBusCreateDevDiscStaticMsg(SoftBusEvtReportMsg * msg)429 static int32_t SoftBusCreateDevDiscStaticMsg(SoftBusEvtReportMsg *msg)
430 {
431     if (strcpy_s(msg->evtName, SOFTBUS_HISYSEVT_NAME_LEN, STATISTIC_EVT_DEVICE_DISCOVERY) != EOK) {
432         COMM_LOGE(COMM_EVENT,
433             "strcpy evtname fail. STATISTIC_EVT_DEVICE_DISCOVERY=%{public}s", STATISTIC_EVT_DEVICE_DISCOVERY);
434         return SOFTBUS_STRCPY_ERR;
435     }
436     msg->evtType = SOFTBUS_EVT_TYPE_STATISTIC;
437     msg->paramNum = DEV_DISCOVERY_STATISTIC_PARAM_NUM;
438     int32_t ret = SetDevDiscStaticMsgParamName(msg);
439     if (ret != SOFTBUS_OK) {
440         COMM_LOGE(COMM_EVENT, "device discovery statistic msg set param name fail");
441         return ret;
442     }
443     if (SoftBusMutexLock(&(g_devDiscoveryRecord.lock)) != SOFTBUS_OK) {
444         COMM_LOGE(COMM_EVENT, "create device disc static msg lock fail");
445         return SOFTBUS_LOCK_ERR;
446     }
447     ret = SetDevDiscStaticMsgParamValve(msg, &g_devDiscoveryRecord);
448     if (ret != SOFTBUS_OK) {
449         COMM_LOGE(COMM_EVENT, "device discovery statistic msg set param valve fail");
450         (void)SoftBusMutexUnlock(&(g_devDiscoveryRecord.lock));
451         return ret;
452     }
453     (void)SoftBusMutexUnlock(&(g_devDiscoveryRecord.lock));
454     return SOFTBUS_OK;
455 }
456 
IsNeedReportDevDiscoveryRecordEvt(void)457 static bool IsNeedReportDevDiscoveryRecordEvt(void)
458 {
459     DevDiscoveryRecord *record = &g_devDiscoveryRecord;
460     if (SoftBusMutexLock(&(record->lock)) != SOFTBUS_OK) {
461         COMM_LOGE(COMM_EVENT, "lock fail");
462         return false;
463     }
464     if ((record->businessDiscoveryCnt == 0) && (record->devFoundCnt == 0) && (record->recvBroadCastCnt == 0)
465         && (record->sendBroadCastCnt == 0) && (record->startDiscoveryCnt == 0)) {
466         (void)SoftBusMutexUnlock(&(record->lock));
467         return false;
468     }
469     (void)SoftBusMutexUnlock(&(record->lock));
470     return true;
471 }
472 
ReportDevDiscoveryRecordEvt(void)473 static int32_t ReportDevDiscoveryRecordEvt(void)
474 {
475     COMM_LOGD(COMM_EVENT, "report device discovery record evt enter");
476     if (!IsNeedReportDevDiscoveryRecordEvt()) {
477         COMM_LOGD(COMM_EVENT, "this time do not need report device discovery record evt");
478         return SOFTBUS_OK;
479     }
480     SoftBusEvtReportMsg *msg = SoftbusCreateEvtReportMsg(DEV_DISCOVERY_STATISTIC_PARAM_NUM);
481     if (msg == NULL) {
482         COMM_LOGE(COMM_EVENT, "create discovery statistic report msg fail");
483         return SOFTBUS_MALLOC_ERR;
484     }
485     int32_t ret = SOFTBUS_OK;
486     do {
487         ret = SoftBusCreateDevDiscStaticMsg(msg);
488         if (ret != SOFTBUS_OK) {
489             COMM_LOGE(COMM_EVENT, "create device discovery statistic report msg fail");
490             break;
491         }
492         ret = SoftbusWriteHisEvt(msg);
493         if (ret != SOFTBUS_OK) {
494             COMM_LOGE(COMM_EVENT, "write device discovery statistic hisevt fail");
495             break;
496         }
497     } while (false);
498     SoftbusFreeEvtReportMsg(msg);
499     CleanDevDiscoveryRecord();
500     return ret;
501 }
502 
ReleaseAppDiscInfoNode(void)503 static void ReleaseAppDiscInfoNode(void)
504 {
505     if (SoftBusMutexLock(&g_appDiscLock) != SOFTBUS_OK) {
506         COMM_LOGE(COMM_EVENT, "release app disc info node lock fail");
507         return;
508     }
509     AppDiscNode *item = NULL;
510     AppDiscNode *nextItem = NULL;
511     if (g_appDiscList.prev == NULL && g_appDiscList.next == NULL) {
512         COMM_LOGE(COMM_EVENT, "g_appDiscList is NULL");
513         ListInit(&g_appDiscList);
514         (void)SoftBusMutexUnlock(&g_appDiscLock);
515         return;
516     }
517     LIST_FOR_EACH_ENTRY_SAFE(item, nextItem, &g_appDiscList, AppDiscNode, node) {
518         ListDelete(&item->node);
519         SoftBusFree(item);
520     }
521     ListInit(&g_appDiscList);
522     (void)SoftBusMutexUnlock(&g_appDiscLock);
523 }
524 
AddAppDiscInfoNodeToList(AppDiscNode * discNode)525 static int32_t AddAppDiscInfoNodeToList(AppDiscNode *discNode)
526 {
527     if (discNode == NULL) {
528         COMM_LOGE(COMM_EVENT, "invalid param");
529         return SOFTBUS_INVALID_PARAM;
530     }
531     AppDiscNode *newDiscNode = SoftBusCalloc(sizeof(AppDiscNode));
532     if (newDiscNode == NULL) {
533         COMM_LOGE(COMM_EVENT, "malloc AppDiscNode fail");
534         return SOFTBUS_MALLOC_ERR;
535     }
536     newDiscNode->appDiscCnt = discNode->appDiscCnt;
537     if (strcpy_s(newDiscNode->appName, SOFTBUS_HISYSEVT_NAME_LEN, discNode->appName) != EOK) {
538         COMM_LOGE(COMM_EVENT, "copy app name fail");
539         SoftBusFree(newDiscNode);
540         return SOFTBUS_STRCPY_ERR;
541     }
542     if (SoftBusMutexLock(&g_appDiscLock) != SOFTBUS_OK) {
543         SoftBusFree(newDiscNode);
544         COMM_LOGE(COMM_EVENT, "lock fail");
545         return SOFTBUS_LOCK_ERR;
546     }
547     ListTailInsert(&g_appDiscList, &newDiscNode->node);
548     (void)SoftBusMutexUnlock(&g_appDiscLock);
549     return SOFTBUS_OK;
550 }
551 
SetAppDiscStaticMsgParamName(SoftBusEvtReportMsg * msg)552 static int32_t SetAppDiscStaticMsgParamName(SoftBusEvtReportMsg *msg)
553 {
554     SoftBusEvtParam *param = NULL;
555     for (int i = SOFTBUS_EVT_PARAM_ZERO; i < APP_DISCOVERY_STATISTIC_PARAM_NUM; i++) {
556         param = &msg->paramArray[i];
557         param->paramType = g_appDiscoveryStaticParam[i].paramType;
558         if (strcpy_s(param->paramName, SOFTBUS_HISYSEVT_PARAM_LEN, g_appDiscoveryStaticParam[i].paramName) != EOK) {
559             COMM_LOGE(COMM_EVENT,
560                 "strcpy_s param name fail. paramName=%{public}s", g_appDiscoveryStaticParam[i].paramName);
561             return SOFTBUS_STRCPY_ERR;
562         }
563     }
564     return SOFTBUS_OK;
565 }
566 
SetAppDiscStaticMsgParamValve(SoftBusEvtReportMsg * msg,AppDiscNode * discNode)567 static int32_t SetAppDiscStaticMsgParamValve(SoftBusEvtReportMsg *msg, AppDiscNode *discNode)
568 {
569     if (strcpy_s(msg->paramArray[SOFTBUS_EVT_PARAM_ZERO].paramValue.str, SOFTBUS_HISYSEVT_NAME_LEN,
570         discNode->appName) != EOK) {
571         COMM_LOGE(COMM_EVENT, "copy app name fail");
572         return SOFTBUS_STRCPY_ERR;
573     }
574     msg->paramArray[SOFTBUS_EVT_PARAM_ONE].paramValue.i32v = discNode->appDiscCnt;
575     return SOFTBUS_OK;
576 }
577 
SoftBusCreateAppDiscStaticMsg(SoftBusEvtReportMsg * msg,AppDiscNode * discNode)578 static int32_t SoftBusCreateAppDiscStaticMsg(SoftBusEvtReportMsg *msg, AppDiscNode *discNode)
579 {
580     if (msg == NULL || discNode == NULL) {
581         COMM_LOGE(COMM_EVENT, "invalid param");
582         return SOFTBUS_INVALID_PARAM;
583     }
584     if (strcpy_s(msg->evtName, SOFTBUS_HISYSEVT_NAME_LEN, STATISTIC_EVT_APP_DISCOVERY) != EOK) {
585         COMM_LOGE(COMM_EVENT,
586             "strcpy evt name fail. STATISTIC_EVT_APP_DISCOVERY=%{public}s", STATISTIC_EVT_APP_DISCOVERY);
587         return SOFTBUS_STRCPY_ERR;
588     }
589     msg->evtType = SOFTBUS_EVT_TYPE_STATISTIC;
590     msg->paramNum = APP_DISCOVERY_STATISTIC_PARAM_NUM;
591     int32_t ret = SetAppDiscStaticMsgParamName(msg);
592     if (ret != SOFTBUS_OK) {
593         COMM_LOGE(COMM_EVENT, "app discovery statistic msg set param name fail");
594         return ret;
595     }
596     ret = SetAppDiscStaticMsgParamValve(msg, discNode);
597     if (ret != SOFTBUS_OK) {
598         COMM_LOGE(COMM_EVENT, "app discovery statistic msg set param valve fail");
599         return ret;
600     }
601     return SOFTBUS_OK;
602 }
603 
ReportAppDiscoveryRecordEvt(void)604 static int32_t ReportAppDiscoveryRecordEvt(void)
605 {
606     COMM_LOGD(COMM_EVENT, "report app discovery record evt enter");
607     if (SoftBusMutexLock(&g_appDiscLock) != SOFTBUS_OK) {
608         COMM_LOGE(COMM_EVENT, "app disc list lock fail");
609         return SOFTBUS_LOCK_ERR;
610     }
611     if (IsListEmpty(&g_appDiscList)) {
612         COMM_LOGE(COMM_EVENT, "app disc list count=0");
613         (void)SoftBusMutexUnlock(&g_appDiscLock);
614         return SOFTBUS_OK;
615     }
616     AppDiscNode *item = NULL;
617     int32_t ret = SOFTBUS_OK;
618     LIST_FOR_EACH_ENTRY(item, &g_appDiscList, AppDiscNode, node) {
619         SoftBusEvtReportMsg *msg = SoftbusCreateEvtReportMsg(APP_DISCOVERY_STATISTIC_PARAM_NUM);
620         if (msg == NULL) {
621             COMM_LOGE(COMM_EVENT, "create app discovery statistic report msg fail");
622             (void)SoftBusMutexUnlock(&g_appDiscLock);
623             return SOFTBUS_MEM_ERR;
624         }
625         do {
626             ret = SoftBusCreateAppDiscStaticMsg(msg, item);
627             if (ret != SOFTBUS_OK) {
628                 COMM_LOGE(COMM_EVENT, "create app discovery statistic report msg fail");
629                 break;
630             }
631             ret = SoftbusWriteHisEvt(msg);
632             if (ret != SOFTBUS_OK) {
633                 COMM_LOGE(COMM_EVENT, "write app discovery statistic hisevt fail");
634                 break;
635             }
636         } while (false);
637         SoftbusFreeEvtReportMsg(msg);
638         if (ret != SOFTBUS_OK) {
639             (void)SoftBusMutexUnlock(&g_appDiscLock);
640             return ret;
641         }
642     }
643     (void)SoftBusMutexUnlock(&g_appDiscLock);
644     ReleaseAppDiscInfoNode();
645     return ret;
646 }
647 
SoftBusRecordDiscoveryResult(DiscoveryStage stage,AppDiscNode * discNode)648 int32_t SoftBusRecordDiscoveryResult(DiscoveryStage stage, AppDiscNode *discNode)
649 {
650     if (stage < START_DISCOVERY || stage > BUSINESS_DISCOVERY) {
651         COMM_LOGE(COMM_EVENT, "record discovery result param is invalid");
652         return SOFTBUS_INVALID_PARAM;
653     }
654     if (SoftBusMutexLock(&(g_devDiscoveryRecord.lock)) != SOFTBUS_OK) {
655         COMM_LOGE(COMM_EVENT, "device discovery result record lock fail");
656         return SOFTBUS_LOCK_ERR;
657     }
658     int32_t ret = SOFTBUS_OK;
659     bool isNeedToDiscList = false;
660     switch (stage) {
661         case START_DISCOVERY:
662             g_devDiscoveryRecord.startDiscoveryCnt++;
663             break;
664         case SEND_BROADCAST:
665             g_devDiscoveryRecord.sendBroadCastCnt++;
666             break;
667         case RECV_BROADCAST:
668             g_devDiscoveryRecord.recvBroadCastCnt++;
669             break;
670         case DEVICE_FOUND:
671             g_devDiscoveryRecord.devFoundCnt++;
672             break;
673         case BUSINESS_DISCOVERY:
674             isNeedToDiscList = true;
675             g_devDiscoveryRecord.businessDiscoveryCnt++;
676             break;
677         default:
678             break;
679     }
680     (void)SoftBusMutexUnlock(&(g_devDiscoveryRecord.lock));
681     if (isNeedToDiscList && (discNode == NULL || AddAppDiscInfoNodeToList(discNode) != SOFTBUS_OK)) {
682         ret = SOFTBUS_STRCPY_ERR;
683     }
684     return ret;
685 }
686 
SetBusCenterFaultMsgParamName(SoftBusEvtReportMsg * msg)687 static int32_t SetBusCenterFaultMsgParamName(SoftBusEvtReportMsg *msg)
688 {
689     SoftBusEvtParam *param = NULL;
690     for (int i = SOFTBUS_EVT_PARAM_ZERO; i < SOFTBUS_FAULT_EVT_PARAM_NUM; i++) {
691         param = &msg->paramArray[i];
692         param->paramType = g_softBusFailEvtParam[i].paramType;
693         if (strcpy_s(param->paramName, SOFTBUS_HISYSEVT_PARAM_LEN, g_softBusFailEvtParam[i].paramName) != EOK) {
694             COMM_LOGE(COMM_EVENT, "strcpy_s param name fail. paramName=%{public}s", g_softBusFailEvtParam[i].paramName);
695             return SOFTBUS_STRCPY_ERR;
696         }
697     }
698     return SOFTBUS_OK;
699 }
700 
SetBusCenterFaultMsgParamValve(SoftBusEvtReportMsg * msg,SoftBusFaultEvtInfo * info)701 static int32_t SetBusCenterFaultMsgParamValve(SoftBusEvtReportMsg *msg, SoftBusFaultEvtInfo *info)
702 {
703     msg->paramArray[SOFTBUS_EVT_PARAM_ZERO].paramValue.u32v = info->moduleType;
704     msg->paramArray[SOFTBUS_EVT_PARAM_ONE].paramValue.u32v = info->linkType;
705     msg->paramArray[SOFTBUS_EVT_PARAM_TWO].paramValue.f = info->channelQuality;
706     msg->paramArray[SOFTBUS_EVT_PARAM_THREE].paramValue.i32v = info->errorCode;
707     msg->paramArray[SOFTBUS_EVT_PARAM_FOUR].paramValue.i32v = info->peerDevType;
708     msg->paramArray[SOFTBUS_EVT_PARAM_FIVE].paramValue.i32v = info->onLineDevNum;
709     msg->paramArray[SOFTBUS_EVT_PARAM_SIX].paramValue.i32v = info->connNum;
710     msg->paramArray[SOFTBUS_EVT_PARAM_SEVEN].paramValue.i32v = info->nightMode;
711     msg->paramArray[SOFTBUS_EVT_PARAM_EIGHT].paramValue.i32v = info->wifiStatue;
712     msg->paramArray[SOFTBUS_EVT_PARAM_NINE].paramValue.i32v = info->bleStatue;
713     msg->paramArray[SOFTBUS_EVT_PARAM_TEN].paramValue.i32v = info->callerAppMode;
714     msg->paramArray[SOFTBUS_EVT_PARAM_ELEVEN].paramValue.i32v = info->subErrCode;
715     msg->paramArray[SOFTBUS_EVT_PARAM_TWELVE].paramValue.i32v = info->connBrNum;
716     msg->paramArray[SOFTBUS_EVT_PARAM_THIRTEEN].paramValue.i32v = info->connBleNum;
717     msg->paramArray[SOFTBUS_EVT_PARAM_FOURTEEN].paramValue.i32v = info->bleBradStatus;
718     msg->paramArray[SOFTBUS_EVT_PARAM_FIFTEEN].paramValue.i32v = info->bleScanStatus;
719     do {
720         if (strcpy_s(msg->paramArray[SOFTBUS_EVT_PARAM_SIXTEEN].paramValue.str, SOFTBUS_HISYSEVT_NAME_LEN,
721             g_busuninessName) != EOK) {
722             COMM_LOGE(COMM_EVENT, "strcpy business name fail");
723             break;
724         }
725         if (strcpy_s(msg->paramArray[SOFTBUS_EVT_PARAM_SEVENTEEN].paramValue.str, SOFTBUS_HISYSEVT_NAME_LEN,
726             g_callerPkgName) != EOK) {
727             COMM_LOGE(COMM_EVENT, "strcpy caller pack name fail");
728             break;
729         }
730         if (strcpy_s(msg->paramArray[SOFTBUS_EVT_PARAM_EIGHTEEN].paramValue.str, SOFTBUS_HISYSEVT_NAME_LEN,
731             g_remoteBizUuid) != EOK) {
732             COMM_LOGE(COMM_EVENT, "strcpy remote biz uuid fail");
733             break;
734         }
735         if (strcpy_s(msg->paramArray[SOFTBUS_EVT_PARAM_NINETEEN].paramValue.str, SOFTBUS_HISYSEVT_NAME_LEN,
736             g_softbusVersion) != EOK) {
737             COMM_LOGE(COMM_EVENT, "strcpy softbus version fail");
738             break;
739         }
740         if (strcpy_s(msg->paramArray[SOFTBUS_EVT_PARAM_TWENTY].paramValue.str, SOFTBUS_HISYSEVT_NAME_LEN,
741             g_packageVersion) != EOK) {
742             COMM_LOGE(COMM_EVENT, "strcpy package version fail");
743             break;
744         }
745         return SOFTBUS_OK;
746     } while (false);
747     return SOFTBUS_STRCPY_ERR;
748 }
749 
SoftBusCreateBusCenterFaultMsg(SoftBusEvtReportMsg * msg,SoftBusFaultEvtInfo * info)750 static int32_t SoftBusCreateBusCenterFaultMsg(SoftBusEvtReportMsg *msg, SoftBusFaultEvtInfo *info)
751 {
752     if (strcpy_s(msg->evtName, SOFTBUS_HISYSEVT_NAME_LEN, FAULT_EVT_BUS_CENTER) != EOK) {
753         COMM_LOGE(COMM_EVENT, "strcpy_s evt name fail. FAULT_EVT_BUS_CENTER=%{public}s", FAULT_EVT_BUS_CENTER);
754         return SOFTBUS_STRCPY_ERR;
755     }
756     msg->evtType = SOFTBUS_EVT_TYPE_FAULT;
757     msg->paramNum = SOFTBUS_FAULT_EVT_PARAM_NUM;
758     int32_t ret = SetBusCenterFaultMsgParamName(msg);
759     if (ret != SOFTBUS_OK) {
760         COMM_LOGE(COMM_EVENT, "set param name fail");
761         return ret;
762     }
763     ret = SetBusCenterFaultMsgParamValve(msg, info);
764     if (ret != SOFTBUS_OK) {
765         COMM_LOGE(COMM_EVENT, "set param valve fail");
766         return ret;
767     }
768     return SOFTBUS_OK;
769 }
770 
SoftBusReportBusCenterFaultEvt(SoftBusFaultEvtInfo * info)771 int32_t SoftBusReportBusCenterFaultEvt(SoftBusFaultEvtInfo *info)
772 {
773     if (info == NULL) {
774         COMM_LOGE(COMM_EVENT, "invalid param");
775         return SOFTBUS_INVALID_PARAM;
776     }
777     SoftBusEvtReportMsg *msg = SoftbusCreateEvtReportMsg(SOFTBUS_FAULT_EVT_PARAM_NUM);
778     if (msg == NULL) {
779         COMM_LOGE(COMM_EVENT, "alloc bus center fault evt report msg fail");
780         return SOFTBUS_MALLOC_ERR;
781     }
782     info->errorCode = GetErrorCodeEx(info->errorCode);
783     SoftBusCreateBusCenterFaultMsg(msg, info);
784     int ret = SoftbusWriteHisEvt(msg);
785     SoftbusFreeEvtReportMsg(msg);
786     if (ret != SOFTBUS_OK) {
787         COMM_LOGE(COMM_EVENT, "sys evt write buscenter fault msg fail");
788     }
789     return ret;
790 }
791 
InitAuthItemMutexLock(SoftBusLinkType linkType,SoftBusMutexAttr * mutexAttr)792 static int32_t InitAuthItemMutexLock(SoftBusLinkType linkType, SoftBusMutexAttr *mutexAttr)
793 {
794     if (SoftBusMutexInit(&(g_authResultRecord[linkType].lock), mutexAttr) != SOFTBUS_OK) {
795         COMM_LOGE(COMM_EVENT, "mutex init fail");
796         return SOFTBUS_LOCK_ERR;
797     }
798     return SOFTBUS_OK;
799 }
800 
InitAuthEvtMutexLock(void)801 static int32_t InitAuthEvtMutexLock(void)
802 {
803     SoftBusMutexAttr mutexAttr = {SOFTBUS_MUTEX_RECURSIVE};
804     int32_t ret = SOFTBUS_OK;
805     for (SoftBusLinkType linkType = SOFTBUS_HISYSEVT_LINK_TYPE_BR; linkType < SOFTBUS_HISYSEVT_LINK_TYPE_BUTT;
806         linkType++) {
807         ret = InitAuthItemMutexLock(linkType, &mutexAttr);
808         if (ret != SOFTBUS_OK) {
809             COMM_LOGE(COMM_EVENT, "lock fail");
810             break;
811         }
812     }
813     return ret;
814 }
815 
DeinitAuthEvtMutexLock(void)816 static void DeinitAuthEvtMutexLock(void)
817 {
818     for (SoftBusLinkType linkType = SOFTBUS_HISYSEVT_LINK_TYPE_BR; linkType < SOFTBUS_HISYSEVT_LINK_TYPE_BUTT;
819         linkType++) {
820         (void)SoftBusMutexDestroy(&(g_authResultRecord[linkType].lock));
821     }
822 }
823 
InitBusCenterItemMutexLock(SoftBusLinkType linkType,SoftBusMutexAttr * mutexAttr)824 static int32_t InitBusCenterItemMutexLock(SoftBusLinkType linkType, SoftBusMutexAttr *mutexAttr)
825 {
826     if (SoftBusMutexInit(&(g_busCenterRecord[linkType].lock), mutexAttr) != SOFTBUS_OK) {
827         COMM_LOGE(COMM_EVENT, "mutex init fail");
828         return SOFTBUS_LOCK_ERR;
829     }
830     return SOFTBUS_OK;
831 }
832 
InitBusCenterEvtMutexLock(void)833 static int32_t InitBusCenterEvtMutexLock(void)
834 {
835     SoftBusMutexAttr mutexAttr = {SOFTBUS_MUTEX_RECURSIVE};
836     int32_t ret = SOFTBUS_OK;
837     for (SoftBusLinkType linkType = SOFTBUS_HISYSEVT_LINK_TYPE_BR; linkType < SOFTBUS_HISYSEVT_LINK_TYPE_BUTT;
838         linkType++) {
839         ret = InitBusCenterItemMutexLock(linkType, &mutexAttr);
840         if (ret != SOFTBUS_OK) {
841             COMM_LOGE(COMM_EVENT, "lock fail");
842             break;
843         }
844     }
845     return ret;
846 }
847 
DeinitBusCenterEvtMutexLock(void)848 static void DeinitBusCenterEvtMutexLock(void)
849 {
850     for (SoftBusLinkType linkType = SOFTBUS_HISYSEVT_LINK_TYPE_BR; linkType < SOFTBUS_HISYSEVT_LINK_TYPE_BUTT;
851         linkType++) {
852         (void)SoftBusMutexDestroy(&(g_busCenterRecord[linkType].lock));
853     }
854 }
855 
InitDevOnlineDurEvtMutexLock(void)856 static int32_t InitDevOnlineDurEvtMutexLock(void)
857 {
858     SoftBusMutexAttr mutexAttr = {SOFTBUS_MUTEX_RECURSIVE};
859     if (SoftBusMutexInit(&(g_devOnlineDurRecord.lock), &mutexAttr) != SOFTBUS_OK) {
860         COMM_LOGE(COMM_EVENT, "mutex init fail");
861         return SOFTBUS_LOCK_ERR;
862     }
863     return SOFTBUS_OK;
864 }
865 
SetOnlineInfoMsgParamName(SoftBusEvtReportMsg * msg)866 static int32_t SetOnlineInfoMsgParamName(SoftBusEvtReportMsg *msg)
867 {
868     SoftBusEvtParam *param = NULL;
869     for (int i = SOFTBUS_EVT_PARAM_ZERO; i < ONLINE_INFO_STATISTIC_PARAM_NUM; i++) {
870         param = &msg->paramArray[i];
871         param->paramType = g_onlineInfoStaticParam[i].paramType;
872         if (strcpy_s(param->paramName, SOFTBUS_HISYSEVT_PARAM_LEN, g_onlineInfoStaticParam[i].paramName) != EOK) {
873             COMM_LOGE(COMM_EVENT,
874                 "strcpy_s param name fail. paramName=%{public}s", g_onlineInfoStaticParam[i].paramName);
875             return SOFTBUS_STRCPY_ERR;
876         }
877     }
878     return SOFTBUS_OK;
879 }
880 
SetOnlineInfoMsgParamValve(SoftBusEvtReportMsg * msg,OnlineDeviceInfo * info)881 static int32_t SetOnlineInfoMsgParamValve(SoftBusEvtReportMsg *msg, OnlineDeviceInfo *info)
882 {
883     msg->paramArray[SOFTBUS_EVT_PARAM_ZERO].paramValue.i32v = (int32_t)info->onlineDevNum;
884     msg->paramArray[SOFTBUS_EVT_PARAM_ONE].paramValue.i32v = (int32_t)info->btOnlineDevNum;
885     msg->paramArray[SOFTBUS_EVT_PARAM_TWO].paramValue.i32v = (int32_t)info->wifiOnlineDevNum;
886     msg->paramArray[SOFTBUS_EVT_PARAM_THREE].paramValue.i32v = (int32_t)info->peerDevType;
887     msg->paramArray[SOFTBUS_EVT_PARAM_FOUR].paramValue.i32v = info->insertFileResult;
888     do {
889         if (strcpy_s(msg->paramArray[SOFTBUS_EVT_PARAM_FIVE].paramValue.str, SOFTBUS_HISYSEVT_NAME_LEN,
890             g_softbusVersion) != EOK) {
891             COMM_LOGE(COMM_EVENT, "strcpy_s peer softbus version fail");
892             break;
893         }
894         if (strcpy_s(msg->paramArray[SOFTBUS_EVT_PARAM_SIX].paramValue.str, SOFTBUS_HISYSEVT_NAME_LEN,
895             g_deviceName) != EOK) {
896             COMM_LOGE(COMM_EVENT, "strcpy_s peer device name fail");
897             break;
898         }
899         if (strcpy_s(msg->paramArray[SOFTBUS_EVT_PARAM_SEVEN].paramValue.str, SOFTBUS_HISYSEVT_NAME_LEN,
900             g_softbusVersion) != EOK) {
901             COMM_LOGE(COMM_EVENT, "strcpy_s local softbus verion fail");
902             break;
903         }
904         if (strcpy_s(msg->paramArray[SOFTBUS_EVT_PARAM_EIGHT].paramValue.str, SOFTBUS_HISYSEVT_NAME_LEN,
905             g_packageVersion) != EOK) {
906             COMM_LOGE(COMM_EVENT, "strcpy_s peer package version fail");
907             break;
908         }
909         if (strcpy_s(msg->paramArray[SOFTBUS_EVT_PARAM_NINE].paramValue.str, SOFTBUS_HISYSEVT_NAME_LEN,
910             g_packageVersion) != EOK) {
911             COMM_LOGE(COMM_EVENT, "strcpy_s local package version fail");
912             break;
913         }
914         return SOFTBUS_OK;
915     } while (false);
916     return SOFTBUS_STRCPY_ERR;
917 }
918 
SoftBusCreateEvtMsgByInfo(SoftBusEvtReportMsg * msg,OnlineDeviceInfo * info)919 static int32_t SoftBusCreateEvtMsgByInfo(SoftBusEvtReportMsg *msg, OnlineDeviceInfo *info)
920 {
921     if (strcpy_s(msg->evtName, SOFTBUS_HISYSEVT_NAME_LEN, STATISTIC_EVT_DEVICE_ONLINE) != EOK) {
922         COMM_LOGE(COMM_EVENT,
923             "strcpy_s evtname fail. STATISTIC_EVT_DEVICE_ONLINE=%{public}s", STATISTIC_EVT_DEVICE_ONLINE);
924         return SOFTBUS_STRCPY_ERR;
925     }
926     msg->evtType = SOFTBUS_EVT_TYPE_STATISTIC;
927     msg->paramNum = ONLINE_INFO_STATISTIC_PARAM_NUM;
928     int32_t ret = SetOnlineInfoMsgParamName(msg);
929     if (ret != SOFTBUS_OK) {
930         COMM_LOGE(COMM_EVENT, "set online info msg param name fail");
931         return ret;
932     }
933     ret = SetOnlineInfoMsgParamValve(msg, info);
934     if (ret != SOFTBUS_OK) {
935         COMM_LOGE(COMM_EVENT, "set online info msg param valve fail");
936         return ret;
937     }
938     return SOFTBUS_OK;
939 }
940 
SoftBusReportDevOnlineEvt(OnlineDeviceInfo * info,const char * udid)941 int32_t SoftBusReportDevOnlineEvt(OnlineDeviceInfo *info, const char *udid)
942 {
943     if (info == NULL || udid == NULL) {
944         COMM_LOGE(COMM_EVENT, "invalid param");
945         return SOFTBUS_INVALID_PARAM;
946     }
947     if (IsUdidAlreadyReported(info, udid)) {
948         COMM_LOGE(COMM_EVENT, "device has already been reported");
949         return SOFTBUS_OK;
950     }
951     int32_t ret = AddUdidInfoNodeToList(info, udid);
952     if (ret != SOFTBUS_OK) {
953         COMM_LOGE(COMM_EVENT, "add online device info to list fail");
954         return ret;
955     }
956     SoftBusEvtReportMsg *msg = SoftbusCreateEvtReportMsg(ONLINE_INFO_STATISTIC_PARAM_NUM);
957     if (msg == NULL) {
958         COMM_LOGE(COMM_EVENT, "alloc device online evt report msg fail");
959         return SOFTBUS_MALLOC_ERR;
960     }
961     SoftBusCreateEvtMsgByInfo(msg, info);
962     ret = SoftbusWriteHisEvt(msg);
963     SoftbusFreeEvtReportMsg(msg);
964     if (ret != SOFTBUS_OK) {
965         COMM_LOGE(COMM_EVENT, "sysevt write online device info msg fail");
966     }
967     return ret;
968 }
969 
CleanAuthResultRecord(void)970 static void CleanAuthResultRecord(void)
971 {
972     for (SoftBusLinkType linkType = SOFTBUS_HISYSEVT_LINK_TYPE_BR; linkType < SOFTBUS_HISYSEVT_LINK_TYPE_BUTT;
973         linkType++) {
974         if (SoftBusMutexLock(&(g_authResultRecord[linkType].lock)) != SOFTBUS_OK) {
975             COMM_LOGE(COMM_EVENT, "lock fail");
976             return;
977         }
978         g_authResultRecord[linkType].linkType = linkType;
979         g_authResultRecord[linkType].authTotalTime = 0;
980         g_authResultRecord[linkType].authTotalCount = 0;
981         g_authResultRecord[linkType].authCount1 = 0;
982         g_authResultRecord[linkType].authCount2 = 0;
983         g_authResultRecord[linkType].authCount3 = 0;
984         g_authResultRecord[linkType].authCount4 = 0;
985         g_authResultRecord[linkType].authCount5 = 0;
986         g_authResultRecord[linkType].failTotalTime = 0;
987         g_authResultRecord[linkType].failTotalCount = 0;
988         g_authResultRecord[linkType].connFailTotalCount = 0;
989         g_authResultRecord[linkType].authFailTotalCount = 0;
990         g_authResultRecord[linkType].exchangeFailTotalCount = 0;
991         (void)SoftBusMutexUnlock(&(g_authResultRecord[linkType].lock));
992     }
993 }
994 
SetAuthResultMsgParamName(SoftBusEvtReportMsg * msg)995 static int32_t SetAuthResultMsgParamName(SoftBusEvtReportMsg *msg)
996 {
997     SoftBusEvtParam *param = NULL;
998     for (int i = SOFTBUS_EVT_PARAM_ZERO; i < AUTH_RESULT_STATISTIC_PARAM_NUM; i++) {
999         param = &msg->paramArray[i];
1000         param->paramType = g_authResultParam[i].paramType;
1001         if (strcpy_s(param->paramName, SOFTBUS_HISYSEVT_PARAM_LEN, g_authResultParam[i].paramName) != EOK) {
1002             COMM_LOGE(COMM_EVENT, "strcpy_s param name fail. paramName=%{public}s", g_authResultParam[i].paramName);
1003             return SOFTBUS_STRCPY_ERR;
1004         }
1005     }
1006     return SOFTBUS_OK;
1007 }
1008 
SetAuthResultMsgParamValve(SoftBusEvtReportMsg * msg,AuthResultRecord * record)1009 static int32_t SetAuthResultMsgParamValve(SoftBusEvtReportMsg *msg, AuthResultRecord *record)
1010 {
1011     msg->paramArray[SOFTBUS_EVT_PARAM_ZERO].paramValue.u32v = record->linkType;
1012     msg->paramArray[SOFTBUS_EVT_PARAM_ONE].paramValue.u64v = record->authTotalTime;
1013     msg->paramArray[SOFTBUS_EVT_PARAM_TWO].paramValue.u32v = record->authTotalCount;
1014     msg->paramArray[SOFTBUS_EVT_PARAM_THREE].paramValue.u32v = record->authCount1;
1015     msg->paramArray[SOFTBUS_EVT_PARAM_FOUR].paramValue.u32v = record->authCount2;
1016     msg->paramArray[SOFTBUS_EVT_PARAM_FIVE].paramValue.u32v = record->authCount3;
1017     msg->paramArray[SOFTBUS_EVT_PARAM_SIX].paramValue.u32v = record->authCount4;
1018     msg->paramArray[SOFTBUS_EVT_PARAM_SEVEN].paramValue.u32v = record->authCount5;
1019     msg->paramArray[SOFTBUS_EVT_PARAM_EIGHT].paramValue.u64v = record->failTotalTime;
1020     msg->paramArray[SOFTBUS_EVT_PARAM_NINE].paramValue.u32v = record->failTotalCount;
1021     msg->paramArray[SOFTBUS_EVT_PARAM_TEN].paramValue.u32v = record->connFailTotalCount;
1022     msg->paramArray[SOFTBUS_EVT_PARAM_ELEVEN].paramValue.u32v = record->authFailTotalCount;
1023     msg->paramArray[SOFTBUS_EVT_PARAM_TWELVE].paramValue.u32v = record->exchangeFailTotalCount;
1024     if (strcpy_s(msg->paramArray[SOFTBUS_EVT_PARAM_THIRTEEN].paramValue.str, SOFTBUS_HISYSEVT_NAME_LEN,
1025         g_softbusVersion) != EOK) {
1026         COMM_LOGE(COMM_EVENT, "copy softbus version fail");
1027         return SOFTBUS_STRCPY_ERR;
1028     }
1029     if (strcpy_s(msg->paramArray[SOFTBUS_EVT_PARAM_FOURTEEN].paramValue.str, SOFTBUS_HISYSEVT_NAME_LEN,
1030         g_packageVersion) != EOK) {
1031         COMM_LOGE(COMM_EVENT, "copy package name fail");
1032         return SOFTBUS_STRCPY_ERR;
1033     }
1034     return SOFTBUS_OK;
1035 }
1036 
SoftBusCreateAuthResultMsg(SoftBusEvtReportMsg * msg,SoftBusLinkType linkType)1037 static int32_t SoftBusCreateAuthResultMsg(SoftBusEvtReportMsg *msg, SoftBusLinkType linkType)
1038 {
1039     if (strcpy_s(msg->evtName, SOFTBUS_HISYSEVT_NAME_LEN, STATISTIC_EVT_AUTH_KPI) != EOK) {
1040         COMM_LOGE(COMM_EVENT, "strcpy evtname fail. STATISTIC_EVT_AUTH_KPI=%{public}s", STATISTIC_EVT_AUTH_KPI);
1041         return SOFTBUS_STRCPY_ERR;
1042     }
1043     msg->evtType = SOFTBUS_EVT_TYPE_STATISTIC;
1044     msg->paramNum = AUTH_RESULT_STATISTIC_PARAM_NUM;
1045     int32_t ret = SetAuthResultMsgParamName(msg);
1046     if (ret != SOFTBUS_OK) {
1047         COMM_LOGE(COMM_EVENT, "set param name fail");
1048         return ret;
1049     }
1050     if (SoftBusMutexLock(&(g_authResultRecord[linkType].lock)) != SOFTBUS_OK) {
1051         COMM_LOGE(COMM_EVENT, "lock fail");
1052         return SOFTBUS_LOCK_ERR;
1053     }
1054     ret = SetAuthResultMsgParamValve(msg, &g_authResultRecord[linkType]);
1055     if (ret != SOFTBUS_OK) {
1056         COMM_LOGE(COMM_EVENT, "set param valve fail");
1057         (void)SoftBusMutexUnlock(&(g_authResultRecord[linkType].lock));
1058         return ret;
1059     }
1060     (void)SoftBusMutexUnlock(&(g_authResultRecord[linkType].lock));
1061     return SOFTBUS_OK;
1062 }
1063 
CleanDevOnlineDurRecord(void)1064 static void CleanDevOnlineDurRecord(void)
1065 {
1066     if (SoftBusMutexLock(&(g_devOnlineDurRecord.lock)) != SOFTBUS_OK) {
1067         COMM_LOGE(COMM_EVENT, "lock fail");
1068         return;
1069     }
1070     g_devOnlineDurRecord.totalTime = 0;
1071     g_devOnlineDurRecord.totalCount = 0;
1072     g_devOnlineDurRecord.count1 = 0;
1073     g_devOnlineDurRecord.count2 = 0;
1074     g_devOnlineDurRecord.count3 = 0;
1075     g_devOnlineDurRecord.count4 = 0;
1076     g_devOnlineDurRecord.count5 = 0;
1077     (void)SoftBusMutexUnlock(&(g_devOnlineDurRecord.lock));
1078 }
1079 
SetOnlineDurMsgParamName(SoftBusEvtReportMsg * msg)1080 static int32_t SetOnlineDurMsgParamName(SoftBusEvtReportMsg *msg)
1081 {
1082     SoftBusEvtParam *param = NULL;
1083     for (int i = SOFTBUS_EVT_PARAM_ZERO; i < ONLINE_DURATION_STATISTIC_PARAM_NUM; i++) {
1084         param = &msg->paramArray[i];
1085         param->paramType = g_busCenterDurStaticParam[i + 1].paramType;
1086         if (strcpy_s(param->paramName, SOFTBUS_HISYSEVT_PARAM_LEN, g_busCenterDurStaticParam[i + 1].paramName) != EOK) {
1087             COMM_LOGE(COMM_EVENT,
1088                 "copy param name fail. paramName=%{public}s", g_busCenterDurStaticParam[i + 1].paramName);
1089             return SOFTBUS_STRCPY_ERR;
1090         }
1091     }
1092     return SOFTBUS_OK;
1093 }
1094 
SetOnlineDurMsgParamValve(SoftBusEvtReportMsg * msg,DevOnlineDurRecord * record)1095 static int32_t SetOnlineDurMsgParamValve(SoftBusEvtReportMsg *msg, DevOnlineDurRecord *record)
1096 {
1097     msg->paramArray[SOFTBUS_EVT_PARAM_ZERO].paramValue.u64v = record->totalTime;
1098     msg->paramArray[SOFTBUS_EVT_PARAM_ONE].paramValue.u32v = record->totalCount;
1099     msg->paramArray[SOFTBUS_EVT_PARAM_TWO].paramValue.u32v = record->count1;
1100     msg->paramArray[SOFTBUS_EVT_PARAM_THREE].paramValue.u32v = record->count2;
1101     msg->paramArray[SOFTBUS_EVT_PARAM_FOUR].paramValue.u32v = record->count3;
1102     msg->paramArray[SOFTBUS_EVT_PARAM_FIVE].paramValue.u32v = record->count4;
1103     msg->paramArray[SOFTBUS_EVT_PARAM_SIX].paramValue.u32v = record->count5;
1104     if (strcpy_s(msg->paramArray[SOFTBUS_EVT_PARAM_SEVEN].paramValue.str, SOFTBUS_HISYSEVT_NAME_LEN,
1105         g_softbusVersion) != EOK) {
1106         COMM_LOGE(COMM_EVENT, "copy softbus version fail");
1107         return SOFTBUS_STRCPY_ERR;
1108     }
1109     if (strcpy_s(msg->paramArray[SOFTBUS_EVT_PARAM_EIGHT].paramValue.str, SOFTBUS_HISYSEVT_NAME_LEN,
1110         g_packageVersion) != EOK) {
1111         COMM_LOGE(COMM_EVENT, "copy package name fail");
1112         return SOFTBUS_STRCPY_ERR;
1113     }
1114     return SOFTBUS_OK;
1115 }
1116 
SoftBusCreateOnlineDurMsg(SoftBusEvtReportMsg * msg)1117 static int32_t SoftBusCreateOnlineDurMsg(SoftBusEvtReportMsg *msg)
1118 {
1119     if (strcpy_s(msg->evtName, SOFTBUS_HISYSEVT_NAME_LEN, STATISTIC_EVT_ONLINE_DURATION) != EOK) {
1120         COMM_LOGE(COMM_EVENT,
1121             "strcpy evtname fail. STATISTIC_EVT_ONLINE_DURATION=%{public}s", STATISTIC_EVT_ONLINE_DURATION);
1122         return SOFTBUS_STRCPY_ERR;
1123     }
1124     msg->evtType = SOFTBUS_EVT_TYPE_STATISTIC;
1125     msg->paramNum = ONLINE_DURATION_STATISTIC_PARAM_NUM;
1126     int32_t ret = SetOnlineDurMsgParamName(msg);
1127     if (ret != SOFTBUS_OK) {
1128         COMM_LOGE(COMM_EVENT, "online duration stastic msg set param name fail");
1129         return ret;
1130     }
1131     if (SoftBusMutexLock(&(g_devOnlineDurRecord.lock)) != SOFTBUS_OK) {
1132         COMM_LOGE(COMM_EVENT, "add online duration record lock fail");
1133         return SOFTBUS_LOCK_ERR;
1134     }
1135     ret = SetOnlineDurMsgParamValve(msg, &g_devOnlineDurRecord);
1136     if (ret != SOFTBUS_OK) {
1137         COMM_LOGE(COMM_EVENT, "online duration stastic msg set param valve fail");
1138         (void)SoftBusMutexUnlock(&(g_devOnlineDurRecord.lock));
1139         return ret;
1140     }
1141     (void)SoftBusMutexUnlock(&(g_devOnlineDurRecord.lock));
1142     return SOFTBUS_OK;
1143 }
1144 
CleanBusCenterRecord(void)1145 static void CleanBusCenterRecord(void)
1146 {
1147     for (SoftBusLinkType linkType = SOFTBUS_HISYSEVT_LINK_TYPE_BR; linkType < SOFTBUS_HISYSEVT_LINK_TYPE_BUTT;
1148         linkType++) {
1149         if (SoftBusMutexLock(&(g_busCenterRecord[linkType].lock)) != SOFTBUS_OK) {
1150             COMM_LOGE(COMM_EVENT, "lock fail");
1151             return;
1152         }
1153         g_busCenterRecord[linkType].linkType = linkType;
1154         g_busCenterRecord[linkType].totalTime = 0;
1155         g_busCenterRecord[linkType].totalCount = 0;
1156         g_busCenterRecord[linkType].count1 = 0;
1157         g_busCenterRecord[linkType].count2 = 0;
1158         g_busCenterRecord[linkType].count3 = 0;
1159         g_busCenterRecord[linkType].count4 = 0;
1160         g_busCenterRecord[linkType].count5 = 0;
1161         (void)SoftBusMutexUnlock(&(g_busCenterRecord[linkType].lock));
1162     }
1163 }
1164 
SetBusCenterDurMsgParamName(SoftBusEvtReportMsg * msg)1165 static int32_t SetBusCenterDurMsgParamName(SoftBusEvtReportMsg *msg)
1166 {
1167     SoftBusEvtParam *param = NULL;
1168     for (int i = SOFTBUS_EVT_PARAM_ZERO; i < BUS_CENTER_DURATION_PARAM_NUM; i++) {
1169         param = &msg->paramArray[i];
1170         param->paramType = g_busCenterDurStaticParam[i].paramType;
1171         if (strcpy_s(param->paramName, SOFTBUS_HISYSEVT_PARAM_LEN, g_busCenterDurStaticParam[i].paramName) != EOK) {
1172             COMM_LOGE(COMM_EVENT, "copy param name fail. paramName=%{public}s", g_busCenterDurStaticParam[i].paramName);
1173             return SOFTBUS_STRCPY_ERR;
1174         }
1175     }
1176     return SOFTBUS_OK;
1177 }
1178 
SetBusCenterDurMsgParamValve(SoftBusEvtReportMsg * msg,BusCenterDuraRecord * record)1179 static int32_t SetBusCenterDurMsgParamValve(SoftBusEvtReportMsg *msg, BusCenterDuraRecord *record)
1180 {
1181     msg->paramArray[SOFTBUS_EVT_PARAM_ZERO].paramValue.u32v = record->linkType;
1182     msg->paramArray[SOFTBUS_EVT_PARAM_ONE].paramValue.u64v = record->totalTime;
1183     msg->paramArray[SOFTBUS_EVT_PARAM_TWO].paramValue.u32v = record->totalCount;
1184     msg->paramArray[SOFTBUS_EVT_PARAM_THREE].paramValue.u32v = record->count1;
1185     msg->paramArray[SOFTBUS_EVT_PARAM_FOUR].paramValue.u32v = record->count2;
1186     msg->paramArray[SOFTBUS_EVT_PARAM_FIVE].paramValue.u32v = record->count3;
1187     msg->paramArray[SOFTBUS_EVT_PARAM_SIX].paramValue.u32v = record->count4;
1188     msg->paramArray[SOFTBUS_EVT_PARAM_SEVEN].paramValue.u32v = record->count5;
1189     if (strcpy_s(msg->paramArray[SOFTBUS_EVT_PARAM_EIGHT].paramValue.str, SOFTBUS_HISYSEVT_NAME_LEN,
1190         g_softbusVersion) != EOK) {
1191         COMM_LOGE(COMM_EVENT, "copy softbus version fail");
1192         return SOFTBUS_STRCPY_ERR;
1193     }
1194     if (strcpy_s(msg->paramArray[SOFTBUS_EVT_PARAM_NINE].paramValue.str, SOFTBUS_HISYSEVT_NAME_LEN,
1195         g_packageVersion) != EOK) {
1196         COMM_LOGE(COMM_EVENT, "copy package name fail");
1197         return SOFTBUS_STRCPY_ERR;
1198     }
1199     return SOFTBUS_OK;
1200 }
1201 
CreateBusCenterDurStasticMsg(SoftBusEvtReportMsg * msg,SoftBusLinkType linkType)1202 static int32_t CreateBusCenterDurStasticMsg(SoftBusEvtReportMsg *msg, SoftBusLinkType linkType)
1203 {
1204     if (strcpy_s(msg->evtName, SOFTBUS_HISYSEVT_NAME_LEN, STATISTIC_EVT_LNN_DURATION) != EOK) {
1205         COMM_LOGE(COMM_EVENT, "strcpy evtname fail. STATISTIC_EVT_LNN_DURATION=%{public}s", STATISTIC_EVT_LNN_DURATION);
1206         return SOFTBUS_STRCPY_ERR;
1207     }
1208     msg->evtType = SOFTBUS_EVT_TYPE_STATISTIC;
1209     msg->paramNum = BUS_CENTER_DURATION_PARAM_NUM;
1210     int32_t ret = SetBusCenterDurMsgParamName(msg);
1211     if (ret != SOFTBUS_OK) {
1212         COMM_LOGE(COMM_EVENT, "set param name fail");
1213         return ret;
1214     }
1215     if (SoftBusMutexLock(&(g_busCenterRecord[linkType].lock)) != SOFTBUS_OK) {
1216         COMM_LOGE(COMM_EVENT, "lock fail");
1217         return SOFTBUS_LOCK_ERR;
1218     }
1219     ret = SetBusCenterDurMsgParamValve(msg, &g_busCenterRecord[linkType]);
1220     if (ret != SOFTBUS_OK) {
1221         COMM_LOGE(COMM_EVENT, "set param valve fail");
1222         (void)SoftBusMutexUnlock(&(g_busCenterRecord[linkType].lock));
1223         return ret;
1224     }
1225     (void)SoftBusMutexUnlock(&(g_busCenterRecord[linkType].lock));
1226     return SOFTBUS_OK;
1227 }
1228 
IsNeedReportOnlineDurRecordEvt(void)1229 static bool IsNeedReportOnlineDurRecordEvt(void)
1230 {
1231     DevOnlineDurRecord *record = &g_devOnlineDurRecord;
1232     if (SoftBusMutexLock(&(record->lock)) != SOFTBUS_OK) {
1233         COMM_LOGE(COMM_EVENT, "lock fail");
1234         return false;
1235     }
1236     if ((record->count1 == 0) && (record->count2 == 0) && (record->count3 == 0) && (record->count4 == 0)
1237         && (record->count5 == 0) && (record->totalCount == 0) && (record->totalTime == 0)) {
1238         (void)SoftBusMutexUnlock(&(record->lock));
1239         return false;
1240     }
1241     (void)SoftBusMutexUnlock(&(record->lock));
1242     return true;
1243 }
1244 
ReportOnlineDurRecordEvt(void)1245 static int32_t ReportOnlineDurRecordEvt(void)
1246 {
1247     COMM_LOGD(COMM_EVENT, "report online duration record evt enter");
1248     if (!IsNeedReportOnlineDurRecordEvt()) {
1249         COMM_LOGD(COMM_EVENT, "this time do not need report online duration record evt");
1250         return SOFTBUS_OK;
1251     }
1252     SoftBusEvtReportMsg *msg = SoftbusCreateEvtReportMsg(ONLINE_DURATION_STATISTIC_PARAM_NUM);
1253     if (msg == NULL) {
1254         COMM_LOGE(COMM_EVENT, "create online duration report msg fail");
1255         return SOFTBUS_MALLOC_ERR;
1256     }
1257     int32_t ret = SOFTBUS_OK;
1258     do {
1259         ret = SoftBusCreateOnlineDurMsg(msg);
1260         if (ret != SOFTBUS_OK) {
1261             COMM_LOGE(COMM_EVENT, "create device online duration report msg fail");
1262             break;
1263         }
1264         ret = SoftbusWriteHisEvt(msg);
1265         if (ret != SOFTBUS_OK) {
1266             COMM_LOGE(COMM_EVENT, "write device online duration hisevt fail");
1267             break;
1268         }
1269     } while (false);
1270     SoftbusFreeEvtReportMsg(msg);
1271     CleanDevOnlineDurRecord();
1272     return ret;
1273 }
1274 
IsNeedReportLnnDurRecordItem(SoftBusLinkType linkType)1275 static bool IsNeedReportLnnDurRecordItem(SoftBusLinkType linkType)
1276 {
1277     BusCenterDuraRecord *record = &g_busCenterRecord[linkType];
1278     if (SoftBusMutexLock(&(record->lock)) != SOFTBUS_OK) {
1279         COMM_LOGE(COMM_EVENT, "lock fail");
1280         return false;
1281     }
1282     if ((record->totalTime == 0) && (record->totalCount == 0) && (record->count1 == 0) && (record->count2 == 0)
1283         && (record->count3 == 0) && (record->count4 == 0) && (record->count5 == 0)) {
1284         (void)SoftBusMutexUnlock(&(record->lock));
1285         return false;
1286     }
1287     (void)SoftBusMutexUnlock(&(record->lock));
1288     return true;
1289 }
1290 
IsNeedReportLnnDurRecordEvt(void)1291 static bool IsNeedReportLnnDurRecordEvt(void)
1292 {
1293     for (SoftBusLinkType linkType = SOFTBUS_HISYSEVT_LINK_TYPE_BR; linkType < SOFTBUS_HISYSEVT_LINK_TYPE_BUTT;
1294         linkType++) {
1295         if (IsNeedReportLnnDurRecordItem(linkType)) {
1296             return true;
1297         }
1298     }
1299     return false;
1300 }
1301 
ReportBusCenterRecordEvt(void)1302 static int32_t ReportBusCenterRecordEvt(void)
1303 {
1304     COMM_LOGD(COMM_EVENT, "report buscenter record evt enter");
1305     ReleaseDevUdidInfoNode();
1306     if (!IsNeedReportLnnDurRecordEvt()) {
1307         COMM_LOGD(COMM_EVENT, "this time do not need report buscenter record evt");
1308         return SOFTBUS_OK;
1309     }
1310     SoftBusEvtReportMsg *msg = SoftbusCreateEvtReportMsg(BUS_CENTER_DURATION_PARAM_NUM);
1311     if (msg == NULL) {
1312         COMM_LOGE(COMM_EVENT, "create buscenter record msg fail");
1313         return SOFTBUS_MALLOC_ERR;
1314     }
1315     int32_t ret = SOFTBUS_OK;
1316     for (SoftBusLinkType linkType = SOFTBUS_HISYSEVT_LINK_TYPE_BR; linkType < SOFTBUS_HISYSEVT_LINK_TYPE_BUTT;
1317         linkType++) {
1318         do {
1319             if (!IsNeedReportLnnDurRecordItem(linkType)) {
1320                 break;
1321             }
1322             ret = CreateBusCenterDurStasticMsg(msg, linkType);
1323             if (ret != SOFTBUS_OK) {
1324                 COMM_LOGE(COMM_EVENT, "create lnn time report msg fail");
1325                 break;
1326             }
1327             ret = SoftbusWriteHisEvt(msg);
1328             if (ret != SOFTBUS_OK) {
1329                 COMM_LOGE(COMM_EVENT, "write lnn time hisevt fail");
1330                 break;
1331             }
1332         } while (false);
1333         if (ret != SOFTBUS_OK) {
1334             break;
1335         }
1336     }
1337     SoftbusFreeEvtReportMsg(msg);
1338     CleanBusCenterRecord();
1339     return ret;
1340 }
1341 
IsNeedReportAuthResultRecordItem(SoftBusLinkType linkType)1342 static bool IsNeedReportAuthResultRecordItem(SoftBusLinkType linkType)
1343 {
1344     AuthResultRecord *record = &g_authResultRecord[linkType];
1345     if (SoftBusMutexLock(&(record->lock)) != SOFTBUS_OK) {
1346         COMM_LOGE(COMM_EVENT, "lock fail");
1347         return false;
1348     }
1349     if ((record->exchangeFailTotalCount == 0) && (record->authTotalTime == 0) && (record->authTotalCount == 0)
1350         && (record->authCount2 == 0) && (record->authCount3 == 0) && (record->authCount4 == 0)
1351         && (record->authCount5 == 0) && (record->failTotalTime == 0) && (record->connFailTotalCount == 0)
1352         && (record->failTotalCount == 0) && (record->authFailTotalCount == 0) && (record->authCount1 == 0)) {
1353         (void)SoftBusMutexUnlock(&(record->lock));
1354         return false;
1355     }
1356     (void)SoftBusMutexUnlock(&(record->lock));
1357     return true;
1358 }
1359 
IsNeedReportAuthResultRecordEvt(void)1360 static bool IsNeedReportAuthResultRecordEvt(void)
1361 {
1362     for (SoftBusLinkType linkType = SOFTBUS_HISYSEVT_LINK_TYPE_BR; linkType < SOFTBUS_HISYSEVT_LINK_TYPE_BUTT;
1363         linkType++) {
1364         if (IsNeedReportAuthResultRecordItem(linkType)) {
1365             return true;
1366         }
1367     }
1368     return false;
1369 }
1370 
ReportAuthResultRecordEvt(void)1371 static int32_t ReportAuthResultRecordEvt(void)
1372 {
1373     COMM_LOGD(COMM_EVENT, "report auth result record evt enter");
1374     if (!IsNeedReportAuthResultRecordEvt()) {
1375         COMM_LOGD(COMM_EVENT, "this time do not need report auth result record evt");
1376         return SOFTBUS_OK;
1377     }
1378     SoftBusEvtReportMsg *msg = SoftbusCreateEvtReportMsg(AUTH_RESULT_STATISTIC_PARAM_NUM);
1379     if (msg == NULL) {
1380         COMM_LOGE(COMM_EVENT, "create auth result report msg fail");
1381         return SOFTBUS_MALLOC_ERR;
1382     }
1383     int32_t ret = SOFTBUS_OK;
1384     for (SoftBusLinkType linkType = SOFTBUS_HISYSEVT_LINK_TYPE_BR; linkType < SOFTBUS_HISYSEVT_LINK_TYPE_BUTT;
1385         linkType++) {
1386         do {
1387             if (!IsNeedReportAuthResultRecordItem(linkType)) {
1388                 break;
1389             }
1390             ret = SoftBusCreateAuthResultMsg(msg, linkType);
1391             if (ret != SOFTBUS_OK) {
1392                 COMM_LOGE(COMM_EVENT, "create auth result report msg fail");
1393                 break;
1394             }
1395             ret = SoftbusWriteHisEvt(msg);
1396             if (ret != SOFTBUS_OK) {
1397                 COMM_LOGE(COMM_EVENT, "write auth result hisevt fail");
1398                 break;
1399             }
1400         } while (false);
1401         if (ret != SOFTBUS_OK) {
1402             break;
1403         }
1404     }
1405     SoftbusFreeEvtReportMsg(msg);
1406     CleanAuthResultRecord();
1407     return ret;
1408 }
1409 
SoftBusRecordDevOnlineDurResult(uint64_t constTime)1410 int32_t SoftBusRecordDevOnlineDurResult(uint64_t constTime)
1411 {
1412     if (constTime < 0) {
1413         COMM_LOGE(COMM_EVENT, "param is invalid");
1414         return SOFTBUS_INVALID_PARAM;
1415     }
1416     DevOnlineDurRecord *reCord = &g_devOnlineDurRecord;
1417     if (SoftBusMutexLock(&reCord->lock) != SOFTBUS_OK) {
1418         COMM_LOGE(COMM_EVENT, "lock fail");
1419         return SOFTBUS_LOCK_ERR;
1420     }
1421     reCord->totalTime += constTime;
1422     reCord->totalCount++;
1423     if (constTime > ONLINE_TIME_STANDARD_S) {
1424         reCord->count1++;
1425     }
1426     if (constTime > ONLINE_TIME_STANDARD_A) {
1427         reCord->count2++;
1428     }
1429     if (constTime > ONLINE_TIME_STANDARD_B) {
1430         reCord->count3++;
1431     }
1432     if (constTime > ONLINE_TIME_STANDARD_C) {
1433         reCord->count4++;
1434     }
1435     if (constTime > ONLINE_TIME_STANDARD_D) {
1436         reCord->count5++;
1437     }
1438     (void)SoftBusMutexUnlock(&reCord->lock);
1439     return SOFTBUS_OK;
1440 }
1441 
SoftBusRecordBusCenterResult(SoftBusLinkType linkType,uint64_t constTime)1442 int32_t SoftBusRecordBusCenterResult(SoftBusLinkType linkType, uint64_t constTime)
1443 {
1444     if (linkType >= SOFTBUS_HISYSEVT_LINK_TYPE_BUTT || constTime < 0) {
1445         COMM_LOGE(COMM_EVENT, "param is invalid");
1446         return SOFTBUS_INVALID_PARAM;
1447     }
1448 
1449     BusCenterDuraRecord *reCord = &g_busCenterRecord[linkType];
1450     if (SoftBusMutexLock(&reCord->lock) != SOFTBUS_OK) {
1451         COMM_LOGE(COMM_EVENT, "lnn result record lock fail");
1452         return SOFTBUS_LOCK_ERR;
1453     }
1454     reCord->totalTime += constTime;
1455     reCord->totalCount++;
1456     if (constTime > LNN_TIME_STANDARD_S) {
1457         reCord->count1++;
1458     }
1459     if (constTime > LNN_TIME_STANDARD_A) {
1460         reCord->count2++;
1461     }
1462     if (constTime > LNN_TIME_STANDARD_B) {
1463         reCord->count3++;
1464     }
1465     if (constTime > LNN_TIME_STANDARD_C) {
1466         reCord->count4++;
1467     }
1468     if (constTime > LNN_TIME_STANDARD_D) {
1469         reCord->count5++;
1470     }
1471     (void)SoftBusMutexUnlock(&reCord->lock);
1472     return SOFTBUS_OK;
1473 }
1474 
SoftBusRecordAuthResult(SoftBusLinkType linkType,int32_t ret,uint64_t constTime,AuthFailStage stage)1475 int32_t SoftBusRecordAuthResult(SoftBusLinkType linkType, int32_t ret, uint64_t constTime, AuthFailStage stage)
1476 {
1477     if (linkType >= SOFTBUS_HISYSEVT_LINK_TYPE_BUTT || constTime < 0) {
1478         COMM_LOGE(COMM_EVENT, "param is invalid");
1479         return SOFTBUS_INVALID_PARAM;
1480     }
1481     AuthResultRecord *reCord = &g_authResultRecord[linkType];
1482     if (SoftBusMutexLock(&reCord->lock) != SOFTBUS_OK) {
1483         COMM_LOGE(COMM_EVENT, "auth result record lock fail");
1484         return SOFTBUS_LOCK_ERR;
1485     }
1486     reCord->authTotalTime += constTime;
1487     reCord->authTotalCount++;
1488     if (constTime > AUTH_TIME_STANDARD_S) {
1489         reCord->authCount1++;
1490     }
1491     if (constTime > AUTH_TIME_STANDARD_A) {
1492         reCord->authCount2++;
1493     }
1494     if (constTime > AUTH_TIME_STANDARD_B) {
1495         reCord->authCount3++;
1496     }
1497     if (constTime > AUTH_TIME_STANDARD_C) {
1498         reCord->authCount4++;
1499     }
1500     if (constTime > AUTH_TIME_STANDARD_D) {
1501         reCord->authCount5++;
1502     }
1503     if (ret != SOFTBUS_OK) {
1504         reCord->failTotalTime += constTime;
1505         reCord->failTotalCount++;
1506         switch (stage) {
1507             case AUTH_CONNECT_STAGE:
1508                 reCord->connFailTotalCount++;
1509                 break;
1510             case AUTH_VERIFY_STAGE:
1511                 reCord->authFailTotalCount++;
1512                 break;
1513             case AUTH_EXCHANGE_STAGE:
1514                 reCord->exchangeFailTotalCount++;
1515                 break;
1516             default:
1517                 break;
1518         }
1519     }
1520     (void)SoftBusMutexUnlock(&reCord->lock);
1521     return SOFTBUS_OK;
1522 }
1523 
InitBusCenterDfx(void)1524 int32_t InitBusCenterDfx(void)
1525 {
1526     if (g_isBusCenterDfxInit) {
1527         return SOFTBUS_OK;
1528     }
1529     if (SoftBusMutexInit(&g_devUdidLock, NULL) != SOFTBUS_OK || SoftBusMutexInit(&g_appDiscLock, NULL) != SOFTBUS_OK) {
1530         COMM_LOGE(COMM_EVENT, "init buscenter dfx lock init fail");
1531         return SOFTBUS_LOCK_ERR;
1532     }
1533     if (InitBusCenterEvtMutexLock() != SOFTBUS_OK || InitDevOnlineDurEvtMutexLock() != SOFTBUS_OK ||
1534         InitAuthEvtMutexLock() != SOFTBUS_OK || InitDevDiscoveryEvtMutexLock() != SOFTBUS_OK) {
1535         return SOFTBUS_LOCK_ERR;
1536     }
1537     ListInit(&g_devUdidList);
1538     ListInit(&g_appDiscList);
1539     CleanBusCenterRecord();
1540     CleanDevOnlineDurRecord();
1541     CleanAuthResultRecord();
1542     CleanDevDiscoveryRecord();
1543     do {
1544         if (SetStatisticEvtReportFunc(SOFTBUS_STATISTIC_EVT_LNN_DURATION, ReportBusCenterRecordEvt) != SOFTBUS_OK) {
1545             COMM_LOGE(COMM_EVENT, "set report buscenter record evt function fail");
1546             break;
1547         }
1548         if (SetStatisticEvtReportFunc(SOFTBUS_STATISTIC_EVT_ONLINE_DURATION,
1549             ReportOnlineDurRecordEvt) != SOFTBUS_OK) {
1550             COMM_LOGE(COMM_EVENT, "set report online duration record evt function fail");
1551             break;
1552         }
1553         if (SetStatisticEvtReportFunc(SOFTBUS_STATISTIC_EVT_AUTH_KPI, ReportAuthResultRecordEvt) != SOFTBUS_OK) {
1554             COMM_LOGE(COMM_EVENT, "set report auth result record evt function fail");
1555             break;
1556         }
1557         if (SetStatisticEvtReportFunc(SOFTBUS_STATISTIC_EVT_DEV_DISCOVERY, ReportDevDiscoveryRecordEvt) != SOFTBUS_OK) {
1558             COMM_LOGE(COMM_EVENT, "set report device discovery record evt function fail");
1559             break;
1560         }
1561         if (SetStatisticEvtReportFunc(SOFTBUS_STATISTIC_EVT_APP_DISCOVERY, ReportAppDiscoveryRecordEvt) != SOFTBUS_OK) {
1562             COMM_LOGE(COMM_EVENT, "set report app discovery record evt function fail");
1563             break;
1564         }
1565         g_isBusCenterDfxInit = true;
1566         return SOFTBUS_OK;
1567     } while (false);
1568     return SOFTBUS_INVALID_PARAM;
1569 }
1570 
DestroyBusCenterDfxMutex(void)1571 static void DestroyBusCenterDfxMutex(void)
1572 {
1573     SoftBusMutexDestroy(&g_devUdidLock);
1574     SoftBusMutexDestroy(&g_appDiscLock);
1575     SoftBusMutexDestroy(&(g_devOnlineDurRecord.lock));
1576     SoftBusMutexDestroy(&(g_devDiscoveryRecord.lock));
1577     DeinitBusCenterEvtMutexLock();
1578     DeinitAuthEvtMutexLock();
1579 }
1580 
DeinitBusCenterDfx(void)1581 void DeinitBusCenterDfx(void)
1582 {
1583     ReleaseDevUdidInfoNode();
1584     ReleaseAppDiscInfoNode();
1585     DestroyBusCenterDfxMutex();
1586     g_isBusCenterDfxInit = false;
1587 }
1588