diff --git a/av_transport/av_trans_engine/filters/test/av_trans_coder_filter_test/av_trans_audio_encoder_filter_test.cpp b/av_transport/av_trans_engine/filters/test/av_trans_coder_filter_test/av_trans_audio_encoder_filter_test.cpp
index c3de3ceee99f458f3c13f8be49a28755f5dc368e..2181295f7ceeed2cc934f6c55d3ac599776ece89 100644
--- a/av_transport/av_trans_engine/filters/test/av_trans_coder_filter_test/av_trans_audio_encoder_filter_test.cpp
+++ b/av_transport/av_trans_engine/filters/test/av_trans_coder_filter_test/av_trans_audio_encoder_filter_test.cpp
@@ -623,5 +623,239 @@ HWTEST_F(AvTransportAudioEncoderFilterTest, OnEncInputBufferAvailable_002, testi
     filter->OnEncInputBufferAvailable(10, normalBuffer);
     delete normalBuffer;
 }
+
+// 测试OnEncOutputBufferAvailable函数中audioEncoder_为nullptr的情况
+HWTEST_F(AvTransportAudioEncoderFilterTest, OnEncOutputBufferAvailable_001, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<Pipeline::AudioEncoderFilter> filter =
+        std::make_shared<Pipeline::AudioEncoderFilter>("builtin.recorder.audioencoderfilter",
+                                                       Pipeline::FilterType::FILTERTYPE_AENC);
+    ASSERT_TRUE(filter != nullptr);
+    
+    // 设置audioEncoder_为nullptr
+    filter->audioEncoder_ = nullptr;
+    filter->isEncoderRunning_.store(true);
+    
+    uint32_t index = 0;
+    OH_AVBuffer *buffer = nullptr;
+    
+    // 应该因为audioEncoder_为nullptr而直接返回
+    ASSERT_NO_FATAL_FAILURE(filter->OnEncOutputBufferAvailable(index, buffer));
+}
+
+// 测试OnEncOutputBufferAvailable函数中isEncoderRunning_为false的情况
+HWTEST_F(AvTransportAudioEncoderFilterTest, OnEncOutputBufferAvailable_002, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<Pipeline::AudioEncoderFilter> filter =
+        std::make_shared<Pipeline::AudioEncoderFilter>("builtin.recorder.audioencoderfilter",
+                                                       Pipeline::FilterType::FILTERTYPE_AENC);
+    ASSERT_TRUE(filter != nullptr);
+    
+    // 设置isEncoderRunning_为false
+    filter->audioEncoder_ = reinterpret_cast<OH_AVCodec*>(0x12345678); // 非空值
+    filter->isEncoderRunning_.store(false);
+    
+    uint32_t index = 0;
+    OH_AVBuffer *buffer = nullptr;
+    
+    // 应该因为isEncoderRunning_为false而直接返回
+    ASSERT_NO_FATAL_FAILURE(filter->OnEncOutputBufferAvailable(index, buffer));
+}
+
+// 测试OnEncOutputBufferAvailable函数中buffer为nullptr的情况
+HWTEST_F(AvTransportAudioEncoderFilterTest, OnEncOutputBufferAvailable_003, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<Pipeline::AudioEncoderFilter> filter =
+        std::make_shared<Pipeline::AudioEncoderFilter>("builtin.recorder.audioencoderfilter",
+                                                       Pipeline::FilterType::FILTERTYPE_AENC);
+    ASSERT_TRUE(filter != nullptr);
+    
+    // 设置正常运行条件
+    filter->audioEncoder_ = reinterpret_cast<OH_AVCodec*>(0x12345678); // 非空值
+    filter->isEncoderRunning_.store(true);
+    
+    uint32_t index = 0;
+    OH_AVBuffer *buffer = nullptr; // nullptr值
+    
+    // 应该因为buffer为nullptr而直接返回
+    ASSERT_NO_FATAL_FAILURE(filter->OnEncOutputBufferAvailable(index, buffer));
+}
+
+// 测试OnEncOutputBufferAvailable函数中buffer->buffer_为nullptr的情况
+HWTEST_F(AvTransportAudioEncoderFilterTest, OnEncOutputBufferAvailable_004, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<Pipeline::AudioEncoderFilter> filter =
+        std::make_shared<Pipeline::AudioEncoderFilter>("builtin.recorder.audioencoderfilter",
+                                                       Pipeline::FilterType::FILTERTYPE_AENC);
+    ASSERT_TRUE(filter != nullptr);
+    
+    // 设置正常运行条件
+    filter->audioEncoder_ = reinterpret_cast<OH_AVCodec*>(0x12345678); // 非空值
+    filter->isEncoderRunning_.store(true);
+    
+    uint32_t index = 0;
+    OH_AVBuffer *buffer = new OH_AVBuffer(nullptr); // buffer->buffer_为nullptr
+    
+    // 应该因为buffer->buffer_为nullptr而直接返回
+    ASSERT_NO_FATAL_FAILURE(filter->OnEncOutputBufferAvailable(index, buffer));
+    
+    delete buffer;
+}
+
+// 测试OnEncOutputBufferAvailable函数中outputProducer_为nullptr的情况
+HWTEST_F(AvTransportAudioEncoderFilterTest, OnEncOutputBufferAvailable_005, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<Pipeline::AudioEncoderFilter> filter =
+        std::make_shared<Pipeline::AudioEncoderFilter>("builtin.recorder.audioencoderfilter",
+                                                       Pipeline::FilterType::FILTERTYPE_AENC);
+    ASSERT_TRUE(filter != nullptr);
+    
+    // 设置正常运行条件
+    filter->audioEncoder_ = reinterpret_cast<OH_AVCodec*>(0x12345678); // 非空值
+    filter->isEncoderRunning_.store(true);
+    filter->outputProducer_ = nullptr; // outputProducer_为nullptr
+    
+    // 创建有效的buffer
+    std::shared_ptr<Media::AVBuffer> audioData = std::make_shared<Media::AVBuffer>();
+    audioData->memory_ = std::make_shared<Media::AVMemory>();
+    audioData->meta_ = std::make_shared<Media::Meta>();
+    OH_AVBuffer *buffer = new OH_AVBuffer(audioData);
+    
+    uint32_t index = 0;
+    
+    // 应该因为outputProducer_为nullptr而直接返回
+    ASSERT_NO_FATAL_FAILURE(filter->OnEncOutputBufferAvailable(index, buffer));
+    
+    delete buffer;
+}
+
+// 测试OnEncOutputBufferAvailable函数中RequestBuffer失败的情况
+HWTEST_F(AvTransportAudioEncoderFilterTest, OnEncOutputBufferAvailable_006, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<Pipeline::AudioEncoderFilter> filter =
+        std::make_shared<Pipeline::AudioEncoderFilter>("builtin.recorder.audioencoderfilter",
+                                                       Pipeline::FilterType::FILTERTYPE_AENC);
+    ASSERT_TRUE(filter != nullptr);
+    
+    // 设置正常运行条件
+    filter->audioEncoder_ = reinterpret_cast<OH_AVCodec*>(0x12345678); // 非空值
+    filter->isEncoderRunning_.store(true);
+    
+    // 创建outputProducer_但不初始化它，使RequestBuffer失败
+    std::shared_ptr<Media::AVBufferQueue> outputBufQue = Media::AVBufferQueue::Create(
+        DEFAULT_BUFFER_NUM, Media::MemoryType::VIRTUAL_MEMORY, INPUT_BUFFERQUEUE_NAME);
+    filter->outputProducer_ = outputBufQue->GetProducer();
+    
+    // 创建有效的buffer
+    std::shared_ptr<Media::AVBuffer> audioData = std::make_shared<Media::AVBuffer>();
+    audioData->memory_ = std::make_shared<Media::AVMemory>();
+    audioData->meta_ = std::make_shared<Media::Meta>();
+    OH_AVBuffer *buffer = new OH_AVBuffer(audioData);
+    
+    uint32_t index = 0;
+    
+    // 应该因为RequestBuffer失败而直接返回
+    ASSERT_NO_FATAL_FAILURE(filter->OnEncOutputBufferAvailable(index, buffer));
+    
+    delete buffer;
+}
+
+// 测试OnEncOutputBufferAvailable函数中outBuffer->meta_为nullptr的情况
+HWTEST_F(AvTransportAudioEncoderFilterTest, OnEncOutputBufferAvailable_007, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<Pipeline::AudioEncoderFilter> filter =
+        std::make_shared<Pipeline::AudioEncoderFilter>("builtin.recorder.audioencoderfilter",
+                                                       Pipeline::FilterType::FILTERTYPE_AENC);
+    ASSERT_TRUE(filter != nullptr);
+    
+    // 设置正常运行条件
+    filter->audioEncoder_ = reinterpret_cast<OH_AVCodec*>(0x12345678); // 非空值
+    filter->isEncoderRunning_.store(true);
+    
+    // 创建outputProducer_
+    std::shared_ptr<Media::AVBufferQueue> outputBufQue = Media::AVBufferQueue::Create(
+        DEFAULT_BUFFER_NUM, Media::MemoryType::VIRTUAL_MEMORY, INPUT_BUFFERQUEUE_NAME);
+    filter->outputProducer_ = outputBufQue->GetProducer();
+    
+    // 创建有效的buffer
+    std::shared_ptr<Media::AVBuffer> audioData = std::make_shared<Media::AVBuffer>();
+    audioData->memory_ = std::make_shared<Media::AVMemory>();
+    audioData->meta_ = std::make_shared<Media::Meta>();
+    OH_AVBuffer *buffer = new OH_AVBuffer(audioData);
+    
+    // 模拟RequestBuffer成功但返回的outBuffer->meta_为nullptr的情况
+    // 这需要更复杂的mock机制，这里只是示意性测试
+    
+    uint32_t index = 0;
+    
+    ASSERT_NO_FATAL_FAILURE(filter->OnEncOutputBufferAvailable(index, buffer));
+    
+    delete buffer;
+}
+
+// 测试OnEncOutputBufferAvailable函数正常执行的情况
+HWTEST_F(AvTransportAudioEncoderFilterTest, OnEncOutputBufferAvailable_008, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<Pipeline::AudioEncoderFilter> filter =
+        std::make_shared<Pipeline::AudioEncoderFilter>("builtin.recorder.audioencoderfilter",
+                                                       Pipeline::FilterType::FILTERTYPE_AENC);
+    ASSERT_TRUE(filter != nullptr);
+    
+    // 设置正常运行条件
+    filter->audioEncoder_ = reinterpret_cast<OH_AVCodec*>(0x12345678); // 非空值
+    filter->isEncoderRunning_.store(true);
+    
+    // 创建outputProducer_
+    std::shared_ptr<Media::AVBufferQueue> outputBufQue = Media::AVBufferQueue::Create(
+        DEFAULT_BUFFER_NUM, Media::MemoryType::VIRTUAL_MEMORY, INPUT_BUFFERQUEUE_NAME);
+    filter->outputProducer_ = outputBufQue->GetProducer();
+    
+    // 创建有效的buffer
+    std::shared_ptr<Media::AVBuffer> audioData = std::make_shared<Media::AVBuffer>();
+    audioData->memory_ = std::make_shared<Media::AVMemory>();
+    audioData->meta_ = std::make_shared<Media::Meta>();
+    OH_AVBuffer *buffer = new OH_AVBuffer(audioData);
+    
+    uint32_t index = 0;
+    
+    // 正常执行
+    ASSERT_NO_FATAL_FAILURE(filter->OnEncOutputBufferAvailable(index, buffer));
+    
+    delete buffer;
+}
+
+// 测试OnEncOutputBufferAvailable函数中frameOutIndex_等于indexFlag_的特殊情况
+HWTEST_F(AvTransportAudioEncoderFilterTest, OnEncOutputBufferAvailable_009, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<Pipeline::AudioEncoderFilter> filter =
+        std::make_shared<Pipeline::AudioEncoderFilter>("builtin.recorder.audioencoderfilter",
+                                                       Pipeline::FilterType::FILTERTYPE_AENC);
+    ASSERT_TRUE(filter != nullptr);
+    
+    // 设置正常运行条件
+    filter->audioEncoder_ = reinterpret_cast<OH_AVCodec*>(0x12345678); // 非空值
+    filter->isEncoderRunning_.store(true);
+    filter->frameOutIndex_ = 5; // 设置frameOutIndex_
+    filter->indexFlag_ = 5; // 使frameOutIndex_等于indexFlag_
+    
+    // 创建outputProducer_
+    std::shared_ptr<Media::AVBufferQueue> outputBufQue = Media::AVBufferQueue::Create(
+        DEFAULT_BUFFER_NUM, Media::MemoryType::VIRTUAL_MEMORY, INPUT_BUFFERQUEUE_NAME);
+    filter->outputProducer_ = outputBufQue->GetProducer();
+    
+    // 创建有效的buffer
+    std::shared_ptr<Media::AVBuffer> audioData = std::make_shared<Media::AVBuffer>();
+    audioData->memory_ = std::make_shared<Media::AVMemory>();
+    audioData->meta_ = std::make_shared<Media::Meta>();
+    OH_AVBuffer *buffer = new OH_AVBuffer(audioData);
+    
+    uint32_t index = 0;
+    
+    // 测试frameOutIndex_等于indexFlag_的特殊情况
+    ASSERT_NO_FATAL_FAILURE(filter->OnEncOutputBufferAvailable(index, buffer));
+    
+    delete buffer;
+}
+
 } // namespace DistributedHardware
 } // namespace OHOS
