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