1 /*
2 * Copyright (C) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "napi_accessibility_element.h"
17 #include <algorithm>
18 #include <map>
19 #include <vector>
20 #include "accessible_ability_client.h"
21 #include "hilog_wrapper.h"
22 #include "napi_accessibility_utils.h"
23
24 using namespace OHOS;
25 using namespace OHOS::Accessibility;
26 using namespace OHOS::AccessibilityNapi;
27 namespace {
28 const std::vector<std::string> ELEMENT_INFO_ATTRIBUTE_NAMES = {"componentId", "inspectorKey",
29 "bundleName", "componentType", "inputType", "text", "hintText", "description", "triggerAction",
30 "textMoveUnit", "contents", "lastContent", "itemCount", "currentIndex", "startIndex", "endIndex",
31 "resourceName", "textLengthLimit", "rect", "checkable", "checked", "focusable", "isVisible",
32 "selected", "clickable", "longClickable", "isEnable", "isPassword", "scrollable",
33 "editable", "pluralLineSupported", "parent", "children", "isFocused", "accessibilityFocused",
34 "error", "isHint", "pageId", "valueMax", "valueMin", "valueNow", "windowId"};
35 const std::vector<std::string> WINDOW_INFO_ATTRIBUTE_NAMES = {"isActive", "screenRect", "layer", "type",
36 "rootElement", "isFocused", "windowId"};
37
38 using AttributeNamesFunc = void (*)(NAccessibilityElementData *callbackInfo, napi_value &value);
39 std::map<std::string, AttributeNamesFunc> elementInfoCompleteMap = {
40 {"componentId", &NAccessibilityElement::GetElementInfoComponentId},
41 {"inspectorKey", &NAccessibilityElement::GetElementInfoInspectorKey},
42 {"bundleName", &NAccessibilityElement::GetElementInfoBundleName},
43 {"componentType", &NAccessibilityElement::GetElementInfoComponentType},
44 {"inputType", &NAccessibilityElement::GetElementInfoInputType},
45 {"text", &NAccessibilityElement::GetElementInfoText},
46 {"hintText", &NAccessibilityElement::GetElementInfoHintText},
47 {"description", &NAccessibilityElement::GetElementInfoDescription},
48 {"resourceName", &NAccessibilityElement::GetElementInfoResourceName},
49 {"textLengthLimit", &NAccessibilityElement::GetElementInfoTextLengthLimit},
50 {"rect", &NAccessibilityElement::GetElementInfoRect},
51 {"checkable", &NAccessibilityElement::GetElementInfoCheckable},
52 {"checked", &NAccessibilityElement::GetElementInfoChecked},
53 {"focusable", &NAccessibilityElement::GetElementInfoFocusable},
54 {"isVisible", &NAccessibilityElement::GetElementInfoIsVisible},
55 {"selected", &NAccessibilityElement::GetElementInfoSelected},
56 {"clickable", &NAccessibilityElement::GetElementInfoClickable},
57 {"longClickable", &NAccessibilityElement::GetElementInfoLongClickable},
58 {"isEnable", &NAccessibilityElement::GetElementInfoIsEnable},
59 {"isPassword", &NAccessibilityElement::GetElementInfoIsPassword},
60 {"scrollable", &NAccessibilityElement::GetElementInfoScrollable},
61 {"editable", &NAccessibilityElement::GetElementInfoEditable},
62 {"pluralLineSupported", &NAccessibilityElement::GetElementInfoPluralLineSupported},
63 {"itemCount", &NAccessibilityElement::GetElementInfoItemCount},
64 {"currentIndex", &NAccessibilityElement::GetElementInfoCurrentIndex},
65 {"startIndex", &NAccessibilityElement::GetElementInfoStartIndex},
66 {"endIndex", &NAccessibilityElement::GetElementInfoEndIndex},
67 {"textMoveUnit", &NAccessibilityElement::GetElementInfoTextMoveUnit},
68 {"parent", &NAccessibilityElement::GetElementInfoParent},
69 {"children", &NAccessibilityElement::GetElementInfoChildren},
70 {"triggerAction", &NAccessibilityElement::GetElementInfoTriggerAction},
71 {"contents", &NAccessibilityElement::GetElementInfoContents},
72 {"lastContent", &NAccessibilityElement::GetElementInfoLastContent},
73 {"isFocused", &NAccessibilityElement::GetElementInfoIsFocused},
74 {"accessibilityFocused", &NAccessibilityElement::GetElementInfoAccessibilityFocused},
75 {"error", &NAccessibilityElement::GetElementInfoError},
76 {"isHint", &NAccessibilityElement::GetElementInfoIsHint},
77 {"pageId", &NAccessibilityElement::GetElementInfoPageId},
78 {"valueMax", &NAccessibilityElement::GetElementInfoValueMax},
79 {"valueMin", &NAccessibilityElement::GetElementInfoValueMin},
80 {"valueNow", &NAccessibilityElement::GetElementInfoValueNow},
81 {"windowId", &NAccessibilityElement::GetElementInfoWindowId},
82 };
83 std::map<std::string, AttributeNamesFunc> windowInfoCompleteMap = {
84 {"isActive", &NAccessibilityElement::GetWindowInfoIsActive},
85 {"screenRect", &NAccessibilityElement::GetWindowInfoScreenRect},
86 {"layer", &NAccessibilityElement::GetWindowInfoLayer},
87 {"type", &NAccessibilityElement::GetWindowInfoType},
88 {"rootElement", &NAccessibilityElement::GetWindowInfoRootElement},
89 {"isFocused", &NAccessibilityElement::GetWindowInfoIsFocused},
90 {"windowId", &NAccessibilityElement::GetWindowInfoWindowId},
91 };
92 } // namespace
93
94 thread_local napi_ref NAccessibilityElement::consRef_ = nullptr;
95
DefineJSAccessibilityElement(napi_env env)96 void NAccessibilityElement::DefineJSAccessibilityElement(napi_env env)
97 {
98 napi_property_descriptor descForAccessibilityElement[] = {
99 DECLARE_NAPI_FUNCTION("attributeNames", NAccessibilityElement::AttributeNames),
100 DECLARE_NAPI_FUNCTION("attributeValue", NAccessibilityElement::AttributeValue),
101 DECLARE_NAPI_FUNCTION("actionNames", NAccessibilityElement::ActionNames),
102 DECLARE_NAPI_FUNCTION("performAction", NAccessibilityElement::PerformAction),
103 DECLARE_NAPI_FUNCTION("findElement", NAccessibilityElement::FindElement),
104 };
105
106 napi_value constructor = nullptr;
107
108 NAPI_CALL_RETURN_VOID(env,
109 napi_define_class(env,
110 "AccessibilityElement",
111 NAPI_AUTO_LENGTH,
112 NAccessibilityElement::JSConstructor,
113 nullptr,
114 sizeof(descForAccessibilityElement) / sizeof(descForAccessibilityElement[0]),
115 descForAccessibilityElement,
116 &constructor));
117 napi_create_reference(env, constructor, 1, &NAccessibilityElement::consRef_);
118 }
119
JSConstructor(napi_env env,napi_callback_info info)120 napi_value NAccessibilityElement::JSConstructor(napi_env env, napi_callback_info info)
121 {
122 napi_value jsthis = nullptr;
123 NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &jsthis, nullptr));
124 return jsthis;
125 }
126
ConvertElementInfoToJS(napi_env env,napi_value result,const AccessibilityElementInfo & elementInfo)127 void NAccessibilityElement::ConvertElementInfoToJS(napi_env env, napi_value result,
128 const AccessibilityElementInfo& elementInfo)
129 {
130 // Bind js object to a Native object
131 std::shared_ptr<AccessibilityElementInfo> elementInformation =
132 std::make_shared<AccessibilityElementInfo>(elementInfo);
133 AccessibilityElement* pAccessibilityElement = new(std::nothrow) AccessibilityElement(elementInformation);
134 if (!pAccessibilityElement) {
135 HILOG_ERROR("Failed to create elementInformation.");
136 return;
137 }
138 napi_status sts = napi_wrap(
139 env,
140 result,
141 pAccessibilityElement,
142 [](napi_env env, void* data, void* hint) {
143 AccessibilityElement* info = static_cast<AccessibilityElement*>(data);
144 delete info;
145 info = nullptr;
146 },
147 nullptr,
148 nullptr);
149 HILOG_DEBUG("napi_wrap status: %{public}d", (int)sts);
150 }
151
ConvertElementInfosToJS(napi_env env,napi_value result,const std::vector<OHOS::Accessibility::AccessibilityElementInfo> & elementInfos)152 void NAccessibilityElement::ConvertElementInfosToJS(
153 napi_env env, napi_value result, const std::vector<OHOS::Accessibility::AccessibilityElementInfo>& elementInfos)
154 {
155 HILOG_DEBUG("elementInfo size(%{public}zu)", elementInfos.size());
156
157 napi_value constructor = nullptr;
158 napi_get_reference_value(env, NAccessibilityElement::consRef_, &constructor);
159
160 size_t index = 0;
161 for (auto& elementInfo : elementInfos) {
162 napi_value obj = nullptr;
163 napi_status status = napi_new_instance(env, constructor, 0, nullptr, &obj);
164 HILOG_INFO("status is %{public}d", status);
165 ConvertElementInfoToJS(env, obj, elementInfo);
166 napi_set_element(env, result, index, obj);
167 index++;
168 }
169 }
170
AttributeNames(napi_env env,napi_callback_info info)171 napi_value NAccessibilityElement::AttributeNames(napi_env env, napi_callback_info info)
172 {
173 HILOG_INFO();
174 size_t argc = ARGS_SIZE_ONE;
175 napi_value argv = nullptr;
176 napi_value thisVar = nullptr;
177 void* data = nullptr;
178 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &argv, &thisVar, &data));
179 HILOG_DEBUG("argc = %{public}d", (int)argc);
180
181 NAccessibilityElementData *callbackInfo = new(std::nothrow) NAccessibilityElementData();
182 if (!callbackInfo) {
183 HILOG_ERROR("Failed to create callbackInfo.");
184 return nullptr;
185 }
186 callbackInfo->env_ = env;
187
188 napi_value promise = nullptr;
189 if (argc > ARGS_SIZE_ONE - 1) {
190 napi_valuetype valueType = napi_null;
191 napi_typeof(env, argv, &valueType);
192 if (valueType == napi_function) {
193 napi_create_reference(env, argv, 1, &callbackInfo->callback_);
194 napi_get_undefined(env, &promise);
195 } else {
196 napi_create_promise(env, &callbackInfo->deferred_, &promise);
197 }
198 } else {
199 napi_create_promise(env, &callbackInfo->deferred_, &promise);
200 }
201
202 AccessibilityElement* accessibilityElement = nullptr;
203 napi_status status = napi_unwrap(env, thisVar, (void**)&accessibilityElement);
204 if (!accessibilityElement || status != napi_ok) {
205 HILOG_ERROR("accessibilityElement is null or status[%{public}d] is wrong", status);
206 return ErrorOperation(callbackInfo);
207 }
208 callbackInfo->accessibilityElement_ = *accessibilityElement;
209
210 napi_value resource = nullptr;
211 napi_create_string_utf8(env, "AttributeNames", NAPI_AUTO_LENGTH, &resource);
212 napi_create_async_work(env, nullptr, resource, [](napi_env env, void* data) {},
213 // Execute the complete function
214 AttributeNamesComplete,
215 reinterpret_cast<void*>(callbackInfo),
216 &callbackInfo->work_);
217 napi_queue_async_work(env, callbackInfo->work_);
218 return promise;
219 }
220
AttributeNamesComplete(napi_env env,napi_status status,void * data)221 void NAccessibilityElement::AttributeNamesComplete(napi_env env, napi_status status, void* data)
222 {
223 HILOG_INFO("AttributeNameComplete execute back");
224 NAccessibilityElementData* callbackInfo = static_cast<NAccessibilityElementData*>(data);
225 napi_value result[ARGS_SIZE_TWO] = {0};
226 napi_value callback = 0;
227 napi_value undefined = 0;
228 napi_get_undefined(env, &undefined);
229 if (!callbackInfo) {
230 HILOG_ERROR("callbackInfo is nullptr");
231 return;
232 }
233
234 napi_create_array(env, &result[1]);
235 if (callbackInfo->accessibilityElement_.isElementInfo_) {
236 HILOG_DEBUG("covert element info to js");
237 ConvertStringVecToJS(env, result[1], ELEMENT_INFO_ATTRIBUTE_NAMES);
238 } else {
239 HILOG_DEBUG("covert window info to js");
240 ConvertStringVecToJS(env, result[1], WINDOW_INFO_ATTRIBUTE_NAMES);
241 }
242
243 if (callbackInfo->callback_) {
244 // Callback mode
245 result[PARAM0] = CreateBusinessError(env, OHOS::Accessibility::RetError::RET_OK);
246 napi_get_reference_value(env, callbackInfo->callback_, &callback);
247 napi_value returnVal;
248 napi_call_function(env, undefined, callback, ARGS_SIZE_TWO, result, &returnVal);
249 napi_delete_reference(env, callbackInfo->callback_);
250 } else {
251 // Promise mode
252 napi_resolve_deferred(env, callbackInfo->deferred_, result[PARAM1]);
253 }
254 napi_delete_async_work(env, callbackInfo->work_);
255 delete callbackInfo;
256 callbackInfo = nullptr;
257 }
258
AttributeValue(napi_env env,napi_callback_info info)259 napi_value NAccessibilityElement::AttributeValue(napi_env env, napi_callback_info info)
260 {
261 size_t argc = ARGS_SIZE_TWO;
262 napi_value argv[ARGS_SIZE_TWO] = {0};
263 napi_value thisVar = nullptr;
264 void* data = nullptr;
265 napi_status status = napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
266 if (status != napi_ok) {
267 HILOG_ERROR("Failed to get cb info");
268 napi_value err = CreateBusinessError(env, RetError::RET_ERR_FAILED);
269 napi_throw(env, err);
270 return nullptr;
271 }
272 HILOG_DEBUG("argc = %{public}d", (int)argc);
273
274 // Unwrap AccessibilityElement
275 AccessibilityElement* accessibilityElement = nullptr;
276 status = napi_unwrap(env, thisVar, (void**)&accessibilityElement);
277 if (!accessibilityElement || status != napi_ok) {
278 HILOG_ERROR("accessibilityElement is null or status[%{public}d] is wrong", status);
279 napi_value err = CreateBusinessError(env, RetError::RET_ERR_NULLPTR);
280 napi_throw(env, err);
281 return nullptr;
282 }
283
284 NAccessibilityElementData *callbackInfo = new(std::nothrow) NAccessibilityElementData();
285 if (!callbackInfo) {
286 HILOG_ERROR("Failed to create callbackInfo.");
287 napi_value err = CreateBusinessError(env, RetError::RET_ERR_NULLPTR);
288 napi_throw(env, err);
289 return nullptr;
290 }
291 callbackInfo->env_ = env;
292 callbackInfo->accessibilityElement_ = *accessibilityElement;
293
294 NAccessibilityErrorCode errCode = NAccessibilityErrorCode::ACCESSIBILITY_OK;
295 if (argc < ARGS_SIZE_TWO - 1) {
296 HILOG_ERROR("argc is invalid: %{public}zu", argc);
297 errCode = NAccessibilityErrorCode::ACCESSIBILITY_ERROR_INVALID_PARAM;
298 }
299
300 if (errCode == NAccessibilityErrorCode::ACCESSIBILITY_OK) {
301 // Parse attribute name
302 std::string attribute = "";
303 if (ParseString(env, attribute, argv[PARAM0])) {
304 HILOG_INFO("attribute = %{public}s", attribute.c_str());
305 callbackInfo->attribute_ = attribute;
306 } else {
307 errCode = NAccessibilityErrorCode::ACCESSIBILITY_ERROR_INVALID_PARAM;
308 }
309 }
310
311 if (errCode == NAccessibilityErrorCode::ACCESSIBILITY_ERROR_INVALID_PARAM) {
312 delete callbackInfo;
313 callbackInfo = nullptr;
314 delete accessibilityElement;
315 accessibilityElement = nullptr;
316 napi_value err = CreateBusinessError(env, RetError::RET_ERR_INVALID_PARAM);
317 HILOG_ERROR("invalid param");
318 napi_throw(env, err);
319 return nullptr;
320 }
321
322 napi_value promise = nullptr;
323 if (argc > ARGS_SIZE_TWO - 1) {
324 napi_valuetype valueType = napi_null;
325 napi_typeof(env, argv[PARAM1], &valueType);
326 if (valueType == napi_function) {
327 napi_create_reference(env, argv[PARAM1], 1, &callbackInfo->callback_);
328 napi_get_undefined(env, &promise);
329 } else {
330 napi_create_promise(env, &callbackInfo->deferred_, &promise);
331 }
332 } else {
333 napi_create_promise(env, &callbackInfo->deferred_, &promise);
334 }
335
336 napi_value resource = nullptr;
337 napi_create_string_utf8(env, "AttributeValue", NAPI_AUTO_LENGTH, &resource);
338 napi_create_async_work(env, nullptr, resource, NAccessibilityElement::AttributeValueExecute,
339 NAccessibilityElement::AttributeValueComplete, reinterpret_cast<void*>(callbackInfo), &callbackInfo->work_);
340 napi_queue_async_work(env, callbackInfo->work_);
341 return promise;
342 }
343
AttributeValueExecute(napi_env env,void * data)344 void NAccessibilityElement::AttributeValueExecute(napi_env env, void* data)
345 {
346 NAccessibilityElementData* callbackInfo = static_cast<NAccessibilityElementData*>(data);
347 if (!callbackInfo) {
348 HILOG_ERROR("callbackInfo is nullptr");
349 return;
350 }
351
352 if (callbackInfo->attribute_ == "parent") {
353 if (callbackInfo->accessibilityElement_.elementInfo_) {
354 callbackInfo->ret_ = AccessibleAbilityClient::GetInstance()->GetParentElementInfo(
355 *callbackInfo->accessibilityElement_.elementInfo_, callbackInfo->nodeInfo_);
356 } else {
357 HILOG_ERROR("elementInfo is nullptr");
358 }
359 } else if (callbackInfo->attribute_ == "children") {
360 if (callbackInfo->accessibilityElement_.elementInfo_) {
361 callbackInfo->ret_ = AccessibleAbilityClient::GetInstance()->GetChildren(
362 *callbackInfo->accessibilityElement_.elementInfo_, callbackInfo->nodeInfos_);
363 } else {
364 HILOG_ERROR("elementInfo is nullptr");
365 }
366 } else if (callbackInfo->attribute_ == "rootElement") {
367 if (callbackInfo->accessibilityElement_.windowInfo_) {
368 callbackInfo->ret_ = AccessibleAbilityClient::GetInstance()->GetRootByWindow(
369 *callbackInfo->accessibilityElement_.windowInfo_, callbackInfo->nodeInfo_);
370 } else {
371 HILOG_ERROR("windowInfo is nullptr");
372 }
373 } else {
374 callbackInfo->ret_ = RET_OK;
375 }
376 HILOG_INFO("attribute[%{public}s], result[%{public}d]", callbackInfo->attribute_.c_str(), callbackInfo->ret_);
377 }
378
AttributeValueComplete(napi_env env,napi_status status,void * data)379 void NAccessibilityElement::AttributeValueComplete(napi_env env, napi_status status, void* data)
380 {
381 NAccessibilityElementData* callbackInfo = static_cast<NAccessibilityElementData*>(data);
382 if (!callbackInfo) {
383 HILOG_ERROR("callbackInfo is nullptr");
384 return;
385 }
386 napi_value result[ARGS_SIZE_TWO] = {0};
387
388 if (callbackInfo->accessibilityElement_.isElementInfo_) {
389 HILOG_DEBUG("It is element info");
390 auto elementIter = elementInfoCompleteMap.find(callbackInfo->attribute_);
391 if (elementIter == elementInfoCompleteMap.end()) {
392 HILOG_ERROR("There is no the attribute[%{public}s] in element info", callbackInfo->attribute_.c_str());
393 napi_get_undefined(callbackInfo->env_, &result[PARAM1]);
394 callbackInfo->ret_ = RET_ERR_PROPERTY_NOT_EXIST;
395 } else {
396 (*elementIter->second)(callbackInfo, result[PARAM1]);
397 }
398 } else {
399 HILOG_DEBUG("It is window info");
400 auto windowIter = windowInfoCompleteMap.find(callbackInfo->attribute_);
401 if (windowIter == windowInfoCompleteMap.end()) {
402 HILOG_ERROR("There is no the attribute[%{public}s]", callbackInfo->attribute_.c_str());
403 napi_get_undefined(callbackInfo->env_, &result[PARAM1]);
404 callbackInfo->ret_ = RET_ERR_PROPERTY_NOT_EXIST;
405 } else {
406 (*windowIter->second)(callbackInfo, result[PARAM1]);
407 }
408 }
409
410 HILOG_DEBUG("result is %{public}d", callbackInfo->ret_);
411 result[PARAM0] = CreateBusinessError(env, callbackInfo->ret_);
412 if (callbackInfo->callback_) {
413 napi_value callback;
414 napi_value returnVal;
415 napi_value undefined;
416 napi_get_reference_value(env, callbackInfo->callback_, &callback);
417 napi_get_undefined(env, &undefined);
418 napi_call_function(env, undefined, callback, ARGS_SIZE_TWO, result, &returnVal);
419 napi_delete_reference(env, callbackInfo->callback_);
420 } else {
421 if (callbackInfo->ret_ == RET_OK) {
422 napi_resolve_deferred(env, callbackInfo->deferred_, result[PARAM1]);
423 } else {
424 napi_reject_deferred(env, callbackInfo->deferred_, result[PARAM0]);
425 }
426 }
427 napi_delete_async_work(env, callbackInfo->work_);
428 delete callbackInfo;
429 callbackInfo = nullptr;
430 }
431
CheckElementInfoParameter(NAccessibilityElementData * callbackInfo,napi_value & value)432 bool NAccessibilityElement::CheckElementInfoParameter(NAccessibilityElementData *callbackInfo, napi_value &value)
433 {
434 if (!callbackInfo) {
435 HILOG_ERROR("callbackInfo is nullptr");
436 return false;
437 }
438 if (!callbackInfo->accessibilityElement_.elementInfo_) {
439 HILOG_ERROR("element info is nullptr");
440 napi_get_undefined(callbackInfo->env_, &value);
441 callbackInfo->ret_ = RET_ERR_FAILED;
442 return false;
443 }
444 return true;
445 }
446
GetElementInfoComponentId(NAccessibilityElementData * callbackInfo,napi_value & value)447 void NAccessibilityElement::GetElementInfoComponentId(NAccessibilityElementData *callbackInfo, napi_value &value)
448 {
449 if (!CheckElementInfoParameter(callbackInfo, value)) {
450 return;
451 }
452 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
453 callbackInfo->accessibilityElement_.elementInfo_->GetAccessibilityId(), &value));
454 }
455
GetElementInfoPageId(NAccessibilityElementData * callbackInfo,napi_value & value)456 void NAccessibilityElement::GetElementInfoPageId(NAccessibilityElementData *callbackInfo, napi_value &value)
457 {
458 if (!CheckElementInfoParameter(callbackInfo, value)) {
459 return;
460 }
461 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
462 callbackInfo->accessibilityElement_.elementInfo_->GetPageId(), &value));
463 }
464
GetElementInfoInspectorKey(NAccessibilityElementData * callbackInfo,napi_value & value)465 void NAccessibilityElement::GetElementInfoInspectorKey(NAccessibilityElementData *callbackInfo, napi_value &value)
466 {
467 if (!CheckElementInfoParameter(callbackInfo, value)) {
468 return;
469 }
470 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
471 callbackInfo->accessibilityElement_.elementInfo_->GetInspectorKey().c_str(), NAPI_AUTO_LENGTH, &value));
472 }
473
GetElementInfoBundleName(NAccessibilityElementData * callbackInfo,napi_value & value)474 void NAccessibilityElement::GetElementInfoBundleName(NAccessibilityElementData *callbackInfo, napi_value &value)
475 {
476 if (!CheckElementInfoParameter(callbackInfo, value)) {
477 return;
478 }
479 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
480 callbackInfo->accessibilityElement_.elementInfo_->GetBundleName().c_str(), NAPI_AUTO_LENGTH, &value));
481 }
482
GetElementInfoComponentType(NAccessibilityElementData * callbackInfo,napi_value & value)483 void NAccessibilityElement::GetElementInfoComponentType(NAccessibilityElementData *callbackInfo, napi_value &value)
484 {
485 if (!CheckElementInfoParameter(callbackInfo, value)) {
486 return;
487 }
488 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
489 callbackInfo->accessibilityElement_.elementInfo_->GetComponentType().c_str(), NAPI_AUTO_LENGTH, &value));
490 }
491
GetElementInfoInputType(NAccessibilityElementData * callbackInfo,napi_value & value)492 void NAccessibilityElement::GetElementInfoInputType(NAccessibilityElementData *callbackInfo, napi_value &value)
493 {
494 if (!CheckElementInfoParameter(callbackInfo, value)) {
495 return;
496 }
497 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
498 callbackInfo->accessibilityElement_.elementInfo_->GetInputType(), &value));
499 }
500
GetElementInfoText(NAccessibilityElementData * callbackInfo,napi_value & value)501 void NAccessibilityElement::GetElementInfoText(NAccessibilityElementData *callbackInfo, napi_value &value)
502 {
503 if (!CheckElementInfoParameter(callbackInfo, value)) {
504 return;
505 }
506 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
507 callbackInfo->accessibilityElement_.elementInfo_->GetContent().c_str(), NAPI_AUTO_LENGTH, &value));
508 }
509
GetElementInfoHintText(NAccessibilityElementData * callbackInfo,napi_value & value)510 void NAccessibilityElement::GetElementInfoHintText(NAccessibilityElementData *callbackInfo, napi_value &value)
511 {
512 if (!CheckElementInfoParameter(callbackInfo, value)) {
513 return;
514 }
515 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
516 callbackInfo->accessibilityElement_.elementInfo_->GetHint().c_str(), NAPI_AUTO_LENGTH, &value));
517 }
518
GetElementInfoDescription(NAccessibilityElementData * callbackInfo,napi_value & value)519 void NAccessibilityElement::GetElementInfoDescription(NAccessibilityElementData *callbackInfo, napi_value &value)
520 {
521 if (!CheckElementInfoParameter(callbackInfo, value)) {
522 return;
523 }
524 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
525 callbackInfo->accessibilityElement_.elementInfo_->GetDescriptionInfo().c_str(), NAPI_AUTO_LENGTH, &value));
526 }
527
GetElementInfoResourceName(NAccessibilityElementData * callbackInfo,napi_value & value)528 void NAccessibilityElement::GetElementInfoResourceName(NAccessibilityElementData *callbackInfo, napi_value &value)
529 {
530 if (!CheckElementInfoParameter(callbackInfo, value)) {
531 return;
532 }
533 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
534 callbackInfo->accessibilityElement_.elementInfo_->GetComponentResourceId().c_str(), NAPI_AUTO_LENGTH, &value));
535 }
536
GetElementInfoTextLengthLimit(NAccessibilityElementData * callbackInfo,napi_value & value)537 void NAccessibilityElement::GetElementInfoTextLengthLimit(NAccessibilityElementData *callbackInfo, napi_value &value)
538 {
539 if (!CheckElementInfoParameter(callbackInfo, value)) {
540 return;
541 }
542 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
543 callbackInfo->accessibilityElement_.elementInfo_->GetTextLengthLimit(), &value));
544 }
545
GetElementInfoRect(NAccessibilityElementData * callbackInfo,napi_value & value)546 void NAccessibilityElement::GetElementInfoRect(NAccessibilityElementData *callbackInfo, napi_value &value)
547 {
548 if (!CheckElementInfoParameter(callbackInfo, value)) {
549 return;
550 }
551 OHOS::Accessibility::Rect screenRect = callbackInfo->accessibilityElement_.elementInfo_->GetRectInScreen();
552 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_object(callbackInfo->env_, &value));
553 ConvertRectToJS(callbackInfo->env_, value, screenRect);
554 }
555
GetElementInfoCheckable(NAccessibilityElementData * callbackInfo,napi_value & value)556 void NAccessibilityElement::GetElementInfoCheckable(NAccessibilityElementData *callbackInfo, napi_value &value)
557 {
558 if (!CheckElementInfoParameter(callbackInfo, value)) {
559 return;
560 }
561 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
562 callbackInfo->accessibilityElement_.elementInfo_->IsCheckable(), &value));
563 }
564
GetElementInfoChecked(NAccessibilityElementData * callbackInfo,napi_value & value)565 void NAccessibilityElement::GetElementInfoChecked(NAccessibilityElementData *callbackInfo, napi_value &value)
566 {
567 if (!CheckElementInfoParameter(callbackInfo, value)) {
568 return;
569 }
570 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
571 callbackInfo->accessibilityElement_.elementInfo_->IsChecked(), &value));
572 }
573
GetElementInfoFocusable(NAccessibilityElementData * callbackInfo,napi_value & value)574 void NAccessibilityElement::GetElementInfoFocusable(NAccessibilityElementData *callbackInfo, napi_value &value)
575 {
576 if (!CheckElementInfoParameter(callbackInfo, value)) {
577 return;
578 }
579 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
580 callbackInfo->accessibilityElement_.elementInfo_->IsFocusable(), &value));
581 }
582
GetElementInfoIsVisible(NAccessibilityElementData * callbackInfo,napi_value & value)583 void NAccessibilityElement::GetElementInfoIsVisible(NAccessibilityElementData *callbackInfo, napi_value &value)
584 {
585 if (!CheckElementInfoParameter(callbackInfo, value)) {
586 return;
587 }
588 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
589 callbackInfo->accessibilityElement_.elementInfo_->IsVisible(), &value));
590 }
591
GetElementInfoAccessibilityFocused(NAccessibilityElementData * callbackInfo,napi_value & value)592 void NAccessibilityElement::GetElementInfoAccessibilityFocused(
593 NAccessibilityElementData *callbackInfo, napi_value &value)
594 {
595 if (!CheckElementInfoParameter(callbackInfo, value)) {
596 return;
597 }
598 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
599 callbackInfo->accessibilityElement_.elementInfo_->HasAccessibilityFocus(), &value));
600 }
601
GetElementInfoSelected(NAccessibilityElementData * callbackInfo,napi_value & value)602 void NAccessibilityElement::GetElementInfoSelected(NAccessibilityElementData *callbackInfo, napi_value &value)
603 {
604 if (!CheckElementInfoParameter(callbackInfo, value)) {
605 return;
606 }
607 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
608 callbackInfo->accessibilityElement_.elementInfo_->IsSelected(), &value));
609 }
610
GetElementInfoClickable(NAccessibilityElementData * callbackInfo,napi_value & value)611 void NAccessibilityElement::GetElementInfoClickable(NAccessibilityElementData *callbackInfo, napi_value &value)
612 {
613 if (!CheckElementInfoParameter(callbackInfo, value)) {
614 return;
615 }
616 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
617 callbackInfo->accessibilityElement_.elementInfo_->IsClickable(), &value));
618 }
619
GetElementInfoLongClickable(NAccessibilityElementData * callbackInfo,napi_value & value)620 void NAccessibilityElement::GetElementInfoLongClickable(NAccessibilityElementData *callbackInfo, napi_value &value)
621 {
622 if (!CheckElementInfoParameter(callbackInfo, value)) {
623 return;
624 }
625 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
626 callbackInfo->accessibilityElement_.elementInfo_->IsLongClickable(), &value));
627 }
628
GetElementInfoIsEnable(NAccessibilityElementData * callbackInfo,napi_value & value)629 void NAccessibilityElement::GetElementInfoIsEnable(NAccessibilityElementData *callbackInfo, napi_value &value)
630 {
631 if (!CheckElementInfoParameter(callbackInfo, value)) {
632 return;
633 }
634 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
635 callbackInfo->accessibilityElement_.elementInfo_->IsEnabled(), &value));
636 }
637
GetElementInfoIsPassword(NAccessibilityElementData * callbackInfo,napi_value & value)638 void NAccessibilityElement::GetElementInfoIsPassword(NAccessibilityElementData *callbackInfo, napi_value &value)
639 {
640 if (!CheckElementInfoParameter(callbackInfo, value)) {
641 return;
642 }
643 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
644 callbackInfo->accessibilityElement_.elementInfo_->IsPassword(), &value));
645 }
646
GetElementInfoScrollable(NAccessibilityElementData * callbackInfo,napi_value & value)647 void NAccessibilityElement::GetElementInfoScrollable(NAccessibilityElementData *callbackInfo, napi_value &value)
648 {
649 if (!CheckElementInfoParameter(callbackInfo, value)) {
650 return;
651 }
652 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
653 callbackInfo->accessibilityElement_.elementInfo_->IsScrollable(), &value));
654 }
655
GetElementInfoEditable(NAccessibilityElementData * callbackInfo,napi_value & value)656 void NAccessibilityElement::GetElementInfoEditable(NAccessibilityElementData *callbackInfo, napi_value &value)
657 {
658 if (!CheckElementInfoParameter(callbackInfo, value)) {
659 return;
660 }
661 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
662 callbackInfo->accessibilityElement_.elementInfo_->IsEditable(), &value));
663 }
664
GetElementInfoPluralLineSupported(NAccessibilityElementData * callbackInfo,napi_value & value)665 void NAccessibilityElement::GetElementInfoPluralLineSupported(
666 NAccessibilityElementData *callbackInfo, napi_value &value)
667 {
668 if (!CheckElementInfoParameter(callbackInfo, value)) {
669 return;
670 }
671 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
672 callbackInfo->accessibilityElement_.elementInfo_->IsPluraLineSupported(), &value));
673 }
674
GetElementInfoIsHint(NAccessibilityElementData * callbackInfo,napi_value & value)675 void NAccessibilityElement::GetElementInfoIsHint(NAccessibilityElementData *callbackInfo, napi_value &value)
676 {
677 if (!CheckElementInfoParameter(callbackInfo, value)) {
678 return;
679 }
680 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
681 callbackInfo->accessibilityElement_.elementInfo_->IsGivingHint(), &value));
682 }
683
GetElementInfoItemCount(NAccessibilityElementData * callbackInfo,napi_value & value)684 void NAccessibilityElement::GetElementInfoItemCount(NAccessibilityElementData *callbackInfo, napi_value &value)
685 {
686 if (!CheckElementInfoParameter(callbackInfo, value)) {
687 return;
688 }
689 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
690 callbackInfo->accessibilityElement_.elementInfo_->GetItemCounts(), &value));
691 }
692
GetElementInfoCurrentIndex(NAccessibilityElementData * callbackInfo,napi_value & value)693 void NAccessibilityElement::GetElementInfoCurrentIndex(NAccessibilityElementData *callbackInfo, napi_value &value)
694 {
695 if (!CheckElementInfoParameter(callbackInfo, value)) {
696 return;
697 }
698 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
699 callbackInfo->accessibilityElement_.elementInfo_->GetCurrentIndex(), &value));
700 }
701
GetElementInfoStartIndex(NAccessibilityElementData * callbackInfo,napi_value & value)702 void NAccessibilityElement::GetElementInfoStartIndex(NAccessibilityElementData *callbackInfo, napi_value &value)
703 {
704 if (!CheckElementInfoParameter(callbackInfo, value)) {
705 return;
706 }
707 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
708 callbackInfo->accessibilityElement_.elementInfo_->GetBeginIndex(), &value));
709 }
710
GetElementInfoEndIndex(NAccessibilityElementData * callbackInfo,napi_value & value)711 void NAccessibilityElement::GetElementInfoEndIndex(NAccessibilityElementData *callbackInfo, napi_value &value)
712 {
713 if (!CheckElementInfoParameter(callbackInfo, value)) {
714 return;
715 }
716 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
717 callbackInfo->accessibilityElement_.elementInfo_->GetEndIndex(), &value));
718 }
719
GetElementInfoValueMax(NAccessibilityElementData * callbackInfo,napi_value & value)720 void NAccessibilityElement::GetElementInfoValueMax(NAccessibilityElementData *callbackInfo, napi_value &value)
721 {
722 if (!CheckElementInfoParameter(callbackInfo, value)) {
723 return;
724 }
725 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
726 callbackInfo->accessibilityElement_.elementInfo_->GetRange().GetMax(), &value));
727 }
728
GetElementInfoValueMin(NAccessibilityElementData * callbackInfo,napi_value & value)729 void NAccessibilityElement::GetElementInfoValueMin(NAccessibilityElementData *callbackInfo, napi_value &value)
730 {
731 if (!CheckElementInfoParameter(callbackInfo, value)) {
732 return;
733 }
734 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
735 callbackInfo->accessibilityElement_.elementInfo_->GetRange().GetMin(), &value));
736 }
737
GetElementInfoValueNow(NAccessibilityElementData * callbackInfo,napi_value & value)738 void NAccessibilityElement::GetElementInfoValueNow(NAccessibilityElementData *callbackInfo, napi_value &value)
739 {
740 if (!CheckElementInfoParameter(callbackInfo, value)) {
741 return;
742 }
743 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
744 callbackInfo->accessibilityElement_.elementInfo_->GetRange().GetCurrent(), &value));
745 }
746
GetElementInfoError(NAccessibilityElementData * callbackInfo,napi_value & value)747 void NAccessibilityElement::GetElementInfoError(NAccessibilityElementData *callbackInfo, napi_value &value)
748 {
749 if (!CheckElementInfoParameter(callbackInfo, value)) {
750 return;
751 }
752 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
753 callbackInfo->accessibilityElement_.elementInfo_->GetError().c_str(), NAPI_AUTO_LENGTH, &value));
754 }
755
GetElementInfoTextMoveUnit(NAccessibilityElementData * callbackInfo,napi_value & value)756 void NAccessibilityElement::GetElementInfoTextMoveUnit(NAccessibilityElementData *callbackInfo, napi_value &value)
757 {
758 if (!CheckElementInfoParameter(callbackInfo, value)) {
759 return;
760 }
761 std::string textMoveUnit = ConvertTextMoveUnitToString(
762 callbackInfo->accessibilityElement_.elementInfo_->GetTextMovementStep());
763 HILOG_DEBUG("ConvertTextMoveUnitToString: [%{public}s]", textMoveUnit.c_str());
764 if (textMoveUnit == "") {
765 callbackInfo->ret_ = RET_ERR_FAILED;
766 napi_get_undefined(callbackInfo->env_, &value);
767 } else {
768 callbackInfo->ret_ = RET_OK;
769 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
770 textMoveUnit.c_str(), NAPI_AUTO_LENGTH, &value));
771 }
772 }
773
GetElementInfoParent(NAccessibilityElementData * callbackInfo,napi_value & value)774 void NAccessibilityElement::GetElementInfoParent(NAccessibilityElementData *callbackInfo, napi_value &value)
775 {
776 if (!CheckElementInfoParameter(callbackInfo, value)) {
777 return;
778 }
779 if (callbackInfo->ret_ == RET_OK) {
780 napi_value constructor = nullptr;
781 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_reference_value(callbackInfo->env_,
782 NAccessibilityElement::consRef_, &constructor));
783 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_new_instance(callbackInfo->env_,
784 constructor, 0, nullptr, &value));
785 ConvertElementInfoToJS(callbackInfo->env_, value, callbackInfo->nodeInfo_);
786 } else {
787 HILOG_ERROR("GetElementInfoParent failed!");
788 napi_get_undefined(callbackInfo->env_, &value);
789 }
790 }
791
GetElementInfoChildren(NAccessibilityElementData * callbackInfo,napi_value & value)792 void NAccessibilityElement::GetElementInfoChildren(NAccessibilityElementData *callbackInfo, napi_value &value)
793 {
794 if (!CheckElementInfoParameter(callbackInfo, value)) {
795 return;
796 }
797 if (callbackInfo->ret_ == RET_OK) {
798 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_array(callbackInfo->env_, &value));
799 ConvertElementInfosToJS(callbackInfo->env_, value, callbackInfo->nodeInfos_);
800 } else {
801 HILOG_ERROR("GetElementInfoChildren failed!");
802 napi_get_undefined(callbackInfo->env_, &value);
803 }
804 }
805
GetElementInfoTriggerAction(NAccessibilityElementData * callbackInfo,napi_value & value)806 void NAccessibilityElement::GetElementInfoTriggerAction(NAccessibilityElementData *callbackInfo, napi_value &value)
807 {
808 if (!CheckElementInfoParameter(callbackInfo, value)) {
809 return;
810 }
811 std::string triggerAction = ConvertOperationTypeToString(
812 callbackInfo->accessibilityElement_.elementInfo_->GetTriggerAction());
813 HILOG_DEBUG("GetElementInfoTriggerAction: [%{public}s]", triggerAction.c_str());
814 if (triggerAction == "") {
815 callbackInfo->ret_ = RET_ERR_FAILED;
816 napi_get_undefined(callbackInfo->env_, &value);
817 } else {
818 callbackInfo->ret_ = RET_OK;
819 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
820 triggerAction.c_str(), NAPI_AUTO_LENGTH, &value));
821 }
822 }
823
GetElementInfoContents(NAccessibilityElementData * callbackInfo,napi_value & value)824 void NAccessibilityElement::GetElementInfoContents(NAccessibilityElementData *callbackInfo, napi_value &value)
825 {
826 if (!CheckElementInfoParameter(callbackInfo, value)) {
827 return;
828 }
829 std::vector<std::string> contents {};
830 callbackInfo->accessibilityElement_.elementInfo_->GetContentList(contents);
831 HILOG_DEBUG("contents size: [%{public}zu]", contents.size());
832
833 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_array(callbackInfo->env_, &value));
834 size_t index = 0;
835 for (auto& content : contents) {
836 napi_value nContent = nullptr;
837 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
838 content.c_str(), NAPI_AUTO_LENGTH, &nContent));
839 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_set_element(callbackInfo->env_, value, index, nContent));
840 index++;
841 }
842 }
843
GetElementInfoLastContent(NAccessibilityElementData * callbackInfo,napi_value & value)844 void NAccessibilityElement::GetElementInfoLastContent(NAccessibilityElementData *callbackInfo, napi_value &value)
845 {
846 if (!CheckElementInfoParameter(callbackInfo, value)) {
847 return;
848 }
849 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
850 callbackInfo->accessibilityElement_.elementInfo_->GetLatestContent().c_str(), NAPI_AUTO_LENGTH, &value));
851 }
852
GetElementInfoWindowId(NAccessibilityElementData * callbackInfo,napi_value & value)853 void NAccessibilityElement::GetElementInfoWindowId(NAccessibilityElementData *callbackInfo, napi_value &value)
854 {
855 if (!CheckElementInfoParameter(callbackInfo, value)) {
856 return;
857 }
858 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
859 callbackInfo->accessibilityElement_.elementInfo_->GetWindowId(), &value));
860 }
861
GetElementInfoIsFocused(NAccessibilityElementData * callbackInfo,napi_value & value)862 void NAccessibilityElement::GetElementInfoIsFocused(NAccessibilityElementData *callbackInfo, napi_value &value)
863 {
864 if (!CheckElementInfoParameter(callbackInfo, value)) {
865 return;
866 }
867 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
868 callbackInfo->accessibilityElement_.elementInfo_->IsFocused(), &value));
869 }
870
CheckWindowInfoParameter(NAccessibilityElementData * callbackInfo,napi_value & value)871 bool NAccessibilityElement::CheckWindowInfoParameter(NAccessibilityElementData *callbackInfo, napi_value &value)
872 {
873 if (!callbackInfo) {
874 HILOG_ERROR("callbackInfo is nullptr");
875 return false;
876 }
877 if (!callbackInfo->accessibilityElement_.windowInfo_) {
878 HILOG_ERROR("window info is nullptr");
879 napi_get_undefined(callbackInfo->env_, &value);
880 callbackInfo->ret_ = RET_ERR_FAILED;
881 return false;
882 }
883 return true;
884 }
885
GetWindowInfoIsActive(NAccessibilityElementData * callbackInfo,napi_value & value)886 void NAccessibilityElement::GetWindowInfoIsActive(NAccessibilityElementData *callbackInfo, napi_value &value)
887 {
888 if (!CheckWindowInfoParameter(callbackInfo, value)) {
889 return;
890 }
891 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
892 callbackInfo->accessibilityElement_.windowInfo_->IsActive(), &value));
893 }
894
GetWindowInfoScreenRect(NAccessibilityElementData * callbackInfo,napi_value & value)895 void NAccessibilityElement::GetWindowInfoScreenRect(NAccessibilityElementData *callbackInfo, napi_value &value)
896 {
897 if (!CheckWindowInfoParameter(callbackInfo, value)) {
898 return;
899 }
900 OHOS::Accessibility::Rect screenRect = callbackInfo->accessibilityElement_.windowInfo_->GetRectInScreen();
901 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_object(callbackInfo->env_, &value));
902 ConvertRectToJS(callbackInfo->env_, value, screenRect);
903 }
904
GetWindowInfoLayer(NAccessibilityElementData * callbackInfo,napi_value & value)905 void NAccessibilityElement::GetWindowInfoLayer(NAccessibilityElementData *callbackInfo, napi_value &value)
906 {
907 if (!CheckWindowInfoParameter(callbackInfo, value)) {
908 return;
909 }
910 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
911 callbackInfo->accessibilityElement_.windowInfo_->GetWindowLayer(), &value));
912 }
913
GetWindowInfoType(NAccessibilityElementData * callbackInfo,napi_value & value)914 void NAccessibilityElement::GetWindowInfoType(NAccessibilityElementData *callbackInfo, napi_value &value)
915 {
916 if (!CheckWindowInfoParameter(callbackInfo, value)) {
917 return;
918 }
919 std::string accessibilityWindowType = ConvertWindowTypeToString(
920 callbackInfo->accessibilityElement_.windowInfo_->GetAccessibilityWindowType());
921 HILOG_DEBUG("GetWindowInfoType: [%{public}s]", accessibilityWindowType.c_str());
922 if (accessibilityWindowType == "") {
923 callbackInfo->ret_ = RET_ERR_FAILED;
924 napi_get_undefined(callbackInfo->env_, &value);
925 } else {
926 callbackInfo->ret_ = RET_OK;
927 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_string_utf8(callbackInfo->env_,
928 accessibilityWindowType.c_str(), NAPI_AUTO_LENGTH, &value));
929 }
930 }
931
GetWindowInfoRootElement(NAccessibilityElementData * callbackInfo,napi_value & value)932 void NAccessibilityElement::GetWindowInfoRootElement(NAccessibilityElementData *callbackInfo, napi_value &value)
933 {
934 if (!CheckWindowInfoParameter(callbackInfo, value)) {
935 return;
936 }
937 if (callbackInfo->ret_ == RET_OK) {
938 napi_value constructor = nullptr;
939 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_reference_value(callbackInfo->env_,
940 NAccessibilityElement::consRef_, &constructor));
941 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_new_instance(callbackInfo->env_,
942 constructor, 0, nullptr, &value));
943 ConvertElementInfoToJS(callbackInfo->env_, value, callbackInfo->nodeInfo_);
944 } else {
945 HILOG_ERROR("GetWindowInfoRootElement failed!");
946 napi_get_undefined(callbackInfo->env_, &value);
947 }
948 }
949
GetWindowInfoIsFocused(NAccessibilityElementData * callbackInfo,napi_value & value)950 void NAccessibilityElement::GetWindowInfoIsFocused(NAccessibilityElementData *callbackInfo, napi_value &value)
951 {
952 if (!CheckWindowInfoParameter(callbackInfo, value)) {
953 return;
954 }
955 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_get_boolean(callbackInfo->env_,
956 callbackInfo->accessibilityElement_.windowInfo_->IsFocused(), &value));
957 }
958
GetWindowInfoWindowId(NAccessibilityElementData * callbackInfo,napi_value & value)959 void NAccessibilityElement::GetWindowInfoWindowId(NAccessibilityElementData *callbackInfo, napi_value &value)
960 {
961 if (!CheckWindowInfoParameter(callbackInfo, value)) {
962 return;
963 }
964 NAPI_CALL_RETURN_VOID(callbackInfo->env_, napi_create_int32(callbackInfo->env_,
965 callbackInfo->accessibilityElement_.windowInfo_->GetWindowId(), &value));
966 }
967
ActionNames(napi_env env,napi_callback_info info)968 napi_value NAccessibilityElement::ActionNames(napi_env env, napi_callback_info info)
969 {
970 HILOG_INFO();
971 size_t argc = ARGS_SIZE_ONE;
972 napi_value argv = nullptr;
973 napi_value thisVar = nullptr;
974 void* data = nullptr;
975 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &argv, &thisVar, &data));
976 HILOG_DEBUG("argc = %{public}zu", argc);
977
978 NAccessibilityElementData *callbackInfo = new(std::nothrow) NAccessibilityElementData();
979 if (!callbackInfo) {
980 HILOG_ERROR("Failed to create callbackInfo.");
981 return nullptr;
982 }
983 callbackInfo->env_ = env;
984
985 napi_value promise = nullptr;
986 if (argc > ARGS_SIZE_ONE - 1) {
987 napi_valuetype valueType = napi_null;
988 napi_typeof(env, argv, &valueType);
989 if (valueType == napi_function) {
990 napi_create_reference(env, argv, 1, &callbackInfo->callback_);
991 napi_get_undefined(env, &promise);
992 } else {
993 napi_create_promise(env, &callbackInfo->deferred_, &promise);
994 }
995 } else {
996 napi_create_promise(env, &callbackInfo->deferred_, &promise);
997 }
998
999 AccessibilityElement* accessibilityElement = nullptr;
1000 napi_status status = napi_unwrap(env, thisVar, (void**)&accessibilityElement);
1001 if (!accessibilityElement || status != napi_ok) {
1002 HILOG_ERROR("accessibilityElement is null or status[%{public}d] is wrong", status);
1003 return ErrorOperation(callbackInfo);
1004 }
1005 callbackInfo->accessibilityElement_ = *accessibilityElement;
1006 if (!callbackInfo->accessibilityElement_.isElementInfo_) {
1007 HILOG_ERROR("it is not element info");
1008 return ErrorOperation(callbackInfo);
1009 }
1010
1011 napi_value resource = nullptr;
1012 napi_create_string_utf8(env, "ActionNames", NAPI_AUTO_LENGTH, &resource);
1013
1014 napi_create_async_work(env, nullptr, resource, [](napi_env env, void* data) {},
1015 // Execute the complete function
1016 ActionNamesComplete,
1017 reinterpret_cast<void*>(callbackInfo),
1018 &callbackInfo->work_);
1019 napi_queue_async_work(env, callbackInfo->work_);
1020 return promise;
1021 }
1022
ActionNamesComplete(napi_env env,napi_status status,void * data)1023 void NAccessibilityElement::ActionNamesComplete(napi_env env, napi_status status, void* data)
1024 {
1025 HILOG_DEBUG("ActionNamesComplete execute back");
1026 NAccessibilityElementData* callbackInfo = static_cast<NAccessibilityElementData*>(data);
1027 napi_value result[ARGS_SIZE_TWO] = {0};
1028 napi_value callback = 0;
1029 napi_value undefined = 0;
1030 napi_get_undefined(env, &undefined);
1031 if (!callbackInfo) {
1032 HILOG_ERROR("callbackInfo is nullptr");
1033 return;
1034 }
1035
1036 if (callbackInfo->accessibilityElement_.elementInfo_) {
1037 std::vector<std::string> actionNames {};
1038 std::vector<AccessibleAction> operations =
1039 callbackInfo->accessibilityElement_.elementInfo_->GetActionList();
1040 HILOG_DEBUG("action list size is %{public}zu", operations.size());
1041 actionNames.resize(operations.size());
1042 std::transform(operations.begin(), operations.end(), actionNames.begin(),
1043 [](const AccessibleAction operation) {
1044 return ConvertOperationTypeToString(operation.GetActionType());
1045 });
1046 napi_create_array(env, &result[PARAM1]);
1047 ConvertStringVecToJS(env, result[PARAM1], actionNames);
1048 callbackInfo->ret_ = RET_OK;
1049 } else {
1050 HILOG_ERROR("no elementInfo_");
1051 callbackInfo->ret_ = RET_ERR_FAILED;
1052 napi_get_undefined(env, &result[PARAM1]);
1053 }
1054
1055 result[PARAM0] = CreateBusinessError(env, callbackInfo->ret_);
1056 if (callbackInfo->callback_) {
1057 // Callback mode
1058 napi_get_reference_value(env, callbackInfo->callback_, &callback);
1059 napi_value returnVal;
1060 napi_call_function(env, undefined, callback, ARGS_SIZE_TWO, result, &returnVal);
1061 napi_delete_reference(env, callbackInfo->callback_);
1062 } else {
1063 // Promise mode
1064 if (callbackInfo->accessibilityElement_.elementInfo_) {
1065 napi_resolve_deferred(env, callbackInfo->deferred_, result[PARAM1]);
1066 } else {
1067 napi_reject_deferred(env, callbackInfo->deferred_, result[PARAM0]);
1068 }
1069 }
1070 napi_delete_async_work(env, callbackInfo->work_);
1071 delete callbackInfo;
1072 callbackInfo = nullptr;
1073 }
1074
PerformAction(napi_env env,napi_callback_info info)1075 napi_value NAccessibilityElement::PerformAction(napi_env env, napi_callback_info info)
1076 {
1077 size_t argc = ARGS_SIZE_THREE;
1078 napi_value argv[ARGS_SIZE_THREE] = {0};
1079 napi_value thisVar;
1080 void* data = nullptr;
1081 napi_status status = napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1082 if (status != napi_ok) {
1083 HILOG_ERROR("Failed to get cb info");
1084 napi_value err = CreateBusinessError(env, RetError::RET_ERR_FAILED);
1085 napi_throw(env, err);
1086 return nullptr;
1087 }
1088 HILOG_DEBUG("argc = %{public}zu", argc);
1089
1090 // Unwrap AccessibilityElement
1091 AccessibilityElement* accessibilityElement = nullptr;
1092 status = napi_unwrap(env, thisVar, (void**)&accessibilityElement);
1093 if (!accessibilityElement || status != napi_ok) {
1094 HILOG_ERROR("accessibilityElement is null or status[%{public}d] is wrong", status);
1095 napi_value err = CreateBusinessError(env, RetError::RET_ERR_NULLPTR);
1096 napi_throw(env, err);
1097 return nullptr;
1098 }
1099 if (!(accessibilityElement->isElementInfo_ && accessibilityElement->elementInfo_)) {
1100 HILOG_ERROR("accessibilityElement is wrong. isElementInfo_[%{public}d]", accessibilityElement->isElementInfo_);
1101 napi_value err = CreateBusinessError(env, RetError::RET_ERR_FAILED);
1102 napi_throw(env, err);
1103 return nullptr;
1104 }
1105
1106 NAccessibilityElementData *callbackInfo = new(std::nothrow) NAccessibilityElementData();
1107 if (!callbackInfo) {
1108 HILOG_ERROR("Failed to create callbackInfo.");
1109 napi_value err = CreateBusinessError(env, RetError::RET_ERR_NULLPTR);
1110 napi_throw(env, err);
1111 return nullptr;
1112 }
1113 callbackInfo->env_ = env;
1114
1115 NAccessibilityErrorCode errCode = NAccessibilityErrorCode::ACCESSIBILITY_OK;
1116 if (argc < ARGS_SIZE_ONE) {
1117 HILOG_ERROR("argc is invalid: %{public}zu", argc);
1118 errCode = NAccessibilityErrorCode::ACCESSIBILITY_ERROR_INVALID_PARAM;
1119 }
1120
1121 std::string actionName;
1122 if (errCode == NAccessibilityErrorCode::ACCESSIBILITY_OK) {
1123 if (!ParseString(env, actionName, argv[PARAM0])) {
1124 HILOG_ERROR("parse action name failed");
1125 errCode = NAccessibilityErrorCode::ACCESSIBILITY_ERROR_INVALID_PARAM;
1126 }
1127 }
1128
1129 if (errCode == NAccessibilityErrorCode::ACCESSIBILITY_ERROR_INVALID_PARAM) {
1130 delete callbackInfo;
1131 callbackInfo = nullptr;
1132 delete accessibilityElement;
1133 accessibilityElement = nullptr;
1134 napi_value err = CreateBusinessError(env, RetError::RET_ERR_INVALID_PARAM);
1135 HILOG_ERROR("invalid param");
1136 napi_throw(env, err);
1137 return nullptr;
1138 }
1139
1140 napi_value promise = nullptr;
1141 std::map<std::string, std::string> actionArguments {};
1142 if (argc >= ARGS_SIZE_THREE) {
1143 napi_valuetype secondParamType = napi_null;
1144 napi_typeof(env, argv[PARAM1], &secondParamType);
1145 napi_valuetype thirdParamType = napi_null;
1146 napi_typeof(env, argv[PARAM2], &thirdParamType);
1147 if (secondParamType == napi_object && thirdParamType == napi_function) {
1148 ConvertActionArgsJSToNAPI(env, argv[PARAM1], actionArguments,
1149 ConvertStringToAccessibleOperationType(actionName));
1150 napi_create_reference(env, argv[PARAM2], 1, &callbackInfo->callback_);
1151 napi_get_undefined(env, &promise);
1152 } else if (thirdParamType == napi_function) {
1153 napi_create_reference(env, argv[PARAM2], 1, &callbackInfo->callback_);
1154 napi_get_undefined(env, &promise);
1155 } else if (secondParamType == napi_function) {
1156 napi_create_reference(env, argv[PARAM1], 1, &callbackInfo->callback_);
1157 napi_get_undefined(env, &promise);
1158 } else {
1159 HILOG_INFO("argc is three, use promise");
1160 napi_create_promise(env, &callbackInfo->deferred_, &promise);
1161 }
1162 } else if (argc == ARGS_SIZE_TWO) {
1163 napi_valuetype valueType = napi_null;
1164 napi_typeof(env, argv[PARAM1], &valueType);
1165 if (valueType == napi_function) {
1166 napi_create_reference(env, argv[PARAM1], 1, &callbackInfo->callback_);
1167 napi_get_undefined(env, &promise);
1168 } else {
1169 if (valueType == napi_object) {
1170 ConvertActionArgsJSToNAPI(env, argv[PARAM1], actionArguments,
1171 ConvertStringToAccessibleOperationType(actionName));
1172 }
1173 HILOG_INFO("argc is two, use promise");
1174 napi_create_promise(env, &callbackInfo->deferred_, &promise);
1175 }
1176 } else {
1177 HILOG_INFO("argc is others, use promise");
1178 napi_create_promise(env, &callbackInfo->deferred_, &promise);
1179 }
1180
1181 HILOG_INFO("actionName = %{public}s", actionName.c_str());
1182 callbackInfo->accessibilityElement_ = *accessibilityElement;
1183 callbackInfo->actionName_ = actionName;
1184 callbackInfo->actionArguments_ = actionArguments;
1185
1186 napi_value resource = nullptr;
1187 napi_create_string_utf8(env, "PerformAction", NAPI_AUTO_LENGTH, &resource);
1188 napi_create_async_work(env, nullptr, resource, PerformActionExecute, PerformActionComplete,
1189 reinterpret_cast<void*>(callbackInfo), &callbackInfo->work_);
1190 napi_queue_async_work(env, callbackInfo->work_);
1191 return promise;
1192 }
1193
PerformActionExecute(napi_env env,void * data)1194 void NAccessibilityElement::PerformActionExecute(napi_env env, void* data)
1195 {
1196 HILOG_DEBUG("PerformActionExecute");
1197 NAccessibilityElementData *callbackInfo = static_cast<NAccessibilityElementData*>(data);
1198 if (!callbackInfo) {
1199 HILOG_ERROR("callbackInfo is nullptr");
1200 return;
1201 }
1202
1203 ActionType action = ConvertStringToAccessibleOperationType(callbackInfo->actionName_);
1204 if (action == ActionType::ACCESSIBILITY_ACTION_INVALID) {
1205 HILOG_ERROR("The action is not supported");
1206 callbackInfo->ret_ = OHOS::Accessibility::RetError::RET_ERR_ACTION_NOT_SUPPORT;
1207 return;
1208 }
1209 callbackInfo->ret_ = AccessibleAbilityClient::GetInstance()->ExecuteAction(
1210 *callbackInfo->accessibilityElement_.elementInfo_, action, callbackInfo->actionArguments_);
1211 HILOG_DEBUG("callbackInfo->ret_[%{public}d]", callbackInfo->ret_);
1212 }
1213
PerformActionComplete(napi_env env,napi_status status,void * data)1214 void NAccessibilityElement::PerformActionComplete(napi_env env, napi_status status, void* data)
1215 {
1216 HILOG_DEBUG("PerformActionComplete execute back");
1217 NAccessibilityElementData* callbackInfo = static_cast<NAccessibilityElementData*>(data);
1218 if (!callbackInfo) {
1219 HILOG_ERROR("callbackInfo is nullptr");
1220 return;
1221 }
1222 napi_value result[ARGS_SIZE_TWO] = {0};
1223 napi_value callback = 0;
1224 napi_value undefined = 0;
1225 napi_get_undefined(env, &undefined);
1226 napi_get_undefined(env, &result[PARAM1]);
1227 result[PARAM0] = CreateBusinessError(env, callbackInfo->ret_);
1228 if (callbackInfo->callback_) {
1229 // Callback mode
1230 napi_get_reference_value(env, callbackInfo->callback_, &callback);
1231 napi_value returnVal;
1232 napi_call_function(env, undefined, callback, ARGS_SIZE_TWO, result, &returnVal);
1233 napi_delete_reference(env, callbackInfo->callback_);
1234 } else {
1235 // Promise mode
1236 if (callbackInfo->ret_ == RET_OK) {
1237 napi_resolve_deferred(env, callbackInfo->deferred_, result[PARAM1]);
1238 } else {
1239 napi_reject_deferred(env, callbackInfo->deferred_, result[PARAM0]);
1240 }
1241 }
1242
1243 napi_delete_async_work(env, callbackInfo->work_);
1244 delete callbackInfo;
1245 callbackInfo = nullptr;
1246 }
1247
FindElement(napi_env env,napi_callback_info info)1248 napi_value NAccessibilityElement::FindElement(napi_env env, napi_callback_info info)
1249 {
1250 size_t argc = ARGS_SIZE_THREE;
1251 napi_value argv[ARGS_SIZE_THREE] = {0};
1252 napi_value thisVar;
1253 void* data = nullptr;
1254 napi_status status = napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1255 if (status != napi_ok) {
1256 HILOG_ERROR("Failed to get cb info");
1257 napi_value err = CreateBusinessError(env, RetError::RET_ERR_FAILED);
1258 napi_throw(env, err);
1259 return nullptr;
1260 }
1261 HILOG_DEBUG("argc = %{public}d", (int)argc);
1262
1263 // Unwrap AccessibilityElement
1264 AccessibilityElement* accessibilityElement = nullptr;
1265 status = napi_unwrap(env, thisVar, (void**)&accessibilityElement);
1266 if (!accessibilityElement || status != napi_ok) {
1267 HILOG_ERROR("accessibilityElement is null or status[%{public}d] is wrong", status);
1268 napi_value err = CreateBusinessError(env, RetError::RET_ERR_NULLPTR);
1269 napi_throw(env, err);
1270 return nullptr;
1271 }
1272 if (!accessibilityElement->isElementInfo_) {
1273 HILOG_ERROR("Type of AccessibilityElement is not right");
1274 napi_value err = CreateBusinessError(env, RetError::RET_ERR_FAILED);
1275 napi_throw(env, err);
1276 return nullptr;
1277 }
1278
1279 NAccessibilityElementData *callbackInfo = new(std::nothrow) NAccessibilityElementData();
1280 if (!callbackInfo) {
1281 HILOG_ERROR("Failed to create callbackInfo.");
1282 napi_value err = CreateBusinessError(env, RetError::RET_ERR_NULLPTR);
1283 napi_throw(env, err);
1284 return nullptr;
1285 }
1286 callbackInfo->env_ = env;
1287
1288 NAccessibilityErrorCode errCode = NAccessibilityErrorCode::ACCESSIBILITY_OK;
1289 if (argc < ARGS_SIZE_THREE - 1) {
1290 HILOG_ERROR("argc is invalid: %{public}zu", argc);
1291 errCode = NAccessibilityErrorCode::ACCESSIBILITY_ERROR_INVALID_PARAM;
1292 }
1293
1294 if (errCode == NAccessibilityErrorCode::ACCESSIBILITY_OK) {
1295 // Parse conditionType name
1296 std::string conditionType = "";
1297 if (ParseString(env, conditionType, argv[PARAM0])) {
1298 HILOG_INFO("conditionType = %{public}s", conditionType.c_str());
1299 if (std::strcmp(conditionType.c_str(), "content") != 0 &&
1300 std::strcmp(conditionType.c_str(), "focusType") != 0 &&
1301 std::strcmp(conditionType.c_str(), "focusDirection") != 0) {
1302 HILOG_ERROR("argv[PARAM0] is wrong[%{public}s", conditionType.c_str());
1303 errCode = NAccessibilityErrorCode::ACCESSIBILITY_ERROR_INVALID_PARAM;
1304 } else {
1305 callbackInfo->conditionId_ = ConvertStringToCondition(conditionType);
1306 }
1307 } else {
1308 errCode = NAccessibilityErrorCode::ACCESSIBILITY_ERROR_INVALID_PARAM;
1309 }
1310
1311 // Parse queryData name
1312 std::string queryData = "";
1313 if (ParseString(env, queryData, argv[PARAM1])) {
1314 HILOG_INFO("queryData = %{public}s", queryData.c_str());
1315 callbackInfo->condition_ = queryData;
1316 } else {
1317 errCode = NAccessibilityErrorCode::ACCESSIBILITY_ERROR_INVALID_PARAM;
1318 }
1319 }
1320
1321 if (errCode == NAccessibilityErrorCode::ACCESSIBILITY_ERROR_INVALID_PARAM) {
1322 delete callbackInfo;
1323 callbackInfo = nullptr;
1324 delete accessibilityElement;
1325 accessibilityElement = nullptr;
1326 napi_value err = CreateBusinessError(env, RetError::RET_ERR_INVALID_PARAM);
1327 HILOG_ERROR("invalid param");
1328 napi_throw(env, err);
1329 return nullptr;
1330 }
1331
1332 napi_value promise = nullptr;
1333 if (argc > ARGS_SIZE_THREE - 1) {
1334 napi_valuetype valueType = napi_null;
1335 napi_typeof(env, argv[PARAM2], &valueType);
1336 if (valueType == napi_function) {
1337 napi_create_reference(env, argv[PARAM2], 1, &callbackInfo->callback_);
1338 napi_get_undefined(env, &promise);
1339 } else {
1340 napi_create_promise(env, &callbackInfo->deferred_, &promise);
1341 }
1342 } else {
1343 napi_create_promise(env, &callbackInfo->deferred_, &promise);
1344 }
1345
1346 callbackInfo->accessibilityElement_ = *accessibilityElement;
1347
1348 napi_value resource = nullptr;
1349 napi_create_string_utf8(callbackInfo->env_, "FindElement", NAPI_AUTO_LENGTH, &resource);
1350 napi_create_async_work(callbackInfo->env_, nullptr, resource, FindElementExecute,
1351 FindElementComplete, reinterpret_cast<void*>(callbackInfo), &callbackInfo->work_);
1352 napi_queue_async_work(callbackInfo->env_, callbackInfo->work_);
1353 return promise;
1354 }
1355
FindElementExecute(napi_env env,void * data)1356 void NAccessibilityElement::FindElementExecute(napi_env env, void* data)
1357 {
1358 NAccessibilityElementData *callbackInfo = static_cast<NAccessibilityElementData*>(data);
1359 if (!callbackInfo) {
1360 HILOG_ERROR("callbackInfo is nullptr");
1361 return;
1362 }
1363
1364 switch (callbackInfo->conditionId_) {
1365 case FindElementCondition::FIND_ELEMENT_CONDITION_INVALID:
1366 HILOG_ERROR("condition id is invalid");
1367 callbackInfo->ret_ = RET_ERR_INVALID_PARAM;
1368 return;
1369 case FindElementCondition::FIND_ELEMENT_CONDITION_CONTENT:
1370 callbackInfo->ret_ = AccessibleAbilityClient::GetInstance()->GetByContent(
1371 *(callbackInfo->accessibilityElement_.elementInfo_), callbackInfo->condition_,
1372 callbackInfo->nodeInfos_);
1373 break;
1374 case FindElementCondition::FIND_ELEMENT_CONDITION_FOCUS_TYPE:
1375 {
1376 int32_t focusType = ConvertStringToFocusType(callbackInfo->condition_);
1377 HILOG_INFO("focusType is %{public}d", focusType);
1378 callbackInfo->ret_ = AccessibleAbilityClient::GetInstance()->GetFocusByElementInfo(
1379 *(callbackInfo->accessibilityElement_.elementInfo_),
1380 focusType, callbackInfo->nodeInfo_);
1381 }
1382 break;
1383 case FindElementCondition::FIND_ELEMENT_CONDITION_FOCUS_DIRECTION:
1384 {
1385 FocusMoveDirection direction = ConvertStringToDirection(callbackInfo->condition_);
1386 HILOG_INFO("direction is %{public}d", direction);
1387 callbackInfo->ret_ = AccessibleAbilityClient::GetInstance()->GetNext(
1388 *(callbackInfo->accessibilityElement_.elementInfo_), direction,
1389 callbackInfo->nodeInfo_);
1390 }
1391 break;
1392 default:
1393 break;
1394 }
1395 HILOG_INFO("condition id[%{public}d], result[%{public}d]", callbackInfo->conditionId_, callbackInfo->ret_);
1396 }
1397
FindElementComplete(napi_env env,napi_status status,void * data)1398 void NAccessibilityElement::FindElementComplete(napi_env env, napi_status status, void* data)
1399 {
1400 NAccessibilityElementData* callbackInfo = static_cast<NAccessibilityElementData*>(data);
1401 if (!callbackInfo) {
1402 HILOG_ERROR("callbackInfo is nullptr");
1403 return;
1404 }
1405
1406 napi_value result[ARGS_SIZE_TWO] = {0};
1407 GetElement(callbackInfo, result[PARAM1]);
1408 result[PARAM0] = CreateBusinessError(env, callbackInfo->ret_);
1409 if (callbackInfo->callback_) {
1410 HILOG_DEBUG("callback mode. result is %{public}d", callbackInfo->ret_);
1411 napi_value callback = 0;
1412 napi_get_reference_value(env, callbackInfo->callback_, &callback);
1413 napi_value returnVal;
1414 napi_value undefined = 0;
1415 napi_get_undefined(env, &undefined);
1416 napi_call_function(env, undefined, callback, ARGS_SIZE_TWO, result, &returnVal);
1417 napi_delete_reference(env, callbackInfo->callback_);
1418 } else {
1419 HILOG_DEBUG("promise mode. result is %{public}d", callbackInfo->ret_);
1420 if (callbackInfo->ret_ == RET_OK) {
1421 napi_resolve_deferred(env, callbackInfo->deferred_, result[PARAM1]);
1422 } else {
1423 napi_reject_deferred(env, callbackInfo->deferred_, result[PARAM0]);
1424 }
1425 }
1426 napi_delete_async_work(env, callbackInfo->work_);
1427 delete callbackInfo;
1428 callbackInfo = nullptr;
1429 }
1430
GetElement(NAccessibilityElementData * callbackInfo,napi_value & value)1431 void NAccessibilityElement::GetElement(NAccessibilityElementData *callbackInfo, napi_value &value)
1432 {
1433 HILOG_INFO("condition id[%{public}d]", callbackInfo->conditionId_);
1434 napi_env env = callbackInfo->env_;
1435 if (callbackInfo->ret_ != RET_OK) {
1436 HILOG_ERROR("GetElementInfo failed!");
1437 napi_get_undefined(env, &value);
1438 return;
1439 }
1440
1441 switch (callbackInfo->conditionId_) {
1442 case FindElementCondition::FIND_ELEMENT_CONDITION_INVALID:
1443 HILOG_ERROR("condition id is invalid");
1444 callbackInfo->ret_ = RET_ERR_INVALID_PARAM;
1445 return;
1446 case FindElementCondition::FIND_ELEMENT_CONDITION_CONTENT:
1447 napi_create_array(env, &value);
1448 ConvertElementInfosToJS(env, value, callbackInfo->nodeInfos_);
1449 break;
1450 case FindElementCondition::FIND_ELEMENT_CONDITION_FOCUS_TYPE:
1451 {
1452 napi_value constructor = nullptr;
1453 napi_get_reference_value(env, NAccessibilityElement::consRef_, &constructor);
1454 napi_new_instance(env, constructor, 0, nullptr, &value);
1455 ConvertElementInfoToJS(env, value, callbackInfo->nodeInfo_);
1456 }
1457 break;
1458 case FindElementCondition::FIND_ELEMENT_CONDITION_FOCUS_DIRECTION:
1459 {
1460 napi_value constructor = nullptr;
1461 napi_get_reference_value(env, NAccessibilityElement::consRef_, &constructor);
1462 napi_new_instance(env, constructor, 0, nullptr, &value);
1463 ConvertElementInfoToJS(env, value, callbackInfo->nodeInfo_);
1464 }
1465 break;
1466 default:
1467 break;
1468 }
1469 }
1470
ErrorOperation(NAccessibilityElementData * callbackInfo)1471 napi_value NAccessibilityElement::ErrorOperation(NAccessibilityElementData *callbackInfo)
1472 {
1473 HILOG_INFO();
1474 napi_value promise = nullptr;
1475 if (!callbackInfo) {
1476 HILOG_ERROR("callbackInfo is nullptr");
1477 return nullptr;
1478 }
1479 napi_env env = callbackInfo->env_;
1480 if (callbackInfo->callback_) {
1481 HILOG_DEBUG("callback mode");
1482 napi_get_undefined(env, &promise);
1483 } else {
1484 HILOG_DEBUG("promise mode");
1485 napi_create_promise(env, &callbackInfo->deferred_, &promise);
1486 }
1487
1488 napi_value resource = nullptr;
1489 napi_create_string_utf8(env, "ErrorOperation", NAPI_AUTO_LENGTH, &resource);
1490 napi_create_async_work(env, nullptr, resource, [](napi_env env, void* data) {},
1491 // Execute the complete function
1492 [](napi_env env, napi_status status, void* data) {
1493 NAccessibilityElementData* callbackInfo = static_cast<NAccessibilityElementData*>(data);
1494 if (!callbackInfo) {
1495 HILOG_ERROR("callbackInfo is nullptr");
1496 return;
1497 }
1498
1499 napi_value result[ARGS_SIZE_TWO] = {0};
1500 napi_value callback = 0;
1501 napi_value undefined = 0;
1502 napi_get_undefined(env, &undefined);
1503 result[PARAM0] = CreateBusinessError(env, callbackInfo->ret_);
1504 if (callbackInfo->callback_) {
1505 // Callback mode
1506 result[PARAM1] = undefined;
1507 napi_get_reference_value(env, callbackInfo->callback_, &callback);
1508 napi_value returnVal;
1509 napi_call_function(env, undefined, callback, ARGS_SIZE_TWO, result, &returnVal);
1510 napi_delete_reference(env, callbackInfo->callback_);
1511 } else {
1512 // Promise mode
1513 napi_reject_deferred(env, callbackInfo->deferred_, result[PARAM0]);
1514 }
1515 napi_delete_async_work(env, callbackInfo->work_);
1516 delete callbackInfo;
1517 callbackInfo = nullptr;
1518 },
1519 reinterpret_cast<void*>(callbackInfo),
1520 &callbackInfo->work_);
1521 napi_queue_async_work(env, callbackInfo->work_);
1522 return promise;
1523 }
1524
ConvertStringToCondition(const std::string & str)1525 FindElementCondition NAccessibilityElement::ConvertStringToCondition(const std::string &str)
1526 {
1527 static const std::map<std::string, FindElementCondition> findElementConditionTable = {
1528 {"content", FindElementCondition::FIND_ELEMENT_CONDITION_CONTENT},
1529 {"focusType", FindElementCondition::FIND_ELEMENT_CONDITION_FOCUS_TYPE},
1530 {"focusDirection", FindElementCondition::FIND_ELEMENT_CONDITION_FOCUS_DIRECTION}
1531 };
1532
1533 if (findElementConditionTable.find(str) == findElementConditionTable.end()) {
1534 return FindElementCondition::FIND_ELEMENT_CONDITION_INVALID;
1535 }
1536
1537 return findElementConditionTable.at(str);
1538 }
1539
ConvertStringToDirection(const std::string & str)1540 FocusMoveDirection NAccessibilityElement::ConvertStringToDirection(const std::string &str)
1541 {
1542 static const std::map<std::string, FocusMoveDirection> focusMoveDirectionTable = {
1543 {"up", FocusMoveDirection::UP},
1544 {"down", FocusMoveDirection::DOWN},
1545 {"left", FocusMoveDirection::LEFT},
1546 {"right", FocusMoveDirection::RIGHT},
1547 {"forward", FocusMoveDirection::FORWARD},
1548 {"backward", FocusMoveDirection::BACKWARD}
1549 };
1550
1551 if (focusMoveDirectionTable.find(str) == focusMoveDirectionTable.end()) {
1552 return FocusMoveDirection::DIRECTION_INVALID;
1553 }
1554
1555 return focusMoveDirectionTable.at(str);
1556 }
1557
ConvertStringToFocusType(const std::string & str)1558 int32_t NAccessibilityElement::ConvertStringToFocusType(const std::string &str)
1559 {
1560 static const std::map<std::string, int32_t> focusTypeTable = {
1561 {"normal", FOCUS_TYPE_INPUT},
1562 {"accessibility", FOCUS_TYPE_ACCESSIBILITY}
1563 };
1564
1565 if (focusTypeTable.find(str) == focusTypeTable.end()) {
1566 return FOCUS_TYPE_INVALID;
1567 }
1568 return focusTypeTable.at(str);
1569 }