diff --git a/audiohandler/include/daudio_handler.h b/audiohandler/include/daudio_handler.h
index e57d0b9bbe9f3a14bc1994edc6be60d63364c2b8..fb9b6dff64096ec07b2fb5fe85bdf0535e62c1c2 100644
--- a/audiohandler/include/daudio_handler.h
+++ b/audiohandler/include/daudio_handler.h
@@ -52,6 +52,7 @@ private:
     ~DAudioHandler();
     int32_t QueryAudioInfo();
     bool AddItemsToObject(DHItem &dhItem, cJSON *infoJson, const int32_t &dhId);
+    std::vector<DHItem> RealQuery(const std::string &dataType);
 private:
     AudioInfo spkInfos_;
     AudioInfo micInfos_;
diff --git a/audiohandler/src/daudio_handler.cpp b/audiohandler/src/daudio_handler.cpp
index b29f1e970ff55a18bada27ab8343f5e49b122d1f..5accbe883a775085e251e8cf35b364e4939ac7a6 100644
--- a/audiohandler/src/daudio_handler.cpp
+++ b/audiohandler/src/daudio_handler.cpp
@@ -103,19 +103,23 @@ bool DAudioHandler::AddItemsToObject(DHItem &dhItem, cJSON* infoJson, const int3
 std::vector<DHItem> DAudioHandler::QueryMeta()
 {
     DHLOGI("Query meta distributed hardware information.");
-    return Query();
+    return RealQuery(KEY_TYPE_META);
 }
 
 std::vector<DHItem> DAudioHandler::Query()
 {
-    DHLOGI("Query distributed hardware information.");
+    DHLOGI("Query full distributed hardware information.");
+    return RealQuery(KEY_TYPE_FULL);
+}
+
+std::vector<DHItem> DAudioHandler::RealQuery(const std::string &dataType)
+{
     auto audioSrv = AudioStandard::AudioSystemManager::GetInstance();
     std::vector<DHItem> dhItemVec;
     if (audioSrv == nullptr) {
         DHLOGE("Unable to get audio system manager.");
         return dhItemVec;
     }
-
     auto audioDevices = audioSrv->GetDevices(AudioStandard::DeviceFlag::ALL_DEVICES_FLAG);
     for (auto dev : audioDevices) {
         auto dhId = audioSrv->GetPinValueFromType(dev->deviceType_, dev->deviceRole_);
@@ -133,8 +137,9 @@ std::vector<DHItem> DAudioHandler::Query()
             cJSON_Delete(infoJson);
             return dhItemVec;
         }
-        cJSON_AddNumberToObject(infoJson, "INTERRUPT_GROUP_ID", dev->interruptGroupId_);
-        cJSON_AddNumberToObject(infoJson, "VOLUME_GROUP_ID", dev->volumeGroupId_);
+        cJSON_AddNumberToObject(infoJson, INTERRUPT_GROUP_ID, dev->interruptGroupId_);
+        cJSON_AddNumberToObject(infoJson, VOLUME_GROUP_ID, dev->volumeGroupId_);
+        cJSON_AddStringToObject(infoJson, KEY_DATATYPE, dataType.c_str());
         dhItem.dhId = AddDhIdPrefix(std::to_string(dhId));
         char *jsonInfo = cJSON_Print(infoJson);
         if (jsonInfo == NULL) {
diff --git a/common/include/daudio_constants.h b/common/include/daudio_constants.h
index 1f9cf97d054cf8bfbbadea13ca0474f6da3d1846..35ad9b46f4184951a8305d4e15639aa8784f03cf 100644
--- a/common/include/daudio_constants.h
+++ b/common/include/daudio_constants.h
@@ -107,6 +107,8 @@ const std::string AUDIO_EVENT_RESTART = "restart";
 const std::string AUDIO_EVENT_PAUSE = "pause";
 
 const std::string AUDIO_ENGINE_FLAG = "persist.distributedhardware.distributedaudio.engine.enable";
+const std::string KEY_TYPE_META = "meta";
+const std::string KEY_TYPE_FULL = "full";
 
 constexpr const char *KEY_TYPE = "type";
 constexpr const char *KEY_CHANGE_TYPE = "ChangeType";
@@ -144,6 +146,8 @@ constexpr const char *MAX_VOLUME_LEVEL = "MAX_VOLUME_LEVEL";
 constexpr const char *MIN_VOLUME_LEVEL = "MIN_VOLUME_LEVEL";
 constexpr const char *VOLUME_GROUP_ID = "VOLUME_GROUP_ID";
 constexpr const char *VOLUME_EVENT_TYPE = "EVENT_TYPE";
+constexpr const char *KEY_DATATYPE = "dataType";
+constexpr const char *INTERRUPT_GROUP_ID = "INTERRUPT_GROUP_ID";
 
 const std::string DUMP_FILE_PATH = "/data/data/daudio";
 const std::string AUDIO_PERMISSION_NAME = "ohos.permission.ENABLE_DISTRIBUTED_HARDWARE";
diff --git a/common/src/daudio_util.cpp b/common/src/daudio_util.cpp
index 2f0cbc87bccadc690061bc3ba53a352576dc8da4..1357ddc5f2bb860eaa5e140c567162cd8945bed2 100644
--- a/common/src/daudio_util.cpp
+++ b/common/src/daudio_util.cpp
@@ -63,6 +63,7 @@ std::map<std::string, JsonTypeCheckFunc> typeCheckMap = {
     std::map<std::string, JsonTypeCheckFunc>::value_type(KEY_SOURCE_TYPE, &DistributedHardware::IsInt32),
     std::map<std::string, JsonTypeCheckFunc>::value_type(KEY_CONTENT_TYPE, &DistributedHardware::IsInt32),
     std::map<std::string, JsonTypeCheckFunc>::value_type(KEY_STREAM_USAGE, &DistributedHardware::IsInt32),
+    std::map<std::string, JsonTypeCheckFunc>::value_type(KEY_DATATYPE, &DistributedHardware::IsString),
 };
 
 std::map<int32_t, std::string> eventNameMap = {
diff --git a/services/audiomanager/managersource/include/daudio_source_dev.h b/services/audiomanager/managersource/include/daudio_source_dev.h
index bcc72391aa7bdbad5f988c5361e56c2742fd087a..10ef8da93efdb2b328a90bc8a4abd60cef670ef4 100644
--- a/services/audiomanager/managersource/include/daudio_source_dev.h
+++ b/services/audiomanager/managersource/include/daudio_source_dev.h
@@ -120,6 +120,7 @@ private:
     int32_t ParseDhidFromEvent(std::string args);
     int32_t ConvertString2Int(std::string val);
     int32_t CreateMicEngine(std::shared_ptr<DAudioIoDev> mic);
+    void SetRegDataType(const std::string &capability);
 
 private:
     static constexpr uint8_t RPC_WAIT_SECONDS = 10;
@@ -143,6 +144,7 @@ private:
     std::mutex rpcWaitMutex_;
     std::condition_variable rpcWaitCond_;
     std::atomic<bool> isRpcOpen_ = false;
+    std::atomic<bool> isFull_ = false;
     int32_t rpcResult_ = ERR_DH_AUDIO_FAILED;
     uint8_t rpcNotify_ = 0;
     std::atomic<bool> threadStatusFlag_ = false;
diff --git a/services/audiomanager/managersource/src/daudio_source_dev.cpp b/services/audiomanager/managersource/src/daudio_source_dev.cpp
index 1a709295a58b2b1f7d234f5d76c3e0540dfdaee2..6847aae17a01b29369124a42577dcc25bd296936 100644
--- a/services/audiomanager/managersource/src/daudio_source_dev.cpp
+++ b/services/audiomanager/managersource/src/daudio_source_dev.cpp
@@ -106,6 +106,27 @@ void DAudioSourceDev::SleepAudioDev()
     DHLOGI("Sleep audio dev over.");
 }
 
+void DAudioSourceDev::SetRegDataType(const std::string &capability)
+{
+    DHLOGI("SetRegDataType enter.");
+    cJSON *jParam = cJSON_Parse(capability.c_str());
+    CHECK_NULL_VOID(jParam);
+    if (!CJsonParamCheck(jParam, { KEY_DATATYPE })) {
+        DHLOGE("The key dataType is not found.");
+        cJSON_Delete(jParam);
+        return;
+    }
+    cJSON *dataType = cJSON_GetObjectItem(jParam, KEY_DATATYPE);
+    CHECK_NULL_AND_FREE_VOID(dataType, jParam);
+    DHLOGI("RegData type is : %{public}s.", dataType->valuestring);
+    std::string typeStr(dataType->valuestring);
+    if (typeStr == KEY_TYPE_FULL) {
+        isFull_.store(true);
+    } else {
+        isFull_.store(false);
+    }
+}
+
 int32_t DAudioSourceDev::EnableDAudio(const std::string &dhId, const std::string &attrs)
 {
     DHLOGI("Enable audio device, dhId: %{public}s.", dhId.c_str());
@@ -130,6 +151,9 @@ int32_t DAudioSourceDev::EnableDAudio(const std::string &dhId, const std::string
     DHLOGI("Enable audio task generate successfully.");
     cJSON_Delete(jParam);
     cJSON_free(jsonString);
+    if (!isFull_.load()) {
+        SetRegDataType(attrs);
+    }
     return DH_SUCCESS;
 }
 
@@ -696,6 +720,9 @@ void DAudioSourceDev::OnDisableTaskResult(int32_t resultCode, const std::string
 void DAudioSourceDev::NotifyFwkRunning(const std::string &devId, const std::string &dhId)
 {
     DAudioSourceManager::GetInstance().OnHardwareStateChanged(devId, dhId, DaudioBusinessState::RUNNING);
+    if (!isFull_.load()) {
+        DAudioSourceManager::GetInstance().OnDataSyncTrigger(devId);
+    }
 }
 
 void DAudioSourceDev::NotifyFwkIdle(const std::string &devId, const std::string &dhId)
@@ -727,14 +754,12 @@ int32_t DAudioSourceDev::TaskOpenDSpeaker(const std::string &args)
         NotifyHDF(NOTIFY_OPEN_SPEAKER_RESULT, HDF_EVENT_INIT_ENGINE_FAILED, dhId);
         return ret;
     }
-
     ret = WaitForRPC(NOTIFY_OPEN_CTRL_RESULT);
     if (ret != DH_SUCCESS) {
         DHLOGE("Speaker init sender engine, create ctrl error.");
         NotifyHDF(NOTIFY_OPEN_SPEAKER_RESULT, HDF_EVENT_INIT_ENGINE_FAILED, dhId);
         return ret;
     }
-
     cJSON *jAudioParam = cJSON_CreateObject();
     CHECK_NULL_RETURN(jAudioParam, ERR_DH_AUDIO_NULLPTR);
     to_json(jAudioParam, speaker->GetAudioParam());
diff --git a/services/audiomanager/test/unittest/sourcedevice/src/daudio_source_dev_test.cpp b/services/audiomanager/test/unittest/sourcedevice/src/daudio_source_dev_test.cpp
index bcbb9f8e3073fc01aaed195930618ab0ba5cf442..1915e4a5256e095917295cd5f3e785ecba10c6b0 100644
--- a/services/audiomanager/test/unittest/sourcedevice/src/daudio_source_dev_test.cpp
+++ b/services/audiomanager/test/unittest/sourcedevice/src/daudio_source_dev_test.cpp
@@ -1213,5 +1213,24 @@ HWTEST_F(DAudioSourceDevTest, ParseDhidFromEvent_001, TestSize.Level1)
     std::string args1 = "{\"devId\":\"10\"}";
     EXPECT_EQ(ERR_DH_AUDIO_NOT_SUPPORT, sourceDev_->DisableDAudio(args1));
 }
+
+/**
+ * @tc.name: EnableDAudio_001
+ * @tc.desc: Verify the EnableDAudio function.
+ * @tc.type: FUNC
+ * @tc.require: AR000H0E5F
+ */
+HWTEST_F(DAudioSourceDevTest, EnableDAudio_001, TestSize.Level1)
+{
+    EXPECT_EQ(DH_SUCCESS, sourceDev_->AwakeAudioDev());
+    sourceDev_->isFull_.store(true);
+    EXPECT_EQ(DH_SUCCESS, sourceDev_->EnableDAudio(DH_ID_SPK, ATTRS));
+    sourceDev_->isFull_.store(false);
+    EXPECT_EQ(DH_SUCCESS, sourceDev_->EnableDAudio(DH_ID_SPK, ATTRS));
+    std::string argsMeta = "{\"dataType\":\"meta\"}";
+    EXPECT_EQ(DH_SUCCESS, sourceDev_->EnableDAudio(DH_ID_SPK, argsMeta));
+    std::string argsFull = "{\"dataType\":\"full\"}";
+    EXPECT_EQ(DH_SUCCESS, sourceDev_->EnableDAudio(DH_ID_SPK, argsFull));
+}
 } // namespace DistributedHardware
 } // namespace OHOS