fix singleton problem

Signed-off-by: jidong <jidong4@huawei.com>
Change-Id: Ica933b50baec62e517847c044888a0e6f09d9912

dfx/hidumper_adapter/account_dump_helper.cpp

@@ -72,7 +72,6 @@ std::string AnonymizeUidStr(const std::string& uidStr)
 
 AccountDumpHelper::AccountDumpHelper(const std::shared_ptr<OhosAccountManager>& ohosAccountMgr,
     OsAccountManagerService *osAccountMgrService)
-    : innerMgrService_(DelayedSingleton<IInnerOsAccountManager>::GetInstance())
 {
     ohosAccountMgr_ = ohosAccountMgr;
     osAccountMgrService_ = osAccountMgrService;
@@ -115,7 +114,7 @@ void AccountDumpHelper::ShowIllegalInformation(std::string& result) const
 void AccountDumpHelper::ShowOhosAccountInfo(std::string& result) const
 {
     auto lockPtr = ohosAccountMgr_.lock();
-    if (lockPtr == nullptr || innerMgrService_ == nullptr) {
+    if (lockPtr == nullptr) {
         result.append(SYSTEM_ERROR + "service ptr is null!\n");
         ACCOUNT_LOGE("service ptr is null!");
         return;
@@ -123,7 +122,7 @@ void AccountDumpHelper::ShowOhosAccountInfo(std::string& result) const
 
     // check os account list
     std::vector<OsAccountInfo> osAccountInfos;
-    ErrCode ret = innerMgrService_->QueryAllCreatedOsAccounts(osAccountInfos);
+    ErrCode ret = IInnerOsAccountManager::GetInstance().QueryAllCreatedOsAccounts(osAccountInfos);
     if (ret != ERR_OK) {
         result.append("Cannot query os account list, error code ");
         result.append(std::to_string(ret));

dfx/hidumper_adapter/account_dump_helper.h

@@ -38,7 +38,6 @@ private:
     void ProcessTwoParameter(const std::string& arg1, const std::string& arg2, std::string& result) const;
     std::weak_ptr<OhosAccountManager> ohosAccountMgr_;
     OsAccountManagerService *osAccountMgrService_;
-    std::shared_ptr<IInnerOsAccount> innerMgrService_;
     void ShowOhosAccountInfo(std::string &result) const;
     void ShowOsAccountInfo(std::string &result) const;
     void SetLogLevel(const std::string& levelStr, std::string& result) const;

frameworks/account_iam/src/account_iam_client.cpp

@@ -34,9 +34,11 @@ const std::string PERMISSION_ACCESS_PIN_AUTH = "ohos.permission.ACCESS_PIN_AUTH"
 const std::string PERMISSION_MANAGE_USER_IDM = "ohos.permission.MANAGE_USER_IDM";
 const std::string PERMISSION_ACCESS_USER_AUTH_INTERNAL = "ohos.permission.ACCESS_USER_AUTH_INTERNAL";
 }
-AccountIAMClient::AccountIAMClient()
+
+AccountIAMClient &AccountIAMClient::GetInstance()
 {
-    permissionManagerPtr_ = DelayedSingleton<AccountPermissionManager>::GetInstance();
+    static AccountIAMClient instance;
+    return instance;
 }
 
 int32_t AccountIAMClient::OpenSession(int32_t userId, std::vector<uint8_t> &challenge)
@@ -281,7 +283,7 @@ void AccountIAMClient::SetProperty(
 ErrCode AccountIAMClient::RegisterPINInputer(const std::shared_ptr<IInputer> &inputer)
 {
     std::lock_guard<std::mutex> lock(pinMutex_);
-    ErrCode result = permissionManagerPtr_->CheckSystemApp(false);
+    ErrCode result = AccountPermissionManager::CheckSystemApp(false);
     if (result != ERR_OK) {
         ACCOUNT_LOGE("is not system application, result = %{public}u.", result);
         return result;
@@ -326,7 +328,7 @@ ErrCode AccountIAMClient::RegisterDomainInputer(const std::shared_ptr<IInputer>
 
 ErrCode AccountIAMClient::RegisterInputer(int32_t authType, const std::shared_ptr<IInputer> &inputer)
 {
-    ErrCode result = permissionManagerPtr_->CheckSystemApp(false);
+    ErrCode result = AccountPermissionManager::CheckSystemApp(false);
     if (result != ERR_OK) {
         ACCOUNT_LOGE("is not system application, result = %{public}u.", result);
         return result;
@@ -350,7 +352,7 @@ ErrCode AccountIAMClient::RegisterInputer(int32_t authType, const std::shared_pt
 
 ErrCode AccountIAMClient::UnregisterInputer(int32_t authType)
 {
-    ErrCode result = permissionManagerPtr_->CheckSystemApp(false);
+    ErrCode result = AccountPermissionManager::CheckSystemApp(false);
     if (result != ERR_OK) {
         ACCOUNT_LOGE("is not system application, result = %{public}u.", result);
         return result;
@@ -371,7 +373,7 @@ ErrCode AccountIAMClient::UnregisterInputer(int32_t authType)
 
 ErrCode AccountIAMClient::UnregisterPINInputer()
 {
-    ErrCode result = permissionManagerPtr_->CheckSystemApp(false);
+    ErrCode result = AccountPermissionManager::CheckSystemApp(false);
     if (result != ERR_OK) {
         ACCOUNT_LOGE("is not system application, result = %{public}u.", result);
         return result;

frameworks/appaccount/native/include/app_account.h

@@ -32,6 +32,7 @@ public:
         SUBSCRIBE_FAILED,
     };
 
+    static AppAccount &GetInstance();
     ErrCode AddAccount(const std::string &name, const std::string &extraInfo);
     ErrCode AddAccountImplicitly(const std::string &owner, const std::string &authType,
         const AAFwk::Want &options, const sptr<IAppAccountAuthenticatorCallback> &callback);
@@ -105,6 +106,8 @@ public:
     ErrCode ResetAppAccountProxy();
 
 private:
+    AppAccount() = default;
+    ~AppAccount() = default;
     ErrCode CheckParameters(const std::string &name, const std::string &extraInfo = "");
     ErrCode CheckSpecialCharacters(const std::string &name);
     ErrCode CheckTokenVisibilityParam(

frameworks/appaccount/native/libapp_account_innerkits.map

@@ -17,6 +17,7 @@
         "non-virtual thunk to OHOS::AccountSA::AppAccountAuthenticatorCallbackStub::~AppAccountAuthenticatorCallbackStub()";
         "non-virtual thunk to OHOS::AccountSA::AppAccountAuthenticatorStub::~AppAccountAuthenticatorStub()";
         "non-virtual thunk to OHOS::AccountSA::AppAccountEventStub::~AppAccountEventStub()";
+        "OHOS::AccountSA::AppAccount::GetInstance()";
         "OHOS::AccountSA::AppAccount::UnsubscribeAppAccount(std::__h::shared_ptr<OHOS::AccountSA::AppAccountSubscriber> const&)";
         "OHOS::AccountSA::AppAccountAuthenticatorCallbackProxy::AppAccountAuthenticatorCallbackProxy(OHOS::sptr<OHOS::IRemoteObject> const&)";
         "OHOS::AccountSA::AppAccountAuthenticatorCallbackProxy::OnRequestContinued()";

frameworks/appaccount/native/src/app_account.cpp

@@ -54,6 +54,12 @@ namespace AccountSA {
         }                                                   \
     } while (0)                                             \
 
+AppAccount &AppAccount::GetInstance()
+{
+    static AppAccount instance;
+    return instance;
+}
+
 ErrCode AppAccount::AddAccount(const std::string &name, const std::string &extraInfo)
 {
     RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(name, Constants::NAME_MAX_SIZE, "name is empty or oversize");

frameworks/appaccount/native/src/app_account_death_recipient.cpp

@@ -17,13 +17,12 @@
 
 #include "account_log_wrapper.h"
 #include "app_account.h"
-#include "singleton.h"
 
 namespace OHOS {
 namespace AccountSA {
 void AppAccountDeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &remote)
 {
-    DelayedSingleton<AppAccount>::GetInstance()->ResetAppAccountProxy();
+    AppAccount::GetInstance().ResetAppAccountProxy();
 }
 }  // namespace AccountSA
 }  // namespace OHOS

frameworks/appaccount/native/src/app_account_manager.cpp

@@ -17,245 +17,244 @@
 
 #include "account_log_wrapper.h"
 #include "app_account.h"
-#include "singleton.h"
 
 namespace OHOS {
 namespace AccountSA {
 ErrCode AppAccountManager::AddAccount(const std::string &name, const std::string &extraInfo)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->AddAccount(name, extraInfo);
+    return AppAccount::GetInstance().AddAccount(name, extraInfo);
 }
 
 ErrCode AppAccountManager::AddAccountImplicitly(const std::string &owner, const std::string &authType,
     const AAFwk::Want &options, const sptr<IAppAccountAuthenticatorCallback> &callback)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->AddAccountImplicitly(
+    return AppAccount::GetInstance().AddAccountImplicitly(
         owner, authType, options, callback);
 }
 
 ErrCode AppAccountManager::CreateAccount(const std::string &name, const CreateAccountOptions &options)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->CreateAccount(name, options);
+    return AppAccount::GetInstance().CreateAccount(name, options);
 }
 
 ErrCode AppAccountManager::CreateAccountImplicitly(const std::string &owner,
     const CreateAccountImplicitlyOptions &options, const sptr<IAppAccountAuthenticatorCallback> &callback)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->CreateAccountImplicitly(owner, options, callback);
+    return AppAccount::GetInstance().CreateAccountImplicitly(owner, options, callback);
 }
 
 ErrCode AppAccountManager::DeleteAccount(const std::string &name)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->DeleteAccount(name);
+    return AppAccount::GetInstance().DeleteAccount(name);
 }
 
 ErrCode AppAccountManager::GetAccountExtraInfo(const std::string &name, std::string &extraInfo)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->GetAccountExtraInfo(name, extraInfo);
+    return AppAccount::GetInstance().GetAccountExtraInfo(name, extraInfo);
 }
 
 ErrCode AppAccountManager::SetAccountExtraInfo(const std::string &name, const std::string &extraInfo)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->SetAccountExtraInfo(name, extraInfo);
+    return AppAccount::GetInstance().SetAccountExtraInfo(name, extraInfo);
 }
 
 ErrCode AppAccountManager::EnableAppAccess(const std::string &name, const std::string &authorizedApp)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->EnableAppAccess(name, authorizedApp);
+    return AppAccount::GetInstance().EnableAppAccess(name, authorizedApp);
 }
 
 ErrCode AppAccountManager::DisableAppAccess(const std::string &name, const std::string &authorizedApp)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->DisableAppAccess(name, authorizedApp);
+    return AppAccount::GetInstance().DisableAppAccess(name, authorizedApp);
 }
 
 ErrCode AppAccountManager::SetAppAccess(const std::string &name, const std::string &authorizedApp, bool isAccessible)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->SetAppAccess(name, authorizedApp, isAccessible);
+    return AppAccount::GetInstance().SetAppAccess(name, authorizedApp, isAccessible);
 }
 
 ErrCode AppAccountManager::CheckAppAccountSyncEnable(const std::string &name, bool &syncEnable)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->CheckAppAccountSyncEnable(name, syncEnable);
+    return AppAccount::GetInstance().CheckAppAccountSyncEnable(name, syncEnable);
 }
 
 ErrCode AppAccountManager::SetAppAccountSyncEnable(const std::string &name, const bool &syncEnable)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->SetAppAccountSyncEnable(name, syncEnable);
+    return AppAccount::GetInstance().SetAppAccountSyncEnable(name, syncEnable);
 }
 
 ErrCode AppAccountManager::GetAssociatedData(const std::string &name, const std::string &key, std::string &value)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->GetAssociatedData(name, key, value);
+    return AppAccount::GetInstance().GetAssociatedData(name, key, value);
 }
 
 ErrCode AppAccountManager::SetAssociatedData(const std::string &name, const std::string &key, const std::string &value)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->SetAssociatedData(name, key, value);
+    return AppAccount::GetInstance().SetAssociatedData(name, key, value);
 }
 
 ErrCode AppAccountManager::GetAccountCredential(
     const std::string &name, const std::string &credentialType, std::string &credential)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->GetAccountCredential(name, credentialType, credential);
+    return AppAccount::GetInstance().GetAccountCredential(name, credentialType, credential);
 }
 
 ErrCode AppAccountManager::SetAccountCredential(
     const std::string &name, const std::string &credentialType, const std::string &credential)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->SetAccountCredential(name, credentialType, credential);
+    return AppAccount::GetInstance().SetAccountCredential(name, credentialType, credential);
 }
 
 ErrCode AppAccountManager::Authenticate(const std::string &name, const std::string &owner,
     const std::string &authType, const AAFwk::Want &options, const sptr<IAppAccountAuthenticatorCallback> &callback)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->Authenticate(name, owner, authType, options, callback);
+    return AppAccount::GetInstance().Authenticate(name, owner, authType, options, callback);
 }
 
 ErrCode AppAccountManager::GetOAuthToken(
     const std::string &name, const std::string &owner, const std::string &authType, std::string &token)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->GetOAuthToken(name, owner, authType, token);
+    return AppAccount::GetInstance().GetOAuthToken(name, owner, authType, token);
 }
 
 ErrCode AppAccountManager::GetAuthToken(
     const std::string &name, const std::string &owner, const std::string &authType, std::string &token)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->GetAuthToken(name, owner, authType, token);
+    return AppAccount::GetInstance().GetAuthToken(name, owner, authType, token);
 }
 
 ErrCode AppAccountManager::SetOAuthToken(
     const std::string &name, const std::string &authType, const std::string &token)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->SetOAuthToken(name, authType, token);
+    return AppAccount::GetInstance().SetOAuthToken(name, authType, token);
 }
 
 ErrCode AppAccountManager::DeleteOAuthToken(
     const std::string &name, const std::string &owner, const std::string &authType, const std::string &token)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->DeleteOAuthToken(name, owner, authType, token);
+    return AppAccount::GetInstance().DeleteOAuthToken(name, owner, authType, token);
 }
 
 ErrCode AppAccountManager::DeleteAuthToken(
     const std::string &name, const std::string &owner, const std::string &authType, const std::string &token)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->DeleteAuthToken(name, owner, authType, token);
+    return AppAccount::GetInstance().DeleteAuthToken(name, owner, authType, token);
 }
 
 ErrCode AppAccountManager::SetOAuthTokenVisibility(
     const std::string &name, const std::string &authType, const std::string &bundleName, bool isVisible)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->SetOAuthTokenVisibility(
+    return AppAccount::GetInstance().SetOAuthTokenVisibility(
         name, authType, bundleName, isVisible);
 }
 
 ErrCode AppAccountManager::SetAuthTokenVisibility(
     const std::string &name, const std::string &authType, const std::string &bundleName, bool isVisible)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->SetAuthTokenVisibility(
+    return AppAccount::GetInstance().SetAuthTokenVisibility(
         name, authType, bundleName, isVisible);
 }
 
 ErrCode AppAccountManager::CheckOAuthTokenVisibility(
     const std::string &name, const std::string &authType, const std::string &bundleName, bool &isVisible)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->CheckOAuthTokenVisibility(
+    return AppAccount::GetInstance().CheckOAuthTokenVisibility(
         name, authType, bundleName, isVisible);
 }
 
 ErrCode AppAccountManager::CheckAuthTokenVisibility(
     const std::string &name, const std::string &authType, const std::string &bundleName, bool &isVisible)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->CheckAuthTokenVisibility(
+    return AppAccount::GetInstance().CheckAuthTokenVisibility(
         name, authType, bundleName, isVisible);
 }
 
 ErrCode AppAccountManager::GetAuthenticatorInfo(const std::string &owner, AuthenticatorInfo &info)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->GetAuthenticatorInfo(owner, info);
+    return AppAccount::GetInstance().GetAuthenticatorInfo(owner, info);
 }
 
 ErrCode AppAccountManager::GetAllOAuthTokens(
     const std::string &name, const std::string &owner, std::vector<OAuthTokenInfo> &tokenInfos)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->GetAllOAuthTokens(name, owner, tokenInfos);
+    return AppAccount::GetInstance().GetAllOAuthTokens(name, owner, tokenInfos);
 }
 
 ErrCode AppAccountManager::GetOAuthList(
     const std::string &name, const std::string &authType, std::set<std::string> &oauthList)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->GetOAuthList(name, authType, oauthList);
+    return AppAccount::GetInstance().GetOAuthList(name, authType, oauthList);
 }
 
 ErrCode AppAccountManager::GetAuthList(
     const std::string &name, const std::string &authType, std::set<std::string> &oauthList)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->GetAuthList(name, authType, oauthList);
+    return AppAccount::GetInstance().GetAuthList(name, authType, oauthList);
 }
 
 ErrCode AppAccountManager::GetAuthenticatorCallback(const std::string &sessionId, sptr<IRemoteObject> &callback)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->GetAuthenticatorCallback(sessionId, callback);
+    return AppAccount::GetInstance().GetAuthenticatorCallback(sessionId, callback);
 }
 
 ErrCode AppAccountManager::GetAllAccounts(const std::string &owner, std::vector<AppAccountInfo> &appAccounts)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->GetAllAccounts(owner, appAccounts);
+    return AppAccount::GetInstance().GetAllAccounts(owner, appAccounts);
 }
 
 ErrCode AppAccountManager::GetAllAccessibleAccounts(std::vector<AppAccountInfo> &appAccounts)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->GetAllAccessibleAccounts(appAccounts);
+    return AppAccount::GetInstance().GetAllAccessibleAccounts(appAccounts);
 }
 
 ErrCode AppAccountManager::QueryAllAccessibleAccounts(
     const std::string &owner, std::vector<AppAccountInfo> &appAccounts)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->QueryAllAccessibleAccounts(owner, appAccounts);
+    return AppAccount::GetInstance().QueryAllAccessibleAccounts(owner, appAccounts);
 }
 
 ErrCode AppAccountManager::CheckAppAccess(const std::string &name, const std::string &authorizedApp, bool &isAccessible)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->CheckAppAccess(name, authorizedApp, isAccessible);
+    return AppAccount::GetInstance().CheckAppAccess(name, authorizedApp, isAccessible);
 }
 
 ErrCode AppAccountManager::DeleteAccountCredential(const std::string &name, const std::string &credentialType)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->DeleteAccountCredential(name, credentialType);
+    return AppAccount::GetInstance().DeleteAccountCredential(name, credentialType);
 }
 
 ErrCode AppAccountManager::SelectAccountsByOptions(
     const SelectAccountsOptions &options, const sptr<IAppAccountAuthenticatorCallback> &callback)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->SelectAccountsByOptions(options, callback);
+    return AppAccount::GetInstance().SelectAccountsByOptions(options, callback);
 }
 
 ErrCode AppAccountManager::VerifyCredential(const std::string &name, const std::string &owner,
     const VerifyCredentialOptions &options, const sptr<IAppAccountAuthenticatorCallback> &callback)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->VerifyCredential(name, owner, options, callback);
+    return AppAccount::GetInstance().VerifyCredential(name, owner, options, callback);
 }
 
 ErrCode AppAccountManager::CheckAccountLabels(const std::string &name, const std::string &owner,
     const std::vector<std::string> &labels, const sptr<IAppAccountAuthenticatorCallback> &callback)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->CheckAccountLabels(name, owner, labels, callback);
+    return AppAccount::GetInstance().CheckAccountLabels(name, owner, labels, callback);
 }
 
 ErrCode AppAccountManager::SetAuthenticatorProperties(const std::string &owner,
     const SetPropertiesOptions &options, const sptr<IAppAccountAuthenticatorCallback> &callback)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->SetAuthenticatorProperties(owner, options, callback);
+    return AppAccount::GetInstance().SetAuthenticatorProperties(owner, options, callback);
 }
 
 ErrCode AppAccountManager::SubscribeAppAccount(const std::shared_ptr<AppAccountSubscriber> &subscriber)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->SubscribeAppAccount(subscriber);
+    return AppAccount::GetInstance().SubscribeAppAccount(subscriber);
 }
 
 ErrCode AppAccountManager::UnsubscribeAppAccount(const std::shared_ptr<AppAccountSubscriber> &subscriber)
 {
-    return DelayedSingleton<AppAccount>::GetInstance()->UnsubscribeAppAccount(subscriber);
+    return AppAccount::GetInstance().UnsubscribeAppAccount(subscriber);
 }
 }  // namespace AccountSA
 }  // namespace OHOS

frameworks/appaccount/native/test/unittest/app_account_manager_test.cpp

@@ -2150,15 +2150,13 @@ HWTEST_F(AppAccountManagerTest, AppAccountManager_QueryAllAccessibleAccounts_010
  */
 HWTEST_F(AppAccountManagerTest, AppAccountManager_UnsubscribeAppAccount_0100, TestSize.Level1)
 {
-    auto appAccountPtr = DelayedSingleton<AppAccount>::GetInstance();
-    ASSERT_NE(appAccountPtr, nullptr);
     AppAccountSubscribeInfo subscribeInfo;
     std::shared_ptr<AppAccountSubscriberTest> appAccountSubscriberPtr =
         std::make_shared<AppAccountSubscriberTest>(subscribeInfo);
     ASSERT_NE(appAccountSubscriberPtr, nullptr);
     auto appAccountEventListenerSptr = new (std::nothrow) AppAccountEventListener(appAccountSubscriberPtr);
     ASSERT_NE(appAccountEventListenerSptr, nullptr);
-    appAccountPtr->eventListeners_[appAccountSubscriberPtr] = appAccountEventListenerSptr;
-    ErrCode result = appAccountPtr->UnsubscribeAppAccount(appAccountSubscriberPtr);
+    AppAccount::GetInstance().eventListeners_[appAccountSubscriberPtr] = appAccountEventListenerSptr;
+    ErrCode result = AppAccount::GetInstance().UnsubscribeAppAccount(appAccountSubscriberPtr);
     ASSERT_EQ(result, ERR_OK);
 }

frameworks/common/utils/include/account_permission_manager.h

@@ -16,18 +16,15 @@
 #ifndef OS_ACCOUNT_SERVICES_ACCOUNTMGR_INCLUDE_ACCOUNT_PERMISSION_MANAGER_H
 #define OS_ACCOUNT_SERVICES_ACCOUNTMGR_INCLUDE_ACCOUNT_PERMISSION_MANAGER_H
 
+#include <string>
 #include "account_error_no.h"
-#include "singleton.h"
 
 namespace OHOS {
 namespace AccountSA {
-class AccountPermissionManager : public DelayedSingleton<AccountPermissionManager> {
+class AccountPermissionManager {
 public:
-    AccountPermissionManager();
-    ~AccountPermissionManager();
-
-    ErrCode VerifyPermission(const std::string &permissionName);
-    ErrCode CheckSystemApp(bool isCallStub = true);
+    static ErrCode VerifyPermission(const std::string &permissionName);
+    static ErrCode CheckSystemApp(bool isCallStub = true);
 
     static const std::string DISTRIBUTED_DATASYNC;
     static const std::string GET_ALL_APP_ACCOUNTS;

frameworks/common/utils/src/account_permission_manager.cpp

@@ -36,12 +36,6 @@ const std::string AccountPermissionManager::ACCESS_USER_AUTH_INTERNAL = "ohos.pe
 const std::string AccountPermissionManager::MANAGE_USER_IDM = "ohos.permission.MANAGE_USER_IDM";
 const std::string AccountPermissionManager::USE_USER_IDM = "ohos.permission.USE_USER_IDM";
 
-AccountPermissionManager::AccountPermissionManager()
-{}
-
-AccountPermissionManager::~AccountPermissionManager()
-{}
-
 ErrCode AccountPermissionManager::VerifyPermission(const std::string &permissionName)
 {
     AccessTokenID callingToken = IPCSkeleton::GetCallingTokenID();

frameworks/domain_account/src/domain_account_client.cpp

@@ -26,6 +26,12 @@
 
 namespace OHOS {
 namespace AccountSA {
+DomainAccountClient &DomainAccountClient::GetInstance()
+{
+    static DomainAccountClient instance;
+    return instance;
+}
+
 ErrCode DomainAccountClient::RegisterPlugin(const std::shared_ptr<DomainAccountPlugin> &plugin)
 {
     if (plugin == nullptr) {
@@ -160,7 +166,7 @@ sptr<IDomainAccount> DomainAccountClient::GetDomainAccountProxy()
     if (proxy_ != nullptr) {
         return proxy_;
     }
-    sptr<IRemoteObject> object = DelayedRefSingleton<OhosAccountKitsImpl>::GetInstance().GetDomainAccountService();
+    sptr<IRemoteObject> object = OhosAccountKitsImpl::GetInstance().GetDomainAccountService();
     if (object == nullptr) {
         ACCOUNT_LOGE("failed to get domain account service");
         return nullptr;

frameworks/ohosaccount/native/src/ohos_account_kits.cpp

@@ -22,7 +22,7 @@ namespace OHOS {
 namespace AccountSA {
 OhosAccountKits& OhosAccountKits::GetInstance()
 {
-    return DelayedRefSingleton<OhosAccountKitsImpl>::GetInstance();
+    return OhosAccountKitsImpl::GetInstance();
 }
 } // namespace AccountSA
 } // namespace OHOS

frameworks/ohosaccount/native/src/ohos_account_kits_impl.cpp

@@ -23,8 +23,11 @@
 
 namespace OHOS {
 namespace AccountSA {
-OhosAccountKitsImpl::OhosAccountKitsImpl() {}
-OhosAccountKitsImpl::~OhosAccountKitsImpl() {}
+OhosAccountKitsImpl &OhosAccountKitsImpl::GetInstance()
+{
+    static OhosAccountKitsImpl instance;
+    return instance;
+}
 
 void OhosAccountKitsImpl::ResetService(const wptr<IRemoteObject>& remote)
 {
@@ -79,7 +82,7 @@ sptr<IAccount> OhosAccountKitsImpl::GetService()
 
 void OhosAccountKitsImpl::DeathRecipient::OnRemoteDied(const wptr<IRemoteObject>& remote)
 {
-    DelayedRefSingleton<OhosAccountKitsImpl>::GetInstance().ResetService(remote);
+    OhosAccountKitsImpl::GetInstance().ResetService(remote);
 }
 
 bool OhosAccountKitsImpl::UpdateOhosAccountInfo(const std::string& accountName, const std::string& uid,

frameworks/osaccount/core/include/os_account.h

@@ -25,6 +25,7 @@ namespace AccountSA {
 class OsAccount {
 public:
     enum SubscribeState { ALREADY_SUBSCRIBED = 0, INITIAL_SUBSCRIPTION, SUBSCRIBE_FAILED };
+    static OsAccount &GetInstance();
     ErrCode CreateOsAccount(const std::string &name, const OsAccountType &type, OsAccountInfo &osAccountInfo);
     ErrCode CreateOsAccountForDomain(const OsAccountType &type, const DomainAccountInfo &domainInfo,
         const std::shared_ptr<DomainAccountCallback> &callback);
@@ -83,6 +84,8 @@ public:
     ErrCode GetDefaultActivatedOsAccount(int32_t &id);
 
 private:
+    OsAccount() = default;
+    ~OsAccount() = default;
     ErrCode GetOsAccountProxy();
     ErrCode CreateOsAccountEventListener(
         const std::shared_ptr<OsAccountSubscriber> &subscriber, sptr<IRemoteObject> &osAccountEventListener);

frameworks/osaccount/core/libos_account_core.map

@@ -16,11 +16,12 @@
     extern "C++" {
         "OHOS::AccountSA::OsAccountInfo::OsAccountInfo()";
         "OHOS::AccountSA::OsAccount::CreateOsAccount(std::__h::basic_string<char, std::__h::char_traits<char>, std::__h::allocator<char> > const&, OHOS::AccountSA::OsAccountType const&, OHOS::AccountSA::OsAccountInfo&)";
-        "VTT for OHOS::AccountSA::OsAccountInfo";
+        "OHOS::AccountSA::OsAccount::GetInstance()";
         "OHOS::AccountSA::OsAccount::RemoveOsAccount(int)";
         "OHOS::AccountSA::OsAccount::DumpState(int const&, std::__h::vector<std::__h::basic_string<char, std::__h::char_traits<char>, std::__h::allocator<char> >, std::__h::allocator<std::__h::basic_string<char, std::__h::char_traits<char>, std::__h::allocator<char> > > >&)";
         "OHOS::AccountSA::OsAccount::SetOsAccountConstraints(int, std::__h::vector<std::__h::basic_string<char, std::__h::char_traits<char>, std::__h::allocator<char> >, std::__h::allocator<std::__h::basic_string<char, std::__h::char_traits<char>, std::__h::allocator<char> > > > const&, bool)";
         "OHOS::AccountSA::OsAccount::ActivateOsAccount(int)";
+        "VTT for OHOS::AccountSA::OsAccountInfo";
     };
   local:
     *;

frameworks/osaccount/core/src/os_account.cpp

@@ -45,6 +45,12 @@ static ErrCode CheckLocalId(int localId)
     return CheckInvalidLocalId(localId);
 }
 
+OsAccount &OsAccount::GetInstance()
+{
+    static OsAccount instance;
+    return instance;
+}
+
 ErrCode OsAccount::CreateOsAccount(const std::string &name, const OsAccountType &type, OsAccountInfo &osAccountInfo)
 {
     if (name.size() > Constants::LOCAL_NAME_MAX_SIZE) {
@@ -523,7 +529,7 @@ ErrCode OsAccount::SubscribeOsAccount(const std::shared_ptr<OsAccountSubscriber>
 
 ErrCode OsAccount::UnsubscribeOsAccount(const std::shared_ptr<OsAccountSubscriber> &subscriber)
 {
-    ErrCode result = DelayedSingleton<AccountPermissionManager>::GetInstance()->CheckSystemApp(false);
+    ErrCode result = AccountPermissionManager::CheckSystemApp(false);
     if (result != ERR_OK) {
         ACCOUNT_LOGE("is not system application, result = %{public}u.", result);
         return result;

frameworks/osaccount/core/src/os_account_death_recipient.cpp

@@ -15,7 +15,6 @@
 
 #include "account_log_wrapper.h"
 #include "os_account.h"
-#include "singleton.h"
 
 #include "os_account_death_recipient.h"
 
@@ -23,7 +22,7 @@ namespace OHOS {
 namespace AccountSA {
 void OsAccountDeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &remote)
 {
-    DelayedSingleton<OsAccount>::GetInstance()->ResetOsAccountProxy();
+    OsAccount::GetInstance().ResetOsAccountProxy();
 }
 }  // namespace AccountSA
 }  // namespace OHOS

frameworks/osaccount/native/src/os_account_manager.cpp

@@ -17,7 +17,6 @@
 #include "account_log_wrapper.h"
 #include "account_permission_manager.h"
 #include "os_account.h"
-#include "singleton.h"
 
 namespace OHOS {
 namespace AccountSA {
@@ -25,62 +24,60 @@ namespace AccountSA {
 ErrCode OsAccountManager::CreateOsAccount(
     const std::string &name, const OsAccountType &type, OsAccountInfo &osAccountInfo)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->CreateOsAccount(name, type, osAccountInfo);
+    return OsAccount::GetInstance().CreateOsAccount(name, type, osAccountInfo);
 }
 
 ErrCode OsAccountManager::CreateOsAccountForDomain(const OsAccountType &type, const DomainAccountInfo &domainInfo,
     const std::shared_ptr<DomainAccountCallback> &callback)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->CreateOsAccountForDomain(
-        type, domainInfo, callback);
+    return OsAccount::GetInstance().CreateOsAccountForDomain(type, domainInfo, callback);
 }
 
 ErrCode OsAccountManager::RemoveOsAccount(const int id)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->RemoveOsAccount(id);
+    return OsAccount::GetInstance().RemoveOsAccount(id);
 }
 
 ErrCode OsAccountManager::IsOsAccountExists(const int id, bool &isOsAccountExists)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->IsOsAccountExists(id, isOsAccountExists);
+    return OsAccount::GetInstance().IsOsAccountExists(id, isOsAccountExists);
 }
 
 ErrCode OsAccountManager::IsOsAccountActived(const int id, bool &isOsAccountActived)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->IsOsAccountActived(id, isOsAccountActived);
+    return OsAccount::GetInstance().IsOsAccountActived(id, isOsAccountActived);
 }
 
 ErrCode OsAccountManager::IsOsAccountConstraintEnable(
     const int id, const std::string &constraint, bool &isConstraintEnable)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->IsOsAccountConstraintEnable(id, constraint, isConstraintEnable);
+    return OsAccount::GetInstance().IsOsAccountConstraintEnable(id, constraint, isConstraintEnable);
 }
 
 ErrCode OsAccountManager::CheckOsAccountConstraintEnabled(
     const int id, const std::string &constraint, bool &isEnabled)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->
-        CheckOsAccountConstraintEnabled(id, constraint, isEnabled);
+    return OsAccount::GetInstance().CheckOsAccountConstraintEnabled(id, constraint, isEnabled);
 }
 
 ErrCode OsAccountManager::IsOsAccountVerified(const int id, bool &isVerified)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->IsOsAccountVerified(id, isVerified);
+    return OsAccount::GetInstance().IsOsAccountVerified(id, isVerified);
 }
 
 ErrCode OsAccountManager::GetCreatedOsAccountsCount(unsigned int &osAccountsCount)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->GetCreatedOsAccountsCount(osAccountsCount);
+    return OsAccount::GetInstance().GetCreatedOsAccountsCount(osAccountsCount);
 }
 
 ErrCode OsAccountManager::GetOsAccountLocalIdFromProcess(int &id)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->GetOsAccountLocalIdFromProcess(id);
+    return OsAccount::GetInstance().GetOsAccountLocalIdFromProcess(id);
 }
 
 ErrCode OsAccountManager::IsMainOsAccount(bool &isMainOsAccount)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->IsMainOsAccount(isMainOsAccount);
+    return OsAccount::GetInstance().IsMainOsAccount(isMainOsAccount);
 }
 
 ErrCode OsAccountManager::GetOsAccountLocalIdFromUid(const int uid, int &id)
@@ -95,7 +92,7 @@ ErrCode OsAccountManager::GetOsAccountLocalIdFromUid(const int uid, int &id)
 
 ErrCode OsAccountManager::GetBundleIdFromUid(const int uid, int &bundleId)
 {
-    ErrCode result = DelayedSingleton<AccountPermissionManager>::GetInstance()->CheckSystemApp(false);
+    ErrCode result = AccountPermissionManager::CheckSystemApp(false);
     if (result != ERR_OK) {
         ACCOUNT_LOGE("is not system application, result = %{public}u.", result);
         return result;
@@ -110,192 +107,192 @@ ErrCode OsAccountManager::GetBundleIdFromUid(const int uid, int &bundleId)
 
 ErrCode OsAccountManager::GetOsAccountLocalIdFromDomain(const DomainAccountInfo &domainInfo, int &id)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->GetOsAccountLocalIdFromDomain(domainInfo, id);
+    return OsAccount::GetInstance().GetOsAccountLocalIdFromDomain(domainInfo, id);
 }
 
 ErrCode OsAccountManager::QueryMaxOsAccountNumber(int &maxOsAccountNumber)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->QueryMaxOsAccountNumber(maxOsAccountNumber);
+    return OsAccount::GetInstance().QueryMaxOsAccountNumber(maxOsAccountNumber);
 }
 
 ErrCode OsAccountManager::GetOsAccountAllConstraints(const int id, std::vector<std::string> &constraints)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->GetOsAccountAllConstraints(id, constraints);
+    return OsAccount::GetInstance().GetOsAccountAllConstraints(id, constraints);
 }
 
 ErrCode OsAccountManager::QueryAllCreatedOsAccounts(std::vector<OsAccountInfo> &osAccountInfos)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->QueryAllCreatedOsAccounts(osAccountInfos);
+    return OsAccount::GetInstance().QueryAllCreatedOsAccounts(osAccountInfos);
 }
 
 ErrCode OsAccountManager::QueryCurrentOsAccount(OsAccountInfo &osAccountInfo)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->QueryCurrentOsAccount(osAccountInfo);
+    return OsAccount::GetInstance().QueryCurrentOsAccount(osAccountInfo);
 }
 
 ErrCode OsAccountManager::QueryOsAccountById(const int id, OsAccountInfo &osAccountInfo)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->QueryOsAccountById(id, osAccountInfo);
+    return OsAccount::GetInstance().QueryOsAccountById(id, osAccountInfo);
 }
 
 ErrCode OsAccountManager::GetOsAccountTypeFromProcess(OsAccountType &type)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->GetOsAccountTypeFromProcess(type);
+    return OsAccount::GetInstance().GetOsAccountTypeFromProcess(type);
 }
 
 ErrCode OsAccountManager::GetOsAccountProfilePhoto(const int id, std::string &photo)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->GetOsAccountProfilePhoto(id, photo);
+    return OsAccount::GetInstance().GetOsAccountProfilePhoto(id, photo);
 }
 
 ErrCode OsAccountManager::IsMultiOsAccountEnable(bool &isMultiOsAccountEnable)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->IsMultiOsAccountEnable(isMultiOsAccountEnable);
+    return OsAccount::GetInstance().IsMultiOsAccountEnable(isMultiOsAccountEnable);
 }
 
 ErrCode OsAccountManager::SetOsAccountName(const int id, const std::string &localName)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->SetOsAccountName(id, localName);
+    return OsAccount::GetInstance().SetOsAccountName(id, localName);
 }
 
 ErrCode OsAccountManager::SetOsAccountConstraints(
     const int id, const std::vector<std::string> &constraints, const bool enable)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->SetOsAccountConstraints(id, constraints, enable);
+    return OsAccount::GetInstance().SetOsAccountConstraints(id, constraints, enable);
 }
 
 ErrCode OsAccountManager::SetOsAccountProfilePhoto(const int id, const std::string &photo)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->SetOsAccountProfilePhoto(id, photo);
+    return OsAccount::GetInstance().SetOsAccountProfilePhoto(id, photo);
 }
 
 ErrCode OsAccountManager::GetDistributedVirtualDeviceId(std::string &deviceId)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->GetDistributedVirtualDeviceId(deviceId);
+    return OsAccount::GetInstance().GetDistributedVirtualDeviceId(deviceId);
 }
 
 ErrCode OsAccountManager::ActivateOsAccount(const int id)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->ActivateOsAccount(id);
+    return OsAccount::GetInstance().ActivateOsAccount(id);
 }
 
 ErrCode OsAccountManager::StartOsAccount(const int id)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->StartOsAccount(id);
