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