\ No newline at end of file
diff --git a/av_transport/av_trans_engine/filters/test/av_trans_input_filter_test/av_trans_bus_input_filter_test.cpp b/av_transport/av_trans_engine/filters/test/av_trans_input_filter_test/av_trans_bus_input_filter_test.cpp
index ef66331b71f95bb0c029e3c728175abf9c16e1bd..b2b95890fb50ded1a777174a9101c06a1f42e8ba 100644
--- a/av_transport/av_trans_engine/filters/test/av_trans_input_filter_test/av_trans_bus_input_filter_test.cpp
+++ b/av_transport/av_trans_engine/filters/test/av_trans_input_filter_test/av_trans_bus_input_filter_test.cpp
@@ -425,7 +425,8 @@ HWTEST_F(AvTransportBusInputFilterTest, UnmarshalAudioMeta_001, testing::ext::Te
             Pipeline::FilterType::AUDIO_DATA_SOURCE);
     ASSERT_TRUE(avBusInputTest_ != nullptr);
     int64_t pts= 0;
-    bool ret = avBusInputTest_->UnmarshalAudioMeta("", pts);
+    int64_t ptsSpecial= 0;
+    bool ret = avBusInputTest_->UnmarshalAudioMeta("", pts, ptsSpecial);
     EXPECT_EQ(false, ret);
 }
 
@@ -436,10 +437,252 @@ HWTEST_F(AvTransportBusInputFilterTest, UnmarshalAudioMeta_002, testing::ext::Te
             Pipeline::FilterType::AUDIO_DATA_SOURCE);
     ASSERT_TRUE(avBusInputTest_ != nullptr);
     int64_t pts= 1;
-    bool ret = avBusInputTest_->UnmarshalAudioMeta("AUDIO", pts);
+    int64_t ptsSpecial= 1;
+    bool ret = avBusInputTest_->UnmarshalAudioMeta("AUDIO", pts, ptsSpecial);
     EXPECT_EQ(false, ret);
 }
 
