diff --git a/common/include/dm_anonymous.h b/common/include/dm_anonymous.h
index 46a5734f61456deaeca84c57d203805a9f8d8ad2..f6ba0fdd8172e1c08a518af7bbc5c31fe7599e2f 100644
--- a/common/include/dm_anonymous.h
+++ b/common/include/dm_anonymous.h
@@ -107,6 +107,7 @@ DM_EXPORT std::string SafetyDump(const JsonItemObject &jsonObj);
 std::string GetSubStr(const std::string &rawStr, const std::string &separator, int32_t index);
 bool IsJsonValIntegerString(const JsonItemObject &jsonObj, const std::string &key);
 std::string GetAnonyJsonString(const std::string &value);
+int64_t GetCurrentTimestamp();
 } // namespace DistributedHardware
 } // namespace OHOS
 #endif // OHOS_DM_ANONYMOUS_H
diff --git a/common/include/dm_constants.h b/common/include/dm_constants.h
index 98484ad0627c505c543db6de4afe33da0adc2a36..ef25722710182c6ee9332e4fb2c8251e8b96ad28 100755
--- a/common/include/dm_constants.h
+++ b/common/include/dm_constants.h
@@ -159,6 +159,8 @@ DM_EXPORT extern const char* CONN_SESSION_TYPE_HML;
 DM_EXPORT extern const char* CONN_SESSION_TYPE_BLE;
 DM_EXPORT extern const char* UN_BIND_PARAM_UDID_KEY;
 
+DM_EXPORT extern const char* DM_BUSINESS_ID;
+
 // screen state
 enum ScreenState {
     DM_SCREEN_UNKNOWN = -1,
diff --git a/common/include/dm_error_type.h b/common/include/dm_error_type.h
index b0a386431a1b39abe311f988febdb929304ea097..e06815c3ca4e5ac02f8e9e07dd58a9a928878de2 100644
--- a/common/include/dm_error_type.h
+++ b/common/include/dm_error_type.h
@@ -142,6 +142,7 @@ enum {
     ERR_DM_GET_BUNDLE_NAME_FAILED = 969298354,
     ERR_DM_DEVICE_FROZEN = 969298355,
     ERR_DM_SOCKET_IN_USED = 969298356,
+	ERR_DM_ANTI_DISTURB_MODE = 969298357,
 };
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/common/src/dm_anonymous.cpp b/common/src/dm_anonymous.cpp
index 57edca138b185da9f1ca5af21277e6e6129b6c6f..69b50d5cc8a0cd625b1935df2a6dfb1db7c1dd49 100644
--- a/common/src/dm_anonymous.cpp
+++ b/common/src/dm_anonymous.cpp
@@ -459,5 +459,12 @@ std::string GetAnonyJsonString(const std::string &value)
     }
     return paramJson.Dump();
 }
+
+int64_t GetCurrentTimestamp()
+{
+    auto now = std::chrono::system_clock::now();
+    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch());
+    return duration.count();
+}
 } // namespace DistributedHardware
 } // namespace OHOS
\ No newline at end of file
diff --git a/common/src/dm_constants.cpp b/common/src/dm_constants.cpp
index f70b2272f119edc1426aba9e585d6932cbf06284..fe35b8f0fee1baa87e9337d018765a40e8266b01 100644
--- a/common/src/dm_constants.cpp
+++ b/common/src/dm_constants.cpp
@@ -149,6 +149,8 @@ const char* CONN_SESSION_TYPE_HML = "HML";
 const char* CONN_SESSION_TYPE_BLE = "BLE";
 const char* UN_BIND_PARAM_UDID_KEY = "udidKey";
 
+const char* DM_BUSINESS_ID = "business_id";
+
 // errCode map
 const std::map<int32_t, int32_t> MAP_ERROR_CODE = {
     { ERR_DM_TIME_OUT, 96929745 }, { ERR_DM_UNSUPPORTED_AUTH_TYPE, 96929760 }, { ERR_DM_AUTH_BUSINESS_BUSY, 96929761 },
diff --git a/services/implementation/include/authentication_v2/auth_manager.h b/services/implementation/include/authentication_v2/auth_manager.h
index 2767c79b47b40e0c818e8cf156e7244e29793f68..1c5395dfe90a59c1efa284c921e243311435cd12 100644
--- a/services/implementation/include/authentication_v2/auth_manager.h
+++ b/services/implementation/include/authentication_v2/auth_manager.h
@@ -123,6 +123,8 @@ public:
     void PrepareSoftbusSessionCallback();
     void DeleteTimer();
 
+    int32_t HandleBusinessEvents(const std::string &businessId, int32_t action);
+
 protected:
     std::shared_ptr<DmAuthContext> context_;
     std::mutex bindParamMutex_;
diff --git a/services/implementation/include/authentication_v2/dm_auth_context.h b/services/implementation/include/authentication_v2/dm_auth_context.h
index c007f4ae5cd81da2bd556b707612e9c9411f0d7c..c2212ab40d15701ffc53a087e1b66a578377ae98 100644
--- a/services/implementation/include/authentication_v2/dm_auth_context.h
+++ b/services/implementation/include/authentication_v2/dm_auth_context.h
@@ -20,6 +20,7 @@
 
 #include "access_control_profile.h"
 #include "authentication.h"
+#include "auth_manager.h"
 #include "auth_ui_state_manager.h"
 #include "dm_ability_manager.h"
 #include "dm_anonymous.h"
@@ -202,6 +203,7 @@ struct DmAuthContext {
     bool successFinished{false};
     bool isAppCredentialVerified{false};        // Whether the application credential has been verified
     bool hmlEnable160M{false};
+    std::string businessId;
     std::string pkgName;    // Business-provided identifier, custom-defined by business, carries risk of spoofing
     std::string pkgLabel;
     std::string importCodeBundleName;           // Bundle name for imported PIN code
diff --git a/services/implementation/include/authentication_v2/dm_auth_message_processor.h b/services/implementation/include/authentication_v2/dm_auth_message_processor.h
index 0183ac5597ce1e6a6c9ab0ad6345cf74632210c6..a9b348b2f6e3855fbc3e849bceb6e04ff889550e 100644
--- a/services/implementation/include/authentication_v2/dm_auth_message_processor.h
+++ b/services/implementation/include/authentication_v2/dm_auth_message_processor.h
@@ -322,6 +322,7 @@ private:
         DmAccess &accessTmp);
     void ParseUltrasonicSide(const JsonObject &jsonObject, std::shared_ptr<DmAuthContext> context);
     void ParseCert(const JsonObject &jsonObject, std::shared_ptr<DmAuthContext> context);
+    void ParseAccesserInfo(const JsonObject &jsonObject, std::shared_ptr<DmAuthContext> context);
     std::shared_ptr<CryptoMgr> cryptoMgr_ = nullptr;
     std::unordered_map<DmMessageType, CreateMessageFuncPtr> createMessageFuncMap_;
     std::unordered_map<DmMessageType, ParaseMessageFuncPtr> paraseMessageFuncMap_;
diff --git a/services/implementation/include/authentication_v2/dm_auth_state.h b/services/implementation/include/authentication_v2/dm_auth_state.h
index e729ae5dd9ee2b3d446670081ce474d837f82e5f..87ebc199cec465ec5ada16db36c5993b07571ec0 100644
--- a/services/implementation/include/authentication_v2/dm_auth_state.h
+++ b/services/implementation/include/authentication_v2/dm_auth_state.h
@@ -477,6 +477,8 @@ private:
         JsonObject &credTypeJson);
     void GetSinkCredTypeForP2P(std::shared_ptr<DmAuthContext> context, const JsonItemObject &credObj,
         JsonObject &aclInfo, JsonObject &credTypeJson, int32_t credType, std::vector<std::string> &deleteCredInfo);
