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 
16 #include "flat_object_store.h"
17 
18 #include "accesstoken_kit.h"
19 #include "block_data.h"
20 #include "bytes_utils.h"
21 #include "client_adaptor.h"
22 #include "distributed_objectstore_impl.h"
23 #include "ipc_skeleton.h"
24 #include "logger.h"
25 #include "object_callback_impl.h"
26 #include "object_radar_reporter.h"
27 #include "object_service_proxy.h"
28 #include "objectstore_errors.h"
29 #include "softbus_adapter.h"
30 #include "string_utils.h"
31 
32 namespace OHOS::ObjectStore {
FlatObjectStore(const std::string & bundleName)33 FlatObjectStore::FlatObjectStore(const std::string &bundleName)
34 {
35     bundleName_ = bundleName;
36     storageEngine_ = std::make_shared<FlatObjectStorageEngine>();
37     uint32_t status = storageEngine_->Open(bundleName);
38     if (status != SUCCESS) {
39         LOG_ERROR("FlatObjectStore: Failed to open, error: open storage engine failure %{public}d", status);
40     }
41     cacheManager_ = new CacheManager();
42 }
43 
~FlatObjectStore()44 FlatObjectStore::~FlatObjectStore()
45 {
46     if (storageEngine_ != nullptr) {
47         storageEngine_->Close();
48         storageEngine_ = nullptr;
49     }
50     delete cacheManager_;
51     cacheManager_ = nullptr;
52 }
53 
CreateObject(const std::string & sessionId)54 uint32_t FlatObjectStore::CreateObject(const std::string &sessionId)
55 {
56     if (!cacheManager_->IsContinue()) { // NOT IN CONTINUE, CHECK PERMISSION
57         auto tokenId = IPCSkeleton::GetSelfTokenID();
58         int32_t ret = Security::AccessToken::AccessTokenKit::VerifyAccessToken(tokenId, DISTRIBUTED_DATASYNC);
59         if (ret != Security::AccessToken::PermissionState::PERMISSION_GRANTED) {
60             return ERR_NO_PERMISSION;
61         }
62     }
63     if (!storageEngine_->isOpened_ && storageEngine_->Open(bundleName_) != SUCCESS) {
64         LOG_ERROR("FlatObjectStore::DB has not inited");
65         return ERR_DB_NOT_INIT;
66     }
67     uint32_t status = storageEngine_->CreateTable(sessionId);
68     if (status != SUCCESS) {
69         LOG_ERROR("FlatObjectStore::CreateObject createTable err %{public}d", status);
70         return status;
71     }
72     SubscribeDataChange(sessionId);
73     ResumeObject(sessionId);
74     return SUCCESS;
75 }
76 
ResumeObject(const std::string & sessionId)77 void FlatObjectStore::ResumeObject(const std::string &sessionId)
78 {
79     std::function<void(const std::map<std::string, std::vector<uint8_t>> &data, bool allReady)> callback =
80     [sessionId, this](
81         const std::map<std::string, std::vector<uint8_t>> &data, bool allReady) {
82         if (data.size() == 0) {
83             LOG_INFO("retrieve empty");
84             return;
85         }
86         LOG_INFO("retrieve success, data.size:%{public}zu, allReady:%{public}d", data.size(), allReady);
87         auto result = storageEngine_->UpdateItems(sessionId, data);
88         if (result != SUCCESS) {
89             LOG_ERROR("UpdateItems failed, status = %{public}d", result);
90         }
91         if (allReady) {
92             std::lock_guard<std::mutex> lck(mutex_);
93             if (find(retrievedCache_.begin(), retrievedCache_.end(), sessionId) == retrievedCache_.end()) {
94                 retrievedCache_.push_back(sessionId);
95                 storageEngine_->NotifyStatus(sessionId, "local", "restored");
96             }
97         }
98     };
99     cacheManager_->ResumeObject(bundleName_, sessionId, callback);
100 }
101 
SubscribeDataChange(const std::string & sessionId)102 void FlatObjectStore::SubscribeDataChange(const std::string &sessionId)
103 {
104     std::function<void(const std::map<std::string, std::vector<uint8_t>> &data, bool allReady)> remoteResumeCallback =
105         [sessionId, this](const std::map<std::string, std::vector<uint8_t>> &data, bool allReady) {
106             LOG_INFO("DataChange callback. data.size:%{public}zu, allReady:%{public}d", data.size(), allReady);
107             std::map<std::string, std::vector<uint8_t>> filteredData = data;
108             FilterData(sessionId, filteredData);
109             if (!filteredData.empty()) {
110                 auto status = storageEngine_->UpdateItems(sessionId, filteredData);
111                 if (status != SUCCESS) {
112                     LOG_ERROR("UpdateItems failed, status = %{public}d", status);
113                 }
114                 storageEngine_->NotifyChange(sessionId, filteredData);
115             }
116             if (allReady) {
117                 std::lock_guard<std::mutex> lck(mutex_);
118                 if (find(retrievedCache_.begin(), retrievedCache_.end(), sessionId) == retrievedCache_.end()) {
119                     retrievedCache_.push_back(sessionId);
120                     storageEngine_->NotifyStatus(sessionId, "local", "restored");
121                 }
122             }
123         };
124     cacheManager_->SubscribeDataChange(bundleName_, sessionId, remoteResumeCallback);
125 }
126 
Delete(const std::string & sessionId)127 uint32_t FlatObjectStore::Delete(const std::string &sessionId)
128 {
129     if (!storageEngine_->isOpened_ && storageEngine_->Open(bundleName_) != SUCCESS) {
130         LOG_ERROR("FlatObjectStore::DB has not inited");
131         return ERR_DB_NOT_INIT;
132     }
133     uint32_t status = storageEngine_->DeleteTable(sessionId);
134     if (status != SUCCESS) {
135         LOG_ERROR("FlatObjectStore: Failed to delete object %{public}d", status);
136         return status;
137     }
138     cacheManager_->UnregisterDataChange(bundleName_, sessionId);
139     cacheManager_->DeleteSnapshot(bundleName_, sessionId);
140     return SUCCESS;
141 }
142 
Watch(const std::string & sessionId,std::shared_ptr<FlatObjectWatcher> watcher)143 uint32_t FlatObjectStore::Watch(const std::string &sessionId, std::shared_ptr<FlatObjectWatcher> watcher)
144 {
145     if (!storageEngine_->isOpened_ && storageEngine_->Open(bundleName_) != SUCCESS) {
146         LOG_ERROR("FlatObjectStore::DB has not inited");
147         return ERR_DB_NOT_INIT;
148     }
149     uint32_t status = storageEngine_->RegisterObserver(sessionId, watcher);
150     if (status != SUCCESS) {
151         LOG_ERROR("FlatObjectStore::Watch failed %{public}d", status);
152     }
153     return status;
154 }
155 
UnWatch(const std::string & sessionId)156 uint32_t FlatObjectStore::UnWatch(const std::string &sessionId)
157 {
158     if (!storageEngine_->isOpened_ && storageEngine_->Open(bundleName_) != SUCCESS) {
159         LOG_ERROR("FlatObjectStore::DB has not inited");
160         return ERR_DB_NOT_INIT;
161     }
162     uint32_t status = storageEngine_->UnRegisterObserver(sessionId);
163     if (status != SUCCESS) {
164         LOG_ERROR("FlatObjectStore::Watch failed %{public}d", status);
165     }
166     return status;
167 }
168 
Put(const std::string & sessionId,const std::string & key,std::vector<uint8_t> value)169 uint32_t FlatObjectStore::Put(const std::string &sessionId, const std::string &key, std::vector<uint8_t> value)
170 {
171     if (!storageEngine_->isOpened_ && storageEngine_->Open(bundleName_) != SUCCESS) {
172         LOG_ERROR("FlatObjectStore::DB has not inited");
173         return ERR_DB_NOT_INIT;
174     }
175     return storageEngine_->UpdateItem(sessionId, key, value);
176 }
177 
Get(const std::string & sessionId,const std::string & key,Bytes & value)178 uint32_t FlatObjectStore::Get(const std::string &sessionId, const std::string &key, Bytes &value)
179 {
180     if (!storageEngine_->isOpened_ && storageEngine_->Open(bundleName_) != SUCCESS) {
181         LOG_ERROR("FlatObjectStore::DB has not inited");
182         return ERR_DB_NOT_INIT;
183     }
184     return storageEngine_->GetItem(sessionId, key, value);
185 }
186 
SetStatusNotifier(std::shared_ptr<StatusWatcher> notifier)187 uint32_t FlatObjectStore::SetStatusNotifier(std::shared_ptr<StatusWatcher> notifier)
188 {
189     if (!storageEngine_->isOpened_ && storageEngine_->Open(bundleName_) != SUCCESS) {
190         LOG_ERROR("FlatObjectStore::DB has not inited");
191         return ERR_DB_NOT_INIT;
192     }
193     return storageEngine_->SetStatusNotifier(notifier);
194 }
195 
Save(const std::string & sessionId,const std::string & deviceId)196 uint32_t FlatObjectStore::Save(const std::string &sessionId, const std::string &deviceId)
197 {
198     RadarReporter::ReportStateStart(std::string(__FUNCTION__), SAVE, SAVE_TO_SERVICE, IDLE, START, bundleName_);
199     if (cacheManager_ == nullptr) {
200         LOG_ERROR("FlatObjectStore::cacheManager_ is null");
201         return ERR_NULL_PTR;
202     }
203     std::map<std::string, std::vector<uint8_t>> objectData;
204     uint32_t status = storageEngine_->GetItems(sessionId, objectData);
205     if (status != SUCCESS) {
206         LOG_ERROR("FlatObjectStore::GetItems fail");
207         RadarReporter::ReportStateError(std::string(__FUNCTION__), SAVE, SAVE_TO_SERVICE,
208             RADAR_FAILED, status, FINISHED);
209         return status;
210     }
211     return cacheManager_->Save(bundleName_, sessionId, deviceId, objectData);
212 }
213 
RevokeSave(const std::string & sessionId)214 uint32_t FlatObjectStore::RevokeSave(const std::string &sessionId)
215 {
216     if (cacheManager_ == nullptr) {
217         LOG_ERROR("FlatObjectStore::cacheManager_ is null");
218         return ERR_NULL_PTR;
219     }
220     return cacheManager_->RevokeSave(bundleName_, sessionId);
221 }
222 
BindAssetStore(const std::string & sessionId,AssetBindInfo & bindInfo,Asset & assetValue)223 uint32_t FlatObjectStore::BindAssetStore(const std::string &sessionId, AssetBindInfo &bindInfo, Asset &assetValue)
224 {
225     std::unique_lock<std::mutex> lck(mutex_);
226     sptr<OHOS::DistributedObject::IObjectService> proxy = ClientAdaptor::GetObjectService();
227     if (proxy == nullptr) {
228         LOG_ERROR("proxy is nullptr.");
229         return ERR_PROCESSING;
230     }
231     int32_t status = proxy->BindAssetStore(bundleName_, sessionId, assetValue, bindInfo);
232     if (status != SUCCESS) {
233         LOG_ERROR("object bind asset failed code=%{public}d.", static_cast<int>(status));
234     }
235     LOG_DEBUG("object bind asset successful sessionId: %{public}s and assetName %{public}s", sessionId.c_str(),
236         assetValue.name.c_str());
237     return status;
238 }
239 
CheckRetrieveCache(const std::string & sessionId)240 void FlatObjectStore::CheckRetrieveCache(const std::string &sessionId)
241 {
242     std::lock_guard<std::mutex> lck(mutex_);
243     auto iter = find(retrievedCache_.begin(), retrievedCache_.end(), sessionId);
244     if (iter != retrievedCache_.end()) {
245         storageEngine_->NotifyStatus(*iter, "local", "restored");
246         retrievedCache_.erase(iter);
247     }
248 }
249 
FilterData(const std::string & sessionId,std::map<std::string,std::vector<uint8_t>> & data)250 void FlatObjectStore::FilterData(const std::string &sessionId,
251                                  std::map<std::string, std::vector<uint8_t>> &data)
252 {
253     std::map<std::string, std::vector<uint8_t>> allData {};
254     storageEngine_->GetItems(sessionId, allData);
255     for (const auto &item : allData) {
256         data.erase(item.first);
257     }
258 }
259 
PutDouble(const std::string & sessionId,const std::string & key,double value)260 uint32_t FlatObjectStore::PutDouble(const std::string &sessionId, const std::string &key, double value)
261 {
262     Bytes data;
263     Type type = Type::TYPE_DOUBLE;
264     BytesUtils::PutNum(&type, 0, sizeof(type), data);
265     BytesUtils::PutNum(&value, sizeof(type), sizeof(value), data);
266     return Put(sessionId, FIELDS_PREFIX + key, data);
267 }
268 
PutBoolean(const std::string & sessionId,const std::string & key,bool value)269 uint32_t FlatObjectStore::PutBoolean(const std::string &sessionId, const std::string &key, bool value)
270 {
271     Bytes data;
272     Type type = Type::TYPE_BOOLEAN;
273     BytesUtils::PutNum(&type, 0, sizeof(type), data);
274     BytesUtils::PutNum(&value, sizeof(type), sizeof(value), data);
275     return Put(sessionId, FIELDS_PREFIX + key, data);
276 }
277 
PutString(const std::string & sessionId,const std::string & key,const std::string & value)278 uint32_t FlatObjectStore::PutString(const std::string &sessionId, const std::string &key, const std::string &value)
279 {
280     Bytes data;
281     Type type = Type::TYPE_STRING;
282     BytesUtils::PutNum(&type, 0, sizeof(type), data);
283     Bytes dst = StringUtils::StrToBytes(value);
284     data.insert(data.end(), dst.begin(), dst.end());
285     return Put(sessionId, FIELDS_PREFIX + key, data);
286 }
287 
GetDouble(const std::string & sessionId,const std::string & key,double & value)288 uint32_t FlatObjectStore::GetDouble(const std::string &sessionId, const std::string &key, double &value)
289 {
290     Bytes data;
291     Bytes keyBytes = StringUtils::StrToBytes(key);
292     uint32_t status = Get(sessionId, FIELDS_PREFIX + key, data);
293     if (status != SUCCESS) {
294         LOG_ERROR("GetDouble field not exist. %{public}d %{public}s", status, key.c_str());
295         return status;
296     }
297     status = BytesUtils::GetNum(data, sizeof(Type), &value, sizeof(value));
298     if (status != SUCCESS) {
299         LOG_ERROR("GetDouble getNum err. %{public}d", status);
300     }
301     return status;
302 }
303 
GetBoolean(const std::string & sessionId,const std::string & key,bool & value)304 uint32_t FlatObjectStore::GetBoolean(const std::string &sessionId, const std::string &key, bool &value)
305 {
306     Bytes data;
307     Bytes keyBytes = StringUtils::StrToBytes(key);
308     uint32_t status = Get(sessionId, FIELDS_PREFIX + key, data);
309     if (status != SUCCESS) {
310         LOG_ERROR("GetBoolean field not exist. %{public}d %{public}s", status, key.c_str());
311         return status;
312     }
313     status = BytesUtils::GetNum(data, sizeof(Type), &value, sizeof(value));
314     if (status != SUCCESS) {
315         LOG_ERROR("GetBoolean getNum err. %{public}d", status);
316         return status;
317     }
318     return SUCCESS;
319 }
320 
GetString(const std::string & sessionId,const std::string & key,std::string & value)321 uint32_t FlatObjectStore::GetString(const std::string &sessionId, const std::string &key, std::string &value)
322 {
323     Bytes data;
324     uint32_t status = Get(sessionId, FIELDS_PREFIX + key, data);
325     if (status != SUCCESS) {
326         LOG_ERROR("GetString field not exist. %{public}d %{public}s", status, key.c_str());
327         return status;
328     }
329     status = StringUtils::BytesToStrWithType(data, value);
330     if (status != SUCCESS) {
331         LOG_ERROR("GetString dataToVal err. %{public}d", status);
332     }
333     return status;
334 }
335 
PutComplex(const std::string & sessionId,const std::string & key,const std::vector<uint8_t> & value)336 uint32_t FlatObjectStore::PutComplex(const std::string &sessionId, const std::string &key,
337     const std::vector<uint8_t> &value)
338 {
339     Bytes data;
340     Type type = Type::TYPE_COMPLEX;
341     BytesUtils::PutNum(&type, 0, sizeof(type), data);
342     data.insert(data.end(), value.begin(), value.end());
343     uint32_t status = Put(sessionId, FIELDS_PREFIX + key, data);
344     if (status != SUCCESS) {
345         LOG_ERROR("PutBoolean setField err %{public}d", status);
346     }
347     return status;
348 }
349 
GetComplex(const std::string & sessionId,const std::string & key,std::vector<uint8_t> & value)350 uint32_t FlatObjectStore::GetComplex(const std::string &sessionId, const std::string &key,
351     std::vector<uint8_t> &value)
352 {
353     uint32_t status = Get(sessionId, FIELDS_PREFIX + key, value);
354     if (status != SUCCESS) {
355         LOG_ERROR("GetString field not exist. %{public}d %{public}s", status, key.c_str());
356         return status;
357     }
358     value.erase(value.begin(), value.begin() + sizeof(Type));
359     return status;
360 }
361 
GetType(const std::string & sessionId,const std::string & key,Type & type)362 uint32_t FlatObjectStore::GetType(const std::string &sessionId, const std::string &key, Type &type)
363 {
364     Bytes data;
365     uint32_t status = Get(sessionId, FIELDS_PREFIX + key, data);
366     if (status != SUCCESS) {
367         LOG_ERROR("GetString field not exist. %{public}d %{public}s", status, key.c_str());
368         return status;
369     }
370     status = BytesUtils::GetNum(data, 0, &type, sizeof(type));
371     if (status != SUCCESS) {
372         LOG_ERROR("GetBoolean getNum err. %{public}d", status);
373         return status;
374     }
375     return SUCCESS;
376 }
377 
GetBundleName()378 std::string FlatObjectStore::GetBundleName()
379 {
380     return bundleName_;
381 }
382 
CacheManager()383 CacheManager::CacheManager()
384 {
385 }
386 
Save(const std::string & bundleName,const std::string & sessionId,const std::string & deviceId,const std::map<std::string,std::vector<uint8_t>> & objectData)387 uint32_t CacheManager::Save(const std::string &bundleName, const std::string &sessionId, const std::string &deviceId,
388     const std::map<std::string, std::vector<uint8_t>> &objectData)
389 {
390     std::unique_lock<std::mutex> lck(mutex_);
391     auto block = std::make_shared<BlockData<std::tuple<bool, int32_t>>>(WAIT_TIME, std::tuple{ true, ERR_DB_GET_FAIL });
392     int32_t status = SaveObject(bundleName, sessionId, deviceId, objectData,
393         [deviceId, block](const std::map<std::string, int32_t> &results) {
394             LOG_INFO("CacheManager::task callback");
395             if (results.count(deviceId) != 0) {
396                 block->SetValue({ false, results.at(deviceId) });
397             } else {
398                 block->SetValue({ false, ERR_DB_GET_FAIL });
399             }
400         });
401     if (status != SUCCESS) {
402         LOG_ERROR("SaveObject failed");
403         return status;
404     }
405     LOG_INFO("CacheManager::start wait");
406     auto [timeout, res] = block->GetValue();
407     LOG_INFO("CacheManager::end wait, timeout: %{public}d, result: %{public}d", timeout, res);
408     return res;
409 }
410 
RevokeSave(const std::string & bundleName,const std::string & sessionId)411 uint32_t CacheManager::RevokeSave(const std::string &bundleName, const std::string &sessionId)
412 {
413     std::unique_lock<std::mutex> lck(mutex_);
414     auto block = std::make_shared<BlockData<std::tuple<bool, int32_t>>>(WAIT_TIME, std::tuple{ true, ERR_DB_GET_FAIL });
415     int32_t status = RevokeSaveObject(bundleName, sessionId, [block](int32_t result) {
416         LOG_INFO("CacheManager::task callback");
417         block->SetValue({ false, result });
418     });
419     if (status != SUCCESS) {
420         LOG_ERROR("RevokeSaveObject failed");
421         return status;
422     }
423     LOG_INFO("CacheManager::start wait");
424     auto [timeout, res] = block->GetValue();
425     LOG_INFO("CacheManager::end wait, timeout: %{public}d, result: %{public}d", timeout, res);
426     return res;
427 }
428 
SaveObject(const std::string & bundleName,const std::string & sessionId,const std::string & deviceId,const std::map<std::string,std::vector<uint8_t>> & objectData,const std::function<void (const std::map<std::string,int32_t> &)> & callback)429 int32_t CacheManager::SaveObject(const std::string &bundleName, const std::string &sessionId,
430     const std::string &deviceId, const std::map<std::string, std::vector<uint8_t>> &objectData,
431     const std::function<void(const std::map<std::string, int32_t> &)> &callback)
432 {
433     sptr<OHOS::DistributedObject::IObjectService> proxy = ClientAdaptor::GetObjectService();
434     if (proxy == nullptr) {
435         LOG_ERROR("proxy is nullptr.");
436         RadarReporter::ReportStateError(std::string(__FUNCTION__), SAVE, SAVE_TO_SERVICE,
437             RADAR_FAILED, SA_DIED, FINISHED);
438         return ERR_PROCESSING;
439     }
440     sptr<ObjectSaveCallbackBroker> objectSaveCallback = new (std::nothrow) ObjectSaveCallback(callback);
441     if (objectSaveCallback == nullptr) {
442         LOG_ERROR("CacheManager::SaveObject no memory for ObjectSaveCallback malloc!");
443         RadarReporter::ReportStateError(std::string(__FUNCTION__), SAVE, SAVE_TO_SERVICE,
444             RADAR_FAILED, NO_MEMORY, FINISHED);
445         return ERR_NULL_PTR;
446     }
447     int32_t status = proxy->ObjectStoreSave(
448         bundleName, sessionId, deviceId, objectData, objectSaveCallback->AsObject().GetRefPtr());
449     if (status != SUCCESS) {
450         LOG_ERROR("object save failed code=%d.", static_cast<int>(status));
451         RadarReporter::ReportStateError(std::string(__FUNCTION__), SAVE, SAVE_TO_SERVICE,
452             RADAR_FAILED, IPC_ERROR, FINISHED);
453     } else {
454         RadarReporter::ReportStage(std::string(__FUNCTION__), SAVE, SAVE_TO_SERVICE, RADAR_SUCCESS);
455     }
456     return status;
457 }
458 
RevokeSaveObject(const std::string & bundleName,const std::string & sessionId,const std::function<void (int32_t)> & callback)459 int32_t CacheManager::RevokeSaveObject(
460     const std::string &bundleName, const std::string &sessionId, const std::function<void(int32_t)> &callback)
461 {
462     sptr<OHOS::DistributedObject::IObjectService> proxy = ClientAdaptor::GetObjectService();
463     if (proxy == nullptr) {
464         LOG_ERROR("proxy is nullptr.");
465         return ERR_PROCESSING;
466     }
467     sptr<ObjectRevokeSaveCallbackBroker> objectRevokeSaveCallback = new (std::nothrow)
468         ObjectRevokeSaveCallback(callback);
469     if (objectRevokeSaveCallback == nullptr) {
470         LOG_ERROR("CacheManager::RevokeSaveObject no memory for ObjectRevokeSaveCallback malloc!");
471         return ERR_NULL_PTR;
472     }
473     int32_t status = proxy->ObjectStoreRevokeSave(
474         bundleName, sessionId, objectRevokeSaveCallback->AsObject().GetRefPtr());
475     if (status != SUCCESS) {
476         LOG_ERROR("object revoke save failed code=%d.", static_cast<int>(status));
477     }
478     LOG_INFO("object revoke save successful");
479     return status;
480 }
481 
ResumeObject(const std::string & bundleName,const std::string & sessionId,std::function<void (const std::map<std::string,std::vector<uint8_t>> & data,bool allReady)> & callback)482 int32_t CacheManager::ResumeObject(const std::string &bundleName, const std::string &sessionId,
483     std::function<void(const std::map<std::string, std::vector<uint8_t>> &data, bool allReady)> &callback)
484 {
485     sptr<OHOS::DistributedObject::IObjectService> proxy = ClientAdaptor::GetObjectService();
486     if (proxy == nullptr) {
487         LOG_ERROR("proxy is nullptr.");
488         return ERR_NULL_PTR;
489     }
490     sptr<ObjectRetrieveCallbackBroker> objectRetrieveCallback = new (std::nothrow) ObjectRetrieveCallback(callback);
491     if (objectRetrieveCallback == nullptr) {
492         LOG_ERROR("CacheManager::ResumeObject no memory for ObjectRetrieveCallback malloc!");
493         return ERR_NULL_PTR;
494     }
495     int32_t status = proxy->ObjectStoreRetrieve(
496         bundleName, sessionId, objectRetrieveCallback->AsObject().GetRefPtr());
497     if (status != SUCCESS) {
498         LOG_ERROR("object resume failed code=%d.", static_cast<int>(status));
499     }
500     LOG_INFO("object resume successful");
501     return status;
502 }
503 
SubscribeDataChange(const std::string & bundleName,const std::string & sessionId,std::function<void (const std::map<std::string,std::vector<uint8_t>> & data,bool allReady)> & callback)504 int32_t CacheManager::SubscribeDataChange(const std::string &bundleName, const std::string &sessionId,
505     std::function<void(const std::map<std::string, std::vector<uint8_t>> &data, bool allReady)> &callback)
506 {
507     sptr<OHOS::DistributedObject::IObjectService> proxy = ClientAdaptor::GetObjectService();
508     if (proxy == nullptr) {
509         LOG_ERROR("proxy is nullptr.");
510         return ERR_NULL_PTR;
511     }
512     sptr<ObjectChangeCallbackBroker> objectRemoteResumeCallback = new (std::nothrow) ObjectChangeCallback(callback);
513     if (objectRemoteResumeCallback == nullptr) {
514         LOG_ERROR("CacheManager::SubscribeDataChange no memory for ObjectChangeCallback malloc!");
515         return ERR_NULL_PTR;
516     }
517     ClientAdaptor::RegisterClientDeathListener(bundleName, objectRemoteResumeCallback->AsObject());
518     int32_t status = proxy->RegisterDataObserver(
519         bundleName, sessionId, objectRemoteResumeCallback->AsObject().GetRefPtr());
520     if (status != SUCCESS) {
521         LOG_ERROR("object remote resume failed code=%d.", static_cast<int>(status));
522     }
523     LOG_INFO("object remote resume successful");
524     return status;
525 }
526 
UnregisterDataChange(const std::string & bundleName,const std::string & sessionId)527 int32_t CacheManager::UnregisterDataChange(const std::string &bundleName, const std::string &sessionId)
528 {
529     sptr<OHOS::DistributedObject::IObjectService> proxy = ClientAdaptor::GetObjectService();
530     if (proxy == nullptr) {
531         LOG_ERROR("proxy is nullptr.");
532         return ERR_NULL_PTR;
533     }
534     int32_t status = proxy->UnregisterDataChangeObserver(bundleName, sessionId);
535     if (status != SUCCESS) {
536         LOG_ERROR("object remote resume failed code=%d.", static_cast<int>(status));
537     }
538     LOG_INFO("object unregister data change observer successful");
539     return status;
540 }
541 
DeleteSnapshot(const std::string & bundleName,const std::string & sessionId)542 int32_t CacheManager::DeleteSnapshot(const std::string &bundleName, const std::string &sessionId)
543 {
544     sptr<OHOS::DistributedObject::IObjectService> proxy = ClientAdaptor::GetObjectService();
545     if (proxy == nullptr) {
546         LOG_ERROR("proxy is nullptr.");
547         return ERR_NULL_PTR;
548     }
549     int32_t status = proxy->DeleteSnapshot(bundleName, sessionId);
550     if (status != SUCCESS) {
551         LOG_ERROR("object delete snapshot failed code=%d.", static_cast<int>(status));
552     }
553     LOG_INFO("object delete snapshot successful");
554     return status;
555 }
556 
IsContinue()557 bool CacheManager::IsContinue()
558 {
559     sptr<OHOS::DistributedObject::IObjectService> proxy = ClientAdaptor::GetObjectService();
560     if (proxy == nullptr) {
561         LOG_ERROR("Object service proxy is nullptr");
562         return false;
563     }
564     bool isContinue = false;
565     int32_t status = proxy->IsContinue(isContinue);
566     if (status != SUCCESS) {
567         LOG_ERROR("Get continue state failed, status: %{public}d, isContinue: %{public}d", status, isContinue);
568     }
569     return isContinue;
570 }
571 } // namespace OHOS::ObjectStore
572