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