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