+// 测试缺少meta_timestamp字段的情况
+HWTEST_F(AvTransportBusInputFilterTest, UnmarshalAudioMeta_003, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<Pipeline::AVTransBusInputFilter> avBusInputTest_ =
+        std::make_shared<Pipeline::AVTransBusInputFilter>("builtin.avtrans.softbus.input",
+            Pipeline::FilterType::AUDIO_DATA_SOURCE);
+    ASSERT_TRUE(avBusInputTest_ != nullptr);
+    int64_t pts = 0;
+    int64_t ptsSpecial = 0;
+    
+    // 创建缺少meta_timestamp字段的JSON
+    cJSON *jsonObj = cJSON_CreateObject();
+    cJSON_AddStringToObject(jsonObj, "meta_timestamp_string", "123456");
+    cJSON_AddStringToObject(jsonObj, "meta_timestamp_special", "789012");
+    char *jsonStr = cJSON_PrintUnformatted(jsonObj);
+    
+    bool ret = avBusInputTest_->UnmarshalAudioMeta(std::string(jsonStr), pts, ptsSpecial);
+    EXPECT_EQ(false, ret);
+    
+    cJSON_free(jsonStr);
+    cJSON_Delete(jsonObj);
+}
+
+// 测试meta_timestamp字段不是数字的情况
+HWTEST_F(AvTransportBusInputFilterTest, UnmarshalAudioMeta_004, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<Pipeline::AVTransBusInputFilter> avBusInputTest_ =
+        std::make_shared<Pipeline::AVTransBusInputFilter>("builtin.avtrans.softbus.input",
+            Pipeline::FilterType::AUDIO_DATA_SOURCE);
+    ASSERT_TRUE(avBusInputTest_ != nullptr);
+    int64_t pts = 0;
+    int64_t ptsSpecial = 0;
+    
+    // 创建meta_timestamp字段为字符串的JSON
+    cJSON *jsonObj = cJSON_CreateObject();
+    cJSON_AddStringToObject(jsonObj, "meta_timestamp", "not_a_number");
+    cJSON_AddStringToObject(jsonObj, "meta_timestamp_string", "123456");
+    cJSON_AddStringToObject(jsonObj, "meta_timestamp_special", "789012");
+    char *jsonStr = cJSON_PrintUnformatted(jsonObj);
+    
+    bool ret = avBusInputTest_->UnmarshalAudioMeta(std::string(jsonStr), pts, ptsSpecial);
+    EXPECT_EQ(false, ret);
+    
+    cJSON_free(jsonStr);
+    cJSON_Delete(jsonObj);
+}
+
+// 测试缺少meta_timestamp_string字段的情况
+HWTEST_F(AvTransportBusInputFilterTest, UnmarshalAudioMeta_005, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<Pipeline::AVTransBusInputFilter> avBusInputTest_ =
+        std::make_shared<Pipeline::AVTransBusInputFilter>("builtin.avtrans.softbus.input",
+            Pipeline::FilterType::AUDIO_DATA_SOURCE);
+    ASSERT_TRUE(avBusInputTest_ != nullptr);
+    int64_t pts = 0;
+    int64_t ptsSpecial = 0;
+    
+    // 创建缺少meta_timestamp_string字段的JSON
+    cJSON *jsonObj = cJSON_CreateObject();
+    cJSON_AddNumberToObject(jsonObj, "meta_timestamp", 123456);
+    cJSON_AddStringToObject(jsonObj, "meta_timestamp_special", "789012");
+    char *jsonStr = cJSON_PrintUnformatted(jsonObj);
+    
+    bool ret = avBusInputTest_->UnmarshalAudioMeta(std::string(jsonStr), pts, ptsSpecial);
+    EXPECT_EQ(false, ret);
+    
+    cJSON_free(jsonStr);
+    cJSON_Delete(jsonObj);
+}
+
+// 测试meta_timestamp_string字段不是字符串的情况
+HWTEST_F(AvTransportBusInputFilterTest, UnmarshalAudioMeta_006, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<Pipeline::AVTransBusInputFilter> avBusInputTest_ =
+        std::make_shared<Pipeline::AVTransBusInputFilter>("builtin.avtrans.softbus.input",
+            Pipeline::FilterType::AUDIO_DATA_SOURCE);
+    ASSERT_TRUE(avBusInputTest_ != nullptr);
+    int64_t pts = 0;
+    int64_t ptsSpecial = 0;
+    
+    // 创建meta_timestamp_string字段为数字的JSON
+    cJSON *jsonObj = cJSON_CreateObject();
+    cJSON_AddNumberToObject(jsonObj, "meta_timestamp", 123456);
+    cJSON_AddNumberToObject(jsonObj, "meta_timestamp_string", 123456);
+    cJSON_AddStringToObject(jsonObj, "meta_timestamp_special", "789012");
+    char *jsonStr = cJSON_PrintUnformatted(jsonObj);
+    
+    bool ret = avBusInputTest_->UnmarshalAudioMeta(std::string(jsonStr), pts, ptsSpecial);
+    EXPECT_EQ(false, ret);
+    
+    cJSON_free(jsonStr);
+    cJSON_Delete(jsonObj);
+}
+
+// 测试meta_timestamp_string字段为空字符串的情况
+HWTEST_F(AvTransportBusInputFilterTest, UnmarshalAudioMeta_007, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<Pipeline::AVTransBusInputFilter> avBusInputTest_ =
+        std::make_shared<Pipeline::AVTransBusInputFilter>("builtin.avtrans.softbus.input",
+            Pipeline::FilterType::AUDIO_DATA_SOURCE);
+    ASSERT_TRUE(avBusInputTest_ != nullptr);
+    int64_t pts = 0;
+    int64_t ptsSpecial = 0;
+    
+    // 创建meta_timestamp_string字段为空的JSON
+    cJSON *jsonObj = cJSON_CreateObject();
+    cJSON_AddNumberToObject(jsonObj, "meta_timestamp", 123456);
+    cJSON_AddStringToObject(jsonObj, "meta_timestamp_string", "");
+    cJSON_AddStringToObject(jsonObj, "meta_timestamp_special", "789012");
+    char *jsonStr = cJSON_PrintUnformatted(jsonObj);
+    
+    bool ret = avBusInputTest_->UnmarshalAudioMeta(std::string(jsonStr), pts, ptsSpecial);
+    EXPECT_EQ(false, ret);
+    
+    cJSON_free(jsonStr);
+    cJSON_Delete(jsonObj);
+}
+
+// 测试缺少meta_timestamp_special字段的情况
+HWTEST_F(AvTransportBusInputFilterTest, UnmarshalAudioMeta_008, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<Pipeline::AVTransBusInputFilter> avBusInputTest_ =
+        std::make_shared<Pipeline::AVTransBusInputFilter>("builtin.avtrans.softbus.input",
+            Pipeline::FilterType::AUDIO_DATA_SOURCE);
+    ASSERT_TRUE(avBusInputTest_ != nullptr);
+    int64_t pts = 0;
+    int64_t ptsSpecial = 0;
+    
+    // 创建缺少meta_timestamp_special字段的JSON
+    cJSON *jsonObj = cJSON_CreateObject();
+    cJSON_AddNumberToObject(jsonObj, "meta_timestamp", 123456);
+    cJSON_AddStringToObject(jsonObj, "meta_timestamp_string", "123456");
+    char *jsonStr = cJSON_PrintUnformatted(jsonObj);
+    
+    bool ret = avBusInputTest_->UnmarshalAudioMeta(std::string(jsonStr), pts, ptsSpecial);
+    EXPECT_EQ(false, ret);
+    
+    cJSON_free(jsonStr);
+    cJSON_Delete(jsonObj);
+}
+
+// 测试meta_timestamp_special字段不是字符串的情况
+HWTEST_F(AvTransportBusInputFilterTest, UnmarshalAudioMeta_009, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<Pipeline::AVTransBusInputFilter> avBusInputTest_ =
+        std::make_shared<Pipeline::AVTransBusInputFilter>("builtin.avtrans.softbus.input",
+            Pipeline::FilterType::AUDIO_DATA_SOURCE);
+    ASSERT_TRUE(avBusInputTest_ != nullptr);
+    int64_t pts = 0;
+    int64_t ptsSpecial = 0;
+    
+    // 创建meta_timestamp_special字段为数字的JSON
+    cJSON *jsonObj = cJSON_CreateObject();
+    cJSON_AddNumberToObject(jsonObj, "meta_timestamp", 123456);
+    cJSON_AddStringToObject(jsonObj, "meta_timestamp_string", "123456");
+    cJSON_AddNumberToObject(jsonObj, "meta_timestamp_special", 789012);
+    char *jsonStr = cJSON_PrintUnformatted(jsonObj);
+    
+    bool ret = avBusInputTest_->UnmarshalAudioMeta(std::string(jsonStr), pts, ptsSpecial);
+    EXPECT_EQ(false, ret);
+    
+    cJSON_free(jsonStr);
+    cJSON_Delete(jsonObj);
+}
+
+// 测试meta_timestamp_special字段为空字符串的情况
+HWTEST_F(AvTransportBusInputFilterTest, UnmarshalAudioMeta_010, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<Pipeline::AVTransBusInputFilter> avBusInputTest_ =
+        std::make_shared<Pipeline::AVTransBusInputFilter>("builtin.avtrans.softbus.input",
+            Pipeline::FilterType::AUDIO_DATA_SOURCE);
+    ASSERT_TRUE(avBusInputTest_ != nullptr);
+    int64_t pts = 0;
+    int64_t ptsSpecial = 0;
+    
+    // 创建meta_timestamp_special字段为空的JSON
+    cJSON *jsonObj = cJSON_CreateObject();
+    cJSON_AddNumberToObject(jsonObj, "meta_timestamp", 123456);
+    cJSON_AddStringToObject(jsonObj, "meta_timestamp_string", "123456");
+    cJSON_AddStringToObject(jsonObj, "meta_timestamp_special", "");
+    char *jsonStr = cJSON_PrintUnformatted(jsonObj);
+    
+    bool ret = avBusInputTest_->UnmarshalAudioMeta(std::string(jsonStr), pts, ptsSpecial);
+    EXPECT_EQ(false, ret);
+    
+    cJSON_free(jsonStr);
+    cJSON_Delete(jsonObj);
+}
+
+// 测试正常情况，所有字段都正确
+HWTEST_F(AvTransportBusInputFilterTest, UnmarshalAudioMeta_011, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<Pipeline::AVTransBusInputFilter> avBusInputTest_ =
+        std::make_shared<Pipeline::AVTransBusInputFilter>("builtin.avtrans.softbus.input",
+            Pipeline::FilterType::AUDIO_DATA_SOURCE);
+    ASSERT_TRUE(avBusInputTest_ != nullptr);
+    int64_t pts = 0;
+    int64_t ptsSpecial = 0;
+    
+    // 创建包含所有正确字段的JSON
+    cJSON *jsonObj = cJSON_CreateObject();
+    cJSON_AddNumberToObject(jsonObj, "meta_timestamp", 123456);
+    cJSON_AddStringToObject(jsonObj, "meta_timestamp_string", "123456");
+    cJSON_AddStringToObject(jsonObj, "meta_timestamp_special", "789012");
+    char *jsonStr = cJSON_PrintUnformatted(jsonObj);
+    
+    bool ret = avBusInputTest_->UnmarshalAudioMeta(std::string(jsonStr), pts, ptsSpecial);
+    EXPECT_EQ(true, ret);
+    EXPECT_EQ(123456, pts);
+    EXPECT_EQ(789012, ptsSpecial);
+    
+    cJSON_free(jsonStr);
+    cJSON_Delete(jsonObj);
+}
+
+// 测试使用stoll转换大数字的情况
+HWTEST_F(AvTransportBusInputFilterTest, UnmarshalAudioMeta_012, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<Pipeline::AVTransBusInputFilter> avBusInputTest_ =
+        std::make_shared<Pipeline::AVTransBusInputFilter>("builtin.avtrans.softbus.input",
+            Pipeline::FilterType::AUDIO_DATA_SOURCE);
+    ASSERT_TRUE(avBusInputTest_ != nullptr);
+    int64_t pts = 0;
+    int64_t ptsSpecial = 0;
+    
+    // 创建包含大数字的JSON
+    cJSON *jsonObj = cJSON_CreateObject();
+    cJSON_AddNumberToObject(jsonObj, "meta_timestamp", 9876543210LL);
+    cJSON_AddStringToObject(jsonObj, "meta_timestamp_string", "9876543210");
+    cJSON_AddStringToObject(jsonObj, "meta_timestamp_special", "1234567890");
+    char *jsonStr = cJSON_PrintUnformatted(jsonObj);
+    
+    bool ret = avBusInputTest_->UnmarshalAudioMeta(std::string(jsonStr), pts, ptsSpecial);
+    EXPECT_EQ(true, ret);
+    EXPECT_EQ(9876543210LL, pts);
+    EXPECT_EQ(1234567890LL, ptsSpecial);
+    
+    cJSON_free(jsonStr);
+    cJSON_Delete(jsonObj);
+}
+
 HWTEST_F(AvTransportBusInputFilterTest, TransName2PkgName_001, testing::ext::TestSize.Level1)
 {
     std::shared_ptr<Pipeline::AVTransBusInputFilter> avBusInputTest_ =
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 71d7c200e0c3d2593dd8bba2bb9cefd92b1cf5a3..cc1db8b99a3960ce77808cd066129e3ef1cbff6e 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
@@ -75,6 +75,7 @@ const std::string DH_SUBTYPE_TEST = "camera";
 const std::string TEST_SOURCE_VERSION_1 = "2.2";
 const std::string TEST_SINK_VERSION_1 = "2.4";
 const std::string TEST_DH_VERSION = "3.1";
+constexpr uint16_t DEV_TYPE_TEST = 14;
 const std::shared_ptr<CapabilityInfo> CAP_INFO_TEST =
     std::make_shared<CapabilityInfo>(DH_ID_TEST, DEV_ID_TEST, DEVICE_NAME, TEST_DEV_TYPE_PAD, DHType::CAMERA, DH_ATTR_1,
     DH_SUBTYPE_TEST);
@@ -1059,308 +1060,479 @@ HWTEST_F(ComponentManagerTest, UpdateBusinessState_002, TestSize.Level1)
     EXPECT_NO_FATAL_FAILURE(ComponentManager::GetInstance().UpdateBusinessState(NETWORK_TEST, DH_ID_TEST, state));
 }
 
