无障碍服务支持动态启停

Signed-off-by: taojuncun <taojuncun@huawei.com>

common/interface/include/accessible_ability_manager_service_stub.h

@@ -179,6 +179,8 @@ private:
     ErrCode HandleGetSceneBoardInnerWinId(MessageParcel &data, MessageParcel &reply);
     ErrCode HandleGetFocusedWindowId(MessageParcel &data, MessageParcel &reply);
 
+    virtual void PostDelayUnloadTask() = 0;
+
     using AccessibilityAbilityManagerServiceFunc = ErrCode (AccessibleAbilityManagerServiceStub::*)(
         MessageParcel &data, MessageParcel &reply);
     std::map<uint32_t, AccessibilityAbilityManagerServiceFunc> memberFuncMap_;

common/interface/src/accessible_ability_manager_service_stub.cpp

@@ -197,6 +197,7 @@ int AccessibleAbilityManagerServiceStub::OnRemoteRequest(
     if (memFunc != memberFuncMap_.end()) {
         auto func = memFunc->second;
         if (func != nullptr) {
+            PostDelayUnloadTask(); // try to unload accessibility sa
             return (this->*func)(data, reply);
         }
     }

common/interface/test/fuzztest/accessibleabilitymanagerservicestub_fuzzer/accessibleabilitymanagerservicestub_fuzzer.cpp

@@ -115,6 +115,7 @@ public:
     void GetSceneBoardInnerWinId(int32_t windowId, int64_t elementId, int32_t& innerWid) override {}
     RetError GetFocusedWindowId(int32_t &focusedWindowId) override {return RET_OK;}
     uint32_t RegisterConfigObserver(const sptr<IAccessibleAbilityManagerConfigObserver> &callback) override {return 0;}
+    void PostDelayUnloadTask() override {}
 };
 
 uint32_t GetU32Data(const uint8_t* ptr)

frameworks/aafwk/include/accessible_ability_client_impl.h

@@ -20,10 +20,14 @@
 #include <deque>
 #include <memory>
 #include <mutex>
+#include <condition_variable>
 #include "accessible_ability_channel_client.h"
 #include "accessible_ability_client.h"
 #include "accessible_ability_client_stub.h"
 #include "i_accessible_ability_manager_service.h"
+#include "refbase.h"
+#include "system_ability_load_callback_stub.h"
+#include "system_ability_status_change_stub.h"
 
 namespace OHOS {
 namespace Accessibility {
@@ -343,6 +347,10 @@ public:
     void AddCacheByAce(int32_t windowId, int64_t elementId, std::vector<AccessibilityElementInfo>& elementInfos);
     void SortElementInfosIfNecessary(std::vector<AccessibilityElementInfo> &elementInfos);
 
+    bool LoadAccessibilityService();
+    void LoadSystemAbilitySuccess(const sptr<IRemoteObject> &remoteObject);
+    void LoadSystemAbilityFail();
+
 private:
     class ElementCacheInfo {
     public:
@@ -398,6 +406,19 @@ private:
         AccessibleAbilityClientImpl &client_;
     };
 
+    class AccessibilityLoadCallback : public SystemAbilityLoadCallbackStub {
+    public:
+        void OnLoadSystemAbilitySuccess(int32_t systemAbilityId,
+            const sptr<IRemoteObject> &remoteObject) override;
+        void OnLoadSystemAbilityFail(int32_t systemAbilityId) override;
+    };
+
+    class AccessibilitySaStatusChange : public SystemAbilityStatusChangeStub {
+    public:
+        void OnAddSystemAbility(int32_t saId, const std::string &deviceId) override;
+        void OnRemoveSystemAbility(int32_t saId, const std::string &deviceId) override;
+    };
+
     bool GetCacheElementInfo(const int32_t windowId,
         const int64_t elementId, AccessibilityElementInfo &elementInfo) const;
     void SetCacheElementInfo(const int32_t windowId,
@@ -405,7 +426,7 @@ private:
     RetError SearchElementInfoFromAce(const int32_t windowId, const int64_t elementId,
         const uint32_t mode, AccessibilityElementInfo &info);
     bool InitAccessibilityServiceProxy();
-    static void OnParameterChanged(const char *key, const char *value, void *context);
+    sptr<Accessibility::IAccessibleAbilityManagerService> GetServiceProxy();
 
     sptr<IRemoteObject::DeathRecipient> deathRecipient_ = nullptr;
     sptr<IRemoteObject::DeathRecipient> accessibilityServiceDeathRecipient_ = nullptr;
@@ -420,6 +441,9 @@ private:
     // used for query element info in batch
     ElementCacheInfo elementCacheInfo_;
     SceneBoardWindowElementMap windowElementMap_;
+
+    std::condition_variable proxyConVar_;
+    std::mutex conVarMutex_;
 };
 } // namespace Accessibility
 } // namespace OHOS

frameworks/aafwk/src/accessible_ability_client_impl.cpp

@@ -26,17 +26,17 @@
 #include "parameter.h"
 #include "system_ability_definition.h"
 