+    return OsAccount::GetInstance().StartOsAccount(id);
 }
 
 ErrCode OsAccountManager::StopOsAccount(const int id)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->StopOsAccount(id);
+    return OsAccount::GetInstance().StopOsAccount(id);
 }
 
 ErrCode OsAccountManager::GetOsAccountLocalIdBySerialNumber(const int64_t serialNumber, int &id)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->GetOsAccountLocalIdBySerialNumber(serialNumber, id);
+    return OsAccount::GetInstance().GetOsAccountLocalIdBySerialNumber(serialNumber, id);
 }
 
 ErrCode OsAccountManager::GetSerialNumberByOsAccountLocalId(const int &id, int64_t &serialNumber)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->GetSerialNumberByOsAccountLocalId(id, serialNumber);
+    return OsAccount::GetInstance().GetSerialNumberByOsAccountLocalId(id, serialNumber);
 }
 
 ErrCode OsAccountManager::SubscribeOsAccount(const std::shared_ptr<OsAccountSubscriber> &subscriber)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->SubscribeOsAccount(subscriber);
+    return OsAccount::GetInstance().SubscribeOsAccount(subscriber);
 }
 
 ErrCode OsAccountManager::UnsubscribeOsAccount(const std::shared_ptr<OsAccountSubscriber> &subscriber)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->UnsubscribeOsAccount(subscriber);
+    return OsAccount::GetInstance().UnsubscribeOsAccount(subscriber);
 }
 OS_ACCOUNT_SWITCH_MOD OsAccountManager::GetOsAccountSwitchMod()
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->GetOsAccountSwitchMod();
+    return OsAccount::GetInstance().GetOsAccountSwitchMod();
 }
 
 ErrCode OsAccountManager::IsCurrentOsAccountVerified(bool &isVerified)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->IsCurrentOsAccountVerified(isVerified);
+    return OsAccount::GetInstance().IsCurrentOsAccountVerified(isVerified);
 }
 
 ErrCode OsAccountManager::IsOsAccountCompleted(const int id, bool &isOsAccountCompleted)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->IsOsAccountCompleted(id, isOsAccountCompleted);
+    return OsAccount::GetInstance().IsOsAccountCompleted(id, isOsAccountCompleted);
 }
 
 ErrCode OsAccountManager::SetCurrentOsAccountIsVerified(const bool isVerified)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->SetCurrentOsAccountIsVerified(isVerified);
+    return OsAccount::GetInstance().SetCurrentOsAccountIsVerified(isVerified);
 }
 
 ErrCode OsAccountManager::SetOsAccountIsVerified(const int id, const bool isVerified)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->SetOsAccountIsVerified(id, isVerified);
+    return OsAccount::GetInstance().SetOsAccountIsVerified(id, isVerified);
 }
 
 ErrCode OsAccountManager::GetCreatedOsAccountNumFromDatabase(const std::string& storeID, int &createdOsAccountNum)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->GetCreatedOsAccountNumFromDatabase(
+    return OsAccount::GetInstance().GetCreatedOsAccountNumFromDatabase(
         storeID, createdOsAccountNum);
 }
 
 ErrCode OsAccountManager::GetSerialNumberFromDatabase(const std::string& storeID, int64_t &serialNumber)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->GetSerialNumberFromDatabase(storeID, serialNumber);
+    return OsAccount::GetInstance().GetSerialNumberFromDatabase(storeID, serialNumber);
 }
 
 ErrCode OsAccountManager::GetMaxAllowCreateIdFromDatabase(const std::string& storeID, int &id)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->GetMaxAllowCreateIdFromDatabase(storeID, id);
+    return OsAccount::GetInstance().GetMaxAllowCreateIdFromDatabase(storeID, id);
 }
 
 ErrCode OsAccountManager::GetOsAccountFromDatabase(const std::string& storeID,
                                                    const int id,
                                                    OsAccountInfo &osAccountInfo)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->GetOsAccountFromDatabase(storeID, id, osAccountInfo);
+    return OsAccount::GetInstance().GetOsAccountFromDatabase(storeID, id, osAccountInfo);
 }
 
 ErrCode OsAccountManager::GetOsAccountListFromDatabase(const std::string& storeID,
                                                        std::vector<OsAccountInfo> &osAccountList)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->GetOsAccountListFromDatabase(storeID, osAccountList);
+    return OsAccount::GetInstance().GetOsAccountListFromDatabase(storeID, osAccountList);
 }
 
 ErrCode OsAccountManager::QueryActiveOsAccountIds(std::vector<int32_t>& ids)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->QueryActiveOsAccountIds(ids);
+    return OsAccount::GetInstance().QueryActiveOsAccountIds(ids);
 }
 
 ErrCode OsAccountManager::QueryOsAccountConstraintSourceTypes(const int32_t id, const std::string constraint,
     std::vector<ConstraintSourceTypeInfo> &constraintSourceTypeInfos)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->
+    return OsAccount::GetInstance().
         QueryOsAccountConstraintSourceTypes(id, constraint, constraintSourceTypeInfos);
 }
 
 ErrCode OsAccountManager::SetGlobalOsAccountConstraints(const std::vector<std::string> &constraints,
     const bool enable, const int32_t enforcerId, const bool isDeviceOwner)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->
+    return OsAccount::GetInstance().
         SetGlobalOsAccountConstraints(constraints, enable, enforcerId, isDeviceOwner);
 }
 
 ErrCode OsAccountManager::SetSpecificOsAccountConstraints(const std::vector<std::string> &constraints,
     const bool enable, const int32_t targetId, const int32_t enforcerId, const bool isDeviceOwner)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->
+    return OsAccount::GetInstance().
         SetSpecificOsAccountConstraints(constraints, enable, targetId, enforcerId, isDeviceOwner);
 }
 
 ErrCode OsAccountManager::SetDefaultActivatedOsAccount(const int32_t id)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->SetDefaultActivatedOsAccount(id);
+    return OsAccount::GetInstance().SetDefaultActivatedOsAccount(id);
 }
 
 ErrCode OsAccountManager::GetDefaultActivatedOsAccount(int32_t &id)
 {
-    return DelayedSingleton<OsAccount>::GetInstance()->GetDefaultActivatedOsAccount(id);
+    return OsAccount::GetInstance().GetDefaultActivatedOsAccount(id);
 }
 }  // namespace AccountSA
 }  // namespace OHOS

interfaces/innerkits/account_iam/native/include/account_iam_client.h

@@ -25,13 +25,12 @@
 #include "account_error_no.h"
 #include "account_permission_manager.h"
 #include "iaccount_iam.h"
