From 7a19a6f269bf8bcf7869006d8bf7e4035dbbb673 Mon Sep 17 00:00:00 2001
From: zqq <zhangqiquan1@huawei.com>
Date: Tue, 15 Nov 2022 16:14:48 +0800
Subject: [PATCH 01/29] add communication optimization interface

Signed-off-by: zqq <zhangqiquan1@huawei.com>
---
 .../distributeddb/common/include/db_common.h  |   2 +
 .../common/include/runtime_context.h          |   6 +
 .../distributeddb/common/src/db_common.cpp    |   9 +
 .../common/src/runtime_context_impl.cpp       |  35 ++-
 .../common/src/runtime_context_impl.h         |   9 +
 .../include/communicator_aggregator.h         |  10 +-
 .../communicator/include/db_status_adapter.h  |  66 ++++++
 .../include/icommunicator_aggregator.h        |   3 +-
 .../src/communicator_aggregator.cpp           |  76 ++++--
 .../communicator/src/communicator_linker.cpp  |  69 +++++-
 .../communicator/src/communicator_linker.h    |  10 +-
 .../communicator/src/db_status_adapter.cpp    | 224 ++++++++++++++++++
 .../libs/distributeddb/distributeddb.gni      |   1 +
 .../interfaces/include/db_info_handle.h       |  34 +++
 .../interfaces/include/runtime_config.h       |   5 +
 .../interfaces/include/store_types.h          |   9 +
 .../interfaces/src/runtime_config.cpp         |  10 +
 .../storage/include/sync_generic_interface.h  |  10 +-
 frameworks/libs/distributeddb/test/BUILD.gn   |   1 +
 .../distributeddb_communicator_common.cpp     |   2 +-
 ...tributeddb_interfaces_auto_launch_test.cpp |   2 +-
 .../virtual_communicator_aggregator.cpp       |   3 +-
 .../syncer/virtual_communicator_aggregator.h  |   2 +-
 23 files changed, 557 insertions(+), 41 deletions(-)
 create mode 100644 frameworks/libs/distributeddb/communicator/include/db_status_adapter.h
 create mode 100644 frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
 create mode 100644 frameworks/libs/distributeddb/interfaces/include/db_info_handle.h

diff --git a/frameworks/libs/distributeddb/common/include/db_common.h b/frameworks/libs/distributeddb/common/include/db_common.h
index 2cdb848cf2e..8f1951cfb4e 100644
--- a/frameworks/libs/distributeddb/common/include/db_common.h
+++ b/frameworks/libs/distributeddb/common/include/db_common.h
@@ -86,6 +86,8 @@ public:
     static bool CaseInsensitiveCompare(std::string first, std::string second);
 
     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 c7fa00cc924..ed2cf757324 100644
--- a/frameworks/libs/distributeddb/common/include/runtime_context.h
+++ b/frameworks/libs/distributeddb/common/include/runtime_context.h
@@ -23,6 +23,7 @@
 #include "auto_launch.h"
 #include "auto_launch_export.h"
 #include "cloud/icloud_data_translate.h"
+#include "db_info_handle.h"
 #include "icommunicator_aggregator.h"
 #include "iprocess_system_api_adapter.h"
 #include "ithread_pool.h"
@@ -30,6 +31,7 @@
 #include "kvdb_properties.h"
 #include "macro_utils.h"
 #include "notification_chain.h"
+#include "query_sync_object.h"
 #include "types_export.h"
 
 namespace DistributedDB {
@@ -146,6 +148,10 @@ public:
 
     virtual void StopTimeTickMonitorIfNeed() = 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 SetTranslateToDeviceIdCallback(const TranslateToDeviceIdCallback &callback) = 0;
 
     virtual int TranslateDeviceId(const std::string &deviceId,
diff --git a/frameworks/libs/distributeddb/common/src/db_common.cpp b/frameworks/libs/distributeddb/common/src/db_common.cpp
index c60311cbb5f..ac7dcea628a 100644
--- a/frameworks/libs/distributeddb/common/src/db_common.cpp
+++ b/frameworks/libs/distributeddb/common/src/db_common.cpp
@@ -439,4 +439,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 8c249fd702d..675b8c29b07 100644
--- a/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
+++ b/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
@@ -32,7 +32,8 @@ RuntimeContextImpl::RuntimeContextImpl()
       timeTickMonitor_(nullptr),
       systemApiAdapter_(nullptr),
       lockStatusObserver_(nullptr),
-      currentSessionId_(1)
+      currentSessionId_(1),
+      dbStatusAdapter_(nullptr)
 {
 }
 
@@ -59,6 +60,7 @@ RuntimeContextImpl::~RuntimeContextImpl()
     delete lockStatusObserver_;
     lockStatusObserver_ = nullptr;
     userChangeMonitor_ = nullptr;
+    dbStatusAdapter_ = nullptr;
     SetThreadPool(nullptr);
 }
 
@@ -96,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_;
@@ -113,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_);
@@ -758,6 +761,34 @@ void RuntimeContextImpl::StopTimeTickMonitorIfNeed()
     }
 }
 
+void RuntimeContextImpl::SetDBInfoHandle(const std::shared_ptr<DBInfoHandle> &handle)
+{
+    std::shared_ptr<DBStatusAdapter> dbStatusAdapter = GetDBStatusAdapter();
+    if (dbStatusAdapter != nullptr) {
+        dbStatusAdapter->SetDBInfoHandle(handle);
+    }
+}
+
+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::SetTranslateToDeviceIdCallback(const TranslateToDeviceIdCallback &callback)
 {
     std::lock_guard<std::mutex> autoLock(translateToDeviceIdLock_);
diff --git a/frameworks/libs/distributeddb/common/src/runtime_context_impl.h b/frameworks/libs/distributeddb/common/src/runtime_context_impl.h
index 5dfc7187f33..0705af15b9c 100644
--- a/frameworks/libs/distributeddb/common/src/runtime_context_impl.h
+++ b/frameworks/libs/distributeddb/common/src/runtime_context_impl.h
@@ -21,6 +21,7 @@
 #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"
@@ -131,6 +132,10 @@ public:
 
     void StopTimeTickMonitorIfNeed() override;
 
+    void SetDBInfoHandle(const std::shared_ptr<DBInfoHandle> &handle) override;
+
+    void NotifyDBInfos(const DeviceInfos &devInfos, const std::vector<DBInfo> &dbInfos) override;
+
     void SetTranslateToDeviceIdCallback(const TranslateToDeviceIdCallback &callback) override;
 
     int TranslateDeviceId(const std::string &deviceId,
@@ -155,6 +160,7 @@ private:
     int PrepareLoop(IEventLoop *&loop);
     int PrepareTaskPool();
     int AllocTimerId(IEvent *evTimer, TimerId &timerId);
+    std::shared_ptr<DBStatusAdapter> GetDBStatusAdapter();
 
     int ScheduleTaskByThreadPool(const TaskAction &task) const;
 
@@ -221,6 +227,9 @@ private:
     mutable std::shared_mutex permissionConditionLock_;
     PermissionConditionCallback permissionConditionCallback_;
 
+    mutable std::mutex statusAdapterMutex_;
+    std::shared_ptr<DBStatusAdapter> dbStatusAdapter_;
+
     mutable std::mutex translateToDeviceIdLock_;
     TranslateToDeviceIdCallback translateToDeviceIdCallback_;
     std::map<std::string, std::map<std::string, std::string>> deviceIdCache_; // cache <uuid, <appId, newDeviceId>>
diff --git a/frameworks/libs/distributeddb/communicator/include/communicator_aggregator.h b/frameworks/libs/distributeddb/communicator/include/communicator_aggregator.h
index ed30b0d6eb6..c94c66d2eec 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();
+
     void InitSendThread();
 
     void SendOnceData();
@@ -184,6 +190,8 @@ private:
     Finalizer onConnectFinalizer_;
     mutable std::mutex onConnectMutex_;
 
+    std::shared_ptr<DBStatusAdapter> dbStatusAdapter_;
+
     std::atomic<bool> useExclusiveThread_ = false;
     bool sendTaskStart_ = false;
     mutable std::mutex scheduleSendTaskMutex_;
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 00000000000..8d58470f6b9
--- /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 06ae9e7c1e9..70ee63cf8f1 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 0b1efd0abfa..aaa58387acf 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;
     InitSendThread();
+    dbStatusAdapter_ = statusAdapter;
+    RegDBChangeCallback();
     return E_OK;
 ROLL_BACK:
     UnRegCallbackFromAdapter();
@@ -127,6 +129,7 @@ void CommunicatorAggregator::Finalize()
     commLinker_ = nullptr;
     retainer_.Finalize();
     combiner_.Finalize();
+    dbStatusAdapter_ = nullptr;
 }
 
 ICommunicator *CommunicatorAggregator::AllocCommunicator(uint64_t commLabel, int &outErrorNo)
@@ -611,24 +614,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=%.3s, 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=%.3s, 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;
 }
@@ -763,6 +749,7 @@ void CommunicatorAggregator::UnRegCallbackFromAdapter()
     adapterHandle_->RegBytesReceiveCallback(nullptr, nullptr);
     adapterHandle_->RegTargetChangeCallback(nullptr, nullptr);
     adapterHandle_->RegSendableCallback(nullptr, nullptr);
+    dbStatusAdapter_->SetDBStatusChangeCallback(nullptr, nullptr);
 }
 
 void CommunicatorAggregator::GenerateLocalSourceId()
@@ -874,6 +861,55 @@ 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();
+                }
+            });
+    }
+}
 void CommunicatorAggregator::InitSendThread()
 {
     if (RuntimeContext::GetInstance()->GetThreadPool() != nullptr) {
diff --git a/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp b/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp
index ede623f08af..48dd32acb86 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 (const auto &entry : totalOnlineTargets) {
-        int errCode = TriggerLabelExchangeEvent(entry);
-        if (errCode != E_OK) {
-            everFail = true;
-        }
-    }
+    bool everFail = TriggerLabelExchangeEvent();
     return everFail ? -E_INTERNAL_ERROR : E_OK;
 }
 
@@ -283,14 +287,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);
@@ -461,5 +477,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 3d0d701d312..7c6a84ecc7f 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 00000000000..e887addf470
--- /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/distributeddb.gni b/frameworks/libs/distributeddb/distributeddb.gni
index eb9ef3d5509..0480a78c651 100644
--- a/frameworks/libs/distributeddb/distributeddb.gni
+++ b/frameworks/libs/distributeddb/distributeddb.gni
@@ -65,6 +65,7 @@ distributeddb_src = [
   "${distributeddb_path}/communicator/src/communicator.cpp",
   "${distributeddb_path}/communicator/src/communicator_aggregator.cpp",
   "${distributeddb_path}/communicator/src/communicator_linker.cpp",
+  "${distributeddb_path}/communicator/src/db_status_adapter.cpp",
   "${distributeddb_path}/communicator/src/frame_combiner.cpp",
   "${distributeddb_path}/communicator/src/frame_retainer.cpp",
   "${distributeddb_path}/communicator/src/header_converter.cpp",
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 00000000000..be05ec21c78
--- /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/runtime_config.h b/frameworks/libs/distributeddb/interfaces/include/runtime_config.h
index 77c078997f1..f98fe90247b 100644
--- a/frameworks/libs/distributeddb/interfaces/include/runtime_config.h
+++ b/frameworks/libs/distributeddb/interfaces/include/runtime_config.h
@@ -20,6 +20,7 @@
 #include <mutex>
 
 #include "auto_launch_export.h"
+#include "db_info_handle.h"
 #include "cloud/icloud_data_translate.h"
 #include "iprocess_communicator.h"
 #include "iprocess_system_api_adapter.h"
@@ -58,6 +59,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);
+
     DB_API static void SetTranslateToDeviceIdCallback(const TranslateToDeviceIdCallback &callback);
 
     DB_API static void SetAutoLaunchRequestCallback(const AutoLaunchRequestCallback &callback, DBType type);
diff --git a/frameworks/libs/distributeddb/interfaces/include/store_types.h b/frameworks/libs/distributeddb/interfaces/include/store_types.h
index 0e7b9e29a2a..447ad77da2b 100644
--- a/frameworks/libs/distributeddb/interfaces/include/store_types.h
+++ b/frameworks/libs/distributeddb/interfaces/include/store_types.h
@@ -171,6 +171,15 @@ 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;
+};
+
 using UpdateKeyCallback = std::function<void (const Key &originKey, Key &newKey)>;
 } // namespace DistributedDB
 #endif // KV_STORE_TYPE_H
diff --git a/frameworks/libs/distributeddb/interfaces/src/runtime_config.cpp b/frameworks/libs/distributeddb/interfaces/src/runtime_config.cpp
index 3c5a314585c..c70cf2abca2 100644
--- a/frameworks/libs/distributeddb/interfaces/src/runtime_config.cpp
+++ b/frameworks/libs/distributeddb/interfaces/src/runtime_config.cpp
@@ -132,6 +132,16 @@ DBStatus RuntimeConfig::SetPermissionConditionCallback(const PermissionCondition
     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);
+}
+
 void RuntimeConfig::SetTranslateToDeviceIdCallback(const DistributedDB::TranslateToDeviceIdCallback &callback)
 {
     RuntimeContext::GetInstance()->SetTranslateToDeviceIdCallback(callback);
diff --git a/frameworks/libs/distributeddb/storage/include/sync_generic_interface.h b/frameworks/libs/distributeddb/storage/include/sync_generic_interface.h
index 0d01835a232..5e6c941dfc9 100644
--- a/frameworks/libs/distributeddb/storage/include/sync_generic_interface.h
+++ b/frameworks/libs/distributeddb/storage/include/sync_generic_interface.h
@@ -16,8 +16,9 @@
 #define SYNC_GENERIC_INTERFACE_H
 
 #include "isync_interface.h"
-#include "query_object.h"
 #include "single_ver_kv_entry.h"
+#include "store_types.h"
+#include "query_object.h"
 
 namespace DistributedDB {
 class SyncGenericInterface : public ISyncInterface {
@@ -145,6 +146,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, "");
+    }
+
     int IsSupportSubscribe() const override
     {
         return -E_NOT_SUPPORT;
diff --git a/frameworks/libs/distributeddb/test/BUILD.gn b/frameworks/libs/distributeddb/test/BUILD.gn
index 64f994750bb..2e84db4cadf 100644
--- a/frameworks/libs/distributeddb/test/BUILD.gn
+++ b/frameworks/libs/distributeddb/test/BUILD.gn
@@ -127,6 +127,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",
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 c13619ccdc8..cf4ae41640b 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 7a40722bbea..cd3db8aa39e 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 50b46eae47b..20764e07946 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 7cad9d98acb..de75b3133f7 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
@@ -28,7 +28,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;
 
-- 
Gitee


From 00616b8deba182ca79fd60bfa497eb72a3dc9305 Mon Sep 17 00:00:00 2001
From: zqq <zhangqiquan1@huawei.com>
Date: Sat, 19 Nov 2022 16:00:02 +0800
Subject: [PATCH 02/29] re subscribe when reopen db

Signed-off-by: zqq <zhangqiquan1@huawei.com>
---
 .../common/include/runtime_context.h          |  9 ++
 .../common/src/runtime_context_impl.cpp       | 70 +++++++++++++-
 .../common/src/runtime_context_impl.h         | 14 +++
 .../libs/distributeddb/distributeddb.gni      |  1 +
 .../syncer/src/isync_task_context.h           |  1 +
 .../syncer/src/single_ver_data_sync.cpp       |  6 ++
 .../syncer/src/single_ver_sync_task_context.h |  1 +
 .../syncer/src/subscribe_recorder.cpp         | 93 +++++++++++++++++++
 .../syncer/src/subscribe_recorder.h           | 52 +++++++++++
 .../distributeddb/syncer/src/sync_engine.cpp  | 67 +++++++++++++
 .../distributeddb/syncer/src/sync_engine.h    |  6 ++
 .../syncer/src/sync_task_context.h            |  1 +
 frameworks/libs/distributeddb/test/BUILD.gn   |  1 +
 13 files changed, 321 insertions(+), 1 deletion(-)
 create mode 100644 frameworks/libs/distributeddb/syncer/src/subscribe_recorder.cpp
 create mode 100644 frameworks/libs/distributeddb/syncer/src/subscribe_recorder.h

diff --git a/frameworks/libs/distributeddb/common/include/runtime_context.h b/frameworks/libs/distributeddb/common/include/runtime_context.h
index ed2cf757324..77189176414 100644
--- a/frameworks/libs/distributeddb/common/include/runtime_context.h
+++ b/frameworks/libs/distributeddb/common/include/runtime_context.h
@@ -152,6 +152,15 @@ public:
 
     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;
+
     virtual void SetTranslateToDeviceIdCallback(const TranslateToDeviceIdCallback &callback) = 0;
 
     virtual int TranslateDeviceId(const std::string &deviceId,
diff --git a/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp b/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
index 675b8c29b07..1b62a5d916f 100644
--- a/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
+++ b/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
@@ -33,7 +33,8 @@ RuntimeContextImpl::RuntimeContextImpl()
       systemApiAdapter_(nullptr),
       lockStatusObserver_(nullptr),
       currentSessionId_(1),
-      dbStatusAdapter_(nullptr)
+      dbStatusAdapter_(nullptr),
+      subscribeRecorder_(nullptr)
 {
 }
 
@@ -61,6 +62,7 @@ RuntimeContextImpl::~RuntimeContextImpl()
     lockStatusObserver_ = nullptr;
     userChangeMonitor_ = nullptr;
     dbStatusAdapter_ = nullptr;
+    subscribeRecorder_ = nullptr;
     SetThreadPool(nullptr);
 }
 
@@ -767,6 +769,10 @@ void RuntimeContextImpl::SetDBInfoHandle(const std::shared_ptr<DBInfoHandle> &ha
     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)
@@ -789,6 +795,68 @@ std::shared_ptr<DBStatusAdapter> RuntimeContextImpl::GetDBStatusAdapter()
     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_;
+}
+
+
 void RuntimeContextImpl::SetTranslateToDeviceIdCallback(const TranslateToDeviceIdCallback &callback)
 {
     std::lock_guard<std::mutex> autoLock(translateToDeviceIdLock_);
diff --git a/frameworks/libs/distributeddb/common/src/runtime_context_impl.h b/frameworks/libs/distributeddb/common/src/runtime_context_impl.h
index 0705af15b9c..057d4bca40a 100644
--- a/frameworks/libs/distributeddb/common/src/runtime_context_impl.h
+++ b/frameworks/libs/distributeddb/common/src/runtime_context_impl.h
@@ -26,6 +26,7 @@
 #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"
@@ -136,6 +137,15 @@ public:
 
     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;
+
     void SetTranslateToDeviceIdCallback(const TranslateToDeviceIdCallback &callback) override;
 
     int TranslateDeviceId(const std::string &deviceId,
@@ -161,6 +171,7 @@ private:
     int PrepareTaskPool();
     int AllocTimerId(IEvent *evTimer, TimerId &timerId);
     std::shared_ptr<DBStatusAdapter> GetDBStatusAdapter();
+    std::shared_ptr<SubscribeRecorder> GetSubscribeRecorder();
 
     int ScheduleTaskByThreadPool(const TaskAction &task) const;
 
@@ -230,6 +241,9 @@ private:
     mutable std::mutex statusAdapterMutex_;
     std::shared_ptr<DBStatusAdapter> dbStatusAdapter_;
 
+    mutable std::mutex subscribeRecorderMutex_;
+    std::shared_ptr<SubscribeRecorder> subscribeRecorder_;
+
     mutable std::mutex translateToDeviceIdLock_;
     TranslateToDeviceIdCallback translateToDeviceIdCallback_;
     std::map<std::string, std::map<std::string, std::string>> deviceIdCache_; // cache <uuid, <appId, newDeviceId>>
diff --git a/frameworks/libs/distributeddb/distributeddb.gni b/frameworks/libs/distributeddb/distributeddb.gni
index 0480a78c651..76147bf167c 100644
--- a/frameworks/libs/distributeddb/distributeddb.gni
+++ b/frameworks/libs/distributeddb/distributeddb.gni
@@ -217,6 +217,7 @@ distributeddb_src = [
   "${distributeddb_path}/syncer/src/single_ver_sync_task_context.cpp",
   "${distributeddb_path}/syncer/src/single_ver_syncer.cpp",
   "${distributeddb_path}/syncer/src/subscribe_manager.cpp",
+  "${distributeddb_path}/syncer/src/subscribe_recorder.cpp",
   "${distributeddb_path}/syncer/src/sync_config.cpp",
   "${distributeddb_path}/syncer/src/sync_engine.cpp",
   "${distributeddb_path}/syncer/src/sync_operation.cpp",
diff --git a/frameworks/libs/distributeddb/syncer/src/isync_task_context.h b/frameworks/libs/distributeddb/syncer/src/isync_task_context.h
index e489afd5495..3b4bb281629 100644
--- a/frameworks/libs/distributeddb/syncer/src/isync_task_context.h
+++ b/frameworks/libs/distributeddb/syncer/src/isync_task_context.h
@@ -182,6 +182,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 0e5371ffa20..f0a7e4de47f 100644
--- a/frameworks/libs/distributeddb/syncer/src/single_ver_data_sync.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/single_ver_data_sync.cpp
@@ -2017,6 +2017,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;
 }
 
@@ -2051,6 +2054,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 3e64ecdcad5..16a10041870 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
@@ -136,6 +136,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_recorder.cpp b/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.cpp
new file mode 100644
index 00000000000..58ce9c8943d
--- /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 00000000000..e05d0babfd0
--- /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 1c1b651ded4..fc2e4e45a0c 100644
--- a/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp
@@ -103,6 +103,7 @@ int SyncEngine::Initialize(ISyncInterface *syncInterface, const std::shared_ptr<
     }
     metadata_ = metadata;
     isActive_ = true;
+    TriggerAddSubscribeAsync();
     LOGI("[SyncEngine] Engine init ok");
     return E_OK;
 }
@@ -853,6 +854,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();
@@ -1199,4 +1203,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 9f2d158046e..5bf21068164 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 98301561470..f086a4a4ed8 100644
--- a/frameworks/libs/distributeddb/syncer/src/sync_task_context.h
+++ b/frameworks/libs/distributeddb/syncer/src/sync_task_context.h
@@ -212,6 +212,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 2e84db4cadf..48c1fc597ab 100644
--- a/frameworks/libs/distributeddb/test/BUILD.gn
+++ b/frameworks/libs/distributeddb/test/BUILD.gn
@@ -279,6 +279,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",
-- 
Gitee


From 895cc959e32860e12371cf686246575455789690 Mon Sep 17 00:00:00 2001
From: zqq <zhangqiquan1@huawei.com>
Date: Mon, 21 Nov 2022 14:10:28 +0800
Subject: [PATCH 03/29] fix codecheck

Signed-off-by: zqq <zhangqiquan1@huawei.com>
---
 .../src/communicator_aggregator.cpp           |  2 +-
 .../distributeddb/syncer/src/sync_engine.cpp  | 34 +++++++++++--------
 .../distributeddb/syncer/src/sync_engine.h    |  2 ++
 3 files changed, 23 insertions(+), 15 deletions(-)

diff --git a/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp b/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp
index aaa58387acf..b27b1dcdc8a 100644
--- a/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp
@@ -903,7 +903,7 @@ void CommunicatorAggregator::RegDBChangeCallback()
             [this](const std::string &devInfo, const std::vector<DBInfo> &dbInfos) {
                 OnRemoteDBStatusChange(devInfo, dbInfos);
             },
-            [this](){
+            [this]() {
                 if (commLinker_ != nullptr) {
                     (void)commLinker_->TriggerLabelExchangeEvent();
                 }
diff --git a/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp b/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp
index fc2e4e45a0c..8ec082f337d 100644
--- a/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp
@@ -1236,20 +1236,7 @@ void SyncEngine::AddSubscribe(ISyncInterface *syncInterface)
     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);
+            AddQuerySubscribe(storage, device, query);
         }
     }
 }
@@ -1266,4 +1253,23 @@ ISyncTaskContext *SyncEngine::CreateSyncTaskContextIfNeed(const std::string &dev
     RefObject::IncObjRef(context);
     return context;
 }
+
+void SyncEngine::AddQuerySubscribe(SyncGenericInterface *storage, const std::string &device,
+    const QuerySyncObject &query)
+{
+    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()));
+        return;
+    }
+    errCode = subManager_->ReserveRemoteSubscribeQuery(device, query);
+    if (errCode != E_OK) {
+        if (!subManager_->IsQueryExistSubscribe(query.GetIdentify())) {
+            (void)storage->RemoveSubscribe(query.GetIdentify());
+        }
+        return;
+    }
+    subManager_->ActiveRemoteSubscribeQuery(device, query);
+}
 } // namespace DistributedDB
diff --git a/frameworks/libs/distributeddb/syncer/src/sync_engine.h b/frameworks/libs/distributeddb/syncer/src/sync_engine.h
index 5bf21068164..166292ea11a 100644
--- a/frameworks/libs/distributeddb/syncer/src/sync_engine.h
+++ b/frameworks/libs/distributeddb/syncer/src/sync_engine.h
@@ -211,6 +211,8 @@ private:
 
     ISyncTaskContext *CreateSyncTaskContextIfNeed(const std::string &device, int &errCode);
 
+    void AddQuerySubscribe(SyncGenericInterface *storage, const std::string &device, const QuerySyncObject &query);
+
     ICommunicator *communicator_;
     DeviceManager *deviceManager_;
     std::function<void(const std::string &)> onRemoteDataChanged_;
-- 
Gitee


From de180ad2968cdbb7a6a7ac28e8f0ebb8518d4917 Mon Sep 17 00:00:00 2001
From: zqq <zhangqiquan1@huawei.com>
Date: Mon, 21 Nov 2022 14:23:20 +0800
Subject: [PATCH 04/29] fix issue

Signed-off-by: zqq <zhangqiquan1@huawei.com>
---
 .../distributeddb/common/include/runtime_context.h    |  3 ++-
 .../libs/distributeddb/common/src/db_common.cpp       |  3 +--
 .../distributeddb/common/src/runtime_context_impl.cpp |  3 ++-
 .../distributeddb/common/src/runtime_context_impl.h   |  2 +-
 .../communicator/src/communicator_aggregator.cpp      |  4 +++-
 .../communicator/src/communicator_linker.cpp          | 11 ++---------
 .../communicator/src/db_status_adapter.cpp            |  2 +-
 .../distributeddb/syncer/src/single_ver_data_sync.cpp |  2 +-
 8 files changed, 13 insertions(+), 17 deletions(-)

diff --git a/frameworks/libs/distributeddb/common/include/runtime_context.h b/frameworks/libs/distributeddb/common/include/runtime_context.h
index 77189176414..bdc66b11a0e 100644
--- a/frameworks/libs/distributeddb/common/include/runtime_context.h
+++ b/frameworks/libs/distributeddb/common/include/runtime_context.h
@@ -152,7 +152,8 @@ public:
 
     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 RecordRemoteSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId,
+        const QuerySyncObject &query) = 0;
 
     virtual void RemoveSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId) = 0;
 
diff --git a/frameworks/libs/distributeddb/common/src/db_common.cpp b/frameworks/libs/distributeddb/common/src/db_common.cpp
index ac7dcea628a..e20775a3331 100644
--- a/frameworks/libs/distributeddb/common/src/db_common.cpp
+++ b/frameworks/libs/distributeddb/common/src/db_common.cpp
@@ -444,8 +444,7 @@ 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);
     }
+    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 1b62a5d916f..1c9eca65d7f 100644
--- a/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
+++ b/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
@@ -795,7 +795,8 @@ std::shared_ptr<DBStatusAdapter> RuntimeContextImpl::GetDBStatusAdapter()
     return dbStatusAdapter_;
 }
 
-void RuntimeContextImpl::RecordSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId, const QuerySyncObject &query)
+void RuntimeContextImpl::RecordRemoteSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId,
+    const QuerySyncObject &query)
 {
     std::shared_ptr<DBStatusAdapter> dbStatusAdapter = GetDBStatusAdapter();
     if (dbStatusAdapter != nullptr && !dbStatusAdapter->IsSupport(deviceId)) {
diff --git a/frameworks/libs/distributeddb/common/src/runtime_context_impl.h b/frameworks/libs/distributeddb/common/src/runtime_context_impl.h
index 057d4bca40a..90422c0f894 100644
--- a/frameworks/libs/distributeddb/common/src/runtime_context_impl.h
+++ b/frameworks/libs/distributeddb/common/src/runtime_context_impl.h
@@ -137,7 +137,7 @@ public:
 
     void NotifyDBInfos(const DeviceInfos &devInfos, const std::vector<DBInfo> &dbInfos) override;
 
-    void RecordSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId, const QuerySyncObject &query) override;
+    void RecordRemoteSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId, const QuerySyncObject &query) override;
 
     void RemoveSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId) override;
 
diff --git a/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp b/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp
index b27b1dcdc8a..a4da3ef7dfe 100644
--- a/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp
@@ -749,7 +749,9 @@ void CommunicatorAggregator::UnRegCallbackFromAdapter()
     adapterHandle_->RegBytesReceiveCallback(nullptr, nullptr);
     adapterHandle_->RegTargetChangeCallback(nullptr, nullptr);
     adapterHandle_->RegSendableCallback(nullptr, nullptr);
-    dbStatusAdapter_->SetDBStatusChangeCallback(nullptr, nullptr);
+    if (dbStatusAdapter_ != nullptr) {
+        dbStatusAdapter_->SetDBStatusChangeCallback(nullptr, nullptr);
+    }
 }
 
 void CommunicatorAggregator::GenerateLocalSourceId()
diff --git a/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp b/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp
index 48dd32acb86..06a1690eeb7 100644
--- a/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp
@@ -129,13 +129,7 @@ int CommunicatorLinker::DecreaseLocalLabel(const LabelType &inLabel)
         localOnlineLabels_.erase(inLabel);
         totalOnlineTargets = remoteOnlineTarget_;
     }
-    bool everFail = false;
-    for (const auto &entry : totalOnlineTargets) {
-        int errCode = TriggerLabelExchangeEvent(entry);
-        if (errCode != E_OK) {
-            everFail = true;
-        }
-    }
+    bool everFail = TriggerLabelExchangeEvent();
     return everFail ? -E_INTERNAL_ERROR : E_OK;
 }
 
@@ -501,8 +495,7 @@ bool CommunicatorLinker::TriggerLabelExchangeEvent()
         if (statusAdapter_ != nullptr && statusAdapter_->ExistDBInfoHandle()) {
             continue;
         }
-        int errCode = TriggerLabelExchangeEvent(entry);
-        if (errCode != E_OK) {
+        if (TriggerLabelExchangeEvent(entry) != E_OK) {
             everFail = true;
         }
     }
diff --git a/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
index e887addf470..94c6f662345 100644
--- a/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
@@ -16,9 +16,9 @@
 
 #include "db_common.h"
 #include "db_errno.h"
