1 /*
2 * Copyright (C) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "accessibility_settings_config.h"
17 #include "hilog_wrapper.h"
18 #include "system_ability_definition.h"
19 #include "utils.h"
20 #include "accessibility_setting_provider.h"
21 #include "accessible_ability_manager_service.h"
22
23 namespace OHOS {
24 namespace Accessibility {
25 namespace {
26 constexpr uint32_t DEFAULT_COLOR = 0xff000000;
27 const int32_t DEFAULT_SCALE = 100;
28 const int32_t SHORT_KEY_TIMEOUT_AFTER_USE = 1000; // ms
29 const int32_t SHORT_KEY_TIMEOUT_BEFORE_USE = 3000; // ms
30 const int32_t DEFAULT_ACCOUNT_ID = 100;
31 const std::string ACCESSIBILITY = "accessibility";
32 const std::string TOUCH_GUIDE_STATE = "touch_guide_state";
33 const std::string GESTURE_KEY = "gesture_state";
34 const std::string CAPTION_KEY = "caption_state";
35 const std::string KEYEVENT_OBSERVER = "keyevent_observer";
36 const std::string SCREEN_MAGNIFICATION_KEY = "accessibility_display_magnification_enabled";
37 const std::string SCREEN_MAGNIFICATION_TYPE = "accessibility_magnification_capability";
38 const std::string MOUSEKEY = "mousekey";
39 const std::string HIGH_CONTRAST_TEXT_KEY = "high_text_contrast_enabled";
40 const std::string DALTONIZATION_STATE = "accessibility_display_daltonizer_enabled";
41 const std::string INVERT_COLOR_KEY = "accessibility_display_inversion_enabled";
42 const std::string ANIMATION_OFF_KEY = "animation_off";
43 const std::string AUDIO_MONO_KEY = "master_mono";
44 const std::string IGNORE_REPEAT_CLICK_SWITCH = "ignore_repeat_click_switch";
45 const std::string SHORTCUT_ENABLED = "accessibility_shortcut_enabled";
46 const std::string SHORTCUT_SERVICE = "accessibility_shortcut_target_service";
47 const std::string CLICK_RESPONCE_TIME = "click_response_time";
48 const std::string IGNORE_REPEAT_CLICK_TIME = "ignore_repeat_click_time";
49 const std::string DALTONIZATION_COLOR_FILTER_KEY = "accessibility_display_daltonizer";
50 const std::string CONTENT_TIMEOUT_KEY = "accessibility_content_timeout";
51 const std::string BRIGHTNESS_DISCOUNT_KEY = "accessibility_brightness_discount";
52 const std::string AUDIO_BALANCE_KEY = "master_balance";
53 const std::string FONT_FAMILY = "accessibility_font_family";
54 const std::string FONT_COLOR = "accessibility_font_color";
55 const std::string FONT_EDGE_TYPE = "accessibility_font_edge_type";
56 const std::string BACKGROUND_COLOR = "accessibility_background_color";
57 const std::string WINDOW_COLOR = "accessibility_window_color";
58 const std::string FONT_SCALE = "accessibility_font_scale";
59 const std::string ENABLED_ACCESSIBILITY_SERVICES = "enabled_accessibility_services";
60 const std::string SHORTCUT_ENABLED_ON_LOCK_SCREEN = "accessibility_shortcut_enabled_on_lock_screen";
61 const std::string SHORTCUT_TIMEOUT = "accessibility_shortcut_timeout";
62 const std::string ACCESSIBILITY_CLONE_FLAG = "accessibility_config_clone";
63 const std::string SCREENREADER_TAG = "screenreader";
64 const std::string INVERT_COLOR_AOS_TAG = "ColorInversion";
65 const std::string INVERT_COLOR_HMOS_TAG = "INVERT_COLOR";
66 const std::string AUDIO_MONO_HMOS_TAG = "AUDIO_MONO";
67 const std::string HIGH_CONTRAST_TEXT_HMOS_TAG = "HIGH_CONTRAST_TEXT";
68 const std::string SCREEN_READER_BUNDLE_ABILITY_NAME = "com.huawei.hmos.screenreader/AccessibilityExtAbility";
69 const std::string ACCESSIBILITY_SCREENREADER_ENABLED = "accessibility_screenreader_enabled";
70 const std::string ACCESSIBILITY_PRIVACY_CLONE_OR_UPGRADE = "accessibility_privacy_clone_or_upgrade";
71 constexpr int DOUBLE_CLICK_RESPONSE_TIME_MEDIUM = 300;
72 constexpr int DOUBLE_IGNORE_REPEAT_CLICK_TIME_SHORTEST = 100;
73 constexpr int DOUBLE_IGNORE_REPEAT_CLICK_TIME_SHORT = 400;
74 constexpr int DOUBLE_IGNORE_REPEAT_CLICK_TIME_MEDIUM = 700;
75 constexpr int DOUBLE_IGNORE_REPEAT_CLICK_TIME_LONG = 1000;
76 constexpr int DISPLAY_DALTONIZER_INVALID = -1;
77 constexpr int DISPLAY_DALTONIZER_GREEN = 12;
78 constexpr int DISPLAY_DALTONIZER_RED = 11;
79 constexpr int DISPLAY_DALTONIZER_BLUE = 13;
80 constexpr int INVALID_MASTER_MONO_VALUE = -1;
81 constexpr int AUDIO_BALANCE_STEP = 5;
82 constexpr float INVALID_MASTER_BALANCE_VALUE = 2.0;
83 constexpr float EPS = 1e-6;
84 } // namespace
AccessibilitySettingsConfig(int32_t id)85 AccessibilitySettingsConfig::AccessibilitySettingsConfig(int32_t id)
86 {
87 HILOG_DEBUG("id = [%{public}d]", id);
88 accountId_ = id;
89 }
90
SetEnabled(const bool state)91 RetError AccessibilitySettingsConfig::SetEnabled(const bool state)
92 {
93 HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
94 auto ret = SetConfigState(ACCESSIBILITY, state);
95 if (ret != RET_OK) {
96 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetEnabled");
97 HILOG_ERROR("set accessibility failed");
98 return ret;
99 }
100 enabled_ = state;
101 return ret;
102 }
103
SetTouchGuideState(const bool state)104 RetError AccessibilitySettingsConfig::SetTouchGuideState(const bool state)
105 {
106 HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
107 auto ret = SetConfigState(TOUCH_GUIDE_STATE, state);
108 if (ret != RET_OK) {
109 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetTouchGuideState");
110 HILOG_ERROR("set eventTouchGuideState_ failed");
111 return ret;
112 }
113 eventTouchGuideState_ = state;
114 return ret;
115 }
116
SetGestureState(const bool state)117 RetError AccessibilitySettingsConfig::SetGestureState(const bool state)
118 {
119 HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
120 auto ret = SetConfigState(GESTURE_KEY, state);
121 if (ret != RET_OK) {
122 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetGestureState");
123 HILOG_ERROR("set gesturesSimulation_ failed");
124 return ret;
125 }
126 gesturesSimulation_ = state;
127 return ret;
128 }
129
SetKeyEventObserverState(const bool state)130 RetError AccessibilitySettingsConfig::SetKeyEventObserverState(const bool state)
131 {
132 HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
133 auto ret = SetConfigState(KEYEVENT_OBSERVER, state);
134 if (ret != RET_OK) {
135 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetKeyEventObserverState");
136 HILOG_ERROR("set filteringKeyEvents_ failed");
137 return ret;
138 }
139 filteringKeyEvents_ = state;
140 return ret;
141 }
142
SetCaptionState(const bool state)143 RetError AccessibilitySettingsConfig::SetCaptionState(const bool state)
144 {
145 HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
146 auto ret = SetConfigState(CAPTION_KEY, state);
147 if (ret != RET_OK) {
148 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetCaptionState");
149 HILOG_ERROR("set isCaptionState_ failed");
150 return ret;
151 }
152 isCaptionState_ = state;
153 return ret;
154 }
155
SetScreenMagnificationState(const bool state)156 RetError AccessibilitySettingsConfig::SetScreenMagnificationState(const bool state)
157 {
158 HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
159 isScreenMagnificationState_ = state;
160 return RET_OK;
161 }
162
SetScreenMagnificationType(const uint32_t type)163 RetError AccessibilitySettingsConfig::SetScreenMagnificationType(const uint32_t type)
164 {
165 HILOG_DEBUG("screenMagnificationType = [%{public}u]", type);
166 screenMagnificationType_ = type;
167 return RET_OK;
168 }
169
SetShortKeyState(const bool state)170 RetError AccessibilitySettingsConfig::SetShortKeyState(const bool state)
171 {
172 HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
173 auto ret = SetConfigState(SHORTCUT_ENABLED, state);
174 if (ret != RET_OK) {
175 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetShortKeyState");
176 HILOG_ERROR("set isShortKeyState_ failed");
177 return ret;
178 }
179 isShortKeyState_ = state;
180 return ret;
181 }
182
SetShortKeyOnLockScreenState(const bool state)183 RetError AccessibilitySettingsConfig::SetShortKeyOnLockScreenState(const bool state)
184 {
185 HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
186 auto ret = SetConfigState(SHORTCUT_ENABLED_ON_LOCK_SCREEN, state);
187 if (ret != RET_OK) {
188 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetShortKeyOnLockScreenState");
189 HILOG_ERROR("set isShortKeyEnabledOnLockScreen_ failed");
190 return ret;
191 }
192 isShortKeyEnabledOnLockScreen_ = state;
193 return ret;
194 }
195
SetShortKeyTimeout(const int32_t time)196 RetError AccessibilitySettingsConfig::SetShortKeyTimeout(const int32_t time)
197 {
198 HILOG_DEBUG("time = [%{public}u]", time);
199 if (!datashare_) {
200 HILOG_ERROR("helper is nullptr");
201 return RET_ERR_NULLPTR;
202 }
203
204 auto ret = datashare_->PutIntValue(SHORTCUT_TIMEOUT, static_cast<int32_t>(time));
205 if (ret != RET_OK) {
206 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetShortKeyTimeout");
207 HILOG_ERROR("set shortKeyTimeout_ failed");
208 return ret;
209 }
210 shortKeyTimeout_ = time;
211 return ret;
212 }
213
SetStartToHosState(const bool state)214 RetError AccessibilitySettingsConfig::SetStartToHosState(const bool state)
215 {
216 HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
217 if (!datashare_) {
218 HILOG_ERROR("helper is nullptr");
219 return RET_ERR_NULLPTR;
220 }
221 auto ret = datashare_->PutBoolValue("AccessibilityStartFromAtoHos", state);
222 if (ret != RET_OK) {
223 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetStartToHosState");
224 HILOG_ERROR("set startToHosState failed");
225 }
226 return ret;
227 }
228
SetMouseKeyState(const bool state)229 RetError AccessibilitySettingsConfig::SetMouseKeyState(const bool state)
230 {
231 HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
232 auto ret = SetConfigState(MOUSEKEY, state);
233 if (ret != RET_OK) {
234 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetMouseKeyState");
235 HILOG_ERROR("set isMouseKeyState_ failed");
236 return ret;
237 }
238 isMouseKeyState_ = state;
239 return ret;
240 }
241
SetMouseAutoClick(const int32_t time)242 RetError AccessibilitySettingsConfig::SetMouseAutoClick(const int32_t time)
243 {
244 HILOG_DEBUG("time = [%{public}d]", time);
245 if (!datashare_) {
246 HILOG_ERROR("helper is nullptr");
247 return RET_ERR_NULLPTR;
248 }
249
250 auto ret = datashare_->PutIntValue("MouseAutoClick", time);
251 if (ret != RET_OK) {
252 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetMouseAutoClick");
253 HILOG_ERROR("set mouseAutoClick_ failed");
254 return ret;
255 }
256 mouseAutoClick_ = time;
257 return ret;
258 }
259
SetShortkeyTarget(const std::string & name)260 RetError AccessibilitySettingsConfig::SetShortkeyTarget(const std::string &name)
261 {
262 HILOG_DEBUG("name = [%{public}s]", name.c_str());
263 if (!datashare_) {
264 HILOG_ERROR("helper is nullptr");
265 return RET_ERR_NULLPTR;
266 }
267
268 auto ret = datashare_->PutStringValue("ShortkeyTarget", name);
269 if (ret != RET_OK) {
270 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetShortkeyTarget");
271 HILOG_ERROR("set shortkeyTarget_ failed");
272 return ret;
273 }
274 shortkeyTarget_ = name;
275 return ret;
276 }
277
SetShortkeyMultiTarget(const std::vector<std::string> & name)278 RetError AccessibilitySettingsConfig::SetShortkeyMultiTarget(const std::vector<std::string> &name)
279 {
280 HILOG_DEBUG();
281 std::set<std::string> targets;
282 std::copy_if(name.begin(), name.end(), std::inserter(targets, targets.end()),
283 [&targets](const std::string &target) {
284 targets.insert(target);
285 return true;
286 });
287 std::lock_guard<ffrt::mutex> lock(interfaceMutex_);
288 if (!datashare_) {
289 HILOG_ERROR("helper is nullptr");
290 return RET_ERR_NULLPTR;
291 }
292
293 std::string stringOut = "";
294 Utils::VectorToString(std::vector<std::string>(targets.begin(), targets.end()), stringOut);
295 auto ret = datashare_->PutStringValue(SHORTCUT_SERVICE, stringOut);
296 if (ret != RET_OK) {
297 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetShortkeyMultiTarget");
298 HILOG_ERROR("set shortkeyMultiTarget_ failed");
299 return ret;
300 }
301 shortkeyMultiTarget_ = std::vector<std::string>(targets.begin(), targets.end());
302 return ret;
303 }
304
SetShortkeyMultiTargetInPkgRemove(const std::string & name)305 RetError AccessibilitySettingsConfig::SetShortkeyMultiTargetInPkgRemove(const std::string &name)
306 {
307 HILOG_DEBUG();
308 std::lock_guard<ffrt::mutex> lock(interfaceMutex_);
309 if (!datashare_) {
310 HILOG_ERROR("helper is nullptr");
311 return RET_ERR_NULLPTR;
312 }
313 RetError rtn = RET_OK;
314
315 for (auto iter = shortkeyMultiTarget_.begin(); iter != shortkeyMultiTarget_.end(); ++iter) {
316 if (*iter == name) {
317 shortkeyMultiTarget_.erase(iter);
318 std::string stringOut = "";
319 Utils::VectorToString(shortkeyMultiTarget_, stringOut);
320 rtn = datashare_->PutStringValue(SHORTCUT_SERVICE, stringOut);
321 break;
322 }
323 }
324 if (rtn != RET_OK) {
325 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetShortkeyMultiTargetInPkgRemove");
326 HILOG_ERROR("set shortkeyMultiTarget_ failed");
327 shortkeyMultiTarget_.push_back(name);
328 }
329 return rtn;
330 }
331
SetHighContrastTextState(const bool state)332 RetError AccessibilitySettingsConfig::SetHighContrastTextState(const bool state)
333 {
334 HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
335 auto ret = SetConfigState(HIGH_CONTRAST_TEXT_KEY, state);
336 if (ret != RET_OK) {
337 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetHighContrastTextState");
338 HILOG_ERROR("set highContrastTextState_ failed");
339 return ret;
340 }
341 highContrastTextState_ = state;
342 return ret;
343 }
344
SetInvertColorState(const bool state)345 RetError AccessibilitySettingsConfig::SetInvertColorState(const bool state)
346 {
347 HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
348 auto ret = SetConfigState(INVERT_COLOR_KEY, state);
349 if (ret != RET_OK) {
350 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetInvertColorState");
351 HILOG_ERROR("set invertColorState_ failed");
352 return ret;
353 }
354 invertColorState_ = state;
355 return ret;
356 }
357
SetAnimationOffState(const bool state)358 RetError AccessibilitySettingsConfig::SetAnimationOffState(const bool state)
359 {
360 HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
361 auto ret = SetConfigState(ANIMATION_OFF_KEY, state);
362 if (ret != RET_OK) {
363 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetAnimationOffState");
364 HILOG_ERROR("set animationOffState_ failed");
365 return ret;
366 }
367 animationOffState_ = state;
368 return ret;
369 }
370
SetAudioMonoState(const bool state)371 RetError AccessibilitySettingsConfig::SetAudioMonoState(const bool state)
372 {
373 HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
374 auto ret = SetConfigState(AUDIO_MONO_KEY, state);
375 if (ret != RET_OK) {
376 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetAudioMonoState");
377 HILOG_ERROR("set audioMonoState_ failed");
378 return ret;
379 }
380 audioMonoState_ = state;
381 return ret;
382 }
383
SetDaltonizationState(const bool state)384 RetError AccessibilitySettingsConfig::SetDaltonizationState(const bool state)
385 {
386 HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
387 auto ret = SetConfigState(DALTONIZATION_STATE, state);
388 if (ret != RET_OK) {
389 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetDaltonizationState");
390 HILOG_ERROR("set daltonizationState_ failed");
391 return ret;
392 }
393 daltonizationState_ = state;
394 return ret;
395 }
396
SetDaltonizationColorFilter(const uint32_t filter)397 RetError AccessibilitySettingsConfig::SetDaltonizationColorFilter(const uint32_t filter)
398 {
399 HILOG_DEBUG("filter = [%{public}u]", filter);
400 if (!datashare_) {
401 HILOG_ERROR("helper is nullptr");
402 return RET_ERR_NULLPTR;
403 }
404
405 uint32_t daltonizationColorFilter = filter;
406 if (filter == DISPLAY_DALTONIZER_GREEN) {
407 daltonizationColorFilter = AccessibilityConfig::Deuteranomaly;
408 } else if (filter == DISPLAY_DALTONIZER_RED) {
409 daltonizationColorFilter = AccessibilityConfig::Protanomaly;
410 } else if (filter == DISPLAY_DALTONIZER_BLUE) {
411 daltonizationColorFilter = AccessibilityConfig::Tritanomaly;
412 } else if (filter == static_cast<uint32_t>(DISPLAY_DALTONIZER_INVALID)) {
413 daltonizationColorFilter = 0;
414 }
415 auto ret = datashare_->PutIntValue(DALTONIZATION_COLOR_FILTER_KEY, static_cast<int32_t>(daltonizationColorFilter));
416 if (ret != RET_OK) {
417 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetDaltonizationColorFilter");
418 HILOG_ERROR("set daltonizationColorFilter_ failed");
419 return ret;
420 }
421 daltonizationColorFilter_ = daltonizationColorFilter;
422 return ret;
423 }
424
425
SetContentTimeout(const uint32_t time)426 RetError AccessibilitySettingsConfig::SetContentTimeout(const uint32_t time)
427 {
428 HILOG_DEBUG("time = [%{public}u]", time);
429 if (!datashare_) {
430 HILOG_ERROR("helper is nullptr");
431 return RET_ERR_NULLPTR;
432 }
433
434 auto ret = datashare_->PutIntValue(CONTENT_TIMEOUT_KEY, static_cast<int32_t>(time));
435 if (ret != RET_OK) {
436 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetContentTimeout");
437 HILOG_ERROR("set contentTimeout_ failed");
438 return ret;
439 }
440 contentTimeout_ = time;
441 return ret;
442 }
443
SetBrightnessDiscount(const float discount)444 RetError AccessibilitySettingsConfig::SetBrightnessDiscount(const float discount)
445 {
446 HILOG_DEBUG("discount = [%{public}f]", discount);
447 if (!datashare_) {
448 HILOG_ERROR("helper is nullptr");
449 return RET_ERR_NULLPTR;
450 }
451
452 auto ret = datashare_->PutFloatValue(BRIGHTNESS_DISCOUNT_KEY, discount);
453 if (ret != RET_OK) {
454 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetBrightnessDiscount");
455 HILOG_ERROR("set brightnessDiscount_ failed");
456 return ret;
457 }
458 brightnessDiscount_ = discount;
459 return ret;
460 }
461
SetAudioBalance(const float balance)462 RetError AccessibilitySettingsConfig::SetAudioBalance(const float balance)
463 {
464 HILOG_DEBUG("balance = [%{public}f]", balance);
465 if (!datashare_) {
466 HILOG_ERROR("helper is nullptr");
467 return RET_ERR_NULLPTR;
468 }
469
470 float audioBalance = round(balance * AUDIO_BALANCE_STEP) / AUDIO_BALANCE_STEP;
471 auto ret = datashare_->PutFloatValue(AUDIO_BALANCE_KEY, audioBalance);
472 if (ret != RET_OK) {
473 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetAudioBalance");
474 HILOG_ERROR("set audioBalance_ failed");
475 return ret;
476 }
477 audioBalance_ = audioBalance;
478 return ret;
479 }
480
SetClickResponseTime(const uint32_t time)481 RetError AccessibilitySettingsConfig::SetClickResponseTime(const uint32_t time)
482 {
483 HILOG_DEBUG("clickResponseTime = [%{public}u]", time);
484 if (!datashare_) {
485 HILOG_ERROR("helper is nullptr");
486 return RET_ERR_NULLPTR;
487 }
488
489 uint32_t clickResponseTime = time;
490 if (time == DOUBLE_CLICK_RESPONSE_TIME_MEDIUM) {
491 clickResponseTime = AccessibilityConfig::ResponseDelayMedium;
492 } else if (time > DOUBLE_CLICK_RESPONSE_TIME_MEDIUM) {
493 clickResponseTime = AccessibilityConfig::ResponseDelayLong;
494 }
495 auto ret = datashare_->PutIntValue(CLICK_RESPONCE_TIME, clickResponseTime);
496 if (ret != RET_OK) {
497 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetClickResponseTime");
498 HILOG_ERROR("set clickResponseTime_ failed");
499 return ret;
500 }
501 clickResponseTime_ = clickResponseTime;
502 return ret;
503 }
504
SetIgnoreRepeatClickState(const bool state)505 RetError AccessibilitySettingsConfig::SetIgnoreRepeatClickState(const bool state)
506 {
507 HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
508 auto ret = SetConfigState(IGNORE_REPEAT_CLICK_SWITCH, state);
509 if (ret != RET_OK) {
510 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetIgnoreRepeatClickState");
511 HILOG_ERROR("set ignoreRepeatClickState_ failed");
512 return ret;
513 }
514 ignoreRepeatClickState_ = state;
515 return ret;
516 }
517
SetIgnoreRepeatClickTime(const uint32_t time)518 RetError AccessibilitySettingsConfig::SetIgnoreRepeatClickTime(const uint32_t time)
519 {
520 HILOG_DEBUG("ignoreRepeatClickTime = [%{public}u]", time);
521 if (!datashare_) {
522 HILOG_ERROR("helper is nullptr");
523 return RET_ERR_NULLPTR;
524 }
525
526 uint32_t ignoreRepeatClickTime = time;
527 if (time == DOUBLE_IGNORE_REPEAT_CLICK_TIME_SHORTEST) {
528 ignoreRepeatClickTime = AccessibilityConfig::RepeatClickTimeoutShortest;
529 } else if (time == DOUBLE_IGNORE_REPEAT_CLICK_TIME_SHORT) {
530 ignoreRepeatClickTime = AccessibilityConfig::RepeatClickTimeoutShort;
531 } else if (time == DOUBLE_IGNORE_REPEAT_CLICK_TIME_MEDIUM) {
532 ignoreRepeatClickTime = AccessibilityConfig::RepeatClickTimeoutMedium;
533 } else if (time == DOUBLE_IGNORE_REPEAT_CLICK_TIME_LONG) {
534 ignoreRepeatClickTime = AccessibilityConfig::RepeatClickTimeoutLong;
535 } else if (time > DOUBLE_IGNORE_REPEAT_CLICK_TIME_LONG) {
536 ignoreRepeatClickTime = AccessibilityConfig::RepeatClickTimeoutLongest;
537 }
538 auto ret = datashare_->PutIntValue(IGNORE_REPEAT_CLICK_TIME, ignoreRepeatClickTime);
539 if (ret != RET_OK) {
540 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetIgnoreRepeatClickTime");
541 HILOG_ERROR("set ignoreRepeatClickTime_ failed");
542 return ret;
543 }
544 ignoreRepeatClickTime_ = ignoreRepeatClickTime;
545 return ret;
546 }
547
SetCaptionProperty(const AccessibilityConfig::CaptionProperty & caption)548 RetError AccessibilitySettingsConfig::SetCaptionProperty(const AccessibilityConfig::CaptionProperty& caption)
549 {
550 HILOG_DEBUG();
551 captionProperty_ = caption;
552 if (!datashare_) {
553 return RET_ERR_NULLPTR;
554 }
555
556 auto fontFamilyRet = datashare_->PutStringValue(FONT_FAMILY, captionProperty_.GetFontFamily());
557 if (fontFamilyRet != RET_OK) {
558 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetCaptionProperty.fontFamily");
559 }
560 auto fontColorRet = datashare_->PutIntValue(FONT_COLOR, static_cast<int32_t>(captionProperty_.GetFontColor()));
561 if (fontColorRet != RET_OK) {
562 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetCaptionProperty.fontColor");
563 }
564 auto fontEdgeTypeRet = datashare_->PutStringValue(FONT_EDGE_TYPE, captionProperty_.GetFontEdgeType());
565 if (fontEdgeTypeRet != RET_OK) {
566 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetCaptionProperty.fontEdgeType");
567 }
568 auto backgroundColorRet = datashare_->PutIntValue(BACKGROUND_COLOR, static_cast<int32_t>(
569 captionProperty_.GetBackgroundColor()));
570 if (backgroundColorRet != RET_OK) {
571 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetCaptionProperty.backgroundColor");
572 }
573 auto windowColorRet = datashare_->PutIntValue(WINDOW_COLOR, static_cast<int32_t>(
574 captionProperty_.GetWindowColor()));
575 if (windowColorRet != RET_OK) {
576 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetCaptionProperty.windowColor");
577 }
578 auto fontScaleRet = datashare_->PutIntValue(FONT_SCALE, captionProperty_.GetFontScale());
579 if (fontScaleRet != RET_OK) {
580 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetCaptionProperty.fontScale");
581 }
582 return RET_OK;
583 }
584
GetCaptionState() const585 bool AccessibilitySettingsConfig::GetCaptionState() const
586 {
587 return isCaptionState_;
588 }
589
GetScreenMagnificationState() const590 bool AccessibilitySettingsConfig::GetScreenMagnificationState() const
591 {
592 return isScreenMagnificationState_;
593 }
594
GetShortKeyState() const595 bool AccessibilitySettingsConfig::GetShortKeyState() const
596 {
597 return isShortKeyState_;
598 }
599
GetShortKeyOnLockScreenState() const600 bool AccessibilitySettingsConfig::GetShortKeyOnLockScreenState() const
601 {
602 return isShortKeyEnabledOnLockScreen_;
603 }
604
GetShortKeyTimeout() const605 int32_t AccessibilitySettingsConfig::GetShortKeyTimeout() const
606 {
607 return shortKeyTimeout_;
608 }
609
GetMouseKeyState() const610 bool AccessibilitySettingsConfig::GetMouseKeyState() const
611 {
612 return isMouseKeyState_;
613 }
614
GetMouseAutoClick() const615 int32_t AccessibilitySettingsConfig::GetMouseAutoClick() const
616 {
617 return mouseAutoClick_;
618 }
619
GetShortkeyTarget() const620 const std::string &AccessibilitySettingsConfig::GetShortkeyTarget() const
621 {
622 return shortkeyTarget_;
623 }
624
GetShortkeyMultiTarget()625 const std::vector<std::string> AccessibilitySettingsConfig::GetShortkeyMultiTarget()
626 {
627 std::lock_guard<ffrt::mutex> lock(interfaceMutex_);
628 std::vector<std::string> rtnVec = shortkeyMultiTarget_;
629 return rtnVec;
630 }
631
GetHighContrastTextState() const632 bool AccessibilitySettingsConfig::GetHighContrastTextState() const
633 {
634 return highContrastTextState_;
635 }
636
GetInvertColorState() const637 bool AccessibilitySettingsConfig::GetInvertColorState() const
638 {
639 return invertColorState_;
640 }
641
GetAnimationOffState() const642 bool AccessibilitySettingsConfig::GetAnimationOffState() const
643 {
644 return animationOffState_;
645 }
646
GetAudioMonoState() const647 bool AccessibilitySettingsConfig::GetAudioMonoState() const
648 {
649 return audioMonoState_;
650 }
651
GetDaltonizationState() const652 bool AccessibilitySettingsConfig::GetDaltonizationState() const
653 {
654 return daltonizationState_;
655 }
656
GetDaltonizationColorFilter() const657 uint32_t AccessibilitySettingsConfig::GetDaltonizationColorFilter() const
658 {
659 return daltonizationColorFilter_;
660 }
661
GetContentTimeout() const662 uint32_t AccessibilitySettingsConfig::GetContentTimeout() const
663 {
664 return contentTimeout_;
665 }
666
GetBrightnessDiscount() const667 float AccessibilitySettingsConfig::GetBrightnessDiscount() const
668 {
669 return brightnessDiscount_;
670 }
671
GetAudioBalance() const672 float AccessibilitySettingsConfig::GetAudioBalance() const
673 {
674 return audioBalance_;
675 }
676
GetEnabledState() const677 bool AccessibilitySettingsConfig::GetEnabledState() const
678 {
679 return enabled_;
680 }
681
GetTouchGuideState() const682 bool AccessibilitySettingsConfig::GetTouchGuideState() const
683 {
684 return eventTouchGuideState_;
685 }
686
GetGestureState() const687 bool AccessibilitySettingsConfig::GetGestureState() const
688 {
689 return gesturesSimulation_;
690 }
691
GetKeyEventObserverState() const692 bool AccessibilitySettingsConfig::GetKeyEventObserverState() const
693 {
694 return filteringKeyEvents_;
695 }
696
GetCaptionProperty() const697 const AccessibilityConfig::CaptionProperty &AccessibilitySettingsConfig::GetCaptionProperty() const
698 {
699 return captionProperty_;
700 };
701
GetClickResponseTime() const702 uint32_t AccessibilitySettingsConfig::GetClickResponseTime() const
703 {
704 return clickResponseTime_;
705 }
706
GetScreenMagnificationType() const707 uint32_t AccessibilitySettingsConfig::GetScreenMagnificationType() const
708 {
709 return screenMagnificationType_;
710 }
711
GetIgnoreRepeatClickState() const712 bool AccessibilitySettingsConfig::GetIgnoreRepeatClickState() const
713 {
714 return ignoreRepeatClickState_;
715 }
716
GetIgnoreRepeatClickTime() const717 uint32_t AccessibilitySettingsConfig::GetIgnoreRepeatClickTime() const
718 {
719 return ignoreRepeatClickTime_;
720 }
721
SetEnabledAccessibilityServices(const std::vector<std::string> & services)722 RetError AccessibilitySettingsConfig::SetEnabledAccessibilityServices(const std::vector<std::string> &services)
723 {
724 std::lock_guard<ffrt::mutex> lock(interfaceMutex_);
725 enabledAccessibilityServices_ = services;
726 if (datashare_ == nullptr) {
727 HILOG_WARN("datashare_ is null.");
728 return RET_ERR_NULLPTR;
729 }
730 std::string stringOut = "";
731 Utils::VectorToString(enabledAccessibilityServices_, stringOut);
732 auto ret = datashare_->PutStringValue(ENABLED_ACCESSIBILITY_SERVICES, stringOut);
733 if (ret != RET_OK) {
734 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetEnabledAccessibilityServices");
735 HILOG_ERROR("set enabledAccessibilityServices failed");
736 }
737 return ret;
738 }
739
GetEnabledAccessibilityServices()740 const std::vector<std::string> AccessibilitySettingsConfig::GetEnabledAccessibilityServices()
741 {
742 std::lock_guard<ffrt::mutex> lock(interfaceMutex_);
743 std::vector<std::string> rtnVec = enabledAccessibilityServices_;
744 return rtnVec;
745 }
746
AddEnabledAccessibilityService(const std::string & serviceName)747 RetError AccessibilitySettingsConfig::AddEnabledAccessibilityService(const std::string &serviceName)
748 {
749 std::lock_guard<ffrt::mutex> lock(interfaceMutex_);
750 auto iter = std::find(enabledAccessibilityServices_.begin(), enabledAccessibilityServices_.end(), serviceName);
751 if (iter != enabledAccessibilityServices_.end()) {
752 return RET_OK;
753 }
754
755 if (!datashare_) {
756 return RET_ERR_NULLPTR;
757 }
758 enabledAccessibilityServices_.push_back(serviceName);
759 std::string stringOut = "";
760 Utils::VectorToString(enabledAccessibilityServices_, stringOut);
761 return datashare_->PutStringValue(ENABLED_ACCESSIBILITY_SERVICES, stringOut);
762 }
763
RemoveEnabledAccessibilityService(const std::string & serviceName)764 RetError AccessibilitySettingsConfig::RemoveEnabledAccessibilityService(const std::string &serviceName)
765 {
766 std::lock_guard<ffrt::mutex> lock(interfaceMutex_);
767 auto iter = std::find(enabledAccessibilityServices_.begin(), enabledAccessibilityServices_.end(), serviceName);
768 if (iter == enabledAccessibilityServices_.end()) {
769 return RET_OK;
770 }
771
772 if (!datashare_) {
773 return RET_ERR_NULLPTR;
774 }
775 enabledAccessibilityServices_.erase(iter);
776 std::string stringOut = "";
777 Utils::VectorToString(enabledAccessibilityServices_, stringOut);
778 return datashare_->PutStringValue(ENABLED_ACCESSIBILITY_SERVICES, stringOut);
779 }
780
GetStartToHosState()781 bool AccessibilitySettingsConfig::GetStartToHosState()
782 {
783 HILOG_DEBUG();
784 if (!datashare_) {
785 return RET_ERR_NULLPTR;
786 }
787
788 bool value = true;
789 value = datashare_->GetBoolValue("AccessibilityStartFromAtoHos", true);
790 return value;
791 }
792
GetConfigState()793 uint32_t AccessibilitySettingsConfig::GetConfigState()
794 {
795 HILOG_DEBUG();
796 uint32_t state = 0;
797 if (isCaptionState_) {
798 state |= STATE_CAPTION_ENABLED;
799 }
800
801 if (isScreenMagnificationState_) {
802 state |= STATE_SCREENMAGNIFIER_ENABLED;
803 }
804
805 if (isMouseKeyState_) {
806 state |= STATE_MOUSEKEY_ENABLED;
807 }
808
809 if (isShortKeyState_) {
810 state |= STATE_SHORTKEY_ENABLED;
811 }
812
813 if (highContrastTextState_) {
814 state |= STATE_HIGHCONTRAST_ENABLED;
815 }
816
817 if (daltonizationState_) {
818 state |= STATE_DALTONIZATION_STATE_ENABLED;
819 }
820
821 if (invertColorState_) {
822 state |= STATE_INVETRTCOLOR_ENABLED;
823 }
824
825 if (animationOffState_) {
826 state |= STATE_ANIMATIONOFF_ENABLED;
827 }
828
829 if (audioMonoState_) {
830 state |= STATE_AUDIOMONO_ENABLED;
831 }
832
833 if (ignoreRepeatClickState_) {
834 state |= STATE_IGNORE_REPEAT_CLICK_ENABLED;
835 }
836 return state;
837 }
838
InitCaption()839 void AccessibilitySettingsConfig::InitCaption()
840 {
841 HILOG_DEBUG();
842 if (datashare_ == nullptr) {
843 return;
844 }
845
846 std::string strValue = datashare_->GetStringValue(CAPTION_KEY, "");
847 HILOG_DEBUG(" pref_->GetString() = %{public}s.", strValue.c_str());
848 if (!std::strcmp(strValue.c_str(), "on")) {
849 isCaptionState_ = true;
850 } else {
851 isCaptionState_ = false;
852 }
853
854 std::string fontFamliy = datashare_->GetStringValue(FONT_FAMILY, "default");
855 HILOG_DEBUG("fontFamily = %{public}s.", fontFamliy.c_str());
856
857 int32_t fontScale = static_cast<int32_t>(datashare_->GetIntValue(FONT_SCALE, DEFAULT_SCALE));
858 HILOG_DEBUG("fontScale = %{public}d.", fontScale);
859
860 uint32_t fontColor = static_cast<uint32_t>(datashare_->GetIntValue(FONT_COLOR, DEFAULT_COLOR));
861 HILOG_DEBUG("fontColor = 0x%{public}x.", fontColor);
862
863 std::string fontEdgeType = datashare_->GetStringValue(FONT_EDGE_TYPE, "none");
864 HILOG_DEBUG("fontEdgeType = 0x%{public}s.", fontEdgeType.c_str());
865
866 uint32_t backgroundColor = static_cast<uint32_t>(datashare_->GetIntValue(BACKGROUND_COLOR, DEFAULT_COLOR));
867 HILOG_DEBUG("backgroundColor = 0x%{public}x.", backgroundColor);
868
869 uint32_t windowColor = static_cast<uint32_t>(datashare_->GetIntValue(WINDOW_COLOR, DEFAULT_COLOR));
870 HILOG_DEBUG("windowColor = 0x%{public}x.", windowColor);
871
872 captionProperty_.SetFontFamily(fontFamliy);
873 captionProperty_.SetFontScale(fontScale);
874 captionProperty_.SetFontColor(fontColor);
875 captionProperty_.SetFontEdgeType(fontEdgeType);
876 captionProperty_.SetBackgroundColor(backgroundColor);
877 captionProperty_.SetWindowColor(windowColor);
878 }
879
InitShortKeyConfig()880 void AccessibilitySettingsConfig::InitShortKeyConfig()
881 {
882 isShortKeyState_ = datashare_->GetBoolValue(SHORTCUT_ENABLED, true);
883 bool isShortKeyEnabledOnLockScreen = datashare_->GetBoolValue(SHORTCUT_ENABLED_ON_LOCK_SCREEN, true);
884 shortKeyTimeout_ = static_cast<int32_t>(datashare_->GetIntValue(SHORTCUT_TIMEOUT, SHORT_KEY_TIMEOUT_BEFORE_USE));
885 // for AOS to HMOS
886 if (shortKeyTimeout_ == 1) {
887 SetShortKeyTimeout(SHORT_KEY_TIMEOUT_AFTER_USE);
888 } else if (shortKeyTimeout_ == 0) {
889 SetShortKeyTimeout(SHORT_KEY_TIMEOUT_BEFORE_USE);
890 }
891
892 shortkeyTarget_ = datashare_->GetStringValue("ShortkeyTarget", "none");
893
894 std::string tmpString = datashare_->GetStringValue(SHORTCUT_SERVICE, SCREEN_READER_BUNDLE_ABILITY_NAME);
895 shortkeyMultiTarget_ = {};
896 Utils::StringToVector(tmpString, shortkeyMultiTarget_);
897
898 bool isScreenReaderEnabledOriginal =
899 (std::find(enabledAccessibilityServices_.begin(), enabledAccessibilityServices_.end(),
900 SCREEN_READER_BUNDLE_ABILITY_NAME) != enabledAccessibilityServices_.end());
901 tmpString = datashare_->GetStringValue(ENABLED_ACCESSIBILITY_SERVICES, "");
902 enabledAccessibilityServices_ = {};
903 Utils::StringToVector(tmpString, enabledAccessibilityServices_);
904 CloneShortkeyService(isScreenReaderEnabledOriginal);
905
906 // Initialization of the private space after cloning or upgrade
907 std::shared_ptr<AccessibilitySettingProvider> service = AccessibilitySettingProvider::GetInstance(
908 POWER_MANAGER_SERVICE_ID);
909 if (service == nullptr) {
910 HILOG_ERROR("service is nullptr");
911 return;
912 }
913 bool cloneOrUpgradeFlag = false;
914 service->GetBoolValue(ACCESSIBILITY_PRIVACY_CLONE_OR_UPGRADE, cloneOrUpgradeFlag);
915 if (cloneOrUpgradeFlag && (accountId_ != DEFAULT_ACCOUNT_ID)) {
916 if (isShortKeyState_) {
917 SetShortKeyOnLockScreenState(true);
918 } else {
919 SetShortKeyOnLockScreenState(false);
920 }
921 SetDefaultShortcutKeyService();
922 service->PutBoolValue(ACCESSIBILITY_PRIVACY_CLONE_OR_UPGRADE, false);
923 }
924 }
925
InitSetting()926 void AccessibilitySettingsConfig::InitSetting()
927 {
928 HILOG_DEBUG();
929 if (datashare_ == nullptr) {
930 return;
931 }
932
933 InitShortKeyConfig();
934 CloneAudioState();
935 isScreenMagnificationState_ = datashare_->GetBoolValue(SCREEN_MAGNIFICATION_KEY, false);
936 isMouseKeyState_= datashare_->GetBoolValue(MOUSEKEY, false);
937 animationOffState_ = datashare_->GetBoolValue(ANIMATION_OFF_KEY, false);
938 invertColorState_ = datashare_->GetBoolValue(INVERT_COLOR_KEY, false);
939 highContrastTextState_ = datashare_->GetBoolValue(HIGH_CONTRAST_TEXT_KEY, false);
940 daltonizationState_ = datashare_->GetBoolValue(DALTONIZATION_STATE, false);
941 audioMonoState_ = datashare_->GetBoolValue(AUDIO_MONO_KEY, false);
942 ignoreRepeatClickState_ = datashare_->GetBoolValue(IGNORE_REPEAT_CLICK_SWITCH, false);
943 mouseAutoClick_ = static_cast<int32_t>(datashare_->GetIntValue("MouseAutoClick", -1));
944 daltonizationColorFilter_ = static_cast<uint32_t>(datashare_->GetIntValue(DALTONIZATION_COLOR_FILTER_KEY, 0));
945 SetDaltonizationColorFilter(daltonizationColorFilter_);
946 contentTimeout_ = static_cast<uint32_t>(datashare_->GetIntValue(CONTENT_TIMEOUT_KEY, 0));
947 brightnessDiscount_ = static_cast<float>(datashare_->GetFloatValue(BRIGHTNESS_DISCOUNT_KEY, 1.0));
948 audioBalance_ = static_cast<float>(datashare_->GetFloatValue(AUDIO_BALANCE_KEY, 0));
949 SetAudioBalance(audioBalance_);
950 screenMagnificationType_ = static_cast<uint32_t>(datashare_->GetIntValue(SCREEN_MAGNIFICATION_TYPE, 0));
951 clickResponseTime_ = static_cast<uint32_t>(datashare_->GetIntValue(CLICK_RESPONCE_TIME, 0));
952 SetClickResponseTime(clickResponseTime_);
953 ignoreRepeatClickTime_ = static_cast<uint32_t>(datashare_->GetIntValue(IGNORE_REPEAT_CLICK_TIME, 0));
954 SetIgnoreRepeatClickTime(ignoreRepeatClickTime_);
955 }
956
InitCapability()957 void AccessibilitySettingsConfig::InitCapability()
958 {
959 HILOG_DEBUG();
960 if (datashare_ == nullptr) {
961 return;
962 }
963
964 enabled_ = datashare_->GetBoolValue(ACCESSIBILITY, false);
965 eventTouchGuideState_ = datashare_->GetBoolValue(TOUCH_GUIDE_STATE, false);
966 gesturesSimulation_ = datashare_->GetBoolValue(GESTURE_KEY, false);
967 filteringKeyEvents_ = datashare_->GetBoolValue(KEYEVENT_OBSERVER, false);
968 }
969
SetConfigState(const std::string & key,bool value)970 RetError AccessibilitySettingsConfig::SetConfigState(const std::string& key, bool value)
971 {
972 if (!datashare_) {
973 return RET_ERR_NULLPTR;
974 }
975 auto ret = datashare_->PutBoolValue(key, value);
976 if (ret != RET_OK) {
977 HILOG_ERROR("set configState failed");
978 }
979 return ret;
980 }
981
Init()982 void AccessibilitySettingsConfig::Init()
983 {
984 HILOG_DEBUG();
985 datashare_ = std::make_shared<AccessibilityDatashareHelper>(DATASHARE_TYPE::SECURE, accountId_);
986 if (datashare_ == nullptr) {
987 return;
988 }
989 datashare_->Initialize(POWER_MANAGER_SERVICE_ID);
990 InitCaption();
991 InitSetting();
992
993 systemDatashare_ = std::make_shared<AccessibilityDatashareHelper>(DATASHARE_TYPE::SYSTEM, accountId_);
994 if (systemDatashare_ == nullptr) {
995 return;
996 }
997 systemDatashare_->Initialize(POWER_MANAGER_SERVICE_ID);
998 }
999
ClearData()1000 void AccessibilitySettingsConfig::ClearData()
1001 {
1002 HILOG_DEBUG();
1003 }
1004
CloneAudioState()1005 void AccessibilitySettingsConfig::CloneAudioState()
1006 {
1007 HILOG_DEBUG();
1008 if (systemDatashare_ == nullptr) {
1009 return;
1010 }
1011
1012 RetError ret = RET_OK;
1013 int32_t monoValue = static_cast<int32_t>(systemDatashare_->GetIntValue(AUDIO_MONO_KEY, INVALID_MASTER_MONO_VALUE));
1014 if (monoValue != INVALID_MASTER_MONO_VALUE) {
1015 SetAudioMonoState(monoValue == 1);
1016 ret = systemDatashare_->PutIntValue(AUDIO_MONO_KEY, INVALID_MASTER_MONO_VALUE);
1017 if (ret != RET_OK) {
1018 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "CloneAudioState.monoValue");
1019 HILOG_ERROR("reset monoValue in system table failed");
1020 }
1021 }
1022
1023 float audioBalance = static_cast<float>(systemDatashare_->GetFloatValue(AUDIO_BALANCE_KEY,
1024 INVALID_MASTER_BALANCE_VALUE));
1025 if (abs(audioBalance - INVALID_MASTER_BALANCE_VALUE) > EPS) {
1026 SetAudioBalance(audioBalance);
1027 ret = systemDatashare_->PutFloatValue(AUDIO_BALANCE_KEY, INVALID_MASTER_BALANCE_VALUE);
1028 if (ret != RET_OK) {
1029 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "CloneAudioState.audioBalance");
1030 HILOG_ERROR("reset audioBalance in system table failed");
1031 }
1032 }
1033 }
1034
GetShortKeyService(std::vector<std::string> & services)1035 uint32_t AccessibilitySettingsConfig::GetShortKeyService(std::vector<std::string> &services)
1036 {
1037 uint32_t serviceFlag = 0;
1038
1039 auto screenReader = std::find_if(services.begin(), services.end(), [&](const std::string& service) {
1040 return service.find(SCREENREADER_TAG) != std::string::npos;
1041 });
1042 serviceFlag = screenReader != services.end() ? STATE_EXPLORATION_ENABLED : serviceFlag;
1043
1044 auto invertColor = std::find_if(services.begin(), services.end(), [&](const std::string& service) {
1045 return service.find(INVERT_COLOR_AOS_TAG) != std::string::npos ||
1046 service.find(INVERT_COLOR_HMOS_TAG) != std::string::npos;
1047 });
1048 serviceFlag = invertColor != services.end() ? (serviceFlag | STATE_INVETRTCOLOR_ENABLED) : serviceFlag;
1049
1050 auto audioMono = std::find_if(services.begin(), services.end(), [&](const std::string& service) {
1051 return service.find(AUDIO_MONO_HMOS_TAG) != std::string::npos;
1052 });
1053 serviceFlag = audioMono != services.end() ? (serviceFlag | STATE_AUDIOMONO_ENABLED) : serviceFlag;
1054
1055 auto highContrastText = std::find_if(services.begin(), services.end(), [&](const std::string& service) {
1056 return service.find(HIGH_CONTRAST_TEXT_HMOS_TAG) != std::string::npos;
1057 });
1058 serviceFlag = highContrastText != services.end() ? (serviceFlag | STATE_HIGHCONTRAST_ENABLED) : serviceFlag;
1059
1060 return serviceFlag;
1061 }
1062
CloneShortkeyService(bool isScreenReaderEnabled)1063 void AccessibilitySettingsConfig::CloneShortkeyService(bool isScreenReaderEnabled)
1064 {
1065 std::vector<std::string> tmpVec = GetShortkeyMultiTarget();
1066 uint32_t shortkeyServiceFlag = GetShortKeyService(tmpVec);
1067 std::vector<std::string> shortkeyService;
1068 if (shortkeyServiceFlag & STATE_EXPLORATION_ENABLED) {
1069 shortkeyService.push_back(SCREEN_READER_BUNDLE_ABILITY_NAME);
1070 }
1071 if (shortkeyServiceFlag & STATE_INVETRTCOLOR_ENABLED) {
1072 shortkeyService.push_back(INVERT_COLOR_HMOS_TAG);
1073 }
1074 if (shortkeyServiceFlag & STATE_AUDIOMONO_ENABLED) {
1075 shortkeyService.push_back(AUDIO_MONO_HMOS_TAG);
1076 }
1077 if (shortkeyServiceFlag & STATE_HIGHCONTRAST_ENABLED) {
1078 shortkeyService.push_back(HIGH_CONTRAST_TEXT_HMOS_TAG);
1079 }
1080 SetShortkeyMultiTarget(shortkeyService);
1081
1082 tmpVec = GetEnabledAccessibilityServices();
1083 shortkeyServiceFlag = GetShortKeyService(tmpVec);
1084 std::vector<std::string> enabledShortkeyService;
1085 if ((shortkeyServiceFlag & STATE_EXPLORATION_ENABLED) || (isScreenReaderEnabled == true)) {
1086 enabledShortkeyService.push_back(SCREEN_READER_BUNDLE_ABILITY_NAME);
1087 }
1088 SetEnabledAccessibilityServices(enabledShortkeyService);
1089 }
1090
SetDefaultShortcutKeyService()1091 void AccessibilitySettingsConfig::SetDefaultShortcutKeyService()
1092 {
1093 HILOG_DEBUG();
1094
1095 if (GetShortkeyMultiTarget().empty()) {
1096 HILOG_INFO("set default shortcut key service.");
1097 std::vector<std::string> defaultService;
1098 defaultService.push_back(SCREEN_READER_BUNDLE_ABILITY_NAME);
1099 SetShortkeyMultiTarget(defaultService);
1100 }
1101 }
1102
OnDataClone()1103 void AccessibilitySettingsConfig::OnDataClone()
1104 {
1105 HILOG_INFO();
1106
1107 bool isShortkeyEnabled = GetShortKeyState();
1108 bool isShortkeyEnabledOnLockScreen = GetShortKeyOnLockScreenState();
1109
1110 InitSetting();
1111 SetDefaultShortcutKeyService();
1112
1113 if (isShortKeyState_) {
1114 SetShortKeyOnLockScreenState(true);
1115 } else {
1116 SetShortKeyOnLockScreenState(false);
1117 }
1118
1119 if (isShortkeyEnabled != GetShortKeyState()) {
1120 SetShortKeyState(isShortkeyEnabled);
1121 SetShortKeyState(!isShortkeyEnabled);
1122 }
1123 if (isShortkeyEnabledOnLockScreen != GetShortKeyOnLockScreenState()) {
1124 SetShortKeyOnLockScreenState(isShortkeyEnabledOnLockScreen);
1125 SetShortKeyOnLockScreenState(!isShortkeyEnabledOnLockScreen);
1126 }
1127 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateShortKeyRegister();
1128
1129 std::shared_ptr<AccessibilitySettingProvider> service =
1130 AccessibilitySettingProvider::GetInstance(POWER_MANAGER_SERVICE_ID);
1131 if (service == nullptr) {
1132 HILOG_ERROR("service is nullptr");
1133 return;
1134 }
1135 bool isScreenReaderEnabled =
1136 (std::find(enabledAccessibilityServices_.begin(), enabledAccessibilityServices_.end(),
1137 SCREEN_READER_BUNDLE_ABILITY_NAME) != enabledAccessibilityServices_.end());
1138 if (isScreenReaderEnabled) {
1139 ErrCode ret = service->PutBoolValue(ACCESSIBILITY_SCREENREADER_ENABLED, true, true);
1140 Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "OnDataClone.screenReader");
1141 HILOG_INFO("set screenReader state, ret = %{public}d", ret);
1142 }
1143 service->PutBoolValue(ACCESSIBILITY_PRIVACY_CLONE_OR_UPGRADE, true);
1144 service->PutBoolValue(ACCESSIBILITY_CLONE_FLAG, false);
1145 }
1146 } // namespace Accessibility
1147 } // namespace OHOS