diff --git a/interfaces/inner_kits/src/distributed_hardware_fwk_kit.cpp b/interfaces/inner_kits/src/distributed_hardware_fwk_kit.cpp
index 91ea88ca18963ff81e1adff3e1c26a84fde9b169..4e3880052b1709698e8bc62b7214c9247469f11d 100644
--- a/interfaces/inner_kits/src/distributed_hardware_fwk_kit.cpp
+++ b/interfaces/inner_kits/src/distributed_hardware_fwk_kit.cpp
@@ -227,7 +227,7 @@ int32_t DistributedHardwareFwkKit::PauseDistributedHardware(DHType dhType, const
         GetAnonyString(networkId).c_str());
 
     if (DHFWKSAManager::GetInstance().GetDHFWKProxy() == nullptr) {
-        DHLOGI("DHFWK not online or get proxy failed, can not register av control center callback.");
+        DHLOGI("DHFWK not online or get proxy failed, can not pause distributed hardware.");
         return ERR_DH_FWK_POINTER_IS_NULL;
     }
     HiSysEventWriteMsg(DHFWK_INIT_END, OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
@@ -244,7 +244,7 @@ int32_t DistributedHardwareFwkKit::ResumeDistributedHardware(DHType dhType, cons
         GetAnonyString(networkId).c_str());
 
     if (DHFWKSAManager::GetInstance().GetDHFWKProxy() == nullptr) {
-        DHLOGI("DHFWK not online or get proxy failed, can not register av control center callback.");
+        DHLOGI("DHFWK not online or get proxy failed, can not resume distributed hardware.");
         return ERR_DH_FWK_POINTER_IS_NULL;
     }
     HiSysEventWriteMsg(DHFWK_INIT_BEGIN, OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
@@ -261,7 +261,7 @@ int32_t DistributedHardwareFwkKit::StopDistributedHardware(DHType dhType, const
         GetAnonyString(networkId).c_str());
 
     if (DHFWKSAManager::GetInstance().GetDHFWKProxy() == nullptr) {
-        DHLOGI("DHFWK not online or get proxy failed, can not register av control center callback.");
+        DHLOGI("DHFWK not online or get proxy failed, can not stop distributed hardware.");
         return ERR_DH_FWK_POINTER_IS_NULL;
     }
     HiSysEventWriteMsg(DHFWK_EXIT_END, OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
@@ -287,7 +287,7 @@ int32_t DistributedHardwareFwkKit::RegisterDHStatusListener(sptr<IHDSinkStatusLi
 {
     DHLOGI("Register distributed hardware status sink listener.");
     if (DHFWKSAManager::GetInstance().GetDHFWKProxy() == nullptr) {
-        DHLOGI("DHFWK not online or get proxy failed, can not register av control center callback.");
+        DHLOGI("DHFWK not online or get proxy failed, can not register distributed hardware status listener.");
         return ERR_DH_FWK_POINTER_IS_NULL;
     }
     return DHFWKSAManager::GetInstance().GetDHFWKProxy()->RegisterDHStatusListener(listener);
@@ -297,7 +297,7 @@ int32_t DistributedHardwareFwkKit::UnregisterDHStatusListener(sptr<IHDSinkStatus
 {
     DHLOGI("Unregister distributed hardware status sink listener.");
     if (DHFWKSAManager::GetInstance().GetDHFWKProxy() == nullptr) {
-        DHLOGI("DHFWK not online or get proxy failed, can not register av control center callback.");
+        DHLOGI("DHFWK not online or get proxy failed, can not unregister distributed hardware status listener.");
         return ERR_DH_FWK_POINTER_IS_NULL;
     }
     return DHFWKSAManager::GetInstance().GetDHFWKProxy()->UnregisterDHStatusListener(listener);
@@ -311,7 +311,7 @@ int32_t DistributedHardwareFwkKit::RegisterDHStatusListener(
     }
     DHLOGI("Register distributed hardware status source listener %{public}s.", GetAnonyString(networkId).c_str());
     if (DHFWKSAManager::GetInstance().GetDHFWKProxy() == nullptr) {
-        DHLOGI("DHFWK not online or get proxy failed, can not register av control center callback.");
+        DHLOGI("DHFWK not online or get proxy failed, can not register distributed hardware status listener.");
         return ERR_DH_FWK_POINTER_IS_NULL;
     }
     return DHFWKSAManager::GetInstance().GetDHFWKProxy()->RegisterDHStatusListener(networkId, listener);
@@ -325,7 +325,7 @@ int32_t DistributedHardwareFwkKit::UnregisterDHStatusListener(
     }
     DHLOGI("Unregister distributed hardware status source listener %{public}s.", GetAnonyString(networkId).c_str());
     if (DHFWKSAManager::GetInstance().GetDHFWKProxy() == nullptr) {
-        DHLOGI("DHFWK not online or get proxy failed, can not register av control center callback.");
+        DHLOGI("DHFWK not online or get proxy failed, can not unregister distributed hardware status listener.");
         return ERR_DH_FWK_POINTER_IS_NULL;
     }
     return DHFWKSAManager::GetInstance().GetDHFWKProxy()->UnregisterDHStatusListener(networkId, listener);
@@ -335,7 +335,7 @@ int32_t DistributedHardwareFwkKit::EnableSink(const std::vector<DHDescriptor> &d
 {
     DHLOGI("Enable distributed hardware sink descriptors %{public}s.", DumpDescriptors(descriptors).c_str());
     if (DHFWKSAManager::GetInstance().GetDHFWKProxy() == nullptr) {
-        DHLOGI("DHFWK not online or get proxy failed, can not register av control center callback.");
+        DHLOGI("DHFWK not online or get proxy failed, can not enable sink.");
         return ERR_DH_FWK_POINTER_IS_NULL;
     }
     return DHFWKSAManager::GetInstance().GetDHFWKProxy()->EnableSink(descriptors);
@@ -345,7 +345,7 @@ int32_t DistributedHardwareFwkKit::DisableSink(const std::vector<DHDescriptor> &
 {
     DHLOGI("Disable distributed hardware sink descriptors %{public}s.", DumpDescriptors(descriptors).c_str());
     if (DHFWKSAManager::GetInstance().GetDHFWKProxy() == nullptr) {
-        DHLOGI("DHFWK not online or get proxy failed, can not register av control center callback.");
+        DHLOGI("DHFWK not online or get proxy failed, can not disable sink.");
         return ERR_DH_FWK_POINTER_IS_NULL;
     }
     return DHFWKSAManager::GetInstance().GetDHFWKProxy()->DisableSink(descriptors);
@@ -360,7 +360,7 @@ int32_t DistributedHardwareFwkKit::EnableSource(
     DHLOGI("Enable distributed hardware source networkId %{public}s, descriptors %{public}s.",
         GetAnonyString(networkId).c_str(), DumpDescriptors(descriptors).c_str());
     if (DHFWKSAManager::GetInstance().GetDHFWKProxy() == nullptr) {
-        DHLOGI("DHFWK not online or get proxy failed, can not register av control center callback.");
+        DHLOGI("DHFWK not online or get proxy failed, can not enable source.");
         return ERR_DH_FWK_POINTER_IS_NULL;
     }
     return DHFWKSAManager::GetInstance().GetDHFWKProxy()->EnableSource(networkId, descriptors);
@@ -375,10 +375,30 @@ int32_t DistributedHardwareFwkKit::DisableSource(
     DHLOGI("Disable distributed hardware source networkId %{public}s, descriptors %{public}s.",
         GetAnonyString(networkId).c_str(), DumpDescriptors(descriptors).c_str());
     if (DHFWKSAManager::GetInstance().GetDHFWKProxy() == nullptr) {
-        DHLOGI("DHFWK not online or get proxy failed, can not register av control center callback.");
+        DHLOGI("DHFWK not online or get proxy failed, can not disable source.");
         return ERR_DH_FWK_POINTER_IS_NULL;
     }
     return DHFWKSAManager::GetInstance().GetDHFWKProxy()->DisableSource(networkId, descriptors);
 }
+
+int32_t DistributedHardwareFwkKit::LoadDistributedHDF(const DHType dhType)
+{
+    DHLOGI("Load distributed HDF, dhType: %{public}u.", dhType);
+    if (DHFWKSAManager::GetInstance().GetDHFWKProxy() == nullptr) {
+        DHLOGI("DHFWK not online or get proxy failed, can not load distributed HDF.");
+        return ERR_DH_FWK_POINTER_IS_NULL;
+    }
+    return DHFWKSAManager::GetInstance().GetDHFWKProxy()->LoadDistributedHDF(dhType);
+}
+
+int32_t DistributedHardwareFwkKit::UnLoadDistributedHDF(const DHType dhType)
+{
+    DHLOGI("UnLoad distributed HDF, dhType: %{public}u.", dhType);
+    if (DHFWKSAManager::GetInstance().GetDHFWKProxy() == nullptr) {
+        DHLOGI("DHFWK not online or get proxy failed, can not unload distributed HDF.");
+        return ERR_DH_FWK_POINTER_IS_NULL;
+    }
+    return DHFWKSAManager::GetInstance().GetDHFWKProxy()->UnLoadDistributedHDF(dhType);
+}
 } // DistributedHardware
 } // OHOS
\ No newline at end of file
diff --git a/interfaces/inner_kits/src/ipc/distributed_hardware_proxy.cpp b/interfaces/inner_kits/src/ipc/distributed_hardware_proxy.cpp
index 47ee352db885aa38588b58f8b7ae2fa6008c8d69..d3f104ce5d6d649f2dff14cdb8856ba7d067d14c 100644
--- a/interfaces/inner_kits/src/ipc/distributed_hardware_proxy.cpp
+++ b/interfaces/inner_kits/src/ipc/distributed_hardware_proxy.cpp
@@ -578,6 +578,10 @@ int32_t DistributedHardwareProxy::GetDistributedHardware(const std::string &netw
 int32_t DistributedHardwareProxy::RegisterDHStatusListener(sptr<IHDSinkStatusListener> listener)
 {
     DHLOGI("DistributedHardwareProxy RegisterDHStatusListener.");
+    if (listener == nullptr) {
+        DHLOGE("status listener is null");
+        return ERR_DH_FWK_STATUS_LISTENER_IS_NULL;
+    }
     sptr<IRemoteObject> remote = Remote();
     if (remote == nullptr) {
         DHLOGE("remote service is null!");
@@ -606,6 +610,10 @@ int32_t DistributedHardwareProxy::RegisterDHStatusListener(sptr<IHDSinkStatusLis
 int32_t DistributedHardwareProxy::UnregisterDHStatusListener(sptr<IHDSinkStatusListener> listener)
 {
     DHLOGI("DistributedHardwareProxy UnregisterDHStatusListener.");
+    if (listener == nullptr) {
+        DHLOGE("status listener is null");
+        return ERR_DH_FWK_STATUS_LISTENER_IS_NULL;
+    }
     sptr<IRemoteObject> remote = Remote();
     if (remote == nullptr) {
         DHLOGE("remote service is null!");
@@ -635,6 +643,10 @@ int32_t DistributedHardwareProxy::RegisterDHStatusListener(
     const std::string &networkId, sptr<IHDSourceStatusListener> listener)
 {
     DHLOGI("DistributedHardwareProxy RegisterDHStatusListener.");
+    if (listener == nullptr) {
+        DHLOGE("status listener is null");
+        return ERR_DH_FWK_STATUS_LISTENER_IS_NULL;
+    }
     if (!IsIdLengthValid(networkId)) {
         return ERR_DH_FWK_PARA_INVALID;
     }
@@ -671,6 +683,10 @@ int32_t DistributedHardwareProxy::UnregisterDHStatusListener(
     const std::string &networkId, sptr<IHDSourceStatusListener> listener)
 {
     DHLOGI("DistributedHardwareProxy UnregisterDHStatusListener.");
+    if (listener == nullptr) {
+        DHLOGE("status listener is null");
+        return ERR_DH_FWK_STATUS_LISTENER_IS_NULL;
+    }
     if (!IsIdLengthValid(networkId)) {
         return ERR_DH_FWK_PARA_INVALID;
     }
@@ -827,6 +843,62 @@ int32_t DistributedHardwareProxy::DisableSource(
     return reply.ReadInt32();
 }
 
+int32_t DistributedHardwareProxy::LoadDistributedHDF(const DHType dhType)
+{
+    sptr<IRemoteObject> remote = Remote();
+    if (remote == nullptr) {
+        DHLOGE("remote service is null");
+        return ERR_DH_AVT_SERVICE_REMOTE_IS_NULL;
+    }
+    MessageParcel data;
+    MessageParcel reply;
+    MessageOption option;
+    if (!data.WriteInterfaceToken(GetDescriptor())) {
+        DHLOGE("WriteInterfaceToken fail!");
+        return ERR_DH_AVT_SERVICE_WRITE_TOKEN_FAIL;
+    }
+    uint32_t type = static_cast<uint32_t>(dhType);
+    if (!data.WriteUint32(type)) {
+        DHLOGE("Write type failed");
+        return ERR_DH_AVT_SERVICE_WRITE_INFO_FAIL;
+    }
+    int32_t ret = remote->SendRequest(static_cast<uint32_t>(DHMsgInterfaceCode::LOAD_HDF),
+        data, reply, option);
+    if (ret != NO_ERROR) {
+        DHLOGE("Send Request failed, ret: %{public}d", ret);
+        return ERR_DH_AVT_SERVICE_IPC_SEND_REQUEST_FAIL;
+    }
+    return reply.ReadInt32();
+}
+
+int32_t DistributedHardwareProxy::UnLoadDistributedHDF(const DHType dhType)
+{
+    sptr<IRemoteObject> remote = Remote();
+    if (remote == nullptr) {
+        DHLOGE("remote service is null");
+        return ERR_DH_AVT_SERVICE_REMOTE_IS_NULL;
+    }
+    MessageParcel data;
+    MessageParcel reply;
+    MessageOption option;
+    if (!data.WriteInterfaceToken(GetDescriptor())) {
+        DHLOGE("WriteInterfaceToken fail!");
+        return ERR_DH_AVT_SERVICE_WRITE_TOKEN_FAIL;
+    }
+    uint32_t type = static_cast<uint32_t>(dhType);
+    if (!data.WriteUint32(type)) {
+        DHLOGE("Write type failed");
+        return ERR_DH_AVT_SERVICE_WRITE_INFO_FAIL;
+    }
+    int32_t ret = remote->SendRequest(static_cast<uint32_t>(DHMsgInterfaceCode::UNLOAD_HDF),
+        data, reply, option);
+    if (ret != NO_ERROR) {
+        DHLOGE("Send Request failed, ret: %{public}d", ret);
+        return ERR_DH_AVT_SERVICE_IPC_SEND_REQUEST_FAIL;
+    }
+    return reply.ReadInt32();
+}
+
 int32_t DistributedHardwareProxy::ReadDescriptors(MessageParcel &data, std::vector<DHDescriptor> &descriptors)
 {
     int32_t size = data.ReadInt32();
diff --git a/interfaces/inner_kits/test/fuzztest/distributedhardwarefwkkit_fuzzer/distributedhardwarefwkkit_fuzzer.cpp b/interfaces/inner_kits/test/fuzztest/distributedhardwarefwkkit_fuzzer/distributedhardwarefwkkit_fuzzer.cpp
index afd2c4a6b638bf432dc0213b105e44a08e1fec49..ec0f72348fdb06aaf00753c55826e89543f8428e 100644
--- a/interfaces/inner_kits/test/fuzztest/distributedhardwarefwkkit_fuzzer/distributedhardwarefwkkit_fuzzer.cpp
+++ b/interfaces/inner_kits/test/fuzztest/distributedhardwarefwkkit_fuzzer/distributedhardwarefwkkit_fuzzer.cpp
@@ -304,6 +304,30 @@ void DisableSinkFuzzTest(const uint8_t *data, size_t size)
     descriptors.push_back(dhDescriptor);
     dhfwkKit.DisableSink(descriptors);
 }
+
+void LoadDistributedHDFFuzzTest(const uint8_t *data, size_t size)
+{
+    if ((data == nullptr) || (size < sizeof(uint32_t))) {
+        return;
+    }
+
+    DHType dhType = static_cast<DHType>(*(reinterpret_cast<const uint32_t*>(data)));
+
+    DistributedHardwareFwkKit dhfwkKit;
+    dhfwkKit.LoadDistributedHDF(dhType);
+}
+
+void UnLoadDistributedHDFFuzzTest(const uint8_t *data, size_t size)
+{
+    if ((data == nullptr) || (size < sizeof(uint32_t))) {
+        return;
+    }
+
+    DHType dhType = static_cast<DHType>(*(reinterpret_cast<const uint32_t*>(data)));
+
+    DistributedHardwareFwkKit dhfwkKit;
+    dhfwkKit.UnLoadDistributedHDF(dhType);
+}
 } // namespace DistributedHardware
 } // namespace OHOS
 
@@ -328,5 +352,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
     OHOS::DistributedHardware::DisableSourceFuzzTest(data, size);
     OHOS::DistributedHardware::EnableSinkFuzzTest(data, size);
     OHOS::DistributedHardware::DisableSinkFuzzTest(data, size);
+    OHOS::DistributedHardware::LoadDistributedHDFFuzzTest(data, size);
+    OHOS::DistributedHardware::UnLoadDistributedHDFFuzzTest(data, size);
     return 0;
 }
\ No newline at end of file
diff --git a/interfaces/inner_kits/test/unittest/common/distributedhardwarefwkkit/src/distributed_hardware_fwk_kit_test.cpp b/interfaces/inner_kits/test/unittest/common/distributedhardwarefwkkit/src/distributed_hardware_fwk_kit_test.cpp
index eb5994952bd5cde0524a5a2a9c1fedd363c94c99..27ecfe959ad5d712e87110711fc6197e1ddba425 100644
--- a/interfaces/inner_kits/test/unittest/common/distributedhardwarefwkkit/src/distributed_hardware_fwk_kit_test.cpp
+++ b/interfaces/inner_kits/test/unittest/common/distributedhardwarefwkkit/src/distributed_hardware_fwk_kit_test.cpp
@@ -603,5 +603,31 @@ HWTEST_F(DistributedHardwareFwkKitTest, DisableSource_001, testing::ext::TestSiz
     ret = dhfwkPtr_->DisableSource(networkId, descriptors);
     EXPECT_EQ(ERR_DH_FWK_POINTER_IS_NULL, ret);
 }
+
+/**
+ * @tc.name: LoadDistributedHDF_001
+ * @tc.desc: Verify the LoadDistributedHDF function
+ * @tc.type: FUNC
+ * @tc.require: AR000GHSJM
+ */
+HWTEST_F(DistributedHardwareFwkKitTest, LoadDistributedHDF_001, testing::ext::TestSize.Level0)
+{
+    ASSERT_TRUE(dhfwkPtr_ != nullptr);
+    int32_t ret = dhfwkPtr_->LoadDistributedHDF(DHType::CAMERA);
+    EXPECT_EQ(ERR_DH_FWK_POINTER_IS_NULL, ret);
+}
+
+/**
+ * @tc.name: UnLoadDistributedHDF_001
+ * @tc.desc: Verify the UnLoadDistributedHDF function
+ * @tc.type: FUNC
+ * @tc.require: AR000GHSJM
+ */
+HWTEST_F(DistributedHardwareFwkKitTest, UnLoadDistributedHDF_001, testing::ext::TestSize.Level0)
+{
+    ASSERT_TRUE(dhfwkPtr_ != nullptr);
+    int32_t ret = dhfwkPtr_->UnLoadDistributedHDF(DHType::CAMERA);
+    EXPECT_EQ(ERR_DH_FWK_POINTER_IS_NULL, ret);
+}
 } // namespace DistributedHardware
 } // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/inner_kits/test/unittest/common/ipc/distributed_hardware_proxy/src/distributed_hardware_proxy_test.cpp b/interfaces/inner_kits/test/unittest/common/ipc/distributed_hardware_proxy/src/distributed_hardware_proxy_test.cpp
index 0195307b1453a40e6fef55f90eb412201671e41a..a318789c972cf1dd1961da250a3d10392a922c86 100644
--- a/interfaces/inner_kits/test/unittest/common/ipc/distributed_hardware_proxy/src/distributed_hardware_proxy_test.cpp
+++ b/interfaces/inner_kits/test/unittest/common/ipc/distributed_hardware_proxy/src/distributed_hardware_proxy_test.cpp
@@ -208,6 +208,18 @@ int32_t DistributedHardwareProxyTest::TestDistributedHardwareStub::DisableSource
     return DH_FWK_SUCCESS;
 }
 
+int32_t DistributedHardwareProxyTest::TestDistributedHardwareStub::LoadDistributedHDF(const DHType dhType)
+{
+    (void)dhType;
+    return DH_FWK_SUCCESS;
+}
+
+int32_t DistributedHardwareProxyTest::TestDistributedHardwareStub::UnLoadDistributedHDF(const DHType dhType)
+{
+    (void)dhType;
+    return DH_FWK_SUCCESS;
+}
+
 void DistributedHardwareProxyTest::TestGetDistributedHardwareCallback::OnSuccess(
     const std::string &networkId, const std::vector<DHDescriptor> &descriptors, EnableStep enableStep)
 {
@@ -586,6 +598,16 @@ HWTEST_F(DistributedHardwareProxyTest, RegisterDHStatusListener_Source_001, Test
     EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
 }
 
+HWTEST_F(DistributedHardwareProxyTest, RegisterDHStatusListener_Source_002, TestSize.Level1)
+{
+    sptr<IRemoteObject> dhStubPtr(new TestDistributedHardwareStub());
+    ASSERT_TRUE(dhStubPtr != nullptr);
+    DistributedHardwareProxy dhProxy(dhStubPtr);
+    sptr<IHDSourceStatusListener> listener(new MockHDSourceStatusListenerStub());
+    auto ret = dhProxy.RegisterDHStatusListener(std::string(), nullptr);
+    EXPECT_EQ(ERR_DH_FWK_STATUS_LISTENER_IS_NULL, ret);
+}
+
 HWTEST_F(DistributedHardwareProxyTest, UnregisterDHStatusListener_Source_001, TestSize.Level1)
 {
     std::string networkId = "123456";
@@ -599,6 +621,16 @@ HWTEST_F(DistributedHardwareProxyTest, UnregisterDHStatusListener_Source_001, Te
     EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
 }
 
+HWTEST_F(DistributedHardwareProxyTest, UnregisterDHStatusListener_Source_002, TestSize.Level1)
+{
+    sptr<IRemoteObject> dhStubPtr(new TestDistributedHardwareStub());
+    ASSERT_TRUE(dhStubPtr != nullptr);
+    DistributedHardwareProxy dhProxy(dhStubPtr);
+    sptr<IHDSourceStatusListener> listener(new MockHDSourceStatusListenerStub());
+    auto ret = dhProxy.UnregisterDHStatusListener(std::string(), nullptr);
+    EXPECT_EQ(ERR_DH_FWK_STATUS_LISTENER_IS_NULL, ret);
+}
+
 HWTEST_F(DistributedHardwareProxyTest, RegisterDHStatusListener_Sink_001, TestSize.Level1)
 {
     sptr<IRemoteObject> dhStubPtr(new TestDistributedHardwareStub());
@@ -609,6 +641,16 @@ HWTEST_F(DistributedHardwareProxyTest, RegisterDHStatusListener_Sink_001, TestSi
     EXPECT_EQ(ERR_DH_AVT_SERVICE_IPC_SEND_REQUEST_FAIL, ret);
 }
 
+HWTEST_F(DistributedHardwareProxyTest, RegisterDHStatusListener_Sink_002, TestSize.Level1)
+{
+    sptr<IRemoteObject> dhStubPtr(new TestDistributedHardwareStub());
+    ASSERT_TRUE(dhStubPtr != nullptr);
+    DistributedHardwareProxy dhProxy(dhStubPtr);
+    sptr<IHDSinkStatusListener> listener(new MockHDSinkStatusListenerStub());
+    auto ret = dhProxy.RegisterDHStatusListener(nullptr);
+    EXPECT_EQ(ERR_DH_FWK_STATUS_LISTENER_IS_NULL, ret);
+}
+
 HWTEST_F(DistributedHardwareProxyTest, UnregisterDHStatusListener_Sink_001, TestSize.Level1)
 {
     sptr<IRemoteObject> dhStubPtr(new TestDistributedHardwareStub());
@@ -619,6 +661,16 @@ HWTEST_F(DistributedHardwareProxyTest, UnregisterDHStatusListener_Sink_001, Test
     EXPECT_EQ(ERR_DH_AVT_SERVICE_IPC_SEND_REQUEST_FAIL, ret);
 }
 
+HWTEST_F(DistributedHardwareProxyTest, UnregisterDHStatusListener_Sink_002, TestSize.Level1)
+{
+    sptr<IRemoteObject> dhStubPtr(new TestDistributedHardwareStub());
+    ASSERT_TRUE(dhStubPtr != nullptr);
+    DistributedHardwareProxy dhProxy(dhStubPtr);
+    sptr<IHDSinkStatusListener> listener(new MockHDSinkStatusListenerStub());
+    auto ret = dhProxy.UnregisterDHStatusListener(nullptr);
+    EXPECT_EQ(ERR_DH_FWK_STATUS_LISTENER_IS_NULL, ret);
+}
+
 HWTEST_F(DistributedHardwareProxyTest, EnableSink_001, TestSize.Level1)
 {
     sptr<IRemoteObject> dhStubPtr(new TestDistributedHardwareStub());
@@ -664,5 +716,39 @@ HWTEST_F(DistributedHardwareProxyTest, DisableSource_001, TestSize.Level1)
     auto ret = dhProxy.DisableSource(networkId, descriptors);
     EXPECT_EQ(ERR_DH_AVT_SERVICE_IPC_SEND_REQUEST_FAIL, ret);
 }
+
+HWTEST_F(DistributedHardwareProxyTest, LoadDistributedHDF_001, TestSize.Level1)
+{
+    sptr<IRemoteObject> dhStubPtr(new TestDistributedHardwareStub());
+    ASSERT_TRUE(dhStubPtr != nullptr);
+    DistributedHardwareProxy dhProxy(dhStubPtr);
+
+    auto ret = dhProxy.LoadDistributedHDF(DHType::CAMERA);
+    EXPECT_EQ(ERR_DH_AVT_SERVICE_IPC_SEND_REQUEST_FAIL, ret);
+}
+
+HWTEST_F(DistributedHardwareProxyTest, LoadDistributedHDF_002, TestSize.Level1)
+{
+    DistributedHardwareProxy dhProxy(nullptr);
+    auto ret = dhProxy.LoadDistributedHDF(DHType::CAMERA);
+    EXPECT_EQ(ERR_DH_AVT_SERVICE_REMOTE_IS_NULL, ret);
+}
+
+HWTEST_F(DistributedHardwareProxyTest, UnLoadDistributedHDF_001, TestSize.Level1)
+{
+    sptr<IRemoteObject> dhStubPtr(new TestDistributedHardwareStub());
+    ASSERT_TRUE(dhStubPtr != nullptr);
+    DistributedHardwareProxy dhProxy(dhStubPtr);
+
+    auto ret = dhProxy.UnLoadDistributedHDF(DHType::CAMERA);
+    EXPECT_EQ(ERR_DH_AVT_SERVICE_IPC_SEND_REQUEST_FAIL, ret);
+}
+
+HWTEST_F(DistributedHardwareProxyTest, UnLoadDistributedHDF_002, TestSize.Level1)
+{
+    DistributedHardwareProxy dhProxy(nullptr);
+    auto ret = dhProxy.UnLoadDistributedHDF(DHType::CAMERA);
+    EXPECT_EQ(ERR_DH_AVT_SERVICE_REMOTE_IS_NULL, ret);
+}
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/distributedhardwarefwkservice/include/hdfoperate/daudio_hdf_operate.h b/services/distributedhardwarefwkservice/include/hdfoperate/daudio_hdf_operate.h
new file mode 100644
index 0000000000000000000000000000000000000000..fa51ef279d6d624f6eadaf19555bf9c7e051361a
--- /dev/null
+++ b/services/distributedhardwarefwkservice/include/hdfoperate/daudio_hdf_operate.h
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2022-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_DAUDIO_HDF_OPERATE_H
+#define OHOS_DAUDIO_HDF_OPERATE_H
+
+#include <atomic>
+#include <condition_variable>
+#include <mutex>
+
+#include "iservstat_listener_hdi.h"
+#include "idevmgr_hdi.h"
+#include "iservmgr_hdi.h"
+#include "single_instance.h"
+#include <v2_0/id_audio_manager.h>
+
+namespace OHOS {
+namespace DistributedHardware {
+const std::string AUDIO_SERVICE_NAME = "daudio_primary_service";
+const std::string AUDIOEXT_SERVICE_NAME = "daudio_ext_service";
+constexpr uint16_t AUDIO_INVALID_VALUE = 0xffff;
+constexpr int32_t AUDIO_WAIT_TIME = 5000;
+using OHOS::HDI::DeviceManager::V1_0::IDeviceManager;
+using OHOS::HDI::ServiceManager::V1_0::IServiceManager;
+using OHOS::HDI::ServiceManager::V1_0::IServStatListener;
+using OHOS::HDI::ServiceManager::V1_0::ServiceStatus;
+using OHOS::HDI::ServiceManager::V1_0::ServStatListenerStub;
+using OHOS::HDI::DistributedAudio::Audioext::V2_0::IDAudioManager;
+using OHOS::HDI::DistributedAudio::Audioext::V2_0::IDAudioHdfCallback;
+using OHOS::HDI::DistributedAudio::Audioext::V2_0::DAudioEvent;
+
+class FwkDAudioHdfCallback;
+class DaudioHdfOperate {
+DECLARE_SINGLE_INSTANCE(DaudioHdfOperate);
+
+public:
+    int32_t LoadDaudioHDFImpl();
+    int32_t UnLoadDaudioHDFImpl();
+    void ResetRefCount();
+
+private:
+    int32_t WaitLoadService(const std::string& servName);
+    OHOS::sptr<IServStatListener> MakeServStatListener();
+    int32_t LoadDevice();
+    int32_t UnLoadDevice();
+    int32_t RegisterHdfListener();
+    int32_t UnRegisterHdfListener();
+
+private:
+    OHOS::sptr<IDeviceManager> devmgr_;
+    OHOS::sptr<IServiceManager> servMgr_;
+    OHOS::sptr<IDAudioManager> audioSrvHdf_;
+    OHOS::sptr<FwkDAudioHdfCallback> fwkDAudioHdfCallback_;
+    std::atomic<uint16_t> audioServStatus_ = AUDIO_INVALID_VALUE;
+    std::atomic<uint16_t> audioextServStatus_ = AUDIO_INVALID_VALUE;
+    std::condition_variable hdfOperateCon_;
+    std::mutex hdfOperateMutex_;
+    int32_t hdfLoadRef_ = 0;
+    std::mutex hdfLoadRefMutex_;
+};
+
+class DAudioHdfServStatListener : public OHOS::HDI::ServiceManager::V1_0::ServStatListenerStub {
+public:
+    using StatusCallback = std::function<void(const ServiceStatus &)>;
+    explicit DAudioHdfServStatListener(StatusCallback callback) : callback_(std::move(callback))
+    {
+    }
+    ~DAudioHdfServStatListener() override = default;
+    void OnReceive(const ServiceStatus& status) override;
+
+private:
+    StatusCallback callback_;
+};
+
+class FwkDAudioHdfCallback : public IDAudioHdfCallback {
+protected:
+    int32_t NotifyEvent(int32_t devId, const DAudioEvent& event) override;
+};
+} // namespace DistributedHardware
+} // namespace OHOS
+#endif // OHOS_DAUDIO_HDF_OPERATE_H
\ No newline at end of file
diff --git a/services/distributedhardwarefwkservice/include/hdfoperate/dcamera_hdf_operate.h b/services/distributedhardwarefwkservice/include/hdfoperate/dcamera_hdf_operate.h
new file mode 100644
index 0000000000000000000000000000000000000000..f7cf7099081b68713d42667ef789facb5b8f114a
--- /dev/null
+++ b/services/distributedhardwarefwkservice/include/hdfoperate/dcamera_hdf_operate.h
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2022-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_DCAMERA_HDF_OPERATE_H
+#define OHOS_DCAMERA_HDF_OPERATE_H
+
+#include <atomic>
+#include <condition_variable>
+#include <mutex>
+
+#include "iservstat_listener_hdi.h"
+#include "idevmgr_hdi.h"
+#include "iservmgr_hdi.h"
+#include "single_instance.h"
+#include "v1_1/id_camera_provider.h"
+
+namespace OHOS {
+namespace DistributedHardware {
+using OHOS::HDI::DeviceManager::V1_0::IDeviceManager;
+using OHOS::HDI::ServiceManager::V1_0::IServiceManager;
+using OHOS::HDI::ServiceManager::V1_0::IServStatListener;
+using OHOS::HDI::ServiceManager::V1_0::ServiceStatus;
+using OHOS::HDI::ServiceManager::V1_0::ServStatListenerStub;
+using OHOS::HDI::DistributedCamera::V1_1::IDCameraProvider;
+using OHOS::HDI::DistributedCamera::V1_1::IDCameraHdfCallback;
+using OHOS::HDI::DistributedCamera::V1_1::DCameraHDFEvent;
+const std::string CAMERA_SERVICE_NAME = "distributed_camera_service";
+const std::string PROVIDER_SERVICE_NAME = "distributed_camera_provider_service";
+constexpr uint16_t CAMERA_INVALID_VALUE = 0xffff;
+constexpr int32_t CAMERA_WAIT_TIME = 2000;
+
+class FwkDCameraHdfCallback;
+class DCameraHdfOperate {
+DECLARE_SINGLE_INSTANCE(DCameraHdfOperate);
+
+public:
+    int32_t LoadDcameraHDFImpl();
+    int32_t UnLoadDcameraHDFImpl();
+    void ResetRefCount();
+
+private:
+    int32_t WaitLoadCameraService();
+    int32_t WaitLoadProviderService();
+    OHOS::sptr<IServStatListener> MakeServStatListener();
+    int32_t LoadDevice();
+    int32_t UnLoadDevice();
+    int32_t RegisterHdfListener();
+    int32_t UnRegisterHdfListener();
+
+private:
+    OHOS::sptr<FwkDCameraHdfCallback> fwkDCameraHdfCallback_;
+    std::atomic<uint16_t> cameraServStatus_ = CAMERA_INVALID_VALUE;
+    std::atomic<uint16_t> providerServStatus_ = CAMERA_INVALID_VALUE;
+    std::condition_variable hdfOperateCon_;
+    std::mutex hdfOperateMutex_;
+    int32_t hdfLoadRef_ = 0;
+    std::mutex hdfLoadRefMutex_;
+};
+
+class DCameraHdfServStatListener : public OHOS::HDI::ServiceManager::V1_0::ServStatListenerStub {
+public:
+    using StatusCallback = std::function<void(const ServiceStatus &)>;
+    explicit DCameraHdfServStatListener(StatusCallback callback) : callback_(std::move(callback))
+    {
+    }
+    ~DCameraHdfServStatListener() override = default;
+    void OnReceive(const ServiceStatus& status) override;
+
+private:
+    StatusCallback callback_;
+};
+
+class FwkDCameraHdfCallback : public IDCameraHdfCallback {
+protected:
+    int32_t NotifyEvent(int32_t devId, const DCameraHDFEvent& event) override;
+};
+} // namespace DistributedHardware
+} // namespace OHOS
+#endif // OHOS_DCAMERA_HDF_OPERATE_H
\ No newline at end of file
diff --git a/services/distributedhardwarefwkservice/src/componentmanager/component_manager.cpp b/services/distributedhardwarefwkservice/src/componentmanager/component_manager.cpp
index 1769e890399eef7871611f2a7080632d1f145f73..b05961a4b1202c0de3eaba8d8f25c9c4df8b8989 100644
--- a/services/distributedhardwarefwkservice/src/componentmanager/component_manager.cpp
+++ b/services/distributedhardwarefwkservice/src/componentmanager/component_manager.cpp
@@ -32,6 +32,8 @@
 #include "component_enable.h"
 #include "component_loader.h"
 #include "constants.h"
+#include "daudio_hdf_operate.h"
+#include "dcamera_hdf_operate.h"
 #include "device_manager.h"
 #include "dh_context.h"
 #include "dh_data_sync_trigger_listener.h"
@@ -639,6 +641,9 @@ void ComponentManager::DoRecover(DHType dhType)
     if (ret != DH_FWK_SUCCESS) {
         DHLOGE("DoRecover setname failed.");
     }
+    // reset hdf load status
+    DHLOGI("Reset HDF load ref for DHType %{public}" PRIu32, (uint32_t)dhType);
+    ResetHdfLoadRefCount(dhType);
     // reset enable status
     DHLOGI("Reset enable status for DHType %{public}" PRIu32, (uint32_t)dhType);
     ResetSinkEnableStatus(dhType);
@@ -1742,6 +1747,20 @@ void ComponentManager::RecoverActiveEnableSource(DHType dhType)
     DHLOGI("RecoverActiveEnableSource end, dhType = %{public}#X.", dhType);
 }
 
+void ComponentManager::ResetHdfLoadRefCount(DHType dhType)
+{
+    switch (dhType) {
+        case DHType::AUDIO:
+            DaudioHdfOperate::GetInstance().ResetRefCount();
+            break;
+        case DHType::CAMERA:
+            DCameraHdfOperate::GetInstance().ResetRefCount();
+            break;
+        default:
+            break;
+    }
+}
+
 int32_t ComponentManager::InitCompSource(DHType dhType)
 {
     std::unique_lock<std::shared_mutex> lock(compSourceMutex_);
diff --git a/services/distributedhardwarefwkservice/src/distributed_hardware_service.cpp b/services/distributedhardwarefwkservice/src/distributed_hardware_service.cpp
index bc63bfd32eb30daf8b48eaecc4f66acac5539bc6..afaa96bc872ca81cd437410ee4286c6fa5c8cdc5 100644
--- a/services/distributedhardwarefwkservice/src/distributed_hardware_service.cpp
+++ b/services/distributedhardwarefwkservice/src/distributed_hardware_service.cpp
@@ -32,6 +32,8 @@
 #include "capability_info_manager.h"
 #include "meta_info_manager.h"
 #include "component_manager.h"
+#include "daudio_hdf_operate.h"
+#include "dcamera_hdf_operate.h"
 #include "dh_context.h"
 #include "dh_utils_tool.h"
 #include "dh_utils_hisysevent.h"
@@ -550,5 +552,31 @@ int32_t DistributedHardwareService::DisableSource(
     }
     return DH_FWK_SUCCESS;
 }
+
+int32_t DistributedHardwareService::LoadDistributedHDF(const DHType dhType)
+{
+    switch (dhType) {
+        case DHType::AUDIO:
+            return DaudioHdfOperate::GetInstance().LoadDaudioHDFImpl();
+        case DHType::CAMERA:
+            return DCameraHdfOperate::GetInstance().LoadDcameraHDFImpl();
+        default:
+            break;
+    }
+    return ERR_DH_FWK_NO_HDF_SUPPORT;
+}
+
+int32_t DistributedHardwareService::UnLoadDistributedHDF(const DHType dhType)
+{
+    switch (dhType) {
+        case DHType::AUDIO:
+            return DaudioHdfOperate::GetInstance().UnLoadDaudioHDFImpl();
+        case DHType::CAMERA:
+            return DCameraHdfOperate::GetInstance().UnLoadDcameraHDFImpl();
+        default:
+            break;
+    }
+    return ERR_DH_FWK_NO_HDF_SUPPORT;
+}
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/distributedhardwarefwkservice/src/distributed_hardware_stub.cpp b/services/distributedhardwarefwkservice/src/distributed_hardware_stub.cpp
index 19c8d50577e58eaf6bb66e7964c94362489ed403..0aeed9455352a246b3f48c360222197960220d22 100644
--- a/services/distributedhardwarefwkservice/src/distributed_hardware_stub.cpp
+++ b/services/distributedhardwarefwkservice/src/distributed_hardware_stub.cpp
@@ -553,6 +553,36 @@ int32_t DistributedHardwareStub::DisableSourceInner(MessageParcel &data, Message
     return DH_FWK_SUCCESS;
 }
 
+int32_t DistributedHardwareStub::LoadDistributedHDFInner(MessageParcel &data, MessageParcel &reply)
+{
+    if (!HasAccessDHPermission()) {
+        DHLOGE("The caller has no ACCESS_DISTRIBUTED_HARDWARE permission.");
+        return ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL;
+    }
+    DHType dhType = static_cast<DHType>(data.ReadUint32());
+    int32_t ret = LoadDistributedHDF(dhType);
+    if (!reply.WriteInt32(ret)) {
+        DHLOGE("Write ret code failed!");
+        return ERR_DH_FWK_SERVICE_WRITE_INFO_FAIL;
+    }
+    return DH_FWK_SUCCESS;
+}
+
+int32_t DistributedHardwareStub::UnLoadDistributedHDFInner(MessageParcel &data, MessageParcel &reply)
+{
+    if (!HasAccessDHPermission()) {
+        DHLOGE("The caller has no ACCESS_DISTRIBUTED_HARDWARE permission.");
+        return ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL;
+    }
+    DHType dhType = static_cast<DHType>(data.ReadUint32());
+    int32_t ret = UnLoadDistributedHDF(dhType);
+    if (!reply.WriteInt32(ret)) {
+        DHLOGE("Write ret code failed!");
+        return ERR_DH_FWK_SERVICE_WRITE_INFO_FAIL;
+    }
+    return DH_FWK_SUCCESS;
+}
+
 int32_t DistributedHardwareStub::ReadDescriptors(MessageParcel &data, std::vector<DHDescriptor> &descriptors)
 {
     int32_t size = data.ReadInt32();
@@ -635,6 +665,12 @@ int32_t DistributedHardwareStub::OnRemoteRequestEx(uint32_t code, MessageParcel
         case static_cast<uint32_t>(DHMsgInterfaceCode::DISABLE_SOURCE): {
             return DisableSourceInner(data, reply);
         }
+        case static_cast<uint32_t>(DHMsgInterfaceCode::LOAD_HDF): {
+            return LoadDistributedHDFInner(data, reply);
+        }
+        case static_cast<uint32_t>(DHMsgInterfaceCode::UNLOAD_HDF): {
+            return UnLoadDistributedHDFInner(data, reply);
+        }
         default:
             return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
     }
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/component_manager_test.cpp b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/component_manager_test.cpp
index 510be3ca49e15ca7afefa5438de9ec923edfb7ae..9d9d05b286b8ab32d9244eb8051c11f9e8363ed9 100644
--- a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/component_manager_test.cpp
+++ b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/component_manager_test.cpp
@@ -926,8 +926,9 @@ HWTEST_F(ComponentManagerTest, Recover_001, TestSize.Level1)
  */
 HWTEST_F(ComponentManagerTest, DoRecover_001, TestSize.Level1)
 {
-    DHType dhType = DHType::CAMERA;
-    ComponentManager::GetInstance().DoRecover(dhType);
+    ComponentManager::GetInstance().DoRecover(DHType::UNKNOWN);
+    ComponentManager::GetInstance().DoRecover(DHType::AUDIO);
+    ComponentManager::GetInstance().DoRecover(DHType::CAMERA);
     EXPECT_EQ(true, ComponentManager::GetInstance().compSource_.empty());
 }
 
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwareservice/src/distributed_hardware_service_test.cpp b/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwareservice/src/distributed_hardware_service_test.cpp
index 1e67bb281ac18fca0512b62e6547fb4ea08f4b29..074df68b573bc4f2e2a591260c7ad65bd0b037f3 100644
--- a/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwareservice/src/distributed_hardware_service_test.cpp
+++ b/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwareservice/src/distributed_hardware_service_test.cpp
@@ -531,5 +531,16 @@ HWTEST_F(DistributedHardwareServiceTest, QueryDhSysSpec_002, TestSize.Level1)
     cJSON_free(cjson1);
     cJSON_Delete(attrJson1);
 }
+
+HWTEST_F(DistributedHardwareServiceTest, LoadDistributedHDF_001, TestSize.Level1)
+{
+    DistributedHardwareService service(ASID, true);
+    EXPECT_EQ(DH_FWK_SUCCESS, service.LoadDistributedHDF(DHType::AUDIO));
+    EXPECT_EQ(DH_FWK_SUCCESS, service.LoadDistributedHDF(DHType::CAMERA));
+    EXPECT_EQ(ERR_DH_FWK_NO_HDF_SUPPORT, service.LoadDistributedHDF(DHType::UNKNOWN));
+    EXPECT_EQ(DH_FWK_SUCCESS, service.UnLoadDistributedHDF(DHType::AUDIO));
+    EXPECT_EQ(DH_FWK_SUCCESS, service.UnLoadDistributedHDF(DHType::CAMERA));
+    EXPECT_EQ(ERR_DH_FWK_NO_HDF_SUPPORT, service.UnLoadDistributedHDF(DHType::UNKNOWN));
+}
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/src/distributed_hardware_stub_test.cpp b/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/src/distributed_hardware_stub_test.cpp
index 4e39062c4e9facce6a05a66399b46b88e41665e4..e8096830c0287fad7ee76a60f95fc9b1573ad6c2 100644
--- a/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/src/distributed_hardware_stub_test.cpp
+++ b/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/src/distributed_hardware_stub_test.cpp
@@ -690,5 +690,37 @@ HWTEST_F(DistributedHardwareStubTest, ValidQueryLocalSpec_002, TestSize.Level1)
     spec = 5;
     EXPECT_EQ(false, stubTest_->ValidQueryLocalSpec(spec));
 }
+
+/**
+ * @tc.name: LoadDistributedHDFInner_001
+ * @tc.desc: Verify the LoadDistributedHDFInner function
+ * @tc.type: FUNC
+ * @tc.require: AR000GHSJM
+ */
+HWTEST_F(DistributedHardwareStubTest, LoadDistributedHDFInner_001, TestSize.Level1)
+{
+    ASSERT_TRUE(stubTest_ != nullptr);
+    ASSERT_TRUE(token_ != nullptr);
+    EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED));
+    MessageParcel data;
+    MessageParcel reply;
+    EXPECT_EQ(DH_FWK_SUCCESS, stubTest_->LoadDistributedHDFInner(data, reply));
+}
+
+/**
+ * @tc.name: UnLoadDistributedHDFInner_001
+ * @tc.desc: Verify the UnLoadDistributedHDFInner function
+ * @tc.type: FUNC
+ * @tc.require: AR000GHSJM
+ */
+HWTEST_F(DistributedHardwareStubTest, UnLoadDistributedHDFInner_001, TestSize.Level1)
+{
+    ASSERT_TRUE(stubTest_ != nullptr);
+    ASSERT_TRUE(token_ != nullptr);
+    EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED));
+    MessageParcel data;
+    MessageParcel reply;
+    EXPECT_EQ(DH_FWK_SUCCESS, stubTest_->UnLoadDistributedHDFInner(data, reply));
+}
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/utils/dh_modem_context_ext_test.cpp b/services/distributedhardwarefwkservice/test/unittest/common/utils/dh_modem_context_ext_test.cpp
index db748356901acc73cefc0b6925ad912d223391ce..873945181bbbcfc6b26386fbf1e4cb37017d26aa 100644
--- a/services/distributedhardwarefwkservice/test/unittest/common/utils/dh_modem_context_ext_test.cpp
+++ b/services/distributedhardwarefwkservice/test/unittest/common/utils/dh_modem_context_ext_test.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
@@ -47,13 +47,6 @@ void DHModemContextExtTest::TearDownTestCase() {}
         EXPECT_EQ(ret, DH_FWK_SUCCESS);
     }
 
-    HWTEST_F(DHModemContextExtTest, GetModemExtInstance_001, TestSize.Level1)
-    {
-        DHModemContextExt::GetInstance().soHandle_ = nullptr;
-        DHModemContextExt::GetInstance().GetModemExtInstance();
-        EXPECT_NE(DHModemContextExt::GetInstance().distributedModemExt_, nullptr);
-    }
-
     HWTEST_F(DHModemContextExtTest, GetModemExtInstance_002, TestSize.Level1)
     {
         int32_t ret = DHModemContextExt::GetInstance().GetHandler();