+#include "log_print.h"
 #include "param_check_utils.h"
 #include "runtime_context.h"
-#include "log_print.h"
 
 namespace DistributedDB {
 DBStatusAdapter::DBStatusAdapter()
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 f0a7e4de47f..37c9eedf549 100644
--- a/frameworks/libs/distributeddb/syncer/src/single_ver_data_sync.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/single_ver_data_sync.cpp
@@ -2019,7 +2019,7 @@ int SingleVerDataSync::SubscribeRequestRecv(SingleVerSyncTaskContext *context, c
     subscribeManager->ActiveRemoteSubscribeQuery(context->GetDeviceId(), packet->GetQuery());
     DBInfo dbInfo;
     storage_->GetDBInfo(dbInfo);
-    RuntimeContext::GetInstance()->RecordSubscribe(dbInfo, context->GetDeviceId(), packet->GetQuery());
+    RuntimeContext::GetInstance()->RecordRemoteSubscribe(dbInfo, context->GetDeviceId(), packet->GetQuery());
     return errCode;
 }
 
-- 
Gitee


From c1ff3d7a75c6cfbefa078e12429a53193a0827c4 Mon Sep 17 00:00:00 2001
From: zqq <zhangqiquan1@huawei.com>
Date: Mon, 21 Nov 2022 16:12:01 +0800
Subject: [PATCH 05/29] fix issue

Signed-off-by: zqq <zhangqiquan1@huawei.com>
---
 .../distributeddb/communicator/include/db_status_adapter.h  | 6 +++---
 .../communicator/src/communicator_aggregator.cpp            | 1 +
 .../distributeddb/communicator/src/communicator_linker.cpp  | 3 +--
 .../distributeddb/communicator/src/db_status_adapter.cpp    | 4 ++--
 .../libs/distributeddb/interfaces/include/db_info_handle.h  | 3 +--
 5 files changed, 8 insertions(+), 9 deletions(-)

diff --git a/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h b/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h
index 8d58470f6b9..cb0d3cdb0e7 100644
--- a/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h
+++ b/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h
@@ -32,7 +32,7 @@ public:
     void SetDBInfoHandle(const std::shared_ptr<DBInfoHandle> &dbInfoHandle);
     bool ExistDBInfoHandle() const;
     bool IsSupport(const std::string &devInfo);
-    int GetDBInfos(std::vector<DBInfo> &dbInfos) const;
+    int GetLocalDBInfos(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);
@@ -57,10 +57,10 @@ private:
     std::vector<DBInfo> localDBInfos_;
 
     mutable std::mutex remoteInfoMutex_;
-    std::map<std::string, std::vector<DBInfo>> remoteDBInfos_;
+    std::map<std::string, std::vector<DBInfo>> remoteDBInfos_; // key: device uuid, value: all db which has notified
 
     mutable std::mutex supportMutex_;
-    std::map<std::string, bool> remoteSupportInfo_;
+    std::map<std::string, bool> remoteSupportInfo_; // key: device uuid, value: is support notified by user
 };
 }
 #endif // DB_STATUS_ADAPTER_H
diff --git a/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp b/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp
index a4da3ef7dfe..0502462c684 100644
--- a/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp
@@ -885,6 +885,7 @@ void CommunicatorAggregator::NotifyConnectChange(const std::string &srcTarget,
         for (const auto &entry : changedLabels) {
             LOGW("[CommAggr] REMEMBER: label=%s, inOnline=%d.", VEC_TO_STR(entry.first), entry.second);
         }
+        return;
     }
     // Do target change notify
     std::lock_guard<std::mutex> commMapLockGuard(commMapMutex_);
diff --git a/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp b/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp
index 06a1690eeb7..7192e684769 100644
--- a/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp
@@ -290,7 +290,7 @@ int CommunicatorLinker::TriggerLabelExchangeEvent(const std::string &toTarget)
     std::set<LabelType> onlineLabels;
     std::vector<DBInfo> dbInfos;
     if (statusAdapter_ != nullptr && statusAdapter_->ExistDBInfoHandle() &&
-        statusAdapter_->GetDBInfos(dbInfos) == E_OK) {
+            statusAdapter_->GetLocalDBInfos(dbInfos) == E_OK) {
         for (const auto &dbInfo: dbInfos) {
             std::string label = DBCommon::GenerateHashLabel(dbInfo);
             LabelType labelType(label.begin(), label.end());
@@ -300,7 +300,6 @@ int CommunicatorLinker::TriggerLabelExchangeEvent(const std::string &toTarget)
         std::lock_guard<std::mutex> entireInfoLockGuard(entireInfoMutex_);
         onlineLabels = localOnlineLabels_;
     }
-
     // Build LabelExchange Frame
     int error = E_OK;
     SerialBuffer *buffer = ProtocolProto::BuildLabelExchange(localDistinctValue_, sequenceId, onlineLabels, error);
diff --git a/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
index 94c6f662345..d66ca262111 100644
--- a/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
@@ -59,11 +59,11 @@ bool DBStatusAdapter::IsSupport(const std::string &devInfo)
     return res;
 }
 
-int DBStatusAdapter::GetDBInfos(std::vector<DBInfo> &dbInfos) const
+int DBStatusAdapter::GetLocalDBInfos(std::vector<DBInfo> &dbInfos) const
 {
     std::shared_ptr<DBInfoHandle> dbInfoHandle = GetDBInfoHandle();
     if (dbInfoHandle == nullptr) {
-        LOGD("[DBStatusAdapter][GetDBInfos] handle not set");
+        LOGD("[DBStatusAdapter][GetLocalDBInfos] handle not set");
         return -E_NOT_SUPPORT;
     }
     std::lock_guard<std::mutex> autoLock(localInfoMutex_);
diff --git a/frameworks/libs/distributeddb/interfaces/include/db_info_handle.h b/frameworks/libs/distributeddb/interfaces/include/db_info_handle.h
index be05ec21c78..1601656ba95 100644
--- a/frameworks/libs/distributeddb/interfaces/include/db_info_handle.h
+++ b/frameworks/libs/distributeddb/interfaces/include/db_info_handle.h
@@ -26,8 +26,7 @@ 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.
+    // return true if you can notify with RuntimeConfig::NotifyDBInfo
     virtual bool IsSupport(const DeviceInfos &devInfo) = 0;
 };
 }
-- 
Gitee


From 0b5e292524f76ec77f167904a4c246c21ff173b1 Mon Sep 17 00:00:00 2001
From: zqq <zhangqiquan1@huawei.com>
Date: Mon, 21 Nov 2022 17:02:41 +0800
Subject: [PATCH 06/29] bugfix and fix issue

Signed-off-by: zqq <zhangqiquan1@huawei.com>
---
 .../communicator/include/db_status_adapter.h  |  2 +-
 .../src/communicator_aggregator.cpp           |  2 +-
 .../communicator/src/communicator_linker.cpp  |  8 ++---
 .../communicator/src/db_status_adapter.cpp    | 23 ++++++++-------
 .../syncer/src/isync_task_context.h           |  1 -
 .../syncer/src/single_ver_sync_task_context.h |  1 -
 .../distributeddb/syncer/src/sync_engine.cpp  | 29 ++++++++++---------
 .../distributeddb/syncer/src/sync_engine.h    |  3 +-
 8 files changed, 35 insertions(+), 34 deletions(-)

diff --git a/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h b/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h
index cb0d3cdb0e7..8751600944d 100644
--- a/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h
+++ b/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h
@@ -38,7 +38,7 @@ public:
     void TargetOffline(const std::string &device);
 private:
     std::shared_ptr<DBInfoHandle> GetDBInfoHandle() const;
-    bool LoadIntoCache(const DeviceInfos &devInfos, const std::vector<DBInfo> &dbInfos,
+    void LoadIntoCache(bool isLocal, const DeviceInfos &devInfos, const std::vector<DBInfo> &dbInfos,
         std::vector<DBInfo> &changeDbInfos);
     void ClearAllCache();
 
diff --git a/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp b/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp
index 0502462c684..b9c3671b0a8 100644
--- a/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp
@@ -880,7 +880,7 @@ void CommunicatorAggregator::OnRemoteDBStatusChange(const std::string &devInfo,
 void CommunicatorAggregator::NotifyConnectChange(const std::string &srcTarget,
     const std::map<LabelType, bool> &changedLabels)
 {
-    if (!commLinker_->IsRemoteTargetOnline(srcTarget)) {
+    if (commLinker_ != nullptr && !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);
diff --git a/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp b/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp
index 7192e684769..429f365a250 100644
--- a/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp
@@ -115,22 +115,18 @@ int CommunicatorLinker::IncreaseLocalLabel(const LabelType &inLabel, std::set<st
             }
         }
     }
-    bool everFail = TriggerLabelExchangeEvent();
-    return everFail ? -E_INTERNAL_ERROR : E_OK;
+    return TriggerLabelExchangeEvent() ? -E_INTERNAL_ERROR : E_OK;
 }
 
 // Del local label. Create async task to send out label_exchange and waiting for label_exchange_ack.
 // If waiting timeout, pass the send&wait task to overrall timing retry task.
 int CommunicatorLinker::DecreaseLocalLabel(const LabelType &inLabel)
 {
-    std::set<std::string> totalOnlineTargets;
     {
         std::lock_guard<std::mutex> entireInfoLockGuard(entireInfoMutex_);
         localOnlineLabels_.erase(inLabel);
-        totalOnlineTargets = remoteOnlineTarget_;
     }
-    bool everFail = TriggerLabelExchangeEvent();
-    return everFail ? -E_INTERNAL_ERROR : E_OK;
+    return TriggerLabelExchangeEvent() ? -E_INTERNAL_ERROR : E_OK;
 }
 
 // Compare the latest labels with previous Label, find out label changes.
diff --git a/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
index d66ca262111..faa7a889c2e 100644
--- a/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
@@ -83,13 +83,16 @@ void DBStatusAdapter::SetDBStatusChangeCallback(const RemoteDBChangeCallback &re
         remoteCallback_ = remote;
         localCallback_ = local;
     }
+    if (remote == nullptr || local == nullptr) {
+        return;
+    }
     // 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();
+        triggerNow = !remoteDBInfos.empty();
     }
     bool triggerLocal = false;
     {
@@ -121,11 +124,12 @@ void DBStatusAdapter::NotifyDBInfos(const DeviceInfos &devInfos, const std::vect
             LOGW("[DBStatusAdapter][NotifyDBInfos] no support dev %s", STR_MASK(devInfos.identifier));
         }
         std::vector<DBInfo> changeDbInfos;
-        bool isRemote = LoadIntoCache(devInfos, dbInfos, changeDbInfos);
+        bool isLocal = IsLocalDeviceId(devInfos.identifier);
+        LoadIntoCache(isLocal, devInfos, dbInfos, changeDbInfos);
         std::lock_guard<std::mutex> autoLock(callbackMutex_);
-        if (isRemote && remoteCallback_ != nullptr) {
+        if (!isLocal && remoteCallback_ != nullptr) {
             remoteCallback_(devInfos.identifier, changeDbInfos);
-        } else if (!isRemote && localCallback_ != nullptr && !changeDbInfos.empty()) {
+        } else if (isLocal && localCallback_ != nullptr && !changeDbInfos.empty()) {
             localCallback_();
         }
     });
@@ -154,20 +158,19 @@ std::shared_ptr<DBInfoHandle> DBStatusAdapter::GetDBInfoHandle() const
     return dbInfoHandle_;
 }
 
-bool DBStatusAdapter::LoadIntoCache(const DeviceInfos &devInfos, const std::vector<DBInfo> &dbInfos,
+void DBStatusAdapter::LoadIntoCache(bool isLocal, const DeviceInfos &devInfos, const std::vector<DBInfo> &dbInfos,
     std::vector<DBInfo> &changeDbInfos)
 {
-    if (IsLocalDeviceId(devInfos.identifier)) {
+    if (isLocal) {
         std::lock_guard<std::mutex> autoLock(localInfoMutex_);
         MergeDBInfos(dbInfos, localDBInfos_, changeDbInfos);
-        return false;
+        return;
     }
     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()
@@ -190,8 +193,8 @@ void DBStatusAdapter::MergeDBInfos(const std::vector<DBInfo> &srcDbInfos, std::v
             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;
+            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);
diff --git a/frameworks/libs/distributeddb/syncer/src/isync_task_context.h b/frameworks/libs/distributeddb/syncer/src/isync_task_context.h
index 3b4bb281629..e489afd5495 100644
--- a/frameworks/libs/distributeddb/syncer/src/isync_task_context.h
+++ b/frameworks/libs/distributeddb/syncer/src/isync_task_context.h
@@ -182,7 +182,6 @@ 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_sync_task_context.h b/frameworks/libs/distributeddb/syncer/src/single_ver_sync_task_context.h
index 16a10041870..3e64ecdcad5 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
@@ -136,7 +136,6 @@ 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/sync_engine.cpp b/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp
index 8ec082f337d..2d2b9d095d8 100644
--- a/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp
@@ -1209,11 +1209,21 @@ void SyncEngine::TriggerAddSubscribeAsync()
     if (syncInterface_ == nullptr) {
         return;
     }
-    syncInterface_->IncRefCount();
-    auto storage = syncInterface_;
+    if (syncInterface_->GetInterfaceType() != ISyncInterface::SYNC_SVD) {
+        return;
+    }
+    DBInfo dbInfo;
+    auto storage = static_cast<SyncGenericInterface *>(syncInterface_);
+    storage->GetDBInfo(dbInfo);
+    std::map<std::string, std::vector<QuerySyncObject>> subscribeQuery;
+    RuntimeContext::GetInstance()->GetSubscribeQuery(dbInfo, subscribeQuery);
+    if (subscribeQuery.empty()) {
+        return;
+    }
+    storage->IncRefCount();
     RefObject::IncObjRef(this);
-    int errCode = RuntimeContext::GetInstance()->ScheduleTask([this, storage]() {
-        AddSubscribe(storage);
+    int errCode = RuntimeContext::GetInstance()->ScheduleTask([this, storage, subscribeQuery]() {
+        AddSubscribe(storage, subscribeQuery);
         storage->DecRefCount();
         RefObject::DecObjRef(this);
     });
@@ -1224,16 +1234,9 @@ void SyncEngine::TriggerAddSubscribeAsync()
     }
 }
 
-void SyncEngine::AddSubscribe(ISyncInterface *syncInterface)
+void SyncEngine::AddSubscribe(SyncGenericInterface *storage,
+    const std::map<std::string, std::vector<QuerySyncObject>> &subscribeQuery)
 {
-    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) {
             AddQuerySubscribe(storage, device, query);
diff --git a/frameworks/libs/distributeddb/syncer/src/sync_engine.h b/frameworks/libs/distributeddb/syncer/src/sync_engine.h
index 166292ea11a..9eeb9377d16 100644
--- a/frameworks/libs/distributeddb/syncer/src/sync_engine.h
+++ b/frameworks/libs/distributeddb/syncer/src/sync_engine.h
@@ -207,7 +207,8 @@ private:
 
     void TriggerAddSubscribeAsync();
 
-    void AddSubscribe(ISyncInterface *syncInterface);
+    void AddSubscribe(SyncGenericInterface *storage,
+        const std::map<std::string, std::vector<QuerySyncObject>> &subscribeQuery);
 
     ISyncTaskContext *CreateSyncTaskContextIfNeed(const std::string &device, int &errCode);
 
-- 
Gitee


From 22fcb12a0fc9e81f0ec51ab02d4c4d9667b82b9d Mon Sep 17 00:00:00 2001
From: zqq <zhangqiquan1@huawei.com>
Date: Mon, 21 Nov 2022 19:00:55 +0800
Subject: [PATCH 07/29] fixed issue

Signed-off-by: zqq <zhangqiquan1@huawei.com>
---
 .../src/communicator_aggregator.cpp             |  2 +-
 .../communicator/src/communicator_linker.cpp    |  4 ++--
 .../communicator/src/communicator_linker.h      |  2 +-
 .../communicator/src/db_status_adapter.cpp      |  7 ++++---
 .../syncer/src/subscribe_recorder.cpp           |  2 +-
 .../distributeddb/syncer/src/sync_engine.cpp    | 17 ++---------------
 .../libs/distributeddb/syncer/src/sync_engine.h |  2 --
 7 files changed, 11 insertions(+), 25 deletions(-)

diff --git a/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp b/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp
index b9c3671b0a8..e8e09bce718 100644
--- a/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp
@@ -908,7 +908,7 @@ void CommunicatorAggregator::RegDBChangeCallback()
             },
             [this]() {
                 if (commLinker_ != nullptr) {
-                    (void)commLinker_->TriggerLabelExchangeEvent();
+                    (void)commLinker_->TriggerLabelExchangeEvent(false);
                 }
             });
     }
diff --git a/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp b/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp
index 429f365a250..a3efae0bc5d 100644
--- a/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp
@@ -478,7 +478,7 @@ void CommunicatorLinker::UpdateOnlineLabels(const std::string &device, const std
     }
 }
 
-bool CommunicatorLinker::TriggerLabelExchangeEvent()
+bool CommunicatorLinker::TriggerLabelExchangeEvent(bool checkAdapter)
 {
     bool everFail = false;
     std::set<std::string> totalOnlineTargets;
@@ -487,7 +487,7 @@ bool CommunicatorLinker::TriggerLabelExchangeEvent()
         totalOnlineTargets = remoteOnlineTarget_;
     }
     for (auto &entry : totalOnlineTargets) {
-        if (statusAdapter_ != nullptr && statusAdapter_->ExistDBInfoHandle()) {
+        if (checkAdapter && statusAdapter_ != nullptr && statusAdapter_->ExistDBInfoHandle()) {
             continue;
         }
         if (TriggerLabelExchangeEvent(entry) != E_OK) {
diff --git a/frameworks/libs/distributeddb/communicator/src/communicator_linker.h b/frameworks/libs/distributeddb/communicator/src/communicator_linker.h
index 7c6a84ecc7f..10733a16cce 100644
--- a/frameworks/libs/distributeddb/communicator/src/communicator_linker.h
+++ b/frameworks/libs/distributeddb/communicator/src/communicator_linker.h
@@ -76,7 +76,7 @@ public:
 
     void UpdateOnlineLabels(const std::string &device, const std::map<LabelType, bool> &labels);
 
-    bool TriggerLabelExchangeEvent();
+    bool TriggerLabelExchangeEvent(bool checkAdapter = true);
 private:
     DECLARE_OBJECT_TAG(CommunicatorLinker);
 
diff --git a/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
index faa7a889c2e..b05336a27b2 100644
--- a/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
@@ -37,7 +37,7 @@ void DBStatusAdapter::SetDBInfoHandle(const std::shared_ptr<DBInfoHandle> &dbInf
 bool DBStatusAdapter::ExistDBInfoHandle() const
 {
     std::lock_guard<std::mutex> autoLock(handleMutex_);
-    return dbInfoHandle_ == nullptr;
+    return dbInfoHandle_ != nullptr;
 }
 
 bool DBStatusAdapter::IsSupport(const std::string &devInfo)
@@ -120,11 +120,12 @@ void DBStatusAdapter::SetDBStatusChangeCallback(const RemoteDBChangeCallback &re
 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)) {
+        bool isLocal = IsLocalDeviceId(devInfos.identifier);
+        if (!isLocal && !IsSupport(devInfos.identifier)) {
             LOGW("[DBStatusAdapter][NotifyDBInfos] no support dev %s", STR_MASK(devInfos.identifier));
+            return;
         }
         std::vector<DBInfo> changeDbInfos;
-        bool isLocal = IsLocalDeviceId(devInfos.identifier);
         LoadIntoCache(isLocal, devInfos, dbInfos, changeDbInfos);
         std::lock_guard<std::mutex> autoLock(callbackMutex_);
         if (!isLocal && remoteCallback_ != nullptr) {
diff --git a/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.cpp b/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.cpp
index 58ce9c8943d..0f05ddb7fc6 100644
--- a/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * 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
diff --git a/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp b/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp
index 2d2b9d095d8..bf8983f5c5f 100644
--- a/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp
@@ -1244,26 +1244,13 @@ void SyncEngine::AddSubscribe(SyncGenericInterface *storage,
     }
 }
 
-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;
-}
-
 void SyncEngine::AddQuerySubscribe(SyncGenericInterface *storage, const std::string &device,
     const QuerySyncObject &query)
 {
     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()));
+        LOGW("[SyncEngine][AddSubscribe] Add trigger failed dev = %s queryId = %s",
+            STR_MASK(device), STR_MASK(query.GetIdentify()));
         return;
     }
     errCode = subManager_->ReserveRemoteSubscribeQuery(device, query);
diff --git a/frameworks/libs/distributeddb/syncer/src/sync_engine.h b/frameworks/libs/distributeddb/syncer/src/sync_engine.h
index 9eeb9377d16..0abf42c9141 100644
--- a/frameworks/libs/distributeddb/syncer/src/sync_engine.h
+++ b/frameworks/libs/distributeddb/syncer/src/sync_engine.h
@@ -210,8 +210,6 @@ private:
     void AddSubscribe(SyncGenericInterface *storage,
         const std::map<std::string, std::vector<QuerySyncObject>> &subscribeQuery);
 
-    ISyncTaskContext *CreateSyncTaskContextIfNeed(const std::string &device, int &errCode);
-
     void AddQuerySubscribe(SyncGenericInterface *storage, const std::string &device, const QuerySyncObject &query);
 
     ICommunicator *communicator_;
-- 
Gitee


From fd78e3451450143958df9d09e2687c1920582a55 Mon Sep 17 00:00:00 2001
From: zqq <zhangqiquan1@huawei.com>
Date: Mon, 21 Nov 2022 20:58:06 +0800
Subject: [PATCH 08/29] add ut

Signed-off-by: zqq <zhangqiquan1@huawei.com>
---
 .../common/distributeddb_tools_unit_test.cpp  |  15 +
 .../common/distributeddb_tools_unit_test.h    |  13 +
 .../distributeddb_communicator_common.cpp     |   9 +-
 .../distributeddb_communicator_common.h       |   8 +-
 .../distributeddb_communicator_test.cpp       | 289 ++++++++++++++++++
 5 files changed, 329 insertions(+), 5 deletions(-)

diff --git a/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.cpp
index 6ab5678c199..f903916f8b0 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.cpp
@@ -1189,4 +1189,19 @@ END:
     SQLiteUtils::ResetStatement(stmt, true, errCode);
     return SQLiteUtils::MapSQLiteErrno(errCode);
 }
+
+bool DBInfoHandleTest::IsSupport(const DeviceInfos &devInfo)
+{
+    std::lock_guard<std::mutex> autoLock(supportMutex_);
+    if (supportStatus_.find(devInfo.identifier) == supportStatus_.end()) {
+        return false;
+    }
+    return supportStatus_[devInfo.identifier];
+}
+
+void DBInfoHandleTest::SetSupport(const std::string &dev, bool isSupport)
+{
+    std::lock_guard<std::mutex> autoLock(supportMutex_);
+    supportStatus_[dev] = isSupport;
+}
 } // namespace DistributedDBUnitTest
diff --git a/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.h b/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.h
index 1cbf6155d97..384f40e7ed3 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.h
+++ b/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.h
@@ -27,6 +27,7 @@
 #include <unordered_map>
 #include <vector>
 
+#include "db_info_handle.h"
 #include "db_types.h"
 #include "kv_store_changed_data.h"
 #include "kv_store_delegate_impl.h"
@@ -326,6 +327,18 @@ public:
     static int GetMetaData(sqlite3 *db, const DistributedDB::Key &key, DistributedDB::Value &value);
     static int SetMetaData(sqlite3 *db, const DistributedDB::Key &key, const DistributedDB::Value &value);
 };
+
+class DBInfoHandleTest : public DistributedDB::DBInfoHandle {
+public:
+    ~DBInfoHandleTest() override = default;
+
+    bool IsSupport(const DistributedDB::DeviceInfos &devInfo) override;
+
+    void SetSupport(const std::string &dev, bool isSupport);
+private:
+    std::mutex supportMutex_;
+    std::map<std::string, bool> supportStatus_;
+};
 } // namespace DistributedDBUnitTest
 
 #endif // DISTRIBUTEDDB_TOOLS_UNIT_TEST_H
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 cf4ae41640b..bb885604b02 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
@@ -23,7 +23,7 @@
 using namespace std;
 using namespace DistributedDB;
 
