• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 GetScreenReaderState();
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     void OnTouchGuideStateChanged();
288 
289 private:
290     /**
291      * @brief Update connected accessibility whether have touch guide
292      * capability. Have touch guide capability isEventTouchGuideState_ is
293      * true, otherwise isEventTouchGuideState_ is false.
294      */
295     void UpdateEventTouchGuideCapability();
296 
297     /**
298      * @brief Update connected accessibility whether have gesture capability.
299      *        Have gesture capability isGesturesSimulation_ is true,
300      *        otherwise isGesturesSimulation_ is false.
301      */
302     void UpdateGesturesSimulationCapability();
303 
304     /**
305      * @brief Update connected accessibility whether have key event observer capability.
306      *        Have key event observer capability isFilteringKeyEvents_ is true,
307      *        otherwise isFilteringKeyEvents_ is false.
308      */
309     void UpdateFilteringKeyEventsCapability();
310 
311     /**
312      * @brief Update connected accessibility whether have zoom capability.
313      *        Have zoom capability isScreenMagnification_ is true,
314      *        otherwise isScreenMagnification_ is false.
315      */
316     void UpdateMagnificationCapability();
317 
318     class AccessibilityAbility {
319     public:
320         AccessibilityAbility() = default;
321         ~AccessibilityAbility() = default;
322         void AddAccessibilityAbility(const std::string& uri, const sptr<AccessibleAbilityConnection>& connection);
323         sptr<AccessibleAbilityConnection> GetAccessibilityAbilityByName(const std::string& elementName);
324         sptr<AccessibleAbilityConnection> GetAccessibilityAbilityByUri(const std::string& uri);
325         void GetAccessibilityAbilities(std::vector<sptr<AccessibleAbilityConnection>>& connectionList);
326         void GetAbilitiesInfo(std::vector<AccessibilityAbilityInfo>& abilities);
327         bool IsExistCapability(Capability capability);
328         void GetAccessibilityAbilitiesMap(std::map<std::string, sptr<AccessibleAbilityConnection>>& connectionMap);
329         void GetDisableAbilities(std::vector<AccessibilityAbilityInfo>& disabledAbilities);
330         int32_t GetSizeByUri(const std::string& uri);
331         void RemoveAccessibilityAbilityByName(const std::string& bundleName, bool& result);
332         void RemoveAccessibilityAbilityByUri(const std::string& uri);
333         void Clear();
334         size_t GetSize();
335     private:
336         std::map<std::string, sptr<AccessibleAbilityConnection>> connectionMap_;
337         ffrt::mutex mutex_;
338     };
339 
340     int32_t id_;
341     AccountSA::OsAccountType accountType_ = AccountSA::OsAccountType::END;
342     bool isEventTouchGuideState_ = false;
343     bool isScreenMagnification_ = false;
344     bool isFilteringKeyEvents_ = false;
345     bool isGesturesSimulation_ = false;
346     bool screenReaderState_ = false;
347     std::string screenReaderAbilityName_ = "com.huawei.hmos.screenreader/AccessibilityExtAbility";
348     std::string screenReaderKey_ = "accessibility_screenreader_enabled";
349     uint32_t connectCounter_ = 1;
350     AccessibilityAbility connectedA11yAbilities_;  // key: bundleName/abilityName
351     AccessibilityAbility connectingA11yAbilities_;  // key: bundleName/abilityName
352     std::vector<sptr<IAccessibilityEnableAbilityListsObserver>> enableAbilityListsObservers_;
353     ffrt::mutex enableAbilityListObserversMutex_; // mutex for enableAbilityListsObservers_
354     std::map<int32_t, sptr<AccessibilityWindowConnection>> asacConnections_; // key: windowId
355     ffrt::mutex asacConnectionsMutex_; // mutex for map asacConnections_
356     CaptionPropertyCallbacks captionPropertyCallbacks_;
357     ffrt::mutex captionPropertyCallbacksMutex_; // mutex for captionPropertyCallbacks_
358     std::vector<AccessibilityAbilityInfo> installedAbilities_;
359     std::vector<std::string> enabledAbilities_; // bundleName/abilityName
360     std::vector<sptr<IAccessibleAbilityManagerConfigObserver>> configCallbacks_;
361     ffrt::mutex configCallbacksMutex_; // mutex for vector configCallbacks_
362     std::shared_ptr<AccessibilitySettingsConfig> config_ = nullptr;
363 };
364 
365 class AccessibilityAccountDataMap {
366 public:
367     AccessibilityAccountDataMap() = default;
368     ~AccessibilityAccountDataMap() = default;
369     sptr<AccessibilityAccountData> AddAccountData(int32_t accountId);
370     sptr<AccessibilityAccountData> GetCurrentAccountData(int32_t accountId);
371     sptr<AccessibilityAccountData> GetAccountData(int32_t accountId);
372     sptr<AccessibilityAccountData> RemoveAccountData(int32_t accountId);
373     std::vector<int32_t> GetAllAccountIds();
374     void Clear();
375 private:
376     std::map<int32_t, sptr<AccessibilityAccountData>> accountDataMap_;
377     ffrt::mutex accountDataMutex_;
378 };
379 } // namespace Accessibility
380 } // namespace OHOS
381 #endif // ACCESSIBILITY_ACCOUNT_DATA_H