1 /*
2  * Copyright (c) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "multimodal_input_preferences_manager.h"
17 
18 #include "mmi_log.h"
19 
20 #undef MMI_LOG_DOMAIN
21 #define MMI_LOG_DOMAIN MMI_LOG_SERVER
22 #undef MMI_LOG_TAG
23 #define MMI_LOG_TAG "MultiModalInputPreferencesManager"
24 
25 namespace OHOS {
26 namespace MMI {
27 namespace {
28 constexpr int32_t KEYBOARD_REPEATRATE { 50 };
29 constexpr int32_t KEYBOARD_REPEATDELAY { 500 };
30 constexpr int32_t MOUSE_SCROLL_ROWS { 3 };
31 constexpr int32_t PRIMARY_BUTTON { 0 };
32 constexpr int32_t POINTER_SPEED { 7 };
33 constexpr int32_t TOUCHPAD_POINTER_SPEED { 6 };
34 constexpr int32_t RIGHT_CLICK_TYPE { 1 };
35 constexpr int32_t POINTER_COLOR { -1 };
36 constexpr int32_t POINTER_SIZE { 1 };
37 #ifdef OHOS_BUILD_ENABLE_MAGICCURSOR
38 constexpr int32_t MAGIC_POINTER_SIZE { 1 };
39 #endif // OHOS_BUILD_ENABLE_MAGICCURSOR
40 constexpr int32_t POINTER_STYLE { 0 };
41 constexpr int32_t ERROR_DELAY_VALUE { -1000 };
42 constexpr bool BOOL_DEFAULT { true };
43 const std::string PATH { "/data/service/el1/public/multimodalinput/" };
44 const std::string SHORT_KEY_FILE_NAME { "Settings.xml" };
45 const std::string MOUSE_FILE_NAME { "mouse_settings.xml" };
46 const std::string KEYBOARD_FILE_NAME { "keyboard_settings.xml" };
47 const std::string TOUCHPAD_FILE_NAME { "touchpad_settings.xml" };
48 } // namespace
49 
50 std::shared_ptr<IPreferenceManager> IPreferenceManager::instance_;
51 std::mutex IPreferenceManager::mutex_;
52 
GetInstance()53 std::shared_ptr<IPreferenceManager> IPreferenceManager::GetInstance()
54 {
55     if (instance_ == nullptr) {
56         std::lock_guard<std::mutex> lock(mutex_);
57         if (instance_ == nullptr) {
58             instance_ = std::make_shared<MultiModalInputPreferencesManager>();
59         }
60     }
61     return instance_;
62 }
63 
InitPreferences()64 int32_t MultiModalInputPreferencesManager::InitPreferences()
65 {
66     CALL_DEBUG_ENTER;
67     int32_t ret = GetPreferencesSettings();
68     if (ret != RET_OK) {
69         MMI_HILOGE("Get multimodal input preferences settings failed");
70         return RET_ERR;
71     }
72     ret = InitPreferencesMap();
73     if (ret != RET_OK) {
74         MMI_HILOGE("Init multimodal input preferences map failed");
75         return RET_ERR;
76     }
77     return RET_OK;
78 }
79 
GetPreferencesSettings()80 int32_t MultiModalInputPreferencesManager::GetPreferencesSettings()
81 {
82     int32_t errCode = RET_OK;
83     std::shared_ptr<NativePreferences::Preferences> mousePref =
84         NativePreferences::PreferencesHelper::GetPreferences(PATH + MOUSE_FILE_NAME, errCode);
85     CHKPR(mousePref, errno);
86     std::shared_ptr<NativePreferences::Preferences> keyboardPref =
87         NativePreferences::PreferencesHelper::GetPreferences(PATH + KEYBOARD_FILE_NAME, errCode);
88     CHKPR(keyboardPref, errno);
89     std::shared_ptr<NativePreferences::Preferences> touchpadPref =
90         NativePreferences::PreferencesHelper::GetPreferences(PATH + TOUCHPAD_FILE_NAME, errCode);
91     CHKPR(touchpadPref, errno);
92     pointerSize_ = mousePref->GetInt(strPointerSize_, POINTER_SIZE);
93     pointerSpeed_ = mousePref->GetInt(strPointerSpeed_, POINTER_SPEED);
94     pointerColor_ = mousePref->GetInt(strPointerColor_, POINTER_COLOR);
95     pointerStyle_ = mousePref->GetInt(strPointerStyle_, POINTER_STYLE);
96     mouseScrollRows_ = mousePref->GetInt(strMouseScrollRows_, MOUSE_SCROLL_ROWS);
97     hoverScrollState_ = mousePref->GetBool(strHoverScrollState_, BOOL_DEFAULT);
98     mousePrimaryButton_ = mousePref->GetInt(strMousePrimaryButton_, PRIMARY_BUTTON);
99     touchpadTapSwitch_ = touchpadPref->GetBool(strTouchpadTapSwitch_, BOOL_DEFAULT);
100     keyboardRepeatRate_ = keyboardPref->GetInt(strKeyboardRepeatRate_, KEYBOARD_REPEATRATE);
101     keyboardRepeatDelay_ = keyboardPref->GetInt(strKeyboardRepeatDelay_, KEYBOARD_REPEATDELAY);
102     touchpadPinchSwitch_ = touchpadPref->GetBool(strTouchpadPinchSwitch_, BOOL_DEFAULT);
103     touchpadSwipeSwitch_ = touchpadPref->GetBool(strTouchpadSwipeSwitch_, BOOL_DEFAULT);
104     touchpadPointerSpeed_ = touchpadPref->GetInt(strTouchpadPointerSpeed_, TOUCHPAD_POINTER_SPEED);
105     touchpadScrollSwitch_ = touchpadPref->GetBool(strTouchpadScrollSwitch_, BOOL_DEFAULT);
106     touchpadRightClickType_ = touchpadPref->GetInt(strTouchpadRightClickType_, RIGHT_CLICK_TYPE);
107     touchpadScrollDirection_ = touchpadPref->GetBool(strTouchpadScrollDirection_, BOOL_DEFAULT);
108     touchpadDoubleTapAndDrag_ = touchpadPref->GetBool(strTouchpadDoubleTapAndDrag_, BOOL_DEFAULT);
109 #ifdef OHOS_BUILD_ENABLE_MAGICCURSOR
110     magicPointerSize_ = mousePref->GetInt(strMagicPointerSize_, MAGIC_POINTER_SIZE);
111     magicPointerColor_ = mousePref->GetInt(strMagicPointerColor_, POINTER_COLOR);
112 #endif // OHOS_BUILD_ENABLE_MAGICCURSOR
113     NativePreferences::PreferencesHelper::RemovePreferencesFromCache(PATH + MOUSE_FILE_NAME);
114     NativePreferences::PreferencesHelper::RemovePreferencesFromCache(PATH + KEYBOARD_FILE_NAME);
115     NativePreferences::PreferencesHelper::RemovePreferencesFromCache(PATH + TOUCHPAD_FILE_NAME);
116     return RET_OK;
117 }
118 
InitPreferencesMap()119 int32_t MultiModalInputPreferencesManager::InitPreferencesMap()
120 {
121     preferencesMap_[strPointerSize_] = {MOUSE_FILE_NAME, pointerSize_};
122     preferencesMap_[strPointerSpeed_] = {MOUSE_FILE_NAME, pointerSpeed_};
123     preferencesMap_[strPointerColor_] = {MOUSE_FILE_NAME, pointerColor_};
124     preferencesMap_[strPointerStyle_] = {MOUSE_FILE_NAME, pointerStyle_};
125     preferencesMap_[strMouseScrollRows_] = {MOUSE_FILE_NAME, mouseScrollRows_};
126     preferencesMap_[strHoverScrollState_] = {MOUSE_FILE_NAME, static_cast<int32_t>(hoverScrollState_)};
127     preferencesMap_[strMousePrimaryButton_] = {MOUSE_FILE_NAME, mousePrimaryButton_};
128     preferencesMap_[strTouchpadTapSwitch_] = {TOUCHPAD_FILE_NAME, static_cast<int32_t>(touchpadTapSwitch_)};
129     preferencesMap_[strKeyboardRepeatRate_] = {KEYBOARD_FILE_NAME, keyboardRepeatRate_};
130     preferencesMap_[strKeyboardRepeatDelay_] = {KEYBOARD_FILE_NAME, keyboardRepeatDelay_};
131     preferencesMap_[strTouchpadPinchSwitch_] = {TOUCHPAD_FILE_NAME, static_cast<int32_t>(touchpadPinchSwitch_)};
132     preferencesMap_[strTouchpadSwipeSwitch_] = {TOUCHPAD_FILE_NAME, static_cast<int32_t>(touchpadSwipeSwitch_)};
133     preferencesMap_[strTouchpadPointerSpeed_] = {TOUCHPAD_FILE_NAME, touchpadPointerSpeed_};
134     preferencesMap_[strTouchpadScrollSwitch_] = {TOUCHPAD_FILE_NAME, static_cast<int32_t>(touchpadScrollSwitch_)};
135     preferencesMap_[strTouchpadRightClickType_] = {TOUCHPAD_FILE_NAME, touchpadRightClickType_};
136     preferencesMap_[strTouchpadScrollDirection_] = {TOUCHPAD_FILE_NAME, static_cast<int32_t>(touchpadScrollDirection_)};
137     preferencesMap_[strTouchpadDoubleTapAndDrag_] = {TOUCHPAD_FILE_NAME,
138                                                     static_cast<int32_t>(touchpadDoubleTapAndDrag_)};
139 #ifdef OHOS_BUILD_ENABLE_MAGICCURSOR
140     preferencesMap_[strMagicPointerSize_] = {MOUSE_FILE_NAME, magicPointerSize_};
141     preferencesMap_[strMagicPointerColor_] = {MOUSE_FILE_NAME, magicPointerColor_};
142 #endif // OHOS_BUILD_ENABLE_MAGICCURSOR
143     return RET_OK;
144 }
145 
GetIntValue(const std::string & key,int32_t defaultValue)146 int32_t MultiModalInputPreferencesManager::GetIntValue(const std::string &key, int32_t defaultValue)
147 {
148     auto iter = preferencesMap_.find(key);
149     if (iter == preferencesMap_.end()) {
150         return defaultValue;
151     }
152     auto [fileName, value] = iter->second;
153     return value;
154 }
155 
GetBoolValue(const std::string & key,bool defaultValue)156 bool MultiModalInputPreferencesManager::GetBoolValue(const std::string &key, bool defaultValue)
157 {
158     auto iter = preferencesMap_.find(key);
159     if (iter == preferencesMap_.end()) {
160         return defaultValue;
161     }
162     auto [fileName, value] = iter->second;
163     return static_cast<bool>(value);
164 }
165 
SetIntValue(const std::string & key,const std::string & setFile,int32_t setValue)166 int32_t MultiModalInputPreferencesManager::SetIntValue(const std::string &key, const std::string &setFile,
167     int32_t setValue)
168 {
169     auto iter = preferencesMap_.find(key);
170     std::string filePath = "";
171     if (iter == preferencesMap_.end()) {
172         preferencesMap_[key] = {setFile, setValue};
173         filePath = PATH + setFile;
174     } else {
175         auto [fileName, value] = iter->second;
176         if (value == setValue) {
177             MMI_HILOGD("The set value is same");
178             return RET_OK;
179         }
180         filePath = PATH + fileName;
181         preferencesMap_[key].second = setValue;
182     }
183 
184     int32_t errCode = RET_OK;
185     std::shared_ptr<NativePreferences::Preferences> pref =
186         NativePreferences::PreferencesHelper::GetPreferences(filePath, errCode);
187     CHKPR(pref, errno);
188     int32_t ret = pref->PutInt(key, setValue);
189     if (ret != RET_OK) {
190         MMI_HILOGE("Put value is failed, ret:%{public}d", ret);
191         return RET_ERR;
192     }
193     ret = pref->FlushSync();
194     if (ret != RET_OK) {
195         MMI_HILOGE("Flush sync is failed, ret:%{public}d", ret);
196         return RET_ERR;
197     }
198     NativePreferences::PreferencesHelper::RemovePreferencesFromCache(filePath);
199     return RET_OK;
200 }
201 
SetBoolValue(const std::string & key,const std::string & setFile,bool setValue)202 int32_t MultiModalInputPreferencesManager::SetBoolValue(const std::string &key, const std::string &setFile,
203     bool setValue)
204 {
205     auto iter = preferencesMap_.find(key);
206     std::string filePath = "";
207     if (iter == preferencesMap_.end()) {
208         preferencesMap_[key] = {setFile, static_cast<int32_t>(setValue)};
209         filePath = PATH + setFile;
210     } else {
211         auto [fileName, value] = iter->second;
212         if (static_cast<bool>(value) == setValue) {
213             MMI_HILOGD("The set value is same");
214             return RET_OK;
215         }
216         filePath = PATH + fileName;
217         preferencesMap_[key].second = setValue;
218     }
219 
220     int32_t errCode = RET_OK;
221     std::shared_ptr<NativePreferences::Preferences> pref =
222         NativePreferences::PreferencesHelper::GetPreferences(filePath, errCode);
223     CHKPR(pref, errno);
224     int32_t ret = pref->PutBool(key, setValue);
225     if (ret != RET_OK) {
226         MMI_HILOGE("Put value is failed, ret:%{public}d", ret);
227         return RET_ERR;
228     }
229     ret = pref->FlushSync();
230     if (ret != RET_OK) {
231         MMI_HILOGE("Flush sync is failed, ret:%{public}d", ret);
232         return RET_ERR;
233     }
234     NativePreferences::PreferencesHelper::RemovePreferencesFromCache(filePath);
235     return RET_OK;
236 }
237 
GetShortKeyDuration(const std::string & key)238 int32_t MultiModalInputPreferencesManager::GetShortKeyDuration(const std::string &key)
239 {
240     int32_t errCode = RET_OK;
241     if (shortcutKeyMap_.empty() || shortcutKeyMap_.find(key) == shortcutKeyMap_.end()) {
242         std::shared_ptr<NativePreferences::Preferences> pref =
243             NativePreferences::PreferencesHelper::GetPreferences(PATH + SHORT_KEY_FILE_NAME, errCode);
244         CHKPR(pref, errno);
245         int32_t duration = pref->GetInt(key, ERROR_DELAY_VALUE);
246         NativePreferences::PreferencesHelper::RemovePreferencesFromCache(PATH + SHORT_KEY_FILE_NAME);
247         shortcutKeyMap_.emplace(key, duration);
248         return duration;
249     }
250     return shortcutKeyMap_[key];
251 }
252 
SetShortKeyDuration(const std::string & key,int32_t setValue)253 int32_t MultiModalInputPreferencesManager::SetShortKeyDuration(const std::string &key, int32_t setValue)
254 {
255     auto iter = shortcutKeyMap_.find(key);
256     if (iter != shortcutKeyMap_.end() && iter->second == setValue) {
257         MMI_HILOGD("The set value is same");
258         return RET_OK;
259     }
260 
261     shortcutKeyMap_[key] = setValue;
262     int32_t errCode = RET_OK;
263     std::shared_ptr<NativePreferences::Preferences> pref =
264         NativePreferences::PreferencesHelper::GetPreferences(PATH + SHORT_KEY_FILE_NAME, errCode);
265     CHKPR(pref, errno);
266     int32_t ret = pref->PutInt(key, setValue);
267     if (ret != RET_OK) {
268         MMI_HILOGE("Put value is failed, ret:%{public}d", ret);
269         return RET_ERR;
270     }
271     ret = pref->FlushSync();
272     if (ret != RET_OK) {
273         MMI_HILOGE("Flush sync is failed, ret:%{public}d", ret);
274         return RET_ERR;
275     }
276     NativePreferences::PreferencesHelper::RemovePreferencesFromCache(PATH + SHORT_KEY_FILE_NAME);
277     return RET_OK;
278 }
279 } // namespace MMI
280 } // namespace OHOS
281