diff --git a/frameworks/libs/distributeddb/BUILD.gn b/frameworks/libs/distributeddb/BUILD.gn
index 4308a9b12c8b8a0ab05d0cdf2a262b229e04cb1d..ee9a8885322761fc6887b70b5709a9737746c874 100644
--- a/frameworks/libs/distributeddb/BUILD.gn
+++ b/frameworks/libs/distributeddb/BUILD.gn
@@ -118,6 +118,7 @@ ohos_shared_library("distributeddb") {
     "communicator/src/communicator.cpp",
     "communicator/src/communicator_aggregator.cpp",
     "communicator/src/communicator_linker.cpp",
+    "communicator/src/db_status_adapter.cpp",
     "communicator/src/frame_combiner.cpp",
     "communicator/src/frame_retainer.cpp",
     "communicator/src/header_converter.cpp",
@@ -254,6 +255,7 @@ ohos_shared_library("distributeddb") {
     "syncer/src/single_ver_sync_task_context.cpp",
     "syncer/src/single_ver_syncer.cpp",
     "syncer/src/subscribe_manager.cpp",
+    "syncer/src/subscribe_recorder.cpp",
     "syncer/src/sync_config.cpp",
     "syncer/src/sync_engine.cpp",
     "syncer/src/sync_operation.cpp",
diff --git a/frameworks/libs/distributeddb/common/include/db_common.h b/frameworks/libs/distributeddb/common/include/db_common.h
index 2b51e51e45d4375a010b8f3753aafba456c1242b..3fdb3f4b24500b0d61b0ae983612bf2ebb48ce39 100644
--- a/frameworks/libs/distributeddb/common/include/db_common.h
+++ b/frameworks/libs/distributeddb/common/include/db_common.h
@@ -70,6 +70,8 @@ public:
     static bool IsSameCipher(CipherType srcType, CipherType inputType);
 
     static bool CheckIsAlnumAndUnderscore(const std::string &text);
+
+    static std::string GenerateHashLabel(const DBInfo &dbInfo);
 };
 
 // Define short macro substitute for original long expression for convenience of using
diff --git a/frameworks/libs/distributeddb/common/include/runtime_context.h b/frameworks/libs/distributeddb/common/include/runtime_context.h
index 85c22557ed5b0b51ffe6569b6cad0dd04bfe0f6d..408427602ca672ba0ef891353af04719c38fd0e8 100644
--- a/frameworks/libs/distributeddb/common/include/runtime_context.h
+++ b/frameworks/libs/distributeddb/common/include/runtime_context.h
@@ -22,12 +22,14 @@
 
 #include "auto_launch.h"
 #include "auto_launch_export.h"
+#include "db_info_handle.h"
 #include "icommunicator_aggregator.h"
 #include "iprocess_system_api_adapter.h"
 #include "kv_store_observer.h"
 #include "kvdb_properties.h"
 #include "macro_utils.h"
 #include "notification_chain.h"
+#include "query_sync_object.h"
 #include "types_export.h"
 
 namespace DistributedDB {
@@ -139,6 +141,19 @@ public:
     virtual std::map<std::string, std::string> GetPermissionCheckParam(const DBProperties &properties) = 0;
 
     virtual void StopTaskPool() = 0;
+
+    virtual void SetDBInfoHandle(const std::shared_ptr<DBInfoHandle> &handle) = 0;
+
+    virtual void NotifyDBInfos(const DeviceInfos &devInfos, const std::vector<DBInfo> &dbInfos) = 0;
+
+    virtual void RecordSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId, const QuerySyncObject &query) = 0;
+
+    virtual void RemoveSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId) = 0;
+
+    virtual void RemoveSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId, const QuerySyncObject &query) = 0;
+
+    virtual void GetSubscribeQuery(const DBInfo &dbInfo,
+        std::map<std::string, std::vector<QuerySyncObject>> &subscribeQuery) = 0;
 protected:
     RuntimeContext() = default;
     virtual ~RuntimeContext() {}
diff --git a/frameworks/libs/distributeddb/common/src/db_common.cpp b/frameworks/libs/distributeddb/common/src/db_common.cpp
index 9b51158ddca8d18a7a384cf5d725d05afb549883..359a93090b31fb767a64df66baa4ce4ab7b9f4c8 100644
--- a/frameworks/libs/distributeddb/common/src/db_common.cpp
+++ b/frameworks/libs/distributeddb/common/src/db_common.cpp
@@ -403,4 +403,13 @@ bool DBCommon::CheckIsAlnumAndUnderscore(const std::string &text)
         });
     return iter == text.end();
 }
+
+std::string DBCommon::GenerateHashLabel(const DBInfo &dbInfo)
+{
+    if (dbInfo.syncDualTupleMode) {
+        return DBCommon::TransferHashString(dbInfo.appId + "-" + dbInfo.storeId);
+    } else {
+        return DBCommon::TransferHashString(dbInfo.userId + "-" + dbInfo.appId + "-" + dbInfo.storeId);
+    }
+}
 } // namespace DistributedDB
diff --git a/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp b/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
index 8398c979b1f0b460c6b4364776d2c7b71687cc43..3f2af04c0cc1c601ea96bd334a79a824f13a81b2 100644
--- a/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
+++ b/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
@@ -31,7 +31,9 @@ RuntimeContextImpl::RuntimeContextImpl()
       timeTickMonitor_(nullptr),
       systemApiAdapter_(nullptr),
       lockStatusObserver_(nullptr),
-      currentSessionId_(1)
+      currentSessionId_(1),
+      dbStatusAdapter_(nullptr),
+      subscribeRecorder_(nullptr)
 {
 }
 
@@ -58,6 +60,8 @@ RuntimeContextImpl::~RuntimeContextImpl()
     delete lockStatusObserver_;
     lockStatusObserver_ = nullptr;
     userChangeMonitor_ = nullptr;
+    dbStatusAdapter_ = nullptr;
+    subscribeRecorder_ = nullptr;
 }
 
 // Set the label of this process.
@@ -94,6 +98,7 @@ int RuntimeContextImpl::SetCommunicatorAdapter(IAdapter *adapter)
 int RuntimeContextImpl::GetCommunicatorAggregator(ICommunicatorAggregator *&outAggregator)
 {
     outAggregator = nullptr;
+    const std::shared_ptr<DBStatusAdapter> statusAdapter = GetDBStatusAdapter();
     std::lock_guard<std::mutex> lock(communicatorLock_);
     if (communicatorAggregator_ != nullptr) {
         outAggregator = communicatorAggregator_;
@@ -111,7 +116,7 @@ int RuntimeContextImpl::GetCommunicatorAggregator(ICommunicatorAggregator *&outA
         return -E_OUT_OF_MEMORY;
     }
 
-    int errCode = communicatorAggregator_->Initialize(adapter_);
+    int errCode = communicatorAggregator_->Initialize(adapter_, statusAdapter);
     if (errCode != E_OK) {
         LOGE("CommunicatorAggregator init failed, err = %d!", errCode);
         RefObject::KillAndDecObjRef(communicatorAggregator_);
@@ -733,4 +738,97 @@ void RuntimeContextImpl::StopTaskPool()
         taskPool_ = nullptr;
     }
 }
+
+void RuntimeContextImpl::SetDBInfoHandle(const std::shared_ptr<DBInfoHandle> &handle)
+{
+    std::shared_ptr<DBStatusAdapter> dbStatusAdapter = GetDBStatusAdapter();
+    if (dbStatusAdapter != nullptr) {
+        dbStatusAdapter->SetDBInfoHandle(handle);
+    }
+    std::shared_ptr<SubscribeRecorder> subscribeRecorder = GetSubscribeRecorder();
+    if (subscribeRecorder != nullptr) {
+        subscribeRecorder->RemoveAllSubscribe();
+    }
+}
+
+void RuntimeContextImpl::NotifyDBInfos(const DeviceInfos &devInfos, const std::vector<DBInfo> &dbInfos)
+{
+    std::shared_ptr<DBStatusAdapter> dbStatusAdapter = GetDBStatusAdapter();
+    if (dbStatusAdapter != nullptr) {
+        dbStatusAdapter->NotifyDBInfos(devInfos, dbInfos);
+    }
+}
+
+std::shared_ptr<DBStatusAdapter> RuntimeContextImpl::GetDBStatusAdapter()
+{
+    std::lock_guard<std::mutex> autoLock(statusAdapterMutex_);
+    if (dbStatusAdapter_ == nullptr) {
+        dbStatusAdapter_ = std::make_unique<DBStatusAdapter>();
+    }
+    if (dbStatusAdapter_ == nullptr) {
+        LOGE("[RuntimeContextImpl] DbStatusAdapter create failed!");
+    }
+    return dbStatusAdapter_;
+}
+
+void RuntimeContextImpl::RecordSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId, const QuerySyncObject &query)
+{
+    std::shared_ptr<DBStatusAdapter> dbStatusAdapter = GetDBStatusAdapter();
+    if (dbStatusAdapter != nullptr && !dbStatusAdapter->IsSupport(deviceId)) {
+        return;
+    }
+    std::shared_ptr<SubscribeRecorder> subscribeRecorder = GetSubscribeRecorder();
+    if (subscribeRecorder != nullptr) {
+        subscribeRecorder->RecordSubscribe(dbInfo, deviceId, query);
+    }
+}
+
+void RuntimeContextImpl::RemoveSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId)
+{
+    std::shared_ptr<DBStatusAdapter> dbStatusAdapter = GetDBStatusAdapter();
+    if (dbStatusAdapter != nullptr && !dbStatusAdapter->IsSupport(deviceId)) {
+        return;
+    }
+    std::shared_ptr<SubscribeRecorder> subscribeRecorder = GetSubscribeRecorder();
+    if (subscribeRecorder != nullptr) {
+        subscribeRecorder->RemoveSubscribe(dbInfo, deviceId);
+    }
+}
+
+void RuntimeContextImpl::RemoveSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId, const QuerySyncObject &query)
+{
+    std::shared_ptr<DBStatusAdapter> dbStatusAdapter = GetDBStatusAdapter();
+    if (dbStatusAdapter != nullptr && !dbStatusAdapter->IsSupport(deviceId)) {
+        return;
+    }
+    std::shared_ptr<SubscribeRecorder> subscribeRecorder = GetSubscribeRecorder();
+    if (subscribeRecorder != nullptr) {
+        subscribeRecorder->RemoveSubscribe(dbInfo, deviceId, query);
+    }
+}
+
+void RuntimeContextImpl::GetSubscribeQuery(const DBInfo &dbInfo,
+    std::map<std::string, std::vector<QuerySyncObject>> &subscribeQuery)
+{
+    std::shared_ptr<DBStatusAdapter> dbStatusAdapter = GetDBStatusAdapter();
+    if (dbStatusAdapter != nullptr && !dbStatusAdapter->ExistDBInfoHandle()) {
+        return;
+    }
+    std::shared_ptr<SubscribeRecorder> subscribeRecorder = GetSubscribeRecorder();
+    if (subscribeRecorder != nullptr) {
+        subscribeRecorder->GetSubscribeQuery(dbInfo, subscribeQuery);
+    }
+}
+
+std::shared_ptr<SubscribeRecorder> RuntimeContextImpl::GetSubscribeRecorder()
+{
+    std::lock_guard<std::mutex> autoLock(subscribeRecorderMutex_);
+    if (subscribeRecorder_ == nullptr) {
+        subscribeRecorder_ = std::make_unique<SubscribeRecorder>();
+    }
+    if (subscribeRecorder_ == nullptr) {
+        LOGE("[RuntimeContextImpl] SubscribeRecorder create failed!");
+    }
+    return subscribeRecorder_;
+}
 } // namespace DistributedDB
