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 33 namespace OHOS { 34 namespace Accessibility { 35 using CaptionPropertyCallbacks = std::vector<sptr<IAccessibleAbilityManagerCaptionObserver>>; 36 class AccessibleAbilityConnection; 37 class AccessibilityWindowConnection; 38 39 class AccessibilityAccountData final : public RefBase { 40 public: 41 AccessibilityAccountData(int32_t accountId); 42 ~AccessibilityAccountData(); 43 44 /** 45 * @brief Get the ID of the account. 46 * @return Returns accountId. 47 */ 48 int32_t GetAccountId(); 49 50 /** 51 * @brief Get Accessibility state. 52 * @return returns whether accessibility is connected and whether can touch browse. 53 */ 54 uint32_t GetAccessibilityState(); 55 56 /** 57 * @brief Switch users and clear old user data. 58 */ 59 void OnAccountSwitched(); 60 61 /** 62 * @brief Add connected accessibility services. 63 * @param connection Accessible ability connection. 64 */ 65 void AddConnectedAbility(sptr<AccessibleAbilityConnection>& connection); 66 67 /** 68 * @brief Remove connected accessibility services. 69 * @param element The element name of ability. 70 */ 71 void RemoveConnectedAbility(const AppExecFwk::ElementName &element); 72 73 /** 74 * @brief Remove connecting accessibility services. 75 * @param uri bundle name + / + ability name. 76 */ 77 void RemoveConnectingA11yAbility(const std::string &uri); 78 79 void AddCaptionPropertyCallback(const sptr<IAccessibleAbilityManagerCaptionObserver>& callback); 80 void RemoveCaptionPropertyCallback(const wptr<IRemoteObject>& callback); 81 82 void AddEnableAbilityListsObserver(const sptr<IAccessibilityEnableAbilityListsObserver>& observer); 83 void RemoveEnableAbilityListsObserver(const wptr<IRemoteObject>& observer); 84 85 /** 86 * @brief Add interface operation interactive connection. 87 * @param windowId Interface operation interactive connection the 88 * corresponding window id. 89 * @param interactionConnection Interface interface operation 90 * interactive connection. 91 */ 92 void AddAccessibilityWindowConnection( 93 const int32_t windowId, const sptr<AccessibilityWindowConnection>& interactionConnection); 94 95 /** 96 * @brief Remove interface operation interactive connection. 97 * @param windowId Interface operation interactive connection the corresponding window id. 98 */ 99 void RemoveAccessibilityWindowConnection(const int32_t windowId); 100 101 /** 102 * @brief Add connecting accessibility. 103 * @param uri The uri of ability 104 * @param connection The connection of ability 105 */ 106 void AddConnectingA11yAbility(const std::string &uri, const sptr<AccessibleAbilityConnection> &connection); 107 108 void AddEnabledAbility(const std::string &name); // For UT 109 110 /** 111 * @brief Remove accessibility that have been opened. 112 * @param name bundle name + / + ability name. 113 * @return return true if removes enabled ability successfully, otherwise refer to the RetError for the failure. 114 */ 115 RetError RemoveEnabledAbility(const std::string &name); 116 117 void AddInstalledAbility(AccessibilityAbilityInfo& abilityInfo); // For UT 118 119 /** 120 * @brief Empty installed accessibility list. 121 * @param abilityInfo Accessibility ability info. 122 */ 123 void RemoveInstalledAbility(const std::string &bundleName); 124 125 /** 126 * @brief The real procedure for add connecting ability. 127 */ 128 void ClearInstalledAbility(); 129 130 /** 131 * @brief Get connected accessibility list. 132 * @return Store map of connected accessibility abilities. 133 */ 134 const std::map<std::string, sptr<AccessibleAbilityConnection>> GetConnectedA11yAbilities(); 135 136 const CaptionPropertyCallbacks GetCaptionPropertyCallbacks(); 137 138 /** 139 * @brief Get interface operation interactive connection list. 140 * @return Store map of interface operation interactive connection. 141 */ 142 const std::map<int32_t, sptr<AccessibilityWindowConnection>> GetAsacConnections(); 143 144 /** 145 * @brief Query accessible ability connection through elementName URI. 146 * @param elementName Accessibility elementName URI 147 * @return Accessible ability connection corresponding to elementName URI. 148 */ 149 const sptr<AccessibleAbilityConnection> GetAccessibleAbilityConnection(const std::string &elementName); 150 151 /** 152 * @brief Query interface operation interactive connection through window id. 153 * @param windowId Interface operation interactive connection the corresponding window id. 154 * @return Interface operation interactive connection corresponding to window id. 155 */ 156 const sptr<AccessibilityWindowConnection> GetAccessibilityWindowConnection(const int32_t windowId); 157 158 /** 159 * @brief Get connecting ability of specified uri. 160 * @param uri The name of ability. 161 * @return Strong point of connecting ability. 162 */ 163 sptr<AccessibleAbilityConnection> GetConnectingA11yAbility(const std::string &uri); 164 165 /** 166 * @brief Get the accessibility ability info of the corresponding state according to the 167 * ability state type. 168 * @param state Ability state type. 169 */ 170 void GetAbilitiesByState(AbilityStateType state, std::vector<AccessibilityAbilityInfo> &abilities) const; 171 172 /** 173 * @brief Get the accessibility ability info of the disabled ability. 174 */ 175 void GetDisableAbilities(std::vector<AccessibilityAbilityInfo> &disabledAbilities) const; 176 177 /** 178 * @brief Get enable accessibility list. 179 * @return Store map of enable accessibility abilities. 180 */ 181 const std::vector<std::string> &GetEnabledAbilities(); 182 183 /** 184 * @brief Get install accessibility list. 185 * @return Store vector of install accessibility abilities. 186 */ 187 const std::vector<AccessibilityAbilityInfo> &GetInstalledAbilities() const; 188 189 /** 190 * @brief Update user enabled accessibility capabilities. 191 */ 192 void UpdateAccountCapabilities(); 193 194 /** 195 * @brief Get flag with whether have zoom capability. 196 * @return isScreenMagnification_. 197 */ GetScreenMagnificationFlag()198 bool GetScreenMagnificationFlag() 199 { 200 return isScreenMagnification_; 201 } 202 203 /** 204 * @brief Get flag with whether have touch guide capability. 205 * @return isEventTouchGuideState_. 206 */ GetEventTouchGuideStateFlag()207 bool GetEventTouchGuideStateFlag() 208 { 209 return isEventTouchGuideState_; 210 } 211 212 /** 213 * @brief Get flag with whether have key event observer capability. 214 * @return isFilteringKeyEvents_. 215 */ GetFilteringKeyEventsFlag()216 bool GetFilteringKeyEventsFlag() 217 { 218 return isFilteringKeyEvents_; 219 } 220 221 /** 222 * @brief Get flag with whether have gesture capability. 223 * @return isGesturesSimulation_. 224 */ GetGesturesSimulationFlag()225 bool GetGesturesSimulationFlag() 226 { 227 return isGesturesSimulation_; 228 } 229 bool GetInstalledAbilitiesFromBMS(); 230 231 std::shared_ptr<AccessibilitySettingsConfig> GetConfig(); 232 233 RetError EnableAbility(const std::string &name, const uint32_t capabilities); 234 235 void Init(); 236 237 void AddConfigCallback(const sptr<IAccessibleAbilityManagerConfigObserver>& callback); 238 void RemoveConfigCallback(const wptr<IRemoteObject>& callback); 239 const std::vector<sptr<IAccessibleAbilityManagerConfigObserver>> &GetConfigCallbacks() const; 240 void SetConfigCallbacks(std::vector<sptr<IAccessibleAbilityManagerConfigObserver>>& observer); 241 242 void GetImportantEnabledAbilities(std::map<std::string, uint32_t> &importantEnabledAbilities) const; 243 void UpdateImportantEnabledAbilities(std::map<std::string, uint32_t> &importantEnabledAbilities); 244 245 uint32_t GetInputFilterFlag() const; 246 void UpdateAbilities(); 247 bool RemoveAbility(const std::string &bundleName); 248 void AddAbility(const std::string &bundleName); 249 void ChangeAbility(const std::string &bundleName); 250 251 void AddUITestClient(const sptr<IRemoteObject> &obj, 252 const std::string &bundleName, const std::string &abilityName); 253 void RemoveUITestClient(sptr<AccessibleAbilityConnection> &connection, const std::string &bundleName); 254 255 private: 256 /** 257 * @brief Update connected accessibility whether have touch guide 258 * capability. Have touch guide capability isEventTouchGuideState_ is 259 * true, otherwise isEventTouchGuideState_ is false. 260 */ 261 void UpdateEventTouchGuideCapability(); 262 263 /** 264 * @brief Update connected accessibility whether have gesture capability. 265 * Have gesture capability isGesturesSimulation_ is true, 266 * otherwise isGesturesSimulation_ is false. 267 */ 268 void UpdateGesturesSimulationCapability(); 269 270 /** 271 * @brief Update connected accessibility whether have key event observer capability. 272 * Have key event observer capability isFilteringKeyEvents_ is true, 273 * otherwise isFilteringKeyEvents_ is false. 274 */ 275 void UpdateFilteringKeyEventsCapability(); 276 277 /** 278 * @brief Update connected accessibility whether have zoom capability. 279 * Have zoom capability isScreenMagnification_ is true, 280 * otherwise isScreenMagnification_ is false. 281 */ 282 void UpdateMagnificationCapability(); 283 284 void UpdateEnableAbilityListsState(); 285 286 int32_t id_; 287 bool isEventTouchGuideState_ = false; 288 bool isScreenMagnification_ = false; 289 bool isFilteringKeyEvents_ = false; 290 bool isGesturesSimulation_ = false; 291 uint32_t connectCounter_ = 1; 292 std::map<std::string, sptr<AccessibleAbilityConnection>> connectedA11yAbilities_; // key: bundleName/abilityName 293 std::map<std::string, sptr<AccessibleAbilityConnection>> connectingA11yAbilities_; // key: bundleName/abilityName 294 std::vector<sptr<IAccessibilityEnableAbilityListsObserver>> enableAbilityListsObservers_; 295 std::map<int32_t, sptr<AccessibilityWindowConnection>> asacConnections_; // key: windowId 296 CaptionPropertyCallbacks captionPropertyCallbacks_; 297 std::vector<AccessibilityAbilityInfo> installedAbilities_; 298 std::vector<std::string> enabledAbilities_; // bundleName/abilityName 299 std::vector<sptr<IAccessibleAbilityManagerConfigObserver>> configCallbacks_; 300 std::shared_ptr<AccessibilitySettingsConfig> config_ = nullptr; 301 }; 302 } // namespace Accessibility 303 } // namespace OHOS 304 #endif // ACCESSIBILITY_ACCOUNT_DATA_H