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