diff --git a/frameworks/libs/distributeddb/common/src/runtime_context_impl.h b/frameworks/libs/distributeddb/common/src/runtime_context_impl.h
index e79d23eee3db91ab9ccfcff3a0139bb23817a405..7ec6ecf6604c03b5bc14c37eb0818a828b1a70f6 100644
--- a/frameworks/libs/distributeddb/common/src/runtime_context_impl.h
+++ b/frameworks/libs/distributeddb/common/src/runtime_context_impl.h
@@ -21,10 +21,12 @@
 #include <shared_mutex>
 
 #include "auto_launch.h"
+#include "db_status_adapter.h"
 #include "evloop/src/ievent.h"
 #include "evloop/src/ievent_loop.h"
 #include "icommunicator_aggregator.h"
 #include "lock_status_observer.h"
+#include "subscribe_recorder.h"
 #include "task_pool.h"
 #include "time_tick_monitor.h"
 #include "user_change_monitor.h"
@@ -127,6 +129,19 @@ public:
     std::map<std::string, std::string> GetPermissionCheckParam(const DBProperties &properties) override;
 
     void StopTaskPool() override;
+
+    void SetDBInfoHandle(const std::shared_ptr<DBInfoHandle> &handle) override;
+
+    void NotifyDBInfos(const DeviceInfos &devInfos, const std::vector<DBInfo> &dbInfos) override;
+
+    void RecordSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId, const QuerySyncObject &query) override;
+
+    void RemoveSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId) override;
+
+    void RemoveSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId, const QuerySyncObject &query) override;
+
+    void GetSubscribeQuery(const DBInfo &dbInfo,
+        std::map<std::string, std::vector<QuerySyncObject>> &subscribeQuery) override;
 private:
     static constexpr int MAX_TP_THREADS = 10;  // max threads of the task pool.
     static constexpr int MIN_TP_THREADS = 1;   // min threads of the task pool.
@@ -135,6 +150,8 @@ private:
     int PrepareLoop(IEventLoop *&loop);
     int PrepareTaskPool();
     int AllocTimerId(IEvent *evTimer, TimerId &timerId);
+    std::shared_ptr<DBStatusAdapter> GetDBStatusAdapter();
+    std::shared_ptr<SubscribeRecorder> GetSubscribeRecorder();
 
     // Context fields
     mutable std::mutex labelMutex_;
@@ -189,6 +206,12 @@ private:
     // Get map from this callback, use for run permission check in remote device
     mutable std::shared_mutex permissionConditionLock_;
     PermissionConditionCallback permissionConditionCallback_;
+
+    mutable std::mutex statusAdapterMutex_;
+    std::shared_ptr<DBStatusAdapter> dbStatusAdapter_;
+
+    mutable std::mutex subscribeRecorderMutex_;
+    std::shared_ptr<SubscribeRecorder> subscribeRecorder_;
 };
 } // namespace DistributedDB
 
diff --git a/frameworks/libs/distributeddb/communicator/include/communicator_aggregator.h b/frameworks/libs/distributeddb/communicator/include/communicator_aggregator.h
index c3a31cdc1271b90bd2d3680f78464a12bb4bee26..c709f748dfe1c21d7b79209cda5efc8df2e8e533 100644
--- a/frameworks/libs/distributeddb/communicator/include/communicator_aggregator.h
+++ b/frameworks/libs/distributeddb/communicator/include/communicator_aggregator.h
@@ -54,7 +54,7 @@ public:
     DISABLE_COPY_ASSIGN_MOVE(CommunicatorAggregator);
 
     // See ICommunicatorAggregator for detail
-    int Initialize(IAdapter *inAdapter) override;
+    int Initialize(IAdapter *inAdapter, const std::shared_ptr<DBStatusAdapter> &statusAdapter) override;
 
     // Must not call any other functions if Finalize had been called. In fact, Finalize has no chance to be called.
     void Finalize() override;
@@ -135,6 +135,12 @@ private:
     // Record the protocol version of remote target.
     void SetRemoteCommunicatorVersion(const std::string &target, uint16_t version);
 
+    void OnRemoteDBStatusChange(const std::string &devInfo, const std::vector<DBInfo> &dbInfos);
+
+    void NotifyConnectChange(const std::string &srcTarget, const std::map<LabelType, bool> &changedLabels);
+
+    void RegDBChangeCallback();
+
     DECLARE_OBJECT_TAG(CommunicatorAggregator);
 
     static std::atomic<bool> isCommunicatorNotFoundFeedbackEnable_;
@@ -175,6 +181,8 @@ private:
     OnConnectCallback onConnectHandle_;
     Finalizer onConnectFinalizer_;
     mutable std::mutex onConnectMutex_;
+
+    std::shared_ptr<DBStatusAdapter> dbStatusAdapter_;
 };
 } // namespace DistributedDB
 
