1 /* 2 * Copyright (C) 2022-2025 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 <map> 20 #include <memory> 21 #include <string> 22 23 #include "accessibility_dumper.h" 24 #include "accessibility_def.h" 25 #include "accessible_ability_manager_service_stub.h" 26 #include "accessible_ability_manager_service_event_handler.h" 27 #include "accessibility_account_data.h" 28 #include "accessibility_common_event.h" 29 #ifdef OHOS_BUILD_ENABLE_DISPLAY_MANAGER 30 #include "accessibility_display_manager.h" 31 #endif 32 #include "accessibility_element_operator_callback_stub.h" 33 #include "accessibility_input_interceptor.h" 34 #include "accessibility_keyevent_filter.h" 35 #include "accessibility_settings.h" 36 #include "accessibility_touchEvent_injector.h" 37 #include "accessibility_window_info.h" 38 #include "bundlemgr/bundle_mgr_interface.h" 39 #include "input_manager.h" 40 #include "singleton.h" 41 #include "system_ability.h" 42 #include "window_manager.h" 43 #include "accessibility_short_key.h" 44 #include "accessibility_resource_bundle_manager.h" 45 #include "refbase.h" 46 #include "magnification_manager.h" 47 #include "accessibility_security_component_manager.h" 48 49 namespace OHOS { 50 namespace Accessibility { 51 class AccessibilityAccountData; 52 class TouchEventInjector; 53 class AccessibilitySettings; 54 class AccessibilityResourceBundleManager; 55 56 enum CallBackID { 57 STATE_CALLBACK, 58 CAPTION_PROPERTY_CALLBACK, 59 ENABLE_ABILITY_LISTS_CALLBACK, 60 CONFIG_CALLBACK 61 }; 62 63 constexpr int REQUEST_ID_INIT = 65535; 64 constexpr int32_t TREE_ID_MAX = 0x00001FFF; 65 constexpr uint32_t TIME_OUT_OPERATOR = 5000; 66 constexpr uint32_t TIME_OUT_1000MS = 1000; 67 constexpr int32_t WAIT_NOTIFY_DISCONNECT_TIMEOUT = 30 * 1000; // 30s 68 69 class AccessibleAbilityManagerService : public SystemAbility, public AccessibleAbilityManagerServiceStub { 70 DECLARE_SINGLETON(AccessibleAbilityManagerService) 71 DECLEAR_SYSTEM_ABILITY(AccessibleAbilityManagerService) 72 public: 73 /* For system ability */ 74 void InitHandler(); 75 void InitActionHandler(); 76 void InitSendEventHandler(); 77 void InitChannelHandler(); 78 void InitInputManagerHandler(); 79 void InitGestureHandler(); 80 void InitHoverEnterHandler(); 81 void OnStart() override; 82 void OnStop() override; 83 void OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override; 84 void OnRemoveSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override; 85 int Dump(int fd, const std::vector<std::u16string>& args) override; 86 void PostDelayUnloadTask(); 87 88 public: 89 /* For AccessibleAbilityManagerServiceStub */ 90 ErrCode SendEvent(const AccessibilityEventInfoParcel& eventInfoParcel, int32_t flag) override; 91 92 RetError VerifyingToKenId(const int32_t windowId, const int64_t elementId); 93 94 ErrCode RegisterStateObserver(const sptr<IAccessibleAbilityManagerStateObserver> &callback, 95 uint32_t &state) override; 96 97 ErrCode RegisterCaptionObserver(const sptr<IAccessibleAbilityManagerCaptionObserver> &callback) override; 98 99 ErrCode RegisterEnableAbilityListsObserver( 100 const sptr<IAccessibilityEnableAbilityListsObserver> &observer) override; 101 102 ErrCode GetAbilityList(uint32_t abilityTypes, int32_t stateType, 103 std::vector<AccessibilityAbilityInfoParcel>& infos) override; 104 105 ErrCode RegisterElementOperatorByWindowId(const int32_t windowId, 106 const sptr<IAccessibilityElementOperator> &elementOperator) override; 107 108 ErrCode RegisterElementOperatorByParameter(const RegistrationPara& parameter, 109 const sptr<IAccessibilityElementOperator>& elementOperator) override; 110 111 ErrCode DeregisterElementOperatorByWindowId(const int32_t windowId) override; 112 113 ErrCode DeregisterElementOperatorByWindowIdAndTreeId(const int32_t windowId, const int32_t treeId) override; 114 115 ErrCode GetCaptionProperty(CaptionPropertyParcel &caption) override; 116 ErrCode SetCaptionProperty(const CaptionPropertyParcel &caption) override; 117 ErrCode SetCaptionState(const bool state) override; 118 119 ErrCode GetCaptionState(bool &state) override; 120 121 ErrCode EnableAbility(const std::string &name, const uint32_t capabilities) override; 122 ErrCode GetEnabledAbilities(std::vector<std::string> &enabledAbilities) override; 123 RetError SetCurtainScreenUsingStatus(bool isEnable); 124 ErrCode CheckExtensionAbilityPermission(std::string& processName) override; 125 ErrCode DisableAbility(const std::string &name) override; 126 ErrCode EnableUITestAbility(const sptr<IRemoteObject>& obj) override; 127 ErrCode DisableUITestAbility() override; 128 ErrCode SetMagnificationState(const bool state) override; 129 ErrCode GetActiveWindow(int32_t &windowId) override; 130 ErrCode GetActiveWindow(int32_t &windowId, bool systemApi) override; 131 ErrCode GetRealWindowAndElementId(int32_t& windowId, int64_t& elementId) override; 132 ErrCode GetSceneBoardInnerWinId(int32_t windowId, int64_t elementId, int32_t& innerWid) override; 133 bool FindFocusedElement(AccessibilityElementInfo &elementInfo, uint32_t timeout = TIME_OUT_OPERATOR); 134 bool ExecuteActionOnAccessibilityFocused(const ActionType &action); 135 ErrCode GetFocusedWindowId(int32_t &focusedWindowId) override; 136 void SetFocusWindowId(const int32_t focusWindowId); 137 void SetFocusElementId(const int64_t focusElementId); 138 int32_t GetFocusWindowId(); 139 int64_t GetFocusElementId(); 140 static int32_t GetTreeIdBySplitElementId(const int64_t elementId); 141 ErrCode GetRootParentId(int32_t windowId, int32_t treeId, int64_t &parentId) override; 142 ErrCode GetRootParentId(int32_t windowId, int32_t treeId, int64_t &parentId, bool systemApi) override; 143 void SetTokenIdMapAndRootParentId(const sptr<AccessibilityWindowConnection> connection, 144 const int32_t treeId, const int64_t nodeId, const uint32_t tokenId); 145 void RemoveTreeDeathRecipient(const int32_t windowId, const int32_t treeId, 146 const sptr<AccessibilityWindowConnection> connection); 147 int32_t GenerateRequestId(); 148 void GetElementOperatorConnection(sptr<AccessibilityWindowConnection> &connection, 149 const int64_t elementId, sptr<IAccessibilityElementOperator> &elementOperator); 150 ErrCode GetScreenReaderState(bool &state) override; 151 ErrCode SearchNeedEvents(std::vector<uint32_t> &needEvents) override; 152 private: 153 int32_t focusWindowId_ = -1; 154 int64_t focusElementId_ = -1; 155 std::atomic<int> requestId_ = REQUEST_ID_INIT; 156 public: 157 /* For inner modules */ 158 bool EnableShortKeyTargetAbility(const std::string &name = ""); 159 bool DisableShortKeyTargetAbility(); 160 void OnShortKeyProcess(); 161 void UpdateShortKeyRegister(); 162 163 void SetTouchEventInjector(const sptr<TouchEventInjector> &touchEventInjector); 164 GetTouchEventInjector()165 inline sptr<TouchEventInjector> GetTouchEventInjector() 166 { 167 return touchEventInjector_; 168 } 169 GetKeyEventFilter()170 inline sptr<KeyEventFilter> GetKeyEventFilter() 171 { 172 return keyEventFilter_; 173 } 174 175 void SetKeyEventFilter(const sptr<KeyEventFilter> &keyEventFilter); 176 177 /* For DisplayResize */ 178 void NotifyDisplayResizeStateChanged(int32_t displayId, Rect& rect, float scale, float centerX, float centerY); 179 IsServiceReady()180 inline bool IsServiceReady() 181 { 182 return isReady_; 183 } 184 GetCurrentAccountId()185 inline int32_t GetCurrentAccountId() 186 { 187 return currentAccountId_; 188 } 189 GetMainHandler()190 inline std::shared_ptr<AAMSEventHandler> &GetMainHandler() 191 { 192 return handler_; 193 } 194 GetMainRunner()195 inline std::shared_ptr<AppExecFwk::EventRunner> &GetMainRunner() 196 { 197 return runner_; 198 } 199 GetChannelRunner()200 inline std::shared_ptr<AppExecFwk::EventRunner> &GetChannelRunner() 201 { 202 return channelRunner_; 203 } 204 GetInputManagerRunner()205 inline std::shared_ptr<AppExecFwk::EventRunner> &GetInputManagerRunner() 206 { 207 return inputManagerRunner_; 208 } 209 GetGestureRunner()210 inline std::shared_ptr<AppExecFwk::EventRunner> &GetGestureRunner() 211 { 212 return gestureRunner_; 213 } 214 215 sptr<AccessibilityAccountData> GetAccountData(int32_t accountId); 216 sptr<AccessibilityAccountData> GetCurrentAccountData(); 217 std::vector<int32_t> GetAllAccountIds(); 218 219 /* For common event */ 220 void AddedUser(int32_t accountId); 221 void RemovedUser(int32_t accountId); 222 void SwitchedUser(int32_t accountId); 223 void PackageChanged(const std::string &bundleName); 224 void PackageRemoved(const std::string &bundleName); 225 void PackageAdd(const std::string &bundleName); 226 227 void UpdateAccessibilityManagerService(); 228 void InsertWindowIdEventPair(int32_t windowId, const AccessibilityEventInfo &event); 229 bool CheckWindowIdEventExist(int32_t windowId); 230 bool CheckWindowRegister(int32_t windowId); 231 RetError GetResourceBundleInfo(AccessibilityEventInfo &eventInfo); 232 RetError GetResourceValue(AccessibilityEventInfo &eventInfo, AppExecFwk::BundleInfo bundleInfo, 233 int32_t userId, std::string &result); 234 235 // used for arkui windowId 1 map to WMS windowId 236 void FindInnerWindowId(const AccessibilityEventInfo &event, int32_t& windowId); 237 bool GetParentElementRecursively(int32_t windowId, int64_t elementId, 238 std::vector<AccessibilityElementInfo>& infos); 239 240 // used for arkui windowId 1 map to WMS windowId 241 class ElementOperatorCallbackImpl : public AccessibilityElementOperatorCallbackStub { 242 public: 243 ElementOperatorCallbackImpl() = default; 244 ~ElementOperatorCallbackImpl() = default; 245 246 virtual void SetSearchElementInfoByAccessibilityIdResult(const std::vector<AccessibilityElementInfo> &infos, 247 const int32_t requestId) override; 248 virtual void SetSearchDefaultFocusByWindowIdResult(const std::vector<AccessibilityElementInfo> &infos, 249 const int32_t requestId) override; 250 virtual void SetSearchElementInfoByTextResult(const std::vector<AccessibilityElementInfo> &infos, 251 const int32_t requestId) override; 252 virtual void SetFindFocusedElementInfoResult(const AccessibilityElementInfo &info, 253 const int32_t requestId) override; 254 virtual void SetFocusMoveSearchResult(const AccessibilityElementInfo &info, const int32_t requestId) override; 255 virtual void SetExecuteActionResult(const bool succeeded, const int32_t requestId) override; 256 virtual void SetCursorPositionResult(const int32_t cursorPosition, const int32_t requestId) override; 257 virtual void SetSearchElementInfoBySpecificPropertyResult(const std::list<AccessibilityElementInfo> &infos, 258 const std::list<AccessibilityElementInfo> &treeInfos, const int32_t requestId) override; 259 260 private: 261 ffrt::promise<void> promise_; 262 bool executeActionResult_ = false; 263 AccessibilityElementInfo accessibilityInfoResult_ = {}; 264 std::vector<AccessibilityElementInfo> elementInfosResult_; 265 int32_t callCursorPosition_ = 0; 266 267 /** 268 * @brief Validate element infos and handle verification failure 269 * @param infos The element infos to validate 270 * @return true if all validations pass, false otherwise 271 */ 272 bool ValidateElementInfos(const std::list<AccessibilityElementInfo>& infos); 273 274 friend class AccessibleAbilityManagerService; 275 }; 276 ErrCode SetScreenMagnificationState(const bool state) override; 277 ErrCode SetShortKeyState(const bool state) override; 278 ErrCode SetMouseKeyState(const bool state) override; 279 ErrCode SetMouseAutoClick(const int32_t time) override; 280 ErrCode SetShortkeyTarget(const std::string &name) override; 281 ErrCode SetShortkeyMultiTarget(const std::vector<std::string> &name) override; 282 ErrCode SetHighContrastTextState(const bool state) override; 283 ErrCode SetInvertColorState(const bool state) override; 284 ErrCode SetAnimationOffState(const bool state) override; 285 ErrCode SetAudioMonoState(const bool state) override; 286 ErrCode SetDaltonizationState(const bool state) override; 287 ErrCode SetDaltonizationColorFilter(const uint32_t filter) override; 288 ErrCode SetContentTimeout(const uint32_t time) override; 289 ErrCode SetBrightnessDiscount(const float discount) override; 290 ErrCode SetAudioBalance(const float balance) override; 291 ErrCode SetClickResponseTime(const uint32_t time) override; 292 ErrCode SetIgnoreRepeatClickState(const bool state) override; 293 ErrCode SetIgnoreRepeatClickTime(const uint32_t time) override; 294 295 ErrCode GetScreenMagnificationState(bool &state) override; 296 ErrCode GetShortKeyState(bool &state) override; 297 ErrCode GetMouseKeyState(bool &state) override; 298 ErrCode GetMouseAutoClick(int32_t &time) override; 299 ErrCode GetShortkeyTarget(std::string &name) override; 300 ErrCode GetShortkeyMultiTarget(std::vector<std::string> &name) override; 301 ErrCode GetHighContrastTextState(bool &state) override; 302 ErrCode GetInvertColorState(bool &state) override; 303 ErrCode GetAnimationOffState(bool &state) override; 304 ErrCode GetAudioMonoState(bool &state) override; 305 ErrCode GetDaltonizationState(bool &state) override; 306 ErrCode GetDaltonizationColorFilter(uint32_t &type) override; 307 ErrCode GetContentTimeout(uint32_t &timer) override; 308 ErrCode GetBrightnessDiscount(float &brightness) override; 309 ErrCode GetAudioBalance(float &balance) override; 310 ErrCode GetClickResponseTime(uint32_t &time) override; 311 ErrCode GetIgnoreRepeatClickState(bool &state) override; 312 ErrCode GetIgnoreRepeatClickTime(uint32_t &time) override; 313 ErrCode GetAllConfigs(AccessibilityConfigData& configData, CaptionPropertyParcel& caption) override; 314 315 ErrCode RegisterConfigObserver(const sptr<IAccessibleAbilityManagerConfigObserver> &callback) override; 316 void UpdateConfigState(); 317 void UpdateAudioBalance(); 318 void UpdateBrightnessDiscount(); 319 void UpdateContentTimeout(); 320 void UpdateDaltonizationColorFilter(); 321 void UpdateMouseAutoClick(); 322 void UpdateShortkeyTarget(); 323 void UpdateShortkeyMultiTarget(); 324 void UpdateClickResponseTime(); 325 void UpdateIgnoreRepeatClickTime(); 326 327 void UpdateInputFilter(); 328 void UpdateAccessibilityState(); 329 void AddRequestId(int32_t windowId, int32_t treeId, int32_t requestId, 330 sptr<IAccessibilityElementOperatorCallback> callback); 331 ErrCode RemoveRequestId(int32_t requestId) override; 332 void OnDataClone(); 333 bool CheckPermission(const std::string &permission) const; 334 int32_t SetEnhanceConfig(const AccessibilitySecCompRawdata& rawData) override; 335 336 // for magnification 337 bool GetMagnificationState(); 338 uint32_t GetMagnificationType(); 339 uint32_t GetMagnificationMode(); 340 void SetMagnificationMode(int32_t mode); 341 float GetMagnificationScale(); 342 void SetMagnificationScale(float scale); 343 std::shared_ptr<MagnificationManager> GetMagnificationMgr(); 344 std::shared_ptr<WindowMagnificationManager> GetWindowMagnificationManager(); 345 std::shared_ptr<FullScreenMagnificationManager> GetFullScreenMagnificationManager(); 346 std::shared_ptr<MagnificationMenuManager> GetMenuManager(); 347 ErrCode AnnouncedForAccessibility(const std::string &announcedText); 348 void InitResource(bool needReInit); 349 std::string &GetResource(const std::string &resourceName); 350 void AnnouncedForMagnification(AnnounceType announceType); 351 void OffZoomGesture(); 352 void InitMagnification(); 353 void OnModeChanged(uint32_t mode); 354 355 RetError UpdateUITestConfigureEvents(std::vector<uint32_t> needEvents); 356 357 private: 358 void StopCallbackWait(int32_t windowId); 359 void StopCallbackWait(int32_t windowId, int32_t treeId); 360 RetError CheckCallingUid(); 361 bool IsApp() const; 362 bool IsSystemApp() const; 363 sptr<AccessibilityWindowConnection> GetRealIdConnection(); 364 bool FindFocusedElementByConnection(sptr<AccessibilityWindowConnection> connection, 365 AccessibilityElementInfo &elementInfo); 366 bool SetTargetAbility(const int32_t targetAbilityValue); 367 bool SetHighContrastTextAbility(bool state); 368 RetError RegisterElementOperatorChildWork(const RegistrationPara ¶meter, const int32_t treeId, 369 const int64_t nodeId, const sptr<IAccessibilityElementOperator> &operation, 370 const uint32_t tokenId, bool isApp); 371 void IsCheckWindowIdEventExist(const int32_t windowId); 372 class StateCallbackDeathRecipient final : public IRemoteObject::DeathRecipient { 373 public: 374 StateCallbackDeathRecipient() = default; 375 ~StateCallbackDeathRecipient() final = default; 376 DISALLOW_COPY_AND_MOVE(StateCallbackDeathRecipient); 377 378 void OnRemoteDied(const wptr<IRemoteObject> &remote) final; 379 }; 380 381 class InteractionOperationDeathRecipient final : public IRemoteObject::DeathRecipient { 382 public: InteractionOperationDeathRecipient(int32_t windowId,int32_t accountId)383 InteractionOperationDeathRecipient(int32_t windowId, int32_t accountId) : windowId_(windowId), 384 accountId_(accountId) {}; InteractionOperationDeathRecipient(int32_t windowId,int32_t treeId,int32_t accountId)385 InteractionOperationDeathRecipient(int32_t windowId, int32_t treeId, int32_t accountId) : windowId_(windowId), 386 treeId_(treeId), accountId_(accountId) {}; 387 ~InteractionOperationDeathRecipient() final = default; 388 DISALLOW_COPY_AND_MOVE(InteractionOperationDeathRecipient); 389 390 void OnRemoteDied(const wptr<IRemoteObject> &remote) final; 391 int32_t windowId_ = INVALID_WINDOW_ID; 392 int32_t treeId_ = INVALID_TREE_ID; 393 int32_t accountId_ = 0; 394 }; 395 396 class CaptionPropertyCallbackDeathRecipient final : public IRemoteObject::DeathRecipient { 397 public: 398 CaptionPropertyCallbackDeathRecipient() = default; 399 ~CaptionPropertyCallbackDeathRecipient() final = default; 400 DISALLOW_COPY_AND_MOVE(CaptionPropertyCallbackDeathRecipient); 401 402 void OnRemoteDied(const wptr<IRemoteObject> &remote) final; 403 }; 404 405 class EnableAbilityListsObserverDeathRecipient final : public IRemoteObject::DeathRecipient { 406 public: 407 EnableAbilityListsObserverDeathRecipient() = default; 408 ~EnableAbilityListsObserverDeathRecipient() final = default; 409 DISALLOW_COPY_AND_MOVE(EnableAbilityListsObserverDeathRecipient); 410 411 void OnRemoteDied(const wptr<IRemoteObject> &remote) final; 412 }; 413 414 bool Init(); 415 void InitInnerResource(); 416 417 class ConfigCallbackDeathRecipient final : public IRemoteObject::DeathRecipient { 418 public: 419 ConfigCallbackDeathRecipient() = default; 420 ~ConfigCallbackDeathRecipient() final = default; 421 DISALLOW_COPY_AND_MOVE(ConfigCallbackDeathRecipient); 422 423 void OnRemoteDied(const wptr<IRemoteObject> &remote) final; 424 }; 425 426 class BundleManagerDeathRecipient final : public IRemoteObject::DeathRecipient { 427 public: 428 BundleManagerDeathRecipient() = default; 429 ~BundleManagerDeathRecipient() final = default; 430 DISALLOW_COPY_AND_MOVE(BundleManagerDeathRecipient); 431 432 void OnRemoteDied(const wptr<IRemoteObject> &remote) final; 433 }; 434 435 class StateObservers { 436 public: 437 StateObservers() = default; 438 ~StateObservers() = default; 439 void AddStateObserver(const sptr<IAccessibleAbilityManagerStateObserver>& stateObserver); 440 void OnStateObservers(uint32_t state); 441 void RemoveStateObserver(const wptr<IRemoteObject>& remote); 442 void Clear(); 443 private: 444 std::vector<sptr<IAccessibleAbilityManagerStateObserver>> observersList_; 445 ffrt::mutex stateObserversMutex_; 446 }; 447 448 RetError InnerEnableAbility(const std::string &name, const uint32_t capabilities); 449 RetError InnerDisableAbility(const std::string &name); 450 451 sptr<AccessibilityWindowConnection> GetAccessibilityWindowConnection(int32_t windowId); 452 void ClearFocus(int32_t windowId); 453 void OutsideTouch(int32_t windowId); 454 void UpdateAccessibilityWindowStateByEvent(const AccessibilityEventInfo &event); 455 456 void UpdateCaptionProperty(); 457 void UpdateSettingsInAtoHosTask(); 458 void UpdateSettingsInAtoHos(); 459 void UpdateAutoStartAbilities(); 460 void UpdateAllSetting(); 461 void UpdateCriticalState(); 462 463 void RemoveCallback(CallBackID callback, const sptr<DeathRecipient> &recipient, const wptr<IRemoteObject> &remote); 464 void RemoveSavedConfigCallback(const wptr<IRemoteObject>& callback); 465 void DeleteConnectionAndDeathRecipient( 466 const int32_t windowId, const sptr<AccessibilityWindowConnection> &connection); 467 468 void OnDeviceProvisioned(); 469 void InitializeShortKeyState(); 470 void RegisterProvisionCallback(); 471 void RegisterShortKeyEvent(); 472 bool IsNeedUnload(); 473 void OnScreenMagnificationStateChanged(); 474 void RegisterScreenMagnificationState(); 475 void OnScreenMagnificationTypeChanged(); 476 void RegisterScreenMagnificationType(); 477 478 void OnVoiceRecognitionChanged(); 479 void RegisterVoiceRecognitionState(); 480 void UpdateVoiceRecognitionState(); 481 void SubscribeOsAccount(); 482 void UnsubscribeOsAccount(); 483 484 int32_t ApplyTreeId(); 485 void RecycleTreeId(int32_t treeId); 486 std::shared_ptr<AccessibilityDatashareHelper> GetCurrentAcountDatashareHelper(); 487 void OnFocusedEvent(const AccessibilityEventInfo &eventInfo); 488 489 bool isReady_ = false; 490 bool isPublished_ = false; 491 std::map<int32_t, bool> dependentServicesStatus_; 492 int32_t currentAccountId_ = -1; 493 AccessibilityAccountDataMap a11yAccountsData_; 494 495 sptr<AccessibilityInputInterceptor> inputInterceptor_ = nullptr; 496 sptr<TouchEventInjector> touchEventInjector_ = nullptr; 497 sptr<KeyEventFilter> keyEventFilter_ = nullptr; 498 sptr<AccessibilityDumper> accessibilityDumper_ = nullptr; 499 500 std::shared_ptr<AppExecFwk::EventRunner> runner_; 501 std::shared_ptr<AAMSEventHandler> handler_; 502 503 std::shared_ptr<AppExecFwk::EventRunner> actionRunner_; 504 std::shared_ptr<AAMSEventHandler> actionHandler_; 505 506 std::shared_ptr<AppExecFwk::EventRunner> sendEventRunner_; 507 std::shared_ptr<AAMSEventHandler> sendEventHandler_; 508 509 std::shared_ptr<AppExecFwk::EventRunner> channelRunner_; 510 std::shared_ptr<AAMSEventHandler> channelHandler_; 511 512 std::shared_ptr<AppExecFwk::EventRunner> inputManagerRunner_; 513 std::shared_ptr<AppExecFwk::EventRunner> gestureRunner_; 514 515 std::shared_ptr<AppExecFwk::EventRunner> hoverEnterRunner_; 516 std::shared_ptr<AAMSEventHandler> hoverEnterHandler_; 517 518 int64_t ipcTimeoutNum_ = 0; // count ipc timeout number 519 520 sptr<IRemoteObject::DeathRecipient> stateObserversDeathRecipient_ = nullptr; 521 std::map<int32_t, sptr<IRemoteObject::DeathRecipient>> interactionOperationDeathRecipients_ {}; 522 std::map<int32_t, std::map<int32_t, sptr<IRemoteObject::DeathRecipient>>> interactionOperationDeathMap_ {}; 523 sptr<IRemoteObject::DeathRecipient> captionPropertyCallbackDeathRecipient_ = nullptr; 524 sptr<IRemoteObject::DeathRecipient> enableAbilityListsObserverDeathRecipient_ = nullptr; 525 sptr<IRemoteObject::DeathRecipient> configCallbackDeathRecipient_ = nullptr; 526 StateObservers stateObservers_; 527 ffrt::mutex mutex_; // current used for register state observer 528 std::vector<sptr<IAccessibleAbilityManagerConfigObserver>> defaultConfigCallbacks_; 529 std::shared_ptr<AccessibilitySettings> accessibilitySettings_ = nullptr; 530 std::shared_ptr<AccessibilityShortKey> accessibilityShortKey_ = nullptr; 531 std::vector<std::string> removedAutoStartAbilities_ {}; 532 SafeMap<int32_t, AccessibilityEventInfo> windowFocusEventMap_ {}; 533 534 std::map<int32_t, std::map<int32_t, std::set<int32_t>>> windowRequestIdMap_ {}; // windowId->treeId->requestId 535 std::map<int32_t, sptr<IAccessibilityElementOperatorCallback>> requestIdMap_ {}; // requestId->callback 536 537 std::bitset<TREE_ID_MAX> treeIdPool_; 538 int32_t preTreeId_ = -1; 539 ffrt::mutex treeIdPoolMutex_; 540 541 bool isSubscribeMSDPCallback_ = false; 542 ffrt::mutex subscribeMSDPMutex_; 543 std::shared_ptr<MagnificationManager> magnificationManager_ = nullptr; 544 bool isResourceInit_ = false; 545 std::shared_ptr<AccountSubscriber> accountSubscriber_ = nullptr; 546 }; 547 } // namespace Accessibility 548 } // namespace OHOS 549 #endif // ACCESSIBLE_ABILITY_MANAGER_SERVICE_H