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