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 "napi_accessibility_element.h"
17 #include <algorithm>
18 #include <map>
19 #include <vector>
20 #include <cinttypes>
21 #include "accessible_ability_client.h"
22 #include "hilog_wrapper.h"
23 #include "accessibility_utils.h"
24 #include "nlohmann/json.hpp"
25
26 #include "ipc_skeleton.h"
27 #include "tokenid_kit.h"
28 #include "accesstoken_kit.h"
29 #include "api_reporter_helper.h"
30 #include "scope_guard.h"
31
32 using namespace OHOS;
33 using namespace OHOS::Accessibility;
34 using namespace OHOS::AccessibilityNapi;
35 using namespace Security::AccessToken;
36
37 namespace {
38 constexpr char ACCESSIBILITY_FOCUSED[] = "accessibilityFocused";
39 constexpr char BUNDLE_NAME[] = "bundleName";
40 constexpr char CHECKABLE[] = "checkable";
41 constexpr char CHECKED[] = "checked";
42 constexpr char CLICKABLE[] = "clickable";
43 constexpr char COMPONENT_ID[] = "componentId";
44 constexpr char COMPONENT_TYPE[] = "componentType";
45 constexpr char CONTENTS[] = "contents";
46 constexpr char CURRENT_INDEX[] = "currentIndex";
47 constexpr char DESCRIPTION[] = "description";
48 constexpr char ERROR[] = "error";
49 constexpr char FOCUSABLE[] = "focusable";
50 constexpr char HINT_TEXT[] = "hintText";
51 constexpr char INPUT_TYPE[] = "inputType";
52 constexpr char IS_ACTIVE[] = "isActive";
53 constexpr char IS_ENABLE[] = "isEnable";
54 constexpr char IS_FOCUSED[] = "isFocused";
55 constexpr char IS_HINT[] = "isHint";
56 constexpr char IS_PASSWORD[] = "isPassword";
57 constexpr char IS_VISIBLE[] = "isVisible";
58 constexpr char LAST_CONTENT[] = "lastContent";
59 constexpr char LONG_CLICKABLE[] = "longClickable";
60 constexpr char MAIN_WINDOW_ID[] = "mainWindowId";
61 constexpr char NAV_DESTINATION_ID[] = "navDestinationId";
62 constexpr char PAGE_ID[] = "pageId";
63 constexpr char PARENT[] = "parent";
64 constexpr char PLURAL_LINE_SUPPORTED[] = "pluralLineSupported";
65 constexpr char RESOURCE_NAME[] = "resourceName";
66 constexpr char ROW[] = "row";
67 constexpr char SCROLLABLE[] = "scrollable";
68 constexpr char SELECTED[] = "selected";
69 constexpr char SPAN[] = "span";
70 constexpr char TEXT[] = "text";
71 constexpr char TEXT_LENGTH_LIMIT[] = "textLengthLimit";
72 constexpr char TEXT_MOVE_UNIT[] = "textMoveUnit";
73 constexpr char TRIGGER_ACTION[] = "triggerAction";
74 constexpr char VALUE_MAX[] = "valueMax";
75 constexpr char VALUE_MIN[] = "valueMin";
76 constexpr char VALUE_NOW[] = "valueNow";
77 constexpr char WINDOW_ID[] = "windowId";
78 constexpr char ACCESSIBILITY_TEXT[] = "accessibilityText";
79 constexpr char TEXT_TYPE[] = "textType";
80 constexpr char OFFSET[] = "offset";
81 constexpr char CURRENT_ITEM[] = "currentItem";
82 constexpr char ACCESSIBILITY_GROUP[] = "accessibilityGroup";
83 constexpr char ACCESSIBILITY_LEVEL[] = "accessibilityLevel";
84 constexpr char CHECKBOX_GROUP_SELECTED_STATUS[] = "checkboxGroupSelectedStatus";
85 constexpr char COLUMN[] = "column";
86 constexpr char LIST_ITEM_INDEX[] = "listItemIndex";
87 constexpr char SIDE_BAR_CONTAINER_STATES[] = "sideBarContainerStates";
88 constexpr char ALL_ATTRIBUTE[] = "allAttribute";
89 constexpr char CLIP[] = "clip";
90 constexpr char CUSTOM_COMPONENT_TYPE[] = "customComponentType";
91 constexpr char EXTRA_INFO[] = "extraInfo";
92 constexpr char ACCESSIBILITY_NEXT_FOCUS_ID[] = "accessibilityNextFocusId";
93 constexpr char ACCESSIBILITY_PREVIOUS_FOCUS_ID[] = "accessibilityPreviousFocusId";
94 constexpr char PARENT_ID[] = "parentId";
95 constexpr char CHILDREN_IDS[] = "childrenIds";
96 constexpr char ACCESSIBILITY_SCROLLABLE[] = "accessibilityScrollable";
97 constexpr char EDITABLE[] = "editable";
98 constexpr char END_INDEX[] = "endIndex";
99 constexpr char INSPECTOR_KEY[] = "inspectorKey";
100 constexpr char ITEM_COUNT[] = "itemCount";
101 constexpr char LAYER[] = "layer";
102 constexpr char RECT[] = "rect";
103 constexpr char SCREEN_RECT[] = "screenRect";
104 constexpr char START_INDEX[] = "startIndex";
105 constexpr char TYPE[] = "type";
106 constexpr char HOT_AREA[] = "hotArea";
107 constexpr char SUPPORTED_ACTION_NAMES[] = "supportedActionNames";
108 constexpr char ACCESSIBILITY_VISIBLE[] = "accessibilityVisible";
109
110 const std::vector<std::string> ELEMENT_INFO_ATTRIBUTE_NAMES = {"componentId", "inspectorKey",
111 "bundleName", "componentType", "inputType", "text", "hintText", "description", "triggerAction",
112 "textMoveUnit", "contents", "lastContent", "itemCount", "currentIndex", "startIndex", "endIndex",
113 "resourceName", "textLengthLimit", "rect", "checkable", "checked", "focusable", "isVisible", "mainWindowId",
114 "selected", "clickable", "longClickable", "isEnable", "isPassword", "scrollable", "navDestinationId",
115 "editable", "pluralLineSupported", "parent", "children", "isFocused", "accessibilityFocused",
116 "error", "isHint", "pageId", "valueMax", "valueMin", "valueNow", "windowId", "accessibilityText",
117 "textType", "offset", "currentItem", "accessibilityGroup", "accessibilityLevel", "checkboxGroupSelectedStatus",
118 "row", "column", "listItemIndex", "sideBarContainerStates", "span", "isActive", "accessibilityVisible",
119 "allAttribute", "clip", "customComponentType", "extraInfo", "accessibilityNextFocusId",
120 "accessibilityPreviousFocusId", "parentId", "childrenIds", "accessibilityScrollable"};
121 const std::vector<std::string> WINDOW_INFO_ATTRIBUTE_NAMES = {"isActive", "screenRect", "layer", "type",
122 "rootElement", "isFocused", "windowId", "mainWindowId"};
123
124 using AttributeNamesFunc = void (*)(NAccessibilityElementData *callbackInfo, napi_value &value);
125 std::map<std::string, AttributeNamesFunc> elementInfoCompleteMap = {
126 {"componentId", &NAccessibilityElement::GetElementInfoComponentId},
127 {"inspectorKey", &NAccessibilityElement::GetElementInfoInspectorKey},
128 {"bundleName", &NAccessibilityElement::GetElementInfoBundleName},
129 {"componentType", &NAccessibilityElement::GetElementInfoComponentType},
130 {"inputType", &NAccessibilityElement::GetElementInfoInputType},
131 {"text", &NAccessibilityElement::GetElementInfoText},
132 {"hintText", &NAccessibilityElement::GetElementInfoHintText},
133 {"description", &NAccessibilityElement::GetElementInfoDescription},
134 {"resourceName", &NAccessibilityElement::GetElementInfoResourceName},
135 {"textLengthLimit", &NAccessibilityElement::GetElementInfoTextLengthLimit},
136 {"rect", &NAccessibilityElement::GetElementInfoRect},
137 {"checkable", &NAccessibilityElement::GetElementInfoCheckable},
138 {"checked", &NAccessibilityElement::GetElementInfoChecked},
139 {"focusable", &NAccessibilityElement::GetElementInfoFocusable},
140 {"isVisible", &NAccessibilityElement::GetElementInfoIsVisible},
141 {"selected", &NAccessibilityElement::GetElementInfoSelected},
142 {"clickable", &NAccessibilityElement::GetElementInfoClickable},
143 {"longClickable", &NAccessibilityElement::GetElementInfoLongClickable},
144 {"isEnable", &NAccessibilityElement::GetElementInfoIsEnable},
145 {"isPassword", &NAccessibilityElement::GetElementInfoIsPassword},
146 {"scrollable", &NAccessibilityElement::GetElementInfoScrollable},
147 {"editable", &NAccessibilityElement::GetElementInfoEditable},
148 {"pluralLineSupported", &NAccessibilityElement::GetElementInfoPluralLineSupported},
149 {"itemCount", &NAccessibilityElement::GetElementInfoItemCount},
150 {"currentIndex", &NAccessibilityElement::GetElementInfoCurrentIndex},
151 {"startIndex", &NAccessibilityElement::GetElementInfoStartIndex},
152 {"endIndex", &NAccessibilityElement::GetElementInfoEndIndex},
153 {"textMoveUnit", &NAccessibilityElement::GetElementInfoTextMoveUnit},
154 {"parent", &NAccessibilityElement::GetElementInfoParent},
155 {"children", &NAccessibilityElement::GetElementInfoChildren},
156 {"triggerAction", &NAccessibilityElement::GetElementInfoTriggerAction},
157 {"contents", &NAccessibilityElement::GetElementInfoContents},
158 {"lastContent", &NAccessibilityElement::GetElementInfoLastContent},
159 {"isFocused", &NAccessibilityElement::GetElementInfoIsFocused},
160 {"accessibilityFocused", &NAccessibilityElement::GetElementInfoAccessibilityFocused},
161 {"error", &NAccessibilityElement::GetElementInfoError},
162 {"isHint", &NAccessibilityElement::GetElementInfoIsHint},
163 {"pageId", &NAccessibilityElement::GetElementInfoPageId},
164 {"valueMax", &NAccessibilityElement::GetElementInfoValueMax},
165 {"valueMin", &NAccessibilityElement::GetElementInfoValueMin},
166 {"valueNow", &NAccessibilityElement::GetElementInfoValueNow},
167 {"windowId", &NAccessibilityElement::GetElementInfoWindowId},
168 {"accessibilityText", &NAccessibilityElement::GetElementInfoAccessibilityText},
169 {"textType", &NAccessibilityElement::GetElementInfoTextType},
170 {"offset", &NAccessibilityElement::GetElementInfoOffset},
171 {"accessibilityGroup", &NAccessibilityElement::GetElementInfoAccessibilityGroup},
172 {"accessibilityLevel", &NAccessibilityElement::GetElementInfoAccessibilityLevel},
173 {"navDestinationId", &NAccessibilityElement::GetElementInfoNavDestinationId},
174 {"currentItem", &NAccessibilityElement::GetElementInfoGridItem},
175 {"checkboxGroupSelectedStatus", &NAccessibilityElement::GetElementInfoCheckboxGroup},
176 {"row", &NAccessibilityElement::GetElementInfoRow},
177 {"column", &NAccessibilityElement::GetElementInfoColumn},
178 {"listItemIndex", &NAccessibilityElement::GetElementInfoListItemIndex},
179 {"sideBarContainerStates", &NAccessibilityElement::GetElementInfoSideBarContainer},
180 {"span", &NAccessibilityElement::GetElementInfoSpan},
181 {"isActive", &NAccessibilityElement::GetElementInfoIsActive},
182 {"accessibilityVisible", &NAccessibilityElement::GetElementInfoAccessibilityVisible},
183 {"mainWindowId", &NAccessibilityElement::GetElementInfoMainWindowId},
184 {"clip", &NAccessibilityElement::GetElementInfoClip},
185 {"customComponentType", &NAccessibilityElement::GetElementInfoCustomComponentType},
186 {"extraInfo", &NAccessibilityElement::GetElementInfoExtraInfo},
187 {"accessibilityNextFocusId", &NAccessibilityElement::GetElementInfoAccessibilityNextFocusId},
188 {"accessibilityPreviousFocusId", &NAccessibilityElement::GetElementInfoAccessibilityPreviousFocusId},
189 {"parentId", &NAccessibilityElement::GetElementInfoAccessibilityParentId},
190 {"childrenIds", &NAccessibilityElement::GetElementInfoAccessibilityChildrenIds},
191 {"allAttribute", &NAccessibilityElement::GetElementInfoAllAttribute},
192 {"accessibilityScrollable", &NAccessibilityElement::GetElementInfoAccessibilityScrollable},
193 {"supportedActionNames", &NAccessibilityElement::GetElementInfoSupportedActionNames},
194 };
195 std::map<std::string, AttributeNamesFunc> windowInfoCompleteMap = {
196 {"isActive", &NAccessibilityElement::GetWindowInfoIsActive},
197 {"screenRect", &NAccessibilityElement::GetWindowInfoScreenRect},
198 {"layer", &NAccessibilityElement::GetWindowInfoLayer},
199 {"type", &NAccessibilityElement::GetWindowInfoType},
200 {"rootElement", &NAccessibilityElement::GetWindowInfoRootElement},
201 {"isFocused", &NAccessibilityElement::GetWindowInfoIsFocused},
202 {"windowId", &NAccessibilityElement::GetWindowInfoWindowId},
203 {"mainWindowId", &NAccessibilityElement::GetWindowInfoMainWindowId},
204 {"hotArea", &NAccessibilityElement::GetWindowInfoHotArea},
205 };
206
207 napi_property_descriptor descForAccessibilityElement[] = {
208 DECLARE_NAPI_FUNCTION("attributeNames", NAccessibilityElement::AttributeNames),
209 DECLARE_NAPI_FUNCTION("attributeValue", NAccessibilityElement::AttributeValue),
210 DECLARE_NAPI_FUNCTION("actionNames", NAccessibilityElement::ActionNames),
211 DECLARE_NAPI_FUNCTION("enableScreenCurtain", NAccessibilityElement::EnableScreenCurtain),
212 DECLARE_NAPI_FUNCTION("performAction", NAccessibilityElement::PerformAction),
213 DECLARE_NAPI_FUNCTION("getCursorPosition", NAccessibilityElement::GetCursorPosition),
214 DECLARE_NAPI_FUNCTION("findElement", NAccessibilityElement::FindElement),
215 DECLARE_NAPI_FUNCTION("findElementById", NAccessibilityElement::FindElementById),
216 DECLARE_NAPI_FUNCTION("findElementByContent", NAccessibilityElement::FindElementByContent),
217 DECLARE_NAPI_FUNCTION("findElementByFocusDirection", NAccessibilityElement::FindElementByFocusDirection),
218 DECLARE_NAPI_FUNCTION("findElementsByAccessibilityHintText",
219 NAccessibilityElement::FindElementsByAccessibilityHintText),
220 DECLARE_NAPI_FUNCTION("getParent", NAccessibilityElement::GetParent),
221 DECLARE_NAPI_FUNCTION("getChildren", NAccessibilityElement::GetChildren),
222 DECLARE_NAPI_FUNCTION("getRoot", NAccessibilityElement::GetRootElement),
223 DECLARE_NAPI_FUNCTION("executeAction", NAccessibilityElement::ExecuteAction),
224 DECLARE_NAPI_GETTER(ACCESSIBILITY_FOCUSED, GetElementProperty<ElementProperty<ACCESSIBILITY_FOCUSED>>),
225 DECLARE_NAPI_GETTER(BUNDLE_NAME, GetElementProperty<ElementProperty<BUNDLE_NAME>>),
226 DECLARE_NAPI_GETTER(CHECKABLE, GetElementProperty<ElementProperty<CHECKABLE>>),
227 DECLARE_NAPI_GETTER(CHECKED, GetElementProperty<ElementProperty<CHECKED>>),
228 DECLARE_NAPI_GETTER(CLICKABLE, GetElementProperty<ElementProperty<CLICKABLE>>),
229 DECLARE_NAPI_GETTER(COMPONENT_ID, GetElementProperty<ElementProperty<COMPONENT_ID>>),
230 DECLARE_NAPI_GETTER(COMPONENT_TYPE, GetElementProperty<ElementProperty<COMPONENT_TYPE>>),
231 DECLARE_NAPI_GETTER(CONTENTS, GetElementProperty<ElementProperty<CONTENTS>>),
232 DECLARE_NAPI_GETTER(CURRENT_INDEX, GetElementProperty<ElementProperty<CURRENT_INDEX>>),
233 DECLARE_NAPI_GETTER(DESCRIPTION, GetElementProperty<ElementProperty<DESCRIPTION>>),
234 DECLARE_NAPI_GETTER(EDITABLE, GetElementProperty<ElementProperty<EDITABLE>>),
235 DECLARE_NAPI_GETTER(END_INDEX, GetElementProperty<ElementProperty<END_INDEX>>),
236 DECLARE_NAPI_GETTER(ERROR, GetElementProperty<ElementProperty<ERROR>>),
237 DECLARE_NAPI_GETTER(FOCUSABLE, GetElementProperty<ElementProperty<FOCUSABLE>>),
238 DECLARE_NAPI_GETTER(HINT_TEXT, GetElementProperty<ElementProperty<HINT_TEXT>>),
239 DECLARE_NAPI_GETTER(INPUT_TYPE, GetElementProperty<ElementProperty<INPUT_TYPE>>),
240 DECLARE_NAPI_GETTER(INSPECTOR_KEY, GetElementProperty<ElementProperty<INSPECTOR_KEY>>),
241 DECLARE_NAPI_GETTER(IS_ACTIVE, GetElementProperty<ElementProperty<IS_ACTIVE>>),
242 DECLARE_NAPI_GETTER(IS_ENABLE, GetElementProperty<ElementProperty<IS_ENABLE>>),
243 DECLARE_NAPI_GETTER(IS_HINT, GetElementProperty<ElementProperty<IS_HINT>>),
244 DECLARE_NAPI_GETTER(IS_FOCUSED, GetElementProperty<ElementProperty<IS_FOCUSED>>),
245 DECLARE_NAPI_GETTER(IS_PASSWORD, GetElementProperty<ElementProperty<IS_PASSWORD>>),
246 DECLARE_NAPI_GETTER(IS_VISIBLE, GetElementProperty<ElementProperty<IS_VISIBLE>>),
247 DECLARE_NAPI_GETTER(ITEM_COUNT, GetElementProperty<ElementProperty<ITEM_COUNT>>),
248 DECLARE_NAPI_GETTER(LAST_CONTENT, GetElementProperty<ElementProperty<LAST_CONTENT>>),
249 DECLARE_NAPI_GETTER(LAYER, GetElementProperty<ElementProperty<LAYER>>),
250 DECLARE_NAPI_GETTER(LONG_CLICKABLE, GetElementProperty<ElementProperty<LONG_CLICKABLE>>),
251 DECLARE_NAPI_GETTER(PAGE_ID, GetElementProperty<ElementProperty<PAGE_ID>>),
252 DECLARE_NAPI_GETTER(PLURAL_LINE_SUPPORTED, GetElementProperty<ElementProperty<PLURAL_LINE_SUPPORTED>>),
253 DECLARE_NAPI_GETTER(RECT, GetElementProperty<ElementProperty<RECT>>),
254 DECLARE_NAPI_GETTER(RESOURCE_NAME, GetElementProperty<ElementProperty<RESOURCE_NAME>>),
255 DECLARE_NAPI_GETTER(SCREEN_RECT, GetElementProperty<ElementProperty<SCREEN_RECT>>),
256 DECLARE_NAPI_GETTER(SCROLLABLE, GetElementProperty<ElementProperty<SCROLLABLE>>),
257 DECLARE_NAPI_GETTER(SELECTED, GetElementProperty<ElementProperty<SELECTED>>),
258 DECLARE_NAPI_GETTER(START_INDEX, GetElementProperty<ElementProperty<START_INDEX>>),
259 DECLARE_NAPI_GETTER(TEXT, GetElementProperty<ElementProperty<TEXT>>),
260 DECLARE_NAPI_GETTER(TEXT_LENGTH_LIMIT, GetElementProperty<ElementProperty<TEXT_LENGTH_LIMIT>>),
261 DECLARE_NAPI_GETTER(TEXT_MOVE_UNIT, GetElementProperty<ElementProperty<TEXT_MOVE_UNIT>>),
262 DECLARE_NAPI_GETTER(TRIGGER_ACTION, GetElementProperty<ElementProperty<TRIGGER_ACTION>>),
263 DECLARE_NAPI_GETTER(TYPE, GetElementProperty<ElementProperty<TYPE>>),
264 DECLARE_NAPI_GETTER(VALUE_MAX, GetElementProperty<ElementProperty<VALUE_MAX>>),
265 DECLARE_NAPI_GETTER(VALUE_MIN, GetElementProperty<ElementProperty<VALUE_MIN>>),
266 DECLARE_NAPI_GETTER(VALUE_NOW, GetElementProperty<ElementProperty<VALUE_NOW>>),
267 DECLARE_NAPI_GETTER(WINDOW_ID, GetElementProperty<ElementProperty<WINDOW_ID>>),
268 DECLARE_NAPI_GETTER(OFFSET, GetElementProperty<ElementProperty<OFFSET>>),
269 DECLARE_NAPI_GETTER(TEXT_TYPE, GetElementProperty<ElementProperty<TEXT_TYPE>>),
270 DECLARE_NAPI_GETTER(ACCESSIBILITY_TEXT, GetElementProperty<ElementProperty<ACCESSIBILITY_TEXT>>),
271 DECLARE_NAPI_GETTER(HOT_AREA, GetElementProperty<ElementProperty<HOT_AREA>>),
272 DECLARE_NAPI_GETTER(CUSTOM_COMPONENT_TYPE, GetElementProperty<ElementProperty<CUSTOM_COMPONENT_TYPE>>),
273 DECLARE_NAPI_GETTER(
274 ACCESSIBILITY_NEXT_FOCUS_ID, GetElementProperty<ElementProperty<ACCESSIBILITY_NEXT_FOCUS_ID>>),
275 DECLARE_NAPI_GETTER(
276 ACCESSIBILITY_PREVIOUS_FOCUS_ID, GetElementProperty<ElementProperty<ACCESSIBILITY_PREVIOUS_FOCUS_ID>>),
277 DECLARE_NAPI_GETTER(EXTRA_INFO, GetElementProperty<ElementProperty<EXTRA_INFO>>),
278 DECLARE_NAPI_GETTER(ACCESSIBILITY_SCROLLABLE, GetElementProperty<ElementProperty<ACCESSIBILITY_SCROLLABLE>>),
279 DECLARE_NAPI_GETTER(SUPPORTED_ACTION_NAMES, GetElementProperty<ElementProperty<SUPPORTED_ACTION_NAMES>>),
280 DECLARE_NAPI_GETTER(ACCESSIBILITY_GROUP, GetElementProperty<ElementProperty<ACCESSIBILITY_GROUP>>),
281 DECLARE_NAPI_GETTER(ACCESSIBILITY_LEVEL, GetElementProperty<ElementProperty<ACCESSIBILITY_LEVEL>>),
282 DECLARE_NAPI_GETTER(NAV_DESTINATION_ID, GetElementProperty<ElementProperty<NAV_DESTINATION_ID>>),
283 DECLARE_NAPI_GETTER(CURRENT_ITEM, GetElementProperty<ElementProperty<CURRENT_ITEM>>),
284 DECLARE_NAPI_GETTER("spans", GetElementProperty<ElementProperty<SPAN>>),
285 DECLARE_NAPI_GETTER(ACCESSIBILITY_VISIBLE, GetElementProperty<ElementProperty<ACCESSIBILITY_VISIBLE>>),
286 DECLARE_NAPI_GETTER(MAIN_WINDOW_ID, GetElementProperty<ElementProperty<MAIN_WINDOW_ID>>),
287 DECLARE_NAPI_GETTER(CLIP, GetElementProperty<ElementProperty<CLIP>>),
288 DECLARE_NAPI_GETTER(PARENT_ID, GetElementProperty<ElementProperty<PARENT_ID>>),
289 DECLARE_NAPI_GETTER(CHILDREN_IDS, GetElementProperty<ElementProperty<CHILDREN_IDS>>),
290 };
291
292 const std::vector<std::string> ACTION_NAMES = {
293 "accessibilityFocus", //AccessibilityAction.ACCESSIBILITY_FOCUS=0
294 "clearAccessibilityFocus", //AccessibilityAction.CLEAR_ACCESSIBILITY_FOCUS=1
295 "focus", //AccessibilityAction.FOCUS=2
296 "clearFocus", //AccessibilityAction.CLEAR_FOCUS=3
297 "click", //AccessibilityAction.CLICK=4
298 "longClick", //AccessibilityAction.LONG_CLICK=5
299 "cut", //AccessibilityAction.CUT=6
300 "copy", //AccessibilityAction.COPY=7
301 "paste", //AccessibilityAction.PASTE=8
302 "select", //AccessibilityAction.SELECT=9
303 "setText", //AccessibilityAction.SET_TEXT=10
304 "scrollForward", //AccessibilityAction.SCROLL_FORWARD=11
305 "scrollBackward", //AccessibilityAction.SCROLL_BACKWARD=12
306 "setSelection", //AccessibilityAction.SET_SELECTION=13
307 "setCursorPosition", //AccessibilityAction.SET_CURSOR_POSITION=14
308 "home", //AccessibilityAction.HOME=15
309 "back", //AccessibilityAction.BACK=16
310 "recentTask", //AccessibilityAction.RECENT_TASK=17
311 "notificationCenter", //AccessibilityAction.NOTIFICATION_CENTER=18
312 "controlCenter", //AccessibilityAction.CONTROL_CENTER=19
313 "common", //AccessibilityAction.COMMON=20
314 "spanClick" //AccessibilityAction.SPAN_CLICK=21
315 };
316 } // namespace
317
318 napi_ref NAccessibilityElement::consRef_ = nullptr;
319
DefineJSAccessibilityElement(napi_env env)320 void NAccessibilityElement::DefineJSAccessibilityElement(napi_env env)
321 {
322 napi_value constructor = nullptr;
323
324 NAPI_CALL_RETURN_VOID(env,
325 napi_define_class(env,
326 "AccessibilityElement",
327 NAPI_AUTO_LENGTH,
328 NAccessibilityElement::JSConstructor,
329 nullptr,
330 sizeof(descForAccessibilityElement) / sizeof(descForAccessibilityElement[0]),
331 descForAccessibilityElement,
332 &constructor));
333 napi_create_reference(env, constructor, 1, &NAccessibilityElement::consRef_);
334 }
335
JSConstructor(napi_env env,napi_callback_info info)336 napi_value NAccessibilityElement::JSConstructor(napi_env env, napi_callback_info info)
337 {
338 napi_value jsthis = nullptr;
339 NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &jsthis, nullptr));
340 return jsthis;
341 }
342
ConvertElementInfoToJS(napi_env env,napi_value result,const AccessibilityElementInfo & elementInfo)343 void NAccessibilityElement::ConvertElementInfoToJS(napi_env env, napi_value result,
344 const AccessibilityElementInfo& elementInfo)
345 {
346 // Bind js object to a Native object
347 std::shared_ptr<AccessibilityElementInfo> elementInformation =
348 std::make_shared<AccessibilityElementInfo>(elementInfo);
349 AccessibilityElement* pAccessibilityElement = new(std::nothrow) AccessibilityElement(elementInformation);
350 if (pAccessibilityElement == nullptr) {
351 HILOG_ERROR("Failed to create elementInformation.");
352 return;
353 }
354 napi_status sts = napi_wrap(
355 env,
356 result,
357 pAccessibilityElement,
358 [](napi_env env, void* data, void* hint) {
359 AccessibilityElement* info = static_cast<AccessibilityElement*>(data);
360 delete info;
361 info = nullptr;
362 },
363 nullptr,
364 nullptr);
365 if (sts != napi_ok) {
366 delete pAccessibilityElement;
367 pAccessibilityElement = nullptr;
368 HILOG_ERROR("failed to wrap JS object");
369 }
370 HILOG_DEBUG("napi_wrap status: %{public}d", (int)sts);
371 }
372
ConvertElementInfosToJS(napi_env env,napi_value result,const std::vector<OHOS::Accessibility::AccessibilityElementInfo> & elementInfos)373 void NAccessibilityElement::ConvertElementInfosToJS(
374 napi_env env, napi_value result, const std::vector<OHOS::Accessibility::AccessibilityElementInfo>& elementInfos)
375 {
376 HILOG_DEBUG("elementInfo size(%{public}zu)", elementInfos.size());
377
378 napi_value constructor = nullptr;
379 napi_get_reference_value(env, NAccessibilityElement::consRef_, &constructor);
380
381 size_t index = 0;
382 for (auto& elementInfo : elementInfos) {
383 napi_value obj = nullptr;
384 napi_status status = napi_new_instance(env, constructor, 0, nullptr, &obj);
385 HILOG_DEBUG("status is %{public}d", status);
386 ConvertElementInfoToJS(env, obj, elementInfo);
387 napi_set_element(env, result, index, obj);
388 index++;
389 }
390 }
391
ConvertElementIdVecToJS(napi_env env,napi_value result,const std::vector<OHOS::Accessibility::AccessibilityElementInfo> & elementInfos)392 void NAccessibilityElement::ConvertElementIdVecToJS(
393 napi_env env, napi_value result, const std::vector<OHOS::Accessibility::AccessibilityElementInfo>& elementInfos)
394 {
395 HILOG_DEBUG("elementInfo size(%{public}zu)", elementInfos.size());
396 if (elementInfos.size() == 0) {
397 return;
398 }
399
400 size_t index = 0;
401 std::vector<std::int64_t> values;
402 int64_t elementId = elementInfos[0].GetAccessibilityId();
403 HILOG_DEBUG("default focus is %{public}" PRId64 "", elementId);
404 values.emplace_back(elementId);
405
406 for (auto& value : values) {
407 napi_value id = nullptr;
408 napi_create_int64(env, value, &id);
409 napi_set_element(env, result, index, id);
410 index++;
411 }
412 }
413
AttributeNames(napi_env env,napi_callback_info info)414 napi_value NAccessibilityElement::AttributeNames(napi_env env, napi_callback_info info)
415 {
416 HILOG_DEBUG();
417 #ifdef ACCESSIBILITY_EMULATOR_DEFINED
418 ApiReportHelper reporter("NAccessibilityElement.AttributeNames");
419 #endif // ACCESSIBILITY_EMULATOR_DEFINED
420 size_t argc = ARGS_SIZE_ONE;
421 napi_value argv = nullptr;
422 napi_value thisVar = nullptr;
423 void* data = nullptr;
424 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &argv, &thisVar, &data));
425 HILOG_DEBUG("argc = %{public}d", (int)argc);
426
427 AccessibilityElement* accessibilityElement = nullptr;
428 napi_status status = napi_unwrap(env, thisVar, (void**)&accessibilityElement);
429 if (!accessibilityElement || status != napi_ok) {
430 HILOG_ERROR("accessibilityElement is null or status[%{public}d] is wrong", status);
431 napi_value err = CreateBusinessError(env, RetError::RET_ERR_NULLPTR);
432 napi_throw(env, err);
433 return nullptr;
434 }
435
436 NAccessibilityElementData *callbackInfo = new(std::nothrow) NAccessibilityElementData();
437 if (callbackInfo == nullptr) {
438 HILOG_ERROR("Failed to create callbackInfo.");
439 return nullptr;
440 }
441 callbackInfo->env_ = env;
442
443 napi_value promise = nullptr;
444 if (argc > ARGS_SIZE_ONE - 1) {
445 napi_valuetype valueType = napi_null;
446 napi_typeof(env, argv, &valueType);
447 if (valueType == napi_function) {
448 napi_create_reference(env, argv, 1, &callbackInfo->callback_);
449 napi_get_undefined(env, &promise);
450 } else {
451 napi_create_promise(env, &callbackInfo->deferred_, &promise);
452 }
453 } else {
454 napi_create_promise(env, &callbackInfo->deferred_, &promise);
455 }
456
457 callbackInfo->accessibilityElement_ = *accessibilityElement;
458
459 napi_value resource = nullptr;
460 napi_create_string_utf8(env, "AttributeNames", NAPI_AUTO_LENGTH, &resource);
461 if (resource == nullptr) {
462 HILOG_ERROR("resource is nullptr.");
463 delete callbackInfo;
464 callbackInfo = nullptr;
465 return nullptr;
466 }
467 napi_create_async_work(env, nullptr, resource, [](napi_env env, void* data) {},
468 // Execute the complete function
469 AttributeNamesComplete,
470 reinterpret_cast<void*>(callbackInfo),
471 &callbackInfo->work_);
472 napi_queue_async_work_with_qos(env, callbackInfo->work_, napi_qos_user_initiated);
473 return promise;
474 }
475
AttributeNamesComplete(napi_env env,napi_status status,void * data)476 void NAccessibilityElement::AttributeNamesComplete(napi_env env, napi_status status, void* data)
477 {
478 HILOG_DEBUG("AttributeNameComplete execute back");
479 NAccessibilityElementData* callbackInfo = static_cast<NAccessibilityElementData*>(data);
480 napi_value result[ARGS_SIZE_TWO] = {0};
481 napi_value callback = 0;
482 napi_value undefined = 0;
483 napi_get_undefined(env, &undefined);
484 if (callbackInfo == nullptr) {
485 HILOG_ERROR("callbackInfo is nullptr");
486 return;
487 }
488
489 napi_create_array(env, &result[1]);
490 if (callbackInfo->accessibilityElement_.isElementInfo_) {
491 HILOG_DEBUG("covert element info to js");
492 ConvertStringVecToJS(env, result[1], ELEMENT_INFO_ATTRIBUTE_NAMES);
493 } else {
494 HILOG_DEBUG("covert window info to js");
495 ConvertStringVecToJS(env, result[1], WINDOW_INFO_ATTRIBUTE_NAMES);
496 }
497
498 if (callbackInfo->callback_) {
499 // Callback mode
500 result[PARAM0] = CreateBusinessError(env, OHOS::Accessibility::RetError::RET_OK);
501 napi_get_reference_value(env, callbackInfo->callback_, &callback);
502 napi_value returnVal = nullptr;
503 napi_call_function(env, undefined, callback, ARGS_SIZE_TWO, result, &returnVal);
504 napi_delete_reference(env, callbackInfo->callback_);
505 } else {
506 // Promise mode
507 napi_resolve_deferred(env, callbackInfo->deferred_, result[PARAM1]);
508 }
509 napi_delete_async_work(env, callbackInfo->work_);
510 delete callbackInfo;
511 callbackInfo = nullptr;
512 }
513
AttributeValue(napi_env env,napi_callback_info info)514 napi_value NAccessibilityElement::AttributeValue(napi_env env, napi_callback_info info)
515 {
516 size_t argc = ARGS_SIZE_TWO;
517 napi_value argv[ARGS_SIZE_TWO] = {0};
518 napi_value thisVar = nullptr;
519 void* data = nullptr;
520 napi_status status = napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
521 if (status != napi_ok) {
522 HILOG_ERROR("Failed to get cb info");
523 napi_value err = CreateBusinessError(env, RetError::RET_ERR_FAILED);
524 napi_throw(env, err);
525 return nullptr;
526 }
527 HILOG_DEBUG("argc = %{public}d", (int)argc);
528
529 // Unwrap AccessibilityElement
530 AccessibilityElement* accessibilityElement = nullptr;
531 status = napi_unwrap(env, thisVar, (void**)&accessibilityElement);
532 if (!accessibilityElement || status != napi_ok) {
533 HILOG_ERROR("accessibilityElement is null or status[%{public}d] is wrong", status);
534 napi_value err = CreateBusinessError(env, RetError::RET_ERR_NULLPTR);
535 napi_throw(env, err);
536 return nullptr;
537 }
538
539 NAccessibilityElementData *callbackInfo = new(std::nothrow) NAccessibilityElementData();
540 if (callbackInfo == nullptr) {
541 HILOG_ERROR("Failed to create callbackInfo.");
542 napi_value err = CreateBusinessError(env, RetError::RET_ERR_NULLPTR);
543 napi_throw(env, err);
544 return nullptr;
545 }
546 callbackInfo->env_ = env;
547 callbackInfo->accessibilityElement_ = *accessibilityElement;
548
549 NAccessibilityErrorCode errCode = GetAttribute(env, argc, argv, callbackInfo);
550 if (errCode == NAccessibilityErrorCode::ACCESSIBILITY_ERROR_INVALID_PARAM) {
551 delete callbackInfo;
552 callbackInfo = nullptr;
553 delete accessibilityElement;
554 accessibilityElement = nullptr;
555 napi_value err = CreateBusinessError(env, RetError::RET_ERR_INVALID_PARAM);
556 HILOG_ERROR("invalid param");
557 napi_throw(env, err);
558 return nullptr;
559 }
560
561 return AttributeValueAsync(env, argc, argv, callbackInfo);
562 }
563
GetAttribute(napi_env env,size_t argc,napi_value * argv,NAccessibilityElementData * callbackInfo)564 NAccessibilityErrorCode NAccessibilityElement::GetAttribute(
565 napi_env env, size_t argc, napi_value* argv, NAccessibilityElementData* callbackInfo)
566 {
567 NAccessibilityErrorCode errCode = NAccessibilityErrorCode::ACCESSIBILITY_OK;
568 if (argc < ARGS_SIZE_TWO - 1) {
569 HILOG_ERROR("argc is invalid: %{public}zu", argc);
570 errCode = NAccessibilityErrorCode::ACCESSIBILITY_ERROR_INVALID_PARAM;
571 }
572
573 if (errCode == NAccessibilityErrorCode::ACCESSIBILITY_OK) {
574 // Parse attribute name
575 std::string attribute = "";
576 if (ParseString(env, attribute, argv[PARAM0])) {
577 HILOG_DEBUG("attribute = %{public}s", attribute.c_str());
578 callbackInfo->attribute_ = attribute;
579 } else {
580 errCode = NAccessibilityErrorCode::ACCESSIBILITY_ERROR_INVALID_PARAM;
581 }
582 }
583 return errCode;
584 }
585
AttributeValueAsync(napi_env env,size_t argc,napi_value * argv,NAccessibilityElementData * callbackInfo)586 napi_value NAccessibilityElement::AttributeValueAsync(
587 napi_env env, size_t argc, napi_value* argv, NAccessibilityElementData* callbackInfo)
588 {
589 napi_value promise = nullptr;
590 if (argc > ARGS_SIZE_TWO - 1) {
591 napi_valuetype valueType = napi_null;
592 napi_typeof(env, argv[PARAM1], &valueType);
593 if (valueType == napi_function) {
594 napi_create_reference(env, argv[PARAM1], 1, &callbackInfo->callback_);
595 napi_get_undefined(env, &promise);
596 } else {
597 napi_create_promise(env, &callbackInfo->deferred_, &promise);
598 }
599 } else {
600 napi_create_promise(env, &callbackInfo->deferred_, &promise);
601 }
602
603 napi_value resource = nullptr;
604 napi_create_string_utf8(env, "AttributeValue", NAPI_AUTO_LENGTH, &resource);
605 napi_create_async_work(env, nullptr, resource, NAccessibilityElement::AttributeValueExecute,
606 NAccessibilityElement::AttributeValueComplete, reinterpret_cast<void*>(callbackInfo), &callbackInfo->work_);
607 napi_queue_async_work_with_qos(env, callbackInfo->work_, napi_qos_user_initiated);
608 return promise;
609 }
610
AttributeValueExecute(napi_env env,void * data)611 void NAccessibilityElement::AttributeValueExecute(napi_env env, void* data)
612 {
613 #ifdef ACCESSIBILITY_EMULATOR_DEFINED
614 ApiReportHelper reporter("NAccessibilityElement.AttributeValueExecute");
615 #endif // ACCESSIBILITY_EMULATOR_DEFINED
616 NAccessibilityElementData* callbackInfo = static_cast<NAccessibilityElementData*>(data);
617 if (callbackInfo == nullptr) {
618 HILOG_ERROR("callbackInfo is nullptr");
619 return;
620 }
621
622 bool systemApi = callbackInfo->systemApi;
623 HILOG_DEBUG("systemApi: %{public}d", systemApi);
624
625 if (callbackInfo->attribute_ == "parent") {
626 if (callbackInfo->accessibilityElement_.elementInfo_) {
627 callbackInfo->ret_ = AccessibleAbilityClient::GetInstance()->GetParentElementInfo(
628 *callbackInfo->accessibilityElement_.elementInfo_, callbackInfo->nodeInfo_, systemApi);
629 } else {
630 HILOG_ERROR("elementInfo is nullptr");
631 }
632 } else if (callbackInfo->attribute_ == "children") {
633 if (callbackInfo->accessibilityElement_.elementInfo_) {
634 callbackInfo->ret_ = AccessibleAbilityClient::GetInstance()->GetChildren(
635 *callbackInfo->accessibilityElement_.elementInfo_, callbackInfo->nodeInfos_, systemApi);
636 } else {
637 HILOG_ERROR("elementInfo is nullptr");
638 }
639 } else if (callbackInfo->attribute_ == "rootElement") {
640 if (callbackInfo->accessibilityElement_.windowInfo_) {
641 callbackInfo->ret_ = AccessibleAbilityClient::GetInstance()->GetRootByWindow(
642 *callbackInfo->accessibilityElement_.windowInfo_, callbackInfo->nodeInfo_, systemApi);
643 } else {
644 HILOG_ERROR("windowInfo is nullptr");
645 }
646 } else {
647 callbackInfo->ret_ = RET_OK;
648 }
649 HILOG_DEBUG("attribute[%{public}s], result[%{public}d]", callbackInfo->attribute_.c_str(), callbackInfo->ret_);
650 }
651
AttributeValueComplete(napi_env env,napi_status status,void * data)652 void NAccessibilityElement::AttributeValueComplete(napi_env env, napi_status status, void* data)
653 {
654 NAccessibilityElementData* callbackInfo = static_cast<NAccessibilityElementData*>(data);
655 if (callbackInfo == nullptr) {
656 HILOG_ERROR("callbackInfo is nullptr");
657 return;
658 }
659 napi_value result[ARGS_SIZE_TWO] = {0};
660
661 if (callbackInfo->accessibilityElement_.isElementInfo_) {
662 HILOG_DEBUG("It is element info");
663 auto elementIter = elementInfoCompleteMap.find(callbackInfo->attribute_);
664 if (elementIter == elementInfoCompleteMap.end()) {
665 HILOG_ERROR("There is no the attribute[%{public}s] in element info", callbackInfo->attribute_.c_str());
666 napi_get_undefined(callbackInfo->env_, &result[PARAM1]);
667 callbackInfo->ret_ = RET_ERR_PROPERTY_NOT_EXIST;
668 } else {
669 (*elementIter->second)(callbackInfo, result[PARAM1]);
670 }
671 } else {
672 HILOG_DEBUG("It is window info");
673 auto windowIter = windowInfoCompleteMap.find(callbackInfo->attribute_);
674 if (windowIter == windowInfoCompleteMap.end()) {
675 HILOG_ERROR("There is no the attribute[%{public}s]", callbackInfo->attribute_.c_str());
676 napi_get_undefined(callbackInfo->env_, &result[PARAM1]);
677 callbackInfo->ret_ = RET_ERR_PROPERTY_NOT_EXIST;
678 } else {
679 (*windowIter->second)(callbackInfo, result[PARAM1]);
680 }
681 }
682
683 HILOG_DEBUG("result is %{public}d", callbackInfo->ret_);
684 result[PARAM0] = CreateBusinessError(env, callbackInfo->ret_);
685 if (callbackInfo->callback_) {
686 napi_value callback = nullptr;
687 napi_value returnVal = nullptr;
688 napi_value undefined = nullptr;
689 napi_get_reference_value(env, callbackInfo->callback_, &callback);
690 napi_get_undefined(env, &undefined); // 是否加判断
691 napi_call_function(env, undefined, callback, ARGS_SIZE_TWO, result, &returnVal);
692 napi_delete_reference(env, callbackInfo->callback_);
693 } else {
694 if (callbackInfo->ret_ == RET_OK) {
695 napi_resolve_deferred(env, callbackInfo->deferred_, result[PARAM1]);
696 } else {
697 napi_reject_deferred(env, callbackInfo->deferred_, result[PARAM0]);
698 }
699 }
700 napi_delete_async_work(env, callbackInfo->work_);
701 delete callbackInfo;
702 callbackInfo = nullptr;
703 }
704
CheckElementInfoParameter(NAccessibilityElementData * callbackInfo,napi_value & value)705 bool NAccessibilityElement::CheckElementInfoParameter(NAccessibilityElementData *callbackInfo, napi_value &value)
706 {
707 if (callbackInfo == nullptr) {
708 HILOG_ERROR("callbackInfo is nullptr");
709 return false;
710 }
711 if (!callbackInfo->accessibilityElement_.elementInfo_) {
712 HILOG_ERROR("element info is nullptr");
713 napi_get_undefined(callbackInfo->env_, &value);
714 callbackInfo->ret_ = RET_ERR_FAILED;
715 return false;
716 }
717 return true;
718 }
719
RunAttributeValue(NAPICbInfo & cbInfo,NAccessibilityElementData * elementData,napi_value & result)720 RetError NAccessibilityElement::RunAttributeValue(NAPICbInfo& cbInfo, NAccessibilityElementData* elementData,
721 napi_value& result)
722 {
723 const auto& infoMap =
724 elementData->accessibilityElement_.isElementInfo_ ? elementInfoCompleteMap : windowInfoCompleteMap;
725
726 auto findResult = infoMap.find(elementData->attribute_);
727 if (findResult == infoMap.end()) {
728 HILOG_ERROR("There is no the attribute[%{public}s] in element info", elementData->attribute_.c_str());
729 napi_get_undefined(elementData->env_, &result);
730 return RetError::RET_OK;
731 }
732
733 (*findResult->second)(elementData, result);
734 return RetError::RET_OK;
735 }
736
GetProperty(napi_env env,napi_callback_info info,std::string key)737 napi_value NAccessibilityElement::GetProperty(napi_env env, napi_callback_info info, std::string key)
738 {
739 return QueryCommon(env,
740 info,
741 {ParseAccessibilityElement,
742 [key](NAPICbInfo& cbInfo, NAccessibilityElementData* elementData) {
743 elementData->attribute_ = key;
744 return RetError::RET_OK;
745 },
746 nullptr,
747 RunAttributeValue
748 });
749 }
750
GetElementInfoComponentId(NAccessibilityElementData * callbackInfo,napi_value & value)751 void NAccessibilityElement::GetElementInfoComponentId(NAccessibilityElementData *callbackInfo, napi_value &value)
752 {
753 if (!CheckElementInfoParameter(callbackInfo, value)) {
754 return;
755 }
756 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int64(callbackInfo->env_,
757 callbackInfo->accessibilityElement_.elementInfo_->GetAccessibilityId(), &value));
758 }
759
GetElementInfoPageId(NAccessibilityElementData * callbackInfo,napi_value & value)760 void NAccessibilityElement::GetElementInfoPageId(NAccessibilityElementData *callbackInfo, napi_value &value)
761 {
762 if (!CheckElementInfoParameter(callbackInfo, value)) {
763 return;
764 }
765 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
766 callbackInfo->accessibilityElement_.elementInfo_->GetPageId(), &value));
767 }
768
GetElementInfoInspectorKey(NAccessibilityElementData * callbackInfo,napi_value & value)769 void NAccessibilityElement::GetElementInfoInspectorKey(NAccessibilityElementData *callbackInfo, napi_value &value)
770 {
771 if (!CheckElementInfoParameter(callbackInfo, value)) {
772 return;
773 }
774 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
775 callbackInfo->accessibilityElement_.elementInfo_->GetInspectorKey().c_str(), NAPI_AUTO_LENGTH, &value));
776 }
777
GetElementInfoBundleName(NAccessibilityElementData * callbackInfo,napi_value & value)778 void NAccessibilityElement::GetElementInfoBundleName(NAccessibilityElementData *callbackInfo, napi_value &value)
779 {
780 if (!CheckElementInfoParameter(callbackInfo, value)) {
781 return;
782 }
783 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
784 callbackInfo->accessibilityElement_.elementInfo_->GetBundleName().c_str(), NAPI_AUTO_LENGTH, &value));
785 }
786
GetElementInfoComponentType(NAccessibilityElementData * callbackInfo,napi_value & value)787 void NAccessibilityElement::GetElementInfoComponentType(NAccessibilityElementData *callbackInfo, napi_value &value)
788 {
789 if (!CheckElementInfoParameter(callbackInfo, value)) {
790 return;
791 }
792 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
793 callbackInfo->accessibilityElement_.elementInfo_->GetComponentType().c_str(), NAPI_AUTO_LENGTH, &value));
794 }
795
GetElementInfoInputType(NAccessibilityElementData * callbackInfo,napi_value & value)796 void NAccessibilityElement::GetElementInfoInputType(NAccessibilityElementData *callbackInfo, napi_value &value)
797 {
798 if (!CheckElementInfoParameter(callbackInfo, value)) {
799 return;
800 }
801 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
802 callbackInfo->accessibilityElement_.elementInfo_->GetInputType(), &value));
803 }
804
GetElementInfoText(NAccessibilityElementData * callbackInfo,napi_value & value)805 void NAccessibilityElement::GetElementInfoText(NAccessibilityElementData *callbackInfo, napi_value &value)
806 {
807 if (!CheckElementInfoParameter(callbackInfo, value)) {
808 return;
809 }
810 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
811 callbackInfo->accessibilityElement_.elementInfo_->GetContent().c_str(), NAPI_AUTO_LENGTH, &value));
812 }
813
GetElementInfoHintText(NAccessibilityElementData * callbackInfo,napi_value & value)814 void NAccessibilityElement::GetElementInfoHintText(NAccessibilityElementData *callbackInfo, napi_value &value)
815 {
816 if (!CheckElementInfoParameter(callbackInfo, value)) {
817 return;
818 }
819 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
820 callbackInfo->accessibilityElement_.elementInfo_->GetHint().c_str(), NAPI_AUTO_LENGTH, &value));
821 }
822
GetElementInfoDescription(NAccessibilityElementData * callbackInfo,napi_value & value)823 void NAccessibilityElement::GetElementInfoDescription(NAccessibilityElementData *callbackInfo, napi_value &value)
824 {
825 if (!CheckElementInfoParameter(callbackInfo, value)) {
826 return;
827 }
828 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
829 callbackInfo->accessibilityElement_.elementInfo_->GetDescriptionInfo().c_str(), NAPI_AUTO_LENGTH, &value));
830 }
831
GetElementInfoResourceName(NAccessibilityElementData * callbackInfo,napi_value & value)832 void NAccessibilityElement::GetElementInfoResourceName(NAccessibilityElementData *callbackInfo, napi_value &value)
833 {
834 if (!CheckElementInfoParameter(callbackInfo, value)) {
835 return;
836 }
837 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
838 callbackInfo->accessibilityElement_.elementInfo_->GetComponentResourceId().c_str(), NAPI_AUTO_LENGTH, &value));
839 }
840
GetElementInfoTextLengthLimit(NAccessibilityElementData * callbackInfo,napi_value & value)841 void NAccessibilityElement::GetElementInfoTextLengthLimit(NAccessibilityElementData *callbackInfo, napi_value &value)
842 {
843 if (!CheckElementInfoParameter(callbackInfo, value)) {
844 return;
845 }
846 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
847 callbackInfo->accessibilityElement_.elementInfo_->GetTextLengthLimit(), &value));
848 }
849
GetElementInfoRect(NAccessibilityElementData * callbackInfo,napi_value & value)850 void NAccessibilityElement::GetElementInfoRect(NAccessibilityElementData *callbackInfo, napi_value &value)
851 {
852 if (!CheckElementInfoParameter(callbackInfo, value)) {
853 return;
854 }
855 OHOS::Accessibility::Rect screenRect = callbackInfo->accessibilityElement_.elementInfo_->GetRectInScreen();
856 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_object(callbackInfo->env_, &value));
857 ConvertRectToJS(callbackInfo->env_, value, screenRect);
858 }
859
GetElementInfoGridItem(NAccessibilityElementData * callbackInfo,napi_value & value)860 void NAccessibilityElement::GetElementInfoGridItem(NAccessibilityElementData *callbackInfo, napi_value &value)
861 {
862 if (!CheckElementInfoParameter(callbackInfo, value)) {
863 return;
864 }
865 OHOS::Accessibility::GridItemInfo gridItem = callbackInfo->accessibilityElement_.elementInfo_->GetGridItem();
866 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_object(callbackInfo->env_, &value));
867 ConvertGridItemToJS(callbackInfo->env_, value, gridItem);
868 }
869
GetExtraElementInfo(NAccessibilityElementData * callbackInfo,napi_value & value,std::string keyStr)870 void NAccessibilityElement::GetExtraElementInfo(NAccessibilityElementData *callbackInfo,
871 napi_value &value, std::string keyStr)
872 {
873 if (callbackInfo == nullptr) {
874 HILOG_ERROR("callbackInfo is nullptr");
875 return;
876 }
877 std::map<std::string, std::string> mapValIsStr =
878 callbackInfo->accessibilityElement_.elementInfo_->GetExtraElement().GetExtraElementInfoValueStr();
879 std::map<std::string, int32_t> mapValIsInt =
880 callbackInfo->accessibilityElement_.elementInfo_->GetExtraElement().GetExtraElementInfoValueInt();
881 HILOG_DEBUG("GetExtraElementInfo: size is extraElementValueStr : [%{public}zu]",
882 mapValIsStr.size());
883 HILOG_DEBUG("GetExtraElementInfo: size is extraElementValueInt : [%{public}zu]",
884 mapValIsInt.size());
885
886 auto iter = mapValIsStr.find(keyStr);
887 if (iter != mapValIsStr.end()) {
888 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
889 iter->second.c_str(), NAPI_AUTO_LENGTH, &value));
890 return;
891 }
892 auto seconditer = mapValIsInt.find(keyStr);
893 if (seconditer != mapValIsInt.end()) {
894 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_, seconditer->second, &value));
895 return;
896 }
897
898 napi_get_undefined(callbackInfo->env_, &value);
899 }
900
GetElementInfoCheckboxGroup(NAccessibilityElementData * callbackInfo,napi_value & value)901 void NAccessibilityElement::GetElementInfoCheckboxGroup(NAccessibilityElementData *callbackInfo, napi_value &value)
902 {
903 if (!CheckElementInfoParameter(callbackInfo, value)) {
904 return;
905 }
906 GetExtraElementInfo(callbackInfo, value, "CheckboxGroupSelectedStatus");
907 }
908
GetElementInfoRow(NAccessibilityElementData * callbackInfo,napi_value & value)909 void NAccessibilityElement::GetElementInfoRow(NAccessibilityElementData *callbackInfo, napi_value &value)
910 {
911 if (!CheckElementInfoParameter(callbackInfo, value)) {
912 return;
913 }
914 GetExtraElementInfo(callbackInfo, value, "Row");
915 }
916
GetElementInfoColumn(NAccessibilityElementData * callbackInfo,napi_value & value)917 void NAccessibilityElement::GetElementInfoColumn(NAccessibilityElementData *callbackInfo, napi_value &value)
918 {
919 if (!CheckElementInfoParameter(callbackInfo, value)) {
920 return;
921 }
922 GetExtraElementInfo(callbackInfo, value, "Column");
923 }
924
GetElementInfoSideBarContainer(NAccessibilityElementData * callbackInfo,napi_value & value)925 void NAccessibilityElement::GetElementInfoSideBarContainer(NAccessibilityElementData *callbackInfo, napi_value &value)
926 {
927 if (!CheckElementInfoParameter(callbackInfo, value)) {
928 return;
929 }
930 GetExtraElementInfo(callbackInfo, value, "SideBarContainerStates");
931 }
932
GetElementInfoListItemIndex(NAccessibilityElementData * callbackInfo,napi_value & value)933 void NAccessibilityElement::GetElementInfoListItemIndex(NAccessibilityElementData *callbackInfo, napi_value &value)
934 {
935 if (!CheckElementInfoParameter(callbackInfo, value)) {
936 return;
937 }
938 GetExtraElementInfo(callbackInfo, value, "ListItemIndex");
939 }
940
GetElementInfoCheckable(NAccessibilityElementData * callbackInfo,napi_value & value)941 void NAccessibilityElement::GetElementInfoCheckable(NAccessibilityElementData *callbackInfo, napi_value &value)
942 {
943 if (!CheckElementInfoParameter(callbackInfo, value)) {
944 return;
945 }
946 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
947 callbackInfo->accessibilityElement_.elementInfo_->IsCheckable(), &value));
948 }
949
GetElementInfoChecked(NAccessibilityElementData * callbackInfo,napi_value & value)950 void NAccessibilityElement::GetElementInfoChecked(NAccessibilityElementData *callbackInfo, napi_value &value)
951 {
952 if (!CheckElementInfoParameter(callbackInfo, value)) {
953 return;
954 }
955 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
956 callbackInfo->accessibilityElement_.elementInfo_->IsChecked(), &value));
957 }
958
GetElementInfoFocusable(NAccessibilityElementData * callbackInfo,napi_value & value)959 void NAccessibilityElement::GetElementInfoFocusable(NAccessibilityElementData *callbackInfo, napi_value &value)
960 {
961 if (!CheckElementInfoParameter(callbackInfo, value)) {
962 return;
963 }
964 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
965 callbackInfo->accessibilityElement_.elementInfo_->IsFocusable(), &value));
966 }
967
GetElementInfoIsVisible(NAccessibilityElementData * callbackInfo,napi_value & value)968 void NAccessibilityElement::GetElementInfoIsVisible(NAccessibilityElementData *callbackInfo, napi_value &value)
969 {
970 if (!CheckElementInfoParameter(callbackInfo, value)) {
971 return;
972 }
973 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
974 callbackInfo->accessibilityElement_.elementInfo_->IsVisible(), &value));
975 }
976
GetElementInfoAccessibilityFocused(NAccessibilityElementData * callbackInfo,napi_value & value)977 void NAccessibilityElement::GetElementInfoAccessibilityFocused(
978 NAccessibilityElementData *callbackInfo, napi_value &value)
979 {
980 if (!CheckElementInfoParameter(callbackInfo, value)) {
981 return;
982 }
983 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
984 callbackInfo->accessibilityElement_.elementInfo_->HasAccessibilityFocus(), &value));
985 }
986
GetElementInfoSelected(NAccessibilityElementData * callbackInfo,napi_value & value)987 void NAccessibilityElement::GetElementInfoSelected(NAccessibilityElementData *callbackInfo, napi_value &value)
988 {
989 if (!CheckElementInfoParameter(callbackInfo, value)) {
990 return;
991 }
992 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
993 callbackInfo->accessibilityElement_.elementInfo_->IsSelected(), &value));
994 }
995
GetElementInfoClickable(NAccessibilityElementData * callbackInfo,napi_value & value)996 void NAccessibilityElement::GetElementInfoClickable(NAccessibilityElementData *callbackInfo, napi_value &value)
997 {
998 if (!CheckElementInfoParameter(callbackInfo, value)) {
999 return;
1000 }
1001 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
1002 callbackInfo->accessibilityElement_.elementInfo_->IsClickable(), &value));
1003 }
1004
GetElementInfoLongClickable(NAccessibilityElementData * callbackInfo,napi_value & value)1005 void NAccessibilityElement::GetElementInfoLongClickable(NAccessibilityElementData *callbackInfo, napi_value &value)
1006 {
1007 if (!CheckElementInfoParameter(callbackInfo, value)) {
1008 return;
1009 }
1010 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
1011 callbackInfo->accessibilityElement_.elementInfo_->IsLongClickable(), &value));
1012 }
1013
GetElementInfoIsEnable(NAccessibilityElementData * callbackInfo,napi_value & value)1014 void NAccessibilityElement::GetElementInfoIsEnable(NAccessibilityElementData *callbackInfo, napi_value &value)
1015 {
1016 if (!CheckElementInfoParameter(callbackInfo, value)) {
1017 return;
1018 }
1019 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
1020 callbackInfo->accessibilityElement_.elementInfo_->IsEnabled(), &value));
1021 }
1022
GetElementInfoIsPassword(NAccessibilityElementData * callbackInfo,napi_value & value)1023 void NAccessibilityElement::GetElementInfoIsPassword(NAccessibilityElementData *callbackInfo, napi_value &value)
1024 {
1025 if (!CheckElementInfoParameter(callbackInfo, value)) {
1026 return;
1027 }
1028 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
1029 callbackInfo->accessibilityElement_.elementInfo_->IsPassword(), &value));
1030 }
1031
GetElementInfoScrollable(NAccessibilityElementData * callbackInfo,napi_value & value)1032 void NAccessibilityElement::GetElementInfoScrollable(NAccessibilityElementData *callbackInfo, napi_value &value)
1033 {
1034 if (!CheckElementInfoParameter(callbackInfo, value)) {
1035 return;
1036 }
1037 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
1038 callbackInfo->accessibilityElement_.elementInfo_->IsScrollable(), &value));
1039 }
1040
GetElementInfoEditable(NAccessibilityElementData * callbackInfo,napi_value & value)1041 void NAccessibilityElement::GetElementInfoEditable(NAccessibilityElementData *callbackInfo, napi_value &value)
1042 {
1043 if (!CheckElementInfoParameter(callbackInfo, value)) {
1044 return;
1045 }
1046 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
1047 callbackInfo->accessibilityElement_.elementInfo_->IsEditable(), &value));
1048 }
1049
GetElementInfoPluralLineSupported(NAccessibilityElementData * callbackInfo,napi_value & value)1050 void NAccessibilityElement::GetElementInfoPluralLineSupported(
1051 NAccessibilityElementData *callbackInfo, napi_value &value)
1052 {
1053 if (!CheckElementInfoParameter(callbackInfo, value)) {
1054 return;
1055 }
1056 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
1057 callbackInfo->accessibilityElement_.elementInfo_->IsPluraLineSupported(), &value));
1058 }
1059
GetElementInfoIsHint(NAccessibilityElementData * callbackInfo,napi_value & value)1060 void NAccessibilityElement::GetElementInfoIsHint(NAccessibilityElementData *callbackInfo, napi_value &value)
1061 {
1062 if (!CheckElementInfoParameter(callbackInfo, value)) {
1063 return;
1064 }
1065 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
1066 callbackInfo->accessibilityElement_.elementInfo_->IsGivingHint(), &value));
1067 }
1068
GetElementInfoItemCount(NAccessibilityElementData * callbackInfo,napi_value & value)1069 void NAccessibilityElement::GetElementInfoItemCount(NAccessibilityElementData *callbackInfo, napi_value &value)
1070 {
1071 if (!CheckElementInfoParameter(callbackInfo, value)) {
1072 return;
1073 }
1074 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
1075 callbackInfo->accessibilityElement_.elementInfo_->GetItemCounts(), &value));
1076 }
1077
GetElementInfoCurrentIndex(NAccessibilityElementData * callbackInfo,napi_value & value)1078 void NAccessibilityElement::GetElementInfoCurrentIndex(NAccessibilityElementData *callbackInfo, napi_value &value)
1079 {
1080 if (!CheckElementInfoParameter(callbackInfo, value)) {
1081 return;
1082 }
1083 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
1084 callbackInfo->accessibilityElement_.elementInfo_->GetCurrentIndex(), &value));
1085 }
1086
GetElementInfoStartIndex(NAccessibilityElementData * callbackInfo,napi_value & value)1087 void NAccessibilityElement::GetElementInfoStartIndex(NAccessibilityElementData *callbackInfo, napi_value &value)
1088 {
1089 if (!CheckElementInfoParameter(callbackInfo, value)) {
1090 return;
1091 }
1092 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
1093 callbackInfo->accessibilityElement_.elementInfo_->GetBeginIndex(), &value));
1094 }
1095
GetElementInfoEndIndex(NAccessibilityElementData * callbackInfo,napi_value & value)1096 void NAccessibilityElement::GetElementInfoEndIndex(NAccessibilityElementData *callbackInfo, napi_value &value)
1097 {
1098 if (!CheckElementInfoParameter(callbackInfo, value)) {
1099 return;
1100 }
1101 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
1102 callbackInfo->accessibilityElement_.elementInfo_->GetEndIndex(), &value));
1103 }
1104
GetElementInfoValueMax(NAccessibilityElementData * callbackInfo,napi_value & value)1105 void NAccessibilityElement::GetElementInfoValueMax(NAccessibilityElementData *callbackInfo, napi_value &value)
1106 {
1107 if (!CheckElementInfoParameter(callbackInfo, value)) {
1108 return;
1109 }
1110 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_double(callbackInfo->env_,
1111 callbackInfo->accessibilityElement_.elementInfo_->GetRange().GetMax(), &value));
1112 }
1113
GetElementInfoValueMin(NAccessibilityElementData * callbackInfo,napi_value & value)1114 void NAccessibilityElement::GetElementInfoValueMin(NAccessibilityElementData *callbackInfo, napi_value &value)
1115 {
1116 if (!CheckElementInfoParameter(callbackInfo, value)) {
1117 return;
1118 }
1119 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_double(callbackInfo->env_,
1120 callbackInfo->accessibilityElement_.elementInfo_->GetRange().GetMin(), &value));
1121 }
1122
GetElementInfoValueNow(NAccessibilityElementData * callbackInfo,napi_value & value)1123 void NAccessibilityElement::GetElementInfoValueNow(NAccessibilityElementData *callbackInfo, napi_value &value)
1124 {
1125 if (!CheckElementInfoParameter(callbackInfo, value)) {
1126 return;
1127 }
1128 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_double(callbackInfo->env_,
1129 callbackInfo->accessibilityElement_.elementInfo_->GetRange().GetCurrent(), &value));
1130 }
1131
GetElementInfoError(NAccessibilityElementData * callbackInfo,napi_value & value)1132 void NAccessibilityElement::GetElementInfoError(NAccessibilityElementData *callbackInfo, napi_value &value)
1133 {
1134 if (!CheckElementInfoParameter(callbackInfo, value)) {
1135 return;
1136 }
1137 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
1138 callbackInfo->accessibilityElement_.elementInfo_->GetError().c_str(), NAPI_AUTO_LENGTH, &value));
1139 }
1140
GetElementInfoTextMoveUnit(NAccessibilityElementData * callbackInfo,napi_value & value)1141 void NAccessibilityElement::GetElementInfoTextMoveUnit(NAccessibilityElementData *callbackInfo, napi_value &value)
1142 {
1143 if (!CheckElementInfoParameter(callbackInfo, value)) {
1144 return;
1145 }
1146 std::string textMoveUnit = ConvertTextMoveUnitToString(
1147 callbackInfo->accessibilityElement_.elementInfo_->GetTextMovementStep());
1148 HILOG_DEBUG("ConvertTextMoveUnitToString: [%{public}s]", textMoveUnit.c_str());
1149 if (textMoveUnit == "") {
1150 callbackInfo->ret_ = RET_ERR_FAILED;
1151 napi_get_undefined(callbackInfo->env_, &value);
1152 } else {
1153 callbackInfo->ret_ = RET_OK;
1154 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
1155 textMoveUnit.c_str(), NAPI_AUTO_LENGTH, &value));
1156 }
1157 }
1158
GetElementInfoParent(NAccessibilityElementData * callbackInfo,napi_value & value)1159 void NAccessibilityElement::GetElementInfoParent(NAccessibilityElementData *callbackInfo, napi_value &value)
1160 {
1161 if (!CheckElementInfoParameter(callbackInfo, value)) {
1162 return;
1163 }
1164 if (callbackInfo->ret_ == RET_OK) {
1165 napi_value constructor = nullptr;
1166 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_reference_value(callbackInfo->env_,
1167 NAccessibilityElement::consRef_, &constructor));
1168 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_new_instance(callbackInfo->env_,
1169 constructor, 0, nullptr, &value));
1170 ConvertElementInfoToJS(callbackInfo->env_, value, callbackInfo->nodeInfo_);
1171 } else {
1172 HILOG_ERROR("GetElementInfoParent failed!");
1173 napi_get_undefined(callbackInfo->env_, &value);
1174 }
1175 }
1176
GetElementInfoChildren(NAccessibilityElementData * callbackInfo,napi_value & value)1177 void NAccessibilityElement::GetElementInfoChildren(NAccessibilityElementData *callbackInfo, napi_value &value)
1178 {
1179 if (!CheckElementInfoParameter(callbackInfo, value)) {
1180 return;
1181 }
1182 if (callbackInfo->ret_ == RET_OK) {
1183 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_array(callbackInfo->env_, &value));
1184 ConvertElementInfosToJS(callbackInfo->env_, value, callbackInfo->nodeInfos_);
1185 } else {
1186 HILOG_ERROR("GetElementInfoChildren failed!");
1187 napi_get_undefined(callbackInfo->env_, &value);
1188 }
1189 }
1190
GetElementInfoTriggerAction(NAccessibilityElementData * callbackInfo,napi_value & value)1191 void NAccessibilityElement::GetElementInfoTriggerAction(NAccessibilityElementData *callbackInfo, napi_value &value)
1192 {
1193 if (!CheckElementInfoParameter(callbackInfo, value)) {
1194 return;
1195 }
1196 std::string triggerAction = ConvertOperationTypeToString(
1197 callbackInfo->accessibilityElement_.elementInfo_->GetTriggerAction());
1198 HILOG_DEBUG("GetElementInfoTriggerAction: [%{public}s]", triggerAction.c_str());
1199 if (triggerAction == "") {
1200 callbackInfo->ret_ = RET_ERR_FAILED;
1201 napi_get_undefined(callbackInfo->env_, &value);
1202 } else {
1203 callbackInfo->ret_ = RET_OK;
1204 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
1205 triggerAction.c_str(), NAPI_AUTO_LENGTH, &value));
1206 }
1207 }
1208
GetElementInfoContents(NAccessibilityElementData * callbackInfo,napi_value & value)1209 void NAccessibilityElement::GetElementInfoContents(NAccessibilityElementData *callbackInfo, napi_value &value)
1210 {
1211 if (!CheckElementInfoParameter(callbackInfo, value)) {
1212 return;
1213 }
1214 std::vector<std::string> contents {};
1215 callbackInfo->accessibilityElement_.elementInfo_->GetContentList(contents);
1216 HILOG_DEBUG("contents size: [%{public}zu]", contents.size());
1217
1218 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_array(callbackInfo->env_, &value));
1219 size_t index = 0;
1220 for (auto& content : contents) {
1221 napi_value nContent = nullptr;
1222 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
1223 content.c_str(), NAPI_AUTO_LENGTH, &nContent));
1224 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_set_element(callbackInfo->env_, value, index, nContent));
1225 index++;
1226 }
1227 }
1228
GetElementInfoLastContent(NAccessibilityElementData * callbackInfo,napi_value & value)1229 void NAccessibilityElement::GetElementInfoLastContent(NAccessibilityElementData *callbackInfo, napi_value &value)
1230 {
1231 if (!CheckElementInfoParameter(callbackInfo, value)) {
1232 return;
1233 }
1234 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
1235 callbackInfo->accessibilityElement_.elementInfo_->GetLatestContent().c_str(), NAPI_AUTO_LENGTH, &value));
1236 }
1237
GetElementInfoWindowId(NAccessibilityElementData * callbackInfo,napi_value & value)1238 void NAccessibilityElement::GetElementInfoWindowId(NAccessibilityElementData *callbackInfo, napi_value &value)
1239 {
1240 if (!CheckElementInfoParameter(callbackInfo, value)) {
1241 return;
1242 }
1243 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
1244 callbackInfo->accessibilityElement_.elementInfo_->GetWindowId(), &value));
1245 }
1246
GetElementInfoMainWindowId(NAccessibilityElementData * callbackInfo,napi_value & value)1247 void NAccessibilityElement::GetElementInfoMainWindowId(NAccessibilityElementData *callbackInfo, napi_value &value)
1248 {
1249 if (!CheckElementInfoParameter(callbackInfo, value)) {
1250 return;
1251 }
1252 int32_t windowId = callbackInfo->accessibilityElement_.elementInfo_->GetWindowId();
1253 int32_t mainWindowId = callbackInfo->accessibilityElement_.elementInfo_->GetMainWindowId();
1254 if (mainWindowId <= 0) {
1255 mainWindowId = windowId;
1256 HILOG_INFO("mainWindowId <= 0, use windowId");
1257 }
1258 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_, mainWindowId, &value));
1259 }
1260
GetElementInfoIsFocused(NAccessibilityElementData * callbackInfo,napi_value & value)1261 void NAccessibilityElement::GetElementInfoIsFocused(NAccessibilityElementData *callbackInfo, napi_value &value)
1262 {
1263 if (!CheckElementInfoParameter(callbackInfo, value)) {
1264 return;
1265 }
1266 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
1267 callbackInfo->accessibilityElement_.elementInfo_->IsFocused(), &value));
1268 }
1269
GetElementInfoAccessibilityText(NAccessibilityElementData * callbackInfo,napi_value & value)1270 void NAccessibilityElement::GetElementInfoAccessibilityText(NAccessibilityElementData *callbackInfo, napi_value &value)
1271 {
1272 if (!CheckElementInfoParameter(callbackInfo, value)) {
1273 return;
1274 }
1275 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
1276 callbackInfo->accessibilityElement_.elementInfo_->GetAccessibilityText().c_str(), NAPI_AUTO_LENGTH, &value));
1277 }
1278
GetElementInfoTextType(NAccessibilityElementData * callbackInfo,napi_value & value)1279 void NAccessibilityElement::GetElementInfoTextType(NAccessibilityElementData *callbackInfo, napi_value &value)
1280 {
1281 if (!CheckElementInfoParameter(callbackInfo, value)) {
1282 return;
1283 }
1284 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
1285 callbackInfo->accessibilityElement_.elementInfo_->GetTextType().c_str(), NAPI_AUTO_LENGTH, &value));
1286 }
1287
GetElementInfoOffset(NAccessibilityElementData * callbackInfo,napi_value & value)1288 void NAccessibilityElement::GetElementInfoOffset(NAccessibilityElementData *callbackInfo, napi_value &value)
1289 {
1290 if (!CheckElementInfoParameter(callbackInfo, value)) {
1291 return;
1292 }
1293 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_double(callbackInfo->env_,
1294 callbackInfo->accessibilityElement_.elementInfo_->GetOffset(), &value));
1295 }
1296
GetElementInfoAccessibilityGroup(NAccessibilityElementData * callbackInfo,napi_value & value)1297 void NAccessibilityElement::GetElementInfoAccessibilityGroup(NAccessibilityElementData *callbackInfo, napi_value &value)
1298 {
1299 if (!CheckElementInfoParameter(callbackInfo, value)) {
1300 return;
1301 }
1302 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
1303 callbackInfo->accessibilityElement_.elementInfo_->GetAccessibilityGroup(), &value));
1304 }
1305
GetElementInfoAccessibilityLevel(NAccessibilityElementData * callbackInfo,napi_value & value)1306 void NAccessibilityElement::GetElementInfoAccessibilityLevel(NAccessibilityElementData *callbackInfo, napi_value &value)
1307 {
1308 if (!CheckElementInfoParameter(callbackInfo, value)) {
1309 return;
1310 }
1311 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
1312 callbackInfo->accessibilityElement_.elementInfo_->GetAccessibilityLevel().c_str(), NAPI_AUTO_LENGTH, &value));
1313 }
1314
GetElementInfoNavDestinationId(NAccessibilityElementData * callbackInfo,napi_value & value)1315 void NAccessibilityElement::GetElementInfoNavDestinationId(NAccessibilityElementData *callbackInfo, napi_value &value)
1316 {
1317 if (!CheckElementInfoParameter(callbackInfo, value)) {
1318 return;
1319 }
1320 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int64(callbackInfo->env_,
1321 callbackInfo->accessibilityElement_.elementInfo_->GetNavDestinationId(), &value));
1322 }
1323
GetElementInfoSpan(NAccessibilityElementData * callbackInfo,napi_value & value)1324 void NAccessibilityElement::GetElementInfoSpan(NAccessibilityElementData *callbackInfo, napi_value &value)
1325 {
1326 if (!CheckElementInfoParameter(callbackInfo, value)) {
1327 return;
1328 }
1329 std::vector<SpanInfo> spanInfo {};
1330 spanInfo = callbackInfo->accessibilityElement_.elementInfo_->GetSpanList();
1331 HILOG_DEBUG("spanInfo size: [%{public}zu]", spanInfo.size());
1332
1333 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_array(callbackInfo->env_, &value));
1334 size_t index = 0;
1335 napi_status status;
1336 for (auto& span : spanInfo) {
1337 napi_value result = nullptr;
1338 status = napi_create_object(callbackInfo->env_, &result);
1339 if (status != napi_ok) {
1340 HILOG_DEBUG("cant create napi object!");
1341 return;
1342 }
1343 ConvertSpanToJS(callbackInfo->env_, result, span);
1344 HILOG_DEBUG("ConvertSpanToJS spanInfo spanid: [%{public}d]", span.GetSpanId());
1345 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_set_element(callbackInfo->env_, value, index, result));
1346 index++;
1347 }
1348 }
1349
GetElementInfoIsActive(NAccessibilityElementData * callbackInfo,napi_value & value)1350 void NAccessibilityElement::GetElementInfoIsActive(NAccessibilityElementData *callbackInfo, napi_value &value)
1351 {
1352 if (!CheckElementInfoParameter(callbackInfo, value)) {
1353 return;
1354 }
1355 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
1356 callbackInfo->accessibilityElement_.elementInfo_->GetIsActive(), &value));
1357 }
1358
GetElementInfoAccessibilityVisible(NAccessibilityElementData * callbackInfo,napi_value & value)1359 void NAccessibilityElement::GetElementInfoAccessibilityVisible(
1360 NAccessibilityElementData *callbackInfo, napi_value &value)
1361 {
1362 if (!CheckElementInfoParameter(callbackInfo, value)) {
1363 return;
1364 }
1365 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
1366 callbackInfo->accessibilityElement_.elementInfo_->GetAccessibilityVisible(), &value));
1367 }
1368
GetElementInfoClip(NAccessibilityElementData * callbackInfo,napi_value & value)1369 void NAccessibilityElement::GetElementInfoClip(NAccessibilityElementData *callbackInfo, napi_value &value)
1370 {
1371 if (!CheckElementInfoParameter(callbackInfo, value)) {
1372 return;
1373 }
1374 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
1375 callbackInfo->accessibilityElement_.elementInfo_->GetClip(), &value));
1376 }
1377
GetElementInfoCustomComponentType(NAccessibilityElementData * callbackInfo,napi_value & value)1378 void NAccessibilityElement::GetElementInfoCustomComponentType(NAccessibilityElementData *callbackInfo,
1379 napi_value &value)
1380 {
1381 if (!CheckElementInfoParameter(callbackInfo, value)) {
1382 return;
1383 }
1384 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
1385 callbackInfo->accessibilityElement_.elementInfo_->GetCustomComponentType().c_str(), NAPI_AUTO_LENGTH, &value));
1386 }
1387
GetElementInfoExtraInfo(NAccessibilityElementData * callbackInfo,napi_value & value)1388 void NAccessibilityElement::GetElementInfoExtraInfo(NAccessibilityElementData *callbackInfo, napi_value &value)
1389 {
1390 if (!CheckElementInfoParameter(callbackInfo, value)) {
1391 return;
1392 }
1393 std::map<std::string, std::string> mapValIsStr =
1394 callbackInfo->accessibilityElement_.elementInfo_->GetExtraElement().GetExtraElementInfoValueStr();
1395 std::map<std::string, int32_t> mapValIsInt =
1396 callbackInfo->accessibilityElement_.elementInfo_->GetExtraElement().GetExtraElementInfoValueInt();
1397 nlohmann::json extraInfoValue;
1398 for (auto &iterStr : mapValIsStr) {
1399 extraInfoValue[iterStr.first] = iterStr.second;
1400 }
1401 for (auto &iterInt : mapValIsInt) {
1402 extraInfoValue[iterInt.first] = iterInt.second;
1403 }
1404 HILOG_DEBUG("GetElementInfoExtraInfo extraInfoValue is [%{public}s]", extraInfoValue.dump().c_str());
1405 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
1406 extraInfoValue.dump().c_str(), NAPI_AUTO_LENGTH, &value));
1407 }
1408
GetElementInfoAccessibilityNextFocusId(NAccessibilityElementData * callbackInfo,napi_value & value)1409 void NAccessibilityElement::GetElementInfoAccessibilityNextFocusId(NAccessibilityElementData *callbackInfo,
1410 napi_value &value)
1411 {
1412 if (!CheckElementInfoParameter(callbackInfo, value)) {
1413 return;
1414 }
1415 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int64(callbackInfo->env_,
1416 callbackInfo->accessibilityElement_.elementInfo_->GetAccessibilityNextFocusId(), &value));
1417 }
1418
GetElementInfoAccessibilityPreviousFocusId(NAccessibilityElementData * callbackInfo,napi_value & value)1419 void NAccessibilityElement::GetElementInfoAccessibilityPreviousFocusId(NAccessibilityElementData *callbackInfo,
1420 napi_value &value)
1421 {
1422 if (!CheckElementInfoParameter(callbackInfo, value)) {
1423 return;
1424 }
1425 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int64(callbackInfo->env_,
1426 callbackInfo->accessibilityElement_.elementInfo_->GetAccessibilityPreviousFocusId(), &value));
1427 }
1428
GetElementInfoAccessibilityParentId(NAccessibilityElementData * callbackInfo,napi_value & value)1429 void NAccessibilityElement::GetElementInfoAccessibilityParentId(NAccessibilityElementData *callbackInfo,
1430 napi_value &value)
1431 {
1432 if (!CheckElementInfoParameter(callbackInfo, value)) {
1433 return;
1434 }
1435 int64_t parentId = callbackInfo->accessibilityElement_.elementInfo_->GetParentNodeId();
1436 if (parentId < 0) {
1437 HILOG_DEBUG("parentId is invalid");
1438 return;
1439 }
1440 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int64(callbackInfo->env_, parentId, &value));
1441 }
1442
GetElementInfoAccessibilityChildrenIds(NAccessibilityElementData * callbackInfo,napi_value & value)1443 void NAccessibilityElement::GetElementInfoAccessibilityChildrenIds(NAccessibilityElementData *callbackInfo,
1444 napi_value &value)
1445 {
1446 if (!CheckElementInfoParameter(callbackInfo, value)) {
1447 return;
1448 }
1449 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_array(callbackInfo->env_, &value));
1450 int32_t childTreeId = callbackInfo->accessibilityElement_.elementInfo_->GetChildTreeId();
1451 int32_t childWindowId = callbackInfo->accessibilityElement_.elementInfo_->GetChildWindowId();
1452 if (childTreeId <= 0 && childWindowId <= 0) {
1453 ConvertInt64VecToJS(
1454 callbackInfo->env_, value, callbackInfo->accessibilityElement_.elementInfo_->GetChildIds());
1455 return;
1456 }
1457 std::vector<AccessibilityElementInfo> children{};
1458 callbackInfo->ret_ = AccessibleAbilityClient::GetInstance()->GetChildren(
1459 *callbackInfo->accessibilityElement_.elementInfo_, children, callbackInfo->systemApi);
1460 if (callbackInfo->ret_ == RET_OK) {
1461 std::vector<int64_t> childIds;
1462 for (const auto& iter : children) {
1463 childIds.emplace_back(iter.GetAccessibilityId());
1464 }
1465 ConvertInt64VecToJS(callbackInfo->env_, value, childIds);
1466 } else {
1467 ConvertInt64VecToJS(
1468 callbackInfo->env_, value, callbackInfo->accessibilityElement_.elementInfo_->GetChildIds());
1469 }
1470 }
1471
GetElementInfoAccessibilityScrollable(NAccessibilityElementData * callbackInfo,napi_value & value)1472 void NAccessibilityElement::GetElementInfoAccessibilityScrollable(NAccessibilityElementData *callbackInfo,
1473 napi_value &value)
1474 {
1475 if (!CheckElementInfoParameter(callbackInfo, value)) {
1476 return;
1477 }
1478 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
1479 callbackInfo->accessibilityElement_.elementInfo_->GetAccessibilityScrollable(), &value));
1480 }
1481
GetElementInfoSupportedActionNames(NAccessibilityElementData * callbackInfo,napi_value & value)1482 void NAccessibilityElement::GetElementInfoSupportedActionNames(
1483 NAccessibilityElementData* callbackInfo, napi_value& value)
1484 {
1485 if (!CheckElementInfoParameter(callbackInfo, value)) {
1486 return;
1487 }
1488
1489 std::vector<std::string> actionNames {};
1490 std::vector<AccessibleAction> operations = callbackInfo->accessibilityElement_.elementInfo_->GetActionList();
1491 HILOG_DEBUG("action list size is %{public}zu", operations.size());
1492 actionNames.resize(operations.size());
1493 std::transform(operations.begin(), operations.end(), actionNames.begin(),
1494 [](const AccessibleAction operation) {
1495 return ConvertOperationTypeToString(operation.GetActionType());
1496 });
1497 napi_create_array(callbackInfo->env_, &value);
1498 ConvertStringVecToJS(callbackInfo->env_, value, actionNames);
1499 }
1500
GetElementInfoAllAttribute(NAccessibilityElementData * callbackInfo,napi_value & value)1501 void NAccessibilityElement::GetElementInfoAllAttribute(NAccessibilityElementData *callbackInfo, napi_value &value)
1502 {
1503 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_object(callbackInfo->env_, &value));
1504 if (CheckElementInfoParameter(callbackInfo, value)) {
1505 GetElementInfoAllAttribute1(callbackInfo, value);
1506 GetElementInfoAllAttribute2(callbackInfo, value);
1507 GetElementInfoAllAttribute3(callbackInfo, value);
1508 GetElementInfoAllAttribute4(callbackInfo, value);
1509 GetElementInfoAllAttribute5(callbackInfo, value);
1510 GetElementInfoAllAttribute6(callbackInfo, value);
1511 } else if (CheckWindowInfoParameter(callbackInfo, value)) {
1512 GetWindowInfoAllAttribute(callbackInfo, value);
1513 } else {
1514 return;
1515 }
1516 }
1517
GetElementInfoAllAttribute1(NAccessibilityElementData * callbackInfo,napi_value & value)1518 void NAccessibilityElement::GetElementInfoAllAttribute1(NAccessibilityElementData *callbackInfo, napi_value &value)
1519 {
1520 napi_env env = callbackInfo->env_;
1521 napi_value componentId = nullptr;
1522 GetElementInfoComponentId(callbackInfo, componentId);
1523 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "componentId", componentId));
1524
1525 napi_value inspectorKey = nullptr;
1526 GetElementInfoInspectorKey(callbackInfo, inspectorKey);
1527 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "inspectorKey", inspectorKey));
1528
1529 napi_value bundleName = nullptr;
1530 GetElementInfoBundleName(callbackInfo, bundleName);
1531 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "bundleName", bundleName));
1532
1533 napi_value componentType = nullptr;
1534 GetElementInfoComponentType(callbackInfo, componentType);
1535 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "componentType", componentType));
1536
1537 napi_value inputType = nullptr;
1538 GetElementInfoInputType(callbackInfo, inputType);
1539 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "inputType", inputType));
1540
1541 napi_value text = nullptr;
1542 GetElementInfoText(callbackInfo, text);
1543 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "text", text));
1544
1545 napi_value hintText = nullptr;
1546 GetElementInfoHintText(callbackInfo, hintText);
1547 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "hintText", hintText));
1548
1549 napi_value description = nullptr;
1550 GetElementInfoDescription(callbackInfo, description);
1551 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "description", description));
1552
1553 napi_value resourceName = nullptr;
1554 GetElementInfoResourceName(callbackInfo, resourceName);
1555 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "resourceName", resourceName));
1556 }
1557
GetElementInfoAllAttribute2(NAccessibilityElementData * callbackInfo,napi_value & value)1558 void NAccessibilityElement::GetElementInfoAllAttribute2(NAccessibilityElementData *callbackInfo, napi_value &value)
1559 {
1560 napi_env env = callbackInfo->env_;
1561 napi_value textLengthLimit = nullptr;
1562 GetElementInfoTextLengthLimit(callbackInfo, textLengthLimit);
1563 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "textLengthLimit", textLengthLimit));
1564
1565 napi_value rect = nullptr;
1566 GetElementInfoRect(callbackInfo, rect);
1567 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "rect", rect));
1568
1569 napi_value checkable = nullptr;
1570 GetElementInfoCheckable(callbackInfo, checkable);
1571 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "checkable", checkable));
1572
1573 napi_value checked = nullptr;
1574 GetElementInfoChecked(callbackInfo, checked);
1575 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "checked", checked));
1576
1577 napi_value focusable = nullptr;
1578 GetElementInfoFocusable(callbackInfo, focusable);
1579 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "focusable", focusable));
1580
1581 napi_value isVisible = nullptr;
1582 GetElementInfoIsVisible(callbackInfo, isVisible);
1583 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "isVisible", isVisible));
1584
1585 napi_value selected = nullptr;
1586 GetElementInfoSelected(callbackInfo, selected);
1587 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "selected", selected));
1588
1589 napi_value clickable = nullptr;
1590 GetElementInfoClickable(callbackInfo, clickable);
1591 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "clickable", clickable));
1592
1593 napi_value longClickable = nullptr;
1594 GetElementInfoLongClickable(callbackInfo, longClickable);
1595 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "longClickable", longClickable));
1596
1597 napi_value isEnable = nullptr;
1598 GetElementInfoIsEnable(callbackInfo, isEnable);
1599 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "isEnable", isEnable));
1600
1601 napi_value isPassword = nullptr;
1602 GetElementInfoIsPassword(callbackInfo, isPassword);
1603 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "isPassword", isPassword));
1604
1605 napi_value parentId = nullptr;
1606 GetElementInfoAccessibilityParentId(callbackInfo, parentId);
1607 if (parentId != nullptr) {
1608 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "parentId", parentId));
1609 }
1610
1611 napi_value childrenIds = nullptr;
1612 GetElementInfoAccessibilityChildrenIds(callbackInfo, childrenIds);
1613 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "childrenIds", childrenIds));
1614 }
1615
GetElementInfoAllAttribute3(NAccessibilityElementData * callbackInfo,napi_value & value)1616 void NAccessibilityElement::GetElementInfoAllAttribute3(NAccessibilityElementData *callbackInfo, napi_value &value)
1617 {
1618 napi_env env = callbackInfo->env_;
1619 napi_value scrollable = nullptr;
1620 GetElementInfoScrollable(callbackInfo, scrollable);
1621 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "scrollable", scrollable));
1622
1623 napi_value editable = nullptr;
1624 GetElementInfoEditable(callbackInfo, editable);
1625 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "editable", editable));
1626
1627 napi_value pluralLineSupported = nullptr;
1628 GetElementInfoPluralLineSupported(callbackInfo, pluralLineSupported);
1629 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "pluralLineSupported", pluralLineSupported));
1630
1631 napi_value itemCount = nullptr;
1632 GetElementInfoItemCount(callbackInfo, itemCount);
1633 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "itemCount", itemCount));
1634
1635 napi_value grid = nullptr;
1636 GetElementInfoGridItem(callbackInfo, grid);
1637 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "grid", grid));
1638
1639 napi_value currentIndex = nullptr;
1640 GetElementInfoCurrentIndex(callbackInfo, currentIndex);
1641 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "currentIndex", currentIndex));
1642
1643 napi_value startIndex = nullptr;
1644 GetElementInfoStartIndex(callbackInfo, startIndex);
1645 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "startIndex", startIndex));
1646
1647 napi_value endIndex = nullptr;
1648 GetElementInfoEndIndex(callbackInfo, endIndex);
1649 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "endIndex", endIndex));
1650
1651 napi_value textMoveUnit = nullptr;
1652 GetElementInfoTextMoveUnit(callbackInfo, textMoveUnit);
1653 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "textMoveUnit", textMoveUnit));
1654
1655 napi_value triggerAction = nullptr;
1656 std::string action = ConvertOperationTypeToString(
1657 callbackInfo->accessibilityElement_.elementInfo_->GetTriggerAction());
1658 if (action == "") {
1659 napi_get_undefined(callbackInfo->env_, &triggerAction);
1660 } else {
1661 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, action.c_str(), NAPI_AUTO_LENGTH, &triggerAction));
1662 }
1663 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "triggerAction", triggerAction));
1664
1665 napi_value contents = nullptr;
1666 GetElementInfoContents(callbackInfo, contents);
1667 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "contents", contents));
1668
1669 napi_value navDestinationId = nullptr;
1670 GetElementInfoNavDestinationId(callbackInfo, navDestinationId);
1671 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "navDestinationId", navDestinationId));
1672 }
1673
GetElementInfoAllAttribute4(NAccessibilityElementData * callbackInfo,napi_value & value)1674 void NAccessibilityElement::GetElementInfoAllAttribute4(NAccessibilityElementData *callbackInfo, napi_value &value)
1675 {
1676 napi_env env = callbackInfo->env_;
1677 napi_value lastContent = nullptr;
1678 GetElementInfoLastContent(callbackInfo, lastContent);
1679 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "lastContent", lastContent));
1680
1681 napi_value isFocused = nullptr;
1682 GetElementInfoIsFocused(callbackInfo, isFocused);
1683 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "isFocused", isFocused));
1684
1685 napi_value accessibilityFocused = nullptr;
1686 GetElementInfoAccessibilityFocused(callbackInfo, accessibilityFocused);
1687 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "accessibilityFocused", accessibilityFocused));
1688
1689 napi_value error = nullptr;
1690 GetElementInfoError(callbackInfo, error);
1691 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "error", error));
1692
1693 napi_value isHint = nullptr;
1694 GetElementInfoIsHint(callbackInfo, isHint);
1695 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "isHint", isHint));
1696
1697 napi_value pageId = nullptr;
1698 GetElementInfoPageId(callbackInfo, pageId);
1699 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "pageId", pageId));
1700
1701 napi_value valueMax = nullptr;
1702 GetElementInfoValueMax(callbackInfo, valueMax);
1703 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "valueMax", valueMax));
1704
1705 napi_value valueMin = nullptr;
1706 GetElementInfoValueMin(callbackInfo, valueMin);
1707 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "valueMin", valueMin));
1708
1709 napi_value valueNow = nullptr;
1710 GetElementInfoValueNow(callbackInfo, valueNow);
1711 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "valueNow", valueNow));
1712
1713 napi_value windowId = nullptr;
1714 GetElementInfoWindowId(callbackInfo, windowId);
1715 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "windowId", windowId));
1716
1717 napi_value accessibilityText = nullptr;
1718 GetElementInfoAccessibilityText(callbackInfo, accessibilityText);
1719 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "accessibilityText", accessibilityText));
1720
1721 napi_value textType = nullptr;
1722 GetElementInfoTextType(callbackInfo, textType);
1723 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "textType", textType));
1724
1725 napi_value offset = nullptr;
1726 GetElementInfoOffset(callbackInfo, offset);
1727 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "offset", offset));
1728
1729 napi_value accessibilityGroup = nullptr;
1730 GetElementInfoAccessibilityGroup(callbackInfo, accessibilityGroup);
1731 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "accessibilityGroup", accessibilityGroup));
1732
1733 napi_value accessibilityLevel = nullptr;
1734 GetElementInfoAccessibilityLevel(callbackInfo, accessibilityLevel);
1735 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "accessibilityLevel", accessibilityLevel));
1736 }
1737
GetElementInfoAllAttribute5(NAccessibilityElementData * callbackInfo,napi_value & value)1738 void NAccessibilityElement::GetElementInfoAllAttribute5(NAccessibilityElementData *callbackInfo, napi_value &value)
1739 {
1740 napi_env env = callbackInfo->env_;
1741 napi_value checkBox = nullptr;
1742 GetElementInfoCheckboxGroup(callbackInfo, checkBox);
1743 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "checkboxGroupSelectedStatus", checkBox));
1744
1745 napi_value row = nullptr;
1746 GetElementInfoRow(callbackInfo, row);
1747 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "row", row));
1748
1749 napi_value column = nullptr;
1750 GetElementInfoColumn(callbackInfo, column);
1751 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "column", column));
1752
1753 napi_value sideBarContainer = nullptr;
1754 GetElementInfoSideBarContainer(callbackInfo, sideBarContainer);
1755 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "sideBarContainerStates", sideBarContainer));
1756
1757 napi_value listItemIndex = nullptr;
1758 GetElementInfoListItemIndex(callbackInfo, listItemIndex);
1759 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "listItemIndex", listItemIndex));
1760
1761 napi_value span = nullptr;
1762 GetElementInfoSpan(callbackInfo, span);
1763 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "span", span));
1764
1765 napi_value isActive = nullptr;
1766 GetElementInfoIsActive(callbackInfo, isActive);
1767 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "isActive", isActive));
1768
1769 napi_value accessibilityVisible = nullptr;
1770 GetElementInfoAccessibilityVisible(callbackInfo, accessibilityVisible);
1771 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "accessibilityVisible", accessibilityVisible));
1772
1773 napi_value clip = nullptr;
1774 GetElementInfoClip(callbackInfo, clip);
1775 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "clip", clip));
1776
1777 napi_value mainWindowId = nullptr;
1778 GetElementInfoMainWindowId(callbackInfo, mainWindowId);
1779 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "mainWindowId", mainWindowId));
1780
1781 napi_value customComponentType = nullptr;
1782 GetElementInfoCustomComponentType(callbackInfo, customComponentType);
1783 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "customComponentType", customComponentType));
1784
1785 napi_value extraInfo = nullptr;
1786 GetElementInfoExtraInfo(callbackInfo, extraInfo);
1787 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "extraInfo", extraInfo));
1788
1789 napi_value accessibilityNextFocusId = nullptr;
1790 GetElementInfoAccessibilityNextFocusId(callbackInfo, accessibilityNextFocusId);
1791 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "accessibilityNextFocusId",
1792 accessibilityNextFocusId));
1793
1794 napi_value accessibilityPreviousFocusId = nullptr;
1795 GetElementInfoAccessibilityPreviousFocusId(callbackInfo, accessibilityPreviousFocusId);
1796 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "accessibilityPreviousFocusId",
1797 accessibilityPreviousFocusId));
1798 }
1799
GetElementInfoAllAttribute6(NAccessibilityElementData * callbackInfo,napi_value & value)1800 void NAccessibilityElement::GetElementInfoAllAttribute6(NAccessibilityElementData *callbackInfo, napi_value &value)
1801 {
1802 napi_env env = callbackInfo->env_;
1803 napi_value accessibilityScrollable = nullptr;
1804 GetElementInfoAccessibilityScrollable(callbackInfo, accessibilityScrollable);
1805 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "accessibilityScrollable",
1806 accessibilityScrollable));
1807 }
1808
GetWindowInfoAllAttribute(NAccessibilityElementData * callbackInfo,napi_value & value)1809 void NAccessibilityElement::GetWindowInfoAllAttribute(NAccessibilityElementData *callbackInfo, napi_value &value)
1810 {
1811 napi_env env = callbackInfo->env_;
1812 napi_value isActive = nullptr;
1813 GetWindowInfoIsActive(callbackInfo, isActive);
1814 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "isActive", isActive));
1815
1816 napi_value screenRect = nullptr;
1817 GetWindowInfoScreenRect(callbackInfo, screenRect);
1818 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "screenRect", screenRect));
1819
1820 napi_value layer = nullptr;
1821 GetWindowInfoLayer(callbackInfo, layer);
1822 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "layer", layer));
1823
1824 napi_value type = nullptr;
1825 GetWindowInfoType(callbackInfo, type);
1826 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "type", type));
1827
1828 napi_value isFocused = nullptr;
1829 GetWindowInfoIsFocused(callbackInfo, isFocused);
1830 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "isFocused", isFocused));
1831
1832 napi_value windowId = nullptr;
1833 GetWindowInfoWindowId(callbackInfo, windowId);
1834 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "windowId", windowId));
1835
1836 napi_value mainWindowId = nullptr;
1837 GetWindowInfoMainWindowId(callbackInfo, mainWindowId);
1838 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "mainWindowId", mainWindowId));
1839 }
1840
CheckWindowInfoParameter(NAccessibilityElementData * callbackInfo,napi_value & value)1841 bool NAccessibilityElement::CheckWindowInfoParameter(NAccessibilityElementData *callbackInfo, napi_value &value)
1842 {
1843 if (callbackInfo == nullptr) {
1844 HILOG_ERROR("callbackInfo is nullptr");
1845 return false;
1846 }
1847 if (!callbackInfo->accessibilityElement_.windowInfo_) {
1848 HILOG_ERROR("window info is nullptr");
1849 napi_get_undefined(callbackInfo->env_, &value);
1850 callbackInfo->ret_ = RET_ERR_FAILED;
1851 return false;
1852 }
1853 return true;
1854 }
1855
GetWindowInfoIsActive(NAccessibilityElementData * callbackInfo,napi_value & value)1856 void NAccessibilityElement::GetWindowInfoIsActive(NAccessibilityElementData *callbackInfo, napi_value &value)
1857 {
1858 if (!CheckWindowInfoParameter(callbackInfo, value)) {
1859 return;
1860 }
1861 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
1862 callbackInfo->accessibilityElement_.windowInfo_->IsActive(), &value));
1863 }
1864
GetWindowInfoScreenRect(NAccessibilityElementData * callbackInfo,napi_value & value)1865 void NAccessibilityElement::GetWindowInfoScreenRect(NAccessibilityElementData *callbackInfo, napi_value &value)
1866 {
1867 if (!CheckWindowInfoParameter(callbackInfo, value)) {
1868 return;
1869 }
1870 OHOS::Accessibility::Rect screenRect = callbackInfo->accessibilityElement_.windowInfo_->GetRectInScreen();
1871 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_object(callbackInfo->env_, &value));
1872 ConvertRectToJS(callbackInfo->env_, value, screenRect);
1873 }
1874
GetWindowInfoLayer(NAccessibilityElementData * callbackInfo,napi_value & value)1875 void NAccessibilityElement::GetWindowInfoLayer(NAccessibilityElementData *callbackInfo, napi_value &value)
1876 {
1877 if (!CheckWindowInfoParameter(callbackInfo, value)) {
1878 return;
1879 }
1880 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
1881 callbackInfo->accessibilityElement_.windowInfo_->GetWindowLayer(), &value));
1882 }
1883
GetWindowInfoType(NAccessibilityElementData * callbackInfo,napi_value & value)1884 void NAccessibilityElement::GetWindowInfoType(NAccessibilityElementData *callbackInfo, napi_value &value)
1885 {
1886 if (!CheckWindowInfoParameter(callbackInfo, value)) {
1887 return;
1888 }
1889 std::string accessibilityWindowType = ConvertWindowTypeToString(
1890 callbackInfo->accessibilityElement_.windowInfo_->GetAccessibilityWindowType());
1891 HILOG_DEBUG("GetWindowInfoType: [%{public}s]", accessibilityWindowType.c_str());
1892 if (accessibilityWindowType == "") {
1893 callbackInfo->ret_ = RET_ERR_FAILED;
1894 napi_get_undefined(callbackInfo->env_, &value);
1895 } else {
1896 callbackInfo->ret_ = RET_OK;
1897 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
1898 accessibilityWindowType.c_str(), NAPI_AUTO_LENGTH, &value));
1899 }
1900 }
1901
GetWindowInfoRootElement(NAccessibilityElementData * callbackInfo,napi_value & value)1902 void NAccessibilityElement::GetWindowInfoRootElement(NAccessibilityElementData *callbackInfo, napi_value &value)
1903 {
1904 if (!CheckWindowInfoParameter(callbackInfo, value)) {
1905 return;
1906 }
1907 if (callbackInfo->ret_ == RET_OK) {
1908 napi_value constructor = nullptr;
1909 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_reference_value(callbackInfo->env_,
1910 NAccessibilityElement::consRef_, &constructor));
1911 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_new_instance(callbackInfo->env_,
1912 constructor, 0, nullptr, &value));
1913 ConvertElementInfoToJS(callbackInfo->env_, value, callbackInfo->nodeInfo_);
1914 } else {
1915 HILOG_ERROR("GetWindowInfoRootElement failed!");
1916 napi_get_undefined(callbackInfo->env_, &value);
1917 }
1918 }
1919
GetWindowInfoIsFocused(NAccessibilityElementData * callbackInfo,napi_value & value)1920 void NAccessibilityElement::GetWindowInfoIsFocused(NAccessibilityElementData *callbackInfo, napi_value &value)
1921 {
1922 if (!CheckWindowInfoParameter(callbackInfo, value)) {
1923 return;
1924 }
1925 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
1926 callbackInfo->accessibilityElement_.windowInfo_->IsFocused(), &value));
1927 }
1928
GetWindowInfoWindowId(NAccessibilityElementData * callbackInfo,napi_value & value)1929 void NAccessibilityElement::GetWindowInfoWindowId(NAccessibilityElementData *callbackInfo, napi_value &value)
1930 {
1931 if (!CheckWindowInfoParameter(callbackInfo, value)) {
1932 return;
1933 }
1934 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
1935 callbackInfo->accessibilityElement_.windowInfo_->GetWindowId(), &value));
1936 }
1937
GetWindowInfoMainWindowId(NAccessibilityElementData * callbackInfo,napi_value & value)1938 void NAccessibilityElement::GetWindowInfoMainWindowId(NAccessibilityElementData *callbackInfo, napi_value &value)
1939 {
1940 if (!CheckWindowInfoParameter(callbackInfo, value)) {
1941 return;
1942 }
1943 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
1944 callbackInfo->accessibilityElement_.windowInfo_->GetMainWindowId(), &value));
1945 }
1946
GetWindowInfoHotArea(NAccessibilityElementData * callbackInfo,napi_value & value)1947 void NAccessibilityElement::GetWindowInfoHotArea(NAccessibilityElementData *callbackInfo, napi_value &value)
1948 {
1949 if (!CheckWindowInfoParameter(callbackInfo, value)) {
1950 return;
1951 }
1952
1953 std::vector<Rect> hotAreas = callbackInfo->accessibilityElement_.windowInfo_->GetTouchHotAreas();
1954 if (hotAreas.empty()) {
1955 napi_get_undefined(callbackInfo->env_, &value);
1956 return;
1957 }
1958
1959 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_object(callbackInfo->env_, &value));
1960 ConvertRectToJS(callbackInfo->env_, value, hotAreas[0]);
1961 }
1962
ActionNames(napi_env env,napi_callback_info info)1963 napi_value NAccessibilityElement::ActionNames(napi_env env, napi_callback_info info)
1964 {
1965 #ifdef ACCESSIBILITY_EMULATOR_DEFINED
1966 ApiReportHelper reporter("NAccessibilityElement.ActionNames");
1967 #endif // ACCESSIBILITY_EMULATOR_DEFINED
1968 size_t argc = ARGS_SIZE_ONE;
1969 napi_value argv = nullptr;
1970 napi_value thisVar = nullptr;
1971 void* data = nullptr;
1972 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &argv, &thisVar, &data));
1973 HILOG_DEBUG("argc = %{public}zu", argc);
1974
1975 AccessibilityElement* accessibilityElement = UnrapAccessibilityElement(env, thisVar);
1976 if (!accessibilityElement) {
1977 return nullptr;
1978 }
1979
1980 NAccessibilityElementData *callbackInfo = new(std::nothrow) NAccessibilityElementData();
1981 if (callbackInfo == nullptr) {
1982 HILOG_ERROR("Failed to create callbackInfo.");
1983 return nullptr;
1984 }
1985 callbackInfo->env_ = env;
1986 callbackInfo->accessibilityElement_ = *accessibilityElement;
1987
1988 napi_value promise = nullptr;
1989 if (argc > ARGS_SIZE_ONE - 1) {
1990 napi_valuetype valueType = napi_null;
1991 napi_typeof(env, argv, &valueType);
1992 if (valueType == napi_function) {
1993 napi_create_reference(env, argv, 1, &callbackInfo->callback_);
1994 napi_get_undefined(env, &promise);
1995 } else {
1996 napi_create_promise(env, &callbackInfo->deferred_, &promise);
1997 }
1998 } else {
1999 napi_create_promise(env, &callbackInfo->deferred_, &promise);
2000 }
2001
2002 napi_value resource = nullptr;
2003 napi_create_string_utf8(env, "ActionNames", NAPI_AUTO_LENGTH, &resource);
2004 if (resource == nullptr) {
2005 HILOG_ERROR("resource is nullptr.");
2006 return nullptr;
2007 }
2008
2009 napi_create_async_work(env, nullptr, resource, [](napi_env env, void* data) {},
2010 // Execute the complete function
2011 ActionNamesComplete,
2012 reinterpret_cast<void*>(callbackInfo),
2013 &callbackInfo->work_);
2014 napi_queue_async_work_with_qos(env, callbackInfo->work_, napi_qos_user_initiated);
2015 return promise;
2016 }
2017
ActionNamesComplete(napi_env env,napi_status status,void * data)2018 void NAccessibilityElement::ActionNamesComplete(napi_env env, napi_status status, void* data)
2019 {
2020 HILOG_DEBUG("ActionNamesComplete execute back");
2021 NAccessibilityElementData* callbackInfo = static_cast<NAccessibilityElementData*>(data);
2022 napi_value result[ARGS_SIZE_TWO] = {0};
2023 napi_value callback = 0;
2024 napi_value undefined = 0;
2025 napi_get_undefined(env, &undefined);
2026 if (callbackInfo == nullptr) {
2027 HILOG_ERROR("callbackInfo is nullptr");
2028 return;
2029 }
2030
2031 if (callbackInfo->accessibilityElement_.elementInfo_) {
2032 std::vector<std::string> actionNames {};
2033 std::vector<AccessibleAction> operations =
2034 callbackInfo->accessibilityElement_.elementInfo_->GetActionList();
2035 HILOG_DEBUG("action list size is %{public}zu", operations.size());
2036 actionNames.resize(operations.size());
2037 std::transform(operations.begin(), operations.end(), actionNames.begin(),
2038 [](const AccessibleAction operation) {
2039 return ConvertOperationTypeToString(operation.GetActionType());
2040 });
2041 napi_create_array(env, &result[PARAM1]);
2042 ConvertStringVecToJS(env, result[PARAM1], actionNames);
2043 callbackInfo->ret_ = RET_OK;
2044 } else {
2045 HILOG_ERROR("no elementInfo_");
2046 callbackInfo->ret_ = RET_ERR_FAILED;
2047 napi_get_undefined(env, &result[PARAM1]);
2048 }
2049
2050 result[PARAM0] = CreateBusinessError(env, callbackInfo->ret_);
2051 if (callbackInfo->callback_) {
2052 // Callback mode
2053 napi_get_reference_value(env, callbackInfo->callback_, &callback);
2054 napi_value returnVal = nullptr;
2055 napi_call_function(env, undefined, callback, ARGS_SIZE_TWO, result, &returnVal);
2056 napi_delete_reference(env, callbackInfo->callback_);
2057 } else {
2058 // Promise mode
2059 if (callbackInfo->accessibilityElement_.elementInfo_) {
2060 napi_resolve_deferred(env, callbackInfo->deferred_, result[PARAM1]);
2061 } else {
2062 napi_reject_deferred(env, callbackInfo->deferred_, result[PARAM0]);
2063 }
2064 }
2065 napi_delete_async_work(env, callbackInfo->work_);
2066 delete callbackInfo;
2067 callbackInfo = nullptr;
2068 }
2069
EnableScreenCurtain(napi_env env,napi_callback_info info)2070 napi_value NAccessibilityElement::EnableScreenCurtain(napi_env env, napi_callback_info info)
2071 {
2072 HILOG_INFO("enter NAccessibilityElement::EnableScreenCurtain");
2073 if (!Security::AccessToken::TokenIdKit::IsSystemAppByFullTokenID(IPCSkeleton::GetCallingFullTokenID())) {
2074 napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_NOT_SYSTEM_APP);
2075 napi_throw(env, err);
2076 HILOG_ERROR("is not system app");
2077 return nullptr;
2078 }
2079
2080 size_t argc = ARGS_SIZE_ONE;
2081 napi_value argv[ARGS_SIZE_ONE] = { 0 };
2082 napi_value thisVar = nullptr;
2083 void* data = nullptr;
2084 napi_status status = napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
2085 if (status != napi_ok) {
2086 HILOG_ERROR("Failed to get cb info");
2087 napi_value err = CreateBusinessError(env, RetError::RET_ERR_FAILED);
2088 napi_throw(env, err);
2089 return nullptr;
2090 }
2091
2092 //get value from ui
2093 bool isEnable = true;
2094 napi_get_value_bool(env, argv[0], &isEnable);
2095 HILOG_INFO("ui argv[0] isEnable = %{public}d", isEnable);
2096
2097 //pass valule to server
2098 AccessibleAbilityClient::GetInstance()->EnableScreenCurtain(isEnable);
2099 return thisVar;
2100 }
2101
PerformAction(napi_env env,napi_callback_info info)2102 napi_value NAccessibilityElement::PerformAction(napi_env env, napi_callback_info info)
2103 {
2104 size_t argc = ARGS_SIZE_THREE;
2105 napi_value argv[ARGS_SIZE_THREE] = {0};
2106 napi_value thisVar = nullptr;
2107 void* data = nullptr;
2108 napi_status status = napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
2109 if (status != napi_ok) {
2110 HILOG_ERROR("Failed to get cb info");
2111 napi_value err = CreateBusinessError(env, RetError::RET_ERR_FAILED);
2112 napi_throw(env, err);
2113 return nullptr;
2114 }
2115 HILOG_DEBUG("argc = %{public}zu", argc);
2116
2117 AccessibilityElement* accessibilityElement = UnrapAccessibilityElement(env, thisVar);
2118 if (!accessibilityElement) {
2119 return nullptr;
2120 }
2121 std::string actionName;
2122 NAccessibilityErrorCode errCode = NAccessibilityErrorCode::ACCESSIBILITY_OK;
2123 if (argc < ARGS_SIZE_ONE || !ParseString(env, actionName, argv[PARAM0])) {
2124 HILOG_ERROR("argc is invalid: %{public}zu", argc);
2125 errCode = NAccessibilityErrorCode::ACCESSIBILITY_ERROR_INVALID_PARAM;
2126 delete accessibilityElement;
2127 accessibilityElement = nullptr;
2128 napi_value err = CreateBusinessError(env, RetError::RET_ERR_INVALID_PARAM);
2129 HILOG_ERROR("invalid param");
2130 napi_throw(env, err);
2131 return nullptr;
2132 }
2133 return PerformActionAsync(env, argc, argv, actionName, accessibilityElement);
2134 }
2135
ExecuteAction(napi_env env,napi_callback_info info)2136 napi_value NAccessibilityElement::ExecuteAction(napi_env env, napi_callback_info info)
2137 {
2138 size_t argc = ARGS_SIZE_TWO;
2139 napi_value argv[ARGS_SIZE_TWO] = {0};
2140 napi_value thisVar = nullptr;
2141 void* data = nullptr;
2142 napi_status status = napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
2143 if (status != napi_ok) {
2144 HILOG_ERROR("Failed to get cb info");
2145 napi_value err = CreateBusinessError(env, RetError::RET_ERR_FAILED);
2146 napi_throw(env, err);
2147 return nullptr;
2148 }
2149 HILOG_DEBUG("argc = %{public}zu", argc);
2150
2151 AccessibilityElement* accessibilityElement = UnrapAccessibilityElement(env, thisVar);
2152 if (!accessibilityElement) {
2153 return nullptr;
2154 }
2155
2156 int32_t action = -1;
2157 NAccessibilityErrorCode errCode = NAccessibilityErrorCode::ACCESSIBILITY_OK;
2158 if (argc < ARGS_SIZE_ONE || !ParseInt32(env, action, argv[PARAM0]) ||
2159 action < 0 || static_cast<uint32_t>(action) >= ACTION_NAMES.size()) {
2160 HILOG_ERROR("parameter is invalid: argc=%{public}zu, action=%{public}d", argc, action);
2161 errCode = NAccessibilityErrorCode::ACCESSIBILITY_ERROR_INVALID_PARAM;
2162 delete accessibilityElement;
2163 accessibilityElement = nullptr;
2164 napi_value err = CreateBusinessError(env, RetError::RET_ERR_INVALID_PARAM);
2165 HILOG_ERROR("invalid param");
2166 napi_throw(env, err);
2167 return nullptr;
2168 }
2169 return PerformActionAsync(env, argc, argv, ACTION_NAMES.at(action), accessibilityElement, true);
2170 }
2171
UnrapAccessibilityElement(napi_env env,napi_value thisVar)2172 AccessibilityElement* NAccessibilityElement::UnrapAccessibilityElement(napi_env env, napi_value thisVar)
2173 {
2174 AccessibilityElement* accessibilityElement = nullptr;
2175 napi_status status = napi_unwrap(env, thisVar, (void**)&accessibilityElement);
2176 if (!accessibilityElement || status != napi_ok) {
2177 HILOG_ERROR("accessibilityElement is null or status[%{public}d] is wrong", status);
2178 napi_value err = CreateBusinessError(env, RetError::RET_ERR_NULLPTR);
2179 napi_throw(env, err);
2180 return nullptr;
2181 }
2182 if (!(accessibilityElement->isElementInfo_ && accessibilityElement->elementInfo_)) {
2183 HILOG_ERROR("accessibilityElement is wrong. isElementInfo_[%{public}d]", accessibilityElement->isElementInfo_);
2184 napi_value err = CreateBusinessError(env, RetError::RET_ERR_FAILED);
2185 napi_throw(env, err);
2186 return nullptr;
2187 }
2188 return accessibilityElement;
2189 }
2190
PerformActionAsync(napi_env env,size_t argc,napi_value * argv,std::string actionName,AccessibilityElement * accessibilityElement,bool checkPerm)2191 napi_value NAccessibilityElement::PerformActionAsync(napi_env env, size_t argc, napi_value* argv,
2192 std::string actionName, AccessibilityElement* accessibilityElement, bool checkPerm)
2193 {
2194 NAccessibilityElementData *callbackInfo = new(std::nothrow) NAccessibilityElementData();
2195 if (callbackInfo == nullptr) {
2196 HILOG_ERROR("Failed to create callbackInfo.");
2197 napi_value err = CreateBusinessError(env, RetError::RET_ERR_NULLPTR);
2198 napi_throw(env, err);
2199 return nullptr;
2200 }
2201 callbackInfo->env_ = env;
2202 callbackInfo->accessibilityElement_ = *accessibilityElement;
2203
2204 return PerformActionConstructPromise(env, argc, argv, callbackInfo, actionName, checkPerm);
2205 }
2206
PerformActionConstructPromise(napi_env env,size_t argc,napi_value * argv,NAccessibilityElementData * callbackInfo,std::string actionName,bool checkPerm)2207 napi_value NAccessibilityElement::PerformActionConstructPromise(napi_env env, size_t argc, napi_value* argv,
2208 NAccessibilityElementData* callbackInfo, std::string actionName, bool checkPerm)
2209 {
2210 napi_value promise = nullptr;
2211 std::map<std::string, std::string> actionArguments {};
2212 if (argc >= ARGS_SIZE_THREE) {
2213 napi_valuetype secondParamType = napi_null;
2214 napi_typeof(env, argv[PARAM1], &secondParamType);
2215 napi_valuetype thirdParamType = napi_null;
2216 napi_typeof(env, argv[PARAM2], &thirdParamType);
2217 if (thirdParamType == napi_function) {
2218 if (secondParamType == napi_object) {
2219 ConvertActionArgsJSToNAPI(env, argv[PARAM1], actionArguments,
2220 ConvertStringToAccessibleOperationType(actionName));
2221 }
2222 napi_create_reference(env, argv[PARAM2], 1, &callbackInfo->callback_);
2223 napi_get_undefined(env, &promise);
2224 } else if (secondParamType == napi_function) {
2225 napi_create_reference(env, argv[PARAM1], 1, &callbackInfo->callback_);
2226 napi_get_undefined(env, &promise);
2227 } else {
2228 HILOG_DEBUG("argc is three, use promise");
2229 napi_create_promise(env, &callbackInfo->deferred_, &promise);
2230 }
2231 } else if (argc == ARGS_SIZE_TWO) {
2232 napi_valuetype valueType = napi_null;
2233 napi_typeof(env, argv[PARAM1], &valueType);
2234 if (valueType == napi_function) {
2235 napi_create_reference(env, argv[PARAM1], 1, &callbackInfo->callback_);
2236 napi_get_undefined(env, &promise);
2237 } else {
2238 if (valueType == napi_object) {
2239 ConvertActionArgsJSToNAPI(env, argv[PARAM1], actionArguments,
2240 ConvertStringToAccessibleOperationType(actionName));
2241 }
2242 HILOG_DEBUG("argc is two, use promise");
2243 napi_create_promise(env, &callbackInfo->deferred_, &promise);
2244 }
2245 } else {
2246 HILOG_DEBUG("argc is others, use promise");
2247 napi_create_promise(env, &callbackInfo->deferred_, &promise);
2248 }
2249
2250 SetPermCheckFlagForAction(checkPerm, actionArguments);
2251
2252 callbackInfo->actionName_ = actionName;
2253 callbackInfo->actionArguments_ = actionArguments;
2254 napi_value resource = nullptr;
2255 napi_create_string_utf8(env, "PerformAction", NAPI_AUTO_LENGTH, &resource);
2256 napi_create_async_work(env, nullptr, resource, PerformActionExecute, PerformActionComplete,
2257 reinterpret_cast<void*>(callbackInfo), &callbackInfo->work_);
2258 napi_queue_async_work_with_qos(env, callbackInfo->work_, napi_qos_user_initiated);
2259 return promise;
2260 }
2261
PerformActionExecute(napi_env env,void * data)2262 void NAccessibilityElement::PerformActionExecute(napi_env env, void* data)
2263 {
2264 HILOG_DEBUG("PerformActionExecute");
2265 NAccessibilityElementData *callbackInfo = static_cast<NAccessibilityElementData*>(data);
2266 if (callbackInfo == nullptr) {
2267 HILOG_ERROR("callbackInfo is nullptr");
2268 return;
2269 }
2270
2271 ActionType action = ConvertStringToAccessibleOperationType(callbackInfo->actionName_);
2272 if (action == ActionType::ACCESSIBILITY_ACTION_INVALID) {
2273 HILOG_ERROR("The action is not supported");
2274 callbackInfo->ret_ = OHOS::Accessibility::RetError::RET_ERR_ACTION_NOT_SUPPORT;
2275 return;
2276 }
2277 callbackInfo->ret_ = AccessibleAbilityClient::GetInstance()->ExecuteAction(
2278 *callbackInfo->accessibilityElement_.elementInfo_, action, callbackInfo->actionArguments_);
2279 HILOG_DEBUG("callbackInfo->ret_[%{public}d]", callbackInfo->ret_);
2280 }
2281
PerformActionComplete(napi_env env,napi_status status,void * data)2282 void NAccessibilityElement::PerformActionComplete(napi_env env, napi_status status, void* data)
2283 {
2284 HILOG_DEBUG("PerformActionComplete execute back");
2285 NAccessibilityElementData* callbackInfo = static_cast<NAccessibilityElementData*>(data);
2286 if (callbackInfo == nullptr) {
2287 HILOG_ERROR("callbackInfo is nullptr");
2288 return;
2289 }
2290 napi_value result[ARGS_SIZE_TWO] = {0};
2291 napi_value callback = 0;
2292 napi_value undefined = 0;
2293 napi_get_undefined(env, &undefined);
2294 napi_get_undefined(env, &result[PARAM1]);
2295 result[PARAM0] = CreateBusinessError(env, callbackInfo->ret_);
2296 if (callbackInfo->callback_) {
2297 // Callback mode
2298 napi_get_reference_value(env, callbackInfo->callback_, &callback);
2299 napi_value returnVal = nullptr;
2300 napi_call_function(env, undefined, callback, ARGS_SIZE_TWO, result, &returnVal);
2301 napi_delete_reference(env, callbackInfo->callback_);
2302 } else {
2303 // Promise mode
2304 if (callbackInfo->ret_ == RET_OK) {
2305 napi_resolve_deferred(env, callbackInfo->deferred_, result[PARAM1]);
2306 } else {
2307 napi_reject_deferred(env, callbackInfo->deferred_, result[PARAM0]);
2308 }
2309 }
2310
2311 napi_delete_async_work(env, callbackInfo->work_);
2312 delete callbackInfo;
2313 callbackInfo = nullptr;
2314 }
2315
FindElement(napi_env env,napi_callback_info info)2316 napi_value NAccessibilityElement::FindElement(napi_env env, napi_callback_info info)
2317 {
2318 size_t argc = ARGS_SIZE_THREE;
2319 napi_value argv[ARGS_SIZE_THREE] = {0};
2320 napi_value thisVar = nullptr;
2321 void* data = nullptr;
2322 napi_status status = napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
2323 if (status != napi_ok) {
2324 HILOG_ERROR("Failed to get cb info");
2325 napi_value err = CreateBusinessError(env, RetError::RET_ERR_FAILED);
2326 napi_throw(env, err);
2327 return nullptr;
2328 }
2329 HILOG_DEBUG("argc = %{public}d", (int)argc);
2330
2331 // Unwrap AccessibilityElement
2332 AccessibilityElement* accessibilityElement = nullptr;
2333 status = napi_unwrap(env, thisVar, (void**)&accessibilityElement);
2334 if (!accessibilityElement || status != napi_ok) {
2335 HILOG_ERROR("accessibilityElement is null or status[%{public}d] is wrong", status);
2336 napi_value err = CreateBusinessError(env, RetError::RET_ERR_NULLPTR);
2337 napi_throw(env, err);
2338 return nullptr;
2339 }
2340 if (!accessibilityElement->isElementInfo_) {
2341 HILOG_ERROR("Type of AccessibilityElement is not right");
2342 napi_value err = CreateBusinessError(env, RetError::RET_ERR_FAILED);
2343 napi_throw(env, err);
2344 return nullptr;
2345 }
2346
2347 NAccessibilityElementData *callbackInfo = new(std::nothrow) NAccessibilityElementData();
2348 if (callbackInfo == nullptr) {
2349 HILOG_ERROR("Failed to create callbackInfo.");
2350 napi_value err = CreateBusinessError(env, RetError::RET_ERR_NULLPTR);
2351 napi_throw(env, err);
2352 return nullptr;
2353 }
2354 callbackInfo->env_ = env;
2355 FindElementConstructCallbackInfo(env, argc, argv, callbackInfo, accessibilityElement);
2356 if (callbackInfo == nullptr) {
2357 return nullptr;
2358 }
2359 return FindElementAsync(env, argc, argv, callbackInfo, accessibilityElement);
2360 }
2361
ParseConditionInt64(NAPICbInfo & cbInfo,NAccessibilityElementData * elementData,size_t paramIndex,FindElementCondition conditionId)2362 RetError NAccessibilityElement::ParseConditionInt64(NAPICbInfo& cbInfo,
2363 NAccessibilityElementData* elementData, size_t paramIndex, FindElementCondition conditionId)
2364 {
2365 int64_t value = -1;
2366 RetError ret = cbInfo.ParseInt64(paramIndex, value);
2367 if (ret != RetError::RET_OK) {
2368 HILOG_ERROR("Parse int64 failed");
2369 return ret;
2370 }
2371
2372 elementData->conditionId_ = conditionId;
2373 elementData->condition_ = std::to_string(value);
2374 elementData->systemApi = true;
2375 return RetError::RET_OK;
2376 }
2377
ParseConditionString(NAPICbInfo & cbInfo,NAccessibilityElementData * elementData,size_t paramIndex,FindElementCondition conditionId)2378 RetError NAccessibilityElement::ParseConditionString(NAPICbInfo& cbInfo,
2379 NAccessibilityElementData* elementData, size_t paramIndex, FindElementCondition conditionId)
2380 {
2381 RetError ret = cbInfo.ParseString(paramIndex, elementData->condition_);
2382 if (ret != RetError::RET_OK) {
2383 HILOG_ERROR("Parse string failed");
2384 return ret;
2385 }
2386
2387 elementData->conditionId_ = conditionId;
2388 elementData->systemApi = true;
2389 return RetError::RET_OK;
2390 }
2391
GetParent(napi_env env,napi_callback_info info)2392 napi_value NAccessibilityElement::GetParent(napi_env env, napi_callback_info info)
2393 {
2394 return QueryCommon(env,
2395 info,
2396 {ParseAccessibilityElement,
2397 [](NAPICbInfo& cbInfo, NAccessibilityElementData* elementData) {
2398 elementData->attribute_ = "parent";
2399 elementData->systemApi = true;
2400 return RetError::RET_OK;
2401 },
2402 std::bind(ParseCallback, std::placeholders::_1, std::placeholders::_2, PARAM0, std::placeholders::_3),
2403 RunAttributeValueAsync});
2404 }
2405
GetChildren(napi_env env,napi_callback_info info)2406 napi_value NAccessibilityElement::GetChildren(napi_env env, napi_callback_info info)
2407 {
2408 return QueryCommon(env,
2409 info,
2410 {ParseAccessibilityElement,
2411 [](NAPICbInfo& cbInfo, NAccessibilityElementData* elementData) {
2412 elementData->attribute_ = "children";
2413 elementData->systemApi = true;
2414 return RetError::RET_OK;
2415 },
2416 std::bind(ParseCallback, std::placeholders::_1, std::placeholders::_2, PARAM0, std::placeholders::_3),
2417 RunAttributeValueAsync});
2418 }
2419
GetRootElement(napi_env env,napi_callback_info info)2420 napi_value NAccessibilityElement::GetRootElement(napi_env env, napi_callback_info info)
2421 {
2422 return QueryCommon(env,
2423 info,
2424 {ParseAccessibilityElement,
2425 [](NAPICbInfo& cbInfo, NAccessibilityElementData* elementData) {
2426 elementData->attribute_ = "rootElement";
2427 elementData->systemApi = true;
2428 return RetError::RET_OK;
2429 },
2430 std::bind(ParseCallback, std::placeholders::_1, std::placeholders::_2, PARAM0, std::placeholders::_3),
2431 RunAttributeValueAsync});
2432 }
2433
FindElementByContent(napi_env env,napi_callback_info info)2434 napi_value NAccessibilityElement::FindElementByContent(napi_env env, napi_callback_info info)
2435 {
2436 return QueryCommon(env,
2437 info,
2438 {ParseAccessibilityElement,
2439 std::bind(ParseConditionString,
2440 std::placeholders::_1,
2441 std::placeholders::_2,
2442 PARAM0,
2443 FindElementCondition::FIND_ELEMENT_CONDITION_CONTENT),
2444 std::bind(ParseCallback, std::placeholders::_1, std::placeholders::_2, PARAM1, std::placeholders::_3),
2445 RunFindElementAsync});
2446 }
2447
FindElementByFocusDirection(napi_env env,napi_callback_info info)2448 napi_value NAccessibilityElement::FindElementByFocusDirection(napi_env env, napi_callback_info info)
2449 {
2450 return QueryCommon(env,
2451 info,
2452 {ParseAccessibilityElement,
2453 std::bind(ParseConditionString,
2454 std::placeholders::_1,
2455 std::placeholders::_2,
2456 PARAM0,
2457 FindElementCondition::FIND_ELEMENT_CONDITION_FOCUS_DIRECTION),
2458 std::bind(ParseCallback, std::placeholders::_1, std::placeholders::_2, PARAM1, std::placeholders::_3),
2459 RunFindElementAsync});
2460 }
2461
FindElementsByAccessibilityHintText(napi_env env,napi_callback_info info)2462 napi_value NAccessibilityElement::FindElementsByAccessibilityHintText(napi_env env, napi_callback_info info)
2463 {
2464 return QueryCommon(env,
2465 info,
2466 {ParseAccessibilityElement,
2467 std::bind(ParseConditionString,
2468 std::placeholders::_1,
2469 std::placeholders::_2,
2470 PARAM0,
2471 FindElementCondition::FIND_ELEMENT_CONDITION_TEXT_TYPE),
2472 std::bind(ParseCallback, std::placeholders::_1, std::placeholders::_2, PARAM1, std::placeholders::_3),
2473 RunFindElementAsync});
2474 }
2475
FindElementById(napi_env env,napi_callback_info info)2476 napi_value NAccessibilityElement::FindElementById(napi_env env, napi_callback_info info)
2477 {
2478 return QueryCommon(env,
2479 info,
2480 {ParseAccessibilityElement,
2481 std::bind(ParseConditionInt64,
2482 std::placeholders::_1,
2483 std::placeholders::_2,
2484 PARAM0,
2485 FindElementCondition::FIND_ELEMENT_CONDITION_ELEMENT_ID),
2486 std::bind(ParseCallback, std::placeholders::_1, std::placeholders::_2, PARAM1, std::placeholders::_3),
2487 RunFindElementAsync});
2488 }
2489
QueryCommon(napi_env env,napi_callback_info info,const ElementFunctionCallbackInfo & callbackInfo)2490 napi_value NAccessibilityElement::QueryCommon(napi_env env, napi_callback_info info,
2491 const ElementFunctionCallbackInfo& callbackInfo)
2492 {
2493 RetError ret = RET_OK;
2494 NAccessibilityElementData* elementData = new(std::nothrow) NAccessibilityElementData();
2495
2496 ScopeGuard guard([&]() {
2497 delete elementData;
2498 elementData = nullptr;
2499 napi_value err = CreateBusinessError(env, ret);
2500 napi_throw(env, err);
2501 });
2502
2503 if (elementData == nullptr) {
2504 HILOG_ERROR("Failed to create elementData.");
2505 ret = RetError::RET_ERR_NULLPTR;
2506 return nullptr;
2507 }
2508
2509 NAPICbInfo cbInfo(ARGS_SIZE_TWO);
2510 ret = cbInfo.Init(env, info);
2511 if (ret != RET_OK) {
2512 HILOG_ERROR("Init cbInfo failed.");
2513 return nullptr;
2514 }
2515
2516 HILOG_DEBUG("argc: %{public}d", (int)cbInfo.argc);
2517 elementData->env_ = env;
2518
2519 ret = callbackInfo.parseElement(cbInfo, elementData);
2520 if (ret != RET_OK) {
2521 HILOG_ERROR("parseElement failed.");
2522 return nullptr;
2523 }
2524
2525 ret = callbackInfo.parseCondition(cbInfo, elementData);
2526 if (ret != RET_OK) {
2527 HILOG_ERROR("parseCondition failed.");
2528 return nullptr;
2529 }
2530 HILOG_DEBUG("condition: %{public}s", elementData->condition_.c_str());
2531
2532 napi_value result = nullptr;
2533 if (callbackInfo.parseCallback) {
2534 callbackInfo.parseCallback(cbInfo, elementData, result);
2535 }
2536
2537 ret = callbackInfo.run(cbInfo, elementData, result);
2538 if (ret != RET_OK) {
2539 HILOG_ERROR("run failed.");
2540 return nullptr;
2541 }
2542
2543 guard.Dismiss();
2544 return result;
2545 }
2546
RunFindElementAsync(NAPICbInfo & cbInfo,NAccessibilityElementData * elementData,napi_value & result)2547 RetError NAccessibilityElement::RunFindElementAsync(NAPICbInfo& cbInfo, NAccessibilityElementData* elementData,
2548 napi_value& result)
2549 {
2550 if (!elementData->accessibilityElement_.isElementInfo_) {
2551 HILOG_ERROR("Type of AccessibilityElement is not right");
2552 return RetError::RET_ERR_FAILED;
2553 }
2554
2555 napi_value resource = nullptr;
2556 napi_create_string_utf8(elementData->env_, "FindElement", NAPI_AUTO_LENGTH, &resource);
2557 napi_create_async_work(elementData->env_, nullptr, resource, FindElementExecute,
2558 FindElementComplete, reinterpret_cast<void*>(elementData), &elementData->work_);
2559 napi_queue_async_work_with_qos(elementData->env_, elementData->work_, napi_qos_user_initiated);
2560
2561 return RetError::RET_OK;
2562 }
2563
RunAttributeValueAsync(NAPICbInfo & cbInfo,NAccessibilityElementData * elementData,napi_value & result)2564 RetError NAccessibilityElement::RunAttributeValueAsync(NAPICbInfo& cbInfo, NAccessibilityElementData* elementData,
2565 napi_value& result)
2566 {
2567 napi_value resource = nullptr;
2568 napi_create_string_utf8(elementData->env_, "AttributeValue", NAPI_AUTO_LENGTH, &resource);
2569 napi_create_async_work(elementData->env_, nullptr, resource, AttributeValueExecute,
2570 AttributeValueComplete, reinterpret_cast<void*>(elementData), &elementData->work_);
2571 napi_queue_async_work_with_qos(elementData->env_, elementData->work_, napi_qos_user_initiated);
2572
2573 return RetError::RET_OK;
2574 }
2575
ParseCallback(NAPICbInfo & cbInfo,NAccessibilityElementData * elementData,size_t paramIndex,napi_value & result)2576 void NAccessibilityElement::ParseCallback(NAPICbInfo& cbInfo, NAccessibilityElementData* elementData,
2577 size_t paramIndex, napi_value& result)
2578 {
2579 if (cbInfo.argc <= paramIndex) {
2580 napi_create_promise(cbInfo.env, &elementData->deferred_, &result);
2581 return;
2582 }
2583
2584 napi_valuetype valueType = napi_null;
2585 napi_typeof(cbInfo.env, cbInfo.argv[paramIndex], &valueType);
2586 if (valueType == napi_function) {
2587 napi_create_reference(cbInfo.env, cbInfo.argv[paramIndex], 1, &elementData->callback_);
2588 napi_get_undefined(cbInfo.env, &result);
2589 return;
2590 }
2591
2592 napi_create_promise(cbInfo.env, &elementData->deferred_, &result);
2593 }
2594
ParseAccessibilityElement(NAPICbInfo & cbInfo,NAccessibilityElementData * elementData)2595 RetError NAccessibilityElement::ParseAccessibilityElement(NAPICbInfo& cbInfo, NAccessibilityElementData* elementData)
2596 {
2597 AccessibilityElement* accessibilityElement = nullptr;
2598 napi_status status = napi_unwrap(cbInfo.env, cbInfo.thisVar, (void**)&accessibilityElement);
2599 if (!accessibilityElement || status != napi_ok) {
2600 HILOG_ERROR("accessibilityElement is null or status[%{public}d] is wrong", status);
2601 return RetError::RET_ERR_NULLPTR;
2602 }
2603
2604 elementData->accessibilityElement_ = *accessibilityElement;
2605 return RetError::RET_OK;
2606 }
2607
GetCursorPositionAsync(napi_env env,size_t argc,napi_value * argv,NAccessibilityElementData * callbackInfo,AccessibilityElement * accessibilityElement)2608 napi_value NAccessibilityElement::GetCursorPositionAsync(napi_env env, size_t argc, napi_value* argv,
2609 NAccessibilityElementData* callbackInfo, AccessibilityElement* accessibilityElement)
2610 {
2611 if (callbackInfo == nullptr) {
2612 HILOG_ERROR("callbackInfo is nullptr");
2613 return nullptr;
2614 }
2615 napi_value promise = nullptr;
2616 if (argc > ARGS_SIZE_ONE - 1) {
2617 napi_valuetype valueType = napi_null;
2618 napi_typeof(env, argv[PARAM0], &valueType);
2619 if (valueType == napi_function) {
2620 napi_create_reference(env, argv[PARAM0], 1, &callbackInfo->callback_);
2621 napi_get_undefined(env, &promise);
2622 } else {
2623 napi_create_promise(env, &callbackInfo->deferred_, &promise);
2624 }
2625 } else {
2626 napi_create_promise(env, &callbackInfo->deferred_, &promise);
2627 }
2628
2629 callbackInfo->accessibilityElement_ = *accessibilityElement;
2630
2631 napi_value resource = nullptr;
2632 napi_create_string_utf8(callbackInfo->env_, "GetCursorPosition", NAPI_AUTO_LENGTH, &resource);
2633 napi_create_async_work(callbackInfo->env_, nullptr, resource, GetCursorPositionExecute,
2634 GetCursorPositionComplete, reinterpret_cast<void*>(callbackInfo), &callbackInfo->work_);
2635 napi_queue_async_work_with_qos(callbackInfo->env_, callbackInfo->work_, napi_qos_user_initiated);
2636 return promise;
2637 }
2638
FindElementAsync(napi_env env,size_t argc,napi_value * argv,NAccessibilityElementData * callbackInfo,AccessibilityElement * accessibilityElement)2639 napi_value NAccessibilityElement::FindElementAsync(napi_env env, size_t argc, napi_value* argv,
2640 NAccessibilityElementData* callbackInfo, AccessibilityElement* accessibilityElement)
2641 {
2642 napi_value promise = nullptr;
2643 if (argc > ARGS_SIZE_THREE - 1) {
2644 napi_valuetype valueType = napi_null;
2645 napi_typeof(env, argv[PARAM2], &valueType);
2646 if (valueType == napi_function) {
2647 napi_create_reference(env, argv[PARAM2], 1, &callbackInfo->callback_);
2648 napi_get_undefined(env, &promise);
2649 } else {
2650 napi_create_promise(env, &callbackInfo->deferred_, &promise);
2651 }
2652 } else {
2653 napi_create_promise(env, &callbackInfo->deferred_, &promise);
2654 }
2655
2656 callbackInfo->accessibilityElement_ = *accessibilityElement;
2657
2658 napi_value resource = nullptr;
2659 napi_create_string_utf8(callbackInfo->env_, "FindElement", NAPI_AUTO_LENGTH, &resource);
2660 napi_create_async_work(callbackInfo->env_, nullptr, resource, FindElementExecute,
2661 FindElementComplete, reinterpret_cast<void*>(callbackInfo), &callbackInfo->work_);
2662 napi_queue_async_work_with_qos(callbackInfo->env_, callbackInfo->work_, napi_qos_user_initiated);
2663 return promise;
2664 }
2665
FindElementConstructCallbackInfo(napi_env env,size_t argc,napi_value * argv,NAccessibilityElementData * callbackInfo,AccessibilityElement * accessibilityElement)2666 void NAccessibilityElement::FindElementConstructCallbackInfo(napi_env env, size_t argc, napi_value* argv,
2667 NAccessibilityElementData* callbackInfo, AccessibilityElement* accessibilityElement)
2668 {
2669 NAccessibilityErrorCode errCode = NAccessibilityErrorCode::ACCESSIBILITY_OK;
2670 if (argc < ARGS_SIZE_THREE - 1) {
2671 HILOG_ERROR("argc is invalid: %{public}zu", argc);
2672 errCode = NAccessibilityErrorCode::ACCESSIBILITY_ERROR_INVALID_PARAM;
2673 }
2674
2675 if (errCode == NAccessibilityErrorCode::ACCESSIBILITY_OK) {
2676 // Parse conditionType name
2677 std::string conditionType = "";
2678 if (ParseString(env, conditionType, argv[PARAM0])) {
2679 HILOG_DEBUG("conditionType = %{public}s", conditionType.c_str());
2680 if (std::strcmp(conditionType.c_str(), "content") != 0 &&
2681 std::strcmp(conditionType.c_str(), "focusType") != 0 &&
2682 std::strcmp(conditionType.c_str(), "focusDirection") != 0 &&
2683 std::strcmp(conditionType.c_str(), "textType") != 0 &&
2684 std::strcmp(conditionType.c_str(), "elementId") != 0) {
2685 HILOG_ERROR("argv[PARAM0] is wrong[%{public}s", conditionType.c_str());
2686 errCode = NAccessibilityErrorCode::ACCESSIBILITY_ERROR_INVALID_PARAM;
2687 } else {
2688 callbackInfo->conditionId_ = ConvertStringToCondition(conditionType);
2689 }
2690 } else {
2691 errCode = NAccessibilityErrorCode::ACCESSIBILITY_ERROR_INVALID_PARAM;
2692 }
2693
2694 // Parse queryData name
2695 std::string queryData = "";
2696 int64_t elementId;
2697 if (ParseString(env, queryData, argv[PARAM1])) {
2698 HILOG_DEBUG("queryData = %{public}s", queryData.c_str());
2699 callbackInfo->condition_ = queryData;
2700 } else if (ParseInt64(env, elementId, argv[PARAM1])) {
2701 queryData = std::to_string(elementId);
2702 HILOG_DEBUG("queryData = %{public}s", queryData.c_str());
2703 callbackInfo->condition_ = queryData;
2704 } else {
2705 errCode = NAccessibilityErrorCode::ACCESSIBILITY_ERROR_INVALID_PARAM;
2706 }
2707 }
2708
2709 if (errCode == NAccessibilityErrorCode::ACCESSIBILITY_ERROR_INVALID_PARAM) {
2710 delete callbackInfo;
2711 callbackInfo = nullptr;
2712 delete accessibilityElement;
2713 accessibilityElement = nullptr;
2714 napi_value err = CreateBusinessError(env, RetError::RET_ERR_INVALID_PARAM);
2715 HILOG_ERROR("invalid param");
2716 napi_throw(env, err);
2717 }
2718 }
2719
FindElementByText(NAccessibilityElementData * callbackInfo)2720 void NAccessibilityElement::FindElementByText(NAccessibilityElementData *callbackInfo)
2721 {
2722 bool systemApi = callbackInfo->systemApi;
2723 nlohmann::json jsonStr;
2724 jsonStr["type"] = (callbackInfo->conditionId_ ==
2725 FindElementCondition::FIND_ELEMENT_CONDITION_CONTENT) ? "content" : "textType";
2726 jsonStr["value"] = callbackInfo->condition_;
2727 callbackInfo->ret_ = AccessibleAbilityClient::GetInstance()->GetByContent(
2728 *(callbackInfo->accessibilityElement_.elementInfo_),
2729 jsonStr.dump().c_str(), callbackInfo->nodeInfos_, systemApi);
2730 return;
2731 }
2732
GetCursorPositionExecute(napi_env env,void * data)2733 void NAccessibilityElement::GetCursorPositionExecute(napi_env env, void* data)
2734 {
2735 HILOG_DEBUG("GetCursorPositionExecute");
2736 NAccessibilityElementData *callbackInfo = static_cast<NAccessibilityElementData*>(data);
2737 if (callbackInfo == nullptr) {
2738 HILOG_ERROR("callbackInfo is nullptr");
2739 return;
2740 }
2741
2742 callbackInfo->ret_ = AccessibleAbilityClient::GetInstance()->GetCursorPosition(
2743 *callbackInfo->accessibilityElement_.elementInfo_, callbackInfo->cursorPosition_);
2744 }
2745
FindElementExecute(napi_env env,void * data)2746 void NAccessibilityElement::FindElementExecute(napi_env env, void* data)
2747 {
2748 NAccessibilityElementData *callbackInfo = static_cast<NAccessibilityElementData*>(data);
2749 if (callbackInfo == nullptr) {
2750 HILOG_ERROR("callbackInfo is nullptr");
2751 return;
2752 }
2753
2754 bool systemApi = callbackInfo->systemApi;
2755 HILOG_DEBUG("systemApi: %{public}d", systemApi);
2756
2757 switch (callbackInfo->conditionId_) {
2758 case FindElementCondition::FIND_ELEMENT_CONDITION_INVALID:
2759 HILOG_ERROR("condition id is invalid");
2760 callbackInfo->ret_ = RET_ERR_INVALID_PARAM;
2761 return;
2762 case FindElementCondition::FIND_ELEMENT_CONDITION_CONTENT:
2763 {
2764 #ifdef ACCESSIBILITY_EMULATOR_DEFINED
2765 ApiReportHelper reporter("NAccessibilityElement.FindElementExecute.content");
2766 #endif // ACCESSIBILITY_EMULATOR_DEFINED
2767 FindElementByText(callbackInfo);
2768 }
2769 break;
2770 case FindElementCondition::FIND_ELEMENT_CONDITION_TEXT_TYPE:
2771 {
2772 #ifdef ACCESSIBILITY_EMULATOR_DEFINED
2773 ApiReportHelper reporterText("NAccessibilityElement.FindElementExecute.textType");
2774 #endif // ACCESSIBILITY_EMULATOR_DEFINED
2775 FindElementByText(callbackInfo);
2776 }
2777 break;
2778 case FindElementCondition::FIND_ELEMENT_CONDITION_FOCUS_TYPE:
2779 {
2780 int32_t focusType = ConvertStringToFocusType(callbackInfo->condition_);
2781 HILOG_DEBUG("focusType is %{public}d", focusType);
2782 callbackInfo->ret_ = AccessibleAbilityClient::GetInstance()->GetFocusByElementInfo(
2783 *(callbackInfo->accessibilityElement_.elementInfo_),
2784 focusType, callbackInfo->nodeInfo_);
2785 }
2786 break;
2787 case FindElementCondition::FIND_ELEMENT_CONDITION_FOCUS_DIRECTION:
2788 {
2789 FocusMoveDirection direction = ConvertStringToDirection(callbackInfo->condition_);
2790 HILOG_DEBUG("direction is %{public}d", direction);
2791 callbackInfo->ret_ = AccessibleAbilityClient::GetInstance()->GetNext(
2792 *(callbackInfo->accessibilityElement_.elementInfo_), direction,
2793 callbackInfo->nodeInfo_, systemApi);
2794 }
2795 break;
2796 case FindElementCondition::FIND_ELEMENT_CONDITION_ELEMENT_ID:
2797 {
2798 int64_t elementId = 0;
2799 if (!ConvertStringToInt64(callbackInfo->condition_, elementId)) {
2800 HILOG_ERROR("condition id convert failed");
2801 callbackInfo->ret_ = RET_ERR_INVALID_PARAM;
2802 return;
2803 }
2804 int32_t windowId = callbackInfo->accessibilityElement_.elementInfo_->GetWindowId();
2805 HILOG_DEBUG("elementId is %{public}" PRId64 " windowId: %{public}d", elementId, windowId);
2806 callbackInfo->ret_ = AccessibleAbilityClient::GetInstance()->GetByElementId(
2807 elementId, windowId, callbackInfo->nodeInfo_, systemApi);
2808 }
2809 break;
2810 default:
2811 break;
2812 }
2813 HILOG_DEBUG("condition id[%{public}d], result[%{public}d]", callbackInfo->conditionId_, callbackInfo->ret_);
2814 }
2815
2816
GetCursorPositionComplete(napi_env env,napi_status status,void * data)2817 void NAccessibilityElement::GetCursorPositionComplete(napi_env env, napi_status status, void* data)
2818 {
2819 HILOG_DEBUG("GetCursorPositionComplete execute back");
2820 NAccessibilityElementData* callbackInfo = static_cast<NAccessibilityElementData*>(data);
2821 if (callbackInfo == nullptr) {
2822 HILOG_ERROR("callbackInfo is nullptr");
2823 return;
2824 }
2825 napi_value result[ARGS_SIZE_TWO] = {0};
2826 napi_value callback = 0;
2827 napi_value undefined = 0;
2828 napi_get_undefined(env, &undefined);
2829 napi_create_int32(env, callbackInfo->cursorPosition_, &result[PARAM1]);
2830 HILOG_INFO("Response [callback cursorPosition:%{public}d]", callbackInfo->cursorPosition_);
2831 result[PARAM0] = CreateBusinessError(env, callbackInfo->ret_);
2832 if (callbackInfo->callback_) {
2833 // Callback mode
2834 napi_get_reference_value(env, callbackInfo->callback_, &callback);
2835 napi_value returnVal = nullptr;
2836 napi_call_function(env, undefined, callback, ARGS_SIZE_TWO, result, &returnVal);
2837 HILOG_INFO("NAccessibilityElement::GetCursorPositionComplete in CallbackMode");
2838 napi_delete_reference(env, callbackInfo->callback_);
2839 } else {
2840 // Promise mode
2841 if (callbackInfo->ret_ == RET_OK) {
2842 napi_resolve_deferred(env, callbackInfo->deferred_, result[PARAM1]);
2843 } else {
2844 napi_reject_deferred(env, callbackInfo->deferred_, result[PARAM0]);
2845 }
2846 }
2847
2848 napi_delete_async_work(env, callbackInfo->work_);
2849 delete callbackInfo;
2850 callbackInfo = nullptr;
2851 }
2852
FindElementComplete(napi_env env,napi_status status,void * data)2853 void NAccessibilityElement::FindElementComplete(napi_env env, napi_status status, void* data)
2854 {
2855 NAccessibilityElementData* callbackInfo = static_cast<NAccessibilityElementData*>(data);
2856 if (callbackInfo == nullptr) {
2857 HILOG_ERROR("callbackInfo is nullptr");
2858 return;
2859 }
2860
2861 napi_value result[ARGS_SIZE_TWO] = {0};
2862 // set reslult mainWindowId = param mainWidnowId
2863 int32_t mainWindowId = -1;
2864 if (callbackInfo->accessibilityElement_.elementInfo_ != nullptr) {
2865 mainWindowId = callbackInfo->accessibilityElement_.elementInfo_->GetMainWindowId();
2866 } else if (callbackInfo->accessibilityElement_.windowInfo_ != nullptr) {
2867 mainWindowId = callbackInfo->accessibilityElement_.windowInfo_->GetMainWindowId();
2868 }
2869
2870 if (mainWindowId > 0) {
2871 HILOG_INFO("callbackInfo node set mainWindowId: %{public}d", mainWindowId);
2872 callbackInfo->nodeInfo_.SetMainWindowId(mainWindowId);
2873 for (auto &node : callbackInfo->nodeInfos_) {
2874 node.SetMainWindowId(mainWindowId);
2875 }
2876 }
2877
2878 GetElement(callbackInfo, result[PARAM1]);
2879 result[PARAM0] = CreateBusinessError(env, callbackInfo->ret_);
2880 if (callbackInfo->callback_) {
2881 HILOG_DEBUG("callback mode. result is %{public}d", callbackInfo->ret_);
2882 napi_value callback = 0;
2883 napi_get_reference_value(env, callbackInfo->callback_, &callback);
2884 napi_value returnVal = nullptr;
2885 napi_value undefined = 0;
2886 napi_get_undefined(env, &undefined);
2887 napi_call_function(env, undefined, callback, ARGS_SIZE_TWO, result, &returnVal);
2888 napi_delete_reference(env, callbackInfo->callback_);
2889 } else {
2890 HILOG_DEBUG("promise mode. result is %{public}d", callbackInfo->ret_);
2891 if (callbackInfo->ret_ == RET_OK) {
2892 napi_resolve_deferred(env, callbackInfo->deferred_, result[PARAM1]);
2893 } else {
2894 napi_reject_deferred(env, callbackInfo->deferred_, result[PARAM0]);
2895 }
2896 }
2897 napi_delete_async_work(env, callbackInfo->work_);
2898 delete callbackInfo;
2899 callbackInfo = nullptr;
2900 }
2901
GetElement(NAccessibilityElementData * callbackInfo,napi_value & value)2902 void NAccessibilityElement::GetElement(NAccessibilityElementData *callbackInfo, napi_value &value)
2903 {
2904 HILOG_DEBUG("condition id[%{public}d]", callbackInfo->conditionId_);
2905 napi_env env = callbackInfo->env_;
2906 if (callbackInfo->ret_ != RET_OK) {
2907 HILOG_ERROR("GetElementInfo failed!");
2908 napi_get_undefined(env, &value);
2909 return;
2910 }
2911
2912 switch (callbackInfo->conditionId_) {
2913 case FindElementCondition::FIND_ELEMENT_CONDITION_INVALID:
2914 HILOG_ERROR("condition id is invalid");
2915 callbackInfo->ret_ = RET_ERR_INVALID_PARAM;
2916 return;
2917 case FindElementCondition::FIND_ELEMENT_CONDITION_CONTENT:
2918 napi_create_array(env, &value);
2919 ConvertElementInfosToJS(env, value, callbackInfo->nodeInfos_);
2920 break;
2921 case FindElementCondition::FIND_ELEMENT_CONDITION_TEXT_TYPE:
2922 napi_create_array(env, &value);
2923 ConvertElementInfosToJS(env, value, callbackInfo->nodeInfos_);
2924 break;
2925 case FindElementCondition::FIND_ELEMENT_CONDITION_FOCUS_TYPE:
2926 {
2927 napi_value constructor = nullptr;
2928 napi_get_reference_value(env, NAccessibilityElement::consRef_, &constructor);
2929 napi_new_instance(env, constructor, 0, nullptr, &value);
2930 ConvertElementInfoToJS(env, value, callbackInfo->nodeInfo_);
2931 }
2932 break;
2933 case FindElementCondition::FIND_ELEMENT_CONDITION_FOCUS_DIRECTION:
2934 {
2935 napi_value constructor = nullptr;
2936 napi_get_reference_value(env, NAccessibilityElement::consRef_, &constructor);
2937 napi_new_instance(env, constructor, 0, nullptr, &value);
2938 ConvertElementInfoToJS(env, value, callbackInfo->nodeInfo_);
2939 }
2940 break;
2941 case FindElementCondition::FIND_ELEMENT_CONDITION_ELEMENT_ID:
2942 {
2943 napi_value constructor = nullptr;
2944 napi_get_reference_value(env, NAccessibilityElement::consRef_, &constructor);
2945 napi_new_instance(env, constructor, 0, nullptr, &value);
2946 ConvertElementInfoToJS(env, value, callbackInfo->nodeInfo_);
2947 }
2948 break;
2949 default:
2950 break;
2951 }
2952 }
2953
ErrorOperation(NAccessibilityElementData * callbackInfo)2954 napi_value NAccessibilityElement::ErrorOperation(NAccessibilityElementData *callbackInfo)
2955 {
2956 HILOG_DEBUG();
2957 napi_value promise = nullptr;
2958 if (callbackInfo == nullptr) {
2959 HILOG_ERROR("callbackInfo is nullptr");
2960 return nullptr;
2961 }
2962 napi_env env = callbackInfo->env_;
2963 if (callbackInfo->callback_) {
2964 HILOG_DEBUG("callback mode");
2965 napi_get_undefined(env, &promise);
2966 } else {
2967 napi_create_promise(env, &callbackInfo->deferred_, &promise);
2968 }
2969
2970 napi_value resource = nullptr;
2971 napi_create_string_utf8(env, "ErrorOperation", NAPI_AUTO_LENGTH, &resource);
2972 if (resource == nullptr) {
2973 HILOG_ERROR("resource is nullptr.");
2974 return nullptr;
2975 }
2976 napi_create_async_work(env, nullptr, resource, [](napi_env env, void* data) {},
2977 // Execute the complete function
2978 [](napi_env env, napi_status status, void* data) {
2979 NAccessibilityElementData* callbackInfo = static_cast<NAccessibilityElementData*>(data);
2980 if (callbackInfo == nullptr) {
2981 HILOG_ERROR("callbackInfo is nullptr");
2982 return;
2983 }
2984
2985 napi_value result[ARGS_SIZE_TWO] = {0};
2986 napi_value callback = 0;
2987 napi_value undefined = 0;
2988 napi_get_undefined(env, &undefined);
2989 result[PARAM0] = CreateBusinessError(env, callbackInfo->ret_);
2990 if (callbackInfo->callback_) {
2991 // Callback mode
2992 result[PARAM1] = undefined;
2993 napi_get_reference_value(env, callbackInfo->callback_, &callback);
2994 napi_value returnVal = nullptr;
2995 napi_call_function(env, undefined, callback, ARGS_SIZE_TWO, result, &returnVal);
2996 napi_delete_reference(env, callbackInfo->callback_);
2997 } else {
2998 // Promise mode
2999 napi_reject_deferred(env, callbackInfo->deferred_, result[PARAM0]);
3000 }
3001 napi_delete_async_work(env, callbackInfo->work_);
3002 delete callbackInfo;
3003 callbackInfo = nullptr;
3004 },
3005 reinterpret_cast<void*>(callbackInfo),
3006 &callbackInfo->work_);
3007 napi_queue_async_work_with_qos(env, callbackInfo->work_, napi_qos_user_initiated);
3008 return promise;
3009 }
3010
GetCursorPosition(napi_env env,napi_callback_info info)3011 napi_value NAccessibilityElement::GetCursorPosition(napi_env env, napi_callback_info info)
3012 {
3013 size_t argc = ARGS_SIZE_ONE;
3014 napi_value argv[ARGS_SIZE_ONE] = {0};
3015 napi_value thisVar = nullptr;
3016 void* data = nullptr;
3017 napi_status status = napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
3018 if (status != napi_ok) {
3019 HILOG_ERROR("Failed to get cb info");
3020 return nullptr;
3021 }
3022 HILOG_DEBUG("argc = %{public}d", (int)argc);
3023
3024 // Unwrap AccessibilityElement
3025 AccessibilityElement* accessibilityElement = nullptr;
3026 status = napi_unwrap(env, thisVar, (void**)&accessibilityElement);
3027 if (!accessibilityElement || status != napi_ok) {
3028 HILOG_ERROR("accessibilityElement is null or status[%{public}d] is wrong", status);
3029 return nullptr;
3030 }
3031 if (!accessibilityElement->isElementInfo_) {
3032 HILOG_ERROR("Type of AccessibilityElement is not right");
3033 return nullptr;
3034 }
3035
3036 NAccessibilityElementData *callbackInfo = new(std::nothrow) NAccessibilityElementData();
3037 if (callbackInfo == nullptr) {
3038 HILOG_ERROR("Failed to create callbackInfo.");
3039 return nullptr;
3040 }
3041 callbackInfo->env_ = env;
3042 return GetCursorPositionAsync(env, argc, argv, callbackInfo, accessibilityElement);
3043 }
3044
ConvertStringToCondition(const std::string & str)3045 FindElementCondition NAccessibilityElement::ConvertStringToCondition(const std::string &str)
3046 {
3047 static const std::map<std::string, FindElementCondition> findElementConditionTable = {
3048 {"content", FindElementCondition::FIND_ELEMENT_CONDITION_CONTENT},
3049 {"focusType", FindElementCondition::FIND_ELEMENT_CONDITION_FOCUS_TYPE},
3050 {"focusDirection", FindElementCondition::FIND_ELEMENT_CONDITION_FOCUS_DIRECTION},
3051 {"elementId", FindElementCondition::FIND_ELEMENT_CONDITION_ELEMENT_ID},
3052 {"textType", FindElementCondition::FIND_ELEMENT_CONDITION_TEXT_TYPE}
3053 };
3054
3055 if (findElementConditionTable.find(str) == findElementConditionTable.end()) {
3056 return FindElementCondition::FIND_ELEMENT_CONDITION_INVALID;
3057 }
3058
3059 return findElementConditionTable.at(str);
3060 }
3061
ConvertStringToDirection(const std::string & str)3062 FocusMoveDirection NAccessibilityElement::ConvertStringToDirection(const std::string &str)
3063 {
3064 static const std::map<std::string, FocusMoveDirection> focusMoveDirectionTable = {
3065 {"up", FocusMoveDirection::UP},
3066 {"down", FocusMoveDirection::DOWN},
3067 {"left", FocusMoveDirection::LEFT},
3068 {"right", FocusMoveDirection::RIGHT},
3069 {"forward", FocusMoveDirection::FORWARD},
3070 {"backward", FocusMoveDirection::BACKWARD}
3071 };
3072
3073 if (focusMoveDirectionTable.find(str) == focusMoveDirectionTable.end()) {
3074 return FocusMoveDirection::DIRECTION_INVALID;
3075 }
3076
3077 return focusMoveDirectionTable.at(str);
3078 }
3079
ConvertStringToFocusType(const std::string & str)3080 int32_t NAccessibilityElement::ConvertStringToFocusType(const std::string &str)
3081 {
3082 static const std::map<std::string, int32_t> focusTypeTable = {
3083 {"normal", FOCUS_TYPE_INPUT},
3084 {"accessibility", FOCUS_TYPE_ACCESSIBILITY}
3085 };
3086
3087 if (focusTypeTable.find(str) == focusTypeTable.end()) {
3088 return FOCUS_TYPE_INVALID;
3089 }
3090 return focusTypeTable.at(str);
3091 }