diff --git a/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h b/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h
new file mode 100644
index 0000000000000000000000000000000000000000..8d58470f6b977ddbe9078b6e9edac830ac35ac00
--- /dev/null
+++ b/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2022 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 DB_STATUS_ADAPTER_H
+#define DB_STATUS_ADAPTER_H
+
+#include "db_info_handle.h"
+#include <mutex>
+#include "macro_utils.h"
+
+namespace DistributedDB {
+using RemoteDBChangeCallback = std::function<void(const std::string &devInfo, const std::vector<DBInfo> &dbInfos)>;
+using LocalDBChangeCallback = std::function<void(void)>;
+class DBStatusAdapter {
+public:
+    DBStatusAdapter();
+    ~DBStatusAdapter() = default;
+    DISABLE_COPY_ASSIGN_MOVE(DBStatusAdapter);
+
+    void SetDBInfoHandle(const std::shared_ptr<DBInfoHandle> &dbInfoHandle);
+    bool ExistDBInfoHandle() const;
+    bool IsSupport(const std::string &devInfo);
+    int GetDBInfos(std::vector<DBInfo> &dbInfos) const;
+    void SetDBStatusChangeCallback(const RemoteDBChangeCallback &remote, const LocalDBChangeCallback &local);
+    void NotifyDBInfos(const DeviceInfos &devInfos, const std::vector<DBInfo> &dbInfos);
+    void TargetOffline(const std::string &device);
+private:
+    std::shared_ptr<DBInfoHandle> GetDBInfoHandle() const;
+    bool LoadIntoCache(const DeviceInfos &devInfos, const std::vector<DBInfo> &dbInfos,
+        std::vector<DBInfo> &changeDbInfos);
+    void ClearAllCache();
+
+    static int GetLocalDeviceId(std::string &deviceId);
+    static bool IsLocalDeviceId(const std::string &deviceId);
+    static void MergeDBInfos(const std::vector<DBInfo> &srcDbInfos, std::vector<DBInfo> &dstDbInfos,
+        std::vector<DBInfo> &changeDbInfos);
+    mutable std::mutex handleMutex_;
+    std::shared_ptr<DBInfoHandle> dbInfoHandle_ = nullptr;
+
+    mutable std::mutex callbackMutex_;
+    RemoteDBChangeCallback remoteCallback_;
+    LocalDBChangeCallback localCallback_;
+
+    mutable std::mutex localInfoMutex_;
+    std::vector<DBInfo> localDBInfos_;
+
+    mutable std::mutex remoteInfoMutex_;
+    std::map<std::string, std::vector<DBInfo>> remoteDBInfos_;
+
+    mutable std::mutex supportMutex_;
+    std::map<std::string, bool> remoteSupportInfo_;
+};
+}
+#endif // DB_STATUS_ADAPTER_H
diff --git a/frameworks/libs/distributeddb/communicator/include/icommunicator_aggregator.h b/frameworks/libs/distributeddb/communicator/include/icommunicator_aggregator.h
index 06ae9e7c1e91e74188cf57540be44690eb309fe8..70ee63cf8f1b09bc74c00931df7a31a36c9f4145 100644
--- a/frameworks/libs/distributeddb/communicator/include/icommunicator_aggregator.h
+++ b/frameworks/libs/distributeddb/communicator/include/icommunicator_aggregator.h
@@ -18,6 +18,7 @@
 
 #include <cstdint>
 #include "communicator_type_define.h"
+#include "db_status_adapter.h"
 #include "iadapter.h"
 #include "ref_object.h"
 
@@ -32,7 +33,7 @@ public:
     // The caller is the owner of inAdapter and responsible for manage its lifecycle.
     // The ICommunicatorAggregator is only the user of inAdapter
     // If Initialize fail, the ICommunicatorAggregator will rollback what had done to inAdapter so it can be reuse.
-    virtual int Initialize(IAdapter *inAdapter) = 0;
+    virtual int Initialize(IAdapter *inAdapter, const std::shared_ptr<DBStatusAdapter> &statusAdapter) = 0;
 
     // Call this method after Initialize successfully and before destroy the ICommunicatorAggregator
     // Emphasize again : DO NOT CALL Finalize IF Initialize FAIL.
diff --git a/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp b/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp
index 3cb9f9aab447e1014d37bdebba8e481af0ac4e28..95f01b098400c9388677b6a3c22f5f07c2b1b53b 100644
--- a/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp
@@ -50,7 +50,7 @@ CommunicatorAggregator::~CommunicatorAggregator()
     commLinker_ = nullptr;
 }
 
-int CommunicatorAggregator::Initialize(IAdapter *inAdapter)
+int CommunicatorAggregator::Initialize(IAdapter *inAdapter, const std::shared_ptr<DBStatusAdapter> &statusAdapter)
 {
     if (inAdapter == nullptr) {
         return -E_INVALID_ARGS;
@@ -62,7 +62,7 @@ int CommunicatorAggregator::Initialize(IAdapter *inAdapter)
     scheduler_.Initialize();
 
     int errCode;
-    commLinker_ = new (std::nothrow) CommunicatorLinker(this);
+    commLinker_ = new (std::nothrow) CommunicatorLinker(this, statusAdapter);
     if (commLinker_ == nullptr) {
         errCode = -E_OUT_OF_MEMORY;
         goto ROLL_BACK;
@@ -83,6 +83,8 @@ int CommunicatorAggregator::Initialize(IAdapter *inAdapter)
 
     shutdown_ = false;
     exclusiveThread_ = std::thread(&CommunicatorAggregator::SendDataRoutine, this);
+    dbStatusAdapter_ = statusAdapter;
+    RegDBChangeCallback();
     return E_OK;
 ROLL_BACK:
     UnRegCallbackFromAdapter();
@@ -118,6 +120,7 @@ void CommunicatorAggregator::Finalize()
     commLinker_ = nullptr;
     retainer_.Finalize();
     combiner_.Finalize();
+    dbStatusAdapter_ = nullptr;
 }
 
 ICommunicator *CommunicatorAggregator::AllocCommunicator(uint64_t commLabel, int &outErrorNo)
@@ -617,23 +620,7 @@ int CommunicatorAggregator::OnCommLayerFrameReceive(const std::string &srcTarget
             LOGE("[CommAggr][CommReceive] Receive LabelExchange Fail.");
             return errCode;
         }
-        if (!commLinker_->IsRemoteTargetOnline(srcTarget)) {
-            LOGW("[CommAggr][CommReceive] Receive LabelExchange from offline target=%s{private}.", srcTarget.c_str());
-            for (const auto &entry : changedLabels) {
-                LOGW("[CommAggr][CommReceive] REMEMBER: label=%s, inOnline=%d.", VEC_TO_STR(entry.first), entry.second);
-            }
-            return E_OK;
-        }
-        // Do target change notify
-        std::lock_guard<std::mutex> commMapLockGuard(commMapMutex_);
-        for (auto &entry : changedLabels) {
-            // Ignore nonactivated communicator
-            if (commMap_.count(entry.first) != 0 && commMap_.at(entry.first).second) {
-                LOGI("[CommAggr][CommReceive] label=%s, srcTarget=%s{private}, isOnline=%d.",
-                    VEC_TO_STR(entry.first), srcTarget.c_str(), entry.second);
-                commMap_.at(entry.first).first->OnConnectChange(srcTarget, entry.second);
-            }
-        }
+        NotifyConnectChange(srcTarget, changedLabels);
     }
     return E_OK;
 }
@@ -768,6 +755,7 @@ void CommunicatorAggregator::UnRegCallbackFromAdapter()
     adapterHandle_->RegBytesReceiveCallback(nullptr, nullptr);
     adapterHandle_->RegTargetChangeCallback(nullptr, nullptr);
     adapterHandle_->RegSendableCallback(nullptr, nullptr);
+    dbStatusAdapter_->SetDBStatusChangeCallback(nullptr, nullptr);
 }
 
 void CommunicatorAggregator::GenerateLocalSourceId()
@@ -879,5 +867,54 @@ std::shared_ptr<ExtendHeaderHandle> CommunicatorAggregator::GetExtendHeaderHandl
     return adapterHandle_->GetExtendHeaderHandle(paramInfo);
 }
 
+void CommunicatorAggregator::OnRemoteDBStatusChange(const std::string &devInfo, const std::vector<DBInfo> &dbInfos)
+{
+    std::map<LabelType, bool> changedLabels;
+    for (const auto &dbInfo: dbInfos) {
+        std::string label = DBCommon::GenerateHashLabel(dbInfo);
+        LabelType labelType(label.begin(), label.end());
+        changedLabels[labelType] = dbInfo.isNeedSync;
+    }
+    if (commLinker_ != nullptr) {
+        commLinker_->UpdateOnlineLabels(devInfo, changedLabels);
+    }
+    NotifyConnectChange(devInfo, changedLabels);
+}
+
+void CommunicatorAggregator::NotifyConnectChange(const std::string &srcTarget,
+    const std::map<LabelType, bool> &changedLabels)
+{
+    if (!commLinker_->IsRemoteTargetOnline(srcTarget)) {
+        LOGW("[CommAggr][NotifyConnectChange] from offline target=%s{private}.", srcTarget.c_str());
+        for (const auto &entry : changedLabels) {
+            LOGW("[CommAggr] REMEMBER: label=%s, inOnline=%d.", VEC_TO_STR(entry.first), entry.second);
+        }
+    }
+    // Do target change notify
+    std::lock_guard<std::mutex> commMapLockGuard(commMapMutex_);
+    for (auto &entry : changedLabels) {
+        // Ignore nonactivated communicator
+        if (commMap_.count(entry.first) != 0 && commMap_.at(entry.first).second) {
+            LOGI("[CommAggr][NotifyConnectChange] label=%s, srcTarget=%s{private}, isOnline=%d.",
+                 VEC_TO_STR(entry.first), srcTarget.c_str(), entry.second);
+            commMap_.at(entry.first).first->OnConnectChange(srcTarget, entry.second);
+        }
+    }
+}
+
+void CommunicatorAggregator::RegDBChangeCallback()
+{
+    if (dbStatusAdapter_ != nullptr) {
+        dbStatusAdapter_->SetDBStatusChangeCallback(
+            [this](const std::string &devInfo, const std::vector<DBInfo> &dbInfos) {
+                OnRemoteDBStatusChange(devInfo, dbInfos);
+            },
+            [this](){
+                if (commLinker_ != nullptr) {
+                    (void)commLinker_->TriggerLabelExchangeEvent();
+                }
+            });
+    }
+}
 DEFINE_OBJECT_TAG_FACILITIES(CommunicatorAggregator)
 } // namespace DistributedDB
