* Copyright (C) 2022-2026 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "accessibility_settings_config.h"
#include "hilog_wrapper.h"
#include "system_ability_definition.h"
#include "utils.h"
#include "accessibility_setting_provider.h"
#include "accessible_ability_manager_service.h"
#include "accessibility_account_data.h"
#include "parameters.h"
#include "accessibility_notification_helper.h"
#include "magnification_def.h"
#include "nlohmann/json.hpp"
#include "accessibility_base_utils.h"
namespace OHOS {
namespace Accessibility {
namespace {
constexpr uint32_t DEFAULT_COLOR = 0xff000000;
const int32_t DEFAULT_FONT_SCALE = 100;
const int32_t SHORT_KEY_TIMEOUT_AFTER_USE = 1000;
const int32_t SHORT_KEY_TIMEOUT_BEFORE_USE = 3000;
const int32_t DEFAULT_ACCOUNT_ID = 100;
const char* ACCESSIBILITY = "accessibility";
const char* TOUCH_GUIDE_STATE = "touch_guide_state";
const char* GESTURE_KEY = "gesture_state";
const char* CAPTION_KEY = "caption_state";
const char* KEYEVENT_OBSERVER = "keyevent_observer";
const char* SCREEN_MAGNIFICATION_KEY = "accessibility_display_magnification_enabled";
const char* SCREEN_MAGNIFICATION_TYPE = "accessibility_magnification_capability";
const char* SCREEN_MAGNIFICATION_MODE = "accessibility_magnification_mode";
const char* SCREEN_MAGNIFICATION_SCALE = "accessibility_display_magnification_scale";
const char* SCREEN_MAGNIFICATION_TRIGGER_METHOD = "accessibility_display_magnification_trigger_method";
const char* MOUSEKEY = "mousekey";
const char* HIGH_CONTRAST_TEXT_KEY = "high_text_contrast_enabled";
const char* DALTONIZATION_STATE = "accessibility_display_daltonizer_enabled";
const char* INVERT_COLOR_KEY = "accessibility_display_inversion_enabled";
const char* ANIMATION_OFF_KEY = "animation_off";
const char* ANIMATION_CACHE_FLAG = "accessibility_animation_cache_flag";
const char* AUDIO_MONO_KEY = "master_mono";
const char* IGNORE_REPEAT_CLICK_SWITCH = "ignore_repeat_click_switch";
const char* SHORTCUT_ENABLED = "accessibility_shortcut_enabled";
const char* SHORTCUT_SERVICE = "accessibility_shortcut_target_service";
const char* CLICK_RESPONCE_TIME = "click_response_time";
const char* IGNORE_REPEAT_CLICK_TIME = "ignore_repeat_click_time";
const char* DALTONIZATION_COLOR_FILTER_KEY = "accessibility_display_daltonizer";
const char* CONTENT_TIMEOUT_KEY = "accessibility_content_timeout";
const char* BRIGHTNESS_DISCOUNT_KEY = "accessibility_brightness_discount";
const char* AUDIO_BALANCE_KEY = "master_balance";
const char* FONT_FAMILY = "accessibility_font_family";
const char* FONT_COLOR = "accessibility_font_color";
const char* FONT_EDGE_TYPE = "accessibility_font_edge_type";
const char* BACKGROUND_COLOR = "accessibility_background_color";
const char* WINDOW_COLOR = "accessibility_window_color";
const char* FONT_SCALE = "accessibility_font_scale";
const char* ENABLED_ACCESSIBILITY_SERVICES = "enabled_accessibility_services";
const char* SHORTCUT_ENABLED_ON_LOCK_SCREEN = "accessibility_shortcut_enabled_on_lock_screen";
const char* SHORTCUT_ON_LOCK_SCREEN = "accessibility_shortcut_on_lock_screen";
const char* SHORTCUT_TIMEOUT = "accessibility_shortcut_timeout";
const char* ACCESSIBILITY_CLONE_FLAG = "accessibility_config_clone";
const char* SCREENREADER_TAG = "screenreader";
const char* INVERT_COLOR_AOS_TAG = "ColorInversion";
const char* INVERT_COLOR_TAG = "INVERT_COLOR";
const char* AUDIO_MONO_TAG = "AUDIO_MONO";
const char* HIGH_CONTRAST_TEXT_TAG = "HIGH_CONTRAST_TEXT";
const char* CAPTIONS_ASSISTANT_HMOS_TAG = "CAPTIONS_ASSISTANT";
const char* SCREEN_MAGNIFICATION_TAG = "SCREEN_MAGNIFICATION";
const char* SCREEN_READER_BUNDLE_ABILITY_NAME = "com.ohos.screenreader/AccessibilityExtAbility";
const char* ACCESSIBILITY_SCREENREADER_ENABLED = "accessibility_screenreader_enabled";
const char* ACCESSIBILITY_PRIVACY_CLONE_OR_UPGRADE = "accessibility_privacy_clone_or_upgrade";
const char* IGNORE_REPEAT_CLICK_RECONFIRM = "accessibility_ignore_repeat_click_reconfirm";
const char* ZOOM_GESTURE_ENABLED_RECONFIRM = "accessibility_zoom_gesture_enabled_reconfirm";
const char* GRAPHIC_ANIMATION_SCALE_NAME = "persist.sys.graphic.animationscale";
const char* ARKUI_ANIMATION_SCALE_NAME = "persist.sys.arkui.animationscale";
const char* FLASH_REMINDER_SWITCH_KEY = "accessibility_flash_reminder_switch";
const char* FLASH_REMINDER_ENABLED = "accessibility_reminder_function_enabled";
const char* VOICE_RECOGNITION_KEY = "accessibility_sound_recognition_switch";
const char* VOICE_RECOGNITION_TYPES = "accessibility_sound_recognition_enabled";
const char* IGNORE_REPEAT_CLICK_TIMESTAMP = "accessibility_ignore_repeat_click_timestamp";
const char* RECOVERY_IGNORE_REPEAT_CLICK_DATE = "recovery_ignore_repeat_click_switch_date";
const char* IGNORE_REPEATED_CLICK_CACHE_FLAG = "accessibility_ignore_repeat_click_cache_flag";
const char* IGNORE_REPEATED_CLICK_EXCLUDE_FLAG = "accessibility_ignore_repeat_click_exclude_flag";
const char* OOBE_COLOR_FILTER_CACHE_FLAG = "accessibility_oobe_color_filter_cache_flag";
const char* OOBE_COLOR_FILTER_SWITCH_CACHE = "accessibility_oobe_color_filter_switch_cache";
const char* OOBE_COLOR_FILTER_DALTONIZER_CACHE = "accessibility_oobe_color_filter_daltonizer_cache";
const char* CLONE_CAPABILITY = "const.accessibility.cloneCapability";
const char* OLD_DEVICE_CAPABILITY = "accessibility_clone_capability";
const char* SUPPORT_THREE_FINGER_ZOOM = "accessibility_support_three_finger_zoom";
const char* TRANSITION_ANIMATIONS_TIMESTAMP = "accessibility_transition_animations_timestamp";
const char* ELDER_CARE_ENABLED_KEY = "accessibility_elder_care_switch_enabled";
constexpr int DOUBLE_CLICK_RESPONSE_TIME_MEDIUM = 300;
constexpr int DOUBLE_IGNORE_REPEAT_CLICK_TIME_SHORTEST = 100;
constexpr int DOUBLE_IGNORE_REPEAT_CLICK_TIME_SHORT = 400;
constexpr int DOUBLE_IGNORE_REPEAT_CLICK_TIME_MEDIUM = 700;
constexpr int DOUBLE_IGNORE_REPEAT_CLICK_TIME_LONG = 1000;
constexpr int DISPLAY_DALTONIZER_INVALID = -1;
constexpr int DISPLAY_DALTONIZER_GREEN = 12;
constexpr int DISPLAY_DALTONIZER_RED = 11;
constexpr int DISPLAY_DALTONIZER_BLUE = 13;
constexpr int INVALID_MASTER_MONO_VALUE = -1;
constexpr int AUDIO_BALANCE_STEP = 5;
constexpr int CLONE_CAPABILITY_ZOOM_GUSTURE = 1 << 0;
constexpr int CLONE_CAPABILITY_HIGH_CONTRAST_TEXT = 1 << 1;
constexpr int CLONE_CAPABILITY_INVERT_COLOR = 1 << 2;
constexpr int CLONE_CAPABILITY_COLOR_CORRECTION = 1 << 3;
constexpr int CLONE_CAPABILITY_TRANSITION_ANIMATION = 1 << 4;
constexpr int CLONE_CAPABILITY_AUDIO_ADJUSTMENT = 1 << 5;
constexpr int CLONE_CAPABILITY_SOUND_RECOGNITION = 1 << 6;
constexpr int CLONE_CAPABILITY_FLASH_REMINDER = 1 << 7;
constexpr int CLONE_CAPABILITY_TOUCH_SCREEN = 1 << 8;
constexpr int CLONE_CAPABILITY_SHORT_KEY = 1 << 9;
constexpr float INVALID_MASTER_BALANCE_VALUE = 2.0;
constexpr uint32_t IGNORE_REPEAT_CLICK_SHORTEST = 0;
constexpr uint32_t IGNORE_REPEAT_CLICK_SHORT = 1;
constexpr float DEFAULT_MAGNIFICATION_SCALE = 2.0;
constexpr int32_t INVALID_TRIGGER_METHOD = -1;
bool g_ignoreRepeatClickOnceFlag = false;
bool g_transitionAnimationsOnceFlag = false;
constexpr int PC_ENABLE_CAPABILITY_LIST[] = {
CLONE_CAPABILITY_INVERT_COLOR,
CLONE_CAPABILITY_COLOR_CORRECTION,
CLONE_CAPABILITY_AUDIO_ADJUSTMENT,
};
}
AccessibilitySettingsConfig::AccessibilitySettingsConfig(int32_t id)
{
HILOG_DEBUG("id = [%{public}d]", id);
accountId_ = id;
}
RetError AccessibilitySettingsConfig::SetEnabled(const bool state)
{
HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
auto ret = SetConfigState(ACCESSIBILITY, state);
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetEnabled");
HILOG_ERROR("set accessibility failed");
return ret;
}
enabled_.store(state);
return ret;
}
RetError AccessibilitySettingsConfig::SetTouchGuideState(const bool state)
{
HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
auto ret = SetConfigState(TOUCH_GUIDE_STATE, state);
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetTouchGuideState");
HILOG_ERROR("set eventTouchGuideState_ failed");
return ret;
}
eventTouchGuideState_.store(state);
return ret;
}
RetError AccessibilitySettingsConfig::SetGestureState(const bool state)
{
HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
auto ret = SetConfigState(GESTURE_KEY, state);
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetGestureState");
HILOG_ERROR("set gesturesSimulation_ failed");
return ret;
}
gesturesSimulation_.store(state);
return ret;
}
RetError AccessibilitySettingsConfig::SetKeyEventObserverState(const bool state)
{
HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
auto ret = SetConfigState(KEYEVENT_OBSERVER, state);
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetKeyEventObserverState");
HILOG_ERROR("set filteringKeyEvents_ failed");
return ret;
}
filteringKeyEvents_.store(state);
return ret;
}
RetError AccessibilitySettingsConfig::SetCaptionState(const bool state)
{
HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
auto ret = SetConfigState(CAPTION_KEY, state);
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetCaptionState");
HILOG_ERROR("set isCaptionState_ failed");
return ret;
}
isCaptionState_.store(state);
return ret;
}
RetError AccessibilitySettingsConfig::SetScreenMagnificationState(const bool state)
{
HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
auto ret = SetConfigState(SCREEN_MAGNIFICATION_KEY, state);
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetScreenMagnificationState");
HILOG_ERROR("set SetScreenMagnificationState failed");
return ret;
}
SetMagnificationState(state);
return ret;
}
RetError AccessibilitySettingsConfig::SetMagnificationState(const bool state)
{
isScreenMagnificationState_.store(state);
return RET_OK;
}
RetError AccessibilitySettingsConfig::SetScreenMagnificationType(const uint32_t type)
{
HILOG_DEBUG("screenMagnificationType = [%{public}u]", type);
screenMagnificationType_.store(type);
return RET_OK;
}
RetError AccessibilitySettingsConfig::SetFlashReminderSwitch(const bool state)
{
HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
flashReminderSwitch_.store(state);
return RET_OK;
}
RetError AccessibilitySettingsConfig::SetSeniorModeState(const bool state)
{
HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
seniorModeState_.store(state);
return RET_OK;
}
RetError AccessibilitySettingsConfig::SetScreenMagnificationMode(const uint32_t mode)
{
HILOG_DEBUG("screenMagnificationMode = [%{public}u]", mode);
screenMagnificationMode_.store(mode);
return RET_OK;
}
RetError AccessibilitySettingsConfig::SetScreenMagnificationTriggerMethod(const int32_t triggerMethod)
{
HILOG_DEBUG("screenMagnificationTriggerMethod = [%{public}d]", triggerMethod);
screenMagnificationTriggerMethod_.store(triggerMethod);
return RET_OK;
}
RetError AccessibilitySettingsConfig::SetScreenMagnificationScale(const float scale)
{
HILOG_DEBUG("screenMagnificationScale = [%{public}f]", scale);
screenMagnificationScale_.store(scale);
return RET_OK;
}
RetError AccessibilitySettingsConfig::SetShortKeyState(const bool state)
{
HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
auto ret = SetConfigState(SHORTCUT_ENABLED, state);
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetShortKeyState");
HILOG_ERROR("set isShortKeyState_ failed");
return ret;
}
isShortKeyState_.store(state);
return ret;
}
RetError AccessibilitySettingsConfig::SetShortKeyOnLockScreenState(const bool state)
{
HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
auto ret = SetConfigState(SHORTCUT_ENABLED_ON_LOCK_SCREEN, state);
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetShortKeyOnLockScreenState");
HILOG_ERROR("set isShortKeyEnabledOnLockScreen_ failed");
return ret;
}
isShortKeyEnabledOnLockScreen_.store(state);
return ret;
}
RetError AccessibilitySettingsConfig::SetShortKeyTimeout(const int32_t time)
{
HILOG_DEBUG("time = [%{public}u]", time);
if (!datashare_) {
HILOG_ERROR("helper is nullptr");
return RET_ERR_NULLPTR;
}
auto ret = datashare_->PutIntValue(SHORTCUT_TIMEOUT, static_cast<int32_t>(time));
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetShortKeyTimeout");
HILOG_ERROR("set shortKeyTimeout_ failed");
return ret;
}
shortKeyTimeout_.store(time);
return ret;
}
RetError AccessibilitySettingsConfig::SetStartToHosState(const bool state)
{
HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
if (!datashare_) {
HILOG_ERROR("helper is nullptr");
return RET_ERR_NULLPTR;
}
auto ret = datashare_->PutBoolValue("AccessibilityStartToHos", state);
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetStartToHosState");
HILOG_ERROR("set startToHosState failed");
}
return ret;
}
RetError AccessibilitySettingsConfig::SetMouseKeyState(const bool state)
{
HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
auto ret = SetConfigState(MOUSEKEY, state);
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetMouseKeyState");
HILOG_ERROR("set isMouseKeyState_ failed");
return ret;
}
isMouseKeyState_.store(state);
return ret;
}
RetError AccessibilitySettingsConfig::SetMouseAutoClick(const int32_t time)
{
HILOG_DEBUG("time = [%{public}d]", time);
if (!datashare_) {
HILOG_ERROR("helper is nullptr");
return RET_ERR_NULLPTR;
}
auto ret = datashare_->PutIntValue("MouseAutoClick", time);
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetMouseAutoClick");
HILOG_ERROR("set mouseAutoClick_ failed");
return ret;
}
mouseAutoClick_.store(time);
return ret;
}
RetError AccessibilitySettingsConfig::SetShortkeyTarget(const std::string &name)
{
HILOG_DEBUG("name = [%{public}s]", name.c_str());
if (!datashare_) {
HILOG_ERROR("helper is nullptr");
return RET_ERR_NULLPTR;
}
auto ret = datashare_->PutStringValue("ShortkeyTarget", name);
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetShortkeyTarget");
HILOG_ERROR("set shortkeyTarget_ failed");
return ret;
}
shortkeyTarget_ = name;
return ret;
}
RetError AccessibilitySettingsConfig::SetShortkeyMultiTarget(const std::vector<std::string> &name)
{
HILOG_DEBUG();
std::set<std::string> targets;
std::copy_if(name.begin(), name.end(), std::inserter(targets, targets.end()),
[&targets](const std::string &target) {
if (targets.find(target) == targets.end()) {
targets.insert(target);
return true;
}
return false;
});
std::lock_guard<ffrt::mutex> lock(interfaceMutex_);
if (!datashare_) {
HILOG_ERROR("helper is nullptr");
return RET_ERR_NULLPTR;
}
std::string stringOut = "";
Utils::VectorToString(std::vector<std::string>(targets.begin(), targets.end()), stringOut);
auto ret = datashare_->PutStringValue(SHORTCUT_SERVICE, stringOut);
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetShortkeyMultiTarget");
HILOG_ERROR("set shortkeyMultiTarget_ failed");
return ret;
}
shortkeyMultiTarget_ = std::vector<std::string>(targets.begin(), targets.end());
return ret;
}
RetError AccessibilitySettingsConfig::SetShortkeyMultiTargetInPkgRemove(const std::string &name)
{
HILOG_DEBUG();
std::lock_guard<ffrt::mutex> lock(interfaceMutex_);
if (!datashare_) {
HILOG_ERROR("helper is nullptr");
return RET_ERR_NULLPTR;
}
RetError rtn = RET_OK;
for (auto iter = shortkeyMultiTarget_.begin(); iter != shortkeyMultiTarget_.end(); ++iter) {
if (*iter == name) {
shortkeyMultiTarget_.erase(iter);
std::string stringOut = "";
Utils::VectorToString(shortkeyMultiTarget_, stringOut);
rtn = datashare_->PutStringValue(SHORTCUT_SERVICE, stringOut);
break;
}
}
if (rtn != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetShortkeyMultiTargetInPkgRemove");
HILOG_ERROR("set shortkeyMultiTarget_ failed");
shortkeyMultiTarget_.push_back(name);
}
return rtn;
}
RetError AccessibilitySettingsConfig::SetHighContrastTextState(const bool state)
{
HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
auto ret = SetConfigState(HIGH_CONTRAST_TEXT_KEY, state);
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetHighContrastTextState");
HILOG_ERROR("set highContrastTextState_ failed");
return ret;
}
highContrastTextState_.store(state);
return ret;
}
RetError AccessibilitySettingsConfig::SetInvertColorState(const bool state)
{
HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
auto ret = SetConfigState(INVERT_COLOR_KEY, state);
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetInvertColorState");
HILOG_ERROR("set invertColorState_ failed");
return ret;
}
invertColorState_.store(state);
return ret;
}
RetError AccessibilitySettingsConfig::SetAnimationOffState(const bool state)
{
HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
auto ret = SetConfigState(ANIMATION_OFF_KEY, state);
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetAnimationOffState");
HILOG_ERROR("set animationOffState_ failed");
return ret;
}
animationOffState_.store(state);
if (state) {
int64_t nowTime = IgnoreRepeatClickNotification::GetWallTimeMs();
ret = datashare_->PutLongValue(TRANSITION_ANIMATIONS_TIMESTAMP, nowTime);
if (nowTime >= 0) {
TransitionAnimationsNotification::RegisterTimers(static_cast<uint64_t>(nowTime));
}
} else {
ret = datashare_->PutLongValue(TRANSITION_ANIMATIONS_TIMESTAMP, 0);
TransitionAnimationsNotification::DestroyTimers();
TransitionAnimationsNotification::CancelNotification();
}
Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateAccessibilityState();
return ret;
}
RetError AccessibilitySettingsConfig::SetAudioMonoState(const bool state)
{
HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
auto ret = SetConfigState(AUDIO_MONO_KEY, state);
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetAudioMonoState");
HILOG_ERROR("set audioMonoState_ failed");
return ret;
}
audioMonoState_.store(state);
return ret;
}
RetError AccessibilitySettingsConfig::SetDaltonizationState(const bool state)
{
HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
auto ret = SetConfigState(DALTONIZATION_STATE, state);
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetDaltonizationState");
HILOG_ERROR("set daltonizationState_ failed");
return ret;
}
daltonizationState_.store(state);
return ret;
}
RetError AccessibilitySettingsConfig::SetDaltonizationColorFilter(const uint32_t filter)
{
HILOG_DEBUG("filter = [%{public}u]", filter);
if (!datashare_) {
HILOG_ERROR("helper is nullptr");
return RET_ERR_NULLPTR;
}
uint32_t daltonizationColorFilter = filter;
if (filter == DISPLAY_DALTONIZER_GREEN) {
daltonizationColorFilter = AccessibilityConfig::Deuteranomaly;
} else if (filter == DISPLAY_DALTONIZER_RED) {
daltonizationColorFilter = AccessibilityConfig::Protanomaly;
} else if (filter == DISPLAY_DALTONIZER_BLUE) {
daltonizationColorFilter = AccessibilityConfig::Tritanomaly;
} else if (filter == static_cast<uint32_t>(DISPLAY_DALTONIZER_INVALID)) {
daltonizationColorFilter = 0;
}
auto ret = datashare_->PutIntValue(DALTONIZATION_COLOR_FILTER_KEY, static_cast<int32_t>(daltonizationColorFilter));
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetDaltonizationColorFilter");
HILOG_ERROR("set daltonizationColorFilter_ failed");
return ret;
}
daltonizationColorFilter_.store(daltonizationColorFilter);
return ret;
}
RetError AccessibilitySettingsConfig::SetContentTimeout(const uint32_t time)
{
HILOG_DEBUG("time = [%{public}u]", time);
if (!datashare_) {
HILOG_ERROR("helper is nullptr");
return RET_ERR_NULLPTR;
}
auto ret = datashare_->PutIntValue(CONTENT_TIMEOUT_KEY, static_cast<int32_t>(time));
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetContentTimeout");
HILOG_ERROR("set contentTimeout_ failed");
return ret;
}
contentTimeout_.store(time);
return ret;
}
RetError AccessibilitySettingsConfig::SetBrightnessDiscount(const float discount)
{
HILOG_DEBUG("discount = [%{public}f]", discount);
if (!datashare_) {
HILOG_ERROR("helper is nullptr");
return RET_ERR_NULLPTR;
}
auto ret = datashare_->PutFloatValue(BRIGHTNESS_DISCOUNT_KEY, discount);
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetBrightnessDiscount");
HILOG_ERROR("set brightnessDiscount_ failed");
return ret;
}
brightnessDiscount_.store(discount);
return ret;
}
RetError AccessibilitySettingsConfig::SetAudioBalance(const float balance)
{
HILOG_DEBUG("balance = [%{public}f]", balance);
if (!datashare_) {
HILOG_ERROR("helper is nullptr");
return RET_ERR_NULLPTR;
}
float audioBalance = round(balance * AUDIO_BALANCE_STEP) / AUDIO_BALANCE_STEP;
auto ret = datashare_->PutFloatValue(AUDIO_BALANCE_KEY, audioBalance);
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetAudioBalance");
HILOG_ERROR("set audioBalance_ failed");
return ret;
}
audioBalance_.store(audioBalance);
return ret;
}
RetError AccessibilitySettingsConfig::SetClickResponseTime(const uint32_t time)
{
HILOG_DEBUG("clickResponseTime = [%{public}u]", time);
if (!datashare_) {
HILOG_ERROR("helper is nullptr");
return RET_ERR_NULLPTR;
}
uint32_t clickResponseTime = time;
if (time == DOUBLE_CLICK_RESPONSE_TIME_MEDIUM) {
clickResponseTime = AccessibilityConfig::ResponseDelayMedium;
} else if (time > DOUBLE_CLICK_RESPONSE_TIME_MEDIUM) {
clickResponseTime = AccessibilityConfig::ResponseDelayLong;
}
auto ret = datashare_->PutIntValue(CLICK_RESPONCE_TIME, clickResponseTime);
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetClickResponseTime");
HILOG_ERROR("set clickResponseTime_ failed");
return ret;
}
clickResponseTime_.store(clickResponseTime);
return ret;
}
RetError AccessibilitySettingsConfig::SetIgnoreRepeatClickState(const bool state)
{
HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
auto ret = SetConfigState(IGNORE_REPEAT_CLICK_SWITCH, state);
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetIgnoreRepeatClickState");
HILOG_ERROR("set ignoreRepeatClickState_ failed");
return ret;
}
ignoreRepeatClickState_.store(state);
if (state) {
int64_t nowTime = IgnoreRepeatClickNotification::GetWallTimeMs();
ret = datashare_->PutLongValue(IGNORE_REPEAT_CLICK_TIMESTAMP, nowTime);
if (nowTime >= 0 ) {
IgnoreRepeatClickNotification::RegisterTimers(static_cast<uint64_t>(nowTime));
}
} else {
ret = datashare_->PutLongValue(IGNORE_REPEAT_CLICK_TIMESTAMP, 0);
IgnoreRepeatClickNotification::DestroyTimers();
IgnoreRepeatClickNotification::CancelNotification();
}
return ret;
}
RetError AccessibilitySettingsConfig::SetIgnoreRepeatClickReconfirm(const bool state)
{
HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
auto ret = SetConfigState(IGNORE_REPEAT_CLICK_RECONFIRM, state);
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetIgnoreRepeatClickReconfirm");
HILOG_ERROR("set ignoreRepeatClickReconfirm failed");
return ret;
}
return ret;
}
RetError AccessibilitySettingsConfig::SetZoomGestureEnabledReconfirm(const bool state)
{
HILOG_DEBUG("state = [%{public}s]", state ? "True" : "False");
auto ret = SetConfigState(ZOOM_GESTURE_ENABLED_RECONFIRM, state);
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetZoomGestureEnabledReconfirm");
HILOG_ERROR("set zoomGestureEnabledReconfirm failed");
return ret;
}
return ret;
}
RetError AccessibilitySettingsConfig::SetColorModeState(const A11yDarkModeType &type)
{
uint32_t darkModeValue = static_cast<uint32_t>(type);
HILOG_DEBUG("name = [%{public}d]", darkModeValue);
if (!systemDatashare_) {
HILOG_ERROR("systemDatashare_ is nullptr");
return RET_ERR_NULLPTR;
}
auto ret = systemDatashare_->PutStringValue("settings.uiappearance.darkmode_mode",
std::to_string(darkModeValue), true);
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetColorModeState");
HILOG_ERROR("set SetColorModeState failed");
}
return ret;
}
RetError AccessibilitySettingsConfig::SetIgnoreRepeatClickTime(const uint32_t time)
{
HILOG_DEBUG("ignoreRepeatClickTime = [%{public}u]", time);
if (!datashare_) {
HILOG_ERROR("helper is nullptr");
return RET_ERR_NULLPTR;
}
uint32_t ignoreRepeatClickTime = time;
if (time == DOUBLE_IGNORE_REPEAT_CLICK_TIME_SHORTEST) {
ignoreRepeatClickTime = AccessibilityConfig::RepeatClickTimeoutShortest;
} else if (time == DOUBLE_IGNORE_REPEAT_CLICK_TIME_SHORT) {
ignoreRepeatClickTime = AccessibilityConfig::RepeatClickTimeoutShort;
} else if (time == DOUBLE_IGNORE_REPEAT_CLICK_TIME_MEDIUM) {
ignoreRepeatClickTime = AccessibilityConfig::RepeatClickTimeoutMedium;
} else if (time == DOUBLE_IGNORE_REPEAT_CLICK_TIME_LONG) {
ignoreRepeatClickTime = AccessibilityConfig::RepeatClickTimeoutLong;
} else if (time > DOUBLE_IGNORE_REPEAT_CLICK_TIME_LONG) {
ignoreRepeatClickTime = AccessibilityConfig::RepeatClickTimeoutLongest;
}
auto ret = datashare_->PutIntValue(IGNORE_REPEAT_CLICK_TIME, ignoreRepeatClickTime);
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetIgnoreRepeatClickTime");
HILOG_ERROR("set ignoreRepeatClickTime_ failed");
return ret;
}
ignoreRepeatClickTime_.store(ignoreRepeatClickTime);
return ret;
}
RetError AccessibilitySettingsConfig::SetCaptionProperty(const AccessibilityConfig::CaptionProperty& caption)
{
HILOG_DEBUG();
captionProperty_ = caption;
if (!datashare_) {
return RET_ERR_NULLPTR;
}
auto fontFamilyRet = datashare_->PutStringValue(FONT_FAMILY, captionProperty_.GetFontFamily());
if (fontFamilyRet != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetCaptionProperty.fontFamily");
}
auto fontColorRet = datashare_->PutIntValue(FONT_COLOR, static_cast<int32_t>(captionProperty_.GetFontColor()));
if (fontColorRet != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetCaptionProperty.fontColor");
}
auto fontEdgeTypeRet = datashare_->PutStringValue(FONT_EDGE_TYPE, captionProperty_.GetFontEdgeType());
if (fontEdgeTypeRet != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetCaptionProperty.fontEdgeType");
}
auto backgroundColorRet = datashare_->PutIntValue(BACKGROUND_COLOR, static_cast<int32_t>(
captionProperty_.GetBackgroundColor()));
if (backgroundColorRet != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetCaptionProperty.backgroundColor");
}
auto windowColorRet = datashare_->PutIntValue(WINDOW_COLOR, static_cast<int32_t>(
captionProperty_.GetWindowColor()));
if (windowColorRet != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetCaptionProperty.windowColor");
}
auto fontScaleRet = datashare_->PutIntValue(FONT_SCALE, captionProperty_.GetFontScale());
if (fontScaleRet != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetCaptionProperty.fontScale");
}
return RET_OK;
}
bool AccessibilitySettingsConfig::GetCaptionState() const
{
return isCaptionState_.load();
}
bool AccessibilitySettingsConfig::GetScreenMagnificationState() const
{
return isScreenMagnificationState_.load();
}
bool AccessibilitySettingsConfig::GetShortKeyState() const
{
return isShortKeyState_.load();
}
bool AccessibilitySettingsConfig::GetShortKeyOnLockScreenState() const
{
return isShortKeyEnabledOnLockScreen_.load();
}
int32_t AccessibilitySettingsConfig::GetShortKeyTimeout() const
{
return shortKeyTimeout_.load();
}
bool AccessibilitySettingsConfig::GetMouseKeyState() const
{
return isMouseKeyState_.load();
}
int32_t AccessibilitySettingsConfig::GetMouseAutoClick() const
{
return mouseAutoClick_.load();
}
const std::string &AccessibilitySettingsConfig::GetShortkeyTarget() const
{
return shortkeyTarget_;
}
const std::vector<std::string> AccessibilitySettingsConfig::GetShortkeyMultiTarget()
{
std::lock_guard<ffrt::mutex> lock(interfaceMutex_);
std::vector<std::string> rtnVec = shortkeyMultiTarget_;
return rtnVec;
}
bool AccessibilitySettingsConfig::GetHighContrastTextState() const
{
return highContrastTextState_.load();
}
bool AccessibilitySettingsConfig::GetInvertColorState() const
{
return invertColorState_.load();
}
bool AccessibilitySettingsConfig::GetAnimationOffState() const
{
return animationOffState_.load();
}
bool AccessibilitySettingsConfig::GetAudioMonoState() const
{
return audioMonoState_.load();
}
bool AccessibilitySettingsConfig::GetDaltonizationState() const
{
return daltonizationState_.load();
}
uint32_t AccessibilitySettingsConfig::GetDaltonizationColorFilter() const
{
return daltonizationColorFilter_.load();
}
uint32_t AccessibilitySettingsConfig::GetContentTimeout() const
{
return contentTimeout_.load();
}
float AccessibilitySettingsConfig::GetBrightnessDiscount() const
{
return brightnessDiscount_.load();
}
float AccessibilitySettingsConfig::GetAudioBalance() const
{
return audioBalance_.load();
}
bool AccessibilitySettingsConfig::GetEnabledState() const
{
return enabled_.load();
}
bool AccessibilitySettingsConfig::GetTouchGuideState() const
{
return eventTouchGuideState_.load();
}
bool AccessibilitySettingsConfig::GetGestureState() const
{
return gesturesSimulation_.load();
}
bool AccessibilitySettingsConfig::GetKeyEventObserverState() const
{
return filteringKeyEvents_.load();
}
const AccessibilityConfig::CaptionProperty &AccessibilitySettingsConfig::GetCaptionProperty() const
{
return captionProperty_;
};
uint32_t AccessibilitySettingsConfig::GetClickResponseTime() const
{
return clickResponseTime_.load();
}
uint32_t AccessibilitySettingsConfig::GetScreenMagnificationType() const
{
return screenMagnificationType_.load();
}
bool AccessibilitySettingsConfig::GetFlashReminderSwitch() const
{
return flashReminderSwitch_.load();
}
bool AccessibilitySettingsConfig::GetSeniorModeState() const
{
return seniorModeState_.load();
}
uint32_t AccessibilitySettingsConfig::GetScreenMagnificationMode() const
{
return screenMagnificationMode_.load();
}
float AccessibilitySettingsConfig::GetScreenMagnificationScale() const
{
return screenMagnificationScale_.load();
}
int32_t AccessibilitySettingsConfig::GetScreenMagnificationTriggerMethod() const
{
return screenMagnificationTriggerMethod_.load();
}
bool AccessibilitySettingsConfig::GetIgnoreRepeatClickState() const
{
return ignoreRepeatClickState_.load();
}
uint32_t AccessibilitySettingsConfig::GetIgnoreRepeatClickTime() const
{
return ignoreRepeatClickTime_.load();
}
RetError AccessibilitySettingsConfig::SetEnabledAccessibilityServices(const std::vector<std::string> &services)
{
std::lock_guard<ffrt::mutex> lock(interfaceMutex_);
enabledAccessibilityServices_ = services;
if (datashare_ == nullptr) {
HILOG_WARN("datashare_ is null.");
return RET_ERR_NULLPTR;
}
std::string stringOut = "";
Utils::VectorToString(enabledAccessibilityServices_, stringOut);
auto ret = datashare_->PutStringValue(ENABLED_ACCESSIBILITY_SERVICES, stringOut);
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetEnabledAccessibilityServices");
HILOG_ERROR("set enabledAccessibilityServices failed");
}
return ret;
}
const std::vector<std::string> AccessibilitySettingsConfig::GetEnabledAccessibilityServices()
{
std::lock_guard<ffrt::mutex> lock(interfaceMutex_);
std::vector<std::string> rtnVec = enabledAccessibilityServices_;
return rtnVec;
}
RetError AccessibilitySettingsConfig::AddEnabledAccessibilityService(const std::string &serviceName)
{
std::lock_guard<ffrt::mutex> lock(interfaceMutex_);
auto iter = std::find(enabledAccessibilityServices_.begin(), enabledAccessibilityServices_.end(), serviceName);
if (iter != enabledAccessibilityServices_.end()) {
return RET_OK;
}
if (!datashare_) {
return RET_ERR_NULLPTR;
}
enabledAccessibilityServices_.push_back(serviceName);
std::string stringOut = "";
Utils::VectorToString(enabledAccessibilityServices_, stringOut);
return datashare_->PutStringValue(ENABLED_ACCESSIBILITY_SERVICES, stringOut);
}
RetError AccessibilitySettingsConfig::RemoveEnabledAccessibilityService(const std::string &serviceName)
{
std::lock_guard<ffrt::mutex> lock(interfaceMutex_);
auto iter = std::find(enabledAccessibilityServices_.begin(), enabledAccessibilityServices_.end(), serviceName);
if (iter == enabledAccessibilityServices_.end()) {
return RET_OK;
}
if (!datashare_) {
return RET_ERR_NULLPTR;
}
enabledAccessibilityServices_.erase(iter);
std::string stringOut = "";
Utils::VectorToString(enabledAccessibilityServices_, stringOut);
return datashare_->PutStringValue(ENABLED_ACCESSIBILITY_SERVICES, stringOut);
}
bool AccessibilitySettingsConfig::GetStartToHosState()
{
HILOG_DEBUG();
if (!datashare_) {
return false;
}
bool value = true;
value = datashare_->GetBoolValue("AccessibilityStartToHos", true);
return value;
}
uint32_t AccessibilitySettingsConfig::GetConfigState()
{
HILOG_DEBUG();
uint32_t state = 0;
if (isCaptionState_.load()) {
state |= STATE_CAPTION_ENABLED;
}
if (isScreenMagnificationState_.load()) {
state |= STATE_SCREENMAGNIFIER_ENABLED;
}
if (isMouseKeyState_.load()) {
state |= STATE_MOUSEKEY_ENABLED;
}
if (isShortKeyState_.load()) {
state |= STATE_SHORTKEY_ENABLED;
}
if (highContrastTextState_.load()) {
state |= STATE_HIGHCONTRAST_ENABLED;
}
if (daltonizationState_.load()) {
state |= STATE_DALTONIZATION_STATE_ENABLED;
}
if (invertColorState_.load()) {
state |= STATE_INVETRTCOLOR_ENABLED;
}
if (animationOffState_.load()) {
state |= STATE_ANIMATIONOFF_ENABLED;
}
if (audioMonoState_.load()) {
state |= STATE_AUDIOMONO_ENABLED;
}
if (ignoreRepeatClickState_.load()) {
state |= STATE_IGNORE_REPEAT_CLICK_ENABLED;
}
return state;
}
void AccessibilitySettingsConfig::InitCaption()
{
HILOG_DEBUG();
if (datashare_ == nullptr) {
return;
}
std::string strValue = datashare_->GetStringValue(CAPTION_KEY, "");
HILOG_DEBUG(" pref_->GetString() = %{public}s.", strValue.c_str());
if (!std::strcmp(strValue.c_str(), "on")) {
isCaptionState_.store(true);
} else {
isCaptionState_.store(false);
}
std::string fontFamliy = datashare_->GetStringValue(FONT_FAMILY, "default");
HILOG_DEBUG("fontFamily = %{public}s.", fontFamliy.c_str());
int32_t fontScale = static_cast<int32_t>(datashare_->GetIntValue(FONT_SCALE, DEFAULT_FONT_SCALE));
HILOG_DEBUG("fontScale = %{public}d.", fontScale);
uint32_t fontColor = static_cast<uint32_t>(datashare_->GetIntValue(FONT_COLOR, DEFAULT_COLOR));
HILOG_DEBUG("fontColor = 0x%{public}x.", fontColor);
std::string fontEdgeType = datashare_->GetStringValue(FONT_EDGE_TYPE, "none");
HILOG_DEBUG("fontEdgeType = 0x%{public}s.", fontEdgeType.c_str());
uint32_t backgroundColor = static_cast<uint32_t>(datashare_->GetIntValue(BACKGROUND_COLOR, DEFAULT_COLOR));
HILOG_DEBUG("backgroundColor = 0x%{public}x.", backgroundColor);
uint32_t windowColor = static_cast<uint32_t>(datashare_->GetIntValue(WINDOW_COLOR, DEFAULT_COLOR));
HILOG_DEBUG("windowColor = 0x%{public}x.", windowColor);
captionProperty_.SetFontFamily(fontFamliy);
captionProperty_.SetFontScale(fontScale);
captionProperty_.SetFontColor(fontColor);
captionProperty_.SetFontEdgeType(fontEdgeType);
captionProperty_.SetBackgroundColor(backgroundColor);
captionProperty_.SetWindowColor(windowColor);
}
void AccessibilitySettingsConfig::InitShortKeyConfig()
{
isShortKeyState_.store(datashare_->GetBoolValue(SHORTCUT_ENABLED, true));
datashare_->GetBoolValue(SHORTCUT_ENABLED_ON_LOCK_SCREEN, true);
shortKeyTimeout_.store(static_cast<int32_t>(datashare_->GetIntValue(SHORTCUT_TIMEOUT,
SHORT_KEY_TIMEOUT_BEFORE_USE)));
if (shortKeyTimeout_.load() == 1) {
SetShortKeyTimeout(SHORT_KEY_TIMEOUT_AFTER_USE);
} else if (shortKeyTimeout_.load() == 0) {
SetShortKeyTimeout(SHORT_KEY_TIMEOUT_BEFORE_USE);
}
shortkeyTarget_ = datashare_->GetStringValue("ShortkeyTarget", "none");
std::string tmpString = datashare_->GetStringValue(SHORTCUT_SERVICE, SCREEN_READER_BUNDLE_ABILITY_NAME);
shortkeyMultiTarget_ = {};
Utils::StringToVector(tmpString, shortkeyMultiTarget_);
bool isScreenReaderEnabledOriginal =
(std::find(enabledAccessibilityServices_.begin(), enabledAccessibilityServices_.end(),
SCREEN_READER_BUNDLE_ABILITY_NAME) != enabledAccessibilityServices_.end());
tmpString = datashare_->GetStringValue(ENABLED_ACCESSIBILITY_SERVICES, "");
enabledAccessibilityServices_ = {};
Utils::StringToVector(tmpString, enabledAccessibilityServices_);
CloneShortkeyService(isScreenReaderEnabledOriginal);
}
void AccessibilitySettingsConfig::InitPrivacySpaceConfig()
{
std::shared_ptr<AccessibilitySettingProvider> service = AccessibilitySettingProvider::GetInstance(
POWER_MANAGER_SERVICE_ID);
if (service == nullptr) {
HILOG_ERROR("service is nullptr");
return;
}
bool cloneOrUpgradeFlag = false;
service->GetBoolValue(ACCESSIBILITY_PRIVACY_CLONE_OR_UPGRADE, cloneOrUpgradeFlag);
if (cloneOrUpgradeFlag && (accountId_ != DEFAULT_ACCOUNT_ID)) {
if (isShortKeyState_.load()) {
SetShortKeyOnLockScreenState(true);
} else {
SetShortKeyOnLockScreenState(false);
}
SetDefaultShortcutKeyService();
SetIgnoreRepeatClickReconfirm(ignoreRepeatClickState_.load());
SetZoomGestureEnabledReconfirm(isScreenMagnificationState_.load());
service->PutBoolValue(ACCESSIBILITY_PRIVACY_CLONE_OR_UPGRADE, false);
}
}
void AccessibilitySettingsConfig::InitAnimationOffConfig()
{
animationOffState_.store(datashare_->GetBoolValue(ANIMATION_OFF_KEY, false));
std::string graphicState = system::GetParameter(GRAPHIC_ANIMATION_SCALE_NAME, "1");
std::string arkuiState = system::GetParameter(ARKUI_ANIMATION_SCALE_NAME, "1");
if (animationOffState_.load()) {
system::SetParameter(GRAPHIC_ANIMATION_SCALE_NAME, "0");
system::SetParameter(ARKUI_ANIMATION_SCALE_NAME, "0");
} else {
if (graphicState == "0") {
system::SetParameter(GRAPHIC_ANIMATION_SCALE_NAME, "1");
graphicState = "1";
}
if (arkuiState == "0") {
system::SetParameter(ARKUI_ANIMATION_SCALE_NAME, "1");
arkuiState = "1";
}
if (arkuiState != graphicState) {
system::SetParameter(ARKUI_ANIMATION_SCALE_NAME, graphicState);
}
}
if (animationOffState_.load()) {
TransitionAnimationsNotification::PublishTransitionAnimationsReminder();
int64_t timeStamp = datashare_->GetLongValue(TRANSITION_ANIMATIONS_TIMESTAMP, 0);
if (timeStamp == 0) {
timeStamp = IgnoreRepeatClickNotification::GetWallTimeMs();
datashare_->PutLongValue(TRANSITION_ANIMATIONS_TIMESTAMP, timeStamp);
}
if (timeStamp > 0) {
TransitionAnimationsNotification::RegisterTimers(static_cast<uint64_t>(timeStamp));
}
if (g_transitionAnimationsOnceFlag) {
TransitionAnimationsNotification::PublishTransitionAnimationsReminder();
} else {
g_transitionAnimationsOnceFlag = true;
}
}
}
void AccessibilitySettingsConfig::HandleIgnoreRepeatClickState()
{
int64_t recoveryDate = datashare_->GetLongValue(RECOVERY_IGNORE_REPEAT_CLICK_DATE, 0);
if (ignoreRepeatClickState_.load() && recoveryDate == 0 &&
(ignoreRepeatClickTime_.load() == IGNORE_REPEAT_CLICK_SHORTEST ||
ignoreRepeatClickTime_.load() == IGNORE_REPEAT_CLICK_SHORT)) {
ignoreRepeatClickState_.store(false);
SetIgnoreRepeatClickState(false);
recoveryDate = IgnoreRepeatClickNotification::GetWallTimeMs();
datashare_->PutLongValue(RECOVERY_IGNORE_REPEAT_CLICK_DATE, recoveryDate);
HILOG_INFO("recovery ignore repeat click %{public}" PRId64, recoveryDate);
}
if (ignoreRepeatClickState_.load()) {
bool isScreenReaderEnabled =
(std::find(enabledAccessibilityServices_.begin(), enabledAccessibilityServices_.end(),
SCREEN_READER_BUNDLE_ABILITY_NAME) != enabledAccessibilityServices_.end());
bool isDataShareScreenReaderEnabled = datashare_->GetBoolValue(ACCESSIBILITY_SCREENREADER_ENABLED, false);
if (isScreenReaderEnabled || isDataShareScreenReaderEnabled) {
HILOG_INFO("screenReader is open, recovery ignore repeat click");
SetIgnoreRepeatClickState(false);
return;
}
IgnoreRepeatClickNotification::PublishIgnoreRepeatClickReminder();
int64_t timeStamp = datashare_->GetLongValue(IGNORE_REPEAT_CLICK_TIMESTAMP, 0);
if (timeStamp == 0) {
timeStamp = IgnoreRepeatClickNotification::GetWallTimeMs();
datashare_->PutLongValue(IGNORE_REPEAT_CLICK_TIMESTAMP, timeStamp);
}
if (timeStamp > 0) {
IgnoreRepeatClickNotification::RegisterTimers(static_cast<uint64_t>(timeStamp));
}
if (g_ignoreRepeatClickOnceFlag) {
IgnoreRepeatClickNotification::PublishIgnoreRepeatClickReminder();
} else {
g_ignoreRepeatClickOnceFlag = true;
}
}
}
void AccessibilitySettingsConfig::HandleIgnoreRepeatClickCache()
{
bool value = false;
value = datashare_->GetBoolValue(IGNORE_REPEATED_CLICK_CACHE_FLAG, false);
if (value) {
ignoreRepeatClickState_.store(true);
datashare_->PutBoolValue(IGNORE_REPEAT_CLICK_SWITCH, true);
datashare_->PutBoolValue(IGNORE_REPEATED_CLICK_CACHE_FLAG, false);
} else {
ignoreRepeatClickState_.store(datashare_->GetBoolValue(IGNORE_REPEAT_CLICK_SWITCH, false));
}
datashare_->PutBoolValue(IGNORE_REPEATED_CLICK_EXCLUDE_FLAG, false);
}
void AccessibilitySettingsConfig::HandleDaltonizationColorCache()
{
if (!datashare_) {
HILOG_ERROR("helper is nullptr");
return;
}
uint32_t daltonizationColorFilter = static_cast<uint32_t>(datashare_->GetIntValue(
DALTONIZATION_COLOR_FILTER_KEY, AccessibilityConfig::DALTONIZATION_TYPE::Deuteranomaly));
bool colorFilterCacheFlag = datashare_->GetBoolValue(OOBE_COLOR_FILTER_CACHE_FLAG, false);
if (colorFilterCacheFlag) {
HILOG_INFO("HandleDaltonizationColorCache recovery");
bool ColorFilterSwitchCache = datashare_->GetBoolValue(OOBE_COLOR_FILTER_SWITCH_CACHE, false);
std::string daltonizerModeCache = datashare_->GetStringValue(OOBE_COLOR_FILTER_DALTONIZER_CACHE, "");
daltonizationColorFilter = ConvertStringToDaltonizationTypes(daltonizerModeCache);
datashare_->PutBoolValue(DALTONIZATION_STATE, ColorFilterSwitchCache);
daltonizationState_.store(ColorFilterSwitchCache);
}
if (daltonizationState_ && daltonizationColorFilter_ == AccessibilityConfig::DALTONIZATION_TYPE::Normal) {
HILOG_INFO("HandleDaltonizationColorCache to default");
daltonizationColorFilter = AccessibilityConfig::DALTONIZATION_TYPE::Deuteranomaly;
datashare_->PutBoolValue(DALTONIZATION_STATE, false);
daltonizationState_.store(false);
}
auto ret = datashare_->PutIntValue(DALTONIZATION_COLOR_FILTER_KEY, static_cast<int32_t>(daltonizationColorFilter));
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "HandleDaltonizationColorCache");
HILOG_ERROR("set daltonizationColorFilter_ failed");
return;
}
daltonizationColorFilter_.store(daltonizationColorFilter);
return;
}
void AccessibilitySettingsConfig::InitSetting()
{
HILOG_DEBUG();
if (datashare_ == nullptr) {
return;
}
InitShortKeyConfig();
InitPrivacySpaceConfig();
InitAnimationOffConfig();
CloneAudioState();
isScreenMagnificationState_.store(datashare_->GetBoolValue(SCREEN_MAGNIFICATION_KEY, false));
isMouseKeyState_.store(datashare_->GetBoolValue(MOUSEKEY, false));
invertColorState_.store(datashare_->GetBoolValue(INVERT_COLOR_KEY, false));
highContrastTextState_.store(datashare_->GetBoolValue(HIGH_CONTRAST_TEXT_KEY, false));
daltonizationState_.store(datashare_->GetBoolValue(DALTONIZATION_STATE, false));
audioMonoState_.store(datashare_->GetBoolValue(AUDIO_MONO_KEY, false));
HandleIgnoreRepeatClickCache();
mouseAutoClick_.store(static_cast<int32_t>(datashare_->GetIntValue("MouseAutoClick", -1)));
daltonizationColorFilter_.store(static_cast<uint32_t>(datashare_->GetIntValue(
DALTONIZATION_COLOR_FILTER_KEY, AccessibilityConfig::DALTONIZATION_TYPE::Deuteranomaly)));
SetDaltonizationColorFilter(daltonizationColorFilter_.load());
HandleDaltonizationColorCache();
contentTimeout_.store(static_cast<uint32_t>(datashare_->GetIntValue(CONTENT_TIMEOUT_KEY, 0)));
brightnessDiscount_.store(static_cast<float>(datashare_->GetFloatValue(BRIGHTNESS_DISCOUNT_KEY, 1.0)));
audioBalance_.store(static_cast<float>(datashare_->GetFloatValue(AUDIO_BALANCE_KEY, 0)));
SetAudioBalance(audioBalance_.load());
screenMagnificationType_.store(static_cast<uint32_t>(
datashare_->GetIntValue(SCREEN_MAGNIFICATION_TYPE, FULL_SCREEN_MAGNIFICATION)));
screenMagnificationMode_.store(static_cast<uint32_t>(
datashare_->GetIntValue(SCREEN_MAGNIFICATION_MODE, FULL_SCREEN_MAGNIFICATION)));
screenMagnificationScale_.store(static_cast<float>(
datashare_->GetFloatValue(SCREEN_MAGNIFICATION_SCALE, DEFAULT_MAGNIFICATION_SCALE)));
int32_t triggerMethodValue = datashare_->GetIntValue(SCREEN_MAGNIFICATION_TRIGGER_METHOD, INVALID_TRIGGER_METHOD);
if (triggerMethodValue == INVALID_TRIGGER_METHOD) {
int32_t defaultTriggerMethod = isScreenMagnificationState_.load() ?
SINGLE_FINGER_TRIPLE_TAP_MODE : THREE_FINGER_DOUBLE_TAP_MODE;
screenMagnificationTriggerMethod_.store(defaultTriggerMethod);
datashare_->PutIntValue(SCREEN_MAGNIFICATION_TRIGGER_METHOD, defaultTriggerMethod);
}
clickResponseTime_.store(static_cast<uint32_t>(datashare_->GetIntValue(CLICK_RESPONCE_TIME, 0)));
SetClickResponseTime(clickResponseTime_.load());
ignoreRepeatClickTime_.store(static_cast<uint32_t>(datashare_->GetIntValue(IGNORE_REPEAT_CLICK_TIME, 0)));
SetIgnoreRepeatClickTime(ignoreRepeatClickTime_.load());
datashare_->GetStringValue(FLASH_REMINDER_SWITCH_KEY, "0");
datashare_->GetStringValue(FLASH_REMINDER_ENABLED, "DEFAULT");
datashare_->GetBoolValue(VOICE_RECOGNITION_KEY, false);
datashare_->GetStringValue(VOICE_RECOGNITION_TYPES, "DEFAULT");
HandleIgnoreRepeatClickState();
flashReminderSwitch_.store(datashare_->GetBoolValue(FLASH_REMINDER_SWITCH_KEY, false));
seniorModeState_.store(datashare_->GetBoolValue(ELDER_CARE_ENABLED_KEY, false));
}
void AccessibilitySettingsConfig::InitCapability()
{
HILOG_DEBUG();
if (datashare_ == nullptr) {
return;
}
enabled_.store(datashare_->GetBoolValue(ACCESSIBILITY, false));
eventTouchGuideState_.store(datashare_->GetBoolValue(TOUCH_GUIDE_STATE, false));
gesturesSimulation_.store(datashare_->GetBoolValue(GESTURE_KEY, false));
filteringKeyEvents_.store(datashare_->GetBoolValue(KEYEVENT_OBSERVER, false));
}
RetError AccessibilitySettingsConfig::SetConfigState(const std::string& key, bool value)
{
if (!datashare_) {
return RET_ERR_NULLPTR;
}
auto ret = datashare_->PutBoolValue(key, value);
if (ret != RET_OK) {
HILOG_ERROR("set configState failed");
}
return ret;
}
void AccessibilitySettingsConfig::Init()
{
HILOG_DEBUG();
if (!datashare_) {
datashare_ = std::make_shared<AccessibilityDatashareHelper>(DATASHARE_TYPE::SECURE, accountId_);
}
if (datashare_ == nullptr) {
return;
}
RetError ret = datashare_->Initialize(POWER_MANAGER_SERVICE_ID);
InitCaption();
InitSetting();
if (!systemDatashare_) {
systemDatashare_ = std::make_shared<AccessibilityDatashareHelper>(DATASHARE_TYPE::SYSTEM, accountId_);
}
if (systemDatashare_ == nullptr) {
return;
}
RetError systemRet = systemDatashare_->Initialize(POWER_MANAGER_SERVICE_ID);
if (!globalDatashare_) {
globalDatashare_ = std::make_shared<AccessibilityDatashareHelper>(DATASHARE_TYPE::GLOBAL, accountId_);
}
if (globalDatashare_ == nullptr) {
return;
}
RetError globalRet = globalDatashare_->Initialize(POWER_MANAGER_SERVICE_ID);
if (ret == RET_OK && systemRet == RET_OK && globalRet == RET_OK) {
isInitialized_ = true;
}
}
void AccessibilitySettingsConfig::CloneAudioState()
{
HILOG_DEBUG();
if (systemDatashare_ == nullptr) {
return;
}
RetError ret = RET_OK;
int32_t monoValue = static_cast<int32_t>(systemDatashare_->GetIntValue(AUDIO_MONO_KEY, INVALID_MASTER_MONO_VALUE));
if (monoValue != INVALID_MASTER_MONO_VALUE) {
SetAudioMonoState(monoValue == 1);
ret = systemDatashare_->PutIntValue(AUDIO_MONO_KEY, INVALID_MASTER_MONO_VALUE);
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "CloneAudioState.monoValue");
HILOG_ERROR("reset monoValue in system table failed");
}
}
float audioBalance = static_cast<float>(systemDatashare_->GetFloatValue(AUDIO_BALANCE_KEY,
INVALID_MASTER_BALANCE_VALUE));
if (abs(audioBalance - INVALID_MASTER_BALANCE_VALUE) > EPS) {
SetAudioBalance(audioBalance);
ret = systemDatashare_->PutFloatValue(AUDIO_BALANCE_KEY, INVALID_MASTER_BALANCE_VALUE);
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "CloneAudioState.audioBalance");
HILOG_ERROR("reset audioBalance in system table failed");
}
}
}
uint32_t AccessibilitySettingsConfig::GetShortKeyService(std::vector<std::string> &services)
{
uint32_t serviceFlag = 0;
auto screenReader = std::find_if(services.begin(), services.end(), [&](const std::string& service) {
return service.find(SCREENREADER_TAG) != std::string::npos;
});
serviceFlag = screenReader != services.end() ? STATE_EXPLORATION_ENABLED : serviceFlag;
auto invertColor = std::find_if(services.begin(), services.end(), [&](const std::string& service) {
return service.find(INVERT_COLOR_AOS_TAG) != std::string::npos ||
service.find(INVERT_COLOR_TAG) != std::string::npos;
});
serviceFlag = invertColor != services.end() ? (serviceFlag | STATE_INVETRTCOLOR_ENABLED) : serviceFlag;
auto audioMono = std::find_if(services.begin(), services.end(), [&](const std::string& service) {
return service.find(AUDIO_MONO_TAG) != std::string::npos;
});
serviceFlag = audioMono != services.end() ? (serviceFlag | STATE_AUDIOMONO_ENABLED) : serviceFlag;
auto highContrastText = std::find_if(services.begin(), services.end(), [&](const std::string& service) {
return service.find(HIGH_CONTRAST_TEXT_TAG) != std::string::npos;
});
serviceFlag = highContrastText != services.end() ? (serviceFlag | STATE_HIGHCONTRAST_ENABLED) : serviceFlag;
auto captionsAssistant = std::find_if(services.begin(), services.end(), [&](const std::string& service) {
return service.find(CAPTIONS_ASSISTANT_HMOS_TAG) != std::string::npos;
});
serviceFlag = captionsAssistant != services.end() ? (serviceFlag | STATE_CAPTION_ENABLED) : serviceFlag;
auto screenMagnification = std::find_if(services.begin(), services.end(), [&](const std::string& service) {
return service.find(SCREEN_MAGNIFICATION_TAG) != std::string::npos;
});
serviceFlag = screenMagnification != services.end() ? (serviceFlag | STATE_SCREENMAGNIFIER_ENABLED) : serviceFlag;
return serviceFlag;
}
void AccessibilitySettingsConfig::CloneShortkeyService(bool isScreenReaderEnabled)
{
std::vector<std::string> tmpVec = GetShortkeyMultiTarget();
uint32_t shortkeyServiceFlag = GetShortKeyService(tmpVec);
std::vector<std::string> shortkeyService;
if (shortkeyServiceFlag & STATE_EXPLORATION_ENABLED) {
shortkeyService.push_back(SCREEN_READER_BUNDLE_ABILITY_NAME);
}
if (shortkeyServiceFlag & STATE_INVETRTCOLOR_ENABLED) {
shortkeyService.push_back(INVERT_COLOR_TAG);
}
if (shortkeyServiceFlag & STATE_AUDIOMONO_ENABLED) {
shortkeyService.push_back(AUDIO_MONO_TAG);
}
if (shortkeyServiceFlag & STATE_HIGHCONTRAST_ENABLED) {
shortkeyService.push_back(HIGH_CONTRAST_TEXT_TAG);
}
if (shortkeyServiceFlag & STATE_CAPTION_ENABLED) {
shortkeyService.push_back(CAPTIONS_ASSISTANT_HMOS_TAG);
}
if (shortkeyServiceFlag & STATE_SCREENMAGNIFIER_ENABLED) {
shortkeyService.push_back(SCREEN_MAGNIFICATION_TAG);
}
SetShortkeyMultiTarget(shortkeyService);
tmpVec = GetEnabledAccessibilityServices();
shortkeyServiceFlag = GetShortKeyService(tmpVec);
std::vector<std::string> enabledShortkeyService;
if ((shortkeyServiceFlag & STATE_EXPLORATION_ENABLED) || (isScreenReaderEnabled == true)) {
enabledShortkeyService.push_back(SCREEN_READER_BUNDLE_ABILITY_NAME);
}
SetEnabledAccessibilityServices(enabledShortkeyService);
}
void AccessibilitySettingsConfig::SetDefaultShortcutKeyService()
{
HILOG_DEBUG();
if (GetShortkeyMultiTarget().empty()) {
HILOG_INFO("set default shortcut key service.");
std::vector<std::string> defaultService;
defaultService.push_back(SCREEN_READER_BUNDLE_ABILITY_NAME);
SetShortkeyMultiTarget(defaultService);
}
}
void AccessibilitySettingsConfig::CloneOnDeviceCapability()
{
HILOG_INFO();
std::string deviceType = OHOS::system::GetDeviceType();
HILOG_INFO("deviceType: %{public}s", deviceType.c_str());
if (deviceType != "2in1") {
return;
}
int32_t newCapability = system::GetIntParameter(CLONE_CAPABILITY, 0);
if (newCapability == 0) {
HILOG_INFO("newCapability is 0");
return;
}
std::shared_ptr<AccessibilitySettingProvider> service =
AccessibilitySettingProvider::GetInstance(POWER_MANAGER_SERVICE_ID);
if (service == nullptr) {
HILOG_ERROR("service is nullptr");
return;
}
int32_t oldCapability = 0;
service->GetIntValue(OLD_DEVICE_CAPABILITY, oldCapability);
HILOG_INFO("newCapability: %{public}d, oldCapability: %{public}d", newCapability, oldCapability);
for (auto capability : PC_ENABLE_CAPABILITY_LIST) {
if ((static_cast<uint32_t>(newCapability) & static_cast<uint32_t>(capability)) != (
static_cast<uint32_t>(oldCapability) & static_cast<uint32_t>(capability))) {
HILOG_INFO("capability: %{public}d is not same, need recover", capability);
recoverCapability(capability);
}
}
service->PutIntValue(OLD_DEVICE_CAPABILITY, 0);
}
void AccessibilitySettingsConfig::recoverCapability(int32_t capability)
{
switch (capability) {
case CLONE_CAPABILITY_ZOOM_GUSTURE:
return;
case CLONE_CAPABILITY_HIGH_CONTRAST_TEXT:
return;
case CLONE_CAPABILITY_INVERT_COLOR:
recoverInvertColor();
return;
case CLONE_CAPABILITY_COLOR_CORRECTION:
recoverColorCorrection();
return;
case CLONE_CAPABILITY_TRANSITION_ANIMATION:
return;
case CLONE_CAPABILITY_AUDIO_ADJUSTMENT:
recoverAudioAdjustment();
return;
case CLONE_CAPABILITY_SOUND_RECOGNITION:
return;
case CLONE_CAPABILITY_FLASH_REMINDER:
return;
case CLONE_CAPABILITY_TOUCH_SCREEN:
return;
case CLONE_CAPABILITY_SHORT_KEY:
return;
}
}
void AccessibilitySettingsConfig::recoverInvertColor()
{
HILOG_INFO();
if (datashare_ == nullptr) {
HILOG_ERROR("datashare_ is nullptr");
return;
}
if (invertColorState_.load() != datashare_->GetBoolValue(INVERT_COLOR_KEY, false)) {
HILOG_INFO("invertColorState_: %{public}d need recovery", invertColorState_.load());
SetInvertColorState(invertColorState_.load());
}
}
void AccessibilitySettingsConfig::recoverColorCorrection()
{
HILOG_INFO();
if (datashare_ == nullptr) {
HILOG_ERROR("datashare_ is nullptr");
return;
}
if (daltonizationState_.load() != datashare_->GetBoolValue(DALTONIZATION_STATE, false)) {
HILOG_INFO("daltonizationState_: %{public}d need recovery", daltonizationState_.load());
SetDaltonizationState(daltonizationState_.load());
}
if (daltonizationColorFilter_.load() !=
static_cast<uint32_t>(datashare_->GetIntValue(
DALTONIZATION_COLOR_FILTER_KEY, AccessibilityConfig::DALTONIZATION_TYPE::Deuteranomaly))) {
HILOG_INFO("daltonizationColorFilter_: %{public}d need recovery", daltonizationColorFilter_.load());
SetDaltonizationColorFilter(daltonizationColorFilter_.load());
}
}
void AccessibilitySettingsConfig::recoverAudioAdjustment()
{
HILOG_INFO();
if (datashare_ == nullptr) {
HILOG_ERROR("datashare_ is nullptr");
return;
}
if (audioMonoState_.load() != datashare_->GetBoolValue(AUDIO_MONO_KEY, false)) {
HILOG_INFO("audioMonoState_: %{public}d need recovery", audioMonoState_.load());
SetAudioMonoState(audioMonoState_.load());
}
if (audioBalance_.load() != static_cast<float>(datashare_->GetFloatValue(AUDIO_BALANCE_KEY, 0))) {
HILOG_INFO("audioBalance_: %{public}f need recovery", audioBalance_.load());
SetAudioBalance(audioBalance_.load());
}
}
void AccessibilitySettingsConfig::OnDataClone()
{
HILOG_INFO();
CloneOnDeviceCapability();
if (ignoreRepeatClickState_.load()) {
IgnoreRepeatClickNotification::CancelNotification();
}
if (animationOffState_.load()) {
TransitionAnimationsNotification::CancelNotification();
}
bool isShortkeyEnabled = GetShortKeyState();
bool isShortkeyEnabledOnLockScreen = GetShortKeyOnLockScreenState();
InitSetting();
SetDefaultShortcutKeyService();
SetIgnoreRepeatClickReconfirm(ignoreRepeatClickState_.load());
SetZoomGestureEnabledReconfirm(isScreenMagnificationState_.load());
if (isShortKeyState_.load()) {
SetShortKeyOnLockScreenState(true);
} else {
SetShortKeyOnLockScreenState(false);
}
if (isShortkeyEnabled != GetShortKeyState()) {
SetShortKeyState(isShortkeyEnabled);
SetShortKeyState(!isShortkeyEnabled);
}
if (isShortkeyEnabledOnLockScreen != GetShortKeyOnLockScreenState()) {
SetShortKeyOnLockScreenState(isShortkeyEnabledOnLockScreen);
SetShortKeyOnLockScreenState(!isShortkeyEnabledOnLockScreen);
}
Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateShortKeyRegister();
std::shared_ptr<AccessibilitySettingProvider> service =
AccessibilitySettingProvider::GetInstance(POWER_MANAGER_SERVICE_ID);
if (service == nullptr) {
HILOG_ERROR("service is nullptr");
return;
}
int32_t isSupportThreeFingerZoom = globalDatashare_->GetIntValue(SUPPORT_THREE_FINGER_ZOOM, -1);
HILOG_INFO("isSupportThreeFingerZoom: %{public}d", isSupportThreeFingerZoom);
if (isSupportThreeFingerZoom == -1) {
bool screenMagnificationEnabled = datashare_->GetBoolValue(SCREEN_MAGNIFICATION_KEY, false);
int32_t triggerMethod = screenMagnificationEnabled ?
SINGLE_FINGER_TRIPLE_TAP_MODE : THREE_FINGER_DOUBLE_TAP_MODE;
datashare_->PutIntValue(SCREEN_MAGNIFICATION_TRIGGER_METHOD, triggerMethod);
screenMagnificationTriggerMethod_.store(triggerMethod);
HILOG_INFO("low version clone, set triggerMethod: %{public}d", triggerMethod);
}
globalDatashare_->PutIntValue(SUPPORT_THREE_FINGER_ZOOM, -1);
bool isScreenReaderEnabled =
(std::find(enabledAccessibilityServices_.begin(), enabledAccessibilityServices_.end(),
SCREEN_READER_BUNDLE_ABILITY_NAME) != enabledAccessibilityServices_.end());
if (isScreenReaderEnabled) {
ErrCode ret = service->PutBoolValue(ACCESSIBILITY_SCREENREADER_ENABLED, true, true);
sptr<AccessibilityAccountData> accountData
= Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
accountData->screenReaderState_ = true;
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "OnDataClone.screenReader");
HILOG_INFO("set screenReader state, ret = %{public}d", ret);
}
service->PutBoolValue(ACCESSIBILITY_PRIVACY_CLONE_OR_UPGRADE, true);
service->PutBoolValue(ACCESSIBILITY_CLONE_FLAG, false);
}
bool AccessibilitySettingsConfig::GetInitializeState()
{
return isInitialized_;
}
void AccessibilitySettingsConfig::SetInitializeState(bool isInitialized)
{
isInitialized_ = isInitialized;
if (isInitialized) {
return;
}
if (datashare_) {
datashare_->Uninitialize();
}
if (systemDatashare_) {
systemDatashare_->Uninitialize();
}
}
void AccessibilitySettingsConfig::SetSeniorModeStateForAppMap(const std::map<std::string, bool>& map)
{
HILOG_DEBUG();
std::lock_guard<ffrt::mutex> lock(seniorModeStateForAppMapMutex_);
seniorModeStateForAppMap_ = map;
}
std::map<std::string, bool> AccessibilitySettingsConfig::GetSeniorModeStateForAppMap() const
{
HILOG_DEBUG();
std::lock_guard<ffrt::mutex> lock(seniorModeStateForAppMapMutex_);
return seniorModeStateForAppMap_;
}
bool AccessibilitySettingsConfig::GetSeniorModeStateForApp(const std::string &bundleName, int32_t appIndex)
{
HILOG_DEBUG();
if (!datashare_) {
HILOG_ERROR("datashare_ is nullptr");
return false;
}
constexpr char SENIOR_MODE_STATE_KEY[] = "accessibility_senior_mode_state_for_app";
std::string seniorModeStateInfo = datashare_->GetStringValue(SENIOR_MODE_STATE_KEY, "{}");
if (!nlohmann::json::accept(seniorModeStateInfo)) {
HILOG_ERROR("Invalid json format");
return false;
}
nlohmann::json jsonObj = nlohmann::json::parse(seniorModeStateInfo);
if (!jsonObj.is_object()) {
HILOG_ERROR("Json is not an object");
return false;
}
std::string key = Utils::GetSeniorModeStateKey(bundleName, appIndex);
if (jsonObj.contains(key) && jsonObj[key].is_boolean()) {
return jsonObj[key].get<bool>();
}
return false;
}
RetError AccessibilitySettingsConfig::SetSeniorModeStateForApp(const std::string &bundleName, int32_t appIndex,
const bool state)
{
HILOG_INFO("bundleName: %{public}s, state: %{public}d", bundleName.c_str(), state);
if (!datashare_) {
return RET_ERR_NULLPTR;
}
constexpr char SENIOR_MODE_STATE_KEY[] = "accessibility_senior_mode_state_for_app";
std::string seniorModeStateInfo = datashare_->GetStringValue(SENIOR_MODE_STATE_KEY, "{}");
nlohmann::json jsonObj;
if (nlohmann::json::accept(seniorModeStateInfo)) {
jsonObj = nlohmann::json::parse(seniorModeStateInfo);
}
if (!jsonObj.is_object()) {
jsonObj = nlohmann::json::object();
}
std::string key = Utils::GetSeniorModeStateKey(bundleName, appIndex);
if (jsonObj.contains(key) && jsonObj[key].is_boolean() && jsonObj[key].get<bool>() == state) {
HILOG_DEBUG("Value unchanged, skip database update");
return RET_OK;
}
jsonObj[key] = state;
std::string newJsonStr = jsonObj.dump();
auto ret = datashare_->PutStringValue(SENIOR_MODE_STATE_KEY, newJsonStr);
if (ret != RET_OK) {
Utils::RecordDatashareInteraction(A11yDatashareValueType::UPDATE, "SetSeniorModeStateForApp");
HILOG_ERROR("SetSeniorModeStateForApp failed");
return ret;
}
return ret;
}
}
}
