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 <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_lite.h" 43 #include "accessibility_short_key.h" 44 45 namespace OHOS { 46 namespace Accessibility { 47 class AccessibilityAccountData; 48 class TouchEventInjector; 49 class AccessibilitySettings; 50 51 enum CallBackID { 52 STATE_CALLBACK, 53 CAPTION_PROPERTY_CALLBACK, 54 ENABLE_ABILITY_LISTS_CALLBACK, 55 CONFIG_CALLBACK 56 }; 57 58 constexpr int REQUEST_ID_INIT = 65535; 59 constexpr int32_t TREE_ID_MAX = 0x00001FFF; 60 61 const std::map<std::string, int32_t> AccessibilityConfigTable = { 62 {"HIGH_CONTRAST_TEXT", HIGH_CONTRAST_TEXT}, 63 {"INVERT_COLOR", INVERT_COLOR}, 64 {"DALTONIZATION_COLOR_FILTER", DALTONIZATION_COLOR_FILTER}, 65 {"CONTENT_TIMEOUT", CONTENT_TIMEOUT}, 66 {"ANIMATION_OFF", ANIMATION_OFF}, 67 {"BRIGHTNESS_DISCOUNT", BRIGHTNESS_DISCOUNT}, 68 {"AUDIO_MONO", AUDIO_MONO}, 69 {"AUDIO_BALANCE", AUDIO_BALANCE}, 70 {"MOUSE_KEY", MOUSE_KEY}, 71 {"CAPTION_STATE", CAPTION_STATE}, 72 {"CAPTION_STYLE", CAPTION_STYLE}, 73 {"SCREEN_MAGNIFICATION", SCREEN_MAGNIFICATION}, 74 {"MOUSE_AUTOCLICK", MOUSE_AUTOCLICK} 75 }; 76 77 class AccessibleAbilityManagerService : public SystemAbility, public AccessibleAbilityManagerServiceStub { 78 DECLARE_SINGLETON(AccessibleAbilityManagerService) 79 DECLEAR_SYSTEM_ABILITY(AccessibleAbilityManagerService) 80 public: 81 /* For system ability */ 82 void InitHandler(); 83 void InitActionHandler(); 84 void InitSendEventHandler(); 85 void InitChannelHandler(); 86 void OnStart() override; 87 void OnStop() override; 88 void OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override; 89 void OnRemoveSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override; 90 int Dump(int fd, const std::vector<std::u16string>& args) override; 91 void PostDelayUnloadTask() override; 92 93 public: 94 /* For AccessibleAbilityManagerServiceStub */ 95 RetError SendEvent(const AccessibilityEventInfo &uiEvent, const int32_t flag = 0) override; 96 97 RetError VerifyingToKenId(const int32_t windowId, const int64_t elementId); 98 99 uint32_t RegisterStateObserver(const sptr<IAccessibleAbilityManagerStateObserver> &callback) override; 100 101 uint32_t RegisterCaptionObserver(const sptr<IAccessibleAbilityManagerCaptionObserver> &callback) override; 102 103 void RegisterEnableAbilityListsObserver( 104 const sptr<IAccessibilityEnableAbilityListsObserver> &observer) override; 105 106 RetError GetAbilityList(const uint32_t abilityTypes, const int32_t stateType, 107 std::vector<AccessibilityAbilityInfo> &infos) override; 108 109 RetError RegisterElementOperator(const int32_t windowId, 110 const sptr<IAccessibilityElementOperator> &operation, bool isApp) override; 111 112 RetError RegisterElementOperator(Registration parameter, 113 const sptr<IAccessibilityElementOperator> &operation, bool isApp) override; 114 115 RetError DeregisterElementOperator(const int32_t windowId) override; 116 117 RetError DeregisterElementOperator(const int32_t windowId, const int32_t treeId) override; 118 119 RetError GetCaptionProperty(AccessibilityConfig::CaptionProperty &caption) override; 120 RetError SetCaptionProperty(const AccessibilityConfig::CaptionProperty &caption) override; 121 RetError SetCaptionState(const bool state) override; 122 123 bool GetEnabledState() override; 124 RetError GetCaptionState(bool &state) override; 125 bool GetTouchGuideState() override; 126 bool GetGestureState() override; 127 bool GetKeyEventObserverState() override; 128 129 RetError EnableAbility(const std::string &name, const uint32_t capabilities) override; 130 RetError GetEnabledAbilities(std::vector<std::string> &enabledAbilities) override; 131 RetError SetCurtainScreenUsingStatus(bool isEnable); 132 RetError DisableAbility(const std::string &name) override; 133 RetError EnableUITestAbility(const sptr<IRemoteObject>& obj) override; 134 RetError DisableUITestAbility() override; 135 int32_t GetActiveWindow() override; 136 void GetRealWindowAndElementId(int32_t& windowId, int64_t& elementId) override; 137 void GetSceneBoardInnerWinId(int32_t windowId, int64_t elementId, int32_t& innerWid) override; 138 bool FindFocusedElement(AccessibilityElementInfo &elementInfo); 139 bool ExecuteActionOnAccessibilityFocused(const ActionType &action); 140 RetError GetFocusedWindowId(int32_t &focusedWindowId) override; 141 void SetFocusWindowId(const int32_t focusWindowId); 142 void SetFocusElementId(const int64_t focusElementId); 143 int32_t GetFocusWindowId(); 144 int64_t GetFocusElementId(); 145 static int32_t GetTreeIdBySplitElementId(const int64_t elementId); 146 int64_t GetRootParentId(int32_t windowId, int32_t treeId) override; 147 RetError GetAllTreeId(int32_t windowId, std::vector<int32_t> &treeIds) override; 148 void SetTokenIdMapAndRootParentId(const sptr<AccessibilityWindowConnection> connection, 149 const int32_t treeId, const int64_t nodeId, const uint32_t tokenId); 150 void RemoveTreeDeathRecipient(const int32_t windowId, const int32_t treeId, 151 const sptr<AccessibilityWindowConnection> connection); 152 int32_t GenerateRequestId(); 153 void GetElementOperatorConnection(sptr<AccessibilityWindowConnection> &connection, 154 const int64_t elementId, sptr<IAccessibilityElementOperator> &elementOperator); 155 private: 156 int32_t focusWindowId_ = -1; 157 int64_t focusElementId_ = -1; 158 std::atomic<int> requestId_ = REQUEST_ID_INIT; 159 public: 160 /* For inner modules */ 161 bool EnableShortKeyTargetAbility(const std::string &name = ""); 162 bool DisableShortKeyTargetAbility(); 163 void OnShortKeyProcess(); 164 void UpdateShortKeyRegister(); 165 166 void SetTouchEventInjector(const sptr<TouchEventInjector> &touchEventInjector); 167 GetTouchEventInjector()168 inline sptr<TouchEventInjector> GetTouchEventInjector() 169 { 170 return touchEventInjector_; 171 } 172 GetKeyEventFilter()173 inline sptr<KeyEventFilter> GetKeyEventFilter() 174 { 175 return keyEventFilter_; 176 } 177 178 void SetKeyEventFilter(const sptr<KeyEventFilter> &keyEventFilter); 179 180 /* For DisplayResize */ 181 void NotifyDisplayResizeStateChanged(int32_t displayId, Rect& rect, float scale, float centerX, float centerY); 182 IsServiceReady()183 inline bool IsServiceReady() 184 { 185 return isReady_; 186 } 187 GetCurrentAccountId()188 inline int32_t GetCurrentAccountId() 189 { 190 return currentAccountId_; 191 } 192 GetMainHandler()193 inline std::shared_ptr<AAMSEventHandler> &GetMainHandler() 194 { 195 return handler_; 196 } 197 GetMainRunner()198 inline std::shared_ptr<AppExecFwk::EventRunner> &GetMainRunner() 199 { 200 return runner_; 201 } 202 GetChannelRunner()203 inline std::shared_ptr<AppExecFwk::EventRunner> &GetChannelRunner() 204 { 205 return channelRunner_; 206 } 207 208 sptr<AccessibilityAccountData> GetAccountData(int32_t accountId); 209 sptr<AccessibilityAccountData> GetCurrentAccountData(); 210 std::vector<int32_t> GetAllAccountIds(); 211 sptr<AppExecFwk::IBundleMgr> GetBundleMgrProxy(); 212 213 /* For common event */ 214 void AddedUser(int32_t accountId); 215 void RemovedUser(int32_t accountId); 216 void SwitchedUser(int32_t accountId); 217 void PackageChanged(const std::string &bundleName); 218 void PackageRemoved(const std::string &bundleName); 219 void PackageAdd(const std::string &bundleName); 220 221 void UpdateAccessibilityManagerService(); 222 void InsertWindowIdEventPair(int32_t windowId, const AccessibilityEventInfo &event); 223 bool CheckWindowIdEventExist(int32_t windowId); 224 bool CheckWindowRegister(int32_t windowId); 225 226 // used for arkui windowId 1 map to WMS windowId 227 void FindInnerWindowId(const AccessibilityEventInfo &event, int32_t& windowId); 228 bool GetParentElementRecursively(int32_t windowId, int64_t elementId, 229 std::vector<AccessibilityElementInfo>& infos); 230 231 // used for arkui windowId 1 map to WMS windowId 232 class ElementOperatorCallbackImpl : public AccessibilityElementOperatorCallbackStub { 233 public: 234 ElementOperatorCallbackImpl() = default; 235 ~ElementOperatorCallbackImpl() = default; 236 237 virtual void SetSearchElementInfoByAccessibilityIdResult(const std::vector<AccessibilityElementInfo> &infos, 238 const int32_t requestId) override; 239 virtual void SetSearchElementInfoByTextResult(const std::vector<AccessibilityElementInfo> &infos, 240 const int32_t requestId) override; 241 virtual void SetFindFocusedElementInfoResult(const AccessibilityElementInfo &info, 242 const int32_t requestId) override; 243 virtual void SetFocusMoveSearchResult(const AccessibilityElementInfo &info, const int32_t requestId) override; 244 virtual void SetExecuteActionResult(const bool succeeded, const int32_t requestId) override; 245 virtual void SetCursorPositionResult(const int32_t cursorPosition, const int32_t requestId) override; 246 247 private: 248 ffrt::promise<void> promise_; 249 bool executeActionResult_ = false; 250 AccessibilityElementInfo accessibilityInfoResult_ = {}; 251 std::vector<AccessibilityElementInfo> elementInfosResult_; 252 int32_t callCursorPosition_ = 0; 253 254 friend class AccessibleAbilityManagerService; 255 }; 256 257 RetError SetScreenMagnificationState(const bool state) override; 258 RetError SetShortKeyState(const bool state) override; 259 RetError SetMouseKeyState(const bool state) override; 260 RetError SetMouseAutoClick(const int32_t time) override; 261 RetError SetShortkeyTarget(const std::string &name) override; 262 RetError SetShortkeyMultiTarget(const std::vector<std::string> &name) override; 263 RetError SetHighContrastTextState(const bool state) override; 264 RetError SetInvertColorState(const bool state) override; 265 RetError SetAnimationOffState(const bool state) override; 266 RetError SetAudioMonoState(const bool state) override; 267 RetError SetDaltonizationState(const bool state) override; 268 RetError SetDaltonizationColorFilter(const uint32_t filter) override; 269 RetError SetContentTimeout(const uint32_t time) override; 270 RetError SetBrightnessDiscount(const float discount) override; 271 RetError SetAudioBalance(const float balance) override; 272 RetError SetClickResponseTime(const uint32_t time) override; 273 RetError SetIgnoreRepeatClickState(const bool state) override; 274 RetError SetIgnoreRepeatClickTime(const uint32_t time) override; 275 276 RetError GetScreenMagnificationState(bool &state) override; 277 RetError GetShortKeyState(bool &state) override; 278 RetError GetMouseKeyState(bool &state) override; 279 RetError GetMouseAutoClick(int32_t &time) override; 280 RetError GetShortkeyTarget(std::string &name) override; 281 RetError GetShortkeyMultiTarget(std::vector<std::string> &name) override; 282 RetError GetHighContrastTextState(bool &state) override; 283 RetError GetInvertColorState(bool &state) override; 284 RetError GetAnimationOffState(bool &state) override; 285 RetError GetAudioMonoState(bool &state) override; 286 RetError GetDaltonizationState(bool &state) override; 287 RetError GetDaltonizationColorFilter(uint32_t &type) override; 288 RetError GetContentTimeout(uint32_t &timer) override; 289 RetError GetBrightnessDiscount(float &brightness) override; 290 RetError GetAudioBalance(float &balance) override; 291 RetError GetClickResponseTime(uint32_t &time) override; 292 RetError GetIgnoreRepeatClickState(bool &state) override; 293 RetError GetIgnoreRepeatClickTime(uint32_t &time) override; 294 void GetAllConfigs(AccessibilityConfigData &configData) override; 295 296 uint32_t RegisterConfigObserver(const sptr<IAccessibleAbilityManagerConfigObserver> &callback) override; 297 void UpdateConfigState(); 298 void UpdateAudioBalance(); 299 void UpdateBrightnessDiscount(); 300 void UpdateContentTimeout(); 301 void UpdateDaltonizationColorFilter(); 302 void UpdateMouseAutoClick(); 303 void UpdateShortkeyTarget(); 304 void UpdateShortkeyMultiTarget(); 305 void UpdateClickResponseTime(); 306 void UpdateIgnoreRepeatClickTime(); 307 308 void UpdateInputFilter(); 309 void AddRequestId(int32_t windowId, int32_t treeId, int32_t requestId, 310 sptr<IAccessibilityElementOperatorCallback> callback); 311 void RemoveRequestId(int32_t requestId) override; 312 void OnDataClone(); 313 314 private: 315 void StopCallbackWait(int32_t windowId); 316 void StopCallbackWait(int32_t windowId, int32_t treeId); 317 RetError CheckCallingUid(); 318 sptr<AccessibilityWindowConnection> GetRealIdConnection(); 319 bool FindFocusedElementByConnection(sptr<AccessibilityWindowConnection> connection, 320 AccessibilityElementInfo &elementInfo); 321 bool SetTargetAbility(const int32_t targetAbilityValue); 322 RetError RegisterElementOperatorChildWork(const Registration ¶meter, const int32_t treeId, 323 const int64_t nodeId, const sptr<IAccessibilityElementOperator> &operation, 324 const uint32_t tokenId, bool isApp); 325 void IsCheckWindowIdEventExist(const int32_t windowId); 326 class StateCallbackDeathRecipient final : public IRemoteObject::DeathRecipient { 327 public: 328 StateCallbackDeathRecipient() = default; 329 ~StateCallbackDeathRecipient() final = default; 330 DISALLOW_COPY_AND_MOVE(StateCallbackDeathRecipient); 331 332 void OnRemoteDied(const wptr<IRemoteObject> &remote) final; 333 }; 334 335 class InteractionOperationDeathRecipient final : public IRemoteObject::DeathRecipient { 336 public: InteractionOperationDeathRecipient(int32_t windowId,int32_t accountId)337 InteractionOperationDeathRecipient(int32_t windowId, int32_t accountId) : windowId_(windowId), 338 accountId_(accountId) {}; InteractionOperationDeathRecipient(int32_t windowId,int32_t treeId,int32_t accountId)339 InteractionOperationDeathRecipient(int32_t windowId, int32_t treeId, int32_t accountId) : windowId_(windowId), 340 treeId_(treeId), accountId_(accountId) {}; 341 ~InteractionOperationDeathRecipient() final = default; 342 DISALLOW_COPY_AND_MOVE(InteractionOperationDeathRecipient); 343 344 void OnRemoteDied(const wptr<IRemoteObject> &remote) final; 345 int32_t windowId_ = INVALID_WINDOW_ID; 346 int32_t treeId_ = INVALID_TREE_ID; 347 int32_t accountId_ = 0; 348 }; 349 350 class CaptionPropertyCallbackDeathRecipient final : public IRemoteObject::DeathRecipient { 351 public: 352 CaptionPropertyCallbackDeathRecipient() = default; 353 ~CaptionPropertyCallbackDeathRecipient() final = default; 354 DISALLOW_COPY_AND_MOVE(CaptionPropertyCallbackDeathRecipient); 355 356 void OnRemoteDied(const wptr<IRemoteObject> &remote) final; 357 }; 358 359 class EnableAbilityListsObserverDeathRecipient final : public IRemoteObject::DeathRecipient { 360 public: 361 EnableAbilityListsObserverDeathRecipient() = default; 362 ~EnableAbilityListsObserverDeathRecipient() final = default; 363 DISALLOW_COPY_AND_MOVE(EnableAbilityListsObserverDeathRecipient); 364 365 void OnRemoteDied(const wptr<IRemoteObject> &remote) final; 366 }; 367 368 bool Init(); 369 void InitInnerResource(); 370 371 class ConfigCallbackDeathRecipient final : public IRemoteObject::DeathRecipient { 372 public: 373 ConfigCallbackDeathRecipient() = default; 374 ~ConfigCallbackDeathRecipient() final = default; 375 DISALLOW_COPY_AND_MOVE(ConfigCallbackDeathRecipient); 376 377 void OnRemoteDied(const wptr<IRemoteObject> &remote) final; 378 }; 379 380 class BundleManagerDeathRecipient final : public IRemoteObject::DeathRecipient { 381 public: 382 BundleManagerDeathRecipient() = default; 383 ~BundleManagerDeathRecipient() final = default; 384 DISALLOW_COPY_AND_MOVE(BundleManagerDeathRecipient); 385 386 void OnRemoteDied(const wptr<IRemoteObject> &remote) final; 387 }; 388 389 class StateObservers { 390 public: 391 StateObservers() = default; 392 ~StateObservers() = default; 393 void AddStateObserver(const sptr<IAccessibleAbilityManagerStateObserver>& stateObserver); 394 void OnStateObservers(uint32_t state); 395 void RemoveStateObserver(const wptr<IRemoteObject>& remote); 396 void Clear(); 397 private: 398 std::vector<sptr<IAccessibleAbilityManagerStateObserver>> observersList_; 399 ffrt::mutex stateObserversMutex_; 400 }; 401 402 RetError InnerEnableAbility(const std::string &name, const uint32_t capabilities); 403 RetError InnerDisableAbility(const std::string &name); 404 405 sptr<AccessibilityWindowConnection> GetAccessibilityWindowConnection(int32_t windowId); 406 void ClearFocus(int32_t windowId); 407 void OutsideTouch(int32_t windowId); 408 void UpdateAccessibilityWindowStateByEvent(const AccessibilityEventInfo &event); 409 410 void UpdateAccessibilityState(); 411 void UpdateCaptionProperty(); 412 void UpdateSettingsInAtoHosTask(); 413 void UpdateSettingsInAtoHos(); 414 void UpdateAutoStartAbilities(); 415 void UpdateAllSetting(); 416 417 void RemoveCallback(CallBackID callback, const sptr<DeathRecipient> &recipient, const wptr<IRemoteObject> &remote); 418 void RemoveSavedConfigCallback(const wptr<IRemoteObject>& callback); 419 void OnBundleManagerDied(const wptr<IRemoteObject> &remote); 420 void DeleteConnectionAndDeathRecipient( 421 const int32_t windowId, const sptr<AccessibilityWindowConnection> &connection); 422 423 void OnDeviceProvisioned(); 424 void InitializeShortKeyState(); 425 void RegisterProvisionCallback(); 426 void RegisterShortKeyEvent(); 427 bool IsNeedUnload(); 428 void OffZoomGesture(); 429 void OnScreenMagnificationStateChanged(); 430 void RegisterScreenMagnificationState(); 431 void OnScreenMagnificationTypeChanged(); 432 void RegisterScreenMagnificationType(); 433 434 int32_t ApplyTreeId(); 435 void RecycleTreeId(int32_t treeId); 436 437 bool isReady_ = false; 438 bool isPublished_ = false; 439 std::map<int32_t, bool> dependentServicesStatus_; 440 int32_t currentAccountId_ = -1; 441 AccessibilityAccountDataMap a11yAccountsData_; 442 sptr<AppExecFwk::IBundleMgr> bundleManager_ = nullptr; 443 444 sptr<AccessibilityInputInterceptor> inputInterceptor_ = nullptr; 445 sptr<TouchEventInjector> touchEventInjector_ = nullptr; 446 sptr<KeyEventFilter> keyEventFilter_ = nullptr; 447 sptr<AccessibilityDumper> accessibilityDumper_ = nullptr; 448 449 std::shared_ptr<AppExecFwk::EventRunner> runner_; 450 std::shared_ptr<AAMSEventHandler> handler_; 451 452 std::shared_ptr<AppExecFwk::EventRunner> actionRunner_; 453 std::shared_ptr<AAMSEventHandler> actionHandler_; 454 455 std::shared_ptr<AppExecFwk::EventRunner> sendEventRunner_; 456 std::shared_ptr<AAMSEventHandler> sendEventHandler_; 457 458 std::shared_ptr<AppExecFwk::EventRunner> channelRunner_; 459 std::shared_ptr<AAMSEventHandler> channelHandler_; 460 461 std::shared_ptr<AppExecFwk::EventRunner> hoverEnterRunner_; 462 std::shared_ptr<AAMSEventHandler> hoverEnterHandler_; 463 464 int64_t ipcTimeoutNum_ = 0; // count ipc timeout number 465 466 sptr<IRemoteObject::DeathRecipient> stateObserversDeathRecipient_ = nullptr; 467 std::map<int32_t, sptr<IRemoteObject::DeathRecipient>> interactionOperationDeathRecipients_ {}; 468 std::map<int32_t, std::map<int32_t, sptr<IRemoteObject::DeathRecipient>>> interactionOperationDeathMap_ {}; 469 sptr<IRemoteObject::DeathRecipient> captionPropertyCallbackDeathRecipient_ = nullptr; 470 sptr<IRemoteObject::DeathRecipient> enableAbilityListsObserverDeathRecipient_ = nullptr; 471 sptr<IRemoteObject::DeathRecipient> configCallbackDeathRecipient_ = nullptr; 472 sptr<IRemoteObject::DeathRecipient> bundleManagerDeathRecipient_ = nullptr; 473 StateObservers stateObservers_; 474 ffrt::mutex mutex_; // current used for register state observer 475 std::vector<sptr<IAccessibleAbilityManagerConfigObserver>> defaultConfigCallbacks_; 476 std::shared_ptr<AccessibilitySettings> accessibilitySettings_ = nullptr; 477 std::shared_ptr<AccessibilityShortKey> accessibilityShortKey_ = nullptr; 478 std::vector<std::string> removedAutoStartAbilities_ {}; 479 std::map<int32_t, AccessibilityEventInfo> windowFocusEventMap_ {}; 480 481 std::map<int32_t, std::map<int32_t, std::set<int32_t>>> windowRequestIdMap_ {}; // windowId->treeId->requestId 482 std::map<int32_t, sptr<IAccessibilityElementOperatorCallback>> requestIdMap_ {}; // requestId->callback 483 484 std::bitset<TREE_ID_MAX> treeIdPool_; 485 int32_t preTreeId_ = -1; 486 ffrt::mutex treeIdPoolMutex_; 487 }; 488 } // namespace Accessibility 489 } // namespace OHOS 490 #endif // ACCESSIBLE_ABILITY_MANAGER_SERVICE_H