diff --git a/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp b/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp
index ab51b370d34c2d2a7361f70f99c9418ff2392bd8..acde3d7324a3b0e57c19016c159215f22893cd23 100644
--- a/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp
@@ -14,7 +14,10 @@
  */
 
 #include "communicator_linker.h"
+
+#include <utility>
 #include "communicator_aggregator.h"
+#include "db_common.h"
 #include "db_errno.h"
 #include "hash.h"
 #include "log_print.h"
@@ -29,10 +32,12 @@ constexpr uint32_t RETRANSMIT_LIMIT = 20; // Currently we do at most 20 retransm
 constexpr uint32_t RETRANSMIT_LIMIT_EQUAL_INTERVAL = 5; // First 5 retransmission will be equal interval
 }
 
-CommunicatorLinker::CommunicatorLinker(CommunicatorAggregator *inAggregator)
+CommunicatorLinker::CommunicatorLinker(CommunicatorAggregator *inAggregator,
+    std::shared_ptr<DBStatusAdapter> statusAdapter)
     : incSequenceId_(0), incAckTriggerId_(0)
 {
     aggregator_ = inAggregator;
+    statusAdapter_ = std::move(statusAdapter);
     RefObject::IncObjRef(aggregator_); // The linker rely on CommunicatorAggregator
 }
 
@@ -40,6 +45,7 @@ CommunicatorLinker::~CommunicatorLinker()
 {
     RefObject::DecObjRef(aggregator_); // The linker no longer rely on CommunicatorAggregator
     aggregator_ = nullptr;
+    statusAdapter_ = nullptr;
 }
 
 void CommunicatorLinker::Initialize()
