diff --git a/services/distributeddataservice/framework/cloud/cloud_server.cpp b/services/distributeddataservice/framework/cloud/cloud_server.cpp
index 2841cf0b29aabee3ecd2b7e37b86428217946d42..5d718ee74ae1faf9e78e0e40505779549e15ddff 100644
--- a/services/distributeddataservice/framework/cloud/cloud_server.cpp
+++ b/services/distributeddataservice/framework/cloud/cloud_server.cpp
@@ -87,4 +87,9 @@ bool CloudServer::IsSupportCloud(int32_t userId)
 {
     return false;
 }
+
+bool CloudServer::CloudDriverUpdated(const std::string &bundleName)
+{
+    return false;
+}
 } // namespace OHOS::DistributedData
\ No newline at end of file
diff --git a/services/distributeddataservice/framework/cloud/schema_meta.cpp b/services/distributeddataservice/framework/cloud/schema_meta.cpp
index 7844058ae4dd70581a94cfd14959407429546665..273fc6b48eed65f1b6859108100c7abeb218dec7 100644
--- a/services/distributeddataservice/framework/cloud/schema_meta.cpp
+++ b/services/distributeddataservice/framework/cloud/schema_meta.cpp
@@ -23,6 +23,7 @@ bool SchemaMeta::Marshal(Serializable::json &node) const
     SetValue(node[GET_NAME(version)], version);
     SetValue(node[GET_NAME(bundleName)], bundleName);
     SetValue(node[GET_NAME(databases)], databases);
+    SetValue(node[GET_NAME(e2eeEnable)], e2eeEnable);
     return true;
 }
 
@@ -35,6 +36,7 @@ bool SchemaMeta::Unmarshal(const Serializable::json &node)
     GetValue(node, GET_NAME(bundleName), bundleName);
     GetValue(node, GET_NAME(databases), databases);
     GetValue(node, GET_NAME(dbSchema), databases);
+    GetValue(node, GET_NAME(e2eeEnable), e2eeEnable);
     return true;
 }
 
diff --git a/services/distributeddataservice/framework/include/cloud/cloud_server.h b/services/distributeddataservice/framework/include/cloud/cloud_server.h
index 9cb060c81f0b941b0356242c364dcf0d477df30a..0d87d02612e131aa0fba104d16696be18b85ca5d 100644
--- a/services/distributeddataservice/framework/include/cloud/cloud_server.h
+++ b/services/distributeddataservice/framework/include/cloud/cloud_server.h
@@ -43,6 +43,7 @@ public:
     virtual void ReleaseUserInfo(int32_t userId);
     virtual void Bind(std::shared_ptr<ExecutorPool> executor);
     virtual bool IsSupportCloud(int32_t userId);
+    virtual bool CloudDriverUpdated(const std::string &bundleName);
 
 private:
     static CloudServer *instance_;
diff --git a/services/distributeddataservice/framework/include/cloud/schema_meta.h b/services/distributeddataservice/framework/include/cloud/schema_meta.h
index 33dc0cb41946842ab8e357ee76d2baa23fde2325..889392199550eb6d11c11bbfba87f1beb4afdb3d 100644
--- a/services/distributeddataservice/framework/include/cloud/schema_meta.h
+++ b/services/distributeddataservice/framework/include/cloud/schema_meta.h
@@ -88,6 +88,7 @@ public:
     int32_t version = 0;
     std::string bundleName;
     std::vector<Database> databases;
+    bool e2eeEnable = false;
 
     bool Marshal(json &node) const override;
     bool Unmarshal(const json &node) override;
diff --git a/services/distributeddataservice/framework/include/store/general_store.h b/services/distributeddataservice/framework/include/store/general_store.h
index 7f1d83b3df1bf1d8df23abbf7c8c6bf0992d0fc1..0b56018c5678e068b105338e38cc885f8f53b674 100644
--- a/services/distributeddataservice/framework/include/store/general_store.h
+++ b/services/distributeddataservice/framework/include/store/general_store.h
@@ -114,6 +114,7 @@ public:
         int32_t maxNumber = 30;
         int32_t maxSize = 1024 * 512 * 3; // 1.5M
         int32_t maxRetryConflictTimes = 3;     // default max retry 3 times when version conflict
