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