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 > MAX_ALLOW_SIZE) {
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(Bool, parcel, clip_);
173 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, mainWindowId_);
174 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, customComponentType_);
175 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, innerWindowId_);
176 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int64, parcel, accessibilityNextFocusId_);
177 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int64, parcel, accessibilityPreviousFocusId_);
178 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, accessibilityScrollable_);
179 return true;
180 }
181
ReadFromParcel(Parcel & parcel)182 bool AccessibilityElementInfoParcel::ReadFromParcel(Parcel &parcel)
183 {
184 if (!ReadFromParcelFirstPart(parcel)) {
185 return false;
186 }
187 if (!ReadFromParcelSecondPart(parcel)) {
188 return false;
189 }
190 if (!ReadFromParcelThirdPart(parcel)) {
191 return false;
192 }
193 if (!ReadFromParcelFourthPart(parcel)) {
194 return false;
195 }
196 return true;
197 }
198
MarshallingFirstPart(Parcel & parcel) const199 bool AccessibilityElementInfoParcel::MarshallingFirstPart(Parcel &parcel) const
200 {
201 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, pageId_);
202 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, static_cast<int32_t>(textMoveStep_));
203 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, itemCounts_);
204 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, windowId_);
205 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int64, parcel, elementId_);
206 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int64, parcel, parentId_);
207 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, belongTreeId_);
208 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, childTreeId_);
209 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, childWindowId_);
210 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, parentWindowId_);
211 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, bundleName_);
212 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, componentType_);
213 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, text_);
214 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, hintText_);
215 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, accessibilityText_);
216 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, contentDescription_);
217 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, resourceName_);
218 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int64Vector, parcel, childNodeIds_);
219 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, childCount_);
220 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, textType_);
221 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Float, parcel, offset_);
222 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, operations_.size());
223 for (auto &operations : operations_) {
224 AccessibleActionParcel action(operations);
225 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &action);
226 }
227 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, textLengthLimit_);
228 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int64, parcel, navDestinationId_);
229 return true;
230 }
231
MarshallingSecondPart(Parcel & parcel) const232 bool AccessibilityElementInfoParcel::MarshallingSecondPart(Parcel &parcel) const
233 {
234 RectParcel boundsParcel(bounds_);
235 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &boundsParcel);
236 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, checkable_);
237 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, checked_);
238 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, focusable_);
239 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, focused_);
240 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, visible_);
241 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, accessibilityFocused_);
242 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, selected_);
243 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, clickable_);
244 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, longClickable_);
245 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, enable_);
246 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, isPassword_);
247 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, scrollable_);
248 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, editable_);
249 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, popupSupported_);
250 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, multiLine_);
251 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, deletable_);
252 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, hint_);
253 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, isEssential_);
254 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, currentIndex_);
255 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, beginIndex_);
256 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, endIndex_);
257 RangeInfoParcel rangeInfoParcel(rangeInfo_);
258 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &rangeInfoParcel);
259 GridInfoParcel gridParcel(grid_);
260 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &gridParcel);
261 GridItemInfoParcel gridItemParcel(gridItem_);
262 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &gridItemParcel);
263
264 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, liveRegion_);
265 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, contentInvalid_);
266 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, error_);
267 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int64, parcel, labeled_);
268 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, beginSelected_);
269 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, endSelected_);
270 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, inputType_);
271 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, validElement_);
272 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, inspectorKey_);
273 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, pagePath_);
274 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, accessibilityGroup_);
275 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, accessibilityLevel_);
276 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, zIndex_);
277 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Float, parcel, opacity_);
278 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, backgroundColor_);
279 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, backgroundImage_);
280 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, blur_);
281 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, hitTestBehavior_);
282 return true;
283 }
284
MarshallingThirdPart(Parcel & parcel) const285 bool AccessibilityElementInfoParcel::MarshallingThirdPart(Parcel &parcel) const
286 {
287 ExtraElementInfoParcel extraElementInfoParcel(extraElementInfo_);
288 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &extraElementInfoParcel);
289
290 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, spanList_.size());
291 for (auto &span : spanList_) {
292 SpanInfoParcel spanList(span);
293 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &spanList);
294 }
295
296 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, isActive_);
297 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, accessibilityVisible_);
298 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, clip_);
299 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, mainWindowId_);
300 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, customComponentType_);
301 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, innerWindowId_);
302 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int64, parcel, accessibilityNextFocusId_);
303 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int64, parcel, accessibilityPreviousFocusId_);
304 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, accessibilityScrollable_);
305 return true;
306 }
307
Marshalling(Parcel & parcel) const308 bool AccessibilityElementInfoParcel::Marshalling(Parcel &parcel) const
309 {
310 if (!MarshallingFirstPart(parcel)) {
311 return false;
312 }
313 if (!MarshallingSecondPart(parcel)) {
314 return false;
315 }
316 if (!MarshallingThirdPart(parcel)) {
317 return false;
318 }
319 return true;
320 }
321
Unmarshalling(Parcel & parcel)322 sptr<AccessibilityElementInfoParcel> AccessibilityElementInfoParcel::Unmarshalling(Parcel& parcel)
323 {
324 sptr<AccessibilityElementInfoParcel> accessibilityInfo = new(std::nothrow) AccessibilityElementInfoParcel();
325 if (accessibilityInfo == nullptr) {
326 HILOG_ERROR("Failed to create accessibilityInfo.");
327 return nullptr;
328 }
329 if (!accessibilityInfo->ReadFromParcel(parcel)) {
330 HILOG_ERROR("read from parcel failed");
331 return nullptr;
332 }
333 return accessibilityInfo;
334 }
335
AccessibleActionParcel(const AccessibleAction & action)336 AccessibleActionParcel::AccessibleActionParcel(const AccessibleAction &action)
337 : AccessibleAction(action)
338 {
339 }
340
ReadFromParcel(Parcel & parcel)341 bool AccessibleActionParcel::ReadFromParcel(Parcel &parcel)
342 {
343 int32_t type = ActionType::ACCESSIBILITY_ACTION_INVALID;
344 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, type);
345 actionType_ = static_cast<ActionType>(type);
346 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, description_);
347 return true;
348 }
349
Marshalling(Parcel & parcel) const350 bool AccessibleActionParcel::Marshalling(Parcel &parcel) const
351 {
352 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, static_cast<int32_t>(actionType_));
353 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, description_);
354
355 return true;
356 }
357
Unmarshalling(Parcel & parcel)358 sptr<AccessibleActionParcel> AccessibleActionParcel::Unmarshalling(Parcel& parcel)
359 {
360 sptr<AccessibleActionParcel> accessibleOperation = new(std::nothrow) AccessibleActionParcel();
361 if (accessibleOperation == nullptr) {
362 HILOG_ERROR("Failed to create accessibleOperation.");
363 return nullptr;
364 }
365 if (!accessibleOperation->ReadFromParcel(parcel)) {
366 HILOG_ERROR("read from parcel failed");
367 return nullptr;
368 }
369 return accessibleOperation;
370 }
371
RangeInfoParcel(const RangeInfo & rangeInfo)372 RangeInfoParcel::RangeInfoParcel(const RangeInfo &rangeInfo)
373 : RangeInfo(rangeInfo)
374 {
375 }
376
ReadFromParcel(Parcel & parcel)377 bool RangeInfoParcel::ReadFromParcel(Parcel &parcel)
378 {
379 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Double, parcel, min_);
380 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Double, parcel, max_);
381 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Double, parcel, current_);
382
383 return true;
384 }
385
Marshalling(Parcel & parcel) const386 bool RangeInfoParcel::Marshalling(Parcel &parcel) const
387 {
388 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Double, parcel, min_);
389 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Double, parcel, max_);
390 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Double, parcel, current_);
391
392 return true;
393 }
394
Unmarshalling(Parcel & parcel)395 sptr<RangeInfoParcel> RangeInfoParcel::Unmarshalling(Parcel& parcel)
396 {
397 sptr<RangeInfoParcel> rangeInfo = new(std::nothrow) RangeInfoParcel();
398 if (rangeInfo == nullptr) {
399 HILOG_ERROR("Failed to create rangeInfo.");
400 return nullptr;
401 }
402 if (!rangeInfo->ReadFromParcel(parcel)) {
403 HILOG_ERROR("read from parcel failed");
404 return nullptr;
405 }
406 return rangeInfo;
407 }
408
GridInfoParcel(const GridInfo & gridInfo)409 GridInfoParcel::GridInfoParcel(const GridInfo &gridInfo)
410 : GridInfo(gridInfo)
411 {
412 }
413
ReadFromParcel(Parcel & parcel)414 bool GridInfoParcel::ReadFromParcel(Parcel &parcel)
415 {
416 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, rowCount_);
417 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, columnCount_);
418 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, selectionMode_);
419
420 return true;
421 }
422
Marshalling(Parcel & parcel) const423 bool GridInfoParcel::Marshalling(Parcel &parcel) const
424 {
425 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, rowCount_);
426 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, columnCount_);
427 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, selectionMode_);
428
429 return true;
430 }
431
Unmarshalling(Parcel & parcel)432 sptr<GridInfoParcel> GridInfoParcel::Unmarshalling(Parcel& parcel)
433 {
434 sptr<GridInfoParcel> grid = new(std::nothrow) GridInfoParcel();
435 if (grid == nullptr) {
436 HILOG_ERROR("Failed to create grid.");
437 return nullptr;
438 }
439 if (!grid->ReadFromParcel(parcel)) {
440 HILOG_ERROR("read from parcel failed");
441 return nullptr;
442 }
443 return grid;
444 }
445
GridItemInfoParcel(const GridItemInfo & itemInfo)446 GridItemInfoParcel::GridItemInfoParcel(const GridItemInfo &itemInfo)
447 : GridItemInfo(itemInfo)
448 {
449 }
450
ReadFromParcel(Parcel & parcel)451 bool GridItemInfoParcel::ReadFromParcel(Parcel &parcel)
452 {
453 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, heading_);
454 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, columnIndex_);
455 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, rowIndex_);
456 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, columnSpan_);
457 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, rowSpan_);
458 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, selected_);
459
460 return true;
461 }
462
Marshalling(Parcel & parcel) const463 bool GridItemInfoParcel::Marshalling(Parcel &parcel) const
464 {
465 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, heading_);
466 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, columnIndex_);
467 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, rowIndex_);
468 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, columnSpan_);
469 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, rowSpan_);
470 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, selected_);
471
472 return true;
473 }
474
Unmarshalling(Parcel & parcel)475 sptr<GridItemInfoParcel> GridItemInfoParcel::Unmarshalling(Parcel& parcel)
476 {
477 sptr<GridItemInfoParcel> gridItem = new(std::nothrow) GridItemInfoParcel();
478 if (gridItem == nullptr) {
479 HILOG_ERROR("Failed to create gridItem.");
480 return nullptr;
481 }
482 if (!gridItem->ReadFromParcel(parcel)) {
483 HILOG_ERROR("read from parcel failed");
484 return nullptr;
485 }
486 return gridItem;
487 }
488
RectParcel(const Rect & rect)489 RectParcel::RectParcel(const Rect &rect)
490 : Rect(rect)
491 {
492 }
493
ReadFromParcel(Parcel & parcel)494 bool RectParcel::ReadFromParcel(Parcel &parcel)
495 {
496 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, leftTopX_);
497 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, leftTopY_);
498 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, rightBottomX_);
499 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, rightBottomY_);
500 return true;
501 }
502
Marshalling(Parcel & parcel) const503 bool RectParcel::Marshalling(Parcel &parcel) const
504 {
505 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, leftTopX_);
506 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, leftTopY_);
507 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, rightBottomX_);
508 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, rightBottomY_);
509 return true;
510 }
511
Unmarshalling(Parcel & parcel)512 sptr<RectParcel> RectParcel::Unmarshalling(Parcel& parcel)
513 {
514 sptr<RectParcel> rect = new(std::nothrow) RectParcel();
515 if (rect == nullptr) {
516 HILOG_ERROR("Failed to create rect.");
517 return nullptr;
518 }
519 if (!rect->ReadFromParcel(parcel)) {
520 HILOG_ERROR("read from parcel failed");
521 return nullptr;
522 }
523 return rect;
524 }
525
ExtraElementInfoParcel(const ExtraElementInfo & extraElementInfo)526 ExtraElementInfoParcel::ExtraElementInfoParcel(const ExtraElementInfo &extraElementInfo)
527 : ExtraElementInfo(extraElementInfo)
528 {
529 }
530
ReadFromParcel(Parcel & parcel)531 bool ExtraElementInfoParcel::ReadFromParcel(Parcel &parcel)
532 {
533 int32_t mapValueStr = 0;
534 int32_t mapValueInt = 0;
535 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, mapValueStr);
536 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, mapValueInt);
537 HILOG_DEBUG("ReadFromParcel: size is map, mapValueStr: %{public}d,mapValueInt: %{public}d",
538 mapValueStr, mapValueInt);
539
540 if (!ContainerSecurityVerify(parcel, mapValueStr, extraElementValueStr_.max_size())) {
541 HILOG_WARN("extraElementValueStr : ExtraElementInfoParcel verify is false");
542 return false;
543 }
544 for (int32_t i = 0; i < mapValueStr; i++) {
545 std::string tempMapKey;
546 std::string tempMapVal;
547
548 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, tempMapKey);
549 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, tempMapVal);
550 HILOG_DEBUG("ReadFromParcel: extraElementValueStr's tempMapKey: %{public}s, tempMapVal: %{public}s",
551 tempMapKey.c_str(), tempMapVal.c_str());
552 extraElementValueStr_[tempMapKey] = tempMapVal;
553 }
554
555 if (!ContainerSecurityVerify(parcel, mapValueInt, extraElementValueInt_.max_size())) {
556 HILOG_WARN("extraElementValueInt : ExtraElementInfoParcel verify is false");
557 return false;
558 }
559 for (int32_t i = 0; i < mapValueInt; i++) {
560 std::string tempMapKey;
561 int32_t tempMapVal;
562
563 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, tempMapKey);
564 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, tempMapVal);
565 HILOG_DEBUG("ReadFromParcel: extraElementValueInt's tempMapKey: %{public}s, tempMapVal: %{public}d",
566 tempMapKey.c_str(), tempMapVal);
567 extraElementValueInt_[tempMapKey] = tempMapVal;
568 }
569
570 return true;
571 }
572
Marshalling(Parcel & parcel) const573 bool ExtraElementInfoParcel::Marshalling(Parcel &parcel) const
574 {
575 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, extraElementValueStr_.size());
576 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, extraElementValueInt_.size());
577 for (auto iterStr = extraElementValueStr_.begin(); iterStr != extraElementValueStr_.end(); ++iterStr) {
578 std::string tempMapKey;
579 std::string tempMapVal;
580 tempMapKey = iterStr->first;
581 tempMapVal = iterStr->second;
582 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, tempMapKey);
583 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, tempMapVal);
584 }
585
586 for (auto iterInt = extraElementValueInt_.begin(); iterInt != extraElementValueInt_.end(); ++iterInt) {
587 std::string tempMapKey;
588 int32_t tempMapVal;
589 tempMapKey = iterInt->first;
590 tempMapVal = iterInt->second;
591 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, tempMapKey);
592 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, tempMapVal);
593 }
594
595 return true;
596 }
597
Unmarshalling(Parcel & parcel)598 sptr<ExtraElementInfoParcel> ExtraElementInfoParcel::Unmarshalling(Parcel &parcel)
599 {
600 sptr<ExtraElementInfoParcel> extraElementInfo = new(std::nothrow) ExtraElementInfoParcel();
601 if (extraElementInfo == nullptr) {
602 HILOG_ERROR("Failed to create extraElementInfo.");
603 return nullptr;
604 }
605 if (!extraElementInfo->ReadFromParcel(parcel)) {
606 HILOG_ERROR("read from parcel failed");
607 return nullptr;
608 }
609 return extraElementInfo;
610 }
611
SpanInfoParcel(const SpanInfo & spanInfo)612 SpanInfoParcel::SpanInfoParcel(const SpanInfo &spanInfo)
613 : SpanInfo(spanInfo)
614 {
615 }
616
ReadFromParcel(Parcel & parcel)617 bool SpanInfoParcel::ReadFromParcel(Parcel &parcel)
618 {
619 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, spanId_);
620 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, spanText_);
621 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, accessibilityText_);
622 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, accessibilityDescription_);
623 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, accessibilityLevel_);
624 return true;
625 }
626
Marshalling(Parcel & parcel) const627 bool SpanInfoParcel::Marshalling(Parcel &parcel) const
628 {
629 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, spanId_);
630 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, spanText_);
631 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, accessibilityText_);
632 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, accessibilityDescription_);
633 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, accessibilityLevel_);
634 return true;
635 }
636
Unmarshalling(Parcel & parcel)637 sptr<SpanInfoParcel> SpanInfoParcel::Unmarshalling(Parcel& parcel)
638 {
639 sptr<SpanInfoParcel> spanInfo = new(std::nothrow) SpanInfoParcel();
640 if (spanInfo == nullptr) {
641 HILOG_ERROR("Failed to create spanInfo.");
642 return nullptr;
643 }
644 if (!spanInfo->ReadFromParcel(parcel)) {
645 HILOG_ERROR("read from parcel failed");
646 return nullptr;
647 }
648 return spanInfo;
649 }
650 } // namespace Accessibility
651 } // namespace OHOS