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 #ifndef ACCESSIBILITY_ACCOUNT_DATA_H
16 #define ACCESSIBILITY_ACCOUNT_DATA_H
17 
18 #include <map>
19 #include <set>
20 #include <string>
21 #include <vector>
22 
23 #include "accessibility_caption.h"
24 #include "i_accessibility_enable_ability_lists_observer.h"
25 #include "accessibility_settings_config.h"
26 #include "accessibility_window_connection.h"
27 #include "accessible_ability_connection.h"
28 #include "i_accessible_ability_manager_caption_observer.h"
29 #include "i_accessible_ability_manager_config_observer.h"
30 #include "i_accessible_ability_manager_state_observer.h"
31 #include "element_name.h"
32 #include "accessibility_setting_provider.h"
33 #include "os_account_info.h"
34 
35 namespace OHOS {
36 namespace Accessibility {
37 using CaptionPropertyCallbacks = std::vector<sptr<IAccessibleAbilityManagerCaptionObserver>>;
38 class AccessibleAbilityConnection;
39 class AccessibilityWindowConnection;
40 
41 struct ConfigValueAtoHosUpdate {
42     bool highContrastText = false;
43     bool invertColor = false;
44     bool audioMono = false;
45     bool daltonizationState = false;
46     float audioBalance = 0.0;
47     bool isScreenReaderEnabled = false;
48     int clickResponseTime = 0;
49     bool ignoreRepeatClickState = false;
50     int ignoreRepeatClickTime = 0;
51     int displayDaltonizer = 0;
52     bool shortcutEnabled = false;
53     bool shortcutEnabledOnLockScreen = false;
54     int shortcutTimeout = 0;
55     bool screenMagnificationState = false;
56 };
57 
58 class AccessibilityAccountData final : public RefBase {
59 public:
60     AccessibilityAccountData(int32_t accountId);
61     ~AccessibilityAccountData();
62 
63     /**
64      * @brief Get the ID of the account.
65      * @return Returns accountId.
66      */
67     int32_t GetAccountId();
68 
69     /**
70      * @brief Get Accessibility state.
71      * @return returns whether accessibility is connected and whether can touch browse.
72      */
73     uint32_t GetAccessibilityState();
74 
75     /**
76      * @brief Switch users and clear old user data.
77      */
78     void OnAccountSwitched();
79 
80     /**
81      * @brief Add connected accessibility services.
82      * @param connection Accessible ability connection.
83      */
84     void AddConnectedAbility(sptr<AccessibleAbilityConnection>& connection);
85 
86     /**
87      * @brief Remove connected accessibility services.
88      * @param element The element name of ability.
89      */
90     void RemoveConnectedAbility(const AppExecFwk::ElementName &element);
91 
92     /**
93      * @brief Remove connecting accessibility services.
94      * @param uri bundle name + / + ability name.
95      */
96     void RemoveConnectingA11yAbility(const std::string &uri);
97 
98     void AddCaptionPropertyCallback(const sptr<IAccessibleAbilityManagerCaptionObserver>& callback);
99     void RemoveCaptionPropertyCallback(const wptr<IRemoteObject>& callback);
100 
101     void AddEnableAbilityListsObserver(const sptr<IAccessibilityEnableAbilityListsObserver>& observer);
102     void RemoveEnableAbilityListsObserver(const wptr<IRemoteObject>& observer);
103 
104     /**
105      * @brief Add interface operation interactive connection.
106      * @param windowId Interface operation interactive connection the
107      * corresponding window id.
108      * @param interactionConnection Interface interface operation
109      * interactive connection.
110      */
111     void AddAccessibilityWindowConnection(
112         const int32_t windowId, const sptr<AccessibilityWindowConnection>& interactionConnection);
113 
114     /**
115      * @brief Remove interface operation interactive connection.
116      * @param windowId Interface operation interactive connection the corresponding window id.
117      */
118     void RemoveAccessibilityWindowConnection(const int32_t windowId);
119 
120     /**
121      * @brief Add connecting accessibility.
122      * @param uri The uri of ability
123      * @param connection The connection of ability
124      */
125     void AddConnectingA11yAbility(const std::string &uri, const sptr<AccessibleAbilityConnection> &connection);
126 
127     void AddEnabledAbility(const std::string &name); // For UT
128 
129     /**
130      * @brief Remove accessibility that have been opened.
131      * @param name bundle name + / + ability name.
132      * @return return true if removes enabled ability successfully, otherwise refer to the RetError for the failure.
133      */
134     RetError RemoveEnabledAbility(const std::string &name);
135 
136     void AddInstalledAbility(AccessibilityAbilityInfo& abilityInfo); // For UT
137 
138     /**
139      * @brief Empty installed accessibility list.
140      * @param abilityInfo Accessibility ability info.
141      */
142     void RemoveInstalledAbility(const std::string &bundleName);
143 
144     /**
145      * @brief The real procedure for add connecting ability.
146      */
147     void ClearInstalledAbility();
148 
149     /**
150      * @brief Get connected accessibility list.
151      * @return Store map of connected accessibility abilities.
152      */
153     const std::map<std::string, sptr<AccessibleAbilityConnection>> GetConnectedA11yAbilities();
154 
155     const CaptionPropertyCallbacks GetCaptionPropertyCallbacks();
156 
157     /**
158      * @brief Get interface operation interactive connection list.
159      * @return Store map of interface operation interactive connection.
160      */
161     const std::map<int32_t, sptr<AccessibilityWindowConnection>> GetAsacConnections();
162 
163     /**
164      * @brief Query accessible ability connection through elementName URI.
165      * @param elementName Accessibility elementName URI
166      * @return Accessible ability connection corresponding to elementName URI.
167      */
168     const sptr<AccessibleAbilityConnection> GetAccessibleAbilityConnection(const std::string &elementName);
169 
170     /**
171      * @brief Query interface operation interactive connection through window id.
172      * @param windowId Interface operation interactive connection the corresponding window id.
173      * @return Interface operation interactive connection corresponding to window id.
174      */
175     const sptr<AccessibilityWindowConnection> GetAccessibilityWindowConnection(const int32_t windowId);
176 
177     /**
178      * @brief Get connecting ability of specified uri.
179      * @param uri The name of ability.
180      * @return Strong point of connecting ability.
181      */
182     sptr<AccessibleAbilityConnection> GetConnectingA11yAbility(const std::string &uri);
183 
184     /**
185      * @brief Get the accessibility ability info of the corresponding state according to the
186      *        ability state type.
187      * @param state Ability state type.
188      */
189     void GetAbilitiesByState(AbilityStateType state, std::vector<AccessibilityAbilityInfo> &abilities);
190 
191     /**
192      * @brief Get the accessibility ability info of the disabled ability.
193      */
194     void GetDisableAbilities(std::vector<AccessibilityAbilityInfo> &disabledAbilities);
195 
196     /**
197      * @brief Get enable accessibility list.
198      * @return Store map of enable accessibility abilities.
199      */
200     const std::vector<std::string> &GetEnabledAbilities();
201 
202     /**
203      * @brief Get install accessibility list.
204      * @return Store vector of install accessibility abilities.
205      */
206     const std::vector<AccessibilityAbilityInfo> &GetInstalledAbilities() const;
207 
208     /**
209      * @brief Update user enabled accessibility capabilities.
210      */
211     void UpdateAccountCapabilities();
212 
213     /**
214      * @brief Get flag with whether have zoom capability.
215      * @return isScreenMagnification_.
216      */
GetScreenMagnificationFlag()217     bool GetScreenMagnificationFlag()
218     {
219         return isScreenMagnification_;
220     }
221 
222     /**
223      * @brief Get flag with whether have touch guide capability.
224      * @return isEventTouchGuideState_.
225      */
GetEventTouchGuideStateFlag()226     bool GetEventTouchGuideStateFlag()
227     {
228         return isEventTouchGuideState_;
229     }
230 
231     /**
232      * @brief Get flag with whether have key event observer capability.
233      * @return isFilteringKeyEvents_.
234      */
GetFilteringKeyEventsFlag()235     bool GetFilteringKeyEventsFlag()
236     {
237         return isFilteringKeyEvents_;
238     }
239 
240     /**
241      * @brief Get flag with whether have gesture capability.
242      * @return isGesturesSimulation_.
243      */
GetGesturesSimulationFlag()244     bool GetGesturesSimulationFlag()
245     {
246         return isGesturesSimulation_;
247     }
248     bool GetInstalledAbilitiesFromBMS();
249 
250     std::shared_ptr<AccessibilitySettingsConfig> GetConfig();
251 
252     RetError EnableAbility(const std::string &name, const uint32_t capabilities);
253 
254     void SetScreenReaderState(const std::string &name, const std::string &state);
255     bool GetDefaultUserScreenReaderState();
256     AccountSA::OsAccountType GetAccountType();
257 
258     void Init();
259 
260     void UpdateEnableAbilityListsState();
261     void UpdateInstallAbilityListsState();
262 
263     void AddConfigCallback(const sptr<IAccessibleAbilityManagerConfigObserver>& callback);
264     void RemoveConfigCallback(const wptr<IRemoteObject>& callback);
265     const std::vector<sptr<IAccessibleAbilityManagerConfigObserver>> GetConfigCallbacks();
266     void SetConfigCallbacks(std::vector<sptr<IAccessibleAbilityManagerConfigObserver>>& observer);
267 
268     void GetImportantEnabledAbilities(std::map<std::string, uint32_t> &importantEnabledAbilities) const;
269     void UpdateImportantEnabledAbilities(std::map<std::string, uint32_t> &importantEnabledAbilities);
270     void UpdateAutoStartEnabledAbilities();
271 
272     uint32_t GetInputFilterFlag() const;
273     void UpdateAbilities();
274     bool RemoveAbility(const std::string &bundleName);
275     void AddAbility(const std::string &bundleName);
276     void ChangeAbility(const std::string &bundleName);
277 
278     void AddUITestClient(const sptr<IRemoteObject> &obj,
279         const std::string &bundleName, const std::string &abilityName);
280     void RemoveUITestClient(sptr<AccessibleAbilityConnection> &connection, const std::string &bundleName);
281     void SetAbilityAutoStartState(const std::string &name, const bool state);
282     void SetScreenReaderExtInAllAccounts(const bool state);
283     void DelAutoStartPrefKeyInRemovePkg(const std::string &bundleName);
284     bool GetAbilityAutoStartState(const std::string &name);
285     void GetConfigValueAtoHos(ConfigValueAtoHosUpdate &value);
286 
287 private:
288     /**
289      * @brief Update connected accessibility whether have touch guide
290      * capability. Have touch guide capability isEventTouchGuideState_ is
291      * true, otherwise isEventTouchGuideState_ is false.
292      */
293     void UpdateEventTouchGuideCapability();
294 
295     /**
296      * @brief Update connected accessibility whether have gesture capability.
297      *        Have gesture capability isGesturesSimulation_ is true,
298      *        otherwise isGesturesSimulation_ is false.
299      */
300     void UpdateGesturesSimulationCapability();
301 
302     /**
303      * @brief Update connected accessibility whether have key event observer capability.
304      *        Have key event observer capability isFilteringKeyEvents_ is true,
305      *        otherwise isFilteringKeyEvents_ is false.
306      */
307     void UpdateFilteringKeyEventsCapability();
308 
309     /**
310      * @brief Update connected accessibility whether have zoom capability.
311      *        Have zoom capability isScreenMagnification_ is true,
312      *        otherwise isScreenMagnification_ is false.
313      */
314     void UpdateMagnificationCapability();
315 
316     class AccessibilityAbility {
317     public:
318         AccessibilityAbility() = default;
319         ~AccessibilityAbility() = default;
320         void AddAccessibilityAbility(const std::string& uri, const sptr<AccessibleAbilityConnection>& connection);
321         sptr<AccessibleAbilityConnection> GetAccessibilityAbilityByName(const std::string& elementName);
322         sptr<AccessibleAbilityConnection> GetAccessibilityAbilityByUri(const std::string& uri);
323         void GetAccessibilityAbilities(std::vector<sptr<AccessibleAbilityConnection>>& connectionList);
324         void GetAbilitiesInfo(std::vector<AccessibilityAbilityInfo>& abilities);
325         bool IsExistCapability(Capability capability);
326         void GetAccessibilityAbilitiesMap(std::map<std::string, sptr<AccessibleAbilityConnection>>& connectionMap);
327         void GetDisableAbilities(std::vector<AccessibilityAbilityInfo>& disabledAbilities);
328         int32_t GetSizeByUri(const std::string& uri);
329         void RemoveAccessibilityAbilityByName(const std::string& bundleName, bool& result);
330         void RemoveAccessibilityAbilityByUri(const std::string& uri);
331         void Clear();
332         size_t GetSize();
333     private:
334         std::map<std::string, sptr<AccessibleAbilityConnection>> connectionMap_;
335         ffrt::mutex mutex_;
336     };
337 
338     int32_t id_;
339     AccountSA::OsAccountType accountType_ = AccountSA::OsAccountType::END;
340     bool isEventTouchGuideState_ = false;
341     bool isScreenMagnification_ = false;
342     bool isFilteringKeyEvents_ = false;
343     bool isGesturesSimulation_ = false;
344     std::string screenReaderAbilityName_ = "com.huawei.hmos.screenreader/AccessibilityExtAbility";
345     std::string screenReaderKey_ = "accessibility_screenreader_enabled";
346     uint32_t connectCounter_ = 1;
347     AccessibilityAbility connectedA11yAbilities_;  // key: bundleName/abilityName
348     AccessibilityAbility connectingA11yAbilities_;  // key: bundleName/abilityName
349     std::vector<sptr<IAccessibilityEnableAbilityListsObserver>> enableAbilityListsObservers_;
350     ffrt::mutex enableAbilityListObserversMutex_; // mutex for enableAbilityListsObservers_
351     std::map<int32_t, sptr<AccessibilityWindowConnection>> asacConnections_; // key: windowId
352     ffrt::mutex asacConnectionsMutex_; // mutex for map asacConnections_
353     CaptionPropertyCallbacks captionPropertyCallbacks_;
354     ffrt::mutex captionPropertyCallbacksMutex_; // mutex for captionPropertyCallbacks_
355     std::vector<AccessibilityAbilityInfo> installedAbilities_;
356     std::vector<std::string> enabledAbilities_; // bundleName/abilityName
357     std::vector<sptr<IAccessibleAbilityManagerConfigObserver>> configCallbacks_;
358     ffrt::mutex configCallbacksMutex_; // mutex for vector configCallbacks_
359     std::shared_ptr<AccessibilitySettingsConfig> config_ = nullptr;
360 };
361 
362 class AccessibilityAccountDataMap {
363 public:
364     AccessibilityAccountDataMap() = default;
365     ~AccessibilityAccountDataMap() = default;
366     sptr<AccessibilityAccountData> AddAccountData(int32_t accountId);
367     sptr<AccessibilityAccountData> GetCurrentAccountData(int32_t accountId);
368     sptr<AccessibilityAccountData> GetAccountData(int32_t accountId);
369     sptr<AccessibilityAccountData> RemoveAccountData(int32_t accountId);
370     std::vector<int32_t> GetAllAccountIds();
371     void Clear();
372 private:
373     std::map<int32_t, sptr<AccessibilityAccountData>> accountDataMap_;
374     ffrt::mutex accountDataMutex_;
375 };
376 } // namespace Accessibility
377 } // namespace OHOS
378 #endif // ACCESSIBILITY_ACCOUNT_DATA_H