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 <cstdio>
17 #include <cstring>
18 #include <pthread.h>
19 #include <unistd.h>
20
21 #include "hilog_wrapper.h"
22 #include "napi_accessibility_config.h"
23 #include "napi/native_api.h"
24 #include "napi/native_node_api.h"
25 #include "accessibility_config.h"
26
27 EXTERN_C_START
28 /*
29 * function for module exports
30 */
31 static napi_property_descriptor configDesc[] = {
32 DECLARE_NAPI_FUNCTION("set", NAccessibilityConfig::SetConfig),
33 DECLARE_NAPI_FUNCTION("get", NAccessibilityConfig::GetConfig),
34 DECLARE_NAPI_FUNCTION("on", NAccessibilityConfig::SubscribeConfigObserver),
35 DECLARE_NAPI_FUNCTION("off", NAccessibilityConfig::UnSubscribeConfigObserver),
36 };
37
InitHighContrastText(napi_env env)38 static napi_value InitHighContrastText(napi_env env)
39 {
40 napi_value highContrastTextValue = nullptr;
41 napi_create_object(env, &highContrastTextValue);
42 if (highContrastTextValue == nullptr) {
43 HILOG_ERROR("napi_create_object fail.");
44 return highContrastTextValue;
45 }
46 NAPI_CALL(env, napi_define_properties(env, highContrastTextValue,
47 sizeof(configDesc) / sizeof(configDesc[0]),
48 configDesc));
49 NAccessibilityConfigClass* nativeObj =
50 new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_HIGH_CONTRAST_TEXT);
51 if (!nativeObj) {
52 HILOG_ERROR("Failed to create nativeObj.");
53 return nullptr;
54 }
55 nativeObj->SetEnv(env);
56 NAPI_CALL(env, napi_wrap(env, highContrastTextValue, reinterpret_cast<void*>(nativeObj),
57 NAccessibilityConfigClass::Destructor, nullptr, nullptr));
58 return highContrastTextValue;
59 }
60
InitInvertColor(napi_env env)61 static napi_value InitInvertColor(napi_env env)
62 {
63 napi_value invertColorValue = nullptr;
64 napi_create_object(env, &invertColorValue);
65 if (invertColorValue == nullptr) {
66 HILOG_ERROR("napi_create_object fail.");
67 return invertColorValue;
68 }
69 NAPI_CALL(env, napi_define_properties(env, invertColorValue,
70 sizeof(configDesc) / sizeof(configDesc[0]),
71 configDesc));
72 NAccessibilityConfigClass* nativeObj =
73 new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_INVERT_COLOR);
74 if (!nativeObj) {
75 HILOG_ERROR("Failed to create nativeObj.");
76 return nullptr;
77 }
78 nativeObj->SetEnv(env);
79 NAPI_CALL(env, napi_wrap(env, invertColorValue, reinterpret_cast<void*>(nativeObj),
80 NAccessibilityConfigClass::Destructor, nullptr, nullptr));
81 return invertColorValue;
82 }
83
InitDaltonizationState(napi_env env)84 static napi_value InitDaltonizationState(napi_env env)
85 {
86 napi_value daltonizationStateValue = nullptr;
87 napi_create_object(env, &daltonizationStateValue);
88 if (daltonizationStateValue == nullptr) {
89 HILOG_ERROR("napi_create_object fail.");
90 return daltonizationStateValue;
91 }
92 NAPI_CALL(env, napi_define_properties(env, daltonizationStateValue,
93 sizeof(configDesc) / sizeof(configDesc[0]),
94 configDesc));
95 NAccessibilityConfigClass* nativeObj =
96 new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_DALTONIZATION_STATE);
97 if (!nativeObj) {
98 HILOG_ERROR("Failed to create nativeObj.");
99 return nullptr;
100 }
101 nativeObj->SetEnv(env);
102 NAPI_CALL(env, napi_wrap(env, daltonizationStateValue, reinterpret_cast<void*>(nativeObj),
103 NAccessibilityConfigClass::Destructor, nullptr, nullptr));
104 return daltonizationStateValue;
105 }
106
InitDaltonizationColorFilter(napi_env env)107 static napi_value InitDaltonizationColorFilter(napi_env env)
108 {
109 napi_value daltonizationColorFilterValue = nullptr;
110 napi_create_object(env, &daltonizationColorFilterValue);
111 if (daltonizationColorFilterValue == nullptr) {
112 HILOG_ERROR("napi_create_object fail.");
113 return daltonizationColorFilterValue;
114 }
115 NAPI_CALL(env, napi_define_properties(env, daltonizationColorFilterValue,
116 sizeof(configDesc) /
117 sizeof(configDesc[0]),
118 configDesc));
119 NAccessibilityConfigClass* nativeObj =
120 new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_DALTONIZATION_COLOR_FILTER);
121 if (!nativeObj) {
122 HILOG_ERROR("Failed to create nativeObj.");
123 return nullptr;
124 }
125 nativeObj->SetEnv(env);
126 NAPI_CALL(env, napi_wrap(env, daltonizationColorFilterValue, reinterpret_cast<void*>(nativeObj),
127 NAccessibilityConfigClass::Destructor, nullptr, nullptr));
128 return daltonizationColorFilterValue;
129 }
130
InitContentTimeout(napi_env env)131 static napi_value InitContentTimeout(napi_env env)
132 {
133 napi_value contentTimeoutValue = nullptr;
134 napi_create_object(env, &contentTimeoutValue);
135 if (contentTimeoutValue == nullptr) {
136 HILOG_ERROR("napi_create_object fail.");
137 return contentTimeoutValue;
138 }
139 NAPI_CALL(env, napi_define_properties(env, contentTimeoutValue,
140 sizeof(configDesc) / sizeof(configDesc[0]),
141 configDesc));
142 NAccessibilityConfigClass* nativeObj =
143 new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_CONTENT_TIMEOUT);
144 if (!nativeObj) {
145 HILOG_ERROR("Failed to create nativeObj.");
146 return nullptr;
147 }
148 nativeObj->SetEnv(env);
149 NAPI_CALL(env, napi_wrap(env, contentTimeoutValue, reinterpret_cast<void*>(nativeObj),
150 NAccessibilityConfigClass::Destructor, nullptr, nullptr));
151 return contentTimeoutValue;
152 }
153
InitAnimationOff(napi_env env)154 static napi_value InitAnimationOff(napi_env env)
155 {
156 napi_value animationOffValue = nullptr;
157 napi_create_object(env, &animationOffValue);
158 if (animationOffValue == nullptr) {
159 HILOG_ERROR("napi_create_object fail.");
160 return animationOffValue;
161 }
162 NAPI_CALL(env, napi_define_properties(env, animationOffValue,
163 sizeof(configDesc) / sizeof(configDesc[0]),
164 configDesc));
165 NAccessibilityConfigClass* nativeObj =
166 new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_ANIMATION_OFF);
167 if (!nativeObj) {
168 HILOG_ERROR("Failed to create nativeObj.");
169 return nullptr;
170 }
171 nativeObj->SetEnv(env);
172 NAPI_CALL(env, napi_wrap(env, animationOffValue, reinterpret_cast<void*>(nativeObj),
173 NAccessibilityConfigClass::Destructor, nullptr, nullptr));
174 return animationOffValue;
175 }
176
InitBrightnessDiscount(napi_env env)177 static napi_value InitBrightnessDiscount(napi_env env)
178 {
179 napi_value brightnessDiscountValue = nullptr;
180 napi_create_object(env, &brightnessDiscountValue);
181 if (brightnessDiscountValue == nullptr) {
182 HILOG_ERROR("napi_create_object fail.");
183 return brightnessDiscountValue;
184 }
185 NAPI_CALL(env, napi_define_properties(env, brightnessDiscountValue,
186 sizeof(configDesc) / sizeof(configDesc[0]),
187 configDesc));
188 NAccessibilityConfigClass* nativeObj =
189 new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_BRIGHTNESS_DISCOUNT);
190 if (!nativeObj) {
191 HILOG_ERROR("Failed to create nativeObj.");
192 return nullptr;
193 }
194 nativeObj->SetEnv(env);
195 NAPI_CALL(env, napi_wrap(env, brightnessDiscountValue, reinterpret_cast<void*>(nativeObj),
196 NAccessibilityConfigClass::Destructor, nullptr, nullptr));
197 return brightnessDiscountValue;
198 }
199
InitScreenMagnifier(napi_env env)200 static napi_value InitScreenMagnifier(napi_env env)
201 {
202 napi_value screenMagnifierValue = nullptr;
203 napi_create_object(env, &screenMagnifierValue);
204 if (screenMagnifierValue == nullptr) {
205 HILOG_ERROR("napi_create_object fail.");
206 return screenMagnifierValue;
207 }
208 NAPI_CALL(env, napi_define_properties(env, screenMagnifierValue,
209 sizeof(configDesc) / sizeof(configDesc[0]),
210 configDesc));
211 NAccessibilityConfigClass* nativeObj =
212 new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_SCREEN_MAGNIFICATION);
213 if (!nativeObj) {
214 HILOG_ERROR("Failed to create nativeObj.");
215 return nullptr;
216 }
217 nativeObj->SetEnv(env);
218 NAPI_CALL(env, napi_wrap(env, screenMagnifierValue, reinterpret_cast<void*>(nativeObj),
219 NAccessibilityConfigClass::Destructor, nullptr, nullptr));
220 return screenMagnifierValue;
221 }
222
InitAudioMono(napi_env env)223 static napi_value InitAudioMono(napi_env env)
224 {
225 napi_value audioMonoValue = nullptr;
226 napi_create_object(env, &audioMonoValue);
227 if (audioMonoValue == nullptr) {
228 HILOG_ERROR("napi_create_object fail.");
229 return audioMonoValue;
230 }
231 NAPI_CALL(env, napi_define_properties(env, audioMonoValue,
232 sizeof(configDesc) / sizeof(configDesc[0]),
233 configDesc));
234 NAccessibilityConfigClass* nativeObj =
235 new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_AUDIO_MONO);
236 if (!nativeObj) {
237 HILOG_ERROR("Failed to create nativeObj.");
238 return nullptr;
239 }
240 nativeObj->SetEnv(env);
241 NAPI_CALL(env, napi_wrap(env, audioMonoValue, reinterpret_cast<void*>(nativeObj),
242 NAccessibilityConfigClass::Destructor, nullptr, nullptr));
243 return audioMonoValue;
244 }
245
InitAudioBalance(napi_env env)246 static napi_value InitAudioBalance(napi_env env)
247 {
248 napi_value audioBalanceValue = nullptr;
249 napi_create_object(env, &audioBalanceValue);
250 if (audioBalanceValue == nullptr) {
251 HILOG_ERROR("napi_create_object fail.");
252 return audioBalanceValue;
253 }
254 NAPI_CALL(env, napi_define_properties(env, audioBalanceValue,
255 sizeof(configDesc) / sizeof(configDesc[0]),
256 configDesc));
257 NAccessibilityConfigClass* nativeObj =
258 new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_AUDIO_BALANCE);
259 if (!nativeObj) {
260 HILOG_ERROR("Failed to create nativeObj.");
261 return nullptr;
262 }
263 nativeObj->SetEnv(env);
264 NAPI_CALL(env, napi_wrap(env, audioBalanceValue, reinterpret_cast<void*>(nativeObj),
265 NAccessibilityConfigClass::Destructor, nullptr, nullptr));
266 return audioBalanceValue;
267 }
268
InitMouseKey(napi_env env)269 static napi_value InitMouseKey(napi_env env)
270 {
271 napi_value mouseKeyValue = nullptr;
272 napi_create_object(env, &mouseKeyValue);
273 if (mouseKeyValue == nullptr) {
274 HILOG_ERROR("napi_create_object fail.");
275 return mouseKeyValue;
276 }
277 NAPI_CALL(env, napi_define_properties(env, mouseKeyValue,
278 sizeof(configDesc) / sizeof(configDesc[0]),
279 configDesc));
280 NAccessibilityConfigClass* nativeObj =
281 new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_MOUSE_KEY);
282 if (!nativeObj) {
283 HILOG_ERROR("Failed to create nativeObj.");
284 return nullptr;
285 }
286 nativeObj->SetEnv(env);
287 NAPI_CALL(env, napi_wrap(env, mouseKeyValue, reinterpret_cast<void*>(nativeObj),
288 NAccessibilityConfigClass::Destructor, nullptr, nullptr));
289 return mouseKeyValue;
290 }
291
InitMouseAutoClick(napi_env env)292 static napi_value InitMouseAutoClick(napi_env env)
293 {
294 napi_value mouseAutoClickValue = nullptr;
295 napi_create_object(env, &mouseAutoClickValue);
296 if (mouseAutoClickValue == nullptr) {
297 HILOG_ERROR("napi_create_object fail.");
298 return mouseAutoClickValue;
299 }
300 NAPI_CALL(env, napi_define_properties(env, mouseAutoClickValue,
301 sizeof(configDesc) / sizeof(configDesc[0]),
302 configDesc));
303 NAccessibilityConfigClass* nativeObj =
304 new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_MOUSE_AUTOCLICK);
305 if (!nativeObj) {
306 HILOG_ERROR("Failed to create nativeObj.");
307 return nullptr;
308 }
309 nativeObj->SetEnv(env);
310 NAPI_CALL(env, napi_wrap(env, mouseAutoClickValue, reinterpret_cast<void*>(nativeObj),
311 NAccessibilityConfigClass::Destructor, nullptr, nullptr));
312 return mouseAutoClickValue;
313 }
314
InitShortKey(napi_env env)315 static napi_value InitShortKey(napi_env env)
316 {
317 napi_value shortKeyValue = nullptr;
318 napi_create_object(env, &shortKeyValue);
319 if (shortKeyValue == nullptr) {
320 HILOG_ERROR("napi_create_object fail.");
321 return shortKeyValue;
322 }
323 NAPI_CALL(env, napi_define_properties(env, shortKeyValue,
324 sizeof(configDesc) / sizeof(configDesc[0]),
325 configDesc));
326 NAccessibilityConfigClass* nativeObj =
327 new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_SHORT_KEY);
328 if (!nativeObj) {
329 HILOG_ERROR("Failed to create nativeObj.");
330 return nullptr;
331 }
332 nativeObj->SetEnv(env);
333 NAPI_CALL(env, napi_wrap(env, shortKeyValue, reinterpret_cast<void*>(nativeObj),
334 NAccessibilityConfigClass::Destructor, nullptr, nullptr));
335 return shortKeyValue;
336 }
337
InitShortKeyTarget(napi_env env)338 static napi_value InitShortKeyTarget(napi_env env)
339 {
340 napi_value shortKeyTargetValue = nullptr;
341 napi_create_object(env, &shortKeyTargetValue);
342 if (shortKeyTargetValue == nullptr) {
343 HILOG_ERROR("napi_create_object fail.");
344 return shortKeyTargetValue;
345 }
346 NAPI_CALL(env, napi_define_properties(env, shortKeyTargetValue,
347 sizeof(configDesc) / sizeof(configDesc[0]),
348 configDesc));
349 NAccessibilityConfigClass* nativeObj =
350 new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_SHORT_KEY_TARGET);
351 if (!nativeObj) {
352 HILOG_ERROR("Failed to create nativeObj.");
353 return nullptr;
354 }
355 nativeObj->SetEnv(env);
356 NAPI_CALL(env, napi_wrap(env, shortKeyTargetValue, reinterpret_cast<void*>(nativeObj),
357 NAccessibilityConfigClass::Destructor, nullptr, nullptr));
358 return shortKeyTargetValue;
359 }
360
InitShortKeyMultiTarget(napi_env env)361 static napi_value InitShortKeyMultiTarget(napi_env env)
362 {
363 napi_value shortKeyMultiTargetValue = nullptr;
364 napi_create_object(env, &shortKeyMultiTargetValue);
365 if (shortKeyMultiTargetValue == nullptr) {
366 HILOG_ERROR("napi_create_object fail.");
367 return shortKeyMultiTargetValue;
368 }
369 NAPI_CALL(env, napi_define_properties(env, shortKeyMultiTargetValue,
370 sizeof(configDesc) / sizeof(configDesc[0]),
371 configDesc));
372 NAccessibilityConfigClass* nativeObj =
373 new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_SHORT_KEY_MULTI_TARGET);
374 if (!nativeObj) {
375 HILOG_ERROR("Failed to create nativeObj.");
376 return nullptr;
377 }
378 nativeObj->SetEnv(env);
379 NAPI_CALL(env, napi_wrap(env, shortKeyMultiTargetValue, reinterpret_cast<void*>(nativeObj),
380 NAccessibilityConfigClass::Destructor, nullptr, nullptr));
381 return shortKeyMultiTargetValue;
382 }
383
InitCaptionsState(napi_env env)384 static napi_value InitCaptionsState(napi_env env)
385 {
386 napi_value captionsValue = nullptr;
387 napi_create_object(env, &captionsValue);
388 if (captionsValue == nullptr) {
389 HILOG_ERROR("napi_create_object fail.");
390 return captionsValue;
391 }
392 NAPI_CALL(env, napi_define_properties(env, captionsValue,
393 sizeof(configDesc) / sizeof(configDesc[0]),
394 configDesc));
395 NAccessibilityConfigClass* nativeObj =
396 new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_CAPTION_STATE);
397 if (!nativeObj) {
398 HILOG_ERROR("Failed to create nativeObj.");
399 return nullptr;
400 }
401 nativeObj->SetEnv(env);
402 NAPI_CALL(env, napi_wrap(env, captionsValue, reinterpret_cast<void*>(nativeObj),
403 NAccessibilityConfigClass::Destructor, nullptr, nullptr));
404 return captionsValue;
405 }
406
InitCaptionsStyle(napi_env env)407 static napi_value InitCaptionsStyle(napi_env env)
408 {
409 napi_value captionsStyleValue = nullptr;
410 napi_create_object(env, &captionsStyleValue);
411 if (captionsStyleValue == nullptr) {
412 HILOG_ERROR("napi_create_object fail.");
413 return captionsStyleValue;
414 }
415 NAPI_CALL(env, napi_define_properties(env, captionsStyleValue,
416 sizeof(configDesc) / sizeof(configDesc[0]),
417 configDesc));
418 NAccessibilityConfigClass* nativeObj =
419 new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_CAPTION_STYLE);
420 if (!nativeObj) {
421 HILOG_ERROR("Failed to create nativeObj.");
422 return nullptr;
423 }
424 nativeObj->SetEnv(env);
425 NAPI_CALL(env, napi_wrap(env, captionsStyleValue, reinterpret_cast<void*>(nativeObj),
426 NAccessibilityConfigClass::Destructor, nullptr, nullptr));
427 return captionsStyleValue;
428 }
429
InitClickResponseTime(napi_env env)430 static napi_value InitClickResponseTime(napi_env env)
431 {
432 napi_value clickResponseTimeValue = nullptr;
433 napi_create_object(env, &clickResponseTimeValue);
434 if (clickResponseTimeValue == nullptr) {
435 HILOG_ERROR("napi_create_object fail.");
436 return clickResponseTimeValue;
437 }
438 NAPI_CALL(env, napi_define_properties(env, clickResponseTimeValue,
439 sizeof(configDesc) / sizeof(configDesc[0]),
440 configDesc));
441 NAccessibilityConfigClass* nativeObj =
442 new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONIFG_CLICK_RESPONSE_TIME);
443 if (!nativeObj) {
444 HILOG_ERROR("Failed to create nativeObj.");
445 return nullptr;
446 }
447 nativeObj->SetEnv(env);
448 NAPI_CALL(env, napi_wrap(env, clickResponseTimeValue, reinterpret_cast<void*>(nativeObj),
449 NAccessibilityConfigClass::Destructor, nullptr, nullptr));
450 return clickResponseTimeValue;
451 }
452
InitIgnoreRepeatClickState(napi_env env)453 static napi_value InitIgnoreRepeatClickState(napi_env env)
454 {
455 napi_value ignoreRepeatClickStateValue = nullptr;
456 napi_create_object(env, &ignoreRepeatClickStateValue);
457 if (ignoreRepeatClickStateValue == nullptr) {
458 HILOG_ERROR("napi_create_object fail.");
459 return ignoreRepeatClickStateValue;
460 }
461 NAPI_CALL(env, napi_define_properties(env, ignoreRepeatClickStateValue,
462 sizeof(configDesc) / sizeof(configDesc[0]),
463 configDesc));
464 NAccessibilityConfigClass* nativeObj =
465 new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_IGNORE_REPEAT_CLICK_STATE);
466 if (!nativeObj) {
467 HILOG_ERROR("Failed to create nativeObj.");
468 return nullptr;
469 }
470 nativeObj->SetEnv(env);
471 NAPI_CALL(env, napi_wrap(env, ignoreRepeatClickStateValue, reinterpret_cast<void*>(nativeObj),
472 NAccessibilityConfigClass::Destructor, nullptr, nullptr));
473 return ignoreRepeatClickStateValue;
474 }
475
InitIgnoreRepeatClickTime(napi_env env)476 static napi_value InitIgnoreRepeatClickTime(napi_env env)
477 {
478 napi_value ignoreRepeatClickTimeValue = nullptr;
479 napi_create_object(env, &ignoreRepeatClickTimeValue);
480 if (ignoreRepeatClickTimeValue == nullptr) {
481 HILOG_ERROR("napi_create_object fail.");
482 return ignoreRepeatClickTimeValue;
483 }
484 NAPI_CALL(env, napi_define_properties(env, ignoreRepeatClickTimeValue,
485 sizeof(configDesc) / sizeof(configDesc[0]),
486 configDesc));
487 NAccessibilityConfigClass* nativeObj =
488 new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_IGNORE_REPEAT_CLICK_TIME);
489 if (!nativeObj) {
490 HILOG_ERROR("Failed to create nativeObj.");
491 return nullptr;
492 }
493 nativeObj->SetEnv(env);
494 NAPI_CALL(env, napi_wrap(env, ignoreRepeatClickTimeValue, reinterpret_cast<void*>(nativeObj),
495 NAccessibilityConfigClass::Destructor, nullptr, nullptr));
496 return ignoreRepeatClickTimeValue;
497 }
498
InitConfigModule(napi_env env,napi_value exports)499 static napi_value InitConfigModule(napi_env env, napi_value exports)
500 {
501 napi_property_descriptor desc[] = {
502 DECLARE_NAPI_FUNCTION("on", NAccessibilityConfig::SubscribeState),
503 DECLARE_NAPI_FUNCTION("off", NAccessibilityConfig::UnsubscribeState),
504 DECLARE_NAPI_FUNCTION("enableAbility", NAccessibilityConfig::EnableAbility),
505 DECLARE_NAPI_FUNCTION("disableAbility", NAccessibilityConfig::DisableAbility),
506 DECLARE_NAPI_STATIC_PROPERTY("highContrastText", InitHighContrastText(env)),
507 DECLARE_NAPI_STATIC_PROPERTY("invertColor", InitInvertColor(env)),
508 DECLARE_NAPI_STATIC_PROPERTY("daltonizationState", InitDaltonizationState(env)),
509 DECLARE_NAPI_STATIC_PROPERTY("daltonizationColorFilter", InitDaltonizationColorFilter(env)),
510 DECLARE_NAPI_STATIC_PROPERTY("contentTimeout", InitContentTimeout(env)),
511 DECLARE_NAPI_STATIC_PROPERTY("animationOff", InitAnimationOff(env)),
512 DECLARE_NAPI_STATIC_PROPERTY("brightnessDiscount", InitBrightnessDiscount(env)),
513 DECLARE_NAPI_STATIC_PROPERTY("screenMagnifier", InitScreenMagnifier(env)),
514 DECLARE_NAPI_STATIC_PROPERTY("audioMono", InitAudioMono(env)),
515 DECLARE_NAPI_STATIC_PROPERTY("audioBalance", InitAudioBalance(env)),
516 DECLARE_NAPI_STATIC_PROPERTY("mouseKey", InitMouseKey(env)),
517 DECLARE_NAPI_STATIC_PROPERTY("mouseAutoClick", InitMouseAutoClick(env)),
518 DECLARE_NAPI_STATIC_PROPERTY("shortkey", InitShortKey(env)),
519 DECLARE_NAPI_STATIC_PROPERTY("shortkeyTarget", InitShortKeyTarget(env)),
520 DECLARE_NAPI_STATIC_PROPERTY("shortkeyMultiTargets", InitShortKeyMultiTarget(env)),
521 DECLARE_NAPI_STATIC_PROPERTY("captions", InitCaptionsState(env)),
522 DECLARE_NAPI_STATIC_PROPERTY("captionsStyle", InitCaptionsStyle(env)),
523 DECLARE_NAPI_STATIC_PROPERTY("clickResponseTime", InitClickResponseTime(env)),
524 DECLARE_NAPI_STATIC_PROPERTY("ignoreRepeatClick", InitIgnoreRepeatClickState(env)),
525 DECLARE_NAPI_STATIC_PROPERTY("repeatClickInterval", InitIgnoreRepeatClickTime(env)),
526 };
527
528 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
529
530 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
531 (void)instance.InitializeContext();
532 NAccessibilityConfig::configObservers_->SubscribeToFramework();
533 NAccessibilityConfig::enableAbilityListsObservers_->SubscribeToFramework();
534 HILOG_INFO("-----Init config module end------");
535 return exports;
536 }
537 EXTERN_C_END
538
539 /*
540 * Module define
541 */
542 static napi_module _config_module = {
543 .nm_version = 1,
544 .nm_flags = 0,
545 .nm_filename = nullptr,
546 .nm_register_func = InitConfigModule,
547 .nm_modname = "accessibility.config",
548 .nm_priv = ((void*)0),
549 .reserved = {0},
550 };
551 /*
552 * Module register function
553 */
RegisterNapiAccessibilityConfigModule(void)554 extern "C" __attribute__((constructor)) void RegisterNapiAccessibilityConfigModule(void)
555 {
556 napi_module_register(&_config_module);
557 }
558