1 /*
2  * Copyright (C) 2022 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 "accessibility_element_info_parcel.h"
17 #include "hilog_wrapper.h"
18 #include "parcel_util.h"
19 
20 namespace OHOS {
21 namespace Accessibility {
22 /* AccessibilityElementInfoParcel       Parcel struct                 */
AccessibilityElementInfoParcel(const AccessibilityElementInfo & elementInfo)23 AccessibilityElementInfoParcel::AccessibilityElementInfoParcel(const AccessibilityElementInfo &elementInfo)
24     : AccessibilityElementInfo(elementInfo)
25 {
26 }
27 
ReadFromParcelFirstPart(Parcel & parcel)28 bool AccessibilityElementInfoParcel::ReadFromParcelFirstPart(Parcel &parcel)
29 {
30     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, pageId_);
31     int32_t textMoveStep = STEP_CHARACTER;
32     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, textMoveStep);
33     textMoveStep_ = static_cast<TextMoveUnit>(textMoveStep);
34     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, itemCounts_);
35     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, windowId_);
36     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int64, parcel, elementId_);
37     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int64, parcel, parentId_);
38     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, belongTreeId_);
39     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, childTreeId_);
40     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, childWindowId_);
41     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, parentWindowId_);
42     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, bundleName_);
43     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, componentType_);
44     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, text_);
45     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, hintText_);
46     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, accessibilityText_);
47     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, contentDescription_);
48     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, resourceName_);
49     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int64Vector, parcel, &childNodeIds_);
50     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, childCount_);
51     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, textType_);
52     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Float, parcel, offset_);
53     return true;
54 }
55 
ReadFromParcelSecondPart(Parcel & parcel)56 bool AccessibilityElementInfoParcel::ReadFromParcelSecondPart(Parcel &parcel)
57 {
58     int32_t operationsSize = 0;
59     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, operationsSize);
60     bool verifyResult = ContainerSecurityVerify(parcel, operationsSize, operations_.max_size());
61     if (!verifyResult || operationsSize < 0 || operationsSize > INT32_MAX) {
62         return false;
63     }
64     for (int32_t i = 0; i < operationsSize; i++) {
65         sptr<AccessibleActionParcel> accessibleOperation = parcel.ReadStrongParcelable<AccessibleActionParcel>();
66         if (accessibleOperation == nullptr) {
67             HILOG_ERROR("ReadStrongParcelable<accessibleOperation> failed");
68             return false;
69         }
70         operations_.emplace_back(*accessibleOperation);
71     }
72 
73     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, textLengthLimit_);
74     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int64, parcel, navDestinationId_);
75     sptr<RectParcel> rect = parcel.ReadStrongParcelable<RectParcel>();
76     if (rect == nullptr) {
77         return false;
78     }
79     bounds_ = *rect;
80 
81     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, checkable_);
82     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, checked_);
83     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, focusable_);
84     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, focused_);
85     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, visible_);
86     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, accessibilityFocused_);
87     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, selected_);
88     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, clickable_);
89     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, longClickable_);
90     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, enable_);
91     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, isPassword_);
92     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, scrollable_);
93     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, editable_);
94     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, popupSupported_);
95     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, multiLine_);
96     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, deletable_);
97     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, hint_);
98     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, isEssential_);
99     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, currentIndex_);
100     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, beginIndex_);
101     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, endIndex_);
102     return true;
103 }
104 
ReadFromParcelThirdPart(Parcel & parcel)105 bool AccessibilityElementInfoParcel::ReadFromParcelThirdPart(Parcel &parcel)
106 {
107     sptr<RangeInfoParcel> rangeInfo = parcel.ReadStrongParcelable<RangeInfoParcel>();
108     if (rangeInfo == nullptr) {
109         return false;
110     }
111     rangeInfo_ = *rangeInfo;
112 
113     sptr<GridInfoParcel> grid = parcel.ReadStrongParcelable<GridInfoParcel>();
114     if (grid == nullptr) {
115         return false;
116     }
117     grid_ = *grid;
118 
119     sptr<GridItemInfoParcel> gridItem = parcel.ReadStrongParcelable<GridItemInfoParcel>();
120     if (gridItem == nullptr) {
121         return false;
122     }
123     gridItem_ = *gridItem;
124 
125     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, liveRegion_);
126     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, contentInvalid_);
127     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, error_);
128     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int64, parcel, labeled_);
129     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, beginSelected_);
130     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, endSelected_);
131     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, inputType_);
132     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, validElement_);
133     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, inspectorKey_);
134     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, pagePath_);
135     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, accessibilityGroup_);
136     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, accessibilityLevel_);
137     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, zIndex_);
138     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Float, parcel, opacity_);
139     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, backgroundColor_);
140     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, backgroundImage_);
141     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, blur_);
142     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, hitTestBehavior_);
143 
144     sptr<ExtraElementInfoParcel> extraElementInfo = parcel.ReadStrongParcelable<ExtraElementInfoParcel>();
145     if (extraElementInfo == nullptr) {
146         return false;
147     }
148     extraElementInfo_ = *extraElementInfo;
149 
150     return true;
151 }
152 
ReadFromParcelFourthPart(Parcel & parcel)153 bool AccessibilityElementInfoParcel::ReadFromParcelFourthPart(Parcel &parcel)
154 {
155     int32_t spanListSize = 0;
156     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, spanListSize);
157     if (!ContainerSecurityVerify(parcel, spanListSize, spanList_.max_size())) {
158         return false;
159     }
160 
161     for (int32_t i = 0; i < spanListSize; i++) {
162         sptr<SpanInfoParcel> spanList = parcel.ReadStrongParcelable<SpanInfoParcel>();
163         if (!spanList) {
164             HILOG_ERROR("ReadStrongParcelable<spanList> failed");
165             return false;
166         }
167         spanList_.emplace_back(*spanList);
168     }
169 
170     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, isActive_);
171     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, accessibilityVisible_);
172     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, mainWindowId_);
173     return true;
174 }
175 
ReadFromParcel(Parcel & parcel)176 bool AccessibilityElementInfoParcel::ReadFromParcel(Parcel &parcel)
177 {
178     if (!ReadFromParcelFirstPart(parcel)) {
179         return false;
180     }
181     if (!ReadFromParcelSecondPart(parcel)) {
182         return false;
183     }
184     if (!ReadFromParcelThirdPart(parcel)) {
185         return false;
186     }
187     if (!ReadFromParcelFourthPart(parcel)) {
188         return false;
189     }
190     return true;
191 }
192 
MarshallingFirstPart(Parcel & parcel) const193 bool AccessibilityElementInfoParcel::MarshallingFirstPart(Parcel &parcel) const
194 {
195     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, pageId_);
196     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, static_cast<int32_t>(textMoveStep_));
197     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, itemCounts_);
198     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, windowId_);
199     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int64, parcel, elementId_);
200     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int64, parcel, parentId_);
201     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, belongTreeId_);
202     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, childTreeId_);
203     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, childWindowId_);
204     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, parentWindowId_);
205     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, bundleName_);
206     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, componentType_);
207     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, text_);
208     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, hintText_);
209     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, accessibilityText_);
210     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, contentDescription_);
211     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, resourceName_);
212     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int64Vector, parcel, childNodeIds_);
213     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, childCount_);
214     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, textType_);
215     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Float, parcel, offset_);
216     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, operations_.size());
217     for (auto &operations : operations_) {
218         AccessibleActionParcel action(operations);
219         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &action);
220     }
221     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, textLengthLimit_);
222     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int64, parcel, navDestinationId_);
223     return true;
224 }
225 
MarshallingSecondPart(Parcel & parcel) const226 bool AccessibilityElementInfoParcel::MarshallingSecondPart(Parcel &parcel) const
227 {
228     RectParcel boundsParcel(bounds_);
229     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &boundsParcel);
230     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, checkable_);
231     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, checked_);
232     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, focusable_);
233     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, focused_);
234     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, visible_);
235     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, accessibilityFocused_);
236     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, selected_);
237     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, clickable_);
238     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, longClickable_);
239     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, enable_);
240     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, isPassword_);
241     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, scrollable_);
242     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, editable_);
243     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, popupSupported_);
244     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, multiLine_);
245     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, deletable_);
246     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, hint_);
247     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, isEssential_);
248     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, currentIndex_);
249     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, beginIndex_);
250     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, endIndex_);
251     RangeInfoParcel rangeInfoParcel(rangeInfo_);
252     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &rangeInfoParcel);
253     GridInfoParcel gridParcel(grid_);
254     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &gridParcel);
255     GridItemInfoParcel gridItemParcel(gridItem_);
256     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &gridItemParcel);
257 
258     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, liveRegion_);
259     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, contentInvalid_);
260     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, error_);
261     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int64, parcel, labeled_);
262     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, beginSelected_);
263     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, endSelected_);
264     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, inputType_);
265     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, validElement_);
266     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, inspectorKey_);
267     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, pagePath_);
268     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, accessibilityGroup_);
269     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, accessibilityLevel_);
270     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, zIndex_);
271     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Float, parcel, opacity_);
272     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, backgroundColor_);
273     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, backgroundImage_);
274     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, blur_);
275     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, hitTestBehavior_);
276     return true;
277 }
278 
MarshallingThirdPart(Parcel & parcel) const279 bool AccessibilityElementInfoParcel::MarshallingThirdPart(Parcel &parcel) const
280 {
281     ExtraElementInfoParcel extraElementInfoParcel(extraElementInfo_);
282     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &extraElementInfoParcel);
283 
284     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, spanList_.size());
285     for (auto &span : spanList_) {
286         SpanInfoParcel spanList(span);
287         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &spanList);
288     }
289 
290     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, isActive_);
291     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, accessibilityVisible_);
292     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, mainWindowId_);
293     return true;
294 }
295 
Marshalling(Parcel & parcel) const296 bool AccessibilityElementInfoParcel::Marshalling(Parcel &parcel) const
297 {
298     if (!MarshallingFirstPart(parcel)) {
299         return false;
300     }
301     if (!MarshallingSecondPart(parcel)) {
302         return false;
303     }
304     if (!MarshallingThirdPart(parcel)) {
305         return false;
306     }
307     return true;
308 }
309 
Unmarshalling(Parcel & parcel)310 sptr<AccessibilityElementInfoParcel> AccessibilityElementInfoParcel::Unmarshalling(Parcel& parcel)
311 {
312     sptr<AccessibilityElementInfoParcel> accessibilityInfo = new(std::nothrow) AccessibilityElementInfoParcel();
313     if (accessibilityInfo == nullptr) {
314         HILOG_ERROR("Failed to create accessibilityInfo.");
315         return nullptr;
316     }
317     if (!accessibilityInfo->ReadFromParcel(parcel)) {
318         HILOG_ERROR("read from parcel failed");
319         return nullptr;
320     }
321     return accessibilityInfo;
322 }
323 
AccessibleActionParcel(const AccessibleAction & action)324 AccessibleActionParcel::AccessibleActionParcel(const AccessibleAction &action)
325     : AccessibleAction(action)
326 {
327 }
328 
ReadFromParcel(Parcel & parcel)329 bool AccessibleActionParcel::ReadFromParcel(Parcel &parcel)
330 {
331     int32_t type = ActionType::ACCESSIBILITY_ACTION_INVALID;
332     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, type);
333     actionType_ = static_cast<ActionType>(type);
334     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, description_);
335     return true;
336 }
337 
Marshalling(Parcel & parcel) const338 bool AccessibleActionParcel::Marshalling(Parcel &parcel) const
339 {
340     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, static_cast<int32_t>(actionType_));
341     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, description_);
342 
343     return true;
344 }
345 
Unmarshalling(Parcel & parcel)346 sptr<AccessibleActionParcel> AccessibleActionParcel::Unmarshalling(Parcel& parcel)
347 {
348     sptr<AccessibleActionParcel> accessibleOperation = new(std::nothrow) AccessibleActionParcel();
349     if (accessibleOperation == nullptr) {
350         HILOG_ERROR("Failed to create accessibleOperation.");
351         return nullptr;
352     }
353     if (!accessibleOperation->ReadFromParcel(parcel)) {
354         HILOG_ERROR("read from parcel failed");
355         return nullptr;
356     }
357     return accessibleOperation;
358 }
359 
RangeInfoParcel(const RangeInfo & rangeInfo)360 RangeInfoParcel::RangeInfoParcel(const RangeInfo &rangeInfo)
361     : RangeInfo(rangeInfo)
362 {
363 }
364 
ReadFromParcel(Parcel & parcel)365 bool RangeInfoParcel::ReadFromParcel(Parcel &parcel)
366 {
367     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Double, parcel, min_);
368     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Double, parcel, max_);
369     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Double, parcel, current_);
370 
371     return true;
372 }
373 
Marshalling(Parcel & parcel) const374 bool RangeInfoParcel::Marshalling(Parcel &parcel) const
375 {
376     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Double, parcel, min_);
377     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Double, parcel, max_);
378     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Double, parcel, current_);
379 
380     return true;
381 }
382 
Unmarshalling(Parcel & parcel)383 sptr<RangeInfoParcel> RangeInfoParcel::Unmarshalling(Parcel& parcel)
384 {
385     sptr<RangeInfoParcel> rangeInfo = new(std::nothrow) RangeInfoParcel();
386     if (rangeInfo == nullptr) {
387         HILOG_ERROR("Failed to create rangeInfo.");
388         return nullptr;
389     }
390     if (!rangeInfo->ReadFromParcel(parcel)) {
391         HILOG_ERROR("read from parcel failed");
392         return nullptr;
393     }
394     return rangeInfo;
395 }
396 
GridInfoParcel(const GridInfo & gridInfo)397 GridInfoParcel::GridInfoParcel(const GridInfo &gridInfo)
398     : GridInfo(gridInfo)
399 {
400 }
401 
ReadFromParcel(Parcel & parcel)402 bool GridInfoParcel::ReadFromParcel(Parcel &parcel)
403 {
404     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, rowCount_);
405     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, columnCount_);
406     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, selectionMode_);
407 
408     return true;
409 }
410 
Marshalling(Parcel & parcel) const411 bool GridInfoParcel::Marshalling(Parcel &parcel) const
412 {
413     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, rowCount_);
414     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, columnCount_);
415     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, selectionMode_);
416 
417     return true;
418 }
419 
Unmarshalling(Parcel & parcel)420 sptr<GridInfoParcel> GridInfoParcel::Unmarshalling(Parcel& parcel)
421 {
422     sptr<GridInfoParcel> grid = new(std::nothrow) GridInfoParcel();
423     if (grid == nullptr) {
424         HILOG_ERROR("Failed to create grid.");
425         return nullptr;
426     }
427     if (!grid->ReadFromParcel(parcel)) {
428         HILOG_ERROR("read from parcel failed");
429         return nullptr;
430     }
431     return grid;
432 }
433 
GridItemInfoParcel(const GridItemInfo & itemInfo)434 GridItemInfoParcel::GridItemInfoParcel(const GridItemInfo &itemInfo)
435     : GridItemInfo(itemInfo)
436 {
437 }
438 
ReadFromParcel(Parcel & parcel)439 bool GridItemInfoParcel::ReadFromParcel(Parcel &parcel)
440 {
441     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, heading_);
442     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, columnIndex_);
443     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, rowIndex_);
444     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, columnSpan_);
445     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, rowSpan_);
446     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, selected_);
447 
448     return true;
449 }
450 
Marshalling(Parcel & parcel) const451 bool GridItemInfoParcel::Marshalling(Parcel &parcel) const
452 {
453     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, heading_);
454     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, columnIndex_);
455     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, rowIndex_);
456     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, columnSpan_);
457     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, rowSpan_);
458     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, selected_);
459 
460     return true;
461 }
462 
Unmarshalling(Parcel & parcel)463 sptr<GridItemInfoParcel> GridItemInfoParcel::Unmarshalling(Parcel& parcel)
464 {
465     sptr<GridItemInfoParcel> gridItem = new(std::nothrow) GridItemInfoParcel();
466     if (gridItem == nullptr) {
467         HILOG_ERROR("Failed to create gridItem.");
468         return nullptr;
469     }
470     if (!gridItem->ReadFromParcel(parcel)) {
471         HILOG_ERROR("read from parcel failed");
472         return nullptr;
473     }
474     return gridItem;
475 }
476 
RectParcel(const Rect & rect)477 RectParcel::RectParcel(const Rect &rect)
478     : Rect(rect)
479 {
480 }
481 
ReadFromParcel(Parcel & parcel)482 bool RectParcel::ReadFromParcel(Parcel &parcel)
483 {
484     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, leftTopX_);
485     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, leftTopY_);
486     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, rightBottomX_);
487     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, rightBottomY_);
488     return true;
489 }
490 
Marshalling(Parcel & parcel) const491 bool RectParcel::Marshalling(Parcel &parcel) const
492 {
493     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, leftTopX_);
494     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, leftTopY_);
495     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, rightBottomX_);
496     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, rightBottomY_);
497     return true;
498 }
499 
Unmarshalling(Parcel & parcel)500 sptr<RectParcel> RectParcel::Unmarshalling(Parcel& parcel)
501 {
502     sptr<RectParcel> rect = new(std::nothrow) RectParcel();
503     if (rect == nullptr) {
504         HILOG_ERROR("Failed to create rect.");
505         return nullptr;
506     }
507     if (!rect->ReadFromParcel(parcel)) {
508         HILOG_ERROR("read from parcel failed");
509         return nullptr;
510     }
511     return rect;
512 }
513 
ExtraElementInfoParcel(const ExtraElementInfo & extraElementInfo)514 ExtraElementInfoParcel::ExtraElementInfoParcel(const ExtraElementInfo &extraElementInfo)
515     : ExtraElementInfo(extraElementInfo)
516 {
517 }
518 
ReadFromParcel(Parcel & parcel)519 bool ExtraElementInfoParcel::ReadFromParcel(Parcel &parcel)
520 {
521     int32_t mapValueStr = 0;
522     int32_t mapValueInt = 0;
523     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, mapValueStr);
524     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, mapValueInt);
525     HILOG_DEBUG("ReadFromParcel: size is map, mapValueStr: %{public}d,mapValueInt: %{public}d",
526         mapValueStr, mapValueInt);
527 
528     if (!ContainerSecurityVerify(parcel, mapValueStr, extraElementValueStr_.max_size())) {
529         HILOG_INFO("extraElementValueStr : ExtraElementInfoParcel verify is false");
530         return false;
531     }
532     for (int32_t i = 0; i < mapValueStr; i++) {
533         std::string tempMapKey;
534         std::string tempMapVal;
535 
536         READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, tempMapKey);
537         READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, tempMapVal);
538         HILOG_INFO("ReadFromParcel: extraElementValueStr's tempMapKey: %{public}s, tempMapVal: %{public}s",
539             tempMapKey.c_str(), tempMapVal.c_str());
540         extraElementValueStr_[tempMapKey] = tempMapVal;
541     }
542 
543     if (!ContainerSecurityVerify(parcel, mapValueInt, extraElementValueInt_.max_size())) {
544         HILOG_INFO("extraElementValueInt : ExtraElementInfoParcel verify is false");
545         return false;
546     }
547     for (int32_t i = 0; i < mapValueInt; i++) {
548         std::string tempMapKey;
549         int32_t tempMapVal;
550 
551         READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, tempMapKey);
552         READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, tempMapVal);
553         HILOG_INFO("ReadFromParcel: extraElementValueInt's tempMapKey: %{public}s, tempMapVal: %{public}d",
554             tempMapKey.c_str(), tempMapVal);
555         extraElementValueInt_[tempMapKey] = tempMapVal;
556     }
557 
558     return true;
559 }
560 
Marshalling(Parcel & parcel) const561 bool ExtraElementInfoParcel::Marshalling(Parcel &parcel) const
562 {
563     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, extraElementValueStr_.size());
564     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, extraElementValueInt_.size());
565     for (auto iterStr = extraElementValueStr_.begin(); iterStr != extraElementValueStr_.end(); ++iterStr) {
566         std::string tempMapKey;
567         std::string tempMapVal;
568         tempMapKey = iterStr->first;
569         tempMapVal = iterStr->second;
570         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, tempMapKey);
571         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, tempMapVal);
572     }
573 
574     for (auto iterInt = extraElementValueInt_.begin(); iterInt != extraElementValueInt_.end(); ++iterInt) {
575         std::string tempMapKey;
576         int32_t tempMapVal;
577         tempMapKey = iterInt->first;
578         tempMapVal = iterInt->second;
579         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, tempMapKey);
580         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, tempMapVal);
581     }
582 
583     return true;
584 }
585 
Unmarshalling(Parcel & parcel)586 sptr<ExtraElementInfoParcel> ExtraElementInfoParcel::Unmarshalling(Parcel &parcel)
587 {
588     sptr<ExtraElementInfoParcel> extraElementInfo = new(std::nothrow) ExtraElementInfoParcel();
589     if (extraElementInfo == nullptr) {
590         HILOG_ERROR("Failed to create extraElementInfo.");
591         return nullptr;
592     }
593     if (!extraElementInfo->ReadFromParcel(parcel)) {
594         HILOG_ERROR("read from parcel failed");
595         return nullptr;
596     }
597     return extraElementInfo;
598 }
599 
SpanInfoParcel(const SpanInfo & spanInfo)600 SpanInfoParcel::SpanInfoParcel(const SpanInfo &spanInfo)
601     : SpanInfo(spanInfo)
602 {
603 }
604 
ReadFromParcel(Parcel & parcel)605 bool SpanInfoParcel::ReadFromParcel(Parcel &parcel)
606 {
607     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, spanId_);
608     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, spanText_);
609     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, accessibilityText_);
610     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, accessibilityDescription_);
611     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, accessibilityLevel_);
612     return true;
613 }
614 
Marshalling(Parcel & parcel) const615 bool SpanInfoParcel::Marshalling(Parcel &parcel) const
616 {
617     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, spanId_);
618     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, spanText_);
619     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, accessibilityText_);
620     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, accessibilityDescription_);
621     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, accessibilityLevel_);
622     return true;
623 }
624 
Unmarshalling(Parcel & parcel)625 sptr<SpanInfoParcel> SpanInfoParcel::Unmarshalling(Parcel& parcel)
626 {
627     sptr<SpanInfoParcel> spanInfo = new(std::nothrow) SpanInfoParcel();
628     if (spanInfo == nullptr) {
629         HILOG_ERROR("Failed to create spanInfo.");
630         return nullptr;
631     }
632     if (!spanInfo->ReadFromParcel(parcel)) {
633         HILOG_ERROR("read from parcel failed");
634         return nullptr;
635     }
636     return spanInfo;
637 }
638 } // namespace Accessibility
639 } // namespace OHOS