1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * 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 "clipboard_policy_serializer.h"
17
18 #include "cJSON.h"
19 #include "cjson_check.h"
20 #include "edm_log.h"
21 namespace OHOS {
22 namespace EDM {
23
Deserialize(const std::string & data,std::map<int32_t,ClipboardInfo> & result)24 bool ClipboardSerializer::Deserialize(const std::string &data, std::map<int32_t, ClipboardInfo> &result)
25 {
26 cJSON* root = cJSON_Parse(data.c_str());
27 if (root == nullptr) {
28 return true;
29 }
30 cJSON* item;
31 cJSON_ArrayForEach(item, root) {
32 cJSON* tokenId = cJSON_GetObjectItem(item, TOKEN_ID.c_str());
33 cJSON* userId = cJSON_GetObjectItem(item, USER_ID.c_str());
34 cJSON* bundleName = cJSON_GetObjectItem(item, BUNDLE_NAME.c_str());
35 cJSON* clipboardPolicy = cJSON_GetObjectItem(item, CLIPBOARD_POLICY_STR.c_str());
36 ClipboardInfo info;
37 if (tokenId == nullptr || clipboardPolicy == nullptr) {
38 cJSON_Delete(root);
39 return false;
40 }
41 if (!cJSON_IsNumber(clipboardPolicy) || !cJSON_IsNumber(tokenId)) {
42 continue;
43 }
44 info.policy = ConvertToClipboardPolicy(clipboardPolicy->valueint);
45 if (userId != nullptr) {
46 if (!cJSON_IsNumber(userId)) {
47 continue;
48 }
49 info.userId = userId->valueint;
50 }
51 if (bundleName != nullptr) {
52 if (!cJSON_IsString(bundleName)) {
53 continue;
54 }
55 info.bundleName = bundleName->valuestring;
56 }
57 result.insert(std::make_pair(tokenId->valueint, info));
58 }
59 cJSON_Delete(root);
60 return true;
61 }
62
Serialize(const std::map<int32_t,ClipboardInfo> & result,std::string & data)63 bool ClipboardSerializer::Serialize(const std::map<int32_t, ClipboardInfo> &result, std::string &data)
64 {
65 if (result.empty()) {
66 return true;
67 }
68 cJSON* root = nullptr;
69 CJSON_CREATE_ARRAY_AND_CHECK(root, false);
70 for (auto& it : result) {
71 cJSON* item = nullptr;
72 CJSON_CREATE_OBJECT_AND_CHECK_AND_CLEAR(item, false, root);
73 cJSON_AddNumberToObject(item, TOKEN_ID.c_str(), it.first);
74 cJSON_AddNumberToObject(item, USER_ID.c_str(), it.second.userId);
75 cJSON_AddStringToObject(item, BUNDLE_NAME.c_str(), it.second.bundleName.c_str());
76 cJSON_AddNumberToObject(item, CLIPBOARD_POLICY_STR.c_str(), static_cast<int32_t>(it.second.policy));
77 if (!cJSON_AddItemToArray(root, item)) {
78 cJSON_Delete(root);
79 cJSON_Delete(item);
80 return false;
81 }
82 }
83 char* jsonStr = cJSON_Print(root);
84 if (jsonStr == nullptr) {
85 cJSON_Delete(root);
86 return false;
87 }
88 data = std::string(jsonStr);
89 cJSON_free(jsonStr);
90 cJSON_Delete(root);
91 return true;
92 }
93
GetPolicy(MessageParcel & data,std::map<int32_t,ClipboardInfo> & result)94 bool ClipboardSerializer::GetPolicy(MessageParcel &data, std::map<int32_t, ClipboardInfo> &result)
95 {
96 ClipboardInfo info;
97 int32_t tokenId = 0;
98 int32_t flag = data.ReadInt32();
99 if (flag == ClipboardFunctionType::SET_HAS_TOKEN_ID) {
100 tokenId = data.ReadInt32();
101 info.policy = ConvertToClipboardPolicy(data.ReadInt32());
102 }
103 if (flag == ClipboardFunctionType::SET_HAS_BUNDLE_NAME) {
104 info.bundleName = data.ReadString();
105 info.userId = data.ReadInt32();
106 info.policy = ConvertToClipboardPolicy(data.ReadInt32());
107 }
108 result.insert(std::make_pair(tokenId, info));
109 return true;
110 }
111
WritePolicy(MessageParcel & reply,std::map<int32_t,ClipboardInfo> & result)112 bool ClipboardSerializer::WritePolicy(MessageParcel &reply, std::map<int32_t, ClipboardInfo> &result)
113 {
114 return true;
115 }
116
MergePolicy(std::vector<std::map<int32_t,ClipboardInfo>> & data,std::map<int32_t,ClipboardInfo> & result)117 bool ClipboardSerializer::MergePolicy(std::vector<std::map<int32_t, ClipboardInfo>> &data,
118 std::map<int32_t, ClipboardInfo> &result)
119 {
120 for (auto policyMap : data) {
121 for (auto iter : policyMap) {
122 if (iter.second.policy == ClipboardPolicy::DEFAULT) {
123 return false;
124 }
125 if (result.find(iter.first) == result.end() ||
126 static_cast<int32_t>(iter.second.policy) < static_cast<int32_t>(result[iter.first].policy)) {
127 result[iter.first] = iter.second;
128 }
129 }
130 }
131 return true;
132 }
133
ConvertToClipboardPolicy(int32_t policy)134 ClipboardPolicy ClipboardSerializer::ConvertToClipboardPolicy(int32_t policy)
135 {
136 switch (policy) {
137 case static_cast<int32_t>(ClipboardPolicy::DEFAULT):
138 return ClipboardPolicy::DEFAULT;
139 case static_cast<int32_t>(ClipboardPolicy::IN_APP):
140 return ClipboardPolicy::IN_APP;
141 case static_cast<int32_t>(ClipboardPolicy::LOCAL_DEVICE):
142 return ClipboardPolicy::LOCAL_DEVICE;
143 case static_cast<int32_t>(ClipboardPolicy::CROSS_DEVICE):
144 return ClipboardPolicy::CROSS_DEVICE;
145 default:
146 return ClipboardPolicy::UNKNOWN;
147 }
148 }
149 } // namespace EDM
150 } // namespace OHOS