-HWTEST_F(ComponentManagerTest, QueryBusinessState_001, TestSize.Level1)
+HWTEST_F(ComponentManagerTest, UpdateBusinessState_003, TestSize.Level1)
 {
-    BusinessState ret = ComponentManager::GetInstance().QueryBusinessState("", "");
-    EXPECT_EQ(BusinessState::UNKNOWN, ret);
-
-    ret = ComponentManager::GetInstance().QueryBusinessState(UUID_TEST, "");
-    EXPECT_EQ(BusinessState::UNKNOWN, ret);
-
-    ret = ComponentManager::GetInstance().QueryBusinessState("", DH_ID_TEST);
-    EXPECT_EQ(BusinessState::UNKNOWN, ret);
+    std::string peeruuid = "123456789";
+    std::string dhid = "audio_132";
+    std::string deviceId = Sha256(peeruuid);
+    BusinessState state = BusinessState::IDLE;
+    std::shared_ptr<CapabilityInfo> capInfo1 = std::make_shared<CapabilityInfo>(
+        dhid, deviceId, "devName_test", DEV_TYPE_TEST, DHType::AUDIO, "attrs", "mic");
+    std::string key = deviceId + "###" + dhid;
+    LocalCapabilityInfoManager::GetInstance()->globalCapInfoMap_[key] = capInfo1;
+    EXPECT_NO_FATAL_FAILURE(ComponentManager::GetInstance().UpdateBusinessState(deviceId, dhid, state));
+
+    dhid = "camera_132";
+    std::shared_ptr<CapabilityInfo> capInfo2 = std::make_shared<CapabilityInfo>(
+        dhid, deviceId, "devName_test", DEV_TYPE_TEST, DHType::CAMERA, "attrs", "camera");
+    key = deviceId + "###" + dhid;
+    LocalCapabilityInfoManager::GetInstance()->globalCapInfoMap_[key] = capInfo2;
+    EXPECT_NO_FATAL_FAILURE(ComponentManager::GetInstance().UpdateBusinessState(deviceId, dhid, state));
+}
+
+HWTEST_F(ComponentManagerTest, GetDHSubtypeByDHId_001, TestSize.Level1)
+{
+    std::string peeruuid = "123456789";
+    std::string dhid = "audio_132";
+    std::string deviceId = Sha256(peeruuid);
+    DHSubtype dhSubtype;
+    std::shared_ptr<CapabilityInfo> capInfo1 = std::make_shared<CapabilityInfo>(
+        dhid, deviceId, "devName_test", DEV_TYPE_TEST, DHType::AUDIO, "attrs", "mic");
+    std::string key = deviceId + "###" + dhid;
+    LocalCapabilityInfoManager::GetInstance()->globalCapInfoMap_[key] = capInfo1;
+    auto ret = ComponentManager::GetInstance().GetDHSubtypeByDHId(dhSubtype, deviceId, dhid);
+    EXPECT_EQ(DHSubtype::AUDIO_MIC, dhSubtype);
+    EXPECT_EQ(ret, DH_FWK_SUCCESS);
+    dhid = "camera_132";
+    std::shared_ptr<CapabilityInfo> capInfo2 = std::make_shared<CapabilityInfo>(
+        dhid, deviceId, "devName_test", DEV_TYPE_TEST, DHType::CAMERA, "attrs", "camera");
+    key = deviceId + "###" + dhid;
+    LocalCapabilityInfoManager::GetInstance()->globalCapInfoMap_[key] = capInfo2;
+    ret = ComponentManager::GetInstance().GetDHSubtypeByDHId(dhSubtype, deviceId, dhid);
+    EXPECT_EQ(DHSubtype::CAMERA, dhSubtype);
+    EXPECT_EQ(ret, DH_FWK_SUCCESS);
+    dhid = "unknown_132";
+    std::shared_ptr<CapabilityInfo> capInfo3 = std::make_shared<CapabilityInfo>(
+        dhid, deviceId, "devName_test", DEV_TYPE_TEST, DHType::UNKNOWN, "attrs", "unknown");
+    key = deviceId + "###" + dhid;
+    LocalCapabilityInfoManager::GetInstance()->globalCapInfoMap_[key] = capInfo3;
+    ret = ComponentManager::GetInstance().GetDHSubtypeByDHId(dhSubtype, deviceId, dhid);
+    EXPECT_EQ(ret, ERR_DH_FWK_BAD_OPERATION);
 }
 
-HWTEST_F(ComponentManagerTest, QueryBusinessState_002, TestSize.Level1)
+HWTEST_F(ComponentManagerTest, InitAVSyncSharedMemory_001, TestSize.Level1)
 {
-    BusinessState ret = ComponentManager::GetInstance().QueryBusinessState(NETWORK_TEST, DH_ID_TEST);
-    EXPECT_EQ(BusinessState::IDLE, ret);
-
-    ComponentManager::GetInstance().dhBizStates_.clear();
-    ret = ComponentManager::GetInstance().QueryBusinessState(NETWORK_TEST, DH_ID_TEST);
-    EXPECT_EQ(BusinessState::UNKNOWN, ret);
+    auto ret = ComponentManager::GetInstance().InitAVSyncSharedMemory();
+    EXPECT_EQ(ret, DH_FWK_SUCCESS);
 }
 
-HWTEST_F(ComponentManagerTest, TriggerFullCapsSync_001, TestSize.Level1)
+HWTEST_F(ComponentManagerTest, DeinitAVSyncSharedMemory_001, TestSize.Level1)
 {
-    EXPECT_NO_FATAL_FAILURE(ComponentManager::GetInstance().TriggerFullCapsSync(""));
-
-    EXPECT_NO_FATAL_FAILURE(ComponentManager::GetInstance().TriggerFullCapsSync(NETWORK_TEST));
-
-    ComponentManager::GetInstance().dhCommToolPtr_ = std::make_shared<DHCommTool>();
-    EXPECT_NO_FATAL_FAILURE(ComponentManager::GetInstance().TriggerFullCapsSync(NETWORK_TEST));
+    ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().DeinitAVSyncSharedMemory());
 }
 
