• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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_config.h"
17 
18 #include <uv.h>
19 #include "hilog_wrapper.h"
20 #include "ipc_skeleton.h"
21 #include "accessibility_utils.h"
22 #include "tokenid_kit.h"
23 #include "accesstoken_kit.h"
24 
25 using namespace OHOS;
26 using namespace OHOS::Accessibility;
27 using namespace OHOS::AccessibilityNapi;
28 using namespace OHOS::AccessibilityConfig;
29 using namespace Security::AccessToken;
30 
31 namespace OHOS {
32 namespace Accessibility {
TmpOpenScope(napi_env env)33 napi_handle_scope TmpOpenScope(napi_env env)
34 {
35     napi_handle_scope scope = nullptr;
36     NAPI_CALL(env, napi_open_handle_scope(env, &scope));
37     return scope;
38 }
39 } // namespace Accessibility
40 } // namespace OHOS
41 
42 std::shared_ptr<NAccessibilityConfigObserverImpl> NAccessibilityConfig::configObservers_ =
43     std::make_shared<NAccessibilityConfigObserverImpl>();
44 std::shared_ptr<EnableAbilityListsObserverImpl> NAccessibilityConfig::enableAbilityListsObservers_ =
45     std::make_shared<EnableAbilityListsObserverImpl>();
46 
EnableAbilityError(size_t & argc,OHOS::Accessibility::RetError & errCode,napi_env env,napi_value * parameters,NAccessibilityConfigData * callbackInfo)47 void NAccessibilityConfig::EnableAbilityError(size_t& argc, OHOS::Accessibility::RetError& errCode,
48     napi_env env, napi_value* parameters, NAccessibilityConfigData* callbackInfo)
49 {
50     if (argc < ARGS_SIZE_THREE - 1) {
51         HILOG_ERROR("argc is invalid: %{public}zu", argc);
52         errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
53     }
54 
55     if (errCode == OHOS::Accessibility::RET_OK) {
56         // parse name
57         std::string ability = "";
58         if (ParseString(env, ability, parameters[PARAM0])) {
59             HILOG_DEBUG("ability = %{private}s", ability.c_str());
60             callbackInfo->abilityName_ = ability;
61         } else {
62             errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
63         }
64 
65         // parse capability
66         if (!ConvertJSToCapabilities(env, parameters[PARAM1], callbackInfo->capabilities_)) {
67             HILOG_ERROR("convert capabilities failed");
68             errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
69         }
70     }
71 }
72 
DisableAbilityError(size_t & argc,OHOS::Accessibility::RetError & errCode,napi_env env,napi_value * parameters,NAccessibilityConfigData * callbackInfo)73 void NAccessibilityConfig::DisableAbilityError(size_t& argc, OHOS::Accessibility::RetError& errCode,
74     napi_env env, napi_value* parameters, NAccessibilityConfigData* callbackInfo)
75 {
76     if (argc < ARGS_SIZE_TWO - 1) {
77         HILOG_ERROR("argc is invalid: %{public}zu", argc);
78         errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
79     }
80 
81     if (errCode == OHOS::Accessibility::RET_OK) {
82         // parse name
83         std::string ability = "";
84         if (ParseString(env, ability, parameters[PARAM0])) {
85             HILOG_DEBUG("ability = %{private}s", ability.c_str());
86             callbackInfo->abilityName_ = ability;
87         } else {
88             errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
89         }
90     }
91 }
92 
EnableAbility(napi_env env,napi_callback_info info)93 napi_value NAccessibilityConfig::EnableAbility(napi_env env, napi_callback_info info)
94 {
95     HILOG_DEBUG();
96     NAccessibilityConfigData* callbackInfo = new(std::nothrow) NAccessibilityConfigData();
97     if (!callbackInfo) {
98         HILOG_ERROR("callbackInfo is nullptr");
99         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_NULLPTR);
100         napi_throw(env, err);
101         return nullptr;
102     }
103 
104     size_t argc = ARGS_SIZE_THREE;
105     napi_value parameters[ARGS_SIZE_THREE] = {0};
106     napi_get_cb_info(env, info, &argc, parameters, nullptr, nullptr);
107 
108     OHOS::Accessibility::RetError errCode = OHOS::Accessibility::RET_OK;
109     EnableAbilityError(argc, errCode, env, parameters, callbackInfo);
110 
111     if (errCode == OHOS::Accessibility::RET_ERR_INVALID_PARAM) {
112         delete callbackInfo;
113         callbackInfo = nullptr;
114         napi_value err = CreateBusinessError(env, errCode);
115         HILOG_ERROR("invalid param");
116         napi_throw(env, err);
117         return nullptr;
118     }
119 
120     napi_value promise = nullptr;
121     if (argc > ARGS_SIZE_THREE - 1 && CheckJsFunction(env, parameters[PARAM2])) {
122         napi_create_reference(env, parameters[PARAM2], 1, &callbackInfo->callback_);
123         napi_get_undefined(env, &promise);
124     } else {
125         napi_create_promise(env, &callbackInfo->deferred_, &promise);
126     }
127 
128     napi_value resource = nullptr;
129     napi_create_string_utf8(env, "EnableAbility", NAPI_AUTO_LENGTH, &resource);
130 
131     napi_create_async_work(env, nullptr, resource,
132         // Execute async to call c++ function
133         [](napi_env env, void* data) {
134             NAccessibilityConfigData* callbackInfo = static_cast<NAccessibilityConfigData*>(data);
135             auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
136             if (callbackInfo->capabilities_ != 0) {
137                 callbackInfo->ret_ = instance.EnableAbility(
138                     callbackInfo->abilityName_, callbackInfo->capabilities_);
139             }
140         }, NAccessibilityConfig::AsyncWorkComplete, reinterpret_cast<void*>(callbackInfo), &callbackInfo->work_);
141     napi_queue_async_work_with_qos(env, callbackInfo->work_, napi_qos_user_initiated);
142     return promise;
143 }
144 
DisableAbility(napi_env env,napi_callback_info info)145 napi_value NAccessibilityConfig::DisableAbility(napi_env env, napi_callback_info info)
146 {
147     HILOG_DEBUG();
148     NAccessibilityConfigData* callbackInfo = new(std::nothrow) NAccessibilityConfigData();
149     if (!callbackInfo) {
150         HILOG_ERROR("DisableAbility callbackInfo is nullptr");
151         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_NULLPTR);
152         napi_throw(env, err);
153         return nullptr;
154     }
155 
156     size_t argc = ARGS_SIZE_TWO;
157     napi_value parameters[ARGS_SIZE_TWO] = {0};
158     napi_get_cb_info(env, info, &argc, parameters, nullptr, nullptr);
159 
160     OHOS::Accessibility::RetError errCode = OHOS::Accessibility::RET_OK;
161     DisableAbilityError(argc, errCode, env, parameters, callbackInfo);
162 
163     if (errCode == OHOS::Accessibility::RET_ERR_INVALID_PARAM) {
164         delete callbackInfo;
165         callbackInfo = nullptr;
166         napi_value err = CreateBusinessError(env, errCode);
167         HILOG_ERROR("DisableAbility invalid param");
168         napi_throw(env, err);
169         return nullptr;
170     }
171 
172     napi_value promise = nullptr;
173     if (argc > ARGS_SIZE_TWO - 1 && CheckJsFunction(env, parameters[PARAM1])) {
174         napi_create_reference(env, parameters[PARAM1], 1, &callbackInfo->callback_);
175         napi_get_undefined(env, &promise);
176     } else {
177         napi_create_promise(env, &callbackInfo->deferred_, &promise);
178     }
179 
180     napi_value resource = nullptr;
181     napi_create_string_utf8(env, "DisableAbility", NAPI_AUTO_LENGTH, &resource);
182 
183     napi_create_async_work(env, nullptr, resource,
184         // Execute async to call c++ function
185         [](napi_env env, void* data) {
186             NAccessibilityConfigData* callbackInfo = static_cast<NAccessibilityConfigData*>(data);
187             auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
188             if (callbackInfo) {
189                 callbackInfo->ret_ = instance.DisableAbility(callbackInfo->abilityName_);
190             }
191         }, NAccessibilityConfig::AsyncWorkComplete,
192         reinterpret_cast<void*>(callbackInfo), &callbackInfo->work_);
193     napi_queue_async_work_with_qos(env, callbackInfo->work_, napi_qos_user_initiated);
194     return promise;
195 }
196 
CheckReadPermission(const std::string & permission)197 bool NAccessibilityConfig::CheckReadPermission(const std::string &permission)
198 {
199     HILOG_DEBUG();
200     uint32_t tokenId = IPCSkeleton::GetCallingTokenID();
201     int result = TypePermissionState::PERMISSION_GRANTED;
202     ATokenTypeEnum tokenType = AccessTokenKit::GetTokenTypeFlag(tokenId);
203     if (tokenType == TOKEN_INVALID) {
204         HILOG_WARN("AccessToken type invalid!");
205         return false;
206     } else {
207         result = AccessTokenKit::VerifyAccessToken(tokenId, permission);
208     }
209     if (result == TypePermissionState::PERMISSION_DENIED) {
210         HILOG_WARN("AccessTokenID denied!");
211         return false;
212     }
213     HILOG_DEBUG("tokenType %{private}d dAccessTokenID:%{private}u, permission:%{private}s matched!",
214         tokenType, tokenId, permission.c_str());
215     return true;
216 }
217 
IsAvailable(napi_env env,napi_callback_info info)218 bool NAccessibilityConfig::IsAvailable(napi_env env, napi_callback_info info)
219 {
220     HILOG_DEBUG();
221     if (!Security::AccessToken::TokenIdKit::IsSystemAppByFullTokenID(IPCSkeleton::GetCallingFullTokenID())) {
222         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_NOT_SYSTEM_APP);
223         napi_throw(env, err);
224         HILOG_ERROR("is not system app");
225         return false;
226     }
227 
228     if (!CheckReadPermission(OHOS_PERMISSION_READ_ACCESSIBILITY_CONFIG)) {
229         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_NO_PERMISSION);
230         napi_throw(env, err);
231         HILOG_ERROR("have no read permission");
232         return false;
233     }
234 
235     return true;
236 }
237 
SubscribeState(napi_env env,napi_callback_info info)238 napi_value NAccessibilityConfig::SubscribeState(napi_env env, napi_callback_info info)
239 {
240     HILOG_DEBUG();
241     if (!IsAvailable(env, info)) {
242         return nullptr;
243     }
244     size_t argc = ARGS_SIZE_TWO;
245     napi_value args[ARGS_SIZE_TWO] = {0};
246     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
247 
248     OHOS::Accessibility::RetError errCode = OHOS::Accessibility::RET_OK;
249     if (argc < ARGS_SIZE_TWO) {
250         HILOG_ERROR("argc is invalid: %{public}zu", argc);
251         errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
252     }
253 
254     std::string observerType = "";
255     if (errCode == OHOS::Accessibility::RET_OK) {
256         if (!ParseString(env, observerType, args[PARAM0])) {
257             HILOG_ERROR("observer type parse failed");
258             errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
259         } else {
260             if (std::strcmp(observerType.c_str(), "enabledAccessibilityExtensionListChange") != 0 &&
261                 std::strcmp(observerType.c_str(), "installedAccessibilityListChange") != 0) {
262                 HILOG_ERROR("args[PARAM0] is wrong[%{public}s", observerType.c_str());
263                 errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
264             }
265         }
266     }
267 
268     if (errCode == OHOS::Accessibility::RET_OK) {
269         napi_valuetype valueType = napi_null;
270         napi_typeof(env, args[PARAM1], &valueType);
271         if (valueType != napi_function) {
272             HILOG_ERROR("SubscribeState args[PARAM1] format is wrong");
273             errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
274         }
275     }
276 
277     if (errCode == OHOS::Accessibility::RET_ERR_INVALID_PARAM) {
278         napi_value err = CreateBusinessError(env, errCode);
279         HILOG_ERROR("invalid param");
280         napi_throw(env, err);
281         return nullptr;
282     }
283     if (enableAbilityListsObservers_ == nullptr) {
284         HILOG_ERROR("enableAbilityListsObservers_ is null");
285         return nullptr;
286     }
287     if (std::strcmp(observerType.c_str(), "enabledAccessibilityExtensionListChange") == 0) {
288         enableAbilityListsObservers_->SubscribeObserver(env, args[PARAM1]);
289     }
290     if (std::strcmp(observerType.c_str(), "installedAccessibilityListChange") == 0) {
291         enableAbilityListsObservers_->SubscribeInstallObserver(env, args[PARAM1]);
292     }
293     return nullptr;
294 }
295 
UnsubscribeState(napi_env env,napi_callback_info info)296 napi_value NAccessibilityConfig::UnsubscribeState(napi_env env, napi_callback_info info)
297 {
298     HILOG_DEBUG();
299     if (!IsAvailable(env, info)) {
300         return nullptr;
301     }
302     size_t argc = ARGS_SIZE_TWO;
303     napi_value args[ARGS_SIZE_TWO] = {0};
304     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
305 
306     OHOS::Accessibility::RetError errCode = OHOS::Accessibility::RET_OK;
307     if (argc < ARGS_SIZE_TWO - 1) {
308         HILOG_ERROR("argc is invalid: %{public}zu", argc);
309         errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
310     }
311     std::string observerType = "";
312     if (errCode == OHOS::Accessibility::RET_OK) {
313         if (!ParseString(env, observerType, args[PARAM0])) {
314             HILOG_ERROR("observer type parse failed");
315             errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
316         } else {
317             if (std::strcmp(observerType.c_str(), "enabledAccessibilityExtensionListChange") != 0 &&
318                 std::strcmp(observerType.c_str(), "installedAccessibilityListChange") != 0) {
319                 HILOG_ERROR("args[PARAM0] is wrong[%{public}s", observerType.c_str());
320                 errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
321             }
322         }
323     }
324 
325     if (errCode == OHOS::Accessibility::RET_ERR_INVALID_PARAM) {
326         napi_value err = CreateBusinessError(env, errCode);
327         HILOG_ERROR("UnsubscribeState invalid param");
328         napi_throw(env, err);
329         return nullptr;
330     }
331     if (enableAbilityListsObservers_ == nullptr) {
332         HILOG_ERROR("enableAbilityListsObservers_ is null");
333         return nullptr;
334     }
335     if (argc > ARGS_SIZE_TWO - 1 && CheckJsFunction(env, args[PARAM1])) {
336         if (std::strcmp(observerType.c_str(), "enabledAccessibilityExtensionListChange") == 0) {
337             enableAbilityListsObservers_->UnsubscribeObserver(env, args[PARAM1]);
338         } else {
339             enableAbilityListsObservers_->UnsubscribeInstallObserver(env, args[PARAM1]);
340         }
341     } else {
342         if (std::strcmp(observerType.c_str(), "enabledAccessibilityExtensionListChange") == 0) {
343             enableAbilityListsObservers_->UnsubscribeObservers();
344         } else {
345             enableAbilityListsObservers_->UnsubscribeInstallObservers();
346         }
347     }
348     return nullptr;
349 }
350 
AsyncWorkComplete(napi_env env,napi_status status,void * data)351 void NAccessibilityConfig::AsyncWorkComplete(napi_env env, napi_status status, void* data)
352 {
353     HILOG_DEBUG();
354     NAccessibilityConfigData* callbackInfo = static_cast<NAccessibilityConfigData*>(data);
355     if (!callbackInfo) {
356         HILOG_ERROR("callbackInfo is nullptr");
357         return;
358     }
359     napi_value result[ARGS_SIZE_ONE] = {0};
360     napi_value callback = 0;
361     napi_value returnVal = 0;
362     napi_value undefined = 0;
363     napi_get_undefined(env, &undefined);
364     result[PARAM0] = CreateBusinessError(env, callbackInfo->ret_);
365     if (callbackInfo->callback_) {
366         napi_get_reference_value(env, callbackInfo->callback_, &callback);
367         napi_call_function(env, undefined, callback, ARGS_SIZE_ONE, result, &returnVal);
368         napi_delete_reference(env, callbackInfo->callback_);
369         HILOG_DEBUG("complete function callback mode");
370     } else {
371         if (callbackInfo->ret_ == OHOS::Accessibility::RET_OK) {
372             napi_resolve_deferred(env, callbackInfo->deferred_, undefined);
373         } else {
374             napi_reject_deferred(env, callbackInfo->deferred_, result[PARAM0]);
375         }
376         HILOG_DEBUG("complete function promise mode");
377     }
378     napi_delete_async_work(env, callbackInfo->work_);
379     delete callbackInfo;
380     callbackInfo = nullptr;
381 }
382 
SetScreenTouchConfigExecute(NAccessibilityConfigData * callbackInfo)383 void NAccessibilityConfig::SetScreenTouchConfigExecute(NAccessibilityConfigData* callbackInfo)
384 {
385     auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
386     if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONIFG_CLICK_RESPONSE_TIME) {
387         auto time = ConvertStringToClickResponseTimeTypes(callbackInfo->stringConfig_);
388         callbackInfo->ret_ = instance.SetClickResponseTime(time);
389     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_IGNORE_REPEAT_CLICK_TIME) {
390         auto time = ConvertStringToIgnoreRepeatClickTimeTypes(callbackInfo->stringConfig_);
391         callbackInfo->ret_ = instance.SetIgnoreRepeatClickTime(time);
392     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_IGNORE_REPEAT_CLICK_STATE) {
393         callbackInfo->ret_ = instance.SetIgnoreRepeatClickState(callbackInfo->boolConfig_);
394     }
395 }
396 
SetConfigExecute(napi_env env,void * data)397 void NAccessibilityConfig::SetConfigExecute(napi_env env, void* data)
398 {
399     NAccessibilityConfigData* callbackInfo = static_cast<NAccessibilityConfigData*>(data);
400     if (!callbackInfo) {
401         HILOG_ERROR("callbackInfo is nullptr");
402         return;
403     }
404 
405     HILOG_DEBUG("callbackInfo->id_ = %{public}d", callbackInfo->id_);
406     auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
407     if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_HIGH_CONTRAST_TEXT) {
408         callbackInfo->ret_ = instance.SetHighContrastTextState(callbackInfo->boolConfig_);
409     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_DALTONIZATION_STATE) {
410         callbackInfo->ret_ = instance.SetDaltonizationState(callbackInfo->boolConfig_);
411     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_INVERT_COLOR) {
412         callbackInfo->ret_ = instance.SetInvertColorState(callbackInfo->boolConfig_);
413     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_ANIMATION_OFF) {
414         callbackInfo->ret_ = instance.SetAnimationOffState(callbackInfo->boolConfig_);
415     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SCREEN_MAGNIFICATION) {
416         callbackInfo->ret_ = instance.SetScreenMagnificationState(callbackInfo->boolConfig_);
417     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_AUDIO_MONO) {
418         callbackInfo->ret_ = instance.SetAudioMonoState(callbackInfo->boolConfig_);
419     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_MOUSE_KEY) {
420         callbackInfo->ret_ = instance.SetMouseKeyState(callbackInfo->boolConfig_);
421     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY) {
422         callbackInfo->ret_ = instance.SetShortKeyState(callbackInfo->boolConfig_);
423     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CAPTION_STATE) {
424         callbackInfo->ret_ = instance.SetCaptionsState(callbackInfo->boolConfig_);
425     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CONTENT_TIMEOUT) {
426         callbackInfo->ret_ = instance.SetContentTimeout(callbackInfo->uint32Config_);
427     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_MOUSE_AUTOCLICK) {
428         callbackInfo->ret_ = instance.SetMouseAutoClick(callbackInfo->int32Config_);
429     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_AUDIO_BALANCE) {
430         callbackInfo->ret_ = instance.SetAudioBalance(callbackInfo->floatConfig_);
431     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_BRIGHTNESS_DISCOUNT) {
432         callbackInfo->ret_ = instance.SetBrightnessDiscount(callbackInfo->floatConfig_);
433     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY_TARGET) {
434         callbackInfo->ret_ = instance.SetShortkeyTarget(callbackInfo->stringConfig_);
435     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY_MULTI_TARGET) {
436         callbackInfo->ret_ = instance.SetShortkeyMultiTarget(callbackInfo->stringVectorConfig_);
437     }  else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CAPTION_STYLE) {
438         callbackInfo->ret_ = instance.SetCaptionsProperty(callbackInfo->captionProperty_);
439     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_DALTONIZATION_COLOR_FILTER) {
440         auto filter = ConvertStringToDaltonizationTypes(callbackInfo->stringConfig_);
441         callbackInfo->ret_ = instance.SetDaltonizationColorFilter(filter);
442     }
443 
444     SetScreenTouchConfigExecute(callbackInfo);
445 }
446 
ConfigCompleteInfoById(napi_env env,NAccessibilityConfigData * callbackInfo,napi_value * result,size_t len)447 void NAccessibilityConfig::ConfigCompleteInfoById(napi_env env, NAccessibilityConfigData* callbackInfo,
448     napi_value* result, size_t len)
449 {
450     switch (callbackInfo->id_) {
451         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_HIGH_CONTRAST_TEXT:
452         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_INVERT_COLOR:
453         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_ANIMATION_OFF:
454         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SCREEN_MAGNIFICATION:
455         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_AUDIO_MONO:
456         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_MOUSE_KEY:
457         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY:
458         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CAPTION_STATE:
459         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_DALTONIZATION_STATE:
460         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_IGNORE_REPEAT_CLICK_STATE:
461             napi_get_boolean(env, callbackInfo->boolConfig_, &result[PARAM1]);
462             break;
463         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CONTENT_TIMEOUT:
464         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_MOUSE_AUTOCLICK:
465             napi_create_int32(env, callbackInfo->int32Config_, &result[PARAM1]);
466             break;
467         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_AUDIO_BALANCE:
468         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_BRIGHTNESS_DISCOUNT:
469             napi_create_double(env, static_cast<double>(callbackInfo->floatConfig_), &result[PARAM1]);
470             break;
471         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_DALTONIZATION_COLOR_FILTER:
472         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY_TARGET:
473         case OHOS::AccessibilityConfig::CONFIG_ID::CONIFG_CLICK_RESPONSE_TIME:
474         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_IGNORE_REPEAT_CLICK_TIME:
475             napi_create_string_utf8(env, callbackInfo->stringConfig_.c_str(), NAPI_AUTO_LENGTH, &result[PARAM1]);
476             break;
477         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY_MULTI_TARGET:
478             napi_create_array(env, &result[PARAM1]);
479             ConvertStringVecToJS(env, result[PARAM1], callbackInfo->stringVectorConfig_);
480             break;
481         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CAPTION_STYLE:
482             napi_create_object(env, &result[PARAM1]);
483             ConvertCaptionPropertyToJS(env, result[PARAM1], callbackInfo->captionProperty_);
484             break;
485         default:
486             break;
487     }
488 }
489 
GetConfigComplete(napi_env env,napi_status status,void * data)490 void NAccessibilityConfig::GetConfigComplete(napi_env env, napi_status status, void* data)
491 {
492     HILOG_DEBUG();
493     NAccessibilityConfigData* callbackInfo = static_cast<NAccessibilityConfigData*>(data);
494     if (!callbackInfo) {
495         HILOG_ERROR("callbackInfo is nullptr");
496         return;
497     }
498     HILOG_DEBUG("callbackInfo->id_ = %{public}d", callbackInfo->id_);
499     napi_value result[ARGS_SIZE_TWO] = {0};
500     ConfigCompleteInfoById(env, callbackInfo, result, ARGS_SIZE_TWO);
501 
502     napi_value returnVal = 0;
503     napi_value callback = 0;
504     napi_value undefined = 0;
505     napi_get_undefined(env, &undefined);
506     result[PARAM0] = CreateBusinessError(env, callbackInfo->ret_);
507     if (callbackInfo->callback_) {
508         napi_get_reference_value(env, callbackInfo->callback_, &callback);
509         napi_call_function(env, undefined, callback, ARGS_SIZE_TWO, result, &returnVal);
510         napi_delete_reference(env, callbackInfo->callback_);
511         HILOG_DEBUG("complete function callback mode");
512     } else {
513         if (callbackInfo->ret_ == OHOS::Accessibility::RET_OK) {
514             HILOG_DEBUG("GetConfigComplete callbackInfo->ret_ is RET_OK");
515             napi_resolve_deferred(env, callbackInfo->deferred_, result[PARAM1]);
516         } else {
517             HILOG_DEBUG("GetConfigComplete callbackInfo->ret_ is not RET_OK");
518             napi_reject_deferred(env, callbackInfo->deferred_, result[PARAM0]);
519         }
520     }
521     napi_delete_async_work(env, callbackInfo->work_);
522     delete callbackInfo;
523     callbackInfo = nullptr;
524 }
525 
GetScreenTouchConfigExecute(NAccessibilityConfigData * callbackInfo)526 void NAccessibilityConfig::GetScreenTouchConfigExecute(NAccessibilityConfigData* callbackInfo)
527 {
528     auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
529     if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONIFG_CLICK_RESPONSE_TIME) {
530         OHOS::AccessibilityConfig::CLICK_RESPONSE_TIME time;
531         callbackInfo->ret_ = instance.GetClickResponseTime(time);
532         callbackInfo->stringConfig_ = ConvertClickResponseTimeTypeToString(time);
533     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_IGNORE_REPEAT_CLICK_TIME) {
534         OHOS::AccessibilityConfig::IGNORE_REPEAT_CLICK_TIME time;
535         callbackInfo->ret_ = instance.GetIgnoreRepeatClickTime(time);
536         callbackInfo->stringConfig_ = ConvertIgnoreRepeatClickTimeTypeToString(time);
537     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_IGNORE_REPEAT_CLICK_STATE) {
538         callbackInfo->ret_ = instance.GetIgnoreRepeatClickState(callbackInfo->boolConfig_);
539     }
540 }
541 
GetConfigExecute(napi_env env,void * data)542 void NAccessibilityConfig::GetConfigExecute(napi_env env, void* data)
543 {
544     NAccessibilityConfigData* callbackInfo = static_cast<NAccessibilityConfigData*>(data);
545     if (!callbackInfo) {
546         HILOG_ERROR("callbackInfo is nullptr");
547         return;
548     }
549 
550     HILOG_DEBUG("callbackInfo->id_ = %{public}d", callbackInfo->id_);
551     auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
552     if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_HIGH_CONTRAST_TEXT) {
553         callbackInfo->ret_ = instance.GetHighContrastTextState(callbackInfo->boolConfig_);
554     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_DALTONIZATION_STATE) {
555         callbackInfo->ret_ = instance.GetDaltonizationState(callbackInfo->boolConfig_);
556     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_INVERT_COLOR) {
557         callbackInfo->ret_ = instance.GetInvertColorState(callbackInfo->boolConfig_);
558     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_ANIMATION_OFF) {
559         callbackInfo->ret_ = instance.GetAnimationOffState(callbackInfo->boolConfig_);
560     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SCREEN_MAGNIFICATION) {
561         callbackInfo->ret_ = instance.GetScreenMagnificationState(callbackInfo->boolConfig_);
562     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_AUDIO_MONO) {
563         callbackInfo->ret_ = instance.GetAudioMonoState(callbackInfo->boolConfig_);
564     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_MOUSE_KEY) {
565         callbackInfo->ret_ = instance.GetMouseKeyState(callbackInfo->boolConfig_);
566     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY) {
567         callbackInfo->ret_ = instance.GetShortKeyState(callbackInfo->boolConfig_);
568     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CAPTION_STATE) {
569         callbackInfo->ret_ = instance.GetCaptionsState(callbackInfo->boolConfig_);
570     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_MOUSE_AUTOCLICK) {
571         callbackInfo->ret_ = instance.GetMouseAutoClick(callbackInfo->int32Config_);
572     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_AUDIO_BALANCE) {
573         callbackInfo->ret_ = instance.GetAudioBalance(callbackInfo->floatConfig_);
574     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_BRIGHTNESS_DISCOUNT) {
575         callbackInfo->ret_ = instance.GetBrightnessDiscount(callbackInfo->floatConfig_);
576     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY_TARGET) {
577         callbackInfo->ret_ = instance.GetShortkeyTarget(callbackInfo->stringConfig_);
578     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY_MULTI_TARGET) {
579         callbackInfo->ret_ = instance.GetShortkeyMultiTarget(callbackInfo->stringVectorConfig_);
580     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CAPTION_STYLE) {
581         callbackInfo->ret_ = instance.GetCaptionsProperty(callbackInfo->captionProperty_);
582     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CONTENT_TIMEOUT) {
583         uint32_t timeout = 0;
584         callbackInfo->ret_ = instance.GetContentTimeout(timeout);
585         callbackInfo->int32Config_ = static_cast<int32_t>(timeout);
586     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_DALTONIZATION_COLOR_FILTER) {
587         OHOS::AccessibilityConfig::DALTONIZATION_TYPE type;
588         callbackInfo->ret_ = instance.GetDaltonizationColorFilter(type);
589         callbackInfo->stringConfig_ = ConvertDaltonizationTypeToString(type);
590     }
591 
592     GetScreenTouchConfigExecute(callbackInfo);
593 }
594 
GetCallbackInfo(napi_env env,napi_callback_info info,napi_value * parameters,size_t & argc,NAccessibilityConfigClass * & obj)595 NAccessibilityConfigData* NAccessibilityConfig::GetCallbackInfo(napi_env env, napi_callback_info info,
596     napi_value* parameters, size_t& argc, NAccessibilityConfigClass*& obj)
597 {
598     napi_value jsthis = nullptr;
599     napi_get_cb_info(env, info, &argc, parameters, &jsthis, nullptr);
600 
601     napi_status status = napi_unwrap(env, jsthis, reinterpret_cast<void**>(&obj));
602     if (status != napi_ok) {
603         HILOG_ERROR("Failed to get unwrap obj");
604         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_FAILED);
605         napi_throw(env, err);
606         return nullptr;
607     }
608     if (!obj) {
609         HILOG_ERROR("obj is nullptr");
610         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_NULLPTR);
611         napi_throw(env, err);
612         return nullptr;
613     }
614     HILOG_DEBUG("ConfigID = %{public}d", obj->GetConfigId());
615     NAccessibilityConfigData* callbackInfo = new(std::nothrow) NAccessibilityConfigData();
616     if (!callbackInfo) {
617         HILOG_ERROR("callbackInfo is nullptr");
618         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_NULLPTR);
619         napi_throw(env, err);
620         return nullptr;
621     }
622     return callbackInfo;
623 }
624 
ParseConnectTimeoutData(napi_env env,NAccessibilityConfigData * callbackInfo,napi_value * parameters)625 bool NAccessibilityConfig::ParseConnectTimeoutData(napi_env env, NAccessibilityConfigData* callbackInfo,
626     napi_value* parameters)
627 {
628     int32_t timeout = 0;
629     bool ret = ParseInt32(env, timeout, parameters[PARAM0]);
630     callbackInfo->uint32Config_ = static_cast<uint32_t>(timeout);
631     return ret;
632 }
633 
ParseMouseAutoClickData(napi_env env,NAccessibilityConfigData * callbackInfo,napi_value * parameters)634 bool NAccessibilityConfig::ParseMouseAutoClickData(napi_env env, NAccessibilityConfigData* callbackInfo,
635     napi_value* parameters)
636 {
637     int32_t time = 0;
638     bool ret = ParseInt32(env, time, parameters[PARAM0]);
639     callbackInfo->int32Config_ = time;
640     return ret;
641 }
642 
SetConfigParseBoolData(napi_env env,NAccessibilityConfigData * callbackInfo,napi_value * parameters)643 bool NAccessibilityConfig::SetConfigParseBoolData(napi_env env, NAccessibilityConfigData* callbackInfo,
644     napi_value* parameters)
645 {
646     bool state = false;
647     bool ret = ParseBool(env, state, parameters[PARAM0]);
648     callbackInfo->boolConfig_ = state;
649     return ret;
650 }
651 
SetConfigParseData(napi_env env,NAccessibilityConfigClass * obj,NAccessibilityConfigData * callbackInfo,napi_value * parameters,size_t argc)652 bool NAccessibilityConfig::SetConfigParseData(napi_env env, NAccessibilityConfigClass* obj,
653     NAccessibilityConfigData* callbackInfo, napi_value* parameters, size_t argc)
654 {
655     bool ret = false;
656     switch (obj->GetConfigId()) {
657         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_HIGH_CONTRAST_TEXT:
658         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_INVERT_COLOR:
659         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_ANIMATION_OFF:
660         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SCREEN_MAGNIFICATION:
661         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_AUDIO_MONO:
662         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_MOUSE_KEY:
663         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY:
664         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CAPTION_STATE:
665         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_DALTONIZATION_STATE:
666         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_IGNORE_REPEAT_CLICK_STATE:
667             return SetConfigParseBoolData(env, callbackInfo, parameters);
668         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CONTENT_TIMEOUT:
669             return ParseConnectTimeoutData(env, callbackInfo, parameters);
670         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_MOUSE_AUTOCLICK:
671             return ParseMouseAutoClickData(env, callbackInfo, parameters);
672         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_AUDIO_BALANCE:
673         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_BRIGHTNESS_DISCOUNT:
674             {
675                 double doubleTemp = 0;
676                 ret = ParseDouble(env, doubleTemp, parameters[PARAM0]);
677                 callbackInfo->floatConfig_ = static_cast<float>(doubleTemp);
678             }
679             break;
680         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_DALTONIZATION_COLOR_FILTER:
681         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY_TARGET:
682         case OHOS::AccessibilityConfig::CONFIG_ID::CONIFG_CLICK_RESPONSE_TIME:
683         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_IGNORE_REPEAT_CLICK_TIME:
684             {
685                 std::string target = "";
686                 ret = ParseString(env, target, parameters[PARAM0]) && target.length() > 0;
687                 callbackInfo->stringConfig_ = target;
688             }
689             break;
690         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY_MULTI_TARGET:
691             {
692                 std::vector<std::string> stringArray;
693                 ConvertStringArrayJSToNAPICommon(env, parameters[PARAM0], stringArray);
694                 callbackInfo->stringVectorConfig_ = stringArray;
695                 return true;
696             }
697         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CAPTION_STYLE:
698             return ConvertObjToCaptionProperty(env, parameters[PARAM0], &callbackInfo->captionProperty_);
699         default:
700             break;
701     }
702     return ret;
703 }
704 
SetConfig(napi_env env,napi_callback_info info)705 napi_value NAccessibilityConfig::SetConfig(napi_env env, napi_callback_info info)
706 {
707     HILOG_DEBUG();
708 
709     NAccessibilityConfigClass* obj;
710     size_t argc = ARGS_SIZE_TWO;
711     napi_value parameters[ARGS_SIZE_TWO] = {0};
712     NAccessibilityConfigData* callbackInfo = GetCallbackInfo(env, info, parameters, argc, obj);
713     if (callbackInfo == nullptr) {
714         return nullptr;
715     }
716 
717     OHOS::Accessibility::RetError errCode = OHOS::Accessibility::RET_OK;
718     if (argc < ARGS_SIZE_TWO - 1) {
719         HILOG_ERROR("argc is invalid: %{public}zu", argc);
720         errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
721     }
722 
723     if (errCode == OHOS::Accessibility::RET_OK) {
724         if (!SetConfigParseData(env, obj, callbackInfo, parameters, argc)) {
725             errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
726         }
727     }
728 
729     if (errCode == OHOS::Accessibility::RET_ERR_INVALID_PARAM) {
730         delete callbackInfo;
731         callbackInfo = nullptr;
732         napi_value err = CreateBusinessError(env, errCode);
733         HILOG_ERROR("SetConfig invalid param");
734         napi_throw(env, err);
735         return nullptr;
736     }
737     callbackInfo->id_ = obj->GetConfigId();
738 
739     // parse function if it needs
740     napi_value promise = nullptr;
741     if (argc >= ARGS_SIZE_TWO && CheckJsFunction(env, parameters[PARAM1])) {
742         napi_create_reference(env, parameters[PARAM1], 1, &callbackInfo->callback_);
743         napi_get_undefined(env, &promise);
744     } else {
745         napi_create_promise(env, &callbackInfo->deferred_, &promise);
746     }
747     napi_value resource = nullptr;
748     napi_create_string_utf8(env, "SetConfig", NAPI_AUTO_LENGTH, &resource);
749 
750     napi_create_async_work(env, nullptr, resource,
751         // Execute async to call c++ function
752         NAccessibilityConfig::SetConfigExecute,
753         // Execute the complete function
754         NAccessibilityConfig::AsyncWorkComplete,
755         reinterpret_cast<void*>(callbackInfo),
756         &callbackInfo->work_);
757     napi_queue_async_work_with_qos(env, callbackInfo->work_, napi_qos_user_initiated);
758     return promise;
759 }
760 
GetConfig(napi_env env,napi_callback_info info)761 napi_value NAccessibilityConfig::GetConfig(napi_env env, napi_callback_info info)
762 {
763     HILOG_DEBUG();
764     size_t argc = ARGS_SIZE_ONE;
765     napi_value parameters[ARGS_SIZE_ONE] = {0};
766     napi_value jsthis = nullptr;
767     napi_get_cb_info(env, info, &argc, parameters, &jsthis, nullptr);
768 
769     NAccessibilityConfigClass* obj;
770     napi_status status = napi_unwrap(env, jsthis, reinterpret_cast<void**>(&obj));
771     if (status != napi_ok) {
772         HILOG_ERROR("Failed to get unwrap obj");
773         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_FAILED);
774         napi_throw(env, err);
775         return nullptr;
776     }
777     if (!obj) {
778         HILOG_ERROR("obj is nullptr");
779         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_NULLPTR);
780         napi_throw(env, err);
781         return nullptr;
782     }
783     HILOG_DEBUG("ConfigID = %{public}d", obj->GetConfigId());
784 
785     NAccessibilityConfigData* callbackInfo = new(std::nothrow) NAccessibilityConfigData();
786     if (!callbackInfo) {
787         HILOG_ERROR("callbackInfo is nullptr");
788         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_NULLPTR);
789         napi_throw(env, err);
790         return nullptr;
791     }
792     callbackInfo->id_ = obj->GetConfigId();
793 
794     // parse function if it needs
795     napi_value promise = nullptr;
796     if (argc >= ARGS_SIZE_ONE && CheckJsFunction(env, parameters[PARAM0])) {
797         napi_create_reference(env, parameters[PARAM0], 1, &callbackInfo->callback_);
798         napi_get_undefined(env, &promise);
799     } else {
800         napi_create_promise(env, &callbackInfo->deferred_, &promise);
801     }
802     napi_value resource = nullptr;
803     napi_create_string_utf8(env, "GetConfig", NAPI_AUTO_LENGTH, &resource);
804 
805     napi_create_async_work(env, nullptr, resource,
806         // Execute async to call c++ function
807         NAccessibilityConfig::GetConfigExecute,
808         // Execute the complete function
809         NAccessibilityConfig::GetConfigComplete,
810         reinterpret_cast<void*>(callbackInfo),
811         &callbackInfo->work_);
812     napi_queue_async_work_with_qos(env, callbackInfo->work_, napi_qos_user_initiated);
813     return promise;
814 }
815 
SubscribeConfigObserver(napi_env env,napi_callback_info info)816 napi_value NAccessibilityConfig::SubscribeConfigObserver(napi_env env, napi_callback_info info)
817 {
818     HILOG_DEBUG();
819     if (!IsAvailable(env, info)) {
820         return nullptr;
821     }
822     size_t argc = ARGS_SIZE_ONE;
823     napi_value parameters[ARGS_SIZE_ONE] = {0};
824     napi_value jsthis = nullptr;
825     napi_get_cb_info(env, info, &argc, parameters, &jsthis, nullptr);
826     NAccessibilityConfigClass* obj;
827     napi_status status = napi_unwrap(env, jsthis, reinterpret_cast<void**>(&obj));
828     if (status != napi_ok) {
829         HILOG_ERROR("Failed to get unwrap obj");
830         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_FAILED);
831         napi_throw(env, err);
832         return nullptr;
833     }
834     if (!obj) {
835         HILOG_ERROR("obj is nullptr");
836         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_NULLPTR);
837         napi_throw(env, err);
838         return nullptr;
839     }
840 
841     OHOS::Accessibility::RetError errCode = OHOS::Accessibility::RET_OK;
842     if (argc < ARGS_SIZE_ONE) {
843         HILOG_ERROR("argc is invalid: %{public}zu", argc);
844         errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
845     }
846 
847     if (errCode == OHOS::Accessibility::RET_OK) {
848         napi_valuetype valueType = napi_null;
849         napi_typeof(env, parameters[PARAM0], &valueType);
850         if (valueType != napi_function) {
851             HILOG_ERROR("parameters[PARAM1] format is wrong");
852             errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
853         }
854     }
855 
856     if (errCode == OHOS::Accessibility::RET_ERR_INVALID_PARAM) {
857         napi_value err = CreateBusinessError(env, errCode);
858         HILOG_ERROR("invalid param");
859         napi_throw(env, err);
860         return nullptr;
861     }
862 
863     configObservers_->SubscribeObserver(env, obj->GetConfigId(), parameters[PARAM0]);
864     return nullptr;
865 }
866 
UnSubscribeConfigObserver(napi_env env,napi_callback_info info)867 napi_value NAccessibilityConfig::UnSubscribeConfigObserver(napi_env env, napi_callback_info info)
868 {
869     HILOG_DEBUG();
870     if (!IsAvailable(env, info)) {
871         return nullptr;
872     }
873     napi_value jsthis = nullptr;
874     size_t argc = ARGS_SIZE_ONE;
875     napi_value parameters[ARGS_SIZE_ONE] = {0};
876     napi_get_cb_info(env, info, &argc, parameters, &jsthis, nullptr);
877     NAccessibilityConfigClass* obj;
878     napi_status status = napi_unwrap(env, jsthis, reinterpret_cast<void**>(&obj));
879     if (status != napi_ok) {
880         HILOG_ERROR("Failed to get unwrap obj");
881         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_FAILED);
882         napi_throw(env, err);
883         return nullptr;
884     }
885     if (!obj) {
886         HILOG_ERROR("obj is nullptr");
887         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_NULLPTR);
888         napi_throw(env, err);
889         return nullptr;
890     }
891     if (argc >= ARGS_SIZE_ONE && CheckJsFunction(env, parameters[PARAM0])) {
892         configObservers_->UnsubscribeObserver(env, obj->GetConfigId(), parameters[PARAM0]);
893     } else {
894         configObservers_->UnsubscribeObservers(obj->GetConfigId());
895     }
896 
897     return nullptr;
898 }
899 
OnEnableAbilityListsStateChanged()900 void EnableAbilityListsObserver::OnEnableAbilityListsStateChanged()
901 {
902     HILOG_DEBUG();
903 
904     AccessibilityCallbackInfo *callbackInfo = new(std::nothrow) AccessibilityCallbackInfo();
905     if (!callbackInfo) {
906         HILOG_ERROR("callbackInfo is nullptr");
907         return;
908     }
909 
910     uv_work_t *work = new(std::nothrow) uv_work_t;
911     if (!work) {
912         HILOG_ERROR("Failed to create work.");
913         delete callbackInfo;
914         callbackInfo = nullptr;
915         return;
916     }
917 
918     callbackInfo->env_ = env_;
919     callbackInfo->ref_ = callback_;
920     work->data = static_cast<void*>(callbackInfo);
921 
922     int ret = OnEnableAbilityListsStateChangedWork(work);
923     if (ret != 0) {
924         HILOG_ERROR("Failed to execute OnEnableAbilityListsStateChanged work queue");
925         delete callbackInfo;
926         callbackInfo = nullptr;
927         delete work;
928         work = nullptr;
929     }
930 }
931 
OnEnableAbilityListsStateChangedWork(uv_work_t * work)932 int EnableAbilityListsObserver::OnEnableAbilityListsStateChangedWork(uv_work_t *work)
933 {
934     uv_loop_s *loop = nullptr;
935     napi_get_uv_event_loop(env_, &loop);
936     if (loop == nullptr || work == nullptr) {
937         HILOG_ERROR("loop or work is nullptr.");
938         return RET_ERR_FAILED;
939     }
940     int ret = uv_queue_work_with_qos(
941         loop,
942         work,
943         [](uv_work_t *work) {},
944         [](uv_work_t *work, int status) {
945             AccessibilityCallbackInfo *callbackInfo = static_cast<AccessibilityCallbackInfo*>(work->data);
946             napi_env env = callbackInfo->env_;
947             auto closeScope = [env](napi_handle_scope scope) {
948                 napi_close_handle_scope(env, scope);
949             };
950             std::unique_ptr<napi_handle_scope__, decltype(closeScope)> scopes(
951                 OHOS::Accessibility::TmpOpenScope(callbackInfo->env_), closeScope);
952             napi_value handler = nullptr;
953             napi_value callResult = nullptr;
954             napi_value jsEvent = nullptr;
955             napi_value undefined = nullptr;
956             napi_get_reference_value(callbackInfo->env_, callbackInfo->ref_, &handler);
957             napi_get_undefined(callbackInfo->env_, &undefined);
958             napi_call_function(callbackInfo->env_, undefined, handler, 1, &jsEvent, &callResult);
959             delete callbackInfo;
960             callbackInfo = nullptr;
961             delete work;
962             work = nullptr;
963         },
964         uv_qos_default);
965     return ret;
966 }
967 
SubscribeToFramework()968 void EnableAbilityListsObserverImpl::SubscribeToFramework()
969 {
970     auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
971     instance.SubscribeEnableAbilityListsObserver(shared_from_this());
972 }
973 
OnEnableAbilityListsStateChanged()974 void EnableAbilityListsObserverImpl::OnEnableAbilityListsStateChanged()
975 {
976     HILOG_DEBUG();
977     std::lock_guard<std::mutex> lock(mutex_);
978     for (auto &observer : enableAbilityListsObservers_) {
979         observer->OnEnableAbilityListsStateChanged();
980     }
981 }
982 
OnInstallAbilityListsStateChanged()983 void EnableAbilityListsObserverImpl::OnInstallAbilityListsStateChanged()
984 {
985     HILOG_DEBUG();
986     std::lock_guard<std::mutex> lock(mutex_);
987     for (auto &observer : installAbilityListsObservers_) {
988         if (observer) {
989             observer->OnEnableAbilityListsStateChanged();
990         } else {
991             HILOG_ERROR("observer is null");
992         }
993     }
994 }
995 
SubscribeObserver(napi_env env,napi_value observer)996 void EnableAbilityListsObserverImpl::SubscribeObserver(napi_env env, napi_value observer)
997 {
998     HILOG_DEBUG();
999     std::lock_guard<std::mutex> lock(mutex_);
1000     for (auto iter = enableAbilityListsObservers_.begin(); iter != enableAbilityListsObservers_.end();) {
1001         if (CheckObserverEqual(env, observer, (*iter)->env_, (*iter)->callback_)) {
1002             HILOG_DEBUG("Observer exist");
1003             return;
1004         } else {
1005             iter++;
1006         }
1007     }
1008 
1009     napi_ref callback = nullptr;
1010     napi_create_reference(env, observer, 1, &callback);
1011     std::shared_ptr<EnableAbilityListsObserver> observerPtr =
1012         std::make_shared<EnableAbilityListsObserver>(env, callback);
1013 
1014     enableAbilityListsObservers_.emplace_back(observerPtr);
1015     HILOG_DEBUG("observer size%{public}zu", enableAbilityListsObservers_.size());
1016 }
1017 
SubscribeInstallObserver(napi_env env,napi_value observer)1018 void EnableAbilityListsObserverImpl::SubscribeInstallObserver(napi_env env, napi_value observer)
1019 {
1020     HILOG_DEBUG();
1021     std::lock_guard<std::mutex> lock(mutex_);
1022     for (auto iter = installAbilityListsObservers_.begin(); iter != installAbilityListsObservers_.end();) {
1023         if (CheckObserverEqual(env, observer, (*iter)->env_, (*iter)->callback_)) {
1024             HILOG_DEBUG("Observer exist");
1025             return;
1026         } else {
1027             iter++;
1028         }
1029     }
1030 
1031     napi_ref callback = nullptr;
1032     napi_create_reference(env, observer, 1, &callback);
1033     std::shared_ptr<EnableAbilityListsObserver> observerPtr =
1034         std::make_shared<EnableAbilityListsObserver>(env, callback);
1035 
1036     installAbilityListsObservers_.emplace_back(observerPtr);
1037     HILOG_DEBUG("observer size%{public}zu", installAbilityListsObservers_.size());
1038 }
1039 
UnsubscribeObserver(napi_env env,napi_value observer)1040 void EnableAbilityListsObserverImpl::UnsubscribeObserver(napi_env env, napi_value observer)
1041 {
1042     HILOG_DEBUG();
1043     std::lock_guard<std::mutex> lock(mutex_);
1044     for (auto iter = enableAbilityListsObservers_.begin(); iter != enableAbilityListsObservers_.end();) {
1045         if (CheckObserverEqual(env, observer, (*iter)->env_, (*iter)->callback_)) {
1046             enableAbilityListsObservers_.erase(iter);
1047             return;
1048         } else {
1049             iter++;
1050         }
1051     }
1052 }
1053 
UnsubscribeObservers()1054 void EnableAbilityListsObserverImpl::UnsubscribeObservers()
1055 {
1056     HILOG_DEBUG();
1057     std::lock_guard<std::mutex> lock(mutex_);
1058     enableAbilityListsObservers_.clear();
1059 }
1060 
UnsubscribeInstallObserver(napi_env env,napi_value observer)1061 void EnableAbilityListsObserverImpl::UnsubscribeInstallObserver(napi_env env, napi_value observer)
1062 {
1063     HILOG_DEBUG();
1064     std::lock_guard<std::mutex> lock(mutex_);
1065     for (auto iter = installAbilityListsObservers_.begin(); iter != installAbilityListsObservers_.end();) {
1066         if (CheckObserverEqual(env, observer, (*iter)->env_, (*iter)->callback_)) {
1067             installAbilityListsObservers_.erase(iter);
1068             return;
1069         } else {
1070             iter++;
1071         }
1072     }
1073 }
1074 
UnsubscribeInstallObservers()1075 void EnableAbilityListsObserverImpl::UnsubscribeInstallObservers()
1076 {
1077     HILOG_DEBUG();
1078     std::lock_guard<std::mutex> lock(mutex_);
1079     installAbilityListsObservers_.clear();
1080 }
1081