-bool SetUpEnv(EnvHandle &inEnv, const string &inName)
+bool SetUpEnv(EnvHandle &inEnv, const string &inName, const std::shared_ptr<DBStatusAdapter> &adapter)
 {
     if (inEnv.adapterHandle != nullptr || inEnv.commAggrHandle != nullptr) {
         LOGI("[UT][Common][SetUp] Already Setup for %s", inName.c_str());
@@ -42,7 +42,7 @@ bool SetUpEnv(EnvHandle &inEnv, const string &inName)
         return false;
     }
 
-    int errCode = inEnv.commAggrHandle->Initialize(inEnv.adapterHandle, nullptr);
+    int errCode = inEnv.commAggrHandle->Initialize(inEnv.adapterHandle, adapter);
     if (errCode != E_OK) {
         LOGI("[UT][Common][SetUp] Init CommunicatorAggregator fail for %s", inName.c_str());
         return false;
@@ -51,6 +51,11 @@ bool SetUpEnv(EnvHandle &inEnv, const string &inName)
     return true;
 }
 
+bool SetUpEnv(EnvHandle &inEnv, const string &inName)
+{
+    return SetUpEnv(inEnv, inName, nullptr);
+}
+
 void TearDownEnv(EnvHandle &inEnv)
 {
     if (inEnv.commAggrHandle != nullptr) {
diff --git a/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_common.h b/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_common.h
index 11be295afdb..ecd04684c3f 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_common.h
+++ b/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_common.h
@@ -19,12 +19,12 @@
 #include <set>
 #include <string>
 #include <vector>
-#include "endian_convert.h"
-#include "message.h"
 #include "adapter_stub.h"
+#include "communicator_aggregator.h"
+#include "endian_convert.h"
 #include "frame_header.h"
 #include "iprocess_communicator.h"
-#include "communicator_aggregator.h"
+#include "message.h"
 #include "store_types.h"
 
 struct EnvHandle {
@@ -38,6 +38,8 @@ struct OnOfflineDevice {
     std::string latestOfflineDevice;
 };
 
+bool SetUpEnv(EnvHandle &inEnv, const std::string &inName,
+    const std::shared_ptr<DistributedDB::DBStatusAdapter> &adapter);
 bool SetUpEnv(EnvHandle &inEnv, const std::string &inName);
 void TearDownEnv(EnvHandle &inEnv);
 
diff --git a/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
index 36fbe246cdd..3d949920300 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
@@ -15,21 +15,26 @@
 
 #include <gtest/gtest.h>
 #include <thread>
+#include "db_common.h"
 #include "db_errno.h"
 #include "distributeddb_communicator_common.h"
+#include "distributeddb_data_generate_unit_test.h"
 #include "distributeddb_tools_unit_test.h"
 #include "endian_convert.h"
 #include "log_print.h"
 #include "thread_pool_test_stub.h"
+#include "virtual_communicator_aggregator.h"
 
 using namespace std;
 using namespace testing::ext;
 using namespace DistributedDB;
+using namespace DistributedDBUnitTest;
 
 namespace {
     EnvHandle g_envDeviceA;
     EnvHandle g_envDeviceB;
     EnvHandle g_envDeviceC;
+}
 
 static void HandleConnectChange(OnOfflineDevice &onlines, const std::string &target, bool isConnect)
 {
@@ -852,4 +857,288 @@ HWTEST_F(DistributedDBCommunicatorTest, ReDeliverMessage003, TestSize.Level2)
     g_envDeviceB.commAggrHandle->RegCommunicatorLackCallback(nullptr, nullptr);
     AdapterStub::DisconnectAdapterStub(g_envDeviceA.adapterHandle, g_envDeviceB.adapterHandle);
 }
+
+namespace {
+    void SetUpEnv(const std::string &localDev, const std::string &supportDev,
+        const std::shared_ptr<DBStatusAdapter> &adapter, bool isSupport, EnvHandle &envDevice)
+    {
+        std::shared_ptr<DBInfoHandleTest> handle = std::make_shared<DBInfoHandleTest>();
+        adapter->SetDBInfoHandle(handle);
+        handle->SetSupport(supportDev, isSupport);
+        SetUpEnv(envDevice, localDev, adapter);
+    }
+
+    void InitCommunicator(DBInfo &dbInfo, EnvHandle &envDevice, OnOfflineDevice &onlineCallback, ICommunicator *&comm)
+    {
+        dbInfo.userId = USER_ID;
+        dbInfo.appId = APP_ID;
+        dbInfo.storeId = STORE_ID_1;
+        dbInfo.isNeedSync = true;
+        dbInfo.syncDualTupleMode = false;
+        std::string label = DBCommon::GenerateHashLabel(dbInfo);
+        std::vector<uint8_t> commLabel(label.begin(), label.end());
+        int errorNo = E_OK;
+        comm = envDevice.commAggrHandle->AllocCommunicator(commLabel, errorNo);
+        ASSERT_NOT_NULL_AND_ACTIVATE(comm);
+        REG_CONNECT_CALLBACK(comm, onlineCallback);
+    }
+}
+
+/**
+  * @tc.name: CommunicationOptimization001
+  * @tc.desc: Test notify with isSupport true.
+  * @tc.type: FUNC
+  * @tc.require: AR000HGD0B
+  * @tc.author: zhangqiquan
+  */
+HWTEST_F(DistributedDBCommunicatorTest, CommunicationOptimization001, TestSize.Level3)
+{
+    auto *pAggregator = new VirtualCommunicatorAggregator();
+    ASSERT_NE(pAggregator, nullptr);
+    const std::string deviceA = "DEVICES_A";
+    const std::string deviceB = "DEVICES_B";
+    RuntimeContext::GetInstance()->SetCommunicatorAggregator(pAggregator);
+    /**
+     * @tc.steps: step1. set up env
+     */
+    EnvHandle envDeviceA;
+    std::shared_ptr<DBStatusAdapter> adapterA = std::make_shared<DBStatusAdapter>();
+    SetUpEnv(deviceA, deviceB, adapterA, true, envDeviceA);
+
+    EnvHandle envDeviceB;
+    std::shared_ptr<DBStatusAdapter> adapterB = std::make_shared<DBStatusAdapter>();
+    SetUpEnv(deviceB, deviceA, adapterB, true, envDeviceB);
+
+    /**
+     * @tc.steps: step2. device alloc communicator using label and register callback
+     */
+    DBInfo dbInfo;
+    ICommunicator *commAA = nullptr;
+    OnOfflineDevice onlineForAA;
+    InitCommunicator(dbInfo, envDeviceA, onlineForAA, commAA);
+
+    ICommunicator *commBB = nullptr;
+    OnOfflineDevice onlineForBB;
+    InitCommunicator(dbInfo, envDeviceB, onlineForBB, commBB);
+
+    /**
+     * @tc.steps: step3. connect device A with device B
+     */
+    AdapterStub::ConnectAdapterStub(envDeviceA.adapterHandle, envDeviceB.adapterHandle);
+
+    /**
+     * @tc.steps: step4. wait for label exchange
+     * @tc.expected: step4. both communicator has no callback;
+     */
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    EXPECT_EQ(onlineForAA.onlineDevices.size(), static_cast<size_t>(0));
+    EXPECT_EQ(onlineForBB.onlineDevices.size(), static_cast<size_t>(0));
+
+    /**
+     * @tc.steps: step5. both notify
+     * @tc.expected: step5. both has callback;
+     */
+    adapterA->NotifyDBInfos({ deviceB }, { dbInfo });
+    adapterB->NotifyDBInfos({ deviceA }, { dbInfo });
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+
+    EXPECT_EQ(onlineForAA.onlineDevices.size(), static_cast<size_t>(1));
+
+    dbInfo.isNeedSync = false;
+    adapterA->NotifyDBInfos({ deviceB }, { dbInfo });
+    adapterB->NotifyDBInfos({ deviceA }, { dbInfo });
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    EXPECT_EQ(onlineForAA.onlineDevices.size(), static_cast<size_t>(0));
+
+    // Clean up and disconnect
+    envDeviceA.commAggrHandle->ReleaseCommunicator(commAA);
+    envDeviceB.commAggrHandle->ReleaseCommunicator(commBB);
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+
+    AdapterStub::DisconnectAdapterStub(envDeviceA.adapterHandle, envDeviceB.adapterHandle);
+
+    TearDownEnv(envDeviceA);
+    TearDownEnv(envDeviceB);
+    RuntimeContext::GetInstance()->SetCommunicatorAggregator(nullptr);
+}
+
+/**
+  * @tc.name: CommunicationOptimization002
+  * @tc.desc: Test notify with isSupport true and can offline by device change.
+  * @tc.type: FUNC
+  * @tc.require: AR000HGD0B
+  * @tc.author: zhangqiquan
+  */
+HWTEST_F(DistributedDBCommunicatorTest, CommunicationOptimization002, TestSize.Level3)
+{
+    auto *pAggregator = new VirtualCommunicatorAggregator();
+    ASSERT_NE(pAggregator, nullptr);
+    const std::string deviceA = "DEVICES_A";
+    const std::string deviceB = "DEVICES_B";
+    RuntimeContext::GetInstance()->SetCommunicatorAggregator(pAggregator);
+    /**
+     * @tc.steps: step1. set up env
+     */
+    EnvHandle envDeviceA;
+    std::shared_ptr<DBStatusAdapter> adapterA = std::make_shared<DBStatusAdapter>();
+    SetUpEnv(deviceA, deviceB, adapterA, true, envDeviceA);
+
+    EnvHandle envDeviceB;
+    std::shared_ptr<DBStatusAdapter> adapterB = std::make_shared<DBStatusAdapter>();
+    SetUpEnv(deviceB, deviceA, adapterB, true, envDeviceB);
+
+    /**
+     * @tc.steps: step2. device alloc communicator using label and register callback
+     */
+    DBInfo dbInfo;
+    ICommunicator *commAA = nullptr;
+    OnOfflineDevice onlineForAA;
+    InitCommunicator(dbInfo, envDeviceA, onlineForAA, commAA);
+    /**
+     * @tc.steps: step3. connect device A with device B
+     */
+    AdapterStub::ConnectAdapterStub(envDeviceA.adapterHandle, envDeviceB.adapterHandle);
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+
+    /**
+     * @tc.steps: step5. A notify remote
+     * @tc.expected: step5. A has callback;
+     */
+    adapterA->NotifyDBInfos({ deviceB }, { dbInfo });
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    EXPECT_EQ(onlineForAA.onlineDevices.size(), static_cast<size_t>(1));
+
+    AdapterStub::DisconnectAdapterStub(envDeviceA.adapterHandle, envDeviceB.adapterHandle);
+    EXPECT_EQ(onlineForAA.onlineDevices.size(), static_cast<size_t>(0));
+
+    // Clean up and disconnect
+    envDeviceA.commAggrHandle->ReleaseCommunicator(commAA);
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+
+    TearDownEnv(envDeviceA);
+    TearDownEnv(envDeviceB);
+    RuntimeContext::GetInstance()->SetCommunicatorAggregator(nullptr);
+}
+
+/**
+  * @tc.name: CommunicationOptimization003
+  * @tc.desc: Test notify with isSupport false.
+  * @tc.type: FUNC
+  * @tc.require: AR000HGD0B
+  * @tc.author: zhangqiquan
+  */
+HWTEST_F(DistributedDBCommunicatorTest, CommunicationOptimization003, TestSize.Level3)
+{
+    auto *pAggregator = new VirtualCommunicatorAggregator();
+    ASSERT_NE(pAggregator, nullptr);
+    const std::string deviceA = "DEVICES_A";
+    const std::string deviceB = "DEVICES_B";
+    RuntimeContext::GetInstance()->SetCommunicatorAggregator(pAggregator);
+    /**
+     * @tc.steps: step1. set up env
+     */
+    EnvHandle envDeviceA;
+    std::shared_ptr<DBStatusAdapter> adapterA = std::make_shared<DBStatusAdapter>();
+    SetUpEnv(deviceA, deviceB, adapterA, false, envDeviceA);
+    EnvHandle envDeviceB;
+    std::shared_ptr<DBStatusAdapter> adapterB = std::make_shared<DBStatusAdapter>();
+    SetUpEnv(deviceB, deviceA, adapterB, false, envDeviceB);
+    /**
+     * @tc.steps: step2. device alloc communicator using label and register callback
+     */
+    DBInfo dbInfo;
+    ICommunicator *commAA = nullptr;
+    OnOfflineDevice onlineForAA;
+    InitCommunicator(dbInfo, envDeviceA, onlineForAA, commAA);
+    ICommunicator *commBB = nullptr;
+    OnOfflineDevice onlineForBB;
+    InitCommunicator(dbInfo, envDeviceB, onlineForBB, commBB);
+    /**
+     * @tc.steps: step3. connect device A with device B
+     */
+    AdapterStub::ConnectAdapterStub(envDeviceA.adapterHandle, envDeviceB.adapterHandle);
+    /**
+     * @tc.steps: step4. wait for label exchange
+     * @tc.expected: step4. both communicator has no callback;
+     */
+    EXPECT_EQ(onlineForAA.onlineDevices.size(), static_cast<size_t>(0));
+    EXPECT_EQ(onlineForBB.onlineDevices.size(), static_cast<size_t>(0));
+    /**
+     * @tc.steps: step5. A notify remote
+     * @tc.expected: step5. B has no callback;
+     */
+    adapterA->NotifyDBInfos({ deviceB }, { dbInfo });
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    EXPECT_EQ(onlineForBB.onlineDevices.size(), static_cast<size_t>(0));
+    /**
+     * @tc.steps: step6. A notify local
+     * @tc.expected: step6. B has no callback;
+     */
+    adapterA->NotifyDBInfos({ deviceA }, { dbInfo });
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    EXPECT_EQ(onlineForBB.onlineDevices.size(), static_cast<size_t>(1));
+    dbInfo.isNeedSync = false;
+    adapterA->NotifyDBInfos({ deviceA }, { dbInfo });
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    EXPECT_EQ(onlineForAA.onlineDevices.size(), static_cast<size_t>(0));
+    // Clean up and disconnect
+    envDeviceA.commAggrHandle->ReleaseCommunicator(commAA);
+    envDeviceB.commAggrHandle->ReleaseCommunicator(commBB);
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    AdapterStub::DisconnectAdapterStub(envDeviceA.adapterHandle, envDeviceB.adapterHandle);
+    TearDownEnv(envDeviceA);
+    TearDownEnv(envDeviceB);
+    RuntimeContext::GetInstance()->SetCommunicatorAggregator(nullptr);
+}
+
+/**
+  * @tc.name: DbStatusAdapter001
+  * @tc.desc: Test notify with isSupport false.
+  * @tc.type: FUNC
+  * @tc.require: AR000HGD0B
+  * @tc.author: zhangqiquan
+  */
+HWTEST_F(DistributedDBCommunicatorTest, DbStatusAdapter001, TestSize.Level1)
+{
+    auto *pAggregator = new VirtualCommunicatorAggregator();
+    ASSERT_NE(pAggregator, nullptr);
+    const std::string deviceA = "DEVICES_A";
+    const std::string deviceB = "DEVICES_B";
+    RuntimeContext::GetInstance()->SetCommunicatorAggregator(pAggregator);
+
+    std::shared_ptr<DBStatusAdapter> adapterA = std::make_shared<DBStatusAdapter>();
+    std::shared_ptr<DBInfoHandleTest> handle = std::make_shared<DBInfoHandleTest>();
+    adapterA->SetDBInfoHandle(handle);
+    handle->SetSupport(deviceB, true);
+    std::string actualRemoteDevInfo;
+    size_t remoteInfoCount = 0u;
+    size_t localCount = 0u;
+    DBInfo dbInfo;
+    adapterA->NotifyDBInfos({ deviceA }, { dbInfo });
+
+    dbInfo = {
+        USER_ID,
+        APP_ID,
+        STORE_ID_1,
+        true,
+        false
+    };
+    adapterA->NotifyDBInfos({ deviceA }, { dbInfo });
+    dbInfo.isNeedSync = false;
+    adapterA->NotifyDBInfos({ deviceA }, { dbInfo });
+    adapterA->NotifyDBInfos({ deviceB }, { dbInfo });
+
+    adapterA->SetDBStatusChangeCallback(
+        [&actualRemoteDevInfo, &remoteInfoCount](const std::string &devInfo, const std::vector<DBInfo> &dbInfos) {
+            actualRemoteDevInfo = devInfo;
+            remoteInfoCount = dbInfos.size();
+        },
+        [&localCount]() {
+            localCount++;
+        });
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    EXPECT_EQ(actualRemoteDevInfo, deviceB);
+    EXPECT_EQ(remoteInfoCount, 1u);
+    EXPECT_EQ(localCount, 1u);
+    RuntimeContext::GetInstance()->SetCommunicatorAggregator(nullptr);
 }
\ No newline at end of file
-- 
Gitee


From ad82b7ddc0ef161714a5f4fe17ac6c14afa50bcc Mon Sep 17 00:00:00 2001
From: zqq <zhangqiquan1@huawei.com>
Date: Mon, 21 Nov 2022 21:58:39 +0800
Subject: [PATCH 09/29] fixbug in subscribe and add ut

Signed-off-by: zqq <zhangqiquan1@huawei.com>
---
 .../common/include/runtime_context.h          |  2 +
 .../common/src/runtime_context_impl.cpp       | 12 +++++
 .../common/src/runtime_context_impl.h         |  2 +
 .../communicator/src/communicator_linker.cpp  |  3 +-
 .../communicator/src/db_status_adapter.cpp    |  3 +-
 .../syncer/src/subscribe_recorder.cpp         | 34 +++++++-----
 .../syncer/src/subscribe_recorder.h           |  4 +-
 .../distributeddb/syncer/src/sync_engine.cpp  |  6 +--
 ...ddb_single_ver_p2p_subscribe_sync_test.cpp | 53 +++++++++++++++++++
 9 files changed, 99 insertions(+), 20 deletions(-)

diff --git a/frameworks/libs/distributeddb/common/include/runtime_context.h b/frameworks/libs/distributeddb/common/include/runtime_context.h
index bdc66b11a0e..0eca61f6d26 100644
--- a/frameworks/libs/distributeddb/common/include/runtime_context.h
+++ b/frameworks/libs/distributeddb/common/include/runtime_context.h
@@ -155,6 +155,8 @@ public:
     virtual void RecordRemoteSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId,
         const QuerySyncObject &query) = 0;
 
+    virtual void RemoveSubscribe(const DeviceID &deviceId) = 0;
+
     virtual void RemoveSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId) = 0;
 
     virtual void RemoveSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId, const QuerySyncObject &query) = 0;
diff --git a/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp b/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
index 1c9eca65d7f..73b7b7944fc 100644
--- a/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
+++ b/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
@@ -808,6 +808,18 @@ void RuntimeContextImpl::RecordRemoteSubscribe(const DBInfo &dbInfo, const Devic
     }
 }
 
+void RuntimeContextImpl::RemoveSubscribe(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(deviceId);
+    }
+}
+
 void RuntimeContextImpl::RemoveSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId)
 {
     std::shared_ptr<DBStatusAdapter> dbStatusAdapter = GetDBStatusAdapter();
diff --git a/frameworks/libs/distributeddb/common/src/runtime_context_impl.h b/frameworks/libs/distributeddb/common/src/runtime_context_impl.h
index 90422c0f894..4f66b987350 100644
--- a/frameworks/libs/distributeddb/common/src/runtime_context_impl.h
+++ b/frameworks/libs/distributeddb/common/src/runtime_context_impl.h
@@ -139,6 +139,8 @@ public:
 
     void RecordRemoteSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId, const QuerySyncObject &query) override;
 
+    void RemoveSubscribe(const DeviceID &deviceId) override;
+
     void RemoveSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId) override;
 
     void RemoveSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId, const QuerySyncObject &query) override;
diff --git a/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp b/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp
index a3efae0bc5d..263b9cd1bf8 100644
--- a/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp
@@ -285,8 +285,7 @@ int CommunicatorLinker::TriggerLabelExchangeEvent(const std::string &toTarget)
     // Get a snapshot of current online labels
     std::set<LabelType> onlineLabels;
     std::vector<DBInfo> dbInfos;
-    if (statusAdapter_ != nullptr && statusAdapter_->ExistDBInfoHandle() &&
-            statusAdapter_->GetLocalDBInfos(dbInfos) == E_OK) {
+    if (statusAdapter_ != nullptr && statusAdapter_->GetLocalDBInfos(dbInfos) == E_OK) {
         for (const auto &dbInfo: dbInfos) {
             std::string label = DBCommon::GenerateHashLabel(dbInfo);
             LabelType labelType(label.begin(), label.end());
diff --git a/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
index b05336a27b2..13c6d7a462e 100644
--- a/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
@@ -129,7 +129,7 @@ void DBStatusAdapter::NotifyDBInfos(const DeviceInfos &devInfos, const std::vect
         LoadIntoCache(isLocal, devInfos, dbInfos, changeDbInfos);
         std::lock_guard<std::mutex> autoLock(callbackMutex_);
         if (!isLocal && remoteCallback_ != nullptr) {
-            remoteCallback_(devInfos.identifier, changeDbInfos);
+            remoteCallback_(devInfos.identifier, dbInfos);
         } else if (isLocal && localCallback_ != nullptr && !changeDbInfos.empty()) {
             localCallback_();
         }
@@ -151,6 +151,7 @@ void DBStatusAdapter::TargetOffline(const std::string &device)
             remoteSupportInfo_.erase(device);
         }
     }
+    RuntimeContext::GetInstance()->RemoveSubscribe(device);
 }
 
 std::shared_ptr<DBInfoHandle> DBStatusAdapter::GetDBInfoHandle() const
diff --git a/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.cpp b/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.cpp
index 0f05ddb7fc6..bccc07034c8 100644
--- a/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.cpp
@@ -19,13 +19,13 @@ void SubscribeRecorder::RecordSubscribe(const DistributedDB::DBInfo &dbInfo, con
     const DistributedDB::QuerySyncObject &query)
 {
     std::lock_guard<std::mutex> autoLock(subscribeMutex_);
-    const auto &find = std::find_if(subscribeCache_.begin(), subscribeCache_.end(),
+    const auto &findSubscribe = 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);
+    if (findSubscribe != subscribeCache_.end()) {
+        findSubscribe->subscribeQuery[deviceId].push_back(query);
         return;
     }
     SubscribeEntry entry;
@@ -40,6 +40,14 @@ void SubscribeRecorder::RemoveAllSubscribe()
     subscribeCache_.clear();
 }
 
+void SubscribeRecorder::RemoveSubscribe(const DistributedDB::DeviceID &deviceId)
+{
+    std::lock_guard<std::mutex> autoLock(subscribeMutex_);
+    for (auto &entry: subscribeCache_) {
+        entry.subscribeQuery.erase(deviceId);
+    }
+}
+
 void SubscribeRecorder::RemoveSubscribe(const DistributedDB::DBInfo &dbInfo, const DistributedDB::DeviceID &deviceId)
 {
     RemoveSubscribeInner(dbInfo, deviceId, "", true);
@@ -55,34 +63,34 @@ 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(),
+    const auto &findSubscribe = 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;
+    if (findSubscribe != subscribeCache_.end()) {
+        subscribeQuery = findSubscribe->subscribeQuery;
     }
 }
 
 void SubscribeRecorder::RemoveSubscribeInner(const DBInfo &dbInfo, const DeviceID &deviceId,
-    const std::string &queryId, bool removeByDevice)
+    const std::string &queryId, bool isRemoveByDevice)
 {
     std::lock_guard<std::mutex> autoLock(subscribeMutex_);
-    const auto &find = std::find_if(subscribeCache_.begin(), subscribeCache_.end(),
+    const auto &findSubscribe = 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()) {
+    if (findSubscribe == subscribeCache_.end()) {
         return;
     }
-    if (removeByDevice) {
-        find->subscribeQuery.erase(deviceId);
+    if (isRemoveByDevice) {
+        findSubscribe->subscribeQuery.erase(deviceId);
         return;
     }
-    const auto &queryList = find->subscribeQuery.find(deviceId);
-    if (queryList == find->subscribeQuery.end()) {
+    const auto &queryList = findSubscribe->subscribeQuery.find(deviceId);
+    if (queryList == findSubscribe->subscribeQuery.end()) {
         return;
     }
     (void) std::remove_if(
diff --git a/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.h b/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.h
index e05d0babfd0..4c6b08e37dc 100644
--- a/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.h
+++ b/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.h
@@ -32,6 +32,8 @@ public:
 
     void RemoveAllSubscribe();
 
+    void RemoveSubscribe(const DeviceID &deviceId);
+
     void RemoveSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId);
 
     void RemoveSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId, const QuerySyncObject &query);
@@ -40,7 +42,7 @@ public:
         std::map<std::string, std::vector<QuerySyncObject>> &subscribeQuery) const;
 private:
     void RemoveSubscribeInner(const DBInfo &dbInfo, const DeviceID &deviceId,
-        const std::string &queryId, bool removeByDevice);
+        const std::string &queryId, bool isRemoveByDevice);
     struct SubscribeEntry {
         DBInfo dbInfo;
         std::map<DeviceID, std::vector<QuerySyncObject>> subscribeQuery;
diff --git a/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp b/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp
index bf8983f5c5f..2a1c2b7d691 100644
--- a/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp
@@ -836,6 +836,9 @@ void SyncEngine::OfflineHandleByDevice(const std::string &deviceId)
             static_cast<SingleVerKvDBSyncInterface *>(syncInterface_)->RemoveSubscribe(queryId);
         }
     }
+    DBInfo dbInfo;
+    static_cast<SyncGenericInterface *>(syncInterface_)->GetDBInfo(dbInfo);
+    RuntimeContext::GetInstance()->RemoveSubscribe(dbInfo, deviceId);
     // get context and Inc context if context is not nullprt
     ISyncTaskContext *context = GetSyncTaskContextAndInc(deviceId);
     if (context != nullptr) {
@@ -854,9 +857,6 @@ 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();
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
index 207e1469a4f..a9f5e4d9ac4 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
@@ -24,6 +24,7 @@
 #include "platform_specific.h"
 #include "query.h"
 #include "query_sync_object.h"
+#include "runtime_config.h"
 #include "single_ver_data_sync.h"
 #include "single_ver_serialize_manager.h"
 #include "subscribe_manager.h"
@@ -1037,6 +1038,58 @@ HWTEST_F(DistributedDBSingleVerP2PSubscribeSyncTest, subscribeSync007, TestSize.
     EXPECT_TRUE(g_schemaKvDelegatePtr->UnSubscribeRemoteQuery(devices, nullptr, query, true) == NOT_SUPPORT);
 }
 
+/**
+ * @tc.name: SubscribeSync008
+ * @tc.desc: test subscribe with reopen db
+ * @tc.type: FUNC
+ * @tc.require: AR000HGD0B
+ * @tc.author: zhangqiquan
+ */
+HWTEST_F(DistributedDBSingleVerP2PSubscribeSyncTest, SubscribeSync008, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. InitSchemaDb
+     */
+    std::shared_ptr<DBInfoHandleTest> handleTest = std::make_shared<DBInfoHandleTest>();
+    handleTest->SetSupport(DEVICE_B, true);
+    RuntimeConfig::SetDBInfoHandle(handleTest);
+
+    LOGI("============step 1============");
+    InitSubSchemaDb();
+    std::vector<std::string> devices;
+    devices.push_back(g_deviceB->GetDeviceId());
+
+    /**
+     * @tc.steps: step2. deviceB subscribe query to deviceA
+     */
+    LOGI("============step 2============");
+    Key key6 { 'k', '6' };
+    Query query = Query::Select();
+    g_deviceB->Subscribe(QuerySyncObject(query), true, 3);
+
+    EXPECT_EQ(g_schemaMgr.CloseKvStore(g_schemaKvDelegatePtr), OK);
+    g_schemaKvDelegatePtr = nullptr;
+    InitSubSchemaDb();
+    g_deviceB->Online();
+    /**
+     * @tc.steps: step3. deviceA put k1,key6 and wait
+     */
+    LOGI("============step 3============");
+    EXPECT_EQ(OK, g_schemaKvDelegatePtr->PutBatch({
+        {key6, Value(SCHEMA_VALUE1.begin(), SCHEMA_VALUE1.end())},
+    }));
+    std::this_thread::sleep_for(std::chrono::milliseconds(500));
+
+    /**
+     * @tc.steps: step4. deviceB has key6
+     */
+    LOGI("============step 4============");
+    VirtualDataItem item;
+    EXPECT_EQ(g_deviceB->GetData(key6, item), E_OK);
+    EXPECT_EQ(item.value, Value(SCHEMA_VALUE1.begin(), SCHEMA_VALUE1.end()));
+    RuntimeConfig::SetDBInfoHandle(nullptr);
+}
+
 namespace {
 KvVirtualDevice *CreateKvVirtualDevice(const std::string &deviceName)
 {
-- 
Gitee


From 22d1519b43d68769b49aa374ca6336ec4e06564b Mon Sep 17 00:00:00 2001
From: zqq <zhangqiquan1@huawei.com>
Date: Fri, 25 Nov 2022 16:07:32 +0800
Subject: [PATCH 10/29] fixbug in subscribe cache

Signed-off-by: zqq <zhangqiquan1@huawei.com>
---
 .../syncer/src/subscribe_recorder.cpp         |  9 ++--
 ...ddb_single_ver_p2p_subscribe_sync_test.cpp | 51 +++++++++++++++++++
 2 files changed, 56 insertions(+), 4 deletions(-)

diff --git a/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.cpp b/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.cpp
index bccc07034c8..bad1195e06a 100644
--- a/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.cpp
@@ -89,13 +89,14 @@ void SubscribeRecorder::RemoveSubscribeInner(const DBInfo &dbInfo, const DeviceI
         findSubscribe->subscribeQuery.erase(deviceId);
         return;
     }
-    const auto &queryList = findSubscribe->subscribeQuery.find(deviceId);
-    if (queryList == findSubscribe->subscribeQuery.end()) {
+    const auto &queryEntry = findSubscribe->subscribeQuery.find(deviceId);
+    if (queryEntry == findSubscribe->subscribeQuery.end()) {
         return;
     }
-    (void) std::remove_if(
-        queryList->second.begin(), queryList->second.end(), [&queryId](const QuerySyncObject &checkQuery) {
+    auto removeQuery = std::remove_if(
+        queryEntry->second.begin(), queryEntry->second.end(), [&queryId](const QuerySyncObject &checkQuery) {
         return checkQuery.GetIdentify() == queryId;
     });
+    queryEntry->second.erase(removeQuery, queryEntry->second.end());
 }
 }
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
index a9f5e4d9ac4..96e1dcbcfe6 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
@@ -28,6 +28,7 @@
 #include "single_ver_data_sync.h"
 #include "single_ver_serialize_manager.h"
 #include "subscribe_manager.h"
+#include "subscribe_recorder.h"
 #include "sync_types.h"
 
 using namespace testing::ext;
@@ -1163,6 +1164,56 @@ HWTEST_F(DistributedDBSingleVerP2PSubscribeSyncTest, SubscribeSync009, TestSize.
     }
 }
 
+/*
+ * @tc.name: SubscribeSync010
+ * @tc.desc: test subscribe query cache
+ * @tc.type: FUNC
+ * @tc.require: AR000H5VLO
+ * @tc.author: zhangqiquan
+ */
+HWTEST_F(DistributedDBSingleVerP2PSubscribeSyncTest, SubscribeSync010, TestSize.Level1)
+{
+    SubscribeRecorder recorder;
+    DBInfo dbInfo = {
+        USER_ID,
+        APP_ID,
+        STORE_ID_1,
+        false,
+        true
+    };
+    Query query = Query::Select();
+    QuerySyncObject querySyncObject(query);
+    /**
+     * @tc.steps: step1. Insert one record and remove
+     */
+    recorder.RecordSubscribe(dbInfo, DEVICE_A, querySyncObject);
+    recorder.RemoveSubscribe(dbInfo, DEVICE_A, querySyncObject);
+    std::map<std::string, std::vector<QuerySyncObject>> subscribeQuery;
+    recorder.GetSubscribeQuery(dbInfo, subscribeQuery);
+    for (const auto &entry: subscribeQuery) {
+        EXPECT_EQ(entry.second.size(), 0u);
+    }
+    /**
+     * @tc.steps: step2. Remove no exist data
+     */
+    recorder.RemoveSubscribe(dbInfo, DEVICE_A, querySyncObject);
+    recorder.GetSubscribeQuery(dbInfo, subscribeQuery);
+    for (const auto &entry: subscribeQuery) {
+        EXPECT_EQ(entry.second.size(), 0u);
+    }
+    /**
+     * @tc.steps: step3. insert two data and remove one data
+     */
+    recorder.RecordSubscribe(dbInfo, DEVICE_A, querySyncObject);
+    Query query2 = Query::Select().EqualTo("test", "test");
+    recorder.RecordSubscribe(dbInfo, DEVICE_A, QuerySyncObject(query2));
+    recorder.RemoveSubscribe(dbInfo, DEVICE_A, querySyncObject);
+    recorder.GetSubscribeQuery(dbInfo, subscribeQuery);
+    for (const auto &entry: subscribeQuery) {
+        EXPECT_EQ(entry.second.size(), 1u);
+    }
+}
+
 /**
  * @tc.name: subscribeSync012
  * @tc.desc: test one device unsubscribe no effect other device
-- 
Gitee


From be38c33bea9be0ee149d9f248ef8462a3a9111af Mon Sep 17 00:00:00 2001
From: zqq <zhangqiquan1@huawei.com>
Date: Mon, 28 Nov 2022 11:49:31 +0800
Subject: [PATCH 11/29] fix issue

Signed-off-by: zqq <zhangqiquan1@huawei.com>
---
 .../syncer/src/subscribe_recorder.cpp         | 35 ++++++++++++++-----
 .../syncer/src/subscribe_recorder.h           |  4 +++
 ...ddb_single_ver_p2p_subscribe_sync_test.cpp |  3 +-
 3 files changed, 32 insertions(+), 10 deletions(-)

diff --git a/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.cpp b/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.cpp
index bad1195e06a..1451cbd1b20 100644
--- a/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.cpp
@@ -77,18 +77,29 @@ void SubscribeRecorder::RemoveSubscribeInner(const DBInfo &dbInfo, const DeviceI
     const std::string &queryId, bool isRemoveByDevice)
 {
     std::lock_guard<std::mutex> autoLock(subscribeMutex_);
+    if (isRemoveByDevice) {
+        RemoveSubscribeQueries(dbInfo, deviceId);
+    } else {
+        RemoveSubscribeQuery(dbInfo, deviceId, queryId);
+    }
+}
+
+void SubscribeRecorder::RemoveSubscribeQueries(const DBInfo &dbInfo, const DeviceID &deviceId)
+{
     const auto &findSubscribe = 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;
+            return CheckSameDBInfo(dbInfo, entry.dbInfo);
+        });
+    findSubscribe->subscribeQuery.erase(deviceId);
+}
+
+void SubscribeRecorder::RemoveSubscribeQuery(const DBInfo &dbInfo, const DeviceID &deviceId,
+    const std::string &queryId)
+{
+    const auto &findSubscribe = std::find_if(subscribeCache_.begin(), subscribeCache_.end(),
+        [&dbInfo](const SubscribeEntry &entry) {
+            return CheckSameDBInfo(dbInfo, entry.dbInfo);
         });
-    if (findSubscribe == subscribeCache_.end()) {
-        return;
-    }
-    if (isRemoveByDevice) {
-        findSubscribe->subscribeQuery.erase(deviceId);
-        return;
-    }
     const auto &queryEntry = findSubscribe->subscribeQuery.find(deviceId);
     if (queryEntry == findSubscribe->subscribeQuery.end()) {
         return;
@@ -99,4 +110,10 @@ void SubscribeRecorder::RemoveSubscribeInner(const DBInfo &dbInfo, const DeviceI
     });
     queryEntry->second.erase(removeQuery, queryEntry->second.end());
 }
+
+bool SubscribeRecorder::CheckSameDBInfo(const DBInfo &srcDbInfo, const DBInfo &dtsDbInfo)
+{
+    return srcDbInfo.userId == dtsDbInfo.userId && srcDbInfo.appId == dtsDbInfo.appId &&
+        srcDbInfo.storeId == dtsDbInfo.storeId;
+}
 }
\ 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
index 4c6b08e37dc..dcfcb261ed8 100644
--- a/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.h
+++ b/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.h
@@ -43,6 +43,10 @@ public:
 private:
     void RemoveSubscribeInner(const DBInfo &dbInfo, const DeviceID &deviceId,
         const std::string &queryId, bool isRemoveByDevice);
+
+    void RemoveSubscribeQueries(const DBInfo &dbInfo, const DeviceID &deviceId);
+    void RemoveSubscribeQuery(const DBInfo &dbInfo, const DeviceID &deviceId, const std::string &queryId);
+    static bool CheckSameDBInfo(const DBInfo &srcDbInfo, const DBInfo &dtsDbInfo);
     struct SubscribeEntry {
         DBInfo dbInfo;
         std::map<DeviceID, std::vector<QuerySyncObject>> subscribeQuery;
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
index 96e1dcbcfe6..89fd8ff277d 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
@@ -1184,9 +1184,10 @@ HWTEST_F(DistributedDBSingleVerP2PSubscribeSyncTest, SubscribeSync010, TestSize.
     Query query = Query::Select();
     QuerySyncObject querySyncObject(query);
     /**
-     * @tc.steps: step1. Insert one record and remove
+     * @tc.steps: step1. Insert one record twice and remove
      */
     recorder.RecordSubscribe(dbInfo, DEVICE_A, querySyncObject);
+    recorder.RecordSubscribe(dbInfo, DEVICE_A, querySyncObject);
     recorder.RemoveSubscribe(dbInfo, DEVICE_A, querySyncObject);
     std::map<std::string, std::vector<QuerySyncObject>> subscribeQuery;
     recorder.GetSubscribeQuery(dbInfo, subscribeQuery);
-- 
Gitee


From 0a944720999243f294cc014b9714037cfa08ec16 Mon Sep 17 00:00:00 2001
From: zqq <zhangqiquan1@huawei.com>
Date: Mon, 28 Nov 2022 14:18:21 +0800
Subject: [PATCH 12/29] fixbug

Signed-off-by: zqq <zhangqiquan1@huawei.com>
---
 .../syncer/src/subscribe_recorder.cpp         | 23 ++++++++-----------
 .../syncer/src/subscribe_recorder.h           |  5 ++--
 ...ddb_single_ver_p2p_subscribe_sync_test.cpp | 10 ++++++++
 3 files changed, 23 insertions(+), 15 deletions(-)

diff --git a/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.cpp b/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.cpp
index 1451cbd1b20..c2ecc8e9786 100644
--- a/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.cpp
@@ -50,13 +50,15 @@ void SubscribeRecorder::RemoveSubscribe(const DistributedDB::DeviceID &deviceId)
 
 void SubscribeRecorder::RemoveSubscribe(const DistributedDB::DBInfo &dbInfo, const DistributedDB::DeviceID &deviceId)
 {
-    RemoveSubscribeInner(dbInfo, deviceId, "", true);
+    std::lock_guard<std::mutex> autoLock(subscribeMutex_);
+    RemoveSubscribeQueries(dbInfo, deviceId);
 }
 
 void SubscribeRecorder::RemoveSubscribe(const DistributedDB::DBInfo &dbInfo, const DistributedDB::DeviceID &deviceId,
     const DistributedDB::QuerySyncObject &query)
 {
-    RemoveSubscribeInner(dbInfo, deviceId, query.GetIdentify(), false);
+    std::lock_guard<std::mutex> autoLock(subscribeMutex_);
+    RemoveSubscribeQuery(dbInfo, deviceId, query.GetIdentify());
 }
 
 void SubscribeRecorder::GetSubscribeQuery(const DistributedDB::DBInfo &dbInfo,
@@ -73,23 +75,15 @@ void SubscribeRecorder::GetSubscribeQuery(const DistributedDB::DBInfo &dbInfo,
     }
 }
 
-void SubscribeRecorder::RemoveSubscribeInner(const DBInfo &dbInfo, const DeviceID &deviceId,
-    const std::string &queryId, bool isRemoveByDevice)
-{
-    std::lock_guard<std::mutex> autoLock(subscribeMutex_);
-    if (isRemoveByDevice) {
-        RemoveSubscribeQueries(dbInfo, deviceId);
-    } else {
-        RemoveSubscribeQuery(dbInfo, deviceId, queryId);
-    }
-}
-
 void SubscribeRecorder::RemoveSubscribeQueries(const DBInfo &dbInfo, const DeviceID &deviceId)
 {
     const auto &findSubscribe = std::find_if(subscribeCache_.begin(), subscribeCache_.end(),
         [&dbInfo](const SubscribeEntry &entry) {
             return CheckSameDBInfo(dbInfo, entry.dbInfo);
         });
+    if (findSubscribe == subscribeCache_.end()) {
+        return;
+    }
     findSubscribe->subscribeQuery.erase(deviceId);
 }
 
@@ -100,6 +94,9 @@ void SubscribeRecorder::RemoveSubscribeQuery(const DBInfo &dbInfo, const DeviceI
         [&dbInfo](const SubscribeEntry &entry) {
             return CheckSameDBInfo(dbInfo, entry.dbInfo);
         });
+    if (findSubscribe == subscribeCache_.end()) {
+        return;
+    }
     const auto &queryEntry = findSubscribe->subscribeQuery.find(deviceId);
     if (queryEntry == findSubscribe->subscribeQuery.end()) {
         return;
diff --git a/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.h b/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.h
index dcfcb261ed8..8f147d7ce49 100644
--- a/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.h
+++ b/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.h
@@ -41,12 +41,13 @@ public:
     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 isRemoveByDevice);
 
     void RemoveSubscribeQueries(const DBInfo &dbInfo, const DeviceID &deviceId);
+
     void RemoveSubscribeQuery(const DBInfo &dbInfo, const DeviceID &deviceId, const std::string &queryId);
+
     static bool CheckSameDBInfo(const DBInfo &srcDbInfo, const DBInfo &dtsDbInfo);
+
     struct SubscribeEntry {
         DBInfo dbInfo;
         std::map<DeviceID, std::vector<QuerySyncObject>> subscribeQuery;
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
index 89fd8ff277d..8d20f1de020 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
@@ -1213,6 +1213,16 @@ HWTEST_F(DistributedDBSingleVerP2PSubscribeSyncTest, SubscribeSync010, TestSize.
     for (const auto &entry: subscribeQuery) {
         EXPECT_EQ(entry.second.size(), 1u);
     }
+    /**
+     * @tc.steps: step4. remove no exist data
+     */
+    dbInfo.storeId = STORE_ID_2;
+    recorder.RemoveSubscribe(dbInfo, DEVICE_A);
+    dbInfo.storeId = STORE_ID_1;
+    recorder.GetSubscribeQuery(dbInfo, subscribeQuery);
+    for (const auto &entry: subscribeQuery) {
+        EXPECT_EQ(entry.second.size(), 1u);
+    }
 }
 
 /**
-- 
Gitee


From 192e526c23b461a93fdee37abf6b5b5494e45fb4 Mon Sep 17 00:00:00 2001
From: zqq <zhangqiquan1@huawei.com>
Date: Mon, 28 Nov 2022 16:36:45 +0800
Subject: [PATCH 13/29] fixbug when reset db info handle

Signed-off-by: zqq <zhangqiquan1@huawei.com>
---
 .../communicator/src/db_status_adapter.cpp    | 11 +++++++----
 .../distributeddb_communicator_test.cpp       | 19 +++++++++++++++++++
 2 files changed, 26 insertions(+), 4 deletions(-)

diff --git a/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
index 13c6d7a462e..7df811ca536 100644
--- a/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
@@ -180,11 +180,14 @@ 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");
+    {
+        std::lock_guard<std::mutex> autoLock(remoteInfoMutex_);
+        remoteDBInfos_.clear();
+    }
+    std::lock_guard<std::mutex> autoLock(supportMutex_);
+    remoteSupportInfo_.clear();
+    LOGD("[DBStatusAdapter] ClearAllCache ok");
 }
 
 void DBStatusAdapter::MergeDBInfos(const std::vector<DBInfo> &srcDbInfos, std::vector<DBInfo> &dstDbInfos,
diff --git a/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
index 3d949920300..cdf901e2963 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
@@ -1141,4 +1141,23 @@ HWTEST_F(DistributedDBCommunicatorTest, DbStatusAdapter001, TestSize.Level1)
     EXPECT_EQ(remoteInfoCount, 1u);
     EXPECT_EQ(localCount, 1u);
     RuntimeContext::GetInstance()->SetCommunicatorAggregator(nullptr);
+}
+
+/**
+  * @tc.name: DbStatusAdapter002
+  * @tc.desc: Test adapter clear cache.
+  * @tc.type: FUNC
+  * @tc.require: AR000HGD0B
+  * @tc.author: zhangqiquan
+  */
+HWTEST_F(DistributedDBCommunicatorTest, DbStatusAdapter002, TestSize.Level1) {
+    const std::string deviceB = "DEVICES_B";
+    std::shared_ptr<DBStatusAdapter> adapterA = std::make_shared<DBStatusAdapter>();
+    std::shared_ptr<DBInfoHandleTest> handle = std::make_shared<DBInfoHandleTest>();
+    adapterA->SetDBInfoHandle(handle);
+    handle->SetSupport(deviceB, true);
+    EXPECT_TRUE(adapterA->IsSupport(deviceB));
+    adapterA->SetDBInfoHandle(handle);
+    handle->SetSupport(deviceB, false);
+    EXPECT_FALSE(adapterA->IsSupport(deviceB));
 }
\ No newline at end of file
-- 
Gitee


From 4dad3c41a22145101f50f7cd64880a462a56d8a4 Mon Sep 17 00:00:00 2001
From: zqq <zhangqiquan1@huawei.com>
Date: Thu, 1 Dec 2022 14:36:21 +0800
Subject: [PATCH 14/29] fixbug when delete kv store

Signed-off-by: zqq <zhangqiquan1@huawei.com>
---
 .../common/include/runtime_context.h          |  9 ++--
 .../common/src/runtime_context_impl.cpp       | 25 ++++++---
 .../common/src/runtime_context_impl.h         |  8 +--
 .../communicator/src/db_status_adapter.cpp    |  2 +-
 .../src/kv_store_delegate_manager.cpp         |  5 ++
 .../syncer/src/single_ver_data_sync.cpp       |  2 +-
 .../syncer/src/subscribe_recorder.cpp         | 21 ++++++--
 .../syncer/src/subscribe_recorder.h           |  8 +--
 .../distributeddb/syncer/src/sync_engine.cpp  |  2 +-
 ...ddb_single_ver_p2p_subscribe_sync_test.cpp | 53 +++++++++++++++++--
 10 files changed, 109 insertions(+), 26 deletions(-)

diff --git a/frameworks/libs/distributeddb/common/include/runtime_context.h b/frameworks/libs/distributeddb/common/include/runtime_context.h
index 0eca61f6d26..cd07184b531 100644
--- a/frameworks/libs/distributeddb/common/include/runtime_context.h
+++ b/frameworks/libs/distributeddb/common/include/runtime_context.h
@@ -155,11 +155,14 @@ public:
     virtual void RecordRemoteSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId,
         const QuerySyncObject &query) = 0;
 
-    virtual void RemoveSubscribe(const DeviceID &deviceId) = 0;
+    virtual void RemoveRemoteSubscribe(const DeviceID &deviceId) = 0;
 
-    virtual void RemoveSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId) = 0;
+    virtual void RemoveRemoteSubscribe(const DBInfo &dbInfo) = 0;
 
-    virtual void RemoveSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId, const QuerySyncObject &query) = 0;
+    virtual void RemoveRemoteSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId) = 0;
+
+    virtual void RemoveRemoteSubscribe(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;
diff --git a/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp b/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
index 73b7b7944fc..8bf874433b0 100644
--- a/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
+++ b/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
@@ -808,7 +808,7 @@ void RuntimeContextImpl::RecordRemoteSubscribe(const DBInfo &dbInfo, const Devic
     }
 }
 
