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 "ipc_model_codec.h"
17 #include "dm_constants.h"
18 #include "dm_log.h"
19 #include "securec.h"
20
21 namespace OHOS {
22 namespace DistributedHardware {
23 namespace {
24 constexpr const char* UK_SEPARATOR = "#";
25 constexpr int32_t MAX_ICON_SIZE = 4 * 1024 * 1024;
26 constexpr uint32_t IPC_VECTOR_MAX_SIZE = 1000;
27 }
28
29 #define READ_HELPER_RET(parcel, type, out, failRet) \
30 do { \
31 bool ret = (parcel).Read##type((out)); \
32 if (!ret) { \
33 LOGE("read value failed!"); \
34 return failRet; \
35 } \
36 } while (0)
37
38 #define CHECK_CPY_SIZE_RETURN(destSize, srcSize) \
39 do { \
40 if ((destSize) <= (srcSize)) { \
41 LOGE("params size invalid"); \
42 return; \
43 } \
44 } while (0)
45
46 //LCOV_EXCL_START
DecodeDmDeviceBasicInfo(MessageParcel & parcel,DmDeviceBasicInfo & devInfo)47 void IpcModelCodec::DecodeDmDeviceBasicInfo(MessageParcel &parcel, DmDeviceBasicInfo &devInfo)
48 {
49 std::string deviceIdStr = parcel.ReadString();
50 CHECK_CPY_SIZE_RETURN(DM_MAX_DEVICE_ID_LEN, deviceIdStr.size());
51 if (strcpy_s(devInfo.deviceId, deviceIdStr.size() + 1, deviceIdStr.c_str()) != DM_OK) {
52 LOGE("strcpy_s deviceId failed!");
53 return;
54 }
55 std::string deviceNameStr = parcel.ReadString();
56 CHECK_CPY_SIZE_RETURN(DM_MAX_DEVICE_NAME_LEN, deviceNameStr.size());
57 if (strcpy_s(devInfo.deviceName, deviceNameStr.size() + 1, deviceNameStr.c_str()) != DM_OK) {
58 LOGE("strcpy_s deviceName failed!");
59 return;
60 }
61 devInfo.deviceTypeId = parcel.ReadUint16();
62 std::string networkIdStr = parcel.ReadString();
63 CHECK_CPY_SIZE_RETURN(DM_MAX_DEVICE_ID_LEN, networkIdStr.size());
64 if (strcpy_s(devInfo.networkId, networkIdStr.size() + 1, networkIdStr.c_str()) != DM_OK) {
65 LOGE("strcpy_s networkId failed!");
66 return;
67 }
68 devInfo.extraData = parcel.ReadString();
69 }
70
EncodePeerTargetId(const PeerTargetId & targetId,MessageParcel & parcel)71 bool IpcModelCodec::EncodePeerTargetId(const PeerTargetId &targetId, MessageParcel &parcel)
72 {
73 bool bRet = true;
74 bRet = (bRet && parcel.WriteString(targetId.deviceId));
75 bRet = (bRet && parcel.WriteString(targetId.brMac));
76 bRet = (bRet && parcel.WriteString(targetId.bleMac));
77 bRet = (bRet && parcel.WriteString(targetId.wifiIp));
78 bRet = (bRet && parcel.WriteUint16(targetId.wifiPort));
79 return bRet;
80 }
81
DecodePeerTargetId(MessageParcel & parcel,PeerTargetId & targetId)82 void IpcModelCodec::DecodePeerTargetId(MessageParcel &parcel, PeerTargetId &targetId)
83 {
84 targetId.deviceId = parcel.ReadString();
85 targetId.brMac = parcel.ReadString();
86 targetId.bleMac = parcel.ReadString();
87 targetId.wifiIp = parcel.ReadString();
88 targetId.wifiPort = parcel.ReadUint16();
89 }
90
EncodeDmAccessCaller(const DmAccessCaller & caller,MessageParcel & parcel)91 bool IpcModelCodec::EncodeDmAccessCaller(const DmAccessCaller &caller, MessageParcel &parcel)
92 {
93 bool bRet = true;
94 bRet = (bRet && parcel.WriteString(caller.accountId));
95 bRet = (bRet && parcel.WriteString(caller.pkgName));
96 bRet = (bRet && parcel.WriteString(caller.networkId));
97 bRet = (bRet && parcel.WriteInt32(caller.userId));
98 bRet = (bRet && parcel.WriteUint64(caller.tokenId));
99 bRet = (bRet && parcel.WriteString(caller.extra));
100 return bRet;
101 }
102
EncodeDmAccessCallee(const DmAccessCallee & callee,MessageParcel & parcel)103 bool IpcModelCodec::EncodeDmAccessCallee(const DmAccessCallee &callee, MessageParcel &parcel)
104 {
105 bool bRet = true;
106 bRet = (bRet && parcel.WriteString(callee.accountId));
107 bRet = (bRet && parcel.WriteString(callee.networkId));
108 bRet = (bRet && parcel.WriteString(callee.peerId));
109 bRet = (bRet && parcel.WriteString(callee.pkgName));
110 bRet = (bRet && parcel.WriteInt32(callee.userId));
111 bRet = (bRet && parcel.WriteString(callee.extra));
112 bRet = (bRet && parcel.WriteUint64(callee.tokenId));
113 return bRet;
114 }
115
DecodeDmDeviceProfileInfoFilterOptions(MessageParcel & parcel,DmDeviceProfileInfoFilterOptions & filterOptions)116 int32_t IpcModelCodec::DecodeDmDeviceProfileInfoFilterOptions(MessageParcel &parcel,
117 DmDeviceProfileInfoFilterOptions &filterOptions)
118 {
119 filterOptions.isCloud = parcel.ReadBool();
120 uint32_t size = parcel.ReadUint32();
121 if (size > MAX_DEVICE_PROFILE_SIZE) {
122 LOGE("size more than %{public}d,", MAX_DEVICE_PROFILE_SIZE);
123 return ERR_DM_IPC_WRITE_FAILED;
124 }
125 if (size > 0) {
126 for (uint32_t i = 0; i < size; i++) {
127 std::string item = parcel.ReadString();
128 filterOptions.deviceIdList.emplace_back(item);
129 }
130 }
131 return DM_OK;
132 }
133
EncodeDmDeviceProfileInfoFilterOptions(const DmDeviceProfileInfoFilterOptions & filterOptions,MessageParcel & parcel)134 bool IpcModelCodec::EncodeDmDeviceProfileInfoFilterOptions(const DmDeviceProfileInfoFilterOptions &filterOptions,
135 MessageParcel &parcel)
136 {
137 bool bRet = true;
138 bRet = (bRet && parcel.WriteBool(filterOptions.isCloud));
139 uint32_t size = filterOptions.deviceIdList.size();
140 bRet = (bRet && parcel.WriteUint32(size));
141 if (bRet && size > 0) {
142 for (const auto& item : filterOptions.deviceIdList) {
143 bRet = (bRet && parcel.WriteString(item));
144 }
145 }
146 return bRet;
147 }
148
DecodeDmServiceProfileInfo(MessageParcel & parcel,DmServiceProfileInfo & svrInfo)149 void IpcModelCodec::DecodeDmServiceProfileInfo(MessageParcel &parcel, DmServiceProfileInfo &svrInfo)
150 {
151 svrInfo.deviceId = parcel.ReadString();
152 svrInfo.serviceId = parcel.ReadString();
153 svrInfo.serviceType = parcel.ReadString();
154 int32_t num = parcel.ReadInt32();
155 if (num > 0 && num <= MAX_DEVICE_PROFILE_SIZE) {
156 for (int32_t i = 0; i < num; ++i) {
157 std::string key = parcel.ReadString();
158 std::string value = parcel.ReadString();
159 svrInfo.data[key] = value;
160 }
161 }
162 }
163
DecodeDmServiceProfileInfos(MessageParcel & parcel,std::vector<DmServiceProfileInfo> & svrInfos)164 void IpcModelCodec::DecodeDmServiceProfileInfos(MessageParcel &parcel, std::vector<DmServiceProfileInfo> &svrInfos)
165 {
166 int32_t svrNum = parcel.ReadInt32();
167 if (svrNum > 0 && svrNum <= MAX_DEVICE_PROFILE_SIZE) {
168 for (int32_t i = 0; i < svrNum; ++i) {
169 DmServiceProfileInfo svrInfo;
170 DecodeDmServiceProfileInfo(parcel, svrInfo);
171 svrInfos.emplace_back(svrInfo);
172 }
173 }
174 }
175
DecodeDmDeviceProfileInfo(MessageParcel & parcel,DmDeviceProfileInfo & devInfo)176 void IpcModelCodec::DecodeDmDeviceProfileInfo(MessageParcel &parcel, DmDeviceProfileInfo &devInfo)
177 {
178 devInfo.deviceId = parcel.ReadString();
179 devInfo.deviceSn = parcel.ReadString();
180 devInfo.mac = parcel.ReadString();
181 devInfo.model = parcel.ReadString();
182 devInfo.internalModel = parcel.ReadString();
183 devInfo.deviceType = parcel.ReadString();
184 devInfo.manufacturer = parcel.ReadString();
185 devInfo.deviceName = parcel.ReadString();
186 devInfo.productName = parcel.ReadString();
187 devInfo.productId = parcel.ReadString();
188 devInfo.subProductId = parcel.ReadString();
189 devInfo.sdkVersion = parcel.ReadString();
190 devInfo.bleMac = parcel.ReadString();
191 devInfo.sleMac = parcel.ReadString();
192 devInfo.firmwareVersion = parcel.ReadString();
193 devInfo.hardwareVersion = parcel.ReadString();
194 devInfo.softwareVersion = parcel.ReadString();
195 devInfo.protocolType = parcel.ReadInt32();
196 devInfo.setupType = parcel.ReadInt32();
197 devInfo.wiseDeviceId = parcel.ReadString();
198 devInfo.wiseUserId = parcel.ReadString();
199 devInfo.registerTime = parcel.ReadString();
200 devInfo.modifyTime = parcel.ReadString();
201 devInfo.shareTime = parcel.ReadString();
202 devInfo.isLocalDevice = parcel.ReadBool();
203 DecodeDmServiceProfileInfos(parcel, devInfo.services);
204 }
205
EncodeDmServiceProfileInfo(const DmServiceProfileInfo & svrInfo,MessageParcel & parcel)206 bool IpcModelCodec::EncodeDmServiceProfileInfo(const DmServiceProfileInfo &svrInfo, MessageParcel &parcel)
207 {
208 bool bRet = true;
209 bRet = (bRet && parcel.WriteString(svrInfo.deviceId));
210 bRet = (bRet && parcel.WriteString(svrInfo.serviceId));
211 bRet = (bRet && parcel.WriteString(svrInfo.serviceType));
212 if (bRet) {
213 if (!parcel.WriteInt32((int32_t)svrInfo.data.size())) {
214 return false;
215 }
216 for (const auto &[key, value] : svrInfo.data) {
217 if (!parcel.WriteString(key)) {
218 return false;
219 }
220 if (!parcel.WriteString(value)) {
221 return false;
222 }
223 }
224 }
225 return bRet;
226 }
227
EncodeDmServiceProfileInfos(const std::vector<DmServiceProfileInfo> & svrInfos,MessageParcel & parcel)228 bool IpcModelCodec::EncodeDmServiceProfileInfos(const std::vector<DmServiceProfileInfo> &svrInfos,
229 MessageParcel &parcel)
230 {
231 if (!parcel.WriteInt32((int32_t)svrInfos.size())) {
232 return false;
233 }
234 for (const auto &svrInfo : svrInfos) {
235 if (!EncodeDmServiceProfileInfo(svrInfo, parcel)) {
236 LOGE("write dm service profile info failed");
237 return false;
238 }
239 }
240 return true;
241 }
242
EncodeDmDeviceProfileInfo(const DmDeviceProfileInfo & devInfo,MessageParcel & parcel)243 bool IpcModelCodec::EncodeDmDeviceProfileInfo(const DmDeviceProfileInfo &devInfo, MessageParcel &parcel)
244 {
245 bool bRet = true;
246 bRet = (bRet && parcel.WriteString(devInfo.deviceId));
247 bRet = (bRet && parcel.WriteString(devInfo.deviceSn));
248 bRet = (bRet && parcel.WriteString(devInfo.mac));
249 bRet = (bRet && parcel.WriteString(devInfo.model));
250 bRet = (bRet && parcel.WriteString(devInfo.internalModel));
251 bRet = (bRet && parcel.WriteString(devInfo.deviceType));
252 bRet = (bRet && parcel.WriteString(devInfo.manufacturer));
253 bRet = (bRet && parcel.WriteString(devInfo.deviceName));
254 bRet = (bRet && parcel.WriteString(devInfo.productName));
255 bRet = (bRet && parcel.WriteString(devInfo.productId));
256 bRet = (bRet && parcel.WriteString(devInfo.subProductId));
257 bRet = (bRet && parcel.WriteString(devInfo.sdkVersion));
258 bRet = (bRet && parcel.WriteString(devInfo.bleMac));
259 bRet = (bRet && parcel.WriteString(devInfo.sleMac));
260 bRet = (bRet && parcel.WriteString(devInfo.firmwareVersion));
261 bRet = (bRet && parcel.WriteString(devInfo.hardwareVersion));
262 bRet = (bRet && parcel.WriteString(devInfo.softwareVersion));
263 bRet = (bRet && parcel.WriteInt32(devInfo.protocolType));
264 bRet = (bRet && parcel.WriteInt32(devInfo.setupType));
265 bRet = (bRet && parcel.WriteString(devInfo.wiseDeviceId));
266 bRet = (bRet && parcel.WriteString(devInfo.wiseUserId));
267 bRet = (bRet && parcel.WriteString(devInfo.registerTime));
268 bRet = (bRet && parcel.WriteString(devInfo.modifyTime));
269 bRet = (bRet && parcel.WriteString(devInfo.shareTime));
270 bRet = (bRet && parcel.WriteBool(devInfo.isLocalDevice));
271 bRet = (bRet && EncodeDmServiceProfileInfos(devInfo.services, parcel));
272 return bRet;
273 }
274
GetDeviceIconInfoUniqueKey(const DmDeviceIconInfoFilterOptions & iconFiter)275 std::string IpcModelCodec::GetDeviceIconInfoUniqueKey(const DmDeviceIconInfoFilterOptions &iconFiter)
276 {
277 return iconFiter.productId + UK_SEPARATOR + iconFiter.subProductId + UK_SEPARATOR +
278 iconFiter.internalModel + UK_SEPARATOR + iconFiter.imageType + UK_SEPARATOR + iconFiter.specName;
279 }
280
GetDeviceIconInfoUniqueKey(const DmDeviceIconInfo & iconInfo)281 std::string IpcModelCodec::GetDeviceIconInfoUniqueKey(const DmDeviceIconInfo &iconInfo)
282 {
283 return iconInfo.productId + UK_SEPARATOR + iconInfo.subProductId + UK_SEPARATOR +
284 iconInfo.internalModel + UK_SEPARATOR + iconInfo.imageType + UK_SEPARATOR + iconInfo.specName;
285 }
286
DecodeDmDeviceIconInfo(MessageParcel & parcel,DmDeviceIconInfo & deviceIconInfo)287 void IpcModelCodec::DecodeDmDeviceIconInfo(MessageParcel &parcel, DmDeviceIconInfo &deviceIconInfo)
288 {
289 deviceIconInfo.productId = parcel.ReadString();
290 deviceIconInfo.subProductId = parcel.ReadString();
291 deviceIconInfo.internalModel = parcel.ReadString();
292 deviceIconInfo.imageType = parcel.ReadString();
293 deviceIconInfo.specName = parcel.ReadString();
294 deviceIconInfo.version = parcel.ReadString();
295 deviceIconInfo.url = parcel.ReadString();
296 int32_t length = parcel.ReadInt32();
297 if (length > 0 && length <= MAX_ICON_SIZE) {
298 const unsigned char *buffer = nullptr;
299 if ((buffer = reinterpret_cast<const unsigned char *>(parcel.ReadRawData((size_t)length))) == nullptr) {
300 LOGE("read raw data failed, length = %{public}d", length);
301 return;
302 }
303 std::vector<uint8_t> icon(buffer, buffer + length);
304 deviceIconInfo.icon = icon;
305 }
306 }
307
EncodeDmDeviceIconInfo(const DmDeviceIconInfo & deviceIconInfo,MessageParcel & parcel)308 bool IpcModelCodec::EncodeDmDeviceIconInfo(const DmDeviceIconInfo &deviceIconInfo, MessageParcel &parcel)
309 {
310 bool bRet = true;
311 bRet = (bRet && parcel.WriteString(deviceIconInfo.productId));
312 bRet = (bRet && parcel.WriteString(deviceIconInfo.subProductId));
313 bRet = (bRet && parcel.WriteString(deviceIconInfo.internalModel));
314 bRet = (bRet && parcel.WriteString(deviceIconInfo.imageType));
315 bRet = (bRet && parcel.WriteString(deviceIconInfo.specName));
316 bRet = (bRet && parcel.WriteString(deviceIconInfo.version));
317 bRet = (bRet && parcel.WriteString(deviceIconInfo.url));
318 int32_t length = static_cast<int32_t>(deviceIconInfo.icon.size());
319 bRet = (bRet && parcel.WriteInt32(length));
320 if (bRet && length > 0) {
321 const unsigned char *buffer = reinterpret_cast<const unsigned char *>(deviceIconInfo.icon.data());
322 bRet = (bRet && parcel.WriteRawData(buffer, length));
323 }
324 return bRet;
325 }
326
DecodeDmDeviceIconInfoFilterOptions(MessageParcel & parcel,DmDeviceIconInfoFilterOptions & filterOptions)327 void IpcModelCodec::DecodeDmDeviceIconInfoFilterOptions(MessageParcel &parcel,
328 DmDeviceIconInfoFilterOptions &filterOptions)
329 {
330 filterOptions.productId = parcel.ReadString();
331 filterOptions.subProductId = parcel.ReadString();
332 filterOptions.internalModel = parcel.ReadString();
333 filterOptions.imageType = parcel.ReadString();
334 filterOptions.specName = parcel.ReadString();
335 }
336
EncodeDmDeviceIconInfoFilterOptions(const DmDeviceIconInfoFilterOptions & filterOptions,MessageParcel & parcel)337 bool IpcModelCodec::EncodeDmDeviceIconInfoFilterOptions(const DmDeviceIconInfoFilterOptions &filterOptions,
338 MessageParcel &parcel)
339 {
340 bool bRet = true;
341 bRet = (bRet && parcel.WriteString(filterOptions.productId));
342 bRet = (bRet && parcel.WriteString(filterOptions.subProductId));
343 bRet = (bRet && parcel.WriteString(filterOptions.internalModel));
344 bRet = (bRet && parcel.WriteString(filterOptions.imageType));
345 bRet = (bRet && parcel.WriteString(filterOptions.specName));
346 return bRet;
347 }
348
DecodeDmDeviceInfo(MessageParcel & parcel,DmDeviceInfo & devInfo)349 void IpcModelCodec::DecodeDmDeviceInfo(MessageParcel &parcel, DmDeviceInfo &devInfo)
350 {
351 std::string deviceIdStr = parcel.ReadString();
352 CHECK_CPY_SIZE_RETURN(DM_MAX_DEVICE_ID_LEN, deviceIdStr.size());
353 if (strcpy_s(devInfo.deviceId, deviceIdStr.size() + 1, deviceIdStr.c_str()) != DM_OK) {
354 LOGE("strcpy_s deviceId failed!");
355 return;
356 }
357 std::string deviceNameStr = parcel.ReadString();
358 CHECK_CPY_SIZE_RETURN(DM_MAX_DEVICE_NAME_LEN, deviceNameStr.size());
359 if (strcpy_s(devInfo.deviceName, deviceNameStr.size() + 1, deviceNameStr.c_str()) != DM_OK) {
360 LOGE("strcpy_s deviceName failed!");
361 return;
362 }
363 devInfo.deviceTypeId = parcel.ReadUint16();
364 std::string networkIdStr = parcel.ReadString();
365 CHECK_CPY_SIZE_RETURN(DM_MAX_DEVICE_ID_LEN, networkIdStr.size());
366 if (strcpy_s(devInfo.networkId, networkIdStr.size() + 1, networkIdStr.c_str()) != DM_OK) {
367 LOGE("strcpy_s networkId failed!");
368 return;
369 }
370 devInfo.range = parcel.ReadInt32();
371 devInfo.networkType = parcel.ReadInt32();
372 devInfo.authForm = static_cast<DmAuthForm>(parcel.ReadInt32());
373 devInfo.extraData = parcel.ReadString();
374 }
375
EncodeLocalServiceInfo(const DMLocalServiceInfo & serviceInfo,MessageParcel & parcel)376 bool IpcModelCodec::EncodeLocalServiceInfo(const DMLocalServiceInfo &serviceInfo, MessageParcel &parcel)
377 {
378 bool bRet = true;
379 bRet = (bRet && parcel.WriteString(serviceInfo.bundleName));
380 bRet = (bRet && parcel.WriteInt32(serviceInfo.authBoxType));
381 bRet = (bRet && parcel.WriteInt32(serviceInfo.authType));
382 bRet = (bRet && parcel.WriteInt32(serviceInfo.pinExchangeType));
383 bRet = (bRet && parcel.WriteString(serviceInfo.pinCode));
384 bRet = (bRet && parcel.WriteString(serviceInfo.description));
385 bRet = (bRet && parcel.WriteString(serviceInfo.extraInfo));
386 return bRet;
387 }
388
EncodeLocalServiceInfos(const std::vector<DMLocalServiceInfo> & serviceInfos,MessageParcel & parcel)389 bool IpcModelCodec::EncodeLocalServiceInfos(const std::vector<DMLocalServiceInfo> &serviceInfos, MessageParcel &parcel)
390 {
391 uint32_t num = static_cast<uint32_t>(serviceInfos.size());
392 if (!parcel.WriteUint32(num)) {
393 LOGE("WriteUint32 num failed");
394 return false;
395 }
396 bool bRet = true;
397 if (num > IPC_VECTOR_MAX_SIZE) {
398 LOGE("num is Invalid value, num = %{public}u", num);
399 return false;
400 }
401 for (uint32_t k = 0; k < num; k++) {
402 DMLocalServiceInfo serviceInfo = serviceInfos[k];
403 bRet = EncodeLocalServiceInfo(serviceInfo, parcel);
404 if (!bRet) {
405 LOGE("EncodeLocalServiceInfo failed");
406 break;
407 }
408 }
409 return bRet;
410 }
411
DecodeLocalServiceInfo(MessageParcel & parcel,DMLocalServiceInfo & serviceInfo)412 bool IpcModelCodec::DecodeLocalServiceInfo(MessageParcel &parcel, DMLocalServiceInfo &serviceInfo)
413 {
414 READ_HELPER_RET(parcel, String, serviceInfo.bundleName, false);
415 READ_HELPER_RET(parcel, Int32, serviceInfo.authBoxType, false);
416 READ_HELPER_RET(parcel, Int32, serviceInfo.authType, false);
417 READ_HELPER_RET(parcel, Int32, serviceInfo.pinExchangeType, false);
418 READ_HELPER_RET(parcel, String, serviceInfo.pinCode, false);
419 READ_HELPER_RET(parcel, String, serviceInfo.description, false);
420 READ_HELPER_RET(parcel, String, serviceInfo.extraInfo, false);
421 return true;
422 }
423
DecodeLocalServiceInfos(MessageParcel & parcel,std::vector<DMLocalServiceInfo> & serviceInfos)424 bool IpcModelCodec::DecodeLocalServiceInfos(MessageParcel &parcel, std::vector<DMLocalServiceInfo> &serviceInfos)
425 {
426 uint32_t num = 0;
427 READ_HELPER_RET(parcel, Uint32, num, false);
428 bool bRet = true;
429 for (uint32_t k = 0; k < num; k++) {
430 DMLocalServiceInfo serviceInfo;
431 bRet = DecodeLocalServiceInfo(parcel, serviceInfo);
432 if (!bRet) {
433 LOGE("DecodeLocalServiceInfo failed");
434 break;
435 }
436 serviceInfos.emplace_back(serviceInfo);
437 }
438 return bRet;
439 }
440
EncodeNetworkIdQueryFilter(const NetworkIdQueryFilter & queryFilter,MessageParcel & parcel)441 bool IpcModelCodec::EncodeNetworkIdQueryFilter(const NetworkIdQueryFilter &queryFilter, MessageParcel &parcel)
442 {
443 bool bRet = true;
444 bRet = (bRet && parcel.WriteString(queryFilter.wiseDeviceId));
445 bRet = (bRet && parcel.WriteInt32(queryFilter.onlineStatus));
446 bRet = (bRet && parcel.WriteString(queryFilter.deviceType));
447 bRet = (bRet && parcel.WriteString(queryFilter.deviceProductId));
448 bRet = (bRet && parcel.WriteString(queryFilter.deviceModel));
449 return bRet;
450 }
451
DecodeNetworkIdQueryFilter(MessageParcel & parcel,NetworkIdQueryFilter & queryFilter)452 bool IpcModelCodec::DecodeNetworkIdQueryFilter(MessageParcel &parcel, NetworkIdQueryFilter &queryFilter)
453 {
454 READ_HELPER_RET(parcel, String, queryFilter.wiseDeviceId, false);
455 READ_HELPER_RET(parcel, Int32, queryFilter.onlineStatus, false);
456 READ_HELPER_RET(parcel, String, queryFilter.deviceType, false);
457 READ_HELPER_RET(parcel, String, queryFilter.deviceProductId, false);
458 READ_HELPER_RET(parcel, String, queryFilter.deviceModel, false);
459 return true;
460 }
461
EncodeStringVector(const std::vector<std::string> & vec,MessageParcel & parcel)462 bool IpcModelCodec::EncodeStringVector(const std::vector<std::string> &vec, MessageParcel &parcel)
463 {
464 uint32_t num = static_cast<uint32_t>(vec.size());
465 if (!parcel.WriteUint32(num)) {
466 LOGE("WriteUint32 num failed");
467 return false;
468 }
469 bool bRet = true;
470 for (uint32_t k = 0; k < num; k++) {
471 std::string str = vec[k];
472 bRet = parcel.WriteString(vec[k]);
473 if (!bRet) {
474 LOGE("EncodeStringVector failed");
475 break;
476 }
477 }
478 return bRet;
479 }
480
DecodeStringVector(MessageParcel & parcel,std::vector<std::string> & vec)481 bool IpcModelCodec::DecodeStringVector(MessageParcel &parcel, std::vector<std::string> &vec)
482 {
483 uint32_t num = 0;
484 READ_HELPER_RET(parcel, Uint32, num, false);
485 if (num > IPC_VECTOR_MAX_SIZE) {
486 LOGE("num is Invalid value, num = %{public}u", num);
487 return false;
488 }
489 for (uint32_t k = 0; k < num; k++) {
490 std::string str = "";
491 READ_HELPER_RET(parcel, String, str, false);
492 vec.emplace_back(str);
493 }
494 return true;
495 }
496 //LCOV_EXCL_STOP
497 } // namespace DistributedHardware
498 } // namespace OHOS
499