+
 namespace OHOS {
 namespace Accessibility {
 // tmp: wait for window registing when client connect done
 constexpr int WAIT_WINDOW_REGIST = 500;
 namespace {
-    const std::string SYSTEM_PARAMETER_AAMS_NAME = "accessibility.config.ready";
-    constexpr int32_t CONFIG_PARAMETER_VALUE_SIZE = 10;
     constexpr int64_t ROOT_NONE_ID = -1;
     constexpr int64_t NODE_ID_MAX = 0x7FFFFFFE;
     std::mutex g_Mutex;
     sptr<AccessibleAbilityClientImpl> g_Instance = nullptr;
+    constexpr int32_t SA_CONNECT_TIMEOUT = 500; // ms
 } // namespace
 
 sptr<AccessibleAbilityClient> AccessibleAbilityClient::GetInstance()
@@ -62,20 +62,15 @@ sptr<AccessibleAbilityClientImpl> AccessibleAbilityClientImpl::GetAbilityClientI
 AccessibleAbilityClientImpl::AccessibleAbilityClientImpl()
 {
     HILOG_DEBUG();
-    char value[CONFIG_PARAMETER_VALUE_SIZE] = "default";
-    int retSysParam = GetParameter(SYSTEM_PARAMETER_AAMS_NAME.c_str(), "false", value, CONFIG_PARAMETER_VALUE_SIZE);
-    if (retSysParam >= 0 && !std::strcmp(value, "true")) {
-        // Accessibility service is ready
-        if (!InitAccessibilityServiceProxy()) {
-            HILOG_ERROR("Init accessibility service proxy failed");
-        }
+    if (!InitAccessibilityServiceProxy()) {
+        HILOG_ERROR("Init accessibility service proxy failed");
     }
 
-    HILOG_DEBUG("Start watching accessibility service.");
-    retSysParam = WatchParameter(SYSTEM_PARAMETER_AAMS_NAME.c_str(),
-        &AccessibleAbilityClientImpl::OnParameterChanged, this);
-    if (retSysParam) {
-        HILOG_ERROR("Watch parameter failed, error = %{public}d", retSysParam);
+    sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+    sptr<AccessibilitySaStatusChange> statusChange = new AccessibilitySaStatusChange();
+    int32_t ret = samgr->SubscribeSystemAbility(ACCESSIBILITY_MANAGER_SERVICE_ID, statusChange);
+    if (ret != 0) {
+        HILOG_ERROR("subscribe accessibility failed, error = %{public}d", ret);
     }
 }
 
@@ -103,19 +98,12 @@ bool AccessibleAbilityClientImpl::InitAccessibilityServiceProxy()
     }
     HILOG_DEBUG("ISystemAbilityManager obtained");
 
-    sptr<IRemoteObject> object = samgr->GetSystemAbility(ACCESSIBILITY_MANAGER_SERVICE_ID);
-    if (!object) {
-        HILOG_ERROR("Get IAccessibleAbilityManagerService object from samgr failed");
+    sptr<IRemoteObject> object = samgr->CheckSystemAbility(ACCESSIBILITY_MANAGER_SERVICE_ID);
+    if (object == nullptr && LoadAccessibilityService() == false) {
         return false;
     }
     HILOG_DEBUG("Get remote object ok");
 
-    serviceProxy_ = iface_cast<IAccessibleAbilityManagerService>(object);
-    if (!serviceProxy_) {
-        HILOG_ERROR("Get aams proxy failed");
-        return false;
-    }
-
     // Add death recipient
     if (!accessibilityServiceDeathRecipient_) {
         accessibilityServiceDeathRecipient_ = new(std::nothrow) AccessibilityServiceDeathRecipient(*this);
@@ -125,40 +113,61 @@ bool AccessibleAbilityClientImpl::InitAccessibilityServiceProxy()
         }
     }
 
-    if (serviceProxy_->AsObject()) {
+    if (serviceProxy_ && serviceProxy_->AsObject()) {
         HILOG_DEBUG("Add death recipient");
         serviceProxy_->AsObject()->AddDeathRecipient(accessibilityServiceDeathRecipient_);
+        return true;
+    }
+    return false;
+}
+
+sptr<Accessibility::IAccessibleAbilityManagerService> AccessibleAbilityClientImpl::GetServiceProxy()
+{
+    if (serviceProxy_ || LoadAccessibilityService()) {
+        return serviceProxy_;
+    }
+    return nullptr;
+}
+
+bool AccessibleAbilityClientImpl::LoadAccessibilityService()
+{
+    std::unique_lock<std::mutex> lock(conVarMutex_);
+    sptr<AccessibilityLoadCallback> loadCallback = new AccessibilityLoadCallback();
+    if (loadCallback == nullptr) {
+        return false;
+    }
+    auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+    if (samgr == nullptr) {
+        return false;
+    }
+    int32_t ret = samgr->LoadSystemAbility(ACCESSIBILITY_MANAGER_SERVICE_ID, loadCallback);
+    if (ret != 0) {
+        return false;
+    }
+    auto waitStatus = proxyConVar_.wait_for(lock, std::chrono::milliseconds(SA_CONNECT_TIMEOUT),
+        [=]() { return serviceProxy_ != nullptr; });
+    if (!waitStatus) {
+        return false;
     }
     return true;
 }
 
-void AccessibleAbilityClientImpl::OnParameterChanged(const char *key, const char *value, void *context)
+void AccessibleAbilityClientImpl::LoadSystemAbilitySuccess(const sptr<IRemoteObject> &remoteObject)
 {
-    HILOG_DEBUG("Parameter key = [%{public}s] value = [%{public}s]", key, value);
-
-    if (!key || std::strcmp(key, SYSTEM_PARAMETER_AAMS_NAME.c_str())) {
-        HILOG_WARN("not accessibility.config.ready callback");
-        return;
+    std::lock_guard<std::mutex> lock(conVarMutex_);
+    if (remoteObject != nullptr) {
+        serviceProxy_ = iface_cast<IAccessibleAbilityManagerService>(remoteObject);
+    } else {
+        serviceProxy_ = nullptr;
     }
+    proxyConVar_.notify_one();
+}
 
-    if (!value || std::strcmp(value, "true")) {
-        HILOG_WARN("accessibility.config.ready value not true");
-        return;
-    }
-
-    if (!context) {
-        HILOG_ERROR("accessibility.config.ready context NULL");
-        return;
-    }
-
-    AccessibleAbilityClientImpl* implPtr = static_cast<AccessibleAbilityClientImpl*>(context);
-    {
-        HILOG_DEBUG("ConnectToService start.");
-        std::lock_guard<std::mutex> lock(implPtr->mutex_);
-        if (implPtr->InitAccessibilityServiceProxy()) {
-            HILOG_DEBUG("ConnectToService Success");
-        }
-    }
+void AccessibleAbilityClientImpl::LoadSystemAbilityFail()
+{
+    std::lock_guard<std::mutex> lock(conVarMutex_);
+    serviceProxy_ = nullptr;
+    proxyConVar_.notify_one();
 }
 
 sptr<IRemoteObject> AccessibleAbilityClientImpl::GetRemoteObject()
@@ -374,7 +383,7 @@ RetError AccessibleAbilityClientImpl::GetRoot(AccessibilityElementInfo &elementI
     }
 
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!serviceProxy_ && !LoadAccessibilityService()) {
         HILOG_ERROR("Failed to connect to aams");
         return RET_ERR_SAMGR;
     }
@@ -449,7 +458,7 @@ RetError AccessibleAbilityClientImpl::GetRootBatch(std::vector<AccessibilityElem
         return RET_ERR_NO_CONNECTION;
     }
 
-    if (!serviceProxy_) {
+    if (!serviceProxy_ && !LoadAccessibilityService()) {
         HILOG_ERROR("failed to connect to aams");
         return RET_ERR_SAMGR;
     }
@@ -526,7 +535,7 @@ RetError AccessibleAbilityClientImpl::GetRootByWindowBatch(const AccessibilityWi
     }
 
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!serviceProxy_ && !LoadAccessibilityService()) {
         HILOG_ERROR("failed to connect to aams");
         return RET_ERR_SAMGR;
     }
@@ -764,7 +773,7 @@ RetError AccessibleAbilityClientImpl::GetByElementId(const int64_t elementId,
     }
 
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!serviceProxy_ && !LoadAccessibilityService()) {
         HILOG_ERROR("failed to connect to aams");
         return RET_ERR_SAMGR;
     }
@@ -992,7 +1001,7 @@ RetError AccessibleAbilityClientImpl::SearchElementInfoByInspectorKey(const std:
     }
 
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!serviceProxy_ && !LoadAccessibilityService()) {
         HILOG_ERROR("Failed to connect to aams");
         return RET_ERR_SAMGR;
     }
@@ -1032,7 +1041,7 @@ RetError AccessibleAbilityClientImpl::Connect()
 {
     HILOG_DEBUG();
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!serviceProxy_ && !LoadAccessibilityService()) {
         HILOG_ERROR("Failed to get aams service");
         return RET_ERR_SAMGR;
     }
@@ -1044,7 +1053,7 @@ RetError AccessibleAbilityClientImpl::Disconnect()
 {
     HILOG_DEBUG();
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!serviceProxy_ && !LoadAccessibilityService()) {
         HILOG_ERROR("Failed to get aams service");
         return RET_ERR_SAMGR;
     }
@@ -1352,5 +1361,38 @@ void AccessibleAbilityClientImpl::SceneBoardWindowElementMap::RemovePairByWindow
     std::lock_guard<std::mutex> lock(mapMutex_);
     windowElementMap_.erase(windowId);
 }
+
+void AccessibleAbilityClientImpl::AccessibilityLoadCallback::OnLoadSystemAbilitySuccess(int32_t systemAbilityId,
+    const sptr<IRemoteObject> &remoteObject)
+{
+    if (AccessibleAbilityClientImpl::GetAbilityClientImplement()) {
+        AccessibleAbilityClientImpl::GetAbilityClientImplement()->LoadSystemAbilitySuccess(remoteObject);
+    }
+}
+
+void AccessibleAbilityClientImpl::AccessibilityLoadCallback::OnLoadSystemAbilityFail(int32_t systemAbilityId)
+{
+    if (AccessibleAbilityClientImpl::GetAbilityClientImplement()) {
+        AccessibleAbilityClientImpl::GetAbilityClientImplement()->LoadSystemAbilityFail();
+    }
+}
+
+void AccessibleAbilityClientImpl::AccessibilitySaStatusChange::OnAddSystemAbility(int32_t saId,
+    const std::string &deviceId)
+{
+    if (AccessibleAbilityClientImpl::GetAbilityClientImplement() &&
+        AccessibleAbilityClientImpl::GetAbilityClientImplement()->InitAccessibilityServiceProxy()) {
+        HILOG_DEBUG("Connect to accessibility service success");
+    }
+}
+
+void AccessibleAbilityClientImpl::AccessibilitySaStatusChange::OnRemoveSystemAbility(int32_t saId,
+    const std::string &deviceId)
+{
+    HILOG_DEBUG("Disconnect to accessibility service");
+    if (AccessibleAbilityClientImpl::GetAbilityClientImplement()) {
+        AccessibleAbilityClientImpl::GetAbilityClientImplement()->SetConnectionState(false);
+    }
+}
 } // namespace Accessibility
 } // namespace OHOS

frameworks/acfwk/include/accessibility_config_impl.h

@@ -17,12 +17,16 @@
 #define ACCESSIBILITY_CONFIG_IMPL_H
 
 #include <mutex>
+#include <condition_variable>
 #include "accessibility_config.h"
 #include "accessibility_enable_ability_lists_observer_stub.h"
 #include "accessible_ability_manager_caption_observer_stub.h"
 #include "accessible_ability_manager_config_observer_stub.h"
 #include "accessible_ability_manager_service_proxy.h"
 #include "event_handler.h"
+#include "refbase.h"
+#include "system_ability_load_callback_stub.h"
+#include "system_ability_status_change_stub.h"
 
 namespace OHOS {
 namespace AccessibilityConfig {
@@ -103,6 +107,10 @@ public:
     void OnAccessibilityEnableAbilityListsChanged();
     void OnAccessibilityInstallAbilityListsChanged();
 
+    void SetInitializeFlag(bool flag)
+    {
+        isInitialized_ = flag;
+    }
 private:
     class AccessibilityEnableAbilityListsObserverImpl :
         public Accessibility::AccessibilityEnableAbilityListsObserverStub {
@@ -139,6 +147,27 @@ private:
         Impl &config_;
     };
 
+    class AccessibilityLoadCallback : public SystemAbilityLoadCallbackStub {
+    public:
+        explicit AccessibilityLoadCallback(Impl* config) : config_(config) {}
+        ~AccessibilityLoadCallback() = default;
+        void OnLoadSystemAbilitySuccess(int32_t systemAbilityId,
+            const sptr<IRemoteObject> &remoteObject) override;
+        void OnLoadSystemAbilityFail(int32_t systemAbilityId) override;
+    private:
+        Impl* config_ = nullptr;
+    };
+
+    class AccessibilitySaStatusChange : public SystemAbilityStatusChangeStub {
+    public:
+        explicit AccessibilitySaStatusChange(Impl* config) : config_(config) {}
+        ~AccessibilitySaStatusChange() = default;
+        void OnAddSystemAbility(int32_t saId, const std::string &deviceId) override;
+        void OnRemoveSystemAbility(int32_t saId, const std::string &deviceId) override;
+    private:
+        Impl* config_ = nullptr;
+    };
+
     class AccessibleAbilityManagerConfigObserverImpl
         : public Accessibility::AccessibleAbilityManagerConfigObserverStub {
     public:
@@ -210,6 +239,11 @@ private:
     bool RegisterToService();
     bool InitAccessibilityServiceProxy();
 
+    bool LoadAccessibilityService();
+    void LoadSystemAbilitySuccess(const sptr<IRemoteObject> &remoteObject);
+    void LoadSystemAbilityFail();
+    sptr<Accessibility::IAccessibleAbilityManagerService> GetServiceProxy();
+
     void NotifyCaptionStateChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
         const bool state);
     void NotifyCaptionChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
@@ -309,6 +343,9 @@ private:
 
     std::shared_ptr<AppExecFwk::EventRunner> runner_;
     std::shared_ptr<AppExecFwk::EventHandler> handler_;
+
+    std::condition_variable proxyConVar_;
+    std::mutex conVarMutex_; // mutex for proxyConVar
 };
 } // namespace AccessibilityConfig
 } // namespace OHOS

