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 == nullptr) {
52         HILOG_ERROR("Failed to create nativeObj.");
53         return nullptr;
54     }
55     nativeObj->SetEnv(env);
56     napi_status sts = napi_wrap(env, highContrastTextValue, reinterpret_cast<void*>(nativeObj),
57         NAccessibilityConfigClass::Destructor, nullptr, nullptr);
58     if (sts != napi_ok) {
59         delete nativeObj;
60         nativeObj = nullptr;
61         HILOG_ERROR("failed to wrap JS object");
62         return nullptr;
63     }
64     return highContrastTextValue;
65 }
66 
InitInvertColor(napi_env env)67 static napi_value InitInvertColor(napi_env env)
68 {
69     napi_value invertColorValue = nullptr;
70     napi_create_object(env, &invertColorValue);
71     if (invertColorValue == nullptr) {
72         HILOG_ERROR("napi_create_object fail.");
73         return invertColorValue;
74     }
75     NAPI_CALL(env, napi_define_properties(env, invertColorValue,
76                                           sizeof(configDesc) / sizeof(configDesc[0]),
77                                           configDesc));
78     NAccessibilityConfigClass* nativeObj =
79         new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_INVERT_COLOR);
80     if (nativeObj == nullptr) {
81         HILOG_ERROR("Failed to create nativeObj.");
82         return nullptr;
83     }
84     nativeObj->SetEnv(env);
85     napi_status sts = napi_wrap(env, invertColorValue, reinterpret_cast<void*>(nativeObj),
86         NAccessibilityConfigClass::Destructor, nullptr, nullptr);
87     if (sts != napi_ok) {
88         delete nativeObj;
89         nativeObj = nullptr;
90         HILOG_ERROR("failed to wrap JS object");
91         return nullptr;
92     }
93     return invertColorValue;
94 }
95 
InitDaltonizationState(napi_env env)96 static napi_value InitDaltonizationState(napi_env env)
97 {
98     napi_value daltonizationStateValue = nullptr;
99     napi_create_object(env, &daltonizationStateValue);
100     if (daltonizationStateValue == nullptr) {
101         HILOG_ERROR("napi_create_object fail.");
102         return daltonizationStateValue;
103     }
104     NAPI_CALL(env, napi_define_properties(env, daltonizationStateValue,
105                                           sizeof(configDesc) / sizeof(configDesc[0]),
106                                           configDesc));
107     NAccessibilityConfigClass* nativeObj =
108         new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_DALTONIZATION_STATE);
109     if (nativeObj == nullptr) {
110         HILOG_ERROR("Failed to create nativeObj.");
111         return nullptr;
112     }
113     nativeObj->SetEnv(env);
114     napi_status sts = napi_wrap(env, daltonizationStateValue, reinterpret_cast<void*>(nativeObj),
115         NAccessibilityConfigClass::Destructor, nullptr, nullptr);
116     if (sts != napi_ok) {
117         delete nativeObj;
118         nativeObj = nullptr;
119         HILOG_ERROR("failed to wrap JS object");
120         return nullptr;
121     }
122     return daltonizationStateValue;
123 }
124 
InitDaltonizationColorFilter(napi_env env)125 static napi_value InitDaltonizationColorFilter(napi_env env)
126 {
127     napi_value daltonizationColorFilterValue = nullptr;
128     napi_create_object(env, &daltonizationColorFilterValue);
129     if (daltonizationColorFilterValue == nullptr) {
130         HILOG_ERROR("napi_create_object fail.");
131         return daltonizationColorFilterValue;
132     }
133     NAPI_CALL(env, napi_define_properties(env, daltonizationColorFilterValue,
134                                           sizeof(configDesc) /
135                                           sizeof(configDesc[0]),
136                                           configDesc));
137     NAccessibilityConfigClass* nativeObj =
138         new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_DALTONIZATION_COLOR_FILTER);
139     if (nativeObj == nullptr) {
140         HILOG_ERROR("Failed to create nativeObj.");
141         return nullptr;
142     }
143     nativeObj->SetEnv(env);
144     napi_status sts = napi_wrap(env, daltonizationColorFilterValue, reinterpret_cast<void*>(nativeObj),
145         NAccessibilityConfigClass::Destructor, nullptr, nullptr);
146     if (sts != napi_ok) {
147         delete nativeObj;
148         nativeObj = nullptr;
149         HILOG_ERROR("failed to wrap JS object");
150         return nullptr;
151     }
152     return daltonizationColorFilterValue;
153 }
154 
InitContentTimeout(napi_env env)155 static napi_value InitContentTimeout(napi_env env)
156 {
157     napi_value contentTimeoutValue = nullptr;
158     napi_create_object(env, &contentTimeoutValue);
159     if (contentTimeoutValue == nullptr) {
160         HILOG_ERROR("napi_create_object fail.");
161         return contentTimeoutValue;
162     }
163     NAPI_CALL(env, napi_define_properties(env, contentTimeoutValue,
164                                           sizeof(configDesc) / sizeof(configDesc[0]),
165                                           configDesc));
166     NAccessibilityConfigClass* nativeObj =
167         new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_CONTENT_TIMEOUT);
168     if (nativeObj == nullptr) {
169         HILOG_ERROR("Failed to create nativeObj.");
170         return nullptr;
171     }
172     nativeObj->SetEnv(env);
173     napi_status sts = napi_wrap(env, contentTimeoutValue, reinterpret_cast<void*>(nativeObj),
174         NAccessibilityConfigClass::Destructor, nullptr, nullptr);
175     if (sts != napi_ok) {
176         delete nativeObj;
177         nativeObj = nullptr;
178         HILOG_ERROR("failed to wrap JS object");
179         return nullptr;
180     }
181     return contentTimeoutValue;
182 }
183 
InitAnimationOff(napi_env env)184 static napi_value InitAnimationOff(napi_env env)
185 {
186     napi_value animationOffValue = nullptr;
187     napi_create_object(env, &animationOffValue);
188     if (animationOffValue == nullptr) {
189         HILOG_ERROR("napi_create_object fail.");
190         return animationOffValue;
191     }
192     NAPI_CALL(env, napi_define_properties(env, animationOffValue,
193                                           sizeof(configDesc) / sizeof(configDesc[0]),
194                                           configDesc));
195     NAccessibilityConfigClass* nativeObj =
196         new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_ANIMATION_OFF);
197     if (nativeObj == nullptr) {
198         HILOG_ERROR("Failed to create nativeObj.");
199         return nullptr;
200     }
201     nativeObj->SetEnv(env);
202     napi_status sts = napi_wrap(env, animationOffValue, reinterpret_cast<void*>(nativeObj),
203         NAccessibilityConfigClass::Destructor, nullptr, nullptr);
204     if (sts != napi_ok) {
205         delete nativeObj;
206         nativeObj = nullptr;
207         HILOG_ERROR("failed to wrap JS object");
208         return nullptr;
209     }
210     return animationOffValue;
211 }
212 
InitBrightnessDiscount(napi_env env)213 static napi_value InitBrightnessDiscount(napi_env env)
214 {
215     napi_value brightnessDiscountValue = nullptr;
216     napi_create_object(env, &brightnessDiscountValue);
217     if (brightnessDiscountValue == nullptr) {
218         HILOG_ERROR("napi_create_object fail.");
219         return brightnessDiscountValue;
220     }
221     NAPI_CALL(env, napi_define_properties(env, brightnessDiscountValue,
222                                           sizeof(configDesc) / sizeof(configDesc[0]),
223                                           configDesc));
224     NAccessibilityConfigClass* nativeObj =
225         new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_BRIGHTNESS_DISCOUNT);
226     if (nativeObj == nullptr) {
227         HILOG_ERROR("Failed to create nativeObj.");
228         return nullptr;
229     }
230     nativeObj->SetEnv(env);
231     napi_status sts = napi_wrap(env, brightnessDiscountValue, reinterpret_cast<void*>(nativeObj),
232         NAccessibilityConfigClass::Destructor, nullptr, nullptr);
233     if (sts != napi_ok) {
234         delete nativeObj;
235         nativeObj = nullptr;
236         HILOG_ERROR("failed to wrap JS object");
237         return nullptr;
238     }
239     return brightnessDiscountValue;
240 }
241 
InitScreenMagnifier(napi_env env)242 static napi_value InitScreenMagnifier(napi_env env)
243 {
244     napi_value screenMagnifierValue = nullptr;
245     napi_create_object(env, &screenMagnifierValue);
246     if (screenMagnifierValue == nullptr) {
247         HILOG_ERROR("napi_create_object fail.");
248         return screenMagnifierValue;
249     }
250     NAPI_CALL(env, napi_define_properties(env, screenMagnifierValue,
251                                           sizeof(configDesc) / sizeof(configDesc[0]),
252                                           configDesc));
253     NAccessibilityConfigClass* nativeObj =
254         new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_SCREEN_MAGNIFICATION);
255     if (nativeObj == nullptr) {
256         HILOG_ERROR("Failed to create nativeObj.");
257         return nullptr;
258     }
259     nativeObj->SetEnv(env);
260     napi_status sts = napi_wrap(env, screenMagnifierValue, reinterpret_cast<void*>(nativeObj),
261         NAccessibilityConfigClass::Destructor, nullptr, nullptr);
262     if (sts != napi_ok) {
263         delete nativeObj;
264         nativeObj = nullptr;
265         HILOG_ERROR("failed to wrap JS object");
266         return nullptr;
267     }
268     return screenMagnifierValue;
269 }
270 
InitAudioMono(napi_env env)271 static napi_value InitAudioMono(napi_env env)
272 {
273     napi_value audioMonoValue = nullptr;
274     napi_create_object(env, &audioMonoValue);
275     if (audioMonoValue == nullptr) {
276         HILOG_ERROR("napi_create_object fail.");
277         return audioMonoValue;
278     }
279     NAPI_CALL(env, napi_define_properties(env, audioMonoValue,
280                                           sizeof(configDesc) / sizeof(configDesc[0]),
281                                           configDesc));
282     NAccessibilityConfigClass* nativeObj =
283         new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_AUDIO_MONO);
284     if (nativeObj == nullptr) {
285         HILOG_ERROR("Failed to create nativeObj.");
286         return nullptr;
287     }
288     nativeObj->SetEnv(env);
289     napi_status sts = napi_wrap(env, audioMonoValue, reinterpret_cast<void*>(nativeObj),
290         NAccessibilityConfigClass::Destructor, nullptr, nullptr);
291     if (sts != napi_ok) {
292         delete nativeObj;
293         nativeObj = nullptr;
294         HILOG_ERROR("failed to wrap JS object");
295         return nullptr;
296     }
297     return audioMonoValue;
298 }
299 
InitAudioBalance(napi_env env)300 static napi_value InitAudioBalance(napi_env env)
301 {
302     napi_value audioBalanceValue = nullptr;
303     napi_create_object(env, &audioBalanceValue);
304     if (audioBalanceValue == nullptr) {
305         HILOG_ERROR("napi_create_object fail.");
306         return audioBalanceValue;
307     }
308     NAPI_CALL(env, napi_define_properties(env, audioBalanceValue,
309                                           sizeof(configDesc) / sizeof(configDesc[0]),
310                                           configDesc));
311     NAccessibilityConfigClass* nativeObj =
312         new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_AUDIO_BALANCE);
313     if (nativeObj == nullptr) {
314         HILOG_ERROR("Failed to create nativeObj.");
315         return nullptr;
316     }
317     nativeObj->SetEnv(env);
318     napi_status sts = napi_wrap(env, audioBalanceValue, reinterpret_cast<void*>(nativeObj),
319         NAccessibilityConfigClass::Destructor, nullptr, nullptr);
320     if (sts != napi_ok) {
321         delete nativeObj;
322         nativeObj = nullptr;
323         HILOG_ERROR("failed to wrap JS object");
324         return nullptr;
325     }
326     return audioBalanceValue;
327 }
328 
InitMouseKey(napi_env env)329 static napi_value InitMouseKey(napi_env env)
330 {
331     napi_value mouseKeyValue = nullptr;
332     napi_create_object(env, &mouseKeyValue);
333     if (mouseKeyValue == nullptr) {
334         HILOG_ERROR("napi_create_object fail.");
335         return mouseKeyValue;
336     }
337     NAPI_CALL(env, napi_define_properties(env, mouseKeyValue,
338                                           sizeof(configDesc) / sizeof(configDesc[0]),
339                                           configDesc));
340     NAccessibilityConfigClass* nativeObj =
341         new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_MOUSE_KEY);
342     if (nativeObj == nullptr) {
343         HILOG_ERROR("Failed to create nativeObj.");
344         return nullptr;
345     }
346     nativeObj->SetEnv(env);
347     napi_status sts = napi_wrap(env, mouseKeyValue, reinterpret_cast<void*>(nativeObj),
348         NAccessibilityConfigClass::Destructor, nullptr, nullptr);
349     if (sts != napi_ok) {
350         delete nativeObj;
351         nativeObj = nullptr;
352         HILOG_ERROR("failed to wrap JS object");
353         return nullptr;
354     }
355     return mouseKeyValue;
356 }
357 
InitMouseAutoClick(napi_env env)358 static napi_value InitMouseAutoClick(napi_env env)
359 {
360     napi_value mouseAutoClickValue = nullptr;
361     napi_create_object(env, &mouseAutoClickValue);
362     if (mouseAutoClickValue == nullptr) {
363         HILOG_ERROR("napi_create_object fail.");
364         return mouseAutoClickValue;
365     }
366     NAPI_CALL(env, napi_define_properties(env, mouseAutoClickValue,
367                                           sizeof(configDesc) / sizeof(configDesc[0]),
368                                           configDesc));
369     NAccessibilityConfigClass* nativeObj =
370         new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_MOUSE_AUTOCLICK);
371     if (nativeObj == nullptr) {
372         HILOG_ERROR("Failed to create nativeObj.");
373         return nullptr;
374     }
375     nativeObj->SetEnv(env);
376     napi_status sts = napi_wrap(env, mouseAutoClickValue, reinterpret_cast<void*>(nativeObj),
377         NAccessibilityConfigClass::Destructor, nullptr, nullptr);
378     if (sts != napi_ok) {
379         delete nativeObj;
380         nativeObj = nullptr;
381         HILOG_ERROR("failed to wrap JS object");
382         return nullptr;
383     }
384     return mouseAutoClickValue;
385 }
386 
InitShortKey(napi_env env)387 static napi_value InitShortKey(napi_env env)
388 {
389     napi_value shortKeyValue = nullptr;
390     napi_create_object(env, &shortKeyValue);
391     if (shortKeyValue == nullptr) {
392         HILOG_ERROR("napi_create_object fail.");
393         return shortKeyValue;
394     }
395     NAPI_CALL(env, napi_define_properties(env, shortKeyValue,
396                                           sizeof(configDesc) / sizeof(configDesc[0]),
397                                           configDesc));
398     NAccessibilityConfigClass* nativeObj =
399         new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_SHORT_KEY);
400     if (nativeObj == nullptr) {
401         HILOG_ERROR("Failed to create nativeObj.");
402         return nullptr;
403     }
404     nativeObj->SetEnv(env);
405     napi_status sts = napi_wrap(env, shortKeyValue, reinterpret_cast<void*>(nativeObj),
406         NAccessibilityConfigClass::Destructor, nullptr, nullptr);
407     if (sts != napi_ok) {
408         delete nativeObj;
409         nativeObj = nullptr;
410         HILOG_ERROR("failed to wrap JS object");
411         return nullptr;
412     }
413     return shortKeyValue;
414 }
415 
InitShortKeyTarget(napi_env env)416 static napi_value InitShortKeyTarget(napi_env env)
417 {
418     napi_value shortKeyTargetValue = nullptr;
419     napi_create_object(env, &shortKeyTargetValue);
420     if (shortKeyTargetValue == nullptr) {
421         HILOG_ERROR("napi_create_object fail.");
422         return shortKeyTargetValue;
423     }
424     NAPI_CALL(env, napi_define_properties(env, shortKeyTargetValue,
425                                           sizeof(configDesc) / sizeof(configDesc[0]),
426                                           configDesc));
427     NAccessibilityConfigClass* nativeObj =
428         new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_SHORT_KEY_TARGET);
429     if (nativeObj == nullptr) {
430         HILOG_ERROR("Failed to create nativeObj.");
431         return nullptr;
432     }
433     nativeObj->SetEnv(env);
434     napi_status sts = napi_wrap(env, shortKeyTargetValue, reinterpret_cast<void*>(nativeObj),
435         NAccessibilityConfigClass::Destructor, nullptr, nullptr);
436     if (sts != napi_ok) {
437         delete nativeObj;
438         nativeObj = nullptr;
439         HILOG_ERROR("failed to wrap JS object");
440         return nullptr;
441     }
442     return shortKeyTargetValue;
443 }
444 
InitShortKeyMultiTarget(napi_env env)445 static napi_value InitShortKeyMultiTarget(napi_env env)
446 {
447     napi_value shortKeyMultiTargetValue = nullptr;
448     napi_create_object(env, &shortKeyMultiTargetValue);
449     if (shortKeyMultiTargetValue == nullptr) {
450         HILOG_ERROR("napi_create_object fail.");
451         return shortKeyMultiTargetValue;
452     }
453     NAPI_CALL(env, napi_define_properties(env, shortKeyMultiTargetValue,
454                                           sizeof(configDesc) / sizeof(configDesc[0]),
455                                           configDesc));
456     NAccessibilityConfigClass* nativeObj =
457         new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_SHORT_KEY_MULTI_TARGET);
458     if (nativeObj == nullptr) {
459         HILOG_ERROR("Failed to create nativeObj.");
460         return nullptr;
461     }
462     nativeObj->SetEnv(env);
463     napi_status sts = napi_wrap(env, shortKeyMultiTargetValue, reinterpret_cast<void*>(nativeObj),
464         NAccessibilityConfigClass::Destructor, nullptr, nullptr);
465     if (sts != napi_ok) {
466         delete nativeObj;
467         nativeObj = nullptr;
468         HILOG_ERROR("failed to wrap JS object");
469         return nullptr;
470     }
471     return shortKeyMultiTargetValue;
472 }
473 
InitCaptionsState(napi_env env)474 static napi_value InitCaptionsState(napi_env env)
475 {
476     napi_value captionsValue = nullptr;
477     napi_create_object(env, &captionsValue);
478     if (captionsValue == nullptr) {
479         HILOG_ERROR("napi_create_object fail.");
480         return captionsValue;
481     }
482     NAPI_CALL(env, napi_define_properties(env, captionsValue,
483                                           sizeof(configDesc) / sizeof(configDesc[0]),
484                                           configDesc));
485     NAccessibilityConfigClass* nativeObj =
486         new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_CAPTION_STATE);
487     if (nativeObj == nullptr) {
488         HILOG_ERROR("Failed to create nativeObj.");
489         return nullptr;
490     }
491     nativeObj->SetEnv(env);
492     napi_status sts = napi_wrap(env, captionsValue, reinterpret_cast<void*>(nativeObj),
493         NAccessibilityConfigClass::Destructor, nullptr, nullptr);
494     if (sts != napi_ok) {
495         delete nativeObj;
496         nativeObj = nullptr;
497         HILOG_ERROR("failed to wrap JS object");
498         return nullptr;
499     }
500     return captionsValue;
501 }
502 
InitCaptionsStyle(napi_env env)503 static napi_value InitCaptionsStyle(napi_env env)
504 {
505     napi_value captionsStyleValue = nullptr;
506     napi_create_object(env, &captionsStyleValue);
507     if (captionsStyleValue == nullptr) {
508         HILOG_ERROR("napi_create_object fail.");
509         return captionsStyleValue;
510     }
511     NAPI_CALL(env, napi_define_properties(env, captionsStyleValue,
512                                           sizeof(configDesc) / sizeof(configDesc[0]),
513                                           configDesc));
514     NAccessibilityConfigClass* nativeObj =
515         new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_CAPTION_STYLE);
516     if (nativeObj == nullptr) {
517         HILOG_ERROR("Failed to create nativeObj.");
518         return nullptr;
519     }
520     nativeObj->SetEnv(env);
521     napi_status sts = napi_wrap(env, captionsStyleValue, reinterpret_cast<void*>(nativeObj),
522         NAccessibilityConfigClass::Destructor, nullptr, nullptr);
523     if (sts != napi_ok) {
524         delete nativeObj;
525         nativeObj = nullptr;
526         HILOG_ERROR("failed to wrap JS object");
527         return nullptr;
528     }
529     return captionsStyleValue;
530 }
531 
InitClickResponseTime(napi_env env)532 static napi_value InitClickResponseTime(napi_env env)
533 {
534     napi_value clickResponseTimeValue = nullptr;
535     napi_create_object(env, &clickResponseTimeValue);
536     if (clickResponseTimeValue == nullptr) {
537         HILOG_ERROR("napi_create_object fail.");
538         return clickResponseTimeValue;
539     }
540     NAPI_CALL(env, napi_define_properties(env, clickResponseTimeValue,
541                                           sizeof(configDesc) / sizeof(configDesc[0]),
542                                           configDesc));
543     NAccessibilityConfigClass* nativeObj =
544         new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONIFG_CLICK_RESPONSE_TIME);
545     if (nativeObj == nullptr) {
546         HILOG_ERROR("Failed to create nativeObj.");
547         return nullptr;
548     }
549     nativeObj->SetEnv(env);
550     napi_status sts = napi_wrap(env, clickResponseTimeValue, reinterpret_cast<void*>(nativeObj),
551         NAccessibilityConfigClass::Destructor, nullptr, nullptr);
552     if (sts != napi_ok) {
553         delete nativeObj;
554         nativeObj = nullptr;
555         HILOG_ERROR("failed to wrap JS object");
556         return nullptr;
557     }
558     return clickResponseTimeValue;
559 }
560 
InitIgnoreRepeatClickState(napi_env env)561 static napi_value InitIgnoreRepeatClickState(napi_env env)
562 {
563     napi_value ignoreRepeatClickStateValue = nullptr;
564     napi_create_object(env, &ignoreRepeatClickStateValue);
565     if (ignoreRepeatClickStateValue == nullptr) {
566         HILOG_ERROR("napi_create_object fail.");
567         return ignoreRepeatClickStateValue;
568     }
569     NAPI_CALL(env, napi_define_properties(env, ignoreRepeatClickStateValue,
570                                           sizeof(configDesc) / sizeof(configDesc[0]),
571                                           configDesc));
572     NAccessibilityConfigClass* nativeObj =
573         new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_IGNORE_REPEAT_CLICK_STATE);
574     if (nativeObj == nullptr) {
575         HILOG_ERROR("Failed to create nativeObj.");
576         return nullptr;
577     }
578     nativeObj->SetEnv(env);
579     napi_status sts = napi_wrap(env, ignoreRepeatClickStateValue, reinterpret_cast<void*>(nativeObj),
580         NAccessibilityConfigClass::Destructor, nullptr, nullptr);
581     if (sts != napi_ok) {
582         delete nativeObj;
583         nativeObj = nullptr;
584         HILOG_ERROR("failed to wrap JS object");
585         return nullptr;
586     }
587     return ignoreRepeatClickStateValue;
588 }
589 
InitIgnoreRepeatClickTime(napi_env env)590 static napi_value InitIgnoreRepeatClickTime(napi_env env)
591 {
592     napi_value ignoreRepeatClickTimeValue = nullptr;
593     napi_create_object(env, &ignoreRepeatClickTimeValue);
594     if (ignoreRepeatClickTimeValue == nullptr) {
595         HILOG_ERROR("napi_create_object fail.");
596         return ignoreRepeatClickTimeValue;
597     }
598     NAPI_CALL(env, napi_define_properties(env, ignoreRepeatClickTimeValue,
599                                           sizeof(configDesc) / sizeof(configDesc[0]),
600                                           configDesc));
601     NAccessibilityConfigClass* nativeObj =
602         new(std::nothrow) NAccessibilityConfigClass(OHOS::AccessibilityConfig::CONFIG_IGNORE_REPEAT_CLICK_TIME);
603     if (nativeObj == nullptr) {
604         HILOG_ERROR("Failed to create nativeObj.");
605         return nullptr;
606     }
607     nativeObj->SetEnv(env);
608     napi_status sts = napi_wrap(env, ignoreRepeatClickTimeValue, reinterpret_cast<void*>(nativeObj),
609         NAccessibilityConfigClass::Destructor, nullptr, nullptr);
610     if (sts != napi_ok) {
611         delete nativeObj;
612         nativeObj = nullptr;
613         HILOG_ERROR("failed to wrap JS object");
614         return nullptr;
615     }
616     return ignoreRepeatClickTimeValue;
617 }
618 
InitConfigModule(napi_env env,napi_value exports)619 static napi_value InitConfigModule(napi_env env, napi_value exports)
620 {
621     napi_property_descriptor desc[] = {
622         DECLARE_NAPI_FUNCTION("on", NAccessibilityConfig::SubscribeState),
623         DECLARE_NAPI_FUNCTION("off", NAccessibilityConfig::UnsubscribeState),
624         DECLARE_NAPI_FUNCTION("enableAbility", NAccessibilityConfig::EnableAbility),
625         DECLARE_NAPI_FUNCTION("disableAbility", NAccessibilityConfig::DisableAbility),
626         DECLARE_NAPI_STATIC_PROPERTY("highContrastText", InitHighContrastText(env)),
627         DECLARE_NAPI_STATIC_PROPERTY("invertColor", InitInvertColor(env)),
628         DECLARE_NAPI_STATIC_PROPERTY("daltonizationState", InitDaltonizationState(env)),
629         DECLARE_NAPI_STATIC_PROPERTY("daltonizationColorFilter", InitDaltonizationColorFilter(env)),
630         DECLARE_NAPI_STATIC_PROPERTY("contentTimeout", InitContentTimeout(env)),
631         DECLARE_NAPI_STATIC_PROPERTY("animationOff", InitAnimationOff(env)),
632         DECLARE_NAPI_STATIC_PROPERTY("brightnessDiscount", InitBrightnessDiscount(env)),
633         DECLARE_NAPI_STATIC_PROPERTY("screenMagnifier", InitScreenMagnifier(env)),
634         DECLARE_NAPI_STATIC_PROPERTY("audioMono", InitAudioMono(env)),
635         DECLARE_NAPI_STATIC_PROPERTY("audioBalance", InitAudioBalance(env)),
636         DECLARE_NAPI_STATIC_PROPERTY("mouseKey", InitMouseKey(env)),
637         DECLARE_NAPI_STATIC_PROPERTY("mouseAutoClick", InitMouseAutoClick(env)),
638         DECLARE_NAPI_STATIC_PROPERTY("shortkey", InitShortKey(env)),
639         DECLARE_NAPI_STATIC_PROPERTY("shortkeyTarget", InitShortKeyTarget(env)),
640         DECLARE_NAPI_STATIC_PROPERTY("shortkeyMultiTargets", InitShortKeyMultiTarget(env)),
641         DECLARE_NAPI_STATIC_PROPERTY("captions", InitCaptionsState(env)),
642         DECLARE_NAPI_STATIC_PROPERTY("captionsStyle", InitCaptionsStyle(env)),
643         DECLARE_NAPI_STATIC_PROPERTY("clickResponseTime", InitClickResponseTime(env)),
644         DECLARE_NAPI_STATIC_PROPERTY("ignoreRepeatClick", InitIgnoreRepeatClickState(env)),
645         DECLARE_NAPI_STATIC_PROPERTY("repeatClickInterval", InitIgnoreRepeatClickTime(env)),
646     };
647 
648     NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
649 
650     auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
651     (void)instance.InitializeContext();
652     NAccessibilityConfig::configObservers_->SubscribeToFramework();
653     NAccessibilityConfig::enableAbilityListsObservers_->SubscribeToFramework();
654     HILOG_INFO("-----Init config module end------");
655     return exports;
656 }
657 EXTERN_C_END
658 
659 /*
660  * Module define
661  */
662 static napi_module _config_module = {
663     .nm_version = 1,
664     .nm_flags = 0,
665     .nm_filename = nullptr,
666     .nm_register_func = InitConfigModule,
667     .nm_modname = "accessibility.config",
668     .nm_priv = ((void*)0),
669     .reserved = {0},
670 };
671 /*
672  * Module register function
673  */
RegisterNapiAccessibilityConfigModule(void)674 extern "C" __attribute__((constructor)) void RegisterNapiAccessibilityConfigModule(void)
675 {
676     napi_module_register(&_config_module);
677 }
678