1 /*
2 * Copyright (c) 2023 Shenzhen Kaihong Digital Industry Development 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 "scene_format.h"
17 #include "common/common_macro.h"
18 #include "common/sharing_log.h"
19
20 namespace OHOS {
21 namespace Sharing {
22
PutBoolValue(const std::string_view &key, bool value)23 bool SceneFormat::PutBoolValue(const std::string_view &key, bool value)
24 {
25 SHARING_LOGD("trace.");
26 FormatData data;
27 data.type = FORMAT_TYPE_BOOL;
28 data.val.boolVal = value;
29 auto ret = formatMap_.insert(std::make_pair(key, data));
30
31 return ret.second;
32 }
33
PutUint16Value(const std::string_view &key, uint16_t value)34 bool SceneFormat::PutUint16Value(const std::string_view &key, uint16_t value)
35 {
36 SHARING_LOGD("trace.");
37 FormatData data;
38 data.type = FORMAT_TYPE_UINT16;
39 data.val.uint16Val = value;
40 auto ret = formatMap_.insert(std::make_pair(key, data));
41
42 return ret.second;
43 }
44
PutIntValue(const std::string_view &key, int32_t value)45 bool SceneFormat::PutIntValue(const std::string_view &key, int32_t value)
46 {
47 SHARING_LOGD("trace.");
48 FormatData data;
49 data.type = FORMAT_TYPE_INT32;
50 data.val.int32Val = value;
51 auto ret = formatMap_.insert(std::make_pair(key, data));
52
53 return ret.second;
54 }
55
PutUint32Value(const std::string_view &key, uint32_t value)56 bool SceneFormat::PutUint32Value(const std::string_view &key, uint32_t value)
57 {
58 SHARING_LOGD("trace.");
59 FormatData data;
60 data.type = FORMAT_TYPE_UINT32;
61 data.val.uint32Val = value;
62 auto ret = formatMap_.insert(std::make_pair(key, data));
63
64 return ret.second;
65 }
66
PutInt64Value(const std::string_view &key, int64_t value)67 bool SceneFormat::PutInt64Value(const std::string_view &key, int64_t value)
68 {
69 SHARING_LOGD("trace.");
70 FormatData data;
71 data.type = FORMAT_TYPE_INT64;
72 data.val.int64Val = value;
73 auto ret = formatMap_.insert(std::make_pair(key, data));
74
75 return ret.second;
76 }
77
PutUint64Value(const std::string_view &key, uint64_t value)78 bool SceneFormat::PutUint64Value(const std::string_view &key, uint64_t value)
79 {
80 SHARING_LOGD("trace.");
81 FormatData data;
82 data.type = FORMAT_TYPE_UINT64;
83 data.val.uint64Val = value;
84 auto ret = formatMap_.insert(std::make_pair(key, data));
85
86 return ret.second;
87 }
88
PutFloatValue(const std::string_view &key, float value)89 bool SceneFormat::PutFloatValue(const std::string_view &key, float value)
90 {
91 SHARING_LOGD("trace.");
92 FormatData data;
93 data.type = FORMAT_TYPE_FLOAT;
94 data.val.floatVal = value;
95 auto ret = formatMap_.insert(std::make_pair(key, data));
96
97 return ret.second;
98 }
99
PutDoubleValue(const std::string_view &key, double value)100 bool SceneFormat::PutDoubleValue(const std::string_view &key, double value)
101 {
102 SHARING_LOGD("trace.");
103 FormatData data;
104 data.type = FORMAT_TYPE_DOUBLE;
105 data.val.doubleVal = value;
106 auto ret = formatMap_.insert(std::make_pair(key, data));
107
108 return ret.second;
109 }
110
PutStringValue(const std::string_view &key, const std::string_view &value)111 bool SceneFormat::PutStringValue(const std::string_view &key, const std::string_view &value)
112 {
113 SHARING_LOGD("trace.");
114 FormatData data;
115 data.type = FORMAT_TYPE_STRING;
116 data.stringVal = value;
117 auto ret = formatMap_.insert(std::make_pair(key, data));
118
119 return ret.second;
120 }
121
PutObjectValue(const std::string_view &key, sptr<IRemoteObject> value)122 bool SceneFormat::PutObjectValue(const std::string_view &key, sptr<IRemoteObject> value)
123 {
124 SHARING_LOGD("trace.");
125 FormatData data;
126 data.type = FORMAT_TYPE_OBJECT;
127 data.objectVal = value;
128 auto ret = formatMap_.insert(std::make_pair(key, data));
129
130 return ret.second;
131 }
132
GetBoolValue(const std::string_view &key, bool &value) const133 bool SceneFormat::GetBoolValue(const std::string_view &key, bool &value) const
134 {
135 SHARING_LOGD("trace.");
136 auto iter = formatMap_.find(key);
137 if (iter == formatMap_.end() || iter->second.type != FORMAT_TYPE_BOOL) {
138 SHARING_LOGE("GetFormat failed. Key: %{public}s.", key.data());
139 return false;
140 }
141
142 value = iter->second.val.boolVal;
143
144 return true;
145 }
146
GetUint16Value(const std::string_view &key, uint16_t &value) const147 bool SceneFormat::GetUint16Value(const std::string_view &key, uint16_t &value) const
148 {
149 SHARING_LOGD("trace.");
150 auto iter = formatMap_.find(key);
151 if (iter == formatMap_.end() || iter->second.type != FORMAT_TYPE_UINT16) {
152 SHARING_LOGE("GetFormat failed. Key: %{public}s.", key.data());
153 return false;
154 }
155
156 value = iter->second.val.uint16Val;
157 return true;
158 }
159
GetIntValue(const std::string_view &key, int32_t &value) const160 bool SceneFormat::GetIntValue(const std::string_view &key, int32_t &value) const
161 {
162 SHARING_LOGD("trace.");
163 auto iter = formatMap_.find(key);
164 if (iter == formatMap_.end() || iter->second.type != FORMAT_TYPE_INT32) {
165 SHARING_LOGE("GetFormat failed. Key: %{public}s.", key.data());
166 return false;
167 }
168
169 value = iter->second.val.int32Val;
170 return true;
171 }
172
GetUint32Value(const std::string_view &key, uint32_t &value) const173 bool SceneFormat::GetUint32Value(const std::string_view &key, uint32_t &value) const
174 {
175 SHARING_LOGD("trace.");
176 auto iter = formatMap_.find(key);
177 if (iter == formatMap_.end() || iter->second.type != FORMAT_TYPE_UINT32) {
178 SHARING_LOGE("GetFormat failed. Key: %{public}s.", key.data());
179 return false;
180 }
181
182 value = iter->second.val.uint32Val;
183 return true;
184 }
185
GetInt64Value(const std::string_view &key, int64_t &value) const186 bool SceneFormat::GetInt64Value(const std::string_view &key, int64_t &value) const
187 {
188 SHARING_LOGD("trace.");
189 auto iter = formatMap_.find(key);
190 if (iter == formatMap_.end() || iter->second.type != FORMAT_TYPE_INT64) {
191 SHARING_LOGE("GetFormat failed. Key: %{public}s.", key.data());
192 return false;
193 }
194
195 value = iter->second.val.int64Val;
196 return true;
197 }
198
GetUint64Value(const std::string_view &key, uint64_t &value) const199 bool SceneFormat::GetUint64Value(const std::string_view &key, uint64_t &value) const
200 {
201 SHARING_LOGD("trace.");
202 auto iter = formatMap_.find(key);
203 if (iter == formatMap_.end() || iter->second.type != FORMAT_TYPE_UINT64) {
204 SHARING_LOGE("GetFormat failed. Key: %{public}s.", key.data());
205 return false;
206 }
207
208 value = iter->second.val.uint64Val;
209 return true;
210 }
211
GetFloatValue(const std::string_view &key, float &value) const212 bool SceneFormat::GetFloatValue(const std::string_view &key, float &value) const
213 {
214 SHARING_LOGD("trace.");
215 auto iter = formatMap_.find(key);
216 if (iter == formatMap_.end() || iter->second.type != FORMAT_TYPE_FLOAT) {
217 SHARING_LOGE("GetFormat failed. Key: %{public}s.", key.data());
218 return false;
219 }
220
221 value = iter->second.val.floatVal;
222 return true;
223 }
224
GetDoubleValue(const std::string_view &key, double &value) const225 bool SceneFormat::GetDoubleValue(const std::string_view &key, double &value) const
226 {
227 SHARING_LOGD("trace.");
228 auto iter = formatMap_.find(key);
229 if (iter == formatMap_.end() || iter->second.type != FORMAT_TYPE_DOUBLE) {
230 SHARING_LOGE("GetFormat failed. Key: %{public}s.", key.data());
231 return false;
232 }
233
234 value = iter->second.val.doubleVal;
235 return true;
236 }
237
GetStringValue(const std::string_view &key, std::string &value) const238 bool SceneFormat::GetStringValue(const std::string_view &key, std::string &value) const
239 {
240 SHARING_LOGD("trace.");
241 auto iter = formatMap_.find(key);
242 if (iter == formatMap_.end() || iter->second.type != FORMAT_TYPE_STRING) {
243 SHARING_LOGE("GetFormat failed. Key: %{public}s.", key.data());
244 return false;
245 }
246
247 value = iter->second.stringVal;
248 return true;
249 }
250
GetObjectValue(const std::string_view &key, sptr<IRemoteObject> &value) const251 bool SceneFormat::GetObjectValue(const std::string_view &key, sptr<IRemoteObject> &value) const
252 {
253 SHARING_LOGD("trace.");
254 auto iter = formatMap_.find(key);
255 if (iter == formatMap_.end() || iter->second.type != FORMAT_TYPE_OBJECT) {
256 SHARING_LOGE("GetFormat failed. Key: %{public}s.", key.data());
257 return false;
258 }
259
260 value = iter->second.objectVal;
261 return true;
262 }
263
Marshalling(MessageParcel &parcel, const SceneFormat &format)264 bool SceneFormatParcel::Marshalling(MessageParcel &parcel, const SceneFormat &format)
265 {
266 SHARING_LOGD("trace.");
267 auto dataMap = format.GetFormatMap();
268 (void)parcel.WriteUint32(dataMap.size());
269
270 for (auto it = dataMap.begin(); it != dataMap.end(); ++it) {
271 (void)parcel.WriteString(it->first);
272 (void)parcel.WriteUint32(it->second.type);
273 switch (it->second.type) {
274 case FORMAT_TYPE_UINT16:
275 (void)parcel.WriteUint16(it->second.val.uint16Val);
276 break;
277 case FORMAT_TYPE_BOOL:
278 (void)parcel.WriteBool(it->second.val.boolVal);
279 break;
280 case FORMAT_TYPE_INT32:
281 (void)parcel.WriteInt32(it->second.val.int32Val);
282 break;
283 case FORMAT_TYPE_UINT32:
284 (void)parcel.WriteUint32(it->second.val.uint32Val);
285 break;
286 case FORMAT_TYPE_INT64:
287 (void)parcel.WriteInt64(it->second.val.int64Val);
288 break;
289 case FORMAT_TYPE_UINT64:
290 (void)parcel.WriteInt64(it->second.val.uint64Val);
291 break;
292 case FORMAT_TYPE_FLOAT:
293 (void)parcel.WriteFloat(it->second.val.floatVal);
294 break;
295 case FORMAT_TYPE_DOUBLE:
296 (void)parcel.WriteDouble(it->second.val.doubleVal);
297 break;
298 case FORMAT_TYPE_STRING:
299 (void)parcel.WriteString(it->second.stringVal);
300 break;
301 case FORMAT_TYPE_OBJECT:
302 (void)parcel.WriteRemoteObject(it->second.objectVal);
303 break;
304 default:
305 SHARING_LOGE("fail to Marshalling Key: %{public}s.", it->first.c_str());
306 return false;
307 }
308 SHARING_LOGD("success to Marshalling Key: %{public}s.", it->first.c_str());
309 }
310
311 return true;
312 }
313
Unmarshalling(MessageParcel &parcel, SceneFormat &format)314 bool SceneFormatParcel::Unmarshalling(MessageParcel &parcel, SceneFormat &format)
315 {
316 SHARING_LOGD("trace.");
317 uint32_t size = parcel.ReadUint32();
318 for (uint32_t index = 0; index < size; index++) {
319 std::string key = parcel.ReadString();
320 uint32_t valType = parcel.ReadUint32();
321 switch (valType) {
322 case FORMAT_TYPE_UINT16:
323 (void)format.PutUint16Value(key, parcel.ReadUint16());
324 break;
325 case FORMAT_TYPE_BOOL:
326 (void)format.PutBoolValue(key, parcel.ReadBool());
327 break;
328 case FORMAT_TYPE_INT32:
329 (void)format.PutIntValue(key, parcel.ReadInt32());
330 break;
331 case FORMAT_TYPE_UINT32:
332 (void)format.PutUint32Value(key, parcel.ReadUint32());
333 break;
334 case FORMAT_TYPE_INT64:
335 (void)format.PutInt64Value(key, parcel.ReadInt64());
336 break;
337 case FORMAT_TYPE_UINT64:
338 (void)format.PutUint64Value(key, parcel.ReadUint64());
339 break;
340 case FORMAT_TYPE_FLOAT:
341 (void)format.PutFloatValue(key, parcel.ReadFloat());
342 break;
343 case FORMAT_TYPE_DOUBLE:
344 (void)format.PutDoubleValue(key, parcel.ReadDouble());
345 break;
346 case FORMAT_TYPE_STRING:
347 (void)format.PutStringValue(key, parcel.ReadString());
348 break;
349 case FORMAT_TYPE_OBJECT:
350 (void)format.PutObjectValue(key, parcel.ReadRemoteObject());
351 break;
352 default:
353 SHARING_LOGE("fail to Unmarshalling Key: %{public}s.", key.c_str());
354 return false;
355 }
356 SHARING_LOGD("success to Unmarshalling Key: %{public}s.", key.c_str());
357 }
358
359 return true;
360 }
361
362 } // namespace Sharing
363 } // namespace OHOS
364