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