@@ -75,6 +81,9 @@ int CommunicatorLinker::TargetOnline(const std::string &inTarget, std::set<Label
 // The caller should notify all related communicator about this target offline.
 void CommunicatorLinker::TargetOffline(const std::string &inTarget, std::set<LabelType> &outRelatedLabels)
 {
+    if (statusAdapter_ != nullptr) {
+        statusAdapter_->TargetOffline(inTarget);
+    }
     std::lock_guard<std::mutex> entireInfoLockGuard(entireInfoMutex_);
     outRelatedLabels = targetMapOnlineLabels_[inTarget];
     // Do not erase the Labels of inTarget from targetMapOnlineLabels_, remember it for using when TargetOnline
@@ -83,6 +92,9 @@ void CommunicatorLinker::TargetOffline(const std::string &inTarget, std::set<Lab
     // the distinctValue of this remote target may be changed, and the sequenceId may start from zero
     targetDistinctValue_.erase(inTarget);
     topRecvLabelSeq_.erase(inTarget);
+    if (statusAdapter_ != nullptr && statusAdapter_->IsSupport(inTarget)) {
+        targetMapOnlineLabels_.erase(inTarget);
+    }
 }
 
 // Add local label. Create async task to send out label_exchange and waiting for label_exchange_ack.
@@ -91,11 +103,9 @@ void CommunicatorLinker::TargetOffline(const std::string &inTarget, std::set<Lab
 // The caller should notify communicator of this label about already online target.
 int CommunicatorLinker::IncreaseLocalLabel(const LabelType &inLabel, std::set<std::string> &outOnlineTarget)
 {
-    std::set<std::string> totalOnlineTargets;
     {
         std::lock_guard<std::mutex> entireInfoLockGuard(entireInfoMutex_);
         localOnlineLabels_.insert(inLabel);
-        totalOnlineTargets = remoteOnlineTarget_;
         for (auto &entry : targetMapOnlineLabels_) {
             if (remoteOnlineTarget_.count(entry.first) == 0) { // Ignore offline target
                 continue;
@@ -105,13 +115,7 @@ int CommunicatorLinker::IncreaseLocalLabel(const LabelType &inLabel, std::set<st
             }
         }
     }
-    bool everFail = false;
-    for (auto &entry : totalOnlineTargets) {
-        int errCode = TriggerLabelExchangeEvent(entry);
-        if (errCode != E_OK) {
-            everFail = true;
-        }
-    }
+    bool everFail = TriggerLabelExchangeEvent();
     return everFail ? -E_INTERNAL_ERROR : E_OK;
 }
 
@@ -288,14 +292,26 @@ void CommunicatorLinker::DetectDistinctValueChange(const std::string &inTarget,
 
 int CommunicatorLinker::TriggerLabelExchangeEvent(const std::string &toTarget)
 {
+    if (statusAdapter_ != nullptr && statusAdapter_->IsSupport(toTarget)) {
+        return E_OK;
+    }
     // Apply for a latest sequenceId
     uint64_t sequenceId = incSequenceId_.fetch_add(1, std::memory_order_seq_cst);
     // Get a snapshot of current online labels
     std::set<LabelType> onlineLabels;
-    {
+    std::vector<DBInfo> dbInfos;
+    if (statusAdapter_ != nullptr && statusAdapter_->ExistDBInfoHandle() &&
+        statusAdapter_->GetDBInfos(dbInfos) == E_OK) {
+        for (const auto &dbInfo: dbInfos) {
+            std::string label = DBCommon::GenerateHashLabel(dbInfo);
+            LabelType labelType(label.begin(), label.end());
+            onlineLabels.insert(labelType);
+        }
+    } else {
         std::lock_guard<std::mutex> entireInfoLockGuard(entireInfoMutex_);
         onlineLabels = localOnlineLabels_;
     }
+
     // Build LabelExchange Frame
     int error = E_OK;
     SerialBuffer *buffer = ProtocolProto::BuildLabelExchange(localDistinctValue_, sequenceId, onlineLabels, error);
@@ -466,5 +482,36 @@ void CommunicatorLinker::SendLabelExchangeAck(const std::string &toTarget, Seria
     }
 }
 
+void CommunicatorLinker::UpdateOnlineLabels(const std::string &device, const std::map<LabelType, bool> &labels)
+{
+    std::lock_guard<std::mutex> entireInfoLockGuard(entireInfoMutex_);
+    for (const auto &[label, isOnline]: labels) {
+        if (isOnline) {
+            targetMapOnlineLabels_[device].insert(label);
+        } else {
+            targetMapOnlineLabels_[device].erase(label);
+        }
+    }
+}
+
+bool CommunicatorLinker::TriggerLabelExchangeEvent()
+{
+    bool everFail = false;
+    std::set<std::string> totalOnlineTargets;
+    {
+        std::lock_guard<std::mutex> entireInfoLockGuard(entireInfoMutex_);
+        totalOnlineTargets = remoteOnlineTarget_;
+    }
+    for (auto &entry : totalOnlineTargets) {
+        if (statusAdapter_ != nullptr && statusAdapter_->ExistDBInfoHandle()) {
+            continue;
+        }
+        int errCode = TriggerLabelExchangeEvent(entry);
+        if (errCode != E_OK) {
+            everFail = true;
+        }
+    }
+    return everFail;
+}
 DEFINE_OBJECT_TAG_FACILITIES(CommunicatorLinker)
 } // namespace DistributedDB
diff --git a/frameworks/libs/distributeddb/communicator/src/communicator_linker.h b/frameworks/libs/distributeddb/communicator/src/communicator_linker.h
index 3d0d701d312d5fa897df033891394057b0d5432c..7c6a84ecc7f92a09fa294907807c3a0e4bf64c6c 100644
--- a/frameworks/libs/distributeddb/communicator/src/communicator_linker.h
+++ b/frameworks/libs/distributeddb/communicator/src/communicator_linker.h
@@ -25,6 +25,7 @@
 #include <string>
 #include <vector>
 #include "communicator_type_define.h"
+#include "db_status_adapter.h"
 #include "ref_object.h"
 #include "serial_buffer.h"
 
@@ -33,7 +34,8 @@ class CommunicatorAggregator; // Forward Declaration
 
 class CommunicatorLinker : public virtual RefObject {
 public:
-    explicit CommunicatorLinker(CommunicatorAggregator *inAggregator);
+    explicit CommunicatorLinker(CommunicatorAggregator *inAggregator,
+        std::shared_ptr<DBStatusAdapter> statusAdapter);
     ~CommunicatorLinker();
 
     DISABLE_COPY_ASSIGN_MOVE(CommunicatorLinker);
@@ -71,6 +73,10 @@ public:
     std::set<std::string> GetOnlineRemoteTarget() const;
 
     bool IsRemoteTargetOnline(const std::string &inTarget) const;
+
+    void UpdateOnlineLabels(const std::string &device, const std::map<LabelType, bool> &labels);
+
+    bool TriggerLabelExchangeEvent();
 private:
     DECLARE_OBJECT_TAG(CommunicatorLinker);
 
@@ -116,6 +122,8 @@ private:
 
     // remember the opened labels no matter target now online or offline
     std::map<std::string, std::set<LabelType>> targetMapOnlineLabels_;
+
+    std::shared_ptr<DBStatusAdapter> statusAdapter_;
 };
 }
 
diff --git a/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e887addf47010acc35aef514d792c07bac37f528
--- /dev/null
+++ b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
@@ -0,0 +1,224 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "db_status_adapter.h"
+
+#include "db_common.h"
+#include "db_errno.h"
+#include "param_check_utils.h"
+#include "runtime_context.h"
+#include "log_print.h"
+
+namespace DistributedDB {
+DBStatusAdapter::DBStatusAdapter()
+    : dbInfoHandle_(nullptr)
+{
+}
+
+void DBStatusAdapter::SetDBInfoHandle(const std::shared_ptr<DBInfoHandle> &dbInfoHandle)
+{
+    std::lock_guard<std::mutex> autoLock(handleMutex_);
+    dbInfoHandle_ = dbInfoHandle;
+    ClearAllCache();
+    LOGI("[DBStatusAdapter] SetDBInfoHandle Finish");
+}
+
+bool DBStatusAdapter::ExistDBInfoHandle() const
+{
+    std::lock_guard<std::mutex> autoLock(handleMutex_);
+    return dbInfoHandle_ == nullptr;
+}
+
+bool DBStatusAdapter::IsSupport(const std::string &devInfo)
+{
+    std::shared_ptr<DBInfoHandle> dbInfoHandle = GetDBInfoHandle();
+    if (dbInfoHandle == nullptr) {
+        LOGD("[DBStatusAdapter] dbInfoHandle not set");
+        return false;
+    }
+    {
+        std::lock_guard<std::mutex> autoLock(supportMutex_);
+        if (remoteSupportInfo_.find(devInfo) != remoteSupportInfo_.end()) {
+            return remoteSupportInfo_[devInfo];
+        }
+    }
+    bool res = dbInfoHandle->IsSupport({devInfo});
+    std::lock_guard<std::mutex> autoLock(supportMutex_);
+    remoteSupportInfo_[devInfo] = res;
+    return res;
+}
+
+int DBStatusAdapter::GetDBInfos(std::vector<DBInfo> &dbInfos) const
+{
+    std::shared_ptr<DBInfoHandle> dbInfoHandle = GetDBInfoHandle();
+    if (dbInfoHandle == nullptr) {
+        LOGD("[DBStatusAdapter][GetDBInfos] handle not set");
+        return -E_NOT_SUPPORT;
+    }
+    std::lock_guard<std::mutex> autoLock(localInfoMutex_);
+    for (const auto &info: localDBInfos_) {
+        if (info.isNeedSync) {
+            dbInfos.push_back(info);
+        }
+    }
+    return E_OK;
+}
+
+void DBStatusAdapter::SetDBStatusChangeCallback(const RemoteDBChangeCallback &remote,
+    const LocalDBChangeCallback &local)
+{
+    {
+        std::lock_guard<std::mutex> autoLock(callbackMutex_);
+        remoteCallback_ = remote;
+        localCallback_ = local;
+    }
+    // avoid notify before set callback
+    bool triggerNow = false;
+    std::map<std::string, std::vector<DBInfo>> remoteDBInfos;
+    {
+        std::lock_guard<std::mutex> autoLock(remoteInfoMutex_);
+        remoteDBInfos = remoteDBInfos_;
+        triggerNow |= !remoteDBInfos.empty();
+    }
+    bool triggerLocal = false;
+    {
+        std::lock_guard<std::mutex> autoLock(localInfoMutex_);
+        triggerLocal = !localDBInfos_.empty();
+        triggerNow |= triggerLocal;
+    }
+    // trigger callback async
+    if (!triggerNow) {
+        return;
+    }
+    int errCode = RuntimeContext::GetInstance()->ScheduleTask([triggerLocal, remoteDBInfos, remote, local]() {
+        for (const auto &[devInfo, dbInfos]: remoteDBInfos) {
+            remote(devInfo, dbInfos);
+        }
+        if (triggerLocal) {
+            local();
+        }
+    });
+    if (errCode != E_OK) {
+        LOGW("[DBStatusAdapter][SetDBStatusChangeCallback] Schedule Task failed! errCode = %d", errCode);
+    }
+}
+
+void DBStatusAdapter::NotifyDBInfos(const DeviceInfos &devInfos, const std::vector<DBInfo> &dbInfos)
+{
+    int errCode = RuntimeContext::GetInstance()->ScheduleTask([this, devInfos, dbInfos]() {
+        if (!IsLocalDeviceId(devInfos.identifier) && !IsSupport(devInfos.identifier)) {
+            LOGW("[DBStatusAdapter][NotifyDBInfos] no support dev %s", STR_MASK(devInfos.identifier));
+        }
+        std::vector<DBInfo> changeDbInfos;
+        bool isRemote = LoadIntoCache(devInfos, dbInfos, changeDbInfos);
+        std::lock_guard<std::mutex> autoLock(callbackMutex_);
+        if (isRemote && remoteCallback_ != nullptr) {
+            remoteCallback_(devInfos.identifier, changeDbInfos);
+        } else if (!isRemote && localCallback_ != nullptr && !changeDbInfos.empty()) {
+            localCallback_();
+        }
+    });
+    if (errCode != E_OK) {
+        LOGW("[DBStatusAdapter][NotifyDBInfos] Schedule Task failed! errCode = %d", errCode);
+    }
+}
+
+void DBStatusAdapter::TargetOffline(const std::string &device)
+{
+    std::shared_ptr<DBInfoHandle> dbInfoHandle = GetDBInfoHandle();
+    if (dbInfoHandle == nullptr) {
+        return;
+    }
+    {
+        std::lock_guard<std::mutex> autoLock(supportMutex_);
+        if (remoteSupportInfo_.find(device) != remoteSupportInfo_.end()) {
+            remoteSupportInfo_.erase(device);
+        }
+    }
+}
+
+std::shared_ptr<DBInfoHandle> DBStatusAdapter::GetDBInfoHandle() const
+{
+    std::lock_guard<std::mutex> autoLock(handleMutex_);
+    return dbInfoHandle_;
+}
+
+bool DBStatusAdapter::LoadIntoCache(const DeviceInfos &devInfos, const std::vector<DBInfo> &dbInfos,
+    std::vector<DBInfo> &changeDbInfos)
+{
+    if (IsLocalDeviceId(devInfos.identifier)) {
+        std::lock_guard<std::mutex> autoLock(localInfoMutex_);
+        MergeDBInfos(dbInfos, localDBInfos_, changeDbInfos);
+        return false;
+    }
+    std::lock_guard<std::mutex> autoLock(remoteInfoMutex_);
+    if (remoteDBInfos_.find(devInfos.identifier) == remoteDBInfos_.end()) {
+        remoteDBInfos_.insert({devInfos.identifier, {}});
+    }
+    MergeDBInfos(dbInfos, remoteDBInfos_[devInfos.identifier], changeDbInfos);
+    return true;
+}
+
+void DBStatusAdapter::ClearAllCache()
+{
+    {
+        std::lock_guard<std::mutex> autoLock(localInfoMutex_);
+        localDBInfos_.clear();
+        LOGD("[DBStatusAdapter][ClearAllCache] LocalCache clear ok");
+    }
+    std::lock_guard<std::mutex> autoLock(remoteInfoMutex_);
+    remoteDBInfos_.clear();
+    LOGD("[DBStatusAdapter][ClearAllCache] RemoteCache clear ok");
+}
+
+void DBStatusAdapter::MergeDBInfos(const std::vector<DBInfo> &srcDbInfos, std::vector<DBInfo> &dstDbInfos,
+    std::vector<DBInfo> &changeDbInfos)
+{
+    for (const auto &srcInfo: srcDbInfos) {
+        if (!ParamCheckUtils::CheckStoreParameter(srcInfo.storeId, srcInfo.appId, srcInfo.userId)) {
+            continue;
+        }
+        auto res = std::find_if(dstDbInfos.begin(), dstDbInfos.end(), [&srcInfo](const DBInfo &dstInfo) {
+            return srcInfo.appId == dstInfo.appId && srcInfo.userId == dstInfo.userId
+                && srcInfo.storeId == dstInfo.storeId && srcInfo.syncDualTupleMode == dstInfo.syncDualTupleMode;
+        });
+        if (res == dstDbInfos.end()) {
+            dstDbInfos.push_back(srcInfo);
+            changeDbInfos.push_back(srcInfo);
+        } else if (res->isNeedSync != srcInfo.isNeedSync){
+            res->isNeedSync = srcInfo.isNeedSync;
+            changeDbInfos.push_back(srcInfo);
+        }
+    }
+}
+
+int DBStatusAdapter::GetLocalDeviceId(std::string &deviceId)
+{
+    ICommunicatorAggregator *communicatorAggregator = nullptr;
+    int errCode = RuntimeContext::GetInstance()->GetCommunicatorAggregator(communicatorAggregator);
+    if (errCode != E_OK) {
+        return errCode;
+    }
+    return communicatorAggregator->GetLocalIdentity(deviceId);
+}
+
+bool DBStatusAdapter::IsLocalDeviceId(const std::string &deviceId)
+{
+    std::string localId;
+    if (GetLocalDeviceId(localId) != E_OK) {
+        return false;
+    }
+    return deviceId == localId;
+}
+}
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/interfaces/include/db_info_handle.h b/frameworks/libs/distributeddb/interfaces/include/db_info_handle.h
new file mode 100644
index 0000000000000000000000000000000000000000..be05ec21c784912bd783a9c00098383bd1419d98
--- /dev/null
+++ b/frameworks/libs/distributeddb/interfaces/include/db_info_handle.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2022 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 DB_INFO_HANDLE_H
+#define DB_INFO_HANDLE_H
+
+#include "iprocess_communicator.h"
+#include "store_types.h"
+
+namespace DistributedDB {
+// For all functions with returnType DBStatus:
+// return DBStatus::OK if successful, otherwise DBStatus::DB_ERROR if anything wrong.
+class DBInfoHandle {
+public:
+    DBInfoHandle() = default;
+    virtual ~DBInfoHandle() = default;
+    // return true if you can notify with RuntimeConfig::NotifyDBInfo,
+    // otherwise return false, and then we will call GetDBInfos for exchange local dbInfo with other devices.
+    virtual bool IsSupport(const DeviceInfos &devInfo) = 0;
+};
+}
+#endif // DB_INFO_HANDLE_H
diff --git a/frameworks/libs/distributeddb/interfaces/include/relational/runtime_config.h b/frameworks/libs/distributeddb/interfaces/include/relational/runtime_config.h
index 1386e47410a2c220dd423ac0530e390acbc01b23..5675d20353bcfda8557c397ea8b8deabea82a5ff 100644
--- a/frameworks/libs/distributeddb/interfaces/include/relational/runtime_config.h
+++ b/frameworks/libs/distributeddb/interfaces/include/relational/runtime_config.h
@@ -19,6 +19,7 @@
 #include <memory>
 #include <mutex>
 
+#include "db_info_handle.h"
 #include "iprocess_communicator.h"
 #include "iprocess_system_api_adapter.h"
 #include "store_types.h"
@@ -50,6 +51,10 @@ public:
 
     DB_API static bool IsProcessSystemApiAdapterValid();
 
+    DB_API static void SetDBInfoHandle(const std::shared_ptr<DBInfoHandle> &handle);
+
+    DB_API static void NotifyDBInfos(const DeviceInfos &devInfos, const std::vector<DBInfo> &dbInfos);
+
 private:
     static std::mutex communicatorMutex_;
     static std::mutex multiUserMutex_;
diff --git a/frameworks/libs/distributeddb/interfaces/include/store_types.h b/frameworks/libs/distributeddb/interfaces/include/store_types.h
index 1fc0b12eddcd3f3c8245e74b18285b65a34751b0..91aad1c0f275fa4315e3d6b8bcccc54e3ea7ead3 100644
--- a/frameworks/libs/distributeddb/interfaces/include/store_types.h
+++ b/frameworks/libs/distributeddb/interfaces/include/store_types.h
@@ -128,5 +128,13 @@ struct RemoteCondition {
     std::string sql;  // The sql statement;
     std::vector<std::string> bindArgs;  // The bind args.
 };
+
+struct DBInfo {
+    std::string userId;
+    std::string appId;
+    std::string storeId;
+    bool syncDualTupleMode = false;
+    bool isNeedSync = false;
+};
 } // namespace DistributedDB
 #endif // KV_STORE_TYPE_H
diff --git a/frameworks/libs/distributeddb/interfaces/src/relational/runtime_config.cpp b/frameworks/libs/distributeddb/interfaces/src/relational/runtime_config.cpp
index 1dbabc517ce0724c432cb55d1798f5bf1ef2a2bd..373884b90b55e97095bc4b7ea39e806d9cbffafa 100644
--- a/frameworks/libs/distributeddb/interfaces/src/relational/runtime_config.cpp
+++ b/frameworks/libs/distributeddb/interfaces/src/relational/runtime_config.cpp
@@ -128,5 +128,15 @@ DBStatus RuntimeConfig::SetPermissionConditionCallback(const PermissionCondition
     int errCode = RuntimeContext::GetInstance()->SetPermissionConditionCallback(callback);
     return TransferDBErrno(errCode);
 }
+
+void RuntimeConfig::SetDBInfoHandle(const std::shared_ptr<DBInfoHandle> &handle)
+{
+    RuntimeContext::GetInstance()->SetDBInfoHandle(handle);
+}
+
+void RuntimeConfig::NotifyDBInfos(const DeviceInfos &devInfos, const std::vector<DBInfo> &dbInfos)
+{
+    RuntimeContext::GetInstance()->NotifyDBInfos(devInfos, dbInfos);
+}
 } // namespace DistributedDB
 #endif
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/storage/include/sync_generic_interface.h b/frameworks/libs/distributeddb/storage/include/sync_generic_interface.h
index 1fc895c431ee671661091548d446b2c2f2f9b962..664ae9ad88919e8ae7fe847c82b525e3e33eabc4 100644
--- a/frameworks/libs/distributeddb/storage/include/sync_generic_interface.h
+++ b/frameworks/libs/distributeddb/storage/include/sync_generic_interface.h
@@ -17,6 +17,7 @@
 
 #include "isync_interface.h"
 #include "single_ver_kv_entry.h"
+#include "store_types.h"
 #include "query_object.h"
 
 namespace DistributedDB {
@@ -144,6 +145,13 @@ public:
     {
         return {};
     }
+
+    void GetDBInfo(DBInfo &dbInfo) const
+    {
+        dbInfo.appId = GetDbProperties().GetStringProp(DBProperties::APP_ID, "");
+        dbInfo.userId = GetDbProperties().GetStringProp(DBProperties::USER_ID, "");
+        dbInfo.storeId = GetDbProperties().GetStringProp(DBProperties::STORE_ID, "");
+    }
 };
 }
 #endif // SYNC_GENERIC_INTERFACE_H
diff --git a/frameworks/libs/distributeddb/syncer/src/isync_task_context.h b/frameworks/libs/distributeddb/syncer/src/isync_task_context.h
index d14caa4ae98e6006767bc12ebce0e5e5f043d6dc..8273553fb837568396573bd4607b6bf5842b9f22 100644
--- a/frameworks/libs/distributeddb/syncer/src/isync_task_context.h
+++ b/frameworks/libs/distributeddb/syncer/src/isync_task_context.h
@@ -180,6 +180,7 @@ public:
     virtual void Dump(int fd) = 0;
 
     virtual void AbortMachineIfNeed(uint32_t syncId) = 0;
+
 protected:
     virtual ~ISyncTaskContext() {};
 };
