1 /*
2  * Copyright (C) 2023 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 <string>
17 #ifdef OHOS_BUILD_ENABLE_HITRACE
18 #include <hitrace_meter.h>
19 #endif // OHOS_BUILD_ENABLE_HITRACE
20 #include "accessibility_account_data.h"
21 #include "accessible_ability_manager_service.h"
22 #include "accessibility_settings.h"
23 #ifdef OHOS_BUILD_ENABLE_POWER_MANAGER
24 #include "accessibility_power_manager.h"
25 #endif
26 #include "hilog_wrapper.h"
27 #include "parameter.h"
28 
29 namespace OHOS {
30 namespace Accessibility {
31 namespace {
32     const std::string GRAPHIC_ANIMATION_SCALE_NAME = "persist.sys.graphic.animationscale";
33     const std::string ARKUI_ANIMATION_SCALE_NAME = "persist.sys.arkui.animationscale";
34     const std::string SCREEN_READER_BUNDLE_ABILITY_NAME = "com.huawei.hmos.screenreader/AccessibilityExtAbility";
35     const int32_t SHORT_KEY_TIMEOUT_BEFORE_USE = 3000; // ms
36     const int32_t SHORT_KEY_TIMEOUT_AFTER_USE = 1000; // ms
37     const int32_t INVALID_SHORTCUT_ON_LOCK_SCREEN_STATE = 2;
38 }
39 
RegisterSettingsHandler(const std::shared_ptr<AppExecFwk::EventHandler> &handler)40 void AccessibilitySettings::RegisterSettingsHandler(const std::shared_ptr<AppExecFwk::EventHandler> &handler)
41 {
42     HILOG_DEBUG();
43     handler_ = handler;
44 }
45 
SetScreenMagnificationState(const bool state)46 RetError AccessibilitySettings::SetScreenMagnificationState(const bool state)
47 {
48     HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
49 #ifdef OHOS_BUILD_ENABLE_HITRACE
50     HITRACE_METER_NAME(HITRACE_TAG_ACCESSIBILITY_MANAGER, "SetScreenMagnificationState:" + std::to_string(state));
51 #endif // OHOS_BUILD_ENABLE_HITRACE
52 
53     sptr<AccessibilityAccountData> accountData =
54         Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
55     if (!accountData) {
56         HILOG_ERROR("accountData is nullptr.");
57         return RET_ERR_NULLPTR;
58     }
59     RetError ret = accountData->GetConfig()->SetScreenMagnificationState(state);
60     UpdateConfigState();
61     Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateInputFilter();
62     return ret;
63 }
64 
SetShortKeyState(const bool state)65 RetError AccessibilitySettings::SetShortKeyState(const bool state)
66 {
67     HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
68 #ifdef OHOS_BUILD_ENABLE_HITRACE
69     HITRACE_METER_NAME(HITRACE_TAG_ACCESSIBILITY_MANAGER, "SetShortKeyState:" + std::to_string(state));
70 #endif // OHOS_BUILD_ENABLE_HITRACE
71 
72     if (!handler_) {
73         HILOG_ERROR("handler_ is nullptr.");
74         return RET_ERR_NULLPTR;
75     }
76 
77     ffrt::promise<RetError> syncPromise;
78     ffrt::future syncFuture = syncPromise.get_future();
79     handler_->PostTask([this, &syncPromise, state]() {
80         sptr<AccessibilityAccountData> accountData =
81             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
82         if (!accountData) {
83             HILOG_ERROR("accountData is nullptr.");
84             syncPromise.set_value(RET_ERR_NULLPTR);
85             return;
86         }
87         RetError ret = accountData->GetConfig()->SetShortKeyState(state);
88         syncPromise.set_value(ret);
89         UpdateConfigState();
90         Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateShortKeyRegister();
91         }, "TASK_SET_SHORTKEY_STATE");
92     return syncFuture.get();
93 }
94 
SetMouseKeyState(const bool state)95 RetError AccessibilitySettings::SetMouseKeyState(const bool state)
96 {
97     HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
98 
99     sptr<AccessibilityAccountData> accountData =
100         Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
101     if (!accountData) {
102         HILOG_ERROR("accountData is nullptr.");
103         return RET_ERR_NULLPTR;
104     }
105     RetError ret = accountData->GetConfig()->SetMouseKeyState(state);
106     UpdateConfigState();
107     Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateInputFilter();
108     return ret;
109 }
110 
SetMouseAutoClick(const int32_t time)111 RetError AccessibilitySettings::SetMouseAutoClick(const int32_t time)
112 {
113     HILOG_INFO("time = [%{public}d]", time);
114     if (!handler_) {
115         HILOG_ERROR("handler_ is nullptr.");
116         return RET_ERR_NULLPTR;
117     }
118 
119     ffrt::promise<RetError> syncPromise;
120     ffrt::future syncFuture = syncPromise.get_future();
121     handler_->PostTask([this, &syncPromise, time]() {
122         sptr<AccessibilityAccountData> accountData =
123             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
124         if (!accountData) {
125             HILOG_ERROR("accountData is nullptr.");
126             syncPromise.set_value(RET_ERR_NULLPTR);
127             return;
128         }
129         RetError ret = accountData->GetConfig()->SetMouseAutoClick(time);
130         syncPromise.set_value(ret);
131         UpdateMouseAutoClick();
132         Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateInputFilter();
133         }, "TASK_SET_MOUSE_AUTOCLICK");
134     return syncFuture.get();
135 }
136 
SetShortkeyTarget(const std::string &name)137 RetError AccessibilitySettings::SetShortkeyTarget(const std::string &name)
138 {
139     HILOG_INFO("name = [%{public}s]", name.c_str());
140 #ifdef OHOS_BUILD_ENABLE_HITRACE
141     HITRACE_METER_NAME(HITRACE_TAG_ACCESSIBILITY_MANAGER, "SetShortkeyTarget:" + name);
142 #endif // OHOS_BUILD_ENABLE_HITRACE
143 
144     if (!handler_) {
145         HILOG_ERROR("handler_ is nullptr.");
146         return RET_ERR_NULLPTR;
147     }
148     ffrt::promise<RetError> syncPromise;
149     ffrt::future syncFuture = syncPromise.get_future();
150     handler_->PostTask([this, &syncPromise, &name]() {
151         sptr<AccessibilityAccountData> accountData =
152             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
153         if (!accountData) {
154             HILOG_ERROR("accountData is nullptr.");
155             syncPromise.set_value(RET_ERR_NULLPTR);
156             return;
157         }
158         RetError ret = accountData->GetConfig()->SetShortkeyTarget(name);
159         syncPromise.set_value(ret);
160         UpdateShortkeyTarget();
161         }, "TASK_SET_SHORTKEY_TARGET");
162     return syncFuture.get();
163 }
164 
SetShortkeyMultiTarget(const std::vector<std::string> &name)165 RetError AccessibilitySettings::SetShortkeyMultiTarget(const std::vector<std::string> &name)
166 {
167     HILOG_DEBUG();
168 #ifdef OHOS_BUILD_ENABLE_HITRACE
169     HITRACE_METER_NAME(HITRACE_TAG_ACCESSIBILITY_MANAGER, "SetShortkeyMultiTarget");
170 #endif // OHOS_BUILD_ENABLE_HITRACE
171 
172     if (!handler_) {
173         HILOG_ERROR("handler_ is nullptr.");
174         return RET_ERR_NULLPTR;
175     }
176     ffrt::promise<RetError> syncPromise;
177     ffrt::future syncFuture = syncPromise.get_future();
178     handler_->PostTask([this, &syncPromise, &name]() {
179         sptr<AccessibilityAccountData> accountData =
180             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
181         if (!accountData) {
182             HILOG_ERROR("accountData is nullptr.");
183             syncPromise.set_value(RET_ERR_NULLPTR);
184             return;
185         }
186         RetError ret = accountData->GetConfig()->SetShortkeyMultiTarget(name);
187         syncPromise.set_value(ret);
188         UpdateShortkeyMultiTarget();
189         }, "TASK_SET_SHORTKEY_MULTI_TARGET");
190     return syncFuture.get();
191 }
192 
SetHighContrastTextState(const bool state)193 RetError AccessibilitySettings::SetHighContrastTextState(const bool state)
194 {
195     HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
196 #ifdef OHOS_BUILD_ENABLE_HITRACE
197     HITRACE_METER_NAME(HITRACE_TAG_ACCESSIBILITY_MANAGER, "SetHighContrastTextState:" + std::to_string(state));
198 #endif // OHOS_BUILD_ENABLE_HITRACE
199 
200     sptr<AccessibilityAccountData> accountData =
201         Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
202     if (!accountData) {
203         HILOG_ERROR("accountData is nullptr.");
204         return RET_ERR_NULLPTR;
205     }
206     RetError ret = accountData->GetConfig()->SetHighContrastTextState(state);
207     UpdateConfigState();
208     return ret;
209 }
210 
SetDaltonizationState(const bool state)211 RetError AccessibilitySettings::SetDaltonizationState(const bool state)
212 {
213     HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
214 #ifdef OHOS_BUILD_ENABLE_HITRACE
215     HITRACE_METER_NAME(HITRACE_TAG_ACCESSIBILITY_MANAGER, "SetDaltonizationState:" + std::to_string(state));
216 #endif // OHOS_BUILD_ENABLE_HITRACE
217 
218     sptr<AccessibilityAccountData> accountData =
219         Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
220     if (!accountData) {
221         HILOG_ERROR("accountData is nullptr.");
222         return RET_ERR_NULLPTR;
223     }
224     RetError ret = accountData->GetConfig()->SetDaltonizationState(state);
225     UpdateConfigState();
226     return ret;
227 }
228 
SetInvertColorState(const bool state)229 RetError AccessibilitySettings::SetInvertColorState(const bool state)
230 {
231     HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
232 #ifdef OHOS_BUILD_ENABLE_HITRACE
233     HITRACE_METER_NAME(HITRACE_TAG_ACCESSIBILITY_MANAGER, "SetInvertColorState:" + std::to_string(state));
234 #endif // OHOS_BUILD_ENABLE_HITRACE
235 
236     sptr<AccessibilityAccountData> accountData =
237         Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
238     if (!accountData) {
239         HILOG_ERROR("accountData is nullptr.");
240         return RET_ERR_NULLPTR;
241     }
242     RetError ret = accountData->GetConfig()->SetInvertColorState(state);
243     UpdateConfigState();
244     return ret;
245 }
246 
SetAnimationOffState(const bool state)247 RetError AccessibilitySettings::SetAnimationOffState(const bool state)
248 {
249     HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
250 
251     sptr<AccessibilityAccountData> accountData =
252         Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
253     if (!accountData) {
254         HILOG_ERROR("accountData is nullptr.");
255         return RET_ERR_NULLPTR;
256     }
257     RetError ret = accountData->GetConfig()->SetAnimationOffState(state);
258     UpdateConfigState();
259     int setGraphicParamRes = -1;
260     int setArkuiParamRes = -1;
261     if (state) {
262         setGraphicParamRes = SetParameter(GRAPHIC_ANIMATION_SCALE_NAME.c_str(), "0");
263         setArkuiParamRes = SetParameter(ARKUI_ANIMATION_SCALE_NAME.c_str(), "0");
264     } else {
265         setGraphicParamRes = SetParameter(GRAPHIC_ANIMATION_SCALE_NAME.c_str(), "1");
266         setArkuiParamRes = SetParameter(ARKUI_ANIMATION_SCALE_NAME.c_str(), "1");
267     }
268     HILOG_INFO("SetParameter results are %{public}d and %{public}d", setGraphicParamRes, setArkuiParamRes);
269     return ret;
270 }
271 
SetAudioMonoState(const bool state)272 RetError AccessibilitySettings::SetAudioMonoState(const bool state)
273 {
274     HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
275 #ifdef OHOS_BUILD_ENABLE_HITRACE
276     HITRACE_METER_NAME(HITRACE_TAG_ACCESSIBILITY_MANAGER, "SetAudioMonoState:" + std::to_string(state));
277 #endif // OHOS_BUILD_ENABLE_HITRACE
278 
279     sptr<AccessibilityAccountData> accountData =
280         Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
281     if (!accountData) {
282         HILOG_ERROR("accountData is nullptr.");
283         return RET_ERR_NULLPTR;
284     }
285     RetError ret = accountData->GetConfig()->SetAudioMonoState(state);
286     UpdateConfigState();
287     return ret;
288 }
289 
SetDaltonizationColorFilter(const uint32_t filter)290 RetError AccessibilitySettings::SetDaltonizationColorFilter(const uint32_t filter)
291 {
292     HILOG_INFO("filter = [%{public}u]", filter);
293 #ifdef OHOS_BUILD_ENABLE_HITRACE
294     HITRACE_METER_NAME(HITRACE_TAG_ACCESSIBILITY_MANAGER, "SetDaltonizationColorFilter:" + std::to_string(filter));
295 #endif // OHOS_BUILD_ENABLE_HITRACE
296     if (!handler_) {
297         HILOG_ERROR("handler_ is nullptr.");
298         return RET_ERR_NULLPTR;
299     }
300 
301     ffrt::promise<RetError> syncPromise;
302     ffrt::future syncFuture = syncPromise.get_future();
303     handler_->PostTask([this, &syncPromise, filter]() {
304         sptr<AccessibilityAccountData> accountData =
305             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
306         if (!accountData) {
307             HILOG_ERROR("accountData is nullptr.");
308             syncPromise.set_value(RET_ERR_NULLPTR);
309             return;
310         }
311         RetError ret = accountData->GetConfig()->SetDaltonizationColorFilter(filter);
312         syncPromise.set_value(ret);
313         UpdateDaltonizationColorFilter();
314         }, "TASK_SET_DALTONIZATION_COLORFILTER");
315     return syncFuture.get();
316 }
317 
SetContentTimeout(const uint32_t time)318 RetError AccessibilitySettings::SetContentTimeout(const uint32_t time)
319 {
320     HILOG_INFO("time = [%{public}u]", time);
321     if (!handler_) {
322         HILOG_ERROR("handler_ is nullptr.");
323         return RET_ERR_NULLPTR;
324     }
325 
326     ffrt::promise<RetError> syncPromise;
327     ffrt::future syncFuture = syncPromise.get_future();
328     handler_->PostTask([this, &syncPromise, time]() {
329         sptr<AccessibilityAccountData> accountData =
330             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
331         if (!accountData) {
332             HILOG_ERROR("accountData is nullptr.");
333             syncPromise.set_value(RET_ERR_NULLPTR);
334             return;
335         }
336         RetError ret = accountData->GetConfig()->SetContentTimeout(time);
337         syncPromise.set_value(ret);
338         UpdateContentTimeout();
339         }, "TASK_SET_CONTENT_TIMEOUT");
340     return syncFuture.get();
341 }
342 
SetBrightnessDiscount(const float discount)343 RetError AccessibilitySettings::SetBrightnessDiscount(const float discount)
344 {
345     HILOG_INFO("discount = [%{public}f]", discount);
346     if (!handler_) {
347         HILOG_ERROR("handler_ is nullptr.");
348         return RET_ERR_NULLPTR;
349     }
350 
351 #ifdef OHOS_BUILD_ENABLE_POWER_MANAGER
352     if (!Singleton<AccessibilityPowerManager>::GetInstance().DiscountBrightness(discount)) {
353         HILOG_ERROR("Failed to set brightness discount");
354         return Accessibility::RET_ERR_FAILED;
355     }
356 #endif
357     ffrt::promise<RetError> syncPromise;
358     ffrt::future syncFuture = syncPromise.get_future();
359     handler_->PostTask([this, &syncPromise, discount]() {
360         sptr<AccessibilityAccountData> accountData =
361             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
362         if (!accountData) {
363             HILOG_ERROR("accountData is nullptr.");
364             syncPromise.set_value(RET_ERR_NULLPTR);
365             return;
366         }
367         RetError ret = accountData->GetConfig()->SetBrightnessDiscount(discount);
368         syncPromise.set_value(ret);
369         UpdateBrightnessDiscount();
370         }, "TASK_SET_BRIGHTNESS_DISCOUNT");
371     return syncFuture.get();
372 }
373 
SetAudioBalance(const float balance)374 RetError AccessibilitySettings::SetAudioBalance(const float balance)
375 {
376     HILOG_INFO("balance = [%{public}f]", balance);
377 #ifdef OHOS_BUILD_ENABLE_HITRACE
378     HITRACE_METER_NAME(HITRACE_TAG_ACCESSIBILITY_MANAGER, "SetAudioBalance:" + std::to_string(balance));
379 #endif // OHOS_BUILD_ENABLE_HITRACE
380 
381     if (!handler_) {
382         HILOG_ERROR("handler_ is nullptr.");
383         return RET_ERR_NULLPTR;
384     }
385 
386     ffrt::promise<RetError> syncPromise;
387     ffrt::future syncFuture = syncPromise.get_future();
388     handler_->PostTask([this, &syncPromise, balance]() {
389         sptr<AccessibilityAccountData> accountData =
390             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
391         if (!accountData) {
392             HILOG_ERROR("accountData is nullptr.");
393             syncPromise.set_value(RET_ERR_NULLPTR);
394             return;
395         }
396         RetError ret = accountData->GetConfig()->SetAudioBalance(balance);
397         syncPromise.set_value(ret);
398         UpdateAudioBalance();
399         }, "TASK_SET_AUDIO_BALANCE");
400     return syncFuture.get();
401 }
402 
SetClickResponseTime(const uint32_t time)403 RetError AccessibilitySettings::SetClickResponseTime(const uint32_t time)
404 {
405     HILOG_INFO("click response time = [%{public}u]", time);
406 #ifdef OHOS_BUILD_ENABLE_HITRACE
407     HITRACE_METER_NAME(HITRACE_TAG_ACCESSIBILITY_MANAGER, "SetClickResponseTime:" + std::to_string(time));
408 #endif // OHOS_BUILD_ENABLE_HITRACE
409 
410     if (!handler_) {
411         HILOG_ERROR("handler_ is nullptr.");
412         return RET_ERR_NULLPTR;
413     }
414 
415     ffrt::promise<RetError> syncPromise;
416     ffrt::future syncFuture = syncPromise.get_future();
417     handler_->PostTask([this, &syncPromise, time]() {
418         sptr<AccessibilityAccountData> accountData =
419             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
420         if (!accountData) {
421             HILOG_ERROR("accountData is nullptr.");
422             syncPromise.set_value(RET_ERR_NULLPTR);
423             return;
424         }
425         RetError ret = accountData->GetConfig()->SetClickResponseTime(time);
426         syncPromise.set_value(ret);
427         UpdateClickResponseTime();
428         Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateInputFilter();
429         }, "TASK_SET_CLICK_RESPONSE_TIME");
430     return syncFuture.get();
431 }
432 
SetIgnoreRepeatClickState(const bool state)433 RetError AccessibilitySettings::SetIgnoreRepeatClickState(const bool state)
434 {
435     HILOG_INFO("ignore repeat click state = [%{public}s]", state ? "True" : "False");
436 #ifdef OHOS_BUILD_ENABLE_HITRACE
437     HITRACE_METER_NAME(HITRACE_TAG_ACCESSIBILITY_MANAGER, "SetIgnoreRepeatClickState:" + std::to_string(state));
438 #endif // OHOS_BUILD_ENABLE_HITRACE
439 
440     if (!handler_) {
441         HILOG_ERROR("handler_ is nullptr.");
442         return RET_ERR_NULLPTR;
443     }
444 
445     ffrt::promise<RetError> syncPromise;
446     ffrt::future syncFuture = syncPromise.get_future();
447     handler_->PostTask([this, &syncPromise, state]() {
448         sptr<AccessibilityAccountData> accountData =
449             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
450         if (!accountData) {
451             HILOG_ERROR("accountData is nullptr.");
452             syncPromise.set_value(RET_ERR_NULLPTR);
453             return;
454         }
455         RetError ret = accountData->GetConfig()->SetIgnoreRepeatClickState(state);
456         syncPromise.set_value(ret);
457         UpdateConfigState();
458         Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateInputFilter();
459         }, "TASK_SET_IGNORE_REPEAT_CLICK_STATE");
460     return syncFuture.get();
461 }
462 
SetIgnoreRepeatClickTime(const uint32_t time)463 RetError AccessibilitySettings::SetIgnoreRepeatClickTime(const uint32_t time)
464 {
465     HILOG_INFO("click response time = [%{public}u]", time);
466 #ifdef OHOS_BUILD_ENABLE_HITRACE
467     HITRACE_METER_NAME(HITRACE_TAG_ACCESSIBILITY_MANAGER, "SetIgnoreRepeatClickTime:" + std::to_string(time));
468 #endif // OHOS_BUILD_ENABLE_HITRACE
469 
470     if (!handler_) {
471         HILOG_ERROR("handler_ is nullptr.");
472         return RET_ERR_NULLPTR;
473     }
474 
475     ffrt::promise<RetError> syncPromise;
476     ffrt::future syncFuture = syncPromise.get_future();
477     handler_->PostTask([this, &syncPromise, time]() {
478         sptr<AccessibilityAccountData> accountData =
479             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
480         if (!accountData) {
481             HILOG_ERROR("accountData is nullptr.");
482             syncPromise.set_value(RET_ERR_NULLPTR);
483             return;
484         }
485         RetError ret = accountData->GetConfig()->SetIgnoreRepeatClickTime(time);
486         syncPromise.set_value(ret);
487         UpdateIgnoreRepeatClickTime();
488         Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateInputFilter();
489         }, "TASK_SET_IGNORE_REPEAT_CLICK_TIME");
490     return syncFuture.get();
491 }
492 
UpdateSettingsInAtoHosStatePart(ConfigValueAtoHosUpdate &atoHosValue)493 void AccessibilitySettings::UpdateSettingsInAtoHosStatePart(ConfigValueAtoHosUpdate &atoHosValue)
494 {
495     sptr<AccessibilityAccountData> accountData =
496         Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
497     // set
498     if (atoHosValue.daltonizationState) {
499         accountData->GetConfig()->SetDaltonizationState(atoHosValue.daltonizationState);
500     }
501     if (atoHosValue.invertColor) {
502         accountData->GetConfig()->SetInvertColorState(atoHosValue.invertColor);
503     }
504     if (atoHosValue.audioMono) {
505         accountData->GetConfig()->SetAudioMonoState(atoHosValue.audioMono);
506     }
507     if (atoHosValue.highContrastText) {
508         accountData->GetConfig()->SetHighContrastTextState(atoHosValue.highContrastText);
509     }
510     if (atoHosValue.ignoreRepeatClickState) {
511         accountData->GetConfig()->SetIgnoreRepeatClickState(atoHosValue.ignoreRepeatClickState);
512     }
513     if (atoHosValue.shortcutEnabled) {
514         accountData->GetConfig()->SetShortKeyState(atoHosValue.shortcutEnabled);
515     }
516     bool shortKeyOnLockScreenAutoOn = false;
517     if (atoHosValue.shortcutTimeout == 1) {
518         accountData->GetConfig()->SetShortKeyTimeout(SHORT_KEY_TIMEOUT_AFTER_USE);
519         if (atoHosValue.shortcutOnLockScreen == INVALID_SHORTCUT_ON_LOCK_SCREEN_STATE) {
520             shortKeyOnLockScreenAutoOn = true;
521             accountData->GetConfig()->SetShortKeyOnLockScreenState(true);
522         }
523     } else if (atoHosValue.shortcutTimeout == 0) {
524         accountData->GetConfig()->SetShortKeyTimeout(SHORT_KEY_TIMEOUT_BEFORE_USE);
525     }
526     if (atoHosValue.shortcutOnLockScreen != INVALID_SHORTCUT_ON_LOCK_SCREEN_STATE) {
527         accountData->GetConfig()->SetShortKeyOnLockScreenState(atoHosValue.shortcutOnLockScreen == 1);
528     } else if (!shortKeyOnLockScreenAutoOn) {
529         accountData->GetConfig()->SetShortKeyOnLockScreenState(atoHosValue.shortcutEnabledOnLockScreen == 1);
530     }
531     if (atoHosValue.screenMagnificationState) {
532         accountData->GetConfig()->SetScreenMagnificationState(atoHosValue.screenMagnificationState);
533     }
534     UpdateConfigState();
535 }
536 
UpdateSettingsInAtoHos()537 void AccessibilitySettings::UpdateSettingsInAtoHos()
538 {
539     sptr<AccessibilityAccountData> accountData =
540         Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
541     ConfigValueAtoHosUpdate atoHosValue;
542     accountData->GetConfigValueAtoHos(atoHosValue);
543 
544     HILOG_INFO("daltonizationState(%{public}d), invertColor(%{public}d), \
545         audioMono(%{public}d), audioBalance(%{public}f), highContrastText(%{public}d), \
546         isScreenReaderEnabled(%{public}d), ignoreRepeatClickState(%{public}d), \
547         clickResponseTime(%{public}d), ignoreRepeatClickTime(%{public}d), displayDaltonizer(%{public}d), \
548         shortcutEnabled(%{public}d), shortcutEnabledOnLockScreen(%{public}d), shortcutTimeout(%{public}d), \
549         screenMagnificationState(%{public}d).",
550         atoHosValue.daltonizationState, atoHosValue.invertColor, atoHosValue.audioMono, atoHosValue.audioBalance,
551         atoHosValue.highContrastText, atoHosValue.isScreenReaderEnabled, atoHosValue.ignoreRepeatClickState,
552         atoHosValue.clickResponseTime, atoHosValue.ignoreRepeatClickTime, atoHosValue.displayDaltonizer,
553         atoHosValue.shortcutEnabled, atoHosValue.shortcutEnabledOnLockScreen, atoHosValue.shortcutTimeout,
554         atoHosValue.screenMagnificationState);
555 
556     UpdateSettingsInAtoHosStatePart(atoHosValue);
557 
558     if (atoHosValue.audioBalance != 0.0) {
559         accountData->GetConfig()->SetAudioBalance(atoHosValue.audioBalance);
560         UpdateAudioBalance();
561     }
562     if (atoHosValue.clickResponseTime != 0) {
563         accountData->GetConfig()->SetClickResponseTime(static_cast<uint32_t>(atoHosValue.clickResponseTime));
564         UpdateClickResponseTime();
565     }
566     if (atoHosValue.ignoreRepeatClickTime != 0) {
567         accountData->GetConfig()->SetIgnoreRepeatClickTime(static_cast<uint32_t>(atoHosValue.ignoreRepeatClickTime));
568         UpdateIgnoreRepeatClickTime();
569     }
570     if (atoHosValue.displayDaltonizer != 0) {
571         accountData->GetConfig()->SetDaltonizationColorFilter(static_cast<uint32_t>(atoHosValue.displayDaltonizer));
572         UpdateDaltonizationColorFilter();
573     }
574 
575     if (atoHosValue.isScreenReaderEnabled) {
576         uint32_t capabilities = CAPABILITY_GESTURE | CAPABILITY_KEY_EVENT_OBSERVER | CAPABILITY_RETRIEVE |
577             CAPABILITY_TOUCH_GUIDE | CAPABILITY_ZOOM;
578         accountData->EnableAbility(SCREEN_READER_BUNDLE_ABILITY_NAME, capabilities);
579     }
580     accountData->GetConfig()->CloneShortkeyService(atoHosValue.isScreenReaderEnabled);
581 
582     accountData->GetConfig()->SetStartFromAtoHosState(false);
583 }
584 
GetScreenMagnificationState(bool &state)585 RetError AccessibilitySettings::GetScreenMagnificationState(bool &state)
586 {
587     HILOG_DEBUG();
588     if (!handler_) {
589         HILOG_ERROR("handler_ is nullptr.");
590         return RET_ERR_NULLPTR;
591     }
592 
593     ffrt::promise<RetError> syncPromise;
594     ffrt::future syncFuture = syncPromise.get_future();
595     handler_->PostTask([this, &syncPromise, &state]() {
596         HILOG_DEBUG();
597         sptr<AccessibilityAccountData> accountData =
598             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
599         if (!accountData) {
600             HILOG_ERROR("accountData is nullptr");
601             syncPromise.set_value(RET_ERR_NULLPTR);
602             return;
603         }
604         state = accountData->GetConfig()->GetScreenMagnificationState();
605         syncPromise.set_value(RET_OK);
606         }, "TASK_GET_SCREENMAGNIFIER_STATE");
607     return syncFuture.get();
608 }
609 
GetShortKeyState(bool &state)610 RetError AccessibilitySettings::GetShortKeyState(bool &state)
611 {
612     HILOG_DEBUG();
613     if (!handler_) {
614         HILOG_ERROR("handler_ is nullptr.");
615         return RET_ERR_NULLPTR;
616     }
617 
618     ffrt::promise<RetError> syncPromise;
619     ffrt::future syncFuture = syncPromise.get_future();
620     handler_->PostTask([this, &syncPromise, &state]() {
621         HILOG_DEBUG();
622         sptr<AccessibilityAccountData> accountData =
623             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
624         if (!accountData) {
625             HILOG_ERROR("accountData is nullptr");
626             syncPromise.set_value(RET_ERR_NULLPTR);
627             return;
628         }
629         state = accountData->GetConfig()->GetShortKeyState();
630         syncPromise.set_value(RET_OK);
631         }, "TASK_GET_SHORTKEY_STATE");
632     return syncFuture.get();
633 }
634 
GetMouseKeyState(bool &state)635 RetError AccessibilitySettings::GetMouseKeyState(bool &state)
636 {
637     HILOG_DEBUG();
638     if (!handler_) {
639         HILOG_ERROR("handler_ is nullptr.");
640         return RET_ERR_NULLPTR;
641     }
642 
643     ffrt::promise<RetError> syncPromise;
644     ffrt::future syncFuture = syncPromise.get_future();
645     handler_->PostTask([this, &syncPromise, &state]() {
646         HILOG_DEBUG();
647         sptr<AccessibilityAccountData> accountData =
648             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
649         if (!accountData) {
650             HILOG_ERROR("accountData is nullptr");
651             syncPromise.set_value(RET_ERR_NULLPTR);
652             return;
653         }
654         state = accountData->GetConfig()->GetMouseKeyState();
655         syncPromise.set_value(RET_OK);
656         }, "TASK_GET_MOUSEKEY_STATE");
657     return syncFuture.get();
658 }
659 
GetMouseAutoClick(int32_t &time)660 RetError AccessibilitySettings::GetMouseAutoClick(int32_t &time)
661 {
662     HILOG_DEBUG();
663     ffrt::promise<RetError> syncPromise;
664     ffrt::future syncFuture = syncPromise.get_future();
665     handler_->PostTask([this, &syncPromise, &time]() {
666         HILOG_DEBUG();
667         sptr<AccessibilityAccountData> accountData =
668             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
669         if (!accountData) {
670             HILOG_ERROR("accountData is nullptr");
671             syncPromise.set_value(RET_ERR_NULLPTR);
672             return;
673         }
674         time = accountData->GetConfig()->GetMouseAutoClick();
675         syncPromise.set_value(RET_OK);
676         }, "TASK_GET_MOUSE_AUTOCLICK");
677 
678     return syncFuture.get();
679 }
680 
GetShortkeyTarget(std::string &name)681 RetError AccessibilitySettings::GetShortkeyTarget(std::string &name)
682 {
683     HILOG_DEBUG();
684     ffrt::promise<RetError> syncPromise;
685     ffrt::future syncFuture = syncPromise.get_future();
686     handler_->PostTask([this, &syncPromise, &name]() {
687         HILOG_DEBUG();
688         sptr<AccessibilityAccountData> accountData =
689             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
690         if (!accountData) {
691             HILOG_ERROR("accountData is nullptr");
692             syncPromise.set_value(RET_ERR_NULLPTR);
693             return;
694         }
695         name = accountData->GetConfig()->GetShortkeyTarget();
696         syncPromise.set_value(RET_OK);
697         }, "TASK_GET_SHORTKEY_TARGET");
698 
699     return syncFuture.get();
700 }
701 
GetShortkeyMultiTarget(std::vector<std::string> &name)702 RetError AccessibilitySettings::GetShortkeyMultiTarget(std::vector<std::string> &name)
703 {
704     HILOG_DEBUG();
705     ffrt::promise<RetError> syncPromise;
706     ffrt::future syncFuture = syncPromise.get_future();
707     handler_->PostTask([this, &syncPromise, &name]() {
708         HILOG_DEBUG();
709         sptr<AccessibilityAccountData> accountData =
710             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
711         if (!accountData) {
712             HILOG_ERROR("accountData is nullptr");
713             syncPromise.set_value(RET_ERR_NULLPTR);
714             return;
715         }
716         name = accountData->GetConfig()->GetShortkeyMultiTarget();
717         syncPromise.set_value(RET_OK);
718         }, "TASK_GET_SHORTKEY_MULTI_TARGET");
719 
720     return syncFuture.get();
721 }
722 
GetHighContrastTextState(bool &state)723 RetError AccessibilitySettings::GetHighContrastTextState(bool &state)
724 {
725     HILOG_DEBUG();
726     ffrt::promise<RetError> syncPromise;
727     ffrt::future syncFuture = syncPromise.get_future();
728     handler_->PostTask([this, &syncPromise, &state]() {
729         HILOG_DEBUG();
730         sptr<AccessibilityAccountData> accountData =
731             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
732         if (!accountData) {
733             HILOG_ERROR("accountData is nullptr");
734             syncPromise.set_value(RET_ERR_NULLPTR);
735             return;
736         }
737         state = accountData->GetConfig()->GetHighContrastTextState();
738         syncPromise.set_value(RET_OK);
739         }, "TASK_GET_HIGHCONTRASTTEXT_STATE");
740 
741     return syncFuture.get();
742 }
743 
GetDaltonizationState(bool &state)744 RetError AccessibilitySettings::GetDaltonizationState(bool &state)
745 {
746     HILOG_DEBUG();
747     ffrt::promise<RetError> syncPromise;
748     ffrt::future syncFuture = syncPromise.get_future();
749     handler_->PostTask([this, &syncPromise, &state]() {
750         HILOG_DEBUG();
751         sptr<AccessibilityAccountData> accountData =
752             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
753         if (!accountData) {
754             HILOG_ERROR("accountData is nullptr");
755             syncPromise.set_value(RET_ERR_NULLPTR);
756             return;
757         }
758         state = accountData->GetConfig()->GetDaltonizationState();
759         syncPromise.set_value(RET_OK);
760         }, "TASK_GET_DALTONIZATIONSTATE_STATE");
761 
762     return syncFuture.get();
763 }
764 
GetInvertColorState(bool &state)765 RetError AccessibilitySettings::GetInvertColorState(bool &state)
766 {
767     HILOG_DEBUG();
768     ffrt::promise<RetError> syncPromise;
769     ffrt::future syncFuture = syncPromise.get_future();
770     handler_->PostTask([this, &syncPromise, &state]() {
771         HILOG_DEBUG();
772         sptr<AccessibilityAccountData> accountData =
773             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
774         if (!accountData) {
775             HILOG_ERROR("accountData is nullptr");
776             syncPromise.set_value(RET_ERR_NULLPTR);
777             return;
778         }
779         state = accountData->GetConfig()->GetInvertColorState();
780         syncPromise.set_value(RET_OK);
781         }, "TASK_GET_INVERTCOLOR_STATE");
782 
783     return syncFuture.get();
784 }
785 
GetAnimationOffState(bool &state)786 RetError AccessibilitySettings::GetAnimationOffState(bool &state)
787 {
788     HILOG_DEBUG();
789     ffrt::promise<RetError> syncPromise;
790     ffrt::future syncFuture = syncPromise.get_future();
791     handler_->PostTask([this, &syncPromise, &state]() {
792         HILOG_DEBUG();
793         sptr<AccessibilityAccountData> accountData =
794             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
795         if (!accountData) {
796             HILOG_ERROR("accountData is nullptr");
797             syncPromise.set_value(RET_ERR_NULLPTR);
798             return;
799         }
800         state = accountData->GetConfig()->GetAnimationOffState();
801         syncPromise.set_value(RET_OK);
802         }, "TASK_GET_ANIMATIONOFF_STATE");
803 
804     return syncFuture.get();
805 }
806 
GetAudioMonoState(bool &state)807 RetError AccessibilitySettings::GetAudioMonoState(bool &state)
808 {
809     HILOG_DEBUG();
810     ffrt::promise<RetError> syncPromise;
811     ffrt::future syncFuture = syncPromise.get_future();
812     handler_->PostTask([this, &syncPromise, &state]() {
813         HILOG_DEBUG();
814         sptr<AccessibilityAccountData> accountData =
815             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
816         if (!accountData) {
817             HILOG_ERROR("accountData is nullptr");
818             syncPromise.set_value(RET_ERR_NULLPTR);
819             return;
820         }
821         state = accountData->GetConfig()->GetAudioMonoState();
822         syncPromise.set_value(RET_OK);
823         }, "TASK_GET_AUDIOMONO_STATE");
824 
825     return syncFuture.get();
826 }
827 
GetDaltonizationColorFilter(uint32_t &type)828 RetError AccessibilitySettings::GetDaltonizationColorFilter(uint32_t &type)
829 {
830     HILOG_DEBUG();
831     ffrt::promise<RetError> syncPromise;
832     ffrt::future syncFuture = syncPromise.get_future();
833     handler_->PostTask([this, &syncPromise, &type]() {
834         HILOG_DEBUG();
835         sptr<AccessibilityAccountData> accountData =
836             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
837         if (!accountData) {
838             HILOG_ERROR("accountData is nullptr");
839             syncPromise.set_value(RET_ERR_NULLPTR);
840             return;
841         }
842         type = accountData->GetConfig()->GetDaltonizationColorFilter();
843         syncPromise.set_value(RET_OK);
844         }, "TASK_GET_DALTONIZATION_COLORFILTER");
845 
846     return syncFuture.get();
847 }
848 
GetContentTimeout(uint32_t &timer)849 RetError AccessibilitySettings::GetContentTimeout(uint32_t &timer)
850 {
851     HILOG_DEBUG();
852     ffrt::promise<RetError> syncPromise;
853     ffrt::future syncFuture = syncPromise.get_future();
854     handler_->PostTask([this, &syncPromise, &timer]() {
855         HILOG_DEBUG();
856         sptr<AccessibilityAccountData> accountData =
857             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
858         if (!accountData) {
859             HILOG_ERROR("accountData is nullptr");
860             syncPromise.set_value(RET_ERR_NULLPTR);
861             return;
862         }
863         timer = accountData->GetConfig()->GetContentTimeout();
864         syncPromise.set_value(RET_OK);
865         }, "TASK_GET_CONTENT_TIMEOUT");
866 
867     return syncFuture.get();
868 }
869 
GetBrightnessDiscount(float &brightness)870 RetError AccessibilitySettings::GetBrightnessDiscount(float &brightness)
871 {
872     HILOG_DEBUG();
873     ffrt::promise<RetError> syncPromise;
874     ffrt::future syncFuture = syncPromise.get_future();
875     handler_->PostTask([this, &syncPromise, &brightness]() {
876         HILOG_DEBUG();
877         sptr<AccessibilityAccountData> accountData =
878             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
879         if (!accountData) {
880             HILOG_ERROR("accountData is nullptr");
881             syncPromise.set_value(RET_ERR_NULLPTR);
882             return;
883         }
884         brightness = accountData->GetConfig()->GetBrightnessDiscount();
885         syncPromise.set_value(RET_OK);
886         }, "TASK_GET_BRIGHTNESS_DISCOUNT");
887 
888     return syncFuture.get();
889 }
890 
GetAudioBalance(float &balance)891 RetError AccessibilitySettings::GetAudioBalance(float &balance)
892 {
893     HILOG_DEBUG();
894     ffrt::promise<RetError> syncPromise;
895     ffrt::future syncFuture = syncPromise.get_future();
896     handler_->PostTask([this, &syncPromise, &balance]() {
897         HILOG_DEBUG();
898         sptr<AccessibilityAccountData> accountData =
899             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
900         if (!accountData) {
901             HILOG_ERROR("accountData is nullptr");
902             syncPromise.set_value(RET_ERR_NULLPTR);
903             return;
904         }
905         balance = accountData->GetConfig()->GetAudioBalance();
906         syncPromise.set_value(RET_OK);
907         }, "TASK_GET_AUDIO_BALANCE");
908 
909     return syncFuture.get();
910 }
911 
GetClickResponseTime(uint32_t &time)912 RetError AccessibilitySettings::GetClickResponseTime(uint32_t &time)
913 {
914     HILOG_DEBUG();
915     ffrt::promise<RetError> syncPromise;
916     ffrt::future syncFuture = syncPromise.get_future();
917     handler_->PostTask([this, &syncPromise, &time]() {
918         HILOG_DEBUG();
919         sptr<AccessibilityAccountData> accountData =
920             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
921         if (!accountData) {
922             HILOG_ERROR("accountData is nullptr");
923             syncPromise.set_value(RET_ERR_NULLPTR);
924             return;
925         }
926         time = accountData->GetConfig()->GetClickResponseTime();
927         syncPromise.set_value(RET_OK);
928         }, "TASK_GET_CLICK_RESPONSE_TIME");
929 
930     return syncFuture.get();
931 }
932 
GetIgnoreRepeatClickState(bool &state)933 RetError AccessibilitySettings::GetIgnoreRepeatClickState(bool &state)
934 {
935     HILOG_DEBUG();
936     ffrt::promise<RetError> syncPromise;
937     ffrt::future syncFuture = syncPromise.get_future();
938     handler_->PostTask([this, &syncPromise, &state]() {
939         HILOG_DEBUG();
940         sptr<AccessibilityAccountData> accountData =
941             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
942         if (!accountData) {
943             HILOG_ERROR("accountData is nullptr");
944             syncPromise.set_value(RET_ERR_NULLPTR);
945             return;
946         }
947         state = accountData->GetConfig()->GetIgnoreRepeatClickState();
948         syncPromise.set_value(RET_OK);
949         }, "TASK_GET_IGNORE_REPEAT_CLICK_STATE");
950 
951     return syncFuture.get();
952 }
953 
GetIgnoreRepeatClickTime(uint32_t &time)954 RetError AccessibilitySettings::GetIgnoreRepeatClickTime(uint32_t &time)
955 {
956     HILOG_DEBUG();
957     ffrt::promise<RetError> syncPromise;
958     ffrt::future syncFuture = syncPromise.get_future();
959     handler_->PostTask([this, &syncPromise, &time]() {
960         HILOG_DEBUG();
961         sptr<AccessibilityAccountData> accountData =
962             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
963         if (!accountData) {
964             HILOG_ERROR("accountData is nullptr");
965             syncPromise.set_value(RET_ERR_NULLPTR);
966             return;
967         }
968         time = accountData->GetConfig()->GetIgnoreRepeatClickTime();
969         syncPromise.set_value(RET_OK);
970         }, "TASK_GET_IGNORE_REPEAT_CLICK_TIME");
971 
972     return syncFuture.get();
973 }
974 
UpdateConfigState()975 void AccessibilitySettings::UpdateConfigState()
976 {
977     handler_->PostTask([this]() {
978         HILOG_INFO("UpdateConfigState.");
979         sptr<AccessibilityAccountData> accountData =
980             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
981         if (!accountData) {
982             HILOG_ERROR("Account data is null");
983             return;
984         }
985 
986         uint32_t state = accountData->GetConfig()->GetConfigState();
987         for (auto &callback : accountData->GetConfigCallbacks()) {
988             if (callback) {
989                 callback->OnConfigStateChanged(state);
990             }
991         }
992         }, "UpdateConfigState");
993 }
994 
UpdateAudioBalance()995 void AccessibilitySettings::UpdateAudioBalance()
996 {
997     handler_->PostTask([this]() {
998         HILOG_INFO("UpdateAudioBalance.");
999         sptr<AccessibilityAccountData> accountData =
1000             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1001         if (!accountData) {
1002             HILOG_ERROR("Account data is null");
1003             return;
1004         }
1005 
1006         float audioBalance = accountData->GetConfig()->GetAudioBalance();
1007         for (auto &callback : accountData->GetConfigCallbacks()) {
1008             if (callback) {
1009                 callback->OnAudioBalanceChanged(audioBalance);
1010             }
1011         }
1012         }, "UpdateAudioBalance");
1013 }
1014 
UpdateBrightnessDiscount()1015 void AccessibilitySettings::UpdateBrightnessDiscount()
1016 {
1017     handler_->PostTask([this]() {
1018         HILOG_INFO("UpdateBrightnessDiscount.");
1019         sptr<AccessibilityAccountData> accountData =
1020             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1021         if (!accountData) {
1022             HILOG_ERROR("Account data is null");
1023             return;
1024         }
1025 
1026         float brightnessDiscount = accountData->GetConfig()->GetBrightnessDiscount();
1027         for (auto &callback : accountData->GetConfigCallbacks()) {
1028             if (callback) {
1029                 callback->OnBrightnessDiscountChanged(brightnessDiscount);
1030             }
1031         }
1032         }, "UpdateBrightnessDiscount");
1033 }
1034 
UpdateContentTimeout()1035 void AccessibilitySettings::UpdateContentTimeout()
1036 {
1037     handler_->PostTask([this]() {
1038         HILOG_INFO("UpdateContentTimeout.");
1039         sptr<AccessibilityAccountData> accountData =
1040             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1041         if (!accountData) {
1042             HILOG_ERROR("Account data is null");
1043             return;
1044         }
1045 
1046         uint32_t contentTimeout = accountData->GetConfig()->GetContentTimeout();
1047         for (auto &callback : accountData->GetConfigCallbacks()) {
1048             if (callback) {
1049                 callback->OnContentTimeoutChanged(contentTimeout);
1050             }
1051         }
1052         }, "UpdateContentTimeout");
1053 }
1054 
UpdateDaltonizationColorFilter()1055 void AccessibilitySettings::UpdateDaltonizationColorFilter()
1056 {
1057     handler_->PostTask([this]() {
1058         HILOG_INFO("UpdateDaltonizationColorFilter.");
1059         sptr<AccessibilityAccountData> accountData =
1060             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1061         if (!accountData) {
1062             HILOG_ERROR("Account data is null");
1063             return;
1064         }
1065 
1066         uint32_t daltonizationColorFilter = accountData->GetConfig()->GetDaltonizationColorFilter();
1067         for (auto &callback : accountData->GetConfigCallbacks()) {
1068             if (callback) {
1069                 callback->OnDaltonizationColorFilterChanged(daltonizationColorFilter);
1070             }
1071         }
1072         }, "UpdateDaltonizationColorFilter");
1073 }
1074 
UpdateMouseAutoClick()1075 void AccessibilitySettings::UpdateMouseAutoClick()
1076 {
1077     handler_->PostTask([this]() {
1078         HILOG_INFO("UpdateMouseAutoClick.");
1079         sptr<AccessibilityAccountData> accountData =
1080             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1081         if (!accountData) {
1082             HILOG_ERROR("Account data is null");
1083             return;
1084         }
1085 
1086         int32_t mouseAutoClick = accountData->GetConfig()->GetMouseAutoClick();
1087         for (auto &callback : accountData->GetConfigCallbacks()) {
1088             if (callback) {
1089                 callback->OnMouseAutoClickChanged(mouseAutoClick);
1090             }
1091         }
1092         }, "UpdateMouseAutoClick");
1093 }
1094 
UpdateShortkeyTarget()1095 void AccessibilitySettings::UpdateShortkeyTarget()
1096 {
1097     handler_->PostTask([this]() {
1098         HILOG_INFO("UpdateShortkeyTarget.");
1099         sptr<AccessibilityAccountData> accountData =
1100             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1101         if (!accountData) {
1102             HILOG_ERROR("Account data is null");
1103             return;
1104         }
1105 
1106         std::string shortkeyTarget = accountData->GetConfig()->GetShortkeyTarget();
1107         for (auto &callback : accountData->GetConfigCallbacks()) {
1108             if (callback) {
1109                 callback->OnShortkeyTargetChanged(shortkeyTarget);
1110             }
1111         }
1112         }, "UpdateShortkeyTarget");
1113 }
1114 
UpdateShortkeyMultiTarget()1115 void AccessibilitySettings::UpdateShortkeyMultiTarget()
1116 {
1117     handler_->PostTask([this]() {
1118         HILOG_INFO("UpdateShortkeyMultiTarget.");
1119         sptr<AccessibilityAccountData> accountData =
1120             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1121         if (!accountData) {
1122             HILOG_ERROR("Account data is null");
1123             return;
1124         }
1125 
1126         std::vector<std::string> shortkeyMultiTarget = accountData->GetConfig()->GetShortkeyMultiTarget();
1127         for (auto &callback : accountData->GetConfigCallbacks()) {
1128             if (callback) {
1129                 callback->OnShortkeyMultiTargetChanged(shortkeyMultiTarget);
1130             }
1131         }
1132         }, "UpdateShortkeyMultiTarget");
1133 }
1134 
UpdateClickResponseTime()1135 void AccessibilitySettings::UpdateClickResponseTime()
1136 {
1137     handler_->PostTask([this]() {
1138         HILOG_INFO("UpdateClickResponseTime.");
1139         sptr<AccessibilityAccountData> accountData =
1140             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1141         if (!accountData) {
1142             HILOG_ERROR("Account data is null");
1143             return;
1144         }
1145 
1146         uint32_t time = accountData->GetConfig()->GetClickResponseTime();
1147         for (auto &callback : accountData->GetConfigCallbacks()) {
1148             if (callback) {
1149                 callback->OnClickResponseTimeChanged(time);
1150             }
1151         }
1152         }, "UpdateClickResponseTime");
1153 }
1154 
UpdateIgnoreRepeatClickTime()1155 void AccessibilitySettings::UpdateIgnoreRepeatClickTime()
1156 {
1157     handler_->PostTask([this]() {
1158         HILOG_INFO("UpdateIgnoreRepeatClickTime.");
1159         sptr<AccessibilityAccountData> accountData =
1160             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1161         if (!accountData) {
1162             HILOG_ERROR("Account data is null");
1163             return;
1164         }
1165 
1166         uint32_t time = accountData->GetConfig()->GetIgnoreRepeatClickTime();
1167         for (auto &callback : accountData->GetConfigCallbacks()) {
1168             if (callback) {
1169                 callback->OnIgnoreRepeatClickTimeChanged(time);
1170             }
1171         }
1172         }, "UpdateIgnoreRepeatClickTime");
1173 }
1174 
GetCaptionProperty(AccessibilityConfig::CaptionProperty &caption)1175 RetError AccessibilitySettings::GetCaptionProperty(AccessibilityConfig::CaptionProperty &caption)
1176 {
1177     HILOG_DEBUG();
1178     if (!handler_) {
1179         HILOG_ERROR("handler_ is nullptr.");
1180         return RET_ERR_NULLPTR;
1181     }
1182 
1183     ffrt::promise<RetError> syncPromise;
1184     ffrt::future syncFuture = syncPromise.get_future();
1185     handler_->PostTask([this, &syncPromise, &caption]() {
1186         HILOG_DEBUG();
1187         sptr<AccessibilityAccountData> accountData =
1188             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1189         if (!accountData) {
1190             HILOG_ERROR("accountData is nullptr.");
1191             syncPromise.set_value(RET_ERR_NULLPTR);
1192             return;
1193         }
1194         caption = accountData->GetConfig()->GetCaptionProperty();
1195         syncPromise.set_value(RET_OK);
1196         }, "TASK_GET_CAPTION_PROPERTY");
1197     return syncFuture.get();
1198 }
1199 
SetCaptionProperty(const AccessibilityConfig::CaptionProperty &caption)1200 RetError AccessibilitySettings::SetCaptionProperty(const AccessibilityConfig::CaptionProperty &caption)
1201 {
1202     HILOG_DEBUG();
1203     if (!handler_) {
1204         HILOG_ERROR("handler_ is nullptr.");
1205         return RET_ERR_NULLPTR;
1206     }
1207 
1208     ffrt::promise<RetError> syncPromise;
1209     ffrt::future syncFuture = syncPromise.get_future();
1210     handler_->PostTask([this, &syncPromise, &caption]() {
1211         HILOG_DEBUG();
1212         sptr<AccessibilityAccountData> accountData =
1213             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1214         if (!accountData) {
1215             HILOG_ERROR("accountData is nullptr.");
1216             syncPromise.set_value(RET_ERR_NULLPTR);
1217             return;
1218         }
1219         RetError ret = accountData->GetConfig()->SetCaptionProperty(caption);
1220         syncPromise.set_value(ret);
1221         UpdateCaptionProperty();
1222         }, "TASK_SET_CAPTION_PROPERTY");
1223     return syncFuture.get();
1224 }
1225 
SetCaptionState(const bool state)1226 RetError AccessibilitySettings::SetCaptionState(const bool state)
1227 {
1228     HILOG_DEBUG();
1229     sptr<AccessibilityAccountData> accountData =
1230         Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1231     if (!accountData) {
1232         HILOG_ERROR("accountData is nullptr.");
1233         return RET_ERR_NULLPTR;
1234     }
1235     RetError ret = accountData->GetConfig()->SetCaptionState(state);
1236     UpdateConfigState();
1237     return ret;
1238 }
1239 
GetCaptionState(bool &state)1240 RetError AccessibilitySettings::GetCaptionState(bool &state)
1241 {
1242     HILOG_DEBUG();
1243     if (!handler_) {
1244         HILOG_ERROR("handler_ is nullptr.");
1245         return RET_ERR_NULLPTR;
1246     }
1247 
1248     ffrt::promise<RetError> syncPromise;
1249     ffrt::future syncFuture = syncPromise.get_future();
1250     handler_->PostTask([this, &syncPromise, &state]() {
1251         HILOG_DEBUG();
1252         sptr<AccessibilityAccountData> accountData =
1253             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1254         if (!accountData) {
1255             HILOG_ERROR("accountData is nullptr");
1256             syncPromise.set_value(RET_ERR_NULLPTR);
1257             return;
1258         }
1259         state = accountData->GetConfig()->GetCaptionState();
1260         syncPromise.set_value(RET_OK);
1261         }, "TASK_GET_CAPTION_STATE");
1262     return syncFuture.get();
1263 }
1264 
UpdateCaptionProperty()1265 void AccessibilitySettings::UpdateCaptionProperty()
1266 {
1267     handler_->PostTask([this]() {
1268         HILOG_DEBUG("UpdateCaptionProperty.");
1269         sptr<AccessibilityAccountData> accountData =
1270             Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1271         if (!accountData) {
1272             HILOG_ERROR("Account data is null");
1273             return;
1274         }
1275 
1276         AccessibilityConfig::CaptionProperty caption = accountData->GetConfig()->GetCaptionProperty();
1277         for (auto &callback : accountData->GetCaptionPropertyCallbacks()) {
1278             if (callback) {
1279                 callback->OnPropertyChanged(caption);
1280             }
1281         }
1282         }, "UpdateCaptionProperty");
1283 }
1284 
UpdateAllSetting()1285 void AccessibilitySettings::UpdateAllSetting()
1286 {
1287     HILOG_DEBUG();
1288     if (!handler_) {
1289         HILOG_ERROR("UpdateAllSetting: handler is nullptr!");
1290         return;
1291     }
1292     handler_->PostTask([this]() {
1293         UpdateConfigState();
1294         UpdateShortkeyTarget();
1295         UpdateShortkeyMultiTarget();
1296         UpdateMouseAutoClick();
1297         UpdateDaltonizationColorFilter();
1298         UpdateContentTimeout();
1299         UpdateBrightnessDiscount();
1300         UpdateAudioBalance();
1301         UpdateClickResponseTime();
1302         UpdateIgnoreRepeatClickTime();
1303         }, "UPDATE_ALL_SETTING");
1304 }
1305 } // namespace Accessibility
1306 } // namespace OHOS