diff --git a/common/include/dm_constants.h b/common/include/dm_constants.h
index 0a2645f57234a62fd297432c44b7c54f216c1083..d1a382e8ea2b16ed7011628ebf4a2ec42fa9c08c 100755
--- a/common/include/dm_constants.h
+++ b/common/include/dm_constants.h
@@ -159,6 +159,13 @@ 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_REJECT_KEY;
+DM_EXPORT extern const char* DM_DISTURBANCE_EVENT_KEY;
+DM_EXPORT extern const char* DM_BUSINESS_ID;
+DM_EXPORT extern const char* DM_TIMESTAMP;
+DM_EXPORT extern const char* DM_AUTH_DIALOG_REJECT;
+DM_EXPORT extern const char* DM_ANTI_DISTURBANCE_MODE;
+
 // 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 cd5225aedad804d56a1c05ad077019671ef1d2e2..6e6552ca32696ddbec5db8e93db61d52a9a4298c 100644
--- a/common/include/dm_error_type.h
+++ b/common/include/dm_error_type.h
@@ -142,6 +142,7 @@ enum {
     ERR_DM_VERIFY_SAME_ACCOUNT_FAILED = 969298353,
     ERR_DM_DEVICE_FREEZED = 969298355,
     ERR_DM_SOCKET_IN_USED = 969298356,
+	ERR_DM_ANTI_DISTURB_MODE = 969298357,
 };
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/common/src/dm_constants.cpp b/common/src/dm_constants.cpp
index 9be2b9fb7155033e0478433413a1cc37f8615d6c..e9a50d7498ca4132378feee557c9f15a9414ea58 100644
--- a/common/src/dm_constants.cpp
+++ b/common/src/dm_constants.cpp
@@ -149,6 +149,13 @@ 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_REJECT_KEY = "business_id_cast+_reject_event";
+const char* DM_DISTURBANCE_EVENT_KEY = "business_id_cast+_disturbance_event";
+const char* DM_BUSINESS_ID = "business_id";
+const char* DM_TIMESTAMP = "timestamp";
+const char* DM_AUTH_DIALOG_REJECT = "is_auth_dialog_reject";
+const char* DM_ANTI_DISTURBANCE_MODE = "is_in_anti_disturbance_mode";
+
 // 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 faf47baa267731adacb7dbbfd59fdeaf9bfebff6..f7cab34d524cd0e4469c4fbf941ed8c1f2050608 100644
--- a/services/implementation/include/authentication_v2/dm_auth_context.h
+++ b/services/implementation/include/authentication_v2/dm_auth_context.h
@@ -32,6 +32,7 @@
 #include "hichain_connector.h"
 #include "softbus_connector.h"
 #include "softbus_session.h"
