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