• 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 "napi_accessibility_utils.h"
21 
22 using namespace OHOS;
23 using namespace OHOS::Accessibility;
24 using namespace OHOS::AccessibilityNapi;
25 using namespace OHOS::AccessibilityConfig;
26 
27 std::shared_ptr<NAccessibilityConfigObserverImpl> NAccessibilityConfig::configObservers_ =
28     std::make_shared<NAccessibilityConfigObserverImpl>();
29 std::shared_ptr<EnableAbilityListsObserverImpl> NAccessibilityConfig::enableAbilityListsObservers_ =
30     std::make_shared<EnableAbilityListsObserverImpl>();
31 
EnableAbility(napi_env env,napi_callback_info info)32 napi_value NAccessibilityConfig::EnableAbility(napi_env env, napi_callback_info info)
33 {
34     HILOG_INFO();
35     NAccessibilityConfigData* callbackInfo = new(std::nothrow) NAccessibilityConfigData();
36     if (!callbackInfo) {
37         HILOG_ERROR("callbackInfo is nullptr");
38         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_NULLPTR);
39         napi_throw(env, err);
40         return nullptr;
41     }
42 
43     size_t argc = ARGS_SIZE_THREE;
44     napi_value parameters[ARGS_SIZE_THREE] = {0};
45     napi_get_cb_info(env, info, &argc, parameters, nullptr, nullptr);
46 
47     OHOS::Accessibility::RetError errCode = OHOS::Accessibility::RET_OK;
48     if (argc < ARGS_SIZE_THREE - 1) {
49         HILOG_ERROR("argc is invalid: %{public}zu", argc);
50         errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
51     }
52 
53     if (errCode == OHOS::Accessibility::RET_OK) {
54         // parse name
55         std::string ability = "";
56         if (ParseString(env, ability, parameters[PARAM0])) {
57             HILOG_INFO("ability = %{private}s", ability.c_str());
58             callbackInfo->abilityName_ = ability;
59         } else {
60             errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
61         }
62 
63         // parse capability
64         if (!ConvertJSToCapabilities(env, parameters[PARAM1], callbackInfo->capabilities_)) {
65             HILOG_ERROR("convert capabilities failed");
66             errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
67         }
68     }
69 
70     if (errCode == OHOS::Accessibility::RET_ERR_INVALID_PARAM) {
71         delete callbackInfo;
72         callbackInfo = nullptr;
73         napi_value err = CreateBusinessError(env, errCode);
74         HILOG_ERROR("invalid param");
75         napi_throw(env, err);
76         return nullptr;
77     }
78 
79     napi_value promise = nullptr;
80     if (argc > ARGS_SIZE_THREE - 1 && CheckJsFunction(env, parameters[PARAM2])) {
81         napi_create_reference(env, parameters[PARAM2], 1, &callbackInfo->callback_);
82         napi_get_undefined(env, &promise);
83     } else {
84         napi_create_promise(env, &callbackInfo->deferred_, &promise);
85     }
86 
87     napi_value resource = nullptr;
88     napi_create_string_utf8(env, "EnableAbility", NAPI_AUTO_LENGTH, &resource);
89 
90     napi_create_async_work(env, nullptr, resource,
91         // Execute async to call c++ function
92         [](napi_env env, void* data) {
93             NAccessibilityConfigData* callbackInfo = static_cast<NAccessibilityConfigData*>(data);
94             auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
95             if (callbackInfo->capabilities_ != 0) {
96                 callbackInfo->ret_ = instance.EnableAbility(
97                     callbackInfo->abilityName_, callbackInfo->capabilities_);
98             }
99         }, NAccessibilityConfig::AsyncWorkComplete, reinterpret_cast<void*>(callbackInfo), &callbackInfo->work_);
100     napi_queue_async_work(env, callbackInfo->work_);
101     return promise;
102 }
103 
DisableAbility(napi_env env,napi_callback_info info)104 napi_value NAccessibilityConfig::DisableAbility(napi_env env, napi_callback_info info)
105 {
106     HILOG_INFO();
107     NAccessibilityConfigData* callbackInfo = new(std::nothrow) NAccessibilityConfigData();
108     if (!callbackInfo) {
109         HILOG_ERROR("callbackInfo is nullptr");
110         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_NULLPTR);
111         napi_throw(env, err);
112         return nullptr;
113     }
114 
115     size_t argc = ARGS_SIZE_TWO;
116     napi_value parameters[ARGS_SIZE_TWO] = {0};
117     napi_get_cb_info(env, info, &argc, parameters, nullptr, nullptr);
118 
119     OHOS::Accessibility::RetError errCode = OHOS::Accessibility::RET_OK;
120     if (argc < ARGS_SIZE_TWO - 1) {
121         HILOG_ERROR("argc is invalid: %{public}zu", argc);
122         errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
123     }
124 
125     if (errCode == OHOS::Accessibility::RET_OK) {
126         // parse name
127         std::string ability = "";
128         if (ParseString(env, ability, parameters[PARAM0])) {
129             HILOG_INFO("ability = %{private}s", ability.c_str());
130             callbackInfo->abilityName_ = ability;
131         } else {
132             errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
133         }
134     }
135 
136     if (errCode == OHOS::Accessibility::RET_ERR_INVALID_PARAM) {
137         delete callbackInfo;
138         callbackInfo = nullptr;
139         napi_value err = CreateBusinessError(env, errCode);
140         HILOG_ERROR("invalid param");
141         napi_throw(env, err);
142         return nullptr;
143     }
144 
145     napi_value promise = nullptr;
146     if (argc > ARGS_SIZE_TWO - 1 && CheckJsFunction(env, parameters[PARAM1])) {
147         napi_create_reference(env, parameters[PARAM1], 1, &callbackInfo->callback_);
148         napi_get_undefined(env, &promise);
149     } else {
150         napi_create_promise(env, &callbackInfo->deferred_, &promise);
151     }
152 
153     napi_value resource = nullptr;
154     napi_create_string_utf8(env, "DisableAbility", NAPI_AUTO_LENGTH, &resource);
155 
156     napi_create_async_work(env, nullptr, resource,
157         // Execute async to call c++ function
158         [](napi_env env, void* data) {
159             NAccessibilityConfigData* callbackInfo = static_cast<NAccessibilityConfigData*>(data);
160             auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
161             if (callbackInfo) {
162                 callbackInfo->ret_ = instance.DisableAbility(callbackInfo->abilityName_);
163             }
164         }, NAccessibilityConfig::AsyncWorkComplete,
165         reinterpret_cast<void*>(callbackInfo), &callbackInfo->work_);
166     napi_queue_async_work(env, callbackInfo->work_);
167     return promise;
168 }
169 
SubscribeState(napi_env env,napi_callback_info info)170 napi_value NAccessibilityConfig::SubscribeState(napi_env env, napi_callback_info info)
171 {
172     HILOG_INFO();
173     size_t argc = ARGS_SIZE_TWO;
174     napi_value args[ARGS_SIZE_TWO] = {0};
175     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
176 
177     OHOS::Accessibility::RetError errCode = OHOS::Accessibility::RET_OK;
178     if (argc < ARGS_SIZE_TWO) {
179         HILOG_ERROR("argc is invalid: %{public}zu", argc);
180         errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
181     }
182 
183     if (errCode == OHOS::Accessibility::RET_OK) {
184         std::string observerType = "";
185         if (!ParseString(env, observerType, args[PARAM0])) {
186             HILOG_ERROR("observer type parse failed");
187             errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
188         } else {
189             if (std::strcmp(observerType.c_str(), "enabledAccessibilityExtensionListChange") != 0) {
190                 HILOG_ERROR("args[PARAM0] is wrong[%{public}s", observerType.c_str());
191                 errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
192             }
193         }
194     }
195 
196     if (errCode == OHOS::Accessibility::RET_OK) {
197         napi_valuetype valueType = napi_null;
198         napi_typeof(env, args[PARAM1], &valueType);
199         if (valueType != napi_function) {
200             HILOG_ERROR("args[PARAM1] format is wrong");
201             errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
202         }
203     }
204 
205     if (errCode == OHOS::Accessibility::RET_ERR_INVALID_PARAM) {
206         napi_value err = CreateBusinessError(env, errCode);
207         HILOG_ERROR("invalid param");
208         napi_throw(env, err);
209         return nullptr;
210     }
211 
212     enableAbilityListsObservers_->SubscribeObserver(env, args[PARAM1]);
213     return nullptr;
214 }
215 
UnsubscribeState(napi_env env,napi_callback_info info)216 napi_value NAccessibilityConfig::UnsubscribeState(napi_env env, napi_callback_info info)
217 {
218     HILOG_INFO();
219     size_t argc = ARGS_SIZE_TWO;
220     napi_value args[ARGS_SIZE_TWO] = {0};
221     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
222 
223     OHOS::Accessibility::RetError errCode = OHOS::Accessibility::RET_OK;
224     if (argc < ARGS_SIZE_TWO - 1) {
225         HILOG_ERROR("argc is invalid: %{public}zu", argc);
226         errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
227     }
228 
229     if (errCode == OHOS::Accessibility::RET_OK) {
230         std::string observerType = "";
231         if (!ParseString(env, observerType, args[PARAM0])) {
232             HILOG_ERROR("observer type parse failed");
233             errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
234         } else {
235             if (std::strcmp(observerType.c_str(), "enabledAccessibilityExtensionListChange") != 0) {
236                 HILOG_ERROR("args[PARAM0] is wrong[%{public}s", observerType.c_str());
237                 errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
238             }
239         }
240     }
241 
242     if (errCode == OHOS::Accessibility::RET_ERR_INVALID_PARAM) {
243         napi_value err = CreateBusinessError(env, errCode);
244         HILOG_ERROR("invalid param");
245         napi_throw(env, err);
246         return nullptr;
247     }
248 
249     if (argc > ARGS_SIZE_TWO - 1 && CheckJsFunction(env, args[PARAM1])) {
250         enableAbilityListsObservers_->UnsubscribeObserver(env, args[PARAM1]);
251     } else {
252         enableAbilityListsObservers_->UnsubscribeObservers();
253     }
254     return nullptr;
255 }
256 
AsyncWorkComplete(napi_env env,napi_status status,void * data)257 void NAccessibilityConfig::AsyncWorkComplete(napi_env env, napi_status status, void* data)
258 {
259     HILOG_INFO();
260     NAccessibilityConfigData* callbackInfo = static_cast<NAccessibilityConfigData*>(data);
261     if (!callbackInfo) {
262         HILOG_ERROR("callbackInfo is nullptr");
263         return;
264     }
265     napi_value result[ARGS_SIZE_ONE] = {0};
266     napi_value callback = 0;
267     napi_value returnVal = 0;
268     napi_value undefined = 0;
269     napi_get_undefined(env, &undefined);
270     result[PARAM0] = CreateBusinessError(env, callbackInfo->ret_);
271     if (callbackInfo->callback_) {
272         napi_get_reference_value(env, callbackInfo->callback_, &callback);
273         napi_call_function(env, undefined, callback, ARGS_SIZE_ONE, result, &returnVal);
274         napi_delete_reference(env, callbackInfo->callback_);
275         HILOG_DEBUG("complete function callback mode");
276     } else {
277         if (callbackInfo->ret_ == OHOS::Accessibility::RET_OK) {
278             napi_resolve_deferred(env, callbackInfo->deferred_, undefined);
279         } else {
280             napi_reject_deferred(env, callbackInfo->deferred_, result[PARAM0]);
281         }
282         HILOG_DEBUG("complete function promise mode");
283     }
284     napi_delete_async_work(env, callbackInfo->work_);
285     delete callbackInfo;
286     callbackInfo = nullptr;
287 }
288 
SetConfigExecute(napi_env env,void * data)289 void NAccessibilityConfig::SetConfigExecute(napi_env env, void* data)
290 {
291     HILOG_INFO();
292     NAccessibilityConfigData* callbackInfo = static_cast<NAccessibilityConfigData*>(data);
293     if (!callbackInfo) {
294         HILOG_ERROR("callbackInfo is nullptr");
295         return;
296     }
297     auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
298     switch (callbackInfo->id_) {
299         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_HIGH_CONTRAST_TEXT:
300             callbackInfo->ret_ = instance.SetHighContrastTextState(callbackInfo->boolConfig_);
301             break;
302         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_INVERT_COLOR:
303             callbackInfo->ret_ = instance.SetInvertColorState(callbackInfo->boolConfig_);
304             break;
305         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_ANIMATION_OFF:
306             callbackInfo->ret_ = instance.SetAnimationOffState(callbackInfo->boolConfig_);
307             break;
308         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SCREEN_MAGNIFICATION:
309             callbackInfo->ret_ = instance.SetScreenMagnificationState(callbackInfo->boolConfig_);
310             break;
311         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_AUDIO_MONO:
312             callbackInfo->ret_ = instance.SetAudioMonoState(callbackInfo->boolConfig_);
313             break;
314         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_MOUSE_KEY:
315             callbackInfo->ret_ = instance.SetMouseKeyState(callbackInfo->boolConfig_);
316             break;
317         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY:
318             callbackInfo->ret_ = instance.SetShortKeyState(callbackInfo->boolConfig_);
319             break;
320         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CAPTION_STATE:
321             callbackInfo->ret_ = instance.SetCaptionsState(callbackInfo->boolConfig_);
322             break;
323         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CONTENT_TIMEOUT:
324             callbackInfo->ret_ = instance.SetContentTimeout(callbackInfo->uint32Config_);
325             break;
326         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_MOUSE_AUTOCLICK:
327             callbackInfo->ret_ = instance.SetMouseAutoClick(callbackInfo->int32Config_);
328             break;
329         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_AUDIO_BALANCE:
330             callbackInfo->ret_ = instance.SetAudioBalance(callbackInfo->floatConfig_);
331             break;
332         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_BRIGHTNESS_DISCOUNT:
333             callbackInfo->ret_ = instance.SetBrightnessDiscount(callbackInfo->floatConfig_);
334             break;
335         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_DALTONIZATION_COLOR_FILTER:
336             {
337                 auto filter = ConvertStringToDaltonizationTypes(callbackInfo->stringConfig_);
338                 callbackInfo->ret_ = instance.SetDaltonizationColorFilter(filter);
339             }
340             break;
341         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY_TARGET:
342             callbackInfo->ret_ = instance.SetShortkeyTarget(callbackInfo->stringConfig_);
343             break;
344         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CAPTION_STYLE:
345             callbackInfo->ret_ = instance.SetCaptionsProperty(callbackInfo->captionProperty_);
346             break;
347         default:
348             break;
349     }
350 }
351 
GetConfigComplete(napi_env env,napi_status status,void * data)352 void NAccessibilityConfig::GetConfigComplete(napi_env env, napi_status status, void* data)
353 {
354     HILOG_INFO();
355     NAccessibilityConfigData* callbackInfo = static_cast<NAccessibilityConfigData*>(data);
356     if (!callbackInfo) {
357         HILOG_ERROR("callbackInfo is nullptr");
358         return;
359     }
360     HILOG_INFO("callbackInfo->id_ = %{public}d", callbackInfo->id_);
361     napi_value result[ARGS_SIZE_TWO] = {0};
362     switch (callbackInfo->id_) {
363         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_HIGH_CONTRAST_TEXT:
364         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_INVERT_COLOR:
365         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_ANIMATION_OFF:
366         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SCREEN_MAGNIFICATION:
367         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_AUDIO_MONO:
368         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_MOUSE_KEY:
369         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY:
370         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CAPTION_STATE:
371             napi_get_boolean(env, callbackInfo->boolConfig_, &result[PARAM1]);
372             break;
373         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CONTENT_TIMEOUT:
374         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_MOUSE_AUTOCLICK:
375             napi_create_int32(env, callbackInfo->int32Config_, &result[PARAM1]);
376             break;
377         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_AUDIO_BALANCE:
378         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_BRIGHTNESS_DISCOUNT:
379             napi_create_double(env, static_cast<double>(callbackInfo->floatConfig_), &result[PARAM1]);
380             break;
381         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_DALTONIZATION_COLOR_FILTER:
382         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY_TARGET:
383             napi_create_string_utf8(env, callbackInfo->stringConfig_.c_str(), NAPI_AUTO_LENGTH, &result[PARAM1]);
384             break;
385         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CAPTION_STYLE:
386             napi_create_object(env, &result[PARAM1]);
387             ConvertCaptionPropertyToJS(env, result[PARAM1], callbackInfo->captionProperty_);
388             break;
389         default:
390             break;
391     }
392 
393     napi_value returnVal = 0;
394     napi_value callback = 0;
395     napi_value undefined = 0;
396     napi_get_undefined(env, &undefined);
397     result[PARAM0] = CreateBusinessError(env, callbackInfo->ret_);
398     if (callbackInfo->callback_) {
399         napi_get_reference_value(env, callbackInfo->callback_, &callback);
400         napi_call_function(env, undefined, callback, ARGS_SIZE_TWO, result, &returnVal);
401         napi_delete_reference(env, callbackInfo->callback_);
402         HILOG_DEBUG("complete function callback mode");
403     } else {
404         if (callbackInfo->ret_ == OHOS::Accessibility::RET_OK) {
405             napi_resolve_deferred(env, callbackInfo->deferred_, result[PARAM1]);
406         } else {
407             napi_reject_deferred(env, callbackInfo->deferred_, result[PARAM0]);
408         }
409     }
410     napi_delete_async_work(env, callbackInfo->work_);
411     delete callbackInfo;
412     callbackInfo = nullptr;
413 }
414 
GetConfigExecute(napi_env env,void * data)415 void NAccessibilityConfig::GetConfigExecute(napi_env env, void* data)
416 {
417     HILOG_INFO();
418     NAccessibilityConfigData* callbackInfo = static_cast<NAccessibilityConfigData*>(data);
419     if (!callbackInfo) {
420         HILOG_ERROR("callbackInfo is nullptr");
421         return;
422     }
423     auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
424     switch (callbackInfo->id_) {
425         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_HIGH_CONTRAST_TEXT:
426             callbackInfo->ret_ = instance.GetHighContrastTextState(callbackInfo->boolConfig_);
427             break;
428         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_INVERT_COLOR:
429             callbackInfo->ret_ = instance.GetInvertColorState(callbackInfo->boolConfig_);
430             break;
431         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_ANIMATION_OFF:
432             callbackInfo->ret_ = instance.GetAnimationOffState(callbackInfo->boolConfig_);
433             break;
434         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SCREEN_MAGNIFICATION:
435             callbackInfo->ret_ = instance.GetScreenMagnificationState(callbackInfo->boolConfig_);
436             break;
437         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_AUDIO_MONO:
438             callbackInfo->ret_ = instance.GetAudioMonoState(callbackInfo->boolConfig_);
439             break;
440         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_MOUSE_KEY:
441             callbackInfo->ret_ = instance.GetMouseKeyState(callbackInfo->boolConfig_);
442             break;
443         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY:
444             callbackInfo->ret_ = instance.GetShortKeyState(callbackInfo->boolConfig_);
445             break;
446         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CAPTION_STATE:
447             callbackInfo->ret_ = instance.GetCaptionsState(callbackInfo->boolConfig_);
448             break;
449         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CONTENT_TIMEOUT:
450             {
451                 uint32_t timeout = 0;
452                 callbackInfo->ret_ = instance.GetContentTimeout(timeout);
453                 callbackInfo->int32Config_ = static_cast<int32_t>(timeout);
454             }
455             break;
456         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_MOUSE_AUTOCLICK:
457             callbackInfo->ret_ = instance.GetMouseAutoClick(callbackInfo->int32Config_);
458             break;
459         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_AUDIO_BALANCE:
460             callbackInfo->ret_ = instance.GetAudioBalance(callbackInfo->floatConfig_);
461             break;
462         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_BRIGHTNESS_DISCOUNT:
463             callbackInfo->ret_ = instance.GetBrightnessDiscount(callbackInfo->floatConfig_);
464             break;
465         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_DALTONIZATION_COLOR_FILTER:
466             {
467                 OHOS::AccessibilityConfig::DALTONIZATION_TYPE type;
468                 callbackInfo->ret_ = instance.GetDaltonizationColorFilter(type);
469                 callbackInfo->stringConfig_ = ConvertDaltonizationTypeToString(type);
470             }
471             break;
472         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY_TARGET:
473             callbackInfo->ret_ = instance.GetShortkeyTarget(callbackInfo->stringConfig_);
474             break;
475         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CAPTION_STYLE:
476             callbackInfo->ret_ = instance.GetCaptionsProperty(callbackInfo->captionProperty_);
477             break;
478         default:
479             break;
480     }
481 }
482 
SetConfig(napi_env env,napi_callback_info info)483 napi_value NAccessibilityConfig::SetConfig(napi_env env, napi_callback_info info)
484 {
485     HILOG_INFO();
486     size_t argc = ARGS_SIZE_TWO;
487     napi_value parameters[ARGS_SIZE_TWO] = {0};
488     napi_value jsthis;
489     napi_get_cb_info(env, info, &argc, parameters, &jsthis, nullptr);
490 
491     NAccessibilityConfigClass* obj;
492     napi_status status = napi_unwrap(env, jsthis, reinterpret_cast<void**>(&obj));
493     if (status != napi_ok) {
494         HILOG_ERROR("Failed to get unwrap obj");
495         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_FAILED);
496         napi_throw(env, err);
497         return nullptr;
498     }
499     if (!obj) {
500         HILOG_ERROR("obj is nullptr");
501         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_NULLPTR);
502         napi_throw(env, err);
503         return nullptr;
504     }
505     HILOG_INFO("ConfigID = %{public}d", obj->GetConfigId());
506     NAccessibilityConfigData* callbackInfo = new(std::nothrow) NAccessibilityConfigData();
507     if (!callbackInfo) {
508         HILOG_ERROR("callbackInfo is nullptr");
509         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_NULLPTR);
510         napi_throw(env, err);
511         return nullptr;
512     }
513     OHOS::Accessibility::RetError errCode = OHOS::Accessibility::RET_OK;
514     if (argc < ARGS_SIZE_TWO - 1) {
515         HILOG_ERROR("argc is invalid: %{public}zu", argc);
516         errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
517     }
518     if (errCode == OHOS::Accessibility::RET_OK) {
519         bool ret = false;
520         switch (obj->GetConfigId()) {
521             case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_HIGH_CONTRAST_TEXT:
522             case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_INVERT_COLOR:
523             case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_ANIMATION_OFF:
524             case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SCREEN_MAGNIFICATION:
525             case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_AUDIO_MONO:
526             case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_MOUSE_KEY:
527             case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY:
528             case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CAPTION_STATE:
529                 {
530                     bool state = false;
531                     ret = ParseBool(env, state, parameters[PARAM0]);
532                     callbackInfo->boolConfig_ = state;
533                 }
534                 break;
535             case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CONTENT_TIMEOUT:
536                 {
537                     int32_t timeout = 0;
538                     ret = ParseInt32(env, timeout, parameters[PARAM0]);
539                     callbackInfo->uint32Config_ = static_cast<uint32_t>(timeout);
540                 }
541                 break;
542             case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_MOUSE_AUTOCLICK:
543                 {
544                     int32_t time = 0;
545                     ret = ParseInt32(env, time, parameters[PARAM0]);
546                     callbackInfo->int32Config_ = time;
547                 }
548                 break;
549             case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_AUDIO_BALANCE:
550             case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_BRIGHTNESS_DISCOUNT:
551                 {
552                     double doubleTemp = 0;
553                     ret = ParseDouble(env, doubleTemp, parameters[PARAM0]);
554                     callbackInfo->floatConfig_ = static_cast<float>(doubleTemp);
555                 }
556                 break;
557             case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_DALTONIZATION_COLOR_FILTER:
558             case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY_TARGET:
559                 {
560                     std::string target = "";
561                     ret = ParseString(env, target, parameters[PARAM0]) && target.length() > 0;
562                     callbackInfo->stringConfig_ = target;
563                 }
564                 break;
565             case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CAPTION_STYLE:
566                 ret = ConvertObjToCaptionProperty(env, parameters[PARAM0], &callbackInfo->captionProperty_);
567                 break;
568             default:
569                 break;
570         }
571         if (!ret) {
572             errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
573         }
574     }
575     if (errCode == OHOS::Accessibility::RET_ERR_INVALID_PARAM) {
576         delete callbackInfo;
577         callbackInfo = nullptr;
578         napi_value err = CreateBusinessError(env, errCode);
579         HILOG_ERROR("invalid param");
580         napi_throw(env, err);
581         return nullptr;
582     }
583     callbackInfo->id_ = obj->GetConfigId();
584 
585     // parse function if it needs
586     napi_value promise = nullptr;
587     if (argc >= ARGS_SIZE_TWO && CheckJsFunction(env, parameters[PARAM1])) {
588         napi_create_reference(env, parameters[PARAM1], 1, &callbackInfo->callback_);
589         napi_get_undefined(env, &promise);
590     } else {
591         napi_create_promise(env, &callbackInfo->deferred_, &promise);
592     }
593     napi_value resource = nullptr;
594     napi_create_string_utf8(env, "SetConfig", NAPI_AUTO_LENGTH, &resource);
595 
596     napi_create_async_work(env, nullptr, resource,
597         // Execute async to call c++ function
598         NAccessibilityConfig::SetConfigExecute,
599         // Execute the complete function
600         NAccessibilityConfig::AsyncWorkComplete,
601         reinterpret_cast<void*>(callbackInfo),
602         &callbackInfo->work_);
603     napi_queue_async_work(env, callbackInfo->work_);
604     return promise;
605 }
606 
607 
GetConfig(napi_env env,napi_callback_info info)608 napi_value NAccessibilityConfig::GetConfig(napi_env env, napi_callback_info info)
609 {
610     HILOG_INFO();
611     size_t argc = ARGS_SIZE_ONE;
612     napi_value parameters[ARGS_SIZE_ONE] = {0};
613     napi_value jsthis;
614     napi_get_cb_info(env, info, &argc, parameters, &jsthis, nullptr);
615 
616     NAccessibilityConfigClass* obj;
617     napi_status status = napi_unwrap(env, jsthis, reinterpret_cast<void**>(&obj));
618     if (status != napi_ok) {
619         HILOG_ERROR("Failed to get unwrap obj");
620         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_FAILED);
621         napi_throw(env, err);
622         return nullptr;
623     }
624     if (!obj) {
625         HILOG_ERROR("obj is nullptr");
626         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_NULLPTR);
627         napi_throw(env, err);
628         return nullptr;
629     }
630     HILOG_INFO("ConfigID = %{public}d", obj->GetConfigId());
631 
632     NAccessibilityConfigData* callbackInfo = new(std::nothrow) NAccessibilityConfigData();
633     if (!callbackInfo) {
634         HILOG_ERROR("callbackInfo is nullptr");
635         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_NULLPTR);
636         napi_throw(env, err);
637         return nullptr;
638     }
639     callbackInfo->id_ = obj->GetConfigId();
640 
641     // parse function if it needs
642     napi_value promise = nullptr;
643     if (argc >= ARGS_SIZE_ONE && CheckJsFunction(env, parameters[PARAM0])) {
644         napi_create_reference(env, parameters[PARAM0], 1, &callbackInfo->callback_);
645         napi_get_undefined(env, &promise);
646     } else {
647         napi_create_promise(env, &callbackInfo->deferred_, &promise);
648     }
649     napi_value resource = nullptr;
650     napi_create_string_utf8(env, "GetConfig", NAPI_AUTO_LENGTH, &resource);
651 
652     napi_create_async_work(env, nullptr, resource,
653         // Execute async to call c++ function
654         NAccessibilityConfig::GetConfigExecute,
655         // Execute the complete function
656         NAccessibilityConfig::GetConfigComplete,
657         reinterpret_cast<void*>(callbackInfo),
658         &callbackInfo->work_);
659     napi_queue_async_work(env, callbackInfo->work_);
660     return promise;
661 }
662 
SubscribeConfigObserver(napi_env env,napi_callback_info info)663 napi_value NAccessibilityConfig::SubscribeConfigObserver(napi_env env, napi_callback_info info)
664 {
665     HILOG_INFO();
666     size_t argc = ARGS_SIZE_ONE;
667     napi_value parameters[ARGS_SIZE_ONE] = {0};
668     napi_value jsthis;
669     napi_get_cb_info(env, info, &argc, parameters, &jsthis, nullptr);
670     NAccessibilityConfigClass* obj;
671     napi_status status = napi_unwrap(env, jsthis, reinterpret_cast<void**>(&obj));
672     if (status != napi_ok) {
673         HILOG_ERROR("Failed to get unwrap obj");
674         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_FAILED);
675         napi_throw(env, err);
676         return nullptr;
677     }
678     if (!obj) {
679         HILOG_ERROR("obj is nullptr");
680         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_NULLPTR);
681         napi_throw(env, err);
682         return nullptr;
683     }
684 
685     OHOS::Accessibility::RetError errCode = OHOS::Accessibility::RET_OK;
686     if (argc < ARGS_SIZE_ONE) {
687         HILOG_ERROR("argc is invalid: %{public}zu", argc);
688         errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
689     }
690 
691     if (errCode == OHOS::Accessibility::RET_OK) {
692         napi_valuetype valueType = napi_null;
693         napi_typeof(env, parameters[PARAM0], &valueType);
694         if (valueType != napi_function) {
695             HILOG_ERROR("parameters[PARAM1] format is wrong");
696             errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
697         }
698     }
699 
700     if (errCode == OHOS::Accessibility::RET_ERR_INVALID_PARAM) {
701         napi_value err = CreateBusinessError(env, errCode);
702         HILOG_ERROR("invalid param");
703         napi_throw(env, err);
704         return nullptr;
705     }
706 
707     configObservers_->SubscribeObserver(env, obj->GetConfigId(), parameters[PARAM0]);
708     return nullptr;
709 }
710 
UnSubscribeConfigObserver(napi_env env,napi_callback_info info)711 napi_value NAccessibilityConfig::UnSubscribeConfigObserver(napi_env env, napi_callback_info info)
712 {
713     HILOG_INFO();
714     napi_value jsthis;
715     size_t argc = ARGS_SIZE_ONE;
716     napi_value parameters[ARGS_SIZE_ONE] = {0};
717     napi_get_cb_info(env, info, &argc, parameters, &jsthis, nullptr);
718     NAccessibilityConfigClass* obj;
719     napi_status status = napi_unwrap(env, jsthis, reinterpret_cast<void**>(&obj));
720     if (status != napi_ok) {
721         HILOG_ERROR("Failed to get unwrap obj");
722         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_FAILED);
723         napi_throw(env, err);
724         return nullptr;
725     }
726     if (!obj) {
727         HILOG_ERROR("obj is nullptr");
728         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_NULLPTR);
729         napi_throw(env, err);
730         return nullptr;
731     }
732     if (argc >= ARGS_SIZE_ONE && CheckJsFunction(env, parameters[PARAM0])) {
733         configObservers_->UnsubscribeObserver(env, obj->GetConfigId(), parameters[PARAM0]);
734     } else {
735         configObservers_->UnsubscribeObservers(obj->GetConfigId());
736     }
737 
738     return nullptr;
739 }
740 
OnEnableAbilityListsStateChanged()741 void EnableAbilityListsObserver::OnEnableAbilityListsStateChanged()
742 {
743     HILOG_INFO();
744 
745     AccessibilityCallbackInfo *callbackInfo = new(std::nothrow) AccessibilityCallbackInfo();
746     if (!callbackInfo) {
747         HILOG_ERROR("callbackInfo is nullptr");
748         return;
749     }
750 
751     uv_work_t *work = new(std::nothrow) uv_work_t;
752     if (!work) {
753         HILOG_ERROR("Failed to create work.");
754         delete callbackInfo;
755         callbackInfo = nullptr;
756         return;
757     }
758 
759     callbackInfo->env_ = env_;
760     callbackInfo->ref_ = callback_;
761     work->data = static_cast<void*>(callbackInfo);
762 
763     uv_loop_s *loop = nullptr;
764     napi_get_uv_event_loop(env_, &loop);
765     int ret = uv_queue_work(
766         loop,
767         work,
768         [](uv_work_t *work) {},
769         [](uv_work_t *work, int status) {
770             AccessibilityCallbackInfo *callbackInfo = static_cast<AccessibilityCallbackInfo*>(work->data);
771             napi_value handler = nullptr;
772             napi_value callResult = nullptr;
773             napi_value jsEvent = nullptr;
774             napi_value undefined = nullptr;
775             napi_get_reference_value(callbackInfo->env_, callbackInfo->ref_, &handler);
776             napi_get_undefined(callbackInfo->env_, &undefined);
777             napi_call_function(callbackInfo->env_, undefined, handler, 1, &jsEvent, &callResult);
778             delete callbackInfo;
779             callbackInfo = nullptr;
780             delete work;
781             work = nullptr;
782         });
783     if (ret != 0) {
784         HILOG_ERROR("Failed to execute OnEnableAbilityListsStateChanged work queue");
785         delete callbackInfo;
786         callbackInfo = nullptr;
787         delete work;
788         work = nullptr;
789     }
790 }
791 
SubscribeToFramework()792 void EnableAbilityListsObserverImpl::SubscribeToFramework()
793 {
794     auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
795     instance.SubscribeEnableAbilityListsObserver(shared_from_this());
796 }
797 
OnEnableAbilityListsStateChanged()798 void EnableAbilityListsObserverImpl::OnEnableAbilityListsStateChanged()
799 {
800     HILOG_INFO();
801     std::lock_guard<std::mutex> lock(mutex_);
802     for (auto &observer : enableAbilityListsObservers_) {
803         observer->OnEnableAbilityListsStateChanged();
804     }
805 }
806 
SubscribeObserver(napi_env env,napi_value observer)807 void EnableAbilityListsObserverImpl::SubscribeObserver(napi_env env, napi_value observer)
808 {
809     HILOG_INFO();
810     std::lock_guard<std::mutex> lock(mutex_);
811     for (auto iter = enableAbilityListsObservers_.begin(); iter != enableAbilityListsObservers_.end();) {
812         if (CheckObserverEqual(env, observer, (*iter)->env_, (*iter)->callback_)) {
813             HILOG_DEBUG("Observer exist");
814             return;
815         } else {
816             iter++;
817         }
818     }
819 
820     napi_ref callback = nullptr;
821     napi_create_reference(env, observer, 1, &callback);
822     std::shared_ptr<EnableAbilityListsObserver> observerPtr =
823         std::make_shared<EnableAbilityListsObserver>(env, callback);
824 
825     enableAbilityListsObservers_.emplace_back(observerPtr);
826     HILOG_INFO("observer size%{public}zu", enableAbilityListsObservers_.size());
827 }
828 
UnsubscribeObserver(napi_env env,napi_value observer)829 void EnableAbilityListsObserverImpl::UnsubscribeObserver(napi_env env, napi_value observer)
830 {
831     HILOG_INFO();
832     std::lock_guard<std::mutex> lock(mutex_);
833     for (auto iter = enableAbilityListsObservers_.begin(); iter != enableAbilityListsObservers_.end();) {
834         if (CheckObserverEqual(env, observer, (*iter)->env_, (*iter)->callback_)) {
835             enableAbilityListsObservers_.erase(iter);
836             return;
837         } else {
838             iter++;
839         }
840     }
841 }
842 
UnsubscribeObservers()843 void EnableAbilityListsObserverImpl::UnsubscribeObservers()
844 {
845     HILOG_INFO();
846     std::lock_guard<std::mutex> lock(mutex_);
847     enableAbilityListsObservers_.clear();
848 }