-void RuntimeContextImpl::RemoveSubscribe(const DeviceID &deviceId)
+void RuntimeContextImpl::RemoveRemoteSubscribe(const DeviceID &deviceId)
 {
     std::shared_ptr<DBStatusAdapter> dbStatusAdapter = GetDBStatusAdapter();
     if (dbStatusAdapter != nullptr && !dbStatusAdapter->IsSupport(deviceId)) {
@@ -816,11 +816,23 @@ void RuntimeContextImpl::RemoveSubscribe(const DeviceID &deviceId)
     }
     std::shared_ptr<SubscribeRecorder> subscribeRecorder = GetSubscribeRecorder();
     if (subscribeRecorder != nullptr) {
-        subscribeRecorder->RemoveSubscribe(deviceId);
+        subscribeRecorder->RemoveRemoteSubscribe(deviceId);
     }
 }
 
-void RuntimeContextImpl::RemoveSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId)
+void RuntimeContextImpl::RemoveRemoteSubscribe(const DBInfo &dbInfo)
+{
+    std::shared_ptr<DBStatusAdapter> dbStatusAdapter = GetDBStatusAdapter();
+    if (dbStatusAdapter != nullptr && !dbStatusAdapter->ExistDBInfoHandle()) {
+        return;
+    }
+    std::shared_ptr<SubscribeRecorder> subscribeRecorder = GetSubscribeRecorder();
+    if (subscribeRecorder != nullptr) {
+        subscribeRecorder->RemoveRemoteSubscribe(dbInfo);
+    }
+}
+
+void RuntimeContextImpl::RemoveRemoteSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId)
 {
     std::shared_ptr<DBStatusAdapter> dbStatusAdapter = GetDBStatusAdapter();
     if (dbStatusAdapter != nullptr && !dbStatusAdapter->IsSupport(deviceId)) {
@@ -828,11 +840,12 @@ void RuntimeContextImpl::RemoveSubscribe(const DBInfo &dbInfo, const DeviceID &d
     }
     std::shared_ptr<SubscribeRecorder> subscribeRecorder = GetSubscribeRecorder();
     if (subscribeRecorder != nullptr) {
-        subscribeRecorder->RemoveSubscribe(dbInfo, deviceId);
+        subscribeRecorder->RemoveRemoteSubscribe(dbInfo, deviceId);
     }
 }
 
-void RuntimeContextImpl::RemoveSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId, const QuerySyncObject &query)
+void RuntimeContextImpl::RemoveRemoteSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId,
+    const QuerySyncObject &query)
 {
     std::shared_ptr<DBStatusAdapter> dbStatusAdapter = GetDBStatusAdapter();
     if (dbStatusAdapter != nullptr && !dbStatusAdapter->IsSupport(deviceId)) {
@@ -840,7 +853,7 @@ void RuntimeContextImpl::RemoveSubscribe(const DBInfo &dbInfo, const DeviceID &d
     }
     std::shared_ptr<SubscribeRecorder> subscribeRecorder = GetSubscribeRecorder();
     if (subscribeRecorder != nullptr) {
-        subscribeRecorder->RemoveSubscribe(dbInfo, deviceId, query);
+        subscribeRecorder->RemoveRemoteSubscribe(dbInfo, deviceId, query);
     }
 }
 
diff --git a/frameworks/libs/distributeddb/common/src/runtime_context_impl.h b/frameworks/libs/distributeddb/common/src/runtime_context_impl.h
index 4f66b987350..60c97fa78ea 100644
--- a/frameworks/libs/distributeddb/common/src/runtime_context_impl.h
+++ b/frameworks/libs/distributeddb/common/src/runtime_context_impl.h
@@ -139,11 +139,13 @@ public:
 
     void RecordRemoteSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId, const QuerySyncObject &query) override;
 
-    void RemoveSubscribe(const DeviceID &deviceId) override;
+    void RemoveRemoteSubscribe(const DeviceID &deviceId) override;
 
-    void RemoveSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId) override;
+    void RemoveRemoteSubscribe(const DBInfo &dbInfo) override;
 
-    void RemoveSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId, const QuerySyncObject &query) override;
+    void RemoveRemoteSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId) override;
+
+    void RemoveRemoteSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId, const QuerySyncObject &query) override;
 
     void GetSubscribeQuery(const DBInfo &dbInfo,
         std::map<std::string, std::vector<QuerySyncObject>> &subscribeQuery) override;
diff --git a/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
index 7df811ca536..5106cb87b29 100644
--- a/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
@@ -151,7 +151,7 @@ void DBStatusAdapter::TargetOffline(const std::string &device)
             remoteSupportInfo_.erase(device);
         }
     }
-    RuntimeContext::GetInstance()->RemoveSubscribe(device);
+    RuntimeContext::GetInstance()->RemoveRemoteSubscribe(device);
 }
 
 std::shared_ptr<DBInfoHandle> DBStatusAdapter::GetDBInfoHandle() const
diff --git a/frameworks/libs/distributeddb/interfaces/src/kv_store_delegate_manager.cpp b/frameworks/libs/distributeddb/interfaces/src/kv_store_delegate_manager.cpp
index 9854e2bf2e3..1bf68a942a0 100644
--- a/frameworks/libs/distributeddb/interfaces/src/kv_store_delegate_manager.cpp
+++ b/frameworks/libs/distributeddb/interfaces/src/kv_store_delegate_manager.cpp
@@ -398,6 +398,11 @@ DBStatus KvStoreDelegateManager::DeleteKvStore(const std::string &storeId)
     int errCode = KvDBManager::RemoveDatabase(properties);
     if (errCode == E_OK) {
         LOGI("Database deleted successfully!");
+        DBInfo dbInfo;
+        dbInfo.userId = userId_;
+        dbInfo.appId = appId_;
+        dbInfo.storeId = storeId;
+        RuntimeContext::GetInstance()->RemoveRemoteSubscribe(dbInfo);
         return OK;
     }
     LOGE("Delete the kv store error:%d", errCode);
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 37c9eedf549..3e071ba8a05 100644
--- a/frameworks/libs/distributeddb/syncer/src/single_ver_data_sync.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/single_ver_data_sync.cpp
@@ -2056,7 +2056,7 @@ int SingleVerDataSync::UnsubscribeRequestRecv(SingleVerSyncTaskContext *context,
     subscribeManager->RemoveRemoteSubscribeQuery(context->GetDeviceId(), packet->GetQuery());
     DBInfo dbInfo;
     storage_->GetDBInfo(dbInfo);
-    RuntimeContext::GetInstance()->RemoveSubscribe(dbInfo, context->GetDeviceId(), packet->GetQuery());
+    RuntimeContext::GetInstance()->RemoveRemoteSubscribe(dbInfo, context->GetDeviceId(), packet->GetQuery());
     metadata_->RemoveQueryFromRecordSet(context->GetDeviceId(), packet->GetQuery().GetIdentify());
     return errCode;
 }
diff --git a/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.cpp b/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.cpp
index c2ecc8e9786..91091eb013e 100644
--- a/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.cpp
@@ -40,7 +40,7 @@ void SubscribeRecorder::RemoveAllSubscribe()
     subscribeCache_.clear();
 }
 
-void SubscribeRecorder::RemoveSubscribe(const DistributedDB::DeviceID &deviceId)
+void SubscribeRecorder::RemoveRemoteSubscribe(const DistributedDB::DeviceID &deviceId)
 {
     std::lock_guard<std::mutex> autoLock(subscribeMutex_);
     for (auto &entry: subscribeCache_) {
@@ -48,14 +48,27 @@ void SubscribeRecorder::RemoveSubscribe(const DistributedDB::DeviceID &deviceId)
     }
 }
 
-void SubscribeRecorder::RemoveSubscribe(const DistributedDB::DBInfo &dbInfo, const DistributedDB::DeviceID &deviceId)
+void SubscribeRecorder::RemoveRemoteSubscribe(const DBInfo &dbInfo)
+{
+    const auto &findSubscribe = std::find_if(subscribeCache_.begin(), subscribeCache_.end(),
+        [&dbInfo](const SubscribeEntry &entry) {
+            return CheckSameDBInfo(dbInfo, entry.dbInfo);
+        });
+    if (findSubscribe == subscribeCache_.end()) {
+        return;
+    }
+    subscribeCache_.erase(findSubscribe);
+}
+
+void SubscribeRecorder::RemoveRemoteSubscribe(const DistributedDB::DBInfo &dbInfo,
+    const DistributedDB::DeviceID &deviceId)
 {
     std::lock_guard<std::mutex> autoLock(subscribeMutex_);
     RemoveSubscribeQueries(dbInfo, deviceId);
 }
 
-void SubscribeRecorder::RemoveSubscribe(const DistributedDB::DBInfo &dbInfo, const DistributedDB::DeviceID &deviceId,
-    const DistributedDB::QuerySyncObject &query)
+void SubscribeRecorder::RemoveRemoteSubscribe(const DistributedDB::DBInfo &dbInfo,
+    const DistributedDB::DeviceID &deviceId, const DistributedDB::QuerySyncObject &query)
 {
     std::lock_guard<std::mutex> autoLock(subscribeMutex_);
     RemoveSubscribeQuery(dbInfo, deviceId, query.GetIdentify());
diff --git a/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.h b/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.h
index 8f147d7ce49..c616a1ce517 100644
--- a/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.h
+++ b/frameworks/libs/distributeddb/syncer/src/subscribe_recorder.h
@@ -32,11 +32,13 @@ public:
 
     void RemoveAllSubscribe();
 
-    void RemoveSubscribe(const DeviceID &deviceId);
+    void RemoveRemoteSubscribe(const DeviceID &deviceId);
 
-    void RemoveSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId);
+    void RemoveRemoteSubscribe(const DBInfo &dbInfo);
 
-    void RemoveSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId, const QuerySyncObject &query);
+    void RemoveRemoteSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId);
+
+    void RemoveRemoteSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId, const QuerySyncObject &query);
 
     void GetSubscribeQuery(const DBInfo &dbInfo,
         std::map<std::string, std::vector<QuerySyncObject>> &subscribeQuery) const;
diff --git a/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp b/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp
index 2a1c2b7d691..d2150c9dc28 100644
--- a/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp
@@ -838,7 +838,7 @@ void SyncEngine::OfflineHandleByDevice(const std::string &deviceId)
     }
     DBInfo dbInfo;
     static_cast<SyncGenericInterface *>(syncInterface_)->GetDBInfo(dbInfo);