-HWTEST_F(ComponentManagerTest, GetDHSourceInstance_001, TestSize.Level1)
+HWTEST_F(ComponentManagerTest, GetDHIdByDHSubtype_001, TestSize.Level1)
 {
-    const IDistributedHardwareSource *sourcePtr = ComponentManager::GetInstance().GetDHSourceInstance(DHType::UNKNOWN);
-    EXPECT_EQ(nullptr, sourcePtr);
+    std::string peeruuid = "123456789";
+    std::string dhid = "audio_132";
+    std::string deviceId = Sha256(peeruuid);
+    std::shared_ptr<CapabilityInfo> capInfo1 = std::make_shared<CapabilityInfo>(
+        dhid, deviceId, "devName_test", DEV_TYPE_TEST, DHType::AUDIO, "attrs", "mic");
+    std::string key = deviceId + "###" + dhid;
+    BusinessState state = BusinessState::IDLE;
+    LocalCapabilityInfoManager::GetInstance()->globalCapInfoMap_[key] = capInfo1;
+    ComponentManager::GetInstance().dhBizStates_.emplace(std::make_pair(deviceId, dhid), state);
+    auto ret = ComponentManager::GetInstance().GetDHIdByDHSubtype(DHSubtype::AUDIO_MIC, deviceId, dhid);
+    EXPECT_EQ(ret, DH_FWK_SUCCESS);
+    ret = ComponentManager::GetInstance().GetDHIdByDHSubtype(DHSubtype::CAMERA, deviceId, dhid);
+    EXPECT_EQ(ret, ERR_DH_FWK_BAD_OPERATION);
 }
 
-HWTEST_F(ComponentManagerTest, GetDHSourceInstance_002, TestSize.Level1)
+HWTEST_F(ComponentManagerTest, HandleIdleStateChange_001, TestSize.Level1)
 {
-    DHType dhType = DHType::CAMERA;
+    std::string networkId = "";
+    std::string dhId = "";
+    DHType dhType = DHType::UNKNOWN;
+    ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().HandleIdleStateChange(networkId, dhId, dhType));
+
+    networkId = "networkId_1";
+    ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().HandleIdleStateChange(networkId, dhId, dhType));
+
+    networkId = "";
+    dhId = "dhId_1";
+    ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().HandleIdleStateChange(networkId, dhId, dhType));
+
+    networkId = "networkId_1";
     IDistributedHardwareSource *sourcePtr = nullptr;
-    ComponentManager::GetInstance().compSource_.insert(std::make_pair(dhType, sourcePtr));
-    IDistributedHardwareSource *dhSourcePtr = ComponentManager::GetInstance().GetDHSourceInstance(dhType);
-    EXPECT_EQ(nullptr, dhSourcePtr);
+    ComponentManager::GetInstance().compSource_.insert(std::make_pair(DHType::CAMERA, sourcePtr));
+    ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().HandleIdleStateChange(networkId, dhId, dhType));
+
+    ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().HandleIdleStateChange(networkId, dhId, DHType::CAMERA));
     ComponentManager::GetInstance().compSource_.clear();
 }
 
-HWTEST_F(ComponentManagerTest, CheckDemandStart_001, TestSize.Level1)
+HWTEST_F(ComponentManagerTest, NotifyBusinessStateChange_001, testing::ext::TestSize.Level1)
 {
-    bool enableSource = false;
-    auto ret = ComponentManager::GetInstance().CheckDemandStart(UUID_TEST, DHType::AUDIO, enableSource);
-    EXPECT_EQ(ret, ERR_DH_FWK_COMPONENT_COMPVERSION_NOT_FOUND);
+    BusinessState state = BusinessState::UNKNOWN;
+    DHSubtype dhSubType = DHSubtype::CAMERA;
+    ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().NotifyBusinessStateChange(dhSubType, state));
 }
 
-HWTEST_F(ComponentManagerTest, RegisterDHStatusListener_001, TestSize.Level1)
+// 测试HandleBusinessStateChange函数中targetDHId或targetNetworkId为空的情况
+HWTEST_F(ComponentManagerTest, HandleBusinessStateChange_002, TestSize.Level1)
 {
-    sptr<IHDSinkStatusListener> listener = nullptr;
-    auto ret = ComponentManager::GetInstance().RegisterDHStatusListener(listener, 0, 0);
-    EXPECT_EQ(ret, DH_FWK_SUCCESS);
-}
+    std::string networkId = "networkId_1";
+    std::string dhid = "audio_132";
+    DHSubtype dhSubType = DHSubtype::AUDIO_MIC;
+    BusinessState state = BusinessState::RUNNING;
 
-HWTEST_F(ComponentManagerTest, RegisterDHStatusListener_002, TestSize.Level1)
-{
-    sptr<IHDSourceStatusListener> listener = nullptr;
-    auto ret = ComponentManager::GetInstance().RegisterDHStatusListener(NETWORK_TEST, listener, 0, 0);
-    EXPECT_EQ(ret, DH_FWK_SUCCESS);
-}
+    // 清理状态确保targetDHId和targetNetworkId为空
+    ComponentManager::GetInstance().dhBizStates_.clear();
+    ComponentManager::GetInstance().compSource_.clear();
 
-HWTEST_F(ComponentManagerTest, UnregisterDHStatusListener_001, TestSize.Level1)
-{
-    sptr<IHDSinkStatusListener> listener = nullptr;
-    auto ret = ComponentManager::GetInstance().UnregisterDHStatusListener(listener, 0, 0);
-    EXPECT_EQ(ret, DH_FWK_SUCCESS);
+    // 此时应该因为targetDHId和targetNetworkId为空而直接返回
+    ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().HandleBusinessStateChange(networkId, dhid, dhSubType, state));
 }
 
-HWTEST_F(ComponentManagerTest, UnregisterDHStatusListener_002, TestSize.Level1)
+// 测试HandleBusinessStateChange函数中targetState不为RUNNING的情况
+HWTEST_F(ComponentManagerTest, HandleBusinessStateChange_003, TestSize.Level1)
 {
-    sptr<IHDSourceStatusListener> listener = nullptr;
-    auto ret = ComponentManager::GetInstance().UnregisterDHStatusListener(NETWORK_TEST, listener, 0, 0);
-    EXPECT_EQ(ret, DH_FWK_SUCCESS);
-}
+    std::string networkId = "networkId_1";
+    std::string dhid = "audio_132";
+    DHSubtype dhSubType = DHSubtype::AUDIO_MIC;
+    BusinessState state = BusinessState::RUNNING;
 
-HWTEST_F(ComponentManagerTest, EnableSink_001, TestSize.Level1)
-{
-    DHDescriptor dhDescriptor {
-        .id = AUDIO_ID_TEST,
-        .dhType = DHType::AUDIO
-    };
-    SetUpComponentLoaderConfig();
-    auto ret = ComponentManager::GetInstance().EnableSink(dhDescriptor, 0, 0);
-    EXPECT_EQ(ret, DH_FWK_SUCCESS);
-    ret = ComponentManager::GetInstance().EnableSink(dhDescriptor, 0, 0);
-    EXPECT_EQ(ret, ERR_DH_FWK_COMPONENT_REPEAT_CALL);
-}
+    // 设置环境，使targetDHId和targetNetworkId不为空，但targetState不是RUNNING
+    std::string peeruuid = "123456789";
+    std::string deviceId = Sha256(peeruuid);
+    std::shared_ptr<CapabilityInfo> capInfo1 = std::make_shared<CapabilityInfo>(
+        dhid, deviceId, "devName_test", DEV_TYPE_TEST, DHType::AUDIO, "attrs", "mic");
+    std::string key = deviceId + "###" + dhid;
+    LocalCapabilityInfoManager::GetInstance()->globalCapInfoMap_[key] = capInfo1;
 
-HWTEST_F(ComponentManagerTest, DisableSink_001, TestSize.Level1)
-{
-    DHDescriptor dhDescriptor {
-        .id = AUDIO_ID_TEST,
-        .dhType = DHType::AUDIO
-    };
-    auto ret = ComponentManager::GetInstance().DisableSink(dhDescriptor, 0, 0);
-    EXPECT_EQ(ret, ERR_DH_FWK_TYPE_NOT_EXIST);
-    ret = ComponentManager::GetInstance().DisableSink(dhDescriptor, 0, 0);
-    SetDownComponentLoaderConfig();
-    EXPECT_EQ(ret, ERR_DH_FWK_TYPE_NOT_EXIST);
-}
+    std::string dhid2 = "camera_132";
+    std::shared_ptr<CapabilityInfo> capInfo2 = std::make_shared<CapabilityInfo>(
+        dhid2, deviceId, "devName_test", DEV_TYPE_TEST, DHType::CAMERA, "attrs", "camera");
+    key = deviceId + "###" + dhid2;
+    LocalCapabilityInfoManager::GetInstance()->globalCapInfoMap_[key] = capInfo2;
 
-HWTEST_F(ComponentManagerTest, EnableSource_001, TestSize.Level1)
-{
-    DHDescriptor dhDescriptor {
-        .id = AUDIO_ID_TEST,
-        .dhType = DHType::AUDIO
-    };
-    SetUpComponentLoaderConfig();
-    auto ret = ComponentManager::GetInstance().EnableSource(NETWORK_TEST, dhDescriptor, 0, 0);
-    SetDownComponentLoaderConfig();
-    EXPECT_EQ(ret, ERR_DH_FWK_COMPONENT_MONITOR_NULL);
-}
+    // targetState设置为IDLE而不是RUNNING
+    ComponentManager::GetInstance().dhBizStates_.emplace(std::make_pair(deviceId, dhid2), BusinessState::IDLE);
 
