• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #define LOG_TAG "KVDBServiceImpl"
16 #include "kvdb_service_impl.h"
17 
18 #include <chrono>
19 #include <cinttypes>
20 
21 #include "accesstoken_kit.h"
22 #include "account/account_delegate.h"
23 #include "backup_manager.h"
24 #include "bootstrap.h"
25 #include "checker/checker_manager.h"
26 #include "cloud/change_event.h"
27 #include "cloud/cloud_server.h"
28 #include "communication_provider.h"
29 #include "communicator_context.h"
30 #include "crypto_manager.h"
31 #include "device_manager_adapter.h"
32 #include "directory/directory_manager.h"
33 #include "dump/dump_manager.h"
34 #include "eventcenter/event_center.h"
35 #include "ipc_skeleton.h"
36 #include "kvdb_general_store.h"
37 #include "kvdb_query.h"
38 #include "kv_radar_reporter.h"
39 #include "log_print.h"
40 #include "matrix_event.h"
41 #include "metadata/appid_meta_data.h"
42 #include "metadata/capability_meta_data.h"
43 #include "metadata/switches_meta_data.h"
44 #include "permit_delegate.h"
45 #include "query_helper.h"
46 #include "store/store_info.h"
47 #include "upgrade.h"
48 #include "utils/anonymous.h"
49 #include "utils/constant.h"
50 #include "utils/converter.h"
51 #include "water_version_manager.h"
52 
53 namespace OHOS::DistributedKv {
54 using namespace OHOS::DistributedData;
55 using namespace OHOS::AppDistributedKv;
56 using namespace OHOS::Security::AccessToken;
57 using system_clock = std::chrono::system_clock;
58 using DMAdapter = DistributedData::DeviceManagerAdapter;
59 using DumpManager = OHOS::DistributedData::DumpManager;
60 using CommContext = OHOS::DistributedData::CommunicatorContext;
61 static constexpr const char *DEFAULT_USER_ID = "0";
62 __attribute__((used)) KVDBServiceImpl::Factory KVDBServiceImpl::factory_;
Factory()63 KVDBServiceImpl::Factory::Factory()
64 {
65     FeatureSystem::GetInstance().RegisterCreator("kv_store", [this]() {
66         if (product_ == nullptr) {
67             product_ = std::make_shared<KVDBServiceImpl>();
68         }
69         return product_;
70     });
71     auto creator = [](const StoreMetaData &metaData) -> GeneralStore* {
72         auto store = new (std::nothrow) KVDBGeneralStore(metaData);
73         if (store != nullptr && !store->IsValid()) {
74             delete store;
75             store = nullptr;
76         }
77         return store;
78     };
79     AutoCache::GetInstance().RegCreator(KvStoreType::SINGLE_VERSION, creator);
80     AutoCache::GetInstance().RegCreator(KvStoreType::DEVICE_COLLABORATION, creator);
81 }
82 
~Factory()83 KVDBServiceImpl::Factory::~Factory()
84 {
85     product_ = nullptr;
86 }
87 
KVDBServiceImpl()88 KVDBServiceImpl::KVDBServiceImpl()
89 {
90 }
91 
~KVDBServiceImpl()92 KVDBServiceImpl::~KVDBServiceImpl()
93 {
94     DumpManager::GetInstance().RemoveHandler("FEATURE_INFO", uintptr_t(this));
95 }
96 
Init()97 void KVDBServiceImpl::Init()
98 {
99     auto process = [this](const Event &event) {
100         const auto &evt = static_cast<const CloudEvent &>(event);
101         const auto &storeInfo = evt.GetStoreInfo();
102         StoreMetaData meta(storeInfo);
103         meta.deviceId = DMAdapter::GetInstance().GetLocalDevice().uuid;
104         if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) {
105             ZLOGE("meta empty, bundleName:%{public}s, storeId:%{public}s, user = %{public}s", meta.bundleName.c_str(),
106                 meta.GetStoreAlias().c_str(), meta.user.c_str());
107             if (meta.user == "0") {
108                 return;
109             }
110             meta.user = "0";
111             StoreMetaDataLocal localMeta;
112             if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKeyLocal(), localMeta, true) || !localMeta.isPublic ||
113                 !MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) {
114                 ZLOGE("meta empty, not public store.");
115                 return;
116             }
117         }
118         if (meta.storeType < StoreMetaData::StoreType::STORE_KV_BEGIN ||
119             meta.storeType > StoreMetaData::StoreType::STORE_KV_END) {
120             return;
121         }
122         auto watchers = GetWatchers(meta.tokenId, meta.storeId);
123         auto store = AutoCache::GetInstance().GetStore(meta, watchers);
124         if (store == nullptr) {
125             ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str());
126             return;
127         }
128         store->RegisterDetailProgressObserver(nullptr);
129     };
130     EventCenter::GetInstance().Subscribe(CloudEvent::CLOUD_SYNC, process);
131     EventCenter::GetInstance().Subscribe(CloudEvent::CLEAN_DATA, process);
132 }
133 
RegisterKvServiceInfo()134 void KVDBServiceImpl::RegisterKvServiceInfo()
135 {
136     OHOS::DistributedData::DumpManager::Config serviceInfoConfig;
137     serviceInfoConfig.fullCmd = "--feature-info";
138     serviceInfoConfig.abbrCmd = "-f";
139     serviceInfoConfig.dumpName = "FEATURE_INFO";
140     serviceInfoConfig.dumpCaption = { "| Display all the service statistics" };
141     DumpManager::GetInstance().AddConfig("FEATURE_INFO", serviceInfoConfig);
142 }
143 
RegisterHandler()144 void KVDBServiceImpl::RegisterHandler()
145 {
146     Handler handler =
147         std::bind(&KVDBServiceImpl::DumpKvServiceInfo, this, std::placeholders::_1, std::placeholders::_2);
148     DumpManager::GetInstance().AddHandler("FEATURE_INFO", uintptr_t(this), handler);
149 }
150 
DumpKvServiceInfo(int fd,std::map<std::string,std::vector<std::string>> & params)151 void KVDBServiceImpl::DumpKvServiceInfo(int fd, std::map<std::string, std::vector<std::string>> &params)
152 {
153     (void)params;
154     std::string info;
155     dprintf(fd, "-------------------------------------KVDBServiceInfo------------------------------\n%s\n",
156         info.c_str());
157 }
158 
GetStoreIds(const AppId & appId,std::vector<StoreId> & storeIds)159 Status KVDBServiceImpl::GetStoreIds(const AppId &appId, std::vector<StoreId> &storeIds)
160 {
161     std::vector<StoreMetaData> metaData;
162     auto user = AccountDelegate::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID());
163     auto deviceId = DMAdapter::GetInstance().GetLocalDevice().uuid;
164     auto prefix = StoreMetaData::GetPrefix({ deviceId, std::to_string(user), "default", appId.appId });
165     auto instanceId = GetInstIndex(IPCSkeleton::GetCallingTokenID(), appId);
166     MetaDataManager::GetInstance().LoadMeta(prefix, metaData, true);
167     for (auto &item : metaData) {
168         if (item.storeType > KvStoreType::MULTI_VERSION || item.instanceId != instanceId) {
169             continue;
170         }
171         storeIds.push_back({ item.storeId });
172     }
173     ZLOGD("appId:%{public}s store size:%{public}zu", appId.appId.c_str(), storeIds.size());
174     return SUCCESS;
175 }
176 
Delete(const AppId & appId,const StoreId & storeId)177 Status KVDBServiceImpl::Delete(const AppId &appId, const StoreId &storeId)
178 {
179     StoreMetaData metaData = GetStoreMetaData(appId, storeId);
180     if (metaData.instanceId < 0) {
181         return ILLEGAL_STATE;
182     }
183 
184     auto tokenId = IPCSkeleton::GetCallingTokenID();
185     syncAgents_.ComputeIfPresent(tokenId, [&appId, &storeId](auto &key, SyncAgent &syncAgent) {
186         if (syncAgent.pid_ != IPCSkeleton::GetCallingPid()) {
187             ZLOGW("agent already changed! old pid:%{public}d new pid:%{public}d appId:%{public}s",
188                 IPCSkeleton::GetCallingPid(), syncAgent.pid_, appId.appId.c_str());
189             return true;
190         }
191         syncAgent.delayTimes_.erase(storeId);
192         return true;
193     });
194     MetaDataManager::GetInstance().DelMeta(metaData.GetKey());
195     MetaDataManager::GetInstance().DelMeta(metaData.GetKey(), true);
196     MetaDataManager::GetInstance().DelMeta(metaData.GetKeyLocal(), true);
197     MetaDataManager::GetInstance().DelMeta(metaData.GetSecretKey(), true);
198     MetaDataManager::GetInstance().DelMeta(metaData.GetStrategyKey());
199     MetaDataManager::GetInstance().DelMeta(metaData.GetBackupSecretKey(), true);
200     MetaDataManager::GetInstance().DelMeta(metaData.GetAutoLaunchKey(), true);
201     MetaDataManager::GetInstance().DelMeta(metaData.GetDebugInfoKey(), true);
202     PermitDelegate::GetInstance().DelCache(metaData.GetKey());
203     AutoCache::GetInstance().CloseStore(tokenId, storeId);
204     ZLOGD("appId:%{public}s storeId:%{public}s instanceId:%{public}d", appId.appId.c_str(),
205         Anonymous::Change(storeId.storeId).c_str(), metaData.instanceId);
206     return SUCCESS;
207 }
208 
Close(const AppId & appId,const StoreId & storeId)209 Status KVDBServiceImpl::Close(const AppId &appId, const StoreId &storeId)
210 {
211     StoreMetaData metaData = GetStoreMetaData(appId, storeId);
212     if (metaData.instanceId < 0) {
213         return ILLEGAL_STATE;
214     }
215     auto tokenId = IPCSkeleton::GetCallingTokenID();
216     AutoCache::GetInstance().CloseStore(tokenId, storeId);
217     ZLOGD("appId:%{public}s storeId:%{public}s instanceId:%{public}d", appId.appId.c_str(),
218         Anonymous::Change(storeId.storeId).c_str(), metaData.instanceId);
219     return SUCCESS;
220 }
221 
CloudSync(const AppId & appId,const StoreId & storeId,const SyncInfo & syncInfo)222 Status KVDBServiceImpl::CloudSync(const AppId &appId, const StoreId &storeId, const SyncInfo &syncInfo)
223 {
224     StoreMetaData metaData = GetStoreMetaData(appId, storeId);
225     if (!MetaDataManager::GetInstance().LoadMeta(metaData.GetKey(), metaData, true)) {
226         ZLOGE("invalid, appId:%{public}s storeId:%{public}s",
227             appId.appId.c_str(), Anonymous::Change(storeId.storeId).c_str());
228         return Status::INVALID_ARGUMENT;
229     }
230     return DoCloudSync(metaData, syncInfo);
231 }
232 
OnAsyncComplete(uint32_t tokenId,uint64_t seqNum,ProgressDetail && detail)233 void KVDBServiceImpl::OnAsyncComplete(uint32_t tokenId, uint64_t seqNum, ProgressDetail &&detail)
234 {
235     ZLOGI("tokenId=%{public}x seqnum=%{public}" PRIu64, tokenId, seqNum);
236     auto [success, agent] = syncAgents_.Find(tokenId);
237     if (success && agent.notifier_ != nullptr) {
238         agent.notifier_->SyncCompleted(seqNum, std::move(detail));
239     }
240 }
241 
Sync(const AppId & appId,const StoreId & storeId,SyncInfo & syncInfo)242 Status KVDBServiceImpl::Sync(const AppId &appId, const StoreId &storeId, SyncInfo &syncInfo)
243 {
244     StoreMetaData metaData = GetStoreMetaData(appId, storeId);
245     MetaDataManager::GetInstance().LoadMeta(metaData.GetKey(), metaData);
246     auto delay = GetSyncDelayTime(syncInfo.delay, storeId);
247     if (metaData.isAutoSync && syncInfo.seqId == std::numeric_limits<uint64_t>::max()) {
248         DeviceMatrix::GetInstance().OnChanged(metaData);
249         StoreMetaDataLocal localMeta;
250         MetaDataManager::GetInstance().LoadMeta(metaData.GetKeyLocal(), localMeta, true);
251         if (!localMeta.HasPolicy(IMMEDIATE_SYNC_ON_CHANGE)) {
252             ZLOGW("appId:%{public}s storeId:%{public}s no IMMEDIATE_SYNC_ON_CHANGE ", appId.appId.c_str(),
253                 Anonymous::Change(storeId.storeId).c_str());
254             return Status::SUCCESS;
255         }
256     }
257     syncInfo.syncId = ++syncId_;
258     RADAR_REPORT(STANDARD_DEVICE_SYNC, ADD_SYNC_TASK, RADAR_SUCCESS, BIZ_STATE, START,
259         SYNC_STORE_ID, Anonymous::Change(storeId.storeId), SYNC_APP_ID, appId.appId, CONCURRENT_ID,
260         std::to_string(syncInfo.syncId), DATA_TYPE, metaData.dataType, SYNC_TYPE,
261         SYNC, OS_TYPE, IsOHOSType(syncInfo.devices));
262     return KvStoreSyncManager::GetInstance()->AddSyncOperation(uintptr_t(metaData.tokenId), delay,
263         std::bind(&KVDBServiceImpl::DoSyncInOrder, this, metaData, syncInfo, std::placeholders::_1, ACTION_SYNC),
264         std::bind(&KVDBServiceImpl::DoComplete, this, metaData, syncInfo, RefCount(), std::placeholders::_1));
265 }
266 
NotifyDataChange(const AppId & appId,const StoreId & storeId,uint64_t delay)267 Status KVDBServiceImpl::NotifyDataChange(const AppId &appId, const StoreId &storeId, uint64_t delay)
268 {
269     StoreMetaData meta = GetStoreMetaData(appId, storeId);
270     if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta)) {
271         ZLOGE("invalid, appId:%{public}s storeId:%{public}s",
272             appId.appId.c_str(), Anonymous::Change(storeId.storeId).c_str());
273         return Status::INVALID_ARGUMENT;
274     }
275     if (DeviceMatrix::GetInstance().IsSupportMatrix() &&
276         (DeviceMatrix::GetInstance().IsStatics(meta) || DeviceMatrix::GetInstance().IsDynamic(meta))) {
277         WaterVersionManager::GetInstance().GenerateWaterVersion(meta.bundleName, meta.storeId);
278         DeviceMatrix::GetInstance().OnChanged(meta);
279     }
280 
281     if (executors_ != nullptr && (meta.cloudAutoSync)) {
282         executors_->Schedule(std::chrono::milliseconds(delay), [this, meta]() {
283             if (meta.cloudAutoSync) {
284                 DoCloudSync(meta, {});
285             }
286         });
287     }
288     return SUCCESS;
289 }
290 
PutSwitch(const AppId & appId,const SwitchData & data)291 Status KVDBServiceImpl::PutSwitch(const AppId &appId, const SwitchData &data)
292 {
293     if (data.value == DeviceMatrix::INVALID_VALUE || data.length == DeviceMatrix::INVALID_LENGTH) {
294         return Status::INVALID_ARGUMENT;
295     }
296     auto deviceId = DMAdapter::GetInstance().GetLocalDevice().uuid;
297     SwitchesMetaData oldMeta;
298     oldMeta.deviceId = deviceId;
299     bool exist = MetaDataManager::GetInstance().LoadMeta(oldMeta.GetKey(), oldMeta, true);
300     SwitchesMetaData newMeta;
301     newMeta.value = data.value;
302     newMeta.length = data.length;
303     newMeta.deviceId = deviceId;
304     if (!exist || newMeta != oldMeta) {
305         bool success = MetaDataManager::GetInstance().SaveMeta(newMeta.GetKey(), newMeta, true);
306         if (success) {
307             ZLOGI("start broadcast swicthes data");
308             DeviceMatrix::DataLevel level = {
309                 .switches = data.value,
310                 .switchesLen = data.length,
311             };
312             RADAR_REPORT(BROADCAST_DEVICE_SYNC, SEND_BROADCAST, RADAR_START, BIZ_STATE, START,
313                 SYNC_APP_ID, appId.appId);
314             DeviceMatrix::GetInstance().Broadcast(level);
315             RADAR_REPORT(BROADCAST_DEVICE_SYNC, SEND_BROADCAST, RADAR_SUCCESS, BIZ_STATE, END,
316                 SYNC_APP_ID, appId.appId);
317         }
318     }
319     ZLOGI("appId:%{public}s, exist:%{public}d, saved:%{public}d", appId.appId.c_str(), exist, newMeta != oldMeta);
320     return Status::SUCCESS;
321 }
322 
GetSwitch(const AppId & appId,const std::string & networkId,SwitchData & data)323 Status KVDBServiceImpl::GetSwitch(const AppId &appId, const std::string &networkId, SwitchData &data)
324 {
325     auto uuid = DMAdapter::GetInstance().ToUUID(networkId);
326     if (uuid.empty()) {
327         return Status::INVALID_ARGUMENT;
328     }
329     SwitchesMetaData meta;
330     meta.deviceId = uuid;
331     if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) {
332         return Status::NOT_FOUND;
333     }
334     data.value = meta.value;
335     data.length = meta.length;
336     return Status::SUCCESS;
337 }
338 
RegServiceNotifier(const AppId & appId,sptr<IKVDBNotifier> notifier)339 Status KVDBServiceImpl::RegServiceNotifier(const AppId &appId, sptr<IKVDBNotifier> notifier)
340 {
341     auto tokenId = IPCSkeleton::GetCallingTokenID();
342     syncAgents_.Compute(tokenId, [&appId, notifier](const auto &, SyncAgent &value) {
343         if (value.pid_ != IPCSkeleton::GetCallingPid()) {
344             value.ReInit(IPCSkeleton::GetCallingPid(), appId);
345         }
346         value.notifier_ = notifier;
347         return true;
348     });
349     return Status::SUCCESS;
350 }
351 
UnregServiceNotifier(const AppId & appId)352 Status KVDBServiceImpl::UnregServiceNotifier(const AppId &appId)
353 {
354     syncAgents_.ComputeIfPresent(IPCSkeleton::GetCallingTokenID(), [&appId](const auto &key, SyncAgent &value) {
355         if (value.pid_ != IPCSkeleton::GetCallingPid()) {
356             ZLOGW("agent already changed! old pid:%{public}d, new pid:%{public}d, appId:%{public}s",
357                 IPCSkeleton::GetCallingPid(), value.pid_, appId.appId.c_str());
358             return true;
359         }
360         value.notifier_ = nullptr;
361         return true;
362     });
363     return SUCCESS;
364 }
365 
SubscribeSwitchData(const AppId & appId)366 Status KVDBServiceImpl::SubscribeSwitchData(const AppId &appId)
367 {
368     sptr<IKVDBNotifier> notifier = nullptr;
369     auto tokenId = IPCSkeleton::GetCallingTokenID();
370     syncAgents_.Compute(tokenId, [&appId, &notifier](const auto &, SyncAgent &value) {
371         if (value.pid_ != IPCSkeleton::GetCallingPid()) {
372             value.ReInit(IPCSkeleton::GetCallingPid(), appId);
373         }
374         if (value.switchesObserverCount_ == 0) {
375             notifier = value.notifier_;
376         }
377         value.switchesObserverCount_++;
378         return true;
379     });
380     if (notifier == nullptr) {
381         return SUCCESS;
382     }
383     bool success = MetaDataManager::GetInstance().Subscribe(SwitchesMetaData::GetPrefix({}),
384         [this, notifier](const std::string &key, const std::string &meta, int32_t action) {
385             SwitchesMetaData metaData;
386             if (!SwitchesMetaData::Unmarshall(meta, metaData)) {
387                 ZLOGE("unmarshall matrix meta failed, action:%{public}d", action);
388                 return true;
389             }
390             auto networkId = DMAdapter::GetInstance().ToNetworkID(metaData.deviceId);
391             SwitchNotification notification;
392             notification.deviceId = std::move(networkId);
393             notification.data.value = metaData.value;
394             notification.data.length = metaData.length;
395             notification.state = ConvertAction(static_cast<Action>(action));
396             if (notifier != nullptr) {
397                 notifier->OnSwitchChange(std::move(notification));
398             }
399             return true;
400         }, true);
401     ZLOGI("subscribe switch status:%{public}d", success);
402     return SUCCESS;
403 }
404 
UnsubscribeSwitchData(const AppId & appId)405 Status KVDBServiceImpl::UnsubscribeSwitchData(const AppId &appId)
406 {
407     bool destroyed = false;
408     auto tokenId = IPCSkeleton::GetCallingTokenID();
409     syncAgents_.ComputeIfPresent(tokenId, [&destroyed](auto &key, SyncAgent &value) {
410         if (value.switchesObserverCount_ > 0) {
411             value.switchesObserverCount_--;
412         }
413         if (value.switchesObserverCount_ == 0) {
414             destroyed = true;
415         }
416         return true;
417     });
418     if (destroyed) {
419         bool status = MetaDataManager::GetInstance().Unsubscribe(SwitchesMetaData::GetPrefix({}));
420         ZLOGI("unsubscribe switch status %{public}d", status);
421     }
422     return SUCCESS;
423 }
424 
HandleGenDetails(const GenDetails & details)425 ProgressDetail KVDBServiceImpl::HandleGenDetails(const GenDetails &details)
426 {
427     ProgressDetail progressDetail;
428     if (details.begin() == details.end()) {
429         return {};
430     }
431     auto genDetail = details.begin()->second;
432     progressDetail.progress = genDetail.progress;
433     progressDetail.code = genDetail.code;
434     auto tableDetails = genDetail.details;
435     if (tableDetails.begin() == tableDetails.end()) {
436         return progressDetail;
437     }
438     auto genTableDetail = tableDetails.begin()->second;
439     auto &tableDetail = progressDetail.details;
440     Constant::Copy(&tableDetail, &genTableDetail);
441     return progressDetail;
442 }
443 
SetSyncParam(const AppId & appId,const StoreId & storeId,const KvSyncParam & syncParam)444 Status KVDBServiceImpl::SetSyncParam(const AppId &appId, const StoreId &storeId, const KvSyncParam &syncParam)
445 {
446     if (syncParam.allowedDelayMs > 0 && syncParam.allowedDelayMs < KvStoreSyncManager::SYNC_MIN_DELAY_MS) {
447         return Status::INVALID_ARGUMENT;
448     }
449     if (syncParam.allowedDelayMs > KvStoreSyncManager::SYNC_MAX_DELAY_MS) {
450         return Status::INVALID_ARGUMENT;
451     }
452     auto tokenId = IPCSkeleton::GetCallingTokenID();
453     syncAgents_.Compute(tokenId, [&appId, &storeId, &syncParam](auto &key, SyncAgent &value) {
454         if (value.pid_ != IPCSkeleton::GetCallingPid()) {
455             value.ReInit(IPCSkeleton::GetCallingPid(), appId);
456         }
457         value.delayTimes_[storeId] = syncParam.allowedDelayMs;
458         return true;
459     });
460     return SUCCESS;
461 }
462 
GetSyncParam(const AppId & appId,const StoreId & storeId,KvSyncParam & syncParam)463 Status KVDBServiceImpl::GetSyncParam(const AppId &appId, const StoreId &storeId, KvSyncParam &syncParam)
464 {
465     syncParam.allowedDelayMs = 0;
466     auto tokenId = IPCSkeleton::GetCallingTokenID();
467     syncAgents_.ComputeIfPresent(tokenId, [&appId, &storeId, &syncParam](auto &key, SyncAgent &value) {
468         if (value.pid_ != IPCSkeleton::GetCallingPid()) {
469             ZLOGW("agent already changed! old pid:%{public}d, new pid:%{public}d, appId:%{public}s",
470                 IPCSkeleton::GetCallingPid(), value.pid_, appId.appId.c_str());
471             return true;
472         }
473 
474         auto it = value.delayTimes_.find(storeId);
475         if (it != value.delayTimes_.end()) {
476             syncParam.allowedDelayMs = it->second;
477         }
478         return true;
479     });
480     return SUCCESS;
481 }
482 
EnableCapability(const AppId & appId,const StoreId & storeId)483 Status KVDBServiceImpl::EnableCapability(const AppId &appId, const StoreId &storeId)
484 {
485     StrategyMeta strategyMeta = GetStrategyMeta(appId, storeId);
486     if (strategyMeta.instanceId < 0) {
487         return ILLEGAL_STATE;
488     }
489     MetaDataManager::GetInstance().LoadMeta(strategyMeta.GetKey(), strategyMeta);
490     strategyMeta.capabilityEnabled = true;
491     MetaDataManager::GetInstance().SaveMeta(strategyMeta.GetKey(), strategyMeta);
492     return SUCCESS;
493 }
494 
DisableCapability(const AppId & appId,const StoreId & storeId)495 Status KVDBServiceImpl::DisableCapability(const AppId &appId, const StoreId &storeId)
496 {
497     StrategyMeta strategyMeta = GetStrategyMeta(appId, storeId);
498     if (strategyMeta.instanceId < 0) {
499         return ILLEGAL_STATE;
500     }
501     MetaDataManager::GetInstance().LoadMeta(strategyMeta.GetKey(), strategyMeta);
502     strategyMeta.capabilityEnabled = false;
503     MetaDataManager::GetInstance().SaveMeta(strategyMeta.GetKey(), strategyMeta);
504     return SUCCESS;
505 }
506 
SetCapability(const AppId & appId,const StoreId & storeId,const std::vector<std::string> & local,const std::vector<std::string> & remote)507 Status KVDBServiceImpl::SetCapability(const AppId &appId, const StoreId &storeId,
508     const std::vector<std::string> &local, const std::vector<std::string> &remote)
509 {
510     StrategyMeta strategy = GetStrategyMeta(appId, storeId);
511     if (strategy.instanceId < 0) {
512         return ILLEGAL_STATE;
513     }
514     MetaDataManager::GetInstance().LoadMeta(strategy.GetKey(), strategy);
515     strategy.capabilityRange.localLabel = local;
516     strategy.capabilityRange.remoteLabel = remote;
517     MetaDataManager::GetInstance().SaveMeta(strategy.GetKey(), strategy);
518     return SUCCESS;
519 }
520 
AddSubscribeInfo(const AppId & appId,const StoreId & storeId,const SyncInfo & syncInfo)521 Status KVDBServiceImpl::AddSubscribeInfo(const AppId &appId, const StoreId &storeId, const SyncInfo &syncInfo)
522 {
523     StoreMetaData metaData = GetStoreMetaData(appId, storeId);
524     MetaDataManager::GetInstance().LoadMeta(metaData.GetKey(), metaData);
525     auto delay = GetSyncDelayTime(syncInfo.delay, storeId);
526     return KvStoreSyncManager::GetInstance()->AddSyncOperation(uintptr_t(metaData.tokenId), delay,
527         std::bind(&KVDBServiceImpl::DoSyncInOrder, this, metaData, syncInfo, std::placeholders::_1, ACTION_SUBSCRIBE),
528         std::bind(&KVDBServiceImpl::DoComplete, this, metaData, syncInfo, RefCount(), std::placeholders::_1));
529 }
530 
RmvSubscribeInfo(const AppId & appId,const StoreId & storeId,const SyncInfo & syncInfo)531 Status KVDBServiceImpl::RmvSubscribeInfo(const AppId &appId, const StoreId &storeId, const SyncInfo &syncInfo)
532 {
533     StoreMetaData metaData = GetStoreMetaData(appId, storeId);
534     MetaDataManager::GetInstance().LoadMeta(metaData.GetKey(), metaData);
535     auto delay = GetSyncDelayTime(syncInfo.delay, storeId);
536     return KvStoreSyncManager::GetInstance()->AddSyncOperation(uintptr_t(metaData.tokenId), delay,
537         std::bind(
538             &KVDBServiceImpl::DoSyncInOrder, this, metaData, syncInfo, std::placeholders::_1, ACTION_UNSUBSCRIBE),
539         std::bind(&KVDBServiceImpl::DoComplete, this, metaData, syncInfo, RefCount(), std::placeholders::_1));
540 }
541 
Subscribe(const AppId & appId,const StoreId & storeId,sptr<IKvStoreObserver> observer)542 Status KVDBServiceImpl::Subscribe(const AppId &appId, const StoreId &storeId, sptr<IKvStoreObserver> observer)
543 {
544     if (observer == nullptr) {
545         return INVALID_ARGUMENT;
546     }
547     auto tokenId = IPCSkeleton::GetCallingTokenID();
548     ZLOGI("appId:%{public}s storeId:%{public}s tokenId:0x%{public}x", appId.appId.c_str(),
549         Anonymous::Change(storeId.storeId).c_str(), tokenId);
550     bool isCreate = false;
551     syncAgents_.Compute(tokenId, [&appId, &storeId, &observer, &isCreate](auto &key, SyncAgent &agent) {
552         if (agent.pid_ != IPCSkeleton::GetCallingPid()) {
553             agent.ReInit(IPCSkeleton::GetCallingPid(), appId);
554         }
555         isCreate = true;
556         auto watcher = std::make_shared<KVDBWatcher>();
557         watcher->SetObserver(observer);
558         agent.watchers_[storeId.storeId].insert(watcher);
559         return true;
560     });
561     if (isCreate) {
562         AutoCache::GetInstance().SetObserver(tokenId, storeId, GetWatchers(tokenId, storeId));
563     }
564     return SUCCESS;
565 }
566 
Unsubscribe(const AppId & appId,const StoreId & storeId,sptr<IKvStoreObserver> observer)567 Status KVDBServiceImpl::Unsubscribe(const AppId &appId, const StoreId &storeId, sptr<IKvStoreObserver> observer)
568 {
569     auto tokenId = IPCSkeleton::GetCallingTokenID();
570     ZLOGI("appId:%{public}s storeId:%{public}s tokenId:0x%{public}x", appId.appId.c_str(),
571         Anonymous::Change(storeId.storeId).c_str(), tokenId);
572     bool destroyed = false;
573     syncAgents_.ComputeIfPresent(tokenId, [&appId, &storeId, &observer, &destroyed](auto &key, SyncAgent &agent) {
574         auto iter = agent.watchers_.find(storeId.storeId);
575         if (iter == agent.watchers_.end()) {
576             return true;
577         }
578         for (auto watcher : iter->second) {
579             if (watcher->GetObserver() == observer) {
580                 destroyed = true;
581                 iter->second.erase(watcher);
582                 break;
583             }
584         }
585         if (iter->second.size() == 0) {
586             agent.watchers_.erase(storeId.storeId);
587         }
588         return true;
589     });
590     if (destroyed) {
591         AutoCache::GetInstance().SetObserver(tokenId, storeId, GetWatchers(tokenId, storeId));
592     }
593     return SUCCESS;
594 }
595 
GetBackupPassword(const AppId & appId,const StoreId & storeId,std::vector<uint8_t> & password,int32_t passwordType)596 Status KVDBServiceImpl::GetBackupPassword(const AppId &appId, const StoreId &storeId, std::vector<uint8_t> &password,
597     int32_t passwordType)
598 {
599     StoreMetaData metaData = GetStoreMetaData(appId, storeId);
600     if (passwordType == KVDBService::PasswordType::BACKUP_SECRET_KEY) {
601         return BackupManager::GetInstance().GetPassWord(metaData, password) ? SUCCESS : ERROR;
602     }
603     if (passwordType == KVDBService::PasswordType::SECRET_KEY) {
604         SecretKeyMetaData secretKey;
605         MetaDataManager::GetInstance().LoadMeta(metaData.GetSecretKey(), secretKey, true);
606         return CryptoManager::GetInstance().Decrypt(secretKey.sKey, password) ? SUCCESS : ERROR;
607     }
608     ZLOGE("passwordType is invalid, appId:%{public}s, storeId:%{public}s, passwordType:%{public}d",
609         appId.appId.c_str(), Anonymous::Change(storeId.storeId).c_str(), passwordType);
610     return ERROR;
611 }
612 
SetConfig(const AppId & appId,const StoreId & storeId,const StoreConfig & storeConfig)613 Status KVDBServiceImpl::SetConfig(const AppId &appId, const StoreId &storeId, const StoreConfig &storeConfig)
614 {
615     StoreMetaData meta = GetStoreMetaData(appId, storeId);
616     auto isCreated = MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true);
617     if (!isCreated) {
618         return SUCCESS;
619     }
620     meta.enableCloud = storeConfig.cloudConfig.enableCloud;
621     meta.cloudAutoSync = storeConfig.cloudConfig.autoSync;
622     if (!MetaDataManager::GetInstance().SaveMeta(meta.GetKey(), meta, true)) {
623         return Status::ERROR;
624     }
625     StoreMetaData syncMeta;
626     if (MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), syncMeta)) {
627         syncMeta.enableCloud = storeConfig.cloudConfig.enableCloud;
628         syncMeta.cloudAutoSync = storeConfig.cloudConfig.autoSync;
629         if (!MetaDataManager::GetInstance().SaveMeta(syncMeta.GetKey(), syncMeta)) {
630             return Status::ERROR;
631         }
632     }
633     auto stores = AutoCache::GetInstance().GetStoresIfPresent(meta.tokenId, storeId);
634     for (auto store : stores) {
635         store->SetConfig({ storeConfig.cloudConfig.enableCloud });
636     }
637     ZLOGI("appId:%{public}s storeId:%{public}s enable:%{public}d", appId.appId.c_str(),
638         Anonymous::Change(storeId.storeId).c_str(), storeConfig.cloudConfig.enableCloud);
639     return Status::SUCCESS;
640 }
641 
BeforeCreate(const AppId & appId,const StoreId & storeId,const Options & options)642 Status KVDBServiceImpl::BeforeCreate(const AppId &appId, const StoreId &storeId, const Options &options)
643 {
644     ZLOGD("appId:%{public}s storeId:%{public}s to export data", appId.appId.c_str(),
645         Anonymous::Change(storeId.storeId).c_str());
646     StoreMetaData meta = GetStoreMetaData(appId, storeId);
647     AddOptions(options, meta);
648 
649     StoreMetaData old;
650     auto isCreated = MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), old, true);
651     if (!isCreated) {
652         return SUCCESS;
653     }
654     StoreMetaDataLocal oldLocal;
655     MetaDataManager::GetInstance().LoadMeta(meta.GetKeyLocal(), oldLocal, true);
656     // when user is 0, old store no "isPublic" attr, as well as new store's "isPublic" is true, do not intercept.
657     if (old.storeType != meta.storeType || Constant::NotEqual(old.isEncrypt, meta.isEncrypt) || old.area != meta.area ||
658         !options.persistent || (meta.securityLevel != NO_LABEL && (old.securityLevel > meta.securityLevel)) ||
659         (Constant::NotEqual(oldLocal.isPublic, options.isPublic) &&
660             (old.user != DEFAULT_USER_ID || !options.isPublic))) {
661         ZLOGE("meta appId:%{public}s storeId:%{public}s user:%{public}s type:%{public}d->%{public}d "
662               "encrypt:%{public}d->%{public}d area:%{public}d->%{public}d persistent:%{public}d "
663               "securityLevel:%{public}d->%{public}d isPublic:%{public}d->%{public}d",
664               appId.appId.c_str(), Anonymous::Change(storeId.storeId).c_str(), old.user.c_str(), old.storeType,
665               meta.storeType, old.isEncrypt, meta.isEncrypt, old.area, meta.area, options.persistent,
666               old.securityLevel, meta.securityLevel, oldLocal.isPublic, options.isPublic);
667         return Status::STORE_META_CHANGED;
668     }
669 
670     if (options.cloudConfig.enableCloud && !meta.enableCloud && executors_ != nullptr) {
671         DistributedData::StoreInfo storeInfo;
672         storeInfo.bundleName = appId.appId;
673         storeInfo.instanceId = GetInstIndex(storeInfo.tokenId, appId);
674         storeInfo.user = std::atoi(meta.user.c_str());
675         executors_->Execute([storeInfo]() {
676             auto event = std::make_unique<CloudEvent>(CloudEvent::GET_SCHEMA, storeInfo);
677             EventCenter::GetInstance().PostEvent(move(event));
678         });
679     }
680 
681     auto dbStatus = DBStatus::OK;
682     if (old != meta) {
683         dbStatus = Upgrade::GetInstance().ExportStore(old, meta);
684     }
685     return dbStatus == DBStatus::OK ? SUCCESS : DB_ERROR;
686 }
687 
AfterCreate(const AppId & appId,const StoreId & storeId,const Options & options,const std::vector<uint8_t> & password)688 Status KVDBServiceImpl::AfterCreate(const AppId &appId, const StoreId &storeId, const Options &options,
689     const std::vector<uint8_t> &password)
690 {
691     if (!appId.IsValid() || !storeId.IsValid() || !options.IsValidType()) {
692         ZLOGE("failed please check type:%{public}d appId:%{public}s storeId:%{public}s dataType:%{public}d",
693             options.kvStoreType, appId.appId.c_str(), Anonymous::Change(storeId.storeId).c_str(), options.dataType);
694         return INVALID_ARGUMENT;
695     }
696 
697     StoreMetaData metaData = GetStoreMetaData(appId, storeId);
698     AddOptions(options, metaData);
699 
700     StoreMetaData oldMeta;
701     auto isCreated = MetaDataManager::GetInstance().LoadMeta(metaData.GetKey(), oldMeta, true);
702     Status status = SUCCESS;
703     if (isCreated && oldMeta != metaData) {
704         auto dbStatus = Upgrade::GetInstance().UpdateStore(oldMeta, metaData, password);
705         ZLOGI("update status:%{public}d appId:%{public}s storeId:%{public}s inst:%{public}d "
706               "type:%{public}d->%{public}d dir:%{public}s dataType:%{public}d->%{public}d",
707             dbStatus, appId.appId.c_str(), Anonymous::Change(storeId.storeId).c_str(), metaData.instanceId,
708             oldMeta.storeType, metaData.storeType, metaData.dataDir.c_str(), oldMeta.dataType, metaData.dataType);
709         if (dbStatus != DBStatus::OK) {
710             status = STORE_UPGRADE_FAILED;
711         }
712     }
713 
714     if (!isCreated || oldMeta != metaData) {
715         if (!CheckerManager::GetInstance().IsDistrust(Converter::ConvertToStoreInfo(metaData))) {
716             MetaDataManager::GetInstance().SaveMeta(metaData.GetKey(), metaData);
717         }
718         MetaDataManager::GetInstance().SaveMeta(metaData.GetKey(), metaData, true);
719     }
720     AppIDMetaData appIdMeta;
721     appIdMeta.bundleName = metaData.bundleName;
722     appIdMeta.appId = metaData.appId;
723     MetaDataManager::GetInstance().SaveMeta(appIdMeta.GetKey(), appIdMeta, true);
724     SaveLocalMetaData(options, metaData);
725     Upgrade::GetInstance().UpdatePassword(metaData, password);
726     ZLOGI("appId:%{public}s storeId:%{public}s instanceId:%{public}d type:%{public}d dir:%{public}s "
727         "isCreated:%{public}d dataType:%{public}d", appId.appId.c_str(), Anonymous::Change(storeId.storeId).c_str(),
728         metaData.instanceId, metaData.storeType, metaData.dataDir.c_str(), isCreated, metaData.dataType);
729     return status;
730 }
731 
OnAppExit(pid_t uid,pid_t pid,uint32_t tokenId,const std::string & appId)732 int32_t KVDBServiceImpl::OnAppExit(pid_t uid, pid_t pid, uint32_t tokenId, const std::string &appId)
733 {
734     ZLOGI("pid:%{public}d uid:%{public}d appId:%{public}s", pid, uid, appId.c_str());
735     CheckerManager::StoreInfo info;
736     info.uid = uid;
737     info.tokenId = tokenId;
738     info.bundleName = appId;
739     syncAgents_.EraseIf([pid, &info](auto &key, SyncAgent &agent) {
740         if (agent.pid_ != pid) {
741             return false;
742         }
743         if (CheckerManager::GetInstance().IsSwitches(info)) {
744             MetaDataManager::GetInstance().Unsubscribe(SwitchesMetaData::GetPrefix({}));
745         }
746         agent.watchers_.clear();
747         auto stores = AutoCache::GetInstance().GetStoresIfPresent(key);
748         for (auto store : stores) {
749             if (store != nullptr) {
750                 store->UnregisterDetailProgressObserver();
751             }
752         }
753         return true;
754     });
755     return SUCCESS;
756 }
757 
ResolveAutoLaunch(const std::string & identifier,DBLaunchParam & param)758 int32_t KVDBServiceImpl::ResolveAutoLaunch(const std::string &identifier, DBLaunchParam &param)
759 {
760     ZLOGI("user:%{public}s appId:%{public}s storeId:%{public}s identifier:%{public}s", param.userId.c_str(),
761         param.appId.c_str(), Anonymous::Change(param.storeId).c_str(), Anonymous::Change(identifier).c_str());
762     std::vector<StoreMetaData> metaData;
763     auto prefix = StoreMetaData::GetPrefix({ DMAdapter::GetInstance().GetLocalDevice().uuid, param.userId });
764     if (!MetaDataManager::GetInstance().LoadMeta(prefix, metaData)) {
765         ZLOGE("no store in user:%{public}s", param.userId.c_str());
766         return STORE_NOT_FOUND;
767     }
768 
769     for (const auto &storeMeta : metaData) {
770         if (storeMeta.storeType < StoreMetaData::StoreType::STORE_KV_BEGIN ||
771             storeMeta.storeType > StoreMetaData::StoreType::STORE_KV_END) {
772             continue;
773         }
774         auto identifierTag = DBManager::GetKvStoreIdentifier("", storeMeta.appId, storeMeta.storeId, true);
775         if (identifier != identifierTag) {
776             continue;
777         }
778         auto watchers = GetWatchers(storeMeta.tokenId, storeMeta.storeId);
779         AutoCache::GetInstance().GetStore(storeMeta, watchers);
780 
781         ZLOGD("user:%{public}s appId:%{public}s storeId:%{public}s", storeMeta.user.c_str(),
782             storeMeta.bundleName.c_str(), Anonymous::Change(storeMeta.storeId).c_str());
783     }
784     return SUCCESS;
785 }
786 
OnUserChange(uint32_t code,const std::string & user,const std::string & account)787 int32_t KVDBServiceImpl::OnUserChange(uint32_t code, const std::string &user, const std::string &account)
788 {
789     (void)code;
790     (void)user;
791     (void)account;
792     std::vector<int32_t> users;
793     AccountDelegate::GetInstance()->QueryUsers(users);
794     std::set<int32_t> userIds(users.begin(), users.end());
795     AutoCache::GetInstance().CloseExcept(userIds);
796     return SUCCESS;
797 }
798 
IsRemoteChange(const StoreMetaData & metaData,const std::string & device)799 bool KVDBServiceImpl::IsRemoteChange(const StoreMetaData &metaData, const std::string &device)
800 {
801     auto code = DeviceMatrix::GetInstance().GetCode(metaData);
802     if (code == DeviceMatrix::INVALID_MASK) {
803         return true;
804     }
805     auto [dynamic, statics] = DeviceMatrix::GetInstance().IsConsistent(device);
806     if (metaData.dataType == DataType::TYPE_STATICS && statics) {
807         return false;
808     }
809     if (metaData.dataType == DataType::TYPE_DYNAMICAL && dynamic) {
810         return false;
811     }
812     auto [exist, mask] = DeviceMatrix::GetInstance().GetRemoteMask(
813         device, static_cast<DeviceMatrix::LevelType>(metaData.dataType));
814     return (mask & code) == code;
815 }
816 
AddOptions(const Options & options,StoreMetaData & metaData)817 void KVDBServiceImpl::AddOptions(const Options &options, StoreMetaData &metaData)
818 {
819     metaData.isAutoSync = options.autoSync;
820     metaData.isBackup = options.backup;
821     metaData.isEncrypt = options.encrypt;
822     metaData.storeType = options.kvStoreType;
823     metaData.securityLevel = options.securityLevel;
824     metaData.area = options.area;
825     metaData.appId = CheckerManager::GetInstance().GetAppId(Converter::ConvertToStoreInfo(metaData));
826     metaData.appType = "harmony";
827     metaData.hapName = options.hapName;
828     metaData.dataDir = DirectoryManager::GetInstance().GetStorePath(metaData);
829     metaData.schema = options.schema;
830     metaData.account = AccountDelegate::GetInstance()->GetCurrentAccountId();
831     metaData.isNeedCompress = options.isNeedCompress;
832     metaData.dataType = options.dataType;
833     metaData.enableCloud = options.cloudConfig.enableCloud;
834     metaData.cloudAutoSync = options.cloudConfig.autoSync;
835     metaData.authType = static_cast<int32_t>(options.authType);
836 }
837 
SaveLocalMetaData(const Options & options,const StoreMetaData & metaData)838 void KVDBServiceImpl::SaveLocalMetaData(const Options &options, const StoreMetaData &metaData)
839 {
840     StoreMetaDataLocal localMetaData;
841     localMetaData.isAutoSync = options.autoSync;
842     localMetaData.isBackup = options.backup;
843     localMetaData.isEncrypt = options.encrypt;
844     localMetaData.dataDir = DirectoryManager::GetInstance().GetStorePath(metaData);
845     localMetaData.schema = options.schema;
846     localMetaData.isPublic = options.isPublic;
847     for (auto &policy : options.policies) {
848         OHOS::DistributedData::PolicyValue value;
849         value.type = policy.type;
850         value.index = policy.value.index();
851         if (const uint32_t *pval = std::get_if<uint32_t>(&policy.value)) {
852             value.valueUint = *pval;
853         }
854         localMetaData.policies.emplace_back(value);
855     }
856     MetaDataManager::GetInstance().SaveMeta(metaData.GetKeyLocal(), localMetaData, true);
857 }
858 
GetStoreMetaData(const AppId & appId,const StoreId & storeId)859 StoreMetaData KVDBServiceImpl::GetStoreMetaData(const AppId &appId, const StoreId &storeId)
860 {
861     StoreMetaData metaData;
862     metaData.uid = IPCSkeleton::GetCallingUid();
863     metaData.tokenId = IPCSkeleton::GetCallingTokenID();
864     metaData.instanceId = GetInstIndex(metaData.tokenId, appId);
865     metaData.bundleName = appId.appId;
866     metaData.deviceId = DMAdapter::GetInstance().GetLocalDevice().uuid;
867     metaData.storeId = storeId.storeId;
868     auto user = AccountDelegate::GetInstance()->GetUserByToken(metaData.tokenId);
869     metaData.user = std::to_string(user);
870     return metaData;
871 }
872 
GetStrategyMeta(const AppId & appId,const StoreId & storeId)873 StrategyMeta KVDBServiceImpl::GetStrategyMeta(const AppId &appId, const StoreId &storeId)
874 {
875     auto tokenId = IPCSkeleton::GetCallingTokenID();
876     auto userId = AccountDelegate::GetInstance()->GetUserByToken(tokenId);
877     auto deviceId = DMAdapter::GetInstance().GetLocalDevice().uuid;
878     StrategyMeta strategyMeta(deviceId, std::to_string(userId), appId.appId, storeId.storeId);
879     strategyMeta.instanceId = GetInstIndex(tokenId, appId);
880     return strategyMeta;
881 }
882 
GetInstIndex(uint32_t tokenId,const AppId & appId)883 int32_t KVDBServiceImpl::GetInstIndex(uint32_t tokenId, const AppId &appId)
884 {
885     if (AccessTokenKit::GetTokenTypeFlag(tokenId) != TOKEN_HAP) {
886         return 0;
887     }
888 
889     HapTokenInfo tokenInfo;
890     tokenInfo.instIndex = -1;
891     int errCode = AccessTokenKit::GetHapTokenInfo(tokenId, tokenInfo);
892     if (errCode != RET_SUCCESS) {
893         ZLOGE("GetHapTokenInfo error:%{public}d, tokenId:0x%{public}x appId:%{public}s", errCode, tokenId,
894             appId.appId.c_str());
895         return -1;
896     }
897     return tokenInfo.instIndex;
898 }
899 
HandleGenBriefDetails(const GenDetails & details)900 KVDBServiceImpl::DBResult KVDBServiceImpl::HandleGenBriefDetails(const GenDetails &details)
901 {
902     DBResult dbResults{};
903     for (const auto &[id, detail] : details) {
904         dbResults[id] = DBStatus(detail.code);
905     }
906     return dbResults;
907 }
908 
DoCloudSync(const StoreMetaData & meta,const SyncInfo & syncInfo)909 Status KVDBServiceImpl::DoCloudSync(const StoreMetaData &meta, const SyncInfo &syncInfo)
910 {
911     if (!meta.enableCloud) {
912         ZLOGE("appId:%{public}s storeId:%{public}s instanceId:%{public}d not supports cloud sync", meta.appId.c_str(),
913             Anonymous::Change(meta.storeId).c_str(), meta.instanceId);
914         return Status::NOT_SUPPORT;
915     }
916     auto instance = CloudServer::GetInstance();
917     if (instance == nullptr) {
918         return Status::CLOUD_DISABLED;
919     }
920     if (!DMAdapter::GetInstance().IsNetworkAvailable()) {
921         return Status::NETWORK_ERROR;
922     }
923     std::vector<int32_t> users;
924     if (meta.user != StoreMetaData::ROOT_USER) {
925         users.push_back(std::atoi(meta.user.c_str()));
926     } else if (!AccountDelegate::GetInstance()->QueryForegroundUsers(users)) {
927         ZLOGE("appId:%{public}s storeId:%{public}s instanceId:%{public}d. no foreground user!", meta.appId.c_str(),
928             Anonymous::Change(meta.storeId).c_str(), meta.instanceId);
929         return Status::CLOUD_DISABLED;
930     }
931     bool res = false;
932     for (auto user : users) {
933         res = instance->IsSupportCloud(user) || res;
934     }
935     if (!res) {
936         return Status::CLOUD_DISABLED;
937     }
938 
939     DistributedData::StoreInfo storeInfo;
940     storeInfo.bundleName = meta.bundleName;
941     storeInfo.user = atoi(meta.user.c_str());
942     storeInfo.tokenId = meta.tokenId;
943     storeInfo.storeName = meta.storeId;
944     GenAsync syncCallback = [tokenId = storeInfo.tokenId, seqId = syncInfo.seqId, this](const GenDetails &details) {
945         OnAsyncComplete(tokenId, seqId, HandleGenDetails(details));
946     };
947     auto mixMode = static_cast<int32_t>(GeneralStore::MixMode(GeneralStore::CLOUD_TIME_FIRST,
948         meta.isAutoSync ? GeneralStore::AUTO_SYNC_MODE : GeneralStore::MANUAL_SYNC_MODE));
949     auto info = ChangeEvent::EventInfo({ mixMode, 0, false, syncInfo.triggerMode }, false, nullptr, syncCallback);
950     auto evt = std::make_unique<ChangeEvent>(std::move(storeInfo), std::move(info));
951     EventCenter::GetInstance().PostEvent(std::move(evt));
952     return SUCCESS;
953 }
954 
DoSync(const StoreMetaData & meta,const SyncInfo & info,const SyncEnd & complete,int32_t type)955 Status KVDBServiceImpl::DoSync(const StoreMetaData &meta, const SyncInfo &info, const SyncEnd &complete, int32_t type)
956 {
957     ZLOGD("seqId:0x%{public}" PRIx64 " type:%{public}d remote:%{public}zu appId:%{public}s storeId:%{public}s",
958         info.seqId, type, info.devices.size(), meta.bundleName.c_str(), Anonymous::Change(meta.storeId).c_str());
959     auto uuids = ConvertDevices(info.devices);
960     if (uuids.empty()) {
961         ZLOGW("no device online seqId:0x%{public}" PRIx64 " remote:%{public}zu appId:%{public}s storeId:%{public}s",
962             info.seqId, info.devices.size(), meta.bundleName.c_str(), Anonymous::Change(meta.storeId).c_str());
963         return Status::ERROR;
964     }
965 
966     return DoSyncBegin(uuids, meta, info, complete, type);
967 }
968 
DoSyncInOrder(const StoreMetaData & meta,const SyncInfo & info,const SyncEnd & complete,int32_t type)969 Status KVDBServiceImpl::DoSyncInOrder(
970     const StoreMetaData &meta, const SyncInfo &info, const SyncEnd &complete, int32_t type)
971 {
972     ZLOGD("type:%{public}d seqId:0x%{public}" PRIx64 " remote:%{public}zu appId:%{public}s storeId:%{public}s", type,
973         info.seqId, info.devices.size(), meta.bundleName.c_str(), Anonymous::Change(meta.storeId).c_str());
974     auto uuids = ConvertDevices(info.devices);
975     if (uuids.empty()) {
976         ZLOGW("no device seqId:0x%{public}" PRIx64 " remote:%{public}zu appId:%{public}s storeId:%{public}s",
977             info.seqId, info.devices.size(), meta.bundleName.c_str(), Anonymous::Change(meta.storeId).c_str());
978         return Status::ERROR;
979     }
980     if (IsNeedMetaSync(meta, uuids)) {
981         auto recv = DeviceMatrix::GetInstance().GetRecvLevel(uuids[0],
982             static_cast<DeviceMatrix::LevelType>(DataType::TYPE_DYNAMICAL));
983         RADAR_REPORT(STANDARD_DEVICE_SYNC, STANDARD_META_SYNC, RADAR_START,
984             SYNC_STORE_ID, Anonymous::Change(meta.storeId), SYNC_APP_ID, meta.bundleName, CONCURRENT_ID,
985             std::to_string(info.syncId), DATA_TYPE, meta.dataType, WATER_VERSION, recv.second);
986         auto result = MetaDataManager::GetInstance().Sync(
987             uuids, [this, meta, info, complete, type](const auto &results) {
988             RADAR_REPORT(STANDARD_DEVICE_SYNC, STANDARD_META_SYNC, RADAR_SUCCESS,
989                 SYNC_STORE_ID, Anonymous::Change(meta.storeId), SYNC_APP_ID, meta.bundleName, CONCURRENT_ID,
990                 std::to_string(info.syncId), DATA_TYPE, meta.dataType);
991             auto ret = ProcessResult(results);
992             if (ret.first.empty()) {
993                 DoComplete(meta, info, RefCount(), ret.second);
994                 return;
995             }
996             auto status = DoSyncBegin(ret.first, meta, info, complete, type);
997             ZLOGD("data sync status:%{public}d appId:%{public}s, storeId:%{public}s",
998                 static_cast<int32_t>(status), meta.bundleName.c_str(), Anonymous::Change(meta.storeId).c_str());
999         });
1000         if (!result) {
1001             RADAR_REPORT(STANDARD_DEVICE_SYNC, STANDARD_META_SYNC, RADAR_FAILED, ERROR_CODE, Status::ERROR,
1002                 BIZ_STATE, END, SYNC_STORE_ID, Anonymous::Change(meta.storeId), SYNC_APP_ID, meta.bundleName,
1003                 CONCURRENT_ID, std::to_string(info.syncId), DATA_TYPE, meta.dataType);
1004         }
1005         return result ? Status::SUCCESS : Status::ERROR;
1006     }
1007     return DoSyncBegin(uuids, meta, info, complete, type);
1008 }
1009 
IsNeedMetaSync(const StoreMetaData & meta,const std::vector<std::string> & uuids)1010 bool KVDBServiceImpl::IsNeedMetaSync(const StoreMetaData &meta, const std::vector<std::string> &uuids)
1011 {
1012     bool isAfterMeta = false;
1013     for (const auto &uuid : uuids) {
1014         auto metaData = meta;
1015         metaData.deviceId = uuid;
1016         CapMetaData capMeta;
1017         auto capKey = CapMetaRow::GetKeyFor(uuid);
1018         auto devInfo = DMAdapter::GetInstance().GetDeviceInfo(uuid);
1019         if ((!MetaDataManager::GetInstance().LoadMeta(std::string(capKey.begin(), capKey.end()), capMeta) &&
1020             !(devInfo.osType != OH_OS_TYPE &&
1021             devInfo.deviceType == static_cast<uint32_t>(DistributedHardware::DmDeviceType::DEVICE_TYPE_CAR))) ||
1022             !MetaDataManager::GetInstance().LoadMeta(metaData.GetKey(), metaData)) {
1023             isAfterMeta = true;
1024             break;
1025         }
1026         auto [exist, mask] = DeviceMatrix::GetInstance().GetRemoteMask(uuid);
1027         if ((mask & DeviceMatrix::META_STORE_MASK) == DeviceMatrix::META_STORE_MASK) {
1028             isAfterMeta = true;
1029             break;
1030         }
1031     }
1032     return isAfterMeta;
1033 }
1034 
GetDistributedDataMeta(const std::string & deviceId)1035 StoreMetaData KVDBServiceImpl::GetDistributedDataMeta(const std::string &deviceId)
1036 {
1037     StoreMetaData meta;
1038     meta.deviceId = deviceId;
1039     meta.bundleName = Bootstrap::GetInstance().GetProcessLabel();
1040     meta.storeId = Bootstrap::GetInstance().GetMetaDBName();
1041     meta.user = DEFAULT_USER_ID;
1042     if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta)) {
1043         ZLOGE("Load meta fail, device: %{public}s", Anonymous::Change(deviceId).c_str());
1044     }
1045     return meta;
1046 }
1047 
ProcessResult(const std::map<std::string,int32_t> & results)1048 KVDBServiceImpl::SyncResult KVDBServiceImpl::ProcessResult(const std::map<std::string, int32_t> &results)
1049 {
1050     std::map<std::string, DBStatus> dbResults;
1051     std::vector<std::string> devices;
1052     for (const auto &[uuid, status] : results) {
1053         dbResults.insert_or_assign(uuid, static_cast<DBStatus>(status));
1054         if (static_cast<DBStatus>(status) != DBStatus::OK) {
1055             continue;
1056         }
1057         DeviceMatrix::GetInstance().OnExchanged(uuid, DeviceMatrix::META_STORE_MASK);
1058         devices.emplace_back(uuid);
1059     }
1060     ZLOGD("meta sync finish, total size:%{public}zu, success size:%{public}zu", dbResults.size(), devices.size());
1061     return { devices, dbResults };
1062 }
1063 
DoSyncBegin(const std::vector<std::string> & devices,const StoreMetaData & meta,const SyncInfo & info,const SyncEnd & complete,int32_t type)1064 Status KVDBServiceImpl::DoSyncBegin(const std::vector<std::string> &devices, const StoreMetaData &meta,
1065     const SyncInfo &info, const SyncEnd &complete, int32_t type)
1066 {
1067     if (devices.empty()) {
1068         return Status::INVALID_ARGUMENT;
1069     }
1070     auto watcher = GetWatchers(meta.tokenId, meta.storeId);
1071     RADAR_REPORT(STANDARD_DEVICE_SYNC, OPEN_STORE, RADAR_START, SYNC_STORE_ID, Anonymous::Change(meta.storeId),
1072         SYNC_APP_ID, meta.bundleName, CONCURRENT_ID, info.syncId, DATA_TYPE, meta.dataType);
1073     auto store = AutoCache::GetInstance().GetStore(meta, watcher);
1074     if (store == nullptr) {
1075         ZLOGE("GetStore failed! appId:%{public}s storeId:%{public}s storeId length:%{public}zu dir:%{public}s",
1076             meta.bundleName.c_str(), Anonymous::Change(meta.storeId).c_str(),
1077             meta.storeId.size(), meta.dataDir.c_str());
1078         RADAR_REPORT(STANDARD_DEVICE_SYNC, OPEN_STORE, RADAR_FAILED, ERROR_CODE, Status::ERROR, BIZ_STATE, END,
1079             SYNC_STORE_ID, Anonymous::Change(meta.storeId), SYNC_APP_ID, meta.bundleName, CONCURRENT_ID,
1080             std::to_string(info.syncId), DATA_TYPE, meta.dataType);
1081         return Status::ERROR;
1082     }
1083     RADAR_REPORT(STANDARD_DEVICE_SYNC, OPEN_STORE, RADAR_SUCCESS, SYNC_STORE_ID, Anonymous::Change(meta.storeId),
1084         SYNC_APP_ID, meta.bundleName, CONCURRENT_ID, std::to_string(info.syncId), DATA_TYPE, meta.dataType);
1085     KVDBQuery query(info.query);
1086     if (!query.IsValidQuery()) {
1087         ZLOGE("failed DBQuery:%{public}s", Anonymous::Change(info.query).c_str());
1088         return Status::INVALID_ARGUMENT;
1089     }
1090     auto mode = ConvertGeneralSyncMode(SyncMode(info.mode), SyncAction(type));
1091     if (GeneralStore::GetSyncMode(mode) < KVDBGeneralStore::NEARBY_END) {
1092         store->SetEqualIdentifier(meta.appId, meta.storeId);
1093     }
1094     SyncParam syncParam{};
1095     syncParam.mode = mode;
1096     RADAR_REPORT(STANDARD_DEVICE_SYNC, START_SYNC, RADAR_START, SYNC_STORE_ID, Anonymous::Change(meta.storeId),
1097         SYNC_APP_ID, meta.bundleName, CONCURRENT_ID, std::to_string(info.syncId), DATA_TYPE, meta.dataType);
1098     auto ret = store->Sync(
1099         devices, query,
1100         [this, complete](const GenDetails &result) mutable {
1101             auto deviceStatus = HandleGenBriefDetails(result);
1102             complete(deviceStatus);
1103         },
1104         syncParam);
1105     auto status = Status(ret);
1106     if (status != Status::SUCCESS) {
1107         RADAR_REPORT(STANDARD_DEVICE_SYNC, START_SYNC, RADAR_FAILED, ERROR_CODE, status, BIZ_STATE, END,
1108             SYNC_STORE_ID, Anonymous::Change(meta.storeId), SYNC_APP_ID, meta.bundleName, CONCURRENT_ID,
1109             std::to_string(info.syncId), DATA_TYPE, meta.dataType);
1110     } else {
1111         RADAR_REPORT(STANDARD_DEVICE_SYNC, START_SYNC, RADAR_SUCCESS, SYNC_STORE_ID, Anonymous::Change(meta.storeId),
1112             SYNC_APP_ID, meta.bundleName, CONCURRENT_ID, std::to_string(info.syncId), DATA_TYPE, meta.dataType);
1113     }
1114     return status;
1115 }
1116 
DoComplete(const StoreMetaData & meta,const SyncInfo & info,RefCount refCount,const DBResult & dbResult)1117 Status KVDBServiceImpl::DoComplete(const StoreMetaData &meta, const SyncInfo &info, RefCount refCount,
1118     const DBResult &dbResult)
1119 {
1120     ZLOGD("seqId:0x%{public}" PRIx64 " tokenId:0x%{public}x remote:%{public}zu", info.seqId, meta.tokenId,
1121         dbResult.size());
1122     RADAR_REPORT(STANDARD_DEVICE_SYNC, FINISH_SYNC, RADAR_SUCCESS, BIZ_STATE, END,
1123         SYNC_STORE_ID, Anonymous::Change(meta.storeId), SYNC_APP_ID, meta.bundleName, CONCURRENT_ID,
1124         std::to_string(info.syncId), DATA_TYPE, meta.dataType);
1125     std::map<std::string, Status> result;
1126     for (auto &[key, status] : dbResult) {
1127         result[key] = ConvertDbStatus(status);
1128     }
1129     for (const auto &device : info.devices) {
1130         auto it = result.find(device);
1131         if (it != result.end() && it->second == SUCCESS) {
1132             DeviceMatrix::GetInstance().OnExchanged(device, meta, ConvertType(static_cast<SyncMode>(info.mode)));
1133         }
1134     }
1135     if (info.seqId == std::numeric_limits<uint64_t>::max()) {
1136         return SUCCESS;
1137     }
1138     sptr<IKVDBNotifier> notifier;
1139     syncAgents_.ComputeIfPresent(meta.tokenId, [&notifier](auto &key, SyncAgent &agent) {
1140         notifier = agent.notifier_;
1141         return true;
1142     });
1143     if (notifier == nullptr) {
1144         return SUCCESS;
1145     }
1146     notifier->SyncCompleted(result, info.seqId);
1147     return SUCCESS;
1148 }
1149 
GetSyncDelayTime(uint32_t delay,const StoreId & storeId)1150 uint32_t KVDBServiceImpl::GetSyncDelayTime(uint32_t delay, const StoreId &storeId)
1151 {
1152     if (delay != 0) {
1153         return std::min(std::max(delay, KvStoreSyncManager::SYNC_MIN_DELAY_MS), KvStoreSyncManager::SYNC_MAX_DELAY_MS);
1154     }
1155 
1156     bool isBackground = Constant::IsBackground(IPCSkeleton::GetCallingPid());
1157     if (!isBackground) {
1158         return delay;
1159     }
1160     delay = KvStoreSyncManager::SYNC_DEFAULT_DELAY_MS;
1161     syncAgents_.ComputeIfPresent(IPCSkeleton::GetCallingTokenID(), [&delay, &storeId](auto &, SyncAgent &agent) {
1162         auto it = agent.delayTimes_.find(storeId);
1163         if (it != agent.delayTimes_.end() && it->second != 0) {
1164             delay = it->second;
1165         }
1166         return true;
1167     });
1168     return delay;
1169 }
1170 
ConvertDbStatus(DBStatus status) const1171 Status KVDBServiceImpl::ConvertDbStatus(DBStatus status) const
1172 {
1173     switch (status) {
1174         case DBStatus::BUSY: // fallthrough
1175         case DBStatus::DB_ERROR:
1176             return Status::DB_ERROR;
1177         case DBStatus::OK:
1178             return Status::SUCCESS;
1179         case DBStatus::INVALID_ARGS:
1180             return Status::INVALID_ARGUMENT;
1181         case DBStatus::NOT_FOUND:
1182             return Status::KEY_NOT_FOUND;
1183         case DBStatus::INVALID_VALUE_FIELDS:
1184             return Status::INVALID_VALUE_FIELDS;
1185         case DBStatus::INVALID_FIELD_TYPE:
1186             return Status::INVALID_FIELD_TYPE;
1187         case DBStatus::CONSTRAIN_VIOLATION:
1188             return Status::CONSTRAIN_VIOLATION;
1189         case DBStatus::INVALID_FORMAT:
1190             return Status::INVALID_FORMAT;
1191         case DBStatus::INVALID_QUERY_FORMAT:
1192             return Status::INVALID_QUERY_FORMAT;
1193         case DBStatus::INVALID_QUERY_FIELD:
1194             return Status::INVALID_QUERY_FIELD;
1195         case DBStatus::NOT_SUPPORT:
1196             return Status::NOT_SUPPORT;
1197         case DBStatus::TIME_OUT:
1198             return Status::TIME_OUT;
1199         case DBStatus::OVER_MAX_LIMITS:
1200             return Status::OVER_MAX_LIMITS;
1201         case DBStatus::EKEYREVOKED_ERROR: // fallthrough
1202         case DBStatus::SECURITY_OPTION_CHECK_ERROR:
1203             return Status::SECURITY_LEVEL_ERROR;
1204         default:
1205             break;
1206     }
1207     return Status::ERROR;
1208 }
1209 
ConvertGeneralErr(GeneralError error) const1210 Status KVDBServiceImpl::ConvertGeneralErr(GeneralError error) const
1211 {
1212     switch (error) {
1213         case GeneralError::E_DB_ERROR:
1214             return Status::DB_ERROR;
1215         case GeneralError::E_OK:
1216             return Status::SUCCESS;
1217         case GeneralError::E_INVALID_ARGS:
1218             return Status::INVALID_ARGUMENT;
1219         case GeneralError::E_RECORD_NOT_FOUND:
1220             return Status::KEY_NOT_FOUND;
1221         case GeneralError::E_INVALID_VALUE_FIELDS:
1222             return Status::INVALID_VALUE_FIELDS;
1223         case GeneralError::E_INVALID_FIELD_TYPE:
1224             return Status::INVALID_FIELD_TYPE;
1225         case GeneralError::E_CONSTRAIN_VIOLATION:
1226             return Status::CONSTRAIN_VIOLATION;
1227         case GeneralError::E_INVALID_FORMAT:
1228             return Status::INVALID_FORMAT;
1229         case GeneralError::E_INVALID_QUERY_FORMAT:
1230             return Status::INVALID_QUERY_FORMAT;
1231         case GeneralError::E_INVALID_QUERY_FIELD:
1232             return Status::INVALID_QUERY_FIELD;
1233         case GeneralError::E_NOT_SUPPORT:
1234             return Status::NOT_SUPPORT;
1235         case GeneralError::E_TIME_OUT:
1236             return Status::TIME_OUT;
1237         case GeneralError::E_OVER_MAX_LIMITS:
1238             return Status::OVER_MAX_LIMITS;
1239         case GeneralError::E_SECURITY_LEVEL_ERROR:
1240             return Status::SECURITY_LEVEL_ERROR;
1241         default:
1242             break;
1243     }
1244     return Status::ERROR;
1245 }
1246 
ConvertDBMode(SyncMode syncMode) const1247 KVDBServiceImpl::DBMode KVDBServiceImpl::ConvertDBMode(SyncMode syncMode) const
1248 {
1249     DBMode dbMode;
1250     if (syncMode == SyncMode::PUSH) {
1251         dbMode = DBMode::SYNC_MODE_PUSH_ONLY;
1252     } else if (syncMode == SyncMode::PULL) {
1253         dbMode = DBMode::SYNC_MODE_PULL_ONLY;
1254     } else {
1255         dbMode = DBMode::SYNC_MODE_PUSH_PULL;
1256     }
1257     return dbMode;
1258 }
1259 
ConvertGeneralSyncMode(SyncMode syncMode,SyncAction syncAction) const1260 GeneralStore::SyncMode KVDBServiceImpl::ConvertGeneralSyncMode(SyncMode syncMode, SyncAction syncAction) const
1261 {
1262     GeneralStore::SyncMode generalSyncMode = GeneralStore::SyncMode::NEARBY_END;
1263     if (syncAction == SyncAction::ACTION_SUBSCRIBE) {
1264         generalSyncMode = GeneralStore::SyncMode::NEARBY_SUBSCRIBE_REMOTE;
1265     } else if (syncAction == SyncAction::ACTION_UNSUBSCRIBE) {
1266         generalSyncMode = GeneralStore::SyncMode::NEARBY_UNSUBSCRIBE_REMOTE;
1267     } else if (syncAction == SyncAction::ACTION_SYNC && syncMode == SyncMode::PUSH) {
1268         generalSyncMode = GeneralStore::SyncMode::NEARBY_PUSH;
1269     } else if (syncAction == SyncAction::ACTION_SYNC && syncMode == SyncMode::PULL) {
1270         generalSyncMode = GeneralStore::SyncMode::NEARBY_PULL;
1271     } else if (syncAction == SyncAction::ACTION_SYNC && syncMode == SyncMode::PUSH_PULL) {
1272         generalSyncMode = GeneralStore::SyncMode::NEARBY_PULL_PUSH;
1273     }
1274     return generalSyncMode;
1275 }
1276 
ConvertType(SyncMode syncMode) const1277 KVDBServiceImpl::ChangeType KVDBServiceImpl::ConvertType(SyncMode syncMode) const
1278 {
1279     switch (syncMode) {
1280         case SyncMode::PUSH:
1281             return ChangeType::CHANGE_LOCAL;
1282         case SyncMode::PULL:
1283             return ChangeType::CHANGE_REMOTE;
1284         case SyncMode::PUSH_PULL:
1285             return ChangeType::CHANGE_ALL;
1286         default:
1287             break;
1288     }
1289     return ChangeType::CHANGE_ALL;
1290 }
1291 
ConvertAction(Action action) const1292 SwitchState KVDBServiceImpl::ConvertAction(Action action) const
1293 {
1294     switch (action) {
1295         case Action::INSERT:
1296             return SwitchState::INSERT;
1297         case Action::UPDATE:
1298             return SwitchState::UPDATE;
1299         case Action::DELETE:
1300             return SwitchState::DELETE;
1301         default:
1302             break;
1303     }
1304     return SwitchState::INSERT;
1305 }
1306 
GetSyncMode(bool local,bool remote) const1307 SyncMode KVDBServiceImpl::GetSyncMode(bool local, bool remote) const
1308 {
1309     if (local && remote) {
1310         return SyncMode::PUSH_PULL;
1311     }
1312     if (local) {
1313         return SyncMode::PUSH;
1314     }
1315     if (remote) {
1316         return SyncMode::PULL;
1317     }
1318     return SyncMode::PUSH_PULL;
1319 }
1320 
ConvertDevices(const std::vector<std::string> & deviceIds) const1321 std::vector<std::string> KVDBServiceImpl::ConvertDevices(const std::vector<std::string> &deviceIds) const
1322 {
1323     if (deviceIds.empty()) {
1324         return DMAdapter::ToUUID(DMAdapter::GetInstance().GetRemoteDevices());
1325     }
1326     return DMAdapter::ToUUID(deviceIds);
1327 }
1328 
GetWatchers(uint32_t tokenId,const std::string & storeId)1329 AutoCache::Watchers KVDBServiceImpl::GetWatchers(uint32_t tokenId, const std::string &storeId)
1330 {
1331     AutoCache::Watchers watchers{};
1332     syncAgents_.ComputeIfPresent(tokenId, [&storeId, &watchers](auto &, SyncAgent &agent) {
1333         auto iter = agent.watchers_.find(storeId);
1334         if (iter != agent.watchers_.end()) {
1335             for (const auto &watcher : iter->second) {
1336                 watchers.insert(watcher);
1337             }
1338         }
1339         return true;
1340     });
1341     return watchers;
1342 }
1343 
ReInit(pid_t pid,const AppId & appId)1344 void KVDBServiceImpl::SyncAgent::ReInit(pid_t pid, const AppId &appId)
1345 {
1346     ZLOGW("pid:%{public}d->%{public}d appId:%{public}s notifier:%{public}d", pid, pid_,
1347         appId_.appId.c_str(), notifier_ == nullptr);
1348     pid_ = pid;
1349     appId_ = appId;
1350     notifier_ = nullptr;
1351     delayTimes_.clear();
1352     watchers_.clear();
1353 }
1354 
OnBind(const BindInfo & bindInfo)1355 int32_t KVDBServiceImpl::OnBind(const BindInfo &bindInfo)
1356 {
1357     executors_ = bindInfo.executors;
1358     KvStoreSyncManager::GetInstance()->SetThreadPool(bindInfo.executors);
1359     DeviceMatrix::GetInstance().SetExecutor(bindInfo.executors);
1360     return 0;
1361 }
1362 
OnInitialize()1363 int32_t KVDBServiceImpl::OnInitialize()
1364 {
1365     RegisterKvServiceInfo();
1366     RegisterHandler();
1367     Init();
1368     return SUCCESS;
1369 }
1370 
IsOHOSType(const std::vector<std::string> & ids)1371 bool KVDBServiceImpl::IsOHOSType(const std::vector<std::string> &ids)
1372 {
1373     if (ids.empty()) {
1374         ZLOGI("ids is empty");
1375         return true;
1376     }
1377     bool isOHOSType = true;
1378     for (auto &id : ids) {
1379         if (!DMAdapter::GetInstance().IsOHOSType(id)) {
1380             isOHOSType = false;
1381             break;
1382         }
1383     }
1384     return isOHOSType;
1385 }
1386 
RemoveDeviceData(const AppId & appId,const StoreId & storeId,const std::string & device)1387 Status KVDBServiceImpl::RemoveDeviceData(const AppId &appId, const StoreId &storeId, const std::string &device)
1388 {
1389     StoreMetaData metaData = GetStoreMetaData(appId, storeId);
1390     MetaDataManager::GetInstance().LoadMeta(metaData.GetKey(), metaData);
1391     auto watcher = GetWatchers(metaData.tokenId, metaData.storeId);
1392     auto store = AutoCache::GetInstance().GetStore(metaData, watcher);
1393     if (store == nullptr) {
1394         ZLOGE("GetStore failed! appId:%{public}s storeId:%{public}s dir:%{public}s", metaData.bundleName.c_str(),
1395             Anonymous::Change(metaData.storeId).c_str(), metaData.dataDir.c_str());
1396         return Status::ERROR;
1397     }
1398 
1399     int32_t ret;
1400     if (device.empty()) {
1401         ret = store->Clean({}, KVDBGeneralStore::NEARBY_DATA, "");
1402     } else {
1403         ret = store->Clean({ DMAdapter::GetInstance().ToUUID(device) }, KVDBGeneralStore::NEARBY_DATA, "");
1404     }
1405     return ConvertGeneralErr(GeneralError(ret));
1406 }
1407 } // namespace OHOS::DistributedKv