diff --git a/frameworks/libs/distributeddb/syncer/src/single_ver_data_sync.cpp b/frameworks/libs/distributeddb/syncer/src/single_ver_data_sync.cpp
index 421c8aae8f06b435b28c3bd075ad7648e627270f..d50e4e8b30ce0e288dd3d71192925f0ca6cd9bde 100644
--- a/frameworks/libs/distributeddb/syncer/src/single_ver_data_sync.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/single_ver_data_sync.cpp
@@ -1971,6 +1971,9 @@ int SingleVerDataSync::SubscribeRequestRecv(SingleVerSyncTaskContext *context, c
         return errCode;
     }
     subscribeManager->ActiveRemoteSubscribeQuery(context->GetDeviceId(), packet->GetQuery());
+    DBInfo dbInfo;
+    storage_->GetDBInfo(dbInfo);
+    RuntimeContext::GetInstance()->RecordSubscribe(dbInfo, context->GetDeviceId(), packet->GetQuery());
     return errCode;
 }
 
@@ -2005,6 +2008,9 @@ int SingleVerDataSync::UnsubscribeRequestRecv(SingleVerSyncTaskContext *context,
         return errCode;
     }
     subscribeManager->RemoveRemoteSubscribeQuery(context->GetDeviceId(), packet->GetQuery());
+    DBInfo dbInfo;
+    storage_->GetDBInfo(dbInfo);
+    RuntimeContext::GetInstance()->RemoveSubscribe(dbInfo, context->GetDeviceId(), packet->GetQuery());
     metadata_->RemoveQueryFromRecordSet(context->GetDeviceId(), packet->GetQuery().GetIdentify());
     return errCode;
 }
diff --git a/frameworks/libs/distributeddb/syncer/src/single_ver_sync_task_context.h b/frameworks/libs/distributeddb/syncer/src/single_ver_sync_task_context.h
index b5dcf47388b367c5ee14754cf82e0728b236d66d..c17c5dfbd36f3c556cc06527354bb02c767355cd 100644
--- a/frameworks/libs/distributeddb/syncer/src/single_ver_sync_task_context.h
+++ b/frameworks/libs/distributeddb/syncer/src/single_ver_sync_task_context.h
@@ -139,6 +139,7 @@ public:
 
     void StartFeedDogForGetData(uint32_t sessionId);
     void StopFeedDogForGetData();