-#include "singleton.h"
 
 namespace OHOS {
 namespace AccountSA {
-class AccountIAMClient : public DelayedRefSingleton<AccountIAMClient> {
+class AccountIAMClient {
 public:
-    AccountIAMClient();
+    static AccountIAMClient &GetInstance();
     int32_t OpenSession(int32_t userId, std::vector<uint8_t> &challenge);
     int32_t CloseSession(int32_t userId);
     void AddCredential(
@@ -65,6 +64,8 @@ public:
     void ClearCredential(int32_t userId);
 
 private:
+    AccountIAMClient() = default;
+    ~AccountIAMClient() = default;
     class AccountIAMDeathRecipient : public IRemoteObject::DeathRecipient {
     public:
         AccountIAMDeathRecipient() = default;
@@ -91,7 +92,6 @@ private:
     sptr<AccountIAMDeathRecipient> deathRecipient_ = nullptr;
     std::shared_ptr<IInputer> pinInputer_ = nullptr;
     std::shared_ptr<IInputer> domainInputer_ = nullptr;
-    std::shared_ptr<AccountPermissionManager> permissionManagerPtr_ = nullptr;
 };
 }  // namespace AccountSA
 }  // namespace OHOS

interfaces/innerkits/domain_account/native/include/domain_account_client.h

@@ -22,12 +22,12 @@
 #include "domain_account_plugin.h"
 #include "domain_auth_callback_service.h"
 #include "idomain_account.h"
-#include "singleton.h"
 
 namespace OHOS {
 namespace AccountSA {
-class DomainAccountClient : public DelayedRefSingleton<DomainAccountClient> {
+class DomainAccountClient {
 public:
+    static DomainAccountClient &GetInstance();
     ErrCode RegisterPlugin(const std::shared_ptr<DomainAccountPlugin> &plugin);
     ErrCode UnregisterPlugin();
     ErrCode Auth(const DomainAccountInfo &info, const std::vector<uint8_t> &password,
@@ -38,6 +38,8 @@ public:
     ErrCode HasDomainAccount(const DomainAccountInfo &info, const std::shared_ptr<DomainAccountCallback> &callback);
 
 private:
+    DomainAccountClient() = default;
+    ~DomainAccountClient() = default;
     class DomainAccountDeathRecipient : public IRemoteObject::DeathRecipient {
     public:
         DomainAccountDeathRecipient() = default;

interfaces/innerkits/ohosaccount/native/include/ohos_account_kits_impl.h

@@ -19,15 +19,13 @@
 #include <mutex>
 #include "ipc_skeleton.h"
 #include "ohos_account_kits.h"
-#include "singleton.h"
 
 namespace OHOS {
 namespace AccountSA {
-class OhosAccountKitsImpl final : public OhosAccountKits, public DelayedRefSingleton<OhosAccountKitsImpl> {
-    DECLARE_DELAYED_REF_SINGLETON(OhosAccountKitsImpl);
-
+class OhosAccountKitsImpl final : public OhosAccountKits {
 public:
     DISALLOW_COPY_AND_MOVE(OhosAccountKitsImpl);
+    static OhosAccountKitsImpl &GetInstance();
     bool UpdateOhosAccountInfo(const std::string& accountName, const std::string& uid,
         const std::string& eventStr) final;
     std::int32_t SetOhosAccountInfo(const OhosAccountInfo &ohosAccountInfo,
@@ -41,6 +39,8 @@ public:
     sptr<IRemoteObject> GetDomainAccountService();
 
 private:
+    OhosAccountKitsImpl() = default;
+    ~OhosAccountKitsImpl() = default;
     // For death event procession
     class DeathRecipient final : public IRemoteObject::DeathRecipient {
     public:

services/accountmgr/include/account_iam/account_iam_mgr_stub.h

@@ -58,7 +58,6 @@ private:
 
 private:
     static const std::map<uint32_t, AccountIAMMessageProc> messageProcMap_;
-    std::shared_ptr<AccountPermissionManager> permissionManagerPtr_ = nullptr;
     DISALLOW_COPY_AND_MOVE(AccountIAMMgrStub);
 };
 }  // namespace AccountSA

services/accountmgr/include/account_iam/inner_account_iam_manager.h

@@ -38,9 +38,9 @@ struct AccountCredentialInfo {
     std::vector<uint8_t> secret;
 };
 
-class InnerAccountIAMManager : public DelayedRefSingleton<InnerAccountIAMManager> {
+class InnerAccountIAMManager {
 public:
-    InnerAccountIAMManager();
+    static InnerAccountIAMManager &GetInstance();
     void OpenSession(int32_t userId, std::vector<uint8_t> &challenge);
     void CloseSession(int32_t userId);
     void AddCredential(
@@ -73,6 +73,8 @@ public:
     bool CheckDomainAuthAvailable(int32_t userId);
 
 private:
+    InnerAccountIAMManager();
+    ~InnerAccountIAMManager() = default;
     ErrCode UpdateStorageKey(int32_t userId, const std::vector<uint8_t> &token,
         const std::vector<uint8_t> &oldSecret, const std::vector<uint8_t> &newSecret);
     ErrCode GetStorageManagerProxy();

services/accountmgr/include/appaccount/app_account_authenticator_manager.h

@@ -18,21 +18,12 @@
 
 #include "account_error_no.h"
 #include "app_account_common.h"
-#include "singleton.h"
 
 namespace OHOS {
 namespace AccountSA {
-class AppAccountAuthenticatorManager : public DelayedSingleton<AppAccountAuthenticatorManager> {
+class AppAccountAuthenticatorManager {
 public:
-    AppAccountAuthenticatorManager();
-    virtual ~AppAccountAuthenticatorManager();
-    ErrCode GetAuthenticatorInfo(const std::string &owner, int32_t userId, AuthenticatorInfo &info);
-
-private:
-    void Init();
-
-private:
-    bool isInitialized_ = false;
+    static ErrCode GetAuthenticatorInfo(const std::string &owner, int32_t userId, AuthenticatorInfo &info);
 };
 }  // namespace AccountSA
 }  // namespace OHOS

services/accountmgr/include/appaccount/app_account_authenticator_session.h

@@ -91,7 +91,6 @@ protected:
 private:
     void Init();
     void CloseSelf() const;
-    int32_t UpdateAuthInfo(const AAFwk::Want &result) const;
     int32_t OnAuthenticateDone(const AAFwk::Want &result) const;
     int32_t OnAddAccountImplicitlyDone(const AAFwk::Want &result) const;
 

services/accountmgr/include/appaccount/app_account_authenticator_session_manager.h

@@ -40,11 +40,9 @@ public:
     void OnAbilityStateChanged(const AppExecFwk::AbilityStateData &abilityStateData) override;
 };
 
-class AppAccountAuthenticatorSessionManager : public DelayedSingleton<AppAccountAuthenticatorSessionManager> {
+class AppAccountAuthenticatorSessionManager {
 public:
-    AppAccountAuthenticatorSessionManager();
-    virtual ~AppAccountAuthenticatorSessionManager();
-
+    static AppAccountAuthenticatorSessionManager &GetInstance();
     ErrCode AddAccountImplicitly(const AuthenticatorSessionRequest &request);
     ErrCode Authenticate(const AuthenticatorSessionRequest &request);
     ErrCode CreateAccountImplicitly(const AuthenticatorSessionRequest &request);
@@ -71,6 +69,8 @@ public:
     void OnSessionRequestContinued(const std::string &sessionId);
 
 private:
+    AppAccountAuthenticatorSessionManager() = default;
+    ~AppAccountAuthenticatorSessionManager();
     void RegisterApplicationStateObserver();
     void UnregisterApplicationStateObserver();
 

services/accountmgr/include/appaccount/app_account_control_manager.h

@@ -23,7 +23,6 @@
 #include "app_account_data_storage.h"
 #include "iapp_account_authenticator_callback.h"
 #include "iremote_object.h"
-#include "singleton.h"
 #include "want_params.h"
 
 namespace OHOS {
@@ -34,11 +33,9 @@ struct AssociatedDataCacheItem {
     int32_t freq;
 };
 
-class AppAccountControlManager : public DelayedSingleton<AppAccountControlManager> {
+class AppAccountControlManager {
 public:
-    AppAccountControlManager();
-    virtual ~AppAccountControlManager() = default;
-
+    static AppAccountControlManager &GetInstance();
     ErrCode AddAccount(const std::string &name, const std::string &extraInfo, const uid_t &uid,
         const std::string &bundleName, AppAccountInfo &appAccountInfo);
     ErrCode CreateAccount(const std::string &name, const CreateAccountOptions &options, const uid_t &uid,
@@ -109,6 +106,8 @@ public:
     void OnAbilityStateChanged(const AppExecFwk::AbilityStateData &abilityStateData);
 
 private:
+    AppAccountControlManager() = default;
+    ~AppAccountControlManager() = default;
     bool RegisterApplicationStateObserver();
     void UnregisterApplicationStateObserver();
     void PopDataFromAssociatedDataCache();

services/accountmgr/include/appaccount/app_account_manager_service.h

@@ -116,7 +116,6 @@ private:
 
 private:
     std::shared_ptr<InnerAppAccountManager> innerManager_ = nullptr;
-    std::shared_ptr<AccountPermissionManager> permissionManagerPtr_ = nullptr;
 #ifdef HAS_CES_PART
     std::shared_ptr<AppAccountCommonEventObserver> observer_ = nullptr;
 #endif // HAS_CES_PART

services/accountmgr/include/appaccount/app_account_subscribe_manager.h

@@ -25,11 +25,9 @@
 
 namespace OHOS {
 namespace AccountSA {
-class AppAccountSubscribeManager : public DelayedSingleton<AppAccountSubscribeManager> {
+class AppAccountSubscribeManager {
 public:
-    AppAccountSubscribeManager();
-    virtual ~AppAccountSubscribeManager() = default;
-
+    static AppAccountSubscribeManager &GetInstance();
     ErrCode SubscribeAppAccount(const std::shared_ptr<AppAccountSubscribeInfo> &subscribeInfoPtr,
         const sptr<IRemoteObject> &eventListener, const uid_t &uid,
         const std::string &bundleName, const uint32_t &appIndex);
@@ -38,6 +36,8 @@ public:
     bool PublishAccount(AppAccountInfo &appAccountInfo, const uid_t &uid, const std::string &bundleName);
 
 private:
+    AppAccountSubscribeManager();
+    ~AppAccountSubscribeManager() = default;
     std::shared_ptr<AppAccountDataStorage> GetDataStorage(const uid_t &uid, const bool &autoSync = false);
     ErrCode GetStoreId(const uid_t &uid, std::string &storeId);
 

services/accountmgr/include/appaccount/inner_app_account_manager.h

@@ -102,10 +102,9 @@ public:
     ErrCode OnUserRemoved(int32_t userId);
 
 private:
-    std::shared_ptr<AppAccountControlManager> controlManagerPtr_ = nullptr;
-    std::shared_ptr<AppAccountSubscribeManager> subscribeManagerPtr_ = nullptr;
-    std::shared_ptr<AppAccountAuthenticatorSessionManager> sessionManagerPtr_ = nullptr;
-    std::shared_ptr<AppAccountAuthenticatorManager> authenticatorManagerPtr_ = nullptr;
+    AppAccountControlManager &controlManager_;
+    AppAccountSubscribeManager &subscribeManager_;
+    AppAccountAuthenticatorSessionManager &sessionManager_;
 
     DISALLOW_COPY_AND_MOVE(InnerAppAccountManager);
 };

services/accountmgr/include/osaccount/iinner_os_account_manager.h

@@ -26,10 +26,9 @@
 
 namespace OHOS {
 namespace AccountSA {
-class IInnerOsAccountManager : public IInnerOsAccount, public DelayedSingleton<IInnerOsAccountManager> {
+class IInnerOsAccountManager : public IInnerOsAccount {
 public:
-    IInnerOsAccountManager();
-    virtual ~IInnerOsAccountManager() = default;
+    static IInnerOsAccountManager &GetInstance();
     void Init() override;
     ErrCode CreateOsAccount(
         const std::string &name, const OsAccountType &type, OsAccountInfo &osAccountInfo) override;
@@ -91,6 +90,8 @@ public:
     ErrCode SendMsgForAccountCreate(OsAccountInfo &osAccountInfo);
 
 private:
+    IInnerOsAccountManager();
+    ~IInnerOsAccountManager() = default;
     void SetOsAccountControl(std::shared_ptr<IOsAccountControl> ptr);
     void StartAccount();
     void RestartActiveAccount();
@@ -122,7 +123,7 @@ private:
     std::shared_ptr<IOsAccountControl> osAccountControl_;
     std::vector<int32_t> activeAccountId_;
     std::vector<int32_t> operatingId_;
-    std::shared_ptr<IOsAccountSubscribe> subscribeManagerPtr_;
+    IOsAccountSubscribe &subscribeManager_;
     std::int32_t deviceOwnerId_;
     std::int32_t defaultActivatedId_;
     mutable std::mutex ativeMutex_;

services/accountmgr/include/osaccount/os_account_manager_service.h

@@ -116,8 +116,7 @@ private:
     bool PermissionCheck(const std::string& permissionName, const std::string& constraintName);
 
 private:
-    std::shared_ptr<IInnerOsAccount> innerManager_;
-    std::shared_ptr<AccountPermissionManager> permissionManagerPtr_;
+    IInnerOsAccount &innerManager_;
     DISALLOW_COPY_AND_MOVE(OsAccountManagerService);
 };
 }  // namespace AccountSA

services/accountmgr/include/osaccount/os_account_stub.h

@@ -91,7 +91,6 @@ private:
     template<typename T>
     bool ReadParcelableVector(std::vector<T> &parcelableInfos, MessageParcel &data);
     static const std::map<uint32_t, OsAccountMessageProc> messageProcMap_;
-    std::shared_ptr<AccountPermissionManager> permissionManagerPtr_ = nullptr;
     DISALLOW_COPY_AND_MOVE(OsAccountStub);
     ErrCode ProcCheckOsAccountConstraintEnabled(uint32_t code, MessageParcel &data, MessageParcel &reply);
 };

services/accountmgr/include/osaccount/os_account_subscribe_manager.h

@@ -24,11 +24,9 @@
 
 namespace OHOS {
 namespace AccountSA {
-class OsAccountSubscribeManager : public IOsAccountSubscribe, public DelayedSingleton<OsAccountSubscribeManager> {
+class OsAccountSubscribeManager : public IOsAccountSubscribe {
 public:
-    OsAccountSubscribeManager();
-    virtual ~OsAccountSubscribeManager();
-
+    static OsAccountSubscribeManager &GetInstance();
     ErrCode SubscribeOsAccount(const std::shared_ptr<OsAccountSubscribeInfo> &subscribeInfoPtr,
         const sptr<IRemoteObject> &eventListener) override;
     ErrCode UnsubscribeOsAccount(const sptr<IRemoteObject> &eventListener) override;
@@ -37,6 +35,8 @@ public:
     bool OnAccountsChanged(const OsSubscribeRecordPtr &osSubscribeRecordPtr, const int id);
 
 private:
+    OsAccountSubscribeManager();
+    ~OsAccountSubscribeManager() = default;
     ErrCode InsertSubscribeRecord(const OsSubscribeRecordPtr &subscribeRecordPtr);
     ErrCode RemoveSubscribeRecord(const sptr<IRemoteObject> &eventListener);
     ErrCode Publish(const int id, OS_ACCOUNT_SUBSCRIBE_TYPE subscribeType, uint32_t& sendCnt);

services/accountmgr/libaccountmgr.map

@@ -48,6 +48,7 @@
         "OHOS::AccountSA::AppAccountAuthenticatorSessionManager::AppAccountAuthenticatorSessionManager()";
         "OHOS::AccountSA::AppAccountAuthenticatorSessionManager::CloseSession(std::__h::basic_string<char, std::__h::char_traits<char>, std::__h::allocator<char> > const&)";
         "OHOS::AccountSA::AppAccountAuthenticatorSessionManager::GetAuthenticatorCallback(OHOS::AccountSA::AuthenticatorSessionRequest const&, OHOS::sptr<OHOS::IRemoteObject>&)";
+        "OHOS::AccountSA::AppAccountAuthenticatorSessionManager::GetInstance()";
         "OHOS::AccountSA::AppAccountAuthenticatorSessionManager::GetSession(std::__h::basic_string<char, std::__h::char_traits<char>, std::__h::allocator<char> > const&)";
         "OHOS::AccountSA::AppAccountAuthenticatorSessionManager::IsAccountRemovable(OHOS::AccountSA::AuthenticatorSessionRequest const&)";
         "OHOS::AccountSA::AppAccountAuthenticatorSessionManager::OnAbilityStateChanged(OHOS::AppExecFwk::AbilityStateData const&)";
@@ -91,9 +92,11 @@
         "OHOS::AccountSA::AppAccountManagerService::AppAccountManagerService()";
         "OHOS::AccountSA::AppAccountManagerService::GetBundleNameAndCheckPerm(int&, std::__h::basic_string<char, std::__h::char_traits<char>, std::__h::allocator<char> >&, std::__h::basic_string<char, std::__h::char_traits<char>, std::__h::allocator<char> > const&)";
         "OHOS::AccountSA::AppAccountManagerService::GetCallingInfo(int&, std::__h::basic_string<char, std::__h::char_traits<char>, std::__h::allocator<char> >&, unsigned int&)";
+        "OHOS::AccountSA::AppAccountControlManager::GetInstance()";
         "OHOS::AccountSA::AppAccountSubscribeManager::AppAccountSubscribeManager()";
         "OHOS::AccountSA::AppAccountSubscribeManager::CheckAppAccess(std::__h::shared_ptr<OHOS::AccountSA::AppAccountSubscribeInfo> const&, unsigned int const&, std::__h::basic_string<char, std::__h::char_traits<char>, std::__h::allocator<char> > const&, unsigned int const&)";
         "OHOS::AccountSA::AppAccountSubscribeManager::GetAccessibleAccountsBySubscribeInfo(std::__h::shared_ptr<OHOS::AccountSA::AppAccountSubscribeInfo> const&, std::__h::vector<OHOS::AccountSA::AppAccountInfo, std::__h::allocator<OHOS::AccountSA::AppAccountInfo> > const&, std::__h::vector<OHOS::AccountSA::AppAccountInfo, std::__h::allocator<OHOS::AccountSA::AppAccountInfo> >&)";
+        "OHOS::AccountSA::AppAccountSubscribeManager::GetInstance()";
         "OHOS::AccountSA::AppAccountSubscribeManager::InsertSubscribeRecord(std::__h::vector<std::__h::basic_string<char, std::__h::char_traits<char>, std::__h::allocator<char> >, std::__h::allocator<std::__h::basic_string<char, std::__h::char_traits<char>, std::__h::allocator<char> > > > const&, std::__h::shared_ptr<OHOS::AccountSA::AppAccountSubscribeRecord> const&)";
         "OHOS::AccountSA::AppAccountSubscribeManager::RemoveSubscribeRecord(OHOS::sptr<OHOS::IRemoteObject> const&)";
         "OHOS::AccountSA::AppAccountSubscribeManager::SubscribeAppAccount(std::__h::shared_ptr<OHOS::AccountSA::AppAccountSubscribeInfo> const&, OHOS::sptr<OHOS::IRemoteObject> const&, unsigned int const&, std::__h::basic_string<char, std::__h::char_traits<char>, std::__h::allocator<char> > const&, unsigned int const&)";
@@ -102,7 +105,6 @@
         "OHOS::AccountSA::DelCredCallback::DelCredCallback(int, unsigned long, std::__h::vector<unsigned char, std::__h::allocator<unsigned char> > const&, OHOS::sptr<OHOS::AccountSA::IIDMCallback> const&)";
         "OHOS::AccountSA::DomainAccountPluginProxy::DomainAccountPluginProxy(OHOS::sptr<OHOS::IRemoteObject> const&)";
         "OHOS::AccountSA::GetCredInfoCallbackWrapper::GetCredInfoCallbackWrapper(int, int, OHOS::sptr<OHOS::AccountSA::IGetCredInfoCallback> const&)";
-        "OHOS::AccountSA::GetPropCallbackWrapper::GetPropCallbackWrapper(OHOS::sptr<OHOS::AccountSA::IGetSetPropCallback> const&";
         "OHOS::AccountSA::GetPropCallbackWrapper::GetPropCallbackWrapper(OHOS::sptr<OHOS::AccountSA::IGetSetPropCallback> const&)";
         "OHOS::AccountSA::GetValidAccountID(std::__h::basic_string<char, std::__h::char_traits<char>, std::__h::allocator<char> > const&, int&)";
         "OHOS::AccountSA::IAccountContext::instance_";
@@ -113,6 +115,7 @@
         "OHOS::AccountSA::IInnerOsAccountManager::CreateBaseStandardAccount()";
         "OHOS::AccountSA::IInnerOsAccountManager::DeActivateOsAccount(int)";
         "OHOS::AccountSA::IInnerOsAccountManager::EraseIdFromActiveList(int)";
+        "OHOS::AccountSA::IInnerOsAccountManager::GetInstance()";
         "OHOS::AccountSA::IInnerOsAccountManager::IInnerOsAccountManager()";
         "OHOS::AccountSA::IInnerOsAccountManager::IsLocalIdInOperating(int)";
         "OHOS::AccountSA::IInnerOsAccountManager::IsOsAccountIDInActiveList(int)";

services/accountmgr/src/account_iam/account_iam_callback.cpp

@@ -67,7 +67,7 @@ void AuthCallback::OnResult(int32_t result, const Attributes &extraInfo)
         innerCallback_->OnResult(ResultCode::FAIL, errInfo);
     } else {
         innerCallback_->OnResult(result, extraInfo);
-        (void)IInnerOsAccountManager::GetInstance()->SetOsAccountIsVerified(userId_, true);
+        (void)IInnerOsAccountManager::GetInstance().SetOsAccountIsVerified(userId_, true);
     }
 }
 

services/accountmgr/src/account_iam/account_iam_mgr_stub.cpp

@@ -25,9 +25,7 @@
 namespace OHOS {
 namespace AccountSA {
 AccountIAMMgrStub::AccountIAMMgrStub()
-{
-    permissionManagerPtr_ = DelayedSingleton<AccountPermissionManager>::GetInstance();
-}
+{}
 
 AccountIAMMgrStub::~AccountIAMMgrStub()
 {}
@@ -146,7 +144,7 @@ std::int32_t AccountIAMMgrStub::OnRemoteRequest(
     const auto &itFunc = messageProcMap_.find(code);
     if (itFunc != messageProcMap_.end()) {
         if (itFunc->second.isSyetemApi) {
-            result = permissionManagerPtr_->CheckSystemApp();
+            result = AccountPermissionManager::CheckSystemApp();
             if (result != ERR_OK) {
                 ACCOUNT_LOGE("is not system application, result = %{public}u.", result);
                 return result;
@@ -523,7 +521,7 @@ ErrCode AccountIAMMgrStub::ProcGetAccountState(MessageParcel &data, MessageParce
 
 bool AccountIAMMgrStub::CheckPermission(const std::string &permission)
 {
-    if (AccountPermissionManager::GetInstance()->VerifyPermission(permission) != ERR_OK) {
+    if (AccountPermissionManager::VerifyPermission(permission) != ERR_OK) {
         ACCOUNT_LOGE("check permission failed, permission name: %{public}s", permission.c_str());
         return false;
     }

services/accountmgr/src/account_iam/account_iam_service.cpp

@@ -166,7 +166,7 @@ IAMState AccountIAMService::GetAccountState(int32_t userId)
 bool AccountIAMService::GetCurrentUserId(int32_t &userId)
 {
     std::vector<int32_t> userIds;
-    (void)IInnerOsAccountManager::GetInstance()->QueryActiveOsAccountIds(userIds);
+    (void)IInnerOsAccountManager::GetInstance().QueryActiveOsAccountIds(userIds);
     if (userIds.empty()) {
         ACCOUNT_LOGE("fail to get activated os account ids");
         return false;

services/accountmgr/src/account_iam/inner_account_iam_manager.cpp

@@ -42,6 +42,12 @@ InnerAccountIAMManager::InnerAccountIAMManager()
     userStateMap_[0] = IDLE;
 }
 
+InnerAccountIAMManager &InnerAccountIAMManager::GetInstance()
+{
+    static InnerAccountIAMManager instance;
+    return instance;
+}
+
 void InnerAccountIAMManager::OpenSession(int32_t userId, std::vector<uint8_t> &challenge)
 {
     challenge = UserIDMClient::GetInstance().OpenSession(userId);
@@ -195,7 +201,7 @@ ErrCode InnerAccountIAMManager::GetDomainAuthStatusInfo(
     int32_t userId, const GetPropertyRequest &request, const sptr<IGetSetPropCallback> &callback)
 {
     OsAccountInfo osAccountInfo;
-    ErrCode result = IInnerOsAccountManager::GetInstance()->QueryOsAccountById(userId, osAccountInfo);
+    ErrCode result = IInnerOsAccountManager::GetInstance().QueryOsAccountById(userId, osAccountInfo);
     if (result != ERR_OK) {
         ACCOUNT_LOGE("failed to get account info");
         return result;
@@ -218,7 +224,7 @@ ErrCode InnerAccountIAMManager::GetDomainAuthStatusInfo(
 bool InnerAccountIAMManager::CheckDomainAuthAvailable(int32_t userId)
 {
     OsAccountInfo osAccountInfo;
-    if (IInnerOsAccountManager::GetInstance()->QueryOsAccountById(userId, osAccountInfo) != ERR_OK) {
+    if (IInnerOsAccountManager::GetInstance().QueryOsAccountById(userId, osAccountInfo) != ERR_OK) {
         ACCOUNT_LOGE("failed to get account info");
         return false;
     }

services/accountmgr/src/appaccount/app_account_app_state_observer.cpp

@@ -23,10 +23,7 @@ AppAccountAppStateObserver::AppAccountAppStateObserver()
 
 void AppAccountAppStateObserver::OnAbilityStateChanged(const AppExecFwk::AbilityStateData &abilityStateData)
 {
-    auto controlManager = AppAccountControlManager::GetInstance();
-    if (controlManager != nullptr) {
-        controlManager->OnAbilityStateChanged(abilityStateData);
-    }
+    AppAccountControlManager::GetInstance().OnAbilityStateChanged(abilityStateData);
 }
 }  // namespace AccountSA
 }  // OHOS

services/accountmgr/src/appaccount/app_account_authenticator_callback.cpp

@@ -29,26 +29,17 @@ AppAccountAuthenticatorCallback::~AppAccountAuthenticatorCallback()
 
 void AppAccountAuthenticatorCallback::OnResult(int32_t resultCode, const AAFwk::Want &result)
 {
-    auto sessionMgr = AppAccountAuthenticatorSessionManager::GetInstance();
-    if (sessionMgr != nullptr) {
-        sessionMgr->OnSessionResult(sessionId_, resultCode, result);
-    }
+    AppAccountAuthenticatorSessionManager::GetInstance().OnSessionResult(sessionId_, resultCode, result);
 }
 
 void AppAccountAuthenticatorCallback::OnRequestRedirected(AAFwk::Want &request)
 {
-    auto sessionMgr = AppAccountAuthenticatorSessionManager::GetInstance();
-    if (sessionMgr != nullptr) {
-        sessionMgr->OnSessionRequestRedirected(sessionId_, request);
-    }
+    AppAccountAuthenticatorSessionManager::GetInstance().OnSessionRequestRedirected(sessionId_, request);
 }
 
 void AppAccountAuthenticatorCallback::OnRequestContinued()
 {
-    auto sessionMgr = AppAccountAuthenticatorSessionManager::GetInstance();
-    if (sessionMgr != nullptr) {
-        sessionMgr->OnSessionRequestContinued(sessionId_);
-    }
+    AppAccountAuthenticatorSessionManager::GetInstance().OnSessionRequestContinued(sessionId_);
 }
 }  // namespace AccountSA
 }  // namespace OHOS

services/accountmgr/src/appaccount/app_account_authenticator_manager.cpp

@@ -24,22 +24,6 @@
 
 namespace OHOS {
 namespace AccountSA {
-AppAccountAuthenticatorManager::AppAccountAuthenticatorManager()
-{
-    Init();
-}
-
-AppAccountAuthenticatorManager::~AppAccountAuthenticatorManager()
-{}
-
-void AppAccountAuthenticatorManager::Init()
-{
-    if (isInitialized_) {
-        return;
-    }
-    isInitialized_ = true;
-}
-
 static ErrCode QueryAbilityInfos(const std::string &owner, int32_t userId,
     std::vector<AppExecFwk::AbilityInfo> &abilityInfos,
     std::vector<AppExecFwk::ExtensionAbilityInfo> &extensionInfos)
@@ -72,9 +56,6 @@ static ErrCode QueryAbilityInfos(const std::string &owner, int32_t userId,
 ErrCode AppAccountAuthenticatorManager::GetAuthenticatorInfo(
     const std::string &owner, int32_t userId, AuthenticatorInfo &info)
 {
-    if (!isInitialized_) {
-        Init();
-    }
     std::vector<AppExecFwk::AbilityInfo> abilityInfos;
     std::vector<AppExecFwk::ExtensionAbilityInfo> extensionInfos;
     ErrCode ret = QueryAbilityInfos(owner, userId, abilityInfos, extensionInfos);

services/accountmgr/src/appaccount/app_account_authenticator_session.cpp

@@ -15,6 +15,7 @@
 
 #include "app_account_authenticator_session.h"
 
+#include <thread>
 #include "ability_manager_adapter.h"
 #include "account_info.h"
 #include "account_log_wrapper.h"
@@ -32,10 +33,7 @@ SessionClientDeathRecipient::SessionClientDeathRecipient(const std::string &sess
 void SessionClientDeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &remote)
 {
     (void)remote;
-    auto sessionMgr = AppAccountAuthenticatorSessionManager::GetInstance();
-    if (sessionMgr != nullptr) {
-        sessionMgr->CloseSession(sessionId_);
-    }
+    AppAccountAuthenticatorSessionManager::GetInstance().CloseSession(sessionId_);
 }
 
 SessionServerDeathRecipient::SessionServerDeathRecipient(const std::string &sessionId) : sessionId_(sessionId)
@@ -44,10 +42,7 @@ SessionServerDeathRecipient::SessionServerDeathRecipient(const std::string &sess
 void SessionServerDeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &remote)
 {
     (void)remote;
-    auto sessionMgr = AppAccountAuthenticatorSessionManager::GetInstance();
-    if (sessionMgr != nullptr) {
-        sessionMgr->OnSessionServerDied(sessionId_);
-    }
+    AppAccountAuthenticatorSessionManager::GetInstance().OnSessionServerDied(sessionId_);
 }
 
 SessionConnection::SessionConnection(const std::string &sessionId) : sessionId_(sessionId)
@@ -59,18 +54,14 @@ SessionConnection::~SessionConnection()
 void SessionConnection::OnAbilityConnectDone(
     const AppExecFwk::ElementName &element, const sptr<IRemoteObject> &remoteObject, int32_t resultCode)
 {
-    auto sessionMgr = AppAccountAuthenticatorSessionManager::GetInstance();
-    if (sessionMgr != nullptr) {
-        sessionMgr->OnSessionAbilityConnectDone(sessionId_, element, remoteObject, resultCode);
-    }
+    AppAccountAuthenticatorSessionManager::GetInstance().OnSessionAbilityConnectDone(
+        sessionId_, element, remoteObject, resultCode);
 }
 
 void SessionConnection::OnAbilityDisconnectDone(const AppExecFwk::ElementName &element, int resultCode)
 {
-    auto sessionMgr = AppAccountAuthenticatorSessionManager::GetInstance();
-    if (sessionMgr != nullptr) {
-        sessionMgr->OnSessionAbilityDisconnectDone(sessionId_, element, resultCode);
-    }
+    AppAccountAuthenticatorSessionManager::GetInstance().OnSessionAbilityDisconnectDone(
+        sessionId_, element, resultCode);
 }
 
 AppAccountAuthenticatorSession::AppAccountAuthenticatorSession(
@@ -99,11 +90,8 @@ void AppAccountAuthenticatorSession::Init()
     clientDeathRecipient_ = new (std::nothrow) SessionClientDeathRecipient(sessionId_);
     serverDeathRecipient_ = new (std::nothrow) SessionServerDeathRecipient(sessionId_);
     authenticatorCb_ = new (std::nothrow) AppAccountAuthenticatorCallback(sessionId_);
-    controlManager_ = AppAccountControlManager::GetInstance();
-    authenticatorMgr_ = AppAccountAuthenticatorManager::GetInstance();
     if ((conn_ == nullptr) || (clientDeathRecipient_ == nullptr)
-        || (serverDeathRecipient_ == nullptr) || (authenticatorCb_ == nullptr)
-        || (controlManager_ == nullptr) || (authenticatorMgr_ == nullptr)) {
+        || (serverDeathRecipient_ == nullptr) || (authenticatorCb_ == nullptr)) {
         conn_ = nullptr;
         clientDeathRecipient_ = nullptr;
         serverDeathRecipient_ = nullptr;
@@ -126,7 +114,7 @@ ErrCode AppAccountAuthenticatorSession::Open()
         return ERR_APPACCOUNT_SERVICE_OAUTH_SERVICE_EXCEPTION;
     }
     AuthenticatorInfo info;
-    ErrCode errCode = authenticatorMgr_->GetAuthenticatorInfo(request_.owner, userId_, info);
+    ErrCode errCode = AppAccountAuthenticatorManager::GetAuthenticatorInfo(request_.owner, userId_, info);
     if (errCode != ERR_OK) {
         ACCOUNT_LOGE("authenticator not exist, owner: %{public}s, errCode: %{public}d.",
             request_.owner.c_str(), errCode);
@@ -134,11 +122,12 @@ ErrCode AppAccountAuthenticatorSession::Open()
     }
     AAFwk::Want want;
     want.SetElementName(request_.owner, info.abilityName);
-    errCode = AbilityManagerAdapter::GetInstance()->ConnectAbility(want, conn_, nullptr, userId_);
-    if (errCode == ERR_OK) {
-        isOpened_ = true;
-    }
-    return errCode;
+    auto task = std::bind(&AbilityManagerAdapter::ConnectAbility,
+        AbilityManagerAdapter::GetInstance().get(), want, conn_, nullptr, userId_);
+    std::thread taskThread(task);
+    taskThread.detach();
+    isOpened_ = true;
+    return ERR_OK;
 }
 
 void AppAccountAuthenticatorSession::Close()
@@ -157,10 +146,7 @@ void AppAccountAuthenticatorSession::Close()
 
 void AppAccountAuthenticatorSession::CloseSelf() const
 {
-    auto sessionManager = AppAccountAuthenticatorSessionManager::GetInstance();
-    if (sessionManager != nullptr) {
-        sessionManager->CloseSession(sessionId_);
-    }
+    AppAccountAuthenticatorSessionManager::GetInstance().CloseSession(sessionId_);
 }
 
 ErrCode AppAccountAuthenticatorSession::AddClientDeathRecipient()
@@ -310,47 +296,13 @@ int32_t AppAccountAuthenticatorSession::OnRequestContinued() const
     return ERR_JS_SUCCESS;
 }
 
-int32_t AppAccountAuthenticatorSession::UpdateAuthInfo(const AAFwk::Want &result) const
-{
-    std::string name = result.GetStringParam(Constants::KEY_NAME);
-    std::string authType = result.GetStringParam(Constants::KEY_AUTH_TYPE);
-    std::string token = result.GetStringParam(Constants::KEY_TOKEN);
-    AppAccountInfo info(name, request_.owner);
-    info.SetAppIndex(request_.appIndex);
-    ErrCode errCode = ERR_OK;
-    controlManager_->AddAccount(name, "", ownerUid_, request_.owner, info);
-    if (!token.empty()) {
-        AuthenticatorSessionRequest request = {
-            .name = name,
-            .authType = authType,
-            .token = token,
-            .callerBundleName = request_.owner,
-            .callerUid = ownerUid_
-        };
-        errCode = controlManager_->SetOAuthToken(request);
-    }
-    if (authType == request_.authType) {
-        AuthenticatorSessionRequest request = {
-            .name = name,
-            .authType = authType,
-            .token = token,
-            .bundleName = request_.callerBundleName,
-            .callerBundleName = request_.owner,
-            .isTokenVisible = true,
-            .callerUid = ownerUid_
-        };
-        errCode = controlManager_->SetOAuthTokenVisibility(request);
-    }
-    return ConvertToJSErrCode(errCode);
-}
-
 int32_t AppAccountAuthenticatorSession::OnAuthenticateDone(const AAFwk::Want &result) const
 {
     std::string name = result.GetStringParam(Constants::KEY_NAME);
     if (name != request_.name) {
         return ERR_JS_ACCOUNT_AUTHENTICATOR_SERVICE_EXCEPTION;
     }
-    return UpdateAuthInfo(result);
+    return ERR_OK;
 }
 
 int32_t AppAccountAuthenticatorSession::OnAddAccountImplicitlyDone(const AAFwk::Want &result) const
@@ -359,7 +311,10 @@ int32_t AppAccountAuthenticatorSession::OnAddAccountImplicitlyDone(const AAFwk::
     if (name.empty()) {
         return ERR_JS_ACCOUNT_AUTHENTICATOR_SERVICE_EXCEPTION;
     }
-    return UpdateAuthInfo(result);
+    AppAccountInfo info(name, request_.owner);
+    info.SetAppIndex(request_.appIndex);
+    AppAccountControlManager::GetInstance().AddAccount(name, "", ownerUid_, request_.owner, info);
+    return ERR_OK;
 }
 
 void AppAccountAuthenticatorSession::GetRequest(AuthenticatorSessionRequest &request) const

services/accountmgr/src/appaccount/app_account_authenticator_session_manager.cpp

@@ -33,15 +33,9 @@ SessionAppStateObserver::SessionAppStateObserver()
 
 void SessionAppStateObserver::OnAbilityStateChanged(const AppExecFwk::AbilityStateData &abilityStateData)
 {
-    auto sessionManager = AppAccountAuthenticatorSessionManager::GetInstance();
-    if (sessionManager != nullptr) {
-        sessionManager->OnAbilityStateChanged(abilityStateData);
-    }
+    AppAccountAuthenticatorSessionManager::GetInstance().OnAbilityStateChanged(abilityStateData);
 }
 
-AppAccountAuthenticatorSessionManager::AppAccountAuthenticatorSessionManager()
-{}
-
 AppAccountAuthenticatorSessionManager::~AppAccountAuthenticatorSessionManager()
 {
     UnregisterApplicationStateObserver();
@@ -49,6 +43,12 @@ AppAccountAuthenticatorSessionManager::~AppAccountAuthenticatorSessionManager()
     abilitySessions_.clear();
 }
 
+AppAccountAuthenticatorSessionManager &AppAccountAuthenticatorSessionManager::GetInstance()
+{
+    static AppAccountAuthenticatorSessionManager instance;
+    return instance;
+}
+
 void AppAccountAuthenticatorSessionManager::RegisterApplicationStateObserver()
 {
     if (appStateObserver_ != nullptr) {

services/accountmgr/src/appaccount/app_account_check_labels_callback.cpp

@@ -42,32 +42,26 @@ void AppAccountCheckLabelsCallback::SendResult(int32_t resultCode)
         result.SetParam(Constants::KEY_ACCOUNT_NAMES, names);
         result.SetParam(Constants::KEY_ACCOUNT_OWNERS, owners);
     }
-    auto sessionManager = AppAccountAuthenticatorSessionManager::GetInstance();
-    if (sessionManager != nullptr) {
-        sessionManager->OnSessionResult(sessionId_, resultCode, result);
-    }
+    AppAccountAuthenticatorSessionManager::GetInstance().OnSessionResult(sessionId_, resultCode, result);
 }
 
 ErrCode AppAccountCheckLabelsCallback::CheckLabels()
 {
-    auto sessionManager = AppAccountAuthenticatorSessionManager::GetInstance();
-    if (sessionManager == nullptr) {
-        return ERR_APPACCOUNT_SERVICE_OAUTH_SERVICE_EXCEPTION;
-    }
+    auto &sessionManager = AppAccountAuthenticatorSessionManager::GetInstance();
     while (index_ < accounts_.size()) {
         AppAccountInfo account = accounts_[index_];
         AuthenticatorSessionRequest newRequest = request_;
         account.GetOwner(newRequest.owner);
         account.GetName(newRequest.name);
         newRequest.callback = this;
-        if (sessionManager->CheckAccountLabels(newRequest) == ERR_OK) {
+        if (sessionManager.CheckAccountLabels(newRequest) == ERR_OK) {
             break;
         }
         index_++;
     }
     if (index_ >= accounts_.size()) {
         SendResult(ERR_JS_SUCCESS);
-        sessionManager->CloseSession(sessionId_);
+        sessionManager.CloseSession(sessionId_);
         return ERR_OK;
     }
     return ERR_OK;

services/accountmgr/src/appaccount/app_account_control_manager.cpp

@@ -31,8 +31,11 @@
 
 namespace OHOS {
 namespace AccountSA {
-AppAccountControlManager::AppAccountControlManager()
-{}
+AppAccountControlManager &AppAccountControlManager::GetInstance()
+{
+    static AppAccountControlManager instance;
+    return instance;
+}
 
 ErrCode AppAccountControlManager::AddAccount(const std::string &name, const std::string &extraInfo, const uid_t &uid,
     const std::string &bundleName, AppAccountInfo &appAccountInfo)
@@ -726,11 +729,7 @@ ErrCode AppAccountControlManager::SelectAccountsByOptions(
     request.callback = callback;
     request.callerUid = uid;
     request.labels = options.requiredLabels;
-    auto sessionManager = AppAccountAuthenticatorSessionManager::GetInstance();
-    if (sessionManager == nullptr) {
-        return ERR_APPACCOUNT_SERVICE_OAUTH_SERVICE_EXCEPTION;
-    }
-    return sessionManager->SelectAccountsByOptions(candidateAccounts, request);
+    return AppAccountAuthenticatorSessionManager::GetInstance().SelectAccountsByOptions(candidateAccounts, request);
 }
 
 void AppAccountControlManager::RemoveAssociatedDataCacheByUid(const uid_t &uid)

services/accountmgr/src/appaccount/app_account_manager_service.cpp

@@ -27,7 +27,6 @@ namespace AccountSA {
 AppAccountManagerService::AppAccountManagerService()
 {
     innerManager_ = std::make_shared<InnerAppAccountManager>();
-    permissionManagerPtr_ = DelayedSingleton<AccountPermissionManager>::GetInstance();
 #ifdef HAS_CES_PART
     CommonEventCallback callback = {
         std::bind(&AppAccountManagerService::OnPackageRemoved,
@@ -552,7 +551,7 @@ ErrCode AppAccountManagerService::GetAllAccounts(const std::string &owner, std::
         return ret;
     }
     if ((owner != bundleName) &&
-        (permissionManagerPtr_->VerifyPermission(AccountPermissionManager::GET_ALL_APP_ACCOUNTS) != ERR_OK)) {
+        (AccountPermissionManager::VerifyPermission(AccountPermissionManager::GET_ALL_APP_ACCOUNTS) != ERR_OK)) {
         ACCOUNT_LOGE("failed to verify permission for %{public}s",
             AccountPermissionManager::GET_ALL_APP_ACCOUNTS.c_str());
         ReportPermissionFail(callingUid, IPCSkeleton::GetCallingPid(),
@@ -758,7 +757,7 @@ ErrCode AppAccountManagerService::GetBundleNameAndCheckPerm(int32_t &callingUid,
         return result;
     }
 
-    result = permissionManagerPtr_->VerifyPermission(permName);
+    result = AccountPermissionManager::VerifyPermission(permName);
     if (result != ERR_OK) {
         ACCOUNT_LOGE("failed to verify permission for %{public}s, result = %{public}d",
             permName.c_str(), result);

services/accountmgr/src/appaccount/app_account_subscribe_death_recipient.cpp

@@ -33,7 +33,7 @@ void AppAccountSubscribeDeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &
         return;
     }
 
-    DelayedSingleton<AppAccountSubscribeManager>::GetInstance()->UnsubscribeAppAccount(object);
+    AppAccountSubscribeManager::GetInstance().UnsubscribeAppAccount(object);
 }
 }  // namespace AccountSA
 }  // namespace OHOS

services/accountmgr/src/appaccount/app_account_subscribe_manager.cpp

@@ -29,6 +29,12 @@ AppAccountSubscribeManager::AppAccountSubscribeManager()
         new (std::nothrow) AppAccountSubscribeDeathRecipient()))
 {}
 
+AppAccountSubscribeManager &AppAccountSubscribeManager::GetInstance()
+{
+    static AppAccountSubscribeManager instance;
+    return instance;
+}
+
 ErrCode AppAccountSubscribeManager::SubscribeAppAccount(
     const std::shared_ptr<AppAccountSubscribeInfo> &subscribeInfoPtr, const sptr<IRemoteObject> &eventListener,
     const uid_t &uid, const std::string &bundleName, const uint32_t &appIndex)
@@ -140,14 +146,7 @@ ErrCode AppAccountSubscribeManager::CheckAppAccess(const std::shared_ptr<AppAcco
         ACCOUNT_LOGE("failed to get owners, result %{public}d.", result);
         return ERR_APPACCOUNT_SERVICE_GET_OWNERS;
     }
-
-    auto controlManagerPtr = AppAccountControlManager::GetInstance();
-    if (controlManagerPtr == nullptr) {
-        ACCOUNT_LOGE("controlManagerPtr is nullptr");
-        return ERR_APPACCOUNT_SERVICE_CONTROL_MANAGER_PTR_IS_NULLPTR;
-    }
-
-    auto dataStoragePtr = controlManagerPtr->GetDataStorage(uid);
+    auto dataStoragePtr = AppAccountControlManager::GetInstance().GetDataStorage(uid);
     if (dataStoragePtr == nullptr) {
         ACCOUNT_LOGE("dataStoragePtr is nullptr");
         return ERR_APPACCOUNT_SERVICE_DATA_STORAGE_PTR_IS_NULLPTR;
@@ -278,13 +277,8 @@ bool AppAccountSubscribeManager::PublishAccount(
 ErrCode AppAccountSubscribeManager::OnAccountsChanged(const std::shared_ptr<AppAccountEventRecord> &record)
 {
     auto uid = record->uid;
-    auto controlManagerPtr = AppAccountControlManager::GetInstance();
-    if (controlManagerPtr == nullptr) {
-        ACCOUNT_LOGE("controlManagerPtr is nullptr");
-        return ERR_APPACCOUNT_SERVICE_CONTROL_MANAGER_PTR_IS_NULLPTR;
-    }
-
-    auto dataStoragePtr = controlManagerPtr->GetDataStorage(uid);
+    auto &controlManagerPtr = AppAccountControlManager::GetInstance();
+    auto dataStoragePtr = controlManagerPtr.GetDataStorage(uid);
     if (dataStoragePtr == nullptr) {
         ACCOUNT_LOGE("dataStoragePtr is nullptr");
         return ERR_APPACCOUNT_SERVICE_DATA_STORAGE_PTR_IS_NULLPTR;
@@ -292,7 +286,7 @@ ErrCode AppAccountSubscribeManager::OnAccountsChanged(const std::shared_ptr<AppA
 
     for (auto receiver : record->receivers) {
         std::vector<AppAccountInfo> accessibleAccounts;
-        ErrCode result = controlManagerPtr->GetAllAccessibleAccountsFromDataStorage(
+        ErrCode result = controlManagerPtr.GetAllAccessibleAccountsFromDataStorage(
             accessibleAccounts, receiver->bundleName, dataStoragePtr, record->appIndex);
         if (result != ERR_OK) {
             ACCOUNT_LOGE("failed to get all accessible accounts from data storage, result = %{public}d", result);

services/accountmgr/src/appaccount/inner_app_account_manager.cpp

@@ -24,10 +24,9 @@
 namespace OHOS {
 namespace AccountSA {
 InnerAppAccountManager::InnerAppAccountManager()
-    : controlManagerPtr_(AppAccountControlManager::GetInstance()),
-      subscribeManagerPtr_(AppAccountSubscribeManager::GetInstance()),
-      sessionManagerPtr_(AppAccountAuthenticatorSessionManager::GetInstance()),
-      authenticatorManagerPtr_(AppAccountAuthenticatorManager::GetInstance())
+    : controlManager_(AppAccountControlManager::GetInstance()),
+      subscribeManager_(AppAccountSubscribeManager::GetInstance()),
+      sessionManager_(AppAccountAuthenticatorSessionManager::GetInstance())
 {}
 
 InnerAppAccountManager::~InnerAppAccountManager()
@@ -36,220 +35,123 @@ InnerAppAccountManager::~InnerAppAccountManager()
 ErrCode InnerAppAccountManager::AddAccount(const std::string &name, const std::string &extraInfo,
     const uid_t &uid, const std::string &bundleName, const uint32_t &appIndex)
 {
-    if (!controlManagerPtr_) {
-        ACCOUNT_LOGE("controlManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_CONTROL_MANAGER_PTR_IS_NULLPTR;
-    }
-
     AppAccountInfo appAccountInfo(name, bundleName);
     appAccountInfo.SetAppIndex(appIndex);
-    ErrCode result = controlManagerPtr_->AddAccount(name, extraInfo, uid, bundleName, appAccountInfo);
-
-    return result;
+    return controlManager_.AddAccount(name, extraInfo, uid, bundleName, appAccountInfo);
 }
 
 ErrCode InnerAppAccountManager::AddAccountImplicitly(const AuthenticatorSessionRequest &request)
 {
-    if (!sessionManagerPtr_) {
-        ACCOUNT_LOGE("sessionManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_SESSION_MANAGER_PTR_IS_NULLPTR;
-    }
-    return sessionManagerPtr_->AddAccountImplicitly(request);
+    return sessionManager_.AddAccountImplicitly(request);
 }
 
 ErrCode InnerAppAccountManager::CreateAccount(const std::string &name, const CreateAccountOptions &options,
     const uid_t &uid, const std::string &bundleName, const uint32_t &appIndex)
 {
-    if (!controlManagerPtr_) {
-        ACCOUNT_LOGE("controlManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_CONTROL_MANAGER_PTR_IS_NULLPTR;
-    }
-
     AppAccountInfo appAccountInfo(name, bundleName);
     appAccountInfo.SetAppIndex(appIndex);
-    ErrCode result = controlManagerPtr_->CreateAccount(name, options, uid, bundleName, appAccountInfo);
-
-    return result;
+    return controlManager_.CreateAccount(name, options, uid, bundleName, appAccountInfo);
 }
 
 ErrCode InnerAppAccountManager::CreateAccountImplicitly(const AuthenticatorSessionRequest &request)
 {
-    if (!sessionManagerPtr_) {
-        ACCOUNT_LOGE("sessionManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_SESSION_MANAGER_PTR_IS_NULLPTR;
-    }
-    return sessionManagerPtr_->CreateAccountImplicitly(request);
+    return sessionManager_.CreateAccountImplicitly(request);
 }
 
 ErrCode InnerAppAccountManager::DeleteAccount(
     const std::string &name, const uid_t &uid, const std::string &bundleName, const uint32_t &appIndex)
 {
-    if (!controlManagerPtr_) {
-        ACCOUNT_LOGE("controlManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_CONTROL_MANAGER_PTR_IS_NULLPTR;
-    }
-
     AppAccountInfo appAccountInfo(name, bundleName);
     appAccountInfo.SetAppIndex(appIndex);
-    ErrCode result = controlManagerPtr_->DeleteAccount(name, uid, bundleName, appAccountInfo);
-
-    if (!subscribeManagerPtr_) {
-        ACCOUNT_LOGE("subscribeManagerPtr_ is nullptr");
-    } else if (subscribeManagerPtr_->PublishAccount(appAccountInfo, uid, bundleName) != true) {
+    ErrCode result = controlManager_.DeleteAccount(name, uid, bundleName, appAccountInfo);
+    if ((result == ERR_OK) && (!subscribeManager_.PublishAccount(appAccountInfo, uid, bundleName))) {
         ACCOUNT_LOGE("failed to publish account");
     }
-
     return result;
 }
 
 ErrCode InnerAppAccountManager::GetAccountExtraInfo(const std::string &name, std::string &extraInfo,
     const uid_t &uid, const std::string &bundleName, const uint32_t &appIndex)
 {
-    if (!controlManagerPtr_) {
-        ACCOUNT_LOGE("controlManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_CONTROL_MANAGER_PTR_IS_NULLPTR;
-    }
-
-    ErrCode result = controlManagerPtr_->GetAccountExtraInfo(name, extraInfo, uid, bundleName, appIndex);
-
-    return result;
+    return controlManager_.GetAccountExtraInfo(name, extraInfo, uid, bundleName, appIndex);
 }
 
 ErrCode InnerAppAccountManager::SetAccountExtraInfo(const std::string &name, const std::string &extraInfo,
     const uid_t &uid, const std::string &bundleName, const uint32_t &appIndex)
 {
-    if (!controlManagerPtr_) {
-        ACCOUNT_LOGE("controlManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_CONTROL_MANAGER_PTR_IS_NULLPTR;
-    }
-
     AppAccountInfo appAccountInfo(name, bundleName);
     appAccountInfo.SetAppIndex(appIndex);
-    ErrCode result = controlManagerPtr_->SetAccountExtraInfo(name, extraInfo, uid, bundleName, appAccountInfo);
-
-    if (!subscribeManagerPtr_) {
-        ACCOUNT_LOGE("subscribeManagerPtr_ is nullptr");
-    } else if (subscribeManagerPtr_->PublishAccount(appAccountInfo, uid, bundleName) != true) {
+    ErrCode result = controlManager_.SetAccountExtraInfo(name, extraInfo, uid, bundleName, appAccountInfo);
+    if ((result == ERR_OK) && (!subscribeManager_.PublishAccount(appAccountInfo, uid, bundleName))) {
         ACCOUNT_LOGE("failed to publish account");
     }
-
     return result;
 }
 
 ErrCode InnerAppAccountManager::EnableAppAccess(const std::string &name, const std::string &authorizedApp,
     AppAccountCallingInfo &appAccountCallingInfo, const uint32_t apiVersion)
 {
-    if (!controlManagerPtr_) {
-        ACCOUNT_LOGE("controlManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_CONTROL_MANAGER_PTR_IS_NULLPTR;
-    }
-
     AppAccountInfo appAccountInfo(name, appAccountCallingInfo.bundleName);
     appAccountInfo.SetAppIndex(appAccountCallingInfo.appIndex);
-    ErrCode result = controlManagerPtr_->EnableAppAccess(
+    ErrCode result = controlManager_.EnableAppAccess(
         name, authorizedApp, appAccountCallingInfo, appAccountInfo, apiVersion);
-
-    if (!subscribeManagerPtr_) {
-        ACCOUNT_LOGE("subscribeManagerPtr_ is nullptr");
-    } else if (subscribeManagerPtr_->PublishAccount(
-        appAccountInfo, appAccountCallingInfo.callingUid, appAccountCallingInfo.bundleName) != true) {
+    if ((result == ERR_OK) && (!subscribeManager_.PublishAccount(
+        appAccountInfo, appAccountCallingInfo.callingUid, appAccountCallingInfo.bundleName))) {
         ACCOUNT_LOGE("failed to publish account");
     }
-
     return result;
 }
 
 ErrCode InnerAppAccountManager::DisableAppAccess(const std::string &name, const std::string &authorizedApp,
     AppAccountCallingInfo &appAccountCallingInfo, const uint32_t apiVersion)
 {
-    if (!controlManagerPtr_) {
-        ACCOUNT_LOGE("controlManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_CONTROL_MANAGER_PTR_IS_NULLPTR;
-    }
-
     AppAccountInfo appAccountInfo(name, appAccountCallingInfo.bundleName);
     appAccountInfo.SetAppIndex(appAccountCallingInfo.appIndex);
-    ErrCode result = controlManagerPtr_->DisableAppAccess(
+    ErrCode result = controlManager_.DisableAppAccess(
         name, authorizedApp, appAccountCallingInfo, appAccountInfo, apiVersion);
-
-    if (!subscribeManagerPtr_) {
-        ACCOUNT_LOGE("subscribeManagerPtr_ is nullptr");
-    } else if (!subscribeManagerPtr_->PublishAccount(
-        appAccountInfo, appAccountCallingInfo.callingUid, appAccountCallingInfo.bundleName)) {
+    if ((result == ERR_OK) && (!subscribeManager_.PublishAccount(
+        appAccountInfo, appAccountCallingInfo.callingUid, appAccountCallingInfo.bundleName))) {
         ACCOUNT_LOGE("failed to publish account");
     }
-
     return result;
 }
 
 ErrCode InnerAppAccountManager::CheckAppAccess(const std::string &name, const std::string &authorizedApp,
     bool &isAccessible, const AppAccountCallingInfo &appAccountCallingInfo)
 {
-    if (!controlManagerPtr_) {
-        ACCOUNT_LOGE("controlManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_CONTROL_MANAGER_PTR_IS_NULLPTR;
-    }
-    return controlManagerPtr_->CheckAppAccess(name, authorizedApp, isAccessible, appAccountCallingInfo);
+    return controlManager_.CheckAppAccess(name, authorizedApp, isAccessible, appAccountCallingInfo);
 }
 
 ErrCode InnerAppAccountManager::CheckAppAccountSyncEnable(const std::string &name, bool &syncEnable,
     const uid_t &uid, const std::string &bundleName, const uint32_t &appIndex)
 {
-    if (!controlManagerPtr_) {
-        ACCOUNT_LOGE("controlManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_CONTROL_MANAGER_PTR_IS_NULLPTR;
-    }
-
-    ErrCode result = controlManagerPtr_->CheckAppAccountSyncEnable(name, syncEnable, uid, bundleName, appIndex);
-
-    return result;
+    return controlManager_.CheckAppAccountSyncEnable(name, syncEnable, uid, bundleName, appIndex);
 }
 
 ErrCode InnerAppAccountManager::SetAppAccountSyncEnable(const std::string &name, const bool &syncEnable,
     const uid_t &uid, const std::string &bundleName, const uint32_t &appIndex)
 {
-    if (!controlManagerPtr_) {
-        ACCOUNT_LOGE("controlManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_CONTROL_MANAGER_PTR_IS_NULLPTR;
-    }
-
     AppAccountInfo appAccountInfo(name, bundleName);
     appAccountInfo.SetAppIndex(appIndex);
-    ErrCode result = controlManagerPtr_->SetAppAccountSyncEnable(name, syncEnable, uid, bundleName, appAccountInfo);
-
-    return result;
+    return controlManager_.SetAppAccountSyncEnable(name, syncEnable, uid, bundleName, appAccountInfo);
 }
 
 ErrCode InnerAppAccountManager::GetAssociatedData(const std::string &name, const std::string &key,
     std::string &value, const uid_t &uid)
 {
-    if (!controlManagerPtr_) {
-        ACCOUNT_LOGE("controlManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_CONTROL_MANAGER_PTR_IS_NULLPTR;
-    }
-
-    ErrCode result = controlManagerPtr_->GetAssociatedData(name, key, value, uid);
-
-    return result;
+    return controlManager_.GetAssociatedData(name, key, value, uid);
 }
 
 ErrCode InnerAppAccountManager::SetAssociatedData(const std::string &name, const std::string &key,
     const std::string &value, const AppAccountCallingInfo &appAccountCallingInfo)
 {
-    if (!controlManagerPtr_) {
-        ACCOUNT_LOGE("controlManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_CONTROL_MANAGER_PTR_IS_NULLPTR;
-    }
-
-    ErrCode result = controlManagerPtr_->SetAssociatedData(name, key, value, appAccountCallingInfo);
-
-    if (!subscribeManagerPtr_) {
-        ACCOUNT_LOGE("subscribeManagerPtr_ is nullptr");
+    ErrCode result = controlManager_.SetAssociatedData(name, key, value, appAccountCallingInfo);
+    if (result != ERR_OK) {
         return result;
     }
     AppAccountInfo appAccountInfo(name, appAccountCallingInfo.bundleName);
     appAccountInfo.SetAppIndex(appAccountCallingInfo.appIndex);
-    if (!subscribeManagerPtr_->PublishAccount(appAccountInfo,
+    if (!subscribeManager_.PublishAccount(appAccountInfo,
         appAccountCallingInfo.callingUid, appAccountCallingInfo.bundleName)) {
         ACCOUNT_LOGE("failed to publish account");
     }
@@ -259,35 +161,20 @@ ErrCode InnerAppAccountManager::SetAssociatedData(const std::string &name, const
 ErrCode InnerAppAccountManager::GetAccountCredential(const std::string &name, const std::string &credentialType,
     std::string &credential, const AppAccountCallingInfo &appAccountCallingInfo)
 {
-    if (!controlManagerPtr_) {
-        ACCOUNT_LOGE("controlManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_CONTROL_MANAGER_PTR_IS_NULLPTR;
-    }
-
-    ErrCode result = controlManagerPtr_->GetAccountCredential(name, credentialType, credential, appAccountCallingInfo);
-
-    return result;
+    return controlManager_.GetAccountCredential(name, credentialType, credential, appAccountCallingInfo);
 }
 
 ErrCode InnerAppAccountManager::SetAccountCredential(const std::string &name, const std::string &credentialType,
     const std::string &credential, const AppAccountCallingInfo &appAccountCallingInfo)
 {
-    if (!controlManagerPtr_) {
-        ACCOUNT_LOGE("controlManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_CONTROL_MANAGER_PTR_IS_NULLPTR;
-    }
-
-    ErrCode result =
-        controlManagerPtr_->SetAccountCredential(name, credentialType, credential, appAccountCallingInfo);
-
-    if (!subscribeManagerPtr_) {
-        ACCOUNT_LOGE("subscribeManagerPtr_ is nullptr");
+    ErrCode result = controlManager_.SetAccountCredential(name, credentialType, credential, appAccountCallingInfo);
+    if (result != ERR_OK) {
         return result;
     }
     AppAccountInfo appAccountInfo(name, appAccountCallingInfo.bundleName);
     appAccountInfo.SetAppIndex(appAccountCallingInfo.appIndex);
-    if (subscribeManagerPtr_->PublishAccount(appAccountInfo,
-        appAccountCallingInfo.callingUid, appAccountCallingInfo.bundleName) != true) {
+    if (!subscribeManager_.PublishAccount(appAccountInfo,
+        appAccountCallingInfo.callingUid, appAccountCallingInfo.bundleName)) {
         ACCOUNT_LOGE("failed to publish account");
     }
     return result;
@@ -296,22 +183,17 @@ ErrCode InnerAppAccountManager::SetAccountCredential(const std::string &name, co
 ErrCode InnerAppAccountManager::DeleteAccountCredential(const std::string &name, const std::string &credentialType,
     const uid_t &uid, const std::string &bundleName, const uint32_t &appIndex)
 {
-    if (!controlManagerPtr_) {
-        ACCOUNT_LOGE("controlManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_CONTROL_MANAGER_PTR_IS_NULLPTR;
-    }
     AppAccountCallingInfo appAccountCallingInfo;
     appAccountCallingInfo.callingUid = uid;
     appAccountCallingInfo.bundleName = bundleName;
     appAccountCallingInfo.appIndex = appIndex;
-    ErrCode result = controlManagerPtr_->SetAccountCredential(name, credentialType, "", appAccountCallingInfo, true);
-    if (!subscribeManagerPtr_) {
-        ACCOUNT_LOGE("subscribeManagerPtr_ is nullptr");
+    ErrCode result = controlManager_.SetAccountCredential(name, credentialType, "", appAccountCallingInfo, true);
+    if (result != ERR_OK) {
         return result;
     }
     AppAccountInfo appAccountInfo(name, bundleName);
     appAccountInfo.SetAppIndex(appIndex);
-    if (subscribeManagerPtr_->PublishAccount(appAccountInfo, uid, bundleName) != true) {
+    if (!subscribeManager_.PublishAccount(appAccountInfo, uid, bundleName)) {
         ACCOUNT_LOGE("failed to publish account");
     }
     return result;
@@ -319,17 +201,13 @@ ErrCode InnerAppAccountManager::DeleteAccountCredential(const std::string &name,
 
 ErrCode InnerAppAccountManager::Authenticate(const AuthenticatorSessionRequest &request)
 {
-    if (!controlManagerPtr_) {
-        ACCOUNT_LOGE("controlManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_CONTROL_MANAGER_PTR_IS_NULLPTR;
-    }
     std::string token;
     ErrCode ret = ERR_OK;
     bool isApi9 = request.options.GetBoolParam(Constants::API_V9, false);
     if (isApi9) {
-        ret = controlManagerPtr_->GetOAuthToken(request, token, Constants::API_VERSION9);
+        ret = controlManager_.GetOAuthToken(request, token, Constants::API_VERSION9);
     } else {
-        ret = controlManagerPtr_->GetOAuthToken(request, token);
+        ret = controlManager_.GetOAuthToken(request, token);
     }
     if (ret == ERR_OK) {
         if ((request.callback != nullptr) && (request.callback->AsObject() != nullptr)) {
@@ -341,43 +219,27 @@ ErrCode InnerAppAccountManager::Authenticate(const AuthenticatorSessionRequest &
         }
         return ERR_OK;
     }
-    if (!sessionManagerPtr_) {
-        ACCOUNT_LOGE("sessionManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_SESSION_MANAGER_PTR_IS_NULLPTR;
-    }
     if (isApi9) {
-        return sessionManagerPtr_->Auth(request);
+        return sessionManager_.Auth(request);
     }
-    return sessionManagerPtr_->Authenticate(request);
+    return sessionManager_.Authenticate(request);
 }
 
 ErrCode InnerAppAccountManager::GetOAuthToken(
     const AuthenticatorSessionRequest &request, std::string &token, const uint32_t apiVersion)
 {
-    if (!controlManagerPtr_) {
-        ACCOUNT_LOGE("controlManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_CONTROL_MANAGER_PTR_IS_NULLPTR;
-    }
-    return controlManagerPtr_->GetOAuthToken(request, token, apiVersion);
+    return controlManager_.GetOAuthToken(request, token, apiVersion);
 }
 
 ErrCode InnerAppAccountManager::SetOAuthToken(const AuthenticatorSessionRequest &request)
 {
-    if (!controlManagerPtr_) {
-        ACCOUNT_LOGE("controlManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_CONTROL_MANAGER_PTR_IS_NULLPTR;
-    }
-    ErrCode result = controlManagerPtr_->SetOAuthToken(request);
+    ErrCode result = controlManager_.SetOAuthToken(request);
     if (result != ERR_OK) {
         return result;
     }
     AppAccountInfo appAccountInfo(request.name, request.callerBundleName);
     appAccountInfo.SetAppIndex(request.appIndex);
-    if (!subscribeManagerPtr_) {
-        ACCOUNT_LOGI("subscribeManagerPtr_ is nullptr");
-        return ERR_OK;
-    }
-    if (!subscribeManagerPtr_->PublishAccount(appAccountInfo, request.callerUid, request.callerBundleName)) {
+    if (!subscribeManager_.PublishAccount(appAccountInfo, request.callerUid, request.callerBundleName)) {
         ACCOUNT_LOGE("failed to publish account");
     }
     return ERR_OK;
@@ -385,189 +247,103 @@ ErrCode InnerAppAccountManager::SetOAuthToken(const AuthenticatorSessionRequest
 
 ErrCode InnerAppAccountManager::DeleteOAuthToken(const AuthenticatorSessionRequest &request, const uint32_t apiVersion)
 {
-    if (!controlManagerPtr_) {
-        ACCOUNT_LOGE("controlManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_CONTROL_MANAGER_PTR_IS_NULLPTR;
-    }
-    return controlManagerPtr_->DeleteOAuthToken(request, apiVersion);
+    return controlManager_.DeleteOAuthToken(request, apiVersion);
 }
 
 ErrCode InnerAppAccountManager::SetOAuthTokenVisibility(
     const AuthenticatorSessionRequest &request, const uint32_t apiVersion)
 {
-    if (!controlManagerPtr_) {
-        ACCOUNT_LOGE("controlManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_CONTROL_MANAGER_PTR_IS_NULLPTR;
-    }
-    return controlManagerPtr_->SetOAuthTokenVisibility(request, apiVersion);
+    return controlManager_.SetOAuthTokenVisibility(request, apiVersion);
 }
 
 ErrCode InnerAppAccountManager::CheckOAuthTokenVisibility(
     const AuthenticatorSessionRequest &request, bool &isVisible, const uint32_t apiVersion)
 {
-    if (!controlManagerPtr_) {
-        ACCOUNT_LOGE("controlManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_CONTROL_MANAGER_PTR_IS_NULLPTR;
-    }
-    return controlManagerPtr_->CheckOAuthTokenVisibility(request, isVisible, apiVersion);
+    return controlManager_.CheckOAuthTokenVisibility(request, isVisible, apiVersion);
 }
 
 ErrCode InnerAppAccountManager::GetAuthenticatorInfo(
     const AuthenticatorSessionRequest &request, AuthenticatorInfo &info)
 {
-    if (!authenticatorManagerPtr_) {
-        ACCOUNT_LOGE("authenticatorManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_AUTHENTICATOR_MANAGER_PTR_IS_NULLPTR;
-    }
-    int32_t userId = request.callerUid / UID_TRANSFORM_DIVISOR;
-    return authenticatorManagerPtr_->GetAuthenticatorInfo(request.owner, userId, info);
+    return AppAccountAuthenticatorManager::GetAuthenticatorInfo(
+        request.owner, request.callerUid / UID_TRANSFORM_DIVISOR, info);
 }
 
 ErrCode InnerAppAccountManager::GetAllOAuthTokens(
     const AuthenticatorSessionRequest &request, std::vector<OAuthTokenInfo> &tokenInfos)
 {
-    if (!controlManagerPtr_) {
-        ACCOUNT_LOGE("controlManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_CONTROL_MANAGER_PTR_IS_NULLPTR;
-    }
-    return controlManagerPtr_->GetAllOAuthTokens(request, tokenInfos);
+    return controlManager_.GetAllOAuthTokens(request, tokenInfos);
 }
 
 ErrCode InnerAppAccountManager::GetOAuthList(
     const AuthenticatorSessionRequest &request, std::set<std::string> &oauthList, const uint32_t apiVersion)
 {
-    if (!controlManagerPtr_) {
-        ACCOUNT_LOGE("controlManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_CONTROL_MANAGER_PTR_IS_NULLPTR;
-    }
-    return controlManagerPtr_->GetOAuthList(request, oauthList, apiVersion);
+    return controlManager_.GetOAuthList(request, oauthList, apiVersion);
 }
 
 ErrCode InnerAppAccountManager::GetAuthenticatorCallback(
     const AuthenticatorSessionRequest &request, sptr<IRemoteObject> &callback)
 {
     callback = nullptr;
-    if (!sessionManagerPtr_) {
-        ACCOUNT_LOGE("controlManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_CONTROL_MANAGER_PTR_IS_NULLPTR;
-    }
-    ErrCode result = sessionManagerPtr_->GetAuthenticatorCallback(request, callback);
-
-    return result;
+    return sessionManager_.GetAuthenticatorCallback(request, callback);
 }
 
 ErrCode InnerAppAccountManager::GetAllAccounts(const std::string &owner, std::vector<AppAccountInfo> &appAccounts,
     const uid_t &uid, const std::string &bundleName, const uint32_t &appIndex)
 {
-    if (!controlManagerPtr_) {
-        ACCOUNT_LOGE("controlManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_CONTROL_MANAGER_PTR_IS_NULLPTR;
-    }
-
-    ErrCode result = controlManagerPtr_->GetAllAccounts(owner, appAccounts, uid, bundleName, appIndex);
-
-    return result;
+    return controlManager_.GetAllAccounts(owner, appAccounts, uid, bundleName, appIndex);
 }
 
 ErrCode InnerAppAccountManager::GetAllAccessibleAccounts(std::vector<AppAccountInfo> &appAccounts,
     const uid_t &uid, const std::string &bundleName, const uint32_t &appIndex)
 {
-    if (!controlManagerPtr_) {
-        ACCOUNT_LOGE("controlManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_CONTROL_MANAGER_PTR_IS_NULLPTR;
-    }
-
-    ErrCode result = controlManagerPtr_->GetAllAccessibleAccounts(appAccounts, uid, bundleName, appIndex);
-
-    return result;
+    return controlManager_.GetAllAccessibleAccounts(appAccounts, uid, bundleName, appIndex);
 }
 
 ErrCode InnerAppAccountManager::SelectAccountsByOptions(
     const SelectAccountsOptions &options, const sptr<IAppAccountAuthenticatorCallback> &callback,
     const uid_t &uid, const std::string &bundleName, const uint32_t &appIndex)
 {
-    if (!controlManagerPtr_) {
-        ACCOUNT_LOGE("controlManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_CONTROL_MANAGER_PTR_IS_NULLPTR;
-    }
     AuthenticatorSessionRequest request;
-    ErrCode result = controlManagerPtr_->SelectAccountsByOptions(options, callback, uid, bundleName, appIndex);
-    return result;
+    return controlManager_.SelectAccountsByOptions(options, callback, uid, bundleName, appIndex);
 }
 
 ErrCode InnerAppAccountManager::VerifyCredential(const AuthenticatorSessionRequest &request)
 {
-    if (!sessionManagerPtr_) {
-        ACCOUNT_LOGE("sessionManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_SESSION_MANAGER_PTR_IS_NULLPTR;
-    }
-    return sessionManagerPtr_->VerifyCredential(request);
+    return sessionManager_.VerifyCredential(request);
 }
 
 ErrCode InnerAppAccountManager::CheckAccountLabels(const AuthenticatorSessionRequest &request)
 {
-    if (!sessionManagerPtr_) {
-        ACCOUNT_LOGE("sessionManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_SESSION_MANAGER_PTR_IS_NULLPTR;
-    }
-    return sessionManagerPtr_->CheckAccountLabels(request);
+    return sessionManager_.CheckAccountLabels(request);
 }
 
 ErrCode InnerAppAccountManager::SetAuthenticatorProperties(const AuthenticatorSessionRequest &request)
 {
-    if (!sessionManagerPtr_) {
-        ACCOUNT_LOGE("sessionManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_CONTROL_MANAGER_PTR_IS_NULLPTR;
-    }
-    return sessionManagerPtr_->SetAuthenticatorProperties(request);
+    return sessionManager_.SetAuthenticatorProperties(request);
 }
 
 ErrCode InnerAppAccountManager::SubscribeAppAccount(const AppAccountSubscribeInfo &subscribeInfo,
     const sptr<IRemoteObject> &eventListener, const uid_t &uid, const std::string &bundleName, const uint32_t &appIndex)
 {
-    if (!subscribeManagerPtr_) {
-        ACCOUNT_LOGE("subscribeManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_SUBSCRIBE_MANAGER_PTR_IS_NULLPTR;
-    }
-
     auto subscribeInfoPtr = std::make_shared<AppAccountSubscribeInfo>(subscribeInfo);
-    ErrCode result = subscribeManagerPtr_->
-        SubscribeAppAccount(subscribeInfoPtr, eventListener, uid, bundleName, appIndex);
-
-    return result;
+    return subscribeManager_.SubscribeAppAccount(subscribeInfoPtr, eventListener, uid, bundleName, appIndex);
 }
 
 ErrCode InnerAppAccountManager::UnsubscribeAppAccount(const sptr<IRemoteObject> &eventListener)
 {
-    if (!subscribeManagerPtr_) {
-        ACCOUNT_LOGE("subscribeManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_SUBSCRIBE_MANAGER_PTR_IS_NULLPTR;
-    }
-
-    ErrCode result = subscribeManagerPtr_->UnsubscribeAppAccount(eventListener);
-
-    return result;
+    return subscribeManager_.UnsubscribeAppAccount(eventListener);
 }
 
 ErrCode InnerAppAccountManager::OnPackageRemoved(
     const uid_t &uid, const std::string &bundleName, const uint32_t &appIndex)
 {
-    if (!controlManagerPtr_) {
-        ACCOUNT_LOGE("controlManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_CONTROL_MANAGER_PTR_IS_NULLPTR;
-    }
-
-    ErrCode result = controlManagerPtr_->OnPackageRemoved(uid, bundleName, appIndex);
-    return result;
+    return controlManager_.OnPackageRemoved(uid, bundleName, appIndex);
 }
 
 ErrCode InnerAppAccountManager::OnUserRemoved(int32_t userId)
 {
-    if (!controlManagerPtr_) {
-        ACCOUNT_LOGE("controlManagerPtr_ is nullptr");
-        return ERR_APPACCOUNT_SERVICE_CONTROL_MANAGER_PTR_IS_NULLPTR;
-    }
-    return controlManagerPtr_->OnUserRemoved(userId);
+    return controlManager_.OnUserRemoved(userId);
 }
 }  // namespace AccountSA
 }  // namespace OHOS

services/accountmgr/src/domain_account/domain_account_stub.cpp

@@ -201,8 +201,7 @@ ErrCode DomainAccountStub::ProcAuthWithPopup(MessageParcel &data, MessageParcel
 
 ErrCode DomainAccountStub::CheckPermission(uint32_t code, int32_t uid)
 {
-    std::shared_ptr<AccountPermissionManager> permManager = AccountPermissionManager::GetInstance();
-    ErrCode errCode = permManager->CheckSystemApp();
+    ErrCode errCode = AccountPermissionManager::CheckSystemApp();
     if (errCode != ERR_OK) {
         ACCOUNT_LOGE("the caller is not system application, errCode = %{public}d.", errCode);
         return errCode;
@@ -228,7 +227,7 @@ ErrCode DomainAccountStub::CheckPermission(uint32_t code, int32_t uid)
     if (permissionName.empty()) {
         return ERR_OK;
     }
-    return permManager->VerifyPermission(permissionName);
+    return AccountPermissionManager::VerifyPermission(permissionName);
 }
 }  // namespace AccountSA
 }  // namespace OHOS

services/accountmgr/src/domain_account/inner_domain_account_manager.cpp

@@ -118,7 +118,7 @@ ErrCode InnerDomainAccountManager::StartAuth(const sptr<IDomainAccountPlugin> &p
 ErrCode InnerDomainAccountManager::GetDomainAccountInfoByUserId(int32_t userId, DomainAccountInfo &domainInfo)
 {
     OsAccountInfo accountInfo;
-    ErrCode errCode = IInnerOsAccountManager::GetInstance()->QueryOsAccountById(userId, accountInfo);
+    ErrCode errCode = IInnerOsAccountManager::GetInstance().QueryOsAccountById(userId, accountInfo);
     if (errCode != ERR_OK) {
         ACCOUNT_LOGE("get os account info failed, errCode: %{public}d", errCode);
         return errCode;
@@ -136,7 +136,7 @@ ErrCode InnerDomainAccountManager::Auth(const DomainAccountInfo &info, const std
 {
     int32_t userId = 0;
     sptr<IDomainAuthCallback> innerCallback = callback;
-    IInnerOsAccountManager::GetInstance()->GetOsAccountLocalIdFromDomain(info, userId);
+    IInnerOsAccountManager::GetInstance().GetOsAccountLocalIdFromDomain(info, userId);
     if (userId != 0) {
         innerCallback = new (std::nothrow) InnerDomainAuthCallback(userId, callback);
         if (innerCallback == nullptr) {
@@ -181,7 +181,7 @@ ErrCode InnerDomainAccountManager::AuthWithPopup(int32_t userId, const sptr<IDom
 {
     if (userId == 0) {
         std::vector<int32_t> userIds;
-        (void)IInnerOsAccountManager::GetInstance()->QueryActiveOsAccountIds(userIds);
+        (void)IInnerOsAccountManager::GetInstance().QueryActiveOsAccountIds(userIds);
         if (userIds.empty()) {
             ACCOUNT_LOGE("fail to get activated os account ids");
             return ERR_OSACCOUNT_SERVICE_INNER_CANNOT_FIND_OSACCOUNT_ERROR;

services/accountmgr/src/ohos_account_manager.cpp

@@ -97,7 +97,7 @@ std::int32_t GetCallingUserID()
     std::int32_t userId = IPCSkeleton::GetCallingUid() / UID_TRANSFORM_DIVISOR;
     if (userId <= 0) {
         std::vector<int32_t> userIds;
-        (void)IInnerOsAccountManager::GetInstance()->QueryActiveOsAccountIds(userIds);
+        (void)IInnerOsAccountManager::GetInstance().QueryActiveOsAccountIds(userIds);
         if (userIds.empty()) {
             return -1;  // invalid user id
         }

services/accountmgr/src/osaccount/inner_os_account_manager.cpp

@@ -33,7 +33,7 @@ namespace {
 const std::string CONSTRAINT_CREATE_ACCOUNT_DIRECTLY = "constraint.os.account.create.directly";
 }
 
-IInnerOsAccountManager::IInnerOsAccountManager() : subscribeManagerPtr_(OsAccountSubscribeManager::GetInstance())
+IInnerOsAccountManager::IInnerOsAccountManager() : subscribeManager_(OsAccountSubscribeManager::GetInstance())
 {
     activeAccountId_.clear();
     operatingId_.clear();
@@ -44,6 +44,12 @@ IInnerOsAccountManager::IInnerOsAccountManager() : subscribeManagerPtr_(OsAccoun
     ACCOUNT_LOGD("OsAccountAccountMgr Init end");
 }
 
+IInnerOsAccountManager &IInnerOsAccountManager::GetInstance()
+{
+    static IInnerOsAccountManager instance;
+    return instance;
+}
+
 void IInnerOsAccountManager::SetOsAccountControl(std::shared_ptr<IOsAccountControl> ptr)
 {
     osAccountControl_ = ptr;
@@ -124,7 +130,7 @@ void IInnerOsAccountManager::StartAccount()
     if (SendMsgForAccountActivate(osAccountInfo) != ERR_OK) {
         return;
     }
-    subscribeManagerPtr_->PublishActivatedOsAccount(osAccountInfo.GetLocalId());
+    subscribeManager_.PublishActivatedOsAccount(osAccountInfo.GetLocalId());
     ACCOUNT_LOGI("OsAccountAccountMgr send to storage and am for start success");
 }
 
@@ -1070,14 +1076,14 @@ ErrCode IInnerOsAccountManager::ActivateOsAccount(const int id)
     }
 
     // activate
-    subscribeManagerPtr_->PublishActivatingOsAccount(id);
+    subscribeManager_.PublishActivatingOsAccount(id);
     errCode = SendMsgForAccountActivate(osAccountInfo);
     if (errCode != ERR_OK) {
         RemoveLocalIdToOperating(id);
         return errCode;
     }
     RemoveLocalIdToOperating(id);
-    subscribeManagerPtr_->PublishActivatedOsAccount(id);
+    subscribeManager_.PublishActivatedOsAccount(id);
     ACCOUNT_LOGI("IInnerOsAccountManager ActivateOsAccount end");
     return ERR_OK;
 }
@@ -1213,25 +1219,16 @@ ErrCode IInnerOsAccountManager::GetSerialNumberByOsAccountLocalId(const int &id,
 ErrCode IInnerOsAccountManager::SubscribeOsAccount(
     const OsAccountSubscribeInfo &subscribeInfo, const sptr<IRemoteObject> &eventListener)
 {
-    if (!subscribeManagerPtr_) {
-        ACCOUNT_LOGE("subscribeManagerPtr_ is nullptr");
-        return ERR_OSACCOUNT_SERVICE_SUBSCRIBE_MANAGER_PTR_IS_NULLPTR;
-    }
-
     auto subscribeInfoPtr = std::make_shared<OsAccountSubscribeInfo>(subscribeInfo);
     if (subscribeInfoPtr == nullptr) {
         ACCOUNT_LOGE("subscribeInfoPtr is nullptr");
     }
-    return subscribeManagerPtr_->SubscribeOsAccount(subscribeInfoPtr, eventListener);
+    return subscribeManager_.SubscribeOsAccount(subscribeInfoPtr, eventListener);
 }
 
 ErrCode IInnerOsAccountManager::UnsubscribeOsAccount(const sptr<IRemoteObject> &eventListener)
 {
-    if (!subscribeManagerPtr_) {
-        ACCOUNT_LOGE("controlManagerPtr_ is nullptr");
-        return ERR_OSACCOUNT_SERVICE_SUBSCRIBE_MANAGER_PTR_IS_NULLPTR;
-    }
-    return subscribeManagerPtr_->UnsubscribeOsAccount(eventListener);
+    return subscribeManager_.UnsubscribeOsAccount(eventListener);
 }
 
 OS_ACCOUNT_SWITCH_MOD IInnerOsAccountManager::GetOsAccountSwitchMod()

services/accountmgr/src/osaccount/os_account_domain_account_callback.cpp

@@ -51,7 +51,7 @@ void CheckAndCreateDomainAccountCallback::OnResult(int32_t errCode, Parcel &parc
         ACCOUNT_LOGE("domain account not found");
         return innerCallback_->OnResult(ERR_JS_ACCOUNT_NOT_FOUND, resultParcel);
     }
-    errCode = IInnerOsAccountManager::GetInstance()->BindDomainAccount(type_, *domainAccountInfo, innerCallback_);
+    errCode = IInnerOsAccountManager::GetInstance().BindDomainAccount(type_, *domainAccountInfo, innerCallback_);
     if (errCode != ERR_OK) {
         return innerCallback_->OnResult(errCode, resultParcel);
     }
@@ -83,7 +83,7 @@ void BindDomainAccountCallback::OnResult(int32_t errCode, Parcel &parcel)
     }
     Parcel resultParcel;
     if (osAccountInfo_.GetLocalId() != Constants::START_USER_ID) {
-        errCode = IInnerOsAccountManager::GetInstance()->SendMsgForAccountCreate(osAccountInfo_);
+        errCode = IInnerOsAccountManager::GetInstance().SendMsgForAccountCreate(osAccountInfo_);
         osAccountInfo_.Marshalling(resultParcel);
         return innerCallback_->OnResult(errCode, resultParcel);
     }

services/accountmgr/src/osaccount/os_account_manager_service.cpp

@@ -66,11 +66,9 @@ ErrCode CheckLocalId(int localId)
 }
 }  // namespace
 
-OsAccountManagerService::OsAccountManagerService()
-{
-    innerManager_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
-    permissionManagerPtr_ = DelayedSingleton<AccountPermissionManager>::GetInstance();
-}
+OsAccountManagerService::OsAccountManagerService() : innerManager_(IInnerOsAccountManager::GetInstance())
+{}
+
 OsAccountManagerService::~OsAccountManagerService()
 {}
 
@@ -78,7 +76,7 @@ ErrCode OsAccountManagerService::CreateOsAccount(
     const std::string &name, const OsAccountType &type, OsAccountInfo &osAccountInfo)
 {
     bool isMultiOsAccountEnable = false;
-    innerManager_->IsMultiOsAccountEnable(isMultiOsAccountEnable);
+    innerManager_.IsMultiOsAccountEnable(isMultiOsAccountEnable);
     if (!isMultiOsAccountEnable) {
         ACCOUNT_LOGE("system is not multi os account enable error");
         return ERR_OSACCOUNT_SERVICE_MANAGER_NOT_ENABLE_MULTI_ERROR;
@@ -106,7 +104,7 @@ ErrCode OsAccountManagerService::CreateOsAccount(
     }
 
     bool isAllowedCreateAdmin = false;
-    ErrCode errCode = innerManager_->IsAllowedCreateAdmin(isAllowedCreateAdmin);
+    ErrCode errCode = innerManager_.IsAllowedCreateAdmin(isAllowedCreateAdmin);
     if (errCode != ERR_OK) {
         ACCOUNT_LOGE("query allowed create admin error");
         return errCode;
@@ -115,7 +113,7 @@ ErrCode OsAccountManagerService::CreateOsAccount(
         ACCOUNT_LOGE("cannot create admin account error");
         return ERR_OSACCOUNT_SERVICE_MANAGER_CREATE_OSACCOUNT_TYPE_ERROR;
     }
-    return innerManager_->CreateOsAccount(name, type, osAccountInfo);
+    return innerManager_.CreateOsAccount(name, type, osAccountInfo);
 }
 
 ErrCode OsAccountManagerService::CreateOsAccountForDomain(const OsAccountType &type,
@@ -123,7 +121,7 @@ ErrCode OsAccountManagerService::CreateOsAccountForDomain(const OsAccountType &t
 {
     ACCOUNT_LOGI("start");
     bool isMultiOsAccountEnable = false;
-    innerManager_->IsMultiOsAccountEnable(isMultiOsAccountEnable);
+    innerManager_.IsMultiOsAccountEnable(isMultiOsAccountEnable);
     if (!isMultiOsAccountEnable) {
         return ERR_OSACCOUNT_SERVICE_MANAGER_NOT_ENABLE_MULTI_ERROR;
     }
@@ -148,14 +146,14 @@ ErrCode OsAccountManagerService::CreateOsAccountForDomain(const OsAccountType &t
     }
 
     bool isAllowedCreateAdmin = false;
-    ErrCode errCode = innerManager_->IsAllowedCreateAdmin(isAllowedCreateAdmin);
+    ErrCode errCode = innerManager_.IsAllowedCreateAdmin(isAllowedCreateAdmin);
     if (errCode != ERR_OK) {
         return errCode;
     }
     if (!isAllowedCreateAdmin && type == OsAccountType::ADMIN) {
         return ERR_OSACCOUNT_SERVICE_MANAGER_CREATE_OSACCOUNT_TYPE_ERROR;
     }
-    return innerManager_->CreateOsAccountForDomain(type, domainInfo, callback);
+    return innerManager_.CreateOsAccountForDomain(type, domainInfo, callback);
 }
 
 ErrCode OsAccountManagerService::RemoveOsAccount(const int id)
@@ -176,12 +174,12 @@ ErrCode OsAccountManagerService::RemoveOsAccount(const int id)
         return ERR_OSACCOUNT_SERVICE_PERMISSION_DENIED;
     }
 
-    return innerManager_->RemoveOsAccount(id);
+    return innerManager_.RemoveOsAccount(id);
 }
 
 ErrCode OsAccountManagerService::IsOsAccountExists(const int id, bool &isOsAccountExists)
 {
-    return innerManager_->IsOsAccountExists(id, isOsAccountExists);
+    return innerManager_.IsOsAccountExists(id, isOsAccountExists);
 }
 
 ErrCode OsAccountManagerService::IsOsAccountActived(const int id, bool &isOsAccountActived)
@@ -194,7 +192,7 @@ ErrCode OsAccountManagerService::IsOsAccountActived(const int id, bool &isOsAcco
     // check current account state
     int callerUserId = IPCSkeleton::GetCallingUid() / UID_TRANSFORM_DIVISOR;
     if (callerUserId == id) {
-        return innerManager_->IsOsAccountActived(id, isOsAccountActived);
+        return innerManager_.IsOsAccountActived(id, isOsAccountActived);
     }
 
     // check other account state, check permission first
@@ -204,7 +202,7 @@ ErrCode OsAccountManagerService::IsOsAccountActived(const int id, bool &isOsAcco
         return ERR_OSACCOUNT_SERVICE_PERMISSION_DENIED;
     }
 
-    return innerManager_->IsOsAccountActived(id, isOsAccountActived);
+    return innerManager_.IsOsAccountActived(id, isOsAccountActived);
 }
 
 ErrCode OsAccountManagerService::IsOsAccountConstraintEnable(
@@ -220,7 +218,7 @@ ErrCode OsAccountManagerService::IsOsAccountConstraintEnable(
         return ERR_OSACCOUNT_SERVICE_PERMISSION_DENIED;
     }
 
-    return innerManager_->IsOsAccountConstraintEnable(id, constraint, isConstraintEnable);
+    return innerManager_.IsOsAccountConstraintEnable(id, constraint, isConstraintEnable);
 }
 
 ErrCode OsAccountManagerService::CheckOsAccountConstraintEnabled(
@@ -237,7 +235,7 @@ ErrCode OsAccountManagerService::CheckOsAccountConstraintEnabled(
         return ERR_OSACCOUNT_SERVICE_PERMISSION_DENIED;
     }
 
-    return innerManager_->IsOsAccountConstraintEnable(id, constraint, isEnabled);
+    return innerManager_.IsOsAccountConstraintEnable(id, constraint, isEnabled);
 }
 
 ErrCode OsAccountManagerService::IsOsAccountVerified(const int id, bool &isVerified)
@@ -249,7 +247,7 @@ ErrCode OsAccountManagerService::IsOsAccountVerified(const int id, bool &isVerif
     // check current account state
     int callerUserId = IPCSkeleton::GetCallingUid() / UID_TRANSFORM_DIVISOR;
     if (callerUserId == id) {
-        return innerManager_->IsOsAccountVerified(id, isVerified);
+        return innerManager_.IsOsAccountVerified(id, isVerified);
     }
 
     // check other account state, check permission first
@@ -259,7 +257,7 @@ ErrCode OsAccountManagerService::IsOsAccountVerified(const int id, bool &isVerif
         return ERR_OSACCOUNT_SERVICE_PERMISSION_DENIED;
     }
 
-    return innerManager_->IsOsAccountVerified(id, isVerified);
+    return innerManager_.IsOsAccountVerified(id, isVerified);
 }
 
 ErrCode OsAccountManagerService::GetCreatedOsAccountsCount(unsigned int &osAccountsCount)
@@ -270,7 +268,7 @@ ErrCode OsAccountManagerService::GetCreatedOsAccountsCount(unsigned int &osAccou
         return ERR_OSACCOUNT_SERVICE_PERMISSION_DENIED;
     }
 
-    return innerManager_->GetCreatedOsAccountsCount(osAccountsCount);
+    return innerManager_.GetCreatedOsAccountsCount(osAccountsCount);
 }
 
 ErrCode OsAccountManagerService::GetOsAccountLocalIdFromProcess(int &id)
@@ -310,12 +308,12 @@ ErrCode OsAccountManagerService::GetOsAccountLocalIdFromDomain(const DomainAccou
         return ERR_OSACCOUNT_SERVICE_PERMISSION_DENIED;
     }
 
-    return innerManager_->GetOsAccountLocalIdFromDomain(domainInfo, id);
+    return innerManager_.GetOsAccountLocalIdFromDomain(domainInfo, id);
 }
 
 ErrCode OsAccountManagerService::QueryMaxOsAccountNumber(int &maxOsAccountNumber)
 {
-    return innerManager_->QueryMaxOsAccountNumber(maxOsAccountNumber);
+    return innerManager_.QueryMaxOsAccountNumber(maxOsAccountNumber);
 }
 
 ErrCode OsAccountManagerService::GetOsAccountAllConstraints(const int id, std::vector<std::string> &constraints)
@@ -330,7 +328,7 @@ ErrCode OsAccountManagerService::GetOsAccountAllConstraints(const int id, std::v
         return ERR_OSACCOUNT_SERVICE_PERMISSION_DENIED;
     }
 
-    return innerManager_->GetOsAccountAllConstraints(id, constraints);
+    return innerManager_.GetOsAccountAllConstraints(id, constraints);
 }
 
 ErrCode OsAccountManagerService::QueryAllCreatedOsAccounts(std::vector<OsAccountInfo> &osAccountInfos)
@@ -341,7 +339,7 @@ ErrCode OsAccountManagerService::QueryAllCreatedOsAccounts(std::vector<OsAccount
         return ERR_OSACCOUNT_SERVICE_PERMISSION_DENIED;
     }
 
-    return innerManager_->QueryAllCreatedOsAccounts(osAccountInfos);
+    return innerManager_.QueryAllCreatedOsAccounts(osAccountInfos);
 }
 
 ErrCode OsAccountManagerService::QueryCurrentOsAccount(OsAccountInfo &osAccountInfo)
@@ -353,7 +351,7 @@ ErrCode OsAccountManagerService::QueryCurrentOsAccount(OsAccountInfo &osAccountI
     }
 
     int id = IPCSkeleton::GetCallingUid() / UID_TRANSFORM_DIVISOR;
-    return innerManager_->QueryOsAccountById(id, osAccountInfo);
+    return innerManager_.QueryOsAccountById(id, osAccountInfo);
 }
 
 ErrCode OsAccountManagerService::QueryOsAccountById(const int id, OsAccountInfo &osAccountInfo)
@@ -370,13 +368,13 @@ ErrCode OsAccountManagerService::QueryOsAccountById(const int id, OsAccountInfo
         return ERR_OSACCOUNT_SERVICE_PERMISSION_DENIED;
     }
 
-    return innerManager_->QueryOsAccountById(id, osAccountInfo);
+    return innerManager_.QueryOsAccountById(id, osAccountInfo);
 }
 
 ErrCode OsAccountManagerService::GetOsAccountTypeFromProcess(OsAccountType &type)
 {
     int id = IPCSkeleton::GetCallingUid() / UID_TRANSFORM_DIVISOR;
-    return innerManager_->GetOsAccountType(id, type);
+    return innerManager_.GetOsAccountType(id, type);
 }
 
 ErrCode OsAccountManagerService::GetOsAccountProfilePhoto(const int id, std::string &photo)
@@ -388,7 +386,7 @@ ErrCode OsAccountManagerService::GetOsAccountProfilePhoto(const int id, std::str
     // get current account photo
     int callerUserId = IPCSkeleton::GetCallingUid() / UID_TRANSFORM_DIVISOR;
     if (callerUserId == id) {
-        return innerManager_->GetOsAccountProfilePhoto(id, photo);
+        return innerManager_.GetOsAccountProfilePhoto(id, photo);
     }
 
     // get other account photo, check permission first
@@ -397,12 +395,12 @@ ErrCode OsAccountManagerService::GetOsAccountProfilePhoto(const int id, std::str
         return ERR_OSACCOUNT_SERVICE_PERMISSION_DENIED;
     }
 
-    return innerManager_->GetOsAccountProfilePhoto(id, photo);
+    return innerManager_.GetOsAccountProfilePhoto(id, photo);
 }
 
 ErrCode OsAccountManagerService::IsMultiOsAccountEnable(bool &isMultiOsAccountEnable)
 {
-    return innerManager_->IsMultiOsAccountEnable(isMultiOsAccountEnable);
+    return innerManager_.IsMultiOsAccountEnable(isMultiOsAccountEnable);
 }
 
 ErrCode OsAccountManagerService::SetOsAccountName(const int id, const std::string &name)
@@ -427,7 +425,7 @@ ErrCode OsAccountManagerService::SetOsAccountName(const int id, const std::strin
         return ERR_OSACCOUNT_SERVICE_PERMISSION_DENIED;
     }
 
-    return innerManager_->SetOsAccountName(id, name);
+    return innerManager_.SetOsAccountName(id, name);
 }
 
 ErrCode OsAccountManagerService::SetOsAccountConstraints(
@@ -444,7 +442,7 @@ ErrCode OsAccountManagerService::SetOsAccountConstraints(
         return ERR_OSACCOUNT_SERVICE_PERMISSION_DENIED;
     }
 
-    return innerManager_->SetBaseOsAccountConstraints(id, constraints, enable);
+    return innerManager_.SetBaseOsAccountConstraints(id, constraints, enable);
 }
 
 ErrCode OsAccountManagerService::SetOsAccountProfilePhoto(const int id, const std::string &photo)
@@ -468,7 +466,7 @@ ErrCode OsAccountManagerService::SetOsAccountProfilePhoto(const int id, const st
         return ERR_OSACCOUNT_SERVICE_PERMISSION_DENIED;
     }
 
-    return innerManager_->SetOsAccountProfilePhoto(id, photo);
+    return innerManager_.SetOsAccountProfilePhoto(id, photo);
 }
 
 ErrCode OsAccountManagerService::ActivateOsAccount(const int id)
@@ -485,17 +483,17 @@ ErrCode OsAccountManagerService::ActivateOsAccount(const int id)
         return ERR_OSACCOUNT_SERVICE_PERMISSION_DENIED;
     }
 
-    return innerManager_->ActivateOsAccount(id);
+    return innerManager_.ActivateOsAccount(id);
 }
 
 ErrCode OsAccountManagerService::StartOsAccount(const int id)
 {
-    return innerManager_->StartOsAccount(id);
+    return innerManager_.StartOsAccount(id);
 }
 
 ErrCode OsAccountManagerService::StopOsAccount(const int id)
 {
-    return innerManager_->StopOsAccount(id);
+    return innerManager_.StopOsAccount(id);
 }
 
 ErrCode OsAccountManagerService::SubscribeOsAccount(
@@ -507,7 +505,7 @@ ErrCode OsAccountManagerService::SubscribeOsAccount(
         return ERR_OSACCOUNT_SERVICE_PERMISSION_DENIED;
     }
 
-    return innerManager_->SubscribeOsAccount(subscribeInfo, eventListener);
+    return innerManager_.SubscribeOsAccount(subscribeInfo, eventListener);
 }
 
 ErrCode OsAccountManagerService::UnsubscribeOsAccount(const sptr<IRemoteObject> &eventListener)
@@ -518,12 +516,12 @@ ErrCode OsAccountManagerService::UnsubscribeOsAccount(const sptr<IRemoteObject>
         return ERR_OSACCOUNT_SERVICE_PERMISSION_DENIED;
     }
 
-    return innerManager_->UnsubscribeOsAccount(eventListener);
+    return innerManager_.UnsubscribeOsAccount(eventListener);
 }
 
 ErrCode OsAccountManagerService::GetOsAccountLocalIdBySerialNumber(const int64_t serialNumber, int &id)
 {
-    return innerManager_->GetOsAccountLocalIdBySerialNumber(serialNumber, id);
+    return innerManager_.GetOsAccountLocalIdBySerialNumber(serialNumber, id);
 }
 
 ErrCode OsAccountManagerService::GetSerialNumberByOsAccountLocalId(const int &id, int64_t &serialNumber)
@@ -532,23 +530,23 @@ ErrCode OsAccountManagerService::GetSerialNumberByOsAccountLocalId(const int &id
     if (result != ERR_OK) {
         return result;
     }
-    return innerManager_->GetSerialNumberByOsAccountLocalId(id, serialNumber);
+    return innerManager_.GetSerialNumberByOsAccountLocalId(id, serialNumber);
 }
 
 OS_ACCOUNT_SWITCH_MOD OsAccountManagerService::GetOsAccountSwitchMod()
 {
-    return innerManager_->GetOsAccountSwitchMod();
+    return innerManager_.GetOsAccountSwitchMod();
 }
 
 ErrCode OsAccountManagerService::IsCurrentOsAccountVerified(bool &isVerified)
 {
     int id = IPCSkeleton::GetCallingUid() / UID_TRANSFORM_DIVISOR;
-    return innerManager_->IsOsAccountVerified(id, isVerified);
+    return innerManager_.IsOsAccountVerified(id, isVerified);
 }
 
 ErrCode OsAccountManagerService::IsOsAccountCompleted(const int id, bool &isOsAccountCompleted)
 {
-    return innerManager_->IsOsAccountCompleted(id, isOsAccountCompleted);
+    return innerManager_.IsOsAccountCompleted(id, isOsAccountCompleted);
 }
 
 ErrCode OsAccountManagerService::SetCurrentOsAccountIsVerified(const bool isVerified)
@@ -566,7 +564,7 @@ ErrCode OsAccountManagerService::SetCurrentOsAccountIsVerified(const bool isVeri
         return res;
     }
 
-    return innerManager_->SetOsAccountIsVerified(id, isVerified);
+    return innerManager_.SetOsAccountIsVerified(id, isVerified);
 }
 
 ErrCode OsAccountManagerService::SetOsAccountIsVerified(const int id, const bool isVerified)
@@ -583,7 +581,7 @@ ErrCode OsAccountManagerService::SetOsAccountIsVerified(const int id, const bool
         return ERR_OSACCOUNT_SERVICE_PERMISSION_DENIED;
     }
 
-    return innerManager_->SetOsAccountIsVerified(id, isVerified);
+    return innerManager_.SetOsAccountIsVerified(id, isVerified);
 }
 
 ErrCode OsAccountManagerService::DumpState(const int &id, std::vector<std::string> &state)
@@ -600,13 +598,13 @@ ErrCode OsAccountManagerService::DumpState(const int &id, std::vector<std::strin
     std::vector<OsAccountInfo> osAccountInfos;
 
     if (id == -1) {
-        result = innerManager_->QueryAllCreatedOsAccounts(osAccountInfos);
+        result = innerManager_.QueryAllCreatedOsAccounts(osAccountInfos);
         if (result != ERR_OK) {
             return result;
         }
     } else {
         OsAccountInfo osAccountInfo;
-        result = innerManager_->QueryOsAccountById(id, osAccountInfo);
+        result = innerManager_.QueryOsAccountById(id, osAccountInfo);
         if (result != ERR_OK) {
             return result;
         }
@@ -623,7 +621,7 @@ ErrCode OsAccountManagerService::DumpOsAccountInfo(std::vector<std::string> &sta
 
     ErrCode result = ERR_OK;
     std::vector<OsAccountInfo> osAccountInfos;
-    result = innerManager_->QueryAllCreatedOsAccounts(osAccountInfos);
+    result = innerManager_.QueryAllCreatedOsAccounts(osAccountInfos);
     if (result != ERR_OK) {
         return result;
     }
@@ -640,25 +638,25 @@ ErrCode OsAccountManagerService::GetCreatedOsAccountNumFromDatabase(const std::s
         return ERR_OSACCOUNT_SERVICE_PERMISSION_DENIED;
     }
 
-    return innerManager_->GetCreatedOsAccountNumFromDatabase(storeID, createdOsAccountNum);
+    return innerManager_.GetCreatedOsAccountNumFromDatabase(storeID, createdOsAccountNum);
 }
 
 void OsAccountManagerService::CreateBasicAccounts()
 {
     ACCOUNT_LOGI("enter!");
-    innerManager_->Init();
+    innerManager_.Init();
     ACCOUNT_LOGI("exit!");
 }
 
 ErrCode OsAccountManagerService::GetSerialNumberFromDatabase(const std::string& storeID,
     int64_t &serialNumber)
 {
-    return innerManager_->GetSerialNumberFromDatabase(storeID, serialNumber);
+    return innerManager_.GetSerialNumberFromDatabase(storeID, serialNumber);
 }
 
 ErrCode OsAccountManagerService::GetMaxAllowCreateIdFromDatabase(const std::string& storeID, int &id)
 {
-    return innerManager_->GetMaxAllowCreateIdFromDatabase(storeID, id);
+    return innerManager_.GetMaxAllowCreateIdFromDatabase(storeID, id);
 }
 
 ErrCode OsAccountManagerService::GetOsAccountFromDatabase(const std::string& storeID,
@@ -670,7 +668,7 @@ ErrCode OsAccountManagerService::GetOsAccountFromDatabase(const std::string& sto
         return ERR_OSACCOUNT_SERVICE_PERMISSION_DENIED;
     }
 
-    return innerManager_->GetOsAccountFromDatabase(storeID, id, osAccountInfo);
+    return innerManager_.GetOsAccountFromDatabase(storeID, id, osAccountInfo);
 }
 
 ErrCode OsAccountManagerService::GetOsAccountListFromDatabase(const std::string& storeID,
@@ -682,7 +680,7 @@ ErrCode OsAccountManagerService::GetOsAccountListFromDatabase(const std::string&
         return ERR_OSACCOUNT_SERVICE_PERMISSION_DENIED;
     }
 
-    return innerManager_->GetOsAccountListFromDatabase(storeID, osAccountList);
+    return innerManager_.GetOsAccountListFromDatabase(storeID, osAccountList);
 }
 
 ErrCode OsAccountManagerService::DumpStateByAccounts(
@@ -732,7 +730,7 @@ ErrCode OsAccountManagerService::DumpStateByAccounts(
 
 ErrCode OsAccountManagerService::QueryActiveOsAccountIds(std::vector<int32_t>& ids)
 {
-    return innerManager_->QueryActiveOsAccountIds(ids);
+    return innerManager_.QueryActiveOsAccountIds(ids);
 }
 
 ErrCode OsAccountManagerService::QueryOsAccountConstraintSourceTypes(const int32_t id,
@@ -755,7 +753,7 @@ ErrCode OsAccountManagerService::QueryOsAccountConstraintSourceTypes(const int32
         return ERR_OSACCOUNT_SERVICE_PERMISSION_DENIED;
     }
 
-    return innerManager_->QueryOsAccountConstraintSourceTypes(id, constraint, constraintSourceTypeInfos);
+    return innerManager_.QueryOsAccountConstraintSourceTypes(id, constraint, constraintSourceTypeInfos);
 }
 
 ErrCode OsAccountManagerService::SetGlobalOsAccountConstraints(const std::vector<std::string> &constraints,
@@ -767,7 +765,7 @@ ErrCode OsAccountManagerService::SetGlobalOsAccountConstraints(const std::vector
         return ERR_OSACCOUNT_SERVICE_PERMISSION_DENIED;
     }
 
-    return innerManager_->SetGlobalOsAccountConstraints(constraints, enable, enforcerId, isDeviceOwner);
+    return innerManager_.SetGlobalOsAccountConstraints(constraints, enable, enforcerId, isDeviceOwner);
 }
 
 ErrCode OsAccountManagerService::SetSpecificOsAccountConstraints(const std::vector<std::string> &constraints,
@@ -785,7 +783,7 @@ ErrCode OsAccountManagerService::SetSpecificOsAccountConstraints(const std::vect
         return ERR_OSACCOUNT_SERVICE_MANAGER_ID_ERROR;
     }
 
-    return innerManager_->SetSpecificOsAccountConstraints(constraints, enable, targetId, enforcerId, isDeviceOwner);
+    return innerManager_.SetSpecificOsAccountConstraints(constraints, enable, targetId, enforcerId, isDeviceOwner);
 }
 
 ErrCode OsAccountManagerService::SetDefaultActivatedOsAccount(const int32_t id)
@@ -802,12 +800,12 @@ ErrCode OsAccountManagerService::SetDefaultActivatedOsAccount(const int32_t id)
         return ERR_OSACCOUNT_SERVICE_PERMISSION_DENIED;
     }
 
-    return innerManager_->SetDefaultActivatedOsAccount(id);
+    return innerManager_.SetDefaultActivatedOsAccount(id);
 }
 
 ErrCode OsAccountManagerService::GetDefaultActivatedOsAccount(int32_t &id)
 {
-    return innerManager_->GetDefaultActivatedOsAccount(id);
+    return innerManager_.GetDefaultActivatedOsAccount(id);
 }
 
 bool OsAccountManagerService::PermissionCheck(const std::string& permissionName, const std::string& constraintName)
@@ -817,7 +815,7 @@ bool OsAccountManagerService::PermissionCheck(const std::string& permissionName,
     if (!constraintName.empty()) {
         int callerUserId = callerUid / UID_TRANSFORM_DIVISOR;
         bool isEnable = true;
-        innerManager_->IsOsAccountConstraintEnable(callerUserId, constraintName, isEnable);
+        innerManager_.IsOsAccountConstraintEnable(callerUserId, constraintName, isEnable);
         if (isEnable) {
             ACCOUNT_LOGE("constraint check %{public}s failed.", constraintName.c_str());
             ReportPermissionFail(callerUid, IPCSkeleton::GetCallingPid(), constraintName);
@@ -831,7 +829,7 @@ bool OsAccountManagerService::PermissionCheck(const std::string& permissionName,
     }
 
     // permission check
-    if ((permissionName.empty()) || (permissionManagerPtr_->VerifyPermission(permissionName) == ERR_OK)) {
+    if ((permissionName.empty()) || (AccountPermissionManager::VerifyPermission(permissionName) == ERR_OK)) {
         return true;
     }
 

services/accountmgr/src/osaccount/os_account_stub.cpp

@@ -344,7 +344,7 @@ int OsAccountStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessagePa
     if (messageProc != messageProcMap_.end()) {
         auto messageProcFunction = messageProc->second;
         if (messageProcFunction.isSyetemApi) {
-            ErrCode result = permissionManagerPtr_->CheckSystemApp();
+            ErrCode result = AccountPermissionManager::CheckSystemApp();
             if (result != ERR_OK) {
                 ACCOUNT_LOGE("is not system application, result = %{public}u.", result);
                 return result;

services/accountmgr/src/osaccount/os_account_subscribe_death_recipient.cpp

@@ -34,7 +34,7 @@ void OsAccountSubscribeDeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &r
         return;
     }
 
-    DelayedSingleton<OsAccountSubscribeManager>::GetInstance()->UnsubscribeOsAccount(object);
+    OsAccountSubscribeManager::GetInstance().UnsubscribeOsAccount(object);
 
     ACCOUNT_LOGI("end");
 }

services/accountmgr/src/osaccount/os_account_subscribe_manager.cpp

@@ -26,8 +26,11 @@ OsAccountSubscribeManager::OsAccountSubscribeManager()
         new (std::nothrow) OsAccountSubscribeDeathRecipient()))
 {}
 
-OsAccountSubscribeManager::~OsAccountSubscribeManager()
-{}
+OsAccountSubscribeManager &OsAccountSubscribeManager::GetInstance()
+{
+    static OsAccountSubscribeManager instance;
+    return instance;
+}
 
 ErrCode OsAccountSubscribeManager::SubscribeOsAccount(
     const std::shared_ptr<OsAccountSubscribeInfo> &subscribeInfoPtr, const sptr<IRemoteObject> &eventListener)

services/accountmgr/test/mock/app_account/app_account_authenticator_manager.cpp

@@ -18,12 +18,6 @@
 
 namespace OHOS {
 namespace AccountSA {
-AppAccountAuthenticatorManager::AppAccountAuthenticatorManager()
-{}
-
-AppAccountAuthenticatorManager::~AppAccountAuthenticatorManager()
-{}
-
 ErrCode AppAccountAuthenticatorManager::GetAuthenticatorInfo(
     const std::string &owner, int32_t userId, AuthenticatorInfo &info)
 {

services/accountmgr/test/mock/app_account/mock_app_account_subscribe_manager.h

@@ -23,9 +23,6 @@ namespace OHOS {
 namespace AccountSA {
 class MockAppAccountSubscribeManager : public AppAccountSubscribeManager {
 public:
-    MockAppAccountSubscribeManager();
-    virtual ~MockAppAccountSubscribeManager();
-
     ErrCode SubscribeAppAccount(const std::shared_ptr<AppAccountSubscribeInfo> &subscribeInfoPtr,
         const sptr<IRemoteObject> &eventListener, const std::string &bundleName, const uint32_t &appIndex);
     ErrCode UnsubscribeAppAccount(const sptr<IRemoteObject> &eventListener);

services/accountmgr/test/moduletest/app_account/account_permission_manager_module_test.cpp

@@ -28,18 +28,13 @@ public:
     static void TearDownTestCase(void);
     void SetUp(void) override;
     void TearDown(void) override;
-
-    std::shared_ptr<AccountPermissionManager>
-        permissionManagerPtr_ = DelayedSingleton<AccountPermissionManager>::GetInstance();
 };
 
 void AccountPermissionManagerModuleTest::SetUpTestCase(void)
 {}
 
 void AccountPermissionManagerModuleTest::TearDownTestCase(void)
-{
-    DelayedSingleton<AccountPermissionManager>::DestroyInstance();
-}
+{}
 
 void AccountPermissionManagerModuleTest::SetUp(void)
 {}
@@ -55,8 +50,6 @@ void AccountPermissionManagerModuleTest::TearDown(void)
  */
 HWTEST_F(AccountPermissionManagerModuleTest, AccountPermissionManager_VerifyPermission_0100, TestSize.Level0)
 {
-    ASSERT_NE(permissionManagerPtr_, nullptr);
-
-    ErrCode result = permissionManagerPtr_->VerifyPermission(AccountPermissionManager::DISTRIBUTED_DATASYNC);
+    ErrCode result = AccountPermissionManager::VerifyPermission(AccountPermissionManager::DISTRIBUTED_DATASYNC);
     EXPECT_EQ(result, ERR_ACCOUNT_ZIDL_CHECK_PERMISSION_ERROR);
 }

services/accountmgr/test/moduletest/app_account/app_account_authenticate_test.cpp

@@ -367,21 +367,6 @@ HWTEST_F(AppAccountAuthenticateModuleTest, AppAccountAuthenticateTest_IsAccountR
     EXPECT_EQ(result, ERR_OK);
 }
 
-/**
- * @tc.name: AppAccountAuthenticatorManagerTest_Init_0100
- * @tc.desc: test Init with isInitialized is true.
- * @tc.type: FUNC
- * @tc.require
- */
-HWTEST_F(AppAccountAuthenticateModuleTest, AppAccountAuthenticatorManagerTest_Init_0100, TestSize.Level1)
-{
-    auto appAccountAuthenticatorManagerPtr = std::make_shared<AppAccountAuthenticatorManager>();
-    ASSERT_NE(appAccountAuthenticatorManagerPtr, nullptr);
-    appAccountAuthenticatorManagerPtr->isInitialized_ = true;
-    appAccountAuthenticatorManagerPtr->Init();
-    ASSERT_EQ(appAccountAuthenticatorManagerPtr->isInitialized_, true);
-}
-
 /**
  * @tc.name: AppAccountAuthenticatorManagerTest_GetAuthenticatorInfo_0100
  * @tc.desc: test GetAuthenticatorInfo with not init.
@@ -391,13 +376,9 @@ HWTEST_F(AppAccountAuthenticateModuleTest, AppAccountAuthenticatorManagerTest_In
 HWTEST_F(AppAccountAuthenticateModuleTest, AppAccountAuthenticatorManagerTest_GetAuthenticatorInfo_0100,
     TestSize.Level1)
 {
-    auto appAccountAuthenticatorManagerPtr = std::make_shared<AppAccountAuthenticatorManager>();
-    ASSERT_NE(appAccountAuthenticatorManagerPtr, nullptr);
-    appAccountAuthenticatorManagerPtr->isInitialized_ = false;
     std::string owner = "owner";
     int32_t userId = 1;
     AuthenticatorInfo info;
-    ErrCode result = appAccountAuthenticatorManagerPtr->GetAuthenticatorInfo(owner, userId, info);
+    ErrCode result = AppAccountAuthenticatorManager::GetAuthenticatorInfo(owner, userId, info);
     ASSERT_NE(result, ERR_OK);
-    ASSERT_EQ(appAccountAuthenticatorManagerPtr->isInitialized_, true);
 }

services/accountmgr/test/moduletest/app_account/app_account_authenticator_session_manager_module_test.cpp

@@ -74,7 +74,7 @@ public:
     static void TearDownTestCase(void);
     void SetUp(void) override;
     void TearDown(void) override;
-    std::shared_ptr<AppAccountAuthenticatorSessionManager> appAccountAuthenticatorSessionManagerPtr_;
+    AppAccountAuthenticatorSessionManager *appAccountAuthenticatorSessionManagerPtr_;
 };
 
 void AppAccountSessionManagerModuleTest::SetUpTestCase(void)
@@ -85,13 +85,15 @@ void AppAccountSessionManagerModuleTest::TearDownTestCase(void)
 
 void AppAccountSessionManagerModuleTest::SetUp(void)
 {
-    appAccountAuthenticatorSessionManagerPtr_ = std::make_shared<AppAccountAuthenticatorSessionManager>();
+    appAccountAuthenticatorSessionManagerPtr_ = &AppAccountAuthenticatorSessionManager::GetInstance();
 }
 
 void AppAccountSessionManagerModuleTest::TearDown(void)
 {
-    DelayedSingleton<AppAccountAuthenticatorSessionManager>::DestroyInstance();
     GTEST_LOG_(INFO) << "TearDownTestCase exit";
+    std::lock_guard<std::mutex> lock(appAccountAuthenticatorSessionManagerPtr_->mutex_);
+    appAccountAuthenticatorSessionManagerPtr_->sessionMap_.clear();
+    appAccountAuthenticatorSessionManagerPtr_->abilitySessions_.clear();
 }
 
 /**

services/accountmgr/test/moduletest/app_account/app_account_authenticator_session_module_test.cpp

@@ -76,8 +76,6 @@ void AppAccountSessionModuleTest::SetUp(void)
 
 void AppAccountSessionModuleTest::TearDown(void)
 {
-    DelayedSingleton<AppAccountControlManager>::DestroyInstance();
-    DelayedSingleton<AppAccountAuthenticatorSession>::DestroyInstance();
     GTEST_LOG_(INFO) << "TearDownTestCase exit";
 }
 
@@ -321,43 +319,6 @@ HWTEST_F(AppAccountSessionModuleTest, AppAccountSessionModuleTest_OnResult_0100,
     ASSERT_EQ(resultCode, ERR_JS_SUCCESS);
 }
 
-/**
- * @tc.name: AppAccountAuthenticateTest_UpdateAuthInfo_0100
- * @tc.desc: test session func UpdateAuthInfo authtype equal request authtype.
- * @tc.type: FUNC
- * @tc.require:
- */
-HWTEST_F(AppAccountSessionModuleTest, AppAccountSessionModuleTest_UpdateAuthInfo_0100, TestSize.Level1)
-{
-    AuthenticatorSessionRequest request;
-    AAFwk::Want result;
-    AuthenticatorAction action = SET_AUTHENTICATOR_PROPERTIES;
-    std::string authType = result.GetStringParam(Constants::KEY_AUTH_TYPE);
-    request.authType = authType;
-    auto appAccountAuthenticatorSessionPtr = std::make_shared<AppAccountAuthenticatorSession>(action, request);
-    ASSERT_NE(appAccountAuthenticatorSessionPtr, nullptr);
-    int32_t resultCode = appAccountAuthenticatorSessionPtr->UpdateAuthInfo(result);
-    ASSERT_EQ(resultCode, ERR_JS_SUCCESS);
-}
-
-/**
- * @tc.name: AppAccountAuthenticateTest_UpdateAuthInfo_0200
- * @tc.desc: test session func UpdateAuthInfo failed with token is empty.
- * @tc.type: FUNC
- * @tc.require:
- */
-HWTEST_F(AppAccountSessionModuleTest, AppAccountSessionModuleTest_UpdateAuthInfo_0200, TestSize.Level1)
-{
-    AuthenticatorSessionRequest request;
-    AAFwk::Want result;
-    AuthenticatorAction action = SET_AUTHENTICATOR_PROPERTIES;
-    result.SetParam(Constants::KEY_TOKEN, STRING_EMPTY);
-    auto appAccountAuthenticatorSessionPtr = std::make_shared<AppAccountAuthenticatorSession>(action, request);
-    ASSERT_NE(appAccountAuthenticatorSessionPtr, nullptr);
-    int32_t resultCode = appAccountAuthenticatorSessionPtr->UpdateAuthInfo(result);
-    ASSERT_EQ(resultCode, ERR_JS_SUCCESS);
-}
-
 /**
  * @tc.name: AppAccountAuthenticateTest_GetAuthenticatorCallback_0100
  * @tc.desc: test func GetAuthenticatorCallback callerUid not equal ownerUid and callerBundleName not equal owner.

services/accountmgr/test/moduletest/app_account/app_account_control_manager_module_test.cpp

@@ -47,7 +47,6 @@ public:
     static void TearDownTestCase(void);
     void SetUp(void) override;
     void TearDown(void) override;
-    std::shared_ptr<AppAccountControlManager> controlManagerPtr_ = AppAccountControlManager::GetInstance();
 };
 
 void AppAccountControlManagerModuleTest::SetUpTestCase(void)
@@ -56,7 +55,6 @@ void AppAccountControlManagerModuleTest::SetUpTestCase(void)
 void AppAccountControlManagerModuleTest::TearDownTestCase(void)
 {
     GTEST_LOG_(INFO) << "TearDownTestCase enter";
-    DelayedSingleton<AppAccountControlManager>::DestroyInstance();
 }
 
 void AppAccountControlManagerModuleTest::SetUp(void)
@@ -74,10 +72,7 @@ void AppAccountControlManagerModuleTest::TearDown(void)
 HWTEST_F(AppAccountControlManagerModuleTest, AppAccountControlManager_AccountMaxSize_0100, TestSize.Level1)
 {
     ACCOUNT_LOGI("AppAccountControlManager_AccountMaxSize_0100");
-
-    ASSERT_NE(controlManagerPtr_, nullptr);
-
-    EXPECT_EQ(controlManagerPtr_->ACCOUNT_MAX_SIZE, ACCOUNT_MAX_SIZE);
+    EXPECT_EQ(AppAccountControlManager::GetInstance().ACCOUNT_MAX_SIZE, ACCOUNT_MAX_SIZE);
 }
 
 /**
@@ -89,9 +84,6 @@ HWTEST_F(AppAccountControlManagerModuleTest, AppAccountControlManager_AccountMax
 HWTEST_F(AppAccountControlManagerModuleTest, AppAccountControlManager_AccountMaxSize_0200, TestSize.Level1)
 {
     ACCOUNT_LOGI("AppAccountControlManager_AccountMaxSize_0200");
-
-    ASSERT_NE(controlManagerPtr_, nullptr);
-
     ErrCode result;
     std::string name;
     for (std::size_t index = 0; index < ACCOUNT_MAX_SIZE; index++) {
@@ -100,14 +92,16 @@ HWTEST_F(AppAccountControlManagerModuleTest, AppAccountControlManager_AccountMax
         GTEST_LOG_(INFO) << "before AddAccount, index = " << index;
 
         AppAccountInfo appAccountInfo(name, STRING_OWNER);
-        result = controlManagerPtr_->AddAccount(name, STRING_EXTRA_INFO, UID, STRING_OWNER, appAccountInfo);
+        result = AppAccountControlManager::GetInstance().AddAccount(
+            name, STRING_EXTRA_INFO, UID, STRING_OWNER, appAccountInfo);
         ASSERT_EQ(result, ERR_OK);
 
         std::this_thread::sleep_for(std::chrono::milliseconds(DELAY_FOR_OPERATION));
     }
 
     AppAccountInfo appAccountInfo(STRING_NAME, STRING_OWNER);
-    result = controlManagerPtr_->AddAccount(STRING_NAME, STRING_EXTRA_INFO, UID, STRING_OWNER, appAccountInfo);
+    result = AppAccountControlManager::GetInstance().AddAccount(
+        STRING_NAME, STRING_EXTRA_INFO, UID, STRING_OWNER, appAccountInfo);
     EXPECT_EQ(result, ERR_APPACCOUNT_SERVICE_ACCOUNT_MAX_SIZE);
 
     for (std::size_t index = 0; index < ACCOUNT_MAX_SIZE; index++) {
@@ -116,7 +110,7 @@ HWTEST_F(AppAccountControlManagerModuleTest, AppAccountControlManager_AccountMax
         GTEST_LOG_(INFO) << "before DeleteAccount, index = " << index;
 
         AppAccountInfo appAccountInfo(name, STRING_OWNER);
-        result = controlManagerPtr_->DeleteAccount(name, UID, STRING_OWNER, appAccountInfo);
+        result = AppAccountControlManager::GetInstance().DeleteAccount(name, UID, STRING_OWNER, appAccountInfo);
         ASSERT_EQ(result, ERR_OK);
 
         std::this_thread::sleep_for(std::chrono::milliseconds(DELAY_FOR_OPERATION));
@@ -132,37 +126,43 @@ HWTEST_F(AppAccountControlManagerModuleTest, AppAccountControlManager_AccountMax
 HWTEST_F(AppAccountControlManagerModuleTest, AppAccountControlManager_dataStoragePtrIsNull_0100, TestSize.Level1)
 {
     ACCOUNT_LOGI("AppAccountControlManager_RemoveAuthorizedAccountFromDataStorage_0100");
-
-    ASSERT_NE(controlManagerPtr_, nullptr);
     std::shared_ptr<AppAccountDataStorage> dataStoragePtr = nullptr;
     AppAccountInfo appAccountInfo;
     ErrCode result =
-        controlManagerPtr_->RemoveAuthorizedAccountFromDataStorage(AUTHORIZED_APP, appAccountInfo, dataStoragePtr);
+        AppAccountControlManager::GetInstance().RemoveAuthorizedAccountFromDataStorage(
+            AUTHORIZED_APP, appAccountInfo, dataStoragePtr);
     ASSERT_EQ(result, ERR_APPACCOUNT_SERVICE_DATA_STORAGE_PTR_IS_NULLPTR);
 
-    result = controlManagerPtr_->SaveAuthorizedAccountIntoDataStorage(AUTHORIZED_APP, appAccountInfo, dataStoragePtr);
+    result = AppAccountControlManager::GetInstance().SaveAuthorizedAccountIntoDataStorage(
+        AUTHORIZED_APP, appAccountInfo, dataStoragePtr);
     ASSERT_EQ(result, ERR_APPACCOUNT_SERVICE_DATA_STORAGE_PTR_IS_NULLPTR);
 
-    result = controlManagerPtr_->RemoveAuthorizedAccount(BUNDLE_NAME, appAccountInfo, dataStoragePtr, UID);
+    result = AppAccountControlManager::GetInstance().RemoveAuthorizedAccount(
+        BUNDLE_NAME, appAccountInfo, dataStoragePtr, UID);
     ASSERT_EQ(result, ERR_APPACCOUNT_SERVICE_DATA_STORAGE_PTR_IS_NULLPTR);
 
-    result = controlManagerPtr_->SaveAuthorizedAccount(BUNDLE_NAME, appAccountInfo, dataStoragePtr, UID);
+    result = AppAccountControlManager::GetInstance().SaveAuthorizedAccount(
+        BUNDLE_NAME, appAccountInfo, dataStoragePtr, UID);
     ASSERT_EQ(result, ERR_APPACCOUNT_SERVICE_DATA_STORAGE_PTR_IS_NULLPTR);
 
-    result = controlManagerPtr_->DeleteAccountInfoFromDataStorage(appAccountInfo, dataStoragePtr, UID);
+    result = AppAccountControlManager::GetInstance().DeleteAccountInfoFromDataStorage(
+        appAccountInfo, dataStoragePtr, UID);
     ASSERT_EQ(result, ERR_APPACCOUNT_SERVICE_DATA_STORAGE_PTR_IS_NULLPTR);
 
-    result = controlManagerPtr_->SaveAccountInfoIntoDataStorage(appAccountInfo, dataStoragePtr, UID);
+    result = AppAccountControlManager::GetInstance().SaveAccountInfoIntoDataStorage(
+        appAccountInfo, dataStoragePtr, UID);
     ASSERT_EQ(result, ERR_APPACCOUNT_SERVICE_DATA_STORAGE_PTR_IS_NULLPTR);
 
-    result = controlManagerPtr_->AddAccountInfoIntoDataStorage(appAccountInfo, dataStoragePtr, UID);
+    result = AppAccountControlManager::GetInstance().AddAccountInfoIntoDataStorage(
+        appAccountInfo, dataStoragePtr, UID);
     ASSERT_EQ(result, ERR_APPACCOUNT_SERVICE_DATA_STORAGE_PTR_IS_NULLPTR);
 
-    result = controlManagerPtr_->GetAccountInfoFromDataStorage(appAccountInfo, dataStoragePtr);
+    result = AppAccountControlManager::GetInstance().GetAccountInfoFromDataStorage(appAccountInfo, dataStoragePtr);
     ASSERT_EQ(result, ERR_APPACCOUNT_SERVICE_DATA_STORAGE_PTR_IS_NULLPTR);
 
     std::vector<AppAccountInfo> appAccounts;
-    result = controlManagerPtr_->GetAllAccessibleAccountsFromDataStorage(appAccounts, BUNDLE_NAME, dataStoragePtr, 0);
+    result = AppAccountControlManager::GetInstance().GetAllAccessibleAccountsFromDataStorage(
+        appAccounts, BUNDLE_NAME, dataStoragePtr, 0);
     ASSERT_EQ(result, ERR_APPACCOUNT_SERVICE_DATA_STORAGE_PTR_IS_NULLPTR);
 }
 
@@ -175,16 +175,13 @@ HWTEST_F(AppAccountControlManagerModuleTest, AppAccountControlManager_dataStorag
 HWTEST_F(AppAccountControlManagerModuleTest, AppAccountControlManager_NeedSyncDataStorage_0100, TestSize.Level1)
 {
     ACCOUNT_LOGI("AppAccountControlManager_GNeedSyncDataStorage_0100");
-
-    ASSERT_NE(controlManagerPtr_, nullptr);
-
     AppAccountInfo appAccountInfo;
     bool syncEnable = false;
     appAccountInfo.SetSyncEnable(syncEnable);
     syncEnable = true;
     appAccountInfo.GetSyncEnable(syncEnable);
     ASSERT_EQ(syncEnable, false);
-    bool result = controlManagerPtr_->NeedSyncDataStorage(appAccountInfo);
+    bool result = AppAccountControlManager::GetInstance().NeedSyncDataStorage(appAccountInfo);
     ASSERT_EQ(result, false);
 }
 
@@ -198,21 +195,18 @@ HWTEST_F(
     AppAccountControlManagerModuleTest, AppAccountControlManager_GetAllAccountsFromDataStorage_0100, TestSize.Level1)
 {
     ACCOUNT_LOGI("AppAccountControlManager_GetAllAccountsFromDataStorage_0100");
-
-    ASSERT_NE(controlManagerPtr_, nullptr);
-
     AppExecFwk::AbilityStateData abilityStateData;
     abilityStateData.abilityState = static_cast<int32_t>(AppExecFwk::AbilityState::ABILITY_STATE_TERMINATED);
-    controlManagerPtr_->OnAbilityStateChanged(abilityStateData);
-    ASSERT_EQ(controlManagerPtr_->associatedDataCache_.empty(), true);
+    AppAccountControlManager::GetInstance().OnAbilityStateChanged(abilityStateData);
+    ASSERT_EQ(AppAccountControlManager::GetInstance().associatedDataCache_.empty(), true);
 
     abilityStateData.abilityState = static_cast<int32_t>(AppExecFwk::AbilityState::ABILITY_STATE_BACKGROUND);
-    controlManagerPtr_->OnAbilityStateChanged(abilityStateData);
+    AppAccountControlManager::GetInstance().OnAbilityStateChanged(abilityStateData);
     std::vector<AppAccountInfo> appAccounts;
 
     std::shared_ptr<AppAccountDataStorage> dataStoragePtr = nullptr;
-    ErrCode result =
-        controlManagerPtr_->GetAllAccountsFromDataStorage(STRING_OWNER, appAccounts, BUNDLE_NAME, dataStoragePtr);
+    ErrCode result = AppAccountControlManager::GetInstance().GetAllAccountsFromDataStorage(
+        STRING_OWNER, appAccounts, BUNDLE_NAME, dataStoragePtr);
     ASSERT_EQ(result, ERR_APPACCOUNT_SERVICE_DATA_STORAGE_PTR_IS_NULLPTR);
 }
 
@@ -225,9 +219,6 @@ HWTEST_F(
 HWTEST_F(AppAccountControlManagerModuleTest, AppAccountControlManager_GetAllOAuthTokens_0100, TestSize.Level1)
 {
     ACCOUNT_LOGI("AppAccountControlManager_GetAllOAuthTokens_0100");
-
-    ASSERT_NE(controlManagerPtr_, nullptr);
-
     AuthenticatorSessionRequest request;
     request.name = STRING_NAME;
     request.owner = STRING_OWNER;
@@ -250,12 +241,12 @@ HWTEST_F(AppAccountControlManagerModuleTest, AppAccountControlManager_GetAllOAut
     bool isSyncEnable = false;
     appAccountInfo.GetSyncEnable(isSyncEnable);
     ASSERT_NE(isSyncEnable, false);
-    auto dataStoragePtr = controlManagerPtr_->GetDataStorage(request.callerUid, false);
+    auto dataStoragePtr = AppAccountControlManager::GetInstance().GetDataStorage(request.callerUid, false);
     ASSERT_NE(dataStoragePtr, nullptr);
-    ErrCode result =
-        controlManagerPtr_->AddAccountInfoIntoDataStorage(appAccountInfo, dataStoragePtr, request.callerUid);
+    ErrCode result = AppAccountControlManager::GetInstance().AddAccountInfoIntoDataStorage(
+        appAccountInfo, dataStoragePtr, request.callerUid);
     ASSERT_EQ(result, ERR_OK);
-    result = controlManagerPtr_->GetAllOAuthTokens(request, tokenInfos);
+    result = AppAccountControlManager::GetInstance().GetAllOAuthTokens(request, tokenInfos);
     ASSERT_EQ(result, ERR_OK);
     EXPECT_EQ(tokenInfos.size(), 1);
 }

services/accountmgr/test/moduletest/app_account/app_account_manager_service_module_test.cpp

@@ -91,7 +91,6 @@ constexpr std::int32_t DELAY_FOR_MESSAGE = 1000;
 constexpr std::int32_t WAIT_FOR_ONE_CASE = 1000;
 std::shared_ptr<AppAccountManagerService> g_accountManagerService =
     std::make_shared<AppAccountManagerService>();
-std::shared_ptr<AppAccountControlManager> g_controlManagerPtr = AppAccountControlManager::GetInstance();
 }  // namespace
 
 class MockAuthenticatorCallback final : public AppAccountAuthenticatorCallbackStub {
@@ -112,7 +111,7 @@ public:
 
 void AppAccountManagerServiceModuleTest::ClearDataStorage()
 {
-    auto dataStoragePtr = g_controlManagerPtr->GetDataStorage(UID);
+    auto dataStoragePtr = AppAccountControlManager::GetInstance().GetDataStorage(UID);
     std::map<std::string, std::shared_ptr<IAccountInfo>> accounts;
     dataStoragePtr->LoadAllData(accounts);
     if (!accounts.empty()) {
@@ -132,19 +131,18 @@ void AppAccountManagerServiceModuleTest::SetUpTestCase(void)
 void AppAccountManagerServiceModuleTest::TearDownTestCase(void)
 {
     GTEST_LOG_(INFO) << "TearDownTestCase enter";
-    auto dataStoragePtr = g_controlManagerPtr->GetDataStorage(UID);
+    auto dataStoragePtr = AppAccountControlManager::GetInstance().GetDataStorage(UID);
     ASSERT_NE(dataStoragePtr, nullptr);
 
     ErrCode result = dataStoragePtr->DeleteKvStore();
     ASSERT_EQ(result, ERR_OK);
 
 #ifdef DISTRIBUTED_FEATURE_ENABLED
-    dataStoragePtr = g_controlManagerPtr->GetDataStorage(UID, true);
+    dataStoragePtr = AppAccountControlManager::GetInstance().GetDataStorage(UID, true);
     ASSERT_NE(dataStoragePtr, nullptr);
 
     result = dataStoragePtr->DeleteKvStore();
     ASSERT_EQ(result, ERR_OK);
-    DelayedSingleton<AppAccountControlManager>::DestroyInstance();
 #endif // DISTRIBUTED_FEATURE_ENABLED
     GTEST_LOG_(INFO) << "TearDownTestCase exit";
 }
@@ -285,7 +283,7 @@ HWTEST_F(AppAccountManagerServiceModuleTest, AppAccountManagerService_DeleteAcco
     result = g_accountManagerService->DeleteAccount(STRING_NAME);
     EXPECT_EQ(result, ERR_OK);
 
-    auto dataStoragePtr = g_controlManagerPtr->GetDataStorage(UID);
+    auto dataStoragePtr = AppAccountControlManager::GetInstance().GetDataStorage(UID);
     ASSERT_NE(dataStoragePtr, nullptr);
 
     std::vector<std::string> accessibleAccounts;
@@ -2118,13 +2116,15 @@ HWTEST_F(AppAccountManagerServiceModuleTest, AppAccountManagerService_GetAllAcco
 
     AppAccountInfo appAccountInfo(STRING_NAME, STRING_BUNDLE_NAME);
     ErrCode result =
-        g_controlManagerPtr->AddAccount(STRING_NAME, STRING_EMPTY, UID, STRING_BUNDLE_NAME, appAccountInfo);
+        AppAccountControlManager::GetInstance().AddAccount(
+            STRING_NAME, STRING_EMPTY, UID, STRING_BUNDLE_NAME, appAccountInfo);
     EXPECT_EQ(result, ERR_OK);
 
     AppAccountCallingInfo appAccountCallingInfo;
     appAccountCallingInfo.callingUid = UID;
     appAccountCallingInfo.bundleName = STRING_BUNDLE_NAME;
-    result = g_controlManagerPtr->EnableAppAccess(STRING_NAME, STRING_OWNER, appAccountCallingInfo, appAccountInfo);
+    result = AppAccountControlManager::GetInstance().EnableAppAccess(
+        STRING_NAME, STRING_OWNER, appAccountCallingInfo, appAccountInfo);
     EXPECT_EQ(result, ERR_OK);
 
     std::vector<AppAccountInfo> appAccounts;
@@ -2136,7 +2136,8 @@ HWTEST_F(AppAccountManagerServiceModuleTest, AppAccountManagerService_GetAllAcco
     appAccounts.begin()->GetOwner(owner);
     EXPECT_EQ(owner, STRING_BUNDLE_NAME);
 
-    result = g_controlManagerPtr->DeleteAccount(STRING_NAME, UID, STRING_BUNDLE_NAME, appAccountInfo);
+    result = AppAccountControlManager::GetInstance().DeleteAccount(
+        STRING_NAME, UID, STRING_BUNDLE_NAME, appAccountInfo);
     EXPECT_EQ(result, ERR_OK);
 }
 
@@ -2151,19 +2152,20 @@ HWTEST_F(AppAccountManagerServiceModuleTest, AppAccountManagerService_GetAllAcco
     ACCOUNT_LOGI("AppAccountManagerService_GetAllAccounts_0500");
 
     AppAccountInfo appAccountInfo(STRING_NAME, STRING_BUNDLE_NAME);
-    ErrCode result =
-        g_controlManagerPtr->AddAccount(STRING_NAME, STRING_EMPTY, UID, STRING_BUNDLE_NAME, appAccountInfo);
+    ErrCode result = AppAccountControlManager::GetInstance().AddAccount(
+            STRING_NAME, STRING_EMPTY, UID, STRING_BUNDLE_NAME, appAccountInfo);
     EXPECT_EQ(result, ERR_OK);
 
     AppAccountInfo appAccountInfoTwo(STRING_NAME_TWO, STRING_OWNER);
-    result = g_controlManagerPtr->AddAccount(STRING_NAME_TWO, STRING_EMPTY, UID, STRING_OWNER, appAccountInfoTwo);
+    result = AppAccountControlManager::GetInstance().AddAccount(
+        STRING_NAME_TWO, STRING_EMPTY, UID, STRING_OWNER, appAccountInfoTwo);
     EXPECT_EQ(result, ERR_OK);
 
     AppAccountCallingInfo appAccountCallingInfo;
     appAccountCallingInfo.callingUid = UID;
     appAccountCallingInfo.bundleName = STRING_BUNDLE_NAME;
-    result =
-        g_controlManagerPtr->EnableAppAccess(STRING_NAME, STRING_OWNER, appAccountCallingInfo, appAccountInfo);
+    result = AppAccountControlManager::GetInstance().EnableAppAccess(
+            STRING_NAME, STRING_OWNER, appAccountCallingInfo, appAccountInfo);
     EXPECT_EQ(result, ERR_OK);
 
     std::vector<AppAccountInfo> appAccounts;
@@ -2179,10 +2181,12 @@ HWTEST_F(AppAccountManagerServiceModuleTest, AppAccountManagerService_GetAllAcco
     appAccounts.begin()->GetName(name);
     EXPECT_EQ(name, STRING_NAME);
 
-    result = g_controlManagerPtr->DeleteAccount(STRING_NAME, UID, STRING_BUNDLE_NAME, appAccountInfo);
+    result = AppAccountControlManager::GetInstance().DeleteAccount(
+        STRING_NAME, UID, STRING_BUNDLE_NAME, appAccountInfo);
     EXPECT_EQ(result, ERR_OK);
 
-    result = g_controlManagerPtr->DeleteAccount(STRING_NAME_TWO, UID, STRING_OWNER, appAccountInfoTwo);
+    result = AppAccountControlManager::GetInstance().DeleteAccount(
+        STRING_NAME_TWO, UID, STRING_OWNER, appAccountInfoTwo);
     EXPECT_EQ(result, ERR_OK);
 }
 
@@ -2292,14 +2296,15 @@ HWTEST_F(AppAccountManagerServiceModuleTest, AppAccountManagerService_QueryAllAc
 HWTEST_F(AppAccountManagerServiceModuleTest, AppAccountManagerService_GetAllAccessibleAccounts_0300, TestSize.Level1)
 {
     AppAccountInfo appAccountInfo(STRING_NAME, STRING_BUNDLE_NAME);
-    ErrCode result =
-        g_controlManagerPtr->AddAccount(STRING_NAME, STRING_EMPTY, UID, STRING_BUNDLE_NAME, appAccountInfo);
+    ErrCode result = AppAccountControlManager::GetInstance().AddAccount(
+        STRING_NAME, STRING_EMPTY, UID, STRING_BUNDLE_NAME, appAccountInfo);
     EXPECT_EQ(result, ERR_OK);
 
     AppAccountCallingInfo appAccountCallingInfo;
     appAccountCallingInfo.callingUid = UID;
     appAccountCallingInfo.bundleName = STRING_BUNDLE_NAME;
-    result = g_controlManagerPtr->EnableAppAccess(STRING_NAME, STRING_OWNER, appAccountCallingInfo, appAccountInfo);
+    result = AppAccountControlManager::GetInstance().EnableAppAccess(
+        STRING_NAME, STRING_OWNER, appAccountCallingInfo, appAccountInfo);
     EXPECT_EQ(result, ERR_OK);
 
     std::vector<AppAccountInfo> appAccounts;
@@ -2322,7 +2327,8 @@ HWTEST_F(AppAccountManagerServiceModuleTest, AppAccountManagerService_GetAllAcce
     appAccounts.begin()->GetOwner(owner);
     EXPECT_EQ(owner, STRING_BUNDLE_NAME);
 
-    result = g_controlManagerPtr->DeleteAccount(STRING_NAME, UID, STRING_BUNDLE_NAME, appAccountInfo);
+    result = AppAccountControlManager::GetInstance().DeleteAccount(
+        STRING_NAME, UID, STRING_BUNDLE_NAME, appAccountInfo);
     EXPECT_EQ(result, ERR_OK);
 }
 
@@ -2335,7 +2341,7 @@ HWTEST_F(AppAccountManagerServiceModuleTest, AppAccountManagerService_GetAllAcce
 HWTEST_F(AppAccountManagerServiceModuleTest, AppAccountManagerService_OnPackageRemoved_0100, TestSize.Level1)
 {
     ACCOUNT_LOGI("AppAccountManagerService_OnPackageRemoved_0100");
-    auto dataStoragePtr = g_controlManagerPtr->GetDataStorage(UID);
+    auto dataStoragePtr = AppAccountControlManager::GetInstance().GetDataStorage(UID);
     ASSERT_NE(dataStoragePtr, nullptr);
 
     AppAccountInfo appAccountInfo(STRING_NAME, STRING_BUNDLE_NAME);

services/accountmgr/test/moduletest/app_account/app_account_manager_service_subscribe_module_test.cpp

@@ -55,7 +55,6 @@ public:
     void TearDown(void) override;
     std::shared_ptr<AppAccountManagerService>
         appAccountManagerServicePtr_ = std::make_shared<AppAccountManagerService>();
-    std::shared_ptr<AppAccountControlManager> controlManagerPtr_ = AppAccountControlManager::GetInstance();
 };
 
 void AppAccountManagerServiceSubscribeModuleTest::SetUpTestCase(void)
@@ -66,7 +65,6 @@ void AppAccountManagerServiceSubscribeModuleTest::SetUpTestCase(void)
 void AppAccountManagerServiceSubscribeModuleTest::TearDownTestCase(void)
 {
     GTEST_LOG_(INFO) << "TearDownTestCase";
-    DelayedSingleton<AppAccountControlManager>::DestroyInstance();
     std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_FOR_EXIT));
 }
 
@@ -243,12 +241,12 @@ HWTEST_F(AppAccountManagerServiceSubscribeModuleTest, AppAccountManagerServiceSu
     // make an event listener
     sptr<IRemoteObject> appAccountEventListener = nullptr;
 
-    ErrCode subscribeState = DelayedSingleton<AppAccount>::GetInstance()->CreateAppAccountEventListener(
+    ErrCode subscribeState = AppAccount::GetInstance().CreateAppAccountEventListener(
         subscriberTestPtr, appAccountEventListener);
     EXPECT_EQ(subscribeState, AppAccount::INITIAL_SUBSCRIPTION);
 
     subscribeState =
-        DelayedSingleton<AppAccount>::GetInstance()->CreateAppAccountEventListener(nullptr, appAccountEventListener);
+        AppAccount::GetInstance().CreateAppAccountEventListener(nullptr, appAccountEventListener);
     EXPECT_EQ(subscribeState, AppAccount::SUBSCRIBE_FAILED);
 
     // subscribe app account
@@ -322,7 +320,7 @@ HWTEST_F(AppAccountManagerServiceSubscribeModuleTest, AppAccountManagerServiceSu
     // make an event listener
     sptr<IRemoteObject> appAccountEventListener = nullptr;
 
-    ErrCode subscribeState = DelayedSingleton<AppAccount>::GetInstance()->CreateAppAccountEventListener(
+    ErrCode subscribeState = AppAccount::GetInstance().CreateAppAccountEventListener(
         subscriberTestPtr, appAccountEventListener);
     EXPECT_EQ(subscribeState, AppAccount::INITIAL_SUBSCRIPTION);
 
@@ -359,7 +357,7 @@ HWTEST_F(AppAccountManagerServiceSubscribeModuleTest, AppAccountManagerServiceSu
     // make an event listener
     sptr<IRemoteObject> appAccountEventListener = nullptr;
 
-    ErrCode subscribeState = DelayedSingleton<AppAccount>::GetInstance()->CreateAppAccountEventListener(
+    ErrCode subscribeState = AppAccount::GetInstance().CreateAppAccountEventListener(
         subscriberTestPtr, appAccountEventListener);
     EXPECT_EQ(subscribeState, AppAccount::INITIAL_SUBSCRIPTION);
 
@@ -383,14 +381,16 @@ HWTEST_F(AppAccountManagerServiceSubscribeModuleTest, AppAccountManagerServiceSu
     std::string name = STRING_NAME;
     std::string bundleName = STRING_BUNDLE_NAME;
     AppAccountInfo appAccountInfo(name, bundleName);
-    ErrCode result = controlManagerPtr_->AddAccount(name, STRING_EXTRA_INFO, UID, bundleName, appAccountInfo);
+    ErrCode result = AppAccountControlManager::GetInstance().AddAccount(
+        name, STRING_EXTRA_INFO, UID, bundleName, appAccountInfo);
     EXPECT_EQ(result, ERR_OK);
 
     // enable app access
     AppAccountCallingInfo appAccountCallingInfo;
     appAccountCallingInfo.callingUid = UID;
     appAccountCallingInfo.bundleName = bundleName;
-    result = controlManagerPtr_->EnableAppAccess(name, STRING_OWNER, appAccountCallingInfo, appAccountInfo);
+    result = AppAccountControlManager::GetInstance().EnableAppAccess(
+        name, STRING_OWNER, appAccountCallingInfo, appAccountInfo);
     EXPECT_EQ(result, ERR_OK);
 
     // make owners
@@ -406,7 +406,7 @@ HWTEST_F(AppAccountManagerServiceSubscribeModuleTest, AppAccountManagerServiceSu
     // make an event listener
     sptr<IRemoteObject> appAccountEventListener = nullptr;
 
-    ErrCode subscribeState = DelayedSingleton<AppAccount>::GetInstance()->CreateAppAccountEventListener(
+    ErrCode subscribeState = AppAccount::GetInstance().CreateAppAccountEventListener(
         subscriberTestPtr, appAccountEventListener);
     EXPECT_EQ(subscribeState, AppAccount::INITIAL_SUBSCRIPTION);
 
@@ -419,7 +419,7 @@ HWTEST_F(AppAccountManagerServiceSubscribeModuleTest, AppAccountManagerServiceSu
     EXPECT_EQ(result, ERR_OK);
 
     // delete account
-    result = controlManagerPtr_->DeleteAccount(name, UID, bundleName, appAccountInfo);
+    result = AppAccountControlManager::GetInstance().DeleteAccount(name, UID, bundleName, appAccountInfo);
     EXPECT_EQ(result, ERR_OK);
 }
 
@@ -460,7 +460,7 @@ HWTEST_F(AppAccountManagerServiceSubscribeModuleTest, AppAccountManagerServiceSu
     // make an event listener
     sptr<IRemoteObject> appAccountEventListener = nullptr;
 
-    ErrCode subscribeState = DelayedSingleton<AppAccount>::GetInstance()->CreateAppAccountEventListener(
+    ErrCode subscribeState = AppAccount::GetInstance().CreateAppAccountEventListener(
         subscriberTestPtr, appAccountEventListener);
     EXPECT_EQ(subscribeState, AppAccount::INITIAL_SUBSCRIPTION);
 
@@ -551,7 +551,7 @@ HWTEST_F(AppAccountManagerServiceSubscribeModuleTest, AppAccountManagerServiceSu
     // make an event listener
     sptr<IRemoteObject> appAccountEventListener = nullptr;
 
-    ErrCode subscribeState = DelayedSingleton<AppAccount>::GetInstance()->CreateAppAccountEventListener(
+    ErrCode subscribeState = AppAccount::GetInstance().CreateAppAccountEventListener(
         subscriberTestPtr, appAccountEventListener);
     EXPECT_EQ(subscribeState, AppAccount::INITIAL_SUBSCRIPTION);
 
@@ -646,7 +646,7 @@ HWTEST_F(AppAccountManagerServiceSubscribeModuleTest, AppAccountManagerServiceSu
     // make an event listener
     sptr<IRemoteObject> appAccountEventListener = nullptr;
 
-    ErrCode subscribeState = DelayedSingleton<AppAccount>::GetInstance()->CreateAppAccountEventListener(
+    ErrCode subscribeState = AppAccount::GetInstance().CreateAppAccountEventListener(
         subscriberTestPtr, appAccountEventListener);
     EXPECT_EQ(subscribeState, AppAccount::INITIAL_SUBSCRIPTION);
 
@@ -724,7 +724,7 @@ HWTEST_F(AppAccountManagerServiceSubscribeModuleTest, AppAccountManagerServiceSu
     // make an event listener
     sptr<IRemoteObject> appAccountEventListener = nullptr;
 
-    ErrCode subscribeState = DelayedSingleton<AppAccount>::GetInstance()->CreateAppAccountEventListener(
+    ErrCode subscribeState = AppAccount::GetInstance().CreateAppAccountEventListener(
         subscriberTestPtr, appAccountEventListener);
     EXPECT_EQ(subscribeState, AppAccount::INITIAL_SUBSCRIPTION);
 
@@ -738,7 +738,7 @@ HWTEST_F(AppAccountManagerServiceSubscribeModuleTest, AppAccountManagerServiceSu
     // make an event listener
     sptr<IRemoteObject> appAccountEventListenerTwo = nullptr;
 
-    subscribeState = DelayedSingleton<AppAccount>::GetInstance()->CreateAppAccountEventListener(
+    subscribeState = AppAccount::GetInstance().CreateAppAccountEventListener(
         subscriberTestPtrTwo, appAccountEventListenerTwo);
     EXPECT_EQ(subscribeState, AppAccount::INITIAL_SUBSCRIPTION);
 

services/accountmgr/test/moduletest/app_account/app_account_manager_service_sync_module_test.cpp

@@ -57,7 +57,6 @@ public:
     void ClearDataStorage(std::shared_ptr<AppAccountDataStorage> &dataStoragePtr);
     std::shared_ptr<AppAccountManagerService>
         appAccountManagerServicePtr_ = std::make_shared<AppAccountManagerService>();
-    std::shared_ptr<AppAccountControlManager> controlManagerPtr_ = AppAccountControlManager::GetInstance();
 };
 
 void AppAccountManagerServiceSyncModuleTest::SetUpTestCase(void)
@@ -66,17 +65,16 @@ void AppAccountManagerServiceSyncModuleTest::SetUpTestCase(void)
 void AppAccountManagerServiceSyncModuleTest::TearDownTestCase(void)
 {
     GTEST_LOG_(INFO) << "TearDownTestCase!";
-    DelayedSingleton<AppAccountControlManager>::DestroyInstance();
     std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_FOR_EXIT));
 }
 
 void AppAccountManagerServiceSyncModuleTest::SetUp(void)
 {
     GTEST_LOG_(INFO) << "SetUp enter!";
-    auto dataStoragePtr = controlManagerPtr_->GetDataStorage(UID);
+    auto dataStoragePtr = AppAccountControlManager::GetInstance().GetDataStorage(UID);
     ClearDataStorage(dataStoragePtr);
 #ifdef DISTRIBUTED_FEATURE_ENABLED
-    dataStoragePtr = controlManagerPtr_->GetDataStorage(UID, true);
+    dataStoragePtr = AppAccountControlManager::GetInstance().GetDataStorage(UID, true);
     ClearDataStorage(dataStoragePtr);
 #endif // DISTRIBUTED_FEATURE_ENABLED
     GTEST_LOG_(INFO) << "SetUp exit!";
@@ -112,7 +110,7 @@ HWTEST_F(AppAccountManagerServiceSyncModuleTest, AppAccountManagerServiceSync_Ad
     ErrCode result = appAccountManagerServicePtr_->AddAccount(STRING_NAME, STRING_EXTRA_INFO);
     EXPECT_EQ(result, ERR_OK);
     std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_FOR_KVSTORE));
-    auto dataStoragePtr = controlManagerPtr_->GetDataStorage(UID);
+    auto dataStoragePtr = AppAccountControlManager::GetInstance().GetDataStorage(UID);
     ASSERT_NE(dataStoragePtr, nullptr);
 
     std::map<std::string, std::shared_ptr<IAccountInfo>> accounts;
@@ -152,7 +150,7 @@ HWTEST_F(AppAccountManagerServiceSyncModuleTest, AppAccountManagerServiceSync_Ad
     std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_FOR_KVSTORE));
 
     {
-        auto dataStoragePtr = controlManagerPtr_->GetDataStorage(UID);
+        auto dataStoragePtr = AppAccountControlManager::GetInstance().GetDataStorage(UID);
         ASSERT_NE(dataStoragePtr, nullptr);
 
         std::map<std::string, std::shared_ptr<IAccountInfo>> accounts;
@@ -170,7 +168,7 @@ HWTEST_F(AppAccountManagerServiceSyncModuleTest, AppAccountManagerServiceSync_Ad
     }
 #ifdef DISTRIBUTED_FEATURE_ENABLED
     {
-        auto dataStoragePtr = controlManagerPtr_->GetDataStorage(UID, true);
+        auto dataStoragePtr = AppAccountControlManager::GetInstance().GetDataStorage(UID, true);
         ASSERT_NE(dataStoragePtr, nullptr);
 
         std::map<std::string, std::shared_ptr<IAccountInfo>> accounts;
@@ -214,7 +212,7 @@ HWTEST_F(AppAccountManagerServiceSyncModuleTest, AppAccountManagerServiceSync_De
     EXPECT_EQ(result, ERR_OK);
 
     {
-        auto dataStoragePtr = controlManagerPtr_->GetDataStorage(UID);
+        auto dataStoragePtr = AppAccountControlManager::GetInstance().GetDataStorage(UID);
         ASSERT_NE(dataStoragePtr, nullptr);
 
         std::map<std::string, std::shared_ptr<IAccountInfo>> accounts;
@@ -224,7 +222,7 @@ HWTEST_F(AppAccountManagerServiceSyncModuleTest, AppAccountManagerServiceSync_De
     }
 #ifdef DISTRIBUTED_FEATURE_ENABLED
     {
-        auto dataStoragePtr = controlManagerPtr_->GetDataStorage(UID, true);
+        auto dataStoragePtr = AppAccountControlManager::GetInstance().GetDataStorage(UID, true);
         ASSERT_NE(dataStoragePtr, nullptr);
 
         std::map<std::string, std::shared_ptr<IAccountInfo>> accounts;
@@ -261,7 +259,7 @@ HWTEST_F(AppAccountManagerServiceSyncModuleTest, AppAccountManagerServiceSync_De
     result = appAccountManagerServicePtr_->DeleteAccount(STRING_NAME);
     EXPECT_EQ(result, ERR_OK);
     {
-        auto dataStoragePtr = controlManagerPtr_->GetDataStorage(UID);
+        auto dataStoragePtr = AppAccountControlManager::GetInstance().GetDataStorage(UID);
         ASSERT_NE(dataStoragePtr, nullptr);
 
         std::map<std::string, std::shared_ptr<IAccountInfo>> accounts;
@@ -294,7 +292,7 @@ HWTEST_F(
     EXPECT_EQ(result, ERR_OK);
 
     {
-        auto dataStoragePtr = controlManagerPtr_->GetDataStorage(UID);
+        auto dataStoragePtr = AppAccountControlManager::GetInstance().GetDataStorage(UID);
         ASSERT_NE(dataStoragePtr, nullptr);
 
         std::map<std::string, std::shared_ptr<IAccountInfo>> accounts;
@@ -316,7 +314,7 @@ HWTEST_F(
     }
 #ifdef DISTRIBUTED_FEATURE_ENABLED
     {
-        auto dataStoragePtr = controlManagerPtr_->GetDataStorage(UID, true);
+        auto dataStoragePtr = AppAccountControlManager::GetInstance().GetDataStorage(UID, true);
         ASSERT_NE(dataStoragePtr, nullptr);
 
         std::map<std::string, std::shared_ptr<IAccountInfo>> accounts;
@@ -373,7 +371,7 @@ HWTEST_F(
     EXPECT_EQ(result, ERR_OK);
 
     {
-        auto dataStoragePtr = controlManagerPtr_->GetDataStorage(UID);
+        auto dataStoragePtr = AppAccountControlManager::GetInstance().GetDataStorage(UID);
         ASSERT_NE(dataStoragePtr, nullptr);
 
         std::map<std::string, std::shared_ptr<IAccountInfo>> accounts;
@@ -398,7 +396,7 @@ HWTEST_F(
     }
 #ifdef DISTRIBUTED_FEATURE_ENABLED
     {
-        auto dataStoragePtr = controlManagerPtr_->GetDataStorage(UID, true);
+        auto dataStoragePtr = AppAccountControlManager::GetInstance().GetDataStorage(UID, true);
         ASSERT_NE(dataStoragePtr, nullptr);
 
         std::map<std::string, std::shared_ptr<IAccountInfo>> accounts;
@@ -460,7 +458,7 @@ HWTEST_F(
     std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_FOR_KVSTORE));
 
     {
-        auto dataStoragePtr = controlManagerPtr_->GetDataStorage(UID);
+        auto dataStoragePtr = AppAccountControlManager::GetInstance().GetDataStorage(UID);
         ASSERT_NE(dataStoragePtr, nullptr);
 
         std::map<std::string, std::shared_ptr<IAccountInfo>> accounts;
@@ -481,7 +479,7 @@ HWTEST_F(
     }
 #ifdef DISTRIBUTED_FEATURE_ENABLED
     {
-        auto dataStoragePtr = controlManagerPtr_->GetDataStorage(UID, true);
+        auto dataStoragePtr = AppAccountControlManager::GetInstance().GetDataStorage(UID, true);
         ASSERT_NE(dataStoragePtr, nullptr);
 
         std::map<std::string, std::shared_ptr<IAccountInfo>> accounts;
@@ -528,7 +526,7 @@ HWTEST_F(AppAccountManagerServiceSyncModuleTest, AppAccountManagerServiceSync_En
     EXPECT_EQ(result, ERR_OK);
 
     {
-        auto dataStoragePtr = controlManagerPtr_->GetDataStorage(UID);
+        auto dataStoragePtr = AppAccountControlManager::GetInstance().GetDataStorage(UID);
         ASSERT_NE(dataStoragePtr, nullptr);
 
         std::string authorizedAccounts;
@@ -548,7 +546,7 @@ HWTEST_F(AppAccountManagerServiceSyncModuleTest, AppAccountManagerServiceSync_En
     }
 #ifdef DISTRIBUTED_FEATURE_ENABLED
     {
-        auto dataStoragePtr = controlManagerPtr_->GetDataStorage(UID, true);
+        auto dataStoragePtr = AppAccountControlManager::GetInstance().GetDataStorage(UID, true);
         ASSERT_NE(dataStoragePtr, nullptr);
 
         std::string authorizedAccounts;
@@ -597,7 +595,7 @@ HWTEST_F(AppAccountManagerServiceSyncModuleTest, AppAccountManagerServiceSync_En
     EXPECT_EQ(result, ERR_APPACCOUNT_SERVICE_ENABLE_APP_ACCESS_ALREADY_EXISTS);
 
     {
-        auto dataStoragePtr = controlManagerPtr_->GetDataStorage(UID);
+        auto dataStoragePtr = AppAccountControlManager::GetInstance().GetDataStorage(UID);
         ASSERT_NE(dataStoragePtr, nullptr);
 
         std::string authorizedAccounts;
@@ -618,7 +616,7 @@ HWTEST_F(AppAccountManagerServiceSyncModuleTest, AppAccountManagerServiceSync_En
     }
 #ifdef DISTRIBUTED_FEATURE_ENABLED
     {
-        auto dataStoragePtr = controlManagerPtr_->GetDataStorage(UID, true);
+        auto dataStoragePtr = AppAccountControlManager::GetInstance().GetDataStorage(UID, true);
         ASSERT_NE(dataStoragePtr, nullptr);
 
         std::string authorizedAccounts;
@@ -668,7 +666,7 @@ HWTEST_F(AppAccountManagerServiceSyncModuleTest, AppAccountManagerServiceSync_Di
     EXPECT_EQ(result, ERR_OK);
 
     {
-        auto dataStoragePtr = controlManagerPtr_->GetDataStorage(UID);
+        auto dataStoragePtr = AppAccountControlManager::GetInstance().GetDataStorage(UID);
         ASSERT_NE(dataStoragePtr, nullptr);
 
         std::string authorizedAccounts;
@@ -684,7 +682,7 @@ HWTEST_F(AppAccountManagerServiceSyncModuleTest, AppAccountManagerServiceSync_Di
     }
 #ifdef DISTRIBUTED_FEATURE_ENABLED
     {
-        auto dataStoragePtr = controlManagerPtr_->GetDataStorage(UID, true);
+        auto dataStoragePtr = AppAccountControlManager::GetInstance().GetDataStorage(UID, true);
         ASSERT_NE(dataStoragePtr, nullptr);
 
         std::string authorizedAccounts;

services/accountmgr/test/moduletest/app_account/app_account_manager_service_thread_module_test.cpp

@@ -68,7 +68,6 @@ void AppAccountManagerServiceThreadModuleTest::SetUpTestCase(void)
 void AppAccountManagerServiceThreadModuleTest::TearDownTestCase(void)
 {
     GTEST_LOG_(INFO) << "TearDownTestCase enter";
-    DelayedSingleton<AppAccountControlManager>::DestroyInstance();
     std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_FOR_EXIT));
 }
 

services/accountmgr/test/moduletest/app_account/app_account_subscribe_manager_test.cpp

@@ -64,11 +64,8 @@ void AppAccountSubscribeManagerTest::TearDown(void)
 HWTEST_F(AppAccountSubscribeManagerTest, SubscribeAppAccount_0100, TestSize.Level1)
 {
     ACCOUNT_LOGI("AppAccountSubscribeManager_SubscribeAppAccount_0100");
-    // check subscribeInfoPtr is nullptr.
-    std::shared_ptr<AppAccountSubscribeManager>
-        appAccountSubscribeSubscribePtr_ = AppAccountSubscribeManager::GetInstance();
-    ErrCode ret = appAccountSubscribeSubscribePtr_->
-        SubscribeAppAccount(nullptr, nullptr, TEST_UID, TEST_BUNDLE_NAME, TEST_APP_INDEX);
+    ErrCode ret = AppAccountSubscribeManager::GetInstance().SubscribeAppAccount(
+        nullptr, nullptr, TEST_UID, TEST_BUNDLE_NAME, TEST_APP_INDEX);
     EXPECT_EQ(ret, ERR_APPACCOUNT_SERVICE_SUBSCRIBE_INFO_PTR_IS_NULLPTR);
 
     // check eventListener is nullptr.
@@ -78,8 +75,8 @@ HWTEST_F(AppAccountSubscribeManagerTest, SubscribeAppAccount_0100, TestSize.Leve
     // make subscribe info with owners.
     AppAccountSubscribeInfo subscribeInfo(owners);
     auto subscribeInfoPtr = std::make_shared<AppAccountSubscribeInfo>(subscribeInfo);
-    ret = appAccountSubscribeSubscribePtr_->
-        SubscribeAppAccount(subscribeInfoPtr, nullptr, TEST_UID, TEST_BUNDLE_NAME, TEST_APP_INDEX);
+    ret = AppAccountSubscribeManager::GetInstance().SubscribeAppAccount(
+        subscribeInfoPtr, nullptr, TEST_UID, TEST_BUNDLE_NAME, TEST_APP_INDEX);
     EXPECT_EQ(ret, ERR_APPACCOUNT_SERVICE_EVENT_LISTENER_IS_NULLPTR);
 }
 
@@ -93,10 +90,8 @@ HWTEST_F(AppAccountSubscribeManagerTest, CheckAppAccess_0100, TestSize.Level1)
 {
     ACCOUNT_LOGI("AppAccountSubscribeManager_CheckAppAccess_0100");
     // check subscribeInfoPtr is nullptr.
-    std::shared_ptr<AppAccountSubscribeManager>
-        appAccountSubscribeSubscribePtr_ = AppAccountSubscribeManager::GetInstance();
-    ErrCode ret = appAccountSubscribeSubscribePtr_->
-        CheckAppAccess(nullptr, TEST_UID, TEST_BUNDLE_NAME, TEST_APP_INDEX);
+    ErrCode ret = AppAccountSubscribeManager::GetInstance().CheckAppAccess(
+        nullptr, TEST_UID, TEST_BUNDLE_NAME, TEST_APP_INDEX);
     EXPECT_EQ(ret, ERR_APPACCOUNT_SERVICE_SUBSCRIBE_INFO_PTR_IS_NULLPTR);
 }
 
@@ -111,15 +106,13 @@ HWTEST_F(AppAccountSubscribeManagerTest, InsertSubscribeRecord_0100, TestSize.Le
     ACCOUNT_LOGI("AppAccountSubscribeManager_InsertSubscribeRecord_0100");
 
     // check owners is empty.
-    std::shared_ptr<AppAccountSubscribeManager>
-        appAccountSubscribeSubscribePtr_ = AppAccountSubscribeManager::GetInstance();
     std::vector<std::string> owners;
-    ErrCode ret = appAccountSubscribeSubscribePtr_->InsertSubscribeRecord(owners, nullptr);
+    ErrCode ret = AppAccountSubscribeManager::GetInstance().InsertSubscribeRecord(owners, nullptr);
     EXPECT_EQ(ret, ERR_APPACCOUNT_SERVICE_OWNERS_SIZE_IS_ZERO);
 
     // check subscribeRecordPtr is nullptr.
     owners.emplace_back(TEST_BUNDLE_NAME);
-    ret = appAccountSubscribeSubscribePtr_->InsertSubscribeRecord(owners, nullptr);
+    ret = AppAccountSubscribeManager::GetInstance().InsertSubscribeRecord(owners, nullptr);
     EXPECT_EQ(ret, ERR_APPACCOUNT_SERVICE_SUBSCRIBE_RECORD_PTR_IS_NULLPTR);
 }
 
@@ -133,9 +126,7 @@ HWTEST_F(AppAccountSubscribeManagerTest, RemoveSubscribeRecord_0100, TestSize.Le
 {
     ACCOUNT_LOGI("AppAccountSubscribeManager_RemoveSubscribeRecord_0100");
     // check eventListener is nullptr.
-    std::shared_ptr<AppAccountSubscribeManager>
-        appAccountSubscribeSubscribePtr_ = AppAccountSubscribeManager::GetInstance();
-    ErrCode ret = appAccountSubscribeSubscribePtr_->RemoveSubscribeRecord(nullptr);
+    ErrCode ret = AppAccountSubscribeManager::GetInstance().RemoveSubscribeRecord(nullptr);
     EXPECT_EQ(ret, ERR_APPACCOUNT_SERVICE_EVENT_LISTENER_IS_NULLPTR);
 }
 
@@ -150,11 +141,9 @@ HWTEST_F(AppAccountSubscribeManagerTest, GetAccessibleAccountsBySubscribeInfo_01
     ACCOUNT_LOGI("AppAccountSubscribeManager_GetAccessibleAccountsBySubscribeInfo_0100");
 
     // check subscribeInfoPtr is nullptr.
-    std::shared_ptr<AppAccountSubscribeManager>
-        appAccountSubscribeSubscribePtr_ = AppAccountSubscribeManager::GetInstance();
     std::vector<AppAccountInfo> accessibleAccounts;
     std::vector<AppAccountInfo> appAccounts;
-    ErrCode ret = appAccountSubscribeSubscribePtr_->
+    ErrCode ret = AppAccountSubscribeManager::GetInstance().
         GetAccessibleAccountsBySubscribeInfo(nullptr, accessibleAccounts, appAccounts);
     EXPECT_EQ(ret, ERR_APPACCOUNT_SERVICE_SUBSCRIBE_INFO_PTR_IS_NULLPTR);
 }

services/accountmgr/test/moduletest/app_account/at_not_mock_app_account_manager_service_module_test.cpp

@@ -37,7 +37,6 @@ public:
 };
 
 namespace {
-std::shared_ptr<AppAccountControlManager> g_controlManagerPtr = AppAccountControlManager::GetInstance();
 std::shared_ptr<AppAccountManagerService> g_accountManagerService = std::make_shared<AppAccountManagerService>();
 } // namespace
 

services/accountmgr/test/moduletest/os_account/os_account_manager_service_module_test.cpp

@@ -185,7 +185,6 @@ void OsAccountManagerServiceModuleTest::SetUpTestCase(void)
 void OsAccountManagerServiceModuleTest::TearDownTestCase(void)
 {
     GTEST_LOG_(INFO) << "TearDownTestCase enter!";
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
     std::this_thread::sleep_for(std::chrono::milliseconds(DELAY_FOR_OPERATION));
     GTEST_LOG_(INFO) << "TearDownTestCase exit!";
 }

services/accountmgr/test/moduletest/os_account/os_account_manager_service_subscribe_module_test.cpp

@@ -47,7 +47,6 @@ void OsAccountManagerServiceSubscribeModuleTest::SetUpTestCase(void)
 
 void OsAccountManagerServiceSubscribeModuleTest::TearDownTestCase(void)
 {
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
     GTEST_LOG_(INFO) << "TearDownTestCase exit!";
 }
 
@@ -102,7 +101,7 @@ HWTEST_F(OsAccountManagerServiceSubscribeModuleTest, OsAccountManagerServiceSubs
     OsAccountInfo osAccountInfo;
     ErrCode result = osAccountManagerService_->CreateOsAccount("test", OsAccountType::GUEST, osAccountInfo);
     subscriberTestPtr->id_ = osAccountInfo.GetLocalId();
-    ErrCode subscribeState = DelayedSingleton<OsAccount>::GetInstance()->CreateOsAccountEventListener(
+    ErrCode subscribeState = OsAccount::GetInstance().CreateOsAccountEventListener(
         subscriberTestPtr, osAccountEventListener);
     EXPECT_EQ(subscribeState, OsAccount::INITIAL_SUBSCRIPTION);
 
@@ -154,7 +153,7 @@ HWTEST_F(OsAccountManagerServiceSubscribeModuleTest, OsAccountManagerServiceSubs
     OsAccountInfo osAccountInfo;
     ErrCode result = osAccountManagerService_->CreateOsAccount("test", OsAccountType::GUEST, osAccountInfo);
     subscriberTestPtr->id_ = osAccountInfo.GetLocalId();
-    ErrCode subscribeState = DelayedSingleton<OsAccount>::GetInstance()->CreateOsAccountEventListener(
+    ErrCode subscribeState = OsAccount::GetInstance().CreateOsAccountEventListener(
         subscriberTestPtr, osAccountEventListener);
     EXPECT_EQ(subscribeState, OsAccount::INITIAL_SUBSCRIPTION);
 

services/accountmgr/test/unittest/account_mgr_service_test/account_dump_helper_test.cpp

@@ -35,7 +35,6 @@ using namespace OHOS::AccountSA;
 namespace {
 const std::string TEST_ACCOUNT_NAME = "TestAccountName";
 const std::string TEST_ACCOUNT_UID = "123456789";
-static std::shared_ptr<OsAccount> g_osAccountPtr = nullptr;
 }
 
 class AccountDumpHelperTest : public testing::Test {
@@ -55,17 +54,14 @@ public:
 AccountDumpHelperTest::AccountDumpHelperTest() {}
 
 void AccountDumpHelperTest::SetUpTestCase()
-{
-    g_osAccountPtr = DelayedSingleton<OsAccount>::GetInstance();
-    EXPECT_NE(g_osAccountPtr, nullptr);
-}
+{}
 
 void AccountDumpHelperTest::TearDownTestCase()
 {
     std::vector<OsAccountInfo> osAccountInfos;
-    g_osAccountPtr->QueryAllCreatedOsAccounts(osAccountInfos);
+    OsAccount::GetInstance().QueryAllCreatedOsAccounts(osAccountInfos);
     for (const auto &info : osAccountInfos) {
-        g_osAccountPtr->RemoveOsAccount(info.GetLocalId());
+        OsAccount::GetInstance().RemoveOsAccount(info.GetLocalId());
     }
 }
 
@@ -126,7 +122,7 @@ HWTEST_F(AccountDumpHelperTest, AccountDumpParameterTest001, TestSize.Level0)
 {
     OsAccountInfo osAccountInfo;
     // create an os account
-    EXPECT_EQ(ERR_OK, g_osAccountPtr->CreateOsAccount("test", OsAccountType::NORMAL, osAccountInfo));
+    EXPECT_EQ(ERR_OK, OsAccount::GetInstance().CreateOsAccount("test", OsAccountType::NORMAL, osAccountInfo));
 
     OhosAccountInfo accountInfo;
     accountInfo.name_ = TEST_ACCOUNT_NAME;
@@ -232,23 +228,6 @@ HWTEST_F(AccountDumpHelperTest, AccountDumpParameterTest005, TestSize.Level0)
     EXPECT_NE(std::string::npos, pos);
 }
 
-/**
- * @tc.name: AccountDumpParameterTest006
- * @tc.desc: Test account info display
- * @tc.type: FUNC
- * @tc.require:
- */
-HWTEST_F(AccountDumpHelperTest, AccountDumpParameterTest006, TestSize.Level0)
-{
-    ASSERT_NE(accountDumpHelper_, nullptr);
-    accountDumpHelper_->innerMgrService_ = nullptr;
-    std::string out;
-    vector<std::string> cmd = {"-ohos_account_infos"};
-    accountDumpHelper_->Dump(cmd, out);
-    auto pos = out.find("System error", 0);
-    EXPECT_NE(std::string::npos, pos);
-}
-
 /**
  * @tc.name: AccountDumpParameterTest007
  * @tc.desc: Test account info display

services/accountmgr/test/unittest/app_account/BUILD.gn

@@ -296,6 +296,5 @@ group("unittest") {
     ":app_account_manager_service_test",
     ":app_account_subscribe_info_test",
     ":app_account_test",
-    ":inner_app_account_manager_test",
   ]
 }

services/accountmgr/test/unittest/app_account/account_permission_manager_test.cpp

@@ -51,8 +51,6 @@ void AccountPermissionManagerTest::TearDown(void)
 HWTEST_F(AccountPermissionManagerTest, AccountPermissionManager_VerifyPermission_0100, TestSize.Level1)
 {
     ACCOUNT_LOGI("AccountPermissionManager_VerifyPermission_0100");
-
-    auto managerPtr = DelayedSingleton<AccountPermissionManager>::GetInstance();
-    ErrCode result = managerPtr->VerifyPermission(AccountPermissionManager::DISTRIBUTED_DATASYNC);
+    ErrCode result = AccountPermissionManager::VerifyPermission(AccountPermissionManager::DISTRIBUTED_DATASYNC);
     EXPECT_EQ(result, ERR_OK);
 }

services/accountmgr/test/unittest/app_account/app_account_data_storage_test.cpp

@@ -54,7 +54,6 @@ void AppAccountDataStorageTest::SetUpTestCase(void)
 void AppAccountDataStorageTest::TearDownTestCase(void)
 {
     GTEST_LOG_(INFO) << "TearDownTestCase!";
-    DelayedSingleton<AppAccountControlManager>::DestroyInstance();
 }
 
 void AppAccountDataStorageTest::SetUp(void)

services/accountmgr/test/unittest/app_account/app_account_manager_service_test.cpp

@@ -49,7 +49,6 @@ void AppAccountManagerServiceTest::SetUpTestCase(void)
 void AppAccountManagerServiceTest::TearDownTestCase(void)
 {
     GTEST_LOG_(INFO) << "TearDownTestCase!";
-    DelayedSingleton<AppAccountControlManager>::DestroyInstance();
 }
 
 void AppAccountManagerServiceTest::SetUp(void)

services/accountmgr/test/unittest/app_account/app_account_test.cpp

@@ -83,8 +83,6 @@ public:
     void TearDown(void) override;
 
     sptr<IRemoteObject> MakeMockObjects(void) const;
-
-    std::shared_ptr<AppAccount> appAccount_;
 };
 
 sptr<IRemoteObject> AppAccountTest::MakeMockObjects(void) const
@@ -103,20 +101,16 @@ void AppAccountTest::TearDownTestCase(void)
 
 void AppAccountTest::SetUp(void)
 {
-    // get the singleton of AppAccount
-    appAccount_ = DelayedSingleton<AppAccount>::GetInstance();
-
     // mock a proxy
     auto mockProxy = iface_cast<IAppAccount>(MakeMockObjects());
 
     // add the mock proxy
-    appAccount_->appAccountProxy_ = mockProxy;
+    AppAccount::GetInstance().appAccountProxy_ = mockProxy;
 }
 
 void AppAccountTest::TearDown(void)
 {
-    // destroy the singleton
-    DelayedSingleton<AppAccount>::DestroyInstance();
+    AppAccount::GetInstance().eventListeners_.clear();
 }
 
 class AppAccountSubscriberTest : public AppAccountSubscriber {
@@ -162,7 +156,7 @@ HWTEST_F(AppAccountTest, AppAccount_AddAccount_0100, TestSize.Level0)
 {
     ACCOUNT_LOGI("AppAccount_AddAccount_0100");
 
-    ErrCode result = appAccount_->AddAccount(STRING_NAME, STRING_EXTRA_INFO);
+    ErrCode result = AppAccount::GetInstance().AddAccount(STRING_NAME, STRING_EXTRA_INFO);
 
     EXPECT_EQ(result, ERR_OK);
 }
@@ -177,7 +171,7 @@ HWTEST_F(AppAccountTest, AppAccount_AddAccount_0200, TestSize.Level1)
 {
     ACCOUNT_LOGI("AppAccount_AddAccount_0200");
 
-    ErrCode result = appAccount_->AddAccount(STRING_NAME_EMPTY, STRING_EXTRA_INFO);
+    ErrCode result = AppAccount::GetInstance().AddAccount(STRING_NAME_EMPTY, STRING_EXTRA_INFO);
 
     EXPECT_EQ(result, ERR_APPACCOUNT_KIT_INVALID_PARAMETER);
 }
@@ -192,7 +186,7 @@ HWTEST_F(AppAccountTest, AppAccount_AddAccount_0300, TestSize.Level1)
 {
     ACCOUNT_LOGI("AppAccount_AddAccount_0300");
 
-    ErrCode result = appAccount_->AddAccount(STRING_NAME, STRING_EXTRA_INFO_EMPTY);
+    ErrCode result = AppAccount::GetInstance().AddAccount(STRING_NAME, STRING_EXTRA_INFO_EMPTY);
 
     EXPECT_EQ(result, ERR_OK);
 }
@@ -207,7 +201,7 @@ HWTEST_F(AppAccountTest, AppAccount_AddAccount_0400, TestSize.Level1)
 {
     ACCOUNT_LOGI("AppAccount_AddAccount_0400");
 
-    ErrCode result = appAccount_->AddAccount(STRING_NAME_OUT_OF_RANGE, STRING_EXTRA_INFO);
+    ErrCode result = AppAccount::GetInstance().AddAccount(STRING_NAME_OUT_OF_RANGE, STRING_EXTRA_INFO);
 
     EXPECT_EQ(result, ERR_APPACCOUNT_KIT_INVALID_PARAMETER);
 }
@@ -222,7 +216,7 @@ HWTEST_F(AppAccountTest, AppAccount_AddAccount_0500, TestSize.Level1)
 {
     ACCOUNT_LOGI("AppAccount_AddAccount_0500");
 
-    ErrCode result = appAccount_->AddAccount(STRING_NAME_CONTAINS_SPECIAL_CHARACTERS, STRING_EXTRA_INFO);
+    ErrCode result = AppAccount::GetInstance().AddAccount(STRING_NAME_CONTAINS_SPECIAL_CHARACTERS, STRING_EXTRA_INFO);
 
     EXPECT_EQ(result, ERR_APPACCOUNT_KIT_INVALID_PARAMETER);
 }
@@ -237,8 +231,8 @@ HWTEST_F(AppAccountTest, AppAccount_AddAccount_0600, TestSize.Level1)
 {
     ACCOUNT_LOGI("AppAccount_AddAccount_0600");
 
-    ErrCode result = appAccount_->AddAccount(STRING_NAME_CONTAINS_SPECIAL_CHARACTERS_TWO, STRING_EXTRA_INFO);
-
+    ErrCode result = AppAccount::GetInstance().AddAccount(
+        STRING_NAME_CONTAINS_SPECIAL_CHARACTERS_TWO, STRING_EXTRA_INFO);
     EXPECT_EQ(result, ERR_APPACCOUNT_KIT_INVALID_PARAMETER);
 }
 
@@ -252,8 +246,8 @@ HWTEST_F(AppAccountTest, AppAccount_AddAccount_0700, TestSize.Level1)
 {
     ACCOUNT_LOGI("AppAccount_AddAccount_0700");
 
-    ErrCode result = appAccount_->AddAccount(STRING_NAME_CONTAINS_SPECIAL_CHARACTERS_THREE, STRING_EXTRA_INFO);
-
+    ErrCode result = AppAccount::GetInstance().AddAccount(
+        STRING_NAME_CONTAINS_SPECIAL_CHARACTERS_THREE, STRING_EXTRA_INFO);
     EXPECT_EQ(result, ERR_APPACCOUNT_KIT_INVALID_PARAMETER);
 }
 
@@ -267,7 +261,7 @@ HWTEST_F(AppAccountTest, AppAccount_AddAccount_0800, TestSize.Level1)
 {
     ACCOUNT_LOGI("AppAccount_AddAccount_0800");
 
-    ErrCode result = appAccount_->AddAccount(STRING_NAME, STRING_EXTRA_INFO_OUT_OF_RANGE);
+    ErrCode result = AppAccount::GetInstance().AddAccount(STRING_NAME, STRING_EXTRA_INFO_OUT_OF_RANGE);
 
     EXPECT_EQ(result, ERR_APPACCOUNT_KIT_INVALID_PARAMETER);
 }
@@ -282,7 +276,7 @@ HWTEST_F(AppAccountTest, AppAccount_DeleteAccount_0100, TestSize.Level1)
 {
     ACCOUNT_LOGI("AppAccount_DeleteAccount_0100");
 
-    ErrCode result = appAccount_->DeleteAccount(STRING_NAME);
+    ErrCode result = AppAccount::GetInstance().DeleteAccount(STRING_NAME);
 
     EXPECT_EQ(result, ERR_OK);
 }
@@ -297,7 +291,7 @@ HWTEST_F(AppAccountTest, AppAccount_DeleteAccount_0200, TestSize.Level1)
 {
     ACCOUNT_LOGI("AppAccount_DeleteAccount_0200");
 
-    ErrCode result = appAccount_->DeleteAccount(STRING_NAME_EMPTY);
+    ErrCode result = AppAccount::GetInstance().DeleteAccount(STRING_NAME_EMPTY);
 
     EXPECT_EQ(result, ERR_APPACCOUNT_KIT_INVALID_PARAMETER);
 }
@@ -312,7 +306,7 @@ HWTEST_F(AppAccountTest, AppAccount_DeleteAccount_0300, TestSize.Level1)
 {
     ACCOUNT_LOGI("AppAccount_DeleteAccount_0300");
 
-    ErrCode result = appAccount_->DeleteAccount(STRING_NAME_OUT_OF_RANGE);
+    ErrCode result = AppAccount::GetInstance().DeleteAccount(STRING_NAME_OUT_OF_RANGE);
 
     EXPECT_EQ(result, ERR_APPACCOUNT_KIT_INVALID_PARAMETER);
 }
@@ -338,7 +332,7 @@ HWTEST_F(AppAccountTest, AppAccount_SubscribeAppAccount_0100, TestSize.Level0)
     // make a subscriber
     auto subscriberTestPtr = std::make_shared<AppAccountSubscriberTest>(subscribeInfo);
     // subscribe app account
-    ErrCode result = appAccount_->SubscribeAppAccount(subscriberTestPtr);
+    ErrCode result = AppAccount::GetInstance().SubscribeAppAccount(subscriberTestPtr);
 
     EXPECT_EQ(result, ERR_OK);
 }
@@ -365,7 +359,7 @@ HWTEST_F(AppAccountTest, AppAccount_SubscribeAppAccount_0200, TestSize.Level1)
     // make a subscriber
     auto subscriberTestPtr = std::make_shared<AppAccountSubscriberTest>(subscribeInfo);
     // subscribe app account
-    ErrCode result = appAccount_->SubscribeAppAccount(subscriberTestPtr);
+    ErrCode result = AppAccount::GetInstance().SubscribeAppAccount(subscriberTestPtr);
 
     EXPECT_EQ(result, ERR_OK);
 }
@@ -381,7 +375,7 @@ HWTEST_F(AppAccountTest, AppAccount_SubscribeAppAccount_0300, TestSize.Level1)
     ACCOUNT_LOGI("AppAccount_SubscribeAppAccount_0300");
 
     // subscribe app account with nullptr
-    ErrCode result = appAccount_->SubscribeAppAccount(nullptr);
+    ErrCode result = AppAccount::GetInstance().SubscribeAppAccount(nullptr);
 
     EXPECT_EQ(result, ERR_APPACCOUNT_KIT_SUBSCRIBER_IS_NULLPTR);
 }
@@ -397,10 +391,10 @@ HWTEST_F(AppAccountTest, AppAccount_GetAppAccountProxy_0100, TestSize.Level1)
     ACCOUNT_LOGI("AppAccount_GetAppAccountProxy_0100");
 
     // get app account proxy
-    ErrCode result = appAccount_->GetAppAccountProxy();
+    ErrCode result = AppAccount::GetInstance().GetAppAccountProxy();
 
     EXPECT_EQ(result, ERR_OK);
-    EXPECT_NE(appAccount_->appAccountProxy_, nullptr);
+    EXPECT_NE(AppAccount::GetInstance().appAccountProxy_, nullptr);
 }
 
 /**
@@ -414,15 +408,15 @@ HWTEST_F(AppAccountTest, AppAccount_ResetAppAccountProxy_0100, TestSize.Level1)
     ACCOUNT_LOGI("AppAccount_ResetAppAccountProxy_0100");
 
     // get app account proxy
-    ErrCode result = appAccount_->GetAppAccountProxy();
+    ErrCode result = AppAccount::GetInstance().GetAppAccountProxy();
     EXPECT_EQ(result, ERR_OK);
-    EXPECT_NE(appAccount_->appAccountProxy_, nullptr);
+    EXPECT_NE(AppAccount::GetInstance().appAccountProxy_, nullptr);
 
     // reset app account proxy
-    result = appAccount_->ResetAppAccountProxy();
+    result = AppAccount::GetInstance().ResetAppAccountProxy();
 
     EXPECT_EQ(result, ERR_OK);
-    EXPECT_EQ(appAccount_->appAccountProxy_, nullptr);
+    EXPECT_EQ(AppAccount::GetInstance().appAccountProxy_, nullptr);
 }
 
 /**
@@ -451,17 +445,17 @@ HWTEST_F(AppAccountTest, AppAccount_CreateAppAccountEventListener_0100, TestSize
     auto subscriberTestPtr = std::make_shared<AppAccountSubscriberTest>(subscribeInfo);
     sptr<IRemoteObject> appAccountEventListener = nullptr;
 
-    EXPECT_EQ(appAccount_->eventListeners_.size(), SUBSCRIBER_ZERO);
+    EXPECT_EQ(AppAccount::GetInstance().eventListeners_.size(), SUBSCRIBER_ZERO);
 
     // initial subscription
-    result = appAccount_->CreateAppAccountEventListener(subscriberTestPtr, appAccountEventListener);
+    result = AppAccount::GetInstance().CreateAppAccountEventListener(subscriberTestPtr, appAccountEventListener);
     EXPECT_EQ(result, AppAccount::SubscribeState::INITIAL_SUBSCRIPTION);
-    EXPECT_EQ(appAccount_->eventListeners_.size(), SUBSCRIBER_ONE);
+    EXPECT_EQ(AppAccount::GetInstance().eventListeners_.size(), SUBSCRIBER_ONE);
 
     // already subscribed
-    result = appAccount_->CreateAppAccountEventListener(subscriberTestPtr, appAccountEventListener);
+    result = AppAccount::GetInstance().CreateAppAccountEventListener(subscriberTestPtr, appAccountEventListener);
     EXPECT_EQ(result, AppAccount::SubscribeState::ALREADY_SUBSCRIBED);
-    EXPECT_EQ(appAccount_->eventListeners_.size(), SUBSCRIBER_ONE);
+    EXPECT_EQ(AppAccount::GetInstance().eventListeners_.size(), SUBSCRIBER_ONE);
 }
 
 /**
@@ -486,20 +480,20 @@ HWTEST_F(AppAccountTest, AppAccount_CreateAppAccountEventListener_0200, TestSize
 
     EXPECT_EQ(result, ERR_OK);
 
-    EXPECT_EQ(appAccount_->eventListeners_.size(), SUBSCRIBER_ZERO);
+    EXPECT_EQ(AppAccount::GetInstance().eventListeners_.size(), SUBSCRIBER_ZERO);
 
     // make max subscribers
     for (std::size_t counter = 1; counter <= Constants::APP_ACCOUNT_SUBSCRIBER_MAX_SIZE + 1; counter += 1) {
         auto subscriberTestPtr = std::make_shared<AppAccountSubscriberTest>(subscribeInfo);
         sptr<IRemoteObject> appAccountEventListener = nullptr;
 
-        result = appAccount_->CreateAppAccountEventListener(subscriberTestPtr, appAccountEventListener);
+        result = AppAccount::GetInstance().CreateAppAccountEventListener(subscriberTestPtr, appAccountEventListener);
         if (counter <= Constants::APP_ACCOUNT_SUBSCRIBER_MAX_SIZE) {
             EXPECT_EQ(result, AppAccount::SubscribeState::INITIAL_SUBSCRIPTION);
-            EXPECT_EQ(appAccount_->eventListeners_.size(), counter);
+            EXPECT_EQ(AppAccount::GetInstance().eventListeners_.size(), counter);
         } else {
             EXPECT_EQ(result, AppAccount::SubscribeState::SUBSCRIBE_FAILED);
-            EXPECT_EQ(appAccount_->eventListeners_.size(), counter - 1);
+            EXPECT_EQ(AppAccount::GetInstance().eventListeners_.size(), counter - 1);
         }
     }
 }
@@ -515,10 +509,10 @@ HWTEST_F(AppAccountTest, AppAccount_CreateAccount_001, TestSize.Level1)
     ACCOUNT_LOGI("AppAccount_CreateAccount_001");
 
     CreateAccountOptions option;
-    ErrCode result = appAccount_->CreateAccount("test", option);
+    ErrCode result = AppAccount::GetInstance().CreateAccount("test", option);
     EXPECT_EQ(result, ERR_OK);
 
-    result = appAccount_->DeleteAccount("test");
+    result = AppAccount::GetInstance().DeleteAccount("test");
     EXPECT_EQ(result, ERR_OK);
 }
 
@@ -534,11 +528,11 @@ HWTEST_F(AppAccountTest, AppAccount_CreateAccount_002, TestSize.Level1)
 
     CreateAccountOptions option;
 
-    ErrCode result = appAccount_->CreateAccount("", option);
+    ErrCode result = AppAccount::GetInstance().CreateAccount("", option);
 
     EXPECT_EQ(result, ERR_APPACCOUNT_KIT_INVALID_PARAMETER);
 
-    result = appAccount_->CreateAccount(STRING_NAME_OUT_OF_RANGE, option);
+    result = AppAccount::GetInstance().CreateAccount(STRING_NAME_OUT_OF_RANGE, option);
 
     EXPECT_EQ(result, ERR_APPACCOUNT_KIT_INVALID_PARAMETER);
 }
@@ -559,6 +553,6 @@ HWTEST_F(AppAccountTest, AppAccount_CreateAccount_003, TestSize.Level1)
         std::string value = key;
         option.customData[key] = value;
     }
-    ErrCode result = appAccount_->CreateAccount("test", option);
+    ErrCode result = AppAccount::GetInstance().CreateAccount("test", option);
     EXPECT_EQ(result, ERR_APPACCOUNT_KIT_INVALID_PARAMETER);
 }

services/accountmgr/test/unittest/os_account/os_account_inner_account_mgr_cov.cpp

@@ -67,8 +67,7 @@ public:
     void SetUp();
     void TearDown();
 public:
-    std::shared_ptr<IInnerOsAccountManager> innerMgrService_;
-    std::shared_ptr<IOsAccountSubscribe> subscribeManagerPtr_;
+    IInnerOsAccountManager *innerMgrService_ = &IInnerOsAccountManager::GetInstance();
 };
 class AccountCommonEventSubscriber final : public EventFwk::CommonEventSubscriber {
 public:
@@ -119,8 +118,6 @@ void OsAccountInnerAccmgrCoverageTest::TearDown(void)
  */
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest001, TestSize.Level1)
 {
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
-
     innerMgrService_->CreateBaseAdminAccount();
 
     std::shared_ptr<IOsAccountControl> osAccountControl = innerMgrService_->osAccountControl_;
@@ -128,8 +125,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest001,
 
     osAccountControl->IsOsAccountExists(Constants::ADMIN_LOCAL_ID, isExistsAccount);
     EXPECT_EQ(true, isExistsAccount);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 
@@ -141,8 +136,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest001,
  */
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest002, TestSize.Level1)
 {
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
-
     innerMgrService_->CreateBaseStandardAccount();
 
     std::shared_ptr<IOsAccountControl> osAccountControl = innerMgrService_->osAccountControl_;
@@ -150,8 +143,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest002,
 
     osAccountControl->IsOsAccountExists(Constants::START_USER_ID, isExistsAccount);
     EXPECT_EQ(true, isExistsAccount);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -162,7 +153,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest002,
  */
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest005, TestSize.Level1)
 {
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     bool ret = false;
     innerMgrService_->PushIdIntoActiveList(TEST_USER_ID10);
     innerMgrService_->PushIdIntoActiveList(TEST_USER_ID10);
@@ -176,8 +166,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest005,
     innerMgrService_->EraseIdFromActiveList(TEST_USER_ID55);
     ret = innerMgrService_->IsOsAccountIDInActiveList(TEST_USER_ID55);
     EXPECT_EQ(ret, false);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -188,7 +176,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest005,
  */
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest007, TestSize.Level1)
 {
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     bool ret = false;
     innerMgrService_->AddLocalIdToOperating(TEST_USER_ID10);
     ret = innerMgrService_->IsLocalIdInOperating(TEST_USER_ID10);
@@ -201,8 +188,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest007,
     innerMgrService_->RemoveLocalIdToOperating(TEST_USER_ID10);
     ret = innerMgrService_->IsLocalIdInOperating(TEST_USER_ID10);
     EXPECT_EQ(ret, false);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -215,8 +200,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest008,
 {
     // create common event subscribe
     setuid(ACCOUNT_UID);
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
-    ASSERT_NE(innerMgrService_, nullptr);
     EventFwk::MatchingSkills matchingSkills;
     matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_USER_INFO_UPDATED);
     EventFwk::CommonEventSubscribeInfo subscribeInfo(matchingSkills);
@@ -254,8 +237,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest009,
 {
     // create common event subscribe
     setuid(ACCOUNT_UID);
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
-    ASSERT_NE(innerMgrService_, nullptr);
     EventFwk::MatchingSkills matchingSkills;
     matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_USER_INFO_UPDATED);
     EventFwk::CommonEventSubscribeInfo subscribeInfo(matchingSkills);

services/accountmgr/test/unittest/os_account/os_account_inner_account_mgr_mock.cpp

@@ -80,8 +80,7 @@ public:
     void SetUp();
     void TearDown();
 public:
-    std::shared_ptr<IInnerOsAccountManager> innerMgrService_;
-    std::shared_ptr<IOsAccountSubscribe> subscribeManagerPtr_;
+    IInnerOsAccountManager *innerMgrService_ = &IInnerOsAccountManager::GetInstance();
 };
 
 void OsAccountInnerAccmgrCoverageTest::SetUpTestCase(void)
@@ -104,8 +103,6 @@ void OsAccountInnerAccmgrCoverageTest::TearDown(void)
  */
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest001, TestSize.Level1)
 {
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
-
     innerMgrService_->CreateBaseAdminAccount();
 
     std::shared_ptr<IOsAccountControl> osAccountControl = innerMgrService_->osAccountControl_;
@@ -113,8 +110,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest001,
 
     osAccountControl->IsOsAccountExists(Constants::ADMIN_LOCAL_ID, isExistsAccount);
     EXPECT_EQ(true, isExistsAccount);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -125,8 +120,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest001,
  */
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest002, TestSize.Level1)
 {
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
-
     innerMgrService_->CreateBaseStandardAccount();
 
     std::shared_ptr<IOsAccountControl> osAccountControl = innerMgrService_->osAccountControl_;
@@ -134,8 +127,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest002,
 
     osAccountControl->IsOsAccountExists(Constants::START_USER_ID, isExistsAccount);
     EXPECT_EQ(true, isExistsAccount);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -146,7 +137,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest002,
  */
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest005, TestSize.Level1)
 {
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     bool ret = false;
 
     innerMgrService_->PushIdIntoActiveList(TEST_USER_ID10);
@@ -160,8 +150,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest005,
     innerMgrService_->EraseIdFromActiveList(TEST_USER_ID55);
     ret = innerMgrService_->IsOsAccountIDInActiveList(TEST_USER_ID55);
     EXPECT_EQ(ret, false);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -172,7 +160,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest005,
  */
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest007, TestSize.Level1)
 {
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     bool ret = false;
     innerMgrService_->AddLocalIdToOperating(TEST_USER_ID10);
     ret = innerMgrService_->IsLocalIdInOperating(TEST_USER_ID10);
@@ -185,8 +172,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest007,
     innerMgrService_->RemoveLocalIdToOperating(TEST_USER_ID10);
     ret = innerMgrService_->IsLocalIdInOperating(TEST_USER_ID10);
     EXPECT_EQ(ret, false);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -202,11 +187,9 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest008,
     EXPECT_CALL(*ptr, GetOsAccountList(::testing::_))
         .WillRepeatedly(testing::Return(-1));
 
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     innerMgrService_->SetOsAccountControl(ptr);
     unsigned int count;
     int ret = innerMgrService_->GetCreatedOsAccountsCount(count);
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
     EXPECT_EQ(ret, -1);
 }
 
@@ -226,7 +209,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest009,
     EXPECT_CALL(*ptr, GetAllowCreateId(::testing::_))
         .WillRepeatedly(testing::Return(-1));
 
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     innerMgrService_->SetOsAccountControl(ptr);
 
     std::string name;
@@ -272,8 +254,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest009,
 
     ret = innerMgrService_->PrepareOsAccountInfo(name, type, domainInfo1, accountInfo);
     EXPECT_EQ(ret, 0);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -286,7 +266,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest010,
 {
     int ret;
     auto ptr = std::make_shared<MockOsAccountControlFileManager>();
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     innerMgrService_->SetOsAccountControl(ptr);
 
     OsAccountInfo osAccountInfoOne;
@@ -323,8 +302,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest010,
 
     (void)setuid(0);
     EXPECT_EQ(OsAccountManager::RemoveOsAccount(osAccountInfoOne.GetLocalId()), ERR_OK);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -337,7 +314,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest011,
 {
     int ret;
     auto ptr = std::make_shared<MockOsAccountControlFileManager>();
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     innerMgrService_->SetOsAccountControl(ptr);
 
     OsAccountInfo osAccountInfoOne;
@@ -365,8 +341,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest011,
 
     (void)setuid(0);
     EXPECT_EQ(OsAccountManager::RemoveOsAccount(osAccountInfoOne.GetLocalId()), ERR_OK);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -380,7 +354,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest012,
 {
     int ret;
     auto ptr = std::make_shared<MockOsAccountControlFileManager>();
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     innerMgrService_->SetOsAccountControl(ptr);
 
     OsAccountInfo osAccountInfoOne;
@@ -417,9 +390,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest012,
 
     ret = innerMgrService_->CreateOsAccountForDomain(type, domainInfo, osAccountInfoOne);
     EXPECT_EQ(ret, ERR_OSACCOUNT_SERVICE_INNER_GET_ACCOUNT_LIST_ERROR);
-    
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 #endif // DOMAIN_ACCOUNT_TEST_CASE
 
@@ -433,7 +403,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest013,
 {
     int ret;
     auto ptr = std::make_shared<MockOsAccountControlFileManager>();
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     innerMgrService_->SetOsAccountControl(ptr);
 
     EXPECT_CALL(*ptr, GetOsAccountList(::testing::_))
@@ -488,8 +457,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest013,
 
     ret = innerMgrService_->RemoveOsAccount(id);
     EXPECT_EQ(ret, 0);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -501,7 +468,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest013,
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest015, TestSize.Level1)
 {
     auto ptr = std::make_shared<MockOsAccountControlFileManager>();
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
 
     OsAccountInfo osAccountInfoOne;
     (void)setuid(ACCOUNT_UID);
@@ -511,7 +477,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest015,
     EXPECT_EQ(ret, 0);
 
     (void)setuid(0);
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -523,7 +488,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest015,
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest016, TestSize.Level1)
 {
     auto ptr = std::make_shared<MockOsAccountControlFileManager>();
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     innerMgrService_->SetOsAccountControl(ptr);
 
     int id = 0;
@@ -540,8 +504,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest016,
     int num = 0;
     ret = innerMgrService_->QueryMaxOsAccountNumber(num);
     EXPECT_EQ(ret, -1);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -553,7 +515,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest016,
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest017, TestSize.Level1)
 {
     auto ptr = std::make_shared<MockOsAccountControlFileManager>();
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     innerMgrService_->SetOsAccountControl(ptr);
 
     int id = 0;
@@ -582,8 +543,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest017,
 
     ret = innerMgrService_->GetOsAccountAllConstraints(id, constraints);
     EXPECT_EQ(ret, -1);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -595,7 +554,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest017,
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest018, TestSize.Level1)
 {
     auto ptr = std::make_shared<MockOsAccountControlFileManager>();
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     innerMgrService_->SetOsAccountControl(ptr);
 
     std::vector<OsAccountInfo> accounts;
@@ -607,8 +565,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest018,
 
     ErrCode ret = innerMgrService_->QueryAllCreatedOsAccounts(accounts);
     EXPECT_EQ(ret, ERR_OSACCOUNT_SERVICE_INNER_GET_ACCOUNT_LIST_ERROR);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -620,7 +576,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest018,
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest019, TestSize.Level1)
 {
     auto ptr = std::make_shared<MockOsAccountControlFileManager>();
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     innerMgrService_->SetOsAccountControl(ptr);
 
     int id = TEST_USER_ID100;
@@ -642,8 +597,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest019,
 
     ret = innerMgrService_->QueryOsAccountById(id, osAccountInfo);
     EXPECT_EQ(ret, -1);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -655,7 +608,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest019,
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest020, TestSize.Level1)
 {
     auto ptr = std::make_shared<MockOsAccountControlFileManager>();
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     innerMgrService_->SetOsAccountControl(ptr);
 
     int id = TEST_USER_ID100;
@@ -666,8 +618,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest020,
 
     ErrCode ret = innerMgrService_->GetOsAccountType(id, type);
     EXPECT_EQ(ret, ERR_OSACCOUNT_SERVICE_INNER_SELECT_OSACCOUNT_BYID_ERROR);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -679,7 +629,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest020,
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest021, TestSize.Level1)
 {
     auto ptr = std::make_shared<MockOsAccountControlFileManager>();
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     innerMgrService_->SetOsAccountControl(ptr);
 
     int id = TEST_USER_ID100;
@@ -690,8 +639,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest021,
 
     ErrCode ret = innerMgrService_->GetOsAccountProfilePhoto(id, photo);
     EXPECT_EQ(ret, ERR_OSACCOUNT_SERVICE_INNER_SELECT_OSACCOUNT_BYID_ERROR);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -703,7 +650,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest021,
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest022, TestSize.Level1)
 {
     auto ptr = std::make_shared<MockOsAccountControlFileManager>();
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     innerMgrService_->SetOsAccountControl(ptr);
 
     bool isMultiOsAccountEnabled = false; ///
@@ -713,8 +659,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest022,
 
     ErrCode ret = innerMgrService_->IsMultiOsAccountEnable(isMultiOsAccountEnabled);
     EXPECT_EQ(ret, -1);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -726,7 +670,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest022,
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest023, TestSize.Level1)
 {
     auto ptr = std::make_shared<MockOsAccountControlFileManager>();
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     innerMgrService_->SetOsAccountControl(ptr);
 
     int id = TEST_USER_ID100;
@@ -755,8 +698,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest023,
 
     ret = innerMgrService_->SetOsAccountName(id, name);
     EXPECT_EQ(ret, ERR_OSACCOUNT_SERVICE_INNER_UPDATE_ACCOUNT_ERROR);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -768,7 +709,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest023,
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest024, TestSize.Level1)
 {
     auto ptr = std::make_shared<MockOsAccountControlFileManager>();
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     innerMgrService_->SetOsAccountControl(ptr);
 
     int id = TEST_USER_ID100;
@@ -822,8 +762,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest024,
         .WillRepeatedly(testing::Return(-1));
     ret = innerMgrService_->SetBaseOsAccountConstraints(id, constraints, enable);
     EXPECT_EQ(ret, -1);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -835,7 +773,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest024,
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest025, TestSize.Level1)
 {
     auto ptr = std::make_shared<MockOsAccountControlFileManager>();
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     innerMgrService_->SetOsAccountControl(ptr);
 
     int id = TEST_USER_ID100;
@@ -868,8 +805,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest025,
     photo += "1";
     ret = innerMgrService_->SetOsAccountProfilePhoto(id, photo);
     EXPECT_EQ(ret, ERR_OSACCOUNT_SERVICE_INNER_UPDATE_ACCOUNT_ERROR);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -881,7 +816,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest025,
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest026, TestSize.Level1)
 {
     auto ptr = std::make_shared<MockOsAccountControlFileManager>();
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     innerMgrService_->SetOsAccountControl(ptr);
 
     int id = TEST_USER_ID100;
@@ -918,8 +852,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest026,
 
     ret = innerMgrService_->ActivateOsAccount(id);
     EXPECT_EQ(ret, ERR_OSACCOUNT_SERVICE_INNER_ACCOUNT_TO_BE_REMOVED_ERROR);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -931,7 +863,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest026,
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest027, TestSize.Level1)
 {
     auto ptr = std::make_shared<MockOsAccountControlFileManager>();
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     innerMgrService_->SetOsAccountControl(ptr);
 
     int64_t serialNumber = Constants::CARRY_NUM * Constants::SERIAL_NUMBER_NUM_START_FOR_ADMIN
@@ -952,33 +883,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest027,
 
     ret = innerMgrService_->GetSerialNumberByOsAccountLocalId(id, serialNumber);
     EXPECT_EQ(ret, ERR_OSACCOUNT_SERVICE_INNER_SELECT_OSACCOUNT_BYID_ERROR);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
-}
-
-/*
- * @tc.name: OsAccountInnerAccmgrCoverageTest028
- * @tc.desc: coverage test
- * @tc.type: FUNC
- * @tc.require:
- */
-HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest028, TestSize.Level1)
-{
-    auto ptr = std::make_shared<MockOsAccountControlFileManager>();
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
-    innerMgrService_->SetOsAccountControl(ptr);
-
-    OsAccountSubscribeInfo info;
-    sptr <IRemoteObject> eventListener;
-    auto tmp = innerMgrService_->subscribeManagerPtr_;
-    innerMgrService_->subscribeManagerPtr_ = nullptr;
-    ErrCode ret = innerMgrService_->SubscribeOsAccount(info, eventListener);
-    EXPECT_EQ(ret, ERR_OSACCOUNT_SERVICE_SUBSCRIBE_MANAGER_PTR_IS_NULLPTR);
-
-    ret = innerMgrService_->UnsubscribeOsAccount(eventListener);
-    EXPECT_EQ(ret, ERR_OSACCOUNT_SERVICE_SUBSCRIBE_MANAGER_PTR_IS_NULLPTR);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -990,7 +894,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest028,
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest029, TestSize.Level1)
 {
     auto ptr = std::make_shared<MockOsAccountControlFileManager>();
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     innerMgrService_->SetOsAccountControl(ptr);
 
     int id = TEST_USER_ID100;
@@ -1018,8 +921,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest029,
 
     ret = innerMgrService_->SetOsAccountIsVerified(id, isVerified);
     EXPECT_EQ(ret, ERR_OSACCOUNT_SERVICE_INNER_UPDATE_ACCOUNT_ERROR);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -1031,7 +932,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest029,
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest030, TestSize.Level1)
 {
     auto ptr = std::make_shared<MockOsAccountControlFileManager>();
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     innerMgrService_->SetOsAccountControl(ptr);
 
     int id = TEST_USER_ID100;
@@ -1049,8 +949,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest030,
         .WillRepeatedly(testing::Return(-1));
     ret = innerMgrService_->GetOsAccountLocalIdFromDomain(domainInfo1, id);
     EXPECT_EQ(ret, ERR_OSACCOUNT_SERVICE_INNER_GET_ACCOUNT_LIST_ERROR);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -1062,7 +960,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest030,
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest031, TestSize.Level1)
 {
     auto ptr = std::make_shared<MockOsAccountControlFileManager>();
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     innerMgrService_->SetOsAccountControl(ptr);
 
     int id = TEST_USER_ID100;
@@ -1074,8 +971,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest031,
     
     ErrCode ret = innerMgrService_->QueryOsAccountConstraintSourceTypes(id, constraint, constraintSourceTypeInfos);
     EXPECT_EQ(ret, ERR_OSACCOUNT_SERVICE_INNER_SELECT_OSACCOUNT_BYID_ERROR);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -1087,7 +982,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest031,
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest032, TestSize.Level1)
 {
     auto ptr = std::make_shared<MockOsAccountControlFileManager>();
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     innerMgrService_->SetOsAccountControl(ptr);
 
     const std::string constraint;
@@ -1134,8 +1028,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest032,
 
     ret = innerMgrService_->SetSpecificOsAccountConstraints(constraints, enable, targetId, enforcerId, isDeviceOwner);
     EXPECT_EQ(ret, -1);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -1147,7 +1039,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest032,
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest033, TestSize.Level1)
 {
     auto ptr = std::make_shared<MockOsAccountControlFileManager>();
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     innerMgrService_->SetOsAccountControl(ptr);
 
     OsAccountInfo osAccountInfo;
@@ -1163,8 +1054,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest033,
     EXPECT_CALL(*ptr, GetOsAccountInfoById(_, _))
         .WillRepeatedly(DoAll(testing::SetArgReferee<1>(osAccountInfo), testing::Return(0)));
     innerMgrService_->StartAccount();
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -1176,7 +1065,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest033,
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest034, TestSize.Level1)
 {
     auto ptr = std::make_shared<MockOsAccountControlFileManager>();
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     innerMgrService_->SetOsAccountControl(ptr);
 
     std::vector<OsAccountInfo> accounts;
@@ -1195,8 +1083,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest034,
     EXPECT_CALL(*ptr, GetOsAccountList(_))
         .WillRepeatedly(DoAll(SetArgReferee<0>(accounts), testing::Return(0)));
     innerMgrService_->RestartActiveAccount();
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -1208,7 +1094,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest034,
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest036, TestSize.Level1)
 {
     auto ptr = std::make_shared<MockOsAccountControlFileManager>();
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     innerMgrService_->SetOsAccountControl(ptr);
 
     std::vector<OsAccountInfo> accounts;
@@ -1232,8 +1117,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest036,
 
     innerMgrService_->ResetAccountStatus();
     EXPECT_EQ(account1.GetIsActived(), true); // this interface has nothing to judge.
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -1245,7 +1128,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest036,
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest037, TestSize.Level1)
 {
     auto ptr = std::make_shared<MockOsAccountControlFileManager>();
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     innerMgrService_->SetOsAccountControl(ptr);
 
     ErrCode ret = innerMgrService_->DeActivateOsAccount(Constants::ADMIN_LOCAL_ID);
@@ -1265,8 +1147,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest037,
 
     ret = innerMgrService_->DeActivateOsAccount(TEST_USER_ID55);
     EXPECT_EQ(ret, ERR_OSACCOUNT_SERVICE_INNER_UPDATE_ACCOUNT_ERROR);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -1278,7 +1158,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest037,
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest038, TestSize.Level1)
 {
     auto ptr = std::make_shared<MockOsAccountControlFileManager>();
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     innerMgrService_->SetOsAccountControl(ptr);
 
     std::vector<OsAccountInfo> accounts;
@@ -1302,8 +1181,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest038,
 
     innerMgrService_->ResetAccountStatus();
     EXPECT_EQ(account1.GetIsActived(), true);// this interface has nothing to judge.
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -1315,7 +1192,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest038,
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest039, TestSize.Level1)
 {
     auto ptr = std::make_shared<MockOsAccountControlFileManager>();
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
 
     OsAccountInfo osAccountInfoOne;
     (void)setuid(ACCOUNT_UID);
@@ -1364,7 +1240,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest039,
     innerMgrService_->CleanGarbageAccounts();
 
     (void)setuid(0);
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -1376,7 +1251,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest039,
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest040, TestSize.Level1)
 {
     auto ptr = std::make_shared<MockOsAccountControlFileManager>();
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     innerMgrService_->SetOsAccountControl(ptr);
 
     OsAccountInfo account1;
@@ -1389,8 +1263,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest040,
 
     int ret = innerMgrService_->SetDefaultActivatedOsAccount(TEST_USER_ID108);
     EXPECT_EQ(ret, ERR_OSACCOUNT_SERVICE_INNER_SELECT_OSACCOUNT_BYID_ERROR);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -1402,7 +1274,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest040,
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest041, TestSize.Level1)
 {
     auto ptr = std::make_shared<MockOsAccountControlFileManager>();
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     innerMgrService_->SetOsAccountControl(ptr);
 
     OsAccountInfo account1;
@@ -1415,8 +1286,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest041,
 
     int ret = innerMgrService_->SetDefaultActivatedOsAccount(TEST_USER_ID108);
     EXPECT_EQ(ret, ERR_OSACCOUNT_SERVICE_INNER_ACCOUNT_IS_UNVERIFIED_ERROR);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -1428,7 +1297,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest041,
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest042, TestSize.Level1)
 {
     auto ptr = std::make_shared<MockOsAccountControlFileManager>();
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     innerMgrService_->SetOsAccountControl(ptr);
 
     OsAccountInfo account1;
@@ -1441,8 +1309,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest042,
 
     int ret = innerMgrService_->SetDefaultActivatedOsAccount(TEST_USER_ID108);
     EXPECT_EQ(ret, ERR_OSACCOUNT_SERVICE_INNER_ACCOUNT_TO_BE_REMOVED_ERROR);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 
 /*
@@ -1454,7 +1320,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest042,
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest043, TestSize.Level1)
 {
     auto ptr = std::make_shared<MockOsAccountControlFileManager>();
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     innerMgrService_->SetOsAccountControl(ptr);
 
     OsAccountInfo account1;
@@ -1468,8 +1333,8 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest043,
         .WillRepeatedly(testing::Return(0));
     int ret = innerMgrService_->SetDefaultActivatedOsAccount(TEST_USER_ID108);
     EXPECT_EQ(ret, ERR_OK);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
+    ret = innerMgrService_->SetDefaultActivatedOsAccount(Constants::START_USER_ID);
+    EXPECT_EQ(ret, ERR_OK);
 }
 
 /*
@@ -1481,7 +1346,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest043,
 HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest044, TestSize.Level1)
 {
     auto ptr = std::make_shared<MockOsAccountControlFileManager>();
-    innerMgrService_ = DelayedSingleton<IInnerOsAccountManager>::GetInstance();
     innerMgrService_->SetOsAccountControl(ptr);
 
     OsAccountInfo account1;
@@ -1495,8 +1359,6 @@ HWTEST_F(OsAccountInnerAccmgrCoverageTest, OsAccountInnerAccmgrCoverageTest044,
         .WillRepeatedly(testing::Return(-1));
     int ret = innerMgrService_->SetDefaultActivatedOsAccount(TEST_USER_ID108);
     EXPECT_EQ(ret, -1);
-
-    DelayedSingleton<IInnerOsAccountManager>::DestroyInstance();
 }
 }  // namespace AccountSA
 }  // namespace OHOS

services/accountmgr/test/unittest/os_account/os_account_subscribe_death_recipient_test.cpp

@@ -74,15 +74,15 @@ HWTEST_F(OsAccountCoverageTest, OnRemoteDiedTest_0100, TestSize.Level1)
 
     auto subscribeInfoPtr = std::make_shared<OsAccountSubscribeInfo>(subscribeInfo);
 
-    DelayedSingleton<OsAccountSubscribeManager>::GetInstance()->SubscribeOsAccount(subscribeInfoPtr, listener);
+    OsAccountSubscribeManager::GetInstance().SubscribeOsAccount(subscribeInfoPtr, listener);
     
-    int size = DelayedSingleton<OsAccountSubscribeManager>::GetInstance()->subscribeRecords_.size();
+    int size = OsAccountSubscribeManager::GetInstance().subscribeRecords_.size();
     EXPECT_EQ(size, 1);
 
     std::shared_ptr<OsAccountSubscribeDeathRecipient> recipient = std::make_shared<OsAccountSubscribeDeathRecipient>();
     ASSERT_NE(nullptr, recipient);
     recipient->OnRemoteDied(listener);
-    size = DelayedSingleton<OsAccountSubscribeManager>::GetInstance()->subscribeRecords_.size();
+    size = OsAccountSubscribeManager::GetInstance().subscribeRecords_.size();
     EXPECT_EQ(size, 0);
 }
 
@@ -101,7 +101,7 @@ HWTEST_F(OsAccountCoverageTest, OnRemoteDiedTest_0200, TestSize.Level1)
     ASSERT_NE(nullptr, recipient);
     wptr<IRemoteObject> wptrDeath = nullptr;
     recipient->OnRemoteDied(wptrDeath);
-    int size = DelayedSingleton<OsAccountSubscribeManager>::GetInstance()->subscribeRecords_.size();
+    int size = OsAccountSubscribeManager::GetInstance().subscribeRecords_.size();
     EXPECT_EQ(size, 0);
 }
 
@@ -121,7 +121,7 @@ HWTEST_F(OsAccountCoverageTest, OnRemoteDiedTest_0300, TestSize.Level1)
     const sptr<IRemoteObject> sptrDeath = nullptr;
     wptr<IRemoteObject> wptrDeath = sptrDeath;
     recipient->OnRemoteDied(wptrDeath);
-    int size = DelayedSingleton<OsAccountSubscribeManager>::GetInstance()->subscribeRecords_.size();
+    int size = OsAccountSubscribeManager::GetInstance().subscribeRecords_.size();
     EXPECT_EQ(size, 0);
 }
 
@@ -158,10 +158,10 @@ HWTEST_F(OsAccountCoverageTest, SubscribeOsAccount_0001, TestSize.Level1)
     auto subscribeInfoPtr = std::make_shared<OsAccountSubscribeInfo>(subscribeInfo);
     ASSERT_NE(nullptr, subscribeInfoPtr);
 
-    ErrCode result = DelayedSingleton<OsAccountSubscribeManager>::GetInstance()->SubscribeOsAccount(nullptr, listener);
+    ErrCode result = OsAccountSubscribeManager::GetInstance().SubscribeOsAccount(nullptr, listener);
     EXPECT_EQ(result, ERR_APPACCOUNT_SERVICE_SUBSCRIBE_INFO_PTR_IS_NULLPTR);
 
-    result = DelayedSingleton<OsAccountSubscribeManager>::GetInstance()->SubscribeOsAccount(subscribeInfoPtr, nullptr);
+    result = OsAccountSubscribeManager::GetInstance().SubscribeOsAccount(subscribeInfoPtr, nullptr);
     EXPECT_EQ(result, ERR_APPACCOUNT_SERVICE_EVENT_LISTENER_IS_NULLPTR);
 }
 
@@ -173,7 +173,7 @@ HWTEST_F(OsAccountCoverageTest, SubscribeOsAccount_0001, TestSize.Level1)
  */
 HWTEST_F(OsAccountCoverageTest, UnsubscribeOsAccount_0001, TestSize.Level1)
 {
-    ErrCode result = DelayedSingleton<OsAccountSubscribeManager>::GetInstance()->UnsubscribeOsAccount(nullptr);
+    ErrCode result = OsAccountSubscribeManager::GetInstance().UnsubscribeOsAccount(nullptr);
     EXPECT_EQ(result, ERR_APPACCOUNT_SERVICE_EVENT_LISTENER_IS_NULLPTR);
 }
 
@@ -185,7 +185,7 @@ HWTEST_F(OsAccountCoverageTest, UnsubscribeOsAccount_0001, TestSize.Level1)
  */
 HWTEST_F(OsAccountCoverageTest, InsertSubscribeRecord_0001, TestSize.Level1)
 {
-    ErrCode result = DelayedSingleton<OsAccountSubscribeManager>::GetInstance()->InsertSubscribeRecord(nullptr);
+    ErrCode result = OsAccountSubscribeManager::GetInstance().InsertSubscribeRecord(nullptr);
     EXPECT_EQ(result, ERR_APPACCOUNT_SERVICE_SUBSCRIBE_RECORD_PTR_IS_NULLPTR);
 }
 
@@ -197,7 +197,7 @@ HWTEST_F(OsAccountCoverageTest, InsertSubscribeRecord_0001, TestSize.Level1)
  */
 HWTEST_F(OsAccountCoverageTest, RemoveSubscribeRecord_0001, TestSize.Level1)
 {
-    ErrCode result = DelayedSingleton<OsAccountSubscribeManager>::GetInstance()->RemoveSubscribeRecord(nullptr);
+    ErrCode result = OsAccountSubscribeManager::GetInstance().RemoveSubscribeRecord(nullptr);
     EXPECT_EQ(result, ERR_APPACCOUNT_SERVICE_EVENT_LISTENER_IS_NULLPTR);
 }
 }  // namespace AccountSA

tools/acm/include/account_command.h

@@ -133,9 +133,6 @@ private:
     ErrCode AnalyzeTypeArgument(OsAccountType &type);
     ErrCode AnalyzeLocalIdArgument(int &id);
     ErrCode AnalyzeConstraintArgument(std::vector<std::string> &constraints);
-
-private:
-    std::shared_ptr<OsAccount> osAccountPtr_;
 };
 }  // namespace AccountSA
 }  // namespace OHOS

tools/acm/src/account_command.cpp

@@ -73,16 +73,7 @@ ErrCode AccountCommand::init()
 {
     ACCOUNT_LOGD("enter");
 
-    ErrCode result = ERR_OK;
-
-    if (!osAccountPtr_) {
-        osAccountPtr_ = DelayedSingleton<OsAccount>::GetInstance();
-        if (!osAccountPtr_) {
-            result = ERR_INVALID_VALUE;
-        }
-    }
-
-    return result;
+    return ERR_OK;
 }
 
 ErrCode AccountCommand::RunAsHelpCommand(void)
@@ -151,7 +142,7 @@ ErrCode AccountCommand::RunAsCreateCommand(void)
         OsAccountInfo osAccountInfo;
 
         // create an os account
-        result = osAccountPtr_->CreateOsAccount(name, osAccountType, osAccountInfo);
+        result = OsAccount::GetInstance().CreateOsAccount(name, osAccountType, osAccountInfo);
         if (result == ERR_OK) {
             resultReceiver_ = STRING_CREATE_OS_ACCOUNT_OK + "\n";
         } else {
@@ -201,7 +192,7 @@ ErrCode AccountCommand::RunAsDeleteCommand(void)
         /* delete */
 
         // delete an os account
-        result = osAccountPtr_->RemoveOsAccount(id);
+        result = OsAccount::GetInstance().RemoveOsAccount(id);
         if (result == ERR_OK) {
             resultReceiver_ = STRING_DELETE_OS_ACCOUNT_OK + "\n";
         } else {
@@ -252,7 +243,7 @@ ErrCode AccountCommand::RunAsDumpCommand(void)
 
         // dump state
         std::vector<std::string> state;
-        result = osAccountPtr_->DumpState(id, state);
+        result = OsAccount::GetInstance().DumpState(id, state);
         if (result == ERR_OK) {
             for (auto info : state) {
                 resultReceiver_ += info + "\n";
@@ -322,7 +313,7 @@ ErrCode AccountCommand::RunAsSetCommand(void)
         /* set */
 
         // set os account constraints
-        result = osAccountPtr_->SetOsAccountConstraints(id, constraints, enable);
+        result = OsAccount::GetInstance().SetOsAccountConstraints(id, constraints, enable);
         if (result == ERR_OK) {
             resultReceiver_ = STRING_SET_OS_ACCOUNT_CONSTRAINTS_OK + "\n";
         } else {
@@ -375,7 +366,7 @@ ErrCode AccountCommand::RunAsSwitchCommand(void)
         /* switch */
 
         // switch an os account
-        result = osAccountPtr_->ActivateOsAccount(id);
+        result = OsAccount::GetInstance().ActivateOsAccount(id);
         if (result == ERR_OK) {
             resultReceiver_ = STRING_SWITCH_OS_ACCOUNT_OK + "\n";
         } else {
@@ -425,7 +416,7 @@ ErrCode AccountCommand::RunAsStopCommand(void)
         /* stop */
 
         // stop an os account
-        result = osAccountPtr_->StopOsAccount(id);
+        result = OsAccount::GetInstance().StopOsAccount(id);
         if (result == ERR_OK) {
             resultReceiver_ = STRING_STOP_OS_ACCOUNT_OK + "\n";
         } else {

tools/test/unittest/acm/account_command_create_test.cpp

@@ -31,7 +31,6 @@ const std::string STRING_TYPE_NORMAL = "normal";
 const std::string STRING_TYPE_ADMIN = "admin";
 const std::string STRING_TYPE_GUEST = "guest";
 const std::string STRING_TYPE_INVALID = "type_invalid";
-static std::shared_ptr<OsAccount> g_osAccountPtr = nullptr;
 }  // namespace
 
 class AccountCommandCreateTest : public testing::Test {
@@ -45,10 +44,7 @@ public:
 };
 
 void AccountCommandCreateTest::SetUpTestCase()
-{
-    g_osAccountPtr = DelayedSingleton<OsAccount>::GetInstance();
-    EXPECT_NE(g_osAccountPtr, nullptr);
-}
+{}
 
 void AccountCommandCreateTest::TearDownTestCase()
 {}
@@ -59,9 +55,9 @@ void AccountCommandCreateTest::SetUp()
     optind = 0;
 
     std::vector<OsAccountInfo> osAccountInfos;
-    g_osAccountPtr->QueryAllCreatedOsAccounts(osAccountInfos);
+    OsAccount::GetInstance().QueryAllCreatedOsAccounts(osAccountInfos);
     for (const auto &info : osAccountInfos) {
-        g_osAccountPtr->RemoveOsAccount(info.GetLocalId());
+        OsAccount::GetInstance().RemoveOsAccount(info.GetLocalId());
     }
 }
 

tools/test/unittest/acm/account_command_delete_test.cpp

@@ -25,7 +25,6 @@ using namespace OHOS::AccountSA;
 
 namespace {
 const std::string HELP_MSG_UNKNOWN_OPTION = "error: unknown option.";
-static std::shared_ptr<OsAccount> g_osAccountPtr = nullptr;
 }  // namespace
 
 class AccountCommandDeleteTest : public testing::Test {
@@ -39,10 +38,7 @@ public:
 };
 
 void AccountCommandDeleteTest::SetUpTestCase()
-{
-    g_osAccountPtr = DelayedSingleton<OsAccount>::GetInstance();
-    EXPECT_NE(g_osAccountPtr, nullptr);
-}
+{}
 
 void AccountCommandDeleteTest::TearDownTestCase()
 {}
@@ -53,9 +49,9 @@ void AccountCommandDeleteTest::SetUp()
     optind = 0;
 
     std::vector<OsAccountInfo> osAccountInfos;
-    g_osAccountPtr->QueryAllCreatedOsAccounts(osAccountInfos);
+    OsAccount::GetInstance().QueryAllCreatedOsAccounts(osAccountInfos);
     for (const auto &info : osAccountInfos) {
-        g_osAccountPtr->RemoveOsAccount(info.GetLocalId());
+        OsAccount::GetInstance().RemoveOsAccount(info.GetLocalId());
     }
 }
 
@@ -273,7 +269,7 @@ HWTEST_F(AccountCommandDeleteTest, Acm_Command_Delete_1100, TestSize.Level1)
 {
     OsAccountInfo osAccountInfo;
     // create an os account
-    EXPECT_EQ(ERR_OK, g_osAccountPtr->CreateOsAccount(TOOL_NAME, OsAccountType::NORMAL, osAccountInfo));
+    EXPECT_EQ(ERR_OK, OsAccount::GetInstance().CreateOsAccount(TOOL_NAME, OsAccountType::NORMAL, osAccountInfo));
 
     std::string userId = std::to_string(osAccountInfo.GetLocalId());
     char *argv[] = {

tools/test/unittest/acm/account_command_dump_test.cpp

@@ -25,7 +25,6 @@ using namespace OHOS::AccountSA;
 
 namespace {
 const std::string HELP_MSG_UNKNOWN_OPTION = "error: unknown option.";
-static std::shared_ptr<OsAccount> g_osAccountPtr = nullptr;
 }  // namespace
 
 class AccountCommandDumpTest : public testing::Test {
@@ -39,10 +38,7 @@ public:
 };
 
 void AccountCommandDumpTest::SetUpTestCase()
-{
-    g_osAccountPtr = DelayedSingleton<OsAccount>::GetInstance();
-    EXPECT_NE(g_osAccountPtr, nullptr);
-}
+{}
 
 void AccountCommandDumpTest::TearDownTestCase()
 {}
@@ -53,9 +49,9 @@ void AccountCommandDumpTest::SetUp()
     optind = 0;
 
     std::vector<OsAccountInfo> osAccountInfos;
-    g_osAccountPtr->QueryAllCreatedOsAccounts(osAccountInfos);
+    OsAccount::GetInstance().QueryAllCreatedOsAccounts(osAccountInfos);
     for (const auto &info : osAccountInfos) {
-        g_osAccountPtr->RemoveOsAccount(info.GetLocalId());
+        OsAccount::GetInstance().RemoveOsAccount(info.GetLocalId());
     }
 }
 
@@ -271,7 +267,7 @@ HWTEST_F(AccountCommandDumpTest, Acm_Command_Dump_1100, TestSize.Level1)
 {
     OsAccountInfo osAccountInfo;
     // create an os account
-    EXPECT_EQ(ERR_OK, g_osAccountPtr->CreateOsAccount(TOOL_NAME, OsAccountType::NORMAL, osAccountInfo));
+    EXPECT_EQ(ERR_OK, OsAccount::GetInstance().CreateOsAccount(TOOL_NAME, OsAccountType::NORMAL, osAccountInfo));
 
     std::string userId = std::to_string(osAccountInfo.GetLocalId());
     char *argv[] = {

tools/test/unittest/acm/account_command_set_test.cpp

@@ -29,7 +29,6 @@ const std::string HELP_MSG_UNKNOWN_OPTION = "error: unknown option.";
 const std::string STRING_LOCAL_ACCOUNT_ID = "1024";
 const std::string STRING_CONSTRAINT = "constraint.bluetooth";
 const std::string STRING_CONSTRAINT1 = "constraint.bluetooth,constraint.bluetooth.set";
-static std::shared_ptr<OsAccount> g_osAccountPtr = nullptr;
 }  // namespace
 
 class AccountCommandSetTest : public testing::Test {
@@ -43,10 +42,7 @@ public:
 };
 
 void AccountCommandSetTest::SetUpTestCase()
-{
-    g_osAccountPtr = DelayedSingleton<OsAccount>::GetInstance();
-    EXPECT_NE(g_osAccountPtr, nullptr);
-}
+{}
 
 void AccountCommandSetTest::TearDownTestCase()
 {}
@@ -57,9 +53,9 @@ void AccountCommandSetTest::SetUp()
     optind = 0;
 
     std::vector<OsAccountInfo> osAccountInfos;
-    g_osAccountPtr->QueryAllCreatedOsAccounts(osAccountInfos);
+    OsAccount::GetInstance().QueryAllCreatedOsAccounts(osAccountInfos);
     for (const auto &info : osAccountInfos) {
-        g_osAccountPtr->RemoveOsAccount(info.GetLocalId());
+        OsAccount::GetInstance().RemoveOsAccount(info.GetLocalId());
     }
 }
 
@@ -361,7 +357,7 @@ HWTEST_F(AccountCommandSetTest, Acm_Command_Set_1500, TestSize.Level1)
 {
     OsAccountInfo osAccountInfo;
     // create an os account
-    EXPECT_EQ(ERR_OK, g_osAccountPtr->CreateOsAccount(TOOL_NAME, OsAccountType::NORMAL, osAccountInfo));
+    EXPECT_EQ(ERR_OK, OsAccount::GetInstance().CreateOsAccount(TOOL_NAME, OsAccountType::NORMAL, osAccountInfo));
 
     std::string userId = std::to_string(osAccountInfo.GetLocalId());
     char *argv[] = {

tools/test/unittest/acm/account_command_switch_test.cpp

@@ -25,7 +25,6 @@ using namespace OHOS::AccountSA;
 
 namespace {
 const std::string HELP_MSG_UNKNOWN_OPTION = "error: unknown option.";
-static std::shared_ptr<OsAccount> g_osAccountPtr = nullptr;
 }  // namespace
 
 class AccountCommandSwitchTest : public testing::Test {
@@ -39,10 +38,7 @@ public:
 };
 
 void AccountCommandSwitchTest::SetUpTestCase()
-{
-    g_osAccountPtr = DelayedSingleton<OsAccount>::GetInstance();
-    EXPECT_NE(g_osAccountPtr, nullptr);
-}
+{}
 
 void AccountCommandSwitchTest::TearDownTestCase()
 {}
@@ -53,9 +49,9 @@ void AccountCommandSwitchTest::SetUp()
     optind = 0;
 
     std::vector<OsAccountInfo> osAccountInfos;
-    g_osAccountPtr->QueryAllCreatedOsAccounts(osAccountInfos);
+    OsAccount::GetInstance().QueryAllCreatedOsAccounts(osAccountInfos);
     for (const auto &info : osAccountInfos) {
-        g_osAccountPtr->RemoveOsAccount(info.GetLocalId());
+        OsAccount::GetInstance().RemoveOsAccount(info.GetLocalId());
     }
 }
 
@@ -251,7 +247,7 @@ HWTEST_F(AccountCommandSwitchTest, Acm_Command_Switch_1000, TestSize.Level1)
 {
     OsAccountInfo osAccountInfo;
     // create an os account
-    EXPECT_EQ(ERR_OK, g_osAccountPtr->CreateOsAccount(TOOL_NAME, OsAccountType::NORMAL, osAccountInfo));
+    EXPECT_EQ(ERR_OK, OsAccount::GetInstance().CreateOsAccount(TOOL_NAME, OsAccountType::NORMAL, osAccountInfo));
 
     std::string userId = std::to_string(osAccountInfo.GetLocalId());
     char *argv[] = {

tools/test/unittest/acm/account_command_test.cpp

@@ -27,7 +27,6 @@ using namespace OHOS::AccountSA;
 
 namespace {
 const std::string HELP_MSG_UNKNOWN_OPTION = "error: unknown option.";
-static std::shared_ptr<OsAccount> g_osAccountPtr = nullptr;
 }  // namespace
 class AccountCommandTest : public testing::Test {
 public:
@@ -39,10 +38,7 @@ public:
 };
 
 void AccountCommandTest::SetUpTestCase()
-{
-    g_osAccountPtr = DelayedSingleton<OsAccount>::GetInstance();
-    EXPECT_NE(g_osAccountPtr, nullptr);
-}
+{}
 
 void AccountCommandTest::TearDownTestCase()
 {}
@@ -340,7 +336,7 @@ HWTEST_F(AccountCommandTest, Acm_Command_1500, TestSize.Level1)
 {
     OsAccountInfo osAccountInfo;
     // create an os account
-    EXPECT_EQ(ERR_OK, g_osAccountPtr->CreateOsAccount(TOOL_NAME, OsAccountType::NORMAL, osAccountInfo));
+    EXPECT_EQ(ERR_OK, OsAccount::GetInstance().CreateOsAccount(TOOL_NAME, OsAccountType::NORMAL, osAccountInfo));
 
     std::string userId = std::to_string(osAccountInfo.GetLocalId());
     char *argv[] = {