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