1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "array_wifi_id_serializer.h"
17 #include "cJSON.h"
18 #include "cjson_check.h"
19 #include "edm_constants.h"
20
21 namespace OHOS {
22 namespace EDM {
23
24 const std::string SSID = "ssid";
25 const std::string BSSID = "bssid";
26
SetUnionPolicyData(std::vector<WifiId> & data,std::vector<WifiId> & currentData)27 std::vector<WifiId> ArrayWifiIdSerializer::SetUnionPolicyData(std::vector<WifiId> &data,
28 std::vector<WifiId> ¤tData)
29 {
30 std::vector<WifiId> mergeData;
31 std::sort(data.begin(), data.end());
32 std::sort(currentData.begin(), currentData.end());
33 std::set_union(data.begin(), data.end(), currentData.begin(), currentData.end(), back_inserter(mergeData));
34 return mergeData;
35 }
36
SetDifferencePolicyData(std::vector<WifiId> & data,std::vector<WifiId> & currentData)37 std::vector<WifiId> ArrayWifiIdSerializer::SetDifferencePolicyData(std::vector<WifiId> &data,
38 std::vector<WifiId> ¤tData)
39 {
40 std::vector<WifiId> mergeData;
41 std::sort(data.begin(), data.end());
42 std::sort(currentData.begin(), currentData.end());
43 std::set_difference(currentData.begin(), currentData.end(), data.begin(), data.end(), back_inserter(mergeData));
44 return mergeData;
45 }
46
Deserialize(const std::string & jsonString,std::vector<WifiId> & dataObj)47 bool ArrayWifiIdSerializer::Deserialize(const std::string &jsonString, std::vector<WifiId> &dataObj)
48 {
49 cJSON* root = cJSON_Parse(jsonString.c_str());
50 if (root == nullptr) {
51 return true;
52 }
53 cJSON* item;
54 cJSON_ArrayForEach(item, root) {
55 cJSON* ssid = cJSON_GetObjectItem(item, SSID.c_str());
56 cJSON* bssid = cJSON_GetObjectItem(item, BSSID.c_str());
57 if (ssid == nullptr || bssid == nullptr) {
58 cJSON_Delete(root);
59 return false;
60 }
61 if (!cJSON_IsString(ssid) || !cJSON_IsString(bssid)) {
62 continue;
63 }
64 WifiId wifiId;
65 wifiId.SetSsid(ssid->valuestring);
66 wifiId.SetBssid(bssid->valuestring);
67 dataObj.push_back(wifiId);
68 }
69 cJSON_Delete(root);
70 return true;
71 }
72
Serialize(const std::vector<WifiId> & dataObj,std::string & jsonString)73 bool ArrayWifiIdSerializer::Serialize(const std::vector<WifiId> &dataObj, std::string &jsonString)
74 {
75 if (dataObj.empty()) {
76 return true;
77 }
78 cJSON* root = nullptr;
79 CJSON_CREATE_ARRAY_AND_CHECK(root, false);
80 for (const auto& wifiId : dataObj) {
81 cJSON* item = nullptr;
82 CJSON_CREATE_OBJECT_AND_CHECK_AND_CLEAR(item, false, root);
83 cJSON_AddStringToObject(item, SSID.c_str(), wifiId.GetSsid().c_str());
84 cJSON_AddStringToObject(item, BSSID.c_str(), wifiId.GetBssid().c_str());
85 if (!cJSON_AddItemToArray(root, item)) {
86 cJSON_Delete(root);
87 cJSON_Delete(item);
88 return false;
89 }
90 }
91 char* jsonStr = cJSON_Print(root);
92 if (jsonStr == nullptr) {
93 cJSON_Delete(root);
94 return false;
95 }
96 jsonString = std::string(jsonStr);
97 cJSON_free(jsonStr);
98 cJSON_Delete(root);
99 return true;
100 }
101
GetPolicy(MessageParcel & data,std::vector<WifiId> & result)102 bool ArrayWifiIdSerializer::GetPolicy(MessageParcel &data, std::vector<WifiId> &result)
103 {
104 uint32_t size = data.ReadUint32();
105 if (size > EdmConstants::WIFI_LIST_MAX_SIZE) {
106 EDMLOGE("ArrayWifiIdSerializer:GetPolicy size=[%{public}u] is too large", size);
107 return false;
108 }
109 for (uint32_t i = 0; i < size; i++) {
110 WifiId wifiId;
111 if (!WifiId::Unmarshalling(data, wifiId)) {
112 EDMLOGE("ArrayWifiIdSerializer::GetPolicy read parcel fail");
113 return false;
114 }
115 result.emplace_back(wifiId);
116 }
117 return true;
118 }
119
WritePolicy(MessageParcel & reply,std::vector<WifiId> & result)120 bool ArrayWifiIdSerializer::WritePolicy(MessageParcel &reply, std::vector<WifiId> &result)
121 {
122 return true;
123 }
124
MergePolicy(std::vector<std::vector<WifiId>> & data,std::vector<WifiId> & result)125 bool ArrayWifiIdSerializer::MergePolicy(std::vector<std::vector<WifiId>> &data,
126 std::vector<WifiId> &result)
127 {
128 std::set<WifiId> stData;
129 for (const auto &dataItem : data) {
130 for (const auto &item : dataItem) {
131 stData.insert(item);
132 }
133 }
134 result.assign(stData.begin(), stData.end());
135 return true;
136 }
137
QueryWifiListPolicy(const std::string & policyData,MessageParcel & reply)138 ErrCode ArrayWifiIdSerializer::QueryWifiListPolicy(const std::string &policyData, MessageParcel &reply)
139 {
140 std::vector<WifiId> wifiIds;
141 if (!Deserialize(policyData, wifiIds)) {
142 EDMLOGE("QueryWifiListPolicy Deserialize error");
143 return EdmReturnErrCode::SYSTEM_ABNORMALLY;
144 }
145 reply.WriteInt32(ERR_OK);
146 reply.WriteUint32(wifiIds.size());
147 for (const auto &wifiId : wifiIds) {
148 if (!wifiId.Marshalling(reply)) {
149 EDMLOGE("QueryWifiListPolicy : write parcel failed!");
150 return EdmReturnErrCode::SYSTEM_ABNORMALLY;
151 }
152 }
153 return ERR_OK;
154 }
155 } // namespace EDM
156 } // namespace OHOS