diff --git a/services/implementation/include/ability/dm_dialog_manager.h b/services/implementation/include/ability/dm_dialog_manager.h
index 73c92997c4d14e53501ac27b0fce80c467d53767..2b2ad90f20a2cf3373d629ac12a279d889cc52b6 100644
--- a/services/implementation/include/ability/dm_dialog_manager.h
+++ b/services/implementation/include/ability/dm_dialog_manager.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -27,96 +27,44 @@
 namespace OHOS {
 namespace DistributedHardware {
 class DmDialogManager {
+    DM_DECLARE_SINGLE_INSTANCE_BASE(DmDialogManager);
 public:
-    static DmDialogManager &GetInstance();
-    static void ConnectExtension();
+    void ConnectExtension();
     void ShowConfirmDialog(const std::string param);
     void ShowPinDialog(const std::string param);
     void ShowInputDialog(const std::string param);
-    static std::string GetBundleName()
-    {
-        return bundleName_;
-    }
-
-    static std::string GetAbilityName()
-    {
-        return abilityName_;
-    }
-
-    static std::string GetPinCode()
-    {
-        return pinCode_;
-    }
-
-    static std::string GetDeviceName()
-    {
-        return deviceName_;
-    }
-
-    static std::string GetAppOperationStr()
-    {
-        return appOperationStr_;
-    }
-
-    static std::string GetCustomDescriptionStr()
-    {
-        return customDescriptionStr_;
-    }
-
-    static int32_t GetDeviceType()
-    {
-        return deviceType_;
-    }
-
-    static std::string GetTargetDeviceName()
-    {
-        return targetDeviceName_;
-    }
-
-    static std::string GetHostPkgLabel()
-    {
-        return hostPkgLabel_;
-    }
-    static bool GetIsProxyBind()
-    {
-        return isProxyBind_;
-    }
-    static std::string GetAppUserData()
-    {
-        return appUserData_;
-    }
-    static std::string GetTitle()
-    {
-        return title_;
-    }
+    void CloseDialog();
+    void OnAbilityConnectDone(
+        const AppExecFwk::ElementName& element, const sptr<IRemoteObject>& remoteObject, int resultCode);
+    void OnAbilityDisconnectDone(const AppExecFwk::ElementName& element, int resultCode);
 private:
     DmDialogManager();
     ~DmDialogManager();
+    void SendMsgRequest(const sptr<IRemoteObject>& remoteObject);
     class DialogAbilityConnection : public OHOS::AAFwk::AbilityConnectionStub {
     public:
         void OnAbilityConnectDone(
             const AppExecFwk::ElementName& element, const sptr<IRemoteObject>& remoteObject, int resultCode) override;
         void OnAbilityDisconnectDone(const AppExecFwk::ElementName& element, int resultCode) override;
-
-    private:
-        std::mutex mutex_;
     };
 
-    static std::string bundleName_;
-    static std::string abilityName_;
-    static std::string deviceName_;
-    static std::string targetDeviceName_;
-    static std::string appOperationStr_;
-    static std::string customDescriptionStr_;
-    static std::string pinCode_;
-    static std::string hostPkgLabel_;
-    static int32_t deviceType_;
-    static std::atomic<bool> isConnectSystemUI_;
-    static sptr<OHOS::AAFwk::IAbilityConnection> dialogConnectionCallback_;
-    static DmDialogManager dialogMgr_;
-    static bool isProxyBind_;
-    static std::string appUserData_;
-    static std::string title_;
+    std::string bundleName_;
+    std::string abilityName_;
+    std::string deviceName_;
+    std::string targetDeviceName_;
+    std::string appOperationStr_;
+    std::string customDescriptionStr_;
+    std::string pinCode_;
+    std::string hostPkgLabel_;
+    int32_t deviceType_;
+    bool isProxyBind_;
+    std::string appUserData_;
+    std::string title_;
+    std::mutex mutex_;
+    sptr<OHOS::AAFwk::IAbilityConnection> dialogConnectionCallback_ = nullptr;
+    sptr<IRemoteObject> g_remoteObject = nullptr;
+    std::atomic<bool> isConnectSystemUI_{false};
+    std::atomic<bool> isCloseDialog_{false};
 };
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/implementation/include/device_manager_service_impl.h b/services/implementation/include/device_manager_service_impl.h
index 75b46dbad39f0831ef09014f33ba392c4033e94b..60726df8f88a2e6bb78e05898265789b5455a390 100644
--- a/services/implementation/include/device_manager_service_impl.h
+++ b/services/implementation/include/device_manager_service_impl.h
@@ -227,12 +227,14 @@ private:
     void HandleRemoteUserRemoved(int32_t preUserId, const std::string &remoteUdid);
     DmAuthForm ConvertBindTypeToAuthForm(int32_t bindType);
     std::shared_ptr<AuthManagerBase> GetAuthMgr();
+    int32_t AddAuthMgr(uint64_t tokenId, int sessionId, std::shared_ptr<AuthManagerBase> authMgr);
+    void EraseAuthMgr(uint64_t tokenId);
     std::shared_ptr<AuthManagerBase> GetAuthMgrByTokenId(uint64_t tokenId);
     std::shared_ptr<AuthManagerBase> GetCurrentAuthMgr();
     void CreateGlobalClassicalAuthMgr();
     std::shared_ptr<Session> GetCurSession(int sessionId);
     std::shared_ptr<Session> GetOrCreateSession(const std::string& deviceId,
-        const std::map<std::string, std::string> &bindParam);
+        const std::map<std::string, std::string> &bindParam, uint64_t tokenId);
     int32_t ParseConnectAddr(const PeerTargetId &targetId, std::string &deviceId,
         const std::map<std::string, std::string> &bindParam);
     std::shared_ptr<Config> GetConfigByTokenId();
@@ -256,7 +258,8 @@ private:
     void ImportAuthCodeToConfig(std::shared_ptr<AuthManagerBase> authMgr, uint64_t tokenId);
 
     void CleanAuthMgrByLogicalSessionId(uint64_t logicalSessionId);
-    void CleanSessionMap(int sessionId, std::shared_ptr<Session> session);
+    void CleanSessionMap(std::shared_ptr<Session> session);
+    void CleanSessionMap(int sessionId);
     void CleanSessionMapByLogicalSessionId(uint64_t logicalSessionId);
     int32_t DeleteAclForProcV2(const std::string &localUdid, uint32_t localTokenId, const std::string &remoteUdid,
         int32_t bindLevel, const std::string &extra, int32_t userId);
@@ -291,16 +294,17 @@ private:
     void SaveTokenIdAndSessionId(uint64_t &tokenId, int32_t &sessionId, uint64_t &logicalSessionId);
     void ReleaseMaps();
     int32_t InitNewProtocolAuthMgr(bool isSrcSide, uint64_t tokenId, uint64_t logicalSessionId,
-        const std::string &pkgName);
-    int32_t InitOldProtocolAuthMgr(uint64_t tokenId, const std::string &pkgName);
-    bool ParseConnectAddrAndSetProcessInfo(const PeerTargetId &targetId,
-        PeerTargetId &targetIdTmp, const std::map<std::string, std::string> &bindParam, ProcessInfo &processInfo,
-        const std::string &pkgName);
+        const std::string &pkgName, int sessionId);
+    int32_t InitOldProtocolAuthMgr(uint64_t tokenId, const std::string &pkgName, int sessionId);
+    bool ParseConnectAddrAndSetProcessInfo(PeerTargetId &targetIdTmp,
+        const std::map<std::string, std::string> &bindParam, ProcessInfo &processInfo,
+        const std::string &pkgName, uint64_t tokenId);
     void OnAuthResultAndOnBindResult(const ProcessInfo &processInfo, const PeerTargetId &targetId,
-        const std::string &deviceId, int32_t reason);
+        const std::string &deviceId, int32_t reason, uint64_t tokenId);
     void GetBundleName(const DMAclQuadInfo &info, std::set<std::string> &pkgNameSet);
     void DeleteSessionKey(int32_t userId, const DistributedDeviceProfile::AccessControlProfile &profile);
 private:
+    std::mutex authMgrMtx_;
     std::shared_ptr<AuthManagerBase> authMgr_;     // Old protocol only
     bool isNeedJoinLnn_ = true;
     std::mutex isNeedJoinLnnMtx_;
@@ -320,11 +324,12 @@ private:
     // The session ID corresponding to the device ID, used only on the src side
     std::map<std::string, int> deviceId2SessionIdMap_;
     std::map<int, std::shared_ptr<Session>> sessionsMap_;  // sessionId corresponds to the session object
-    std::map<std::string, std::mutex> deviceIdMutexMap_;  // Lock corresponding to the device ID
     std::mutex mapMutex_;  // sessionsMap_ lock
     std::map<int, std::condition_variable> sessionEnableCvMap_;  // Condition variable corresponding to the session
     std::map<int, std::mutex> sessionEnableMutexMap_;      // Lock corresponding to the session
     std::map<int, bool> sessionEnableCvReadyMap_;  // Condition variable ready flag
