From 65f29d15f18b4b7deb33b2a114a96b338aece59f Mon Sep 17 00:00:00 2001 From: shihaojie Date: Wed, 16 Jul 2025 07:39:43 +0000 Subject: [PATCH 01/13] zly Signed-off-by: shihaojie --- wifi/test/zly.txt | 1254 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1254 insertions(+) create mode 100644 wifi/test/zly.txt diff --git a/wifi/test/zly.txt b/wifi/test/zly.txt new file mode 100644 index 000000000..71e8da668 --- /dev/null +++ b/wifi/test/zly.txt @@ -0,0 +1,1254 @@ +#include "cJSON.h" + + + + cJSON *param = cJSON_CreateObject(); + if (param == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(param, "ability.want.params.uiExtensionType", "sysDialog/common"); + cJSON_AddNumberToObject(param, "wifiDialogType", static_cast(type)); + switch (type) { + case AUTO_IDENTIFY_CONN: + case SETTINGS_AUTO_IDENTIFY_CONN: + cJSON_AddStringToObject(param, "wifi5gSsid", comInfo.c_str()); + break; + case P2P_WSC_PBC_DIALOG: + cJSON_AddStringToObject(param, "p2pDeviceName", comInfo.c_str()); + break; + case CANDIDATE_CONNECT: + cJSON_AddStringToObject(param, "targetSsid", comInfo.c_str()); + break; + default: + break; + + } + char *cjsonStr = cJSON_PrintUnformatted(param); + if (cjsonStr == nullptr) { + WIFI_LOGE("Failed to print cJSON object"); + cJSON_Delete(param); + return; + } + std::string cmdData(cjsonStr); + free(cjsonStr); + cJSON_Delete(param); + + + + + + cJSON *param = cJSON_CreateObject(); + if (param == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(param, "ability.want.params.uiExtensionType", "sysDialog/common"); + char *cjsonStr = cJSON_PrintUnformatted(param); + if (cjsonStr == nullptr) { + WIFI_LOGE("Failed to print cJSON object"); + cJSON_Delete(param); + return; + } + std::string cmdData(cjsonStr); + free(cjsonStr); + cJSON_Delete(param); + + + + +#include "cJSON.h" + + + + cJSON *root = FillWifiProStatisticsJson(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_PRO_STATISTICS", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); + + + + +cJSON *WifiProChr::FillWifiProStatisticsJson() +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return nullptr; + } + cJSON_AddNumberToObject(root, "FAST_SCAN_CNT", fastScanCnt_); + cJSON_AddNumberToObject(root, "FULL_SCAN_CNT", fullScanCnt_); + cJSON_AddNumberToObject(root, "WIFIPRO_POOR_LINK_CNT", poorLinkCnt_); + cJSON_AddNumberToObject(root, "WIFIPRO_NONET_CNT", noNetCnt_); + cJSON_AddNumberToObject(root, "WIFIPRO_QOE_SLOW_CNT", qoeSlowCnt_); + cJSON_AddNumberToObject( + root, "POOR_LINK_SELECT_NET_SUCC_CNT", selectNetResultCnt_[WifiProEventResult::POORLINK_SUCC]); + cJSON_AddNumberToObject(root, "NONET_SELECT_NET_SUCC_CNT", selectNetResultCnt_[WifiProEventResult::NONET_SUCC]); + cJSON_AddNumberToObject(root, "QOE_SLOW_SELECT_NET_SUCC_CNT", selectNetResultCnt_[WifiProEventResult::QOE_SUCCC]); + cJSON_AddNumberToObject( + root, "POOR_LINK_SELECT_NET_FAILED_CNT", selectNetResultCnt_[WifiProEventResult::POORLINK_FAILED]); + cJSON_AddNumberToObject(root, "NONET_SELECT_NET_FAILED_CNT", selectNetResultCnt_[WifiProEventResult::NONET_FAILED]); + cJSON_AddNumberToObject( + root, "QOE_SLOW_SELECT_NET_FAILED_CNT", selectNetResultCnt_[WifiProEventResult::QOESLOW_FAILED]); + cJSON_AddNumberToObject(root, "POOR_LINK_SWITCH_SUCC_CNT", wifiProResultCnt_[WifiProEventResult::POORLINK_SUCC]); + cJSON_AddNumberToObject(root, "NONET_SWITCH_SUCC_CNT", wifiProResultCnt_[WifiProEventResult::NONET_SUCC]); + cJSON_AddNumberToObject(root, "QOE_SLOW_SWITCH_SUCC_CNT", wifiProResultCnt_[WifiProEventResult::QOE_SUCCC]); + cJSON_AddNumberToObject( + root, "POOR_LINK_SWITCH_FAILED_CNT", wifiProResultCnt_[WifiProEventResult::POORLINK_FAILED]); + + FillWifiProStatisticsJsons(root); + return root; +} + +void WifiProChr::FillWifiProStatisticsJsons(cJSON *root) +{ + cJSON_AddNumberToObject(root, "NONET_SWITCH_FAILED_CNT", wifiProResultCnt_[WifiProEventResult::NONET_FAILED]); + cJSON_AddNumberToObject(root, "QOE_SLOW_SWITCH_FAILED_CNT", wifiProResultCnt_[WifiProEventResult::QOESLOW_FAILED]); + cJSON_AddNumberToObject(root, "TIME_LEVEL1_CNT", wifiProSwitchTimeCnt_[SWITCH_TIME_LEVEL1]); + cJSON_AddNumberToObject(root, "TIME_LEVEL2_CNT", wifiProSwitchTimeCnt_[SWITCH_TIME_LEVEL2]); + cJSON_AddNumberToObject(root, "TIME_LEVEL3_CNT", wifiProSwitchTimeCnt_[SWITCH_TIME_LEVEL3]); + cJSON_AddNumberToObject(root, "TIME_START_TO_CONNECT_LEVEL1_CNT", wifiProSwitchTimeCnt_[START_TO_CONNECT_LEVEL1]); + cJSON_AddNumberToObject(root, "TIME_START_TO_CONNECT_LEVEL2_CNT", wifiProSwitchTimeCnt_[START_TO_CONNECT_LEVEL2]); + cJSON_AddNumberToObject(root, "TIME_START_TO_CONNECT_LEVEL3_CNT", wifiProSwitchTimeCnt_[START_TO_CONNECT_LEVEL3]); + cJSON_AddNumberToObject(root, "TIME_CONNECT_TO_SUCC_LEVEL1_CNT", wifiProSwitchTimeCnt_[CONNECT_TO_SUCC_LEVEL1]); + cJSON_AddNumberToObject(root, "TIME_CONNECT_TO_SUCC_LEVEL2_CNT", wifiProSwitchTimeCnt_[CONNECT_TO_SUCC_LEVEL2]); + cJSON_AddNumberToObject(root, "TIME_CONNECT_TO_SUCC_LEVEL3_CNT", wifiProSwitchTimeCnt_[CONNECT_TO_SUCC_LEVEL3]); + cJSON_AddNumberToObject( + root, "REASON_NOT_SWITCH_SWITCHING", reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_SWITCHING]); + cJSON_AddNumberToObject( + root, "REASON_NOT_SWITCH_SELFCURING", reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_SELFCURING]); + cJSON_AddNumberToObject( + root, "REASON_NOT_SWITCH_NONET_BEFORE", reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_NONET_BEFORE_CONNECT]); + cJSON_AddNumberToObject( + root, "REASON_NOT_SWITCH_SIGNAL_BRIDGE", reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_SIGNAL_BRIDGE_ON]); + cJSON_AddNumberToObject( + root, "REASON_NOT_SWITCH_AP_STA_ON", reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_AP_STA_ON]); + cJSON_AddNumberToObject( + root, "REASON_NOT_SWITCH_APP_WLISTS", reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_APP_WHITE_LISTS]); + cJSON_AddNumberToObject( + root, "REASON_NOT_SWITCH_ISCALLING", reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_ISCALLING]); + cJSON_AddNumberToObject( + root, "REASON_NOT_SWITCH_NOT_AUTOSWITCH", reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_NOT_ALLOW_AUTOSWITCH]); + cJSON_AddNumberToObject(root, "REASON_NOT_SWITCH_DISABLED", reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_DISABLED]); +} + + + + + + cJSON *FillWifiProStatisticsJson(); + void FillWifiProStatisticsJsons(cJSON *root); + + + + + + cJSON *root = cJSON_Parse(model.result.c_str()); + if (root == nullptr) { + + + WIFI_LOGE("model.result is null"); + return WIFI_OPT_FAILED; + } + + cJSON *statusItem = cJSON_GetObjectItem(root, "status"); + if (statusItem && cJSON_IsNumber(statusItem) && statusItem->valueint != 0) { + WIFI_LOGE("RequestSecurityModelResultSync status error= %d", statusItem->valueint); + cJSON_Delete(root); + return WIFI_OPT_FAILED; + } + + cJSON *resultItem = cJSON_GetObjectItem(root, "result"); + std::string SecurityResult; + if (resultItem && cJSON_IsString(resultItem)) { + SecurityResult = resultItem->valuestring; + } else { + SecurityResult = ""; + } + + cJSON_Delete(root); + + + + + + + + + +void WifiSecurityDetect::ConverWifiLinkInfoToJson(const WifiLinkedInfo &info, cJSON *root) +{ + WifiDeviceConfig config; + if (WifiSettings::GetInstance().GetDeviceConfig(info.networkId, config) != 0) { + WIFI_LOGE("%{public}s, not find networkId:%{public}d", __FUNCTION__, info.networkId); + return; + } + IpInfo wifiIpInfo; + int32_t instId = 0; + WifiConfigCenter::GetInstance().GetIpInfo(wifiIpInfo, instId); + + AddWifiStandardToJson(root, info.wifiStandard); + + cJSON_AddStringToObject(root, "ssid", config.ssid.c_str()); + cJSON_AddStringToObject(root, "bssid", config.bssid.c_str()); + cJSON_AddNumberToObject(root, "signalStrength", config.rssi); + cJSON_AddNumberToObject(root, "authentication", AuthenticationConvert(config.keyMgmt)); + if (config.frequency >= MIN_5G_FREQUENCY && config.frequency <= MAX_5G_FREQUENCY) { + cJSON_AddStringToObject(root, "frequencyBand", "5GHz"); + } else { + cJSON_AddStringToObject(root, "frequencyBand", "2.4GHz"); + } + cJSON_AddStringToObject(root, "gatewayIp", IpTools::ConvertIpv4Address(wifiIpInfo.ipAddress).c_str()); + cJSON_AddStringToObject(root, "gatewayMac", config.macAddress.c_str()); + cJSON_AddStringToObject(root, "primaryDns", IpTools::ConvertIpv4Address(wifiIpInfo.primaryDns).c_str()); + if (wifiIpInfo.secondDns == 0) { + cJSON_AddStringToObject(root, "secondDns", "0.0.0.0"); + } else { + cJSON_AddStringToObject(root, "secondDns", IpTools::ConvertIpv4Address(wifiIpInfo.secondDns).c_str()); + } +} + +void WifiSecurityDetect::AddWifiStandardToJson(cJSON *root, int wifiStandard) +{ + switch (wifiStandard) { + case WireType::WIRE_802_11A: + cJSON_AddStringToObject(root, "wirelessType", "802.11a"); + break; + case WireType::WIRE_802_11B: + cJSON_AddStringToObject(root, "wirelessType", "802.11b"); + break; + case WireType::WIRE_802_11G: + cJSON_AddStringToObject(root, "wirelessType", "802.11g"); + break; + case WireType::WIRE_802_11N: + cJSON_AddStringToObject(root, "wirelessType", "802.11n"); + break; + case WireType::WIRE_802_11AC: + cJSON_AddStringToObject(root, "wirelessType", "802.11ac"); + break; + case WireType::WIRE_802_11AX: + cJSON_AddStringToObject(root, "wirelessType", "802.11ax"); + break; + default: + WIFI_LOGE("wifi wirelessType is unknown"); + cJSON_AddStringToObject(root, "wirelessType", ""); + break; + + + + + + + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + ConverWifiLinkInfoToJson(info, root); + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr != nullptr) { + model.param = jsonStr; + WIFI_LOGI("%s", model.param.c_str()); + free(jsonStr); + } + cJSON_Delete(root); + + + + + +void AddWifiStandardToJson(cJSON *root, int wifiStandard); + + void ConverWifiLinkInfoToJson(const WifiLinkedInfo &info, cJSON *root); + + + + + + + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + LOGE("Failed to create cJSON object"); + return ""; + } + cJSON *resultInfo = cJSON_CreateArray(); + if (resultInfo == nullptr) { + LOGE("Failed to create cJSON Arr"); + cJSON_Delete(root); + return ""; + } + cJSON *errorInfo = cJSON_CreateObject(); + if (errorInfo == nullptr) { + LOGE("Failed to create cJSON object"); + cJSON_Delete(root); + return ""; + } + + cJSON_AddStringToObject(errorInfo, "type", "ErrorInfo"); + std::string codeStr = std::to_string(replyCode); + cJSON_AddStringToObject(errorInfo, "errorCode", codeStr.c_str()); + cJSON_AddStringToObject(errorInfo, "errorInfo", ""); + + cJSON_AddItemToArray(resultInfo, errorInfo); + + + cJSON_AddItemToObject(root, "resultInfo", resultInfo); + + char *jsonStr = cJSON_PrintUnformatted(root); + std::string result; + if (jsonStr != nullptr) { + result = jsonStr; + free(jsonStr); + } + + cJSON_Delete(root); + return result; + + + + + if (errorInfo == nullptr) { + LOGE("Failed to create cJSON object"); + cJSON_Delete(root); + return ""; + } + + cJSON_AddStringToObject(errorInfo, "type", "ErrorInfo"); + std::string codeStr = std::to_string(replyCode); + cJSON_AddStringToObject(errorInfo, "errorCode", codeStr.c_str()); + cJSON_AddStringToObject(errorInfo, "errorInfo", ""); + + cJSON_AddItemToArray(resultInfo, errorInfo); + + + cJSON_AddItemToObject(root, "resultInfo", resultInfo); + + char *jsonStr = cJSON_PrintUnformatted(root); + std::string result; + if (jsonStr != nullptr) { + result = jsonStr; + free(jsonStr); + } + + cJSON_Delete(root); + return result; + + + + + + cJSON *root = cJSON_Parse(jsonString.c_str()); + if (root == nullptr) { + + + + LOGE("ParseJson failed to parse json data."); + return false; + } + if (!cJSON_IsArray(root)) { + cJSON_Delete(root); + return false; + } + int nSize = cJSON_GetArraySize(root); + for (int i = 0; i < nSize; i++) { + cJSON *item = cJSON_GetArrayItem(root, i); + if (item == nullptr || !cJSON_IsObject(item)) { + continue; + } + cJSON *typeItem = cJSON_GetObjectItem(item, type.c_str()); // 比如 "data" + if (typeItem == nullptr) { + continue; + } + if (ParseJsonKey(typeItem, key, value)) { + cJSON_Delete(root); + return true; + } + } + cJSON_Delete(root); + return false; +} + + + + + + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "WIFI_STATE", static_cast(operType)); + cJSON_AddStringToObject(root, "TYPE", serviceType.c_str()); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_WIFI_STATE", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); + + + + + +void WriteWifiOperateStateHiSysEvent(int operateType, int operateState) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "OPERATE_TYPE", operateType); + cJSON_AddNumberToObject(root, "OPERATE_STATE", operateState); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_OPERATE_STATE", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteWifiAbnormalDisconnectHiSysEvent(int errorCode, int locallyGenerated) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "ERROR_CODE", errorCode); + cJSON_AddNumberToObject(root, "IS_ACTIVE_DISCONNECT", locallyGenerated); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_ABNORMAL_DISCONNECT", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteWifiBeaconLostHiSysEvent(int32_t errorCode) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "ERROR_CODE", errorCode); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_BEACON_LOST", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteWifiConnectionInfoHiSysEvent(int networkId) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "NETWORK_ID", networkId); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_CONNECTION_INFO", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteWifiOpenAndCloseFailedHiSysEvent(int operateType, std::string failReason, int apState) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "OPERATE_TYPE", operateType); + cJSON_AddStringToObject(root, "FAIL_REASON", failReason.c_str()); + cJSON_AddNumberToObject(root, "AP_STATE", apState); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_OPEN_AND_CLOSE_FAILED", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteSoftApOpenAndCloseFailedEvent(int operateType, std::string failReason) +{ + WIFI_LOGE("WriteSoftApOpenAndCloseFailedEvent operateType=%{public}d", operateType); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "OPERATE_TYPE", operateType); + cJSON_AddStringToObject(root, "FAIL_REASON", failReason.c_str()); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "SOFTAP_OPEN_AND_CLOSE_FAILED", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteWifiAccessIntFailedHiSysEvent( + int operateRes, int failCnt, int selfCureResetState, std::string selfCureHistory) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "OPERATE_TYPE", operateRes); + cJSON_AddNumberToObject(root, "FAIL_CNT", failCnt); + cJSON_AddNumberToObject(root, "RESET_STATE", selfCureResetState); + cJSON_AddStringToObject(root, "SELF_CURE_HISTORY", selfCureHistory.c_str()); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_ACCESS_INTERNET_FAILED", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteWifiPnoScanHiSysEvent(int isStartScan, int suspendReason) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "IS_START", isStartScan); + cJSON_AddNumberToObject(root, "SUSPEND_REASON", suspendReason); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_PNO_SCAN_INFO", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteBrowserFailedForPortalHiSysEvent(int respCode, std::string &server) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "RESP_CODE", respCode); + cJSON_AddStringToObject(root, "SERVER", server.c_str()); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "BROWSER_FAILED_FOR_PORTAL", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteAuthFailHiSysEvent(const std::string &authFailReason, int subErrCode) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(root, "FAIL_REASON", authFailReason.c_str()); + cJSON_AddNumberToObject(root, "SUB_ERR_CODE", subErrCode); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_AUTH_FAIL_INFO", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteAssocFailHiSysEvent(const std::string &assocFailReason, int subErrCode) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(root, "FAIL_REASON", assocFailReason.c_str()); + cJSON_AddNumberToObject(root, "SUB_ERR_CODE", subErrCode); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_ASSOC_FAIL_INFO", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteDhcpFailHiSysEvent(const std::string &dhcpFailReason, int subErrCode) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(root, "FAIL_REASON", dhcpFailReason.c_str()); + cJSON_AddNumberToObject(root, "SUB_ERR_CODE", subErrCode); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_DHCP_FAIL_INFO", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteScanLimitHiSysEvent(const std::string &scanInitiator, int scanLimitType, bool isForeground) + if (scanInitiator.empty()) { + return; + } + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(root, "SCAN_INITIATOR", scanInitiator.c_str()); + cJSON_AddBoolToObject(root, "IS_FOREGROUND", isForeground); + cJSON_AddNumberToObject(root, "SCAN_LIMIT_TYPE", scanLimitType); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_SCAN_LIMIT_STATISTICS", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteAutoConnectFailEvent(const std::string &failReason, const std::string &subReason) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(root, "FAIL_REASON", failReason.c_str()); + cJSON_AddStringToObject(root, "SUB_REASON", subReason.c_str()); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_AUTO_RECONNECT_FAILED", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteP2pKpiCountHiSysEvent(int eventType) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "EVENT_TYPE", eventType); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "P2P_CONNECT_STATICS", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteP2pConnectFailedHiSysEvent(int errCode, int failRes) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "EVENT_TYPE", errCode); + cJSON_AddNumberToObject(root, "FAIL_RES", failRes); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "P2P_CONNECT_FAIL", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteP2pAbDisConnectHiSysEvent(int errCode, int failRes) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "EVENT_TYPE", errCode); + cJSON_AddNumberToObject(root, "FAIL_RES", failRes); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "P2P_ABNORMAL_DISCONNECT", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteSoftApAbDisconnectHiSysEvent(int errorCode) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "ERROR_CODE", errorCode); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "SOFTAP_ABNORMAL_DISCONNECT", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteIsInternetHiSysEvent(int isInternet) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "IS_INTERNET", isInternet); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_KPI_INTERNET", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteSoftApConnectFailHiSysEvent(int errorCnt) +{ + WIFI_LOGE("WriteSoftApConnectFailHiSysEvent errorCnt=%{public}d", errorCnt); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "ERROR_CODE", errorCnt); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "SOFTAP_CONNECT_FAILED", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteSoftApClientAccessNetErrorHiSysEvent(int errorCode) +{ + WIFI_LOGE("WriteSoftApClientAccessNetErrorHiSysEvent errorCode=%{public}d", errorCode); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "ERROR_CODE", errorCode); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "SOFTAP_CLIENT_ACCESS_NET_ERROR", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteWifiScanApiFailHiSysEvent(const std::string &pkgName, const WifiScanFailReason failReason) +{ +#ifndef OHOS_ARCH_LITE + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(root, "PKG_NAME", pkgName.c_str()); + cJSON_AddNumberToObject(root, "FAIL_REASON", static_cast(failReason)); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFISCANCONTROL_TRIGGER_API_FAIL", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +#endif +} + +void WriteWifiEncryptionFailHiSysEvent( + int event, const std::string &maskSsid, const std::string &keyMgmt, int encryptedModule) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "ENCRY_OR_DECRY_EVENT", event); + cJSON_AddStringToObject(root, "SSID", maskSsid.c_str()); + cJSON_AddStringToObject(root, "ENCRYKEYMANAGEMENT", keyMgmt.c_str()); + cJSON_AddNumberToObject(root, "ENCRYEVENTMODULE", encryptedModule); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFIENCRY_OR_DECRY_FAIL", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WritePortalStateHiSysEvent(int portalState) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "PORTAL_STATE", portalState); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_PORTAL_STATE", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteArpInfoHiSysEvent(uint64_t arpRtt, int32_t arpFailedCount, int32_t gatewayCnt) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "ARP_RTT", static_cast(arpRtt)); + cJSON_AddNumberToObject(root, "ARP_FAILED_COUNT", arpFailedCount); + cJSON_AddNumberToObject(root, "ARP_GWCOUNT", gatewayCnt); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_ARP_DETECTION_INFO", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteLinkInfoHiSysEvent(int signalLevel, int rssi, int band, int linkSpeed) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "LEVEL", signalLevel); + cJSON_AddNumberToObject(root, "BAND", band); + cJSON_AddNumberToObject(root, "RSSI", rssi); + cJSON_AddNumberToObject(root, "LINKSPEED", linkSpeed); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_LINK_INFO", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteConnectTypeHiSysEvent(int connectType, bool isFirstConnect) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + std::string connectTypeStr = ""; + if (g_connectTypeTransMap.find(connectType) != g_connectTypeTransMap.end()) { + connectTypeStr = g_connectTypeTransMap.at(connectType); + if (isFirstConnect) { + connectTypeStr = "FIRST_CONNECT"; + } + cJSON_AddStringToObject(root, "CONNECT_TYPE", connectTypeStr.c_str()); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "_CONNECT_TYPE", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteWifiLinkTypeHiSysEvent(const std::string &ssid, int32_t wifiLinkType, const std::string &triggerReason) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(root, "SSID", ssid.c_str()); + cJSON_AddNumberToObject(root, "WIFI_LINK_TYPE", wifiLinkType); + cJSON_AddStringToObject(root, "TRIGGER_REASON", triggerReason.c_str()); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_WIFI_LINK_TYPE_UPDATE", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteEmlsrExitReasonHiSysEvent(const std::string &ssid, int32_t reason) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(root, "SSID", ssid.c_str()); + cJSON_AddNumberToObject(root, "EMLSR_EXIT_REASON", reason); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_WIFI_EMLSR_EXIT_REASON", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteStaConnectIface(const std::string &ifName) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed create cJSON object"); + return; + } + cJSON_AddStringToObject(root, "IFACE_NAME", ifName.c_str()); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_STA_CONNECT_IFNAME", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteWifiWpaStateHiSysEvent(int state) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "WPA_STATE", state); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_WPA_STATE", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WritePortalAuthExpiredHisysevent( + int respCode, int detectNum, time_t connTime, time_t portalAuthTime, bool isNotificationClicked) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + time_t now = time(nullptr); + if (now < 0) { + now = 0; + } + int64_t authDura = (now > 0 && portalAuthTime > 0 && now > portalAuthTime) ? (now - portalAuthTime) : 0; + int64_t connDura = (now > 0 && connTime > 0 && now > connTime) ? (now - connTime) : 0; + int64_t authCostDura = + (portalAuthTime > 0 && connTime > 0 && portalAuthTime > connTime) ? (portalAuthTime - connTime) : 0; + cJSON_AddNumberToObject(root, "RESP_CODE", respCode); + cJSON_AddNumberToObject(root, "DURA", authDura); + cJSON_AddNumberToObject(root, "CONN_DURA", connDura); + cJSON_AddNumberToObject(root, "AUTH_COST_DURA", authCostDura); + cJSON_AddNumberToObject(root, "DET_NUM", detectNum); + cJSON_AddBoolToObject(root, "IS_NOTIFICA_CLICKED", isNotificationClicked); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "PORTAL_AUTH_EXPIRED", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteWifiSelfcureHisysevent(int type) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "WIFI_SELFCURE_TYPE", type); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_SELFCURE", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void Write3VapConflictHisysevent(int type) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "WIFI_3VAP_CONFLICT_TYPE", type); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_3VAP_CONFLICT", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void Write5gPrefFailedHisysevent(Pref5gStatisticsInfo &info) + int64_t conDuration = 0; + if (info.isIn5gPref && !info.has5gPrefSwitch) { + if (info.noInternetTime != std::chrono::steady_clock::time_point::min()) { + info.durationNoInternet += + std::chrono::duration_cast(std::chrono::steady_clock::now() - info.noInternetTime) + .count(); + } + if (info.connectTime != std::chrono::steady_clock::time_point::min()) { + conDuration = + std::chrono::duration_cast(std::chrono::steady_clock::now() - info.connectTime) + .count(); + } + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(root, "BSSID", info.bssid.c_str()); + cJSON_AddStringToObject(root, "SSID", info.ssid.c_str()); + cJSON_AddNumberToObject(root, "FREQ", info.freq); + cJSON_AddNumberToObject(root, "CON_DURATION", conDuration); + cJSON_AddNumberToObject(root, "DURATION_NO_INTERNET", info.durationNoInternet); + cJSON_AddNumberToObject(root, "ENTER_MONITOR_NUM", info.enterMonitorNum); + cJSON_AddNumberToObject(root, "MONITOR_ACTIVE_SCAN_NUM", info.monitorActiveScanNum); + cJSON_AddNumberToObject(root, "RELA_5G_NUM", info.rela5gNum); + cJSON_AddNumberToObject(root, "NOT_ADJ_5g_NUM", info.notAdj5gNum); + cJSON_AddNumberToObject(root, "NOT_INTERNET_RELA_5G_NUM", info.notInternetRela5gNum); + cJSON_AddNumberToObject(root, "ALL_RELA_5G_IN_BLOCK_LIST_NUM", info.allRela5gInBlockListNum); + cJSON_AddNumberToObject(root, "SATISFY_NO_SELECTED_NUM", info.satisfySwitchRssiNoSelectedNum); + cJSON_AddNumberToObject(root, "IS_USER_CONNECTED", info.isUserConnected ? 1 : 0); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_5G_PREF_FAILED", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); + } +} + +void WriteAutoSelectHiSysEvent( + int selectType, const std::string &selectedInfo, const std::string &filteredReason, const std::string &savedResult) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "AUTO_SELECT_TYPE", selectType); + cJSON_AddStringToObject(root, "AUTO_SELECT_RESULT", selectedInfo.c_str()); + cJSON_AddStringToObject(root, "AUTO_SELECT_FILTER", filteredReason.c_str()); + cJSON_AddStringToObject(root, "SAVED_NETWORK_IN_SCAN", savedResult.c_str()); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_AUTO_SELECT_STATISTIC", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteDhcpInfoHiSysEvent(const IpInfo &ipInfo, const IpV6Info &ipv6Info) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(root, "IPV4_IPADDRESS", Ipv4IntAnonymize(ipInfo.ipAddress).c_str()); + cJSON_AddStringToObject(root, "IPV4_GATEWAY", Ipv4IntAnonymize(ipInfo.gateway).c_str()); + cJSON_AddStringToObject(root, "IPV4_NETMASK", Ipv4IntAnonymize(ipInfo.netmask).c_str()); + cJSON_AddStringToObject(root, "IPV4_PRIMARYDNS", Ipv4IntAnonymize(ipInfo.primaryDns).c_str()); + cJSON_AddStringToObject(root, "IPV4_SECONDDNS", Ipv4IntAnonymize(ipInfo.secondDns).c_str()); + cJSON_AddStringToObject(root, "IPV4_SERVERIP", Ipv4IntAnonymize(ipInfo.serverIp).c_str()); + cJSON_AddNumberToObject(root, "IPV4_LEASE", ipInfo.leaseDuration); + cJSON_AddNumberToObject(root, "IPV4_DNS_VEC_SIZE", static_cast(ipInfo.dnsAddr.size())); + for (size_t i = 0; i < ipInfo.dnsAddr.size(); i++) { + if (i >= MAX_DNS_NUM) { + WIFI_LOGE("ipInfo.dnsAddr size over limit"); + break; + } + std::string keyString = "IPV4_DNS" + std::to_string(i); + cJSON_AddStringToObject(root, keyString.c_str(), Ipv4IntAnonymize(ipInfo.dnsAddr[i]).c_str()); + } + cJSON_AddStringToObject(root, "IPV6_LINKIPV6ADDR", Ipv6Anonymize(ipv6Info.linkIpV6Address).c_str()); + cJSON_AddStringToObject(root, "IPV6_GLOBALIPV6ADDR", Ipv6Anonymize(ipv6Info.globalIpV6Address).c_str()); + cJSON_AddStringToObject(root, "IPV6_RANDGLOBALIPV6ADDR", Ipv6Anonymize(ipv6Info.randGlobalIpV6Address).c_str()); + cJSON_AddStringToObject(root, "IPV6_GATEWAY", Ipv6Anonymize(ipv6Info.gateway).c_str()); + cJSON_AddStringToObject(root, "IPV6_NETMASK", Ipv6Anonymize(ipv6Info.netmask).c_str()); + cJSON_AddStringToObject(root, "IPV6_PRIMARYDNS", Ipv6Anonymize(ipv6Info.primaryDns).c_str()); + cJSON_AddStringToObject(root, "IPV6_SECONDDNS", Ipv6Anonymize(ipv6Info.secondDns).c_str()); + cJSON_AddStringToObject(root, "IPV6_UNIQUELOCALADDR1", Ipv6Anonymize(ipv6Info.uniqueLocalAddress1).c_str()); + cJSON_AddStringToObject(root, "IPV6_UNIQUELOCALADDR2", Ipv6Anonymize(ipv6Info.uniqueLocalAddress2).c_str()); + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_DHCP_INFO", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteIodHiSysEvent(const IodStatisticInfo &iodStatisticInfo) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "OUTDOORFILTERCNT", iodStatisticInfo.outdoorFilterCnt); + cJSON_AddNumberToObject(root, "OUTDOORSELECTWIFICNT", iodStatisticInfo.outdoorAutoSelectCnt); + cJSON_AddNumberToObject(root, "INTOOUTDOORCNT", iodStatisticInfo.in2OutCnt); + cJSON_AddNumberToObject(root, "OUTTOINDOORCNT", iodStatisticInfo.out2InCnt); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_IOD_STATISTIC", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + + + + + + + + + + + + + + -- Gitee From 7e04b13cb1cd16cd40dea3ee1c7a370dd09b8a9d Mon Sep 17 00:00:00 2001 From: shihaojie Date: Wed, 16 Jul 2025 07:39:43 +0000 Subject: [PATCH 02/13] zly Signed-off-by: shihaojie --- wifi/base/BUILD.gn | 1 + .../shared_util/wifi_notification_util.cpp | 49 +- .../wifi_framework/wifi_manage/BUILD.gn | 1 + .../wifi_manage/wifi_pro/wifi_pro_chr.cpp | 117 +- .../wifi_manage/wifi_pro/wifi_pro_chr.h | 3 + .../wifi_security_detect.cpp | 101 +- .../wifi_security_detect.h | 5 +- .../wifi_toolkit/config/wifi_settings.cpp | 51 +- .../wifi_toolkit/utils/wifi_global_func.cpp | 27 +- .../fuzztest/wifi_sta/wifiap_fuzzer/BUILD.gn | 1 + .../wifi_sta/wifistaserver_fuzzer/BUILD.gn | 1 + wifi/test/wifi_standard/non_mock/BUILD.gn | 1 + .../wifi_manage/idl_client/unittest/BUILD.gn | 1 + .../wifi_manage/unittest/BUILD.gn | 1 + .../wifi_manage/wifi_ap/BUILD.gn | 1 + .../wifi_manage/wifi_pro/BUILD.gn | 1 + .../wifi_manage/wifi_scan/BUILD.gn | 1 + .../wifi_manage/wifi_sta_ext/BUILD.gn | 1 + .../wifi_security_detect_test.cpp | 2 +- .../wifi_manage/wifi_sub_manage/BUILD.gn | 1 + .../wifi_toolkit/unittest/BUILD.gn | 1 + wifi/test/zly.txt | 1254 +++++++++++++++++ wifi/utils/BUILD.gn | 1 + wifi/utils/src/wifi_hisysevent.cpp | 991 +++++++++---- 24 files changed, 2220 insertions(+), 394 deletions(-) create mode 100644 wifi/test/zly.txt diff --git a/wifi/base/BUILD.gn b/wifi/base/BUILD.gn index 113943512..d4e80983a 100644 --- a/wifi/base/BUILD.gn +++ b/wifi/base/BUILD.gn @@ -116,6 +116,7 @@ if (defined(ohos_lite)) { external_deps = [ "ability_runtime:extension_manager", "c_utils:utils", + "cJSON:cjson", "data_share:datashare_common", "data_share:datashare_consumer", "hicollie:libhicollie", diff --git a/wifi/base/shared_util/wifi_notification_util.cpp b/wifi/base/shared_util/wifi_notification_util.cpp index 318d828ac..5da7d935e 100644 --- a/wifi/base/shared_util/wifi_notification_util.cpp +++ b/wifi/base/shared_util/wifi_notification_util.cpp @@ -14,6 +14,7 @@ */ #include "ability_manager_ipc_interface_code.h" +#include "cJSON.h" #include "extension_manager_client.h" #include "iservice_registry.h" #include "message_parcel.h" @@ -155,25 +156,37 @@ void WifiNotificationUtil::ShowDialog(WifiDialogType type, std::string comInfo) std::string bundleName = "com.ohos.sceneboard"; std::string abilityName = "com.ohos.sceneboard.systemdialog"; want.SetElementName(bundleName, abilityName); - nlohmann::json param; - param["ability.want.params.uiExtensionType"] = "sysDialog/common"; - param["wifiDialogType"] = static_cast(type); + cJSON *param = cJSON_CreateObject(); + if (param == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(param, "ability.want.params.uiExtensionType", "sysDialog/common"); + cJSON_AddNumberToObject(param, "wifiDialogType", static_cast(type)); switch (type) { case AUTO_IDENTIFY_CONN: case SETTINGS_AUTO_IDENTIFY_CONN: - param["wifi5gSsid"] = comInfo; + cJSON_AddStringToObject(param, "wifi5gSsid", comInfo.c_str()); break; case P2P_WSC_PBC_DIALOG: - param["p2pDeviceName"] = comInfo; + cJSON_AddStringToObject(param, "p2pDeviceName", comInfo.c_str()); break; case CANDIDATE_CONNECT: - param["targetSsid"] = comInfo; + cJSON_AddStringToObject(param, "targetSsid", comInfo.c_str()); break; - default: { + default: break; - } + } - std::string cmdData = param.dump(); + char *cjsonStr = cJSON_PrintUnformatted(param); + if (cjsonStr == nullptr) { + WIFI_LOGE("Failed to print cJSON object"); + cJSON_Delete(param); + return; + } + std::string cmdData(cjsonStr); + free(cjsonStr); + cJSON_Delete(param); sptr connection( new (std::nothrow) UIExtensionAbilityConnection(cmdData, "com.ohos.locationdialog", "WifiUIExtAbility")); if (connection == nullptr) { @@ -194,9 +207,21 @@ void WifiNotificationUtil::ShowSettingsDialog(WifiDialogType type, std::string s std::string bundleName = "com.ohos.sceneboard"; std::string abilityName = "com.ohos.sceneboard.systemdialog"; want.SetElementName(bundleName, abilityName); - nlohmann::json param; - param["ability.want.params.uiExtensionType"] = "sysDialog/common"; - std::string cmdData = param.dump(); + cJSON *param = cJSON_CreateObject(); + if (param == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(param, "ability.want.params.uiExtensionType", "sysDialog/common"); + char *cjsonStr = cJSON_PrintUnformatted(param); + if (cjsonStr == nullptr) { + WIFI_LOGE("Failed to print cJSON object"); + cJSON_Delete(param); + return; + } + std::string cmdData(cjsonStr); + free(cjsonStr); + cJSON_Delete(param); if (settings.empty()) { WIFI_LOGI("settings name is null"); return; diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/BUILD.gn b/wifi/services/wifi_standard/wifi_framework/wifi_manage/BUILD.gn index 84db7c493..a6fbc486d 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/BUILD.gn +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/BUILD.gn @@ -588,6 +588,7 @@ if (defined(ohos_lite)) { "bundle_framework:appexecfwk_core", "c_utils:utils", "common_event_service:cesfwk_innerkits", + "cJSON:cjson", "data_share:datashare_common", "data_share:datashare_consumer", "dhcp:dhcp_sdk", diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_chr.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_chr.cpp index df66edee8..99560b186 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_chr.cpp +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_chr.cpp @@ -20,6 +20,7 @@ #include "wifi_hisysevent.h" #include "hisysevent.h" #include "json/json.h" +#include "cJSON.h" namespace OHOS { namespace Wifi { DEFINE_WIFILOG_LABEL("WifiProChr"); @@ -248,44 +249,84 @@ void WifiProChr::RecordCountWiFiPro(bool isValid) void WifiProChr::WriteWifiProSysEvent() { WIFI_LOGI("WriteWifiProSysEvent enter"); - Json::Value root; - Json::FastWriter writer; - root["FAST_SCAN_CNT"] = fastScanCnt_; - root["FULL_SCAN_CNT"] = fullScanCnt_; - root["WIFIPRO_POOR_LINK_CNT"] = poorLinkCnt_; - root["WIFIPRO_NONET_CNT"] = noNetCnt_; - root["WIFIPRO_QOE_SLOW_CNT"] = qoeSlowCnt_; - root["POOR_LINK_SELECT_NET_SUCC_CNT"] = selectNetResultCnt_[WifiProEventResult::POORLINK_SUCC]; - root["NONET_SELECT_NET_SUCC_CNT"] = selectNetResultCnt_[WifiProEventResult::NONET_SUCC]; - root["QOE_SLOW_SELECT_NET_SUCC_CNT"] = selectNetResultCnt_[WifiProEventResult::QOE_SUCCC]; - root["POOR_LINK_SELECT_NET_FAILED_CNT"] = selectNetResultCnt_[WifiProEventResult::POORLINK_FAILED]; - root["NONET_SELECT_NET_FAILED_CNT"] = selectNetResultCnt_[WifiProEventResult::NONET_FAILED]; - root["QOE_SLOW_SELECT_NET_FAILED_CNT"] = selectNetResultCnt_[WifiProEventResult::QOESLOW_FAILED]; - root["POOR_LINK_SWITCH_SUCC_CNT"] = wifiProResultCnt_[WifiProEventResult::POORLINK_SUCC]; - root["NONET_SWITCH_SUCC_CNT"] = wifiProResultCnt_[WifiProEventResult::NONET_SUCC]; - root["QOE_SLOW_SWITCH_SUCC_CNT"] = wifiProResultCnt_[WifiProEventResult::QOE_SUCCC]; - root["POOR_LINK_SWITCH_FAILED_CNT"] = wifiProResultCnt_[WifiProEventResult::POORLINK_FAILED]; - root["NONET_SWITCH_FAILED_CNT"] = wifiProResultCnt_[WifiProEventResult::NONET_FAILED]; - root["QOE_SLOW_SWITCH_FAILED_CNT"] = wifiProResultCnt_[WifiProEventResult::QOESLOW_FAILED]; - root["TIME_LEVEL1_CNT"] = wifiProSwitchTimeCnt_[SWITCH_TIME_LEVEL1]; - root["TIME_LEVEL2_CNT"] = wifiProSwitchTimeCnt_[SWITCH_TIME_LEVEL2]; - root["TIME_LEVEL3_CNT"] = wifiProSwitchTimeCnt_[SWITCH_TIME_LEVEL3]; - root["TIME_START_TO_CONNECT_LEVEL1_CNT"] = wifiProSwitchTimeCnt_[START_TO_CONNECT_LEVEL1]; - root["TIME_START_TO_CONNECT_LEVEL2_CNT"] = wifiProSwitchTimeCnt_[START_TO_CONNECT_LEVEL2]; - root["TIME_START_TO_CONNECT_LEVEL3_CNT"] = wifiProSwitchTimeCnt_[START_TO_CONNECT_LEVEL3]; - root["TIME_CONNECT_TO_SUCC_LEVEL1_CNT"] = wifiProSwitchTimeCnt_[CONNECT_TO_SUCC_LEVEL1]; - root["TIME_CONNECT_TO_SUCC_LEVEL2_CNT"] = wifiProSwitchTimeCnt_[CONNECT_TO_SUCC_LEVEL2]; - root["TIME_CONNECT_TO_SUCC_LEVEL3_CNT"] = wifiProSwitchTimeCnt_[CONNECT_TO_SUCC_LEVEL3]; - root["REASON_NOT_SWTICH_SWITCHING"] = reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_SWITCHING]; - root["REASON_NOT_SWTICH_SELFCURING"] = reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_SELFCURING]; - root["REASON_NOT_SWTICH_NONET_BEFORE"] = reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_NONET_BEFORE_CONNECT]; - root["REASON_NOT_SWTICH_SIGNAL_BRIDGE"] = reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_SIGNAL_BRIDGE_ON]; - root["REASON_NOT_SWTICH_AP_STA_ON"] = reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_AP_STA_ON]; - root["REASON_NOT_SWTICH_APP_WLISTS"] = reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_APP_WHITE_LISTS]; - root["REASON_NOT_SWTICH_ISCALLING"] = reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_ISCALLING]; - root["REASON_NOT_SWTICH_NOT_AUTOSWITCH"] = reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_NOT_ALLOW_AUTOSWITCH]; - root["REASON_NOT_SWTICH_DISABLED"] = reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_DISABLED]; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_PRO_STATISTICS", "EVENT_VALUE", writer.write(root)); + cJSON *root = FillWifiProStatisticsJson(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_PRO_STATISTICS", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +cJSON *WifiProChr::FillWifiProStatisticsJson() +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return nullptr; + } + cJSON_AddNumberToObject(root, "FAST_SCAN_CNT", fastScanCnt_); + cJSON_AddNumberToObject(root, "FULL_SCAN_CNT", fullScanCnt_); + cJSON_AddNumberToObject(root, "WIFIPRO_POOR_LINK_CNT", poorLinkCnt_); + cJSON_AddNumberToObject(root, "WIFIPRO_NONET_CNT", noNetCnt_); + cJSON_AddNumberToObject(root, "WIFIPRO_QOE_SLOW_CNT", qoeSlowCnt_); + cJSON_AddNumberToObject( + root, "POOR_LINK_SELECT_NET_SUCC_CNT", selectNetResultCnt_[WifiProEventResult::POORLINK_SUCC]); + cJSON_AddNumberToObject(root, "NONET_SELECT_NET_SUCC_CNT", selectNetResultCnt_[WifiProEventResult::NONET_SUCC]); + cJSON_AddNumberToObject(root, "QOE_SLOW_SELECT_NET_SUCC_CNT", selectNetResultCnt_[WifiProEventResult::QOE_SUCCC]); + cJSON_AddNumberToObject( + root, "POOR_LINK_SELECT_NET_FAILED_CNT", selectNetResultCnt_[WifiProEventResult::POORLINK_FAILED]); + cJSON_AddNumberToObject(root, "NONET_SELECT_NET_FAILED_CNT", selectNetResultCnt_[WifiProEventResult::NONET_FAILED]); + cJSON_AddNumberToObject( + root, "QOE_SLOW_SELECT_NET_FAILED_CNT", selectNetResultCnt_[WifiProEventResult::QOESLOW_FAILED]); + cJSON_AddNumberToObject(root, "POOR_LINK_SWITCH_SUCC_CNT", wifiProResultCnt_[WifiProEventResult::POORLINK_SUCC]); + cJSON_AddNumberToObject(root, "NONET_SWITCH_SUCC_CNT", wifiProResultCnt_[WifiProEventResult::NONET_SUCC]); + cJSON_AddNumberToObject(root, "QOE_SLOW_SWITCH_SUCC_CNT", wifiProResultCnt_[WifiProEventResult::QOE_SUCCC]); + cJSON_AddNumberToObject( + root, "POOR_LINK_SWITCH_FAILED_CNT", wifiProResultCnt_[WifiProEventResult::POORLINK_FAILED]); + + FillWifiProStatisticsJsons(root); + return root; +} + +void WifiProChr::FillWifiProStatisticsJsons(cJSON *root) +{ + cJSON_AddNumberToObject(root, "NONET_SWITCH_FAILED_CNT", wifiProResultCnt_[WifiProEventResult::NONET_FAILED]); + cJSON_AddNumberToObject(root, "QOE_SLOW_SWITCH_FAILED_CNT", wifiProResultCnt_[WifiProEventResult::QOESLOW_FAILED]); + cJSON_AddNumberToObject(root, "TIME_LEVEL1_CNT", wifiProSwitchTimeCnt_[SWITCH_TIME_LEVEL1]); + cJSON_AddNumberToObject(root, "TIME_LEVEL2_CNT", wifiProSwitchTimeCnt_[SWITCH_TIME_LEVEL2]); + cJSON_AddNumberToObject(root, "TIME_LEVEL3_CNT", wifiProSwitchTimeCnt_[SWITCH_TIME_LEVEL3]); + cJSON_AddNumberToObject(root, "TIME_START_TO_CONNECT_LEVEL1_CNT", wifiProSwitchTimeCnt_[START_TO_CONNECT_LEVEL1]); + cJSON_AddNumberToObject(root, "TIME_START_TO_CONNECT_LEVEL2_CNT", wifiProSwitchTimeCnt_[START_TO_CONNECT_LEVEL2]); + cJSON_AddNumberToObject(root, "TIME_START_TO_CONNECT_LEVEL3_CNT", wifiProSwitchTimeCnt_[START_TO_CONNECT_LEVEL3]); + cJSON_AddNumberToObject(root, "TIME_CONNECT_TO_SUCC_LEVEL1_CNT", wifiProSwitchTimeCnt_[CONNECT_TO_SUCC_LEVEL1]); + cJSON_AddNumberToObject(root, "TIME_CONNECT_TO_SUCC_LEVEL2_CNT", wifiProSwitchTimeCnt_[CONNECT_TO_SUCC_LEVEL2]); + cJSON_AddNumberToObject(root, "TIME_CONNECT_TO_SUCC_LEVEL3_CNT", wifiProSwitchTimeCnt_[CONNECT_TO_SUCC_LEVEL3]); + cJSON_AddNumberToObject( + root, "REASON_NOT_SWITCH_SWITCHING", reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_SWITCHING]); + cJSON_AddNumberToObject( + root, "REASON_NOT_SWITCH_SELFCURING", reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_SELFCURING]); + cJSON_AddNumberToObject( + root, "REASON_NOT_SWITCH_NONET_BEFORE", reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_NONET_BEFORE_CONNECT]); + cJSON_AddNumberToObject( + root, "REASON_NOT_SWITCH_SIGNAL_BRIDGE", reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_SIGNAL_BRIDGE_ON]); + cJSON_AddNumberToObject( + root, "REASON_NOT_SWITCH_AP_STA_ON", reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_AP_STA_ON]); + cJSON_AddNumberToObject( + root, "REASON_NOT_SWITCH_APP_WLISTS", reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_APP_WHITE_LISTS]); + cJSON_AddNumberToObject( + root, "REASON_NOT_SWITCH_ISCALLING", reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_ISCALLING]); + cJSON_AddNumberToObject( + root, "REASON_NOT_SWITCH_NOT_AUTOSWITCH", reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_NOT_ALLOW_AUTOSWITCH]); + cJSON_AddNumberToObject(root, "REASON_NOT_SWITCH_DISABLED", reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_DISABLED]); } } // namespace Wifi } // namespace OHOS \ No newline at end of file diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_chr.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_chr.h index 8509cbe14..3ec25fa0d 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_chr.h +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_chr.h @@ -18,6 +18,7 @@ #include #include #include +#include "cJSON.h" #include "wifi_logger.h" #include "wifi_pro_common.h" #include "wifi_msg.h" @@ -78,6 +79,8 @@ public: void RecordWifiProSwitchSuccTime(); void RecordCountWiFiPro(bool isValid); void WriteWifiProSysEvent(); + cJSON *FillWifiProStatisticsJson(); + void FillWifiProStatisticsJsons(cJSON *root); private: int64_t wifiProStartTime_ = 0; diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_security_detect/wifi_security_detect.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_security_detect/wifi_security_detect.cpp index b4630aafd..35d1e5599 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_security_detect/wifi_security_detect.cpp +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_security_detect/wifi_security_detect.cpp @@ -15,7 +15,7 @@ #ifdef WIFI_SECURITY_DETECT_ENABLE #include -#include "json/json.h" +#include "cJSON.h" #include "ip_tools.h" #include "wifi_security_detect.h" #include "wifi_security_detect_observer.h" @@ -237,19 +237,30 @@ void WifiSecurityDetect::UnRegisterSecurityDetectObserver() ErrCode WifiSecurityDetect::SecurityModelJsonResult(SecurityModelResult model, bool &result) { - Json::Value root; - Json::Reader reader; - bool parsingSuccess = reader.parse(model.result, root); - if (!parsingSuccess) { + cJSON *root = cJSON_Parse(model.result.c_str()); + if (root == nullptr) { + + WIFI_LOGE("model.result is null"); return WIFI_OPT_FAILED; } - - if (root["status"].isInt() && root["status"].asInt() != 0) { - WIFI_LOGE("RequestSecurityModelResultSync status error= %{public}d", root["status"].asInt()); + + cJSON *statusItem = cJSON_GetObjectItem(root, "status"); + if (statusItem && cJSON_IsNumber(statusItem) && statusItem->valueint != 0) { + WIFI_LOGE("RequestSecurityModelResultSync status error= %d", statusItem->valueint); + cJSON_Delete(root); return WIFI_OPT_FAILED; } + + cJSON *resultItem = cJSON_GetObjectItem(root, "result"); std::string SecurityResult; + if (resultItem && cJSON_IsString(resultItem)) { + SecurityResult = resultItem->valuestring; + } else { + SecurityResult = ""; + } + + cJSON_Delete(root); if (root["result"].isString()) { SecurityResult = root["result"].asString(); } else { @@ -293,7 +304,7 @@ int32_t WifiSecurityDetect::AuthenticationConvert(std::string key) } } -void WifiSecurityDetect::ConverWifiLinkInfoToJson(const WifiLinkedInfo &info, Json::Value &root) +void WifiSecurityDetect::ConverWifiLinkInfoToJson(const WifiLinkedInfo &info, cJSON *root) { WifiDeviceConfig config; if (WifiSettings::GetInstance().GetDeviceConfig(info.networkId, config) != 0) { @@ -303,45 +314,53 @@ void WifiSecurityDetect::ConverWifiLinkInfoToJson(const WifiLinkedInfo &info, Js IpInfo wifiIpInfo; int32_t instId = 0; WifiConfigCenter::GetInstance().GetIpInfo(wifiIpInfo, instId); - switch (info.wifiStandard) { + + AddWifiStandardToJson(root, info.wifiStandard); + + cJSON_AddStringToObject(root, "ssid", config.ssid.c_str()); + cJSON_AddStringToObject(root, "bssid", config.bssid.c_str()); + cJSON_AddNumberToObject(root, "signalStrength", config.rssi); + cJSON_AddNumberToObject(root, "authentication", AuthenticationConvert(config.keyMgmt)); + if (config.frequency >= MIN_5G_FREQUENCY && config.frequency <= MAX_5G_FREQUENCY) { + cJSON_AddStringToObject(root, "frequencyBand", "5GHz"); + } else { + cJSON_AddStringToObject(root, "frequencyBand", "2.4GHz"); + } + cJSON_AddStringToObject(root, "gatewayIp", IpTools::ConvertIpv4Address(wifiIpInfo.ipAddress).c_str()); + cJSON_AddStringToObject(root, "gatewayMac", config.macAddress.c_str()); + cJSON_AddStringToObject(root, "primaryDns", IpTools::ConvertIpv4Address(wifiIpInfo.primaryDns).c_str()); + if (wifiIpInfo.secondDns == 0) { + cJSON_AddStringToObject(root, "secondDns", "0.0.0.0"); + } else { + cJSON_AddStringToObject(root, "secondDns", IpTools::ConvertIpv4Address(wifiIpInfo.secondDns).c_str()); + } +} + +void WifiSecurityDetect::AddWifiStandardToJson(cJSON *root, int wifiStandard) +{ + switch (wifiStandard) { case WireType::WIRE_802_11A: - root["wirelessType"] = "802.11a"; + cJSON_AddStringToObject(root, "wirelessType", "802.11a"); break; case WireType::WIRE_802_11B: - root["wirelessType"] = "802.11b"; + cJSON_AddStringToObject(root, "wirelessType", "802.11b"); break; case WireType::WIRE_802_11G: - root["wirelessType"] = "802.11g"; + cJSON_AddStringToObject(root, "wirelessType", "802.11g"); break; case WireType::WIRE_802_11N: - root["wirelessType"] = "802.11n"; + cJSON_AddStringToObject(root, "wirelessType", "802.11n"); break; case WireType::WIRE_802_11AC: - root["wirelessType"] = "802.11ac"; + cJSON_AddStringToObject(root, "wirelessType", "802.11ac"); break; case WireType::WIRE_802_11AX: - root["wirelessType"] = "802.11ax"; + cJSON_AddStringToObject(root, "wirelessType", "802.11ax"); break; default: WIFI_LOGE("wifi wirelessType is unknown"); - root["wirelessType"] = ""; - } - root["ssid"] = config.ssid; - root["bssid"] = config.bssid; - root["signalStrength"] = config.rssi; - root["authentication"] = AuthenticationConvert(config.keyMgmt); - if (config.frequency >= MIN_5G_FREQUENCY && config.frequency <= MAX_5G_FREQUENCY) { - root["frequencyBand"] = "5GHz"; - } else { - root["frequencyBand"] = "2.4GHz"; - } - root["gatewayIp"] = IpTools::ConvertIpv4Address(wifiIpInfo.ipAddress); - root["gatewayMac"] = config.macAddress; - root["primaryDns"] = IpTools::ConvertIpv4Address(wifiIpInfo.primaryDns); - if (wifiIpInfo.secondDns == 0) { - root["secondDns"] = "0.0.0.0"; - } else { - root["secondDns"] = IpTools::ConvertIpv4Address(wifiIpInfo.secondDns); + cJSON_AddStringToObject(root, "wirelessType", ""); + break; } } @@ -361,10 +380,18 @@ void WifiSecurityDetect::SecurityDetect(const WifiLinkedInfo &info) return; } - Json::Value root; - Json::FastWriter writer; + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } ConverWifiLinkInfoToJson(info, root); - model.param = writer.write(root); + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr != nullptr) { + model.param = jsonStr; + free(jsonStr); + } + cJSON_Delete(root); WIFI_LOGI( "ssid:%{public}s bssid:%{public}s", SsidAnonymize(config.ssid).c_str(), MacAnonymize(config.bssid).c_str()); securityDetectThread_->PostAsyncTask([=]() mutable -> int32_t { diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_security_detect/wifi_security_detect.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_security_detect/wifi_security_detect.h index d4915d865..e983a934c 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_security_detect/wifi_security_detect.h +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_security_detect/wifi_security_detect.h @@ -15,7 +15,7 @@ #ifndef WIFI_SECURITY_DETECT_H #define WIFI_SECURITY_DETECT_H -#include "json/json.h" +#include "cJSON.h" #include "sta_service_callback.h" #include "wifi_event_handler.h" #include "wifi_datashare_utils.h" @@ -73,6 +73,7 @@ public: void SetDatashareReady(); void RegisterSecurityDetectObserver(); void SecurityDetect(const WifiLinkedInfo &info); + void AddWifiStandardToJson(cJSON *root, int wifiStandard); void PopupNotification(int status, int networkid); private: @@ -86,7 +87,7 @@ private: bool IsSecurityDetectTimeout(const int &networkId); ErrCode SecurityDetectResult(const std::string &devId, uint32_t modelId, const std::string ¶m, bool &result); ErrCode SecurityModelJsonResult(SecurityModelResult model, bool &result); - void ConverWifiLinkInfoToJson(const WifiLinkedInfo &info, Json::Value &root); + void ConverWifiLinkInfoToJson(const WifiLinkedInfo &info, cJSON *root); int32_t AuthenticationConvert(std::string key); void UnRegisterSecurityDetectObserver(); }; diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/config/wifi_settings.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/config/wifi_settings.cpp index 3654e3597..584606c79 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/config/wifi_settings.cpp +++ b/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/config/wifi_settings.cpp @@ -27,7 +27,7 @@ #include "softap_parser.h" #include "package_parser.h" #include "wifi_backup_config.h" -#include "json/json.h" +#include "cJSON.h" #endif #ifdef SUPPORT_ClOUD_WIFI_ASSET #include "wifi_asset_manager.h" @@ -966,19 +966,42 @@ int WifiSettings::OnBackup(UniqueFd &fd, const std::string &backupInfo) std::string WifiSettings::SetBackupReplyCode(int replyCode) { - Json::Value root; - Json::Value resultInfo; - Json::Value errorInfo; - - errorInfo["type"] = "ErrorInfo"; - errorInfo["errorCode"] = std::to_string(replyCode); - errorInfo["errorInfo"] = ""; - - resultInfo.append(errorInfo); - root["resultInfo"] = resultInfo; - - Json::FastWriter writer; - return writer.write(root); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + LOGE("Failed to create cJSON object"); + return ""; + } + cJSON *resultInfo = cJSON_CreateArray(); + if (resultInfo == nullptr) { + LOGE("Failed to create cJSON Arr"); + cJSON_Delete(root); + return ""; + } + cJSON *errorInfo = cJSON_CreateObject(); + if (errorInfo == nullptr) { + LOGE("Failed to create cJSON object"); + cJSON_Delete(root); + return ""; + } + + cJSON_AddStringToObject(errorInfo, "type", "ErrorInfo"); + std::string codeStr = std::to_string(replyCode); + cJSON_AddStringToObject(errorInfo, "errorCode", codeStr.c_str()); + cJSON_AddStringToObject(errorInfo, "errorInfo", ""); + + cJSON_AddItemToArray(resultInfo, errorInfo); + + cJSON_AddItemToObject(root, "resultInfo", resultInfo); + + char *jsonStr = cJSON_PrintUnformatted(root); + std::string result; + if (jsonStr != nullptr) { + result = jsonStr; + free(jsonStr); + } + + cJSON_Delete(root); + return result; } void WifiSettings::RemoveBackupFile() diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/utils/wifi_global_func.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/utils/wifi_global_func.cpp index f42b17f9c..b83dc46e8 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/utils/wifi_global_func.cpp +++ b/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/utils/wifi_global_func.cpp @@ -21,7 +21,7 @@ #include "wifi_common_util.h" #include "wifi_log.h" #ifndef OHOS_ARCH_LITE -#include "json/json.h" +#include "cJSON.h" #include "wifi_country_code_define.h" #endif #ifdef INIT_LIB_ENABLE @@ -637,24 +637,31 @@ bool ParseJsonKey(const Json::Value &jsonValue, const std::string &key, std::str bool ParseJson(const std::string &jsonString, const std::string &type, const std::string &key, std::string &value) { - LOGI("ParseJson enter."); - Json::Value root; - Json::Reader reader; - bool success = reader.parse(jsonString, root); - if (!success) { + cJSON *root = cJSON_Parse(jsonString.c_str()); + if (root == nullptr) { LOGE("ParseJson failed to parse json data."); return false; } - int nSize = static_cast(root.size()); + if (!cJSON_IsArray(root)) { + cJSON_Delete(root); + return false; + } + int nSize = cJSON_GetArraySize(root); for (int i = 0; i < nSize; i++) { - if (!root[i].isMember(type)) { - LOGW("ParseJson JSON[%{public}d] has no member %{public}s.", nSize, type.c_str()); + cJSON *item = cJSON_GetArrayItem(root, i); + if (item == nullptr || !cJSON_IsObject(item)) { + continue; + } + cJSON *typeItem = cJSON_GetObjectItem(item, type.c_str()); // 比如 "data" + if (typeItem == nullptr) { continue; } - if (ParseJsonKey(root[i][type], key, value)) { + if (ParseJsonKey(typeItem, key, value)) { + cJSON_Delete(root); return true; } } + cJSON_Delete(root); return false; } diff --git a/wifi/test/fuzztest/wifi_sta/wifiap_fuzzer/BUILD.gn b/wifi/test/fuzztest/wifi_sta/wifiap_fuzzer/BUILD.gn index 29a2cd410..1c13b469c 100644 --- a/wifi/test/fuzztest/wifi_sta/wifiap_fuzzer/BUILD.gn +++ b/wifi/test/fuzztest/wifi_sta/wifiap_fuzzer/BUILD.gn @@ -105,6 +105,7 @@ ohos_fuzztest("WifiApFuzzTest") { "ability_base:base", "ability_base:want", "c_utils:utils", + "cJSON:cjson", "common_event_service:cesfwk_core", "dhcp:dhcp_sdk", "hilog:libhilog", diff --git a/wifi/test/fuzztest/wifi_sta/wifistaserver_fuzzer/BUILD.gn b/wifi/test/fuzztest/wifi_sta/wifistaserver_fuzzer/BUILD.gn index 41f3236b6..3b26f0e31 100644 --- a/wifi/test/fuzztest/wifi_sta/wifistaserver_fuzzer/BUILD.gn +++ b/wifi/test/fuzztest/wifi_sta/wifistaserver_fuzzer/BUILD.gn @@ -122,6 +122,7 @@ ohos_fuzztest("WifiStaServerFuzzTest") { "bundle_framework:appexecfwk_base", "bundle_framework:appexecfwk_core", "c_utils:utils", + "cJSON:cjson", "data_share:datashare_consumer", "dhcp:dhcp_sdk", "hilog:libhilog", diff --git a/wifi/test/wifi_standard/non_mock/BUILD.gn b/wifi/test/wifi_standard/non_mock/BUILD.gn index 51397a349..f40e7c657 100644 --- a/wifi/test/wifi_standard/non_mock/BUILD.gn +++ b/wifi/test/wifi_standard/non_mock/BUILD.gn @@ -80,6 +80,7 @@ ohos_unittest("wifi_non_mock_unittest") { "ability_base:zuri", "ability_runtime:wantagent_innerkits", "c_utils:utils", + "cJSON:cjson", "hilog:libhilog", "jsoncpp:jsoncpp", "libxml2:libxml2", diff --git a/wifi/test/wifi_standard/wifi_framework/wifi_manage/idl_client/unittest/BUILD.gn b/wifi/test/wifi_standard/wifi_framework/wifi_manage/idl_client/unittest/BUILD.gn index 273dbd3bd..2b9aa642f 100644 --- a/wifi/test/wifi_standard/wifi_framework/wifi_manage/idl_client/unittest/BUILD.gn +++ b/wifi/test/wifi_standard/wifi_framework/wifi_manage/idl_client/unittest/BUILD.gn @@ -93,6 +93,7 @@ ohos_unittest("idl_client_unittest") { external_deps = [ "c_utils:utils", + "cJSON:cjson", "googletest:gmock_main", "googletest:gtest_main", "hdf_core:libhdf_ipc_adapter", diff --git a/wifi/test/wifi_standard/wifi_framework/wifi_manage/unittest/BUILD.gn b/wifi/test/wifi_standard/wifi_framework/wifi_manage/unittest/BUILD.gn index 6990a40e9..00167c880 100644 --- a/wifi/test/wifi_standard/wifi_framework/wifi_manage/unittest/BUILD.gn +++ b/wifi/test/wifi_standard/wifi_framework/wifi_manage/unittest/BUILD.gn @@ -203,6 +203,7 @@ ohos_unittest("manager_unittest") { "bundle_framework:appexecfwk_base", "bundle_framework:appexecfwk_core", "c_utils:utils", + "cJSON:cjson", "common_event_service:cesfwk_innerkits", "data_share:datashare_common", "data_share:datashare_consumer", diff --git a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_ap/BUILD.gn b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_ap/BUILD.gn index 6fa05fef2..6d6e72abc 100644 --- a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_ap/BUILD.gn +++ b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_ap/BUILD.gn @@ -140,6 +140,7 @@ ohos_unittest("WifiApServiceTest") { "ability_base:base", "ability_base:want", "c_utils:utils", + "cJSON:cjson", "common_event_service:cesfwk_innerkits", "dhcp:dhcp_sdk", "googletest:gmock_main", diff --git a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_pro/BUILD.gn b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_pro/BUILD.gn index 283ce583e..2c7634999 100644 --- a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_pro/BUILD.gn +++ b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_pro/BUILD.gn @@ -165,6 +165,7 @@ ohos_unittest("wifi_pro_unittest") { "bundle_framework:appexecfwk_base", "bundle_framework:appexecfwk_core", "c_utils:utils", + "cJSON:cjson", "data_share:datashare_consumer", "dhcp:dhcp_sdk", "googletest:gmock_main", diff --git a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_scan/BUILD.gn b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_scan/BUILD.gn index 36edeab6f..e5f394d81 100644 --- a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_scan/BUILD.gn +++ b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_scan/BUILD.gn @@ -153,6 +153,7 @@ ohos_unittest("wifi_scan_unittest") { "bundle_framework:appexecfwk_base", "bundle_framework:appexecfwk_core", "c_utils:utils", + "cJSON:cjson", "common_event_service:cesfwk_innerkits", "data_share:datashare_common", "data_share:datashare_consumer", diff --git a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta_ext/BUILD.gn b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta_ext/BUILD.gn index 957392f52..634496c75 100644 --- a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta_ext/BUILD.gn +++ b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta_ext/BUILD.gn @@ -107,6 +107,7 @@ ohos_unittest("wifi_sta_ext_unittest") { "bundle_framework:appexecfwk_base", "bundle_framework:appexecfwk_core", "c_utils:utils", + "cJSON:cjson", "certificate_manager:cert_manager_sdk", "data_share:datashare_consumer", "dhcp:dhcp_sdk", diff --git a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta_ext/wifi_security_detect_test.cpp b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta_ext/wifi_security_detect_test.cpp index 7c1bf1825..b36d9d426 100644 --- a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta_ext/wifi_security_detect_test.cpp +++ b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta_ext/wifi_security_detect_test.cpp @@ -12,7 +12,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#include "json/json.h" +#include "cJSON.h" #include "wifi_security_detect_test.h" using namespace testing::ext; diff --git a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sub_manage/BUILD.gn b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sub_manage/BUILD.gn index 80a4504e4..84d806531 100644 --- a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sub_manage/BUILD.gn +++ b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sub_manage/BUILD.gn @@ -160,6 +160,7 @@ ohos_unittest("wifi_sub_manage_unittest") { "bundle_framework:appexecfwk_base", "bundle_framework:appexecfwk_core", "c_utils:utils", + "cJSON:cjson", "data_share:datashare_consumer", "dhcp:dhcp_sdk", "googletest:gmock_main", diff --git a/wifi/test/wifi_standard/wifi_framework/wifi_toolkit/unittest/BUILD.gn b/wifi/test/wifi_standard/wifi_framework/wifi_toolkit/unittest/BUILD.gn index dc3d9b0bd..374b00ca2 100644 --- a/wifi/test/wifi_standard/wifi_framework/wifi_toolkit/unittest/BUILD.gn +++ b/wifi/test/wifi_standard/wifi_framework/wifi_toolkit/unittest/BUILD.gn @@ -124,6 +124,7 @@ ohos_unittest("toolkit_unittest") { ] external_deps = [ "c_utils:utils", + "cJSON:cjson", "certificate_manager:cert_manager_sdk", "dhcp:dhcp_sdk", "dhcp:dhcp_utils", diff --git a/wifi/test/zly.txt b/wifi/test/zly.txt new file mode 100644 index 000000000..71e8da668 --- /dev/null +++ b/wifi/test/zly.txt @@ -0,0 +1,1254 @@ +#include "cJSON.h" + + + + cJSON *param = cJSON_CreateObject(); + if (param == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(param, "ability.want.params.uiExtensionType", "sysDialog/common"); + cJSON_AddNumberToObject(param, "wifiDialogType", static_cast(type)); + switch (type) { + case AUTO_IDENTIFY_CONN: + case SETTINGS_AUTO_IDENTIFY_CONN: + cJSON_AddStringToObject(param, "wifi5gSsid", comInfo.c_str()); + break; + case P2P_WSC_PBC_DIALOG: + cJSON_AddStringToObject(param, "p2pDeviceName", comInfo.c_str()); + break; + case CANDIDATE_CONNECT: + cJSON_AddStringToObject(param, "targetSsid", comInfo.c_str()); + break; + default: + break; + + } + char *cjsonStr = cJSON_PrintUnformatted(param); + if (cjsonStr == nullptr) { + WIFI_LOGE("Failed to print cJSON object"); + cJSON_Delete(param); + return; + } + std::string cmdData(cjsonStr); + free(cjsonStr); + cJSON_Delete(param); + + + + + + cJSON *param = cJSON_CreateObject(); + if (param == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(param, "ability.want.params.uiExtensionType", "sysDialog/common"); + char *cjsonStr = cJSON_PrintUnformatted(param); + if (cjsonStr == nullptr) { + WIFI_LOGE("Failed to print cJSON object"); + cJSON_Delete(param); + return; + } + std::string cmdData(cjsonStr); + free(cjsonStr); + cJSON_Delete(param); + + + + +#include "cJSON.h" + + + + cJSON *root = FillWifiProStatisticsJson(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_PRO_STATISTICS", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); + + + + +cJSON *WifiProChr::FillWifiProStatisticsJson() +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return nullptr; + } + cJSON_AddNumberToObject(root, "FAST_SCAN_CNT", fastScanCnt_); + cJSON_AddNumberToObject(root, "FULL_SCAN_CNT", fullScanCnt_); + cJSON_AddNumberToObject(root, "WIFIPRO_POOR_LINK_CNT", poorLinkCnt_); + cJSON_AddNumberToObject(root, "WIFIPRO_NONET_CNT", noNetCnt_); + cJSON_AddNumberToObject(root, "WIFIPRO_QOE_SLOW_CNT", qoeSlowCnt_); + cJSON_AddNumberToObject( + root, "POOR_LINK_SELECT_NET_SUCC_CNT", selectNetResultCnt_[WifiProEventResult::POORLINK_SUCC]); + cJSON_AddNumberToObject(root, "NONET_SELECT_NET_SUCC_CNT", selectNetResultCnt_[WifiProEventResult::NONET_SUCC]); + cJSON_AddNumberToObject(root, "QOE_SLOW_SELECT_NET_SUCC_CNT", selectNetResultCnt_[WifiProEventResult::QOE_SUCCC]); + cJSON_AddNumberToObject( + root, "POOR_LINK_SELECT_NET_FAILED_CNT", selectNetResultCnt_[WifiProEventResult::POORLINK_FAILED]); + cJSON_AddNumberToObject(root, "NONET_SELECT_NET_FAILED_CNT", selectNetResultCnt_[WifiProEventResult::NONET_FAILED]); + cJSON_AddNumberToObject( + root, "QOE_SLOW_SELECT_NET_FAILED_CNT", selectNetResultCnt_[WifiProEventResult::QOESLOW_FAILED]); + cJSON_AddNumberToObject(root, "POOR_LINK_SWITCH_SUCC_CNT", wifiProResultCnt_[WifiProEventResult::POORLINK_SUCC]); + cJSON_AddNumberToObject(root, "NONET_SWITCH_SUCC_CNT", wifiProResultCnt_[WifiProEventResult::NONET_SUCC]); + cJSON_AddNumberToObject(root, "QOE_SLOW_SWITCH_SUCC_CNT", wifiProResultCnt_[WifiProEventResult::QOE_SUCCC]); + cJSON_AddNumberToObject( + root, "POOR_LINK_SWITCH_FAILED_CNT", wifiProResultCnt_[WifiProEventResult::POORLINK_FAILED]); + + FillWifiProStatisticsJsons(root); + return root; +} + +void WifiProChr::FillWifiProStatisticsJsons(cJSON *root) +{ + cJSON_AddNumberToObject(root, "NONET_SWITCH_FAILED_CNT", wifiProResultCnt_[WifiProEventResult::NONET_FAILED]); + cJSON_AddNumberToObject(root, "QOE_SLOW_SWITCH_FAILED_CNT", wifiProResultCnt_[WifiProEventResult::QOESLOW_FAILED]); + cJSON_AddNumberToObject(root, "TIME_LEVEL1_CNT", wifiProSwitchTimeCnt_[SWITCH_TIME_LEVEL1]); + cJSON_AddNumberToObject(root, "TIME_LEVEL2_CNT", wifiProSwitchTimeCnt_[SWITCH_TIME_LEVEL2]); + cJSON_AddNumberToObject(root, "TIME_LEVEL3_CNT", wifiProSwitchTimeCnt_[SWITCH_TIME_LEVEL3]); + cJSON_AddNumberToObject(root, "TIME_START_TO_CONNECT_LEVEL1_CNT", wifiProSwitchTimeCnt_[START_TO_CONNECT_LEVEL1]); + cJSON_AddNumberToObject(root, "TIME_START_TO_CONNECT_LEVEL2_CNT", wifiProSwitchTimeCnt_[START_TO_CONNECT_LEVEL2]); + cJSON_AddNumberToObject(root, "TIME_START_TO_CONNECT_LEVEL3_CNT", wifiProSwitchTimeCnt_[START_TO_CONNECT_LEVEL3]); + cJSON_AddNumberToObject(root, "TIME_CONNECT_TO_SUCC_LEVEL1_CNT", wifiProSwitchTimeCnt_[CONNECT_TO_SUCC_LEVEL1]); + cJSON_AddNumberToObject(root, "TIME_CONNECT_TO_SUCC_LEVEL2_CNT", wifiProSwitchTimeCnt_[CONNECT_TO_SUCC_LEVEL2]); + cJSON_AddNumberToObject(root, "TIME_CONNECT_TO_SUCC_LEVEL3_CNT", wifiProSwitchTimeCnt_[CONNECT_TO_SUCC_LEVEL3]); + cJSON_AddNumberToObject( + root, "REASON_NOT_SWITCH_SWITCHING", reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_SWITCHING]); + cJSON_AddNumberToObject( + root, "REASON_NOT_SWITCH_SELFCURING", reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_SELFCURING]); + cJSON_AddNumberToObject( + root, "REASON_NOT_SWITCH_NONET_BEFORE", reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_NONET_BEFORE_CONNECT]); + cJSON_AddNumberToObject( + root, "REASON_NOT_SWITCH_SIGNAL_BRIDGE", reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_SIGNAL_BRIDGE_ON]); + cJSON_AddNumberToObject( + root, "REASON_NOT_SWITCH_AP_STA_ON", reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_AP_STA_ON]); + cJSON_AddNumberToObject( + root, "REASON_NOT_SWITCH_APP_WLISTS", reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_APP_WHITE_LISTS]); + cJSON_AddNumberToObject( + root, "REASON_NOT_SWITCH_ISCALLING", reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_ISCALLING]); + cJSON_AddNumberToObject( + root, "REASON_NOT_SWITCH_NOT_AUTOSWITCH", reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_NOT_ALLOW_AUTOSWITCH]); + cJSON_AddNumberToObject(root, "REASON_NOT_SWITCH_DISABLED", reasonNotSwitchCnt_[ReasonNotSwitch::WIFIPRO_DISABLED]); +} + + + + + + cJSON *FillWifiProStatisticsJson(); + void FillWifiProStatisticsJsons(cJSON *root); + + + + + + cJSON *root = cJSON_Parse(model.result.c_str()); + if (root == nullptr) { + + + WIFI_LOGE("model.result is null"); + return WIFI_OPT_FAILED; + } + + cJSON *statusItem = cJSON_GetObjectItem(root, "status"); + if (statusItem && cJSON_IsNumber(statusItem) && statusItem->valueint != 0) { + WIFI_LOGE("RequestSecurityModelResultSync status error= %d", statusItem->valueint); + cJSON_Delete(root); + return WIFI_OPT_FAILED; + } + + cJSON *resultItem = cJSON_GetObjectItem(root, "result"); + std::string SecurityResult; + if (resultItem && cJSON_IsString(resultItem)) { + SecurityResult = resultItem->valuestring; + } else { + SecurityResult = ""; + } + + cJSON_Delete(root); + + + + + + + + + +void WifiSecurityDetect::ConverWifiLinkInfoToJson(const WifiLinkedInfo &info, cJSON *root) +{ + WifiDeviceConfig config; + if (WifiSettings::GetInstance().GetDeviceConfig(info.networkId, config) != 0) { + WIFI_LOGE("%{public}s, not find networkId:%{public}d", __FUNCTION__, info.networkId); + return; + } + IpInfo wifiIpInfo; + int32_t instId = 0; + WifiConfigCenter::GetInstance().GetIpInfo(wifiIpInfo, instId); + + AddWifiStandardToJson(root, info.wifiStandard); + + cJSON_AddStringToObject(root, "ssid", config.ssid.c_str()); + cJSON_AddStringToObject(root, "bssid", config.bssid.c_str()); + cJSON_AddNumberToObject(root, "signalStrength", config.rssi); + cJSON_AddNumberToObject(root, "authentication", AuthenticationConvert(config.keyMgmt)); + if (config.frequency >= MIN_5G_FREQUENCY && config.frequency <= MAX_5G_FREQUENCY) { + cJSON_AddStringToObject(root, "frequencyBand", "5GHz"); + } else { + cJSON_AddStringToObject(root, "frequencyBand", "2.4GHz"); + } + cJSON_AddStringToObject(root, "gatewayIp", IpTools::ConvertIpv4Address(wifiIpInfo.ipAddress).c_str()); + cJSON_AddStringToObject(root, "gatewayMac", config.macAddress.c_str()); + cJSON_AddStringToObject(root, "primaryDns", IpTools::ConvertIpv4Address(wifiIpInfo.primaryDns).c_str()); + if (wifiIpInfo.secondDns == 0) { + cJSON_AddStringToObject(root, "secondDns", "0.0.0.0"); + } else { + cJSON_AddStringToObject(root, "secondDns", IpTools::ConvertIpv4Address(wifiIpInfo.secondDns).c_str()); + } +} + +void WifiSecurityDetect::AddWifiStandardToJson(cJSON *root, int wifiStandard) +{ + switch (wifiStandard) { + case WireType::WIRE_802_11A: + cJSON_AddStringToObject(root, "wirelessType", "802.11a"); + break; + case WireType::WIRE_802_11B: + cJSON_AddStringToObject(root, "wirelessType", "802.11b"); + break; + case WireType::WIRE_802_11G: + cJSON_AddStringToObject(root, "wirelessType", "802.11g"); + break; + case WireType::WIRE_802_11N: + cJSON_AddStringToObject(root, "wirelessType", "802.11n"); + break; + case WireType::WIRE_802_11AC: + cJSON_AddStringToObject(root, "wirelessType", "802.11ac"); + break; + case WireType::WIRE_802_11AX: + cJSON_AddStringToObject(root, "wirelessType", "802.11ax"); + break; + default: + WIFI_LOGE("wifi wirelessType is unknown"); + cJSON_AddStringToObject(root, "wirelessType", ""); + break; + + + + + + + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + ConverWifiLinkInfoToJson(info, root); + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr != nullptr) { + model.param = jsonStr; + WIFI_LOGI("%s", model.param.c_str()); + free(jsonStr); + } + cJSON_Delete(root); + + + + + +void AddWifiStandardToJson(cJSON *root, int wifiStandard); + + void ConverWifiLinkInfoToJson(const WifiLinkedInfo &info, cJSON *root); + + + + + + + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + LOGE("Failed to create cJSON object"); + return ""; + } + cJSON *resultInfo = cJSON_CreateArray(); + if (resultInfo == nullptr) { + LOGE("Failed to create cJSON Arr"); + cJSON_Delete(root); + return ""; + } + cJSON *errorInfo = cJSON_CreateObject(); + if (errorInfo == nullptr) { + LOGE("Failed to create cJSON object"); + cJSON_Delete(root); + return ""; + } + + cJSON_AddStringToObject(errorInfo, "type", "ErrorInfo"); + std::string codeStr = std::to_string(replyCode); + cJSON_AddStringToObject(errorInfo, "errorCode", codeStr.c_str()); + cJSON_AddStringToObject(errorInfo, "errorInfo", ""); + + cJSON_AddItemToArray(resultInfo, errorInfo); + + + cJSON_AddItemToObject(root, "resultInfo", resultInfo); + + char *jsonStr = cJSON_PrintUnformatted(root); + std::string result; + if (jsonStr != nullptr) { + result = jsonStr; + free(jsonStr); + } + + cJSON_Delete(root); + return result; + + + + + if (errorInfo == nullptr) { + LOGE("Failed to create cJSON object"); + cJSON_Delete(root); + return ""; + } + + cJSON_AddStringToObject(errorInfo, "type", "ErrorInfo"); + std::string codeStr = std::to_string(replyCode); + cJSON_AddStringToObject(errorInfo, "errorCode", codeStr.c_str()); + cJSON_AddStringToObject(errorInfo, "errorInfo", ""); + + cJSON_AddItemToArray(resultInfo, errorInfo); + + + cJSON_AddItemToObject(root, "resultInfo", resultInfo); + + char *jsonStr = cJSON_PrintUnformatted(root); + std::string result; + if (jsonStr != nullptr) { + result = jsonStr; + free(jsonStr); + } + + cJSON_Delete(root); + return result; + + + + + + cJSON *root = cJSON_Parse(jsonString.c_str()); + if (root == nullptr) { + + + + LOGE("ParseJson failed to parse json data."); + return false; + } + if (!cJSON_IsArray(root)) { + cJSON_Delete(root); + return false; + } + int nSize = cJSON_GetArraySize(root); + for (int i = 0; i < nSize; i++) { + cJSON *item = cJSON_GetArrayItem(root, i); + if (item == nullptr || !cJSON_IsObject(item)) { + continue; + } + cJSON *typeItem = cJSON_GetObjectItem(item, type.c_str()); // 比如 "data" + if (typeItem == nullptr) { + continue; + } + if (ParseJsonKey(typeItem, key, value)) { + cJSON_Delete(root); + return true; + } + } + cJSON_Delete(root); + return false; +} + + + + + + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "WIFI_STATE", static_cast(operType)); + cJSON_AddStringToObject(root, "TYPE", serviceType.c_str()); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_WIFI_STATE", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); + + + + + +void WriteWifiOperateStateHiSysEvent(int operateType, int operateState) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "OPERATE_TYPE", operateType); + cJSON_AddNumberToObject(root, "OPERATE_STATE", operateState); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_OPERATE_STATE", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteWifiAbnormalDisconnectHiSysEvent(int errorCode, int locallyGenerated) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "ERROR_CODE", errorCode); + cJSON_AddNumberToObject(root, "IS_ACTIVE_DISCONNECT", locallyGenerated); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_ABNORMAL_DISCONNECT", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteWifiBeaconLostHiSysEvent(int32_t errorCode) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "ERROR_CODE", errorCode); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_BEACON_LOST", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteWifiConnectionInfoHiSysEvent(int networkId) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "NETWORK_ID", networkId); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_CONNECTION_INFO", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteWifiOpenAndCloseFailedHiSysEvent(int operateType, std::string failReason, int apState) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "OPERATE_TYPE", operateType); + cJSON_AddStringToObject(root, "FAIL_REASON", failReason.c_str()); + cJSON_AddNumberToObject(root, "AP_STATE", apState); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_OPEN_AND_CLOSE_FAILED", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteSoftApOpenAndCloseFailedEvent(int operateType, std::string failReason) +{ + WIFI_LOGE("WriteSoftApOpenAndCloseFailedEvent operateType=%{public}d", operateType); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "OPERATE_TYPE", operateType); + cJSON_AddStringToObject(root, "FAIL_REASON", failReason.c_str()); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "SOFTAP_OPEN_AND_CLOSE_FAILED", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteWifiAccessIntFailedHiSysEvent( + int operateRes, int failCnt, int selfCureResetState, std::string selfCureHistory) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "OPERATE_TYPE", operateRes); + cJSON_AddNumberToObject(root, "FAIL_CNT", failCnt); + cJSON_AddNumberToObject(root, "RESET_STATE", selfCureResetState); + cJSON_AddStringToObject(root, "SELF_CURE_HISTORY", selfCureHistory.c_str()); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_ACCESS_INTERNET_FAILED", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteWifiPnoScanHiSysEvent(int isStartScan, int suspendReason) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "IS_START", isStartScan); + cJSON_AddNumberToObject(root, "SUSPEND_REASON", suspendReason); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_PNO_SCAN_INFO", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteBrowserFailedForPortalHiSysEvent(int respCode, std::string &server) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "RESP_CODE", respCode); + cJSON_AddStringToObject(root, "SERVER", server.c_str()); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "BROWSER_FAILED_FOR_PORTAL", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteAuthFailHiSysEvent(const std::string &authFailReason, int subErrCode) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(root, "FAIL_REASON", authFailReason.c_str()); + cJSON_AddNumberToObject(root, "SUB_ERR_CODE", subErrCode); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_AUTH_FAIL_INFO", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteAssocFailHiSysEvent(const std::string &assocFailReason, int subErrCode) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(root, "FAIL_REASON", assocFailReason.c_str()); + cJSON_AddNumberToObject(root, "SUB_ERR_CODE", subErrCode); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_ASSOC_FAIL_INFO", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteDhcpFailHiSysEvent(const std::string &dhcpFailReason, int subErrCode) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(root, "FAIL_REASON", dhcpFailReason.c_str()); + cJSON_AddNumberToObject(root, "SUB_ERR_CODE", subErrCode); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_DHCP_FAIL_INFO", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteScanLimitHiSysEvent(const std::string &scanInitiator, int scanLimitType, bool isForeground) + if (scanInitiator.empty()) { + return; + } + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(root, "SCAN_INITIATOR", scanInitiator.c_str()); + cJSON_AddBoolToObject(root, "IS_FOREGROUND", isForeground); + cJSON_AddNumberToObject(root, "SCAN_LIMIT_TYPE", scanLimitType); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_SCAN_LIMIT_STATISTICS", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteAutoConnectFailEvent(const std::string &failReason, const std::string &subReason) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(root, "FAIL_REASON", failReason.c_str()); + cJSON_AddStringToObject(root, "SUB_REASON", subReason.c_str()); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_AUTO_RECONNECT_FAILED", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteP2pKpiCountHiSysEvent(int eventType) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "EVENT_TYPE", eventType); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "P2P_CONNECT_STATICS", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteP2pConnectFailedHiSysEvent(int errCode, int failRes) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "EVENT_TYPE", errCode); + cJSON_AddNumberToObject(root, "FAIL_RES", failRes); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "P2P_CONNECT_FAIL", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteP2pAbDisConnectHiSysEvent(int errCode, int failRes) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "EVENT_TYPE", errCode); + cJSON_AddNumberToObject(root, "FAIL_RES", failRes); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "P2P_ABNORMAL_DISCONNECT", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteSoftApAbDisconnectHiSysEvent(int errorCode) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "ERROR_CODE", errorCode); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "SOFTAP_ABNORMAL_DISCONNECT", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteIsInternetHiSysEvent(int isInternet) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "IS_INTERNET", isInternet); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_KPI_INTERNET", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteSoftApConnectFailHiSysEvent(int errorCnt) +{ + WIFI_LOGE("WriteSoftApConnectFailHiSysEvent errorCnt=%{public}d", errorCnt); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "ERROR_CODE", errorCnt); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "SOFTAP_CONNECT_FAILED", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteSoftApClientAccessNetErrorHiSysEvent(int errorCode) +{ + WIFI_LOGE("WriteSoftApClientAccessNetErrorHiSysEvent errorCode=%{public}d", errorCode); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "ERROR_CODE", errorCode); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "SOFTAP_CLIENT_ACCESS_NET_ERROR", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteWifiScanApiFailHiSysEvent(const std::string &pkgName, const WifiScanFailReason failReason) +{ +#ifndef OHOS_ARCH_LITE + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(root, "PKG_NAME", pkgName.c_str()); + cJSON_AddNumberToObject(root, "FAIL_REASON", static_cast(failReason)); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFISCANCONTROL_TRIGGER_API_FAIL", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +#endif +} + +void WriteWifiEncryptionFailHiSysEvent( + int event, const std::string &maskSsid, const std::string &keyMgmt, int encryptedModule) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "ENCRY_OR_DECRY_EVENT", event); + cJSON_AddStringToObject(root, "SSID", maskSsid.c_str()); + cJSON_AddStringToObject(root, "ENCRYKEYMANAGEMENT", keyMgmt.c_str()); + cJSON_AddNumberToObject(root, "ENCRYEVENTMODULE", encryptedModule); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFIENCRY_OR_DECRY_FAIL", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WritePortalStateHiSysEvent(int portalState) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "PORTAL_STATE", portalState); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_PORTAL_STATE", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteArpInfoHiSysEvent(uint64_t arpRtt, int32_t arpFailedCount, int32_t gatewayCnt) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "ARP_RTT", static_cast(arpRtt)); + cJSON_AddNumberToObject(root, "ARP_FAILED_COUNT", arpFailedCount); + cJSON_AddNumberToObject(root, "ARP_GWCOUNT", gatewayCnt); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_ARP_DETECTION_INFO", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteLinkInfoHiSysEvent(int signalLevel, int rssi, int band, int linkSpeed) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "LEVEL", signalLevel); + cJSON_AddNumberToObject(root, "BAND", band); + cJSON_AddNumberToObject(root, "RSSI", rssi); + cJSON_AddNumberToObject(root, "LINKSPEED", linkSpeed); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_LINK_INFO", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteConnectTypeHiSysEvent(int connectType, bool isFirstConnect) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + std::string connectTypeStr = ""; + if (g_connectTypeTransMap.find(connectType) != g_connectTypeTransMap.end()) { + connectTypeStr = g_connectTypeTransMap.at(connectType); + if (isFirstConnect) { + connectTypeStr = "FIRST_CONNECT"; + } + cJSON_AddStringToObject(root, "CONNECT_TYPE", connectTypeStr.c_str()); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "_CONNECT_TYPE", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteWifiLinkTypeHiSysEvent(const std::string &ssid, int32_t wifiLinkType, const std::string &triggerReason) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(root, "SSID", ssid.c_str()); + cJSON_AddNumberToObject(root, "WIFI_LINK_TYPE", wifiLinkType); + cJSON_AddStringToObject(root, "TRIGGER_REASON", triggerReason.c_str()); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_WIFI_LINK_TYPE_UPDATE", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteEmlsrExitReasonHiSysEvent(const std::string &ssid, int32_t reason) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(root, "SSID", ssid.c_str()); + cJSON_AddNumberToObject(root, "EMLSR_EXIT_REASON", reason); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_WIFI_EMLSR_EXIT_REASON", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteStaConnectIface(const std::string &ifName) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed create cJSON object"); + return; + } + cJSON_AddStringToObject(root, "IFACE_NAME", ifName.c_str()); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_STA_CONNECT_IFNAME", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteWifiWpaStateHiSysEvent(int state) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "WPA_STATE", state); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_WPA_STATE", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WritePortalAuthExpiredHisysevent( + int respCode, int detectNum, time_t connTime, time_t portalAuthTime, bool isNotificationClicked) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + time_t now = time(nullptr); + if (now < 0) { + now = 0; + } + int64_t authDura = (now > 0 && portalAuthTime > 0 && now > portalAuthTime) ? (now - portalAuthTime) : 0; + int64_t connDura = (now > 0 && connTime > 0 && now > connTime) ? (now - connTime) : 0; + int64_t authCostDura = + (portalAuthTime > 0 && connTime > 0 && portalAuthTime > connTime) ? (portalAuthTime - connTime) : 0; + cJSON_AddNumberToObject(root, "RESP_CODE", respCode); + cJSON_AddNumberToObject(root, "DURA", authDura); + cJSON_AddNumberToObject(root, "CONN_DURA", connDura); + cJSON_AddNumberToObject(root, "AUTH_COST_DURA", authCostDura); + cJSON_AddNumberToObject(root, "DET_NUM", detectNum); + cJSON_AddBoolToObject(root, "IS_NOTIFICA_CLICKED", isNotificationClicked); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "PORTAL_AUTH_EXPIRED", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteWifiSelfcureHisysevent(int type) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "WIFI_SELFCURE_TYPE", type); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_SELFCURE", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void Write3VapConflictHisysevent(int type) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "WIFI_3VAP_CONFLICT_TYPE", type); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_3VAP_CONFLICT", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void Write5gPrefFailedHisysevent(Pref5gStatisticsInfo &info) + int64_t conDuration = 0; + if (info.isIn5gPref && !info.has5gPrefSwitch) { + if (info.noInternetTime != std::chrono::steady_clock::time_point::min()) { + info.durationNoInternet += + std::chrono::duration_cast(std::chrono::steady_clock::now() - info.noInternetTime) + .count(); + } + if (info.connectTime != std::chrono::steady_clock::time_point::min()) { + conDuration = + std::chrono::duration_cast(std::chrono::steady_clock::now() - info.connectTime) + .count(); + } + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(root, "BSSID", info.bssid.c_str()); + cJSON_AddStringToObject(root, "SSID", info.ssid.c_str()); + cJSON_AddNumberToObject(root, "FREQ", info.freq); + cJSON_AddNumberToObject(root, "CON_DURATION", conDuration); + cJSON_AddNumberToObject(root, "DURATION_NO_INTERNET", info.durationNoInternet); + cJSON_AddNumberToObject(root, "ENTER_MONITOR_NUM", info.enterMonitorNum); + cJSON_AddNumberToObject(root, "MONITOR_ACTIVE_SCAN_NUM", info.monitorActiveScanNum); + cJSON_AddNumberToObject(root, "RELA_5G_NUM", info.rela5gNum); + cJSON_AddNumberToObject(root, "NOT_ADJ_5g_NUM", info.notAdj5gNum); + cJSON_AddNumberToObject(root, "NOT_INTERNET_RELA_5G_NUM", info.notInternetRela5gNum); + cJSON_AddNumberToObject(root, "ALL_RELA_5G_IN_BLOCK_LIST_NUM", info.allRela5gInBlockListNum); + cJSON_AddNumberToObject(root, "SATISFY_NO_SELECTED_NUM", info.satisfySwitchRssiNoSelectedNum); + cJSON_AddNumberToObject(root, "IS_USER_CONNECTED", info.isUserConnected ? 1 : 0); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_5G_PREF_FAILED", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); + } +} + +void WriteAutoSelectHiSysEvent( + int selectType, const std::string &selectedInfo, const std::string &filteredReason, const std::string &savedResult) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "AUTO_SELECT_TYPE", selectType); + cJSON_AddStringToObject(root, "AUTO_SELECT_RESULT", selectedInfo.c_str()); + cJSON_AddStringToObject(root, "AUTO_SELECT_FILTER", filteredReason.c_str()); + cJSON_AddStringToObject(root, "SAVED_NETWORK_IN_SCAN", savedResult.c_str()); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_AUTO_SELECT_STATISTIC", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteDhcpInfoHiSysEvent(const IpInfo &ipInfo, const IpV6Info &ipv6Info) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(root, "IPV4_IPADDRESS", Ipv4IntAnonymize(ipInfo.ipAddress).c_str()); + cJSON_AddStringToObject(root, "IPV4_GATEWAY", Ipv4IntAnonymize(ipInfo.gateway).c_str()); + cJSON_AddStringToObject(root, "IPV4_NETMASK", Ipv4IntAnonymize(ipInfo.netmask).c_str()); + cJSON_AddStringToObject(root, "IPV4_PRIMARYDNS", Ipv4IntAnonymize(ipInfo.primaryDns).c_str()); + cJSON_AddStringToObject(root, "IPV4_SECONDDNS", Ipv4IntAnonymize(ipInfo.secondDns).c_str()); + cJSON_AddStringToObject(root, "IPV4_SERVERIP", Ipv4IntAnonymize(ipInfo.serverIp).c_str()); + cJSON_AddNumberToObject(root, "IPV4_LEASE", ipInfo.leaseDuration); + cJSON_AddNumberToObject(root, "IPV4_DNS_VEC_SIZE", static_cast(ipInfo.dnsAddr.size())); + for (size_t i = 0; i < ipInfo.dnsAddr.size(); i++) { + if (i >= MAX_DNS_NUM) { + WIFI_LOGE("ipInfo.dnsAddr size over limit"); + break; + } + std::string keyString = "IPV4_DNS" + std::to_string(i); + cJSON_AddStringToObject(root, keyString.c_str(), Ipv4IntAnonymize(ipInfo.dnsAddr[i]).c_str()); + } + cJSON_AddStringToObject(root, "IPV6_LINKIPV6ADDR", Ipv6Anonymize(ipv6Info.linkIpV6Address).c_str()); + cJSON_AddStringToObject(root, "IPV6_GLOBALIPV6ADDR", Ipv6Anonymize(ipv6Info.globalIpV6Address).c_str()); + cJSON_AddStringToObject(root, "IPV6_RANDGLOBALIPV6ADDR", Ipv6Anonymize(ipv6Info.randGlobalIpV6Address).c_str()); + cJSON_AddStringToObject(root, "IPV6_GATEWAY", Ipv6Anonymize(ipv6Info.gateway).c_str()); + cJSON_AddStringToObject(root, "IPV6_NETMASK", Ipv6Anonymize(ipv6Info.netmask).c_str()); + cJSON_AddStringToObject(root, "IPV6_PRIMARYDNS", Ipv6Anonymize(ipv6Info.primaryDns).c_str()); + cJSON_AddStringToObject(root, "IPV6_SECONDDNS", Ipv6Anonymize(ipv6Info.secondDns).c_str()); + cJSON_AddStringToObject(root, "IPV6_UNIQUELOCALADDR1", Ipv6Anonymize(ipv6Info.uniqueLocalAddress1).c_str()); + cJSON_AddStringToObject(root, "IPV6_UNIQUELOCALADDR2", Ipv6Anonymize(ipv6Info.uniqueLocalAddress2).c_str()); + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_DHCP_INFO", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + +void WriteIodHiSysEvent(const IodStatisticInfo &iodStatisticInfo) +{ + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "OUTDOORFILTERCNT", iodStatisticInfo.outdoorFilterCnt); + cJSON_AddNumberToObject(root, "OUTDOORSELECTWIFICNT", iodStatisticInfo.outdoorAutoSelectCnt); + cJSON_AddNumberToObject(root, "INTOOUTDOORCNT", iodStatisticInfo.in2OutCnt); + cJSON_AddNumberToObject(root, "OUTTOINDOORCNT", iodStatisticInfo.out2InCnt); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_IOD_STATISTIC", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); +} + + + + + + + + + + + + + + diff --git a/wifi/utils/BUILD.gn b/wifi/utils/BUILD.gn index e07d0e094..60d1fb39b 100644 --- a/wifi/utils/BUILD.gn +++ b/wifi/utils/BUILD.gn @@ -90,6 +90,7 @@ if (defined(ohos_lite)) { "bundle_framework:appexecfwk_base", "bundle_framework:appexecfwk_core", "c_utils:utils", + "cJSON:cjson", "hilog:libhilog", "hisysevent:libhisysevent", "ipc:ipc_single", diff --git a/wifi/utils/src/wifi_hisysevent.cpp b/wifi/utils/src/wifi_hisysevent.cpp index 3418dca71..0cf6eebcc 100644 --- a/wifi/utils/src/wifi_hisysevent.cpp +++ b/wifi/utils/src/wifi_hisysevent.cpp @@ -18,7 +18,7 @@ #include "hisysevent.h" #include "sta_define.h" #include "wifi_logger.h" -#include "json/json.h" +#include "cJSON.h" #include namespace OHOS { @@ -61,11 +61,22 @@ void WriteWifiStateHiSysEvent(const std::string& serviceType, WifiOperType operT { WriteEvent("WIFI_STATE", "TYPE", serviceType, "OPER_TYPE", static_cast(operType)); - Json::Value root; - Json::FastWriter writer; - root["WIFI_STATE"] = static_cast(operType); - root["TYPE"] = serviceType; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_WIFI_STATE", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "WIFI_STATE", static_cast(operType)); + cJSON_AddStringToObject(root, "TYPE", serviceType.c_str()); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_WIFI_STATE", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } void WriteWifiApStateHiSysEvent(int32_t state) @@ -110,252 +121,542 @@ void WriteWifiSignalHiSysEvent(int direction, int txPackets, int rxPackets) void WriteWifiOperateStateHiSysEvent(int operateType, int operateState) { - Json::Value root; - Json::FastWriter writer; - root["OPERATE_TYPE"] = operateType; - root["OPERATE_STATE"] = operateState; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_OPERATE_STATE", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "OPERATE_TYPE", operateType); + cJSON_AddNumberToObject(root, "OPERATE_STATE", operateState); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_OPERATE_STATE", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - + void WriteWifiAbnormalDisconnectHiSysEvent(int errorCode, int locallyGenerated) { - Json::Value root; - Json::FastWriter writer; - root["ERROR_CODE"] = errorCode; - root["IS_ACTIVE_DISCONNECT"] = locallyGenerated; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_ABNORMAL_DISCONNECT", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "ERROR_CODE", errorCode); + cJSON_AddNumberToObject(root, "IS_ACTIVE_DISCONNECT", locallyGenerated); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_ABNORMAL_DISCONNECT", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - + void WriteWifiBeaconLostHiSysEvent(int32_t errorCode) { - Json::Value root; - Json::FastWriter writer; - root["ERROR_CODE"] = errorCode; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_BEACON_LOST", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "ERROR_CODE", errorCode); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_BEACON_LOST", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - + void WriteWifiConnectionInfoHiSysEvent(int networkId) { - Json::Value root; - Json::FastWriter writer; - root["NETWORK_ID"] = networkId; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_CONNECTION_INFO", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "NETWORK_ID", networkId); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_CONNECTION_INFO", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - + void WriteWifiOpenAndCloseFailedHiSysEvent(int operateType, std::string failReason, int apState) { - Json::Value root; - Json::FastWriter writer; - root["OPERATE_TYPE"] = operateType; - root["FAIL_REASON"] = failReason; - root["AP_STATE"] = apState; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_OPEN_AND_CLOSE_FAILED", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "OPERATE_TYPE", operateType); + cJSON_AddStringToObject(root, "FAIL_REASON", failReason.c_str()); + cJSON_AddNumberToObject(root, "AP_STATE", apState); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_OPEN_AND_CLOSE_FAILED", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - + void WriteSoftApOpenAndCloseFailedEvent(int operateType, std::string failReason) { WIFI_LOGE("WriteSoftApOpenAndCloseFailedEvent operateType=%{public}d", operateType); - Json::Value root; - Json::FastWriter writer; - root["OPERATE_TYPE"] = operateType; - root["FAIL_REASON"] = failReason; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "SOFTAP_OPEN_AND_CLOSE_FAILED", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "OPERATE_TYPE", operateType); + cJSON_AddStringToObject(root, "FAIL_REASON", failReason.c_str()); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "SOFTAP_OPEN_AND_CLOSE_FAILED", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - -void WriteWifiAccessIntFailedHiSysEvent(int operateRes, int failCnt, int selfCureResetState, - std::string selfCureHistory) + +void WriteWifiAccessIntFailedHiSysEvent( + int operateRes, int failCnt, int selfCureResetState, std::string selfCureHistory) { - Json::Value root; - Json::FastWriter writer; - root["OPERATE_TYPE"] = operateRes; - root["FAIL_CNT"] = failCnt; - root["RESET_STATE"] = selfCureResetState; - root["SELF_CURE_HISTORY"] = selfCureHistory; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_ACCESS_INTERNET_FAILED", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "OPERATE_TYPE", operateRes); + cJSON_AddNumberToObject(root, "FAIL_CNT", failCnt); + cJSON_AddNumberToObject(root, "RESET_STATE", selfCureResetState); + cJSON_AddStringToObject(root, "SELF_CURE_HISTORY", selfCureHistory.c_str()); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_ACCESS_INTERNET_FAILED", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - + void WriteWifiPnoScanHiSysEvent(int isStartScan, int suspendReason) { - Json::Value root; - Json::FastWriter writer; - root["IS_START"] = isStartScan; - root["SUSPEND_REASON"] = suspendReason; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_PNO_SCAN_INFO", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "IS_START", isStartScan); + cJSON_AddNumberToObject(root, "SUSPEND_REASON", suspendReason); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_PNO_SCAN_INFO", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - + void WriteBrowserFailedForPortalHiSysEvent(int respCode, std::string &server) { - Json::Value root; - Json::FastWriter writer; - root["RESP_CODE"] = respCode; - root["SERVER"] = server; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "BROWSER_FAILED_FOR_PORTAL", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "RESP_CODE", respCode); + cJSON_AddStringToObject(root, "SERVER", server.c_str()); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "BROWSER_FAILED_FOR_PORTAL", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - + void WriteAuthFailHiSysEvent(const std::string &authFailReason, int subErrCode) { - Json::Value root; - Json::FastWriter writer; - root["FAIL_REASON"] = authFailReason; - root["SUB_ERR_CODE"] = subErrCode; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_AUTH_FAIL_INFO", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(root, "FAIL_REASON", authFailReason.c_str()); + cJSON_AddNumberToObject(root, "SUB_ERR_CODE", subErrCode); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_AUTH_FAIL_INFO", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - + void WriteAssocFailHiSysEvent(const std::string &assocFailReason, int subErrCode) { - Json::Value root; - Json::FastWriter writer; - root["FAIL_REASON"] = assocFailReason; - root["SUB_ERR_CODE"] = subErrCode; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_ASSOC_FAIL_INFO", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(root, "FAIL_REASON", assocFailReason.c_str()); + cJSON_AddNumberToObject(root, "SUB_ERR_CODE", subErrCode); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_ASSOC_FAIL_INFO", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } void WriteDhcpFailHiSysEvent(const std::string &dhcpFailReason, int subErrCode) { - Json::Value root; - Json::FastWriter writer; - root["FAIL_REASON"] = dhcpFailReason; - root["SUB_ERR_CODE"] = subErrCode; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_DHCP_FAIL_INFO", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(root, "FAIL_REASON", dhcpFailReason.c_str()); + cJSON_AddNumberToObject(root, "SUB_ERR_CODE", subErrCode); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_DHCP_FAIL_INFO", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - + void WriteScanLimitHiSysEvent(const std::string &scanInitiator, int scanLimitType, bool isForeground) { if (scanInitiator.empty()) { return; } - Json::Value root; - Json::FastWriter writer; - root["SCAN_INITIATOR"] = scanInitiator; - root["IS_FOREGROUND"] = isForeground; - root["SCAN_LIMIT_TYPE"] = scanLimitType; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_SCAN_LIMIT_STATISTICS", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(root, "SCAN_INITIATOR", scanInitiator.c_str()); + cJSON_AddBoolToObject(root, "IS_FOREGROUND", isForeground); + cJSON_AddNumberToObject(root, "SCAN_LIMIT_TYPE", scanLimitType); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_SCAN_LIMIT_STATISTICS", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - + void WriteAutoConnectFailEvent(const std::string &failReason, const std::string &subReason) { - Json::Value root; - Json::FastWriter writer; - root["FAIL_REASON"] = failReason; - root["SUB_REASON"] = subReason; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_AUTO_RECONNECT_FAILED", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(root, "FAIL_REASON", failReason.c_str()); + cJSON_AddStringToObject(root, "SUB_REASON", subReason.c_str()); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_AUTO_RECONNECT_FAILED", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - + void WriteP2pKpiCountHiSysEvent(int eventType) { - Json::Value root; - Json::FastWriter writer; - root["EVENT_TYPE"] = eventType; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "P2P_CONNECT_STATICS", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "EVENT_TYPE", eventType); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "P2P_CONNECT_STATICS", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - + void WriteP2pConnectFailedHiSysEvent(int errCode, int failRes) { - Json::Value root; - Json::FastWriter writer; - root["EVENT_TYPE"] = errCode; - root["FAIL_RES"] = failRes; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "P2P_CONNECT_FAIL", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "EVENT_TYPE", errCode); + cJSON_AddNumberToObject(root, "FAIL_RES", failRes); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "P2P_CONNECT_FAIL", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - + void WriteP2pAbDisConnectHiSysEvent(int errCode, int failRes) { - Json::Value root; - Json::FastWriter writer; - root["EVENT_TYPE"] = errCode; - root["FAIL_RES"] = failRes; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "P2P_ABNORMAL_DISCONNECT", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "EVENT_TYPE", errCode); + cJSON_AddNumberToObject(root, "FAIL_RES", failRes); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "P2P_ABNORMAL_DISCONNECT", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - + void WriteSoftApAbDisconnectHiSysEvent(int errorCode) { - Json::Value root; - Json::FastWriter writer; - root["ERROR_CODE"] = errorCode; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "SOFTAP_ABNORMAL_DISCONNECT", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "ERROR_CODE", errorCode); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "SOFTAP_ABNORMAL_DISCONNECT", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - + void WriteIsInternetHiSysEvent(int isInternet) { - Json::Value root; - Json::FastWriter writer; - root["IS_INTERNET"] = isInternet; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_KPI_INTERNET", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "IS_INTERNET", isInternet); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_KPI_INTERNET", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - + void WriteSoftApConnectFailHiSysEvent(int errorCnt) { WIFI_LOGE("WriteSoftApConnectFailHiSysEvent errorCnt=%{public}d", errorCnt); - Json::Value root; - Json::FastWriter writer; - root["ERROR_CODE"] = errorCnt; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "SOFTAP_CONNECT_FAILED", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "ERROR_CODE", errorCnt); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "SOFTAP_CONNECT_FAILED", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - + void WriteSoftApClientAccessNetErrorHiSysEvent(int errorCode) { WIFI_LOGE("WriteSoftApClientAccessNetErrorHiSysEvent errorCode=%{public}d", errorCode); - Json::Value root; - Json::FastWriter writer; - root["ERROR_CODE"] = errorCode; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "SOFTAP_CLIENT_ACCESS_NET_ERROR", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "ERROR_CODE", errorCode); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "SOFTAP_CLIENT_ACCESS_NET_ERROR", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - -void WriteWifiScanApiFailHiSysEvent(const std::string& pkgName, const WifiScanFailReason failReason) + +void WriteWifiScanApiFailHiSysEvent(const std::string &pkgName, const WifiScanFailReason failReason) { #ifndef OHOS_ARCH_LITE - Json::Value root; - Json::FastWriter writer; - root["PKG_NAME"] = pkgName; - root["FAIL_REASON"] = static_cast(failReason); - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFISCANCONTROL_TRIGGER_API_FAIL", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(root, "PKG_NAME", pkgName.c_str()); + cJSON_AddNumberToObject(root, "FAIL_REASON", static_cast(failReason)); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFISCANCONTROL_TRIGGER_API_FAIL", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); #endif } - -void WriteWifiEncryptionFailHiSysEvent(int event, const std::string& maskSsid, const std::string &keyMgmt, int encryptedModule) + +void WriteWifiEncryptionFailHiSysEvent( + int event, const std::string &maskSsid, const std::string &keyMgmt, int encryptedModule) { - Json::Value root; - Json::FastWriter writer; - root["ENCRY_OR_DECRY_EVENT"] = event; - root["SSID"] = maskSsid; - root["ENCRYKEYMANAGEMENT"] = keyMgmt; - root["ENCRYEVENTMODULE"] = encryptedModule; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFIENCRY_OR_DECRY_FAIL", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "ENCRY_OR_DECRY_EVENT", event); + cJSON_AddStringToObject(root, "SSID", maskSsid.c_str()); + cJSON_AddStringToObject(root, "ENCRYKEYMANAGEMENT", keyMgmt.c_str()); + cJSON_AddNumberToObject(root, "ENCRYEVENTMODULE", encryptedModule); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFIENCRY_OR_DECRY_FAIL", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - + void WritePortalStateHiSysEvent(int portalState) { - Json::Value root; - Json::FastWriter writer; - root["PORTAL_STATE"] = portalState; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_PORTAL_STATE", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "PORTAL_STATE", portalState); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_PORTAL_STATE", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - + void WriteArpInfoHiSysEvent(uint64_t arpRtt, int32_t arpFailedCount, int32_t gatewayCnt) { - Json::Value root; - Json::FastWriter writer; - root["ARP_RTT"] = arpRtt; - root["ARP_FAILED_COUNT"] = arpFailedCount; - root["ARP_GWCOUNT"] = gatewayCnt; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_ARP_DETECTION_INFO", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "ARP_RTT", static_cast(arpRtt)); + cJSON_AddNumberToObject(root, "ARP_FAILED_COUNT", arpFailedCount); + cJSON_AddNumberToObject(root, "ARP_GWCOUNT", gatewayCnt); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_ARP_DETECTION_INFO", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - + void WriteLinkInfoHiSysEvent(int signalLevel, int rssi, int band, int linkSpeed) { - Json::Value root; - Json::FastWriter writer; - root["LEVEL"] = signalLevel; - root["BAND"] = band; - root["RSSI"] = rssi; - root["LINKSPEED"] = linkSpeed; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_LINK_INFO", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "LEVEL", signalLevel); + cJSON_AddNumberToObject(root, "BAND", band); + cJSON_AddNumberToObject(root, "RSSI", rssi); + cJSON_AddNumberToObject(root, "LINKSPEED", linkSpeed); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_LINK_INFO", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - + void WriteConnectTypeHiSysEvent(int connectType, bool isFirstConnect) { - Json::Value root; - Json::FastWriter writer; + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } std::string connectTypeStr = ""; if (g_connectTypeTransMap.find(connectType) != g_connectTypeTransMap.end()) { connectTypeStr = g_connectTypeTransMap.at(connectType); @@ -363,167 +664,297 @@ void WriteConnectTypeHiSysEvent(int connectType, bool isFirstConnect) if (isFirstConnect) { connectTypeStr = "FIRST_CONNECT"; } - root["CONNECT_TYPE"] = connectTypeStr; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_CONNECT_TYPE", "EVENT_VALUE", writer.write(root)); + cJSON_AddStringToObject(root, "CONNECT_TYPE", connectTypeStr.c_str()); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "_CONNECT_TYPE", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - + void WriteWifiLinkTypeHiSysEvent(const std::string &ssid, int32_t wifiLinkType, const std::string &triggerReason) { - Json::Value root; - Json::FastWriter writer; - root["SSID"] = ssid; - root["WIFI_LINK_TYPE"] = wifiLinkType; - root["TRIGGER_REASON"] = triggerReason; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_WIFI_LINK_TYPE_UPDATE", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(root, "SSID", ssid.c_str()); + cJSON_AddNumberToObject(root, "WIFI_LINK_TYPE", wifiLinkType); + cJSON_AddStringToObject(root, "TRIGGER_REASON", triggerReason.c_str()); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_WIFI_LINK_TYPE_UPDATE", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - + void WriteEmlsrExitReasonHiSysEvent(const std::string &ssid, int32_t reason) { - Json::Value root; - Json::FastWriter writer; - root["SSID"] = ssid; - root["EMLSR_EXIT_REASON"] = reason; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_WIFI_EMLSR_EXIT_REASON", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(root, "SSID", ssid.c_str()); + cJSON_AddNumberToObject(root, "EMLSR_EXIT_REASON", reason); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_WIFI_EMLSR_EXIT_REASON", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - + void WriteStaConnectIface(const std::string &ifName) { - Json::Value root; - Json::FastWriter writer; - root["IFACE_NAME"] = ifName; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_STA_CONNECT_IFNAME", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed create cJSON object"); + return; + } + cJSON_AddStringToObject(root, "IFACE_NAME", ifName.c_str()); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_STA_CONNECT_IFNAME", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - + void WriteWifiWpaStateHiSysEvent(int state) { - Json::Value root; - Json::FastWriter writer; - root["WPA_STATE"] = state; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_WPA_STATE", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "WPA_STATE", state); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "EVENT_WPA_STATE", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - -void WritePortalAuthExpiredHisysevent(int respCode, int detectNum, time_t connTime, - time_t portalAuthTime, bool isNotificationClicked) + +void WritePortalAuthExpiredHisysevent( + int respCode, int detectNum, time_t connTime, time_t portalAuthTime, bool isNotificationClicked) { - Json::Value root; - Json::FastWriter writer; + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } time_t now = time(nullptr); if (now < 0) { now = 0; } - int64_t authDura = (now > 0 && portalAuthTime > 0 && now > portalAuthTime) ? now - portalAuthTime : 0; - int64_t connDura = (now > 0 && connTime > 0 && now > connTime) ? now - connTime : 0; + int64_t authDura = (now > 0 && portalAuthTime > 0 && now > portalAuthTime) ? (now - portalAuthTime) : 0; + int64_t connDura = (now > 0 && connTime > 0 && now > connTime) ? (now - connTime) : 0; int64_t authCostDura = - (portalAuthTime > 0 && connTime > 0 && portalAuthTime > connTime) ? portalAuthTime - connTime : 0; - root["RESP_CODE"] = respCode; - root["DURA"] = authDura; - root["CONN_DURA"] = connDura; - root["AUTH_COST_DURA"] = authCostDura; - root["DET_NUM"] = detectNum; - root["IS_NOTIFICA_CLICKED"] = isNotificationClicked ? 1 : 0; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "PORTAL_AUTH_EXPIRED", "EVENT_VALUE", writer.write(root)); + (portalAuthTime > 0 && connTime > 0 && portalAuthTime > connTime) ? (portalAuthTime - connTime) : 0; + cJSON_AddNumberToObject(root, "RESP_CODE", respCode); + cJSON_AddNumberToObject(root, "DURA", authDura); + cJSON_AddNumberToObject(root, "CONN_DURA", connDura); + cJSON_AddNumberToObject(root, "AUTH_COST_DURA", authCostDura); + cJSON_AddNumberToObject(root, "DET_NUM", detectNum); + cJSON_AddBoolToObject(root, "IS_NOTIFICA_CLICKED", isNotificationClicked); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "PORTAL_AUTH_EXPIRED", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - + void WriteWifiSelfcureHisysevent(int type) { - Json::Value root; - Json::FastWriter writer; - root["WIFI_SELFCURE_TYPE"] = type; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_SELFCURE", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "WIFI_SELFCURE_TYPE", type); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_SELFCURE", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - + void Write3VapConflictHisysevent(int type) { - Json::Value root; - Json::FastWriter writer; - root["WIFI_3VAP_CONFLICT_TYPE"] = type; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_3VAP_CONFLICT", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "WIFI_3VAP_CONFLICT_TYPE", type); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_3VAP_CONFLICT", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - + void Write5gPrefFailedHisysevent(Pref5gStatisticsInfo &info) { int64_t conDuration = 0; if (info.isIn5gPref && !info.has5gPrefSwitch) { if (info.noInternetTime != std::chrono::steady_clock::time_point::min()) { - info.durationNoInternet += std::chrono::duration_cast(std::chrono::steady_clock::now() - - info.noInternetTime).count(); + info.durationNoInternet += + std::chrono::duration_cast(std::chrono::steady_clock::now() - info.noInternetTime) + .count(); } if (info.connectTime != std::chrono::steady_clock::time_point::min()) { - conDuration = std::chrono::duration_cast(std::chrono::steady_clock::now() - - info.connectTime).count(); + conDuration = + std::chrono::duration_cast(std::chrono::steady_clock::now() - info.connectTime) + .count(); + } + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; } - Json::Value root; - Json::FastWriter writer; - root["BSSID"] = info.bssid; - root["SSID"] = info.ssid; - root["FREQ"] = info.freq; - root["CON_DURATION"] = conDuration; - root["DURATION_NO_INTERNET"] = info.durationNoInternet; - root["ENTER_MONITOR_NUM"] = info.enterMonitorNum; - root["MONITOR_ACTIVE_SCAN_NUM"] = info.monitorActiveScanNum; - root["RELA_5G_NUM"] = info.rela5gNum; - root["NOT_ADJ_5g_NUM"] = info.notAdj5gNum; - root["NOT_INTERNET_RELA_5G_NUM"] = info.notInternetRela5gNum; - root["ALL_RELA_5G_IN_BLOCK_LIST_NUM"] = info.allRela5gInBlockListNum; - root["SATISFY_NO_SELECTED_NUM"] = info.satisfySwitchRssiNoSelectedNum; - root["IS_USER_CONNECTED"] = (info.isUserConnected) ? 1 : 0; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_5G_PREF_FAILED", "EVENT_VALUE", writer.write(root)); + cJSON_AddStringToObject(root, "BSSID", info.bssid.c_str()); + cJSON_AddStringToObject(root, "SSID", info.ssid.c_str()); + cJSON_AddNumberToObject(root, "FREQ", info.freq); + cJSON_AddNumberToObject(root, "CON_DURATION", conDuration); + cJSON_AddNumberToObject(root, "DURATION_NO_INTERNET", info.durationNoInternet); + cJSON_AddNumberToObject(root, "ENTER_MONITOR_NUM", info.enterMonitorNum); + cJSON_AddNumberToObject(root, "MONITOR_ACTIVE_SCAN_NUM", info.monitorActiveScanNum); + cJSON_AddNumberToObject(root, "RELA_5G_NUM", info.rela5gNum); + cJSON_AddNumberToObject(root, "NOT_ADJ_5g_NUM", info.notAdj5gNum); + cJSON_AddNumberToObject(root, "NOT_INTERNET_RELA_5G_NUM", info.notInternetRela5gNum); + cJSON_AddNumberToObject(root, "ALL_RELA_5G_IN_BLOCK_LIST_NUM", info.allRela5gInBlockListNum); + cJSON_AddNumberToObject(root, "SATISFY_NO_SELECTED_NUM", info.satisfySwitchRssiNoSelectedNum); + cJSON_AddNumberToObject(root, "IS_USER_CONNECTED", info.isUserConnected ? 1 : 0); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_5G_PREF_FAILED", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } } - -void WriteAutoSelectHiSysEvent(int selectType, const std::string &selectedInfo, - const std::string &filteredReason, const std::string &savedResult) + +void WriteAutoSelectHiSysEvent( + int selectType, const std::string &selectedInfo, const std::string &filteredReason, const std::string &savedResult) { - Json::Value root; - Json::FastWriter writer; - root["AUTO_SELECT_TYPE"] = selectType; - root["AUTO_SELECT_RESULT"] = selectedInfo; - root["AUTO_SELECT_FILTER"] = filteredReason; - root["SAVED_NETWORK_IN_SCAN"] = savedResult; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_AUTO_SELECT_STATISTIC", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "AUTO_SELECT_TYPE", selectType); + cJSON_AddStringToObject(root, "AUTO_SELECT_RESULT", selectedInfo.c_str()); + cJSON_AddStringToObject(root, "AUTO_SELECT_FILTER", filteredReason.c_str()); + cJSON_AddStringToObject(root, "SAVED_NETWORK_IN_SCAN", savedResult.c_str()); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_AUTO_SELECT_STATISTIC", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - + void WriteDhcpInfoHiSysEvent(const IpInfo &ipInfo, const IpV6Info &ipv6Info) { - Json::Value root; - Json::FastWriter writer; - root["IPV4_IPADDRESS"] = Ipv4IntAnonymize(ipInfo.ipAddress); - root["IPV4_GATEWAY"] = Ipv4IntAnonymize(ipInfo.gateway); - root["IPV4_NETMASK"] = Ipv4IntAnonymize(ipInfo.netmask); - root["IPV4_PRIMARYDNS"] = Ipv4IntAnonymize(ipInfo.primaryDns); - root["IPV4_SECONDDNS"] = Ipv4IntAnonymize(ipInfo.secondDns); - root["IPV4_SERVERIP"] = Ipv4IntAnonymize(ipInfo.serverIp); - root["IPV4_LEASE"] = ipInfo.leaseDuration; - root["IPV4_DNS_VEC_SIZE"] = static_cast(ipInfo.dnsAddr.size()); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddStringToObject(root, "IPV4_IPADDRESS", Ipv4IntAnonymize(ipInfo.ipAddress).c_str()); + cJSON_AddStringToObject(root, "IPV4_GATEWAY", Ipv4IntAnonymize(ipInfo.gateway).c_str()); + cJSON_AddStringToObject(root, "IPV4_NETMASK", Ipv4IntAnonymize(ipInfo.netmask).c_str()); + cJSON_AddStringToObject(root, "IPV4_PRIMARYDNS", Ipv4IntAnonymize(ipInfo.primaryDns).c_str()); + cJSON_AddStringToObject(root, "IPV4_SECONDDNS", Ipv4IntAnonymize(ipInfo.secondDns).c_str()); + cJSON_AddStringToObject(root, "IPV4_SERVERIP", Ipv4IntAnonymize(ipInfo.serverIp).c_str()); + cJSON_AddNumberToObject(root, "IPV4_LEASE", ipInfo.leaseDuration); + cJSON_AddNumberToObject(root, "IPV4_DNS_VEC_SIZE", static_cast(ipInfo.dnsAddr.size())); for (size_t i = 0; i < ipInfo.dnsAddr.size(); i++) { if (i >= MAX_DNS_NUM) { WIFI_LOGE("ipInfo.dnsAddr size over limit"); break; } std::string keyString = "IPV4_DNS" + std::to_string(i); - root[keyString] = Ipv4IntAnonymize(ipInfo.dnsAddr[i]); - } - root["IPV6_LINKIPV6ADDR"] = Ipv6Anonymize(ipv6Info.linkIpV6Address); - root["IPV6_GLOBALIPV6ADDR"] = Ipv6Anonymize(ipv6Info.globalIpV6Address); - root["IPV6_RANDGLOBALIPV6ADDR"] = Ipv6Anonymize(ipv6Info.randGlobalIpV6Address); - root["IPV6_GATEWAY"] = Ipv6Anonymize(ipv6Info.gateway); - root["IPV6_NETMASK"] = Ipv6Anonymize(ipv6Info.netmask); - root["IPV6_PRIMARYDNS"] = Ipv6Anonymize(ipv6Info.primaryDns); - root["IPV6_SECONDDNS"] = Ipv6Anonymize(ipv6Info.secondDns); - root["IPV6_UNIQUELOCALADDR1"] = Ipv6Anonymize(ipv6Info.uniqueLocalAddress1); - root["IPV6_UNIQUELOCALADDR2"] = Ipv6Anonymize(ipv6Info.uniqueLocalAddress2); - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_DHCP_INFO", "EVENT_VALUE", writer.write(root)); + cJSON_AddStringToObject(root, keyString.c_str(), Ipv4IntAnonymize(ipInfo.dnsAddr[i]).c_str()); + } + cJSON_AddStringToObject(root, "IPV6_LINKIPV6ADDR", Ipv6Anonymize(ipv6Info.linkIpV6Address).c_str()); + cJSON_AddStringToObject(root, "IPV6_GLOBALIPV6ADDR", Ipv6Anonymize(ipv6Info.globalIpV6Address).c_str()); + cJSON_AddStringToObject(root, "IPV6_RANDGLOBALIPV6ADDR", Ipv6Anonymize(ipv6Info.randGlobalIpV6Address).c_str()); + cJSON_AddStringToObject(root, "IPV6_GATEWAY", Ipv6Anonymize(ipv6Info.gateway).c_str()); + cJSON_AddStringToObject(root, "IPV6_NETMASK", Ipv6Anonymize(ipv6Info.netmask).c_str()); + cJSON_AddStringToObject(root, "IPV6_PRIMARYDNS", Ipv6Anonymize(ipv6Info.primaryDns).c_str()); + cJSON_AddStringToObject(root, "IPV6_SECONDDNS", Ipv6Anonymize(ipv6Info.secondDns).c_str()); + cJSON_AddStringToObject(root, "IPV6_UNIQUELOCALADDR1", Ipv6Anonymize(ipv6Info.uniqueLocalAddress1).c_str()); + cJSON_AddStringToObject(root, "IPV6_UNIQUELOCALADDR2", Ipv6Anonymize(ipv6Info.uniqueLocalAddress2).c_str()); + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_DHCP_INFO", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } - + void WriteIodHiSysEvent(const IodStatisticInfo &iodStatisticInfo) { - Json::Value root; - Json::FastWriter writer; - root["OUTDOORFILTERCNT"] = iodStatisticInfo.outdoorFilterCnt; - root["OUTDOORSELECTWIFICNT"] = iodStatisticInfo.outdoorAutoSelectCnt; - root["INTOOUTDOORCNT"] = iodStatisticInfo.in2OutCnt; - root["OUTTOINDOORCNT"] = iodStatisticInfo.out2InCnt; - WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_IOD_STATISTIC", "EVENT_VALUE", writer.write(root)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + WIFI_LOGE("Failed to create cJSON object"); + return; + } + cJSON_AddNumberToObject(root, "OUTDOORFILTERCNT", iodStatisticInfo.outdoorFilterCnt); + cJSON_AddNumberToObject(root, "OUTDOORSELECTWIFICNT", iodStatisticInfo.outdoorAutoSelectCnt); + cJSON_AddNumberToObject(root, "INTOOUTDOORCNT", iodStatisticInfo.in2OutCnt); + cJSON_AddNumberToObject(root, "OUTTOINDOORCNT", iodStatisticInfo.out2InCnt); + + char *jsonStr = cJSON_PrintUnformatted(root); + if (jsonStr == nullptr) { + cJSON_Delete(root); + return; + } + WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_IOD_STATISTIC", "EVENT_VALUE", std::string(jsonStr)); + free(jsonStr); + cJSON_Delete(root); } } // namespace Wifi } // namespace OHOS \ No newline at end of file -- Gitee From ad3586ddf551b2a853e42aab060c0e2aa2d0f661 Mon Sep 17 00:00:00 2001 From: shihaojie Date: Thu, 17 Jul 2025 10:02:57 +0000 Subject: [PATCH 03/13] zly Signed-off-by: shihaojie --- .../wifi_toolkit/utils/wifi_global_func.cpp | 40 +++++++++++-------- 1 file changed, 23 insertions(+), 17 deletions(-) diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/utils/wifi_global_func.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/utils/wifi_global_func.cpp index b83dc46e8..7a95f3716 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/utils/wifi_global_func.cpp +++ b/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/utils/wifi_global_func.cpp @@ -613,22 +613,28 @@ bool IsSignalSmoothingEnable() } #ifndef OHOS_ARCH_LITE -bool ParseJsonKey(const Json::Value &jsonValue, const std::string &key, std::string &value) -{ - if (jsonValue.isArray()) { - int nSize = static_cast(jsonValue.size()); - for (int i = 0; i < nSize; i++) { - if (!jsonValue[i].isMember(key)) { - LOGW("ParseJsonKey JSON[%{public}d] has no member %{public}s.", nSize, key.c_str()); - return false; - } - if (jsonValue[i][key].isString()) { - value = jsonValue[i][key].asString(); - return true; - } else if (jsonValue[i][key].isInt()) { - value = std::to_string(jsonValue[i][key].asInt()); - return true; - } +bool ParseJsonKey(const cJSON *jsonValue, const std::string &key, std::string &value) +{ + if (!cJSON_IsArray(jsonValue)) { + return false; + } + int nSize = cJSON_GetArraySize(jsonValue); + for (int i = 0; i < nSize; ++i) { + cJSON *item = cJSON_GetArrayItem(jsonValue, i); + if (item == nullptr || !cJSON_IsObject(item)) { + return false; + } + cJSON *keyItem = cJSON_GetObjectItem(item, key.c_str()); + if (keyItem == nullptr) { + return false; + } + if (cJSON_IsString(keyItem) && keyItem->valuestring != nullptr) { + value = keyItem->valuestring; + return true; + } else if (cJSON_IsNumber(keyItem)) { + value = std::to_string(keyItem->valueint); + return true; + } else { return false; } } @@ -652,7 +658,7 @@ bool ParseJson(const std::string &jsonString, const std::string &type, const std if (item == nullptr || !cJSON_IsObject(item)) { continue; } - cJSON *typeItem = cJSON_GetObjectItem(item, type.c_str()); // 比如 "data" + cJSON *typeItem = cJSON_GetObjectItem(item, type.c_str()); if (typeItem == nullptr) { continue; } -- Gitee From aca11685685f5ccf02e43d587ffdb0535daa3233 Mon Sep 17 00:00:00 2001 From: shihaojie Date: Thu, 17 Jul 2025 11:25:20 +0000 Subject: [PATCH 04/13] zly Signed-off-by: shihaojie --- .../wifi_security_detect/wifi_security_detect.cpp | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_security_detect/wifi_security_detect.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_security_detect/wifi_security_detect.cpp index 35d1e5599..c6d6d2c1b 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_security_detect/wifi_security_detect.cpp +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_security_detect/wifi_security_detect.cpp @@ -261,12 +261,7 @@ ErrCode WifiSecurityDetect::SecurityModelJsonResult(SecurityModelResult model, b } cJSON_Delete(root); - if (root["result"].isString()) { - SecurityResult = root["result"].asString(); - } else { - WIFI_LOGE("The result is not string"); - return WIFI_OPT_FAILED; - } + if (CheckDataLegal(SecurityResult) == 0) { WIFI_LOGI("SG wifi result is secure"); result = true; -- Gitee From 1b70b85b50da00e2fbe03c40bb8834c16aedfd71 Mon Sep 17 00:00:00 2001 From: shihaojie Date: Thu, 17 Jul 2025 11:39:57 +0000 Subject: [PATCH 05/13] zly Signed-off-by: shihaojie --- wifi/base/shared_util/wifi_notification_util.cpp | 1 - .../wifi_manage/wifi_security_detect/wifi_security_detect.cpp | 2 -- .../wifi_framework/wifi_toolkit/utils/wifi_global_func.cpp | 2 +- 3 files changed, 1 insertion(+), 4 deletions(-) diff --git a/wifi/base/shared_util/wifi_notification_util.cpp b/wifi/base/shared_util/wifi_notification_util.cpp index 5da7d935e..cb0491d5c 100644 --- a/wifi/base/shared_util/wifi_notification_util.cpp +++ b/wifi/base/shared_util/wifi_notification_util.cpp @@ -176,7 +176,6 @@ void WifiNotificationUtil::ShowDialog(WifiDialogType type, std::string comInfo) break; default: break; - } char *cjsonStr = cJSON_PrintUnformatted(param); if (cjsonStr == nullptr) { diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_security_detect/wifi_security_detect.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_security_detect/wifi_security_detect.cpp index c6d6d2c1b..28d8153ca 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_security_detect/wifi_security_detect.cpp +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_security_detect/wifi_security_detect.cpp @@ -239,8 +239,6 @@ ErrCode WifiSecurityDetect::SecurityModelJsonResult(SecurityModelResult model, b { cJSON *root = cJSON_Parse(model.result.c_str()); if (root == nullptr) { - - WIFI_LOGE("model.result is null"); return WIFI_OPT_FAILED; } diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/utils/wifi_global_func.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/utils/wifi_global_func.cpp index 7a95f3716..a00adb34c 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/utils/wifi_global_func.cpp +++ b/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/utils/wifi_global_func.cpp @@ -658,7 +658,7 @@ bool ParseJson(const std::string &jsonString, const std::string &type, const std if (item == nullptr || !cJSON_IsObject(item)) { continue; } - cJSON *typeItem = cJSON_GetObjectItem(item, type.c_str()); + cJSON *typeItem = cJSON_GetObjectItem(item, type.c_str()); if (typeItem == nullptr) { continue; } -- Gitee From 4b76ba9d34913552ed57e7ddb5eb8c6a1772f65c Mon Sep 17 00:00:00 2001 From: shihaojie Date: Thu, 17 Jul 2025 12:14:06 +0000 Subject: [PATCH 06/13] zly Signed-off-by: shihaojie --- wifi/test/fuzztest/wifi_sta/wifitoolkit_fuzzer/BUILD.gn | 1 + 1 file changed, 1 insertion(+) diff --git a/wifi/test/fuzztest/wifi_sta/wifitoolkit_fuzzer/BUILD.gn b/wifi/test/fuzztest/wifi_sta/wifitoolkit_fuzzer/BUILD.gn index a332cd4d4..9497a1eee 100644 --- a/wifi/test/fuzztest/wifi_sta/wifitoolkit_fuzzer/BUILD.gn +++ b/wifi/test/fuzztest/wifi_sta/wifitoolkit_fuzzer/BUILD.gn @@ -77,6 +77,7 @@ ohos_fuzztest("WifiToolkitFuzzTest") { external_deps = [ "c_utils:utils", + "cJSON:cjson", "dhcp:dhcp_sdk", "dhcp:dhcp_utils", "hilog:libhilog", -- Gitee From fa4a299ba20789eddbe2870f1da009a69b76cc71 Mon Sep 17 00:00:00 2001 From: shihaojie Date: Sun, 20 Jul 2025 13:04:58 +0000 Subject: [PATCH 07/13] 1 Signed-off-by: shihaojie --- wifi/base/BUILD.gn | 1 - wifi/services/wifi_standard/wifi_framework/wifi_manage/BUILD.gn | 1 - .../wifi_standard/wifi_framework/wifi_manage/wifi_pro/BUILD.gn | 1 - 3 files changed, 3 deletions(-) diff --git a/wifi/base/BUILD.gn b/wifi/base/BUILD.gn index d4e80983a..c062a0a23 100644 --- a/wifi/base/BUILD.gn +++ b/wifi/base/BUILD.gn @@ -122,7 +122,6 @@ if (defined(ohos_lite)) { "hicollie:libhicollie", "hilog:libhilog", "ipc:ipc_single", - "jsoncpp:jsoncpp", "libxml2:libxml2", "openssl:libcrypto_shared", "openssl:libssl_shared", diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/BUILD.gn b/wifi/services/wifi_standard/wifi_framework/wifi_manage/BUILD.gn index a6fbc486d..a241244da 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/BUILD.gn +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/BUILD.gn @@ -602,7 +602,6 @@ if (defined(ohos_lite)) { "samgr:samgr_proxy", "time_service:time_client", "window_manager:libdm_lite", - "jsoncpp:jsoncpp", ] if (wifi_feature_with_encryption || wifi_feature_with_local_random_mac) { diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/BUILD.gn b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/BUILD.gn index ff5670516..166e4aed5 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/BUILD.gn +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/BUILD.gn @@ -106,7 +106,6 @@ ohos_static_library("wifi_pro") { "hilog:libhilog", "hisysevent:libhisysevent", "init:libbegetutil", - "jsoncpp:jsoncpp", "netmanager_base:net_conn_manager_if", "netmanager_base:net_stats_manager_if", "netmanager_base:netsys_controller", -- Gitee From b9239cd4cf9c9e354ccd9a33214c6c69acf4b7e7 Mon Sep 17 00:00:00 2001 From: shihaojie Date: Sun, 20 Jul 2025 13:05:37 +0000 Subject: [PATCH 08/13] 1 Signed-off-by: shihaojie --- wifi/services/wifi_standard/wifi_framework/wifi_toolkit/BUILD.gn | 1 - .../wifi_framework/wifi_manage/wifi_sub_manage/BUILD.gn | 1 - 2 files changed, 2 deletions(-) diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/BUILD.gn b/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/BUILD.gn index 373d10954..27fd51abd 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/BUILD.gn +++ b/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/BUILD.gn @@ -167,7 +167,6 @@ if (defined(ohos_lite)) { "hilog:libhilog", "icu:shared_icuuc", "ipc:ipc_single", - "jsoncpp:jsoncpp", "libxml2:libxml2", "samgr:samgr_proxy", "window_manager:libdm_lite", diff --git a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sub_manage/BUILD.gn b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sub_manage/BUILD.gn index 84d806531..29882b99f 100644 --- a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sub_manage/BUILD.gn +++ b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sub_manage/BUILD.gn @@ -168,7 +168,6 @@ ohos_unittest("wifi_sub_manage_unittest") { "hilog:libhilog", "init:libbegetutil", "ipc:ipc_single", - "jsoncpp:jsoncpp", "libxml2:libxml2", "netmanager_base:net_conn_manager_if", "netmanager_base:net_native_manager_if", -- Gitee From 7e3092b118a20918fcff2035b0021aa8527c580d Mon Sep 17 00:00:00 2001 From: shihaojie Date: Sun, 20 Jul 2025 13:05:44 +0000 Subject: [PATCH 09/13] 1 Signed-off-by: shihaojie --- .../wifi_standard/wifi_framework/wifi_toolkit/unittest/BUILD.gn | 1 - wifi/test/wifi_utils/unittest/BUILD.gn | 1 - wifi/utils/BUILD.gn | 1 - 3 files changed, 3 deletions(-) diff --git a/wifi/test/wifi_standard/wifi_framework/wifi_toolkit/unittest/BUILD.gn b/wifi/test/wifi_standard/wifi_framework/wifi_toolkit/unittest/BUILD.gn index 374b00ca2..ef4f9b3b2 100644 --- a/wifi/test/wifi_standard/wifi_framework/wifi_toolkit/unittest/BUILD.gn +++ b/wifi/test/wifi_standard/wifi_framework/wifi_toolkit/unittest/BUILD.gn @@ -134,7 +134,6 @@ ohos_unittest("toolkit_unittest") { "icu:shared_icuuc", "init:libbegetutil", "ipc:ipc_single", - "jsoncpp:jsoncpp", "libxml2:libxml2", "netstack:http_client", "samgr:samgr_proxy", diff --git a/wifi/test/wifi_utils/unittest/BUILD.gn b/wifi/test/wifi_utils/unittest/BUILD.gn index 7aba7aeb2..90e9f54ce 100644 --- a/wifi/test/wifi_utils/unittest/BUILD.gn +++ b/wifi/test/wifi_utils/unittest/BUILD.gn @@ -59,7 +59,6 @@ ohos_unittest("utils_unittest") { "hilog:libhilog", "hisysevent:libhisysevent", "ipc:ipc_single", - "jsoncpp:jsoncpp", "openssl:libcrypto_shared", "openssl:libssl_shared", "samgr:samgr_proxy", diff --git a/wifi/utils/BUILD.gn b/wifi/utils/BUILD.gn index 60d1fb39b..3f019baa1 100644 --- a/wifi/utils/BUILD.gn +++ b/wifi/utils/BUILD.gn @@ -94,7 +94,6 @@ if (defined(ohos_lite)) { "hilog:libhilog", "hisysevent:libhisysevent", "ipc:ipc_single", - "jsoncpp:jsoncpp", "openssl:libcrypto_shared", "openssl:libssl_shared", "samgr:samgr_proxy", -- Gitee From 7d07ba0ec868bb286d0ade2ef6627045db61a838 Mon Sep 17 00:00:00 2001 From: shihaojie Date: Sun, 20 Jul 2025 13:05:51 +0000 Subject: [PATCH 10/13] 1 Signed-off-by: shihaojie --- .../wifi_standard/wifi_framework/wifi_manage/wifi_pro/BUILD.gn | 1 - .../wifi_standard/wifi_framework/wifi_manage/wifi_sta/BUILD.gn | 1 - .../wifi_framework/wifi_manage/wifi_sta_ext/BUILD.gn | 1 - 3 files changed, 3 deletions(-) diff --git a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_pro/BUILD.gn b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_pro/BUILD.gn index 2c7634999..90d7fa12f 100644 --- a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_pro/BUILD.gn +++ b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_pro/BUILD.gn @@ -174,7 +174,6 @@ ohos_unittest("wifi_pro_unittest") { "hisysevent:libhisysevent", "init:libbegetutil", "ipc:ipc_single", - "jsoncpp:jsoncpp", "libxml2:libxml2", "netmanager_base:net_conn_manager_if", "netmanager_base:net_native_manager_if", diff --git a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta/BUILD.gn b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta/BUILD.gn index 8eb73d820..74f6ca78d 100644 --- a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta/BUILD.gn +++ b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta/BUILD.gn @@ -174,7 +174,6 @@ local_base_external_deps = [ "hilog:libhilog", "init:libbegetutil", "ipc:ipc_single", - "jsoncpp:jsoncpp", "libxml2:libxml2", "netmanager_base:net_conn_manager_if", "netmanager_base:net_native_manager_if", diff --git a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta_ext/BUILD.gn b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta_ext/BUILD.gn index 634496c75..1e9d987c3 100644 --- a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta_ext/BUILD.gn +++ b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta_ext/BUILD.gn @@ -117,7 +117,6 @@ ohos_unittest("wifi_sta_ext_unittest") { "hilog:libhilog", "init:libbegetutil", "ipc:ipc_single", - "jsoncpp:jsoncpp", "libxml2:libxml2", "netmanager_base:net_conn_manager_if", "netmanager_base:net_native_manager_if", -- Gitee From 7375dfcf4602195482f01f6043d6c57b3f23e773 Mon Sep 17 00:00:00 2001 From: shihaojie Date: Sun, 20 Jul 2025 13:05:57 +0000 Subject: [PATCH 11/13] 1 Signed-off-by: shihaojie --- wifi/test/wifi_standard/non_mock/BUILD.gn | 1 - wifi/test/wifi_standard/precompiled_macro/BUILD.gn | 1 - .../wifi_framework/wifi_manage/idl_client/unittest/BUILD.gn | 1 - .../wifi_standard/wifi_framework/wifi_manage/wifi_ap/BUILD.gn | 1 - 4 files changed, 4 deletions(-) diff --git a/wifi/test/wifi_standard/non_mock/BUILD.gn b/wifi/test/wifi_standard/non_mock/BUILD.gn index f40e7c657..a6c1425f5 100644 --- a/wifi/test/wifi_standard/non_mock/BUILD.gn +++ b/wifi/test/wifi_standard/non_mock/BUILD.gn @@ -82,7 +82,6 @@ ohos_unittest("wifi_non_mock_unittest") { "c_utils:utils", "cJSON:cjson", "hilog:libhilog", - "jsoncpp:jsoncpp", "libxml2:libxml2", "samgr:samgr_proxy", "time_service:time_client", diff --git a/wifi/test/wifi_standard/precompiled_macro/BUILD.gn b/wifi/test/wifi_standard/precompiled_macro/BUILD.gn index 6daa35b01..5f6e02c09 100644 --- a/wifi/test/wifi_standard/precompiled_macro/BUILD.gn +++ b/wifi/test/wifi_standard/precompiled_macro/BUILD.gn @@ -138,7 +138,6 @@ ohos_unittest("precompiled_macro_unittest") { "hilog:libhilog", "init:libbegetutil", "ipc:ipc_single", - "jsoncpp:jsoncpp", "libxml2:libxml2", "netmanager_base:net_conn_manager_if", "netmanager_base:net_native_manager_if", diff --git a/wifi/test/wifi_standard/wifi_framework/wifi_manage/idl_client/unittest/BUILD.gn b/wifi/test/wifi_standard/wifi_framework/wifi_manage/idl_client/unittest/BUILD.gn index 2b9aa642f..6d9d85796 100644 --- a/wifi/test/wifi_standard/wifi_framework/wifi_manage/idl_client/unittest/BUILD.gn +++ b/wifi/test/wifi_standard/wifi_framework/wifi_manage/idl_client/unittest/BUILD.gn @@ -100,7 +100,6 @@ ohos_unittest("idl_client_unittest") { "hdf_core:libhdi", "hdf_core:libpub_utils", "hilog:libhilog", - "jsoncpp:jsoncpp", "samgr:samgr_proxy", ] diff --git a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_ap/BUILD.gn b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_ap/BUILD.gn index 6d6e72abc..942f3d686 100644 --- a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_ap/BUILD.gn +++ b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_ap/BUILD.gn @@ -148,7 +148,6 @@ ohos_unittest("WifiApServiceTest") { "hilog:libhilog", "ipc:ipc_single", "icu:shared_icuuc", - "jsoncpp:jsoncpp", "libxml2:libxml2", "netmanager_base:net_conn_manager_if", "samgr:samgr_proxy", -- Gitee From 474268ebcba35d9b9d5b70e27c172d88e3ade876 Mon Sep 17 00:00:00 2001 From: shihaojie Date: Sun, 20 Jul 2025 13:06:04 +0000 Subject: [PATCH 12/13] 1 Signed-off-by: shihaojie --- wifi/bundle.json | 1 - wifi/test/fuzztest/wifi_sta/enablep2p_fuzzer/BUILD.gn | 1 - wifi/test/fuzztest/wifi_sta/wifiap_fuzzer/BUILD.gn | 1 - wifi/test/fuzztest/wifi_sta/wifitoolkit_fuzzer/BUILD.gn | 1 - 4 files changed, 4 deletions(-) diff --git a/wifi/bundle.json b/wifi/bundle.json index cacf470af..39f34086a 100644 --- a/wifi/bundle.json +++ b/wifi/bundle.json @@ -123,7 +123,6 @@ "power_manager", "time_service", "bounds_checking_function", - "jsoncpp", "libxml2", "asset", "runtime_core", diff --git a/wifi/test/fuzztest/wifi_sta/enablep2p_fuzzer/BUILD.gn b/wifi/test/fuzztest/wifi_sta/enablep2p_fuzzer/BUILD.gn index e5299b0f5..20fd08d40 100644 --- a/wifi/test/fuzztest/wifi_sta/enablep2p_fuzzer/BUILD.gn +++ b/wifi/test/fuzztest/wifi_sta/enablep2p_fuzzer/BUILD.gn @@ -209,7 +209,6 @@ ohos_fuzztest("EnableP2pFuzzTest") { "hilog:libhilog", "init:libbegetutil", "ipc:ipc_single", - "jsoncpp:jsoncpp", "libxml2:libxml2", "netmanager_base:net_conn_manager_if", "netmanager_base:net_native_manager_if", diff --git a/wifi/test/fuzztest/wifi_sta/wifiap_fuzzer/BUILD.gn b/wifi/test/fuzztest/wifi_sta/wifiap_fuzzer/BUILD.gn index 1c13b469c..32e105c73 100644 --- a/wifi/test/fuzztest/wifi_sta/wifiap_fuzzer/BUILD.gn +++ b/wifi/test/fuzztest/wifi_sta/wifiap_fuzzer/BUILD.gn @@ -110,7 +110,6 @@ ohos_fuzztest("WifiApFuzzTest") { "dhcp:dhcp_sdk", "hilog:libhilog", "ipc:ipc_single", - "jsoncpp:jsoncpp", "libxml2:libxml2", "netmanager_base:net_conn_manager_if", "samgr:samgr_proxy", diff --git a/wifi/test/fuzztest/wifi_sta/wifitoolkit_fuzzer/BUILD.gn b/wifi/test/fuzztest/wifi_sta/wifitoolkit_fuzzer/BUILD.gn index 9497a1eee..0480b1385 100644 --- a/wifi/test/fuzztest/wifi_sta/wifitoolkit_fuzzer/BUILD.gn +++ b/wifi/test/fuzztest/wifi_sta/wifitoolkit_fuzzer/BUILD.gn @@ -82,7 +82,6 @@ ohos_fuzztest("WifiToolkitFuzzTest") { "dhcp:dhcp_utils", "hilog:libhilog", "ipc:ipc_single", - "jsoncpp:jsoncpp", "libxml2:libxml2", "netstack:http_client", "samgr:samgr_proxy", -- Gitee From 27674dd25c554125378f4f7303879d5853f4ea6c Mon Sep 17 00:00:00 2001 From: shihaojie Date: Sun, 20 Jul 2025 13:06:08 +0000 Subject: [PATCH 13/13] 1 Signed-off-by: shihaojie --- .../wifi_framework/wifi_manage/wifi_pro/wifi_pro_chr.cpp | 1 - .../wifi_manage/wifi_sta_ext/wifi_security_detect_test.h | 1 - 2 files changed, 2 deletions(-) diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_chr.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_chr.cpp index 99560b186..2d1fb03cc 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_chr.cpp +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_chr.cpp @@ -19,7 +19,6 @@ #include "wifi_settings.h" #include "wifi_hisysevent.h" #include "hisysevent.h" -#include "json/json.h" #include "cJSON.h" namespace OHOS { namespace Wifi { diff --git a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta_ext/wifi_security_detect_test.h b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta_ext/wifi_security_detect_test.h index f6e56f85e..35ab2c767 100644 --- a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta_ext/wifi_security_detect_test.h +++ b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta_ext/wifi_security_detect_test.h @@ -17,7 +17,6 @@ #define OHOS_WIFI_SECURITY_DETECT_TEST_H #include #include "wifi_security_detect.h" -#include "json/json.h" #include "datashare_helper.h" #include "sta_service_callback.h" #include "wifi_event_handler.h" -- Gitee