+
 protected:
     ~SingleVerSyncTaskContext() override;
     void CopyTargetData(const ISyncTarget *target, const TaskParam &taskParam) override;
diff --git a/frameworks/libs/distributeddb/syncer/src/subscribe_manager.cpp b/frameworks/libs/distributeddb/syncer/src/subscribe_manager.cpp
index 757ed5800e1cc4a4c34452d5b10a1a2283243e16..54525cacca90c03b9156becc5f5c47b866fbf849 100644
--- a/frameworks/libs/distributeddb/syncer/src/subscribe_manager.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/subscribe_manager.cpp
@@ -226,6 +226,12 @@ int SubscribeManager::LocalSubscribeLimitCheck(const std::vector<std::string> &d
     return E_OK;
 }
 
+bool SubscribeManager::IsQueryExistSubscribe(const std::string &queryId) const
+{
+    std::shared_lock<std::shared_mutex> lockGuard(remoteSubscribedMapLock_);
+    return remoteSubscribedTotalMap_.find(queryId) == remoteSubscribedTotalMap_.end();
+}
+
 void SubscribeManager::ClearSubscribeQuery(const std::string &device, SubscribeMap &subscribeMap,
     SubscribedTotalMap &subscribedTotalMap)
 {
diff --git a/frameworks/libs/distributeddb/syncer/src/subscribe_manager.h b/frameworks/libs/distributeddb/syncer/src/subscribe_manager.h
index 42ca070c54b65850421b2d62c5ce5bc16d6283c4..fa6021402e0da54a484045de0b9f2f19a6354f4e 100644
--- a/frameworks/libs/distributeddb/syncer/src/subscribe_manager.h
+++ b/frameworks/libs/distributeddb/syncer/src/subscribe_manager.h
@@ -85,6 +85,8 @@ public:
     bool IsLastRemoteContainSubscribe(const std::string &device, const std::string &queryId) const;
 
     int LocalSubscribeLimitCheck(const std::vector<std::string> &devices, QuerySyncObject &query) const;
+
+    bool IsQueryExistSubscribe(const std::string &queryId) const;
 private:
     void ClearSubscribeQuery(const std::string &device, SubscribeMap &subscribeMap,
         SubscribedTotalMap &subscribedTotalMap);
diff --git a/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.cpp b/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..58ce9c8943dbdfc456bbfac4c5737d7e6cda5558
--- /dev/null
+++ b/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.cpp
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "subscribe_recorder.h"
+
+namespace DistributedDB {
+void SubscribeRecorder::RecordSubscribe(const DistributedDB::DBInfo &dbInfo, const DistributedDB::DeviceID &deviceId,
+    const DistributedDB::QuerySyncObject &query)
+{
+    std::lock_guard<std::mutex> autoLock(subscribeMutex_);
+    const auto &find = std::find_if(subscribeCache_.begin(), subscribeCache_.end(),
+    [&dbInfo](const SubscribeEntry &entry) {
+        return entry.dbInfo.userId == dbInfo.userId && entry.dbInfo.appId == dbInfo.appId &&
+            entry.dbInfo.storeId == dbInfo.storeId;
+    });
+    if (find != subscribeCache_.end()) {
+        find->subscribeQuery[deviceId].push_back(query);
+        return;
+    }
+    SubscribeEntry entry;
+    entry.dbInfo = dbInfo;
+    entry.subscribeQuery[deviceId].push_back(query);
+    subscribeCache_.push_back(entry);
+}
+
+void SubscribeRecorder::RemoveAllSubscribe()
+{
+    std::lock_guard<std::mutex> autoLock(subscribeMutex_);
+    subscribeCache_.clear();
+}
+
+void SubscribeRecorder::RemoveSubscribe(const DistributedDB::DBInfo &dbInfo, const DistributedDB::DeviceID &deviceId)
+{
+    RemoveSubscribeInner(dbInfo, deviceId, "", true);
+}
+
+void SubscribeRecorder::RemoveSubscribe(const DistributedDB::DBInfo &dbInfo, const DistributedDB::DeviceID &deviceId,
+    const DistributedDB::QuerySyncObject &query)
+{
+    RemoveSubscribeInner(dbInfo, deviceId, query.GetIdentify(), false);
+}
+
+void SubscribeRecorder::GetSubscribeQuery(const DistributedDB::DBInfo &dbInfo,
+    std::map<std::string, std::vector<QuerySyncObject>> &subscribeQuery) const
+{
+    std::lock_guard<std::mutex> autoLock(subscribeMutex_);
+    const auto &find = std::find_if(subscribeCache_.begin(), subscribeCache_.end(),
+    [&dbInfo](const SubscribeEntry &entry) {
+        return entry.dbInfo.userId == dbInfo.userId && entry.dbInfo.appId == dbInfo.appId &&
+               entry.dbInfo.storeId == dbInfo.storeId;
+    });
+    if (find != subscribeCache_.end()) {
+        subscribeQuery = find->subscribeQuery;
+    }
+}
+
+void SubscribeRecorder::RemoveSubscribeInner(const DBInfo &dbInfo, const DeviceID &deviceId,
+    const std::string &queryId, bool removeByDevice)
+{
+    std::lock_guard<std::mutex> autoLock(subscribeMutex_);
+    const auto &find = std::find_if(subscribeCache_.begin(), subscribeCache_.end(),
+        [&dbInfo](const SubscribeEntry &entry) {
+            return entry.dbInfo.userId == dbInfo.userId && entry.dbInfo.appId == dbInfo.appId &&
+                   entry.dbInfo.storeId == dbInfo.storeId;
+        });
+    if (find == subscribeCache_.end()) {
+        return;
+    }
+    if (removeByDevice) {
+        find->subscribeQuery.erase(deviceId);
+        return;
+    }
+    const auto &queryList = find->subscribeQuery.find(deviceId);
+    if (queryList == find->subscribeQuery.end()) {
+        return;
+    }
+    (void) std::remove_if(
+        queryList->second.begin(), queryList->second.end(), [&queryId](const QuerySyncObject &checkQuery) {
+        return checkQuery.GetIdentify() == queryId;
+    });
+}
+}
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.h b/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.h
new file mode 100644
index 0000000000000000000000000000000000000000..e05d0babfd0b679d6578280a7cbe0a7fe6d34b5b
--- /dev/null
+++ b/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2021 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 SUBSCRIBE_RECORDER_H
+#define SUBSCRIBE_RECORDER_H
+
+#include <map>
+#include <mutex>
+#include "db_types.h"
+#include "query_sync_object.h"
+#include "store_types.h"
+
+namespace DistributedDB {
+class SubscribeRecorder final {
+public:
+    SubscribeRecorder() = default;
+    ~SubscribeRecorder() = default;
+
+    void RecordSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId, const QuerySyncObject &query);
+
+    void RemoveAllSubscribe();
+
+    void RemoveSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId);
+
+    void RemoveSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId, const QuerySyncObject &query);
+
+    void GetSubscribeQuery(const DBInfo &dbInfo,
+        std::map<std::string, std::vector<QuerySyncObject>> &subscribeQuery) const;
+private:
+    void RemoveSubscribeInner(const DBInfo &dbInfo, const DeviceID &deviceId,
+        const std::string &queryId, bool removeByDevice);
+    struct SubscribeEntry {
+        DBInfo dbInfo;
+        std::map<DeviceID, std::vector<QuerySyncObject>> subscribeQuery;
+    };
+    mutable std::mutex subscribeMutex_;
+    std::vector<SubscribeEntry> subscribeCache_;
+};
+}
+#endif // SUBSCRIBE_RECORDER_H
diff --git a/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp b/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp
index 449d8dd85960e36818f64bb3991de01419b1bfc6..182c90f38fe3fab491d41ceb59c291bae5e6edeb 100644
--- a/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp
@@ -102,6 +102,7 @@ int SyncEngine::Initialize(ISyncInterface *syncInterface, std::shared_ptr<Metada
     }
     metadata_ = metadata;
     isActive_ = true;
+    TriggerAddSubscribeAsync();
     LOGI("[SyncEngine] Engine init ok");
     return E_OK;
 }
@@ -814,7 +815,7 @@ void SyncEngine::OfflineHandleByDevice(const std::string &deviceId)
     std::vector<std::string> remoteQueryId;
     subManager_->GetRemoteSubscribeQueryIds(deviceId, remoteQueryId);
     subManager_->ClearRemoteSubscribeQuery(deviceId);
-    static_cast<SingleVerKvDBSyncInterface *>(syncInterface_)->RemoveSubscribe(remoteQueryId);
+    static_cast<SyncGenericInterface *>(syncInterface_)->RemoveSubscribe(remoteQueryId);
     // get context and Inc context if context is not nullprt
     ISyncTaskContext *context = GetSyncTaskContextAndInc(deviceId);
     if (context != nullptr) {
@@ -833,6 +834,9 @@ void SyncEngine::OfflineHandleByDevice(const std::string &deviceId)
     }
     // means device is offline, clear local subscribe
     subManager_->ClearLocalSubscribeQuery(deviceId);