+    std::map<int, bool> sessionStopMap_;  // stop flag
+    std::map<int, bool> sessionEnableMap_;  // enable flag
     std::mutex logicalSessionId2TokenIdMapMtx_;
     std::map<uint64_t, uint64_t> logicalSessionId2TokenIdMap_;  // The relationship between logicalSessionId and tokenId
     std::mutex logicalSessionId2SessionIdMapMtx_;
@@ -333,6 +338,8 @@ private:
     std::map<uint64_t, std::shared_ptr<Config>> configsMap_;    // Import when authMgr is not initialized
     std::mutex authMgrMapMtx_;
     std::map<uint64_t, std::shared_ptr<AuthManagerBase>> authMgrMap_;  // New protocol sharing
+    std::mutex tokenIdSessionIdMapMtx_;
+    std::map<uint64_t, int> tokenIdSessionIdMap_;  // New protocol sharing
 };
 
 using CreateDMServiceFuncPtr = IDeviceManagerServiceImpl *(*)(void);
diff --git a/services/implementation/src/ability/standard/dm_dialog_manager.cpp b/services/implementation/src/ability/standard/dm_dialog_manager.cpp
index 71ae90d94eac0ed1bc04b6987e7c679441c0b460..1f8d7d094e01acf7195fd2f420ce1293052f2254 100644
--- a/services/implementation/src/ability/standard/dm_dialog_manager.cpp
+++ b/services/implementation/src/ability/standard/dm_dialog_manager.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -32,34 +32,20 @@
 
 namespace OHOS {
 namespace DistributedHardware {
-static constexpr int32_t INVALID_USERID = -1;
-static constexpr int32_t MESSAGE_PARCEL_KEY_SIZE = 3;
-static constexpr int32_t WINDOW_LEVEL_UPPER = 2;
-static constexpr int32_t WINDOW_LEVEL_DEFAULT = 1;
+namespace {
+constexpr int32_t INVALID_USERID = -1;
+constexpr int32_t MESSAGE_PARCEL_KEY_SIZE = 3;
+constexpr int32_t WINDOW_LEVEL_UPPER = 2;
+constexpr int32_t WINDOW_LEVEL_DEFAULT = 1;
 constexpr const char* CONNECT_PIN_DIALOG = "pinDialog";
 constexpr const char* DM_UI_BUNDLE_NAME = "com.ohos.devicemanagerui";
 constexpr const char* CONFIRM_ABILITY_NAME = "com.ohos.devicemanagerui.ConfirmUIExtAbility";
 constexpr const char* PIN_ABILITY_NAME = "com.ohos.devicemanagerui.PincodeUIExtAbility";
 constexpr const char* INPUT_ABILITY_NAME = "com.ohos.devicemanagerui.InputUIExtAbility";
-
-std::string DmDialogManager::bundleName_ = "";
-std::string DmDialogManager::abilityName_ = "";
-std::string DmDialogManager::deviceName_ = "";
-std::string DmDialogManager::appOperationStr_ = "";
-std::string DmDialogManager::customDescriptionStr_ = "";
-std::string DmDialogManager::targetDeviceName_ = "";
-std::string DmDialogManager::pinCode_ = "";
-std::string DmDialogManager::hostPkgLabel_ = "";
-int32_t DmDialogManager::deviceType_ = -1;
-bool DmDialogManager::isProxyBind_ = false;
-std::string DmDialogManager::appUserData_ = "";
-std::string DmDialogManager::title_ = "";
-DmDialogManager DmDialogManager::dialogMgr_;
-sptr<OHOS::AAFwk::IAbilityConnection> DmDialogManager::dialogConnectionCallback_(
-    new (std::nothrow) DialogAbilityConnection());
-
-std::atomic<bool> DmDialogManager::isConnectSystemUI_(false);
-sptr<IRemoteObject> g_remoteObject = nullptr;
+constexpr uint32_t CLOSE_DIALOG_CMD_CODE = 3;
+constexpr uint32_t SHOW_DIALOG_CMD_CODE = 1;
+}
+DM_IMPLEMENT_SINGLE_INSTANCE(DmDialogManager);
 
 DmDialogManager::DmDialogManager()
 {
@@ -71,11 +57,6 @@ DmDialogManager::~DmDialogManager()
     LOGI("DmDialogManager destructor");
 }
 
-DmDialogManager &DmDialogManager::GetInstance()
-{
-    return dialogMgr_;
-}
-
 void DmDialogManager::ShowConfirmDialog(const std::string param)
 {
     std::string deviceName = "";
@@ -83,54 +64,60 @@ void DmDialogManager::ShowConfirmDialog(const std::string param)
     std::string customDescriptionStr = "";
     std::string hostPkgLabel = "";
     int32_t deviceType = -1;
-    JsonObject jsonObject(param);
-    if (!jsonObject.IsDiscarded()) {
-        if (IsString(jsonObject, TAG_REQUESTER)) {
-            deviceName = jsonObject[TAG_REQUESTER].Get<std::string>();
-        }
-        if (IsString(jsonObject, TAG_APP_OPERATION)) {
-            appOperationStr = jsonObject[TAG_APP_OPERATION].Get<std::string>();
-        }
-        if (IsString(jsonObject, TAG_CUSTOM_DESCRIPTION)) {
-            customDescriptionStr = jsonObject[TAG_CUSTOM_DESCRIPTION].Get<std::string>();
+    {
+        std::unique_lock<std::mutex> lock(mutex_);
+        JsonObject jsonObject(param);
+        if (!jsonObject.IsDiscarded()) {
+            if (IsString(jsonObject, TAG_REQUESTER)) {
+                deviceName = jsonObject[TAG_REQUESTER].Get<std::string>();
+            }
+            if (IsString(jsonObject, TAG_APP_OPERATION)) {
+                appOperationStr = jsonObject[TAG_APP_OPERATION].Get<std::string>();
+            }
+            if (IsString(jsonObject, TAG_CUSTOM_DESCRIPTION)) {
+                customDescriptionStr = jsonObject[TAG_CUSTOM_DESCRIPTION].Get<std::string>();
+            }
+            if (IsInt32(jsonObject, TAG_LOCAL_DEVICE_TYPE)) {
+                deviceType = jsonObject[TAG_LOCAL_DEVICE_TYPE].Get<std::int32_t>();
+            }
+            if (IsString(jsonObject, TAG_HOST_PKGLABEL)) {
+                hostPkgLabel = jsonObject[TAG_HOST_PKGLABEL].Get<std::string>();
+            }
+            if (IsBool(jsonObject, PARAM_KEY_IS_PROXY_BIND)) {
+                isProxyBind_ = jsonObject[PARAM_KEY_IS_PROXY_BIND].Get<bool>();
+            }
+            if (IsString(jsonObject, APP_USER_DATA)) {
+                appUserData_ = jsonObject[APP_USER_DATA].Get<std::string>();
+            }
+            if (IsString(jsonObject, TITLE)) {
+                title_ = jsonObject[TITLE].Get<std::string>();
+            }
         }
-        if (IsInt32(jsonObject, TAG_LOCAL_DEVICE_TYPE)) {
-            deviceType = jsonObject[TAG_LOCAL_DEVICE_TYPE].Get<std::int32_t>();
-        }
-        if (IsString(jsonObject, TAG_HOST_PKGLABEL)) {
-            hostPkgLabel = jsonObject[TAG_HOST_PKGLABEL].Get<std::string>();
-        }
-        if (IsBool(jsonObject, PARAM_KEY_IS_PROXY_BIND)) {
-            isProxyBind_ = jsonObject[PARAM_KEY_IS_PROXY_BIND].Get<bool>();
-        }
-        if (IsString(jsonObject, APP_USER_DATA)) {
-            appUserData_ = jsonObject[APP_USER_DATA].Get<std::string>();
-        }
-        if (IsString(jsonObject, TITLE)) {
-            title_ = jsonObject[TITLE].Get<std::string>();
-        }
-    }
 
-    bundleName_ = DM_UI_BUNDLE_NAME;
-    abilityName_ = CONFIRM_ABILITY_NAME;
-    deviceName_ = deviceName;
-    appOperationStr_ = appOperationStr;
-    customDescriptionStr_ = customDescriptionStr;
-    deviceType_ = deviceType;
-    hostPkgLabel_ = hostPkgLabel;
+        bundleName_ = DM_UI_BUNDLE_NAME;
+        abilityName_ = CONFIRM_ABILITY_NAME;
+        deviceName_ = deviceName;
+        appOperationStr_ = appOperationStr;
+        customDescriptionStr_ = customDescriptionStr;
+        deviceType_ = deviceType;
+        hostPkgLabel_ = hostPkgLabel;
+    }
     ConnectExtension();
 }
 
 void DmDialogManager::ShowPinDialog(const std::string param)
 {
     LOGI("pinCode: %{public}s", GetAnonyString(param).c_str());
-    bundleName_ = DM_UI_BUNDLE_NAME;
-    abilityName_ = PIN_ABILITY_NAME;
-    pinCode_ = param;
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        bundleName_ = DM_UI_BUNDLE_NAME;
+        abilityName_ = PIN_ABILITY_NAME;
+        pinCode_ = param;
+    }
 #if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
-    ffrt::submit([]() { ConnectExtension(); });
+    ffrt::submit([]() { DmDialogManager::GetInstance().ConnectExtension(); });
 #else
-    std::thread pinDilog([]() { ConnectExtension(); });
+    std::thread pinDilog([]() { DmDialogManager::GetInstance().ConnectExtension(); });
     int32_t ret = pthread_setname_np(pinDilog.native_handle(), CONNECT_PIN_DIALOG.c_str());
     if (ret != DM_OK) {
         LOGE("pinDilog setname failed.");
@@ -141,18 +128,41 @@ void DmDialogManager::ShowPinDialog(const std::string param)
 
 void DmDialogManager::ShowInputDialog(const std::string param)
 {
-    targetDeviceName_ = param;
-    bundleName_ = DM_UI_BUNDLE_NAME;
-    abilityName_ = INPUT_ABILITY_NAME;
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        targetDeviceName_ = param;
+        bundleName_ = DM_UI_BUNDLE_NAME;
+        abilityName_ = INPUT_ABILITY_NAME;
+    }
     ConnectExtension();
 }
 
+void DmDialogManager::CloseDialog()
+{
+    LOGI("In");
+    std::unique_lock<std::mutex> lock(mutex_);
+    if (g_remoteObject == nullptr) {
+        LOGW("g_remoteObject is nullptr");
+        isCloseDialog_.store(true);
+        return;
+    }
+    MessageParcel data;
+    MessageParcel reply;
+    MessageOption option;
+    int32_t ret = g_remoteObject->SendRequest(CLOSE_DIALOG_CMD_CODE, data, reply, option);
+    if (ret != ERR_OK) {
+        LOGE("close dm dialog is failed: %{public}d", ret);
+        return;
+    }
+}
+
 void DmDialogManager::ConnectExtension()
 {
     LOGI("DmDialogManager::ConnectExtension start.");
+    isCloseDialog_.store(false);
     if (isConnectSystemUI_.load() && dialogConnectionCallback_ != nullptr && g_remoteObject != nullptr) {
         AppExecFwk::ElementName element;
-        dialogConnectionCallback_->OnAbilityConnectDone(element, g_remoteObject, INVALID_USERID);
+        OnAbilityConnectDone(element, g_remoteObject, INVALID_USERID);
         LOGI("DmDialogManager::ConnectExtension dialog has been show.");
         return;
     }
@@ -166,6 +176,14 @@ void DmDialogManager::ConnectExtension()
         return;
     }
 
+    std::lock_guard<std::mutex> lock(mutex_);
+    if (dialogConnectionCallback_ == nullptr) {
+        dialogConnectionCallback_ = new (std::nothrow) DialogAbilityConnection();
+    }
+    if (dialogConnectionCallback_ == nullptr) {
+        LOGE("create dialogConnectionCallback_ failed.");
+        return;
+    }
     LOGI("DmDialogManager::ConnectExtension abilityManager ConnectAbility begin.");
     auto ret = abilityManager->ConnectAbility(want, dialogConnectionCallback_, INVALID_USERID);
     if (ret != ERR_OK) {
@@ -175,12 +193,12 @@ void DmDialogManager::ConnectExtension()
         want.SetElementName(bundleName, abilityName);
         ret = abilityManager->ConnectAbility(want, dialogConnectionCallback_, INVALID_USERID);
         if (ret != ERR_OK) {
-            LOGE("ConnectExtensionAbility systemui failed.");
+            LOGE("ConnectExtensionAbility systemui failed again.");
         }
     }
 }
 
-void DmDialogManager::DialogAbilityConnection::OnAbilityConnectDone(
+void DmDialogManager::OnAbilityConnectDone(
     const AppExecFwk::ElementName& element, const sptr<IRemoteObject>& remoteObject, int resultCode)
 {
     LOGI("OnAbilityConnectDone");
@@ -192,54 +210,75 @@ void DmDialogManager::DialogAbilityConnection::OnAbilityConnectDone(
     if (g_remoteObject == nullptr) {
         g_remoteObject = remoteObject;
     }
+    isConnectSystemUI_.store(true);
+    if (isCloseDialog_.load()) {
+        LOGW("isCloseDialog_  is true");
+        isCloseDialog_.store(false);
+        return;
+    }
+    SendMsgRequest(remoteObject);
+}
+
+void DmDialogManager::SendMsgRequest(const sptr<IRemoteObject>& remoteObject)
+{
     MessageParcel data;
     MessageParcel reply;
     MessageOption option;
     data.WriteInt32(MESSAGE_PARCEL_KEY_SIZE);
     data.WriteString16(u"bundleName");
-    data.WriteString16(Str8ToStr16(DmDialogManager::GetBundleName()));
+    data.WriteString16(Str8ToStr16(bundleName_));
     data.WriteString16(u"abilityName");
-    data.WriteString16(Str8ToStr16(DmDialogManager::GetAbilityName()));
+    data.WriteString16(Str8ToStr16(abilityName_));
     data.WriteString16(u"parameters");
     JsonObject param;
     param["ability.want.params.uiExtensionType"] = "sysDialog/common";
     param["sysDialogZOrder"] = WINDOW_LEVEL_DEFAULT;
-    if (DmDialogManager::GetAbilityName() == INPUT_ABILITY_NAME) {
+    if (abilityName_ == INPUT_ABILITY_NAME) {
         param["sysDialogZOrder"] = WINDOW_LEVEL_UPPER;
     }
-    std::string pinCodeHash = GetAnonyString(Crypto::Sha256(DmDialogManager::GetPinCode()));
+    std::string pinCodeHash = GetAnonyString(Crypto::Sha256(pinCode_));
     LOGI("OnAbilityConnectDone pinCodeHash: %{public}s", pinCodeHash.c_str());
-    param["isProxyBind"] = DmDialogManager::GetIsProxyBind();
-    param["appUserData"] = DmDialogManager::GetAppUserData();
-    param["title"] = DmDialogManager::GetTitle();
-    param["pinCode"] = DmDialogManager::GetPinCode();
-    param["deviceName"] = DmDialogManager::GetDeviceName();
-    param["appOperationStr"] = DmDialogManager::GetAppOperationStr();
-    param["customDescriptionStr"] = DmDialogManager::GetCustomDescriptionStr();
-    param["deviceType"] = DmDialogManager::GetDeviceType();
-    param[TAG_TARGET_DEVICE_NAME] = DmDialogManager::GetTargetDeviceName();
-    param[TAG_HOST_PKGLABEL] = DmDialogManager::GetHostPkgLabel();
+    param["isProxyBind"] = isProxyBind_;
+    param["appUserData"] = appUserData_;
+    param["title"] = title_;
+    param["pinCode"] = pinCode_;
+    param["deviceName"] = deviceName_;
+    param["appOperationStr"] = appOperationStr_;
+    param["customDescriptionStr"] = customDescriptionStr_;
+    param["deviceType"] = deviceType_;
+    param[TAG_TARGET_DEVICE_NAME] = targetDeviceName_;
+    param[TAG_HOST_PKGLABEL] = hostPkgLabel_;
     param["disableUpGesture"] = 1;
     std::string paramStr = param.Dump();
     data.WriteString16(Str8ToStr16(paramStr));
     LOGI("show dm dialog is begin");
-    const uint32_t cmdCode = 1;
-    int32_t ret = remoteObject->SendRequest(cmdCode, data, reply, option);
+    int32_t ret = remoteObject->SendRequest(SHOW_DIALOG_CMD_CODE, data, reply, option);
     if (ret != ERR_OK) {
         LOGE("show dm dialog is failed: %{public}d", ret);
         return;
     }
-    isConnectSystemUI_.store(true);
     LOGI("show dm dialog is success");
 }
 
-void DmDialogManager::DialogAbilityConnection::OnAbilityDisconnectDone(
-    const AppExecFwk::ElementName& element, int resultCode)
+void DmDialogManager::OnAbilityDisconnectDone(const AppExecFwk::ElementName& element, int resultCode)
 {
     LOGI("OnAbilityDisconnectDone");
     std::lock_guard<std::mutex> lock(mutex_);
     g_remoteObject = nullptr;
     isConnectSystemUI_.store(false);
+    isCloseDialog_.store(false);
+}
+
+void DmDialogManager::DialogAbilityConnection::OnAbilityConnectDone(
+    const AppExecFwk::ElementName& element, const sptr<IRemoteObject>& remoteObject, int resultCode)
+{
+    DmDialogManager::GetInstance().OnAbilityConnectDone(element, remoteObject, resultCode);
+}
+
+void DmDialogManager::DialogAbilityConnection::OnAbilityDisconnectDone(
+    const AppExecFwk::ElementName& element, int resultCode)
+{
+    DmDialogManager::GetInstance().OnAbilityDisconnectDone(element, resultCode);
 }
 }
 }
\ No newline at end of file
diff --git a/services/implementation/src/authentication/auth_ui_state_manager.cpp b/services/implementation/src/authentication/auth_ui_state_manager.cpp
index df081c5a3663f70feefe66759e9806b3c0798c3a..f234237946e6da2b6808d9e4e3fa346fdf5ca32d 100644
--- a/services/implementation/src/authentication/auth_ui_state_manager.cpp
+++ b/services/implementation/src/authentication/auth_ui_state_manager.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023 Huawei Device Co., Ltd.
+ * Copyright (c) 2023-2025 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -15,6 +15,7 @@
 
 #include "auth_ui_state_manager.h"
 #include "dm_anonymous.h"
+#include "dm_dialog_manager.h"
 #include "dm_log.h"
 #include "json_object.h"
 #if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
@@ -64,6 +65,15 @@ void AuthUiStateManager::UpdateUiState(const DmUiStateMsg msg)
     jsonObj[UI_STATE_MSG] = msg;
     std::string paramJson = jsonObj.Dump();
     std::lock_guard<std::mutex> lock(pkgSetMutex_);
+    if (pkgSet_.empty()) {
+        LOGW("pkgSet_ is empty");
+        if (msg == MSG_CANCEL_CONFIRM_SHOW) {
+            LOGW("cancel confirm dialog");
+            DmDialogManager::GetInstance().CloseDialog();
+            return;
+        }
+        return;
+    }
     for (auto item : pkgSet_) {
         listener_->OnUiCall(item, paramJson);
     }
diff --git a/services/implementation/src/authentication_v2/auth_stages/auth_confirm.cpp b/services/implementation/src/authentication_v2/auth_stages/auth_confirm.cpp
index 28ed7e71f357dfbdb0aeea4605c96c877d7cc9e8..c5fe661fd07e3a2911b82511e90ca0e0b9e0b6f8 100644
--- a/services/implementation/src/authentication_v2/auth_stages/auth_confirm.cpp
+++ b/services/implementation/src/authentication_v2/auth_stages/auth_confirm.cpp
@@ -650,7 +650,7 @@ void AuthSrcConfirmState::GenerateCertificate(std::shared_ptr<DmAuthContext> con
 
 int32_t AuthSrcConfirmState::Action(std::shared_ptr<DmAuthContext> context)
 {
-    LOGI("start.");
+    LOGI("AuthSrcConfirmState start.");
     CHECK_NULL_RETURN(context, ERR_DM_POINT_NULL);
     context->timer->DeleteTimer(std::string(NEGOTIATE_TIMEOUT_TASK));
     ResetBindLevel(context);
diff --git a/services/implementation/src/device_manager_service_impl.cpp b/services/implementation/src/device_manager_service_impl.cpp
index ec8fc15184d4b75ca5f55aa96861a84c048ba6d9..51a976963e901454e6c5e14e09be8d329ae51543 100644
--- a/services/implementation/src/device_manager_service_impl.cpp
+++ b/services/implementation/src/device_manager_service_impl.cpp
@@ -74,7 +74,11 @@ constexpr const char* NO_NEED_JOIN_LNN = "1";
 // currently, we just support one bind session in one device at same time
 constexpr size_t MAX_NEW_PROC_SESSION_COUNT_TEMP = 1;
 const int32_t USLEEP_TIME_US_500000 = 500000; // 500ms
+const int32_t USLEEP_TIME_US_550000 = 550000; // 550ms
+const int32_t USLEEP_TIME_US_20000 = 20000; // 20ms
 const int32_t OPEN_AUTH_SESSION_TIMEOUT = 15000; // 15000ms
+const int32_t MAX_TRY_STOP_CNT = 5;
+const int32_t DEFAULT_SESSION_ID = -1;
 
 const std::map<std::string, std::string> BUNDLENAME_MAPPING = {
     { "wear_link_service", "watch_system_service" }
@@ -160,7 +164,7 @@ static uint64_t GetTokenId(bool isSrcSide, int32_t displayId, std::string &bundl
     } else {
         // sink end
         int64_t tmpTokenId;
-         // get userId
+        // get userId
         int32_t targetUserId = AuthManagerBase::DmGetUserId(displayId);
         if (targetUserId == -1) {
             return tokenId;
@@ -234,7 +238,7 @@ void DeviceManagerServiceImpl::ImportAuthCodeToConfig(std::shared_ptr<AuthManage
 }
 
 int32_t DeviceManagerServiceImpl::InitNewProtocolAuthMgr(bool isSrcSide, uint64_t tokenId, uint64_t logicalSessionId,
-    const std::string &pkgName)
+    const std::string &pkgName, int sessionId)
 {
     LOGI("isSrcSide:%{public}d, tokenId: %{public}" PRIu64 ", logicalSesId: %{public}" PRIu64 ", pkgname:%{public}s",
         isSrcSide, tokenId, logicalSessionId, pkgName.c_str());
@@ -258,25 +262,24 @@ int32_t DeviceManagerServiceImpl::InitNewProtocolAuthMgr(bool isSrcSide, uint64_
     hiChainAuthConnector_->RegisterHiChainAuthCallbackById(logicalSessionId, authMgr);
     LOGI("Initialize authMgr token: %{public}" PRId64 ".", tokenId);
     ImportConfig(authMgr, tokenId, pkgName);
-    {
-        std::lock_guard<std::mutex> lock(authMgrMapMtx_);
-        authMgrMap_[tokenId] = authMgr;
-    }
-    return DM_OK;
+    return AddAuthMgr(tokenId, sessionId, authMgr);
 }
 
-int32_t DeviceManagerServiceImpl::InitOldProtocolAuthMgr(uint64_t tokenId, const std::string &pkgName)
+int32_t DeviceManagerServiceImpl::InitOldProtocolAuthMgr(uint64_t tokenId, const std::string &pkgName, int sessionId)
 {
     LOGI("tokenId: %{public}" PRIu64 ", pkgname:%{public}s", tokenId, pkgName.c_str());
-    if (authMgr_ == nullptr) {
-        CreateGlobalClassicalAuthMgr();
-    }
-    authMgr_->PrepareSoftbusSessionCallback();
     {
-        std::lock_guard<std::mutex> lock(authMgrMapMtx_);
-        authMgrMap_[tokenId] = authMgr_;
+        std::lock_guard<std::mutex> lock(authMgrMtx_);
+        if (authMgr_ == nullptr) {
+            CreateGlobalClassicalAuthMgr();
+        }
+        authMgr_->PrepareSoftbusSessionCallback();
+        ImportConfig(authMgr_, tokenId, pkgName);
+        int32_t ret = AddAuthMgr(tokenId, sessionId, authMgr_);
+        if (ret != DM_OK) {
+            return ret;
+        }
     }
-    ImportConfig(authMgr_, tokenId, pkgName);
     {
         // The value of logicalSessionId in the old protocol is always 0.
         std::lock_guard<std::mutex> tokenIdLock(logicalSessionId2TokenIdMapMtx_);
@@ -304,30 +307,20 @@ int32_t DeviceManagerServiceImpl::InitAndRegisterAuthMgr(bool isSrcSide, uint64_
             return ERR_DM_AUTH_BUSINESS_BUSY;
         }
     }
-    {
-        std::lock_guard<std::mutex> lock(authMgrMapMtx_);
-        if (authMgrMap_.find(tokenId) != authMgrMap_.end()) {
-            // authMgr_ has been created, indicating that a binding event already exists.
-            // Other requests are rejected, and an error code is returned.
-            LOGE("BindTarget failed, this device is being bound. Please try again later.");
-            return ERR_DM_AUTH_BUSINESS_BUSY;
-        }
-        if (authMgrMap_.size() > MAX_NEW_PROC_SESSION_COUNT_TEMP) {
-            LOGE("Other bind session exist, can not start new one.");
-            return ERR_DM_AUTH_BUSINESS_BUSY;
-        }
-    }
     if (session->version_ == "" || CompareVersion(session->version_, DM_VERSION_5_0_OLD_MAX)) {
-        return InitNewProtocolAuthMgr(isSrcSide, tokenId, logicalSessionId, pkgName);
+        return InitNewProtocolAuthMgr(isSrcSide, tokenId, logicalSessionId, pkgName, session->sessionId_);
     }
     LOGI("InitAndRegisterAuthMgr old authMgr.");
-    return InitOldProtocolAuthMgr(tokenId, pkgName);
+    return InitOldProtocolAuthMgr(tokenId, pkgName, session->sessionId_);
 }
 
-void DeviceManagerServiceImpl::CleanSessionMap(int sessionId, std::shared_ptr<Session> session)
+void DeviceManagerServiceImpl::CleanSessionMap(std::shared_ptr<Session> session)
 {
+    if (session == nullptr) {
+        return;
+    }
     session->logicalSessionCnt_.fetch_sub(1);
-    if (session->logicalSessionCnt_.load(std::memory_order_relaxed) == 0) {
+    if (session->logicalSessionCnt_.load(std::memory_order_relaxed) <= 0) {
         {
             std::lock_guard<std::mutex> lock(isNeedJoinLnnMtx_);
             if (isNeedJoinLnn_) {
@@ -335,18 +328,33 @@ void DeviceManagerServiceImpl::CleanSessionMap(int sessionId, std::shared_ptr<Se
             }
             isNeedJoinLnn_ = true;
         }
-        CHECK_NULL_VOID(softbusConnector_);
+        CleanSessionMap(session->sessionId_);
+    }
+}
+
+void DeviceManagerServiceImpl::CleanSessionMap(int sessionId)
+{
+    LOGI("In sessionId:%{public}d.", sessionId);
+    if (softbusConnector_ != nullptr) {
         softbusConnector_->GetSoftbusSession()->CloseAuthSession(sessionId);
+    }
+    {
         std::lock_guard<std::mutex> lock(mapMutex_);
+        std::shared_ptr<Session> session = nullptr;
         if (sessionsMap_.find(sessionId) != sessionsMap_.end()) {
-            sessionsMap_[sessionId] = nullptr;
+            session = sessionsMap_[sessionId];
             sessionsMap_.erase(sessionId);
         }
-        if (deviceId2SessionIdMap_.find(session->deviceId_) != deviceId2SessionIdMap_.end()) {
+        if (session != nullptr && deviceId2SessionIdMap_.find(session->deviceId_) != deviceId2SessionIdMap_.end()) {
             deviceId2SessionIdMap_.erase(session->deviceId_);
         }
+        if (sessionEnableMutexMap_.find(sessionId) != sessionEnableMutexMap_.end()) {
+            sessionStopMap_.erase(sessionId);
+            sessionEnableMap_.erase(sessionId);
+            sessionEnableCvReadyMap_.erase(sessionId);
+            sessionEnableMutexMap_.erase(sessionId);
+        }
     }
-    return;
 }
 
 void DeviceManagerServiceImpl::CleanSessionMapByLogicalSessionId(uint64_t logicalSessionId)
@@ -366,7 +374,7 @@ void DeviceManagerServiceImpl::CleanSessionMapByLogicalSessionId(uint64_t logica
     }
     auto session = GetCurSession(sessionId);
     if (session != nullptr) {
-        CleanSessionMap(sessionId, session);
+        CleanSessionMap(session);
     }
     return;
 }
@@ -390,28 +398,60 @@ void DeviceManagerServiceImpl::CleanAuthMgrByLogicalSessionId(uint64_t logicalSe
         authMgr_->ClearSoftbusSessionCallback();
     }
     hiChainAuthConnector_->UnRegisterHiChainAuthCallbackById(logicalSessionId);
+    EraseAuthMgr(tokenId);
+    return;
+}
+
+std::shared_ptr<AuthManagerBase> DeviceManagerServiceImpl::GetAuthMgr()
+{
+    uint64_t tokenId = IPCSkeleton::GetCallingTokenID();
+    return GetAuthMgrByTokenId(tokenId);
+}
+
+int32_t DeviceManagerServiceImpl::AddAuthMgr(uint64_t tokenId, int sessionId, std::shared_ptr<AuthManagerBase> authMgr)
+{
+    if (authMgr == nullptr) {
+        LOGE("authMgr is nullptr.");
+        return ERR_DM_POINT_NULL;
+    }
+    {
+        std::lock_guard<std::mutex> mapLock(mapMutex_);
+        if (sessionEnableMap_.find(sessionId) != sessionEnableMap_.end() && !sessionEnableMap_[sessionId]) {
+            LOGE("session is not open, no need add authMgr.");
+            return ERR_DM_AUTH_OPEN_SESSION_FAILED;
+        }
+    }
     {
         std::lock_guard<std::mutex> lock(authMgrMapMtx_);
-        if (authMgrMap_.find(tokenId) != authMgrMap_.end()) {
-            authMgrMap_[tokenId] = nullptr;
-            authMgrMap_.erase(tokenId);
+        if (authMgrMap_.size() > MAX_NEW_PROC_SESSION_COUNT_TEMP) {
+            LOGE("Other bind session exist, can not start new one. authMgrMap_.size:%{public}zu", authMgrMap_.size());
+            return ERR_DM_AUTH_BUSINESS_BUSY;
         }
+        authMgrMap_[tokenId] = authMgr;
     }
-    return;
+    {
+        std::lock_guard<std::mutex> mapLock(tokenIdSessionIdMapMtx_);
+        if (tokenIdSessionIdMap_.find(tokenId) == tokenIdSessionIdMap_.end()) {
+            tokenIdSessionIdMap_[tokenId] = sessionId;
+        }
+    }
+    return DM_OK;
 }
 
-std::shared_ptr<AuthManagerBase> DeviceManagerServiceImpl::GetAuthMgr()
+void DeviceManagerServiceImpl::EraseAuthMgr(uint64_t tokenId)
 {
-    uint64_t tokenId = IPCSkeleton::GetCallingTokenID();
     {
         std::lock_guard<std::mutex> lock(authMgrMapMtx_);
         if (authMgrMap_.find(tokenId) != authMgrMap_.end()) {
-            LOGI("authMgrMap_ token: %{public}" PRId64 ".", tokenId);
-            return authMgrMap_[tokenId];
+            LOGI("authMgrMap_ erase token: %{public}" PRIu64 ".", tokenId);
+            authMgrMap_.erase(tokenId);
         }
     }
-    LOGE("authMgrMap_ not found, token: %{public}" PRId64 ".", tokenId);
-    return nullptr;
+    {
+        std::lock_guard<std::mutex> lock(tokenIdSessionIdMapMtx_);
+        LOGI("tokenIdSessionIdMap_ erase token: %{public}" PRIu64 ".", tokenId);
+        tokenIdSessionIdMap_.erase(tokenId);
+    }
 }
 
 // Needed in the callback function
@@ -420,11 +460,11 @@ std::shared_ptr<AuthManagerBase> DeviceManagerServiceImpl::GetAuthMgrByTokenId(u
     {
         std::lock_guard<std::mutex> lock(authMgrMapMtx_);
         if (authMgrMap_.find(tokenId) != authMgrMap_.end()) {
-            LOGI("authMgrMap_ token: %{public}" PRId64 ".", tokenId);
+            LOGI("authMgrMap_ token: %{public}" PRIu64 ".", tokenId);
             return authMgrMap_[tokenId];
         }
     }
-    LOGE("authMgrMap_ not found, token: %{public}" PRId64 ".", tokenId);
+    LOGE("authMgrMap_ not found, token: %{public}" PRIu64 ".", tokenId);
     return nullptr;
 }
 
@@ -525,9 +565,11 @@ void DeviceManagerServiceImpl::ReleaseMaps()
         configsMap_.clear();
     }
     deviceId2SessionIdMap_.clear();
-    deviceIdMutexMap_.clear();
     sessionEnableMutexMap_.clear();
     sessionEnableCvMap_.clear();
+    sessionStopMap_.clear();
+    sessionEnableMap_.clear();
+    sessionEnableCvReadyMap_.clear();
     {
         std::lock_guard<std::mutex> tokenIdLock(logicalSessionId2TokenIdMapMtx_);
         logicalSessionId2TokenIdMap_.clear();
@@ -593,12 +635,50 @@ int32_t DeviceManagerServiceImpl::StopAuthenticateDevice(const std::string &pkgN
         LOGE("DeviceManagerServiceImpl::StopAuthenticateDevice failed");
         return ERR_DM_INPUT_PARA_INVALID;
     }
-    auto authMgr = GetAuthMgr();
-    if (authMgr == nullptr) {
-        LOGE("authMgr is nullptr");
-        return ERR_DM_POINT_NULL;
+    uint64_t tokenId = IPCSkeleton::GetCallingTokenID();
+    int32_t sessionId = DEFAULT_SESSION_ID;
+    int32_t tryCnt = 0;
+    while (tryCnt < MAX_TRY_STOP_CNT) {
+        {
+            std::lock_guard<std::mutex> lock(tokenIdSessionIdMapMtx_);
+            if (tokenIdSessionIdMap_.find(tokenId) == tokenIdSessionIdMap_.end()) {
+                LOGI("sessionId not create, pkgName:%{public}s, tokenId:%{public}" PRIu64, pkgName.c_str(), tokenId);
+                return DM_OK;
+            }
+            sessionId = tokenIdSessionIdMap_[tokenId];
+        }
+        if (sessionId > 0) {
+            break;
+        }
+        usleep(USLEEP_TIME_US_20000);
+        tryCnt++;
+    }
+    if (sessionId == DEFAULT_SESSION_ID) {
+        LOGE("sessionId is creating, pkgName:%{public}s, tokenId:%{public}" PRIu64, pkgName.c_str(), tokenId);
+        return ERR_DM_AUTH_BUSINESS_BUSY;
+    }
+    LOGI("pkgName:%{public}s, sessionId:%{public}d, tokenId:%{public}" PRIu64, pkgName.c_str(), sessionId, tokenId);
+    if (sessionEnableCvMap_.find(sessionId) != sessionEnableCvMap_.end()) {
+        std::unique_lock<std::mutex> cvLock(sessionEnableMutexMap_[sessionId]);
+        if (sessionEnableMap_.find(sessionId) != sessionEnableMap_.end() && !sessionEnableMap_[sessionId]) {
+            sessionStopMap_[sessionId] = true;
+        }
+        sessionEnableCvReadyMap_[sessionId] = true;
+        sessionEnableCvMap_[sessionId].notify_all();
+        LOGI("notify_all by stop, sessionId:%{public}d, tokenId:%{public}" PRIu64, sessionId, tokenId);
+    }
+    auto authMgr = GetAuthMgrByTokenId(tokenId);
+    int32_t ret = DM_OK;
+    if (authMgr != nullptr) {
+        ret = authMgr->StopAuthenticateDevice(pkgName);
+        if (ret == DM_OK) {
+            usleep(USLEEP_TIME_US_550000);
+        }
+    } else {
+        CleanSessionMap(sessionId);
     }
-    return authMgr->StopAuthenticateDevice(pkgName);
+    EraseAuthMgr(tokenId);
+    return ret;
 }
 
 int32_t DeviceManagerServiceImpl::UnBindDevice(const std::string &pkgName, const std::string &udid,
@@ -839,10 +919,16 @@ std::string DeviceManagerServiceImpl::GetUdidHashByNetworkId(const std::string &
 
 int DeviceManagerServiceImpl::OnSessionOpened(int sessionId, int result)
 {
-    {
+    bool isNeedCloseSession = false;
+    if (sessionEnableCvMap_.find(sessionId) != sessionEnableCvMap_.end()) {
         std::lock_guard<std::mutex> lock(sessionEnableMutexMap_[sessionId]);
         if (result == 0) {
-            LOGE("OnSessionOpened successful, sessionId: %{public}d", sessionId);
+            LOGI("OnSessionOpened successful, sessionId: %{public}d", sessionId);
+            if (sessionStopMap_.find(sessionId) != sessionStopMap_.end() && sessionStopMap_[sessionId]) {
+                isNeedCloseSession = true;
+            } else {
+                sessionEnableMap_[sessionId] = true;
+            }
         } else {
             LOGE("OnSessionOpened failed, sessionId: %{public}d, res: %{public}d", sessionId, result);
         }
@@ -861,7 +947,10 @@ int DeviceManagerServiceImpl::OnSessionOpened(int sessionId, int result)
     if (!DmRadarHelper::GetInstance().ReportAuthSessionOpenCb(info)) {
         LOGE("ReportAuthSessionOpenCb failed");
     }
-
+    if (isNeedCloseSession) {
+        CleanSessionMap(sessionId);
+        return DM_OK;
+    }
     // Get the remote deviceId, sink end gives sessionsMap[deviceId] = session;
     {
         std::lock_guard<std::mutex> lock(mapMutex_);
@@ -991,10 +1080,7 @@ int32_t DeviceManagerServiceImpl::TransferSrcOldAuthMgr(std::shared_ptr<Session>
     int32_t authType = -1;
     authMgr->ParseAuthType(bindParam, authType);
     ImportAuthCodeToConfig(authMgr, tokenId);
-    {
-        std::lock_guard<std::mutex> lock(authMgrMapMtx_);
-        authMgrMap_.erase(tokenId);
-    }
+    EraseAuthMgr(tokenId);
     if (InitAndRegisterAuthMgr(true, tokenId, curSession, logicalSessionId, "") != DM_OK) {
         return ERR_DM_AUTH_FAILED;
     }
@@ -1544,56 +1630,54 @@ int DeviceManagerServiceImpl::OpenAuthSession(const std::string& deviceId,
 }
 
 std::shared_ptr<Session> DeviceManagerServiceImpl::GetOrCreateSession(const std::string& deviceId,
-    const std::map<std::string, std::string> &bindParam)
+    const std::map<std::string, std::string> &bindParam, uint64_t tokenId)
 {
     std::shared_ptr<Session> instance;
     int sessionId = -1;
-    // Acquire global lock to ensure thread safety for maps
-    {
-        std::lock_guard<std::mutex> lock(mapMutex_);
-        if (deviceId2SessionIdMap_.find(deviceId) != deviceId2SessionIdMap_.end()) {
-            sessionId = deviceId2SessionIdMap_[deviceId];
-        }
-        if (sessionsMap_.find(sessionId) != sessionsMap_.end()) {
-            return sessionsMap_[sessionId];
-        }
-    }
-
-    // Get the lock corresponding to deviceId
-    std::mutex& device_mutex = deviceIdMutexMap_[deviceId];
-    std::lock_guard<std::mutex> lock(device_mutex);
 
     // Check again whether the corresponding object already exists (because other threads may have created it during
     //  the lock acquisition in the previous step)
-    {
-        std::lock_guard<std::mutex> lock(mapMutex_);
-        if (deviceId2SessionIdMap_.find(deviceId) != deviceId2SessionIdMap_.end()) {
-            sessionId = deviceId2SessionIdMap_[deviceId];
-        }
-        if (sessionsMap_.find(sessionId) != sessionsMap_.end()) {
-            return sessionsMap_[sessionId];
-        }
 
-        sessionId = OpenAuthSession(deviceId, bindParam);
-        if (sessionId < 0) {
-            LOGE("OpenAuthSession failed, stop the authentication");
-            return nullptr;
-        }
+    std::lock_guard<std::mutex> lock(mapMutex_);
+    if (deviceId2SessionIdMap_.find(deviceId) != deviceId2SessionIdMap_.end()) {
+        sessionId = deviceId2SessionIdMap_[deviceId];
+    }
+    if (sessionsMap_.find(sessionId) != sessionsMap_.end()) {
+        return sessionsMap_[sessionId];
+    }
 
-        std::unique_lock<std::mutex> cvLock(sessionEnableMutexMap_[sessionId]);
-        sessionEnableCvReadyMap_[sessionId] = false;
-        if (sessionEnableCvMap_[sessionId].wait_for(cvLock, std::chrono::milliseconds(OPEN_AUTH_SESSION_TIMEOUT),
-            [&] { return sessionEnableCvReadyMap_[sessionId]; })) {
-            LOGI("session enable, sessionId: %{public}d.", sessionId);
-        } else {
-            LOGE("wait session enable timeout or enable fail, sessionId: %{public}d.", sessionId);
-            return nullptr;
-        }
-        sessionEnableCvReadyMap_.erase(sessionId);
-        instance = std::make_shared<Session>(sessionId, deviceId);
-        deviceId2SessionIdMap_[deviceId] = sessionId;
-        sessionsMap_[sessionId] = instance;
+    sessionId = OpenAuthSession(deviceId, bindParam);
+    if (sessionId < 0) {
+        LOGE("OpenAuthSession failed, stop the authentication");
+        return nullptr;
     }
+
+    {
+        std::lock_guard<std::mutex> lock(tokenIdSessionIdMapMtx_);
+        tokenIdSessionIdMap_[tokenId] = sessionId;
+    }
+
+    std::unique_lock<std::mutex> cvLock(sessionEnableMutexMap_[sessionId]);
+    sessionEnableCvReadyMap_[sessionId] = false;
+    sessionStopMap_[sessionId] = false;
+    sessionEnableMap_[sessionId] = false;
+    if (!sessionEnableCvMap_[sessionId].wait_for(cvLock, std::chrono::milliseconds(OPEN_AUTH_SESSION_TIMEOUT),
+        [&] { return sessionEnableCvReadyMap_[sessionId]; })) {
+        LOGE("wait session enable timeout or enable fail, sessionId: %{public}d.", sessionId);
+        return nullptr;
+    }
+    if (sessionStopMap_.find(sessionId) != sessionStopMap_.end() && sessionStopMap_[sessionId]) {
+        LOGW("stop by caller, sessionId: %{public}d.", sessionId);
+        return nullptr;
+    }
+    if (sessionEnableMap_.find(sessionId) != sessionEnableMap_.end() && !sessionEnableMap_[sessionId]) {
+        LOGW("Open session failed, sessionId: %{public}d.", sessionId);
+        return nullptr;
+    }
+    instance = std::make_shared<Session>(sessionId, deviceId);
+    deviceId2SessionIdMap_[deviceId] = sessionId;
+    sessionsMap_[sessionId] = instance;
+
     return instance;
 }
 
@@ -1714,9 +1798,9 @@ void DeviceManagerServiceImpl::SaveTokenIdAndSessionId(uint64_t &tokenId,
     }
 }
 
-bool DeviceManagerServiceImpl::ParseConnectAddrAndSetProcessInfo(const PeerTargetId &targetId,
-    PeerTargetId &targetIdTmp, const std::map<std::string, std::string> &bindParam, ProcessInfo &processInfo,
-    const std::string &pkgName)
+bool DeviceManagerServiceImpl::ParseConnectAddrAndSetProcessInfo(PeerTargetId &targetId,
+    const std::map<std::string, std::string> &bindParam, ProcessInfo &processInfo,
+    const std::string &pkgName, uint64_t tokenId)
 {
     processInfo.pkgName = pkgName;
     if (bindParam.count(BIND_CALLER_USERID) != 0) {
@@ -1724,11 +1808,11 @@ bool DeviceManagerServiceImpl::ParseConnectAddrAndSetProcessInfo(const PeerTarge
     }
     std::string deviceId = "";
     if (ParseConnectAddr(targetId, deviceId, bindParam) == DM_OK) {
-        targetIdTmp.deviceId = deviceId;
+        targetId.deviceId = deviceId;
     } else {
         if (targetId.deviceId.empty()) {
             LOGE("DeviceManagerServiceImpl::BindTarget failed, ParseConnectAddr failed.");
-            OnAuthResultAndOnBindResult(processInfo, targetId, targetId.deviceId, ERR_DM_INPUT_PARA_INVALID);
+            OnAuthResultAndOnBindResult(processInfo, targetId, "", ERR_DM_INPUT_PARA_INVALID, tokenId);
             return false;
         }
     }
@@ -1736,8 +1820,15 @@ bool DeviceManagerServiceImpl::ParseConnectAddrAndSetProcessInfo(const PeerTarge
 }
 
 void DeviceManagerServiceImpl::OnAuthResultAndOnBindResult(const ProcessInfo &processInfo, const PeerTargetId &targetId,
-    const std::string &deviceId, int32_t reason)
+    const std::string &deviceId, int32_t reason, uint64_t tokenId)
 {
+    {
+        std::lock_guard<std::mutex> lock(tokenIdSessionIdMapMtx_);
+        auto iter = tokenIdSessionIdMap_.find(tokenId);
+        if (iter != tokenIdSessionIdMap_.end()) {
+            tokenIdSessionIdMap_.erase(iter);
+        }
+    }
     CHECK_NULL_VOID(listener_);
     listener_->OnAuthResult(processInfo, deviceId, "", DmAuthStatus::STATUS_DM_AUTH_DEFAULT, reason);
     listener_->OnBindResult(processInfo, targetId, reason, DmAuthStatus::STATUS_DM_AUTH_DEFAULT, "");
@@ -1748,15 +1839,14 @@ void DeviceManagerServiceImpl::BindTargetImpl(uint64_t tokenId, const std::strin
 {
     PeerTargetId targetIdTmp = const_cast<PeerTargetId&>(targetId);
     ProcessInfo processInfo;
-    if (!ParseConnectAddrAndSetProcessInfo(targetId, targetIdTmp, bindParam, processInfo, pkgName)) {
+    if (!ParseConnectAddrAndSetProcessInfo(targetIdTmp, bindParam, processInfo, pkgName, tokenId)) {
         return;
     }
     // Created only at the source end. The same target device will not be created repeatedly with the new protocol.
-    std::shared_ptr<Session> curSession = GetOrCreateSession(targetIdTmp.deviceId, bindParam);
+    std::shared_ptr<Session> curSession = GetOrCreateSession(targetIdTmp.deviceId, bindParam, tokenId);
     if (curSession == nullptr) {
-        LOGE("Failed to create the session. Target deviceId: %{public}s.",
-            GetAnonyString(targetIdTmp.deviceId).c_str());
-        OnAuthResultAndOnBindResult(processInfo, targetId, targetIdTmp.deviceId, ERR_DM_TIME_OUT);
+        LOGE("create session failed. Target deviceId: %{public}s.", GetAnonyString(targetIdTmp.deviceId).c_str());
+        OnAuthResultAndOnBindResult(processInfo, targetId, targetIdTmp.deviceId, ERR_DM_TIME_OUT, tokenId);
         return;
     }
 
@@ -1767,8 +1857,9 @@ void DeviceManagerServiceImpl::BindTargetImpl(uint64_t tokenId, const std::strin
         logicalSessionId = GenerateRandNum(sessionId);
         if (curSession->logicalSessionSet_.find(logicalSessionId) != curSession->logicalSessionSet_.end()) {
             LOGE("Failed to create the logical session.");
-            softbusConnector_->GetSoftbusSession()->CloseAuthSession(sessionId);
-            OnAuthResultAndOnBindResult(processInfo, targetId, targetIdTmp.deviceId, ERR_DM_INPUT_PARA_INVALID);
+            CleanSessionMap(sessionId);
+            OnAuthResultAndOnBindResult(processInfo, targetId, targetIdTmp.deviceId,
+                ERR_DM_INPUT_PARA_INVALID, tokenId);
             return;
         }
     }
@@ -1777,8 +1868,8 @@ void DeviceManagerServiceImpl::BindTargetImpl(uint64_t tokenId, const std::strin
     int32_t ret = InitAndRegisterAuthMgr(true, tokenId, curSession, logicalSessionId, "");
     if (ret != DM_OK) {
         LOGE("InitAndRegisterAuthMgr failed, ret %{public}d.", ret);
-        softbusConnector_->GetSoftbusSession()->CloseAuthSession(sessionId);
-        OnAuthResultAndOnBindResult(processInfo, targetId, targetIdTmp.deviceId, ret);
+        CleanSessionMap(sessionId);
+        OnAuthResultAndOnBindResult(processInfo, targetId, targetIdTmp.deviceId, ret, tokenId);
         return;
     }
     curSession->logicalSessionSet_.insert(logicalSessionId);
@@ -1787,16 +1878,16 @@ void DeviceManagerServiceImpl::BindTargetImpl(uint64_t tokenId, const std::strin
     auto authMgr = GetAuthMgrByTokenId(tokenId);
     if (authMgr == nullptr) {
         CleanAuthMgrByLogicalSessionId(logicalSessionId);
-        OnAuthResultAndOnBindResult(processInfo, targetId, targetIdTmp.deviceId, ERR_DM_POINT_NULL);
+        OnAuthResultAndOnBindResult(processInfo, targetId, targetIdTmp.deviceId, ERR_DM_POINT_NULL, tokenId);
         return;
     }
     authMgr->SetBindTargetParams(targetId);
     if ((ret = authMgr->BindTarget(pkgName, targetIdTmp, bindParam, sessionId, logicalSessionId)) != DM_OK) {
         LOGE("authMgr BindTarget failed, ret %{public}d.", ret);
         CleanAuthMgrByLogicalSessionId(logicalSessionId);
-        OnAuthResultAndOnBindResult(processInfo, targetId, targetIdTmp.deviceId, ret);
+        OnAuthResultAndOnBindResult(processInfo, targetId, targetIdTmp.deviceId, ret, tokenId);
     }
-    LOGI("end, tokenId %{public}" PRId64".", tokenId);
+    LOGI("end, tokenId %{public}" PRIu64".", tokenId);
     return;
 }
 
@@ -1812,12 +1903,19 @@ int32_t DeviceManagerServiceImpl::BindTarget(const std::string &pkgName, const P
     std::map<std::string, std::string> bindParamTmp;
     SetBindCallerInfoToBindParam(bindParam, bindParamTmp, bindCallerInfo);
     uint64_t tokenId = IPCSkeleton::GetCallingTokenID();
+    LOGI("DeviceManagerServiceImpl In, pkgName:%{public}s, tokenId:%{public}" PRIu64, pkgName.c_str(), tokenId);
     {
-        std::lock_guard<std::mutex> lock(authMgrMapMtx_);
-        if (authMgrMap_.find(tokenId) != authMgrMap_.end()) {
-            LOGE("BindTarget failed, this device is being bound. please try again later.");
+        std::lock_guard<std::mutex> lock(tokenIdSessionIdMapMtx_);
+        if (tokenIdSessionIdMap_.find(tokenId) != tokenIdSessionIdMap_.end()) {
+            LOGE("BindTarget failed, this device is being bound. please try again later,"
+                "pkgName:%{public}s, tokenId:%{public}" PRIu64, pkgName.c_str(), tokenId);
+            return ERR_DM_AUTH_BUSINESS_BUSY;
+        }
+        if (tokenIdSessionIdMap_.size() > MAX_NEW_PROC_SESSION_COUNT_TEMP) {
+            LOGE("Other bind exist, can not start new one. size:%{public}zu", tokenIdSessionIdMap_.size());
             return ERR_DM_AUTH_BUSINESS_BUSY;
         }
+        tokenIdSessionIdMap_[tokenId] = DEFAULT_SESSION_ID;
     }
     std::thread newThread(&DeviceManagerServiceImpl::BindTargetImpl, this, tokenId, pkgName, targetId, bindParamTmp);
     newThread.detach();
@@ -2986,6 +3084,7 @@ void DeviceManagerServiceImpl::GetBindCallerInfo(DmBindCallerInfo &bindCallerInf
         bindLevel = static_cast<int32_t>(DmRole::DM_ROLE_FA);
     }
     if (AppManager::GetInstance().IsSystemSA()) {
+        isSystemSA = true;
         bindLevel = static_cast<int32_t>(DmRole::DM_ROLE_SA);
     }
     if (AuthManagerBase::CheckProcessNameInWhiteList(bundleName)) {
diff --git a/test/unittest/UTTest_device_manager_service_impl.cpp b/test/unittest/UTTest_device_manager_service_impl.cpp
index 992779122679e4ba3b18b6bfcc547fdc935e0004..3c1e0aed2233392ac63cfa4585c80afa7b0861a9 100644
--- a/test/unittest/UTTest_device_manager_service_impl.cpp
+++ b/test/unittest/UTTest_device_manager_service_impl.cpp
@@ -1636,8 +1636,9 @@ HWTEST_F(DeviceManagerServiceImplTest, StopAuthenticateDevice_102, testing::ext:
     if (deviceManagerServiceImpl_->authMgr_ == nullptr) {
         deviceManagerServiceImpl_->Initialize(listener_);
     }
+    deviceManagerServiceImpl_->tokenIdSessionIdMap_.clear();
     int ret = deviceManagerServiceImpl_->StopAuthenticateDevice(pkgName);
-    EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    EXPECT_EQ(ret, DM_OK);
 }
 
 HWTEST_F(DeviceManagerServiceImplTest, CheckIsSameAccount_001, testing::ext::TestSize.Level1)
@@ -2106,26 +2107,93 @@ HWTEST_F(DeviceManagerServiceImplTest, InitNewProtocolAuthMgr_001, testing::ext:
     bool isSrcSide = true;
     uint64_t tokenId = 1000023;
     uint64_t logicalSessionId = 456789;
+    int sessionId = 1;
     const std::string pkgName = "InitNewProtocolAuthMgr";
-    int32_t ret = deviceManagerServiceImpl_->InitNewProtocolAuthMgr(isSrcSide, tokenId, logicalSessionId, pkgName);
+    int32_t ret = deviceManagerServiceImpl_->InitNewProtocolAuthMgr(isSrcSide, tokenId, logicalSessionId, pkgName,
+        sessionId);
     EXPECT_EQ(ret, DM_OK);
 
     isSrcSide = false;
-    ret = deviceManagerServiceImpl_->InitNewProtocolAuthMgr(isSrcSide, tokenId, logicalSessionId, pkgName);
+    ret = deviceManagerServiceImpl_->InitNewProtocolAuthMgr(isSrcSide, tokenId, logicalSessionId, pkgName, sessionId);
     EXPECT_EQ(ret, DM_OK);
 }
 
 HWTEST_F(DeviceManagerServiceImplTest, InitOldProtocolAuthMgr_001, testing::ext::TestSize.Level1)
 {
     uint64_t tokenId = 100002311;
+    int sessionId = 1;
     const std::string pkgName = "InitOldProtocolAuthMgr";
-    int32_t ret = deviceManagerServiceImpl_->InitOldProtocolAuthMgr(tokenId, pkgName);
+    int32_t ret = deviceManagerServiceImpl_->InitOldProtocolAuthMgr(tokenId, pkgName, sessionId);
     EXPECT_EQ(ret, DM_OK);
 
     deviceManagerServiceImpl_->authMgr_ = nullptr;
-    ret = deviceManagerServiceImpl_->InitOldProtocolAuthMgr(tokenId, pkgName);
+    ret = deviceManagerServiceImpl_->InitOldProtocolAuthMgr(tokenId, pkgName, sessionId);
     EXPECT_EQ(ret, DM_OK);
 }
+
+HWTEST_F(DeviceManagerServiceImplTest, CleanSessionMap_001, testing::ext::TestSize.Level1)
+{
+    int sessionId = 0;
+    std::string deviceId = "deviceId";
+    deviceManagerServiceImpl_->CleanSessionMap(nullptr);
+    std::shared_ptr<Session> session = std::make_shared<Session>(sessionId, deviceId);
+    session->logicalSessionCnt_.fetch_add(1);
+    deviceManagerServiceImpl_->CleanSessionMap(session);
+    EXPECT_EQ(session->logicalSessionCnt_.load(), 0);
+}
+
+HWTEST_F(DeviceManagerServiceImplTest, CleanSessionMap_002, testing::ext::TestSize.Level1)
+{
+    int sessionId = 0;
+    deviceManagerServiceImpl_->softbusConnector_ = nullptr;
+    deviceManagerServiceImpl_->CleanSessionMap(sessionId);
+    if (deviceManagerServiceImpl_->softbusConnector_ == nullptr) {
+        deviceManagerServiceImpl_->Initialize(listener_);
+    }
+    deviceManagerServiceImpl_->sessionsMap_.clear();
+    deviceManagerServiceImpl_->CleanSessionMap(sessionId);
+    std::string deviceId = "deviceId";
+    std::shared_ptr<Session> session = std::make_shared<Session>(sessionId, deviceId);
+    deviceManagerServiceImpl_->sessionsMap_[sessionId] = session;
+    deviceManagerServiceImpl_->CleanSessionMap(sessionId);
+    EXPECT_TRUE(deviceManagerServiceImpl_->sessionsMap_.empty());
+}
+
+HWTEST_F(DeviceManagerServiceImplTest, AddAuthMgr_001, testing::ext::TestSize.Level1)
+{
+    uint64_t tokenId = 0;
+    int sessionId = 1;
+    deviceManagerServiceImpl_->authMgrMap_.clear();
+    deviceManagerServiceImpl_->AddAuthMgr(tokenId, sessionId, nullptr);
+    EXPECT_TRUE(deviceManagerServiceImpl_->authMgrMap_.empty());
+
+    if (deviceManagerServiceImpl_->softbusConnector_ == nullptr) {
+        deviceManagerServiceImpl_->Initialize(listener_);
+    }
+    std::shared_ptr<AuthManagerBase> authMgr = std::make_shared<AuthSrcManager>(
+        deviceManagerServiceImpl_->softbusConnector_, deviceManagerServiceImpl_->hiChainConnector_,
+        deviceManagerServiceImpl_->listener_, deviceManagerServiceImpl_->hiChainAuthConnector_);
+    deviceManagerServiceImpl_->sessionEnableMap_[sessionId] = false;
+    deviceManagerServiceImpl_->AddAuthMgr(tokenId, sessionId, authMgr);
+    EXPECT_TRUE(deviceManagerServiceImpl_->authMgrMap_.empty());
+
+    deviceManagerServiceImpl_->sessionEnableMap_.clear();
+    deviceManagerServiceImpl_->AddAuthMgr(tokenId, sessionId, authMgr);
+    EXPECT_FALSE(deviceManagerServiceImpl_->authMgrMap_.empty());
+    deviceManagerServiceImpl_->sessionEnableMap_.clear();
+    deviceManagerServiceImpl_->authMgrMap_.clear();
+}
+
+HWTEST_F(DeviceManagerServiceImplTest, EraseAuthMgr_001, testing::ext::TestSize.Level1)
+{
+    uint64_t tokenId = 0;
+    std::shared_ptr<AuthManagerBase> authMgr = std::make_shared<AuthSrcManager>(
+        deviceManagerServiceImpl_->softbusConnector_, deviceManagerServiceImpl_->hiChainConnector_,
+        deviceManagerServiceImpl_->listener_, deviceManagerServiceImpl_->hiChainAuthConnector_);
+    deviceManagerServiceImpl_->authMgrMap_[tokenId] = authMgr;
+    deviceManagerServiceImpl_->EraseAuthMgr(tokenId);
+    EXPECT_TRUE(deviceManagerServiceImpl_->authMgrMap_.find(tokenId) == deviceManagerServiceImpl_->authMgrMap_.end());
+}
 } // namespace
 } // namespace DistributedHardware
 } // namespace OHOS