+#include "auth_manager.h"
 
 namespace OHOS {
 namespace DistributedHardware {
@@ -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 cf5a594b28f2402dcf4b1f6264e2e2cd5fc7b0b9..a9082d772514588b355fac3e504bd274322da238 100644
--- a/services/implementation/src/authentication_v2/auth_manager.cpp
+++ b/services/implementation/src/authentication_v2/auth_manager.cpp
@@ -14,6 +14,8 @@
  */
 
 #include <memory>
+#include <chrono>
+#include "cJSON.h"
 
 #include "app_manager.h"
 #include "softbus_common.h"
@@ -38,6 +40,8 @@
 #include "dm_auth_context.h"
 #include "dm_auth_message_processor.h"
 #include "dm_auth_state.h"
+#include "business_event.h"
+#include "distributed_device_profile_client.h"
 
 namespace OHOS {
 namespace DistributedHardware {
@@ -48,6 +52,13 @@ constexpr int32_t MAX_PIN_CODE = 999999;
 constexpr int32_t DM_ULTRASONIC_FORWARD = 0;
 constexpr int32_t DM_ULTRASONIC_REVERSE = 1;
 
+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();
+}
+
 int32_t GetCloseSessionDelaySeconds(std::string &delaySecondsStr)
 {
     if (!IsNumberString(delaySecondsStr)) {
@@ -136,6 +147,7 @@ AuthManager::AuthManager(std::shared_ptr<SoftbusConnector> softbusConnector,
     context_->accessee.dmVersion = DM_VERSION_5_1_1;
     context_->timer = std::make_shared<DmTimer>();
     context_->authMessageProcessor = std::make_shared<DmAuthMessageProcessor>();
+    context_->businessId = "";
 }
 
 AuthManager::~AuthManager()
@@ -416,6 +428,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>();
     }
@@ -750,6 +765,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:
@@ -1103,5 +1128,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 0639821f5398a6ec18b3b22d16f9ff68a618b012..eaebb8e639333c2821865006e109b378666eb535 100644
--- a/services/implementation/src/authentication_v2/auth_stages/auth_negotiate.cpp
+++ b/services/implementation/src/authentication_v2/auth_stages/auth_negotiate.cpp
@@ -43,6 +43,8 @@
 #include "multiple_user_connector.h"
 #include "os_account_manager.h"
 #include "parameter.h"
+#include "business_event.h"
+#include "distributed_device_profile_client.h"
 
 using namespace OHOS::Security::AccessToken;
 
@@ -226,6 +228,11 @@ int32_t VerifyCertificate(std::shared_ptr<DmAuthContext> context)
 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().IsFreezed(context->accessee.bundleName, context->accessee.deviceType)) {
         LOGE("Device is Freezed");
         return ERR_DM_DEVICE_FREEZED;
@@ -584,5 +591,65 @@ 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)
+{
+    cJSON* root = cJSON_Parse(businessValue.c_str());
+    if (root == nullptr) {
+        LOGE("AuthManager::IsAntiDisturbMode failed: invalid JSON format in businessValue.");
+        return false;
+    }
+
+    cJSON* businessIdItem = cJSON_GetObjectItem(root, DM_BUSINESS_ID);
+    if (businessIdItem == nullptr || !cJSON_IsString(businessIdItem)) {
+        LOGE("AuthManager::IsAntiDisturbMode failed: 'business_id' field is missing or invalid.");
+        cJSON_Delete(root);
+        return false;
+    }
+    std::string parsedBusinessId = businessIdItem->valuestring;
+    if (parsedBusinessId != businessId) {
+        LOGE("AuthManager::IsAntiDisturbMode failed: businessId mismatch. Expected: %{public}s, Found: %{public}s",
+            businessId.c_str(), parsedBusinessId.c_str());
+        cJSON_Delete(root);
+        return false;
+    }
+
+    cJSON* antiDisturbModeItem = cJSON_GetObjectItem(root, DM_ANTI_DISTURBANCE_MODE);
+    if (antiDisturbModeItem == nullptr || !cJSON_IsBool(antiDisturbModeItem)) {
+        LOGE("AuthManager::IsAntiDisturbMode failed: 'is_in_anti_disturbance_mode' field is missing or invalid.");
+        cJSON_Delete(root);
+        return false;
+    }
+
+    bool isInAntiDisturbanceMode = cJSON_IsTrue(antiDisturbModeItem);
+    LOGI("AuthManager::IsAntiDisturbMode result: %{public}s", isInAntiDisturbanceMode ? "true" : "false");
+
+    cJSON_Delete(root);
+    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 043302bf8374c79955eafed7cfcc7b5bd48afc6d..a7c5576722c8fc4391f4bd103d3398bc53119e9a 100644
--- a/services/implementation/src/authentication_v2/dm_auth_message_processor.cpp
+++ b/services/implementation/src/authentication_v2/dm_auth_message_processor.cpp
@@ -655,6 +655,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;
 }
 
@@ -976,14 +979,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 (jsonObject[TAG_PEER_PKG_NAME].IsString()) {
+        context->accessee.pkgName = jsonObject[TAG_PEER_PKG_NAME].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>();
+    }
+    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>();
     }
@@ -1005,20 +1030,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);
-    ParseCert(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 8e572f9a316271d8f0b5d53bd5a89f9ba6572171..3438965bc8b772145d79b5ad40975e639138a516 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",
@@ -2180,6 +2181,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" ]
@@ -2201,6 +2203,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..29ed84fc4a42ced4528248b1c3510fca075b899f
--- /dev/null
+++ b/test/unittest/UTTest_auth_manager.cpp
@@ -0,0 +1,96 @@
+/*
+ * 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, 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, 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);
+}
+} // 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..3c6f59eeaaa551e14247a3b134bdf38a1b22215f
--- /dev/null
+++ b/test/unittest/UTTest_auth_manager.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2022-2024 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..2e2bb60f9ec7ea65e31e2c319f2539187352b8a5 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,7 @@ void AuthNegotiateTest::TearDownTestCase()
     softbusSessionMock = nullptr;
     DmSoftbusConnector::dmSoftbusConnector = nullptr;
     DmSoftbusSession::dmSoftbusSession = nullptr;
+    distributedDeviceProfileClientMock_ = nullptr;
 }
 
 void AuthNegotiateTest::SetUp()
@@ -61,6 +64,7 @@ void AuthNegotiateTest::SetUp()
 
     Mock::VerifyAndClearExpectations(&*softbusConnectorMock);
     Mock::VerifyAndClearExpectations(&*softbusSessionMock);
+    Mock::VerifyAndClearExpectations(&*distributedDeviceProfileClientMock_);
 }
 
 void AuthNegotiateTest::TearDown()
@@ -77,6 +81,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 +243,125 @@ 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));
+}
 }
 }
\ 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/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));
 };
 }
 }