-    RuntimeContext::GetInstance()->RemoveSubscribe(dbInfo, deviceId);
+    RuntimeContext::GetInstance()->RemoveRemoteSubscribe(dbInfo, deviceId);
     // get context and Inc context if context is not nullprt
     ISyncTaskContext *context = GetSyncTaskContextAndInc(deviceId);
     if (context != nullptr) {
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
index 8d20f1de020..b7c19003065 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
@@ -1188,7 +1188,7 @@ HWTEST_F(DistributedDBSingleVerP2PSubscribeSyncTest, SubscribeSync010, TestSize.
      */
     recorder.RecordSubscribe(dbInfo, DEVICE_A, querySyncObject);
     recorder.RecordSubscribe(dbInfo, DEVICE_A, querySyncObject);
-    recorder.RemoveSubscribe(dbInfo, DEVICE_A, querySyncObject);
+    recorder.RemoveRemoteSubscribe(dbInfo, DEVICE_A, querySyncObject);
     std::map<std::string, std::vector<QuerySyncObject>> subscribeQuery;
     recorder.GetSubscribeQuery(dbInfo, subscribeQuery);
     for (const auto &entry: subscribeQuery) {
@@ -1197,7 +1197,7 @@ HWTEST_F(DistributedDBSingleVerP2PSubscribeSyncTest, SubscribeSync010, TestSize.
     /**
      * @tc.steps: step2. Remove no exist data
      */
-    recorder.RemoveSubscribe(dbInfo, DEVICE_A, querySyncObject);
+    recorder.RemoveRemoteSubscribe(dbInfo, DEVICE_A, querySyncObject);
     recorder.GetSubscribeQuery(dbInfo, subscribeQuery);
     for (const auto &entry: subscribeQuery) {
         EXPECT_EQ(entry.second.size(), 0u);
@@ -1208,7 +1208,7 @@ HWTEST_F(DistributedDBSingleVerP2PSubscribeSyncTest, SubscribeSync010, TestSize.
     recorder.RecordSubscribe(dbInfo, DEVICE_A, querySyncObject);
     Query query2 = Query::Select().EqualTo("test", "test");
     recorder.RecordSubscribe(dbInfo, DEVICE_A, QuerySyncObject(query2));
-    recorder.RemoveSubscribe(dbInfo, DEVICE_A, querySyncObject);
+    recorder.RemoveRemoteSubscribe(dbInfo, DEVICE_A, querySyncObject);
     recorder.GetSubscribeQuery(dbInfo, subscribeQuery);
     for (const auto &entry: subscribeQuery) {
         EXPECT_EQ(entry.second.size(), 1u);
@@ -1217,7 +1217,7 @@ HWTEST_F(DistributedDBSingleVerP2PSubscribeSyncTest, SubscribeSync010, TestSize.
      * @tc.steps: step4. remove no exist data
      */
     dbInfo.storeId = STORE_ID_2;
-    recorder.RemoveSubscribe(dbInfo, DEVICE_A);
+    recorder.RemoveRemoteSubscribe(dbInfo, DEVICE_A);
     dbInfo.storeId = STORE_ID_1;
     recorder.GetSubscribeQuery(dbInfo, subscribeQuery);
     for (const auto &entry: subscribeQuery) {
@@ -1225,6 +1225,51 @@ HWTEST_F(DistributedDBSingleVerP2PSubscribeSyncTest, SubscribeSync010, TestSize.
     }
 }
 
+/*
+ * @tc.name: SubscribeSync011
+ * @tc.desc: test subscribe query cache
+ * @tc.type: FUNC
+ * @tc.require: AR000H5VLO
+ * @tc.author: zhangqiquan
+ */
+HWTEST_F(DistributedDBSingleVerP2PSubscribeSyncTest, SubscribeSync011, TestSize.Level1)
+{
+    SubscribeRecorder recorder;
+    DBInfo dbInfo = {
+            USER_ID,
+            APP_ID,
+            STORE_ID_1,
+            false,
+            true
+    };
+    /**
+     * @tc.steps: step1. Insert 2 record in db1 and 1 record in db2
+     */
+    Query query = Query::Select();
+    QuerySyncObject querySyncObject(query);
+    recorder.RecordSubscribe(dbInfo, DEVICE_A, querySyncObject);
+    recorder.RecordSubscribe(dbInfo, DEVICE_B, querySyncObject);
+    DBInfo dbInfo2 = dbInfo;
+    dbInfo2.storeId = STORE_ID_2;
+    recorder.RecordSubscribe(dbInfo2, DEVICE_B, querySyncObject);
+    /**
+     * @tc.steps: step2. Insert 2 record in db1
+     */
+    recorder.RemoveRemoteSubscribe(dbInfo);
+    std::map<std::string, std::vector<QuerySyncObject>> subscribeQuery;
+    recorder.GetSubscribeQuery(dbInfo, subscribeQuery);
+    EXPECT_EQ(subscribeQuery.size(), 0u);
+    recorder.GetSubscribeQuery(dbInfo2, subscribeQuery);
+    EXPECT_EQ(subscribeQuery.size(), 1u);
+    /**
+     * @tc.steps: step3. Insert 1 record in db2
+     */
+    recorder.RemoveRemoteSubscribe(dbInfo2);
+    subscribeQuery.clear();
+    recorder.GetSubscribeQuery(dbInfo2, subscribeQuery);
+    EXPECT_EQ(subscribeQuery.size(), 0u);
+}
+
 /**
  * @tc.name: subscribeSync012
  * @tc.desc: test one device unsubscribe no effect other device
-- 
Gitee


From 35d75af366fc5989292a7115031128bcaac4cc5b Mon Sep 17 00:00:00 2001
From: zqq <zhangqiquan1@huawei.com>
Date: Fri, 2 Dec 2022 14:43:09 +0800
Subject: [PATCH 15/29] trigger auto sync after add trigger

Signed-off-by: zqq <zhangqiquan1@huawei.com>
---
 .../distributeddb/syncer/src/generic_syncer.h |  2 +-
 .../distributeddb/syncer/src/isync_engine.h   |  2 +
 .../syncer/src/single_ver_kv_syncer.cpp       | 44 +++++++++++++++++++
 .../syncer/src/single_ver_kv_syncer.h         |  5 +++
 .../distributeddb/syncer/src/sync_engine.cpp  | 31 -------------
 .../distributeddb/syncer/src/sync_engine.h    |  7 +--
 ...ddb_single_ver_p2p_subscribe_sync_test.cpp | 10 ++---
 7 files changed, 59 insertions(+), 42 deletions(-)

diff --git a/frameworks/libs/distributeddb/syncer/src/generic_syncer.h b/frameworks/libs/distributeddb/syncer/src/generic_syncer.h
index 3b5c315a247..95201aee9d4 100644
--- a/frameworks/libs/distributeddb/syncer/src/generic_syncer.h
+++ b/frameworks/libs/distributeddb/syncer/src/generic_syncer.h
@@ -133,7 +133,7 @@ protected:
     int InitTimeHelper(ISyncInterface *syncInterface);
 
     // Init the Sync engine
-    int InitSyncEngine(ISyncInterface *syncInterface);
+    virtual int InitSyncEngine(ISyncInterface *syncInterface);
 
     int CheckSyncActive(ISyncInterface *syncInterface, bool isNeedActive);
 
diff --git a/frameworks/libs/distributeddb/syncer/src/isync_engine.h b/frameworks/libs/distributeddb/syncer/src/isync_engine.h
index 4690099c700..8bca65d7dfb 100644
--- a/frameworks/libs/distributeddb/syncer/src/isync_engine.h
+++ b/frameworks/libs/distributeddb/syncer/src/isync_engine.h
@@ -96,6 +96,8 @@ public:
 
     virtual void AbortMachineIfNeed(uint32_t syncId) = 0;
 
+    virtual void AddSubscribe(SyncGenericInterface *storage,
+        const std::map<std::string, std::vector<QuerySyncObject>> &subscribeQuery) = 0;
 protected:
     ~ISyncEngine() override {};
 };
diff --git a/frameworks/libs/distributeddb/syncer/src/single_ver_kv_syncer.cpp b/frameworks/libs/distributeddb/syncer/src/single_ver_kv_syncer.cpp
index e7541fb568f..081eefd1e61 100644
--- a/frameworks/libs/distributeddb/syncer/src/single_ver_kv_syncer.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/single_ver_kv_syncer.cpp
@@ -287,4 +287,48 @@ SyncerBasicInfo SingleVerKVSyncer::DumpSyncerBasicInfo()
     basicInfo.isAutoSync = autoSyncEnable_;
     return basicInfo;
 }
+
+int SingleVerKVSyncer::InitSyncEngine(DistributedDB::ISyncInterface *syncInterface)
+{
+    int errCode = GenericSyncer::InitSyncEngine(syncInterface);
+    if (errCode != E_OK) {
+        return errCode;
+    }
+    TriggerAddSubscribeAsync(syncInterface);
+    return E_OK;
+}
+
+void SingleVerKVSyncer::TriggerAddSubscribeAsync(ISyncInterface *syncInterface)
+{
+    if (syncInterface == nullptr || syncEngine_ == nullptr) {
+        return;
+    }
+    if (syncInterface->GetInterfaceType() != ISyncInterface::SYNC_SVD) {
+        return;
+    }
+    DBInfo dbInfo;
+    auto storage = static_cast<SyncGenericInterface *>(syncInterface);
+    storage->GetDBInfo(dbInfo);
+    std::map<std::string, std::vector<QuerySyncObject>> subscribeQuery;
+    RuntimeContext::GetInstance()->GetSubscribeQuery(dbInfo, subscribeQuery);
+    if (subscribeQuery.empty()) {
+        LOGD("[SingleVerKVSyncer][TriggerAddSubscribeAsync] Subscribe cache is empty");
+        return;
+    }
+    storage->IncRefCount();
+    ISyncEngine *engine = syncEngine_;
+    RefObject::IncObjRef(engine);
+    int errCode = RuntimeContext::GetInstance()->ScheduleTask([this, engine, storage, subscribeQuery]() {
+        engine->AddSubscribe(storage, subscribeQuery);
+        // try to trigger query sync after add trigger
+        LocalDataChanged(SQLITE_GENERAL_NS_PUT_EVENT);
+        storage->DecRefCount();
+        RefObject::DecObjRef(engine);
+    });
+    if (errCode != E_OK) {
+        LOGW("[SingleVerKVSyncer] TriggerAddSubscribeAsync failed errCode = %d", errCode);
+        syncInterface->DecRefCount();
+        RefObject::DecObjRef(engine);
+    }
+}
 } // namespace DistributedDB
diff --git a/frameworks/libs/distributeddb/syncer/src/single_ver_kv_syncer.h b/frameworks/libs/distributeddb/syncer/src/single_ver_kv_syncer.h
index 6ca4a03fc35..8ecb4dfddbc 100644
--- a/frameworks/libs/distributeddb/syncer/src/single_ver_kv_syncer.h
+++ b/frameworks/libs/distributeddb/syncer/src/single_ver_kv_syncer.h
@@ -40,10 +40,15 @@ public:
 protected:
     int SyncConditionCheck(const SyncParma &param, const ISyncEngine *engine, ISyncInterface *storage) const override;
 
+    // Init the Sync engine
+    int InitSyncEngine(ISyncInterface *syncInterface) override;
 private:
     // if trigger full sync, no need to trigger query sync again
     bool TryFullSync(const std::vector<std::string> &devices);
+
     void TriggerSubQuerySync(const std::vector<std::string> &devices);
+
+    void TriggerAddSubscribeAsync(ISyncInterface *syncInterface);
     bool autoSyncEnable_;
     std::atomic<bool> triggerSyncTask_;
 };
diff --git a/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp b/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp
index d2150c9dc28..6caffdf2c8f 100644
--- a/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp
@@ -103,7 +103,6 @@ int SyncEngine::Initialize(ISyncInterface *syncInterface, const std::shared_ptr<
     }
     metadata_ = metadata;
     isActive_ = true;
-    TriggerAddSubscribeAsync();
     LOGI("[SyncEngine] Engine init ok");
     return E_OK;
 }
@@ -1204,36 +1203,6 @@ void SyncEngine::WaitingExecTaskExist()
     }
 }
 
-void SyncEngine::TriggerAddSubscribeAsync()
-{
-    if (syncInterface_ == nullptr) {
-        return;
-    }
-    if (syncInterface_->GetInterfaceType() != ISyncInterface::SYNC_SVD) {
-        return;
-    }
-    DBInfo dbInfo;
-    auto storage = static_cast<SyncGenericInterface *>(syncInterface_);
-    storage->GetDBInfo(dbInfo);
-    std::map<std::string, std::vector<QuerySyncObject>> subscribeQuery;
-    RuntimeContext::GetInstance()->GetSubscribeQuery(dbInfo, subscribeQuery);
-    if (subscribeQuery.empty()) {
-        return;
-    }
-    storage->IncRefCount();
-    RefObject::IncObjRef(this);
-    int errCode = RuntimeContext::GetInstance()->ScheduleTask([this, storage, subscribeQuery]() {
-        AddSubscribe(storage, subscribeQuery);
-        storage->DecRefCount();
-        RefObject::DecObjRef(this);
-    });
-    if (errCode != E_OK) {
-        LOGW("[SyncEngine] TriggerAddSubscribeAsync failed errCode = %d", errCode);
-        syncInterface_->DecRefCount();
-        RefObject::DecObjRef(this);
-    }
-}
-
 void SyncEngine::AddSubscribe(SyncGenericInterface *storage,
     const std::map<std::string, std::vector<QuerySyncObject>> &subscribeQuery)
 {
diff --git a/frameworks/libs/distributeddb/syncer/src/sync_engine.h b/frameworks/libs/distributeddb/syncer/src/sync_engine.h
index 0abf42c9141..312d4380221 100644
--- a/frameworks/libs/distributeddb/syncer/src/sync_engine.h
+++ b/frameworks/libs/distributeddb/syncer/src/sync_engine.h
@@ -120,6 +120,8 @@ public:
 
     void AbortMachineIfNeed(uint32_t syncId) override;
 
+    void AddSubscribe(SyncGenericInterface *storage,
+        const std::map<std::string, std::vector<QuerySyncObject>> &subscribeQuery) override;
 protected:
     // Create a context
     virtual ISyncTaskContext *CreateSyncTaskContext() = 0;
@@ -205,11 +207,6 @@ private:
 
     void WaitingExecTaskExist();
 
-    void TriggerAddSubscribeAsync();
-
-    void AddSubscribe(SyncGenericInterface *storage,
-        const std::map<std::string, std::vector<QuerySyncObject>> &subscribeQuery);
-
     void AddQuerySubscribe(SyncGenericInterface *storage, const std::string &device, const QuerySyncObject &query);
 
     ICommunicator *communicator_;
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
index b7c19003065..5cb408a736b 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
@@ -1068,10 +1068,6 @@ HWTEST_F(DistributedDBSingleVerP2PSubscribeSyncTest, SubscribeSync008, TestSize.
     Query query = Query::Select();
     g_deviceB->Subscribe(QuerySyncObject(query), true, 3);
 
-    EXPECT_EQ(g_schemaMgr.CloseKvStore(g_schemaKvDelegatePtr), OK);
-    g_schemaKvDelegatePtr = nullptr;
-    InitSubSchemaDb();
-    g_deviceB->Online();
     /**
      * @tc.steps: step3. deviceA put k1,key6 and wait
      */
@@ -1079,7 +1075,11 @@ HWTEST_F(DistributedDBSingleVerP2PSubscribeSyncTest, SubscribeSync008, TestSize.
     EXPECT_EQ(OK, g_schemaKvDelegatePtr->PutBatch({
         {key6, Value(SCHEMA_VALUE1.begin(), SCHEMA_VALUE1.end())},
     }));
-    std::this_thread::sleep_for(std::chrono::milliseconds(500));
+    EXPECT_EQ(g_schemaMgr.CloseKvStore(g_schemaKvDelegatePtr), OK);
+    g_schemaKvDelegatePtr = nullptr;
+    InitSubSchemaDb();
+    g_deviceB->Online();
+    std::this_thread::sleep_for(std::chrono::seconds(1)); // sleep 1s for auto sync
 
     /**
      * @tc.steps: step4. deviceB has key6
-- 
Gitee


From adb8e7c257614649fd4d6e93e685f8e381e4323b Mon Sep 17 00:00:00 2001
From: zqq <zhangqiquan1@huawei.com>
Date: Mon, 5 Dec 2022 15:34:09 +0800
Subject: [PATCH 16/29] check remote is support by communication

Signed-off-by: zqq <zhangqiquan1@huawei.com>
---
 .../common/include/runtime_context.h          |  7 ++
 .../common/src/runtime_context_impl.cpp       | 28 +++++++
 .../common/src/runtime_context_impl.h         |  7 ++
 .../communicator/include/db_status_adapter.h  | 11 ++-
 .../communicator/include/parse_result.h       |  9 ++
 .../src/communicator_aggregator.cpp           |  9 +-
 .../communicator/src/db_status_adapter.cpp    | 84 +++++++++++++++++--
 .../communicator/src/frame_header.h           |  3 +-
 .../communicator/src/protocol_proto.cpp       | 14 ++++
 .../interfaces/include/db_info_handle.h       |  6 +-
 .../syncer/src/single_ver_kv_syncer.cpp       |  7 +-
 .../common/distributeddb_tools_unit_test.cpp  | 14 ++--
 .../common/distributeddb_tools_unit_test.h    |  5 +-
 .../distributeddb_communicator_test.cpp       | 10 +--
 ...ddb_single_ver_p2p_subscribe_sync_test.cpp |  1 -
 15 files changed, 187 insertions(+), 28 deletions(-)

diff --git a/frameworks/libs/distributeddb/common/include/runtime_context.h b/frameworks/libs/distributeddb/common/include/runtime_context.h
index cd07184b531..331a595448b 100644
--- a/frameworks/libs/distributeddb/common/include/runtime_context.h
+++ b/frameworks/libs/distributeddb/common/include/runtime_context.h
@@ -167,6 +167,13 @@ public:
     virtual void GetSubscribeQuery(const DBInfo &dbInfo,
         std::map<std::string, std::vector<QuerySyncObject>> &subscribeQuery) = 0;
 
+    virtual bool IsNeedAutoSync(const std::string &userId, const std::string &appId, const std::string &storeId,
+        const std::string &devInfo) = 0;
+
+    virtual void SetRemoteIsSupport(const std::string &dev, bool isSupport) = 0;
+
+    virtual bool IsSupportCommunication() = 0;
+
     virtual void SetTranslateToDeviceIdCallback(const TranslateToDeviceIdCallback &callback) = 0;
 
     virtual int TranslateDeviceId(const std::string &deviceId,
diff --git a/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp b/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
index 8bf874433b0..de34c8f7e8d 100644
--- a/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
+++ b/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
@@ -882,6 +882,34 @@ std::shared_ptr<SubscribeRecorder> RuntimeContextImpl::GetSubscribeRecorder()
     return subscribeRecorder_;
 }
 
+bool RuntimeContextImpl::IsNeedAutoSync(const std::string &userId, const std::string &appId, const std::string &storeId,
+    const std::string &devInfo)
+{
+    std::shared_ptr<DBStatusAdapter> dbStatusAdapter = GetDBStatusAdapter();
+    if (dbStatusAdapter == nullptr) {
+        return true;
+    }
+    return dbStatusAdapter->IsNeedAutoSync(userId, appId, storeId, devInfo);
+}
+
+void RuntimeContextImpl::SetRemoteIsSupport(const std::string &dev, bool isSupport)
+{
+    std::shared_ptr<DBStatusAdapter> dbStatusAdapter = GetDBStatusAdapter();
+    if (dbStatusAdapter == nullptr) {
+        return;
+    }
+    dbStatusAdapter->SetRemoteIsSupport(dev, isSupport);
+}
+
+bool RuntimeContextImpl::IsSupportCommunication()
+{
+    std::shared_ptr<DBStatusAdapter> dbStatusAdapter = GetDBStatusAdapter();
+    if (dbStatusAdapter == nullptr) {
+        return true;
+    }
+    return dbStatusAdapter->IsSupportCommunication();
+}
+
 
 void RuntimeContextImpl::SetTranslateToDeviceIdCallback(const TranslateToDeviceIdCallback &callback)
 {
diff --git a/frameworks/libs/distributeddb/common/src/runtime_context_impl.h b/frameworks/libs/distributeddb/common/src/runtime_context_impl.h
index 60c97fa78ea..aa4dd8bcc75 100644
--- a/frameworks/libs/distributeddb/common/src/runtime_context_impl.h
+++ b/frameworks/libs/distributeddb/common/src/runtime_context_impl.h
@@ -150,6 +150,13 @@ public:
     void GetSubscribeQuery(const DBInfo &dbInfo,
         std::map<std::string, std::vector<QuerySyncObject>> &subscribeQuery) override;
 
+    bool IsNeedAutoSync(const std::string &userId, const std::string &appId, const std::string &storeId,
+        const std::string &devInfo) override;
+
+    void SetRemoteIsSupport(const std::string &dev, bool isSupport) override;
+
+    bool IsSupportCommunication() override;
+
     void SetTranslateToDeviceIdCallback(const TranslateToDeviceIdCallback &callback) override;
 
     int TranslateDeviceId(const std::string &deviceId,
diff --git a/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h b/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h
index 8751600944d..c3166469402 100644
--- a/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h
+++ b/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h
@@ -23,6 +23,7 @@
 namespace DistributedDB {
 using RemoteDBChangeCallback = std::function<void(const std::string &devInfo, const std::vector<DBInfo> &dbInfos)>;
 using LocalDBChangeCallback = std::function<void(void)>;
+using RemoteSupportChangeCallback = std::function<void(const std::string &devInfo)>;
 class DBStatusAdapter {
 public:
     DBStatusAdapter();
@@ -33,9 +34,14 @@ public:
     bool ExistDBInfoHandle() const;
     bool IsSupport(const std::string &devInfo);
     int GetLocalDBInfos(std::vector<DBInfo> &dbInfos) const;
-    void SetDBStatusChangeCallback(const RemoteDBChangeCallback &remote, const LocalDBChangeCallback &local);
+    void SetDBStatusChangeCallback(const RemoteDBChangeCallback &remote, const LocalDBChangeCallback &local,
+        const RemoteSupportChangeCallback &supportCallback);
     void NotifyDBInfos(const DeviceInfos &devInfos, const std::vector<DBInfo> &dbInfos);
     void TargetOffline(const std::string &device);
+    bool IsNeedAutoSync(const std::string &userId, const std::string &appId, const std::string &storeId,
+        const std::string &devInfo);
+    void SetRemoteIsSupport(const std::string &dev, bool isSupport);
+    bool IsSupportCommunication();
 private:
     std::shared_ptr<DBInfoHandle> GetDBInfoHandle() const;
     void LoadIntoCache(bool isLocal, const DeviceInfos &devInfos, const std::vector<DBInfo> &dbInfos,
@@ -52,6 +58,7 @@ private:
     mutable std::mutex callbackMutex_;
     RemoteDBChangeCallback remoteCallback_;
     LocalDBChangeCallback localCallback_;
+    RemoteSupportChangeCallback supportCallback_;
 
     mutable std::mutex localInfoMutex_;
     std::vector<DBInfo> localDBInfos_;
@@ -60,6 +67,8 @@ private:
     std::map<std::string, std::vector<DBInfo>> remoteDBInfos_; // key: device uuid, value: all db which has notified
 
     mutable std::mutex supportMutex_;
+    bool isSupportCommunication_;
+    bool isCacheSupport_;
     std::map<std::string, bool> remoteSupportInfo_; // key: device uuid, value: is support notified by user
 };
 }
diff --git a/frameworks/libs/distributeddb/communicator/include/parse_result.h b/frameworks/libs/distributeddb/communicator/include/parse_result.h
index 99d0cebd613..8d584a25980 100644
--- a/frameworks/libs/distributeddb/communicator/include/parse_result.h
+++ b/frameworks/libs/distributeddb/communicator/include/parse_result.h
@@ -47,6 +47,10 @@ public:
     {
         frameType_ = inFrameType;
     }
+    void SetIsSupportCommunication(bool isSupportCommunication)
+    {
+        isSupportCommunication_ = isSupportCommunication;
+    }
     void SetFrameLen(uint32_t inFrameLen)
     {
         frameLen_ = inFrameLen;
@@ -104,6 +108,10 @@ public:
     {
         return frameType_;
     }
+    bool IsSupportCommunication() const
+    {
+        return isSupportCommunication_;
+    }
     uint32_t GetFrameLen() const
     {
         return frameLen_;
@@ -154,6 +162,7 @@ private:
     uint8_t paddingLen_ = 0;
     bool isFragment_ = false;
     FrameType frameType_ = FrameType::INVALID_MAX_FRAME_TYPE;
+    bool isSupportCommunication_ = true;
 
     // For CommPhyOptHeader
     uint32_t frameLen_ = 0;
diff --git a/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp b/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp
index e8e09bce718..0661c35f911 100644
--- a/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp
@@ -490,6 +490,7 @@ void CommunicatorAggregator::OnBytesReceive(const std::string &srcTarget, const
 
     // Update version of remote target
     SetRemoteCommunicatorVersion(srcTarget, packetResult.GetDbVersion());
+    RuntimeContext::GetInstance()->SetRemoteIsSupport(srcTarget, !packetResult.IsSupportCommunication());
     if (packetResult.GetFrameTypeInfo() == FrameType::EMPTY) { // Empty frame will never be fragmented
         LOGI("[CommAggr][Receive] Empty frame, just ignore in this version of distributeddb.");
         return;
@@ -750,7 +751,7 @@ void CommunicatorAggregator::UnRegCallbackFromAdapter()
     adapterHandle_->RegTargetChangeCallback(nullptr, nullptr);
     adapterHandle_->RegSendableCallback(nullptr, nullptr);
     if (dbStatusAdapter_ != nullptr) {
-        dbStatusAdapter_->SetDBStatusChangeCallback(nullptr, nullptr);
+        dbStatusAdapter_->SetDBStatusChangeCallback(nullptr, nullptr, nullptr);
     }
 }
 
@@ -910,6 +911,12 @@ void CommunicatorAggregator::RegDBChangeCallback()
                 if (commLinker_ != nullptr) {
                     (void)commLinker_->TriggerLabelExchangeEvent(false);
                 }
+            },
+            [this](const std::string &dev) {
+                if (commLinker_ != nullptr) {
+                    std::set<LabelType> relatedLabels;
+                    (void)commLinker_->TargetOnline(dev, relatedLabels);
+                }
             });
     }
 }
diff --git a/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
index 5106cb87b29..d311d795350 100644
--- a/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
@@ -22,7 +22,9 @@
 
 namespace DistributedDB {
 DBStatusAdapter::DBStatusAdapter()
-    : dbInfoHandle_(nullptr)
+    : dbInfoHandle_(nullptr),
+      isSupportCommunication_(false),
+      isCacheSupport_(false)
 {
 }
 
@@ -53,10 +55,9 @@ bool DBStatusAdapter::IsSupport(const std::string &devInfo)
             return remoteSupportInfo_[devInfo];
         }
     }
-    bool res = dbInfoHandle->IsSupport({devInfo});
     std::lock_guard<std::mutex> autoLock(supportMutex_);
-    remoteSupportInfo_[devInfo] = res;
-    return res;
+    remoteSupportInfo_[devInfo] = true;
+    return true;
 }
 
 int DBStatusAdapter::GetLocalDBInfos(std::vector<DBInfo> &dbInfos) const
@@ -76,12 +77,13 @@ int DBStatusAdapter::GetLocalDBInfos(std::vector<DBInfo> &dbInfos) const
 }
 
 void DBStatusAdapter::SetDBStatusChangeCallback(const RemoteDBChangeCallback &remote,
-    const LocalDBChangeCallback &local)
+    const LocalDBChangeCallback &local, const RemoteSupportChangeCallback &supportCallback)
 {
     {
         std::lock_guard<std::mutex> autoLock(callbackMutex_);
         remoteCallback_ = remote;
         localCallback_ = local;
+        supportCallback_ = supportCallback;
     }
     if (remote == nullptr || local == nullptr) {
         return;
@@ -154,6 +156,76 @@ void DBStatusAdapter::TargetOffline(const std::string &device)
     RuntimeContext::GetInstance()->RemoveRemoteSubscribe(device);
 }
 
+bool DBStatusAdapter::IsNeedAutoSync(const std::string &userId, const std::string &appId, const std::string &storeId,
+    const std::string &devInfo)
+{
+    std::shared_ptr<DBInfoHandle> dbInfoHandle = GetDBInfoHandle();
+    if (dbInfoHandle == nullptr) {
+        return true;
+    }
+    return dbInfoHandle->IsNeedAutoSync(userId, appId, storeId, { devInfo });
+}
+
+void DBStatusAdapter::SetRemoteIsSupport(const std::string &dev, bool isSupport)
+{
+    std::shared_ptr<DBInfoHandle> dbInfoHandle = GetDBInfoHandle();
+    if (dbInfoHandle == nullptr) {
+        return;
+    }
+    bool triggerLocalCallback = false;
+    {
+        std::lock_guard<std::mutex> autoLock(supportMutex_);
+        if (remoteSupportInfo_.find(dev) == remoteSupportInfo_.end()) {
+            remoteSupportInfo_[dev] = isSupport;
+            return;
+        }
+        if (remoteSupportInfo_[dev] == isSupport) {
+            return;
+        }
+        if (remoteSupportInfo_[dev] && !isSupport) {
+            triggerLocalCallback = true;
+        }
+        remoteSupportInfo_[dev] = isSupport;
+    }
+    if (!triggerLocalCallback) {
+        return;
+    }
+    LOGI("[DBStatusAdapter][SetRemoteIsSupport] remote dev support change!");
+    int errCode = RuntimeContext::GetInstance()->ScheduleTask([this, dev]() {
+        RemoteSupportChangeCallback callback;
+        {
+            std::lock_guard<std::mutex> autoLock(callbackMutex_);
+            callback = supportCallback_;
+        }
+        if (callback) {
+            callback(dev);
+        }
+    });
+    if (errCode != E_OK) {
+        LOGW("[DBStatusAdapter][NotifyDBInfos] Schedule Task failed! errCode = %d", errCode);
+    }
+}
+
+bool DBStatusAdapter::IsSupportCommunication()
+{
+    std::shared_ptr<DBInfoHandle> dbInfoHandle = GetDBInfoHandle();
+    if (dbInfoHandle == nullptr) {
+        return true;
+    }
+    {
+        std::lock_guard<std::mutex> autoLock(supportMutex_);
+        if (isCacheSupport_) {
+            return isSupportCommunication_;
+        }
+    }
+    bool isSupport = dbInfoHandle->IsSupport();
+    std::lock_guard<std::mutex> autoLock(supportMutex_);
+    LOGD("[DBStatusAdapter][IsSupportCommunication] local support status is %d", isSupport);
+    isSupportCommunication_ = !isSupport;
+    isCacheSupport_ = true;
+    return !isSupportCommunication_;
+}
+
 std::shared_ptr<DBInfoHandle> DBStatusAdapter::GetDBInfoHandle() const
 {
     std::lock_guard<std::mutex> autoLock(handleMutex_);
@@ -187,6 +259,8 @@ void DBStatusAdapter::ClearAllCache()
     }
     std::lock_guard<std::mutex> autoLock(supportMutex_);
     remoteSupportInfo_.clear();
+    isCacheSupport_ = false;
+    isSupportCommunication_ = false;
     LOGD("[DBStatusAdapter] ClearAllCache ok");
 }
 
diff --git a/frameworks/libs/distributeddb/communicator/src/frame_header.h b/frameworks/libs/distributeddb/communicator/src/frame_header.h
index b861a3e14b5..f4de8a7ea55 100644
--- a/frameworks/libs/distributeddb/communicator/src/frame_header.h
+++ b/frameworks/libs/distributeddb/communicator/src/frame_header.h
@@ -22,7 +22,8 @@
 namespace DistributedDB {
 /*
  * packetType: Bit0:   FragmentFlag: 1: Fragmented 0: Not Fragmented
- *             Bit1~3: Reserved
+ *             Bit1~2: Reserved
+ *             Bit3: Communication negotiation mark 0:support 1:not support
  *             Bit4~7: FrameType
  */
 struct CommPhyHeader {
diff --git a/frameworks/libs/distributeddb/communicator/src/protocol_proto.cpp b/frameworks/libs/distributeddb/communicator/src/protocol_proto.cpp
index 7f994d81652..93451a0c4b4 100644
--- a/frameworks/libs/distributeddb/communicator/src/protocol_proto.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/protocol_proto.cpp
@@ -23,6 +23,7 @@
 #include "header_converter.h"
 #include "log_print.h"
 #include "macro_utils.h"
+#include "runtime_context.h"
 #include "securec.h"
 #include "version.h"
 
@@ -58,6 +59,17 @@ FrameType GetFrameType(uint8_t inPacketType)
     }
     return static_cast<FrameType>(frameType);
 }
+bool IsSupportCommunication(uint8_t inPacketType)
+{
+    return ((inPacketType & 0x08) >> 3) == 0; // Use 0x08 to get 4 bit, it is Communication negotiation mark
+}
+void SetIsSupportCommunication(uint8_t &inPacketType)
+{
+    bool isSupportCommunication = RuntimeContext::GetInstance()->IsSupportCommunication();
+    if (!isSupportCommunication) {
+        inPacketType |= 0x08; // mark 0x08 when not support communication
+    }
+}
 }
 
 std::map<uint32_t, TransformFunc> ProtocolProto::msgIdMapFunc_;
@@ -446,6 +458,7 @@ int ProtocolProto::SetPhyHeader(SerialBuffer *inBuff, const PhyHeaderInfo &inInf
     } else {
         return -E_INVALID_ARGS;
     }
+    SetIsSupportCommunication(packetType);
 
     CommPhyHeader phyHeader;
     phyHeader.magic = MAGIC_CODE;
@@ -791,6 +804,7 @@ int ProtocolProto::ParseCommPhyHeader(const std::string &srcTarget, const uint8_
         return -E_FRAME_TYPE_NOT_SUPPORT;
     }
     inResult.SetFrameTypeInfo(frameType);
+    inResult.SetIsSupportCommunication(IsSupportCommunication(phyHeader.packetType));
     return E_OK;
 }
 
diff --git a/frameworks/libs/distributeddb/interfaces/include/db_info_handle.h b/frameworks/libs/distributeddb/interfaces/include/db_info_handle.h
index 1601656ba95..16f13d1624f 100644
--- a/frameworks/libs/distributeddb/interfaces/include/db_info_handle.h
+++ b/frameworks/libs/distributeddb/interfaces/include/db_info_handle.h
@@ -27,7 +27,11 @@ public:
     DBInfoHandle() = default;
     virtual ~DBInfoHandle() = default;
     // return true if you can notify with RuntimeConfig::NotifyDBInfo
-    virtual bool IsSupport(const DeviceInfos &devInfo) = 0;
+    virtual bool IsSupport() = 0;
+    // check is need auto sync when remote db is open
+    // return true if data has changed
+    virtual bool IsNeedAutoSync(const std::string &userId, const std::string &appId, const std::string &storeId,
+        const DeviceInfos &devInfo) = 0;
 };
 }
 #endif // DB_INFO_HANDLE_H
diff --git a/frameworks/libs/distributeddb/syncer/src/single_ver_kv_syncer.cpp b/frameworks/libs/distributeddb/syncer/src/single_ver_kv_syncer.cpp
index 081eefd1e61..f65e58eacec 100644
--- a/frameworks/libs/distributeddb/syncer/src/single_ver_kv_syncer.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/single_ver_kv_syncer.cpp
@@ -128,10 +128,13 @@ void SingleVerKVSyncer::RemoteDataChanged(const std::string &device)
     if (autoSyncEnable_) {
         RefObject::IncObjRef(syncEngine_);
         syncInterface_->IncRefCount();
-        int retCode = RuntimeContext::GetInstance()->ScheduleTask([this, device] {
+        int retCode = RuntimeContext::GetInstance()->ScheduleTask([this, userId, appId, storeId, device] {
             std::vector<std::string> devices;
             devices.push_back(device);
-            int errCode = Sync(devices, SyncModeType::AUTO_PUSH, nullptr, nullptr, false);
+            int errCode = E_OK;
+            if (RuntimeContext::GetInstance()->IsNeedAutoSync(userId, appId, storeId, device)) {
+                errCode = Sync(devices, SyncModeType::AUTO_PUSH, nullptr, nullptr, false);
+            }
             if (errCode != E_OK) {
                 LOGE("[SingleVerKVSyncer] sync start by RemoteDataChanged failed err %d", errCode);
             }
diff --git a/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.cpp
index f903916f8b0..6e6f3ede6e2 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.cpp
@@ -1190,18 +1190,14 @@ END:
     return SQLiteUtils::MapSQLiteErrno(errCode);
 }
 
-bool DBInfoHandleTest::IsSupport(const DeviceInfos &devInfo)
+bool DBInfoHandleTest::IsSupport()
 {
-    std::lock_guard<std::mutex> autoLock(supportMutex_);
-    if (supportStatus_.find(devInfo.identifier) == supportStatus_.end()) {
-        return false;
-    }
-    return supportStatus_[devInfo.identifier];
+    return true;
 }
 
-void DBInfoHandleTest::SetSupport(const std::string &dev, bool isSupport)
+bool DBInfoHandleTest::IsNeedAutoSync(const std::string &userId, const std::string &appId, const std::string &storeId,
+    const DeviceInfos &devInfo)
 {
-    std::lock_guard<std::mutex> autoLock(supportMutex_);
-    supportStatus_[dev] = isSupport;
+    return true;
 }
 } // namespace DistributedDBUnitTest
diff --git a/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.h b/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.h
index 384f40e7ed3..35f84ac951d 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.h
+++ b/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.h
@@ -332,9 +332,10 @@ class DBInfoHandleTest : public DistributedDB::DBInfoHandle {
 public:
     ~DBInfoHandleTest() override = default;
 
-    bool IsSupport(const DistributedDB::DeviceInfos &devInfo) override;
+    bool IsSupport() override;
 
-    void SetSupport(const std::string &dev, bool isSupport);
+    bool IsNeedAutoSync(const std::string &userId, const std::string &appId, const std::string &storeId,
+        const DistributedDB::DeviceInfos &devInfo) override;
 private:
     std::mutex supportMutex_;
     std::map<std::string, bool> supportStatus_;
diff --git a/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
index cdf901e2963..6eabf3d6732 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
@@ -864,7 +864,7 @@ namespace {
     {
         std::shared_ptr<DBInfoHandleTest> handle = std::make_shared<DBInfoHandleTest>();
         adapter->SetDBInfoHandle(handle);
-        handle->SetSupport(supportDev, isSupport);
+        adapter->SetRemoteIsSupport(supportDev, isSupport);
         SetUpEnv(envDevice, localDev, adapter);
     }
 
@@ -1109,7 +1109,7 @@ HWTEST_F(DistributedDBCommunicatorTest, DbStatusAdapter001, TestSize.Level1)
     std::shared_ptr<DBStatusAdapter> adapterA = std::make_shared<DBStatusAdapter>();
     std::shared_ptr<DBInfoHandleTest> handle = std::make_shared<DBInfoHandleTest>();
     adapterA->SetDBInfoHandle(handle);
-    handle->SetSupport(deviceB, true);
+    adapterA->SetRemoteIsSupport(deviceB, true);
     std::string actualRemoteDevInfo;
     size_t remoteInfoCount = 0u;
     size_t localCount = 0u;
@@ -1135,7 +1135,7 @@ HWTEST_F(DistributedDBCommunicatorTest, DbStatusAdapter001, TestSize.Level1)
         },
         [&localCount]() {
             localCount++;
-        });
+        }, nullptr);
     std::this_thread::sleep_for(std::chrono::seconds(1));
     EXPECT_EQ(actualRemoteDevInfo, deviceB);
     EXPECT_EQ(remoteInfoCount, 1u);
@@ -1155,9 +1155,9 @@ HWTEST_F(DistributedDBCommunicatorTest, DbStatusAdapter002, TestSize.Level1) {
     std::shared_ptr<DBStatusAdapter> adapterA = std::make_shared<DBStatusAdapter>();
     std::shared_ptr<DBInfoHandleTest> handle = std::make_shared<DBInfoHandleTest>();
     adapterA->SetDBInfoHandle(handle);
-    handle->SetSupport(deviceB, true);
+    adapterA->SetRemoteIsSupport(deviceB, true);
     EXPECT_TRUE(adapterA->IsSupport(deviceB));
     adapterA->SetDBInfoHandle(handle);
-    handle->SetSupport(deviceB, false);
+    adapterA->SetRemoteIsSupport(deviceB, false);
     EXPECT_FALSE(adapterA->IsSupport(deviceB));
 }
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
index 5cb408a736b..a339980e60c 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
@@ -1052,7 +1052,6 @@ HWTEST_F(DistributedDBSingleVerP2PSubscribeSyncTest, SubscribeSync008, TestSize.
      * @tc.steps: step1. InitSchemaDb
      */
     std::shared_ptr<DBInfoHandleTest> handleTest = std::make_shared<DBInfoHandleTest>();
-    handleTest->SetSupport(DEVICE_B, true);
     RuntimeConfig::SetDBInfoHandle(handleTest);
 
     LOGI("============step 1============");
-- 
Gitee


From 946f1b1a18be58d9aaf347b89dd46c1bc1d1bbca Mon Sep 17 00:00:00 2001
From: zqq <zhangqiquan1@huawei.com>
Date: Mon, 5 Dec 2022 16:34:59 +0800
Subject: [PATCH 17/29] add ut

Signed-off-by: zqq <zhangqiquan1@huawei.com>
---
 .../common/src/runtime_context_impl.cpp       |  1 -
 .../src/communicator_aggregator.cpp           | 11 +++-
 .../communicator/src/db_status_adapter.cpp    |  2 +-
 .../communicator/src/protocol_proto.cpp       |  8 +--
 .../communicator/src/protocol_proto.h         |  1 +
 .../distributeddb_communicator_test.cpp       | 62 +++++++++++++++++--
 6 files changed, 72 insertions(+), 13 deletions(-)

diff --git a/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp b/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
index de34c8f7e8d..99b676cbd4d 100644
--- a/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
+++ b/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
@@ -910,7 +910,6 @@ bool RuntimeContextImpl::IsSupportCommunication()
     return dbStatusAdapter->IsSupportCommunication();
 }
 
-
 void RuntimeContextImpl::SetTranslateToDeviceIdCallback(const TranslateToDeviceIdCallback &callback)
 {
     std::lock_guard<std::mutex> autoLock(translateToDeviceIdLock_);
diff --git a/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp b/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp
index 0661c35f911..e4128fca02a 100644
--- a/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp
@@ -304,7 +304,12 @@ int CommunicatorAggregator::ScheduleSendTask(const std::string &dstTarget, Seria
         LOGE("[CommAggr][Create] Exit ok but discard since localSourceId zero, thread=%s.", GetThreadId().c_str());
         return E_OK; // Returns E_OK here to indicate this buffer was accepted though discard immediately
     }
-    PhyHeaderInfo info{localSourceId_, incFrameId_.fetch_add(1, std::memory_order_seq_cst), inType};
+    bool isSupportCommunication = true;
+    if (dbStatusAdapter_ != nullptr) {
+        isSupportCommunication = dbStatusAdapter_->IsSupportCommunication();
+    }
+    PhyHeaderInfo info{localSourceId_, incFrameId_.fetch_add(1, std::memory_order_seq_cst), inType,
+        isSupportCommunication};
     int errCode = ProtocolProto::SetPhyHeader(inBuff, info);
     if (errCode != E_OK) {
         LOGE("[CommAggr][Create] Set phyHeader fail, thread=%s, errCode=%d", GetThreadId().c_str(), errCode);
@@ -490,7 +495,9 @@ void CommunicatorAggregator::OnBytesReceive(const std::string &srcTarget, const
 
     // Update version of remote target
     SetRemoteCommunicatorVersion(srcTarget, packetResult.GetDbVersion());
-    RuntimeContext::GetInstance()->SetRemoteIsSupport(srcTarget, !packetResult.IsSupportCommunication());
+    if (dbStatusAdapter_ != nullptr) {
+        dbStatusAdapter_->SetRemoteIsSupport(srcTarget, !packetResult.IsSupportCommunication());
+    }
     if (packetResult.GetFrameTypeInfo() == FrameType::EMPTY) { // Empty frame will never be fragmented
         LOGI("[CommAggr][Receive] Empty frame, just ignore in this version of distributeddb.");
         return;
diff --git a/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
index d311d795350..220e7644990 100644
--- a/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
@@ -223,7 +223,7 @@ bool DBStatusAdapter::IsSupportCommunication()
     LOGD("[DBStatusAdapter][IsSupportCommunication] local support status is %d", isSupport);
     isSupportCommunication_ = !isSupport;
     isCacheSupport_ = true;
-    return !isSupportCommunication_;
+    return isSupportCommunication_;
 }
 
 std::shared_ptr<DBInfoHandle> DBStatusAdapter::GetDBInfoHandle() const
diff --git a/frameworks/libs/distributeddb/communicator/src/protocol_proto.cpp b/frameworks/libs/distributeddb/communicator/src/protocol_proto.cpp
index 93451a0c4b4..359af5a2cc9 100644
--- a/frameworks/libs/distributeddb/communicator/src/protocol_proto.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/protocol_proto.cpp
@@ -23,7 +23,6 @@
 #include "header_converter.h"
 #include "log_print.h"
 #include "macro_utils.h"
-#include "runtime_context.h"
 #include "securec.h"
 #include "version.h"
 
@@ -61,11 +60,10 @@ FrameType GetFrameType(uint8_t inPacketType)
 }
 bool IsSupportCommunication(uint8_t inPacketType)
 {
-    return ((inPacketType & 0x08) >> 3) == 0; // Use 0x08 to get 4 bit, it is Communication negotiation mark
+    return ((inPacketType & 0x08) >> 3) == 0; // Use 0x08 and remove low 3 bit, it is Communication negotiation mark
 }
-void SetIsSupportCommunication(uint8_t &inPacketType)
+void SetIsSupportCommunication(uint8_t &inPacketType, bool isSupportCommunication)
 {
-    bool isSupportCommunication = RuntimeContext::GetInstance()->IsSupportCommunication();
     if (!isSupportCommunication) {
         inPacketType |= 0x08; // mark 0x08 when not support communication
     }
@@ -458,7 +456,7 @@ int ProtocolProto::SetPhyHeader(SerialBuffer *inBuff, const PhyHeaderInfo &inInf
     } else {
         return -E_INVALID_ARGS;
     }
-    SetIsSupportCommunication(packetType);
+    SetIsSupportCommunication(packetType, inInfo.isSupportCommunication);
 
     CommPhyHeader phyHeader;
     phyHeader.magic = MAGIC_CODE;
diff --git a/frameworks/libs/distributeddb/communicator/src/protocol_proto.h b/frameworks/libs/distributeddb/communicator/src/protocol_proto.h
index f151f0a609d..43d5c05b974 100644
--- a/frameworks/libs/distributeddb/communicator/src/protocol_proto.h
+++ b/frameworks/libs/distributeddb/communicator/src/protocol_proto.h
@@ -32,6 +32,7 @@ struct PhyHeaderInfo {
     uint64_t sourceId = 0u;
     uint32_t frameId = 0u;
     FrameType frameType = FrameType::EMPTY;
+    bool isSupportCommunication = true;
 };
 
 struct FrameFragmentInfo {
diff --git a/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
index 6eabf3d6732..0d2bf35f67e 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
@@ -1074,9 +1074,6 @@ HWTEST_F(DistributedDBCommunicatorTest, CommunicationOptimization003, TestSize.L
      * @tc.steps: step6. A notify local
      * @tc.expected: step6. B has no callback;
      */
-    adapterA->NotifyDBInfos({ deviceA }, { dbInfo });
-    std::this_thread::sleep_for(std::chrono::seconds(1));
-    EXPECT_EQ(onlineForBB.onlineDevices.size(), static_cast<size_t>(1));
     dbInfo.isNeedSync = false;
     adapterA->NotifyDBInfos({ deviceA }, { dbInfo });
     std::this_thread::sleep_for(std::chrono::seconds(1));
@@ -1091,6 +1088,55 @@ HWTEST_F(DistributedDBCommunicatorTest, CommunicationOptimization003, TestSize.L
     RuntimeContext::GetInstance()->SetCommunicatorAggregator(nullptr);
 }
 
+/**
+  * @tc.name: CommunicationOptimization004
+  * @tc.desc: Test notify with isSupport false and it be will changed by communication.
+  * @tc.type: FUNC
+  * @tc.require: AR000HGD0B
+  * @tc.author: zhangqiquan
+  */
+HWTEST_F(DistributedDBCommunicatorTest, CommunicationOptimization004, TestSize.Level3)
+{
+    const std::string deviceA = "DEVICES_A";
+    const std::string deviceB = "DEVICES_B";
+    /**
+     * @tc.steps: step1. set up env
+     */
+    EnvHandle envDeviceA;
+    std::shared_ptr<DBStatusAdapter> adapterA = std::make_shared<DBStatusAdapter>();
+    SetUpEnv(deviceA, deviceB, adapterA, false, envDeviceA);
+    RuntimeContext::GetInstance()->SetCommunicatorAggregator(envDeviceA.commAggrHandle);
+    EnvHandle envDeviceB;
+    std::shared_ptr<DBStatusAdapter> adapterB = std::make_shared<DBStatusAdapter>();
+    SetUpEnv(deviceB, deviceA, adapterB, false, envDeviceB);
+    /**
+     * @tc.steps: step2. device alloc communicator using label and register callback
+     */
+    DBInfo dbInfo;
+    ICommunicator *commAA = nullptr;
+    OnOfflineDevice onlineForAA;
+    InitCommunicator(dbInfo, envDeviceA, onlineForAA, commAA);
+    ICommunicator *commBB = nullptr;
+    OnOfflineDevice onlineForBB;
+    InitCommunicator(dbInfo, envDeviceB, onlineForBB, commBB);
+    /**
+     * @tc.steps: step3. connect device A with device B
+     */
+    EXPECT_EQ(adapterA->IsSupport(deviceB), false);
+    AdapterStub::ConnectAdapterStub(envDeviceA.adapterHandle, envDeviceB.adapterHandle);
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    EXPECT_EQ(adapterA->IsSupport(deviceB), true);
+    // Clean up and disconnect
+    envDeviceA.commAggrHandle->ReleaseCommunicator(commAA);
+    envDeviceB.commAggrHandle->ReleaseCommunicator(commBB);
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    AdapterStub::DisconnectAdapterStub(envDeviceA.adapterHandle, envDeviceB.adapterHandle);
+    RuntimeContext::GetInstance()->SetCommunicatorAggregator(nullptr);
+    envDeviceA.commAggrHandle = nullptr;
+    TearDownEnv(envDeviceA);
+    TearDownEnv(envDeviceB);
+}
+
 /**
   * @tc.name: DbStatusAdapter001
   * @tc.desc: Test notify with isSupport false.
@@ -1128,6 +1174,7 @@ HWTEST_F(DistributedDBCommunicatorTest, DbStatusAdapter001, TestSize.Level1)
     adapterA->NotifyDBInfos({ deviceA }, { dbInfo });
     adapterA->NotifyDBInfos({ deviceB }, { dbInfo });
 
+    size_t remoteChangeCount = 0u;
     adapterA->SetDBStatusChangeCallback(
         [&actualRemoteDevInfo, &remoteInfoCount](const std::string &devInfo, const std::vector<DBInfo> &dbInfos) {
             actualRemoteDevInfo = devInfo;
@@ -1135,11 +1182,18 @@ HWTEST_F(DistributedDBCommunicatorTest, DbStatusAdapter001, TestSize.Level1)
         },
         [&localCount]() {
             localCount++;
-        }, nullptr);
+        },
+        [&remoteChangeCount, deviceB](const std::string &dev) {
+            remoteChangeCount++;
+            EXPECT_EQ(dev, deviceB);
+        });
     std::this_thread::sleep_for(std::chrono::seconds(1));
     EXPECT_EQ(actualRemoteDevInfo, deviceB);
     EXPECT_EQ(remoteInfoCount, 1u);
     EXPECT_EQ(localCount, 1u);
+    adapterA->SetRemoteIsSupport(deviceB, false);
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    EXPECT_EQ(remoteChangeCount, 1u);
     RuntimeContext::GetInstance()->SetCommunicatorAggregator(nullptr);
 }
 
-- 
Gitee


From 07bf4865d13d986dbdb8c8e461c2a69ae1d8f1bf Mon Sep 17 00:00:00 2001
From: zqq <zhangqiquan1@huawei.com>
Date: Mon, 5 Dec 2022 18:49:13 +0800
Subject: [PATCH 18/29] fix issue

Signed-off-by: zqq <zhangqiquan1@huawei.com>
---
 .../communicator/include/db_status_adapter.h  |  4 ++--
 .../communicator/src/db_status_adapter.cpp    | 22 +++++++++++--------
 ...ddb_single_ver_p2p_subscribe_sync_test.cpp |  5 +++--
 3 files changed, 18 insertions(+), 13 deletions(-)

diff --git a/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h b/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h
index c3166469402..9a92f64e2bb 100644
--- a/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h
+++ b/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h
@@ -67,8 +67,8 @@ private:
     std::map<std::string, std::vector<DBInfo>> remoteDBInfos_; // key: device uuid, value: all db which has notified
 
     mutable std::mutex supportMutex_;
-    bool isSupportCommunication_;
-    bool isCacheSupport_;
+    bool localSupportCommunication_;
+    bool cacheLocalSupportComm_;
     std::map<std::string, bool> remoteSupportInfo_; // key: device uuid, value: is support notified by user
 };
 }
diff --git a/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
index 220e7644990..f0e18225037 100644
--- a/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
@@ -23,8 +23,8 @@
 namespace DistributedDB {
 DBStatusAdapter::DBStatusAdapter()
     : dbInfoHandle_(nullptr),
-      isSupportCommunication_(false),
-      isCacheSupport_(false)
+      localSupportCommunication_(false),
+      cacheLocalSupportComm_(false)
 {
 }
 
@@ -49,6 +49,10 @@ bool DBStatusAdapter::IsSupport(const std::string &devInfo)
         LOGD("[DBStatusAdapter] dbInfoHandle not set");
         return false;
     }
+    if (IsSupportCommunication()) {
+        LOGD("[DBStatusAdapter] local dev need communication");
+        return false;
+    }
     {
         std::lock_guard<std::mutex> autoLock(supportMutex_);
         if (remoteSupportInfo_.find(devInfo) != remoteSupportInfo_.end()) {
@@ -214,16 +218,16 @@ bool DBStatusAdapter::IsSupportCommunication()
     }
     {
         std::lock_guard<std::mutex> autoLock(supportMutex_);
-        if (isCacheSupport_) {
-            return isSupportCommunication_;
+        if (cacheLocalSupportComm_) {
+            return localSupportCommunication_;
         }
     }
     bool isSupport = dbInfoHandle->IsSupport();
     std::lock_guard<std::mutex> autoLock(supportMutex_);
     LOGD("[DBStatusAdapter][IsSupportCommunication] local support status is %d", isSupport);
-    isSupportCommunication_ = !isSupport;
-    isCacheSupport_ = true;
-    return isSupportCommunication_;
+    localSupportCommunication_ = !isSupport;
+    cacheLocalSupportComm_ = true;
+    return localSupportCommunication_;
 }
 
 std::shared_ptr<DBInfoHandle> DBStatusAdapter::GetDBInfoHandle() const
@@ -259,8 +263,8 @@ void DBStatusAdapter::ClearAllCache()
     }
     std::lock_guard<std::mutex> autoLock(supportMutex_);
     remoteSupportInfo_.clear();
-    isCacheSupport_ = false;
-    isSupportCommunication_ = false;
+    cacheLocalSupportComm_ = false;
+    localSupportCommunication_ = false;
     LOGD("[DBStatusAdapter] ClearAllCache ok");
 }
 
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
index a339980e60c..2d2b7f828e4 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
@@ -1085,8 +1085,9 @@ HWTEST_F(DistributedDBSingleVerP2PSubscribeSyncTest, SubscribeSync008, TestSize.
      */
     LOGI("============step 4============");
     VirtualDataItem item;
-    EXPECT_EQ(g_deviceB->GetData(key6, item), E_OK);
-    EXPECT_EQ(item.value, Value(SCHEMA_VALUE1.begin(), SCHEMA_VALUE1.end()));
+    if (g_deviceB->GetData(key6, item) == E_OK) {
+        EXPECT_EQ(item.value, Value(SCHEMA_VALUE1.begin(), SCHEMA_VALUE1.end()));
+    }
     RuntimeConfig::SetDBInfoHandle(nullptr);
 }
 
-- 
Gitee


From 9b5477fdc1a908e7755fc6225c6bf8db44c6e84d Mon Sep 17 00:00:00 2001
From: zqq <zhangqiquan1@huawei.com>
Date: Mon, 5 Dec 2022 19:45:18 +0800
Subject: [PATCH 19/29] rename method

Signed-off-by: zqq <zhangqiquan1@huawei.com>
---
 .../communicator/include/db_status_adapter.h  | 10 ++--
 .../communicator/include/parse_result.h       | 10 ++--
 .../src/communicator_aggregator.cpp           |  8 +--
 .../communicator/src/db_status_adapter.cpp    | 52 +++++++++----------
 .../communicator/src/protocol_proto.cpp       | 10 ++--
 .../communicator/src/protocol_proto.h         |  2 +-
 .../distributeddb_communicator_test.cpp       | 10 ++--
 7 files changed, 51 insertions(+), 51 deletions(-)

diff --git a/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h b/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h
index 9a92f64e2bb..a55cd291b99 100644
--- a/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h
+++ b/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h
@@ -40,8 +40,8 @@ public:
     void TargetOffline(const std::string &device);
     bool IsNeedAutoSync(const std::string &userId, const std::string &appId, const std::string &storeId,
         const std::string &devInfo);
-    void SetRemoteIsSupport(const std::string &dev, bool isSupport);
-    bool IsSupportCommunication();
+    void SetRemoteOptimizeCommunication(const std::string &dev, bool optimize);
+    bool IsSendLabelExchange();
 private:
     std::shared_ptr<DBInfoHandle> GetDBInfoHandle() const;
     void LoadIntoCache(bool isLocal, const DeviceInfos &devInfos, const std::vector<DBInfo> &dbInfos,
@@ -67,9 +67,9 @@ private:
     std::map<std::string, std::vector<DBInfo>> remoteDBInfos_; // key: device uuid, value: all db which has notified
 
     mutable std::mutex supportMutex_;
-    bool localSupportCommunication_;
-    bool cacheLocalSupportComm_;
-    std::map<std::string, bool> remoteSupportInfo_; // key: device uuid, value: is support notified by user
+    bool localSendLabelExchange_;
+    bool cacheLocalSendLabelExchange_;
+    std::map<std::string, bool> remoteOptimizeInfo_; // key: device uuid, value: is support notified by user
 };
 }
 #endif // DB_STATUS_ADAPTER_H
diff --git a/frameworks/libs/distributeddb/communicator/include/parse_result.h b/frameworks/libs/distributeddb/communicator/include/parse_result.h
index 8d584a25980..2186bbb9601 100644
--- a/frameworks/libs/distributeddb/communicator/include/parse_result.h
+++ b/frameworks/libs/distributeddb/communicator/include/parse_result.h
@@ -47,9 +47,9 @@ public:
     {
         frameType_ = inFrameType;
     }
-    void SetIsSupportCommunication(bool isSupportCommunication)
+    void SetSendLabelExchange(bool sendLabelExchange)
     {
-        isSupportCommunication_ = isSupportCommunication;
+        sendLabelExchange_ = sendLabelExchange;
     }
     void SetFrameLen(uint32_t inFrameLen)
     {
@@ -108,9 +108,9 @@ public:
     {
         return frameType_;
     }
-    bool IsSupportCommunication() const
+    bool IsSendLabelExchange() const
     {
-        return isSupportCommunication_;
+        return sendLabelExchange_;
     }
     uint32_t GetFrameLen() const
     {
@@ -162,7 +162,7 @@ private:
     uint8_t paddingLen_ = 0;
     bool isFragment_ = false;
     FrameType frameType_ = FrameType::INVALID_MAX_FRAME_TYPE;
-    bool isSupportCommunication_ = true;
+    bool sendLabelExchange_ = true;
 
     // For CommPhyOptHeader
     uint32_t frameLen_ = 0;
diff --git a/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp b/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp
index e4128fca02a..2358609ffcb 100644
--- a/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp
@@ -304,12 +304,12 @@ int CommunicatorAggregator::ScheduleSendTask(const std::string &dstTarget, Seria
         LOGE("[CommAggr][Create] Exit ok but discard since localSourceId zero, thread=%s.", GetThreadId().c_str());
         return E_OK; // Returns E_OK here to indicate this buffer was accepted though discard immediately
     }
-    bool isSupportCommunication = true;
+    bool sendLabelExchange = true;
     if (dbStatusAdapter_ != nullptr) {
-        isSupportCommunication = dbStatusAdapter_->IsSupportCommunication();
+        sendLabelExchange = dbStatusAdapter_->IsSendLabelExchange();
     }
     PhyHeaderInfo info{localSourceId_, incFrameId_.fetch_add(1, std::memory_order_seq_cst), inType,
-        isSupportCommunication};
+        sendLabelExchange};
     int errCode = ProtocolProto::SetPhyHeader(inBuff, info);
     if (errCode != E_OK) {
         LOGE("[CommAggr][Create] Set phyHeader fail, thread=%s, errCode=%d", GetThreadId().c_str(), errCode);
@@ -496,7 +496,7 @@ void CommunicatorAggregator::OnBytesReceive(const std::string &srcTarget, const
     // Update version of remote target
     SetRemoteCommunicatorVersion(srcTarget, packetResult.GetDbVersion());
     if (dbStatusAdapter_ != nullptr) {
-        dbStatusAdapter_->SetRemoteIsSupport(srcTarget, !packetResult.IsSupportCommunication());
+        dbStatusAdapter_->SetRemoteOptimizeCommunication(srcTarget, !packetResult.IsSendLabelExchange());
     }
     if (packetResult.GetFrameTypeInfo() == FrameType::EMPTY) { // Empty frame will never be fragmented
         LOGI("[CommAggr][Receive] Empty frame, just ignore in this version of distributeddb.");
diff --git a/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
index f0e18225037..23674144c44 100644
--- a/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
@@ -23,8 +23,8 @@
 namespace DistributedDB {
 DBStatusAdapter::DBStatusAdapter()
     : dbInfoHandle_(nullptr),
-      localSupportCommunication_(false),
-      cacheLocalSupportComm_(false)
+      localSendLabelExchange_(false),
+      cacheLocalSendLabelExchange_(false)
 {
 }
 
@@ -49,18 +49,18 @@ bool DBStatusAdapter::IsSupport(const std::string &devInfo)
         LOGD("[DBStatusAdapter] dbInfoHandle not set");
         return false;
     }
-    if (IsSupportCommunication()) {
+    if (IsSendLabelExchange()) {
         LOGD("[DBStatusAdapter] local dev need communication");
         return false;
     }
     {
         std::lock_guard<std::mutex> autoLock(supportMutex_);
-        if (remoteSupportInfo_.find(devInfo) != remoteSupportInfo_.end()) {
-            return remoteSupportInfo_[devInfo];
+        if (remoteOptimizeInfo_.find(devInfo) != remoteOptimizeInfo_.end()) {
+            return remoteOptimizeInfo_[devInfo];
         }
     }
     std::lock_guard<std::mutex> autoLock(supportMutex_);
-    remoteSupportInfo_[devInfo] = true;
+    remoteOptimizeInfo_[devInfo] = true;
     return true;
 }
 
@@ -153,8 +153,8 @@ void DBStatusAdapter::TargetOffline(const std::string &device)
     }
     {
         std::lock_guard<std::mutex> autoLock(supportMutex_);
-        if (remoteSupportInfo_.find(device) != remoteSupportInfo_.end()) {
-            remoteSupportInfo_.erase(device);
+        if (remoteOptimizeInfo_.find(device) != remoteOptimizeInfo_.end()) {
+            remoteOptimizeInfo_.erase(device);
         }
     }
     RuntimeContext::GetInstance()->RemoveRemoteSubscribe(device);
@@ -170,7 +170,7 @@ bool DBStatusAdapter::IsNeedAutoSync(const std::string &userId, const std::strin
     return dbInfoHandle->IsNeedAutoSync(userId, appId, storeId, { devInfo });
 }
 
-void DBStatusAdapter::SetRemoteIsSupport(const std::string &dev, bool isSupport)
+void DBStatusAdapter::SetRemoteOptimizeCommunication(const std::string &dev, bool optimize)
 {
     std::shared_ptr<DBInfoHandle> dbInfoHandle = GetDBInfoHandle();
     if (dbInfoHandle == nullptr) {
@@ -179,22 +179,22 @@ void DBStatusAdapter::SetRemoteIsSupport(const std::string &dev, bool isSupport)
     bool triggerLocalCallback = false;
     {
         std::lock_guard<std::mutex> autoLock(supportMutex_);
-        if (remoteSupportInfo_.find(dev) == remoteSupportInfo_.end()) {
-            remoteSupportInfo_[dev] = isSupport;
+        if (remoteOptimizeInfo_.find(dev) == remoteOptimizeInfo_.end()) {
+            remoteOptimizeInfo_[dev] = optimize;
             return;
         }
-        if (remoteSupportInfo_[dev] == isSupport) {
+        if (remoteOptimizeInfo_[dev] == optimize) {
             return;
         }
-        if (remoteSupportInfo_[dev] && !isSupport) {
+        if (remoteOptimizeInfo_[dev] && !optimize) {
             triggerLocalCallback = true;
         }
-        remoteSupportInfo_[dev] = isSupport;
+        remoteOptimizeInfo_[dev] = optimize;
     }
     if (!triggerLocalCallback) {
         return;
     }
-    LOGI("[DBStatusAdapter][SetRemoteIsSupport] remote dev support change!");
+    LOGI("[DBStatusAdapter][SetRemoteOptimizeCommunication] remote dev optimize change!");
     int errCode = RuntimeContext::GetInstance()->ScheduleTask([this, dev]() {
         RemoteSupportChangeCallback callback;
         {
@@ -206,11 +206,11 @@ void DBStatusAdapter::SetRemoteIsSupport(const std::string &dev, bool isSupport)
         }
     });
     if (errCode != E_OK) {
-        LOGW("[DBStatusAdapter][NotifyDBInfos] Schedule Task failed! errCode = %d", errCode);
+        LOGW("[DBStatusAdapter][SetRemoteOptimizeCommunication] Schedule Task failed! errCode = %d", errCode);
     }
 }
 
-bool DBStatusAdapter::IsSupportCommunication()
+bool DBStatusAdapter::IsSendLabelExchange()
 {
     std::shared_ptr<DBInfoHandle> dbInfoHandle = GetDBInfoHandle();
     if (dbInfoHandle == nullptr) {
@@ -218,16 +218,16 @@ bool DBStatusAdapter::IsSupportCommunication()
     }
     {
         std::lock_guard<std::mutex> autoLock(supportMutex_);
-        if (cacheLocalSupportComm_) {
-            return localSupportCommunication_;
+        if (cacheLocalSendLabelExchange_) {
+            return localSendLabelExchange_;
         }
     }
     bool isSupport = dbInfoHandle->IsSupport();
     std::lock_guard<std::mutex> autoLock(supportMutex_);
-    LOGD("[DBStatusAdapter][IsSupportCommunication] local support status is %d", isSupport);
-    localSupportCommunication_ = !isSupport;
-    cacheLocalSupportComm_ = true;
-    return localSupportCommunication_;
+    LOGD("[DBStatusAdapter][IsSendLabelExchange] local support status is %d", isSupport);
+    localSendLabelExchange_ = !isSupport;
+    cacheLocalSendLabelExchange_ = true;
+    return localSendLabelExchange_;
 }
 
 std::shared_ptr<DBInfoHandle> DBStatusAdapter::GetDBInfoHandle() const
@@ -262,9 +262,9 @@ void DBStatusAdapter::ClearAllCache()
         remoteDBInfos_.clear();
     }
     std::lock_guard<std::mutex> autoLock(supportMutex_);
-    remoteSupportInfo_.clear();
-    cacheLocalSupportComm_ = false;
-    localSupportCommunication_ = false;
+    remoteOptimizeInfo_.clear();
+    cacheLocalSendLabelExchange_ = false;
+    localSendLabelExchange_ = false;
     LOGD("[DBStatusAdapter] ClearAllCache ok");
 }
 
diff --git a/frameworks/libs/distributeddb/communicator/src/protocol_proto.cpp b/frameworks/libs/distributeddb/communicator/src/protocol_proto.cpp
index 359af5a2cc9..84048d9810c 100644
--- a/frameworks/libs/distributeddb/communicator/src/protocol_proto.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/protocol_proto.cpp
@@ -58,13 +58,13 @@ FrameType GetFrameType(uint8_t inPacketType)
     }
     return static_cast<FrameType>(frameType);
 }
-bool IsSupportCommunication(uint8_t inPacketType)
+bool IsSendLabelExchange(uint8_t inPacketType)
 {
     return ((inPacketType & 0x08) >> 3) == 0; // Use 0x08 and remove low 3 bit, it is Communication negotiation mark
 }
-void SetIsSupportCommunication(uint8_t &inPacketType, bool isSupportCommunication)
+void SetSendLabelExchange(uint8_t &inPacketType, bool sendLabelExchange)
 {
-    if (!isSupportCommunication) {
+    if (!sendLabelExchange) {
         inPacketType |= 0x08; // mark 0x08 when not support communication
     }
 }
@@ -456,7 +456,7 @@ int ProtocolProto::SetPhyHeader(SerialBuffer *inBuff, const PhyHeaderInfo &inInf
     } else {
         return -E_INVALID_ARGS;
     }
-    SetIsSupportCommunication(packetType, inInfo.isSupportCommunication);
+    SetSendLabelExchange(packetType, inInfo.sendLabelExchange);
 
     CommPhyHeader phyHeader;
     phyHeader.magic = MAGIC_CODE;
@@ -802,7 +802,7 @@ int ProtocolProto::ParseCommPhyHeader(const std::string &srcTarget, const uint8_
         return -E_FRAME_TYPE_NOT_SUPPORT;
     }
     inResult.SetFrameTypeInfo(frameType);
-    inResult.SetIsSupportCommunication(IsSupportCommunication(phyHeader.packetType));
+    inResult.SetSendLabelExchange(IsSendLabelExchange(phyHeader.packetType));
     return E_OK;
 }
 
diff --git a/frameworks/libs/distributeddb/communicator/src/protocol_proto.h b/frameworks/libs/distributeddb/communicator/src/protocol_proto.h
index 43d5c05b974..34c02107186 100644
--- a/frameworks/libs/distributeddb/communicator/src/protocol_proto.h
+++ b/frameworks/libs/distributeddb/communicator/src/protocol_proto.h
@@ -32,7 +32,7 @@ struct PhyHeaderInfo {
     uint64_t sourceId = 0u;
     uint32_t frameId = 0u;
     FrameType frameType = FrameType::EMPTY;
-    bool isSupportCommunication = true;
+    bool sendLabelExchange = true;
 };
 
 struct FrameFragmentInfo {
diff --git a/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
index 0d2bf35f67e..fba39b58a59 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
@@ -864,7 +864,7 @@ namespace {
     {
         std::shared_ptr<DBInfoHandleTest> handle = std::make_shared<DBInfoHandleTest>();
         adapter->SetDBInfoHandle(handle);
-        adapter->SetRemoteIsSupport(supportDev, isSupport);
+        adapter->SetRemoteOptimizeCommunication(supportDev, isSupport);
         SetUpEnv(envDevice, localDev, adapter);
     }
 
@@ -1155,7 +1155,7 @@ HWTEST_F(DistributedDBCommunicatorTest, DbStatusAdapter001, TestSize.Level1)
     std::shared_ptr<DBStatusAdapter> adapterA = std::make_shared<DBStatusAdapter>();
     std::shared_ptr<DBInfoHandleTest> handle = std::make_shared<DBInfoHandleTest>();
     adapterA->SetDBInfoHandle(handle);
-    adapterA->SetRemoteIsSupport(deviceB, true);
+    adapterA->SetRemoteOptimizeCommunication(deviceB, true);
     std::string actualRemoteDevInfo;
     size_t remoteInfoCount = 0u;
     size_t localCount = 0u;
@@ -1191,7 +1191,7 @@ HWTEST_F(DistributedDBCommunicatorTest, DbStatusAdapter001, TestSize.Level1)
     EXPECT_EQ(actualRemoteDevInfo, deviceB);
     EXPECT_EQ(remoteInfoCount, 1u);
     EXPECT_EQ(localCount, 1u);
-    adapterA->SetRemoteIsSupport(deviceB, false);
+    adapterA->SetRemoteOptimizeCommunication(deviceB, false);
     std::this_thread::sleep_for(std::chrono::seconds(1));
     EXPECT_EQ(remoteChangeCount, 1u);
     RuntimeContext::GetInstance()->SetCommunicatorAggregator(nullptr);
@@ -1209,9 +1209,9 @@ HWTEST_F(DistributedDBCommunicatorTest, DbStatusAdapter002, TestSize.Level1) {
     std::shared_ptr<DBStatusAdapter> adapterA = std::make_shared<DBStatusAdapter>();
     std::shared_ptr<DBInfoHandleTest> handle = std::make_shared<DBInfoHandleTest>();
     adapterA->SetDBInfoHandle(handle);
-    adapterA->SetRemoteIsSupport(deviceB, true);
+    adapterA->SetRemoteOptimizeCommunication(deviceB, true);
     EXPECT_TRUE(adapterA->IsSupport(deviceB));
     adapterA->SetDBInfoHandle(handle);
-    adapterA->SetRemoteIsSupport(deviceB, false);
+    adapterA->SetRemoteOptimizeCommunication(deviceB, false);
     EXPECT_FALSE(adapterA->IsSupport(deviceB));
 }
\ No newline at end of file
-- 
Gitee


From ac30ff8106b56b47f70056826b980402bfc58fe7 Mon Sep 17 00:00:00 2001
From: zqq <zhangqiquan1@huawei.com>
Date: Tue, 6 Dec 2022 20:51:44 +0800
Subject: [PATCH 20/29] when is support get false ignored notify and send local
 open db msg

Signed-off-by: zqq <zhangqiquan1@huawei.com>
---
 .../communicator/include/db_status_adapter.h  |  2 +-
 .../communicator/src/db_status_adapter.cpp    | 10 +++++++--
 .../common/distributeddb_tools_unit_test.cpp  |  9 +++++++-
 .../common/distributeddb_tools_unit_test.h    |  4 +++-
 .../distributeddb_communicator_test.cpp       | 21 +++++++++++++++++++
 5 files changed, 41 insertions(+), 5 deletions(-)

diff --git a/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h b/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h
index a55cd291b99..c4dc1cc96a1 100644
--- a/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h
+++ b/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h
@@ -33,7 +33,7 @@ public:
     void SetDBInfoHandle(const std::shared_ptr<DBInfoHandle> &dbInfoHandle);
     bool ExistDBInfoHandle() const;
     bool IsSupport(const std::string &devInfo);
-    int GetLocalDBInfos(std::vector<DBInfo> &dbInfos) const;
+    int GetLocalDBInfos(std::vector<DBInfo> &dbInfos);
     void SetDBStatusChangeCallback(const RemoteDBChangeCallback &remote, const LocalDBChangeCallback &local,
         const RemoteSupportChangeCallback &supportCallback);
     void NotifyDBInfos(const DeviceInfos &devInfos, const std::vector<DBInfo> &dbInfos);
diff --git a/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
index 23674144c44..a5e34f66d20 100644
--- a/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
@@ -50,7 +50,6 @@ bool DBStatusAdapter::IsSupport(const std::string &devInfo)
         return false;
     }
     if (IsSendLabelExchange()) {
-        LOGD("[DBStatusAdapter] local dev need communication");
         return false;
     }
     {
@@ -64,13 +63,16 @@ bool DBStatusAdapter::IsSupport(const std::string &devInfo)
     return true;
 }
 
-int DBStatusAdapter::GetLocalDBInfos(std::vector<DBInfo> &dbInfos) const
+int DBStatusAdapter::GetLocalDBInfos(std::vector<DBInfo> &dbInfos)
 {
     std::shared_ptr<DBInfoHandle> dbInfoHandle = GetDBInfoHandle();
     if (dbInfoHandle == nullptr) {
         LOGD("[DBStatusAdapter][GetLocalDBInfos] handle not set");
         return -E_NOT_SUPPORT;
     }
+    if (IsSendLabelExchange()) {
+        return -E_NOT_SUPPORT;
+    }
     std::lock_guard<std::mutex> autoLock(localInfoMutex_);
     for (const auto &info: localDBInfos_) {
         if (info.isNeedSync) {
@@ -126,6 +128,10 @@ void DBStatusAdapter::SetDBStatusChangeCallback(const RemoteDBChangeCallback &re
 void DBStatusAdapter::NotifyDBInfos(const DeviceInfos &devInfos, const std::vector<DBInfo> &dbInfos)
 {
     int errCode = RuntimeContext::GetInstance()->ScheduleTask([this, devInfos, dbInfos]() {
+        if (IsSendLabelExchange()) {
+            LOGW("[DBStatusAdapter][NotifyDBInfos] local dev no support communication optimize");
+            return;
+        }
         bool isLocal = IsLocalDeviceId(devInfos.identifier);
         if (!isLocal && !IsSupport(devInfos.identifier)) {
             LOGW("[DBStatusAdapter][NotifyDBInfos] no support dev %s", STR_MASK(devInfos.identifier));
diff --git a/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.cpp
index 6e6f3ede6e2..c3e646adfc8 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.cpp
@@ -1192,7 +1192,8 @@ END:
 
 bool DBInfoHandleTest::IsSupport()
 {
-    return true;
+    std::lock_guard<std::mutex> autoLock(supportMutex_);
+    return localIsSupport_;
 }
 
 bool DBInfoHandleTest::IsNeedAutoSync(const std::string &userId, const std::string &appId, const std::string &storeId,
@@ -1200,4 +1201,10 @@ bool DBInfoHandleTest::IsNeedAutoSync(const std::string &userId, const std::stri
 {
     return true;
 }
+
+void DBInfoHandleTest::SetLocalIsSupport(bool isSupport)
+{
+    std::lock_guard<std::mutex> autoLock(supportMutex_);
+    localIsSupport_ = isSupport;
+}
 } // namespace DistributedDBUnitTest
diff --git a/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.h b/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.h
index 35f84ac951d..807fa4589b7 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.h
+++ b/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.h
@@ -336,9 +336,11 @@ public:
 
     bool IsNeedAutoSync(const std::string &userId, const std::string &appId, const std::string &storeId,
         const DistributedDB::DeviceInfos &devInfo) override;
+
+    void SetLocalIsSupport(bool isSupport);
 private:
     std::mutex supportMutex_;
-    std::map<std::string, bool> supportStatus_;
+    bool localIsSupport_ = true;
 };
 } // namespace DistributedDBUnitTest
 
diff --git a/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
index fba39b58a59..2f93cc98d62 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
@@ -1214,4 +1214,25 @@ HWTEST_F(DistributedDBCommunicatorTest, DbStatusAdapter002, TestSize.Level1) {
     adapterA->SetDBInfoHandle(handle);
     adapterA->SetRemoteOptimizeCommunication(deviceB, false);
     EXPECT_FALSE(adapterA->IsSupport(deviceB));
+}
+
+/**
+  * @tc.name: DbStatusAdapter003
+  * @tc.desc: Test adapter get local dbInfo.
+  * @tc.type: FUNC
+  * @tc.require: AR000HGD0B
+  * @tc.author: zhangqiquan
+  */
+HWTEST_F(DistributedDBCommunicatorTest, DbStatusAdapter003, TestSize.Level1) {
+    const std::string deviceB = "DEVICES_B";
+    std::shared_ptr<DBStatusAdapter> adapterA = std::make_shared<DBStatusAdapter>();
+    std::shared_ptr<DBInfoHandleTest> handle = std::make_shared<DBInfoHandleTest>();
+    adapterA->SetDBInfoHandle(handle);
+    handle->SetLocalIsSupport(true);
+    std::vector<DBInfo> dbInfos;
+    EXPECT_EQ(adapterA->GetLocalDBInfos(dbInfos), E_OK);
+    handle->SetLocalIsSupport(false);
+    EXPECT_EQ(adapterA->GetLocalDBInfos(dbInfos), E_OK);
+    adapterA->SetDBInfoHandle(handle);
+    EXPECT_EQ(adapterA->GetLocalDBInfos(dbInfos), -E_NOT_SUPPORT);
 }
\ No newline at end of file
-- 
Gitee


From 9cb303c782d4b2417864aee3965f38553a581e9e Mon Sep 17 00:00:00 2001
From: zqq <zhangqiquan1@huawei.com>
Date: Fri, 9 Dec 2022 14:19:14 +0800
Subject: [PATCH 21/29] fixbug in create communicator

Signed-off-by: zqq <zhangqiquan1@huawei.com>
---
 .../common/src/runtime_context_impl.cpp       |  4 +-
 .../communicator/include/db_status_adapter.h  |  1 -
 .../communicator/src/communicator_linker.cpp  |  2 +-
 .../communicator/src/db_status_adapter.cpp    |  6 ---
 .../distributeddb_communicator_test.cpp       | 54 +++++++++++++++++++
 5 files changed, 57 insertions(+), 10 deletions(-)

diff --git a/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp b/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
index 99b676cbd4d..42a8b0c762d 100644
--- a/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
+++ b/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
@@ -823,7 +823,7 @@ void RuntimeContextImpl::RemoveRemoteSubscribe(const DeviceID &deviceId)
 void RuntimeContextImpl::RemoveRemoteSubscribe(const DBInfo &dbInfo)
 {
     std::shared_ptr<DBStatusAdapter> dbStatusAdapter = GetDBStatusAdapter();
-    if (dbStatusAdapter != nullptr && !dbStatusAdapter->ExistDBInfoHandle()) {
+    if (dbStatusAdapter != nullptr && dbStatusAdapter->IsSendLabelExchange()) {
         return;
     }
     std::shared_ptr<SubscribeRecorder> subscribeRecorder = GetSubscribeRecorder();
@@ -861,7 +861,7 @@ 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()) {
+    if (dbStatusAdapter != nullptr && dbStatusAdapter->IsSendLabelExchange()) {
         return;
     }
     std::shared_ptr<SubscribeRecorder> subscribeRecorder = GetSubscribeRecorder();
diff --git a/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h b/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h
index c4dc1cc96a1..7340c457b95 100644
--- a/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h
+++ b/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h
@@ -31,7 +31,6 @@ public:
     DISABLE_COPY_ASSIGN_MOVE(DBStatusAdapter);
 
     void SetDBInfoHandle(const std::shared_ptr<DBInfoHandle> &dbInfoHandle);
-    bool ExistDBInfoHandle() const;
     bool IsSupport(const std::string &devInfo);
     int GetLocalDBInfos(std::vector<DBInfo> &dbInfos);
     void SetDBStatusChangeCallback(const RemoteDBChangeCallback &remote, const LocalDBChangeCallback &local,
diff --git a/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp b/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp
index 263b9cd1bf8..b24bd8bbc96 100644
--- a/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp
@@ -486,7 +486,7 @@ bool CommunicatorLinker::TriggerLabelExchangeEvent(bool checkAdapter)
         totalOnlineTargets = remoteOnlineTarget_;
     }
     for (auto &entry : totalOnlineTargets) {
-        if (checkAdapter && statusAdapter_ != nullptr && statusAdapter_->ExistDBInfoHandle()) {
+        if (checkAdapter && statusAdapter_ != nullptr && !statusAdapter_->IsSendLabelExchange()) {
             continue;
         }
         if (TriggerLabelExchangeEvent(entry) != E_OK) {
diff --git a/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
index a5e34f66d20..618217eff3e 100644
--- a/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
@@ -36,12 +36,6 @@ void DBStatusAdapter::SetDBInfoHandle(const std::shared_ptr<DBInfoHandle> &dbInf
     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();
diff --git a/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
index 2f93cc98d62..f25800cfcb9 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
@@ -1075,6 +1075,7 @@ HWTEST_F(DistributedDBCommunicatorTest, CommunicationOptimization003, TestSize.L
      * @tc.expected: step6. B has no callback;
      */
     dbInfo.isNeedSync = false;
+    onlineForAA.onlineDevices.clear();
     adapterA->NotifyDBInfos({ deviceA }, { dbInfo });
     std::this_thread::sleep_for(std::chrono::seconds(1));
     EXPECT_EQ(onlineForAA.onlineDevices.size(), static_cast<size_t>(0));
@@ -1137,6 +1138,59 @@ HWTEST_F(DistributedDBCommunicatorTest, CommunicationOptimization004, TestSize.L
     TearDownEnv(envDeviceB);
 }
 
+/**
+  * @tc.name: CommunicationOptimization005
+  * @tc.desc: Test notify with isSupport false and send label exchange.
+  * @tc.type: FUNC
+  * @tc.require: AR000HGD0B
+  * @tc.author: zhangqiquan
+  */
+HWTEST_F(DistributedDBCommunicatorTest, CommunicationOptimization005, TestSize.Level3)
+{
+    const std::string deviceA = "DEVICES_A";
+    const std::string deviceB = "DEVICES_B";
+    /**
+     * @tc.steps: step1. set up env
+     */
+    EnvHandle envDeviceA;
+    std::shared_ptr<DBStatusAdapter> adapterA = std::make_shared<DBStatusAdapter>();
+    std::shared_ptr<DBInfoHandleTest> handle = std::make_shared<DBInfoHandleTest>();
+    handle->SetLocalIsSupport(false);
+    adapterA->SetDBInfoHandle(handle);
+    SetUpEnv(envDeviceA, deviceA, adapterA);
+    RuntimeContext::GetInstance()->SetCommunicatorAggregator(envDeviceA.commAggrHandle);
+    EnvHandle envDeviceB;
+    SetUpEnv(envDeviceB, deviceB, nullptr);
+    /**
+     * @tc.steps: step2. connect device A with device B
+     */
+    EXPECT_EQ(adapterA->IsSupport(deviceB), false);
+    AdapterStub::ConnectAdapterStub(envDeviceA.adapterHandle, envDeviceB.adapterHandle);
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    /**
+     * @tc.steps: step3. device alloc communicator using label and register callback
+     */
+    DBInfo dbInfo;
+    ICommunicator *commAA = nullptr;
+    OnOfflineDevice onlineForAA;
+    InitCommunicator(dbInfo, envDeviceA, onlineForAA, commAA);
+    ICommunicator *commBB = nullptr;
+    OnOfflineDevice onlineForBB;
+    InitCommunicator(dbInfo, envDeviceB, onlineForBB, commBB);
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    EXPECT_EQ(onlineForBB.onlineDevices.size(), static_cast<size_t>(1));
+
+    // Clean up and disconnect
+    envDeviceA.commAggrHandle->ReleaseCommunicator(commAA);
+    envDeviceB.commAggrHandle->ReleaseCommunicator(commBB);
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    AdapterStub::DisconnectAdapterStub(envDeviceA.adapterHandle, envDeviceB.adapterHandle);
+    RuntimeContext::GetInstance()->SetCommunicatorAggregator(nullptr);
+    envDeviceA.commAggrHandle = nullptr;
+    TearDownEnv(envDeviceA);
+    TearDownEnv(envDeviceB);
+}
+
 /**
   * @tc.name: DbStatusAdapter001
   * @tc.desc: Test notify with isSupport false.
-- 
Gitee


From 5cde89442a6e20dff3c6dfd2914e22cf03258596 Mon Sep 17 00:00:00 2001
From: zqq <zhangqiquan1@huawei.com>
Date: Mon, 12 Dec 2022 16:25:53 +0800
Subject: [PATCH 22/29] fixbug when remote dev offline

Signed-off-by: zqq <zhangqiquan1@huawei.com>
---
 .../storage/include/sync_generic_interface.h         |  2 +-
 .../distributeddb/syncer/src/single_ver_syncer.cpp   |  2 +-
 .../libs/distributeddb/syncer/src/sync_engine.cpp    | 12 ++++++++----
 .../libs/distributeddb/syncer/src/sync_engine.h      |  2 +-
 .../syncer/distributeddb_mock_sync_module_test.cpp   | 10 +++++++++-
 ...tributeddb_single_ver_p2p_subscribe_sync_test.cpp |  1 +
 .../unittest/common/syncer/mock_kv_sync_interface.h  |  1 +
 7 files changed, 22 insertions(+), 8 deletions(-)

diff --git a/frameworks/libs/distributeddb/storage/include/sync_generic_interface.h b/frameworks/libs/distributeddb/storage/include/sync_generic_interface.h
index 5e6c941dfc9..759aaad9d6a 100644
--- a/frameworks/libs/distributeddb/storage/include/sync_generic_interface.h
+++ b/frameworks/libs/distributeddb/storage/include/sync_generic_interface.h
@@ -146,7 +146,7 @@ public:
         return {};
     }
 
-    void GetDBInfo(DBInfo &dbInfo) const
+    virtual void GetDBInfo(DBInfo &dbInfo) const
     {
         dbInfo.appId = GetDbProperties().GetStringProp(DBProperties::APP_ID, "");
         dbInfo.userId = GetDbProperties().GetStringProp(DBProperties::USER_ID, "");
diff --git a/frameworks/libs/distributeddb/syncer/src/single_ver_syncer.cpp b/frameworks/libs/distributeddb/syncer/src/single_ver_syncer.cpp
index f91afc3ddcc..5bc1678d12f 100644
--- a/frameworks/libs/distributeddb/syncer/src/single_ver_syncer.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/single_ver_syncer.cpp
@@ -37,7 +37,7 @@ void SingleVerSyncer::RemoteDeviceOffline(const std::string &device)
     ISyncInterface *storage = syncInterface_;
     storage->IncRefCount();
     int errCode = RuntimeContext::GetInstance()->ScheduleTask([engine, device, storage]() {
-        static_cast<SingleVerSyncEngine *>(engine)->OfflineHandleByDevice(device);
+        static_cast<SingleVerSyncEngine *>(engine)->OfflineHandleByDevice(device, storage);
         RefObject::DecObjRef(engine);
         storage->DecRefCount();
     });
diff --git a/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp b/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp
index 6caffdf2c8f..b34a5ec3f1d 100644
--- a/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp
@@ -818,8 +818,12 @@ void SyncEngine::SetEqualIdentifierMap(const std::string &identifier, const std:
     }
 }
 
-void SyncEngine::OfflineHandleByDevice(const std::string &deviceId)
+void SyncEngine::OfflineHandleByDevice(const std::string &deviceId, ISyncInterface *storage)
 {
+    if (!isActive_) {
+        LOGD("[SyncEngine][OfflineHandleByDevice] ignore offline because not init");
+        return;
+    }
     RemoteExecutor *executor = GetAndIncRemoteExector();
     if (executor != nullptr) {
         executor->NotifyDeviceOffline(deviceId);
@@ -832,13 +836,13 @@ void SyncEngine::OfflineHandleByDevice(const std::string &deviceId)
     subManager_->ClearRemoteSubscribeQuery(deviceId);
     for (const auto &queryId: remoteQueryId) {
         if (!subManager_->IsQueryExistSubscribe(queryId)) {
-            static_cast<SingleVerKvDBSyncInterface *>(syncInterface_)->RemoveSubscribe(queryId);
+            static_cast<SingleVerKvDBSyncInterface *>(storage)->RemoveSubscribe(queryId);
         }
     }
     DBInfo dbInfo;
-    static_cast<SyncGenericInterface *>(syncInterface_)->GetDBInfo(dbInfo);
+    static_cast<SyncGenericInterface *>(storage)->GetDBInfo(dbInfo);
     RuntimeContext::GetInstance()->RemoveRemoteSubscribe(dbInfo, deviceId);
-    // get context and Inc context if context is not nullprt
+    // get context and Inc context if context is not nullptr
     ISyncTaskContext *context = GetSyncTaskContextAndInc(deviceId);
     if (context != nullptr) {
         context->SetIsNeedResetAbilitySync(true);
diff --git a/frameworks/libs/distributeddb/syncer/src/sync_engine.h b/frameworks/libs/distributeddb/syncer/src/sync_engine.h
index 312d4380221..ac46b8c085e 100644
--- a/frameworks/libs/distributeddb/syncer/src/sync_engine.h
+++ b/frameworks/libs/distributeddb/syncer/src/sync_engine.h
@@ -84,7 +84,7 @@ public:
 
     void SetEqualIdentifierMap(const std::string &identifier, const std::vector<std::string> &targets) override;
 
-    void OfflineHandleByDevice(const std::string &deviceId);
+    void OfflineHandleByDevice(const std::string &deviceId, ISyncInterface *storage);
 
     void GetLocalSubscribeQueries(const std::string &device, std::vector<QuerySyncObject> &subscribeQueries);
 
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_mock_sync_module_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_mock_sync_module_test.cpp
index 27cd9b0caf0..852bde1f255 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_mock_sync_module_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_mock_sync_module_test.cpp
@@ -1131,19 +1131,27 @@ HWTEST_F(DistributedDBMockSyncModuleTest, SyncLifeTest005, TestSize.Level3)
     RuntimeContext::GetInstance()->SetCommunicatorAggregator(virtualCommunicatorAggregator);
     auto syncDBInterface = new MockKvSyncInterface();
     int incRefCount = 0;
+    int dbInfoCount = 0;
     EXPECT_CALL(*syncDBInterface, IncRefCount()).WillRepeatedly([&incRefCount]() {
         incRefCount++;
     });
     EXPECT_CALL(*syncDBInterface, DecRefCount()).WillRepeatedly(Return());
+    EXPECT_CALL(*syncDBInterface, GetDBInfo(_)).WillRepeatedly([&dbInfoCount](DBInfo &) {
+        dbInfoCount++;
+    });
     std::vector<uint8_t> identifier(COMM_LABEL_LENGTH, 1u);
     syncDBInterface->SetIdentifier(identifier);
     syncer->Initialize(syncDBInterface, true);
+    syncer->Close(true);
+    incRefCount = 0;
+    dbInfoCount = 0;
     syncer->RemoteDeviceOffline("dev");
     std::this_thread::sleep_for(std::chrono::seconds(1));
+    EXPECT_EQ(incRefCount, 1); // refCount is 1 when remote dev offline
+    EXPECT_EQ(dbInfoCount, 0); // dbInfoCount is 0 when remote dev offline
     syncer = nullptr;
     RuntimeContext::GetInstance()->SetCommunicatorAggregator(nullptr);
     delete syncDBInterface;
-    EXPECT_EQ(incRefCount, 2); // refCount is 2
 }
 
 /**
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
index 2d2b7f828e4..074306d998e 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
@@ -1161,6 +1161,7 @@ HWTEST_F(DistributedDBSingleVerP2PSubscribeSyncTest, SubscribeSync009, TestSize.
     };
     for (const auto &dev: devices) {
         dev->UnSubscribe(QuerySyncObject(query), true, 1, callback); // sync id is 1
+        delete dev;
     }
 }
 
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/mock_kv_sync_interface.h b/frameworks/libs/distributeddb/test/unittest/common/syncer/mock_kv_sync_interface.h
index 1aacb5351f7..7d9c3fa01e9 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/mock_kv_sync_interface.h
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/mock_kv_sync_interface.h
@@ -24,6 +24,7 @@ class MockKvSyncInterface : public VirtualSingleVerSyncDBInterface {
 public:
     MOCK_METHOD0(IncRefCount, void(void));
     MOCK_METHOD0(DecRefCount, void(void));
+    MOCK_CONST_METHOD1(GetDBInfo, void(DBInfo &));
 };
 } // namespace DistributedDB
 #endif  // #define MOCK_KV_SYNC_INTERFACE_H
\ No newline at end of file
-- 
Gitee


From 5510e7d0514aa70c999adc1f7420d2584261994a Mon Sep 17 00:00:00 2001
From: zqq <zhangqiquan1@huawei.com>
Date: Tue, 13 Dec 2022 15:29:08 +0800
Subject: [PATCH 23/29] notify offline when reset handle

Signed-off-by: zqq <zhangqiquan1@huawei.com>
---
 .../communicator/src/db_status_adapter.cpp    | 31 ++++++++++++--
 .../distributeddb_communicator_test.cpp       | 42 +++++++++++++++++++
 2 files changed, 69 insertions(+), 4 deletions(-)

diff --git a/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
index 618217eff3e..ea7ab0cb533 100644
--- a/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
@@ -257,15 +257,38 @@ void DBStatusAdapter::ClearAllCache()
         std::lock_guard<std::mutex> autoLock(localInfoMutex_);
         localDBInfos_.clear();
     }
+    std::map<std::string, std::vector<DBInfo>> remoteOnlineDBInfos;
     {
         std::lock_guard<std::mutex> autoLock(remoteInfoMutex_);
+        for (auto &[dev, dbInfos]: remoteDBInfos_) {
+            for (auto &dbInfo: dbInfos) {
+                if (dbInfo.isNeedSync) {
+                    dbInfo.isNeedSync = false;
+                    remoteOnlineDBInfos[dev].push_back(dbInfo);
+                }
+            }
+        }
         remoteDBInfos_.clear();
     }
-    std::lock_guard<std::mutex> autoLock(supportMutex_);
-    remoteOptimizeInfo_.clear();
-    cacheLocalSendLabelExchange_ = false;
-    localSendLabelExchange_ = false;
+    {
+        std::lock_guard<std::mutex> autoLock(supportMutex_);
+        remoteOptimizeInfo_.clear();
+        cacheLocalSendLabelExchange_ = false;
+        localSendLabelExchange_ = false;
+    }
     LOGD("[DBStatusAdapter] ClearAllCache ok");
+    RemoteDBChangeCallback callback;
+    {
+        std::lock_guard<std::mutex> autoLock(callbackMutex_);
+        callback = remoteCallback_;
+    }
+    if (callback == nullptr || remoteOnlineDBInfos.empty()) {
+        return;
+    }
+    for (const auto &[dev, dbInfos]: remoteOnlineDBInfos) {
+        callback(dev, dbInfos);
+    }
+    LOGD("[DBStatusAdapter] Notify offline after reset cache ok");
 }
 
 void DBStatusAdapter::MergeDBInfos(const std::vector<DBInfo> &srcDbInfos, std::vector<DBInfo> &dstDbInfos,
diff --git a/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
index f25800cfcb9..be4ced1ccf7 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
@@ -1289,4 +1289,46 @@ HWTEST_F(DistributedDBCommunicatorTest, DbStatusAdapter003, TestSize.Level1) {
     EXPECT_EQ(adapterA->GetLocalDBInfos(dbInfos), E_OK);
     adapterA->SetDBInfoHandle(handle);
     EXPECT_EQ(adapterA->GetLocalDBInfos(dbInfos), -E_NOT_SUPPORT);
+}
+
+/**
+  * @tc.name: DbStatusAdapter004
+  * @tc.desc: Test adapter clear cache will get callback.
+  * @tc.type: FUNC
+  * @tc.require: AR000HGD0B
+  * @tc.author: zhangqiquan
+  */
+HWTEST_F(DistributedDBCommunicatorTest, DbStatusAdapter004, TestSize.Level1) {
+    const std::string deviceB = "DEVICES_B";
+    std::shared_ptr<DBStatusAdapter> adapterA = std::make_shared<DBStatusAdapter>();
+    std::shared_ptr<DBInfoHandleTest> handle = std::make_shared<DBInfoHandleTest>();
+    adapterA->SetDBInfoHandle(handle);
+    handle->SetLocalIsSupport(true);
+    std::vector<DBInfo> dbInfos;
+    DBInfo dbInfo = {
+        USER_ID,
+        APP_ID,
+        STORE_ID_1,
+        true,
+        true
+    };
+    dbInfos.push_back(dbInfo);
+    dbInfo.storeId = STORE_ID_2;
+    dbInfos.push_back(dbInfo);
+    dbInfo.storeId = STORE_ID_3;
+    dbInfo.isNeedSync = false;
+    dbInfos.push_back(dbInfo);
+    adapterA->NotifyDBInfos({"dev"}, dbInfos);
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    size_t notifyCount = 0u;
+    adapterA->SetDBStatusChangeCallback([&notifyCount](const std::string &devInfo,
+        const std::vector<DBInfo> &dbInfos) {
+        LOGD("on callback");
+        for (const auto &dbInfo: dbInfos) {
+            EXPECT_FALSE(dbInfo.isNeedSync);
+        }
+        notifyCount = dbInfos.size();
+    }, nullptr, nullptr);
+    adapterA->SetDBInfoHandle(nullptr);
+    EXPECT_EQ(notifyCount, 2u); // 2 dbInfo is need sync now it should be offline
 }
\ No newline at end of file
-- 
Gitee


From bc9c8c3223311a1c99b2cc2dad1120e5108562fc Mon Sep 17 00:00:00 2001
From: zqq <zhangqiquan1@huawei.com>
Date: Tue, 13 Dec 2022 15:52:28 +0800
Subject: [PATCH 24/29] extract method

Signed-off-by: zqq <zhangqiquan1@huawei.com>
---
 .../communicator/include/db_status_adapter.h  |  1 +
 .../communicator/src/db_status_adapter.cpp    | 40 ++++++++++++-------
 .../distributeddb_communicator_test.cpp       |  3 +-
 3 files changed, 28 insertions(+), 16 deletions(-)

diff --git a/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h b/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h
index 7340c457b95..177b8d7e921 100644
--- a/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h
+++ b/frameworks/libs/distributeddb/communicator/include/db_status_adapter.h
@@ -46,6 +46,7 @@ private:
     void LoadIntoCache(bool isLocal, const DeviceInfos &devInfos, const std::vector<DBInfo> &dbInfos,
         std::vector<DBInfo> &changeDbInfos);
     void ClearAllCache();
+    void NotifyRemoteOffline();
 
     static int GetLocalDeviceId(std::string &deviceId);
     static bool IsLocalDeviceId(const std::string &deviceId);
diff --git a/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
index ea7ab0cb533..389cfdcc2e4 100644
--- a/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
@@ -30,8 +30,11 @@ DBStatusAdapter::DBStatusAdapter()
 
 void DBStatusAdapter::SetDBInfoHandle(const std::shared_ptr<DBInfoHandle> &dbInfoHandle)
 {
-    std::lock_guard<std::mutex> autoLock(handleMutex_);
-    dbInfoHandle_ = dbInfoHandle;
+    {
+        std::lock_guard<std::mutex> autoLock(handleMutex_);
+        dbInfoHandle_ = dbInfoHandle;
+    }
+    NotifyRemoteOffline();
     ClearAllCache();
     LOGI("[DBStatusAdapter] SetDBInfoHandle Finish");
 }
@@ -257,38 +260,45 @@ void DBStatusAdapter::ClearAllCache()
         std::lock_guard<std::mutex> autoLock(localInfoMutex_);
         localDBInfos_.clear();
     }
+    {
+        std::lock_guard<std::mutex> autoLock(remoteInfoMutex_);
+        remoteDBInfos_.clear();
+    }
+    std::lock_guard<std::mutex> autoLock(supportMutex_);
+    remoteOptimizeInfo_.clear();
+    cacheLocalSendLabelExchange_ = false;
+    localSendLabelExchange_ = false;
+    LOGD("[DBStatusAdapter] ClearAllCache ok");
+}
+
+void DBStatusAdapter::NotifyRemoteOffline()
+{
     std::map<std::string, std::vector<DBInfo>> remoteOnlineDBInfos;
     {
         std::lock_guard<std::mutex> autoLock(remoteInfoMutex_);
-        for (auto &[dev, dbInfos]: remoteDBInfos_) {
-            for (auto &dbInfo: dbInfos) {
+        for (const auto &[dev, dbInfos]: remoteDBInfos_) {
+            for (const auto &dbInfo: dbInfos) {
                 if (dbInfo.isNeedSync) {
-                    dbInfo.isNeedSync = false;
-                    remoteOnlineDBInfos[dev].push_back(dbInfo);
+                    DBInfo info = dbInfo;
+                    info.isNeedSync = false;
+                    remoteOnlineDBInfos[dev].push_back(info);
                 }
             }
         }
-        remoteDBInfos_.clear();
     }
-    {
-        std::lock_guard<std::mutex> autoLock(supportMutex_);
-        remoteOptimizeInfo_.clear();
-        cacheLocalSendLabelExchange_ = false;
-        localSendLabelExchange_ = false;
-    }
-    LOGD("[DBStatusAdapter] ClearAllCache ok");
     RemoteDBChangeCallback callback;
     {
         std::lock_guard<std::mutex> autoLock(callbackMutex_);
         callback = remoteCallback_;
     }
     if (callback == nullptr || remoteOnlineDBInfos.empty()) {
+        LOGD("[DBStatusAdapter] no need to notify offline when reset handle");
         return;
     }
     for (const auto &[dev, dbInfos]: remoteOnlineDBInfos) {
         callback(dev, dbInfos);
     }
-    LOGD("[DBStatusAdapter] Notify offline after reset cache ok");
+    LOGD("[DBStatusAdapter] Notify offline ok");
 }
 
 void DBStatusAdapter::MergeDBInfos(const std::vector<DBInfo> &srcDbInfos, std::vector<DBInfo> &dstDbInfos,
diff --git a/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
index be4ced1ccf7..4692eb4c898 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
@@ -1298,7 +1298,8 @@ HWTEST_F(DistributedDBCommunicatorTest, DbStatusAdapter003, TestSize.Level1) {
   * @tc.require: AR000HGD0B
   * @tc.author: zhangqiquan
   */
-HWTEST_F(DistributedDBCommunicatorTest, DbStatusAdapter004, TestSize.Level1) {
+HWTEST_F(DistributedDBCommunicatorTest, DbStatusAdapter004, TestSize.Level1)
+{
     const std::string deviceB = "DEVICES_B";
     std::shared_ptr<DBStatusAdapter> adapterA = std::make_shared<DBStatusAdapter>();
     std::shared_ptr<DBInfoHandleTest> handle = std::make_shared<DBInfoHandleTest>();
-- 
Gitee


From 3113a8197c17cf0da293216230931c247fdcd041 Mon Sep 17 00:00:00 2001
From: zqq <zhangqiquan1@huawei.com>
Date: Wed, 14 Dec 2022 16:23:18 +0800
Subject: [PATCH 25/29] record subscribe cache when local use communication
 optimize

Signed-off-by: zqq <zhangqiquan1@huawei.com>
---
 .../common/include/runtime_context.h          |  4 +-
 .../common/src/runtime_context_impl.cpp       | 21 ++-----
 .../common/src/runtime_context_impl.h         |  4 +-
 ...ddb_single_ver_p2p_subscribe_sync_test.cpp | 58 +++++++++++++++++++
 4 files changed, 66 insertions(+), 21 deletions(-)

diff --git a/frameworks/libs/distributeddb/common/include/runtime_context.h b/frameworks/libs/distributeddb/common/include/runtime_context.h
index 331a595448b..4cea9b95cab 100644
--- a/frameworks/libs/distributeddb/common/include/runtime_context.h
+++ b/frameworks/libs/distributeddb/common/include/runtime_context.h
@@ -170,9 +170,7 @@ public:
     virtual bool IsNeedAutoSync(const std::string &userId, const std::string &appId, const std::string &storeId,
         const std::string &devInfo) = 0;
 
-    virtual void SetRemoteIsSupport(const std::string &dev, bool isSupport) = 0;
-
-    virtual bool IsSupportCommunication() = 0;
+    virtual void SetRemoteOptimizeCommunication(const std::string &dev, bool optimize) = 0;
 
     virtual void SetTranslateToDeviceIdCallback(const TranslateToDeviceIdCallback &callback) = 0;
 
diff --git a/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp b/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
index 42a8b0c762d..62d10e255ef 100644
--- a/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
+++ b/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
@@ -799,7 +799,7 @@ void RuntimeContextImpl::RecordRemoteSubscribe(const DBInfo &dbInfo, const Devic
     const QuerySyncObject &query)
 {
     std::shared_ptr<DBStatusAdapter> dbStatusAdapter = GetDBStatusAdapter();
-    if (dbStatusAdapter != nullptr && !dbStatusAdapter->IsSupport(deviceId)) {
+    if (dbStatusAdapter != nullptr && dbStatusAdapter->IsSendLabelExchange()) {
         return;
     }
     std::shared_ptr<SubscribeRecorder> subscribeRecorder = GetSubscribeRecorder();
@@ -811,7 +811,7 @@ void RuntimeContextImpl::RecordRemoteSubscribe(const DBInfo &dbInfo, const Devic
 void RuntimeContextImpl::RemoveRemoteSubscribe(const DeviceID &deviceId)
 {
     std::shared_ptr<DBStatusAdapter> dbStatusAdapter = GetDBStatusAdapter();
-    if (dbStatusAdapter != nullptr && !dbStatusAdapter->IsSupport(deviceId)) {
+    if (dbStatusAdapter != nullptr && dbStatusAdapter->IsSendLabelExchange()) {
         return;
     }
     std::shared_ptr<SubscribeRecorder> subscribeRecorder = GetSubscribeRecorder();
@@ -835,7 +835,7 @@ void RuntimeContextImpl::RemoveRemoteSubscribe(const DBInfo &dbInfo)
 void RuntimeContextImpl::RemoveRemoteSubscribe(const DBInfo &dbInfo, const DeviceID &deviceId)
 {
     std::shared_ptr<DBStatusAdapter> dbStatusAdapter = GetDBStatusAdapter();
-    if (dbStatusAdapter != nullptr && !dbStatusAdapter->IsSupport(deviceId)) {
+    if (dbStatusAdapter != nullptr && dbStatusAdapter->IsSendLabelExchange()) {
         return;
     }
     std::shared_ptr<SubscribeRecorder> subscribeRecorder = GetSubscribeRecorder();
@@ -848,7 +848,7 @@ void RuntimeContextImpl::RemoveRemoteSubscribe(const DBInfo &dbInfo, const Devic
     const QuerySyncObject &query)
 {
     std::shared_ptr<DBStatusAdapter> dbStatusAdapter = GetDBStatusAdapter();
-    if (dbStatusAdapter != nullptr && !dbStatusAdapter->IsSupport(deviceId)) {
+    if (dbStatusAdapter != nullptr && dbStatusAdapter->IsSendLabelExchange()) {
         return;
     }
     std::shared_ptr<SubscribeRecorder> subscribeRecorder = GetSubscribeRecorder();
@@ -892,22 +892,13 @@ bool RuntimeContextImpl::IsNeedAutoSync(const std::string &userId, const std::st
     return dbStatusAdapter->IsNeedAutoSync(userId, appId, storeId, devInfo);
 }
 
-void RuntimeContextImpl::SetRemoteIsSupport(const std::string &dev, bool isSupport)
+void RuntimeContextImpl::SetRemoteOptimizeCommunication(const std::string &dev, bool optimize)
 {
     std::shared_ptr<DBStatusAdapter> dbStatusAdapter = GetDBStatusAdapter();
     if (dbStatusAdapter == nullptr) {
         return;
     }
-    dbStatusAdapter->SetRemoteIsSupport(dev, isSupport);
-}
-
-bool RuntimeContextImpl::IsSupportCommunication()
-{
-    std::shared_ptr<DBStatusAdapter> dbStatusAdapter = GetDBStatusAdapter();
-    if (dbStatusAdapter == nullptr) {
-        return true;
-    }
-    return dbStatusAdapter->IsSupportCommunication();
+    dbStatusAdapter->SetRemoteOptimizeCommunication(dev, optimize);
 }
 
 void RuntimeContextImpl::SetTranslateToDeviceIdCallback(const TranslateToDeviceIdCallback &callback)
diff --git a/frameworks/libs/distributeddb/common/src/runtime_context_impl.h b/frameworks/libs/distributeddb/common/src/runtime_context_impl.h
index aa4dd8bcc75..c14b0312e8a 100644
--- a/frameworks/libs/distributeddb/common/src/runtime_context_impl.h
+++ b/frameworks/libs/distributeddb/common/src/runtime_context_impl.h
@@ -153,9 +153,7 @@ public:
     bool IsNeedAutoSync(const std::string &userId, const std::string &appId, const std::string &storeId,
         const std::string &devInfo) override;
 
-    void SetRemoteIsSupport(const std::string &dev, bool isSupport) override;
-
-    bool IsSupportCommunication() override;
+    void SetRemoteOptimizeCommunication(const std::string &dev, bool optimize) override;
 
     void SetTranslateToDeviceIdCallback(const TranslateToDeviceIdCallback &callback) override;
 
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
index 074306d998e..2f06a9060b5 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
@@ -1329,6 +1329,64 @@ HWTEST_F(DistributedDBSingleVerP2PSubscribeSyncTest, SubscribeSync012, TestSize.
     }
 }
 
+/*
+ * @tc.name: SubscribeSync013
+ * @tc.desc: test subscribe query cache with remote support false
+ * @tc.type: FUNC
+ * @tc.require: AR000H5VLO
+ * @tc.author: zhangqiquan
+ */
+HWTEST_F(DistributedDBSingleVerP2PSubscribeSyncTest, SubscribeSync013, TestSize.Level1)
+{
+    std::shared_ptr<DBInfoHandleTest> handle = std::make_shared<DBInfoHandleTest>();
+    RuntimeConfig::SetDBInfoHandle(handle);
+    handle->SetLocalIsSupport(true);
+    DBInfo dbInfo = {
+        USER_ID,
+        APP_ID,
+        STORE_ID_1,
+        false,
+        true
+    };
+    RuntimeContext::GetInstance()->SetRemoteOptimizeCommunication(DEVICE_A, false);
+    Query query = Query::Select();
+    QuerySyncObject querySyncObject(query);
+    /**
+     * @tc.steps: step1. Insert one record
+     */
+    RuntimeContext::GetInstance()->RecordRemoteSubscribe(dbInfo, DEVICE_A, querySyncObject);
+    std::map<std::string, std::vector<QuerySyncObject>> subscribeQuery;
+    RuntimeContext::GetInstance()->GetSubscribeQuery(dbInfo, subscribeQuery);
+    EXPECT_EQ(subscribeQuery.size(), 1u);
+    /**
+     * @tc.steps: step2. Remove one record
+     */
+    RuntimeContext::GetInstance()->RemoveRemoteSubscribe(dbInfo, DEVICE_A, querySyncObject);
+    RuntimeContext::GetInstance()->GetSubscribeQuery(dbInfo, subscribeQuery);
+    EXPECT_EQ(subscribeQuery[DEVICE_A].size(), 0u);
+    /**
+     * @tc.steps: step3. Record again and remove by dbInfo and device
+     */
+    RuntimeContext::GetInstance()->RecordRemoteSubscribe(dbInfo, DEVICE_A, querySyncObject);
+    RuntimeContext::GetInstance()->RemoveRemoteSubscribe(dbInfo, DEVICE_A);
+    RuntimeContext::GetInstance()->GetSubscribeQuery(dbInfo, subscribeQuery);
+    EXPECT_EQ(subscribeQuery.size(), 0u);
+    /**
+     * @tc.steps: step4. Record again and remove by device
+     */
+    RuntimeContext::GetInstance()->RecordRemoteSubscribe(dbInfo, DEVICE_A, querySyncObject);
+    RuntimeContext::GetInstance()->RemoveRemoteSubscribe(DEVICE_A);
+    RuntimeContext::GetInstance()->GetSubscribeQuery(dbInfo, subscribeQuery);
+    EXPECT_EQ(subscribeQuery.size(), 0u);
+    /**
+     * @tc.steps: step5. Record again and remove by dbInfo
+     */
+    RuntimeContext::GetInstance()->RecordRemoteSubscribe(dbInfo, DEVICE_A, querySyncObject);
+    RuntimeContext::GetInstance()->RemoveRemoteSubscribe(dbInfo);
+    RuntimeContext::GetInstance()->GetSubscribeQuery(dbInfo, subscribeQuery);
+    EXPECT_EQ(subscribeQuery.size(), 0u);
+    RuntimeConfig::SetDBInfoHandle(nullptr);
+}
 /**
  * @tc.name: SubscribeSync014
  * @tc.desc: test device subscribe with put a lot of times
-- 
Gitee


From dfeeea3ed9ff28102e32d599a9050826c599cf20 Mon Sep 17 00:00:00 2001
From: zqq <zhangqiquan1@huawei.com>
Date: Thu, 5 Jan 2023 11:27:18 +0800
Subject: [PATCH 26/29] fixbug in auto sync

Signed-off-by: zqq <zhangqiquan1@huawei.com>
---
 .../communicator/src/db_status_adapter.cpp    |  2 +-
 .../syncer/src/single_ver_kv_syncer.cpp       |  2 +-
 .../common/distributeddb_tools_unit_test.cpp  |  9 ++++++-
 .../common/distributeddb_tools_unit_test.h    |  4 +++
 .../distributeddb_communicator_test.cpp       | 25 +++++++++++++++++++
 5 files changed, 39 insertions(+), 3 deletions(-)

diff --git a/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
index 389cfdcc2e4..b11d7079328 100644
--- a/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
@@ -167,7 +167,7 @@ bool DBStatusAdapter::IsNeedAutoSync(const std::string &userId, const std::strin
     const std::string &devInfo)
 {
     std::shared_ptr<DBInfoHandle> dbInfoHandle = GetDBInfoHandle();
-    if (dbInfoHandle == nullptr) {
+    if (dbInfoHandle == nullptr || IsSendLabelExchange()) {
         return true;
     }
     return dbInfoHandle->IsNeedAutoSync(userId, appId, storeId, { devInfo });
diff --git a/frameworks/libs/distributeddb/syncer/src/single_ver_kv_syncer.cpp b/frameworks/libs/distributeddb/syncer/src/single_ver_kv_syncer.cpp
index f65e58eacec..54a52589b63 100644
--- a/frameworks/libs/distributeddb/syncer/src/single_ver_kv_syncer.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/single_ver_kv_syncer.cpp
@@ -324,7 +324,7 @@ void SingleVerKVSyncer::TriggerAddSubscribeAsync(ISyncInterface *syncInterface)
     int errCode = RuntimeContext::GetInstance()->ScheduleTask([this, engine, storage, subscribeQuery]() {
         engine->AddSubscribe(storage, subscribeQuery);
         // try to trigger query sync after add trigger
-        LocalDataChanged(SQLITE_GENERAL_NS_PUT_EVENT);
+        LocalDataChanged(static_cast<int>(SQLiteGeneralNSNotificationEventType::SQLITE_GENERAL_NS_PUT_EVENT));
         storage->DecRefCount();
         RefObject::DecObjRef(engine);
     });
diff --git a/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.cpp
index c3e646adfc8..7e04aa9b522 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.cpp
@@ -1199,7 +1199,8 @@ bool DBInfoHandleTest::IsSupport()
 bool DBInfoHandleTest::IsNeedAutoSync(const std::string &userId, const std::string &appId, const std::string &storeId,
     const DeviceInfos &devInfo)
 {
-    return true;
+    std::lock_guard<std::mutex> autoLock(autoSyncMutex_);
+    return isNeedAutoSync_;
 }
 
 void DBInfoHandleTest::SetLocalIsSupport(bool isSupport)
@@ -1207,4 +1208,10 @@ void DBInfoHandleTest::SetLocalIsSupport(bool isSupport)
     std::lock_guard<std::mutex> autoLock(supportMutex_);
     localIsSupport_ = isSupport;
 }
+
+void DBInfoHandleTest::SetNeedAutoSync(bool needAutoSync)
+{
+    std::lock_guard<std::mutex> autoLock(autoSyncMutex_);
+    isNeedAutoSync_ = needAutoSync;
+}
 } // namespace DistributedDBUnitTest
diff --git a/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.h b/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.h
index 807fa4589b7..cbaa60b24dd 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.h
+++ b/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.h
@@ -338,9 +338,13 @@ public:
         const DistributedDB::DeviceInfos &devInfo) override;
 
     void SetLocalIsSupport(bool isSupport);
+
+    void SetNeedAutoSync(bool needAutoSync);
 private:
     std::mutex supportMutex_;
     bool localIsSupport_ = true;
+    std::mutex autoSyncMutex_;
+    bool isNeedAutoSync_ = true;
 };
 } // namespace DistributedDBUnitTest
 
diff --git a/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
index 4692eb4c898..48dc9e9e1ce 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
@@ -1332,4 +1332,29 @@ HWTEST_F(DistributedDBCommunicatorTest, DbStatusAdapter004, TestSize.Level1)
     }, nullptr, nullptr);
     adapterA->SetDBInfoHandle(nullptr);
     EXPECT_EQ(notifyCount, 2u); // 2 dbInfo is need sync now it should be offline
+}
+
+/**
+  * @tc.name: DbStatusAdapter005
+  * @tc.desc: Test adapter is need auto sync.
+  * @tc.type: FUNC
+  * @tc.require: AR000HGD0B
+  * @tc.author: zhangqiquan
+  */
+HWTEST_F(DistributedDBCommunicatorTest, DbStatusAdapter005, TestSize.Level1)
+{
+    const std::string deviceB = "DEVICES_B";
+    std::shared_ptr<DBStatusAdapter> adapterA = std::make_shared<DBStatusAdapter>();
+    std::shared_ptr<DBInfoHandleTest> handle = std::make_shared<DBInfoHandleTest>();
+    adapterA->SetDBInfoHandle(handle);
+    handle->SetLocalIsSupport(true);
+    EXPECT_EQ(adapterA->IsNeedAutoSync(USER_ID, APP_ID, STORE_ID_1, deviceB), true);
+    handle->SetNeedAutoSync(false);
+    EXPECT_EQ(adapterA->IsNeedAutoSync(USER_ID, APP_ID, STORE_ID_1, deviceB), false);
+    handle->SetLocalIsSupport(false);
+    EXPECT_EQ(adapterA->IsNeedAutoSync(USER_ID, APP_ID, STORE_ID_1, deviceB), false);
+    adapterA->SetDBInfoHandle(handle);
+    EXPECT_EQ(adapterA->IsNeedAutoSync(USER_ID, APP_ID, STORE_ID_1, deviceB), true);
+    adapterA->SetDBInfoHandle(nullptr);
+    EXPECT_EQ(adapterA->IsNeedAutoSync(USER_ID, APP_ID, STORE_ID_1, deviceB), true);
 }
\ No newline at end of file
-- 
Gitee


From 2d48a514cf2f1210c6d6a5647b4b251ab2cb3b00 Mon Sep 17 00:00:00 2001
From: zqq <zhangqiquan1@huawei.com>
Date: Tue, 17 Jan 2023 16:05:12 +0800
Subject: [PATCH 27/29] fix ut bug

Signed-off-by: zqq <zhangqiquan1@huawei.com>
---
 .../common/communicator/distributeddb_communicator_test.cpp      | 1 -
 1 file changed, 1 deletion(-)

diff --git a/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
index 48dc9e9e1ce..54a2661c621 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
@@ -1244,7 +1244,6 @@ HWTEST_F(DistributedDBCommunicatorTest, DbStatusAdapter001, TestSize.Level1)
     std::this_thread::sleep_for(std::chrono::seconds(1));
     EXPECT_EQ(actualRemoteDevInfo, deviceB);
     EXPECT_EQ(remoteInfoCount, 1u);
-    EXPECT_EQ(localCount, 1u);
     adapterA->SetRemoteOptimizeCommunication(deviceB, false);
     std::this_thread::sleep_for(std::chrono::seconds(1));
     EXPECT_EQ(remoteChangeCount, 1u);
-- 
Gitee


From b0f6301615f4a9d6a839b83e92b6bc50926168be Mon Sep 17 00:00:00 2001
From: zqq <zhangqiquan1@huawei.com>
Date: Fri, 5 May 2023 10:12:29 +0800
Subject: [PATCH 28/29] inc ref count when trigger sync

Signed-off-by: zqq <zhangqiquan1@huawei.com>
---
 .../syncer/src/single_ver_kv_syncer.cpp          | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/frameworks/libs/distributeddb/syncer/src/single_ver_kv_syncer.cpp b/frameworks/libs/distributeddb/syncer/src/single_ver_kv_syncer.cpp
index 54a52589b63..648d6b10926 100644
--- a/frameworks/libs/distributeddb/syncer/src/single_ver_kv_syncer.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/single_ver_kv_syncer.cpp
@@ -90,16 +90,20 @@ void SingleVerKVSyncer::LocalDataChanged(int notifyEvent)
         triggerSyncTask_ = true;
         return;
     }
-    RefObject::IncObjRef(syncEngine_);
+    ISyncEngine *engine = syncEngine_;
+    ISyncInterface *storage = syncInterface_;
+    RefObject::IncObjRef(engine);
+    storage->IncRefCount();
     // To avoid many task were produced and waiting in the queue. For example, put value in a loop.
     // It will consume thread pool resources, so other task will delay until these task finish.
     // In extreme situation, 10 thread run the localDataChanged task and 1 task waiting in queue.
-    int errCode = RuntimeContext::GetInstance()->ScheduleTask([this, devices] {
+    int errCode = RuntimeContext::GetInstance()->ScheduleTask([this, devices, engine, storage] {
         triggerSyncTask_ = true;
         if (!TryFullSync(devices)) {
             TriggerSubQuerySync(devices);
         }
-        RefObject::DecObjRef(syncEngine_);
+        RefObject::DecObjRef(engine);
+        storage->DecRefCount();
     });
     // if task schedule failed, but triggerSyncTask_ is not set to true, other thread may skip the schedule time
     // when task schedule failed, it means unormal status, it is unable to schedule next time probably
@@ -107,9 +111,9 @@ void SingleVerKVSyncer::LocalDataChanged(int notifyEvent)
     if (errCode != E_OK) {
         triggerSyncTask_ = true;
         LOGE("[TriggerSync] LocalDataChanged retCode:%d", errCode);
-        RefObject::DecObjRef(syncEngine_);
+        RefObject::DecObjRef(engine);
+        storage->DecRefCount();
     }
-    return;
 }
 
 // remote device online callback
@@ -325,8 +329,8 @@ void SingleVerKVSyncer::TriggerAddSubscribeAsync(ISyncInterface *syncInterface)
         engine->AddSubscribe(storage, subscribeQuery);
         // try to trigger query sync after add trigger
         LocalDataChanged(static_cast<int>(SQLiteGeneralNSNotificationEventType::SQLITE_GENERAL_NS_PUT_EVENT));
-        storage->DecRefCount();
         RefObject::DecObjRef(engine);
+        storage->DecRefCount();
     });
     if (errCode != E_OK) {
         LOGW("[SingleVerKVSyncer] TriggerAddSubscribeAsync failed errCode = %d", errCode);
-- 
Gitee


From 8ed48342d0e77fee19e33fb25d473c65d087b304 Mon Sep 17 00:00:00 2001
From: zqq <zhangqiquan1@huawei.com>
Date: Sat, 6 May 2023 14:37:59 +0800
Subject: [PATCH 29/29] add ut

Signed-off-by: zqq <zhangqiquan1@huawei.com>
---
 .../syncer/src/single_ver_kv_syncer.h         |  3 +-
 .../distributeddb_mock_sync_module_test.cpp   | 45 +++++++++++++++++++
 .../common/syncer/mock_single_ver_kv_syncer.h | 10 +++++
 .../unittest/common/syncer/mock_sync_engine.h |  5 +++
 4 files changed, 62 insertions(+), 1 deletion(-)

diff --git a/frameworks/libs/distributeddb/syncer/src/single_ver_kv_syncer.h b/frameworks/libs/distributeddb/syncer/src/single_ver_kv_syncer.h
index 8ecb4dfddbc..f2f6ca27dd1 100644
--- a/frameworks/libs/distributeddb/syncer/src/single_ver_kv_syncer.h
+++ b/frameworks/libs/distributeddb/syncer/src/single_ver_kv_syncer.h
@@ -42,13 +42,14 @@ protected:
 
     // Init the Sync engine
     int InitSyncEngine(ISyncInterface *syncInterface) override;
+
+    void TriggerAddSubscribeAsync(ISyncInterface *syncInterface);
 private:
     // if trigger full sync, no need to trigger query sync again
     bool TryFullSync(const std::vector<std::string> &devices);
 
     void TriggerSubQuerySync(const std::vector<std::string> &devices);
 
-    void TriggerAddSubscribeAsync(ISyncInterface *syncInterface);
     bool autoSyncEnable_;
     std::atomic<bool> triggerSyncTask_;
 };
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_mock_sync_module_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_mock_sync_module_test.cpp
index 852bde1f255..e10f0ac9236 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_mock_sync_module_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_mock_sync_module_test.cpp
@@ -2043,6 +2043,51 @@ HWTEST_F(DistributedDBMockSyncModuleTest, SyncerCheck007, TestSize.Level1)
     delete syncDBInterface;
 }
 
+/**
+ * @tc.name: SyncerCheck007
+ * @tc.desc: Test syncer call set sync retry before init.
+ * @tc.type: FUNC
+ * @tc.require: AR000CCPOM
+ * @tc.author: zhangqiquan
+ */
+HWTEST_F(DistributedDBMockSyncModuleTest, SyncerCheck007, TestSize.Level1)
+{
+    MockSingleVerKVSyncer syncer;
+    auto syncDBInterface = new(std::nothrow) MockKvSyncInterface();
+    ASSERT_NE(syncDBInterface, nullptr);
+    auto engine = new (std::nothrow) MockSyncEngine();
+    ASSERT_NE(engine, nullptr);
+    engine->InitSubscribeManager();
+    syncer.SetSyncEngine(engine);
+    int incRefCount = 0;
+    int decRefCount = 0;
+    EXPECT_CALL(*syncDBInterface, GetDBInfo(_)).WillRepeatedly([](DBInfo &) {
+    });
+    EXPECT_CALL(*syncDBInterface, IncRefCount()).WillRepeatedly([&incRefCount]() {
+        incRefCount++;
+    });
+    EXPECT_CALL(*syncDBInterface, DecRefCount()).WillRepeatedly([&decRefCount]() {
+        decRefCount++;
+    });
+    DBInfo info;
+    QuerySyncObject querySyncObject;
+    std::shared_ptr<DBInfoHandleTest> handleTest = std::make_shared<DBInfoHandleTest>();
+    RuntimeContext::GetInstance()->SetDBInfoHandle(handleTest);
+    RuntimeContext::GetInstance()->RecordRemoteSubscribe(info, "DEVICE", querySyncObject);
+
+    syncer.CallTriggerAddSubscribeAsync(syncDBInterface);
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+
+    RuntimeContext::GetInstance()->StopTaskPool();
+    RuntimeContext::GetInstance()->SetDBInfoHandle(nullptr);
+    syncer.SetSyncEngine(nullptr);
+
+    EXPECT_EQ(incRefCount, 1);
+    EXPECT_EQ(decRefCount, 1);
+    RefObject::KillAndDecObjRef(engine);
+    delete syncDBInterface;
+}
+
 /**
  * @tc.name: SessionId001
  * @tc.desc: Test syncer call set sync retry before init.
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/mock_single_ver_kv_syncer.h b/frameworks/libs/distributeddb/test/unittest/common/syncer/mock_single_ver_kv_syncer.h
index 4bb7d46e7be..69b775ba959 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/mock_single_ver_kv_syncer.h
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/mock_single_ver_kv_syncer.h
@@ -26,6 +26,16 @@ public:
         RecordTimeChangeOffset(changedOffset);
     }
 
+    void CallTriggerAddSubscribeAsync(ISyncInterface *syncInterface)
+    {
+        SingleVerKVSyncer::TriggerAddSubscribeAsync(syncInterface);
+    }
+
+    void SetSyncEngine(ISyncEngine *engine)
+    {
+        syncEngine_ = engine;
+    }
+
     void CallQueryAutoSync(const InternalSyncParma &param)
     {
         SingleVerKVSyncer::QueryAutoSync(param);
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/mock_sync_engine.h b/frameworks/libs/distributeddb/test/unittest/common/syncer/mock_sync_engine.h
index 1be10d2bc38..d1c44fb3dce 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/mock_sync_engine.h
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/mock_sync_engine.h
@@ -23,6 +23,11 @@ namespace DistributedDB {
 class MockSyncEngine : public SyncEngine {
 public:
     MOCK_METHOD0(CreateSyncTaskContext, ISyncTaskContext *(void));
+
+    void InitSubscribeManager()
+    {
+        subManager_ = std::make_shared<SubscribeManager>();
+    }
 };
 } // namespace DistributedDB
 #endif  // #define MOCK_SYNC_ENGINE_H
\ No newline at end of file
-- 
Gitee