frameworks/acfwk/src/accessibility_config_impl.cpp

@@ -23,9 +23,8 @@
 namespace OHOS {
 namespace AccessibilityConfig {
 namespace {
-    const std::string SYSTEM_PARAMETER_AAMS_NAME = "accessibility.config.ready";
-    constexpr int32_t CONFIG_PARAMETER_VALUE_SIZE = 10;
-} // namespace
+    constexpr int32_t SA_CONNECT_TIMEOUT = 500; // ms
+}
 
 AccessibilityConfig::Impl::Impl()
 {}
@@ -33,63 +32,31 @@ AccessibilityConfig::Impl::Impl()
 bool AccessibilityConfig::Impl::InitializeContext()
 {
     HILOG_DEBUG();
-    std::lock_guard<std::mutex> lock(mutex_);
     if (isInitialized_) {
         HILOG_DEBUG("Context has initialized");
         return true;
     }
     isInitialized_ = ConnectToService();
-
     return isInitialized_;
 }
 
-void AccessibilityConfig::Impl::OnParameterChanged(const char *key, const char *value, void *context)
-{
-    HILOG_DEBUG("Parameter key = [%{public}s] value = [%{public}s]", key, value);
-
-    if (!key || std::strcmp(key, SYSTEM_PARAMETER_AAMS_NAME.c_str())) {
-        HILOG_WARN("not accessibility.config.ready callback");
-        return;
-    }
-
-    if (!value || std::strcmp(value, "true")) {
-        HILOG_WARN("accessibility.config.ready value not true");
-        return;
-    }
-
-    if (!context) {
-        HILOG_ERROR("accessibility.config.ready context NULL");
-        return;
-    }
-
-    Impl* implPtr = static_cast<Impl*>(context);
-    (void)implPtr->ConnectToServiceAsync();
-}
-
 bool AccessibilityConfig::Impl::ConnectToService()
 {
-    char value[CONFIG_PARAMETER_VALUE_SIZE] = "default";
-    int retSysParam = GetParameter(SYSTEM_PARAMETER_AAMS_NAME.c_str(), "false", value, CONFIG_PARAMETER_VALUE_SIZE);
-    if (retSysParam >= 0 && !std::strcmp(value, "true")) {
-        // Accessibility service is ready
-        if (!InitAccessibilityServiceProxy()) {
-            return false;
-        }
-
-        if (!RegisterToService()) {
-            return false;
-        }
-
-        InitConfigValues();
-    } else {
-        HILOG_DEBUG("Start watching accessibility service.");
-        retSysParam = WatchParameter(SYSTEM_PARAMETER_AAMS_NAME.c_str(), &OnParameterChanged, this);
-        if (retSysParam) {
-            HILOG_ERROR("Watch parameter failed, error = %{public}d", retSysParam);
-            return false;
-        }
+    std::lock_guard<std::mutex> lock(mutex_);
+    auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+    if (samgr == nullptr) {
+        return false;
+    }
+    if (InitAccessibilityServiceProxy() && RegisterToService()) {
+        InitConfigValues();
+        return true;
+    }
+    sptr<AccessibilitySaStatusChange> statusChange = new AccessibilitySaStatusChange(this);
+    int32_t ret = samgr->SubscribeSystemAbility(ACCESSIBILITY_MANAGER_SERVICE_ID, statusChange);
+    if (ret != 0) {
+        HILOG_ERROR("subscribe accessibility failed, error = %{public}d", ret);
+        return false;
     }
-
     return true;
 }
 
@@ -100,6 +67,7 @@ bool AccessibilityConfig::Impl::ConnectToServiceAsync()
     if (InitAccessibilityServiceProxy()) {
         (void)RegisterToService();
         InitConfigValues();
+        isInitialized_ = true;
         return true;
     } else {
         HILOG_ERROR("ConnectToServiceAsync fail");
@@ -107,6 +75,101 @@ bool AccessibilityConfig::Impl::ConnectToServiceAsync()
     }
 }
 
+bool AccessibilityConfig::Impl::InitAccessibilityServiceProxy()
+{
+    HILOG_DEBUG();
+    if (serviceProxy_) {
+        return true;
+    }
+    auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+    if (samgr == nullptr) {
+        return false;
+    }
+    auto object = samgr->CheckSystemAbility(ACCESSIBILITY_MANAGER_SERVICE_ID);
+    if (object != nullptr) {
+        if (!deathRecipient_) {
+            deathRecipient_ = new(std::nothrow) DeathRecipient(*this);
+            if (!deathRecipient_) {
+                HILOG_ERROR("create deathRecipient_ fail");
+                return false;
+            }
+        }
+
+        if (object->IsProxyObject() && !object->AddDeathRecipient(deathRecipient_)) {
+            HILOG_ERROR("Failed to add death recipient");
+        }
+
+        serviceProxy_ = iface_cast<Accessibility::IAccessibleAbilityManagerService>(object);
+        if (!serviceProxy_) {
+            HILOG_ERROR("IAccessibleAbilityManagerService iface_cast failed");
+            return false;
+        }
+        HILOG_DEBUG("InitAccessibilityServiceProxy success");
+        return true;
+    } else {
+        if (LoadAccessibilityService()) {
+            isInitialized_ = true;
+            HILOG_DEBUG("InitAccessibilityServiceProxy success");
+            return true;
+        } else {
+            return false;
+        }
+    }
+    return true;
+}
+
+bool AccessibilityConfig::Impl::LoadAccessibilityService()
+{
+    std::unique_lock<std::mutex> lock(conVarMutex_);
+    sptr<AccessibilityLoadCallback> loadCallback = new AccessibilityLoadCallback(this);
+    if (loadCallback == nullptr) {
+        return false;
+    }
+    auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+    if (samgr == nullptr) {
+        return false;
+    }
+    int32_t ret = samgr->LoadSystemAbility(ACCESSIBILITY_MANAGER_SERVICE_ID, loadCallback);
+    if (ret != 0) {
+        return false;
+    }
+    auto waitStatus = proxyConVar_.wait_for(lock, std::chrono::milliseconds(SA_CONNECT_TIMEOUT),
+        [=]() { return serviceProxy_ != nullptr; });
+    if (!waitStatus) {
+        return false;
+    }
+    (void)RegisterToService();
+    InitConfigValues();
+    return true;
+}
+
+void AccessibilityConfig::Impl::LoadSystemAbilitySuccess(const sptr<IRemoteObject> &remoteObject)
+{
+    std::lock_guard<std::mutex> lock(conVarMutex_);
+    if (remoteObject != nullptr) {
+        serviceProxy_ = iface_cast<Accessibility::IAccessibleAbilityManagerService>(remoteObject);
+        if (!deathRecipient_) {
+            deathRecipient_ = new(std::nothrow) DeathRecipient(*this);
+            if (!deathRecipient_) {
+                HILOG_ERROR("create deathRecipient_ fail.");
+            }
+        }
+        if (remoteObject->IsProxyObject() && remoteObject->AddDeathRecipient(deathRecipient_)) {
+            HILOG_DEBUG("successed to add death recipient");
+        }
+    } else {
+        serviceProxy_ = nullptr;
+    }
+    proxyConVar_.notify_one();
+}
+
+void AccessibilityConfig::Impl::LoadSystemAbilityFail()
+{
+    std::lock_guard<std::mutex> lock(conVarMutex_);
+    serviceProxy_ = nullptr;
+    proxyConVar_.notify_one();
+}
+
 bool AccessibilityConfig::Impl::RegisterToService()
 {
     if (!serviceProxy_) {
@@ -158,46 +221,12 @@ bool AccessibilityConfig::Impl::RegisterToService()
     return true;
 }
 
-bool AccessibilityConfig::Impl::InitAccessibilityServiceProxy()
+sptr<Accessibility::IAccessibleAbilityManagerService> AccessibilityConfig::Impl::GetServiceProxy()
 {
-    if (serviceProxy_) {
-        HILOG_DEBUG("Accessibility Service is connected");
-        return true;
+    if (serviceProxy_ || LoadAccessibilityService()) {
+        return serviceProxy_;
     }
-
-    sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    if (!samgr) {
-        HILOG_ERROR("Failed to get ISystemAbilityManager");
-        return false;
-    }
-
-    sptr<IRemoteObject> object = samgr->GetSystemAbility(ACCESSIBILITY_MANAGER_SERVICE_ID);
-    if (!object) {
-        HILOG_ERROR("Get IAccessibleAbilityManagerService object from samgr failed");
-        return false;
-    }
-
-    if (!deathRecipient_) {
-        deathRecipient_ = new(std::nothrow) DeathRecipient(*this);
-        if (!deathRecipient_) {
-            HILOG_ERROR("Create deathRecipient_ fail.");
-            return false;
-        }
-    }
-
-    if ((object->IsProxyObject()) && (!object->AddDeathRecipient(deathRecipient_))) {
-        HILOG_ERROR("Failed to add death recipient");
-        return false;
-    }
-
-    serviceProxy_ = iface_cast<Accessibility::IAccessibleAbilityManagerService>(object);
-    if (!serviceProxy_) {
-        HILOG_ERROR("IAccessibleAbilityManagerService iface_cast failed");
-        return false;
-    }
-
-    HILOG_DEBUG("InitAccessibilityServiceProxy success");
-    return true;
+    return nullptr;
 }
 
 void AccessibilityConfig::Impl::ResetService(const wptr<IRemoteObject> &remote)
@@ -221,32 +250,32 @@ Accessibility::RetError AccessibilityConfig::Impl::EnableAbility(const std::stri
 {
     HILOG_INFO("name = [%{private}s] capabilities = [%{private}u]", name.c_str(), capabilities);
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
-    return serviceProxy_->EnableAbility(name, capabilities);
+    return GetServiceProxy()->EnableAbility(name, capabilities);
 }
 
 Accessibility::RetError AccessibilityConfig::Impl::DisableAbility(const std::string &name)
 {
     HILOG_INFO("name = [%{private}s]", name.c_str());
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
-    return serviceProxy_->DisableAbility(name);
+    return GetServiceProxy()->DisableAbility(name);
 }
 
 Accessibility::RetError AccessibilityConfig::Impl::GetCaptionsState(bool &state)
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
-    Accessibility::RetError ret = serviceProxy_->GetCaptionState(state);
+    Accessibility::RetError ret = GetServiceProxy()->GetCaptionState(state);
     HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
     return ret;
 }
@@ -254,11 +283,11 @@ Accessibility::RetError AccessibilityConfig::Impl::GetCaptionsState(bool &state)
 Accessibility::RetError AccessibilityConfig::Impl::GetCaptionsProperty(CaptionProperty &caption)
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
-    Accessibility::RetError ret = serviceProxy_->GetCaptionProperty(caption);
+    Accessibility::RetError ret = GetServiceProxy()->GetCaptionProperty(caption);
     HILOG_INFO();
     return ret;
 }
@@ -267,22 +296,22 @@ Accessibility::RetError AccessibilityConfig::Impl::SetCaptionsProperty(const Cap
 {
     HILOG_INFO();
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
-    return serviceProxy_->SetCaptionProperty(caption);
+    return GetServiceProxy()->SetCaptionProperty(caption);
 }
 
 Accessibility::RetError AccessibilityConfig::Impl::SetCaptionsState(const bool state)
 {
     HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
-    return serviceProxy_->SetCaptionState(state);
+    return GetServiceProxy()->SetCaptionState(state);
 }
 
 void AccessibilityConfig::Impl::NotifyCaptionStateChanged(
@@ -390,44 +419,44 @@ Accessibility::RetError AccessibilityConfig::Impl::SetScreenMagnificationState(c
 {
     HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
-    return serviceProxy_->SetScreenMagnificationState(state);
+    return GetServiceProxy()->SetScreenMagnificationState(state);
 }
 
 Accessibility::RetError AccessibilityConfig::Impl::SetShortKeyState(const bool state)
 {
     HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
-    return serviceProxy_->SetShortKeyState(state);
+    return GetServiceProxy()->SetShortKeyState(state);
 }
 
 Accessibility::RetError AccessibilityConfig::Impl::SetMouseKeyState(const bool state)
 {
     HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
-    return serviceProxy_->SetMouseKeyState(state);
+    return GetServiceProxy()->SetMouseKeyState(state);
 }
 
 Accessibility::RetError AccessibilityConfig::Impl::GetScreenMagnificationState(bool &state)
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
 
-    Accessibility::RetError ret = serviceProxy_->GetScreenMagnificationState(state);
+    Accessibility::RetError ret = GetServiceProxy()->GetScreenMagnificationState(state);
     HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
     return ret;
 }
@@ -435,12 +464,12 @@ Accessibility::RetError AccessibilityConfig::Impl::GetScreenMagnificationState(b
 Accessibility::RetError AccessibilityConfig::Impl::GetShortKeyState(bool &state)
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
 
-    Accessibility::RetError ret = serviceProxy_->GetShortKeyState(state);
+    Accessibility::RetError ret = GetServiceProxy()->GetShortKeyState(state);
     HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
     return ret;
 }
@@ -448,12 +477,12 @@ Accessibility::RetError AccessibilityConfig::Impl::GetShortKeyState(bool &state)
 Accessibility::RetError AccessibilityConfig::Impl::GetMouseKeyState(bool &state)
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
 
-    Accessibility::RetError ret = serviceProxy_->GetMouseKeyState(state);
+    Accessibility::RetError ret = GetServiceProxy()->GetMouseKeyState(state);
     HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
     return ret;
 }
@@ -782,44 +811,44 @@ Accessibility::RetError AccessibilityConfig::Impl::SetMouseAutoClick(const int32
 {
     HILOG_INFO("time = [%{public}d]", time);
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
-    return serviceProxy_->SetMouseAutoClick(time);
+    return GetServiceProxy()->SetMouseAutoClick(time);
 }
 
 Accessibility::RetError AccessibilityConfig::Impl::SetShortkeyTarget(const std::string& name)
 {
     HILOG_INFO("name = [%{public}s]", name.c_str());
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
-    return serviceProxy_->SetShortkeyTarget(name);
+    return GetServiceProxy()->SetShortkeyTarget(name);
 }
 
 Accessibility::RetError AccessibilityConfig::Impl::SetShortkeyMultiTarget(const std::vector<std::string>& name)
 {
     HILOG_INFO("start");
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
-    return serviceProxy_->SetShortkeyMultiTarget(name);
+    return GetServiceProxy()->SetShortkeyMultiTarget(name);
 }
 
 Accessibility::RetError AccessibilityConfig::Impl::GetMouseAutoClick(int32_t &time)
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
 
-    Accessibility::RetError ret = serviceProxy_->GetMouseAutoClick(time);
+    Accessibility::RetError ret = GetServiceProxy()->GetMouseAutoClick(time);
     HILOG_INFO("time = [%{public}d]", time);
     return ret;
 }
@@ -827,12 +856,12 @@ Accessibility::RetError AccessibilityConfig::Impl::GetMouseAutoClick(int32_t &ti
 Accessibility::RetError AccessibilityConfig::Impl::GetShortkeyTarget(std::string &name)
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
 
-    Accessibility::RetError ret = serviceProxy_->GetShortkeyTarget(name);
+    Accessibility::RetError ret = GetServiceProxy()->GetShortkeyTarget(name);
     HILOG_INFO("name = [%{public}s]", name.c_str());
     return ret;
 }
@@ -840,12 +869,12 @@ Accessibility::RetError AccessibilityConfig::Impl::GetShortkeyTarget(std::string
 Accessibility::RetError AccessibilityConfig::Impl::GetShortkeyMultiTarget(std::vector<std::string> &name)
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
 
-    Accessibility::RetError ret = serviceProxy_->GetShortkeyMultiTarget(name);
+    Accessibility::RetError ret = GetServiceProxy()->GetShortkeyMultiTarget(name);
     return ret;
 }
 
@@ -1010,143 +1039,143 @@ Accessibility::RetError AccessibilityConfig::Impl::SetHighContrastTextState(cons
 {
     HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
-    return serviceProxy_->SetHighContrastTextState(state);
+    return GetServiceProxy()->SetHighContrastTextState(state);
 }
 
 Accessibility::RetError AccessibilityConfig::Impl::SetInvertColorState(const bool state)
 {
     HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
-    return serviceProxy_->SetInvertColorState(state);
+    return GetServiceProxy()->SetInvertColorState(state);
 }
 
 Accessibility::RetError AccessibilityConfig::Impl::SetDaltonizationState(const bool state)
 {
     HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
-    return serviceProxy_->SetDaltonizationState(state);
+    return GetServiceProxy()->SetDaltonizationState(state);
 }
 
 Accessibility::RetError AccessibilityConfig::Impl::SetDaltonizationColorFilter(const DALTONIZATION_TYPE type)
 {
     HILOG_INFO("type = [%{public}u]", static_cast<uint32_t>(type));
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
-    return serviceProxy_->SetDaltonizationColorFilter(type);
+    return GetServiceProxy()->SetDaltonizationColorFilter(type);
 }
 
 Accessibility::RetError AccessibilityConfig::Impl::SetContentTimeout(const uint32_t timer)
 {
     HILOG_INFO("timer = [%{public}u]", timer);
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
-    return serviceProxy_->SetContentTimeout(timer);
+    return GetServiceProxy()->SetContentTimeout(timer);
 }
 
 Accessibility::RetError AccessibilityConfig::Impl::SetAnimationOffState(const bool state)
 {
     HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
-    return serviceProxy_->SetAnimationOffState(state);
+    return GetServiceProxy()->SetAnimationOffState(state);
 }
 
 Accessibility::RetError AccessibilityConfig::Impl::SetBrightnessDiscount(const float brightness)
 {
     HILOG_INFO("brightness = [%{public}f]", brightness);
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
-    return serviceProxy_->SetBrightnessDiscount(brightness);
+    return GetServiceProxy()->SetBrightnessDiscount(brightness);
 }
 
 Accessibility::RetError AccessibilityConfig::Impl::SetAudioMonoState(const bool state)
 {
     HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
-    return serviceProxy_->SetAudioMonoState(state);
+    return GetServiceProxy()->SetAudioMonoState(state);
 }
 
 Accessibility::RetError AccessibilityConfig::Impl::SetAudioBalance(const float balance)
 {
     HILOG_INFO("balance = [%{public}f]", balance);
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
-    return serviceProxy_->SetAudioBalance(balance);
+    return GetServiceProxy()->SetAudioBalance(balance);
 }
 
 Accessibility::RetError AccessibilityConfig::Impl::SetClickResponseTime(const CLICK_RESPONSE_TIME time)
 {
     HILOG_INFO("click response time = [%{public}u]", time);
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
-    return serviceProxy_->SetClickResponseTime(time);
+    return GetServiceProxy()->SetClickResponseTime(time);
 }
 
 Accessibility::RetError AccessibilityConfig::Impl::SetIgnoreRepeatClickState(const bool state)
 {
     HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
-    return serviceProxy_->SetIgnoreRepeatClickState(state);
+    return GetServiceProxy()->SetIgnoreRepeatClickState(state);
 }
 
 Accessibility::RetError AccessibilityConfig::Impl::SetIgnoreRepeatClickTime(const IGNORE_REPEAT_CLICK_TIME time)
 {
     HILOG_INFO("ignore repeat click time = [%{public}u]", time);
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
-    return serviceProxy_->SetIgnoreRepeatClickTime(time);
+    return GetServiceProxy()->SetIgnoreRepeatClickTime(time);
 }
 
 Accessibility::RetError AccessibilityConfig::Impl::GetInvertColorState(bool &state)
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
 
-    Accessibility::RetError ret = serviceProxy_->GetInvertColorState(state);
+    Accessibility::RetError ret = GetServiceProxy()->GetInvertColorState(state);
     HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
     return ret;
 }
@@ -1154,12 +1183,12 @@ Accessibility::RetError AccessibilityConfig::Impl::GetInvertColorState(bool &sta
 Accessibility::RetError AccessibilityConfig::Impl::GetHighContrastTextState(bool &state)
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
 
-    Accessibility::RetError ret = serviceProxy_->GetHighContrastTextState(state);
+    Accessibility::RetError ret = GetServiceProxy()->GetHighContrastTextState(state);
     HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
     return ret;
 }
@@ -1167,12 +1196,12 @@ Accessibility::RetError AccessibilityConfig::Impl::GetHighContrastTextState(bool
 Accessibility::RetError AccessibilityConfig::Impl::GetDaltonizationState(bool &state)
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
 
-    Accessibility::RetError ret = serviceProxy_->GetDaltonizationState(state);
+    Accessibility::RetError ret = GetServiceProxy()->GetDaltonizationState(state);
     HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
     return ret;
 }
@@ -1180,13 +1209,13 @@ Accessibility::RetError AccessibilityConfig::Impl::GetDaltonizationState(bool &s
 Accessibility::RetError AccessibilityConfig::Impl::GetDaltonizationColorFilter(DALTONIZATION_TYPE &type)
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
 
     uint32_t filterType = 0;
-    Accessibility::RetError ret = serviceProxy_->GetDaltonizationColorFilter(filterType);
+    Accessibility::RetError ret = GetServiceProxy()->GetDaltonizationColorFilter(filterType);
     type = static_cast<DALTONIZATION_TYPE>(filterType);
     HILOG_INFO("type = [%{public}u]", static_cast<uint32_t>(type));
     return ret;
@@ -1195,12 +1224,12 @@ Accessibility::RetError AccessibilityConfig::Impl::GetDaltonizationColorFilter(D
 Accessibility::RetError AccessibilityConfig::Impl::GetContentTimeout(uint32_t &timer)
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
 
-    Accessibility::RetError ret = serviceProxy_->GetContentTimeout(timer);
+    Accessibility::RetError ret = GetServiceProxy()->GetContentTimeout(timer);
     HILOG_INFO("timer = [%{public}u]", timer);
     return ret;
 }
@@ -1208,12 +1237,12 @@ Accessibility::RetError AccessibilityConfig::Impl::GetContentTimeout(uint32_t &t
 Accessibility::RetError AccessibilityConfig::Impl::GetAnimationOffState(bool &state)
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
 
-    Accessibility::RetError ret = serviceProxy_->GetAnimationOffState(state);
+    Accessibility::RetError ret = GetServiceProxy()->GetAnimationOffState(state);
     HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
     return ret;
 }
@@ -1221,12 +1250,12 @@ Accessibility::RetError AccessibilityConfig::Impl::GetAnimationOffState(bool &st
 Accessibility::RetError AccessibilityConfig::Impl::GetBrightnessDiscount(float &brightness)
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
 
-    Accessibility::RetError ret = serviceProxy_->GetBrightnessDiscount(brightness);
+    Accessibility::RetError ret = GetServiceProxy()->GetBrightnessDiscount(brightness);
     HILOG_INFO("brightness = [%{public}f]", brightness);
     return ret;
 }
@@ -1234,12 +1263,12 @@ Accessibility::RetError AccessibilityConfig::Impl::GetBrightnessDiscount(float &
 Accessibility::RetError AccessibilityConfig::Impl::GetAudioMonoState(bool &state)
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
 
-    Accessibility::RetError ret = serviceProxy_->GetAudioMonoState(state);
+    Accessibility::RetError ret = GetServiceProxy()->GetAudioMonoState(state);
     HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
     return ret;
 }
@@ -1247,12 +1276,12 @@ Accessibility::RetError AccessibilityConfig::Impl::GetAudioMonoState(bool &state
 Accessibility::RetError AccessibilityConfig::Impl::GetAudioBalance(float &balance)
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
 
-    Accessibility::RetError ret = serviceProxy_->GetAudioBalance(balance);
+    Accessibility::RetError ret = GetServiceProxy()->GetAudioBalance(balance);
     HILOG_INFO("balance = [%{public}f]", balance);
     return ret;
 }
@@ -1260,13 +1289,13 @@ Accessibility::RetError AccessibilityConfig::Impl::GetAudioBalance(float &balanc
 Accessibility::RetError AccessibilityConfig::Impl::GetClickResponseTime(CLICK_RESPONSE_TIME &time)
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
 
     uint32_t responseTime = 0;
-    Accessibility::RetError ret = serviceProxy_->GetClickResponseTime(responseTime);
+    Accessibility::RetError ret = GetServiceProxy()->GetClickResponseTime(responseTime);
     time = static_cast<CLICK_RESPONSE_TIME>(responseTime);
     HILOG_INFO("click response time = [%{public}u]", time);
     return ret;
@@ -1275,12 +1304,12 @@ Accessibility::RetError AccessibilityConfig::Impl::GetClickResponseTime(CLICK_RE
 Accessibility::RetError AccessibilityConfig::Impl::GetIgnoreRepeatClickState(bool &state)
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
 
-    Accessibility::RetError ret = serviceProxy_->GetIgnoreRepeatClickState(state);
+    Accessibility::RetError ret = GetServiceProxy()->GetIgnoreRepeatClickState(state);
     HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
     return ret;
 }
@@ -1288,13 +1317,13 @@ Accessibility::RetError AccessibilityConfig::Impl::GetIgnoreRepeatClickState(boo
 Accessibility::RetError AccessibilityConfig::Impl::GetIgnoreRepeatClickTime(IGNORE_REPEAT_CLICK_TIME &time)
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!GetServiceProxy()) {
         HILOG_ERROR("Failed to get accessibility service");
         return Accessibility::RET_ERR_SAMGR;
     }
 
     uint32_t ignoreRepeatClickTime = 0;
-    Accessibility::RetError ret = serviceProxy_->GetIgnoreRepeatClickTime(ignoreRepeatClickTime);
+    Accessibility::RetError ret = GetServiceProxy()->GetIgnoreRepeatClickTime(ignoreRepeatClickTime);
     time = static_cast<IGNORE_REPEAT_CLICK_TIME>(ignoreRepeatClickTime);
     HILOG_INFO("ignore repeat click time = [%{public}u]", time);
     return ret;
@@ -1780,5 +1809,41 @@ void AccessibilityConfig::Impl::NotifyDefaultConfigs()
     NotifyDefaultShortKeyMultiConfigs();
 }
 
+void AccessibilityConfig::Impl::AccessibilityLoadCallback::OnLoadSystemAbilitySuccess(int32_t systemAbilityId,
+    const sptr<IRemoteObject> &remoteObject)
+{
+    HILOG_DEBUG();
+    if (config_) {
+        config_->LoadSystemAbilitySuccess(remoteObject);
+    }
+}
+
+void AccessibilityConfig::Impl::AccessibilityLoadCallback::OnLoadSystemAbilityFail(int32_t systemAbilityId)
+{
+    HILOG_DEBUG();
+    if (config_) {
+        config_->LoadSystemAbilityFail();
+    }
+}
+
+void AccessibilityConfig::Impl::AccessibilitySaStatusChange::OnAddSystemAbility(int32_t saId,
+    const std::string &deviceId)
+{
+    HILOG_DEBUG();
+    if (config_ && config_->ConnectToServiceAsync()) {
+        config_->SetInitializeFlag(true);
+        HILOG_DEBUG("connect to accessibility service success.");
+    }
+}
+
+void AccessibilityConfig::Impl::AccessibilitySaStatusChange::OnRemoveSystemAbility(int32_t saId,
+    const std::string &deviceId)
+{
+    HILOG_DEBUG();
+    if (config_) {
+        config_->SetInitializeFlag(false);
+        HILOG_DEBUG("disconnect to Accessibility service");
+    }
+}
 } // namespace AccessibilityConfig
 } // namespace OHOS

frameworks/asacfwk/include/accessibility_system_ability_client_impl.h

@@ -18,10 +18,14 @@
 
 #include <array>
 #include <mutex>
+#include <condition_variable>
 #include "accessibility_element_operator_impl.h"
 #include "accessibility_system_ability_client.h"
 #include "accessible_ability_manager_state_observer_stub.h"
 #include "i_accessible_ability_manager_service.h"
+#include "refbase.h"
+#include "system_ability_load_callback_stub.h"
+#include "system_ability_status_change_stub.h"
 
 namespace OHOS {
 namespace Accessibility {
@@ -202,6 +206,10 @@ public:
     virtual void SetPerformActionResult(const bool succeeded, const int32_t requestId) override;
     virtual RetError GetFocusedWindowId(int32_t &focusedWindowId) override;
 
+    bool LoadAccessibilityService();
+    void LoadSystemAbilitySuccess(const sptr<IRemoteObject> &remoteObject);
+    void LoadSystemAbilityFail();
+
 private:
     class AccessibleAbilityManagerStateObserverImpl : public AccessibleAbilityManagerStateObserverStub {
     public:
@@ -231,6 +239,19 @@ private:
         AccessibilitySystemAbilityClientImpl &client_;
     };
 
+    class AccessibilityLoadCallback : public SystemAbilityLoadCallbackStub {
+    public:
+        void OnLoadSystemAbilitySuccess(int32_t systemAbilityId,
+            const sptr<IRemoteObject> &remoteObject) override;
+        void OnLoadSystemAbilityFail(int32_t systemAbilityId) override;
+    };
+
+    class AccessibilitySaStatusChange : public SystemAbilityStatusChangeStub {
+    public:
+        void OnAddSystemAbility(int32_t saId, const std::string &deviceId) override;
+        void OnRemoveSystemAbility(int32_t saId, const std::string &deviceId) override;
+    };
+
     /**
      * @brief Connect to AAMS Service.
      * @return success : true, failed : false.
@@ -265,6 +286,9 @@ private:
     sptr<IRemoteObject::DeathRecipient> deathRecipient_ = nullptr;
     sptr<IAccessibleAbilityManagerService> serviceProxy_ = nullptr;
     sptr<AccessibleAbilityManagerStateObserverImpl> stateObserver_ = nullptr;
+
+    std::condition_variable proxyConVar_;
+    std::mutex conVarMutex_; // mutex for proxyConVar
 };
 } // namespace Accessibility
 } // namespace OHOS

frameworks/asacfwk/src/accessibility_system_ability_client_impl.cpp

@@ -25,8 +25,7 @@ namespace OHOS {
 namespace Accessibility {
 namespace {
     constexpr int32_t REQUEST_WINDOW_ID_MASK_BIT = 16;
-    constexpr int32_t CONFIG_PARAMETER_VALUE_SIZE = 10;
-    const std::string SYSTEM_PARAMETER_AAMS_NAME = "accessibility.config.ready";
+    constexpr int32_t SA_CONNECT_TIMEOUT = 500; // ms
 } // namespaces
 
 static std::mutex g_Mutex;
@@ -49,20 +48,14 @@ AccessibilitySystemAbilityClientImpl::AccessibilitySystemAbilityClientImpl()
     HILOG_DEBUG();
 
     stateArray_.fill(false);
-    char value[CONFIG_PARAMETER_VALUE_SIZE] = "default";
-    int retSysParam = GetParameter(SYSTEM_PARAMETER_AAMS_NAME.c_str(), "false", value, CONFIG_PARAMETER_VALUE_SIZE);
-    if (retSysParam >= 0 && !std::strcmp(value, "true")) {
-        HILOG_ERROR("accessibility service is ready.");
-        if (!ConnectToService()) {
-            HILOG_ERROR("Failed to connect to aams service");
-            return;
-        }
-        Init();
+    auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+    if (samgr == nullptr) {
+        return;
     }
-
-    retSysParam = WatchParameter(SYSTEM_PARAMETER_AAMS_NAME.c_str(), &OnParameterChanged, this);
-    if (retSysParam) {
-        HILOG_ERROR("Watch parameter failed, error = %{public}d", retSysParam);
+    sptr<AccessibilitySaStatusChange> statusChange = new AccessibilitySaStatusChange();
+    int32_t ret = samgr->SubscribeSystemAbility(ACCESSIBILITY_MANAGER_SERVICE_ID, statusChange);
+    if (ret != 0) {
+        HILOG_ERROR("subscribe accessibility failed, error = %{public}d", ret);
     }
 }
 
@@ -80,14 +73,14 @@ bool AccessibilitySystemAbilityClientImpl::ConnectToService()
         return true;
     }
 
-    sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+    auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
     if (!samgr) {
         HILOG_ERROR("Failed to get ISystemAbilityManager");
         return false;
     }
 
-    sptr<IRemoteObject> object = samgr->GetSystemAbility(ACCESSIBILITY_MANAGER_SERVICE_ID);
-    if (!object) {
+    sptr<IRemoteObject> object = samgr->CheckSystemAbility(ACCESSIBILITY_MANAGER_SERVICE_ID);
+    if (object == nullptr && LoadAccessibilityService() == false) {
         HILOG_ERROR("Get IAccessibleAbilityManagerService object from samgr failed");
         return false;
     }
@@ -113,40 +106,45 @@ bool AccessibilitySystemAbilityClientImpl::ConnectToService()
     return true;
 }
 
-void AccessibilitySystemAbilityClientImpl::OnParameterChanged(const char *key, const char *value, void *context)
+bool AccessibilitySystemAbilityClientImpl::LoadAccessibilityService()
 {
-    HILOG_DEBUG("Parameter key = [%{public}s] value = [%{public}s]", key, value);
-
-    if (!key || std::strcmp(key, SYSTEM_PARAMETER_AAMS_NAME.c_str())) {
-        HILOG_WARN("not accessibility.config.ready callback");
-        return;
+    std::unique_lock<std::mutex> lock(conVarMutex_);
+    sptr<AccessibilityLoadCallback> loadCallback = new AccessibilityLoadCallback();
+    if (loadCallback == nullptr) {
+        return false;
     }
-
-    if (!value || std::strcmp(value, "true")) {
-        HILOG_WARN("accessibility.config.ready value not true");
-        return;
+    auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+    if (samgr == nullptr) {
+        return false;
     }
-
-    if (!context) {
-        HILOG_ERROR("accessibility.config.ready context NULL");
-        return;
+    int32_t ret = samgr->LoadSystemAbility(ACCESSIBILITY_MANAGER_SERVICE_ID, loadCallback);
+    if (ret != 0) {
+        return false;
     }
-
-    AccessibilitySystemAbilityClientImpl* implPtr = static_cast<AccessibilitySystemAbilityClientImpl*>(context);
-    {
-        HILOG_DEBUG("ConnectToService start.");
-        std::lock_guard<std::mutex> lock(implPtr->mutex_);
-        if (implPtr->serviceProxy_) {
-            HILOG_DEBUG("service is already started.");
-            return;
-        }
-        if (!implPtr->ConnectToService()) {
-            HILOG_ERROR("Failed to connect to aams service");
-            return;
-        }
-        implPtr->Init();
-        implPtr->ReregisterElementOperator();
+    auto waitStatus = proxyConVar_.wait_for(lock, std::chrono::milliseconds(SA_CONNECT_TIMEOUT),
+        [=]() { return serviceProxy_ != nullptr; });
+    if (!waitStatus) {
+        return false;
     }
+    return true;
+}
+
+void AccessibilitySystemAbilityClientImpl::LoadSystemAbilitySuccess(const sptr<IRemoteObject> &remoteObject)
+{
+    std::lock_guard<std::mutex> lock(conVarMutex_);
+    if (remoteObject != nullptr) {
+        serviceProxy_ = iface_cast<IAccessibleAbilityManagerService>(remoteObject);
+    } else {
+        serviceProxy_ = nullptr;
+    }
+    proxyConVar_.notify_one();
+}
+
+void AccessibilitySystemAbilityClientImpl::LoadSystemAbilityFail()
+{
+    std::lock_guard<std::mutex> lock(conVarMutex_);
+    serviceProxy_ = nullptr;
+    proxyConVar_.notify_one();
 }
 
 void AccessibilitySystemAbilityClientImpl::Init()
@@ -160,6 +158,9 @@ void AccessibilitySystemAbilityClientImpl::Init()
             return;
         }
     }
+    if (serviceProxy_ == nullptr) {
+        return;
+    }
     uint32_t stateType = serviceProxy_->RegisterStateObserver(stateObserver_);
     if (stateType & STATE_ACCESSIBILITY_ENABLED) {
         stateArray_[AccessibilityStateEventType::EVENT_ACCESSIBILITY_STATE_CHANGED] = true;
@@ -198,7 +199,7 @@ RetError AccessibilitySystemAbilityClientImpl::RegisterElementOperator(
         HILOG_ERROR("Input operation is null");
         return RET_ERR_INVALID_PARAM;
     }
-    if (!serviceProxy_) {
+    if (!serviceProxy_ && !LoadAccessibilityService()) {
         HILOG_ERROR("Failed to get aams service");
         return RET_ERR_SAMGR;
     }
@@ -237,7 +238,7 @@ RetError AccessibilitySystemAbilityClientImpl::DeregisterElementOperator(const i
     HILOG_INFO("Deregister windowId[%{public}d] start", windowId);
     std::lock_guard<std::mutex> lock(mutex_);
 
-    if (!serviceProxy_) {
+    if (!serviceProxy_ && !LoadAccessibilityService()) {
         HILOG_ERROR("Failed to get aams service");
         return RET_ERR_SAMGR;
     }
@@ -289,7 +290,7 @@ RetError AccessibilitySystemAbilityClientImpl::GetAbilityList(const uint32_t acc
             accessibilityAbilityTypes, stateType);
         return RET_ERR_INVALID_PARAM;
     }
-    if (!serviceProxy_) {
+    if (!serviceProxy_ && !LoadAccessibilityService()) {
         HILOG_ERROR("Failed to get aams service");
         return RET_ERR_SAMGR;
     }
@@ -317,7 +318,7 @@ RetError AccessibilitySystemAbilityClientImpl::SendEvent(const EventType eventTy
     AccessibilityEventInfo event;
     event.SetEventType(eventType);
     event.SetSource(componentId);
-    if (!serviceProxy_) {
+    if (!serviceProxy_ && !LoadAccessibilityService()) {
         HILOG_ERROR("Failed to get aams service");
         return RET_ERR_SAMGR;
     }
@@ -331,7 +332,7 @@ RetError AccessibilitySystemAbilityClientImpl::SendEvent(const AccessibilityEven
     if (!CheckEventType(event.GetEventType())) {
         return RET_ERR_INVALID_PARAM;
     }
-    if (!serviceProxy_) {
+    if (!serviceProxy_ && !LoadAccessibilityService()) {
         HILOG_ERROR("Failed to get aams service");
         return RET_ERR_SAMGR;
     }
@@ -417,7 +418,7 @@ RetError AccessibilitySystemAbilityClientImpl::GetEnabledAbilities(std::vector<s
 {
     HILOG_DEBUG();
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!serviceProxy_ && !LoadAccessibilityService()) {
         HILOG_ERROR("Failed to get aams service");
         return RET_ERR_SAMGR;
     }
@@ -605,11 +606,52 @@ RetError AccessibilitySystemAbilityClientImpl::GetFocusedWindowId(int32_t &focus
 {
     HILOG_DEBUG();
     std::lock_guard<std::mutex> lock(mutex_);
-    if (!serviceProxy_) {
+    if (!serviceProxy_ && !LoadAccessibilityService()) {
         HILOG_ERROR("Failed to get aams service");
         return RET_ERR_SAMGR;
     }
     return serviceProxy_->GetFocusedWindowId(focusedWindowId);
 }
+
+void AccessibilitySystemAbilityClientImpl::AccessibilityLoadCallback::OnLoadSystemAbilitySuccess(
+    int32_t systemAbilityId, const sptr<IRemoteObject> &remoteObject)
+{
+    HILOG_DEBUG();
+    if (g_Instance) {
+        g_Instance->LoadSystemAbilitySuccess(remoteObject);
+    }
+}
+
+void AccessibilitySystemAbilityClientImpl::AccessibilityLoadCallback::OnLoadSystemAbilityFail(int32_t systemAbilityId)
+{
+    HILOG_DEBUG();
+    if (g_Instance) {
+        g_Instance->LoadSystemAbilityFail();
+    }
+}
+
+void AccessibilitySystemAbilityClientImpl::AccessibilitySaStatusChange::OnAddSystemAbility(int32_t saId,
+    const std::string &deviceId)
+{
+    HILOG_DEBUG();
+    if (!g_Instance) {
+        return;
+    }
+    std::lock_guard<std::mutex> lock(g_Instance->mutex_);
+    if (g_Instance->serviceProxy_) {
+        return;
+    }
+    if (!g_Instance->ConnectToService()) {
+        return;
+    }
+    g_Instance->Init();
+    g_Instance->ReregisterElementOperator();
+}
+
+void AccessibilitySystemAbilityClientImpl::AccessibilitySaStatusChange::OnRemoveSystemAbility(int32_t saId,
+    const std::string &deviceId)
+{
+    HILOG_WARN("disconnect to accessibility service");
+}
 } // namespace Accessibility
-} // namespace OHOS
+} // namespace OHOS

frameworks/asacfwk/test/BUILD.gn

@@ -82,6 +82,7 @@ ohos_unittest("asac_unit_test") {
     "hilog:libhilog",
     "init:libbegetutil",
     "ipc:ipc_core",
+    "samgr:samgr_proxy",
   ]
 }
 

services/aams/include/accessible_ability_manager_service.h

@@ -82,6 +82,7 @@ public:
     void OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override;
     void OnRemoveSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override;
     int Dump(int fd, const std::vector<std::u16string>& args) override;
+    void PostDelayUnloadTask() override;
 
 public:
     /* For AccessibleAbilityManagerServiceStub */
@@ -367,6 +368,7 @@ private:
     
     void OnDeviceProvisioned();
     void RegisterShortKeyEvent();
+    bool IsNeedUnload();
 
     bool isReady_ = false;
     bool isPublished_ = false;

services/aams/src/accessible_ability_channel.cpp

@@ -51,6 +51,7 @@ RetError AccessibleAbilityChannel::SearchElementInfoByAccessibilityId(const int3
     const int32_t mode, bool isFilter)
 {
     HILOG_DEBUG();
+    Singleton<AccessibleAbilityManagerService>::GetInstance().PostDelayUnloadTask();
 
     if (!eventHandler_) {
         HILOG_ERROR("eventHandler_ is nullptr.");
@@ -96,6 +97,7 @@ RetError AccessibleAbilityChannel::SearchElementInfosByText(const int32_t access
     const sptr<IAccessibilityElementOperatorCallback> &callback)
 {
     HILOG_DEBUG();
+    Singleton<AccessibleAbilityManagerService>::GetInstance().PostDelayUnloadTask();
 
     if (!eventHandler_) {
         HILOG_ERROR("eventHandler_ is nullptr.");
@@ -134,6 +136,7 @@ RetError AccessibleAbilityChannel::FindFocusedElementInfo(const int32_t accessib
     const sptr<IAccessibilityElementOperatorCallback> &callback)
 {
     HILOG_DEBUG();
+    Singleton<AccessibleAbilityManagerService>::GetInstance().PostDelayUnloadTask();
 
     if (!eventHandler_) {
         HILOG_ERROR("eventHandler_ is nullptr.");
@@ -171,6 +174,7 @@ RetError AccessibleAbilityChannel::FocusMoveSearch(const int32_t accessibilityWi
     const int32_t direction, const int32_t requestId, const sptr<IAccessibilityElementOperatorCallback> &callback)
 {
     HILOG_DEBUG();
+    Singleton<AccessibleAbilityManagerService>::GetInstance().PostDelayUnloadTask();
 
     if (!eventHandler_) {
         HILOG_ERROR("eventHandler_ is nullptr.");
@@ -207,6 +211,7 @@ RetError AccessibleAbilityChannel::FocusMoveSearch(const int32_t accessibilityWi
 void AccessibleAbilityChannel::SetKeyCodeSingle(std::shared_ptr<MMI::KeyEvent>& keyEvent, const int32_t keyCode)
 {
     HILOG_DEBUG();
+    Singleton<AccessibleAbilityManagerService>::GetInstance().PostDelayUnloadTask();
     if (!keyEvent) {
         HILOG_ERROR("KeyEvent is nullptr");
         return;
@@ -226,6 +231,7 @@ void AccessibleAbilityChannel::SetKeyCodeMulti(std::shared_ptr<MMI::KeyEvent>& k
     const int32_t keyCodeNext)
 {
     HILOG_DEBUG();
+    Singleton<AccessibleAbilityManagerService>::GetInstance().PostDelayUnloadTask();
     if (!keyEvent) {
         HILOG_ERROR("KeyEvent is nullptr");
         return;
@@ -248,6 +254,7 @@ void AccessibleAbilityChannel::SetKeyCodeMulti(std::shared_ptr<MMI::KeyEvent>& k
 RetError AccessibleAbilityChannel::TransmitActionToMmi(const int32_t action)
 {
     HILOG_DEBUG("The action is %{public}d", action);
+    Singleton<AccessibleAbilityManagerService>::GetInstance().PostDelayUnloadTask();
     std::shared_ptr<MMI::KeyEvent> keyEvent = MMI::KeyEvent::Create();
     if (!keyEvent) {
         HILOG_ERROR("KeyEvent is nullptr");
@@ -275,6 +282,7 @@ RetError AccessibleAbilityChannel::TransmitActionToMmi(const int32_t action)
 RetError AccessibleAbilityChannel::EnableScreenCurtain(bool isEnable)
 {
     HILOG_DEBUG();
+    Singleton<AccessibleAbilityManagerService>::GetInstance().PostDelayUnloadTask();
     HILOG_INFO("enter AccessibleAbilityChannel::EnableScreenCurtain isEnable = %{public}d", isEnable);
 
     if (!eventHandler_) {
@@ -298,7 +306,7 @@ RetError AccessibleAbilityChannel::ExecuteAction(const int32_t accessibilityWind
     const sptr<IAccessibilityElementOperatorCallback> &callback)
 {
     HILOG_DEBUG();
-
+    Singleton<AccessibleAbilityManagerService>::GetInstance().PostDelayUnloadTask();
     if (!eventHandler_) {
         HILOG_ERROR("eventHandler_ is nullptr.");
         return RET_ERR_NULLPTR;
@@ -343,7 +351,7 @@ RetError AccessibleAbilityChannel::ExecuteAction(const int32_t accessibilityWind
 RetError AccessibleAbilityChannel::GetWindow(const int32_t windowId, AccessibilityWindowInfo &windowInfo)
 {
     HILOG_DEBUG("windowId:%{public}d", windowId);
-
+    Singleton<AccessibleAbilityManagerService>::GetInstance().PostDelayUnloadTask();
     if (!eventHandler_) {
         HILOG_ERROR("eventHandler_ is nullptr.");
         return RET_ERR_NULLPTR;
@@ -387,6 +395,7 @@ RetError AccessibleAbilityChannel::GetWindow(const int32_t windowId, Accessibili
 RetError AccessibleAbilityChannel::GetWindows(std::vector<AccessibilityWindowInfo> &windows)
 {
     HILOG_DEBUG();
+    Singleton<AccessibleAbilityManagerService>::GetInstance().PostDelayUnloadTask();
 #ifdef OHOS_BUILD_ENABLE_DISPLAY_MANAGER
     uint64_t displayId = Singleton<AccessibilityDisplayManager>::GetInstance().GetDefaultDisplayId();
     HILOG_DEBUG("default display id is %{public}" PRIu64 "", displayId);
@@ -459,7 +468,7 @@ RetError AccessibleAbilityChannel::GetWindows(uint64_t displayId, std::vector<Ac
 void AccessibleAbilityChannel::SetOnKeyPressEventResult(const bool handled, const int32_t sequence)
 {
     HILOG_DEBUG();
-
+    Singleton<AccessibleAbilityManagerService>::GetInstance().PostDelayUnloadTask();
     if (!eventHandler_) {
         HILOG_ERROR("eventHandler_ is nullptr.");
         return;
@@ -485,6 +494,7 @@ RetError AccessibleAbilityChannel::GetCursorPosition(const int32_t accessibility
     const int32_t requestId, const sptr<IAccessibilityElementOperatorCallback> &callback)
 {
     HILOG_DEBUG();
+    Singleton<AccessibleAbilityManagerService>::GetInstance().PostDelayUnloadTask();
     if (!eventHandler_) {
         HILOG_ERROR("eventHandler_ is nullptr.");
         return RET_ERR_NULLPTR;
@@ -520,6 +530,7 @@ RetError AccessibleAbilityChannel::SendSimulateGesture(
     const std::shared_ptr<AccessibilityGestureInjectPath>& gesturePath)
 {
     HILOG_INFO();
+    Singleton<AccessibleAbilityManagerService>::GetInstance().PostDelayUnloadTask();
     if (!eventHandler_) {
         HILOG_ERROR("eventHandler_ is nullptr");
         return RET_ERR_NULLPTR;
@@ -564,6 +575,7 @@ RetError AccessibleAbilityChannel::SendSimulateGesture(
 RetError AccessibleAbilityChannel::SetTargetBundleName(const std::vector<std::string> &targetBundleNames)
 {
     HILOG_DEBUG();
+    Singleton<AccessibleAbilityManagerService>::GetInstance().PostDelayUnloadTask();
     if (!eventHandler_) {
         HILOG_ERROR("eventHandler_ is nullptr");
         return RET_ERR_NULLPTR;

services/aams/src/accessible_ability_manager_service.cpp

@@ -50,11 +50,13 @@ namespace {
     const std::string ARKUI_ANIMATION_SCALE_NAME = "persist.sys.arkui.animationscale";
     const std::string SCREEN_READER_BUNDLE_ABILITY_NAME = "com.huawei.hmos.screenreader/AccessibilityExtAbility";
     const std::string DEVICE_PROVISIONED = "device_provisioned";
+    const std::string DELAY_UNLOAD_TASK = "TASK_UNLOAD_ACCESSIBILITY_SA";
     constexpr int32_t QUERY_USER_ID_RETRY_COUNT = 600;
     constexpr int32_t QUERY_USER_ID_SLEEP_TIME = 50;
     constexpr uint32_t TIME_OUT_OPERATOR = 5000;
     constexpr int32_t REQUEST_ID_MAX = 0x0000FFFF;
     constexpr int32_t DEFAULT_ACCOUNT_ID = 100;
+    constexpr int32_t UNLOAD_TASK_INTERNAL = 3 * 60 * 1000; // ms
 } // namespace
 
 const bool REGISTER_RESULT =
@@ -102,7 +104,6 @@ void AccessibleAbilityManagerService::OnStart()
             return;
         }
     }
-    SetParameter(SYSTEM_PARAMETER_AAMS_NAME.c_str(), "false");
 
     HILOG_DEBUG("AddAbilityListener!");
     AddSystemAbilityListener(ABILITY_MGR_SERVICE_ID);
@@ -154,7 +155,6 @@ void AccessibleAbilityManagerService::OnStop()
 
     isReady_ = false;
     isPublished_ = false;
-    SetParameter(SYSTEM_PARAMETER_AAMS_NAME.c_str(), "false");
     HILOG_INFO("AccessibleAbilityManagerService::OnStop OK.");
 }
 
@@ -196,9 +196,9 @@ void AccessibleAbilityManagerService::OnAddSystemAbility(int32_t systemAbilityId
         InitInnerResource();
 
         isReady_ = true;
-        SetParameter(SYSTEM_PARAMETER_AAMS_NAME.c_str(), "true");
         HILOG_DEBUG("AAMS is ready!");
         RegisterShortKeyEvent();
+        PostDelayUnloadTask();
         }), "OnAddSystemAbility");
 }
 
@@ -227,7 +227,6 @@ void AccessibleAbilityManagerService::OnRemoveSystemAbility(int32_t systemAbilit
             Singleton<AccessibilityWindowManager>::GetInstance().DeInit();
 
             isReady_ = false;
-            SetParameter(SYSTEM_PARAMETER_AAMS_NAME.c_str(), "false");
         }
         }), "OnRemoveSystemAbility");
 }
@@ -2226,5 +2225,58 @@ bool AccessibleAbilityManagerService::CheckWindowRegister(int32_t windowId)
     }
     return accountData->GetAccessibilityWindowConnection(windowId) != nullptr;
 }
+
+void AccessibleAbilityManagerService::PostDelayUnloadTask()
+{
+    auto task = [=]() {
+        sptr<ISystemAbilityManager> systemAbilityManager =
+            SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        if (systemAbilityManager == nullptr) {
+            HILOG_ERROR("failed to get system ability mgr");
+            return;
+        }
+        if (!IsNeedUnload()) {
+            return;
+        }
+        int32_t ret = systemAbilityManager->UnloadSystemAbility(ACCESSIBILITY_MANAGER_SERVICE_ID);
+        if (ret != ERR_OK) {
+            HILOG_ERROR("unload system ability failed");
+            return;
+        }
+    };
+    handler_->RemoveTask(DELAY_UNLOAD_TASK);
+    handler_->PostTask(task, DELAY_UNLOAD_TASK, UNLOAD_TASK_INTERNAL);
+}
+
+bool AccessibleAbilityManagerService::IsNeedUnload()
+{
+    HILOG_DEBUG();
+    sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
+    if (!accountData) {
+        HILOG_ERROR("accountData is nullptr");
+        return true;
+    }
+
+    // do not unload when any extension is enabled
+    std::vector<std::string> enableAbilityList = accountData->GetEnabledAbilities();
+    if (enableAbilityList.size() != 0) {
+        return false;
+    }
+    if (!accountData->GetConfig()) {
+        return true;
+    }
+    if (accountData->GetConfig()->GetHighContrastTextState() != false ||
+        accountData->GetConfig()->GetDaltonizationState() != false ||
+        accountData->GetConfig()->GetInvertColorState() != false ||
+        accountData->GetConfig()->GetAnimationOffState() != false ||
+        accountData->GetConfig()->GetMouseKeyState() != false ||
+        accountData->GetConfig()->GetCaptionState() != false ||
+        accountData->GetConfig()->GetScreenMagnificationState() != false ||
+        accountData->GetConfig()->GetShortKeyState() != false ||
+        accountData->GetConfig()->GetBrightnessDiscount() != 1) {
+        return false;
+    }
+    return true;
+}
 } // namespace Accessibility
 } // namespace OHOS

services/aams/test/mock/src/mock_accessible_ability_manager_service.cpp

@@ -572,5 +572,9 @@ bool AccessibleAbilityManagerService::CheckWindowRegister(int32_t windowId)
     (void)windowId;
     return true;
 }
+
+void AccessibleAbilityManagerService::PostDelayUnloadTask()
+{
+}
 } // namespace Accessibility
 } // namespace OHOS