+    DBInfo dbInfo;
+    static_cast<SyncGenericInterface *>(syncInterface_)->GetDBInfo(dbInfo);
+    RuntimeContext::GetInstance()->RemoveSubscribe(dbInfo, deviceId);
     // clear sync task
     if (context != nullptr) {
         context->ClearAllSyncTask();
@@ -1165,4 +1169,67 @@ void SyncEngine::WaitingExecTaskExist()
         LOGD("SyncEngine Close with executing task!");
     }
 }
+
+void SyncEngine::TriggerAddSubscribeAsync()
+{
+    if (syncInterface_ == nullptr) {
+        return;
+    }
+    syncInterface_->IncRefCount();
+    auto storage = syncInterface_;
+    RefObject::IncObjRef(this);
+    int errCode = RuntimeContext::GetInstance()->ScheduleTask([this, storage]() {
+        AddSubscribe(storage);
+        storage->DecRefCount();
+        RefObject::DecObjRef(this);
+    });
+    if (errCode != E_OK) {
+        LOGW("[SyncEngine] TriggerAddSubscribeAsync failed errCode = %d", errCode);
+        syncInterface_->DecRefCount();
+        RefObject::DecObjRef(this);
+    }
+}
+
+void SyncEngine::AddSubscribe(ISyncInterface *syncInterface)
+{
+    if (syncInterface->GetInterfaceType() != ISyncInterface::SYNC_SVD) {
+        return;
+    }
+    auto storage = static_cast<SyncGenericInterface *>(syncInterface);
+    DBInfo dbInfo;
+    storage->GetDBInfo(dbInfo);
+    std::map<std::string, std::vector<QuerySyncObject>> subscribeQuery;
+    RuntimeContext::GetInstance()->GetSubscribeQuery(dbInfo, subscribeQuery);
+    for (const auto &[device, queryList]: subscribeQuery) {
+        for (const auto &query: queryList) {
+            int errCode = storage->AddSubscribe(query.GetIdentify(), query, true);
+            if (errCode != E_OK) {
+                LOGW("[SyncEngine][AddSubscribe] Add trigger failed dev = %d queryId",
+                    STR_MASK(device), STR_MASK(query.GetIdentify()));
+                continue;
+            }
+            errCode = subManager_->ReserveRemoteSubscribeQuery(device, query);
+            if (errCode != E_OK) {
+                if (!subManager_->IsQueryExistSubscribe(query.GetIdentify())) {
+                    (void)storage->RemoveSubscribe(query.GetIdentify());
+                }
+                continue;
+            }
+            subManager_->ActiveRemoteSubscribeQuery(device, query);
+        }
+    }
+}
+
+ISyncTaskContext *SyncEngine::CreateSyncTaskContextIfNeed(const std::string &device, int &errCode)
+{
+    std::lock_guard<std::mutex> lock(contextMapLock_);
+    ISyncTaskContext *context = FindSyncTaskContext(device);
+    if (context == nullptr) {
+        if (!IsKilled()) {
+            context = GetSyncTaskContext(device, errCode);
+        }
+    }
+    RefObject::IncObjRef(context);
+    return context;
+}
 } // namespace DistributedDB
diff --git a/frameworks/libs/distributeddb/syncer/src/sync_engine.h b/frameworks/libs/distributeddb/syncer/src/sync_engine.h
index b791ea4a97e5fd0073f1184e498bb9a68fc07196..93530942fd800259e8716e6a4a39274c81a78eff 100644
--- a/frameworks/libs/distributeddb/syncer/src/sync_engine.h
+++ b/frameworks/libs/distributeddb/syncer/src/sync_engine.h
@@ -205,6 +205,12 @@ private:
 
     void WaitingExecTaskExist();
 
+    void TriggerAddSubscribeAsync();
+
+    void AddSubscribe(ISyncInterface *syncInterface);
+
+    ISyncTaskContext *CreateSyncTaskContextIfNeed(const std::string &device, int &errCode);
+
     ICommunicator *communicator_;
     DeviceManager *deviceManager_;
     std::function<void(const std::string &)> onRemoteDataChanged_;
diff --git a/frameworks/libs/distributeddb/syncer/src/sync_task_context.h b/frameworks/libs/distributeddb/syncer/src/sync_task_context.h
index c9aa9d17b2e55472d502161b48e6a1c8776c44f9..c502504ad841ed8091c7b48280fdb2df68b1769a 100644
--- a/frameworks/libs/distributeddb/syncer/src/sync_task_context.h
+++ b/frameworks/libs/distributeddb/syncer/src/sync_task_context.h
@@ -210,6 +210,7 @@ public:
     void Dump(int fd) override;
 
     void AbortMachineIfNeed(uint32_t syncId) override;
+
 protected:
     const static int KILL_WAIT_SECONDS = INT32_MAX;
 
diff --git a/frameworks/libs/distributeddb/test/BUILD.gn b/frameworks/libs/distributeddb/test/BUILD.gn
index 2dd72ada340182ca6723738c40060622a9a8c181..41a3c9e30aef45f2a416b607c812f33283f1f641 100644
--- a/frameworks/libs/distributeddb/test/BUILD.gn
+++ b/frameworks/libs/distributeddb/test/BUILD.gn
@@ -119,6 +119,7 @@ ohos_source_set("src_file") {
     "../communicator/src/communicator.cpp",
     "../communicator/src/communicator_aggregator.cpp",
     "../communicator/src/communicator_linker.cpp",
+    "../communicator/src/db_status_adapter.cpp",
     "../communicator/src/frame_combiner.cpp",
     "../communicator/src/frame_retainer.cpp",
     "../communicator/src/header_converter.cpp",
@@ -255,6 +256,7 @@ ohos_source_set("src_file") {
     "../syncer/src/single_ver_sync_task_context.cpp",
     "../syncer/src/single_ver_syncer.cpp",
     "../syncer/src/subscribe_manager.cpp",
+    "../syncer/src/subscribe_recorder.cpp",
     "../syncer/src/sync_config.cpp",
     "../syncer/src/sync_engine.cpp",
     "../syncer/src/sync_operation.cpp",
diff --git a/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_common.cpp b/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_common.cpp
index 27d86ff996bfaaae189ec656f8224e246b72c673..211fcb38c90a94fdf4569a0dcaaffa45f14b4518 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_common.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_common.cpp
@@ -42,7 +42,7 @@ bool SetUpEnv(EnvHandle &inEnv, const string &inName)
         return false;
     }
 
-    int errCode = inEnv.commAggrHandle->Initialize(inEnv.adapterHandle);
+    int errCode = inEnv.commAggrHandle->Initialize(inEnv.adapterHandle, nullptr);
     if (errCode != E_OK) {
         LOGI("[UT][Common][SetUp] Init CommunicatorAggregator fail for %s", inName.c_str());
         return false;
diff --git a/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_auto_launch_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_auto_launch_test.cpp
index f3772f70c34052bbfb9b60d83a2c8cfae213fd2f..886956757bacf02d95e64cdd9f13fbef4a50314b 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_auto_launch_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_auto_launch_test.cpp
@@ -65,7 +65,7 @@ namespace {
     class StoreCommunicatorAggregator : public ICommunicatorAggregator {
     public:
         // Return 0 as success. Return negative as error
-        int Initialize(IAdapter *inAdapter) override
+        int Initialize(IAdapter *inAdapter, const std::shared_ptr<DBStatusAdapter> &statusAdapter) override
         {
             return E_OK;
         }
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator_aggregator.cpp b/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator_aggregator.cpp
index 7e40b97c0bd716882010664fa9cc54e11c910ebb..1cd3cb8d148a6a72dd897f6069590028cdbeb311 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator_aggregator.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator_aggregator.cpp
@@ -24,7 +24,8 @@
 #include "runtime_context.h"
 
 namespace DistributedDB {
-int VirtualCommunicatorAggregator::Initialize(IAdapter *inAdapter)
+int VirtualCommunicatorAggregator::Initialize(IAdapter *inAdapter,
+    const std::shared_ptr<DBStatusAdapter> &statusAdapter)
 {
     return E_OK;
 }
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator_aggregator.h b/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator_aggregator.h
index c1848a2cac9aae93f46d01890b30bc1c9742a384..2a5bfc9cc2671fe3103bbed3fb60e7647429ca4a 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator_aggregator.h
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator_aggregator.h
@@ -27,7 +27,7 @@ class ICommunicator;  // Forward Declaration
 class VirtualCommunicatorAggregator : public ICommunicatorAggregator {
 public:
     // Return 0 as success. Return negative as error
-    int Initialize(IAdapter *inAdapter) override;
+    int Initialize(IAdapter *inAdapter, const std::shared_ptr<DBStatusAdapter> &statusAdapter) override;
 
     void Finalize() override;