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