1 /*
2 * Copyright (C) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "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 using namespace OHOS;
27 using namespace OHOS::Accessibility;
28 using namespace OHOS::AccessibilityNapi;
29 namespace {
30 const std::vector<std::string> ELEMENT_INFO_ATTRIBUTE_NAMES = {"componentId", "inspectorKey",
31 "bundleName", "componentType", "inputType", "text", "hintText", "description", "triggerAction",
32 "textMoveUnit", "contents", "lastContent", "itemCount", "currentIndex", "startIndex", "endIndex",
33 "resourceName", "textLengthLimit", "rect", "checkable", "checked", "focusable", "isVisible",
34 "selected", "clickable", "longClickable", "isEnable", "isPassword", "scrollable", "navDestinationId",
35 "editable", "pluralLineSupported", "parent", "children", "isFocused", "accessibilityFocused",
36 "error", "isHint", "pageId", "valueMax", "valueMin", "valueNow", "windowId", "accessibilityText",
37 "textType", "offset", "currentItem", "accessibilityGroup", "accessibilityLevel", "checkboxGroupSelectedStatus",
38 "row", "column", "listItemIndex", "sideBarContainerStates", "span", "isActive", "accessibilityVisible",
39 "allAttribute", "clip"};
40 const std::vector<std::string> WINDOW_INFO_ATTRIBUTE_NAMES = {"isActive", "screenRect", "layer", "type",
41 "rootElement", "isFocused", "windowId"};
42
43 using AttributeNamesFunc = void (*)(NAccessibilityElementData *callbackInfo, napi_value &value);
44 std::map<std::string, AttributeNamesFunc> elementInfoCompleteMap = {
45 {"componentId", &NAccessibilityElement::GetElementInfoComponentId},
46 {"inspectorKey", &NAccessibilityElement::GetElementInfoInspectorKey},
47 {"bundleName", &NAccessibilityElement::GetElementInfoBundleName},
48 {"componentType", &NAccessibilityElement::GetElementInfoComponentType},
49 {"inputType", &NAccessibilityElement::GetElementInfoInputType},
50 {"text", &NAccessibilityElement::GetElementInfoText},
51 {"hintText", &NAccessibilityElement::GetElementInfoHintText},
52 {"description", &NAccessibilityElement::GetElementInfoDescription},
53 {"resourceName", &NAccessibilityElement::GetElementInfoResourceName},
54 {"textLengthLimit", &NAccessibilityElement::GetElementInfoTextLengthLimit},
55 {"rect", &NAccessibilityElement::GetElementInfoRect},
56 {"checkable", &NAccessibilityElement::GetElementInfoCheckable},
57 {"checked", &NAccessibilityElement::GetElementInfoChecked},
58 {"focusable", &NAccessibilityElement::GetElementInfoFocusable},
59 {"isVisible", &NAccessibilityElement::GetElementInfoIsVisible},
60 {"selected", &NAccessibilityElement::GetElementInfoSelected},
61 {"clickable", &NAccessibilityElement::GetElementInfoClickable},
62 {"longClickable", &NAccessibilityElement::GetElementInfoLongClickable},
63 {"isEnable", &NAccessibilityElement::GetElementInfoIsEnable},
64 {"isPassword", &NAccessibilityElement::GetElementInfoIsPassword},
65 {"scrollable", &NAccessibilityElement::GetElementInfoScrollable},
66 {"editable", &NAccessibilityElement::GetElementInfoEditable},
67 {"pluralLineSupported", &NAccessibilityElement::GetElementInfoPluralLineSupported},
68 {"itemCount", &NAccessibilityElement::GetElementInfoItemCount},
69 {"currentIndex", &NAccessibilityElement::GetElementInfoCurrentIndex},
70 {"startIndex", &NAccessibilityElement::GetElementInfoStartIndex},
71 {"endIndex", &NAccessibilityElement::GetElementInfoEndIndex},
72 {"textMoveUnit", &NAccessibilityElement::GetElementInfoTextMoveUnit},
73 {"parent", &NAccessibilityElement::GetElementInfoParent},
74 {"children", &NAccessibilityElement::GetElementInfoChildren},
75 {"triggerAction", &NAccessibilityElement::GetElementInfoTriggerAction},
76 {"contents", &NAccessibilityElement::GetElementInfoContents},
77 {"lastContent", &NAccessibilityElement::GetElementInfoLastContent},
78 {"isFocused", &NAccessibilityElement::GetElementInfoIsFocused},
79 {"accessibilityFocused", &NAccessibilityElement::GetElementInfoAccessibilityFocused},
80 {"error", &NAccessibilityElement::GetElementInfoError},
81 {"isHint", &NAccessibilityElement::GetElementInfoIsHint},
82 {"pageId", &NAccessibilityElement::GetElementInfoPageId},
83 {"valueMax", &NAccessibilityElement::GetElementInfoValueMax},
84 {"valueMin", &NAccessibilityElement::GetElementInfoValueMin},
85 {"valueNow", &NAccessibilityElement::GetElementInfoValueNow},
86 {"windowId", &NAccessibilityElement::GetElementInfoWindowId},
87 {"accessibilityText", &NAccessibilityElement::GetElementInfoAccessibilityText},
88 {"textType", &NAccessibilityElement::GetElementInfoTextType},
89 {"offset", &NAccessibilityElement::GetElementInfoOffset},
90 {"accessibilityGroup", &NAccessibilityElement::GetElementInfoAccessibilityGroup},
91 {"accessibilityLevel", &NAccessibilityElement::GetElementInfoAccessibilityLevel},
92 {"navDestinationId", &NAccessibilityElement::GetElementInfoNavDestinationId},
93 {"currentItem", &NAccessibilityElement::GetElementInfoGridItem},
94 {"checkboxGroupSelectedStatus", &NAccessibilityElement::GetElementInfoCheckboxGroup},
95 {"row", &NAccessibilityElement::GetElementInfoRow},
96 {"column", &NAccessibilityElement::GetElementInfoColumn},
97 {"listItemIndex", &NAccessibilityElement::GetElementInfoListItemIndex},
98 {"sideBarContainerStates", &NAccessibilityElement::GetElementInfoSideBarContainer},
99 {"span", &NAccessibilityElement::GetElementInfoSpan},
100 {"isActive", &NAccessibilityElement::GetElementInfoIsActive},
101 {"accessibilityVisible", &NAccessibilityElement::GetElementInfoAccessibilityVisible},
102 {"allAttribute", &NAccessibilityElement::GetElementInfoAllAttribute},
103 {"clip", &NAccessibilityElement::GetElementInfoClip},
104 };
105 std::map<std::string, AttributeNamesFunc> windowInfoCompleteMap = {
106 {"isActive", &NAccessibilityElement::GetWindowInfoIsActive},
107 {"screenRect", &NAccessibilityElement::GetWindowInfoScreenRect},
108 {"layer", &NAccessibilityElement::GetWindowInfoLayer},
109 {"type", &NAccessibilityElement::GetWindowInfoType},
110 {"rootElement", &NAccessibilityElement::GetWindowInfoRootElement},
111 {"isFocused", &NAccessibilityElement::GetWindowInfoIsFocused},
112 {"windowId", &NAccessibilityElement::GetWindowInfoWindowId},
113 };
114 } // namespace
115
116 thread_local napi_ref NAccessibilityElement::consRef_ = nullptr;
117
DefineJSAccessibilityElement(napi_env env)118 void NAccessibilityElement::DefineJSAccessibilityElement(napi_env env)
119 {
120 napi_property_descriptor descForAccessibilityElement[] = {
121 DECLARE_NAPI_FUNCTION("attributeNames", NAccessibilityElement::AttributeNames),
122 DECLARE_NAPI_FUNCTION("attributeValue", NAccessibilityElement::AttributeValue),
123 DECLARE_NAPI_FUNCTION("actionNames", NAccessibilityElement::ActionNames),
124 DECLARE_NAPI_FUNCTION("enableScreenCurtain", NAccessibilityElement::EnableScreenCurtain),
125 DECLARE_NAPI_FUNCTION("performAction", NAccessibilityElement::PerformAction),
126 DECLARE_NAPI_FUNCTION("getCursorPosition", NAccessibilityElement::GetCursorPosition),
127 DECLARE_NAPI_FUNCTION("findElement", NAccessibilityElement::FindElement),
128 };
129
130 napi_value constructor = nullptr;
131
132 NAPI_CALL_RETURN_VOID(env,
133 napi_define_class(env,
134 "AccessibilityElement",
135 NAPI_AUTO_LENGTH,
136 NAccessibilityElement::JSConstructor,
137 nullptr,
138 sizeof(descForAccessibilityElement) / sizeof(descForAccessibilityElement[0]),
139 descForAccessibilityElement,
140 &constructor));
141 napi_create_reference(env, constructor, 1, &NAccessibilityElement::consRef_);
142 }
143
JSConstructor(napi_env env,napi_callback_info info)144 napi_value NAccessibilityElement::JSConstructor(napi_env env, napi_callback_info info)
145 {
146 napi_value jsthis = nullptr;
147 NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &jsthis, nullptr));
148 return jsthis;
149 }
150
ConvertElementInfoToJS(napi_env env,napi_value result,const AccessibilityElementInfo & elementInfo)151 void NAccessibilityElement::ConvertElementInfoToJS(napi_env env, napi_value result,
152 const AccessibilityElementInfo& elementInfo)
153 {
154 // Bind js object to a Native object
155 std::shared_ptr<AccessibilityElementInfo> elementInformation =
156 std::make_shared<AccessibilityElementInfo>(elementInfo);
157 AccessibilityElement* pAccessibilityElement = new(std::nothrow) AccessibilityElement(elementInformation);
158 if (!pAccessibilityElement) {
159 HILOG_ERROR("Failed to create elementInformation.");
160 return;
161 }
162 napi_status sts = napi_wrap(
163 env,
164 result,
165 pAccessibilityElement,
166 [](napi_env env, void* data, void* hint) {
167 AccessibilityElement* info = static_cast<AccessibilityElement*>(data);
168 delete info;
169 info = nullptr;
170 },
171 nullptr,
172 nullptr);
173 HILOG_DEBUG("napi_wrap status: %{public}d", (int)sts);
174 }
175
ConvertElementInfosToJS(napi_env env,napi_value result,const std::vector<OHOS::Accessibility::AccessibilityElementInfo> & elementInfos)176 void NAccessibilityElement::ConvertElementInfosToJS(
177 napi_env env, napi_value result, const std::vector<OHOS::Accessibility::AccessibilityElementInfo>& elementInfos)
178 {
179 HILOG_DEBUG("elementInfo size(%{public}zu)", elementInfos.size());
180
181 napi_value constructor = nullptr;
182 napi_get_reference_value(env, NAccessibilityElement::consRef_, &constructor);
183
184 size_t index = 0;
185 for (auto& elementInfo : elementInfos) {
186 napi_value obj = nullptr;
187 napi_status status = napi_new_instance(env, constructor, 0, nullptr, &obj);
188 HILOG_DEBUG("status is %{public}d", status);
189 ConvertElementInfoToJS(env, obj, elementInfo);
190 napi_set_element(env, result, index, obj);
191 index++;
192 }
193 }
194
AttributeNames(napi_env env,napi_callback_info info)195 napi_value NAccessibilityElement::AttributeNames(napi_env env, napi_callback_info info)
196 {
197 HILOG_DEBUG();
198 size_t argc = ARGS_SIZE_ONE;
199 napi_value argv = nullptr;
200 napi_value thisVar = nullptr;
201 void* data = nullptr;
202 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &argv, &thisVar, &data));
203 HILOG_DEBUG("argc = %{public}d", (int)argc);
204
205 NAccessibilityElementData *callbackInfo = new(std::nothrow) NAccessibilityElementData();
206 if (!callbackInfo) {
207 HILOG_ERROR("Failed to create callbackInfo.");
208 return nullptr;
209 }
210 callbackInfo->env_ = env;
211
212 napi_value promise = nullptr;
213 if (argc > ARGS_SIZE_ONE - 1) {
214 napi_valuetype valueType = napi_null;
215 napi_typeof(env, argv, &valueType);
216 if (valueType == napi_function) {
217 napi_create_reference(env, argv, 1, &callbackInfo->callback_);
218 napi_get_undefined(env, &promise);
219 } else {
220 napi_create_promise(env, &callbackInfo->deferred_, &promise);
221 }
222 } else {
223 napi_create_promise(env, &callbackInfo->deferred_, &promise);
224 }
225
226 AccessibilityElement* accessibilityElement = nullptr;
227 napi_status status = napi_unwrap(env, thisVar, (void**)&accessibilityElement);
228 if (!accessibilityElement || status != napi_ok) {
229 HILOG_ERROR("accessibilityElement is null or status[%{public}d] is wrong", status);
230 return ErrorOperation(callbackInfo);
231 }
232 callbackInfo->accessibilityElement_ = *accessibilityElement;
233
234 napi_value resource = nullptr;
235 napi_create_string_utf8(env, "AttributeNames", NAPI_AUTO_LENGTH, &resource);
236 if (resource == nullptr) {
237 HILOG_ERROR("resource is nullptr.");
238 return nullptr;
239 }
240 napi_create_async_work(env, nullptr, resource, [](napi_env env, void* data) {},
241 // Execute the complete function
242 AttributeNamesComplete,
243 reinterpret_cast<void*>(callbackInfo),
244 &callbackInfo->work_);
245 napi_queue_async_work_with_qos(env, callbackInfo->work_, napi_qos_user_initiated);
246 return promise;
247 }
248
AttributeNamesComplete(napi_env env,napi_status status,void * data)249 void NAccessibilityElement::AttributeNamesComplete(napi_env env, napi_status status, void* data)
250 {
251 HILOG_DEBUG("AttributeNameComplete execute back");
252 NAccessibilityElementData* callbackInfo = static_cast<NAccessibilityElementData*>(data);
253 napi_value result[ARGS_SIZE_TWO] = {0};
254 napi_value callback = 0;
255 napi_value undefined = 0;
256 napi_get_undefined(env, &undefined);
257 if (!callbackInfo) {
258 HILOG_ERROR("callbackInfo is nullptr");
259 return;
260 }
261
262 napi_create_array(env, &result[1]);
263 if (callbackInfo->accessibilityElement_.isElementInfo_) {
264 HILOG_DEBUG("covert element info to js");
265 ConvertStringVecToJS(env, result[1], ELEMENT_INFO_ATTRIBUTE_NAMES);
266 } else {
267 HILOG_DEBUG("covert window info to js");
268 ConvertStringVecToJS(env, result[1], WINDOW_INFO_ATTRIBUTE_NAMES);
269 }
270
271 if (callbackInfo->callback_) {
272 // Callback mode
273 result[PARAM0] = CreateBusinessError(env, OHOS::Accessibility::RetError::RET_OK);
274 napi_get_reference_value(env, callbackInfo->callback_, &callback);
275 napi_value returnVal = nullptr;
276 napi_call_function(env, undefined, callback, ARGS_SIZE_TWO, result, &returnVal);
277 napi_delete_reference(env, callbackInfo->callback_);
278 } else {
279 // Promise mode
280 napi_resolve_deferred(env, callbackInfo->deferred_, result[PARAM1]);
281 }
282 napi_delete_async_work(env, callbackInfo->work_);
283 delete callbackInfo;
284 callbackInfo = nullptr;
285 }
286
AttributeValue(napi_env env,napi_callback_info info)287 napi_value NAccessibilityElement::AttributeValue(napi_env env, napi_callback_info info)
288 {
289 size_t argc = ARGS_SIZE_TWO;
290 napi_value argv[ARGS_SIZE_TWO] = {0};
291 napi_value thisVar = nullptr;
292 void* data = nullptr;
293 napi_status status = napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
294 if (status != napi_ok) {
295 HILOG_ERROR("Failed to get cb info");
296 napi_value err = CreateBusinessError(env, RetError::RET_ERR_FAILED);
297 napi_throw(env, err);
298 return nullptr;
299 }
300 HILOG_DEBUG("argc = %{public}d", (int)argc);
301
302 // Unwrap AccessibilityElement
303 AccessibilityElement* accessibilityElement = nullptr;
304 status = napi_unwrap(env, thisVar, (void**)&accessibilityElement);
305 if (!accessibilityElement || status != napi_ok) {
306 HILOG_ERROR("accessibilityElement is null or status[%{public}d] is wrong", status);
307 napi_value err = CreateBusinessError(env, RetError::RET_ERR_NULLPTR);
308 napi_throw(env, err);
309 return nullptr;
310 }
311
312 NAccessibilityElementData *callbackInfo = new(std::nothrow) NAccessibilityElementData();
313 if (!callbackInfo) {
314 HILOG_ERROR("Failed to create callbackInfo.");
315 napi_value err = CreateBusinessError(env, RetError::RET_ERR_NULLPTR);
316 napi_throw(env, err);
317 return nullptr;
318 }
319 callbackInfo->env_ = env;
320 callbackInfo->accessibilityElement_ = *accessibilityElement;
321
322 NAccessibilityErrorCode errCode = GetAttribute(env, argc, argv, callbackInfo);
323 if (errCode == NAccessibilityErrorCode::ACCESSIBILITY_ERROR_INVALID_PARAM) {
324 delete callbackInfo;
325 callbackInfo = nullptr;
326 delete accessibilityElement;
327 accessibilityElement = nullptr;
328 napi_value err = CreateBusinessError(env, RetError::RET_ERR_INVALID_PARAM);
329 HILOG_ERROR("invalid param");
330 napi_throw(env, err);
331 return nullptr;
332 }
333
334 return AttributeValueAsync(env, argc, argv, callbackInfo);
335 }
336
GetAttribute(napi_env env,size_t argc,napi_value * argv,NAccessibilityElementData * callbackInfo)337 NAccessibilityErrorCode NAccessibilityElement::GetAttribute(
338 napi_env env, size_t argc, napi_value* argv, NAccessibilityElementData* callbackInfo)
339 {
340 NAccessibilityErrorCode errCode = NAccessibilityErrorCode::ACCESSIBILITY_OK;
341 if (argc < ARGS_SIZE_TWO - 1) {
342 HILOG_ERROR("argc is invalid: %{public}zu", argc);
343 errCode = NAccessibilityErrorCode::ACCESSIBILITY_ERROR_INVALID_PARAM;
344 }
345
346 if (errCode == NAccessibilityErrorCode::ACCESSIBILITY_OK) {
347 // Parse attribute name
348 std::string attribute = "";
349 if (ParseString(env, attribute, argv[PARAM0])) {
350 HILOG_DEBUG("attribute = %{public}s", attribute.c_str());
351 callbackInfo->attribute_ = attribute;
352 } else {
353 errCode = NAccessibilityErrorCode::ACCESSIBILITY_ERROR_INVALID_PARAM;
354 }
355 }
356 return errCode;
357 }
358
AttributeValueAsync(napi_env env,size_t argc,napi_value * argv,NAccessibilityElementData * callbackInfo)359 napi_value NAccessibilityElement::AttributeValueAsync(
360 napi_env env, size_t argc, napi_value* argv, NAccessibilityElementData* callbackInfo)
361 {
362 napi_value promise = nullptr;
363 if (argc > ARGS_SIZE_TWO - 1) {
364 napi_valuetype valueType = napi_null;
365 napi_typeof(env, argv[PARAM1], &valueType);
366 if (valueType == napi_function) {
367 napi_create_reference(env, argv[PARAM1], 1, &callbackInfo->callback_);
368 napi_get_undefined(env, &promise);
369 } else {
370 napi_create_promise(env, &callbackInfo->deferred_, &promise);
371 }
372 } else {
373 napi_create_promise(env, &callbackInfo->deferred_, &promise);
374 }
375
376 napi_value resource = nullptr;
377 napi_create_string_utf8(env, "AttributeValue", NAPI_AUTO_LENGTH, &resource);
378 napi_create_async_work(env, nullptr, resource, NAccessibilityElement::AttributeValueExecute,
379 NAccessibilityElement::AttributeValueComplete, reinterpret_cast<void*>(callbackInfo), &callbackInfo->work_);
380 napi_queue_async_work_with_qos(env, callbackInfo->work_, napi_qos_user_initiated);
381 return promise;
382 }
383
AttributeValueExecute(napi_env env,void * data)384 void NAccessibilityElement::AttributeValueExecute(napi_env env, void* data)
385 {
386 NAccessibilityElementData* callbackInfo = static_cast<NAccessibilityElementData*>(data);
387 if (!callbackInfo) {
388 HILOG_ERROR("callbackInfo is nullptr");
389 return;
390 }
391
392 if (callbackInfo->attribute_ == "parent") {
393 if (callbackInfo->accessibilityElement_.elementInfo_) {
394 callbackInfo->ret_ = AccessibleAbilityClient::GetInstance()->GetParentElementInfo(
395 *callbackInfo->accessibilityElement_.elementInfo_, callbackInfo->nodeInfo_);
396 } else {
397 HILOG_ERROR("elementInfo is nullptr");
398 }
399 } else if (callbackInfo->attribute_ == "children") {
400 if (callbackInfo->accessibilityElement_.elementInfo_) {
401 callbackInfo->ret_ = AccessibleAbilityClient::GetInstance()->GetChildren(
402 *callbackInfo->accessibilityElement_.elementInfo_, callbackInfo->nodeInfos_);
403 } else {
404 HILOG_ERROR("elementInfo is nullptr");
405 }
406 } else if (callbackInfo->attribute_ == "rootElement") {
407 if (callbackInfo->accessibilityElement_.windowInfo_) {
408 callbackInfo->ret_ = AccessibleAbilityClient::GetInstance()->GetRootByWindow(
409 *callbackInfo->accessibilityElement_.windowInfo_, callbackInfo->nodeInfo_);
410 } else {
411 HILOG_ERROR("windowInfo is nullptr");
412 }
413 } else {
414 callbackInfo->ret_ = RET_OK;
415 }
416 HILOG_DEBUG("attribute[%{public}s], result[%{public}d]", callbackInfo->attribute_.c_str(), callbackInfo->ret_);
417 }
418
AttributeValueComplete(napi_env env,napi_status status,void * data)419 void NAccessibilityElement::AttributeValueComplete(napi_env env, napi_status status, void* data)
420 {
421 NAccessibilityElementData* callbackInfo = static_cast<NAccessibilityElementData*>(data);
422 if (!callbackInfo) {
423 HILOG_ERROR("callbackInfo is nullptr");
424 return;
425 }
426 napi_value result[ARGS_SIZE_TWO] = {0};
427
428 if (callbackInfo->accessibilityElement_.isElementInfo_) {
429 HILOG_DEBUG("It is element info");
430 auto elementIter = elementInfoCompleteMap.find(callbackInfo->attribute_);
431 if (elementIter == elementInfoCompleteMap.end()) {
432 HILOG_ERROR("There is no the attribute[%{public}s] in element info", callbackInfo->attribute_.c_str());
433 napi_get_undefined(callbackInfo->env_, &result[PARAM1]);
434 callbackInfo->ret_ = RET_ERR_PROPERTY_NOT_EXIST;
435 } else {
436 (*elementIter->second)(callbackInfo, result[PARAM1]);
437 }
438 } else {
439 HILOG_DEBUG("It is window info");
440 auto windowIter = windowInfoCompleteMap.find(callbackInfo->attribute_);
441 if (windowIter == windowInfoCompleteMap.end()) {
442 HILOG_ERROR("There is no the attribute[%{public}s]", callbackInfo->attribute_.c_str());
443 napi_get_undefined(callbackInfo->env_, &result[PARAM1]);
444 callbackInfo->ret_ = RET_ERR_PROPERTY_NOT_EXIST;
445 } else {
446 (*windowIter->second)(callbackInfo, result[PARAM1]);
447 }
448 }
449
450 HILOG_DEBUG("result is %{public}d", callbackInfo->ret_);
451 result[PARAM0] = CreateBusinessError(env, callbackInfo->ret_);
452 if (callbackInfo->callback_) {
453 napi_value callback = nullptr;
454 napi_value returnVal = nullptr;
455 napi_value undefined = nullptr;
456 napi_get_reference_value(env, callbackInfo->callback_, &callback);
457 napi_get_undefined(env, &undefined); // 是否加判断
458 napi_call_function(env, undefined, callback, ARGS_SIZE_TWO, result, &returnVal);
459 napi_delete_reference(env, callbackInfo->callback_);
460 } else {
461 if (callbackInfo->ret_ == RET_OK) {
462 napi_resolve_deferred(env, callbackInfo->deferred_, result[PARAM1]);
463 } else {
464 napi_reject_deferred(env, callbackInfo->deferred_, result[PARAM0]);
465 }
466 }
467 napi_delete_async_work(env, callbackInfo->work_);
468 delete callbackInfo;
469 callbackInfo = nullptr;
470 }
471
CheckElementInfoParameter(NAccessibilityElementData * callbackInfo,napi_value & value)472 bool NAccessibilityElement::CheckElementInfoParameter(NAccessibilityElementData *callbackInfo, napi_value &value)
473 {
474 if (!callbackInfo) {
475 HILOG_ERROR("callbackInfo is nullptr");
476 return false;
477 }
478 if (!callbackInfo->accessibilityElement_.elementInfo_) {
479 HILOG_ERROR("element info is nullptr");
480 napi_get_undefined(callbackInfo->env_, &value);
481 callbackInfo->ret_ = RET_ERR_FAILED;
482 return false;
483 }
484 return true;
485 }
486
GetElementInfoComponentId(NAccessibilityElementData * callbackInfo,napi_value & value)487 void NAccessibilityElement::GetElementInfoComponentId(NAccessibilityElementData *callbackInfo, napi_value &value)
488 {
489 if (!CheckElementInfoParameter(callbackInfo, value)) {
490 return;
491 }
492 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_bigint_int64(callbackInfo->env_,
493 callbackInfo->accessibilityElement_.elementInfo_->GetAccessibilityId(), &value));
494 }
495
GetElementInfoPageId(NAccessibilityElementData * callbackInfo,napi_value & value)496 void NAccessibilityElement::GetElementInfoPageId(NAccessibilityElementData *callbackInfo, napi_value &value)
497 {
498 if (!CheckElementInfoParameter(callbackInfo, value)) {
499 return;
500 }
501 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
502 callbackInfo->accessibilityElement_.elementInfo_->GetPageId(), &value));
503 }
504
GetElementInfoInspectorKey(NAccessibilityElementData * callbackInfo,napi_value & value)505 void NAccessibilityElement::GetElementInfoInspectorKey(NAccessibilityElementData *callbackInfo, napi_value &value)
506 {
507 if (!CheckElementInfoParameter(callbackInfo, value)) {
508 return;
509 }
510 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
511 callbackInfo->accessibilityElement_.elementInfo_->GetInspectorKey().c_str(), NAPI_AUTO_LENGTH, &value));
512 }
513
GetElementInfoBundleName(NAccessibilityElementData * callbackInfo,napi_value & value)514 void NAccessibilityElement::GetElementInfoBundleName(NAccessibilityElementData *callbackInfo, napi_value &value)
515 {
516 if (!CheckElementInfoParameter(callbackInfo, value)) {
517 return;
518 }
519 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
520 callbackInfo->accessibilityElement_.elementInfo_->GetBundleName().c_str(), NAPI_AUTO_LENGTH, &value));
521 }
522
GetElementInfoComponentType(NAccessibilityElementData * callbackInfo,napi_value & value)523 void NAccessibilityElement::GetElementInfoComponentType(NAccessibilityElementData *callbackInfo, napi_value &value)
524 {
525 if (!CheckElementInfoParameter(callbackInfo, value)) {
526 return;
527 }
528 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
529 callbackInfo->accessibilityElement_.elementInfo_->GetComponentType().c_str(), NAPI_AUTO_LENGTH, &value));
530 }
531
GetElementInfoInputType(NAccessibilityElementData * callbackInfo,napi_value & value)532 void NAccessibilityElement::GetElementInfoInputType(NAccessibilityElementData *callbackInfo, napi_value &value)
533 {
534 if (!CheckElementInfoParameter(callbackInfo, value)) {
535 return;
536 }
537 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
538 callbackInfo->accessibilityElement_.elementInfo_->GetInputType(), &value));
539 }
540
GetElementInfoText(NAccessibilityElementData * callbackInfo,napi_value & value)541 void NAccessibilityElement::GetElementInfoText(NAccessibilityElementData *callbackInfo, napi_value &value)
542 {
543 if (!CheckElementInfoParameter(callbackInfo, value)) {
544 return;
545 }
546 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
547 callbackInfo->accessibilityElement_.elementInfo_->GetContent().c_str(), NAPI_AUTO_LENGTH, &value));
548 }
549
GetElementInfoHintText(NAccessibilityElementData * callbackInfo,napi_value & value)550 void NAccessibilityElement::GetElementInfoHintText(NAccessibilityElementData *callbackInfo, napi_value &value)
551 {
552 if (!CheckElementInfoParameter(callbackInfo, value)) {
553 return;
554 }
555 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
556 callbackInfo->accessibilityElement_.elementInfo_->GetHint().c_str(), NAPI_AUTO_LENGTH, &value));
557 }
558
GetElementInfoDescription(NAccessibilityElementData * callbackInfo,napi_value & value)559 void NAccessibilityElement::GetElementInfoDescription(NAccessibilityElementData *callbackInfo, napi_value &value)
560 {
561 if (!CheckElementInfoParameter(callbackInfo, value)) {
562 return;
563 }
564 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
565 callbackInfo->accessibilityElement_.elementInfo_->GetDescriptionInfo().c_str(), NAPI_AUTO_LENGTH, &value));
566 }
567
GetElementInfoResourceName(NAccessibilityElementData * callbackInfo,napi_value & value)568 void NAccessibilityElement::GetElementInfoResourceName(NAccessibilityElementData *callbackInfo, napi_value &value)
569 {
570 if (!CheckElementInfoParameter(callbackInfo, value)) {
571 return;
572 }
573 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
574 callbackInfo->accessibilityElement_.elementInfo_->GetComponentResourceId().c_str(), NAPI_AUTO_LENGTH, &value));
575 }
576
GetElementInfoTextLengthLimit(NAccessibilityElementData * callbackInfo,napi_value & value)577 void NAccessibilityElement::GetElementInfoTextLengthLimit(NAccessibilityElementData *callbackInfo, napi_value &value)
578 {
579 if (!CheckElementInfoParameter(callbackInfo, value)) {
580 return;
581 }
582 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
583 callbackInfo->accessibilityElement_.elementInfo_->GetTextLengthLimit(), &value));
584 }
585
GetElementInfoRect(NAccessibilityElementData * callbackInfo,napi_value & value)586 void NAccessibilityElement::GetElementInfoRect(NAccessibilityElementData *callbackInfo, napi_value &value)
587 {
588 if (!CheckElementInfoParameter(callbackInfo, value)) {
589 return;
590 }
591 OHOS::Accessibility::Rect screenRect = callbackInfo->accessibilityElement_.elementInfo_->GetRectInScreen();
592 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_object(callbackInfo->env_, &value));
593 ConvertRectToJS(callbackInfo->env_, value, screenRect);
594 }
595
GetElementInfoGridItem(NAccessibilityElementData * callbackInfo,napi_value & value)596 void NAccessibilityElement::GetElementInfoGridItem(NAccessibilityElementData *callbackInfo, napi_value &value)
597 {
598 if (!CheckElementInfoParameter(callbackInfo, value)) {
599 return;
600 }
601 OHOS::Accessibility::GridItemInfo gridItem = callbackInfo->accessibilityElement_.elementInfo_->GetGridItem();
602 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_object(callbackInfo->env_, &value));
603 ConvertGridItemToJS(callbackInfo->env_, value, gridItem);
604 }
605
GetExtraElementInfo(NAccessibilityElementData * callbackInfo,napi_value & value,std::string keyStr)606 void NAccessibilityElement::GetExtraElementInfo(NAccessibilityElementData *callbackInfo,
607 napi_value &value, std::string keyStr)
608 {
609 std::map<std::string, std::string> mapValIsStr =
610 callbackInfo->accessibilityElement_.elementInfo_->GetExtraElement().GetExtraElementInfoValueStr();
611 std::map<std::string, int32_t> mapValIsInt =
612 callbackInfo->accessibilityElement_.elementInfo_->GetExtraElement().GetExtraElementInfoValueInt();
613 HILOG_DEBUG("GetExtraElementInfo: size is extraElementValueStr : [%{public}zu]",
614 mapValIsStr.size());
615 HILOG_DEBUG("GetExtraElementInfo: size is extraElementValueInt : [%{public}zu]",
616 mapValIsInt.size());
617
618 auto iter = mapValIsStr.find(keyStr);
619 if (iter != mapValIsStr.end()) {
620 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
621 iter->second.c_str(), NAPI_AUTO_LENGTH, &value));
622 return;
623 }
624 auto seconditer = mapValIsInt.find(keyStr);
625 if (seconditer != mapValIsInt.end()) {
626 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_, seconditer->second, &value));
627 return;
628 }
629
630 napi_get_undefined(callbackInfo->env_, &value);
631 }
632
GetElementInfoCheckboxGroup(NAccessibilityElementData * callbackInfo,napi_value & value)633 void NAccessibilityElement::GetElementInfoCheckboxGroup(NAccessibilityElementData *callbackInfo, napi_value &value)
634 {
635 if (!CheckElementInfoParameter(callbackInfo, value)) {
636 return;
637 }
638 GetExtraElementInfo(callbackInfo, value, "CheckboxGroupSelectedStatus");
639 }
640
GetElementInfoRow(NAccessibilityElementData * callbackInfo,napi_value & value)641 void NAccessibilityElement::GetElementInfoRow(NAccessibilityElementData *callbackInfo, napi_value &value)
642 {
643 if (!CheckElementInfoParameter(callbackInfo, value)) {
644 return;
645 }
646 GetExtraElementInfo(callbackInfo, value, "Row");
647 }
648
GetElementInfoColumn(NAccessibilityElementData * callbackInfo,napi_value & value)649 void NAccessibilityElement::GetElementInfoColumn(NAccessibilityElementData *callbackInfo, napi_value &value)
650 {
651 if (!CheckElementInfoParameter(callbackInfo, value)) {
652 return;
653 }
654 GetExtraElementInfo(callbackInfo, value, "Column");
655 }
656
GetElementInfoSideBarContainer(NAccessibilityElementData * callbackInfo,napi_value & value)657 void NAccessibilityElement::GetElementInfoSideBarContainer(NAccessibilityElementData *callbackInfo, napi_value &value)
658 {
659 if (!CheckElementInfoParameter(callbackInfo, value)) {
660 return;
661 }
662 GetExtraElementInfo(callbackInfo, value, "SideBarContainerStates");
663 }
664
GetElementInfoListItemIndex(NAccessibilityElementData * callbackInfo,napi_value & value)665 void NAccessibilityElement::GetElementInfoListItemIndex(NAccessibilityElementData *callbackInfo, napi_value &value)
666 {
667 if (!CheckElementInfoParameter(callbackInfo, value)) {
668 return;
669 }
670 GetExtraElementInfo(callbackInfo, value, "ListItemIndex");
671 }
672
GetElementInfoCheckable(NAccessibilityElementData * callbackInfo,napi_value & value)673 void NAccessibilityElement::GetElementInfoCheckable(NAccessibilityElementData *callbackInfo, napi_value &value)
674 {
675 if (!CheckElementInfoParameter(callbackInfo, value)) {
676 return;
677 }
678 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
679 callbackInfo->accessibilityElement_.elementInfo_->IsCheckable(), &value));
680 }
681
GetElementInfoChecked(NAccessibilityElementData * callbackInfo,napi_value & value)682 void NAccessibilityElement::GetElementInfoChecked(NAccessibilityElementData *callbackInfo, napi_value &value)
683 {
684 if (!CheckElementInfoParameter(callbackInfo, value)) {
685 return;
686 }
687 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
688 callbackInfo->accessibilityElement_.elementInfo_->IsChecked(), &value));
689 }
690
GetElementInfoFocusable(NAccessibilityElementData * callbackInfo,napi_value & value)691 void NAccessibilityElement::GetElementInfoFocusable(NAccessibilityElementData *callbackInfo, napi_value &value)
692 {
693 if (!CheckElementInfoParameter(callbackInfo, value)) {
694 return;
695 }
696 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
697 callbackInfo->accessibilityElement_.elementInfo_->IsFocusable(), &value));
698 }
699
GetElementInfoIsVisible(NAccessibilityElementData * callbackInfo,napi_value & value)700 void NAccessibilityElement::GetElementInfoIsVisible(NAccessibilityElementData *callbackInfo, napi_value &value)
701 {
702 if (!CheckElementInfoParameter(callbackInfo, value)) {
703 return;
704 }
705 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
706 callbackInfo->accessibilityElement_.elementInfo_->IsVisible(), &value));
707 }
708
GetElementInfoAccessibilityFocused(NAccessibilityElementData * callbackInfo,napi_value & value)709 void NAccessibilityElement::GetElementInfoAccessibilityFocused(
710 NAccessibilityElementData *callbackInfo, napi_value &value)
711 {
712 if (!CheckElementInfoParameter(callbackInfo, value)) {
713 return;
714 }
715 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
716 callbackInfo->accessibilityElement_.elementInfo_->HasAccessibilityFocus(), &value));
717 }
718
GetElementInfoSelected(NAccessibilityElementData * callbackInfo,napi_value & value)719 void NAccessibilityElement::GetElementInfoSelected(NAccessibilityElementData *callbackInfo, napi_value &value)
720 {
721 if (!CheckElementInfoParameter(callbackInfo, value)) {
722 return;
723 }
724 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
725 callbackInfo->accessibilityElement_.elementInfo_->IsSelected(), &value));
726 }
727
GetElementInfoClickable(NAccessibilityElementData * callbackInfo,napi_value & value)728 void NAccessibilityElement::GetElementInfoClickable(NAccessibilityElementData *callbackInfo, napi_value &value)
729 {
730 if (!CheckElementInfoParameter(callbackInfo, value)) {
731 return;
732 }
733 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
734 callbackInfo->accessibilityElement_.elementInfo_->IsClickable(), &value));
735 }
736
GetElementInfoLongClickable(NAccessibilityElementData * callbackInfo,napi_value & value)737 void NAccessibilityElement::GetElementInfoLongClickable(NAccessibilityElementData *callbackInfo, napi_value &value)
738 {
739 if (!CheckElementInfoParameter(callbackInfo, value)) {
740 return;
741 }
742 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
743 callbackInfo->accessibilityElement_.elementInfo_->IsLongClickable(), &value));
744 }
745
GetElementInfoIsEnable(NAccessibilityElementData * callbackInfo,napi_value & value)746 void NAccessibilityElement::GetElementInfoIsEnable(NAccessibilityElementData *callbackInfo, napi_value &value)
747 {
748 if (!CheckElementInfoParameter(callbackInfo, value)) {
749 return;
750 }
751 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
752 callbackInfo->accessibilityElement_.elementInfo_->IsEnabled(), &value));
753 }
754
GetElementInfoIsPassword(NAccessibilityElementData * callbackInfo,napi_value & value)755 void NAccessibilityElement::GetElementInfoIsPassword(NAccessibilityElementData *callbackInfo, napi_value &value)
756 {
757 if (!CheckElementInfoParameter(callbackInfo, value)) {
758 return;
759 }
760 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
761 callbackInfo->accessibilityElement_.elementInfo_->IsPassword(), &value));
762 }
763
GetElementInfoScrollable(NAccessibilityElementData * callbackInfo,napi_value & value)764 void NAccessibilityElement::GetElementInfoScrollable(NAccessibilityElementData *callbackInfo, napi_value &value)
765 {
766 if (!CheckElementInfoParameter(callbackInfo, value)) {
767 return;
768 }
769 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
770 callbackInfo->accessibilityElement_.elementInfo_->IsScrollable(), &value));
771 }
772
GetElementInfoEditable(NAccessibilityElementData * callbackInfo,napi_value & value)773 void NAccessibilityElement::GetElementInfoEditable(NAccessibilityElementData *callbackInfo, napi_value &value)
774 {
775 if (!CheckElementInfoParameter(callbackInfo, value)) {
776 return;
777 }
778 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
779 callbackInfo->accessibilityElement_.elementInfo_->IsEditable(), &value));
780 }
781
GetElementInfoPluralLineSupported(NAccessibilityElementData * callbackInfo,napi_value & value)782 void NAccessibilityElement::GetElementInfoPluralLineSupported(
783 NAccessibilityElementData *callbackInfo, napi_value &value)
784 {
785 if (!CheckElementInfoParameter(callbackInfo, value)) {
786 return;
787 }
788 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
789 callbackInfo->accessibilityElement_.elementInfo_->IsPluraLineSupported(), &value));
790 }
791
GetElementInfoIsHint(NAccessibilityElementData * callbackInfo,napi_value & value)792 void NAccessibilityElement::GetElementInfoIsHint(NAccessibilityElementData *callbackInfo, napi_value &value)
793 {
794 if (!CheckElementInfoParameter(callbackInfo, value)) {
795 return;
796 }
797 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
798 callbackInfo->accessibilityElement_.elementInfo_->IsGivingHint(), &value));
799 }
800
GetElementInfoItemCount(NAccessibilityElementData * callbackInfo,napi_value & value)801 void NAccessibilityElement::GetElementInfoItemCount(NAccessibilityElementData *callbackInfo, napi_value &value)
802 {
803 if (!CheckElementInfoParameter(callbackInfo, value)) {
804 return;
805 }
806 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
807 callbackInfo->accessibilityElement_.elementInfo_->GetItemCounts(), &value));
808 }
809
GetElementInfoCurrentIndex(NAccessibilityElementData * callbackInfo,napi_value & value)810 void NAccessibilityElement::GetElementInfoCurrentIndex(NAccessibilityElementData *callbackInfo, napi_value &value)
811 {
812 if (!CheckElementInfoParameter(callbackInfo, value)) {
813 return;
814 }
815 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
816 callbackInfo->accessibilityElement_.elementInfo_->GetCurrentIndex(), &value));
817 }
818
GetElementInfoStartIndex(NAccessibilityElementData * callbackInfo,napi_value & value)819 void NAccessibilityElement::GetElementInfoStartIndex(NAccessibilityElementData *callbackInfo, napi_value &value)
820 {
821 if (!CheckElementInfoParameter(callbackInfo, value)) {
822 return;
823 }
824 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
825 callbackInfo->accessibilityElement_.elementInfo_->GetBeginIndex(), &value));
826 }
827
GetElementInfoEndIndex(NAccessibilityElementData * callbackInfo,napi_value & value)828 void NAccessibilityElement::GetElementInfoEndIndex(NAccessibilityElementData *callbackInfo, napi_value &value)
829 {
830 if (!CheckElementInfoParameter(callbackInfo, value)) {
831 return;
832 }
833 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
834 callbackInfo->accessibilityElement_.elementInfo_->GetEndIndex(), &value));
835 }
836
GetElementInfoValueMax(NAccessibilityElementData * callbackInfo,napi_value & value)837 void NAccessibilityElement::GetElementInfoValueMax(NAccessibilityElementData *callbackInfo, napi_value &value)
838 {
839 if (!CheckElementInfoParameter(callbackInfo, value)) {
840 return;
841 }
842 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_double(callbackInfo->env_,
843 callbackInfo->accessibilityElement_.elementInfo_->GetRange().GetMax(), &value));
844 }
845
GetElementInfoValueMin(NAccessibilityElementData * callbackInfo,napi_value & value)846 void NAccessibilityElement::GetElementInfoValueMin(NAccessibilityElementData *callbackInfo, napi_value &value)
847 {
848 if (!CheckElementInfoParameter(callbackInfo, value)) {
849 return;
850 }
851 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_double(callbackInfo->env_,
852 callbackInfo->accessibilityElement_.elementInfo_->GetRange().GetMin(), &value));
853 }
854
GetElementInfoValueNow(NAccessibilityElementData * callbackInfo,napi_value & value)855 void NAccessibilityElement::GetElementInfoValueNow(NAccessibilityElementData *callbackInfo, napi_value &value)
856 {
857 if (!CheckElementInfoParameter(callbackInfo, value)) {
858 return;
859 }
860 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_double(callbackInfo->env_,
861 callbackInfo->accessibilityElement_.elementInfo_->GetRange().GetCurrent(), &value));
862 }
863
GetElementInfoError(NAccessibilityElementData * callbackInfo,napi_value & value)864 void NAccessibilityElement::GetElementInfoError(NAccessibilityElementData *callbackInfo, napi_value &value)
865 {
866 if (!CheckElementInfoParameter(callbackInfo, value)) {
867 return;
868 }
869 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
870 callbackInfo->accessibilityElement_.elementInfo_->GetError().c_str(), NAPI_AUTO_LENGTH, &value));
871 }
872
GetElementInfoTextMoveUnit(NAccessibilityElementData * callbackInfo,napi_value & value)873 void NAccessibilityElement::GetElementInfoTextMoveUnit(NAccessibilityElementData *callbackInfo, napi_value &value)
874 {
875 if (!CheckElementInfoParameter(callbackInfo, value)) {
876 return;
877 }
878 std::string textMoveUnit = ConvertTextMoveUnitToString(
879 callbackInfo->accessibilityElement_.elementInfo_->GetTextMovementStep());
880 HILOG_DEBUG("ConvertTextMoveUnitToString: [%{public}s]", textMoveUnit.c_str());
881 if (textMoveUnit == "") {
882 callbackInfo->ret_ = RET_ERR_FAILED;
883 napi_get_undefined(callbackInfo->env_, &value);
884 } else {
885 callbackInfo->ret_ = RET_OK;
886 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
887 textMoveUnit.c_str(), NAPI_AUTO_LENGTH, &value));
888 }
889 }
890
GetElementInfoParent(NAccessibilityElementData * callbackInfo,napi_value & value)891 void NAccessibilityElement::GetElementInfoParent(NAccessibilityElementData *callbackInfo, napi_value &value)
892 {
893 if (!CheckElementInfoParameter(callbackInfo, value)) {
894 return;
895 }
896 if (callbackInfo->ret_ == RET_OK) {
897 napi_value constructor = nullptr;
898 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_reference_value(callbackInfo->env_,
899 NAccessibilityElement::consRef_, &constructor));
900 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_new_instance(callbackInfo->env_,
901 constructor, 0, nullptr, &value));
902 ConvertElementInfoToJS(callbackInfo->env_, value, callbackInfo->nodeInfo_);
903 } else {
904 HILOG_ERROR("GetElementInfoParent failed!");
905 napi_get_undefined(callbackInfo->env_, &value);
906 }
907 }
908
GetElementInfoChildren(NAccessibilityElementData * callbackInfo,napi_value & value)909 void NAccessibilityElement::GetElementInfoChildren(NAccessibilityElementData *callbackInfo, napi_value &value)
910 {
911 if (!CheckElementInfoParameter(callbackInfo, value)) {
912 return;
913 }
914 if (callbackInfo->ret_ == RET_OK) {
915 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_array(callbackInfo->env_, &value));
916 ConvertElementInfosToJS(callbackInfo->env_, value, callbackInfo->nodeInfos_);
917 } else {
918 HILOG_ERROR("GetElementInfoChildren failed!");
919 napi_get_undefined(callbackInfo->env_, &value);
920 }
921 }
922
GetElementInfoTriggerAction(NAccessibilityElementData * callbackInfo,napi_value & value)923 void NAccessibilityElement::GetElementInfoTriggerAction(NAccessibilityElementData *callbackInfo, napi_value &value)
924 {
925 if (!CheckElementInfoParameter(callbackInfo, value)) {
926 return;
927 }
928 std::string triggerAction = ConvertOperationTypeToString(
929 callbackInfo->accessibilityElement_.elementInfo_->GetTriggerAction());
930 HILOG_DEBUG("GetElementInfoTriggerAction: [%{public}s]", triggerAction.c_str());
931 if (triggerAction == "") {
932 callbackInfo->ret_ = RET_ERR_FAILED;
933 napi_get_undefined(callbackInfo->env_, &value);
934 } else {
935 callbackInfo->ret_ = RET_OK;
936 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
937 triggerAction.c_str(), NAPI_AUTO_LENGTH, &value));
938 }
939 }
940
GetElementInfoContents(NAccessibilityElementData * callbackInfo,napi_value & value)941 void NAccessibilityElement::GetElementInfoContents(NAccessibilityElementData *callbackInfo, napi_value &value)
942 {
943 if (!CheckElementInfoParameter(callbackInfo, value)) {
944 return;
945 }
946 std::vector<std::string> contents {};
947 callbackInfo->accessibilityElement_.elementInfo_->GetContentList(contents);
948 HILOG_DEBUG("contents size: [%{public}zu]", contents.size());
949
950 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_array(callbackInfo->env_, &value));
951 size_t index = 0;
952 for (auto& content : contents) {
953 napi_value nContent = nullptr;
954 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
955 content.c_str(), NAPI_AUTO_LENGTH, &nContent));
956 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_set_element(callbackInfo->env_, value, index, nContent));
957 index++;
958 }
959 }
960
GetElementInfoLastContent(NAccessibilityElementData * callbackInfo,napi_value & value)961 void NAccessibilityElement::GetElementInfoLastContent(NAccessibilityElementData *callbackInfo, napi_value &value)
962 {
963 if (!CheckElementInfoParameter(callbackInfo, value)) {
964 return;
965 }
966 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
967 callbackInfo->accessibilityElement_.elementInfo_->GetLatestContent().c_str(), NAPI_AUTO_LENGTH, &value));
968 }
969
GetElementInfoWindowId(NAccessibilityElementData * callbackInfo,napi_value & value)970 void NAccessibilityElement::GetElementInfoWindowId(NAccessibilityElementData *callbackInfo, napi_value &value)
971 {
972 if (!CheckElementInfoParameter(callbackInfo, value)) {
973 return;
974 }
975 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
976 callbackInfo->accessibilityElement_.elementInfo_->GetWindowId(), &value));
977 }
978
GetElementInfoIsFocused(NAccessibilityElementData * callbackInfo,napi_value & value)979 void NAccessibilityElement::GetElementInfoIsFocused(NAccessibilityElementData *callbackInfo, napi_value &value)
980 {
981 if (!CheckElementInfoParameter(callbackInfo, value)) {
982 return;
983 }
984 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
985 callbackInfo->accessibilityElement_.elementInfo_->IsFocused(), &value));
986 }
987
GetElementInfoAccessibilityText(NAccessibilityElementData * callbackInfo,napi_value & value)988 void NAccessibilityElement::GetElementInfoAccessibilityText(NAccessibilityElementData *callbackInfo, napi_value &value)
989 {
990 if (!CheckElementInfoParameter(callbackInfo, value)) {
991 return;
992 }
993 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
994 callbackInfo->accessibilityElement_.elementInfo_->GetAccessibilityText().c_str(), NAPI_AUTO_LENGTH, &value));
995 }
996
GetElementInfoTextType(NAccessibilityElementData * callbackInfo,napi_value & value)997 void NAccessibilityElement::GetElementInfoTextType(NAccessibilityElementData *callbackInfo, napi_value &value)
998 {
999 if (!CheckElementInfoParameter(callbackInfo, value)) {
1000 return;
1001 }
1002 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
1003 callbackInfo->accessibilityElement_.elementInfo_->GetTextType().c_str(), NAPI_AUTO_LENGTH, &value));
1004 }
1005
GetElementInfoOffset(NAccessibilityElementData * callbackInfo,napi_value & value)1006 void NAccessibilityElement::GetElementInfoOffset(NAccessibilityElementData *callbackInfo, napi_value &value)
1007 {
1008 if (!CheckElementInfoParameter(callbackInfo, value)) {
1009 return;
1010 }
1011 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_double(callbackInfo->env_,
1012 callbackInfo->accessibilityElement_.elementInfo_->GetOffset(), &value));
1013 }
1014
GetElementInfoAccessibilityGroup(NAccessibilityElementData * callbackInfo,napi_value & value)1015 void NAccessibilityElement::GetElementInfoAccessibilityGroup(NAccessibilityElementData *callbackInfo, napi_value &value)
1016 {
1017 if (!CheckElementInfoParameter(callbackInfo, value)) {
1018 return;
1019 }
1020 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
1021 callbackInfo->accessibilityElement_.elementInfo_->GetAccessibilityGroup(), &value));
1022 }
1023
GetElementInfoAccessibilityLevel(NAccessibilityElementData * callbackInfo,napi_value & value)1024 void NAccessibilityElement::GetElementInfoAccessibilityLevel(NAccessibilityElementData *callbackInfo, napi_value &value)
1025 {
1026 if (!CheckElementInfoParameter(callbackInfo, value)) {
1027 return;
1028 }
1029 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
1030 callbackInfo->accessibilityElement_.elementInfo_->GetAccessibilityLevel().c_str(), NAPI_AUTO_LENGTH, &value));
1031 }
1032
GetElementInfoNavDestinationId(NAccessibilityElementData * callbackInfo,napi_value & value)1033 void NAccessibilityElement::GetElementInfoNavDestinationId(NAccessibilityElementData *callbackInfo, napi_value &value)
1034 {
1035 if (!CheckElementInfoParameter(callbackInfo, value)) {
1036 return;
1037 }
1038 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int64(callbackInfo->env_,
1039 callbackInfo->accessibilityElement_.elementInfo_->GetNavDestinationId(), &value));
1040 }
1041
GetElementInfoSpan(NAccessibilityElementData * callbackInfo,napi_value & value)1042 void NAccessibilityElement::GetElementInfoSpan(NAccessibilityElementData *callbackInfo, napi_value &value)
1043 {
1044 if (!CheckElementInfoParameter(callbackInfo, value)) {
1045 return;
1046 }
1047 std::vector<SpanInfo> spanInfo {};
1048 spanInfo = callbackInfo->accessibilityElement_.elementInfo_->GetSpanList();
1049 HILOG_DEBUG("spanInfo size: [%{public}zu]", spanInfo.size());
1050
1051 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_array(callbackInfo->env_, &value));
1052 size_t index = 0;
1053 napi_status status;
1054 for (auto& span : spanInfo) {
1055 napi_value result = nullptr;
1056 status = napi_create_object(callbackInfo->env_, &result);
1057 if (status != napi_ok) {
1058 HILOG_DEBUG("cant create napi object!");
1059 return;
1060 }
1061 ConvertSpanToJS(callbackInfo->env_, result, span);
1062 HILOG_DEBUG("ConvertSpanToJS spanInfo spanid: [%{public}d]", span.GetSpanId());
1063 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_set_element(callbackInfo->env_, value, index, result));
1064 index++;
1065 }
1066 }
1067
GetElementInfoIsActive(NAccessibilityElementData * callbackInfo,napi_value & value)1068 void NAccessibilityElement::GetElementInfoIsActive(NAccessibilityElementData *callbackInfo, napi_value &value)
1069 {
1070 if (!CheckElementInfoParameter(callbackInfo, value)) {
1071 return;
1072 }
1073 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int64(callbackInfo->env_,
1074 callbackInfo->accessibilityElement_.elementInfo_->GetIsActive(), &value));
1075 }
1076
GetElementInfoAccessibilityVisible(NAccessibilityElementData * callbackInfo,napi_value & value)1077 void NAccessibilityElement::GetElementInfoAccessibilityVisible(
1078 NAccessibilityElementData *callbackInfo, napi_value &value)
1079 {
1080 if (!CheckElementInfoParameter(callbackInfo, value)) {
1081 return;
1082 }
1083 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int64(callbackInfo->env_,
1084 callbackInfo->accessibilityElement_.elementInfo_->GetAccessibilityVisible(), &value));
1085 }
1086
GetElementInfoClip(NAccessibilityElementData * callbackInfo,napi_value & value)1087 void NAccessibilityElement::GetElementInfoClip(NAccessibilityElementData *callbackInfo, napi_value &value)
1088 {
1089 if (!CheckElementInfoParameter(callbackInfo, value)) {
1090 return;
1091 }
1092 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int64(callbackInfo->env_,
1093 callbackInfo->accessibilityElement_.elementInfo_->GetClip(), &value));
1094 }
1095
GetElementInfoAllAttribute(NAccessibilityElementData * callbackInfo,napi_value & value)1096 void NAccessibilityElement::GetElementInfoAllAttribute(NAccessibilityElementData *callbackInfo, napi_value &value)
1097 {
1098 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_object(callbackInfo->env_, &value));
1099 if (CheckElementInfoParameter(callbackInfo, value)) {
1100 GetElementInfoAllAttribute1(callbackInfo, value);
1101 GetElementInfoAllAttribute2(callbackInfo, value);
1102 GetElementInfoAllAttribute3(callbackInfo, value);
1103 GetElementInfoAllAttribute4(callbackInfo, value);
1104 GetElementInfoAllAttribute5(callbackInfo, value);
1105 } else if (CheckWindowInfoParameter(callbackInfo, value)) {
1106 GetWindowInfoAllAttribute(callbackInfo, value);
1107 } else {
1108 return;
1109 }
1110 }
1111
GetElementInfoAllAttribute1(NAccessibilityElementData * callbackInfo,napi_value & value)1112 void NAccessibilityElement::GetElementInfoAllAttribute1(NAccessibilityElementData *callbackInfo, napi_value &value)
1113 {
1114 napi_env env = callbackInfo->env_;
1115 napi_value componentId = nullptr;
1116 GetElementInfoComponentId(callbackInfo, componentId);
1117 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "componentId", componentId));
1118
1119 napi_value inspectorKey = nullptr;
1120 GetElementInfoInspectorKey(callbackInfo, inspectorKey);
1121 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "inspectorKey", inspectorKey));
1122
1123 napi_value bundleName = nullptr;
1124 GetElementInfoBundleName(callbackInfo, bundleName);
1125 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "bundleName", bundleName));
1126
1127 napi_value componentType = nullptr;
1128 GetElementInfoComponentType(callbackInfo, componentType);
1129 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "componentType", componentType));
1130
1131 napi_value inputType = nullptr;
1132 GetElementInfoInputType(callbackInfo, inputType);
1133 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "inputType", inputType));
1134
1135 napi_value text = nullptr;
1136 GetElementInfoText(callbackInfo, text);
1137 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "text", text));
1138
1139 napi_value hintText = nullptr;
1140 GetElementInfoHintText(callbackInfo, hintText);
1141 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "hintText", hintText));
1142
1143 napi_value description = nullptr;
1144 GetElementInfoDescription(callbackInfo, description);
1145 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "description", description));
1146
1147 napi_value resourceName = nullptr;
1148 GetElementInfoResourceName(callbackInfo, resourceName);
1149 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "resourceName", resourceName));
1150 }
1151
GetElementInfoAllAttribute2(NAccessibilityElementData * callbackInfo,napi_value & value)1152 void NAccessibilityElement::GetElementInfoAllAttribute2(NAccessibilityElementData *callbackInfo, napi_value &value)
1153 {
1154 napi_env env = callbackInfo->env_;
1155 napi_value textLengthLimit = nullptr;
1156 GetElementInfoTextLengthLimit(callbackInfo, textLengthLimit);
1157 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "textLengthLimit", textLengthLimit));
1158
1159 napi_value rect = nullptr;
1160 GetElementInfoRect(callbackInfo, rect);
1161 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "rect", rect));
1162
1163 napi_value checkable = nullptr;
1164 GetElementInfoCheckable(callbackInfo, checkable);
1165 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "checkable", checkable));
1166
1167 napi_value checked = nullptr;
1168 GetElementInfoChecked(callbackInfo, checked);
1169 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "checked", checked));
1170
1171 napi_value focusable = nullptr;
1172 GetElementInfoFocusable(callbackInfo, focusable);
1173 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "focusable", focusable));
1174
1175 napi_value isVisible = nullptr;
1176 GetElementInfoIsVisible(callbackInfo, isVisible);
1177 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "isVisible", isVisible));
1178
1179 napi_value selected = nullptr;
1180 GetElementInfoSelected(callbackInfo, selected);
1181 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "selected", selected));
1182
1183 napi_value clickable = nullptr;
1184 GetElementInfoClickable(callbackInfo, clickable);
1185 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "clickable", clickable));
1186
1187 napi_value longClickable = nullptr;
1188 GetElementInfoLongClickable(callbackInfo, longClickable);
1189 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "longClickable", longClickable));
1190
1191 napi_value isEnable = nullptr;
1192 GetElementInfoIsEnable(callbackInfo, isEnable);
1193 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "isEnable", isEnable));
1194
1195 napi_value isPassword = nullptr;
1196 GetElementInfoIsPassword(callbackInfo, isPassword);
1197 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "isPassword", isPassword));
1198 }
1199
GetElementInfoAllAttribute3(NAccessibilityElementData * callbackInfo,napi_value & value)1200 void NAccessibilityElement::GetElementInfoAllAttribute3(NAccessibilityElementData *callbackInfo, napi_value &value)
1201 {
1202 napi_env env = callbackInfo->env_;
1203 napi_value scrollable = nullptr;
1204 GetElementInfoScrollable(callbackInfo, scrollable);
1205 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "scrollable", scrollable));
1206
1207 napi_value editable = nullptr;
1208 GetElementInfoEditable(callbackInfo, editable);
1209 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "editable", editable));
1210
1211 napi_value pluralLineSupported = nullptr;
1212 GetElementInfoPluralLineSupported(callbackInfo, pluralLineSupported);
1213 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "pluralLineSupported", pluralLineSupported));
1214
1215 napi_value itemCount = nullptr;
1216 GetElementInfoItemCount(callbackInfo, itemCount);
1217 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "itemCount", itemCount));
1218
1219 napi_value grid = nullptr;
1220 GetElementInfoGridItem(callbackInfo, grid);
1221 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "grid", grid));
1222
1223 napi_value currentIndex = nullptr;
1224 GetElementInfoCurrentIndex(callbackInfo, currentIndex);
1225 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "currentIndex", currentIndex));
1226
1227 napi_value startIndex = nullptr;
1228 GetElementInfoStartIndex(callbackInfo, startIndex);
1229 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "startIndex", startIndex));
1230
1231 napi_value endIndex = nullptr;
1232 GetElementInfoEndIndex(callbackInfo, endIndex);
1233 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "endIndex", endIndex));
1234
1235 napi_value textMoveUnit = nullptr;
1236 GetElementInfoTextMoveUnit(callbackInfo, textMoveUnit);
1237 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "textMoveUnit", textMoveUnit));
1238
1239 napi_value triggerAction = nullptr;
1240 std::string action = ConvertOperationTypeToString(
1241 callbackInfo->accessibilityElement_.elementInfo_->GetTriggerAction());
1242 if (action == "") {
1243 napi_get_undefined(callbackInfo->env_, &triggerAction);
1244 } else {
1245 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, action.c_str(), NAPI_AUTO_LENGTH, &triggerAction));
1246 }
1247 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "triggerAction", triggerAction));
1248
1249 napi_value contents = nullptr;
1250 GetElementInfoContents(callbackInfo, contents);
1251 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "contents", contents));
1252
1253 napi_value navDestinationId = nullptr;
1254 GetElementInfoNavDestinationId(callbackInfo, navDestinationId);
1255 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "navDestinationId", navDestinationId));
1256 }
1257
GetElementInfoAllAttribute4(NAccessibilityElementData * callbackInfo,napi_value & value)1258 void NAccessibilityElement::GetElementInfoAllAttribute4(NAccessibilityElementData *callbackInfo, napi_value &value)
1259 {
1260 napi_env env = callbackInfo->env_;
1261 napi_value lastContent = nullptr;
1262 GetElementInfoLastContent(callbackInfo, lastContent);
1263 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "lastContent", lastContent));
1264
1265 napi_value isFocused = nullptr;
1266 GetElementInfoIsFocused(callbackInfo, isFocused);
1267 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "isFocused", isFocused));
1268
1269 napi_value accessibilityFocused = nullptr;
1270 GetElementInfoAccessibilityFocused(callbackInfo, accessibilityFocused);
1271 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "accessibilityFocused", accessibilityFocused));
1272
1273 napi_value error = nullptr;
1274 GetElementInfoError(callbackInfo, error);
1275 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "error", error));
1276
1277 napi_value isHint = nullptr;
1278 GetElementInfoIsHint(callbackInfo, isHint);
1279 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "isHint", isHint));
1280
1281 napi_value pageId = nullptr;
1282 GetElementInfoPageId(callbackInfo, pageId);
1283 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "pageId", pageId));
1284
1285 napi_value valueMax = nullptr;
1286 GetElementInfoValueMax(callbackInfo, valueMax);
1287 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "valueMax", valueMax));
1288
1289 napi_value valueMin = nullptr;
1290 GetElementInfoValueMin(callbackInfo, valueMin);
1291 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "valueMin", valueMin));
1292
1293 napi_value valueNow = nullptr;
1294 GetElementInfoValueNow(callbackInfo, valueNow);
1295 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "valueNow", valueNow));
1296
1297 napi_value windowId = nullptr;
1298 GetElementInfoWindowId(callbackInfo, windowId);
1299 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "windowId", windowId));
1300
1301 napi_value accessibilityText = nullptr;
1302 GetElementInfoAccessibilityText(callbackInfo, accessibilityText);
1303 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "accessibilityText", accessibilityText));
1304
1305 napi_value textType = nullptr;
1306 GetElementInfoTextType(callbackInfo, textType);
1307 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "textType", textType));
1308
1309 napi_value offset = nullptr;
1310 GetElementInfoOffset(callbackInfo, offset);
1311 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "offset", offset));
1312
1313 napi_value accessibilityGroup = nullptr;
1314 GetElementInfoAccessibilityGroup(callbackInfo, accessibilityGroup);
1315 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "accessibilityGroup", accessibilityGroup));
1316
1317 napi_value accessibilityLevel = nullptr;
1318 GetElementInfoAccessibilityLevel(callbackInfo, accessibilityLevel);
1319 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "accessibilityLevel", accessibilityLevel));
1320 }
1321
GetElementInfoAllAttribute5(NAccessibilityElementData * callbackInfo,napi_value & value)1322 void NAccessibilityElement::GetElementInfoAllAttribute5(NAccessibilityElementData *callbackInfo, napi_value &value)
1323 {
1324 napi_env env = callbackInfo->env_;
1325 napi_value checkBox = nullptr;
1326 GetElementInfoCheckboxGroup(callbackInfo, checkBox);
1327 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "checkboxGroupSelectedStatus", checkBox));
1328
1329 napi_value row = nullptr;
1330 GetElementInfoRow(callbackInfo, row);
1331 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "row", row));
1332
1333 napi_value column = nullptr;
1334 GetElementInfoColumn(callbackInfo, column);
1335 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "column", column));
1336
1337 napi_value sideBarContainer = nullptr;
1338 GetElementInfoSideBarContainer(callbackInfo, sideBarContainer);
1339 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "sideBarContainerStates", sideBarContainer));
1340
1341 napi_value listItemIndex = nullptr;
1342 GetElementInfoListItemIndex(callbackInfo, listItemIndex);
1343 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "listItemIndex", listItemIndex));
1344
1345 napi_value span = nullptr;
1346 GetElementInfoSpan(callbackInfo, span);
1347 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "span", span));
1348
1349 napi_value isActive = nullptr;
1350 GetElementInfoSpan(callbackInfo, isActive);
1351 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "isActive", isActive));
1352
1353 napi_value accessibilityVisible = nullptr;
1354 GetElementInfoSpan(callbackInfo, accessibilityVisible);
1355 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "accessibilityVisible", accessibilityVisible));
1356
1357 napi_value clip = nullptr;
1358 GetElementInfoSpan(callbackInfo, clip);
1359 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "clip", clip));
1360 }
1361
GetWindowInfoAllAttribute(NAccessibilityElementData * callbackInfo,napi_value & value)1362 void NAccessibilityElement::GetWindowInfoAllAttribute(NAccessibilityElementData *callbackInfo, napi_value &value)
1363 {
1364 napi_env env = callbackInfo->env_;
1365 napi_value isActive = nullptr;
1366 GetWindowInfoIsActive(callbackInfo, isActive);
1367 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "isActive", isActive));
1368
1369 napi_value screenRect = nullptr;
1370 GetWindowInfoScreenRect(callbackInfo, screenRect);
1371 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "screenRect", screenRect));
1372
1373 napi_value layer = nullptr;
1374 GetWindowInfoLayer(callbackInfo, layer);
1375 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "layer", layer));
1376
1377 napi_value type = nullptr;
1378 GetWindowInfoType(callbackInfo, type);
1379 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "type", type));
1380
1381 napi_value isFocused = nullptr;
1382 GetWindowInfoIsFocused(callbackInfo, isFocused);
1383 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "isFocused", isFocused));
1384
1385 napi_value windowId = nullptr;
1386 GetWindowInfoWindowId(callbackInfo, windowId);
1387 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "windowId", windowId));
1388 }
1389
CheckWindowInfoParameter(NAccessibilityElementData * callbackInfo,napi_value & value)1390 bool NAccessibilityElement::CheckWindowInfoParameter(NAccessibilityElementData *callbackInfo, napi_value &value)
1391 {
1392 if (!callbackInfo) {
1393 HILOG_ERROR("callbackInfo is nullptr");
1394 return false;
1395 }
1396 if (!callbackInfo->accessibilityElement_.windowInfo_) {
1397 HILOG_ERROR("window info is nullptr");
1398 napi_get_undefined(callbackInfo->env_, &value);
1399 callbackInfo->ret_ = RET_ERR_FAILED;
1400 return false;
1401 }
1402 return true;
1403 }
1404
GetWindowInfoIsActive(NAccessibilityElementData * callbackInfo,napi_value & value)1405 void NAccessibilityElement::GetWindowInfoIsActive(NAccessibilityElementData *callbackInfo, napi_value &value)
1406 {
1407 if (!CheckWindowInfoParameter(callbackInfo, value)) {
1408 return;
1409 }
1410 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
1411 callbackInfo->accessibilityElement_.windowInfo_->IsActive(), &value));
1412 }
1413
GetWindowInfoScreenRect(NAccessibilityElementData * callbackInfo,napi_value & value)1414 void NAccessibilityElement::GetWindowInfoScreenRect(NAccessibilityElementData *callbackInfo, napi_value &value)
1415 {
1416 if (!CheckWindowInfoParameter(callbackInfo, value)) {
1417 return;
1418 }
1419 OHOS::Accessibility::Rect screenRect = callbackInfo->accessibilityElement_.windowInfo_->GetRectInScreen();
1420 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_object(callbackInfo->env_, &value));
1421 ConvertRectToJS(callbackInfo->env_, value, screenRect);
1422 }
1423
GetWindowInfoLayer(NAccessibilityElementData * callbackInfo,napi_value & value)1424 void NAccessibilityElement::GetWindowInfoLayer(NAccessibilityElementData *callbackInfo, napi_value &value)
1425 {
1426 if (!CheckWindowInfoParameter(callbackInfo, value)) {
1427 return;
1428 }
1429 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
1430 callbackInfo->accessibilityElement_.windowInfo_->GetWindowLayer(), &value));
1431 }
1432
GetWindowInfoType(NAccessibilityElementData * callbackInfo,napi_value & value)1433 void NAccessibilityElement::GetWindowInfoType(NAccessibilityElementData *callbackInfo, napi_value &value)
1434 {
1435 if (!CheckWindowInfoParameter(callbackInfo, value)) {
1436 return;
1437 }
1438 std::string accessibilityWindowType = ConvertWindowTypeToString(
1439 callbackInfo->accessibilityElement_.windowInfo_->GetAccessibilityWindowType());
1440 HILOG_DEBUG("GetWindowInfoType: [%{public}s]", accessibilityWindowType.c_str());
1441 if (accessibilityWindowType == "") {
1442 callbackInfo->ret_ = RET_ERR_FAILED;
1443 napi_get_undefined(callbackInfo->env_, &value);
1444 } else {
1445 callbackInfo->ret_ = RET_OK;
1446 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
1447 accessibilityWindowType.c_str(), NAPI_AUTO_LENGTH, &value));
1448 }
1449 }
1450
GetWindowInfoRootElement(NAccessibilityElementData * callbackInfo,napi_value & value)1451 void NAccessibilityElement::GetWindowInfoRootElement(NAccessibilityElementData *callbackInfo, napi_value &value)
1452 {
1453 if (!CheckWindowInfoParameter(callbackInfo, value)) {
1454 return;
1455 }
1456 if (callbackInfo->ret_ == RET_OK) {
1457 napi_value constructor = nullptr;
1458 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_reference_value(callbackInfo->env_,
1459 NAccessibilityElement::consRef_, &constructor));
1460 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_new_instance(callbackInfo->env_,
1461 constructor, 0, nullptr, &value));
1462 ConvertElementInfoToJS(callbackInfo->env_, value, callbackInfo->nodeInfo_);
1463 } else {
1464 HILOG_ERROR("GetWindowInfoRootElement failed!");
1465 napi_get_undefined(callbackInfo->env_, &value);
1466 }
1467 }
1468
GetWindowInfoIsFocused(NAccessibilityElementData * callbackInfo,napi_value & value)1469 void NAccessibilityElement::GetWindowInfoIsFocused(NAccessibilityElementData *callbackInfo, napi_value &value)
1470 {
1471 if (!CheckWindowInfoParameter(callbackInfo, value)) {
1472 return;
1473 }
1474 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
1475 callbackInfo->accessibilityElement_.windowInfo_->IsFocused(), &value));
1476 }
1477
GetWindowInfoWindowId(NAccessibilityElementData * callbackInfo,napi_value & value)1478 void NAccessibilityElement::GetWindowInfoWindowId(NAccessibilityElementData *callbackInfo, napi_value &value)
1479 {
1480 if (!CheckWindowInfoParameter(callbackInfo, value)) {
1481 return;
1482 }
1483 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
1484 callbackInfo->accessibilityElement_.windowInfo_->GetWindowId(), &value));
1485 }
1486
ActionNames(napi_env env,napi_callback_info info)1487 napi_value NAccessibilityElement::ActionNames(napi_env env, napi_callback_info info)
1488 {
1489 size_t argc = ARGS_SIZE_ONE;
1490 napi_value argv = nullptr;
1491 napi_value thisVar = nullptr;
1492 void* data = nullptr;
1493 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &argv, &thisVar, &data));
1494 HILOG_DEBUG("argc = %{public}zu", argc);
1495
1496 NAccessibilityElementData *callbackInfo = new(std::nothrow) NAccessibilityElementData();
1497 if (!callbackInfo) {
1498 HILOG_ERROR("Failed to create callbackInfo.");
1499 return nullptr;
1500 }
1501 callbackInfo->env_ = env;
1502
1503 napi_value promise = nullptr;
1504 if (argc > ARGS_SIZE_ONE - 1) {
1505 napi_valuetype valueType = napi_null;
1506 napi_typeof(env, argv, &valueType);
1507 if (valueType == napi_function) {
1508 napi_create_reference(env, argv, 1, &callbackInfo->callback_);
1509 napi_get_undefined(env, &promise);
1510 } else {
1511 napi_create_promise(env, &callbackInfo->deferred_, &promise);
1512 }
1513 } else {
1514 napi_create_promise(env, &callbackInfo->deferred_, &promise);
1515 }
1516
1517 AccessibilityElement* accessibilityElement = nullptr;
1518 napi_status status = napi_unwrap(env, thisVar, (void**)&accessibilityElement);
1519 if (!accessibilityElement || status != napi_ok) {
1520 HILOG_ERROR("accessibilityElement is null or status[%{public}d] is wrong", status);
1521 return ErrorOperation(callbackInfo);
1522 }
1523 callbackInfo->accessibilityElement_ = *accessibilityElement;
1524 if (!callbackInfo->accessibilityElement_.isElementInfo_) {
1525 HILOG_ERROR("it is not element info");
1526 return ErrorOperation(callbackInfo);
1527 }
1528
1529 napi_value resource = nullptr;
1530 napi_create_string_utf8(env, "ActionNames", NAPI_AUTO_LENGTH, &resource);
1531 if (resource == nullptr) {
1532 HILOG_ERROR("resource is nullptr.");
1533 return nullptr;
1534 }
1535
1536 napi_create_async_work(env, nullptr, resource, [](napi_env env, void* data) {},
1537 // Execute the complete function
1538 ActionNamesComplete,
1539 reinterpret_cast<void*>(callbackInfo),
1540 &callbackInfo->work_);
1541 napi_queue_async_work_with_qos(env, callbackInfo->work_, napi_qos_user_initiated);
1542 return promise;
1543 }
1544
ActionNamesComplete(napi_env env,napi_status status,void * data)1545 void NAccessibilityElement::ActionNamesComplete(napi_env env, napi_status status, void* data)
1546 {
1547 HILOG_DEBUG("ActionNamesComplete execute back");
1548 NAccessibilityElementData* callbackInfo = static_cast<NAccessibilityElementData*>(data);
1549 napi_value result[ARGS_SIZE_TWO] = {0};
1550 napi_value callback = 0;
1551 napi_value undefined = 0;
1552 napi_get_undefined(env, &undefined);
1553 if (!callbackInfo) {
1554 HILOG_ERROR("callbackInfo is nullptr");
1555 return;
1556 }
1557
1558 if (callbackInfo->accessibilityElement_.elementInfo_) {
1559 std::vector<std::string> actionNames {};
1560 std::vector<AccessibleAction> operations =
1561 callbackInfo->accessibilityElement_.elementInfo_->GetActionList();
1562 HILOG_DEBUG("action list size is %{public}zu", operations.size());
1563 actionNames.resize(operations.size());
1564 std::transform(operations.begin(), operations.end(), actionNames.begin(),
1565 [](const AccessibleAction operation) {
1566 return ConvertOperationTypeToString(operation.GetActionType());
1567 });
1568 napi_create_array(env, &result[PARAM1]);
1569 ConvertStringVecToJS(env, result[PARAM1], actionNames);
1570 callbackInfo->ret_ = RET_OK;
1571 } else {
1572 HILOG_ERROR("no elementInfo_");
1573 callbackInfo->ret_ = RET_ERR_FAILED;
1574 napi_get_undefined(env, &result[PARAM1]);
1575 }
1576
1577 result[PARAM0] = CreateBusinessError(env, callbackInfo->ret_);
1578 if (callbackInfo->callback_) {
1579 // Callback mode
1580 napi_get_reference_value(env, callbackInfo->callback_, &callback);
1581 napi_value returnVal = nullptr;
1582 napi_call_function(env, undefined, callback, ARGS_SIZE_TWO, result, &returnVal);
1583 napi_delete_reference(env, callbackInfo->callback_);
1584 } else {
1585 // Promise mode
1586 if (callbackInfo->accessibilityElement_.elementInfo_) {
1587 napi_resolve_deferred(env, callbackInfo->deferred_, result[PARAM1]);
1588 } else {
1589 napi_reject_deferred(env, callbackInfo->deferred_, result[PARAM0]);
1590 }
1591 }
1592 napi_delete_async_work(env, callbackInfo->work_);
1593 delete callbackInfo;
1594 callbackInfo = nullptr;
1595 }
1596
EnableScreenCurtain(napi_env env,napi_callback_info info)1597 napi_value NAccessibilityElement::EnableScreenCurtain(napi_env env, napi_callback_info info)
1598 {
1599 HILOG_INFO("enter NAccessibilityElement::EnableScreenCurtain");
1600
1601 size_t argc = ARGS_SIZE_ONE;
1602 napi_value argv[ARGS_SIZE_ONE] = { 0 };
1603 napi_value thisVar = nullptr;
1604 void* data = nullptr;
1605 napi_status status = napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1606 if (status != napi_ok) {
1607 HILOG_ERROR("Failed to get cb info");
1608 napi_value err = CreateBusinessError(env, RetError::RET_ERR_FAILED);
1609 napi_throw(env, err);
1610 return nullptr;
1611 }
1612
1613 //get value from ui
1614 bool isEnable = true;
1615 napi_get_value_bool(env, argv[0], &isEnable);
1616 HILOG_INFO("ui argv[0] isEnable = %{public}d", isEnable);
1617
1618 //pass valule to server
1619 AccessibleAbilityClient::GetInstance()->EnableScreenCurtain(isEnable);
1620 return thisVar;
1621 }
1622
PerformAction(napi_env env,napi_callback_info info)1623 napi_value NAccessibilityElement::PerformAction(napi_env env, napi_callback_info info)
1624 {
1625 size_t argc = ARGS_SIZE_THREE;
1626 napi_value argv[ARGS_SIZE_THREE] = {0};
1627 napi_value thisVar = nullptr;
1628 void* data = nullptr;
1629 napi_status status = napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1630 if (status != napi_ok) {
1631 HILOG_ERROR("Failed to get cb info");
1632 napi_value err = CreateBusinessError(env, RetError::RET_ERR_FAILED);
1633 napi_throw(env, err);
1634 return nullptr;
1635 }
1636 HILOG_DEBUG("argc = %{public}zu", argc);
1637
1638 AccessibilityElement* accessibilityElement = UnrapAccessibilityElement(env, thisVar);
1639 if (!accessibilityElement) {
1640 return nullptr;
1641 }
1642 std::string actionName;
1643 NAccessibilityErrorCode errCode = NAccessibilityErrorCode::ACCESSIBILITY_OK;
1644 if (argc < ARGS_SIZE_ONE || !ParseString(env, actionName, argv[PARAM0])) {
1645 HILOG_ERROR("argc is invalid: %{public}zu", argc);
1646 errCode = NAccessibilityErrorCode::ACCESSIBILITY_ERROR_INVALID_PARAM;
1647 delete accessibilityElement;
1648 accessibilityElement = nullptr;
1649 napi_value err = CreateBusinessError(env, RetError::RET_ERR_INVALID_PARAM);
1650 HILOG_ERROR("invalid param");
1651 napi_throw(env, err);
1652 return nullptr;
1653 }
1654 return PerformActionAsync(env, argc, argv, actionName, accessibilityElement);
1655 }
1656
UnrapAccessibilityElement(napi_env env,napi_value thisVar)1657 AccessibilityElement* NAccessibilityElement::UnrapAccessibilityElement(napi_env env, napi_value thisVar)
1658 {
1659 AccessibilityElement* accessibilityElement = nullptr;
1660 napi_status status = napi_unwrap(env, thisVar, (void**)&accessibilityElement);
1661 if (!accessibilityElement || status != napi_ok) {
1662 HILOG_ERROR("accessibilityElement is null or status[%{public}d] is wrong", status);
1663 napi_value err = CreateBusinessError(env, RetError::RET_ERR_NULLPTR);
1664 napi_throw(env, err);
1665 return nullptr;
1666 }
1667 if (!(accessibilityElement->isElementInfo_ && accessibilityElement->elementInfo_)) {
1668 HILOG_ERROR("accessibilityElement is wrong. isElementInfo_[%{public}d]", accessibilityElement->isElementInfo_);
1669 napi_value err = CreateBusinessError(env, RetError::RET_ERR_FAILED);
1670 napi_throw(env, err);
1671 return nullptr;
1672 }
1673 return accessibilityElement;
1674 }
1675
PerformActionAsync(napi_env env,size_t argc,napi_value * argv,std::string actionName,AccessibilityElement * accessibilityElement)1676 napi_value NAccessibilityElement::PerformActionAsync(napi_env env, size_t argc, napi_value* argv,
1677 std::string actionName, AccessibilityElement* accessibilityElement)
1678 {
1679 NAccessibilityElementData *callbackInfo = new(std::nothrow) NAccessibilityElementData();
1680 if (!callbackInfo) {
1681 HILOG_ERROR("Failed to create callbackInfo.");
1682 napi_value err = CreateBusinessError(env, RetError::RET_ERR_NULLPTR);
1683 napi_throw(env, err);
1684 return nullptr;
1685 }
1686 callbackInfo->env_ = env;
1687 callbackInfo->accessibilityElement_ = *accessibilityElement;
1688
1689 return PerformActionConstructPromise(env, argc, argv, callbackInfo, actionName);
1690 }
1691
PerformActionConstructPromise(napi_env env,size_t argc,napi_value * argv,NAccessibilityElementData * callbackInfo,std::string actionName)1692 napi_value NAccessibilityElement::PerformActionConstructPromise(napi_env env, size_t argc, napi_value* argv,
1693 NAccessibilityElementData* callbackInfo, std::string actionName)
1694 {
1695 napi_value promise = nullptr;
1696 std::map<std::string, std::string> actionArguments {};
1697 if (argc >= ARGS_SIZE_THREE) {
1698 napi_valuetype secondParamType = napi_null;
1699 napi_typeof(env, argv[PARAM1], &secondParamType);
1700 napi_valuetype thirdParamType = napi_null;
1701 napi_typeof(env, argv[PARAM2], &thirdParamType);
1702 if (thirdParamType == napi_function) {
1703 if (secondParamType == napi_object) {
1704 ConvertActionArgsJSToNAPI(env, argv[PARAM1], actionArguments,
1705 ConvertStringToAccessibleOperationType(actionName));
1706 }
1707 napi_create_reference(env, argv[PARAM2], 1, &callbackInfo->callback_);
1708 napi_get_undefined(env, &promise);
1709 } else if (secondParamType == napi_function) {
1710 napi_create_reference(env, argv[PARAM1], 1, &callbackInfo->callback_);
1711 napi_get_undefined(env, &promise);
1712 } else {
1713 HILOG_DEBUG("argc is three, use promise");
1714 napi_create_promise(env, &callbackInfo->deferred_, &promise);
1715 }
1716 } else if (argc == ARGS_SIZE_TWO) {
1717 napi_valuetype valueType = napi_null;
1718 napi_typeof(env, argv[PARAM1], &valueType);
1719 if (valueType == napi_function) {
1720 napi_create_reference(env, argv[PARAM1], 1, &callbackInfo->callback_);
1721 napi_get_undefined(env, &promise);
1722 } else {
1723 if (valueType == napi_object) {
1724 ConvertActionArgsJSToNAPI(env, argv[PARAM1], actionArguments,
1725 ConvertStringToAccessibleOperationType(actionName));
1726 }
1727 HILOG_DEBUG("argc is two, use promise");
1728 napi_create_promise(env, &callbackInfo->deferred_, &promise);
1729 }
1730 } else {
1731 HILOG_DEBUG("argc is others, use promise");
1732 napi_create_promise(env, &callbackInfo->deferred_, &promise);
1733 }
1734
1735 callbackInfo->actionName_ = actionName;
1736 callbackInfo->actionArguments_ = actionArguments;
1737 napi_value resource = nullptr;
1738 napi_create_string_utf8(env, "PerformAction", NAPI_AUTO_LENGTH, &resource);
1739 napi_create_async_work(env, nullptr, resource, PerformActionExecute, PerformActionComplete,
1740 reinterpret_cast<void*>(callbackInfo), &callbackInfo->work_);
1741 napi_queue_async_work_with_qos(env, callbackInfo->work_, napi_qos_user_initiated);
1742 return promise;
1743 }
1744
PerformActionExecute(napi_env env,void * data)1745 void NAccessibilityElement::PerformActionExecute(napi_env env, void* data)
1746 {
1747 HILOG_DEBUG("PerformActionExecute");
1748 NAccessibilityElementData *callbackInfo = static_cast<NAccessibilityElementData*>(data);
1749 if (!callbackInfo) {
1750 HILOG_ERROR("callbackInfo is nullptr");
1751 return;
1752 }
1753
1754 ActionType action = ConvertStringToAccessibleOperationType(callbackInfo->actionName_);
1755 if (action == ActionType::ACCESSIBILITY_ACTION_INVALID) {
1756 HILOG_ERROR("The action is not supported");
1757 callbackInfo->ret_ = OHOS::Accessibility::RetError::RET_ERR_ACTION_NOT_SUPPORT;
1758 return;
1759 }
1760 callbackInfo->ret_ = AccessibleAbilityClient::GetInstance()->ExecuteAction(
1761 *callbackInfo->accessibilityElement_.elementInfo_, action, callbackInfo->actionArguments_);
1762 HILOG_DEBUG("callbackInfo->ret_[%{public}d]", callbackInfo->ret_);
1763 }
1764
PerformActionComplete(napi_env env,napi_status status,void * data)1765 void NAccessibilityElement::PerformActionComplete(napi_env env, napi_status status, void* data)
1766 {
1767 HILOG_DEBUG("PerformActionComplete execute back");
1768 NAccessibilityElementData* callbackInfo = static_cast<NAccessibilityElementData*>(data);
1769 if (!callbackInfo) {
1770 HILOG_ERROR("callbackInfo is nullptr");
1771 return;
1772 }
1773 napi_value result[ARGS_SIZE_TWO] = {0};
1774 napi_value callback = 0;
1775 napi_value undefined = 0;
1776 napi_get_undefined(env, &undefined);
1777 napi_get_undefined(env, &result[PARAM1]);
1778 result[PARAM0] = CreateBusinessError(env, callbackInfo->ret_);
1779 if (callbackInfo->callback_) {
1780 // Callback mode
1781 napi_get_reference_value(env, callbackInfo->callback_, &callback);
1782 napi_value returnVal = nullptr;
1783 napi_call_function(env, undefined, callback, ARGS_SIZE_TWO, result, &returnVal);
1784 napi_delete_reference(env, callbackInfo->callback_);
1785 } else {
1786 // Promise mode
1787 if (callbackInfo->ret_ == RET_OK) {
1788 napi_resolve_deferred(env, callbackInfo->deferred_, result[PARAM1]);
1789 } else {
1790 napi_reject_deferred(env, callbackInfo->deferred_, result[PARAM0]);
1791 }
1792 }
1793
1794 napi_delete_async_work(env, callbackInfo->work_);
1795 delete callbackInfo;
1796 callbackInfo = nullptr;
1797 }
1798
FindElement(napi_env env,napi_callback_info info)1799 napi_value NAccessibilityElement::FindElement(napi_env env, napi_callback_info info)
1800 {
1801 size_t argc = ARGS_SIZE_THREE;
1802 napi_value argv[ARGS_SIZE_THREE] = {0};
1803 napi_value thisVar = nullptr;
1804 void* data = nullptr;
1805 napi_status status = napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1806 if (status != napi_ok) {
1807 HILOG_ERROR("Failed to get cb info");
1808 napi_value err = CreateBusinessError(env, RetError::RET_ERR_FAILED);
1809 napi_throw(env, err);
1810 return nullptr;
1811 }
1812 HILOG_DEBUG("argc = %{public}d", (int)argc);
1813
1814 // Unwrap AccessibilityElement
1815 AccessibilityElement* accessibilityElement = nullptr;
1816 status = napi_unwrap(env, thisVar, (void**)&accessibilityElement);
1817 if (!accessibilityElement || status != napi_ok) {
1818 HILOG_ERROR("accessibilityElement is null or status[%{public}d] is wrong", status);
1819 napi_value err = CreateBusinessError(env, RetError::RET_ERR_NULLPTR);
1820 napi_throw(env, err);
1821 return nullptr;
1822 }
1823 if (!accessibilityElement->isElementInfo_) {
1824 HILOG_ERROR("Type of AccessibilityElement is not right");
1825 napi_value err = CreateBusinessError(env, RetError::RET_ERR_FAILED);
1826 napi_throw(env, err);
1827 return nullptr;
1828 }
1829
1830 NAccessibilityElementData *callbackInfo = new(std::nothrow) NAccessibilityElementData();
1831 if (!callbackInfo) {
1832 HILOG_ERROR("Failed to create callbackInfo.");
1833 napi_value err = CreateBusinessError(env, RetError::RET_ERR_NULLPTR);
1834 napi_throw(env, err);
1835 return nullptr;
1836 }
1837 callbackInfo->env_ = env;
1838 FindElementConstructCallbackInfo(env, argc, argv, callbackInfo, accessibilityElement);
1839 if (!callbackInfo) {
1840 return nullptr;
1841 }
1842 return FindElementAsync(env, argc, argv, callbackInfo, accessibilityElement);
1843 }
1844
GetCursorPositionAsync(napi_env env,size_t argc,napi_value * argv,NAccessibilityElementData * callbackInfo,AccessibilityElement * accessibilityElement)1845 napi_value NAccessibilityElement::GetCursorPositionAsync(napi_env env, size_t argc, napi_value* argv,
1846 NAccessibilityElementData* callbackInfo, AccessibilityElement* accessibilityElement)
1847 {
1848 if (!callbackInfo) {
1849 HILOG_ERROR("callbackInfo is nullptr");
1850 return nullptr;
1851 }
1852 napi_value promise = nullptr;
1853 if (argc > ARGS_SIZE_ONE - 1) {
1854 napi_valuetype valueType = napi_null;
1855 napi_typeof(env, argv[PARAM0], &valueType);
1856 if (valueType == napi_function) {
1857 napi_create_reference(env, argv[PARAM0], 1, &callbackInfo->callback_);
1858 napi_get_undefined(env, &promise);
1859 } else {
1860 napi_create_promise(env, &callbackInfo->deferred_, &promise);
1861 }
1862 } else {
1863 napi_create_promise(env, &callbackInfo->deferred_, &promise);
1864 }
1865
1866 callbackInfo->accessibilityElement_ = *accessibilityElement;
1867
1868 napi_value resource = nullptr;
1869 napi_create_string_utf8(callbackInfo->env_, "GetCursorPosition", NAPI_AUTO_LENGTH, &resource);
1870 napi_create_async_work(callbackInfo->env_, nullptr, resource, GetCursorPositionExecute,
1871 GetCursorPositionComplete, reinterpret_cast<void*>(callbackInfo), &callbackInfo->work_);
1872 napi_queue_async_work_with_qos(callbackInfo->env_, callbackInfo->work_, napi_qos_user_initiated);
1873 return promise;
1874 }
1875
FindElementAsync(napi_env env,size_t argc,napi_value * argv,NAccessibilityElementData * callbackInfo,AccessibilityElement * accessibilityElement)1876 napi_value NAccessibilityElement::FindElementAsync(napi_env env, size_t argc, napi_value* argv,
1877 NAccessibilityElementData* callbackInfo, AccessibilityElement* accessibilityElement)
1878 {
1879 napi_value promise = nullptr;
1880 if (argc > ARGS_SIZE_THREE - 1) {
1881 napi_valuetype valueType = napi_null;
1882 napi_typeof(env, argv[PARAM2], &valueType);
1883 if (valueType == napi_function) {
1884 napi_create_reference(env, argv[PARAM2], 1, &callbackInfo->callback_);
1885 napi_get_undefined(env, &promise);
1886 } else {
1887 napi_create_promise(env, &callbackInfo->deferred_, &promise);
1888 }
1889 } else {
1890 napi_create_promise(env, &callbackInfo->deferred_, &promise);
1891 }
1892
1893 callbackInfo->accessibilityElement_ = *accessibilityElement;
1894
1895 napi_value resource = nullptr;
1896 napi_create_string_utf8(callbackInfo->env_, "FindElement", NAPI_AUTO_LENGTH, &resource);
1897 napi_create_async_work(callbackInfo->env_, nullptr, resource, FindElementExecute,
1898 FindElementComplete, reinterpret_cast<void*>(callbackInfo), &callbackInfo->work_);
1899 napi_queue_async_work_with_qos(callbackInfo->env_, callbackInfo->work_, napi_qos_user_initiated);
1900 return promise;
1901 }
1902
FindElementConstructCallbackInfo(napi_env env,size_t argc,napi_value * argv,NAccessibilityElementData * callbackInfo,AccessibilityElement * accessibilityElement)1903 void NAccessibilityElement::FindElementConstructCallbackInfo(napi_env env, size_t argc, napi_value* argv,
1904 NAccessibilityElementData* callbackInfo, AccessibilityElement* accessibilityElement)
1905 {
1906 NAccessibilityErrorCode errCode = NAccessibilityErrorCode::ACCESSIBILITY_OK;
1907 if (argc < ARGS_SIZE_THREE - 1) {
1908 HILOG_ERROR("argc is invalid: %{public}zu", argc);
1909 errCode = NAccessibilityErrorCode::ACCESSIBILITY_ERROR_INVALID_PARAM;
1910 }
1911
1912 if (errCode == NAccessibilityErrorCode::ACCESSIBILITY_OK) {
1913 // Parse conditionType name
1914 std::string conditionType = "";
1915 if (ParseString(env, conditionType, argv[PARAM0])) {
1916 HILOG_DEBUG("conditionType = %{public}s", conditionType.c_str());
1917 if (std::strcmp(conditionType.c_str(), "content") != 0 &&
1918 std::strcmp(conditionType.c_str(), "focusType") != 0 &&
1919 std::strcmp(conditionType.c_str(), "focusDirection") != 0 &&
1920 std::strcmp(conditionType.c_str(), "textType") != 0 &&
1921 std::strcmp(conditionType.c_str(), "elementId") != 0) {
1922 HILOG_ERROR("argv[PARAM0] is wrong[%{public}s", conditionType.c_str());
1923 errCode = NAccessibilityErrorCode::ACCESSIBILITY_ERROR_INVALID_PARAM;
1924 } else {
1925 callbackInfo->conditionId_ = ConvertStringToCondition(conditionType);
1926 }
1927 } else {
1928 errCode = NAccessibilityErrorCode::ACCESSIBILITY_ERROR_INVALID_PARAM;
1929 }
1930
1931 // Parse queryData name
1932 std::string queryData = "";
1933 int64_t elementId;
1934 if (ParseString(env, queryData, argv[PARAM1])) {
1935 HILOG_DEBUG("queryData = %{public}s", queryData.c_str());
1936 callbackInfo->condition_ = queryData;
1937 } else if (ParseInt64(env, elementId, argv[PARAM1])) {
1938 queryData = std::to_string(elementId);
1939 HILOG_DEBUG("queryData = %{public}s", queryData.c_str());
1940 callbackInfo->condition_ = queryData;
1941 } else if (ParseBigInt(env, elementId, argv[PARAM1])) {
1942 queryData = std::to_string(elementId);
1943 HILOG_DEBUG("queryData = %{public}s", queryData.c_str());
1944 callbackInfo->condition_ = queryData;
1945 } else {
1946 errCode = NAccessibilityErrorCode::ACCESSIBILITY_ERROR_INVALID_PARAM;
1947 }
1948 }
1949
1950 if (errCode == NAccessibilityErrorCode::ACCESSIBILITY_ERROR_INVALID_PARAM) {
1951 delete callbackInfo;
1952 callbackInfo = nullptr;
1953 delete accessibilityElement;
1954 accessibilityElement = nullptr;
1955 napi_value err = CreateBusinessError(env, RetError::RET_ERR_INVALID_PARAM);
1956 HILOG_ERROR("invalid param");
1957 napi_throw(env, err);
1958 }
1959 }
1960
FindElementByText(NAccessibilityElementData * callbackInfo)1961 void NAccessibilityElement::FindElementByText(NAccessibilityElementData *callbackInfo)
1962 {
1963 nlohmann::json jsonStr;
1964 jsonStr["type"] = (callbackInfo->conditionId_ ==
1965 FindElementCondition::FIND_ELEMENT_CONDITION_CONTENT) ? "content" : "textType";
1966 jsonStr["value"] = callbackInfo->condition_;
1967 callbackInfo->ret_ = AccessibleAbilityClient::GetInstance()->GetByContent(
1968 *(callbackInfo->accessibilityElement_.elementInfo_),
1969 jsonStr.dump().c_str(), callbackInfo->nodeInfos_);
1970 return;
1971 }
1972
GetCursorPositionExecute(napi_env env,void * data)1973 void NAccessibilityElement::GetCursorPositionExecute(napi_env env, void* data)
1974 {
1975 HILOG_DEBUG("GetCursorPositionExecute");
1976 NAccessibilityElementData *callbackInfo = static_cast<NAccessibilityElementData*>(data);
1977 if (!callbackInfo) {
1978 HILOG_ERROR("callbackInfo is nullptr");
1979 return;
1980 }
1981
1982 callbackInfo->ret_ = AccessibleAbilityClient::GetInstance()->GetCursorPosition(
1983 *callbackInfo->accessibilityElement_.elementInfo_, callbackInfo->cursorPosition_);
1984 }
1985
FindElementExecute(napi_env env,void * data)1986 void NAccessibilityElement::FindElementExecute(napi_env env, void* data)
1987 {
1988 NAccessibilityElementData *callbackInfo = static_cast<NAccessibilityElementData*>(data);
1989 if (!callbackInfo) {
1990 HILOG_ERROR("callbackInfo is nullptr");
1991 return;
1992 }
1993
1994 switch (callbackInfo->conditionId_) {
1995 case FindElementCondition::FIND_ELEMENT_CONDITION_INVALID:
1996 HILOG_ERROR("condition id is invalid");
1997 callbackInfo->ret_ = RET_ERR_INVALID_PARAM;
1998 return;
1999 case FindElementCondition::FIND_ELEMENT_CONDITION_CONTENT:
2000 case FindElementCondition::FIND_ELEMENT_CONDITION_TEXT_TYPE:
2001 FindElementByText(callbackInfo);
2002 break;
2003 case FindElementCondition::FIND_ELEMENT_CONDITION_FOCUS_TYPE:
2004 {
2005 int32_t focusType = ConvertStringToFocusType(callbackInfo->condition_);
2006 HILOG_DEBUG("focusType is %{public}d", focusType);
2007 callbackInfo->ret_ = AccessibleAbilityClient::GetInstance()->GetFocusByElementInfo(
2008 *(callbackInfo->accessibilityElement_.elementInfo_),
2009 focusType, callbackInfo->nodeInfo_);
2010 }
2011 break;
2012 case FindElementCondition::FIND_ELEMENT_CONDITION_FOCUS_DIRECTION:
2013 {
2014 FocusMoveDirection direction = ConvertStringToDirection(callbackInfo->condition_);
2015 HILOG_DEBUG("direction is %{public}d", direction);
2016 callbackInfo->ret_ = AccessibleAbilityClient::GetInstance()->GetNext(
2017 *(callbackInfo->accessibilityElement_.elementInfo_), direction,
2018 callbackInfo->nodeInfo_);
2019 }
2020 break;
2021 case FindElementCondition::FIND_ELEMENT_CONDITION_ELEMENT_ID:
2022 {
2023 int64_t elementId = std::stoll(callbackInfo->condition_);
2024 int32_t windowId = callbackInfo->accessibilityElement_.elementInfo_->GetWindowId();
2025 HILOG_DEBUG("elementId is %{public}" PRId64 " windowId: %{public}d", elementId, windowId);
2026 callbackInfo->ret_ = AccessibleAbilityClient::GetInstance()->GetByElementId(
2027 elementId, windowId, callbackInfo->nodeInfo_);
2028 }
2029 break;
2030 default:
2031 break;
2032 }
2033 HILOG_DEBUG("condition id[%{public}d], result[%{public}d]", callbackInfo->conditionId_, callbackInfo->ret_);
2034 }
2035
2036
GetCursorPositionComplete(napi_env env,napi_status status,void * data)2037 void NAccessibilityElement::GetCursorPositionComplete(napi_env env, napi_status status, void* data)
2038 {
2039 HILOG_DEBUG("GetCursorPositionComplete execute back");
2040 NAccessibilityElementData* callbackInfo = static_cast<NAccessibilityElementData*>(data);
2041 if (!callbackInfo) {
2042 HILOG_ERROR("callbackInfo is nullptr");
2043 return;
2044 }
2045 napi_value result[ARGS_SIZE_TWO] = {0};
2046 napi_value callback = 0;
2047 napi_value undefined = 0;
2048 napi_get_undefined(env, &undefined);
2049 napi_create_int32(env, callbackInfo->cursorPosition_, &result[PARAM1]);
2050 HILOG_INFO("Response [callback cursorPosition:%{public}d]", callbackInfo->cursorPosition_);
2051 result[PARAM0] = CreateBusinessError(env, callbackInfo->ret_);
2052 if (callbackInfo->callback_) {
2053 // Callback mode
2054 napi_get_reference_value(env, callbackInfo->callback_, &callback);
2055 napi_value returnVal = nullptr;
2056 napi_call_function(env, undefined, callback, ARGS_SIZE_TWO, result, &returnVal);
2057 HILOG_INFO("NAccessibilityElement::GetCursorPositionComplete in CallbackMode");
2058 napi_delete_reference(env, callbackInfo->callback_);
2059 } else {
2060 // Promise mode
2061 if (callbackInfo->ret_ == RET_OK) {
2062 napi_resolve_deferred(env, callbackInfo->deferred_, result[PARAM1]);
2063 } else {
2064 napi_reject_deferred(env, callbackInfo->deferred_, result[PARAM0]);
2065 }
2066 }
2067
2068 napi_delete_async_work(env, callbackInfo->work_);
2069 delete callbackInfo;
2070 callbackInfo = nullptr;
2071 }
2072
FindElementComplete(napi_env env,napi_status status,void * data)2073 void NAccessibilityElement::FindElementComplete(napi_env env, napi_status status, void* data)
2074 {
2075 NAccessibilityElementData* callbackInfo = static_cast<NAccessibilityElementData*>(data);
2076 if (!callbackInfo) {
2077 HILOG_ERROR("callbackInfo is nullptr");
2078 return;
2079 }
2080
2081 napi_value result[ARGS_SIZE_TWO] = {0};
2082 GetElement(callbackInfo, result[PARAM1]);
2083 result[PARAM0] = CreateBusinessError(env, callbackInfo->ret_);
2084 if (callbackInfo->callback_) {
2085 HILOG_DEBUG("callback mode. result is %{public}d", callbackInfo->ret_);
2086 napi_value callback = 0;
2087 napi_get_reference_value(env, callbackInfo->callback_, &callback);
2088 napi_value returnVal = nullptr;
2089 napi_value undefined = 0;
2090 napi_get_undefined(env, &undefined);
2091 napi_call_function(env, undefined, callback, ARGS_SIZE_TWO, result, &returnVal);
2092 napi_delete_reference(env, callbackInfo->callback_);
2093 } else {
2094 HILOG_DEBUG("promise mode. result is %{public}d", callbackInfo->ret_);
2095 if (callbackInfo->ret_ == RET_OK) {
2096 napi_resolve_deferred(env, callbackInfo->deferred_, result[PARAM1]);
2097 } else {
2098 napi_reject_deferred(env, callbackInfo->deferred_, result[PARAM0]);
2099 }
2100 }
2101 napi_delete_async_work(env, callbackInfo->work_);
2102 delete callbackInfo;
2103 callbackInfo = nullptr;
2104 }
2105
GetElement(NAccessibilityElementData * callbackInfo,napi_value & value)2106 void NAccessibilityElement::GetElement(NAccessibilityElementData *callbackInfo, napi_value &value)
2107 {
2108 HILOG_DEBUG("condition id[%{public}d]", callbackInfo->conditionId_);
2109 napi_env env = callbackInfo->env_;
2110 if (callbackInfo->ret_ != RET_OK) {
2111 HILOG_ERROR("GetElementInfo failed!");
2112 napi_get_undefined(env, &value);
2113 return;
2114 }
2115
2116 switch (callbackInfo->conditionId_) {
2117 case FindElementCondition::FIND_ELEMENT_CONDITION_INVALID:
2118 HILOG_ERROR("condition id is invalid");
2119 callbackInfo->ret_ = RET_ERR_INVALID_PARAM;
2120 return;
2121 case FindElementCondition::FIND_ELEMENT_CONDITION_CONTENT:
2122 napi_create_array(env, &value);
2123 ConvertElementInfosToJS(env, value, callbackInfo->nodeInfos_);
2124 break;
2125 case FindElementCondition::FIND_ELEMENT_CONDITION_TEXT_TYPE:
2126 napi_create_array(env, &value);
2127 ConvertElementInfosToJS(env, value, callbackInfo->nodeInfos_);
2128 break;
2129 case FindElementCondition::FIND_ELEMENT_CONDITION_FOCUS_TYPE:
2130 {
2131 napi_value constructor = nullptr;
2132 napi_get_reference_value(env, NAccessibilityElement::consRef_, &constructor);
2133 napi_new_instance(env, constructor, 0, nullptr, &value);
2134 ConvertElementInfoToJS(env, value, callbackInfo->nodeInfo_);
2135 }
2136 break;
2137 case FindElementCondition::FIND_ELEMENT_CONDITION_FOCUS_DIRECTION:
2138 {
2139 napi_value constructor = nullptr;
2140 napi_get_reference_value(env, NAccessibilityElement::consRef_, &constructor);
2141 napi_new_instance(env, constructor, 0, nullptr, &value);
2142 ConvertElementInfoToJS(env, value, callbackInfo->nodeInfo_);
2143 }
2144 break;
2145 case FindElementCondition::FIND_ELEMENT_CONDITION_ELEMENT_ID:
2146 {
2147 napi_value constructor = nullptr;
2148 napi_get_reference_value(env, NAccessibilityElement::consRef_, &constructor);
2149 napi_new_instance(env, constructor, 0, nullptr, &value);
2150 ConvertElementInfoToJS(env, value, callbackInfo->nodeInfo_);
2151 }
2152 break;
2153 default:
2154 break;
2155 }
2156 }
2157
ErrorOperation(NAccessibilityElementData * callbackInfo)2158 napi_value NAccessibilityElement::ErrorOperation(NAccessibilityElementData *callbackInfo)
2159 {
2160 HILOG_DEBUG();
2161 napi_value promise = nullptr;
2162 if (!callbackInfo) {
2163 HILOG_ERROR("callbackInfo is nullptr");
2164 return nullptr;
2165 }
2166 napi_env env = callbackInfo->env_;
2167 if (callbackInfo->callback_) {
2168 HILOG_DEBUG("callback mode");
2169 napi_get_undefined(env, &promise);
2170 } else {
2171 napi_create_promise(env, &callbackInfo->deferred_, &promise);
2172 }
2173
2174 napi_value resource = nullptr;
2175 napi_create_string_utf8(env, "ErrorOperation", NAPI_AUTO_LENGTH, &resource);
2176 if (resource == nullptr) {
2177 HILOG_ERROR("resource is nullptr.");
2178 return nullptr;
2179 }
2180 napi_create_async_work(env, nullptr, resource, [](napi_env env, void* data) {},
2181 // Execute the complete function
2182 [](napi_env env, napi_status status, void* data) {
2183 NAccessibilityElementData* callbackInfo = static_cast<NAccessibilityElementData*>(data);
2184 if (!callbackInfo) {
2185 HILOG_ERROR("callbackInfo is nullptr");
2186 return;
2187 }
2188
2189 napi_value result[ARGS_SIZE_TWO] = {0};
2190 napi_value callback = 0;
2191 napi_value undefined = 0;
2192 napi_get_undefined(env, &undefined);
2193 result[PARAM0] = CreateBusinessError(env, callbackInfo->ret_);
2194 if (callbackInfo->callback_) {
2195 // Callback mode
2196 result[PARAM1] = undefined;
2197 napi_get_reference_value(env, callbackInfo->callback_, &callback);
2198 napi_value returnVal = nullptr;
2199 napi_call_function(env, undefined, callback, ARGS_SIZE_TWO, result, &returnVal);
2200 napi_delete_reference(env, callbackInfo->callback_);
2201 } else {
2202 // Promise mode
2203 napi_reject_deferred(env, callbackInfo->deferred_, result[PARAM0]);
2204 }
2205 napi_delete_async_work(env, callbackInfo->work_);
2206 delete callbackInfo;
2207 callbackInfo = nullptr;
2208 },
2209 reinterpret_cast<void*>(callbackInfo),
2210 &callbackInfo->work_);
2211 napi_queue_async_work_with_qos(env, callbackInfo->work_, napi_qos_user_initiated);
2212 return promise;
2213 }
2214
GetCursorPosition(napi_env env,napi_callback_info info)2215 napi_value NAccessibilityElement::GetCursorPosition(napi_env env, napi_callback_info info)
2216 {
2217 size_t argc = ARGS_SIZE_ONE;
2218 napi_value argv[ARGS_SIZE_ONE] = {0};
2219 napi_value thisVar = nullptr;
2220 void* data = nullptr;
2221 napi_status status = napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
2222 if (status != napi_ok) {
2223 HILOG_ERROR("Failed to get cb info");
2224 return nullptr;
2225 }
2226 HILOG_DEBUG("argc = %{public}d", (int)argc);
2227
2228 // Unwrap AccessibilityElement
2229 AccessibilityElement* accessibilityElement = nullptr;
2230 status = napi_unwrap(env, thisVar, (void**)&accessibilityElement);
2231 if (!accessibilityElement || status != napi_ok) {
2232 HILOG_ERROR("accessibilityElement is null or status[%{public}d] is wrong", status);
2233 return nullptr;
2234 }
2235 if (!accessibilityElement->isElementInfo_) {
2236 HILOG_ERROR("Type of AccessibilityElement is not right");
2237 return nullptr;
2238 }
2239
2240 NAccessibilityElementData *callbackInfo = new(std::nothrow) NAccessibilityElementData();
2241 if (!callbackInfo) {
2242 HILOG_ERROR("Failed to create callbackInfo.");
2243 return nullptr;
2244 }
2245 callbackInfo->env_ = env;
2246 return GetCursorPositionAsync(env, argc, argv, callbackInfo, accessibilityElement);
2247 }
2248
ConvertStringToCondition(const std::string & str)2249 FindElementCondition NAccessibilityElement::ConvertStringToCondition(const std::string &str)
2250 {
2251 static const std::map<std::string, FindElementCondition> findElementConditionTable = {
2252 {"content", FindElementCondition::FIND_ELEMENT_CONDITION_CONTENT},
2253 {"focusType", FindElementCondition::FIND_ELEMENT_CONDITION_FOCUS_TYPE},
2254 {"focusDirection", FindElementCondition::FIND_ELEMENT_CONDITION_FOCUS_DIRECTION},
2255 {"elementId", FindElementCondition::FIND_ELEMENT_CONDITION_ELEMENT_ID},
2256 {"textType", FindElementCondition::FIND_ELEMENT_CONDITION_TEXT_TYPE}
2257 };
2258
2259 if (findElementConditionTable.find(str) == findElementConditionTable.end()) {
2260 return FindElementCondition::FIND_ELEMENT_CONDITION_INVALID;
2261 }
2262
2263 return findElementConditionTable.at(str);
2264 }
2265
ConvertStringToDirection(const std::string & str)2266 FocusMoveDirection NAccessibilityElement::ConvertStringToDirection(const std::string &str)
2267 {
2268 static const std::map<std::string, FocusMoveDirection> focusMoveDirectionTable = {
2269 {"up", FocusMoveDirection::UP},
2270 {"down", FocusMoveDirection::DOWN},
2271 {"left", FocusMoveDirection::LEFT},
2272 {"right", FocusMoveDirection::RIGHT},
2273 {"forward", FocusMoveDirection::FORWARD},
2274 {"backward", FocusMoveDirection::BACKWARD}
2275 };
2276
2277 if (focusMoveDirectionTable.find(str) == focusMoveDirectionTable.end()) {
2278 return FocusMoveDirection::DIRECTION_INVALID;
2279 }
2280
2281 return focusMoveDirectionTable.at(str);
2282 }
2283
ConvertStringToFocusType(const std::string & str)2284 int32_t NAccessibilityElement::ConvertStringToFocusType(const std::string &str)
2285 {
2286 static const std::map<std::string, int32_t> focusTypeTable = {
2287 {"normal", FOCUS_TYPE_INPUT},
2288 {"accessibility", FOCUS_TYPE_ACCESSIBILITY}
2289 };
2290
2291 if (focusTypeTable.find(str) == focusTypeTable.end()) {
2292 return FOCUS_TYPE_INVALID;
2293 }
2294 return focusTypeTable.at(str);
2295 }