-HWTEST_F(ComponentManagerTest, DisableSource_001, TestSize.Level1)
-{
-    DHDescriptor dhDescriptor {
-        .id = AUDIO_ID_TEST,
-        .dhType = DHType::AUDIO
-    };
-    SetUpComponentLoaderConfig();
-    auto ret = ComponentManager::GetInstance().DisableSource(NETWORK_TEST, dhDescriptor, 0, 0);
-    SetDownComponentLoaderConfig();
-    EXPECT_EQ(ret, ERR_DH_FWK_COMPONENT_REPEAT_CALL);
-}
+    ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().HandleBusinessStateChange(networkId, dhid, dhSubType, state));
 
-HWTEST_F(ComponentManagerTest, ForceDisableSink_001, TestSize.Level1)
-{
-    DHDescriptor dhDescriptor {
-        .id = AUDIO_ID_TEST,
-        .dhType = DHType::AUDIO
-    };
-    SetUpComponentLoaderConfig();
-    auto ret = ComponentManager::GetInstance().ForceDisableSink(dhDescriptor);
-    SetDownComponentLoaderConfig();
-    EXPECT_EQ(ret, ERR_DH_FWK_TYPE_NOT_EXIST);
+    ComponentManager::GetInstance().dhBizStates_.clear();
+    ComponentManager::GetInstance().compSource_.clear();
 }
 
-HWTEST_F(ComponentManagerTest, ForceDisableSource_001, TestSize.Level1)
+// 测试HandleBusinessStateChange函数中compSource_找不到handler的情况
+HWTEST_F(ComponentManagerTest, HandleBusinessStateChange_004, TestSize.Level1)
 {
-    DHDescriptor dhDescriptor {
-        .id = AUDIO_ID_TEST,
-        .dhType = DHType::AUDIO
-    };
-    SetUpComponentLoaderConfig();
-    auto ret = ComponentManager::GetInstance().ForceDisableSource(NETWORK_TEST, dhDescriptor);
-    SetDownComponentLoaderConfig();
-    EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID);
-}
+    std::string networkId = "networkId_1";
+    std::string dhid = "audio_132";
+    DHSubtype dhSubType = DHSubtype::AUDIO_MIC;
+    BusinessState state = BusinessState::RUNNING;
 
-HWTEST_F(ComponentManagerTest, UninitCompSource_001, TestSize.Level1)
-{
-    SetUpComponentLoaderConfig();
-    auto ret = ComponentManager::GetInstance().UninitCompSource(DHType::AUDIO);
-    SetDownComponentLoaderConfig();
-    EXPECT_EQ(ret, ERR_DH_FWK_COMPONENT_MONITOR_NULL);
-}
+    // 设置环境，使targetDHId和targetNetworkId不为空，targetState为RUNNING
+    std::string peeruuid = "123456789";
+    std::string deviceId = Sha256(peeruuid);
+    std::shared_ptr<CapabilityInfo> capInfo1 = std::make_shared<CapabilityInfo>(
+        dhid, deviceId, "devName_test", DEV_TYPE_TEST, DHType::AUDIO, "attrs", "mic");
+    std::string key = deviceId + "###" + dhid;
+    LocalCapabilityInfoManager::GetInstance()->globalCapInfoMap_[key] = capInfo1;
 
-HWTEST_F(ComponentManagerTest, UninitCompSink_001, TestSize.Level1)
-{
-    ComponentLoader::GetInstance().compHandlerMap_.clear();
-    SetUpComponentLoaderConfig();
-    auto ret = ComponentManager::GetInstance().UninitCompSink(DHType::AUDIO);
-    SetDownComponentLoaderConfig();
-    EXPECT_EQ(ret, ERR_DH_FWK_LOADER_SINK_UNLOAD);
-}
+    std::string dhid2 = "camera_132";
+    std::shared_ptr<CapabilityInfo> capInfo2 = std::make_shared<CapabilityInfo>(
+        dhid2, deviceId, "devName_test", DEV_TYPE_TEST, DHType::CAMERA, "attrs", "camera");
+    key = deviceId + "###" + dhid2;
+    LocalCapabilityInfoManager::GetInstance()->globalCapInfoMap_[key] = capInfo2;
 
-HWTEST_F(ComponentManagerTest, OnDataSyncTrigger_001, testing::ext::TestSize.Level1)
-{
-    DHDataSyncTriggerListener dhDataSyncTrigger;
-    std::string networkId = "";
-    ASSERT_NO_FATAL_FAILURE(dhDataSyncTrigger.OnDataSyncTrigger(networkId));
+    ComponentManager::GetInstance().dhBizStates_.emplace(std::make_pair(deviceId, dhid2), BusinessState::RUNNING);
+    ComponentManager::GetInstance().dhBizStates_.emplace(std::make_pair(deviceId, dhid), BusinessState::RUNNING);
 
-    networkId = "networkId_test";
-    ASSERT_NO_FATAL_FAILURE(dhDataSyncTrigger.OnDataSyncTrigger(networkId));
+    // 不添加任何handler到compSource_，这会导致找不到cameraHandler或audioHandler
+    ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().HandleBusinessStateChange(networkId, dhid, dhSubType, state));
+
+    ComponentManager::GetInstance().dhBizStates_.clear();
+    ComponentManager::GetInstance().compSource_.clear();
 }
 
-HWTEST_F(ComponentManagerTest, OnStateChanged_001, testing::ext::TestSize.Level1)
+// 测试HandleBusinessStateChange函数中CAMERA到AUDIO_MIC的转换情况
+HWTEST_F(ComponentManagerTest, HandleBusinessStateChange_005, TestSize.Level1)
 {
-    DHStateListener dhStateListenenr;
-    std::string dhId = "dhId_test";
-    BusinessState state = BusinessState::UNKNOWN;
-    std::string networkId = "";
-    ASSERT_NO_FATAL_FAILURE(dhStateListenenr.OnStateChanged(networkId, dhId, state));
+    std::string networkId = "networkId_1";
+    std::string dhid = "camera_132";
+    DHSubtype dhSubType = DHSubtype::CAMERA;  // 与之前测试相反的subtype
+    BusinessState state = BusinessState::IDLE;
 
-    networkId = "networkId_test";
-    ASSERT_NO_FATAL_FAILURE(dhStateListenenr.OnStateChanged(networkId, dhId, state));
-}
+    ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().HandleBusinessStateChange(networkId, dhid, dhSubType, state));
 
-HWTEST_F(ComponentManagerTest, CheckSinkConfigStart_001, TestSize.Level1)
-{
-    bool enableSink = false;
-    auto ret = ComponentManager::GetInstance().CheckSinkConfigStart(DHType::GPS, enableSink);
-    EXPECT_EQ(ret, ERR_DH_FWK_TYPE_NOT_EXIST);
-}
+    state = BusinessState::RUNNING;
+    std::string peeruuid = "123456789";
+    std::string deviceId = Sha256(peeruuid);
+    std::shared_ptr<CapabilityInfo> capInfo1 = std::make_shared<CapabilityInfo>(
+        dhid, deviceId, "devName_test", DEV_TYPE_TEST, DHType::CAMERA, "attrs", "camera");
+    std::string key = deviceId + "###" + dhid;
+    LocalCapabilityInfoManager::GetInstance()->globalCapInfoMap_[key] = capInfo1;
+    ComponentManager::GetInstance().dhBizStates_.emplace(std::make_pair(deviceId, dhid), BusinessState::IDLE);
 
-HWTEST_F(ComponentManagerTest, InitAndUnInit_DHCommTool_001, TestSize.Level0)
-{
-    ComponentManager::GetInstance().dhCommToolPtr_ = nullptr;
-    EXPECT_NO_FATAL_FAILURE(ComponentManager::GetInstance().InitDHCommTool());
-    EXPECT_NO_FATAL_FAILURE(ComponentManager::GetInstance().UnInitDHCommTool());
+    std::string dhid2 = "audio_132";
+    std::shared_ptr<CapabilityInfo> capInfo2 = std::make_shared<CapabilityInfo>(
+        dhid2, deviceId, "devName_test", DEV_TYPE_TEST, DHType::AUDIO, "attrs", "mic");
+    key = deviceId + "###" + dhid2;
+    LocalCapabilityInfoManager::GetInstance()->globalCapInfoMap_[key] = capInfo2;
+    ComponentManager::GetInstance().dhBizStates_.emplace(std::make_pair(deviceId, dhid2), BusinessState::UNKNOWN);
 
-    ComponentManager::GetInstance().dhCommToolPtr_ = std::make_shared<DHCommTool>();
-    EXPECT_NO_FATAL_FAILURE(ComponentManager::GetInstance().InitDHCommTool());
-    EXPECT_NO_FATAL_FAILURE(ComponentManager::GetInstance().UnInitDHCommTool());
-}
+    ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().HandleBusinessStateChange(networkId, dhid, dhSubType, state));
 
