1 /*
2 * Copyright (c) 2022 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 "KVDBServiceClient"
16 #include "kvdb_service_client.h"
17 #include <cinttypes>
18 #include "distributeddata_kvdb_ipc_interface_code.h"
19 #include "itypes_util.h"
20 #include "kvstore_observer_client.h"
21 #include "kvstore_service_death_notifier.h"
22 #include "log_print.h"
23 #include "security_manager.h"
24 #include "single_store_impl.h"
25 #include "store_factory.h"
26 #include "store_util.h"
27 namespace OHOS::DistributedKv {
28 #define IPC_SEND(code, reply, ...) \
29 ({ \
30 int32_t __status = SUCCESS; \
31 do { \
32 MessageParcel request; \
33 if (!request.WriteInterfaceToken(GetDescriptor())) { \
34 __status = IPC_PARCEL_ERROR; \
35 break; \
36 } \
37 if (!ITypesUtil::Marshal(request, ##__VA_ARGS__)) { \
38 __status = IPC_PARCEL_ERROR; \
39 break; \
40 } \
41 MessageOption option; \
42 auto result = remote_->SendRequest((code), request, reply, option); \
43 if (result != 0) { \
44 __status = IPC_ERROR; \
45 break; \
46 } \
47 \
48 ITypesUtil::Unmarshal(reply, __status); \
49 } while (0); \
50 __status; \
51 })
52
53 std::mutex KVDBServiceClient::mutex_;
54 std::shared_ptr<KVDBServiceClient> KVDBServiceClient::instance_;
55 std::atomic_bool KVDBServiceClient::isWatched_(false);
56
GetInstance()57 std::shared_ptr<KVDBServiceClient> KVDBServiceClient::GetInstance()
58 {
59 if (!isWatched_.exchange(true)) {
60 KvStoreServiceDeathNotifier::AddServiceDeathWatcher(std::make_shared<ServiceDeath>());
61 }
62
63 std::lock_guard<decltype(mutex_)> lockGuard(mutex_);
64 if (instance_ != nullptr) {
65 return instance_;
66 }
67
68 sptr<IKvStoreDataService> ability = KvStoreServiceDeathNotifier::GetDistributedKvDataService();
69 if (ability == nullptr) {
70 return nullptr;
71 }
72
73 sptr<IRemoteObject> service = ability->GetFeatureInterface("kv_store");
74 if (service == nullptr) {
75 return nullptr;
76 }
77
78 sptr<KVDBServiceClient> client = nullptr;
79 if (service->IsProxyObject()) {
80 client = iface_cast<KVDBServiceClient>(service);
81 }
82
83 if (client == nullptr) {
84 client = new (std::nothrow) KVDBServiceClient(service);
85 }
86
87 if (client == nullptr) {
88 return nullptr;
89 }
90
91 instance_.reset(client.GetRefPtr(), [client](auto *) mutable { client = nullptr; });
92 return instance_;
93 }
94
OnRemoteDied()95 void KVDBServiceClient::ServiceDeath::OnRemoteDied()
96 {
97 std::lock_guard<decltype(mutex_)> lockGuard(mutex_);
98 instance_ = nullptr;
99 }
100
KVDBServiceClient(const sptr<IRemoteObject> & handle)101 KVDBServiceClient::KVDBServiceClient(const sptr<IRemoteObject> &handle) : IRemoteProxy(handle)
102 {
103 remote_ = Remote();
104 }
105
GetStoreIds(const AppId & appId,int32_t subUser,std::vector<StoreId> & storeIds)106 Status KVDBServiceClient::GetStoreIds(const AppId &appId, int32_t subUser, std::vector<StoreId> &storeIds)
107 {
108 MessageParcel reply;
109 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_GET_STORE_IDS),
110 reply, appId, StoreId(), subUser);
111 if (status != SUCCESS) {
112 ZLOGE("status:0x%{public}x, appId:%{public}s", status, appId.appId.c_str());
113 return static_cast<Status>(status);
114 }
115 ITypesUtil::Unmarshal(reply, storeIds);
116 return static_cast<Status>(status);
117 }
118
BeforeCreate(const AppId & appId,const StoreId & storeId,const Options & options)119 Status KVDBServiceClient::BeforeCreate(const AppId &appId, const StoreId &storeId, const Options &options)
120 {
121 MessageParcel reply;
122 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_BEFORE_CREATE),
123 reply, appId, storeId, options);
124 if (status != SUCCESS) {
125 ZLOGE("status:0x%{public}x appId:%{public}s, storeId:%{public}s", status, appId.appId.c_str(),
126 StoreUtil::Anonymous(storeId.storeId).c_str());
127 }
128 return static_cast<Status>(status);
129 }
130
AfterCreate(const AppId & appId,const StoreId & storeId,const Options & options,const std::vector<uint8_t> & password)131 Status KVDBServiceClient::AfterCreate(
132 const AppId &appId, const StoreId &storeId, const Options &options, const std::vector<uint8_t> &password)
133 {
134 MessageParcel reply;
135 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_AFTER_CREATE),
136 reply, appId, storeId, options, password);
137 if (status != SUCCESS) {
138 ZLOGE("status:0x%{public}x appId:%{public}s, storeId:%{public}s, encrypt:%{public}d", status,
139 appId.appId.c_str(), StoreUtil::Anonymous(storeId.storeId).c_str(), options.encrypt);
140 }
141 return static_cast<Status>(status);
142 }
143
Delete(const AppId & appId,const StoreId & storeId,int32_t subUser)144 Status KVDBServiceClient::Delete(const AppId &appId, const StoreId &storeId, int32_t subUser)
145 {
146 MessageParcel reply;
147 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_DELETE),
148 reply, appId, storeId, subUser);
149 if (status != SUCCESS) {
150 ZLOGE("status:0x%{public}x appId:%{public}s, storeId:%{public}s", status, appId.appId.c_str(),
151 StoreUtil::Anonymous(storeId.storeId).c_str());
152 }
153 return static_cast<Status>(status);
154 }
155
Close(const AppId & appId,const StoreId & storeId,int32_t subUser)156 Status KVDBServiceClient::Close(const AppId &appId, const StoreId &storeId, int32_t subUser)
157 {
158 MessageParcel reply;
159 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_CLOSE),
160 reply, appId, storeId, subUser);
161 if (status != SUCCESS) {
162 ZLOGE("status:0x%{public}x appId:%{public}s, storeId:%{public}s", status, appId.appId.c_str(),
163 StoreUtil::Anonymous(storeId.storeId).c_str());
164 }
165 return static_cast<Status>(status);
166 }
167
Sync(const AppId & appId,const StoreId & storeId,int32_t subUser,SyncInfo & syncInfo)168 Status KVDBServiceClient::Sync(const AppId &appId, const StoreId &storeId, int32_t subUser, SyncInfo &syncInfo)
169 {
170 MessageParcel reply;
171 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_SYNC), reply, appId, storeId,
172 syncInfo.seqId, syncInfo.mode, syncInfo.devices, syncInfo.delay, syncInfo.query, subUser, syncInfo.isRetry);
173 if (status != SUCCESS) {
174 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s, sequenceId:%{public}" PRIu64, status,
175 appId.appId.c_str(), StoreUtil::Anonymous(storeId.storeId).c_str(), syncInfo.seqId);
176 }
177 return static_cast<Status>(status);
178 }
179
CloudSync(const AppId & appId,const StoreId & storeId,const SyncInfo & syncInfo)180 Status KVDBServiceClient::CloudSync(const AppId &appId, const StoreId &storeId, const SyncInfo &syncInfo)
181 {
182 MessageParcel reply;
183 int32_t status = IPC_SEND(
184 static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_CLOUD_SYNC), reply, appId, storeId, syncInfo.seqId);
185 if (status != SUCCESS) {
186 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s" PRIu64, status, appId.appId.c_str(),
187 StoreUtil::Anonymous(storeId.storeId).c_str());
188 }
189 return static_cast<Status>(status);
190 }
191
NotifyDataChange(const AppId & appId,const StoreId & storeId,uint64_t delay)192 Status KVDBServiceClient::NotifyDataChange(const AppId &appId, const StoreId &storeId, uint64_t delay)
193 {
194 MessageParcel reply;
195 int32_t status = IPC_SEND(
196 static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_NOTIFY_DATA_CHANGE), reply, appId, storeId, delay);
197 if (status != SUCCESS) {
198 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s",
199 status, appId.appId.c_str(), StoreUtil::Anonymous(storeId.storeId).c_str());
200 }
201 return static_cast<Status>(status);
202 }
203
RegServiceNotifier(const AppId & appId,sptr<IKVDBNotifier> notifier)204 Status KVDBServiceClient::RegServiceNotifier(const AppId &appId, sptr<IKVDBNotifier> notifier)
205 {
206 MessageParcel reply;
207 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_REGISTER_NOTIFIER), reply,
208 appId, StoreId(), notifier->AsObject().GetRefPtr());
209 if (status != SUCCESS) {
210 ZLOGE("status:0x%{public}x, appId:%{public}s, notifier:0x%{public}x", status, appId.appId.c_str(),
211 StoreUtil::Anonymous(notifier.GetRefPtr()));
212 }
213 return static_cast<Status>(status);
214 }
215
UnregServiceNotifier(const AppId & appId)216 Status KVDBServiceClient::UnregServiceNotifier(const AppId &appId)
217 {
218 MessageParcel reply;
219 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_UNREGISTER_NOTIFIER),
220 reply, appId, StoreId());
221 if (status != SUCCESS) {
222 ZLOGE("status:0x%{public}x, appId:%{public}s", status, appId.appId.c_str());
223 }
224 return static_cast<Status>(status);
225 }
226
SetSyncParam(const AppId & appId,const StoreId & storeId,int32_t subUser,const KvSyncParam & syncParam)227 Status KVDBServiceClient::SetSyncParam(const AppId &appId, const StoreId &storeId, int32_t subUser,
228 const KvSyncParam &syncParam)
229 {
230 MessageParcel reply;
231 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_SET_SYNC_PARAM), reply,
232 appId, storeId, syncParam.allowedDelayMs, subUser);
233 if (status != SUCCESS) {
234 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s", status, appId.appId.c_str(),
235 StoreUtil::Anonymous(storeId.storeId).c_str());
236 }
237 return static_cast<Status>(status);
238 }
239
GetSyncParam(const AppId & appId,const StoreId & storeId,int32_t subUser,KvSyncParam & syncParam)240 Status KVDBServiceClient::GetSyncParam(const AppId &appId, const StoreId &storeId, int32_t subUser,
241 KvSyncParam &syncParam)
242 {
243 MessageParcel reply;
244 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_GET_SYNC_PARAM),
245 reply, appId, storeId, subUser);
246 if (status != SUCCESS) {
247 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s", status, appId.appId.c_str(),
248 StoreUtil::Anonymous(storeId.storeId).c_str());
249 return static_cast<Status>(status);
250 }
251 ITypesUtil::Unmarshal(reply, syncParam.allowedDelayMs);
252 return static_cast<Status>(status);
253 }
254
EnableCapability(const AppId & appId,const StoreId & storeId,int32_t subUser)255 Status KVDBServiceClient::EnableCapability(const AppId &appId, const StoreId &storeId, int32_t subUser)
256 {
257 MessageParcel reply;
258 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_ENABLE_CAP),
259 reply, appId, storeId, subUser);
260 if (status != SUCCESS) {
261 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s", status, appId.appId.c_str(),
262 StoreUtil::Anonymous(storeId.storeId).c_str());
263 }
264 return static_cast<Status>(status);
265 }
266
DisableCapability(const AppId & appId,const StoreId & storeId,int32_t subUser)267 Status KVDBServiceClient::DisableCapability(const AppId &appId, const StoreId &storeId, int32_t subUser)
268 {
269 MessageParcel reply;
270 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_DISABLE_CAP),
271 reply, appId, storeId, subUser);
272 if (status != SUCCESS) {
273 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s", status, appId.appId.c_str(),
274 StoreUtil::Anonymous(storeId.storeId).c_str());
275 }
276 return static_cast<Status>(status);
277 }
278
SetCapability(const AppId & appId,const StoreId & storeId,int32_t subUser,const std::vector<std::string> & local,const std::vector<std::string> & remote)279 Status KVDBServiceClient::SetCapability(const AppId &appId, const StoreId &storeId, int32_t subUser,
280 const std::vector<std::string> &local, const std::vector<std::string> &remote)
281 {
282 MessageParcel reply;
283 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_SET_CAP),
284 reply, appId, storeId, local, remote, subUser);
285 if (status != SUCCESS) {
286 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s", status, appId.appId.c_str(),
287 StoreUtil::Anonymous(storeId.storeId).c_str());
288 }
289 return static_cast<Status>(status);
290 }
291
AddSubscribeInfo(const AppId & appId,const StoreId & storeId,int32_t subUser,const SyncInfo & syncInfo)292 Status KVDBServiceClient::AddSubscribeInfo(const AppId &appId, const StoreId &storeId, int32_t subUser,
293 const SyncInfo &syncInfo)
294 {
295 MessageParcel reply;
296 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_ADD_SUB),
297 reply, appId, storeId, syncInfo.seqId, syncInfo.devices, syncInfo.query, subUser);
298 if (status != SUCCESS) {
299 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s, query:%{public}s", status,
300 appId.appId.c_str(), StoreUtil::Anonymous(storeId.storeId).c_str(),
301 StoreUtil::Anonymous(syncInfo.query).c_str());
302 }
303 return static_cast<Status>(status);
304 }
305
RmvSubscribeInfo(const AppId & appId,const StoreId & storeId,int32_t subUser,const SyncInfo & syncInfo)306 Status KVDBServiceClient::RmvSubscribeInfo(const AppId &appId, const StoreId &storeId, int32_t subUser,
307 const SyncInfo &syncInfo)
308 {
309 MessageParcel reply;
310 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_RMV_SUB),
311 reply, appId, storeId, syncInfo.seqId, syncInfo.devices, syncInfo.query, subUser);
312 if (status != SUCCESS) {
313 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s, query:%{public}s", status,
314 appId.appId.c_str(), StoreUtil::Anonymous(storeId.storeId).c_str(),
315 StoreUtil::Anonymous(syncInfo.query).c_str());
316 }
317 return static_cast<Status>(status);
318 }
319
Subscribe(const AppId & appId,const StoreId & storeId,int32_t subUser,sptr<IKvStoreObserver> observer)320 Status KVDBServiceClient::Subscribe(const AppId &appId, const StoreId &storeId, int32_t subUser,
321 sptr<IKvStoreObserver> observer)
322 {
323 MessageParcel reply;
324 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_SUB),
325 reply, appId, storeId, observer->AsObject(), subUser);
326 if (status != SUCCESS) {
327 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s, observer:0x%{public}x", status,
328 appId.appId.c_str(), StoreUtil::Anonymous(storeId.storeId).c_str(),
329 StoreUtil::Anonymous(observer.GetRefPtr()));
330 }
331 return static_cast<Status>(status);
332 }
333
Unsubscribe(const AppId & appId,const StoreId & storeId,int32_t subUser,sptr<IKvStoreObserver> observer)334 Status KVDBServiceClient::Unsubscribe(const AppId &appId, const StoreId &storeId, int32_t subUser,
335 sptr<IKvStoreObserver> observer)
336 {
337 MessageParcel reply;
338 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_UNSUB),
339 reply, appId, storeId, observer->AsObject().GetRefPtr(), subUser);
340 if (status != SUCCESS) {
341 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s, observer:0x%{public}x", status,
342 appId.appId.c_str(), StoreUtil::Anonymous(storeId.storeId).c_str(),
343 StoreUtil::Anonymous(observer.GetRefPtr()));
344 }
345 return static_cast<Status>(status);
346 }
347
GetBackupPassword(const AppId & appId,const StoreId & storeId,int32_t subUser,std::vector<std::vector<uint8_t>> & passwords,int32_t passwordType)348 Status KVDBServiceClient::GetBackupPassword(const AppId &appId, const StoreId &storeId, int32_t subUser,
349 std::vector<std::vector<uint8_t>> &passwords, int32_t passwordType)
350 {
351 MessageParcel reply;
352 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_GET_PASSWORD),
353 reply, appId, storeId, passwordType, subUser);
354 if (status != SUCCESS) {
355 ZLOGE("status:0x%{public}x appId:%{public}s, storeId:%{public}s", status,
356 appId.appId.c_str(), StoreUtil::Anonymous(storeId.storeId).c_str());
357 }
358 ITypesUtil::Unmarshal(reply, passwords);
359 return static_cast<Status>(status);
360 }
361
GetServiceAgent(const AppId & appId)362 sptr<KVDBNotifierClient> KVDBServiceClient::GetServiceAgent(const AppId &appId)
363 {
364 std::lock_guard<decltype(agentMtx_)> lockGuard(agentMtx_);
365 if (serviceAgent_ != nullptr) {
366 return serviceAgent_;
367 }
368
369 sptr<KVDBNotifierClient> serviceAgent = new (std::nothrow) KVDBNotifierClient();
370 if (serviceAgent == nullptr) {
371 ZLOGE("New KVDBNotifierClient failed, appId:%{public}s", appId.appId.c_str());
372 return nullptr;
373 }
374 auto status = RegServiceNotifier(appId, serviceAgent);
375 if (status == SUCCESS) {
376 serviceAgent_ = std::move(serviceAgent);
377 }
378 return serviceAgent_;
379 }
380
PutSwitch(const AppId & appId,const SwitchData & data)381 Status KVDBServiceClient::PutSwitch(const AppId &appId, const SwitchData &data)
382 {
383 MessageParcel reply;
384 int32_t status = IPC_SEND(
385 static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_PUT_SWITCH), reply, appId, StoreId(), data);
386 if (status != SUCCESS) {
387 ZLOGE("status:0x%{public}x, appId:%{public}s", status, appId.appId.c_str());
388 }
389 return static_cast<Status>(status);
390 }
391
GetSwitch(const AppId & appId,const std::string & networkId,SwitchData & data)392 Status KVDBServiceClient::GetSwitch(const AppId &appId, const std::string &networkId, SwitchData &data)
393 {
394 MessageParcel reply;
395 int32_t status = IPC_SEND(
396 static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_GET_SWITCH), reply, appId, StoreId(), networkId);
397 if (status != SUCCESS) {
398 ZLOGE("status:0x%{public}x, appId:%{public}s, networkId:%{public}s",
399 status, appId.appId.c_str(), StoreUtil::Anonymous(networkId).c_str());
400 }
401 ITypesUtil::Unmarshal(reply, data);
402 return static_cast<Status>(status);
403 }
404
SubscribeSwitchData(const AppId & appId)405 Status KVDBServiceClient::SubscribeSwitchData(const AppId &appId)
406 {
407 MessageParcel reply;
408 int32_t status = IPC_SEND(
409 static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_SUBSCRIBE_SWITCH_DATA), reply, appId, StoreId());
410 if (status != SUCCESS) {
411 ZLOGE("status:0x%{public}x, appId:%{public}s", status, appId.appId.c_str());
412 }
413 return static_cast<Status>(status);
414 }
415
UnsubscribeSwitchData(const AppId & appId)416 Status KVDBServiceClient::UnsubscribeSwitchData(const AppId &appId)
417 {
418 MessageParcel reply;
419 int32_t status = IPC_SEND(
420 static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_UNSUBSCRIBE_SWITCH_DATA), reply, appId, StoreId());
421 if (status != SUCCESS) {
422 ZLOGE("status:0x%{public}x, appId:%{public}s", status, appId.appId.c_str());
423 }
424 return static_cast<Status>(status);
425 }
426
SetConfig(const AppId & appId,const StoreId & storeId,const StoreConfig & storeConfig)427 Status KVDBServiceClient::SetConfig(const AppId &appId, const StoreId &storeId, const StoreConfig &storeConfig)
428 {
429 MessageParcel reply;
430 int32_t status = IPC_SEND(
431 static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_SET_CONFIG), reply, appId, storeId, storeConfig);
432 if (status != SUCCESS) {
433 ZLOGE("status:0x%{public}x appId:%{public}s, storeId:%{public}s", status,
434 appId.appId.c_str(), StoreUtil::Anonymous(storeId.storeId).c_str());
435 }
436 return static_cast<Status>(status);
437 }
438
RemoveDeviceData(const AppId & appId,const StoreId & storeId,int32_t subUser,const std::string & device)439 Status KVDBServiceClient::RemoveDeviceData(const AppId &appId, const StoreId &storeId, int32_t subUser,
440 const std::string &device)
441 {
442 MessageParcel reply;
443 int32_t status = IPC_SEND(
444 static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_REMOVE_DEVICE_DATA), reply, appId, storeId, device,
445 subUser);
446 if (status != SUCCESS) {
447 ZLOGE("status:0x%{public}x appId:%{public}s, storeId:%{public}s", status,
448 appId.appId.c_str(), StoreUtil::Anonymous(storeId.storeId).c_str());
449 }
450 return static_cast<Status>(status);
451 }
452 } // namespace OHOS::DistributedKv