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