-HWTEST_F(ComponentManagerTest, SyncRemoteDeviceInfoBySoftbus_001, TestSize.Level0)
-{
-    std::string realNetworkId = "realNetworkId_1";
-    EnableStep enableStep = EnableStep::ENABLE_SOURCE;
-    sptr<IGetDhDescriptorsCallback> callback = nullptr;
-    EXPECT_NO_FATAL_FAILURE(
-        ComponentManager::GetInstance().SyncRemoteDeviceInfoBySoftbus(realNetworkId, enableStep, callback));
-}
+    ComponentManager::GetInstance().dhBizStates_.emplace(std::make_pair(deviceId, dhid2), BusinessState::RUNNING);
+    IDistributedHardwareSource *sourcePtr1 = nullptr;
+    ComponentManager::GetInstance().compSource_.insert(std::make_pair(DHType::AUDIO, sourcePtr1));
+    ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().HandleBusinessStateChange(networkId, dhid, dhSubType, state));
 
-HWTEST_F(ComponentManagerTest, OnGetDescriptors_001, TestSize.Level0)
-{
-    std::string realNetworkId = "realNetworkId_1";
-    std::vector<DHDescriptor> descriptors;
-    ComponentManager::GetInstance().OnGetDescriptors(realNetworkId, descriptors);
-    EXPECT_TRUE(ComponentManager::GetInstance().syncDeviceInfoMap_.empty());
-}
+    IDistributedHardwareSource *sourcePtr2 = nullptr;
+    ComponentManager::GetInstance().compSource_.insert(std::make_pair(DHType::CAMERA, sourcePtr2));
+    ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().HandleBusinessStateChange(networkId, dhid, dhSubType, state));
 
-HWTEST_F(ComponentManagerTest, OnGetDescriptors_002, TestSize.Level0)
-{
-    std::string realNetworkId = "realNetworkId_1";
-    EnableStep enableStep = EnableStep::ENABLE_SOURCE;
-    std::vector<DHDescriptor> descriptors;
-    DHDescriptor descriptor;
-    descriptor.id = "camera_1";
-    descriptor.dhType = DHType::CAMERA;
-    descriptors.push_back(descriptor);
-    ComponentManager::GetInstance().syncDeviceInfoMap_[realNetworkId] = {enableStep, nullptr};
-    ComponentManager::GetInstance().OnGetDescriptors("realNetworkId_test", descriptors);
-    EXPECT_FALSE(ComponentManager::GetInstance().syncDeviceInfoMap_.empty());
+    ComponentManager::GetInstance().dhBizStates_.clear();
+    ComponentManager::GetInstance().compSource_.clear();
 }
 
-HWTEST_F(ComponentManagerTest, OnGetDescriptorsError_001, TestSize.Level0)
+// 测试HandleBusinessStateChange函数中InitAVSyncSharedMemory失败的情况
+HWTEST_F(ComponentManagerTest, HandleBusinessStateChange_006, TestSize.Level1)
 {
-    std::string realNetworkId = "realNetworkId_1";
-    EnableStep enableStep = EnableStep::ENABLE_SOURCE;
-    ComponentManager::GetInstance().syncDeviceInfoMap_[realNetworkId] = {enableStep, nullptr};
-    ComponentManager::GetInstance().OnGetDescriptorsError();
-    EXPECT_FALSE(ComponentManager::GetInstance().syncDeviceInfoMap_.empty());
+    std::string networkId = "networkId_1";
+    std::string dhid = "audio_132";
+    DHSubtype dhSubType = DHSubtype::AUDIO_MIC;
+    BusinessState state = BusinessState::RUNNING;
+
+    // 设置完整的环境
+    std::string peeruuid = "123456789";
+    std::string deviceId = Sha256(peeruuid);
+    std::shared_ptr<CapabilityInfo> capInfo1 = std::make_shared<CapabilityInfo>(
+        dhid, deviceId, "devName_test", DEV_TYPE_TEST, DHType::AUDIO, "attrs", "mic");
+    std::string key = deviceId + "###" + dhid;
+    LocalCapabilityInfoManager::GetInstance()->globalCapInfoMap_[key] = capInfo1;
+
+    std::string dhid2 = "camera_132";
+    std::shared_ptr<CapabilityInfo> capInfo2 = std::make_shared<CapabilityInfo>(
+        dhid2, deviceId, "devName_test", DEV_TYPE_TEST, DHType::CAMERA, "attrs", "camera");
+    key = deviceId + "###" + dhid2;
+    LocalCapabilityInfoManager::GetInstance()->globalCapInfoMap_[key] = capInfo2;
+
+    ComponentManager::GetInstance().dhBizStates_.emplace(std::make_pair(deviceId, dhid2), BusinessState::RUNNING);
+    ComponentManager::GetInstance().dhBizStates_.emplace(std::make_pair(deviceId, dhid), BusinessState::RUNNING);
+
+    // 添加mock handlers
+    IDistributedHardwareSource *sourcePtr1 = new MockDistributedHardwareSource();
+    IDistributedHardwareSource *sourcePtr2 = new MockDistributedHardwareSource();
+    ComponentManager::GetInstance().compSource_.insert(std::make_pair(DHType::CAMERA, sourcePtr1));
+    ComponentManager::GetInstance().compSource_.insert(std::make_pair(DHType::AUDIO, sourcePtr2));
+
+    // 先初始化一次共享内存，让syncSharedMem_不为空，然后测试失败情况
+    ComponentManager::GetInstance().InitAVSyncSharedMemory();
+    ComponentManager::GetInstance().DeinitAVSyncSharedMemory();
+
+    ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().HandleBusinessStateChange(networkId, dhid, dhSubType, state));
+
+    ComponentManager::GetInstance().dhBizStates_.clear();
+    ComponentManager::GetInstance().compSource_.clear();
+    delete sourcePtr1;
+    delete sourcePtr2;
 }
 
-HWTEST_F(ComponentManagerTest, OnStateChanged_Sink_001, testing::ext::TestSize.Level1)
+// 测试HandleBusinessStateChange函数中targetHandler->UpdateDistributedHardwareWorkMode失败的情况
+HWTEST_F(ComponentManagerTest, HandleBusinessStateChange_007, TestSize.Level1)
 {
-    DHSinkStateListener sinkStateListenenr;
-    std::string dhId = "";
-    std::string networkId = "";
-    BusinessSinkState state = BusinessSinkState::UNKNOWN;
-    ASSERT_NO_FATAL_FAILURE(sinkStateListenenr.OnStateChanged(networkId, dhId, state));
+    std::string networkId = "networkId_1";
+    std::string dhid = "audio_132";
+    DHSubtype dhSubType = DHSubtype::AUDIO_MIC;
+    BusinessState state = BusinessState::RUNNING;
 
-    networkId = "networkId_1";
-    ASSERT_NO_FATAL_FAILURE(sinkStateListenenr.OnStateChanged(networkId, dhId, state));
+    // 设置完整的环境
+    std::string peeruuid = "123456789";
+    std::string deviceId = Sha256(peeruuid);
+    std::shared_ptr<CapabilityInfo> capInfo1 = std::make_shared<CapabilityInfo>(
+        dhid, deviceId, "devName_test", DEV_TYPE_TEST, DHType::AUDIO, "attrs", "mic");
+    std::string key = deviceId + "###" + dhid;
+    LocalCapabilityInfoManager::GetInstance()->globalCapInfoMap_[key] = capInfo1;
 
-    networkId = "";
-    dhId = "dhId_1";
-    ASSERT_NO_FATAL_FAILURE(sinkStateListenenr.OnStateChanged(networkId, dhId, state));
+    std::string dhid2 = "camera_132";
+    std::shared_ptr<CapabilityInfo> capInfo2 = std::make_shared<CapabilityInfo>(
+        dhid2, deviceId, "devName_test", DEV_TYPE_TEST, DHType::CAMERA, "attrs", "camera");
+    key = deviceId + "###" + dhid2;
+    LocalCapabilityInfoManager::GetInstance()->globalCapInfoMap_[key] = capInfo2;
 
-    networkId = "networkId_1";
-    dhId = "dhId_1";
-    ASSERT_NO_FATAL_FAILURE(sinkStateListenenr.OnStateChanged(networkId, dhId, state));
+    ComponentManager::GetInstance().dhBizStates_.emplace(std::make_pair(deviceId, dhid2), BusinessState::RUNNING);
+    ComponentManager::GetInstance().dhBizStates_.emplace(std::make_pair(deviceId, dhid), BusinessState::RUNNING);
+
+    // 添加mock handlers，其中targetHandler返回失败
+    IDistributedHardwareSource *sourcePtr1 = new MockDistributedHardwareSourceFailure(1); // targetHandler失败
+    IDistributedHardwareSource *sourcePtr2 = new MockDistributedHardwareSourceFailure(0); // sourceHandler成功
+    ComponentManager::GetInstance().compSource_.insert(std::make_pair(DHType::CAMERA, sourcePtr1));
+    ComponentManager::GetInstance().compSource_.insert(std::make_pair(DHType::AUDIO, sourcePtr2));
+
+    ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().HandleBusinessStateChange(networkId, dhid, dhSubType, state));
+
+    ComponentManager::GetInstance().dhBizStates_.clear();
+    ComponentManager::GetInstance().compSource_.clear();
+    delete sourcePtr1;
+    delete sourcePtr2;
 }
 
