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