diff --git a/services/distributeddataservice/service/object/include/object_callback_proxy.h b/services/distributeddataservice/service/object/include/object_callback_proxy.h index e29908493e5d2e0fe57a3f33710ed8a158e64ef4..fabd1494186af829b9f377b09fe6fa4c10e7e358 100644 --- a/services/distributeddataservice/service/object/include/object_callback_proxy.h +++ b/services/distributeddataservice/service/object/include/object_callback_proxy.h @@ -80,6 +80,20 @@ public: private: static inline BrokerDelegator delegator_; }; + +class ObjectProgressCallbackProxyBroker : public IObjectProgressCallback, public IRemoteBroker { +public: + DECLARE_INTERFACE_DESCRIPTOR(u"OHOS.DistributedObject.IObjectProgressCallback"); +}; + +class ObjectProgressCallbackProxy : public IRemoteProxy { +public: + explicit ObjectProgressCallbackProxy(const sptr &impl); + ~ObjectProgressCallbackProxy() = default; + void Completed(int32_t progress) override; +private: + static inline BrokerDelegator delegator_; +}; } // namespace DistributedObject } // namespace OHOS #endif // DISTRIBUTEDDATAMGR_OBJECT_CALLBACK_PROXY_H diff --git a/services/distributeddataservice/service/object/include/object_manager.h b/services/distributeddataservice/service/object/include/object_manager.h index c87f1196a38ce52ad09aae8655197174e781144a..7be1336b1a7f57d54f8faf9d3af98981f42cf27e 100644 --- a/services/distributeddataservice/service/object/include/object_manager.h +++ b/services/distributeddataservice/service/object/include/object_manager.h @@ -92,14 +92,18 @@ public: int32_t InitUserMeta(); int32_t DeleteByAppId(const std::string &appId, int32_t user); void RegisterRemoteCallback(const std::string &bundleName, const std::string &sessionId, - pid_t pid, uint32_t tokenId, - sptr callback); + pid_t pid, uint32_t tokenId, sptr callback); void UnregisterRemoteCallback(const std::string &bundleName, pid_t pid, uint32_t tokenId, - const std::string &sessionId = ""); + const std::string &sessionId = ""); + void RegisterProgressObserverCallback(const std::string &bundleName, const std::string &sessionId, + pid_t pid, uint32_t tokenId, sptr callback); + void UnregisterProgressObserverCallback(const std::string &bundleName, pid_t pid, uint32_t tokenId, + const std::string &sessionId = ""); void NotifyChange(const ObjectRecord &changedData); void NotifyAssetsReady(const std::string& objectKey, const std::string& bundleName, const std::string& srcNetworkId = ""); void NotifyAssetsStart(const std::string& objectKey, const std::string& srcNetworkId = ""); + void NotifyAssetsRecvProgress(const std::string& objectKey, int32_t progress); void SetThreadPool(std::shared_ptr executors); UriToSnapshot GetSnapShots(const std::string &bundleName, const std::string &storeName); int32_t BindAsset(const uint32_t tokenId, const std::string& appId, const std::string& sessionId, @@ -128,10 +132,15 @@ private: std::map> observers_; bool operator<(const CallbackInfo &it_) const { - if (pid < it_.pid) { - return true; - } - return false; + return pid < it_.pid; + } + }; + struct ProgressCallbackInfo { + pid_t pid; + std::map> observers_; + bool operator<(const ProgressCallbackInfo &it_) const + { + return pid < it_.pid; } }; struct SaveInfo : DistributedData::Serializable { @@ -213,12 +222,16 @@ private: std::string userId_; std::atomic isSyncing_ = false; ConcurrentMap callbacks_; + ConcurrentMap processCallbacks_; std::shared_ptr executors_; DistributedData::AssetBindInfo ConvertBindInfo(ObjectStore::AssetBindInfo& bindInfo); ConcurrentMap> snapshots_; // key:bundleName_sessionId ConcurrentMap bindSnapshots_; // key:bundleName_storeName ConcurrentMap restoreStatus_; // key:bundleName+sessionId ConcurrentMap objectTimer_; // key:bundleName+sessionId + ConcurrentMap assetsRecvProgress_; // key:bundleName+sessionId + std::map progressInfo_; + std::mutex progressMutex_; }; } // namespace DistributedObject } // namespace OHOS diff --git a/services/distributeddataservice/service/object/include/object_service_impl.h b/services/distributeddataservice/service/object/include/object_service_impl.h index e398edface1861cb6e1ff32a6e57eb41293fba57..4dd5f1ca69e85670efaf8718cfdbf92255eb352b 100644 --- a/services/distributeddataservice/service/object/include/object_service_impl.h +++ b/services/distributeddataservice/service/object/include/object_service_impl.h @@ -38,6 +38,9 @@ public: int32_t RegisterDataObserver(const std::string &bundleName, const std::string &sessionId, sptr callback) override; int32_t UnregisterDataChangeObserver(const std::string &bundleName, const std::string &sessionId) override; + int32_t RegisterProgressObserver(const std::string &bundleName, const std::string &sessionId, + sptr callback) override; + int32_t UnregisterProgressObserver(const std::string &bundleName, const std::string &sessionId) override; int32_t DeleteSnapshot(const std::string &bundleName, const std::string &sessionId) override; int32_t IsBundleNameEqualTokenId( const std::string &bundleName, const std::string &sessionId, const uint32_t &tokenId); diff --git a/services/distributeddataservice/service/object/include/object_service_stub.h b/services/distributeddataservice/service/object/include/object_service_stub.h index fef5c7ecaac6985175b2a45baf113ea1eaf075c4..e254a2bd1584eff386c236388ad3c9173f4e22a8 100644 --- a/services/distributeddataservice/service/object/include/object_service_stub.h +++ b/services/distributeddataservice/service/object/include/object_service_stub.h @@ -37,6 +37,8 @@ private: int32_t ObjectStoreBindAssetOnRemote(MessageParcel &data, MessageParcel &reply); int32_t OnDeleteSnapshot(MessageParcel &data, MessageParcel &reply); int32_t OnIsContinue(MessageParcel &data, MessageParcel &reply); + int32_t OnSubscribeProgress(MessageParcel &data, MessageParcel &reply); + int32_t OnUnsubscribeProgress(MessageParcel &data, MessageParcel &reply); using RequestHandle = int (ObjectServiceStub::*)(MessageParcel &, MessageParcel &); static constexpr RequestHandle HANDLERS[static_cast(ObjectCode::OBJECTSTORE_SERVICE_CMD_MAX)] = { &ObjectServiceStub::ObjectStoreSaveOnRemote, @@ -48,6 +50,8 @@ private: &ObjectServiceStub::ObjectStoreBindAssetOnRemote, &ObjectServiceStub::OnDeleteSnapshot, &ObjectServiceStub::OnIsContinue, + &ObjectServiceStub::OnSubscribeProgress, + &ObjectServiceStub::OnUnsubscribeProgress, }; }; } // namespace OHOS::DistributedRdb diff --git a/services/distributeddataservice/service/object/src/object_callback_proxy.cpp b/services/distributeddataservice/service/object/src/object_callback_proxy.cpp index 7e4c649a5cab95e7d7b400dfe3601688a38bf209..ddf0e956e5f553c2a1c54b89c5883836de0e5ded 100644 --- a/services/distributeddataservice/service/object/src/object_callback_proxy.cpp +++ b/services/distributeddataservice/service/object/src/object_callback_proxy.cpp @@ -42,6 +42,11 @@ ObjectChangeCallbackProxy::ObjectChangeCallbackProxy(const sptr & { } +ObjectProgressCallbackProxy::ObjectProgressCallbackProxy(const sptr &impl) + : IRemoteProxy(impl) +{ +} + void ObjectSaveCallbackProxy::Completed(const std::map &results) { MessageParcel data; @@ -117,5 +122,24 @@ void ObjectChangeCallbackProxy::Completed(const std::mapSendRequest(COMPLETED, data, reply, mo); + if (error != 0) { + ZLOGW("SendRequest failed, error %d", error); + } +} } // namespace DistributedObject } // namespace OHOS \ No newline at end of file diff --git a/services/distributeddataservice/service/object/src/object_data_listener.cpp b/services/distributeddataservice/service/object/src/object_data_listener.cpp index b327f5f5d3b1ed2a1b61b08b439963d5f0e8bf87..33d03df1a478c94d14eddc35f9af58736f9c9416 100644 --- a/services/distributeddataservice/service/object/src/object_data_listener.cpp +++ b/services/distributeddataservice/service/object/src/object_data_listener.cpp @@ -22,6 +22,8 @@ #include "utils/anonymous.h" namespace OHOS { namespace DistributedObject { +constexpr int32_t PROGRESS_MAX = 100; +constexpr int32_t PROGRESS_INVALID = -1; ObjectDataListener::ObjectDataListener() { } @@ -52,6 +54,7 @@ int32_t ObjectAssetsRecvListener::OnStart(const std::string &srcNetworkId, const auto objectKey = dstBundleName + sessionId; ZLOGI("OnStart, objectKey:%{public}s", objectKey.c_str()); ObjectStoreManager::GetInstance()->NotifyAssetsStart(objectKey, srcNetworkId); + ObjectStoreManager::GetInstance()->NotifyAssetsRecvProgress(objectKey, 0); return OBJECT_SUCCESS; } @@ -69,23 +72,31 @@ int32_t ObjectAssetsRecvListener::OnFinished(const std::string &srcNetworkId, co ZLOGI("OnFinished, status:%{public}d objectKey:%{public}s, asset size:%{public}zu", result, objectKey.c_str(), assetObj->uris_.size()); ObjectStoreManager::GetInstance()->NotifyAssetsReady(objectKey, assetObj->dstBundleName_, srcNetworkId); + if (result != OBJECT_SUCCESS) { + ObjectStoreManager::GetInstance()->NotifyAssetsRecvProgress(objectKey, PROGRESS_INVALID); + } else { + ObjectStoreManager::GetInstance()->NotifyAssetsRecvProgress(objectKey, PROGRESS_MAX); + } return OBJECT_SUCCESS; } - -int32_t ObjectAssetsRecvListener::OnRecvProgress(const std::string &srcNetworkId, const sptr &assetObj, - uint64_t totalBytes, uint64_t processBytes) +int32_t ObjectAssetsRecvListener::OnRecvProgress( + const std::string &srcNetworkId, const sptr &assetObj, uint64_t totalBytes, uint64_t processBytes) { - if (assetObj == nullptr) { - ZLOGE("OnRecvProgress error! srcNetworkId:%{public}s", - DistributedData::Anonymous::Change(srcNetworkId).c_str()); + if (assetObj == nullptr || totalBytes == 0) { + ZLOGE("OnRecvProgress error! srcNetworkId:%{public}s, totalBytes: %{public}llu", + DistributedData::Anonymous::Change(srcNetworkId).c_str(), totalBytes); return OBJECT_INNER_ERROR; } auto objectKey = assetObj->dstBundleName_ + assetObj->sessionId_; - ZLOGI("OnRecvProgress, srcNetworkId: %{public}s, objectKey:%{public}s, totalBytes: %{public}" PRIu64 - ", processBytes: %{public}" PRIu64 ".", - DistributedData::Anonymous::Change(srcNetworkId).c_str(), objectKey.c_str(), totalBytes, processBytes); + ZLOGI("srcNetworkId: %{public}s, objectKey:%{public}s, totalBytes: %{public}llu," + "processBytes: %{public}llu.", + DistributedData::Anonymous::Change(srcNetworkId).c_str(), + DistributedData::Anonymous::Change(objectKey).c_str(), totalBytes, processBytes); + + int32_t progress = static_cast((processBytes * 100.0 / totalBytes) * 0.9); + ObjectStoreManager::GetInstance()->NotifyAssetsRecvProgress(objectKey, progress); return OBJECT_SUCCESS; } } // namespace DistributedObject diff --git a/services/distributeddataservice/service/object/src/object_manager.cpp b/services/distributeddataservice/service/object/src/object_manager.cpp index 958470f18cce7a13ca498683ee70ae92ac86761d..557b61de3a91759c4c61c2f58b582f3e594a8f46 100644 --- a/services/distributeddataservice/service/object/src/object_manager.cpp +++ b/services/distributeddataservice/service/object/src/object_manager.cpp @@ -45,6 +45,8 @@ using AccessTokenKit = Security::AccessToken::AccessTokenKit; using ValueProxy = OHOS::DistributedData::ValueProxy; using DistributedFileDaemonManager = Storage::DistributedFile::DistributedFileDaemonManager; constexpr const char *SAVE_INFO = "p_###SAVEINFO###"; +constexpr int32_t PROGRESS_MAX = 100; +constexpr int32_t PROGRESS_INVALID = -1; ObjectStoreManager::ObjectStoreManager() { ZLOGI("ObjectStoreManager construct"); @@ -318,6 +320,7 @@ int32_t ObjectStoreManager::Clear() } result = RevokeSaveToStore(""); callbacks_.Clear(); + processCallbacks_.Clear(); Close(); return result; } @@ -386,8 +389,8 @@ void ObjectStoreManager::RegisterRemoteCallback(const std::string &bundleName, c })); } -void ObjectStoreManager::UnregisterRemoteCallback(const std::string &bundleName, pid_t pid, uint32_t tokenId, - const std::string &sessionId) +void ObjectStoreManager::UnregisterRemoteCallback( + const std::string &bundleName, pid_t pid, uint32_t tokenId, const std::string &sessionId) { if (bundleName.empty()) { ZLOGD("bundleName is empty"); @@ -412,6 +415,73 @@ void ObjectStoreManager::UnregisterRemoteCallback(const std::string &bundleName, })); } +void ObjectStoreManager::RegisterProgressObserverCallback(const std::string &bundleName, const std::string &sessionId, + pid_t pid, uint32_t tokenId, sptr callback) +{ + if (bundleName.empty() || sessionId.empty()) { + ZLOGD("ObjectStoreManager::RegisterProgressObserverCallback empty bundleName = %{public}s, sessionId = " + "%{public}s", + bundleName.c_str(), DistributedData::Anonymous::Change(sessionId).c_str()); + return; + } + auto proxy = iface_cast(callback); + std::string objectKey = bundleName + sessionId; + sptr observer; + processCallbacks_.Compute( + tokenId, ([pid, &proxy, &objectKey, &observer](const uint32_t key, ProgressCallbackInfo &value) { + if (value.pid != pid) { + value = ProgressCallbackInfo{ pid }; + } + value.observers_.insert_or_assign(objectKey, proxy); + observer = value.observers_[objectKey]; + return !value.observers_.empty(); + })); + int32_t progress = PROGRESS_INVALID; + { + std::lock_guard lock(progressMutex_); + auto it = progressInfo_.find(objectKey); + if (it == progressInfo_.end()) { + return; + } + progress = it->second; + } + if (observer != nullptr && progress != PROGRESS_INVALID) { + observer->Completed(progress); + } + if (progress == PROGRESS_MAX) { + assetsRecvProgress_.Erase(objectKey); + std::lock_guard lock(progressMutex_); + progressInfo_.erase(objectKey); + } +} + +void ObjectStoreManager::UnregisterProgressObserverCallback( + const std::string &bundleName, pid_t pid, uint32_t tokenId, const std::string &sessionId) +{ + if (bundleName.empty()) { + ZLOGD("bundleName is empty"); + return; + } + processCallbacks_.Compute( + tokenId, ([pid, &sessionId, &bundleName](const uint32_t key, ProgressCallbackInfo &value) { + if (value.pid != pid) { + return true; + } + if (sessionId.empty()) { + return false; + } + std::string prefix = bundleName + sessionId; + for (auto it = value.observers_.begin(); it != value.observers_.end();) { + if ((*it).first == prefix) { + it = value.observers_.erase(it); + } else { + ++it; + } + } + return true; + })); +} + void ObjectStoreManager::NotifyChange(const ObjectRecord &changedData) { ZLOGI("OnChange start, size:%{public}zu", changedData.size()); @@ -570,8 +640,42 @@ void ObjectStoreManager::PullAssets(const std::map& d } } -void ObjectStoreManager::NotifyAssetsReady(const std::string& objectKey, const std::string& bundleName, - const std::string& srcNetworkId) +void ObjectStoreManager::NotifyAssetsRecvProgress(const std::string &objectKey, int32_t progress) +{ + assetsRecvProgress_.InsertOrAssign(objectKey, progress); + std::list> observers; + bool flag = false; + processCallbacks_.ForEach( + [&objectKey, &observers, &flag](uint32_t tokenId, const ProgressCallbackInfo &value) { + if (value.observers_.empty()) { + flag = true; + return false; + } + auto it = value.observers_.find(objectKey); + if (it != value.observers_.end()) { + observers.push_back(it->second); + } + return false; + }); + if (flag) { + std::lock_guard lock(progressMutex_); + progressInfo_.insert_or_assign(objectKey, progress); + } + for (auto &observer : observers) { + if (observer == nullptr) { + continue; + } + observer->Completed(progress); + } + if (!observers.empty() && progress == PROGRESS_MAX) { + assetsRecvProgress_.Erase(objectKey); + std::lock_guard lock(progressMutex_); + progressInfo_.erase(objectKey); + } +} + +void ObjectStoreManager::NotifyAssetsReady( + const std::string &objectKey, const std::string &bundleName, const std::string &srcNetworkId) { restoreStatus_.ComputeIfAbsent( objectKey, [](const std::string& key) -> auto { diff --git a/services/distributeddataservice/service/object/src/object_service_impl.cpp b/services/distributeddataservice/service/object/src/object_service_impl.cpp index 5df3363c770e7da4ee9908f7d845c8cc698372f5..ca912ab3d6798742aee3b91639e79b5bc94bea64 100644 --- a/services/distributeddataservice/service/object/src/object_service_impl.cpp +++ b/services/distributeddataservice/service/object/src/object_service_impl.cpp @@ -260,6 +260,31 @@ int32_t ObjectServiceImpl::UnregisterDataChangeObserver(const std::string &bundl return OBJECT_SUCCESS; } +int32_t ObjectServiceImpl::RegisterProgressObserver( + const std::string &bundleName, const std::string &sessionId, sptr callback) +{ + uint32_t tokenId = IPCSkeleton::GetCallingTokenID(); + int32_t status = IsBundleNameEqualTokenId(bundleName, sessionId, tokenId); + if (status != OBJECT_SUCCESS) { + return status; + } + auto pid = IPCSkeleton::GetCallingPid(); + ObjectStoreManager::GetInstance()->RegisterProgressObserverCallback(bundleName, sessionId, pid, tokenId, callback); + return OBJECT_SUCCESS; +} + +int32_t ObjectServiceImpl::UnregisterProgressObserver(const std::string &bundleName, const std::string &sessionId) +{ + uint32_t tokenId = IPCSkeleton::GetCallingTokenID(); + int32_t status = IsBundleNameEqualTokenId(bundleName, sessionId, tokenId); + if (status != OBJECT_SUCCESS) { + return status; + } + auto pid = IPCSkeleton::GetCallingPid(); + ObjectStoreManager::GetInstance()->UnregisterProgressObserverCallback(bundleName, pid, tokenId, sessionId); + return OBJECT_SUCCESS; +} + int32_t ObjectServiceImpl::DeleteSnapshot(const std::string &bundleName, const std::string &sessionId) { uint32_t tokenId = IPCSkeleton::GetCallingTokenID(); @@ -339,6 +364,7 @@ int32_t ObjectServiceImpl::OnAppExit(pid_t uid, pid_t pid, uint32_t tokenId, con ZLOGI("ObjectServiceImpl::OnAppExit uid=%{public}d, pid=%{public}d, tokenId=%{public}d, bundleName=%{public}s", uid, pid, tokenId, appId.c_str()); ObjectStoreManager::GetInstance()->UnregisterRemoteCallback(appId, pid, tokenId); + ObjectStoreManager::GetInstance()->UnregisterProgressObserverCallback(appId, pid, tokenId); return FeatureSystem::STUB_SUCCESS; } diff --git a/services/distributeddataservice/service/object/src/object_service_stub.cpp b/services/distributeddataservice/service/object/src/object_service_stub.cpp index 20255eab45911b9c02250c8a6bc9421e70040497..fb2ba99e4e7ece85d73193da3d7383f9e762b3a4 100644 --- a/services/distributeddataservice/service/object/src/object_service_stub.cpp +++ b/services/distributeddataservice/service/object/src/object_service_stub.cpp @@ -164,6 +164,41 @@ int32_t ObjectServiceStub::OnUnsubscribeRequest(MessageParcel &data, MessageParc return 0; } +int32_t ObjectServiceStub::OnSubscribeProgress(MessageParcel &data, MessageParcel &reply) +{ + std::string sessionId; + std::string bundleName; + sptr obj; + if (!ITypesUtil::Unmarshal(data, bundleName, sessionId, obj) || obj == nullptr) { + ZLOGE("Unmarshal sessionId:%{public}s bundleName:%{public}s, callback is nullptr: %{public}d", + DistributedData::Anonymous::Change(sessionId).c_str(), bundleName.c_str(), obj == nullptr); + return IPC_STUB_INVALID_DATA_ERR; + } + int32_t status = RegisterProgressObserver(bundleName, sessionId, obj); + if (!ITypesUtil::Marshal(reply, status)) { + ZLOGE("Marshal status:0x%{public}x", status); + return IPC_STUB_WRITE_PARCEL_ERR; + } + return status; +} + +int32_t ObjectServiceStub::OnUnsubscribeProgress(MessageParcel &data, MessageParcel &reply) +{ + std::string sessionId; + std::string bundleName; + if (!ITypesUtil::Unmarshal(data, bundleName, sessionId)) { + ZLOGE("Unmarshal sessionId:%{public}s bundleName:%{public}s", + DistributedData::Anonymous::Change(sessionId).c_str(), bundleName.c_str()); + return IPC_STUB_INVALID_DATA_ERR; + } + int32_t status = UnregisterProgressObserver(bundleName, sessionId); + if (!ITypesUtil::Marshal(reply, status)) { + ZLOGE("Marshal status:0x%{public}x", status); + return IPC_STUB_WRITE_PARCEL_ERR; + } + return status; +} + int32_t ObjectServiceStub::OnDeleteSnapshot(MessageParcel &data, MessageParcel &reply) { std::string sessionId; diff --git a/services/distributeddataservice/service/test/object_manager_test.cpp b/services/distributeddataservice/service/test/object_manager_test.cpp index 61eb66a80f3e58419b9ba1dc9f12bff86b94ebb9..e2d9e0ce447b6d506a39c6c3e48de0958b4c435b 100644 --- a/services/distributeddataservice/service/test/object_manager_test.cpp +++ b/services/distributeddataservice/service/test/object_manager_test.cpp @@ -1111,4 +1111,115 @@ HWTEST_F(ObjectManagerTest, InitUserMeta001, TestSize.Level1) auto status = manager->InitUserMeta(); ASSERT_EQ(status, DistributedObject::OBJECT_SUCCESS); } + +/** +* @tc.name: registerAndUnregisterProgressObserverCallback001 +* @tc.desc: test RegisterProgressObserverCallback and UnregisterProgressObserverCallback. +* @tc.type: FUNC +* @tc.require: +* @tc.author: +*/ +HWTEST_F(ObjectManagerTest, registerAndUnregisterProgressObserverCallback001, TestSize.Level0) +{ + auto manager = ObjectStoreManager::GetInstance(); + sptr callback; + manager->RegisterProgressObserverCallback(bundleName_, sessionId_, pid_, tokenId_, callback); + ObjectStoreManager::ProgressCallbackInfo progressCallbackInfo = manager->processCallbacks_.Find(tokenId_).second; + std::string objectKey = bundleName_ + sessionId_; + ASSERT_NE(progressCallbackInfo.observers_.find(objectKey), progressCallbackInfo.observers_.end()); + manager->UnregisterProgressObserverCallback(bundleName_, pid_, tokenId_, sessionId_); + progressCallbackInfo = manager->processCallbacks_.Find(tokenId_).second; + ASSERT_EQ(progressCallbackInfo.observers_.find(objectKey), progressCallbackInfo.observers_.end()); +} + +/** +* @tc.name: registerAndUnregisterProgressObserverCallback002 +* @tc.desc: abnormal use cases. +* @tc.type: FUNC +* @tc.require: +* @tc.author: +*/ +HWTEST_F(ObjectManagerTest, registerAndUnregisterProgressObserverCallback002, TestSize.Level0) +{ + auto manager = ObjectStoreManager::GetInstance(); + sptr callback; + uint32_t tokenId = 101; + manager->RegisterProgressObserverCallback("", sessionId_, pid_, tokenId, callback); + manager->RegisterProgressObserverCallback(bundleName_, "", pid_, tokenId, callback); + manager->RegisterProgressObserverCallback("", "", pid_, tokenId, callback); + ObjectStoreManager::ProgressCallbackInfo progressCallbackInfo = manager->processCallbacks_.Find(tokenId_).second; + progressCallbackInfo.pid = pid_; + manager->RegisterProgressObserverCallback(bundleName_, sessionId_, pid_, tokenId_, callback); + ASSERT_EQ(manager->processCallbacks_.Find(tokenId).first, false); + manager->UnregisterProgressObserverCallback("", pid_, tokenId, sessionId_); + manager->UnregisterProgressObserverCallback("", pid_, tokenId, ""); + manager->UnregisterProgressObserverCallback(bundleName_, pid_, tokenId, ""); +} + +/** +* @tc.name: NotifyAssetsRecvProgress001 +* @tc.desc: NotifyAssetsRecvProgress test. +* @tc.type: FUNC +* @tc.require: +* @tc.author: +*/ +HWTEST_F(ObjectManagerTest, NotifyAssetsRecvProgress001, TestSize.Level0) +{ + auto manager = ObjectStoreManager::GetInstance(); + std::string objectKey = bundleName_ + sessionId_; + std::string errProgress = "errProgress"; + int32_t progress = 100; + ASSERT_EQ(manager->assetsRecvProgress_.Find(objectKey).first, true); + ObjectStoreManager::ProgressCallbackInfo progressCallbackInfo = manager->processCallbacks_.Find(tokenId_).second; + manager->NotifyAssetsRecvProgress(errProgress, progress); + manager->assetsRecvProgress_.Clear(); + manager->assetsRecvProgress_.Insert(objectKey, progress); + progressCallbackInfo.observers_.clear(); + manager->NotifyAssetsRecvProgress(errProgress, progress); +} + +/** +* @tc.name: OnRecvProgress001 +* @tc.desc: OnRecvProgress test. +* @tc.type: FUNC +*/ +HWTEST_F(ObjectManagerTest, OnRecvProgress001, TestSize.Level1) +{ + std::string srcNetworkId = "srcNetworkId"; + sptr assetObj = nullptr; + uint64_t totalBytes = 100; + uint64_t processBytes = 100; + ObjectAssetsRecvListener listener; + int32_t ret = listener.OnRecvProgress(srcNetworkId, assetObj, totalBytes, processBytes); + EXPECT_EQ(ret, DistributedObject::OBJECT_INNER_ERROR); + uint64_t totalBytes_01 = 0; + ret = listener.OnRecvProgress(srcNetworkId, assetObj, totalBytes_01, processBytes); + EXPECT_EQ(ret, DistributedObject::OBJECT_INNER_ERROR); + sptr assetObj_1 = new AssetObj(); + ret = listener.OnRecvProgress(srcNetworkId, assetObj_1, totalBytes_01, processBytes); + EXPECT_EQ(ret, DistributedObject::OBJECT_INNER_ERROR); + ret = listener.OnRecvProgress(srcNetworkId, assetObj_1, totalBytes, processBytes); + EXPECT_EQ(ret, DistributedObject::OBJECT_SUCCESS); +} + +/** +* @tc.name: OnFinished002 +* @tc.desc: OnFinished test. +* @tc.type: FUNC +*/ +HWTEST_F(ObjectManagerTest, OnFinished002, TestSize.Level1) +{ + std::string srcNetworkId = "srcNetworkId"; + ObjectAssetsRecvListener listener; + sptr assetObj_1 = new AssetObj(); + assetObj_1->dstBundleName_ = bundleName_; + assetObj_1->srcBundleName_ = bundleName_; + assetObj_1->dstNetworkId_ = "1"; + assetObj_1->sessionId_ = "123"; + int32_t result = 100; + auto ret = listener.OnFinished(srcNetworkId, assetObj_1, result); + int32_t result_1 = 0; + ret = listener.OnFinished(srcNetworkId, assetObj_1, result_1); + EXPECT_EQ(ret, DistributedObject::OBJECT_SUCCESS); +} } // namespace OHOS::Test diff --git a/services/distributeddataservice/service/test/object_service_impl_test.cpp b/services/distributeddataservice/service/test/object_service_impl_test.cpp index 4a0a0b2f3cd273cd88fbc0901649e59f781ea3d2..11a66c41ffba0c9b9b6e9862af557d8cca824229 100644 --- a/services/distributeddataservice/service/test/object_service_impl_test.cpp +++ b/services/distributeddataservice/service/test/object_service_impl_test.cpp @@ -151,4 +151,29 @@ HWTEST_F(ObjectServiceImplTest, ResolveAutoLaunch001, TestSize.Level1) int32_t ret = objectServiceImpl->ResolveAutoLaunch(identifier, param); EXPECT_EQ(ret, OBJECT_SUCCESS); } + +/** + * @tc.name: RegisterProgressObserver001 + * @tc.desc: RegisterProgressObserver test. + * @tc.type: FUNC + */ +HWTEST_F(ObjectServiceImplTest, RegisterProgressObserver001, TestSize.Level1) +{ + std::shared_ptr objectServiceImpl = std::make_shared(); + sptr callback; + int32_t ret = objectServiceImpl->RegisterProgressObserver(bundleName_, sessionId_, callback); + EXPECT_EQ(ret, OBJECT_PERMISSION_DENIED); +} + +/** + * @tc.name: UnregisterProgressObserver001 + * @tc.desc: UnregisterProgressObserver test. + * @tc.type: FUNC + */ +HWTEST_F(ObjectServiceImplTest, UnregisterProgressObserver001, TestSize.Level1) +{ + std::shared_ptr objectServiceImpl = std::make_shared(); + int32_t ret = objectServiceImpl->UnregisterProgressObserver(bundleName_, sessionId_); + EXPECT_EQ(ret, OBJECT_PERMISSION_DENIED); +} } \ No newline at end of file diff --git a/services/distributeddataservice/service/test/object_service_stub_test.cpp b/services/distributeddataservice/service/test/object_service_stub_test.cpp index 1cbb5e1a50af60a3f88510fde236c00b25c5d19a..274ef0f979dc43a76f24031e74a9f61128d3873d 100644 --- a/services/distributeddataservice/service/test/object_service_stub_test.cpp +++ b/services/distributeddataservice/service/test/object_service_stub_test.cpp @@ -99,6 +99,12 @@ HWTEST_F(ObjectServiceStubTest, ObjectServiceTest002, TestSize.Level1) result = objectServiceStub->ObjectStoreBindAssetOnRemote(request, reply); EXPECT_EQ(result, IPC_STUB_INVALID_DATA_ERR); + result = objectServiceStub->OnSubscribeProgress(request, reply); + EXPECT_EQ(result, IPC_STUB_INVALID_DATA_ERR); + + result = objectServiceStub->OnUnsubscribeProgress(request, reply); + EXPECT_EQ(result, IPC_STUB_INVALID_DATA_ERR); + result = objectServiceStub->OnDeleteSnapshot(request, reply); EXPECT_EQ(result, IPC_STUB_INVALID_DATA_ERR);