+        bool isSupportEncrypt = false;
     };
 
     enum class DistributedTableMode : int {
diff --git a/services/distributeddataservice/service/cloud/cloud_service_impl.cpp b/services/distributeddataservice/service/cloud/cloud_service_impl.cpp
index fdfbd83bc6fe6263bc7a375fdac2dff641cd629b..4404b855a04f323d13f47c38b0dac1e495275b94 100644
--- a/services/distributeddataservice/service/cloud/cloud_service_impl.cpp
+++ b/services/distributeddataservice/service/cloud/cloud_service_impl.cpp
@@ -74,6 +74,7 @@ static constexpr const char *FT_USER_UNLOCK = "USER_UNLOCK";
 static constexpr const char *FT_NETWORK_RECOVERY = "NETWORK_RECOVERY";
 static constexpr const char *FT_SERVICE_INIT = "SERVICE_INIT";
 static constexpr const char *FT_SYNC_TASK = "SYNC_TASK";
+static constexpr const char *FT_ENCRYPT_CHANGED = "ENCRYPT_CHANGED";
 static constexpr const char *CLOUD_SCHEMA = "arkdata/cloud/cloud_schema.json";
 __attribute__((used)) CloudServiceImpl::Factory CloudServiceImpl::factory_;
 const CloudServiceImpl::SaveStrategy CloudServiceImpl::STRATEGY_SAVERS[Strategy::STRATEGY_BUTT] = {
@@ -923,6 +924,54 @@ bool CloudServiceImpl::UpdateSchema(int32_t user, CloudSyncScene scene)
     return true;
 }
 
+/**
+* Will be called when 'cloudDriver' OnAppUpdate/OnAppInstall to get the newest 'e2eeEnable'.
+*/
+int32_t CloudServiceImpl::UpdateSchemaFromServer(int32_t user)
+{
+    auto [status, cloudInfo] = GetCloudInfo(user);
+    if (status != SUCCESS) {
+        ZLOGW("get cloud info failed, user:%{public}d, status:%{public}d", user, status);
+        return status;
+    }
+    return UpdateSchemaFromServer(cloudInfo, user);
+}
+
+int32_t CloudServiceImpl::UpdateSchemaFromServer(const CloudInfo &cloudInfo, int32_t user)
+{
+    auto keys = cloudInfo.GetSchemaKey();
+    for (const auto &[bundle, key] : keys) {
+        auto [status, schemaMeta] = GetAppSchemaFromServer(user, bundle);
+        if (status == NOT_SUPPORT) {
+            ZLOGW("app not support, del cloudInfo! user:%{public}d, bundleName:%{public}s", user, bundle.c_str());
+            MetaDataManager::GetInstance().DelMeta(cloudInfo.GetKey(), true);
+            return status;
+        }
+        if (status != SUCCESS) {
+            continue;
+        }
+        UpdateE2eeEnable(key, schemaMeta.e2eeEnable, bundle);
+    }
+    return SUCCESS;
+}
+
+void CloudServiceImpl::UpdateE2eeEnable(const std::string &schemaKey, bool newE2eeEnable,
+    const std::string &bundleName)
+{
+    SchemaMeta oldMeta;
+    if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, oldMeta, true)) {
+        return;
+    }
+    if (oldMeta.e2eeEnable == newE2eeEnable) {
+        return;
+    }
+    ZLOGI("Update e2eeEnable: %{public}d->%{public}d", oldMeta.e2eeEnable, newE2eeEnable);
+    oldMeta.e2eeEnable = newE2eeEnable;
+    Report(FT_ENCRYPT_CHANGED, Fault::CSF_APP_SCHEMA, bundleName,
+        "oldE2eeEnable=" + std::to_string(oldMeta.e2eeEnable) + ",newE2eeEnable=" + std::to_string(newE2eeEnable));
+    MetaDataManager::GetInstance().SaveMeta(schemaKey, oldMeta, true);
+}
+
 std::pair<int32_t, SchemaMeta> CloudServiceImpl::GetAppSchemaFromServer(int32_t user, const std::string &bundleName)
 {
     SchemaMeta schemaMeta;
@@ -1080,6 +1129,9 @@ int32_t CloudServiceImpl::CloudStatic::OnAppUninstall(const std::string &bundleN
 int32_t CloudServiceImpl::CloudStatic::OnAppInstall(const std::string &bundleName, int32_t user, int32_t index)
 {
     ZLOGI("bundleName:%{public}s,user:%{public}d,instanceId:%{public}d", bundleName.c_str(), user, index);
+    if (CloudDriverCheck(bundleName, user)) {
+        return SUCCESS;
+    }
     auto ret = UpdateCloudInfoFromServer(user);
     if (ret == E_OK) {
         StoreInfo info{.bundleName = bundleName,  .instanceId = index, .user = user};
@@ -1091,11 +1143,29 @@ int32_t CloudServiceImpl::CloudStatic::OnAppInstall(const std::string &bundleNam
 int32_t CloudServiceImpl::CloudStatic::OnAppUpdate(const std::string &bundleName, int32_t user, int32_t index)
 {
     ZLOGI("bundleName:%{public}s,user:%{public}d,instanceId:%{public}d", bundleName.c_str(), user, index);
+    if (CloudDriverCheck(bundleName, user)) {
+        return SUCCESS;
+    }
     HapInfo hapInfo{ .user = user, .instIndex = index, .bundleName = bundleName };
     Execute([this, hapInfo]() { UpdateSchemaFromHap(hapInfo); });
     return SUCCESS;
 }
 
+bool CloudServiceImpl::CloudStatic::CloudDriverCheck(const std::string &bundleName, int32_t user)
+{
+    auto instance = CloudServer::GetInstance();
+    if (instance == nullptr) {
+        return false;
+    }
+    if (instance->CloudDriverUpdated(bundleName)) {
+        // cloudDriver install, update schema(for update 'e2eeEnable')
+        ZLOGI("cloud driver check valid, bundleName:%{public}s, user:%{public}d", bundleName.c_str(), user);
+        Execute([this, user]() { UpdateSchemaFromServer(user); });
+        return true;
+    }
+    return false;
+}
+
 int32_t CloudServiceImpl::UpdateSchemaFromHap(const HapInfo &hapInfo)
 {
     auto [status, cloudInfo] = GetCloudInfoFromMeta(hapInfo.user);
diff --git a/services/distributeddataservice/service/cloud/cloud_service_impl.h b/services/distributeddataservice/service/cloud/cloud_service_impl.h
index 271627229a7ba6c5ac471add5935c537a87e38c3..4410519c14c0d09b7e8a50426a3e149b40db4be2 100644
--- a/services/distributeddataservice/service/cloud/cloud_service_impl.h
+++ b/services/distributeddataservice/service/cloud/cloud_service_impl.h
@@ -88,6 +88,8 @@ private:
         int32_t OnAppUninstall(const std::string &bundleName, int32_t user, int32_t index) override;
         int32_t OnAppInstall(const std::string &bundleName, int32_t user, int32_t index) override;
         int32_t OnAppUpdate(const std::string &bundleName, int32_t user, int32_t index) override;
+    private:
+        bool CloudDriverCheck(const std::string &bundleName, int32_t user);
     };
     class Factory {
     public:
@@ -197,11 +199,14 @@ private:
     using SaveStrategy = int32_t (*)(const std::vector<CommonType::Value> &values, const HapInfo &hapInfo);
     static const SaveStrategy STRATEGY_SAVERS[Strategy::STRATEGY_BUTT];
     static int32_t SaveNetworkStrategy(const std::vector<CommonType::Value> &values, const HapInfo &hapInfo);
-    void Report(const std::string &faultType, DistributedDataDfx::Fault errCode, const std::string &bundleName,
+    static void Report(const std::string &faultType, DistributedDataDfx::Fault errCode, const std::string &bundleName,
         const std::string &appendix);
 
     static std::pair<int32_t, SchemaMeta> GetSchemaFromHap(const HapInfo &hapInfo);
     static int32_t UpdateSchemaFromHap(const HapInfo &hapInfo);
+    static int32_t UpdateSchemaFromServer(int32_t user);
+    static int32_t UpdateSchemaFromServer(const CloudInfo &cloudInfo, int32_t user);
+    static void UpdateE2eeEnable(const std::string &schemaKey, bool newE2eeEnable, const std::string &bundleName);
     static void UpdateClearWaterMark(
         const HapInfo &hapInfo, const SchemaMeta &newSchemaMeta, const SchemaMeta &schemaMeta);
     QueryLastResults AssembleLastResults(const std::vector<Database> &databases,
diff --git a/services/distributeddataservice/service/cloud/sync_manager.cpp b/services/distributeddataservice/service/cloud/sync_manager.cpp
index db4e6099c6f1bca302c20adc550ee962b94f3983..03500258240f603c774451c70a40241c7804d519 100644
--- a/services/distributeddataservice/service/cloud/sync_manager.cpp
+++ b/services/distributeddataservice/service/cloud/sync_manager.cpp
@@ -623,7 +623,6 @@ std::pair<int32_t, AutoCache::Store> SyncManager::GetStore(const StoreMetaData &
         return { E_USER_UNLOCK, nullptr };
     }
     if (CloudServer::GetInstance() == nullptr) {
-        ZLOGD("not support cloud sync");
         return { E_NOT_SUPPORT, nullptr };
     }
     auto [status, store] = AutoCache::GetInstance().GetDBStore(meta, {});
@@ -662,6 +661,7 @@ std::pair<int32_t, AutoCache::Store> SyncManager::GetStore(const StoreMetaData &
         if (MetaDataManager::GetInstance().LoadMeta(info.GetKey(), info, true)) {
             config.maxNumber = info.maxNumber;
             config.maxSize = info.maxSize;
+            config.isSupportEncrypt = schemaMeta.e2eeEnable;
         }
         store->Bind(dbMeta, bindInfos, config);
     }
diff --git a/services/distributeddataservice/service/kvdb/kvdb_general_store.cpp b/services/distributeddataservice/service/kvdb/kvdb_general_store.cpp
index b2fab36ce1372baebde812d824559fdba10e5cac..ebb198a64dce9c5b4f0f332afbf35e32f0f82cea 100644
--- a/services/distributeddataservice/service/kvdb/kvdb_general_store.cpp
+++ b/services/distributeddataservice/service/kvdb/kvdb_general_store.cpp
@@ -257,6 +257,7 @@ int32_t KVDBGeneralStore::Bind(
     dbConfig.maxUploadCount = config.maxNumber;
     dbConfig.maxUploadSize = config.maxSize;
     dbConfig.maxRetryConflictTimes = config.maxRetryConflictTimes;
+    dbConfig.isSupportEncrypt = config.isSupportEncrypt;
     std::shared_lock<decltype(rwMutex_)> lock(rwMutex_);
     if (delegate_ == nullptr) {
         return GeneralError::E_ALREADY_CLOSED;
diff --git a/services/distributeddataservice/service/rdb/rdb_general_store.cpp b/services/distributeddataservice/service/rdb/rdb_general_store.cpp
index 33c2d657d296535b12065ce798a63558805a1403..4cfddd2788638de9c0a2aa7d48066af1ab69fb54 100644
--- a/services/distributeddataservice/service/rdb/rdb_general_store.cpp
+++ b/services/distributeddataservice/service/rdb/rdb_general_store.cpp
@@ -263,6 +263,7 @@ int32_t RdbGeneralStore::Bind(const Database &database, const std::map<uint32_t,
     dbConfig.maxUploadCount = config.maxNumber;
     dbConfig.maxUploadSize = config.maxSize;
     dbConfig.maxRetryConflictTimes = config.maxRetryConflictTimes;
+    dbConfig.isSupportEncrypt = config.isSupportEncrypt;
     DBSchema schema = GetDBSchema(database);
     std::shared_lock<decltype(rwMutex_)> lock(rwMutex_);
     if (delegate_ == nullptr) {
diff --git a/services/distributeddataservice/service/test/cloud_data_test.cpp b/services/distributeddataservice/service/test/cloud_data_test.cpp
index c9a6e00fafb185b64727478bcb2366249b73d881..ce7e8d8c88c7162bca1e80dcc27dd5a8b93266fe 100644
--- a/services/distributeddataservice/service/test/cloud_data_test.cpp
+++ b/services/distributeddataservice/service/test/cloud_data_test.cpp
@@ -243,6 +243,7 @@ void CloudDataTest::InitSchemaMeta()
     schemaMeta_.databases.emplace_back(database);
     database.alias = TEST_CLOUD_DATABASE_ALIAS_2;
     schemaMeta_.databases.emplace_back(database);
+    schemaMeta_.e2eeEnable = false;
 }
 
 void CloudDataTest::InitCloudInfo()
@@ -1058,7 +1059,7 @@ HWTEST_F(CloudDataTest, SetCloudStrategy001, TestSize.Level1)
 * @tc.type: FUNC
 * @tc.require:
  */
-HWTEST_F(CloudDataTest, CloudSync001, TestSize.Level1)
+HWTEST_F(CloudDataTest, CloudSync001, TestSize.Level0)
 {
     int32_t syncMode = DistributedData::GeneralStore::NEARBY_BEGIN;
     uint32_t seqNum = 10;
@@ -1073,7 +1074,7 @@ HWTEST_F(CloudDataTest, CloudSync001, TestSize.Level1)
 * @tc.type: FUNC
 * @tc.require:
  */
-HWTEST_F(CloudDataTest, CloudSync002, TestSize.Level1)
+HWTEST_F(CloudDataTest, CloudSync002, TestSize.Level0)
 {
     int32_t syncMode = DistributedData::GeneralStore::NEARBY_PULL_PUSH;
     uint32_t seqNum = 10;
@@ -1144,7 +1145,7 @@ HWTEST_F(CloudDataTest, CloudSync006, TestSize.Level1)
 * @tc.type: FUNC
 * @tc.require:
  */
-HWTEST_F(CloudDataTest, CloudSync007, TestSize.Level1)
+HWTEST_F(CloudDataTest, CloudSync007, TestSize.Level0)
 {
     int32_t syncMode = DistributedData::GeneralStore::CLOUD_END;
     uint32_t seqNum = 10;
@@ -1158,7 +1159,7 @@ HWTEST_F(CloudDataTest, CloudSync007, TestSize.Level1)
 * @tc.type: FUNC
 * @tc.require:
  */
-HWTEST_F(CloudDataTest, InitNotifier001, TestSize.Level1)
+HWTEST_F(CloudDataTest, InitNotifier001, TestSize.Level0)
 {
     sptr<IRemoteObject> notifier = nullptr;
     auto ret = cloudServiceImpl_->InitNotifier(notifier);
@@ -2157,6 +2158,68 @@ HWTEST_F(CloudDataTest, GetCloudInfo, TestSize.Level1)
     EXPECT_EQ(ret.first, CloudData::SUCCESS);
 }
 
+/**
+* @tc.name: UpdateSchemaFromServer_001
+* @tc.desc: Test get UpdateSchemaFromServer
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, UpdateSchemaFromServer_001, TestSize.Level1)
+{
+    auto status = cloudServiceImpl_->UpdateSchemaFromServer(cloudInfo_.user);
+    EXPECT_EQ(status, CloudData::SUCCESS);
+}
+
+/**
+ * @tc.name: OnAppInstallTest
+ * @tc.desc: Test the OnAppInstallTest
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(CloudDataTest, OnAppInstallTest, TestSize.Level1)
+{
+    ZLOGI("CloudDataTest OnAppInstallTest start");
+    ASSERT_NE(cloudServiceImpl_, nullptr);
+    ASSERT_NE(cloudServiceImpl_->factory_.staticActs_, nullptr);
+    int32_t index = 0;
+    auto status = cloudServiceImpl_->factory_.staticActs_->OnAppInstall(TEST_CLOUD_BUNDLE, cloudInfo_.user, index);
+    EXPECT_EQ(status, GeneralError::E_OK);
+}
+
+/**
+ * @tc.name: OnAppUpdateTest
+ * @tc.desc: Test the OnAppUpdateTest
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(CloudDataTest, OnAppUpdateTest, TestSize.Level1)
+{
+    ZLOGI("CloudDataTest OnAppUpdateTest start");
+    ASSERT_NE(cloudServiceImpl_, nullptr);
+    ASSERT_NE(cloudServiceImpl_->factory_.staticActs_, nullptr);
+    int32_t index = 0;
+    auto status = cloudServiceImpl_->factory_.staticActs_->OnAppUpdate(TEST_CLOUD_BUNDLE, cloudInfo_.user, index);
+    EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
+}
+
+/**
+* @tc.name: UpdateE2eeEnableTest
+* @tc.desc: Test the UpdateE2eeEnable
+* @tc.type: FUNC
+* @tc.require:
+*/
+HWTEST_F(CloudDataTest, UpdateE2eeEnableTest, TestSize.Level1)
+{
+    SchemaMeta schemaMeta;
+    std::string schemaKey = CloudInfo::GetSchemaKey(cloudInfo_.user, TEST_CLOUD_BUNDLE, 0);
+    ASSERT_TRUE(MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true));
+    EXPECT_EQ(schemaMeta.e2eeEnable, schemaMeta_.e2eeEnable);
+
+    ASSERT_NE(cloudServiceImpl_, nullptr);
+    EXPECT_NO_FATAL_FAILURE(cloudServiceImpl_->UpdateE2eeEnable(schemaKey, false, TEST_CLOUD_BUNDLE));
+    EXPECT_NO_FATAL_FAILURE(cloudServiceImpl_->UpdateE2eeEnable(schemaKey, true, TEST_CLOUD_BUNDLE));
+}
+
 /**
 * @tc.name: SubTask
 * @tc.desc: Test the subtask execution logic
diff --git a/services/distributeddataservice/service/test/cloud_service_impl_test.cpp b/services/distributeddataservice/service/test/cloud_service_impl_test.cpp
index 08aea3fe6451f09d191ad1324ee66d32fa652c78..253832a641e4b4ac4fdaf77cb066323e5dc530ab 100644
--- a/services/distributeddataservice/service/test/cloud_service_impl_test.cpp
+++ b/services/distributeddataservice/service/test/cloud_service_impl_test.cpp
@@ -326,6 +326,110 @@ HWTEST_F(CloudServiceImplTest, DoSubscribe, TestSize.Level0)
     EXPECT_TRUE(status);
 }
 
+/**
+ * @tc.name: OnAppInstallTest
+ * @tc.desc: Test the OnAppInstallTest
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(CloudServiceImplTest, OnAppInstallTest, TestSize.Level0)
+{
+    ZLOGI("CloudServiceImplTest OnAppInstallTest start");
+    ASSERT_NE(cloudServiceImpl_, nullptr);
+    ASSERT_NE(cloudServiceImpl_->factory_.staticActs_, nullptr);
+    int32_t user = 0;
+    int32_t index = 0;
+    auto status = cloudServiceImpl_->factory_.staticActs_->OnAppInstall(TEST_CLOUD_BUNDLE, user, index);
+    EXPECT_EQ(status, GeneralError::E_ERROR);
+}
+
+/**
+ * @tc.name: OnAppUpdateTest
+ * @tc.desc: Test the OnAppUpdateTest
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(CloudServiceImplTest, OnAppUpdateTest, TestSize.Level0)
+{
+    ZLOGI("CloudServiceImplTest OnAppUpdateTest start");
+    ASSERT_NE(cloudServiceImpl_, nullptr);
+    ASSERT_NE(cloudServiceImpl_->factory_.staticActs_, nullptr);
+    int32_t user = 0;
+    int32_t index = 0;
+    auto status = cloudServiceImpl_->factory_.staticActs_->OnAppUpdate(TEST_CLOUD_BUNDLE, user, index);
+    EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
+}
+
+/**
+ * @tc.name: CloudDriverCheckTest
+ * @tc.desc: Test the CloudDriverCheck
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(CloudServiceImplTest, CloudDriverCheckTest, TestSize.Level0)
+{
+    ZLOGI("CloudServiceImplTest CloudDriverCheckTest start");
+    ASSERT_NE(cloudServiceImpl_, nullptr);
+    ASSERT_NE(cloudServiceImpl_->factory_.staticActs_, nullptr);
+    int32_t user = 0;
+    auto result = cloudServiceImpl_->factory_.staticActs_->CloudDriverCheck(TEST_CLOUD_BUNDLE, user);
+    EXPECT_EQ(result, false);
+}
+
+/**
+ * @tc.name: UpdateSchemaFromServerTest_001
+ * @tc.desc: Test UpdateSchemaFromServer functions
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(CloudServiceImplTest, UpdateSchemaFromServerTest_001, TestSize.Level0)
+{
+    ZLOGI("CloudServiceImplTest UpdateSchemaFromServerTest_001 start");
+    CloudServer cloudServer;
+    CloudServer::RegisterCloudInstance(&cloudServer);
+    int user = 100;
+    auto status = cloudServiceImpl_->UpdateSchemaFromServer(user);
+    EXPECT_EQ(status, E_ERROR);
+    CloudServer::instance_ = nullptr;
+}
+
+/**
+ * @tc.name: UpdateSchemaFromServerTest_002
+ * @tc.desc: Test UpdateSchemaFromServer functions.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(CloudServiceImplTest, UpdateSchemaFromServerTest_002, TestSize.Level0)
+{
+    ZLOGI("CloudServiceImplTest UpdateSchemaFromServerTest_002 start");
+    CloudServer cloudServer;
+    CloudServer::RegisterCloudInstance(&cloudServer);
+    int user = 0;
+    CloudInfo cloudInfo;
+    cloudInfo.user = user;
+    DistributedData::CloudInfo::AppInfo appInfo;
+    appInfo.bundleName = TEST_CLOUD_BUNDLE;
+    appInfo.appId = TEST_CLOUD_APPID;
+    appInfo.cloudSwitch = true;
+    cloudInfo.apps = {{ TEST_CLOUD_BUNDLE, appInfo }};
+    auto status = cloudServiceImpl_->UpdateSchemaFromServer(cloudInfo, user);
+    EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
+    CloudServer::instance_ = nullptr;
+}
+
+/**
+ * @tc.name: UpdateE2eeEnableTest
+ * @tc.desc: Test UpdateE2eeEnable functions.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(CloudServiceImplTest, UpdateE2eeEnableTest, TestSize.Level0)
+{
+    ZLOGI("CloudServiceImplTest UpdateE2eeEnableTest start");
+    std::string schemaKey = "schemaKey";
+    EXPECT_NO_FATAL_FAILURE(cloudServiceImpl_->UpdateE2eeEnable(schemaKey, true, TEST_CLOUD_BUNDLE));
+}
+
 /**
  * @tc.name: Share001
  * @tc.desc: Test the Share with invalid parameters