+    bool IsAntiDisturbanceMode(const std::string &businessId);
+    bool ParseAndCheckAntiDisturbanceMode(const std::string &businessId, const std::string &businessValue);
 };
 
 class AuthSinkDataSyncState : public DmAuthState {
diff --git a/services/implementation/src/authentication_v2/auth_manager.cpp b/services/implementation/src/authentication_v2/auth_manager.cpp
index 88668d9ddc83baf4679266941b6b6b548d27a214..8bd8aef10a3aceb80274bbba23adcfb7b4a65c0a 100644
--- a/services/implementation/src/authentication_v2/auth_manager.cpp
+++ b/services/implementation/src/authentication_v2/auth_manager.cpp
@@ -16,6 +16,8 @@
 #include <memory>
 
 #include "app_manager.h"
+#include "business_event.h"
+#include "distributed_device_profile_client.h"
 #include "softbus_common.h"
 #include "system_ability_definition.h"
 #include "iservice_registry.h"
@@ -36,6 +38,7 @@
 #include "dm_auth_context.h"
 #include "dm_auth_message_processor.h"
 #include "dm_auth_state.h"
+#include "json_object.h"
 
 namespace OHOS {
 namespace DistributedHardware {
@@ -46,6 +49,9 @@ constexpr int32_t MAX_PIN_CODE = 999999;
 constexpr int32_t DM_ULTRASONIC_FORWARD = 0;
 constexpr int32_t DM_ULTRASONIC_REVERSE = 1;
 const char* IS_NEED_JOIN_LNN = "IsNeedJoinLnn";
+const char* DM_REJECT_KEY = "business_id_cast+_reject_event";
+const char* DM_AUTH_DIALOG_REJECT = "is_auth_dialog_reject";
+const char* DM_TIMESTAMP = "timestamp";
 
 int32_t GetCloseSessionDelaySeconds(std::string &delaySecondsStr)
 {
@@ -135,6 +141,7 @@ AuthManager::AuthManager(std::shared_ptr<SoftbusConnector> softbusConnector,
     context_->accessee.dmVersion = DM_CURRENT_VERSION;
     context_->timer = std::make_shared<DmTimer>();
     context_->authMessageProcessor = std::make_shared<DmAuthMessageProcessor>();
+    context_->businessId = "";
 }
 
 AuthManager::~AuthManager()
@@ -415,6 +422,9 @@ std::string AuthManager::GetBundleName(const JsonObject &jsonObject)
 
 void AuthManager::ParseJsonObject(const JsonObject &jsonObject)
 {
+    if (IsString(jsonObject, DM_BUSINESS_ID)) {
+        context_->businessId = jsonObject[DM_BUSINESS_ID].Get<std::string>();
+    }
     if (jsonObject[APP_OPERATION_KEY].IsString()) {
         context_->appOperation = jsonObject[APP_OPERATION_KEY].Get<std::string>();
     }
@@ -727,6 +737,16 @@ int32_t AuthSinkManager::OnUserOperation(int32_t action, const std::string &para
         return ERR_DM_AUTH_NOT_START;
     }
 
+    std::string businessId = context_->businessId;
+    if (!businessId.empty()) {
+        LOGI("AuthSinkManager::OnUserOperation found businessId: %{public}s", businessId.c_str());
+        int32_t ret = HandleBusinessEvents(businessId, action);
+        if (ret != DM_OK) {
+            LOGE("AuthSinkManager::OnUserOperation failed to handle business events, ret: %{public}d", ret);
+            return ret;
+        }
+    }
+
     switch (action) {
         case USER_OPERATION_TYPE_CANCEL_AUTH:
         case USER_OPERATION_TYPE_ALLOW_AUTH:
@@ -1080,5 +1100,24 @@ void AuthManager::DeleteTimer()
     }
     LOGI("end.");
 }
+
+int32_t AuthManager::HandleBusinessEvents(const std::string &businessId, int32_t action)
+{
+    LOGI("AuthManager::HandleBusinessEvents start.");
+    DistributedDeviceProfile::BusinessEvent rejectEvent;
+    rejectEvent.SetBusinessKey(DM_REJECT_KEY);
+    JsonObject rejectJson;
+    rejectJson[DM_BUSINESS_ID] = businessId;
+    rejectJson[DM_AUTH_DIALOG_REJECT] = (action == USER_OPERATION_TYPE_CANCEL_AUTH);
+    rejectJson[DM_TIMESTAMP] = std::to_string(GetCurrentTimestamp());
+    rejectEvent.SetBusinessValue(rejectJson.Dump());
+    int32_t ret = DistributedDeviceProfile::DistributedDeviceProfileClient::GetInstance().PutBusinessEvent(rejectEvent);
+    if (ret != DM_OK) {
+        LOGE("HandleBusinessEvents failed to store reject_event, ret: %{public}d", ret);
+        return ret;
+    }
+    LOGI("HandleBusinessEvents successfully stored reject_event.");
+    return DM_OK;
+}
 }  // namespace DistributedHardware
 }  // namespace OHOS
\ No newline at end of file
diff --git a/services/implementation/src/authentication_v2/auth_stages/auth_negotiate.cpp b/services/implementation/src/authentication_v2/auth_stages/auth_negotiate.cpp
index bf1474fd68d1bcd2adeb7203f8031abd5ba479ba..2a4066dbf3fbfe2a0c4d75328b164d5be3786a1f 100644
--- a/services/implementation/src/authentication_v2/auth_stages/auth_negotiate.cpp
+++ b/services/implementation/src/authentication_v2/auth_stages/auth_negotiate.cpp
@@ -22,6 +22,8 @@
 #include "accessee.h"
 #include "auth_manager.h"
 #include "app_manager.h"
+#include "business_event.h"
+#include "distributed_device_profile_client.h"
 #include "dm_auth_cert.h"
 #include "dm_auth_attest_common.h"
 #include "dm_crypto.h"
@@ -48,6 +50,10 @@ using namespace OHOS::Security::AccessToken;
 
 namespace OHOS {
 namespace DistributedHardware {
+namespace {
+    const char* DM_DISTURBANCE_EVENT_KEY = "business_id_cast+_disturbance_event";
+    const char* DM_ANTI_DISTURBANCE_MODE = "is_in_anti_disturbance_mode";
+}
 
 DmAuthStateType AuthSrcStartState::GetStateType()
 {
@@ -184,6 +190,11 @@ int32_t AuthSinkNegotiateStateMachine::ProcRespNegotiate5_1_0(std::shared_ptr<Dm
 int32_t AuthSinkNegotiateStateMachine::Action(std::shared_ptr<DmAuthContext> context)
 {
     LOGI("AuthSinkNegotiateStateMachine::Action sessionid %{public}d", context->sessionId);
+    if (IsAntiDisturbanceMode(context->businessId)) {
+        LOGI("Sink is AntiDisturbMode.");
+        context->reason = ERR_DM_ANTI_DISTURB_MODE;
+        return ERR_DM_ANTI_DISTURB_MODE;
+    }
     if (FreezeProcess::GetInstance().IsFrozen()) {
         LOGE("Device is Frozen");
         return ERR_DM_DEVICE_FROZEN;
@@ -535,5 +546,56 @@ void AuthSinkNegotiateStateMachine::GetP2PCredentialInfo(std::shared_ptr<DmAuthC
         LOGE("QueryCredentialInfo failed credInfo %{public}s.", credInfo.Dump().c_str());
     }
 }
+
+bool AuthSinkNegotiateStateMachine::IsAntiDisturbanceMode(const std::string &businessId)
+{
+    LOGI("AuthManager::IsAntiDisturbMode start.");
+    if (businessId.empty()) {
+        LOGE("AuthManager::IsAntiDisturbMode businessId is empty.");
+        return false;
+    }
+
+    DistributedDeviceProfile::BusinessEvent event;
+    event.SetBusinessKey(DM_DISTURBANCE_EVENT_KEY);
+    int32_t ret = DistributedDeviceProfile::DistributedDeviceProfileClient::GetInstance().GetBusinessEvent(event);
+    if (ret != DM_OK) {
+        LOGE("GetBusinessEvent failed to get event, ret: %{public}d", ret);
+        return false;
+    }
+    std::string businessValue = event.GetBusinessValue();
+    if (businessValue.empty()) {
+        LOGE("AuthManager::IsAntiDisturbMode failed: businessValue is empty.");
+        return false;
+    }
+    return ParseAndCheckAntiDisturbanceMode(businessId, businessValue);
+}
+
+bool AuthSinkNegotiateStateMachine::ParseAndCheckAntiDisturbanceMode(const std::string &businessId,
+    const std::string &businessValue)
+{
+    JsonObject jsonObject(businessValue);
+    if (jsonObject.IsDiscarded()) {
+        LOGE("AuthManager::IsAntiDisturbMode failed: invalid JSON format in businessValue.");
+        return false;
+    }
+    if (!IsString(jsonObject, DM_BUSINESS_ID)) {
+        LOGE("AuthManager::IsAntiDisturbMode failed: 'business_id' field is missing or invalid.");
+        return false;
+    }
+    std::string parsedBusinessId = jsonObject[DM_BUSINESS_ID].Get<std::string>();
+    if (parsedBusinessId != businessId) {
+        LOGE("AuthManager::IsAntiDisturbMode failed: businessId mismatch. Expected: %{public}s, Found: %{public}s",
+            businessId.c_str(), parsedBusinessId.c_str());
+        return false;
+    }
+    if (!jsonObject.Contains(DM_ANTI_DISTURBANCE_MODE) || !jsonObject[DM_ANTI_DISTURBANCE_MODE].IsBoolean()) {
+        LOGE("AuthManager::IsAntiDisturbMode failed: 'is_in_anti_disturbance_mode' field is missing or invalid.");
+        return false;
+    }
+    bool isInAntiDisturbanceMode = jsonObject[DM_ANTI_DISTURBANCE_MODE].Get<bool>();
+    LOGI("AuthManager::IsAntiDisturbMode result: %{public}s", isInAntiDisturbanceMode ? "true" : "false");
+
+    return isInAntiDisturbanceMode;
+}
 } // namespace DistributedHardware
 } // namespace OHOS
\ No newline at end of file
diff --git a/services/implementation/src/authentication_v2/dm_auth_message_processor.cpp b/services/implementation/src/authentication_v2/dm_auth_message_processor.cpp
index 2dbaeb495b4b81d5fa625a148452703e5f8fd79d..03712b2b4d39b9df08bc4abfa064cf93082bf9ff 100644
--- a/services/implementation/src/authentication_v2/dm_auth_message_processor.cpp
+++ b/services/implementation/src/authentication_v2/dm_auth_message_processor.cpp
@@ -653,6 +653,9 @@ int32_t DmAuthMessageProcessor::CreateNegotiateMessage(std::shared_ptr<DmAuthCon
     jsonObject[TAG_PEER_PKG_NAME] = context->accessee.pkgName;
     jsonObject[TAG_HOST_PKGLABEL] = context->pkgLabel;
 
+    if (!context->businessId.empty()) {
+        jsonObject[DM_BUSINESS_ID] = context->businessId;
+    }
     return DM_OK;
 }
 
@@ -974,14 +977,36 @@ int32_t DmAuthMessageProcessor::ParseNegotiateMessage(
         context->logicalSessionId = jsonObject[DM_TAG_LOGICAL_SESSION_ID].Get<uint64_t>();
         context->requestId = static_cast<int64_t>(context->logicalSessionId);
     }
+    if (IsString(jsonObject, TAG_PEER_PKG_NAME)) {
+        context->accessee.pkgName = jsonObject[TAG_PEER_PKG_NAME].Get<std::string>();
+    }
+    if (IsString(jsonObject, TAG_PEER_BUNDLE_NAME_V2)) {
+        context->accessee.bundleName = jsonObject[TAG_PEER_BUNDLE_NAME_V2].Get<std::string>();
+    }
+    if (IsInt32(jsonObject, TAG_PEER_DISPLAY_ID)) {
+        context->accessee.displayId = jsonObject[TAG_PEER_DISPLAY_ID].Get<int32_t>();
+    }
+    if (IsString(jsonObject, TAG_HOST_PKGLABEL)) {
+        context->pkgLabel = jsonObject[TAG_HOST_PKGLABEL].Get<std::string>();
+    }
+    if (IsString(jsonObject, DM_BUSINESS_ID)) {
+        context->businessId = jsonObject[DM_BUSINESS_ID].Get<std::string>();
+    }
+    ParseAccesserInfo(jsonObject, context);
+    ParseUltrasonicSide(jsonObject, context);
+    ParseCert(jsonObject, context);
+    context->authStateMachine->TransitionTo(std::make_shared<AuthSinkNegotiateStateMachine>());
+    return DM_OK;
+}
+
+void DmAuthMessageProcessor::ParseAccesserInfo(const JsonObject &jsonObject,
+    std::shared_ptr<DmAuthContext> context)
+{
     if (jsonObject[TAG_PKG_NAME].IsString()) {
         context->pkgName = jsonObject[TAG_PKG_NAME].Get<std::string>();
         context->accesser.pkgName = context->pkgName;
         context->accessee.pkgName = context->accesser.pkgName;
     }
-    if (jsonObject[TAG_PEER_PKG_NAME].IsString()) {
-        context->accessee.pkgName = jsonObject[TAG_PEER_PKG_NAME].Get<std::string>();
-    }
     if (jsonObject[TAG_DM_VERSION_V2].IsString()) {
         context->accesser.dmVersion = jsonObject[TAG_DM_VERSION_V2].Get<std::string>();
     }
@@ -1003,19 +1028,6 @@ int32_t DmAuthMessageProcessor::ParseNegotiateMessage(
     if (jsonObject[TAG_EXTRA_INFO].IsString()) {
         context->accesser.extraInfo = jsonObject[TAG_EXTRA_INFO].Get<std::string>();
     }
-
-    if (jsonObject[TAG_PEER_BUNDLE_NAME_V2].IsString()) {
-        context->accessee.bundleName = jsonObject[TAG_PEER_BUNDLE_NAME_V2].Get<std::string>();
-    }
-    if (jsonObject[TAG_PEER_DISPLAY_ID].IsNumberInteger()) {
-        context->accessee.displayId = jsonObject[TAG_PEER_DISPLAY_ID].Get<int32_t>();
-    }
-    if (IsString(jsonObject, TAG_HOST_PKGLABEL)) {
-        context->pkgLabel = jsonObject[TAG_HOST_PKGLABEL].Get<std::string>();
-    }
-    ParseUltrasonicSide(jsonObject, context);
-    context->authStateMachine->TransitionTo(std::make_shared<AuthSinkNegotiateStateMachine>());
-    return DM_OK;
 }
 
 void DmAuthMessageProcessor::ParseCert(const JsonObject &jsonObject,
diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn
index 79713a5768e0ae9c0724ed102c67e50d1d4e52ff..4901c787a25e7b7b385bad8cfb3cb6578736629d 100644
--- a/test/unittest/BUILD.gn
+++ b/test/unittest/BUILD.gn
@@ -24,6 +24,7 @@ group("unittest") {
     ":UTTest_auth_acl",
     ":UTTest_auth_confirm",
     ":UTTest_auth_credential_state",
+    ":UTTest_auth_manager",
     ":UTTest_auth_message_processor",
     ":UTTest_auth_negotiate",
     ":UTTest_auth_pin_auth_state",
@@ -2181,6 +2182,7 @@ ohos_unittest("UTTest_auth_negotiate") {
     "${devicemanager_path}/test/unittest/mock/accesstoken_kit_mock.cpp",
     "${devicemanager_path}/test/unittest/mock/softbus_connector_mock.cpp",
     "${devicemanager_path}/test/unittest/mock/softbus_session_mock.cpp",
+    "${devicemanager_path}/test/unittest/mock/distributed_device_profile_client_mock.cpp",
   ]
 
   deps = [ ":device_manager_test_common" ]
@@ -2202,6 +2204,37 @@ ohos_unittest("UTTest_auth_negotiate") {
 
 ## UnitTest UTTest_auth_negotiate }}}
 
+## UnitTest UTTest_auth_manager {{{
+
+ohos_unittest("UTTest_auth_manager") {
+  module_out_path = module_out_path
+
+  include_dirs = []
+
+  sources = [
+    "${devicemanager_path}/test/unittest/UTTest_auth_manager.cpp",
+    "${devicemanager_path}/test/unittest/mock/distributed_device_profile_client_mock.cpp",
+  ]
+
+  deps = [ ":device_manager_test_common" ]
+
+  external_deps = [
+    "access_token:libaccesstoken_sdk",
+    "access_token:libnativetoken",
+    "access_token:libtoken_setproc",
+    "device_auth:deviceauth_sdk",
+    "device_info_manager:distributed_device_profile_common",
+    "device_info_manager:distributed_device_profile_sdk",
+    "dsoftbus:softbus_client",
+    "ffrt:libffrt",
+    "googletest:gmock",
+    "googletest:gmock_main",
+    "hilog:libhilog",
+  ]
+}
+
+## UnitTest UTTest_auth_manager }}}
+
 ## UnitTest UTTest_auth_confirm {{{
 
 ohos_unittest("UTTest_auth_confirm") {
diff --git a/test/unittest/UTTest_auth_manager.cpp b/test/unittest/UTTest_auth_manager.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1af89b982050a0edae87bb3c8cc30cd7f0f09668
--- /dev/null
+++ b/test/unittest/UTTest_auth_manager.cpp
@@ -0,0 +1,200 @@
+/*
+ * Copyright (c) 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
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "UTTest_auth_manager.h"
+
+#include "distributed_device_profile_client.h"
+#include "dm_auth_state.h"
+
+using namespace testing;
+namespace OHOS {
+namespace DistributedHardware {
+
+void AuthManagerTest::SetUp()
+{
+    softbusConnector = std::make_shared<SoftbusConnector>();
+    deviceManagerServicelistener = std::make_shared<DeviceManagerServiceListener>();
+    hiChainAuthConnector = std::make_shared<HiChainAuthConnector>();
+    hiChainConnector = std::make_shared<HiChainConnector>();
+    authManager = std::make_shared<AuthSinkManager>(softbusConnector, hiChainConnector, deviceManagerServicelistener,
+        hiChainAuthConnector);
+}
+
+void AuthManagerTest::TearDown()
+{
+    softbusConnector = nullptr;
+    deviceManagerServicelistener = nullptr;
+    hiChainAuthConnector = nullptr;
+    hiChainConnector = nullptr;
+    authManager = nullptr;
+}
+
+void AuthManagerTest::SetUpTestCase()
+{
+    DistributedDeviceProfile::DpDistributedDeviceProfileClient::dpDistributedDeviceProfileClient =
+        distributedDeviceProfileClientMock_;
+}
+
+void AuthManagerTest::TearDownTestCase()
+{
+    DistributedDeviceProfile::DpDistributedDeviceProfileClient::dpDistributedDeviceProfileClient = nullptr;
+    distributedDeviceProfileClientMock_ = nullptr;
+}
+
+HWTEST_F(AuthManagerTest, HandleBusinessEvents_001, testing::ext::TestSize.Level1)
+{
+    std::string businessId = "testBusinessId";
+    int32_t action = USER_OPERATION_TYPE_CANCEL_AUTH;
+    EXPECT_CALL(*distributedDeviceProfileClientMock_,
+        PutBusinessEvent(::testing::_)).WillOnce(::testing::Return(DM_OK));
+
+    int32_t ret = authManager->HandleBusinessEvents(businessId, action);
+    EXPECT_EQ(ret, DM_OK);
+}
+
+HWTEST_F(AuthManagerTest, HandleBusinessEvents_002, testing::ext::TestSize.Level1)
+{
+    std::string businessId = "testBusinessId";
+    int32_t action = USER_OPERATION_TYPE_CANCEL_AUTH;
+
+    EXPECT_CALL(*distributedDeviceProfileClientMock_,
+        PutBusinessEvent(::testing::_)).WillOnce(::testing::Return(ERR_DM_AUTH_NOT_START));
+
+    int32_t ret = authManager->HandleBusinessEvents(businessId, action);
+    EXPECT_EQ(ret, ERR_DM_AUTH_NOT_START);
+}
+
+HWTEST_F(AuthManagerTest, HandleBusinessEvents_003, testing::ext::TestSize.Level1)
+{
+    std::string businessId = "testBusinessId";
+    int32_t action = USER_OPERATION_TYPE_ALLOW_AUTH;
+
+    EXPECT_CALL(*distributedDeviceProfileClientMock_, PutBusinessEvent(::testing::_))
+        .WillOnce(::testing::Return(DM_OK));
+
+    int32_t result = authManager->HandleBusinessEvents(businessId, action);
+
+    EXPECT_EQ(result, DM_OK);
+}
+
+HWTEST_F(AuthManagerTest, HandleBusinessEvents_004, testing::ext::TestSize.Level1)
+{
+    std::string businessId = "";
+    int32_t action = USER_OPERATION_TYPE_CANCEL_AUTH;
+
+    EXPECT_CALL(*distributedDeviceProfileClientMock_, PutBusinessEvent(::testing::_))
+        .WillOnce(::testing::Return(DM_OK));
+
+    int32_t result = authManager->HandleBusinessEvents(businessId, action);
+
+    EXPECT_EQ(result, DM_OK);
+}
+
+HWTEST_F(AuthManagerTest, ParseJsonObject_001, testing::ext::TestSize.Level1)
+{
+    JsonObject jsonObject;
+    jsonObject[DM_BUSINESS_ID] = "testBusinessId";
+
+    authManager->ParseJsonObject(jsonObject);
+    EXPECT_EQ(jsonObject[DM_BUSINESS_ID].Get<std::string>(), "testBusinessId");
+}
+
+HWTEST_F(AuthManagerTest, ParseJsonObject_002, testing::ext::TestSize.Level1)
+{
+    JsonObject jsonObject;
+    authManager->ParseJsonObject(jsonObject);
+    EXPECT_EQ(jsonObject[DM_BUSINESS_ID].Get<std::string>(), "");
+}
+
+HWTEST_F(AuthManagerTest, OnUserOperation_001, testing::ext::TestSize.Level1)
+{
+    int32_t action = UiAction::USER_OPERATION_TYPE_CANCEL_AUTH;
+    std::string params = "testParams";
+    int32_t ret = authManager->OnUserOperation(action, params);
+    EXPECT_EQ(ret, DM_OK);
+}
+
+HWTEST_F(AuthManagerTest, OnUserOperation_002, testing::ext::TestSize.Level1)
+{
+    authManager->SetAuthContext(nullptr);
+
+    int32_t action = USER_OPERATION_TYPE_CANCEL_AUTH;
+    std::string params = "";
+
+    int32_t ret = authManager->OnUserOperation(action, params);
+
+    EXPECT_EQ(ret, ERR_DM_AUTH_NOT_START);
+}
+
+HWTEST_F(AuthManagerTest, OnUserOperation_003, testing::ext::TestSize.Level1)
+{
+    authManager->GetAuthContext()->businessId = "";
+
+    int32_t action = USER_OPERATION_TYPE_CANCEL_AUTH;
+    std::string params = "";
+
+    int32_t ret = authManager->OnUserOperation(action, params);
+
+    EXPECT_EQ(ret, DM_OK);
+}
+
+HWTEST_F(AuthManagerTest, OnUserOperation_004, testing::ext::TestSize.Level1)
+{
+    authManager->GetAuthContext()->businessId = "testBusinessId";
+
+    EXPECT_CALL(*distributedDeviceProfileClientMock_, PutBusinessEvent(::testing::_))
+        .WillOnce(::testing::Return(ERR_DM_FAILED));
+
+    int32_t action = USER_OPERATION_TYPE_CANCEL_AUTH;
+    std::string params = "";
+
+    int32_t ret = authManager->OnUserOperation(action, params);
+
+    EXPECT_EQ(ret, ERR_DM_FAILED);
+}
+
+HWTEST_F(AuthManagerTest, OnUserOperation_005, testing::ext::TestSize.Level1)
+{
+    int32_t action = USER_OPERATION_TYPE_AUTH_CONFIRM_TIMEOUT;
+    std::string params = "";
+
+    int32_t ret = authManager->OnUserOperation(action, params);
+
+    EXPECT_EQ(ret, DM_OK);
+    EXPECT_EQ(authManager->GetAuthContext()->reason, ERR_DM_TIME_OUT);
+}
+
+HWTEST_F(AuthManagerTest, OnUserOperation_006, testing::ext::TestSize.Level1)
+{
+    int32_t action = USER_OPERATION_TYPE_CANCEL_PINCODE_DISPLAY;
+    std::string params = "";
+
+    int32_t ret = authManager->OnUserOperation(action, params);
+
+    EXPECT_EQ(ret, DM_OK);
+    EXPECT_EQ(authManager->GetAuthContext()->reason, ERR_DM_BIND_USER_CANCEL_PIN_CODE_DISPLAY);
+}
+
+HWTEST_F(AuthManagerTest, OnUserOperation_007, testing::ext::TestSize.Level1)
+{
+    int32_t action = -1;
+    std::string params = "";
+
+    int32_t ret = authManager->OnUserOperation(action, params);
+
+    EXPECT_EQ(ret, DM_OK);
+}
+} // namespace DistributedHardware
+} // namespace OHOS
diff --git a/test/unittest/UTTest_auth_manager.h b/test/unittest/UTTest_auth_manager.h
new file mode 100644
index 0000000000000000000000000000000000000000..e2c0b995d4d78b676cb94e226cd7aa94587ac1fc
--- /dev/null
+++ b/test/unittest/UTTest_auth_manager.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 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
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OHOS_UTTEST_AUTH_MANAGER_H
+#define OHOS_UTTEST_AUTH_MANAGER_H
+
+#include <gtest/gtest.h>
+
+#include "auth_manager.h"
+#include "device_manager_service_listener.h"
+#include "hichain_connector.h"
+#include "softbus_connector.h"
+#include "distributed_device_profile_client_mock.h"
+
+namespace OHOS {
+namespace DistributedHardware {
+class AuthManagerTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp();
+    void TearDown();
+private:
+    static inline std::shared_ptr<DistributedDeviceProfile::DistributedDeviceProfileClientMock>
+        distributedDeviceProfileClientMock_ =
+        std::make_shared<DistributedDeviceProfile::DistributedDeviceProfileClientMock>();
+
+    std::shared_ptr<SoftbusConnector> softbusConnector;
+    std::shared_ptr<IDeviceManagerServiceListener> deviceManagerServicelistener;
+    std::shared_ptr<HiChainAuthConnector> hiChainAuthConnector;
+    std::shared_ptr<HiChainConnector> hiChainConnector;
+    std::shared_ptr<AuthManager> authManager;
+};
+} // namespace DistributedHardware
+} // namespace OHOS
+#endif
diff --git a/test/unittest/UTTest_auth_negotiate.cpp b/test/unittest/UTTest_auth_negotiate.cpp
index 02d4a30d32db24eca407c1cd4e20efbb061fc7ec..8bc9f61238275199f68ab34b94fc58b4820e7bad 100644
--- a/test/unittest/UTTest_auth_negotiate.cpp
+++ b/test/unittest/UTTest_auth_negotiate.cpp
@@ -33,6 +33,8 @@ void AuthNegotiateTest::SetUpTestCase()
 
     DmSoftbusConnector::dmSoftbusConnector = softbusConnectorMock;
     DmSoftbusSession::dmSoftbusSession = softbusSessionMock;
+    DistributedDeviceProfile::DpDistributedDeviceProfileClient::dpDistributedDeviceProfileClient =
+        distributedDeviceProfileClientMock_;
 }
 
 void AuthNegotiateTest::TearDownTestCase()
@@ -42,6 +44,8 @@ void AuthNegotiateTest::TearDownTestCase()
     softbusSessionMock = nullptr;
     DmSoftbusConnector::dmSoftbusConnector = nullptr;
     DmSoftbusSession::dmSoftbusSession = nullptr;
+    DistributedDeviceProfile::DpDistributedDeviceProfileClient::dpDistributedDeviceProfileClient = nullptr;
+    distributedDeviceProfileClientMock_ = nullptr;
 }
 
 void AuthNegotiateTest::SetUp()
@@ -61,6 +65,7 @@ void AuthNegotiateTest::SetUp()
 
     Mock::VerifyAndClearExpectations(&*softbusConnectorMock);
     Mock::VerifyAndClearExpectations(&*softbusSessionMock);
+    Mock::VerifyAndClearExpectations(&*distributedDeviceProfileClientMock_);
 }
 
 void AuthNegotiateTest::TearDown()
@@ -77,6 +82,24 @@ void AuthNegotiateTest::TearDown()
     tokenMock = nullptr;
 }
 
+int32_t GetBusinessEventMockTrue(DistributedDeviceProfile::BusinessEvent &event)
+{
+    event.SetBusinessValue("{\"business_id\":\"test_business_id\",\"is_in_anti_disturbance_mode\":true}");
+    return DM_OK;
+}
+
+int32_t GetBusinessEventMockEmpty(DistributedDeviceProfile::BusinessEvent &event)
+{
+    event.SetBusinessValue("");
+    return DM_OK;
+}
+
+int32_t GetBusinessEventMockFalse(DistributedDeviceProfile::BusinessEvent &event)
+{
+    event.SetBusinessValue("{\"business_id\":\"test_business_id\",\"is_in_anti_disturbance_mode\":false}");
+    return DM_OK;
+}
+
 HWTEST_F(AuthNegotiateTest, AuthSrcStartState_001, testing::ext::TestSize.Level1)
 {
     std::shared_ptr<AuthSrcStartState> authState = std::make_shared<AuthSrcStartState>();
@@ -221,5 +244,143 @@ HWTEST_F(AuthNegotiateTest, AuthSinkNegotiateStateMachine_008, testing::ext::Tes
     EXPECT_FALSE(result);
 }
 
+HWTEST_F(AuthNegotiateTest, AuthSinkNegotiateStateMachine_Action_003, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<AuthSinkNegotiateStateMachine> authState = std::make_shared<AuthSinkNegotiateStateMachine>();
+
+    std::shared_ptr<DmAuthContext> context = std::make_shared<DmAuthContext>();
+    context->businessId = "test_business_id";
+
+    EXPECT_CALL(*distributedDeviceProfileClientMock_, GetBusinessEvent(::testing::_))
+        .WillOnce(::testing::Invoke(GetBusinessEventMockTrue));
+
+    int32_t result = authState->Action(context);
+
+    EXPECT_EQ(result, ERR_DM_ANTI_DISTURB_MODE);
+    EXPECT_EQ(context->reason, ERR_DM_ANTI_DISTURB_MODE);
+}
+
+HWTEST_F(AuthNegotiateTest, AuthSinkNegotiateStateMachine_Action_004, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<AuthSinkNegotiateStateMachine> authState = std::make_shared<AuthSinkNegotiateStateMachine>();
+
+    std::shared_ptr<DmAuthContext> context = std::make_shared<DmAuthContext>();
+    context->businessId = "test_business_id";
+
+    EXPECT_CALL(*distributedDeviceProfileClientMock_, GetBusinessEvent(::testing::_))
+        .WillOnce(::testing::Invoke(GetBusinessEventMockFalse));
+
+    int32_t result = authState->Action(context);
+
+    EXPECT_NE(result, ERR_DM_ANTI_DISTURB_MODE);
+    EXPECT_NE(context->reason, ERR_DM_ANTI_DISTURB_MODE);
+}
+
+HWTEST_F(AuthNegotiateTest, IsAntiDisturbanceMode_001, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<AuthSinkNegotiateStateMachine> authState = std::make_shared<AuthSinkNegotiateStateMachine>();
+    std::string businessId = "";
+    businessId.clear();
+    EXPECT_FALSE(authState->IsAntiDisturbanceMode(businessId));
+}
+
+HWTEST_F(AuthNegotiateTest, IsAntiDisturbanceMode_002, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<AuthSinkNegotiateStateMachine> authState = std::make_shared<AuthSinkNegotiateStateMachine>();
+    std::string businessId = "test_business_id";
+
+    EXPECT_CALL(*distributedDeviceProfileClientMock_, GetBusinessEvent(::testing::_))
+        .WillOnce(::testing::Return(ERR_DM_FAILED));
+
+    EXPECT_FALSE(authState->IsAntiDisturbanceMode(businessId));
+}
+
+HWTEST_F(AuthNegotiateTest, IsAntiDisturbanceMode_003, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<AuthSinkNegotiateStateMachine> authState = std::make_shared<AuthSinkNegotiateStateMachine>();
+    std::string businessId = "test_business_id";
+
+    EXPECT_CALL(*distributedDeviceProfileClientMock_, GetBusinessEvent(::testing::_))
+        .WillOnce(::testing::Invoke(GetBusinessEventMockEmpty));
+
+    EXPECT_FALSE(authState->IsAntiDisturbanceMode(businessId));
+}
+
+HWTEST_F(AuthNegotiateTest, IsAntiDisturbanceMode_004, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<AuthSinkNegotiateStateMachine> authState = std::make_shared<AuthSinkNegotiateStateMachine>();
+    std::string businessId = "test_business_id";
+
+    EXPECT_CALL(*distributedDeviceProfileClientMock_, GetBusinessEvent(::testing::_))
+        .WillOnce(::testing::Invoke(GetBusinessEventMockTrue));
+
+    EXPECT_TRUE(authState->IsAntiDisturbanceMode(businessId));
+}
+
+HWTEST_F(AuthNegotiateTest, ParseAndCheckAntiDisturbanceMode_001, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<AuthSinkNegotiateStateMachine> authState = std::make_shared<AuthSinkNegotiateStateMachine>();
+    std::string businessId = "test_business_id";
+    std::string businessValue = "invalid_json";
+    EXPECT_FALSE(authState->ParseAndCheckAntiDisturbanceMode(businessId, businessValue));
+}
+
+HWTEST_F(AuthNegotiateTest, ParseAndCheckAntiDisturbanceMode_002, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<AuthSinkNegotiateStateMachine> authState = std::make_shared<AuthSinkNegotiateStateMachine>();
+    std::string businessId = "test_business_id";
+    std::string businessValue = "{\"is_in_anti_disturbance_mode\":true}";
+    EXPECT_FALSE(authState->ParseAndCheckAntiDisturbanceMode(businessId, businessValue));
+}
+
+HWTEST_F(AuthNegotiateTest, ParseAndCheckAntiDisturbanceMode_003, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<AuthSinkNegotiateStateMachine> authState = std::make_shared<AuthSinkNegotiateStateMachine>();
+    std::string businessId = "test_business_id";
+    std::string businessValue = "{\"business_id\":\"wrong_id\",\"is_in_anti_disturbance_mode\":true}";
+    EXPECT_FALSE(authState->ParseAndCheckAntiDisturbanceMode(businessId, businessValue));
+}
+
+HWTEST_F(AuthNegotiateTest, ParseAndCheckAntiDisturbanceMode_004, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<AuthSinkNegotiateStateMachine> authState = std::make_shared<AuthSinkNegotiateStateMachine>();
+    std::string businessId = "test_business_id";
+    std::string businessValue = "{\"business_id\":\"test_business_id\"}";
+    EXPECT_FALSE(authState->ParseAndCheckAntiDisturbanceMode(businessId, businessValue));
+}
+
+HWTEST_F(AuthNegotiateTest, ParseAndCheckAntiDisturbanceMode_005, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<AuthSinkNegotiateStateMachine> authState = std::make_shared<AuthSinkNegotiateStateMachine>();
+    std::string businessId = "test_business_id";
+    std::string businessValue = "{\"business_id\":\"test_business_id\",\"is_in_anti_disturbance_mode\":true}";
+    EXPECT_TRUE(authState->ParseAndCheckAntiDisturbanceMode(businessId, businessValue));
+}
+
+HWTEST_F(AuthNegotiateTest, ParseAndCheckAntiDisturbanceMode_006, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<AuthSinkNegotiateStateMachine> authState = std::make_shared<AuthSinkNegotiateStateMachine>();
+    std::string businessId = "test_business_id";
+    std::string businessValue = "{\"business_id\":\"test_business_id\",\"is_in_anti_disturbance_mode\":false}";
+    EXPECT_FALSE(authState->ParseAndCheckAntiDisturbanceMode(businessId, businessValue));
+}
+
+HWTEST_F(AuthNegotiateTest, ParseAndCheckAntiDisturbanceMode_007, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<AuthSinkNegotiateStateMachine> authState = std::make_shared<AuthSinkNegotiateStateMachine>();
+    std::string businessId = "test_business_id";
+    std::string businessValue = "{\"business_id\":123,\"is_in_anti_disturbance_mode\":true}";
+
+    EXPECT_FALSE(authState->ParseAndCheckAntiDisturbanceMode(businessId, businessValue));
+}
+
+HWTEST_F(AuthNegotiateTest, ParseAndCheckAntiDisturbanceMode_008, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<AuthSinkNegotiateStateMachine> authState = std::make_shared<AuthSinkNegotiateStateMachine>();
+    std::string businessId = "test_business_id";
+    std::string businessValue = "{\"business_id\":\"test_business_id\",\"is_in_anti_disturbance_mode\":123}";
+
+    EXPECT_FALSE(authState->ParseAndCheckAntiDisturbanceMode(businessId, businessValue));
+}
 }
 }
\ No newline at end of file
diff --git a/test/unittest/UTTest_auth_negotiate.h b/test/unittest/UTTest_auth_negotiate.h
index 81608c77d9bc6832b89482b3db74eda9b401e44f..e3c9ab90961e9531b78349cad9747063702896f0 100644
--- a/test/unittest/UTTest_auth_negotiate.h
+++ b/test/unittest/UTTest_auth_negotiate.h
@@ -21,6 +21,7 @@
 #include "accesstoken_kit_mock.h"
 #include "softbus_connector_mock.h"
 #include "softbus_session_mock.h"
+#include "distributed_device_profile_client_mock.h"
 
 namespace OHOS {
 namespace DistributedHardware {
@@ -36,6 +37,9 @@ private:
         std::make_shared<SoftbusConnectorMock>();
     static inline std::shared_ptr<SoftbusSessionMock> softbusSessionMock =
         std::make_shared<SoftbusSessionMock>();
+    static inline std::shared_ptr<DistributedDeviceProfile::DistributedDeviceProfileClientMock>
+        distributedDeviceProfileClientMock_ =
+        std::make_shared<DistributedDeviceProfile::DistributedDeviceProfileClientMock>();
     static inline std::shared_ptr<AccessTokenKitMock> tokenMock = nullptr;
     std::shared_ptr<SoftbusConnector> softbusConnector;
     std::shared_ptr<IDeviceManagerServiceListener> listener;
diff --git a/test/unittest/UTTest_dm_auth_message_processor.cpp b/test/unittest/UTTest_dm_auth_message_processor.cpp
index fe1f00860193618424d97bb483144db218fb8f0f..43793179d304a2c4e7c3944b74c31978bb44c990 100644
--- a/test/unittest/UTTest_dm_auth_message_processor.cpp
+++ b/test/unittest/UTTest_dm_auth_message_processor.cpp
@@ -111,6 +111,90 @@ HWTEST_F(DmAuthMessageProcessorTest, ParseMessageForwardUltrasonicNegotiate_001,
     EXPECT_EQ(processor->ParseMessageForwardUltrasonicNegotiate(json, context), DM_OK);
 }
 
+HWTEST_F(DmAuthMessageProcessorTest, ParseNegotiateMessage_001, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<DmAuthContext> context = std::make_shared<DmAuthContext>();
+    context->authStateMachine = std::make_shared<DmAuthStateMachine>(context);
+    JsonObject jsonObject;
+    jsonObject[DM_TAG_LOGICAL_SESSION_ID] = 12345;
+
+    std::shared_ptr<DmAuthMessageProcessor> processor = std::make_shared<DmAuthMessageProcessor>();
+    int32_t ret = processor->ParseNegotiateMessage(jsonObject, context);
+
+    EXPECT_EQ(ret, DM_OK);
+    EXPECT_EQ(context->logicalSessionId, 12345);
+    EXPECT_EQ(context->requestId, 12345);
+}
+
+HWTEST_F(DmAuthMessageProcessorTest, ParseNegotiateMessage_002, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<DmAuthContext> context = std::make_shared<DmAuthContext>();
+    context->authStateMachine = std::make_shared<DmAuthStateMachine>(context);
+    JsonObject jsonObject;
+    jsonObject[TAG_PEER_PKG_NAME] = "testPkgName";
+
+    std::shared_ptr<DmAuthMessageProcessor> processor = std::make_shared<DmAuthMessageProcessor>();
+    int32_t ret = processor->ParseNegotiateMessage(jsonObject, context);
+
+    EXPECT_EQ(ret, DM_OK);
+    EXPECT_EQ(context->accessee.pkgName, "testPkgName");
+}
+
+HWTEST_F(DmAuthMessageProcessorTest, ParseNegotiateMessage_003, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<DmAuthContext> context = std::make_shared<DmAuthContext>();
+    context->authStateMachine = std::make_shared<DmAuthStateMachine>(context);
+    JsonObject jsonObject;
+    jsonObject[TAG_PEER_BUNDLE_NAME_V2] = "testBundleName";
+
+    std::shared_ptr<DmAuthMessageProcessor> processor = std::make_shared<DmAuthMessageProcessor>();
+    int32_t ret = processor->ParseNegotiateMessage(jsonObject, context);
+
+    EXPECT_EQ(ret, DM_OK);
+    EXPECT_EQ(context->accessee.bundleName, "testBundleName");
+}
+
+HWTEST_F(DmAuthMessageProcessorTest, ParseNegotiateMessage_004, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<DmAuthContext> context = std::make_shared<DmAuthContext>();
+    context->authStateMachine = std::make_shared<DmAuthStateMachine>(context);
+    JsonObject jsonObject;
+    jsonObject[TAG_PEER_DISPLAY_ID] = 123;
+
+    std::shared_ptr<DmAuthMessageProcessor> processor = std::make_shared<DmAuthMessageProcessor>();
+    int32_t ret = processor->ParseNegotiateMessage(jsonObject, context);
+
+    EXPECT_EQ(ret, DM_OK);
+    EXPECT_EQ(context->accessee.displayId, 123);
+}
+
+HWTEST_F(DmAuthMessageProcessorTest, ParseNegotiateMessage_005, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<DmAuthContext> context = std::make_shared<DmAuthContext>();
+    context->authStateMachine = std::make_shared<DmAuthStateMachine>(context);
+    JsonObject jsonObject;
+    jsonObject[TAG_HOST_PKGLABEL] = "testPkgLabel";
+
+    std::shared_ptr<DmAuthMessageProcessor> processor = std::make_shared<DmAuthMessageProcessor>();
+    int32_t ret = processor->ParseNegotiateMessage(jsonObject, context);
+
+    EXPECT_EQ(ret, DM_OK);
+    EXPECT_EQ(context->pkgLabel, "testPkgLabel");
+}
+
+HWTEST_F(DmAuthMessageProcessorTest, ParseNegotiateMessage_006, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<DmAuthContext> context = std::make_shared<DmAuthContext>();
+    context->authStateMachine = std::make_shared<DmAuthStateMachine>(context);
+    JsonObject jsonObject;
+    jsonObject[DM_BUSINESS_ID] = "testBusinessId";
+
+    std::shared_ptr<DmAuthMessageProcessor> processor = std::make_shared<DmAuthMessageProcessor>();
+    int32_t ret = processor->ParseNegotiateMessage(jsonObject, context);
+
+    EXPECT_EQ(ret, DM_OK);
+    EXPECT_EQ(context->businessId, "testBusinessId");
+}
 } // namespace DistributedHardware
 } // namespace OHOS
  
\ No newline at end of file
diff --git a/test/unittest/mock/distributed_device_profile_client_mock.cpp b/test/unittest/mock/distributed_device_profile_client_mock.cpp
index 89f1b92cd153b7d65a84469f9c6a746be5b797a3..c67eda3c159a8906bc57c38b9b470f03dd95b371 100644
--- a/test/unittest/mock/distributed_device_profile_client_mock.cpp
+++ b/test/unittest/mock/distributed_device_profile_client_mock.cpp
@@ -86,5 +86,15 @@ int32_t DistributedDeviceProfileClient::GetLocalServiceInfoByBundleAndPinType(co
     return DpDistributedDeviceProfileClient::dpDistributedDeviceProfileClient->GetLocalServiceInfoByBundleAndPinType(
         bundleName, pinExchangeType, localServiceInfo);
 }
+
+int32_t DistributedDeviceProfileClient::GetBusinessEvent(BusinessEvent &event)
+{
+    return DpDistributedDeviceProfileClient::dpDistributedDeviceProfileClient->GetBusinessEvent(event);
+}
+
+int32_t DistributedDeviceProfileClient::PutBusinessEvent(const DistributedDeviceProfile::BusinessEvent &event)
+{
+    return DpDistributedDeviceProfileClient::dpDistributedDeviceProfileClient->PutBusinessEvent(event);
+}
 } // namespace DistributedHardware
 } // namespace OHOS
\ No newline at end of file
diff --git a/test/unittest/mock/distributed_device_profile_client_mock.h b/test/unittest/mock/distributed_device_profile_client_mock.h
index 2109ca5dbe00bde14636684248ecc918fefa6f59..13495ff3a1f5c7269886694730a0fbab0e025920 100644
--- a/test/unittest/mock/distributed_device_profile_client_mock.h
+++ b/test/unittest/mock/distributed_device_profile_client_mock.h
@@ -40,6 +40,8 @@ public:
     virtual int32_t UpdateLocalServiceInfo(const LocalServiceInfo& localServiceInfo) = 0;
     virtual int32_t GetLocalServiceInfoByBundleAndPinType(const std::string& bundleName,
         int32_t pinExchangeType, LocalServiceInfo& localServiceInfo) = 0;
+    virtual int32_t GetBusinessEvent(BusinessEvent &event) = 0;
+    virtual int32_t PutBusinessEvent(const DistributedDeviceProfile::BusinessEvent &event) = 0;
 public:
     static inline std::shared_ptr<DpDistributedDeviceProfileClient> dpDistributedDeviceProfileClient = nullptr;
 };
@@ -58,6 +60,8 @@ public:
     MOCK_METHOD(int32_t, DeleteLocalServiceInfo, (const std::string&, int32_t));
     MOCK_METHOD(int32_t, UpdateLocalServiceInfo, (const LocalServiceInfo&));
     MOCK_METHOD(int32_t, GetLocalServiceInfoByBundleAndPinType, (const std::string&, int32_t, LocalServiceInfo&));
+    MOCK_METHOD(int32_t, GetBusinessEvent, (BusinessEvent &event));
+    MOCK_METHOD(int32_t, PutBusinessEvent, (const DistributedDeviceProfile::BusinessEvent &event));
 };
 }
 }