-HWTEST_F(ComponentManagerTest, SetAVSyncScene_001, testing::ext::TestSize.Level1)
+// 测试HandleBusinessStateChange函数中sourceHandler->UpdateDistributedHardwareWorkMode失败的情况
+HWTEST_F(ComponentManagerTest, HandleBusinessStateChange_008, TestSize.Level1)
 {
-    DHTopic topic = DHTopic::TOPIC_AV_LOW_LATENCY;
-    ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().SetAVSyncScene(topic));
+    std::string networkId = "networkId_1";
+    std::string dhid = "audio_132";
+    DHSubtype dhSubType = DHSubtype::AUDIO_MIC;
+    BusinessState state = BusinessState::RUNNING;
+
+    // 设置完整的环境
+    std::string peeruuid = "123456789";
+    std::string deviceId = Sha256(peeruuid);
+    std::shared_ptr<CapabilityInfo> capInfo1 = std::make_shared<CapabilityInfo>(
+        dhid, deviceId, "devName_test", DEV_TYPE_TEST, DHType::AUDIO, "attrs", "mic");
+    std::string key = deviceId + "###" + dhid;
+    LocalCapabilityInfoManager::GetInstance()->globalCapInfoMap_[key] = capInfo1;
+
+    std::string dhid2 = "camera_132";
+    std::shared_ptr<CapabilityInfo> capInfo2 = std::make_shared<CapabilityInfo>(
+        dhid2, deviceId, "devName_test", DEV_TYPE_TEST, DHType::CAMERA, "attrs", "camera");
+    key = deviceId + "###" + dhid2;
+    LocalCapabilityInfoManager::GetInstance()->globalCapInfoMap_[key] = capInfo2;
+
+    ComponentManager::GetInstance().dhBizStates_.emplace(std::make_pair(deviceId, dhid2), BusinessState::RUNNING);
+    ComponentManager::GetInstance().dhBizStates_.emplace(std::make_pair(deviceId, dhid), BusinessState::RUNNING);
 
-    topic = DHTopic::TOPIC_AV_FLUENCY;
-    ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().SetAVSyncScene(topic));
+    // 添加mock handlers，其中sourceHandler返回失败
+    IDistributedHardwareSource *sourcePtr1 = new MockDistributedHardwareSourceFailure(0); // targetHandler成功
+    IDistributedHardwareSource *sourcePtr2 = new MockDistributedHardwareSourceFailure(2); // sourceHandler失败
+    ComponentManager::GetInstance().compSource_.insert(std::make_pair(DHType::CAMERA, sourcePtr1));
+    ComponentManager::GetInstance().compSource_.insert(std::make_pair(DHType::AUDIO, sourcePtr2));
 
-    topic = DHTopic::TOPIC_MAX;
-    ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().SetAVSyncScene(topic));
+    ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().HandleBusinessStateChange(networkId, dhid, dhSubType, state));
+
+    ComponentManager::GetInstance().dhBizStates_.clear();
+    ComponentManager::GetInstance().compSource_.clear();
+    delete sourcePtr1;
+    delete sourcePtr2;
 }
 
-HWTEST_F(ComponentManagerTest, UpdateSinkBusinessState_001, testing::ext::TestSize.Level1)
+// 测试NotifyBusinessStateChange函数正常执行所有情况
+HWTEST_F(ComponentManagerTest, NotifyBusinessStateChange_006, testing::ext::TestSize.Level1)
 {
-    std::string networkId = "";
-    std::string dhId = "";
-    BusinessSinkState state = BusinessSinkState::UNKNOWN;
-    ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().UpdateSinkBusinessState(networkId, dhId, state));
+    // 测试不同的dhSubType和state组合
 
-    networkId = "networkId_1";
-    ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().UpdateSinkBusinessState(networkId, dhId, state));
+    // 测试AUDIO_MIC + RUNNING
+    BusinessState state1 = BusinessState::RUNNING;
+    DHSubtype dhSubType1 = DHSubtype::AUDIO_MIC;
+    ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().NotifyBusinessStateChange(dhSubType1, state1));
 
-    networkId = "";
-    dhId = "dhId_1";
-    ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().UpdateSinkBusinessState(networkId, dhId, state));
+    // 测试CAMERA + IDLE
+    BusinessState state2 = BusinessState::IDLE;
+    DHSubtype dhSubType2 = DHSubtype::CAMERA;
+    ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().NotifyBusinessStateChange(dhSubType2, state2));
 
-    networkId = "networkId_1";
-    ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().UpdateSinkBusinessState(networkId, dhId, state));
+    // 测试AUDIO_MIC + UNKNOWN
+    BusinessState state3 = BusinessState::UNKNOWN;
+    DHSubtype dhSubType3 = DHSubtype::AUDIO_MIC;
+    ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().NotifyBusinessStateChange(dhSubType3, state3));
+
+    // 测试CAMERA + RUNNING
+    BusinessState state4 = BusinessState::RUNNING;
+    DHSubtype dhSubType4 = DHSubtype::CAMERA;
+    ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().NotifyBusinessStateChange(dhSubType4, state4));
 }
+
+// Mock类定义
+class MockDistributedHardwareSource : public IDistributedHardwareSource {
+public:
+    int32_t InitSource(const std::string &params) override {
+        return DH_FWK_SUCCESS;
+    }
+
+    int32_t ReleaseSource() override {
+        return DH_FWK_SUCCESS;
+    }
+
+    int32_t RegisterDistributedHardware(const std::string &networkId, const std::string &dhId,
+        const EnableParam &param, std::shared_ptr<RegisterCallback> callback) override {
+        return DH_FWK_SUCCESS;
+    }
+
+    int32_t UnregisterDistributedHardware(const std::string &networkId, const std::string &dhId,
+        std::shared_ptr<UnregisterCallback> callback) override {
+        return DH_FWK_SUCCESS;
+    }
+
+    int32_t ConfigDistributedHardware(const std::string &networkId, const std::string &dhId,
+        const std::string &key, const std::string &value) override {
+        return DH_FWK_SUCCESS;
+    }
+
+    void RegisterDistributedHardwareStateListener(
+        std::shared_ptr<DistributedHardwareStateListener> listener) override {
+    }
+
+    void UnregisterDistributedHardwareStateListener() override {
+    }
+
+    void RegisterDataSyncTriggerListener(std::shared_ptr<DataSyncTriggerListener> listener) override {
+    }
+
+    void UnregisterDataSyncTriggerListener() override {
+    }
+
+    int32_t UpdateDistributedHardwareWorkMode(const std::string &networkId, const std::string &dhId,
+        const WorkModeParam &param) override {
+        return DH_FWK_SUCCESS;
+    }
+};
+
+// 带失败模式的Mock类定义
+class MockDistributedHardwareSourceFailure : public IDistributedHardwareSource {
+private:
+    int failMode_; // 0-都不失败, 1-targetHandler失败, 2-sourceHandler失败
+
+public:
+    explicit MockDistributedHardwareSourceFailure(int failMode) : failMode_(failMode) {}
+
+    int32_t InitSource(const std::string &params) override {
+        return DH_FWK_SUCCESS;
+    }
+
+    int32_t ReleaseSource() override {
+        return DH_FWK_SUCCESS;
+    }
+
+    int32_t RegisterDistributedHardware(const std::string &networkId, const std::string &dhId,
+        const EnableParam &param, std::shared_ptr<RegisterCallback> callback) override {
+        return DH_FWK_SUCCESS;
+    }
+
+    int32_t UnregisterDistributedHardware(const std::string &networkId, const std::string &dhId,
+        std::shared_ptr<UnregisterCallback> callback) override {
+        return DH_FWK_SUCCESS;
+    }
+
+    int32_t ConfigDistributedHardware(const std::string &networkId, const std::string &dhId,
+        const std::string &key, const std::string &value) override {
+        return DH_FWK_SUCCESS;
+    }
+
+    void RegisterDistributedHardwareStateListener(
+        std::shared_ptr<DistributedHardwareStateListener> listener) override {
+    }
+
+    void UnregisterDistributedHardwareStateListener() override {
+    }
+
+    void RegisterDataSyncTriggerListener(std::shared_ptr<DataSyncTriggerListener> listener) override {
+    }
+
+    void UnregisterDataSyncTriggerListener() override {
+    }
+
+    int32_t UpdateDistributedHardwareWorkMode(const std::string &networkId, const std::string &dhId,
+        const WorkModeParam &param) override {
+        // 根据failMode_决定是否返回失败
+        if ((failMode_ == 1 && networkId == "networkId_1") || // targetHandler情况
+            (failMode_ == 2 && dhId == "audio_132")) { // sourceHandler情况
+            return ERR_DH_FWK_BAD_OPERATION;
+        }
+        return DH_FWK_SUCCESS;
+    }
+};
 } // namespace DistributedHardware
 } // namespace OHOS