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 16 #ifndef ACCESSIBLE_ABILITY_MANAGER_SERVICE_H 17 #define ACCESSIBLE_ABILITY_MANAGER_SERVICE_H 18 19 #include <future> 20 #include <map> 21 #include <memory> 22 #include <mutex> 23 #include <string> 24 25 #include "accessibility_dumper.h" 26 #include "accessibility_def.h" 27 #include "accessible_ability_manager_service_stub.h" 28 #include "accessible_ability_manager_service_event_handler.h" 29 #include "accessibility_account_data.h" 30 #include "accessibility_common_event.h" 31 #ifdef OHOS_BUILD_ENABLE_DISPLAY_MANAGER 32 #include "accessibility_display_manager.h" 33 #endif 34 #include "accessibility_element_operator_callback_stub.h" 35 #include "accessibility_input_interceptor.h" 36 #include "accessibility_keyevent_filter.h" 37 #include "accessibility_settings.h" 38 #include "accessibility_touchEvent_injector.h" 39 #include "accessibility_window_info.h" 40 #include "bundlemgr/bundle_mgr_interface.h" 41 #include "input_manager.h" 42 #include "singleton.h" 43 #include "system_ability.h" 44 #include "window_manager.h" 45 46 namespace OHOS { 47 namespace Accessibility { 48 class AccessibilityAccountData; 49 class TouchEventInjector; 50 class AccessibilitySettings; 51 52 enum CallBackID { 53 STATE_CALLBACK, 54 CAPTION_PROPERTY_CALLBACK, 55 ENABLE_ABILITY_LISTS_CALLBACK, 56 CONFIG_CALLBACK 57 }; 58 59 const std::map<std::string, int32_t> AccessibilityConfigTable = { 60 {"HIGH_CONTRAST_TEXT", HIGH_CONTRAST_TEXT}, 61 {"INVERT_COLOR", INVERT_COLOR}, 62 {"DALTONIZATION_COLOR_FILTER", DALTONIZATION_COLOR_FILTER}, 63 {"CONTENT_TIMEOUT", CONTENT_TIMEOUT}, 64 {"ANIMATION_OFF", ANIMATION_OFF}, 65 {"BRIGHTNESS_DISCOUNT", BRIGHTNESS_DISCOUNT}, 66 {"AUDIO_MONO", AUDIO_MONO}, 67 {"AUDIO_BALANCE", AUDIO_BALANCE}, 68 {"MOUSE_KEY", MOUSE_KEY}, 69 {"CAPTION_STATE", CAPTION_STATE}, 70 {"CAPTION_STYLE", CAPTION_STYLE}, 71 {"SCREEN_MAGNIFICATION", SCREEN_MAGNIFICATION}, 72 {"MOUSE_AUTOCLICK", MOUSE_AUTOCLICK} 73 }; 74 75 class AccessibleAbilityManagerService : public SystemAbility, public AccessibleAbilityManagerServiceStub { 76 DECLARE_SINGLETON(AccessibleAbilityManagerService) 77 DECLEAR_SYSTEM_ABILITY(AccessibleAbilityManagerService) 78 public: 79 /* For system ability */ 80 void OnStart() override; 81 void OnStop() override; 82 void OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override; 83 void OnRemoveSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override; 84 int Dump(int fd, const std::vector<std::u16string>& args) override; 85 86 public: 87 /* For AccessibleAbilityManagerServiceStub */ 88 RetError SendEvent(const AccessibilityEventInfo &uiEvent) override; 89 90 uint32_t RegisterStateObserver(const sptr<IAccessibleAbilityManagerStateObserver> &callback) override; 91 92 uint32_t RegisterCaptionObserver(const sptr<IAccessibleAbilityManagerCaptionObserver> &callback) override; 93 94 void RegisterEnableAbilityListsObserver( 95 const sptr<IAccessibilityEnableAbilityListsObserver> &observer) override; 96 97 RetError GetAbilityList(const uint32_t abilityTypes, const int32_t stateType, 98 std::vector<AccessibilityAbilityInfo> &infos) override; 99 100 RetError RegisterElementOperator(const int32_t windowId, 101 const sptr<IAccessibilityElementOperator> &operation, bool isApp) override; 102 103 RetError DeregisterElementOperator(const int32_t windowId) override; 104 105 RetError GetCaptionProperty(AccessibilityConfig::CaptionProperty &caption) override; 106 RetError SetCaptionProperty(const AccessibilityConfig::CaptionProperty &caption) override; 107 RetError SetCaptionState(const bool state) override; 108 109 bool GetEnabledState() override; 110 RetError GetCaptionState(bool &state) override; 111 bool GetTouchGuideState() override; 112 bool GetGestureState() override; 113 bool GetKeyEventObserverState() override; 114 115 RetError EnableAbility(const std::string &name, const uint32_t capabilities) override; 116 RetError GetEnabledAbilities(std::vector<std::string> &enabledAbilities) override; 117 RetError DisableAbility(const std::string &name) override; 118 RetError EnableUITestAbility(const sptr<IRemoteObject>& obj) override; 119 RetError DisableUITestAbility() override; 120 int32_t GetActiveWindow() override; 121 void GetRealWindowAndElementId(int32_t& windowId, int64_t& elementId) override; 122 void GetSceneBoardInnerWinId(int32_t windowId, int64_t elementId, int32_t& innerWid) override; 123 bool ExecuteActionOnAccessibilityFocused(const ActionType &action); 124 RetError GetFocusedWindowId(int32_t &focusedWindowId) override; 125 126 public: 127 /* For inner modules */ 128 bool EnableShortKeyTargetAbility(const std::string &name = ""); 129 bool DisableShortKeyTargetAbility(); 130 void OnShortKeyProcess(); 131 132 void SetTouchEventInjector(const sptr<TouchEventInjector> &touchEventInjector); 133 GetTouchEventInjector()134 inline sptr<TouchEventInjector> GetTouchEventInjector() 135 { 136 return touchEventInjector_; 137 } 138 GetKeyEventFilter()139 inline sptr<KeyEventFilter> GetKeyEventFilter() 140 { 141 return keyEventFilter_; 142 } 143 144 void SetKeyEventFilter(const sptr<KeyEventFilter> &keyEventFilter); 145 146 /* For DisplayResize */ 147 void NotifyDisplayResizeStateChanged(int32_t displayId, Rect& rect, float scale, float centerX, float centerY); 148 IsServiceReady()149 inline bool IsServiceReady() 150 { 151 return isReady_; 152 } 153 GetCurrentAccountId()154 inline int32_t GetCurrentAccountId() 155 { 156 return currentAccountId_; 157 } 158 GetMainHandler()159 inline std::shared_ptr<AAMSEventHandler> &GetMainHandler() 160 { 161 return handler_; 162 } 163 GetMainRunner()164 inline std::shared_ptr<AppExecFwk::EventRunner> &GetMainRunner() 165 { 166 return runner_; 167 } 168 169 sptr<AccessibilityAccountData> GetAccountData(int32_t accountId); 170 sptr<AccessibilityAccountData> GetCurrentAccountData(); 171 sptr<AppExecFwk::IBundleMgr> GetBundleMgrProxy(); 172 173 /* For common event */ 174 void AddedUser(int32_t accountId); 175 void RemovedUser(int32_t accountId); 176 void SwitchedUser(int32_t accountId); 177 void PackageChanged(const std::string &bundleName); 178 void PackageRemoved(const std::string &bundleName); 179 void PackageAdd(const std::string &bundleName); 180 181 void UpdateAccessibilityManagerService(); 182 183 // used for arkui windowId 1 map to WMS windowId 184 void FindInnerWindowId(const AccessibilityEventInfo &event, int32_t& windowId); 185 bool GetParentElementRecursively(int32_t windowId, int64_t elementId, 186 std::vector<AccessibilityElementInfo>& infos); 187 188 // used for arkui windowId 1 map to WMS windowId 189 class ElementOperatorCallbackImpl : public AccessibilityElementOperatorCallbackStub { 190 public: 191 ElementOperatorCallbackImpl() = default; 192 ~ElementOperatorCallbackImpl() = default; 193 194 virtual void SetSearchElementInfoByAccessibilityIdResult(const std::vector<AccessibilityElementInfo> &infos, 195 const int32_t requestId) override; 196 virtual void SetSearchElementInfoByTextResult(const std::vector<AccessibilityElementInfo> &infos, 197 const int32_t requestId) override; 198 virtual void SetFindFocusedElementInfoResult(const AccessibilityElementInfo &info, 199 const int32_t requestId) override; 200 virtual void SetFocusMoveSearchResult(const AccessibilityElementInfo &info, const int32_t requestId) override; 201 virtual void SetExecuteActionResult(const bool succeeded, const int32_t requestId) override; 202 203 private: 204 std::promise<void> promise_; 205 bool executeActionResult_ = false; 206 AccessibilityElementInfo accessibilityInfoResult_ = {}; 207 std::vector<AccessibilityElementInfo> elementInfosResult_; 208 209 friend class AccessibleAbilityManagerService; 210 }; 211 212 RetError SetScreenMagnificationState(const bool state) override; 213 RetError SetShortKeyState(const bool state) override; 214 RetError SetMouseKeyState(const bool state) override; 215 RetError SetMouseAutoClick(const int32_t time) override; 216 RetError SetShortkeyTarget(const std::string &name) override; 217 RetError SetShortkeyMultiTarget(const std::vector<std::string> &name) override; 218 RetError SetHighContrastTextState(const bool state) override; 219 RetError SetInvertColorState(const bool state) override; 220 RetError SetAnimationOffState(const bool state) override; 221 RetError SetAudioMonoState(const bool state) override; 222 RetError SetDaltonizationState(const bool state) override; 223 RetError SetDaltonizationColorFilter(const uint32_t filter) override; 224 RetError SetContentTimeout(const uint32_t time) override; 225 RetError SetBrightnessDiscount(const float discount) override; 226 RetError SetAudioBalance(const float balance) override; 227 RetError SetClickResponseTime(const uint32_t time) override; 228 RetError SetIgnoreRepeatClickState(const bool state) override; 229 RetError SetIgnoreRepeatClickTime(const uint32_t time) override; 230 231 RetError GetScreenMagnificationState(bool &state) override; 232 RetError GetShortKeyState(bool &state) override; 233 RetError GetMouseKeyState(bool &state) override; 234 RetError GetMouseAutoClick(int32_t &time) override; 235 RetError GetShortkeyTarget(std::string &name) override; 236 RetError GetShortkeyMultiTarget(std::vector<std::string> &name) override; 237 RetError GetHighContrastTextState(bool &state) override; 238 RetError GetInvertColorState(bool &state) override; 239 RetError GetAnimationOffState(bool &state) override; 240 RetError GetAudioMonoState(bool &state) override; 241 RetError GetDaltonizationState(bool &state) override; 242 RetError GetDaltonizationColorFilter(uint32_t &type) override; 243 RetError GetContentTimeout(uint32_t &timer) override; 244 RetError GetBrightnessDiscount(float &brightness) override; 245 RetError GetAudioBalance(float &balance) override; 246 RetError GetClickResponseTime(uint32_t &time) override; 247 RetError GetIgnoreRepeatClickState(bool &state) override; 248 RetError GetIgnoreRepeatClickTime(uint32_t &time) override; 249 void GetAllConfigs(AccessibilityConfigData &configData) override; 250 251 uint32_t RegisterConfigObserver(const sptr<IAccessibleAbilityManagerConfigObserver> &callback) override; 252 void UpdateConfigState(); 253 void UpdateAudioBalance(); 254 void UpdateBrightnessDiscount(); 255 void UpdateContentTimeout(); 256 void UpdateDaltonizationColorFilter(); 257 void UpdateMouseAutoClick(); 258 void UpdateShortkeyTarget(); 259 void UpdateShortkeyMultiTarget(); 260 void UpdateClickResponseTime(); 261 void UpdateIgnoreRepeatClickTime(); 262 263 void UpdateInputFilter(); 264 265 private: 266 bool SetTargetAbility(const int32_t targetAbilityValue); 267 class StateCallbackDeathRecipient final : public IRemoteObject::DeathRecipient { 268 public: 269 StateCallbackDeathRecipient() = default; 270 ~StateCallbackDeathRecipient() final = default; 271 DISALLOW_COPY_AND_MOVE(StateCallbackDeathRecipient); 272 273 void OnRemoteDied(const wptr<IRemoteObject> &remote) final; 274 }; 275 276 class InteractionOperationDeathRecipient final : public IRemoteObject::DeathRecipient { 277 public: InteractionOperationDeathRecipient(int32_t windowId)278 InteractionOperationDeathRecipient(int32_t windowId) : windowId_(windowId) {}; 279 ~InteractionOperationDeathRecipient() final = default; 280 DISALLOW_COPY_AND_MOVE(InteractionOperationDeathRecipient); 281 282 void OnRemoteDied(const wptr<IRemoteObject> &remote) final; 283 int32_t windowId_ = INVALID_WINDOW_ID; 284 }; 285 286 class CaptionPropertyCallbackDeathRecipient final : public IRemoteObject::DeathRecipient { 287 public: 288 CaptionPropertyCallbackDeathRecipient() = default; 289 ~CaptionPropertyCallbackDeathRecipient() final = default; 290 DISALLOW_COPY_AND_MOVE(CaptionPropertyCallbackDeathRecipient); 291 292 void OnRemoteDied(const wptr<IRemoteObject> &remote) final; 293 }; 294 295 class EnableAbilityListsObserverDeathRecipient final : public IRemoteObject::DeathRecipient { 296 public: 297 EnableAbilityListsObserverDeathRecipient() = default; 298 ~EnableAbilityListsObserverDeathRecipient() final = default; 299 DISALLOW_COPY_AND_MOVE(EnableAbilityListsObserverDeathRecipient); 300 301 void OnRemoteDied(const wptr<IRemoteObject> &remote) final; 302 }; 303 304 bool Init(); 305 void InitInnerResource(); 306 307 class ConfigCallbackDeathRecipient final : public IRemoteObject::DeathRecipient { 308 public: 309 ConfigCallbackDeathRecipient() = default; 310 ~ConfigCallbackDeathRecipient() final = default; 311 DISALLOW_COPY_AND_MOVE(ConfigCallbackDeathRecipient); 312 313 void OnRemoteDied(const wptr<IRemoteObject> &remote) final; 314 }; 315 316 class BundleManagerDeathRecipient final : public IRemoteObject::DeathRecipient { 317 public: 318 BundleManagerDeathRecipient() = default; 319 ~BundleManagerDeathRecipient() final = default; 320 DISALLOW_COPY_AND_MOVE(BundleManagerDeathRecipient); 321 322 void OnRemoteDied(const wptr<IRemoteObject> &remote) final; 323 }; 324 325 class StateObservers { 326 public: 327 StateObservers() = default; 328 ~StateObservers() = default; 329 void AddStateObserver(const sptr<IAccessibleAbilityManagerStateObserver>& stateObserver); 330 void OnStateObservers(uint32_t state); 331 void RemoveStateObserver(const wptr<IRemoteObject>& remote); 332 void Clear(); 333 private: 334 std::vector<sptr<IAccessibleAbilityManagerStateObserver>> observersList_; 335 std::mutex stateObserversMutex_; 336 }; 337 338 RetError InnerEnableAbility(const std::string &name, const uint32_t capabilities); 339 RetError InnerDisableAbility(const std::string &name); 340 341 sptr<AccessibilityWindowConnection> GetAccessibilityWindowConnection(int32_t windowId); 342 void ClearFocus(int32_t windowId); 343 void OutsideTouch(int32_t windowId); 344 void UpdateAccessibilityWindowStateByEvent(const AccessibilityEventInfo &event); 345 346 void UpdateAccessibilityState(); 347 void UpdateCaptionProperty(); 348 void UpdateSettingsInAtoHosTask(); 349 void UpdateSettingsInAtoHos(); 350 void UpdateAutoStartAbilities(); 351 void UpdateAllSetting(); 352 353 void RemoveCallback(CallBackID callback, const sptr<DeathRecipient> &recipient, const wptr<IRemoteObject> &remote); 354 void RemoveSavedConfigCallback(const wptr<IRemoteObject>& callback); 355 void OnBundleManagerDied(const wptr<IRemoteObject> &remote); 356 void DeleteConnectionAndDeathRecipient( 357 const int32_t windowId, const sptr<AccessibilityWindowConnection> &connection); 358 359 bool isReady_ = false; 360 bool isPublished_ = false; 361 std::map<int32_t, bool> dependentServicesStatus_; 362 int32_t currentAccountId_ = -1; 363 AccessibilityAccountDataMap a11yAccountsData_; 364 sptr<AppExecFwk::IBundleMgr> bundleManager_ = nullptr; 365 366 sptr<AccessibilityInputInterceptor> inputInterceptor_ = nullptr; 367 sptr<TouchEventInjector> touchEventInjector_ = nullptr; 368 sptr<KeyEventFilter> keyEventFilter_ = nullptr; 369 sptr<AccessibilityDumper> accessibilityDumper_ = nullptr; 370 371 std::shared_ptr<AppExecFwk::EventRunner> runner_; 372 std::shared_ptr<AAMSEventHandler> handler_; 373 374 int64_t ipcTimeoutNum_ = 0; // count ipc timeout number 375 376 sptr<IRemoteObject::DeathRecipient> stateObserversDeathRecipient_ = nullptr; 377 std::map<int32_t, sptr<IRemoteObject::DeathRecipient>> interactionOperationDeathRecipients_ {}; 378 sptr<IRemoteObject::DeathRecipient> captionPropertyCallbackDeathRecipient_ = nullptr; 379 sptr<IRemoteObject::DeathRecipient> enableAbilityListsObserverDeathRecipient_ = nullptr; 380 sptr<IRemoteObject::DeathRecipient> configCallbackDeathRecipient_ = nullptr; 381 sptr<IRemoteObject::DeathRecipient> bundleManagerDeathRecipient_ = nullptr; 382 StateObservers stateObservers_; 383 std::mutex mutex_; // current used for register state observer 384 std::vector<sptr<IAccessibleAbilityManagerConfigObserver>> defaultConfigCallbacks_; 385 std::shared_ptr<AccessibilitySettings> accessibilitySettings_ = nullptr; 386 std::vector<std::string> removedAutoStartAbilities_ {}; 387 }; 388 } // namespace Accessibility 389 } // namespace OHOS 390 #endif // ACCESSIBLE_ABILITY_MANAGER_SERVICE_H