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 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "wifi_hisysevent.h"
17 #include "wifi_common_util.h"
18 #include "hisysevent.h"
19 #include "sta_define.h"
20 #include "wifi_logger.h"
21 #include "cJSON.h"
22 #include <map>
23
24 namespace OHOS {
25 namespace Wifi {
26 DEFINE_WIFILOG_LABEL("WifiHiSysEvent");
27
28 const std::map<int, std::string> g_connectTypeTransMap {
29 { NETWORK_SELECTED_BY_UNKNOWN, "UNKNOWN" },
30 { NETWORK_SELECTED_BY_AUTO, "AUTO_CONNECT" },
31 { NETWORK_SELECTED_BY_USER, "SELECT_CONNECT" },
32 { NETWORK_SELECTED_BY_RETRY, "RETRY_CONNECT" },
33 { NETWORK_SELECTED_BY_WIFIPRO, "WIFIPRO_CONNECT" },
34 { NETWORK_SELECTED_BY_SELFCURE, "SELFCURE_CONNECT" },
35 { NETWORK_SELECTED_BY_ROAM, "ROMA_CONNECT" },
36 { NETWORK_SELECTED_BY_REASSOC, "REASSOC" },
37 };
38 constexpr int MAX_DNS_NUM = 10;
39
40 template<typename... Types>
WriteEvent(const std::string & eventType,Types...args)41 static void WriteEvent(const std::string& eventType, Types... args)
42 {
43 int ret = HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::COMMUNICATION, eventType,
44 HiviewDFX::HiSysEvent::EventType::STATISTIC, args...);
45 if (ret != 0) {
46 WIFI_LOGE("Write event fail: %{public}s", eventType.c_str());
47 }
48 }
49
50 template<typename... Type>
WriteEventBehavior(const std::string & eventType,Type...args)51 static void WriteEventBehavior(const std::string& eventType, Type... args)
52 {
53 int ret = HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::COMMUNICATION, eventType,
54 HiviewDFX::HiSysEvent::EventType::BEHAVIOR, args...);
55 if (ret != 0) {
56 WIFI_LOGE("Write event fail: %{public}s", eventType.c_str());
57 }
58 }
59
WriteWifiStateHiSysEvent(const std::string & serviceType,WifiOperType operType)60 void WriteWifiStateHiSysEvent(const std::string& serviceType, WifiOperType operType)
61 {
62 WriteEvent("WIFI_STATE", "TYPE", serviceType, "OPER_TYPE", static_cast<int>(operType));
63
64 cJSON *root = cJSON_CreateObject();
65 if (root == nullptr) {
66 WIFI_LOGE("Failed to create cJSON object");
67 return;
68 }
69 cJSON_AddNumberToObject(root, "WIFI_STATE", static_cast<int>(operType));
70 cJSON_AddStringToObject(root, "TYPE", serviceType.c_str());
71
72 char *jsonStr = cJSON_PrintUnformatted(root);
73 if (jsonStr == nullptr) {
74 cJSON_Delete(root);
75 return;
76 }
77 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_WIFI_STATE", "EVENT_VALUE", std::string(jsonStr));
78 free(jsonStr);
79 cJSON_Delete(root);
80 }
81
WriteWifiApStateHiSysEvent(int32_t state)82 void WriteWifiApStateHiSysEvent(int32_t state)
83 {
84 WriteEventBehavior("WIFI_AP_STATE", "STATE", state);
85 }
86
WriteWifiBridgeStateHiSysEvent(int32_t state)87 void WriteWifiBridgeStateHiSysEvent(int32_t state)
88 {
89 WriteEventBehavior("WIFI_BRIDGE_STATE", "STATE", state);
90 }
91
WriteWifiP2pStateHiSysEvent(const std::string & inter,int32_t type,int32_t state)92 void WriteWifiP2pStateHiSysEvent(const std::string& inter, int32_t type, int32_t state)
93 {
94 WriteEventBehavior("WIFI_P2P_STATE", "INTERFACE", inter, "P2PTYPE", type, "STATE", state);
95 }
96
WriteWifiConnectionHiSysEvent(int type,const std::string & pkgName)97 void WriteWifiConnectionHiSysEvent(int type, const std::string& pkgName)
98 {
99 WriteEvent("WIFI_CONNECTION", "TYPE", type, "PACKAGE_NAME", pkgName);
100 }
101
WriteWifiScanHiSysEvent(const int result,const std::string & pkgName)102 void WriteWifiScanHiSysEvent(const int result, const std::string& pkgName)
103 {
104 WriteEvent("WIFI_SCAN", "EXECUTE_RESULT", result, "PACKAGE_NAME", pkgName);
105 }
106
WriteWifiEventReceivedHiSysEvent(const std::string & eventType,int value)107 void WriteWifiEventReceivedHiSysEvent(const std::string& eventType, int value)
108 {
109 WriteEvent("WIFI_EVENT_RECEIVED", "EVENT_TYPE", eventType, "VALUE", value);
110 }
111
WriteWifiBandHiSysEvent(int band)112 void WriteWifiBandHiSysEvent(int band)
113 {
114 WriteEvent("WIFI_BAND", "BAND", band);
115 }
116
WriteWifiSignalHiSysEvent(int direction,int txPackets,int rxPackets)117 void WriteWifiSignalHiSysEvent(int direction, int txPackets, int rxPackets)
118 {
119 WriteEvent("WIFI_SIGNAL", "DIRECTION", direction, "TXPACKETS", txPackets, "RXPACKETS", rxPackets);
120 }
121
WriteWifiOperateStateHiSysEvent(int operateType,int operateState)122 void WriteWifiOperateStateHiSysEvent(int operateType, int operateState)
123 {
124 cJSON *root = cJSON_CreateObject();
125 if (root == nullptr) {
126 WIFI_LOGE("Failed to create cJSON object");
127 return;
128 }
129 cJSON_AddNumberToObject(root, "OPERATE_TYPE", operateType);
130 cJSON_AddNumberToObject(root, "OPERATE_STATE", operateState);
131
132 char *jsonStr = cJSON_PrintUnformatted(root);
133 if (jsonStr == nullptr) {
134 cJSON_Delete(root);
135 return;
136 }
137 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_OPERATE_STATE", "EVENT_VALUE", std::string(jsonStr));
138 free(jsonStr);
139 cJSON_Delete(root);
140 }
141
WriteWifiAbnormalDisconnectHiSysEvent(int errorCode,int locallyGenerated)142 void WriteWifiAbnormalDisconnectHiSysEvent(int errorCode, int locallyGenerated)
143 {
144 cJSON *root = cJSON_CreateObject();
145 if (root == nullptr) {
146 WIFI_LOGE("Failed to create cJSON object");
147 return;
148 }
149 cJSON_AddNumberToObject(root, "ERROR_CODE", errorCode);
150 cJSON_AddNumberToObject(root, "IS_ACTIVE_DISCONNECT", locallyGenerated);
151
152 char *jsonStr = cJSON_PrintUnformatted(root);
153 if (jsonStr == nullptr) {
154 cJSON_Delete(root);
155 return;
156 }
157 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_ABNORMAL_DISCONNECT", "EVENT_VALUE", std::string(jsonStr));
158 free(jsonStr);
159 cJSON_Delete(root);
160 }
161
WriteWifiBeaconLostHiSysEvent(int32_t errorCode)162 void WriteWifiBeaconLostHiSysEvent(int32_t errorCode)
163 {
164 cJSON *root = cJSON_CreateObject();
165 if (root == nullptr) {
166 WIFI_LOGE("Failed to create cJSON object");
167 return;
168 }
169 cJSON_AddNumberToObject(root, "ERROR_CODE", errorCode);
170
171 char *jsonStr = cJSON_PrintUnformatted(root);
172 if (jsonStr == nullptr) {
173 cJSON_Delete(root);
174 return;
175 }
176 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_BEACON_LOST", "EVENT_VALUE", std::string(jsonStr));
177 free(jsonStr);
178 cJSON_Delete(root);
179 }
180
WriteWifiConnectionInfoHiSysEvent(int networkId)181 void WriteWifiConnectionInfoHiSysEvent(int networkId)
182 {
183 cJSON *root = cJSON_CreateObject();
184 if (root == nullptr) {
185 WIFI_LOGE("Failed to create cJSON object");
186 return;
187 }
188 cJSON_AddNumberToObject(root, "NETWORK_ID", networkId);
189
190 char *jsonStr = cJSON_PrintUnformatted(root);
191 if (jsonStr == nullptr) {
192 cJSON_Delete(root);
193 return;
194 }
195 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_CONNECTION_INFO", "EVENT_VALUE", std::string(jsonStr));
196 free(jsonStr);
197 cJSON_Delete(root);
198 }
199
WriteWifiOpenAndCloseFailedHiSysEvent(int operateType,std::string failReason,int apState)200 void WriteWifiOpenAndCloseFailedHiSysEvent(int operateType, std::string failReason, int apState)
201 {
202 cJSON *root = cJSON_CreateObject();
203 if (root == nullptr) {
204 WIFI_LOGE("Failed to create cJSON object");
205 return;
206 }
207 cJSON_AddNumberToObject(root, "OPERATE_TYPE", operateType);
208 cJSON_AddStringToObject(root, "FAIL_REASON", failReason.c_str());
209 cJSON_AddNumberToObject(root, "AP_STATE", apState);
210
211 char *jsonStr = cJSON_PrintUnformatted(root);
212 if (jsonStr == nullptr) {
213 cJSON_Delete(root);
214 return;
215 }
216 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_OPEN_AND_CLOSE_FAILED", "EVENT_VALUE", std::string(jsonStr));
217 free(jsonStr);
218 cJSON_Delete(root);
219 }
220
WriteSoftApOpenAndCloseFailedEvent(int operateType,std::string failReason)221 void WriteSoftApOpenAndCloseFailedEvent(int operateType, std::string failReason)
222 {
223 WIFI_LOGE("WriteSoftApOpenAndCloseFailedEvent operateType=%{public}d", operateType);
224 cJSON *root = cJSON_CreateObject();
225 if (root == nullptr) {
226 WIFI_LOGE("Failed to create cJSON object");
227 return;
228 }
229 cJSON_AddNumberToObject(root, "OPERATE_TYPE", operateType);
230 cJSON_AddStringToObject(root, "FAIL_REASON", failReason.c_str());
231
232 char *jsonStr = cJSON_PrintUnformatted(root);
233 if (jsonStr == nullptr) {
234 cJSON_Delete(root);
235 return;
236 }
237 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "SOFTAP_OPEN_AND_CLOSE_FAILED", "EVENT_VALUE", std::string(jsonStr));
238 free(jsonStr);
239 cJSON_Delete(root);
240 }
241
WriteSoftApOperateHiSysEvent(int operateType)242 void WriteSoftApOperateHiSysEvent(int operateType)
243 {
244 cJSON *root = cJSON_CreateObject();
245 if (root == nullptr) {
246 WIFI_LOGE("Failed to create cJSON object");
247 return;
248 }
249 cJSON_AddNumberToObject(root, "OPERATE_TYPE", operateType);
250
251 char *jsonStr = cJSON_PrintUnformatted(root);
252 if (jsonStr == nullptr) {
253 cJSON_Delete(root);
254 return;
255 }
256 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "SOFTAP_OPERATE_STATE", "EVENT_VALUE", std::string(jsonStr));
257 free(jsonStr);
258 cJSON_Delete(root);
259 }
260
WriteWifiAccessIntFailedHiSysEvent(int operateRes,int failCnt,int selfCureResetState,std::string selfCureHistory)261 void WriteWifiAccessIntFailedHiSysEvent(
262 int operateRes, int failCnt, int selfCureResetState, std::string selfCureHistory)
263 {
264 cJSON *root = cJSON_CreateObject();
265 if (root == nullptr) {
266 WIFI_LOGE("Failed to create cJSON object");
267 return;
268 }
269 cJSON_AddNumberToObject(root, "OPERATE_TYPE", operateRes);
270 cJSON_AddNumberToObject(root, "FAIL_CNT", failCnt);
271 cJSON_AddNumberToObject(root, "RESET_STATE", selfCureResetState);
272 cJSON_AddStringToObject(root, "SELF_CURE_HISTORY", selfCureHistory.c_str());
273
274 char *jsonStr = cJSON_PrintUnformatted(root);
275 if (jsonStr == nullptr) {
276 cJSON_Delete(root);
277 return;
278 }
279 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_ACCESS_INTERNET_FAILED", "EVENT_VALUE", std::string(jsonStr));
280 free(jsonStr);
281 cJSON_Delete(root);
282 }
283
WriteWifiPnoScanHiSysEvent(int isStartScan,int suspendReason)284 void WriteWifiPnoScanHiSysEvent(int isStartScan, int suspendReason)
285 {
286 cJSON *root = cJSON_CreateObject();
287 if (root == nullptr) {
288 WIFI_LOGE("Failed to create cJSON object");
289 return;
290 }
291 cJSON_AddNumberToObject(root, "IS_START", isStartScan);
292 cJSON_AddNumberToObject(root, "SUSPEND_REASON", suspendReason);
293
294 char *jsonStr = cJSON_PrintUnformatted(root);
295 if (jsonStr == nullptr) {
296 cJSON_Delete(root);
297 return;
298 }
299 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_PNO_SCAN_INFO", "EVENT_VALUE", std::string(jsonStr));
300 free(jsonStr);
301 cJSON_Delete(root);
302 }
303
WriteBrowserFailedForPortalHiSysEvent(int respCode,std::string & server)304 void WriteBrowserFailedForPortalHiSysEvent(int respCode, std::string &server)
305 {
306 cJSON *root = cJSON_CreateObject();
307 if (root == nullptr) {
308 WIFI_LOGE("Failed to create cJSON object");
309 return;
310 }
311 cJSON_AddNumberToObject(root, "RESP_CODE", respCode);
312 cJSON_AddStringToObject(root, "SERVER", server.c_str());
313
314 char *jsonStr = cJSON_PrintUnformatted(root);
315 if (jsonStr == nullptr) {
316 cJSON_Delete(root);
317 return;
318 }
319 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "BROWSER_FAILED_FOR_PORTAL", "EVENT_VALUE", std::string(jsonStr));
320 free(jsonStr);
321 cJSON_Delete(root);
322 }
323
WriteAuthFailHiSysEvent(const std::string & authFailReason,int subErrCode)324 void WriteAuthFailHiSysEvent(const std::string &authFailReason, int subErrCode)
325 {
326 cJSON *root = cJSON_CreateObject();
327 if (root == nullptr) {
328 WIFI_LOGE("Failed to create cJSON object");
329 return;
330 }
331 cJSON_AddStringToObject(root, "FAIL_REASON", authFailReason.c_str());
332 cJSON_AddNumberToObject(root, "SUB_ERR_CODE", subErrCode);
333
334 char *jsonStr = cJSON_PrintUnformatted(root);
335 if (jsonStr == nullptr) {
336 cJSON_Delete(root);
337 return;
338 }
339 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_AUTH_FAIL_INFO", "EVENT_VALUE", std::string(jsonStr));
340 free(jsonStr);
341 cJSON_Delete(root);
342 }
343
WriteAssocFailHiSysEvent(const std::string & assocFailReason,int subErrCode)344 void WriteAssocFailHiSysEvent(const std::string &assocFailReason, int subErrCode)
345 {
346 cJSON *root = cJSON_CreateObject();
347 if (root == nullptr) {
348 WIFI_LOGE("Failed to create cJSON object");
349 return;
350 }
351 cJSON_AddStringToObject(root, "FAIL_REASON", assocFailReason.c_str());
352 cJSON_AddNumberToObject(root, "SUB_ERR_CODE", subErrCode);
353
354 char *jsonStr = cJSON_PrintUnformatted(root);
355 if (jsonStr == nullptr) {
356 cJSON_Delete(root);
357 return;
358 }
359 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_ASSOC_FAIL_INFO", "EVENT_VALUE", std::string(jsonStr));
360 free(jsonStr);
361 cJSON_Delete(root);
362 }
363
WriteDhcpFailHiSysEvent(const std::string & dhcpFailReason,int subErrCode)364 void WriteDhcpFailHiSysEvent(const std::string &dhcpFailReason, int subErrCode)
365 {
366 cJSON *root = cJSON_CreateObject();
367 if (root == nullptr) {
368 WIFI_LOGE("Failed to create cJSON object");
369 return;
370 }
371 cJSON_AddStringToObject(root, "FAIL_REASON", dhcpFailReason.c_str());
372 cJSON_AddNumberToObject(root, "SUB_ERR_CODE", subErrCode);
373
374 char *jsonStr = cJSON_PrintUnformatted(root);
375 if (jsonStr == nullptr) {
376 cJSON_Delete(root);
377 return;
378 }
379 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_DHCP_FAIL_INFO", "EVENT_VALUE", std::string(jsonStr));
380 free(jsonStr);
381 cJSON_Delete(root);
382 }
383
WriteScanLimitHiSysEvent(const std::string & scanInitiator,int scanLimitType,bool isForeground)384 void WriteScanLimitHiSysEvent(const std::string &scanInitiator, int scanLimitType, bool isForeground)
385 {
386 if (scanInitiator.empty()) {
387 return;
388 }
389 cJSON *root = cJSON_CreateObject();
390 if (root == nullptr) {
391 WIFI_LOGE("Failed to create cJSON object");
392 return;
393 }
394 cJSON_AddStringToObject(root, "SCAN_INITIATOR", scanInitiator.c_str());
395 cJSON_AddBoolToObject(root, "IS_FOREGROUND", isForeground);
396 cJSON_AddNumberToObject(root, "SCAN_LIMIT_TYPE", scanLimitType);
397
398 char *jsonStr = cJSON_PrintUnformatted(root);
399 if (jsonStr == nullptr) {
400 cJSON_Delete(root);
401 return;
402 }
403 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_SCAN_LIMIT_STATISTICS", "EVENT_VALUE", std::string(jsonStr));
404 free(jsonStr);
405 cJSON_Delete(root);
406 }
407
WriteAutoConnectFailEvent(const std::string & failReason,const std::string & subReason)408 void WriteAutoConnectFailEvent(const std::string &failReason, const std::string &subReason)
409 {
410 cJSON *root = cJSON_CreateObject();
411 if (root == nullptr) {
412 WIFI_LOGE("Failed to create cJSON object");
413 return;
414 }
415 cJSON_AddStringToObject(root, "FAIL_REASON", failReason.c_str());
416 cJSON_AddStringToObject(root, "SUB_REASON", subReason.c_str());
417
418 char *jsonStr = cJSON_PrintUnformatted(root);
419 if (jsonStr == nullptr) {
420 cJSON_Delete(root);
421 return;
422 }
423 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_AUTO_RECONNECT_FAILED", "EVENT_VALUE", std::string(jsonStr));
424 free(jsonStr);
425 cJSON_Delete(root);
426 }
427
WriteP2pKpiCountHiSysEvent(int eventType)428 void WriteP2pKpiCountHiSysEvent(int eventType)
429 {
430 cJSON *root = cJSON_CreateObject();
431 if (root == nullptr) {
432 WIFI_LOGE("Failed to create cJSON object");
433 return;
434 }
435 cJSON_AddNumberToObject(root, "EVENT_TYPE", eventType);
436
437 char *jsonStr = cJSON_PrintUnformatted(root);
438 if (jsonStr == nullptr) {
439 cJSON_Delete(root);
440 return;
441 }
442 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "P2P_CONNECT_STATICS", "EVENT_VALUE", std::string(jsonStr));
443 free(jsonStr);
444 cJSON_Delete(root);
445 }
446
WriteP2pConnectFailedHiSysEvent(int errCode,int failRes)447 void WriteP2pConnectFailedHiSysEvent(int errCode, int failRes)
448 {
449 cJSON *root = cJSON_CreateObject();
450 if (root == nullptr) {
451 WIFI_LOGE("Failed to create cJSON object");
452 return;
453 }
454 cJSON_AddNumberToObject(root, "EVENT_TYPE", errCode);
455 cJSON_AddNumberToObject(root, "FAIL_RES", failRes);
456
457 char *jsonStr = cJSON_PrintUnformatted(root);
458 if (jsonStr == nullptr) {
459 cJSON_Delete(root);
460 return;
461 }
462 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "P2P_CONNECT_FAIL", "EVENT_VALUE", std::string(jsonStr));
463 free(jsonStr);
464 cJSON_Delete(root);
465 }
466
WriteP2pAbDisConnectHiSysEvent(int errCode,int failRes)467 void WriteP2pAbDisConnectHiSysEvent(int errCode, int failRes)
468 {
469 cJSON *root = cJSON_CreateObject();
470 if (root == nullptr) {
471 WIFI_LOGE("Failed to create cJSON object");
472 return;
473 }
474 cJSON_AddNumberToObject(root, "EVENT_TYPE", errCode);
475 cJSON_AddNumberToObject(root, "FAIL_RES", failRes);
476
477 char *jsonStr = cJSON_PrintUnformatted(root);
478 if (jsonStr == nullptr) {
479 cJSON_Delete(root);
480 return;
481 }
482 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "P2P_ABNORMAL_DISCONNECT", "EVENT_VALUE", std::string(jsonStr));
483 free(jsonStr);
484 cJSON_Delete(root);
485 }
486
WriteSoftApAbDisconnectHiSysEvent(int errorCode)487 void WriteSoftApAbDisconnectHiSysEvent(int errorCode)
488 {
489 cJSON *root = cJSON_CreateObject();
490 if (root == nullptr) {
491 WIFI_LOGE("Failed to create cJSON object");
492 return;
493 }
494 cJSON_AddNumberToObject(root, "ERROR_CODE", errorCode);
495
496 char *jsonStr = cJSON_PrintUnformatted(root);
497 if (jsonStr == nullptr) {
498 cJSON_Delete(root);
499 return;
500 }
501 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "SOFTAP_ABNORMAL_DISCONNECT", "EVENT_VALUE", std::string(jsonStr));
502 free(jsonStr);
503 cJSON_Delete(root);
504 }
505
WriteIsInternetHiSysEvent(int isInternet)506 void WriteIsInternetHiSysEvent(int isInternet)
507 {
508 cJSON *root = cJSON_CreateObject();
509 if (root == nullptr) {
510 WIFI_LOGE("Failed to create cJSON object");
511 return;
512 }
513 cJSON_AddNumberToObject(root, "IS_INTERNET", isInternet);
514
515 char *jsonStr = cJSON_PrintUnformatted(root);
516 if (jsonStr == nullptr) {
517 cJSON_Delete(root);
518 return;
519 }
520 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_KPI_INTERNET", "EVENT_VALUE", std::string(jsonStr));
521 free(jsonStr);
522 cJSON_Delete(root);
523 }
524
WriteSoftApConnectFailHiSysEvent(int errorCnt)525 void WriteSoftApConnectFailHiSysEvent(int errorCnt)
526 {
527 cJSON *root = cJSON_CreateObject();
528 if (root == nullptr) {
529 WIFI_LOGE("Failed to create cJSON object");
530 return;
531 }
532 cJSON_AddNumberToObject(root, "ERROR_CODE", errorCnt);
533
534 char *jsonStr = cJSON_PrintUnformatted(root);
535 if (jsonStr == nullptr) {
536 cJSON_Delete(root);
537 return;
538 }
539 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "SOFTAP_CONNECT_FAILED", "EVENT_VALUE", std::string(jsonStr));
540 free(jsonStr);
541 cJSON_Delete(root);
542 }
543
WriteSoftApClientAccessNetErrorHiSysEvent(int errorCode)544 void WriteSoftApClientAccessNetErrorHiSysEvent(int errorCode)
545 {
546 cJSON *root = cJSON_CreateObject();
547 if (root == nullptr) {
548 WIFI_LOGE("Failed to create cJSON object");
549 return;
550 }
551 cJSON_AddNumberToObject(root, "ERROR_CODE", errorCode);
552
553 char *jsonStr = cJSON_PrintUnformatted(root);
554 if (jsonStr == nullptr) {
555 cJSON_Delete(root);
556 return;
557 }
558 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "SOFTAP_CLIENT_ACCESS_NET_ERROR", "EVENT_VALUE", std::string(jsonStr));
559 free(jsonStr);
560 cJSON_Delete(root);
561 }
562
WriteWifiScanApiFailHiSysEvent(const std::string & pkgName,const WifiScanFailReason failReason)563 void WriteWifiScanApiFailHiSysEvent(const std::string &pkgName, const WifiScanFailReason failReason)
564 {
565 #ifndef OHOS_ARCH_LITE
566 cJSON *root = cJSON_CreateObject();
567 if (root == nullptr) {
568 WIFI_LOGE("Failed to create cJSON object");
569 return;
570 }
571 cJSON_AddStringToObject(root, "PKG_NAME", pkgName.c_str());
572 cJSON_AddNumberToObject(root, "FAIL_REASON", static_cast<int>(failReason));
573
574 char *jsonStr = cJSON_PrintUnformatted(root);
575 if (jsonStr == nullptr) {
576 cJSON_Delete(root);
577 return;
578 }
579 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFISCANCONTROL_TRIGGER_API_FAIL", "EVENT_VALUE", std::string(jsonStr));
580 free(jsonStr);
581 cJSON_Delete(root);
582 #endif
583 }
584
WriteWifiEncryptionFailHiSysEvent(int event,const std::string & maskSsid,const std::string & keyMgmt,int encryptedModule)585 void WriteWifiEncryptionFailHiSysEvent(
586 int event, const std::string &maskSsid, const std::string &keyMgmt, int encryptedModule)
587 {
588 cJSON *root = cJSON_CreateObject();
589 if (root == nullptr) {
590 WIFI_LOGE("Failed to create cJSON object");
591 return;
592 }
593 cJSON_AddNumberToObject(root, "ENCRY_OR_DECRY_EVENT", event);
594 cJSON_AddStringToObject(root, "SSID", maskSsid.c_str());
595 cJSON_AddStringToObject(root, "ENCRYKEYMANAGEMENT", keyMgmt.c_str());
596 cJSON_AddNumberToObject(root, "ENCRYEVENTMODULE", encryptedModule);
597
598 char *jsonStr = cJSON_PrintUnformatted(root);
599 if (jsonStr == nullptr) {
600 cJSON_Delete(root);
601 return;
602 }
603 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFIENCRY_OR_DECRY_FAIL", "EVENT_VALUE", std::string(jsonStr));
604 free(jsonStr);
605 cJSON_Delete(root);
606 }
607
WritePortalStateHiSysEvent(int portalState)608 void WritePortalStateHiSysEvent(int portalState)
609 {
610 cJSON *root = cJSON_CreateObject();
611 if (root == nullptr) {
612 WIFI_LOGE("Failed to create cJSON object");
613 return;
614 }
615 cJSON_AddNumberToObject(root, "PORTAL_STATE", portalState);
616
617 char *jsonStr = cJSON_PrintUnformatted(root);
618 if (jsonStr == nullptr) {
619 cJSON_Delete(root);
620 return;
621 }
622 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_PORTAL_STATE", "EVENT_VALUE", std::string(jsonStr));
623 free(jsonStr);
624 cJSON_Delete(root);
625 }
626
WriteArpInfoHiSysEvent(uint64_t arpRtt,int32_t arpFailedCount,int32_t gatewayCnt)627 void WriteArpInfoHiSysEvent(uint64_t arpRtt, int32_t arpFailedCount, int32_t gatewayCnt)
628 {
629 cJSON *root = cJSON_CreateObject();
630 if (root == nullptr) {
631 WIFI_LOGE("Failed to create cJSON object");
632 return;
633 }
634 cJSON_AddNumberToObject(root, "ARP_RTT", static_cast<double>(arpRtt));
635 cJSON_AddNumberToObject(root, "ARP_FAILED_COUNT", arpFailedCount);
636 cJSON_AddNumberToObject(root, "ARP_GWCOUNT", gatewayCnt);
637
638 char *jsonStr = cJSON_PrintUnformatted(root);
639 if (jsonStr == nullptr) {
640 cJSON_Delete(root);
641 return;
642 }
643 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_ARP_DETECTION_INFO", "EVENT_VALUE", std::string(jsonStr));
644 free(jsonStr);
645 cJSON_Delete(root);
646 }
647
WriteLinkInfoHiSysEvent(int signalLevel,int rssi,int band,int linkSpeed)648 void WriteLinkInfoHiSysEvent(int signalLevel, int rssi, int band, int linkSpeed)
649 {
650 cJSON *root = cJSON_CreateObject();
651 if (root == nullptr) {
652 WIFI_LOGE("Failed to create cJSON object");
653 return;
654 }
655 cJSON_AddNumberToObject(root, "LEVEL", signalLevel);
656 cJSON_AddNumberToObject(root, "BAND", band);
657 cJSON_AddNumberToObject(root, "RSSI", rssi);
658 cJSON_AddNumberToObject(root, "LINKSPEED", linkSpeed);
659
660 char *jsonStr = cJSON_PrintUnformatted(root);
661 if (jsonStr == nullptr) {
662 cJSON_Delete(root);
663 return;
664 }
665 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_LINK_INFO", "EVENT_VALUE", std::string(jsonStr));
666 free(jsonStr);
667 cJSON_Delete(root);
668 }
669
WriteConnectTypeHiSysEvent(int connectType,bool isFirstConnect)670 void WriteConnectTypeHiSysEvent(int connectType, bool isFirstConnect)
671 {
672 cJSON *root = cJSON_CreateObject();
673 if (root == nullptr) {
674 WIFI_LOGE("Failed to create cJSON object");
675 return;
676 }
677 std::string connectTypeStr = "";
678 if (g_connectTypeTransMap.find(connectType) != g_connectTypeTransMap.end()) {
679 connectTypeStr = g_connectTypeTransMap.at(connectType);
680 }
681 if (isFirstConnect) {
682 connectTypeStr = "FIRST_CONNECT";
683 }
684 cJSON_AddStringToObject(root, "CONNECT_TYPE", connectTypeStr.c_str());
685
686 char *jsonStr = cJSON_PrintUnformatted(root);
687 if (jsonStr == nullptr) {
688 cJSON_Delete(root);
689 return;
690 }
691 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "_CONNECT_TYPE", "EVENT_VALUE", std::string(jsonStr));
692 free(jsonStr);
693 cJSON_Delete(root);
694 }
695
WriteWifiLinkTypeHiSysEvent(const std::string & ssid,int32_t wifiLinkType,const std::string & triggerReason)696 void WriteWifiLinkTypeHiSysEvent(const std::string &ssid, int32_t wifiLinkType, const std::string &triggerReason)
697 {
698 cJSON *root = cJSON_CreateObject();
699 if (root == nullptr) {
700 WIFI_LOGE("Failed to create cJSON object");
701 return;
702 }
703 cJSON_AddStringToObject(root, "SSID", ssid.c_str());
704 cJSON_AddNumberToObject(root, "WIFI_LINK_TYPE", wifiLinkType);
705 cJSON_AddStringToObject(root, "TRIGGER_REASON", triggerReason.c_str());
706
707 char *jsonStr = cJSON_PrintUnformatted(root);
708 if (jsonStr == nullptr) {
709 cJSON_Delete(root);
710 return;
711 }
712 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_WIFI_LINK_TYPE_UPDATE", "EVENT_VALUE", std::string(jsonStr));
713 free(jsonStr);
714 cJSON_Delete(root);
715 }
716
WriteEmlsrExitReasonHiSysEvent(const std::string & ssid,int32_t reason)717 void WriteEmlsrExitReasonHiSysEvent(const std::string &ssid, int32_t reason)
718 {
719 cJSON *root = cJSON_CreateObject();
720 if (root == nullptr) {
721 WIFI_LOGE("Failed to create cJSON object");
722 return;
723 }
724 cJSON_AddStringToObject(root, "SSID", ssid.c_str());
725 cJSON_AddNumberToObject(root, "EMLSR_EXIT_REASON", reason);
726
727 char *jsonStr = cJSON_PrintUnformatted(root);
728 if (jsonStr == nullptr) {
729 cJSON_Delete(root);
730 return;
731 }
732 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_WIFI_EMLSR_EXIT_REASON", "EVENT_VALUE", std::string(jsonStr));
733 free(jsonStr);
734 cJSON_Delete(root);
735 }
736
WriteStaConnectIface(const std::string & ifName)737 void WriteStaConnectIface(const std::string &ifName)
738 {
739 cJSON *root = cJSON_CreateObject();
740 if (root == nullptr) {
741 WIFI_LOGE("Failed create cJSON object");
742 return;
743 }
744 cJSON_AddStringToObject(root, "IFACE_NAME", ifName.c_str());
745
746 char *jsonStr = cJSON_PrintUnformatted(root);
747 if (jsonStr == nullptr) {
748 cJSON_Delete(root);
749 return;
750 }
751 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_STA_CONNECT_IFNAME", "EVENT_VALUE", std::string(jsonStr));
752 free(jsonStr);
753 cJSON_Delete(root);
754 }
755
WriteWifiWpaStateHiSysEvent(int state)756 void WriteWifiWpaStateHiSysEvent(int state)
757 {
758 cJSON *root = cJSON_CreateObject();
759 if (root == nullptr) {
760 WIFI_LOGE("Failed to create cJSON object");
761 return;
762 }
763 cJSON_AddNumberToObject(root, "WPA_STATE", state);
764
765 char *jsonStr = cJSON_PrintUnformatted(root);
766 if (jsonStr == nullptr) {
767 cJSON_Delete(root);
768 return;
769 }
770 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_WPA_STATE", "EVENT_VALUE", std::string(jsonStr));
771 free(jsonStr);
772 cJSON_Delete(root);
773 }
774
WritePortalAuthExpiredHisysevent(int respCode,int detectNum,time_t connTime,time_t portalAuthTime,bool isNotificationClicked)775 void WritePortalAuthExpiredHisysevent(
776 int respCode, int detectNum, time_t connTime, time_t portalAuthTime, bool isNotificationClicked)
777 {
778 cJSON *root = cJSON_CreateObject();
779 if (root == nullptr) {
780 WIFI_LOGE("Failed to create cJSON object");
781 return;
782 }
783 time_t now = time(nullptr);
784 if (now < 0) {
785 now = 0;
786 }
787 int64_t authDura = (now > 0 && portalAuthTime > 0 && now > portalAuthTime) ? (now - portalAuthTime) : 0;
788 int64_t connDura = (now > 0 && connTime > 0 && now > connTime) ? (now - connTime) : 0;
789 int64_t authCostDura =
790 (portalAuthTime > 0 && connTime > 0 && portalAuthTime > connTime) ? (portalAuthTime - connTime) : 0;
791 cJSON_AddNumberToObject(root, "RESP_CODE", respCode);
792 cJSON_AddNumberToObject(root, "DURA", authDura);
793 cJSON_AddNumberToObject(root, "CONN_DURA", connDura);
794 cJSON_AddNumberToObject(root, "AUTH_COST_DURA", authCostDura);
795 cJSON_AddNumberToObject(root, "DET_NUM", detectNum);
796 cJSON_AddBoolToObject(root, "IS_NOTIFICA_CLICKED", isNotificationClicked);
797
798 char *jsonStr = cJSON_PrintUnformatted(root);
799 if (jsonStr == nullptr) {
800 cJSON_Delete(root);
801 return;
802 }
803 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "PORTAL_AUTH_EXPIRED", "EVENT_VALUE", std::string(jsonStr));
804 free(jsonStr);
805 cJSON_Delete(root);
806 }
807
WriteWifiSelfcureHisysevent(int type)808 void WriteWifiSelfcureHisysevent(int type)
809 {
810 cJSON *root = cJSON_CreateObject();
811 if (root == nullptr) {
812 WIFI_LOGE("Failed to create cJSON object");
813 return;
814 }
815 cJSON_AddNumberToObject(root, "WIFI_SELFCURE_TYPE", type);
816
817 char *jsonStr = cJSON_PrintUnformatted(root);
818 if (jsonStr == nullptr) {
819 cJSON_Delete(root);
820 return;
821 }
822 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_SELFCURE", "EVENT_VALUE", std::string(jsonStr));
823 free(jsonStr);
824 cJSON_Delete(root);
825 }
826
Write3VapConflictHisysevent(int type)827 void Write3VapConflictHisysevent(int type)
828 {
829 cJSON *root = cJSON_CreateObject();
830 if (root == nullptr) {
831 WIFI_LOGE("Failed to create cJSON object");
832 return;
833 }
834 cJSON_AddNumberToObject(root, "WIFI_3VAP_CONFLICT_TYPE", type);
835
836 char *jsonStr = cJSON_PrintUnformatted(root);
837 if (jsonStr == nullptr) {
838 cJSON_Delete(root);
839 return;
840 }
841 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_3VAP_CONFLICT", "EVENT_VALUE", std::string(jsonStr));
842 free(jsonStr);
843 cJSON_Delete(root);
844 }
845
Write5gPrefFailedHisysevent(Pref5gStatisticsInfo & info)846 void Write5gPrefFailedHisysevent(Pref5gStatisticsInfo &info)
847 {
848 int64_t conDuration = 0;
849 if (info.isIn5gPref && !info.has5gPrefSwitch) {
850 if (info.noInternetTime != std::chrono::steady_clock::time_point::min()) {
851 info.durationNoInternet +=
852 std::chrono::duration_cast<std::chrono::seconds>(std::chrono::steady_clock::now() - info.noInternetTime)
853 .count();
854 }
855 if (info.connectTime != std::chrono::steady_clock::time_point::min()) {
856 conDuration =
857 std::chrono::duration_cast<std::chrono::seconds>(std::chrono::steady_clock::now() - info.connectTime)
858 .count();
859 }
860 cJSON *root = cJSON_CreateObject();
861 if (root == nullptr) {
862 WIFI_LOGE("Failed to create cJSON object");
863 return;
864 }
865 cJSON_AddStringToObject(root, "BSSID", info.bssid.c_str());
866 cJSON_AddStringToObject(root, "SSID", info.ssid.c_str());
867 cJSON_AddNumberToObject(root, "FREQ", info.freq);
868 cJSON_AddNumberToObject(root, "CON_DURATION", conDuration);
869 cJSON_AddNumberToObject(root, "DURATION_NO_INTERNET", info.durationNoInternet);
870 cJSON_AddNumberToObject(root, "ENTER_MONITOR_NUM", info.enterMonitorNum);
871 cJSON_AddNumberToObject(root, "MONITOR_ACTIVE_SCAN_NUM", info.monitorActiveScanNum);
872 cJSON_AddNumberToObject(root, "RELA_5G_NUM", info.rela5gNum);
873 cJSON_AddNumberToObject(root, "NOT_ADJ_5g_NUM", info.notAdj5gNum);
874 cJSON_AddNumberToObject(root, "NOT_INTERNET_RELA_5G_NUM", info.notInternetRela5gNum);
875 cJSON_AddNumberToObject(root, "ALL_RELA_5G_IN_BLOCK_LIST_NUM", info.allRela5gInBlockListNum);
876 cJSON_AddNumberToObject(root, "SATISFY_NO_SELECTED_NUM", info.satisfySwitchRssiNoSelectedNum);
877 cJSON_AddNumberToObject(root, "IS_USER_CONNECTED", info.isUserConnected ? 1 : 0);
878
879 char *jsonStr = cJSON_PrintUnformatted(root);
880 if (jsonStr == nullptr) {
881 cJSON_Delete(root);
882 return;
883 }
884 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_5G_PREF_FAILED", "EVENT_VALUE", std::string(jsonStr));
885 free(jsonStr);
886 cJSON_Delete(root);
887 }
888 }
889
WriteAutoSelectHiSysEvent(int selectType,const std::string & selectedInfo,const std::string & filteredReason,const std::string & savedResult)890 void WriteAutoSelectHiSysEvent(
891 int selectType, const std::string &selectedInfo, const std::string &filteredReason, const std::string &savedResult)
892 {
893 cJSON *root = cJSON_CreateObject();
894 if (root == nullptr) {
895 WIFI_LOGE("Failed to create cJSON object");
896 return;
897 }
898 cJSON_AddNumberToObject(root, "AUTO_SELECT_TYPE", selectType);
899 cJSON_AddStringToObject(root, "AUTO_SELECT_RESULT", selectedInfo.c_str());
900 cJSON_AddStringToObject(root, "AUTO_SELECT_FILTER", filteredReason.c_str());
901 cJSON_AddStringToObject(root, "SAVED_NETWORK_IN_SCAN", savedResult.c_str());
902
903 char *jsonStr = cJSON_PrintUnformatted(root);
904 if (jsonStr == nullptr) {
905 cJSON_Delete(root);
906 return;
907 }
908 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_AUTO_SELECT_STATISTIC", "EVENT_VALUE", std::string(jsonStr));
909 free(jsonStr);
910 cJSON_Delete(root);
911 }
912
WriteDhcpInfoHiSysEvent(const IpInfo & ipInfo,const IpV6Info & ipv6Info)913 void WriteDhcpInfoHiSysEvent(const IpInfo &ipInfo, const IpV6Info &ipv6Info)
914 {
915 cJSON *root = cJSON_CreateObject();
916 if (root == nullptr) {
917 WIFI_LOGE("Failed to create cJSON object");
918 return;
919 }
920 cJSON_AddStringToObject(root, "IPV4_IPADDRESS", Ipv4IntAnonymize(ipInfo.ipAddress).c_str());
921 cJSON_AddStringToObject(root, "IPV4_GATEWAY", Ipv4IntAnonymize(ipInfo.gateway).c_str());
922 cJSON_AddStringToObject(root, "IPV4_NETMASK", Ipv4IntAnonymize(ipInfo.netmask).c_str());
923 cJSON_AddStringToObject(root, "IPV4_PRIMARYDNS", Ipv4IntAnonymize(ipInfo.primaryDns).c_str());
924 cJSON_AddStringToObject(root, "IPV4_SECONDDNS", Ipv4IntAnonymize(ipInfo.secondDns).c_str());
925 cJSON_AddStringToObject(root, "IPV4_SERVERIP", Ipv4IntAnonymize(ipInfo.serverIp).c_str());
926 cJSON_AddNumberToObject(root, "IPV4_LEASE", ipInfo.leaseDuration);
927 cJSON_AddNumberToObject(root, "IPV4_DNS_VEC_SIZE", static_cast<int32_t>(ipInfo.dnsAddr.size()));
928 for (size_t i = 0; i < ipInfo.dnsAddr.size(); i++) {
929 if (i >= MAX_DNS_NUM) {
930 WIFI_LOGE("ipInfo.dnsAddr size over limit");
931 break;
932 }
933 std::string keyString = "IPV4_DNS" + std::to_string(i);
934 cJSON_AddStringToObject(root, keyString.c_str(), Ipv4IntAnonymize(ipInfo.dnsAddr[i]).c_str());
935 }
936 cJSON_AddStringToObject(root, "IPV6_LINKIPV6ADDR", Ipv6Anonymize(ipv6Info.linkIpV6Address).c_str());
937 cJSON_AddStringToObject(root, "IPV6_GLOBALIPV6ADDR", Ipv6Anonymize(ipv6Info.globalIpV6Address).c_str());
938 cJSON_AddStringToObject(root, "IPV6_RANDGLOBALIPV6ADDR", Ipv6Anonymize(ipv6Info.randGlobalIpV6Address).c_str());
939 cJSON_AddStringToObject(root, "IPV6_GATEWAY", Ipv6Anonymize(ipv6Info.gateway).c_str());
940 cJSON_AddStringToObject(root, "IPV6_NETMASK", Ipv6Anonymize(ipv6Info.netmask).c_str());
941 cJSON_AddStringToObject(root, "IPV6_PRIMARYDNS", Ipv6Anonymize(ipv6Info.primaryDns).c_str());
942 cJSON_AddStringToObject(root, "IPV6_SECONDDNS", Ipv6Anonymize(ipv6Info.secondDns).c_str());
943 cJSON_AddStringToObject(root, "IPV6_UNIQUELOCALADDR1", Ipv6Anonymize(ipv6Info.uniqueLocalAddress1).c_str());
944 cJSON_AddStringToObject(root, "IPV6_UNIQUELOCALADDR2", Ipv6Anonymize(ipv6Info.uniqueLocalAddress2).c_str());
945 char *jsonStr = cJSON_PrintUnformatted(root);
946 if (jsonStr == nullptr) {
947 cJSON_Delete(root);
948 return;
949 }
950 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_DHCP_INFO", "EVENT_VALUE", std::string(jsonStr));
951 free(jsonStr);
952 cJSON_Delete(root);
953 }
954
WriteIodHiSysEvent(const IodStatisticInfo & iodStatisticInfo)955 void WriteIodHiSysEvent(const IodStatisticInfo &iodStatisticInfo)
956 {
957 cJSON *root = cJSON_CreateObject();
958 if (root == nullptr) {
959 WIFI_LOGE("Failed to create cJSON object");
960 return;
961 }
962 cJSON_AddNumberToObject(root, "OUTDOOR_FILTER_CNT", iodStatisticInfo.outdoorFilterCnt);
963 cJSON_AddNumberToObject(root, "OUTDOOR_SELECT_WIFI_CNT", iodStatisticInfo.outdoorAutoSelectCnt);
964 cJSON_AddNumberToObject(root, "IN_TO_OUTDOOR_CNT", iodStatisticInfo.in2OutCnt);
965 cJSON_AddNumberToObject(root, "OUT_TO_INDOOR_CNT", iodStatisticInfo.out2InCnt);
966 cJSON_AddNumberToObject(root, "OUTDOOR_CONN_LEVEL0", iodStatisticInfo.outdoorConnLevel0);
967 cJSON_AddNumberToObject(root, "OUTDOOR_CONN_LEVEL1", iodStatisticInfo.outdoorConnLevel1);
968 cJSON_AddNumberToObject(root, "OUTDOOR_CONN_LEVEL2", iodStatisticInfo.outdoorConnLevel2);
969 cJSON_AddNumberToObject(root, "OUTDOOR_CONN_LEVEL3", iodStatisticInfo.outdoorConnLevel3);
970 cJSON_AddNumberToObject(root, "OUTDOOR_CONN_LEVEL4", iodStatisticInfo.outdoorConnLevel4);
971 cJSON_AddNumberToObject(root, "INDOOR_CONN_LEVEL0", iodStatisticInfo.indoorConnLevel0);
972 cJSON_AddNumberToObject(root, "INDOOR_CONN_LEVEL1", iodStatisticInfo.indoorConnLevel1);
973 cJSON_AddNumberToObject(root, "INDOOR_CONN_LEVEL2", iodStatisticInfo.indoorConnLevel2);
974 cJSON_AddNumberToObject(root, "INDOOR_CONN_LEVEL3", iodStatisticInfo.indoorConnLevel3);
975 cJSON_AddNumberToObject(root, "INDOOR_CONN_LEVEL4", iodStatisticInfo.indoorConnLevel4);
976 cJSON_AddNumberToObject(root, "OUTDOOR_CONN_SHORT", iodStatisticInfo.outdoorConnShortTime);
977 cJSON_AddNumberToObject(root, "INDOOR_CONN_SHORT", iodStatisticInfo.indoorConnShortTime);
978
979 char *jsonStr = cJSON_PrintUnformatted(root);
980 if (jsonStr == nullptr) {
981 cJSON_Delete(root);
982 return;
983 }
984 WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_IOD_STATISTIC", "EVENT_VALUE", std::string(jsonStr));
985 free(jsonStr);
986 cJSON_Delete(root);
987 }
988 } // namespace Wifi
989 } // namespace OHOS