From 7d67e7655c3c9438b74215fc99b43d3248b38503 Mon Sep 17 00:00:00 2001 From: fengjq Date: Sat, 12 Jul 2025 15:10:15 +0800 Subject: [PATCH] Fix for download Inner and Js Api Signed-off-by: fengjq --- .../src/data_sync_manager.cpp | 24 +- .../include/cloud_sync_manager_impl.h | 18 +- .../src/cloud_sync_manager_impl.cpp | 174 ++------ .../src/cloud_sync_service_proxy_lite.cpp | 31 +- .../cloud_file_kit_inner/data_sync_manager.h | 16 +- .../cloudsync_kit_inner/cloud_sync_common.h | 8 +- .../cloudsync_kit_inner/cloud_sync_manager.h | 16 +- .../kits/js/ani/file_cloud_sync/BUILD.gn | 4 +- .../include/cloud_download_callback_ani.h | 41 -- .../include/cloud_download_callback_middle.h | 30 -- .../include/cloud_file_cache_ani.h | 5 + .../src/cloud_download_ani.cpp | 125 +++--- .../src/cloud_download_callback_ani.cpp | 138 ------- .../src/cloud_file_cache_ani.cpp | 145 ++++--- .../src/download_callback_impl_ani.cpp | 6 +- interfaces/kits/js/cloudfilesync/BUILD.gn | 1 - .../cloudfilesync/cloud_file_cache_core.cpp | 155 +++---- .../js/cloudfilesync/cloud_file_cache_core.h | 59 +-- .../cloudfilesync/cloud_file_cache_napi.cpp | 377 ++++++++++-------- .../js/cloudfilesync/cloud_file_cache_napi.h | 35 +- .../kits/js/cloudfilesync/cloud_file_core.cpp | 74 +--- .../kits/js/cloudfilesync/cloud_file_core.h | 11 +- .../cloud_file_download_napi.cpp | 39 -- .../cloudfilesync/cloud_file_download_napi.h | 30 -- .../kits/js/cloudfilesync/cloud_file_napi.cpp | 270 +++++-------- .../kits/js/cloudfilesync/cloud_file_napi.h | 47 +-- .../cloudfilesync/cloud_sync_n_exporter.cpp | 1 - .../multi_download_progress_napi.cpp | 4 - .../cloudsyncservice/ICloudSyncService.idl | 10 +- .../include/ipc/cloud_sync_service.h | 11 +- .../src/ipc/cloud_sync_service.cpp | 84 +--- .../cloudsyncmanager_fuzzer.cpp | 25 +- .../cloudsyncservicestub_fuzzer.cpp | 59 +-- test/unittests/ani_core/BUILD.gn | 7 +- .../ani_core/cloud_file_cache_core_test.cpp | 79 ++-- .../ani_core/cloud_file_core_test.cpp | 57 +-- .../cloud_sync_manager_impl_test.cpp | 123 ++---- .../cloud_sync_manager_impl_unnomal_test.cpp | 27 +- .../cloud_sync_service_proxy_test.cpp | 98 +---- .../include/i_cloud_sync_service_mock.h | 23 +- .../ipc/cloud_sync_service_stub_test.cpp | 86 +--- .../ipc/cloud_sync_service_test.cpp | 45 +-- 42 files changed, 786 insertions(+), 1832 deletions(-) delete mode 100644 interfaces/kits/js/ani/file_cloud_sync/include/cloud_download_callback_ani.h delete mode 100644 interfaces/kits/js/ani/file_cloud_sync/include/cloud_download_callback_middle.h delete mode 100644 interfaces/kits/js/ani/file_cloud_sync/src/cloud_download_callback_ani.cpp delete mode 100644 interfaces/kits/js/cloudfilesync/cloud_file_download_napi.cpp delete mode 100644 interfaces/kits/js/cloudfilesync/cloud_file_download_napi.h diff --git a/frameworks/native/cloud_file_kit_inner/src/data_sync_manager.cpp b/frameworks/native/cloud_file_kit_inner/src/data_sync_manager.cpp index e9fe89a6c..9b998bf01 100644 --- a/frameworks/native/cloud_file_kit_inner/src/data_sync_manager.cpp +++ b/frameworks/native/cloud_file_kit_inner/src/data_sync_manager.cpp @@ -93,27 +93,9 @@ int32_t DataSyncManager::StartDownloadFile(const BundleNameUserInfo &bundleNameU } int32_t DataSyncManager::StopDownloadFile(const BundleNameUserInfo &bundleNameUserInfo, - const std::string &path, - bool needClean) -{ - return E_OK; -} - -int32_t DataSyncManager::StopFileCache(const BundleNameUserInfo &bundleNameUserInfo, - int64_t downloadId, - bool needClean, - int32_t timeout) -{ - return E_OK; -} - -int32_t DataSyncManager::RegisterDownloadFileCallback(const BundleNameUserInfo &bundleNameUserInfo, - const sptr &downloadCallback) -{ - return E_OK; -} - -int32_t DataSyncManager::UnregisterDownloadFileCallback(const BundleNameUserInfo &bundleNameUserInfo) + int64_t downloadId, + bool needClean, + int32_t timeout) { return E_OK; } diff --git a/frameworks/native/cloudsync_kit_inner/include/cloud_sync_manager_impl.h b/frameworks/native/cloudsync_kit_inner/include/cloud_sync_manager_impl.h index 6afddaace..de592796b 100644 --- a/frameworks/native/cloudsync_kit_inner/include/cloud_sync_manager_impl.h +++ b/frameworks/native/cloudsync_kit_inner/include/cloud_sync_manager_impl.h @@ -54,19 +54,17 @@ public: int32_t NotifyEventChange(int32_t userId, const std::string &eventId, const std::string &extraData) override; int32_t EnableCloud(const std::string &accoutId, const SwitchDataObj &switchData) override; int32_t DisableCloud(const std::string &accoutId) override; - int32_t StartDownloadFile(const std::string &uri) override; - int32_t StartFileCache(const std::string &uri) override; - int32_t StartFileCache(const std::vector &uriVec, int64_t &downloadId, - int32_t fieldkey = FIELDKEY_CONTENT, + int32_t StartDownloadFile(const std::string &uri, + const std::shared_ptr downloadCallback, + int64_t &downloadId) override; + int32_t StartFileCache(const std::vector &uriVec, + int64_t &downloadId, + int32_t fieldkey = FieldKey::FIELDKEY_CONTENT, const std::shared_ptr downloadCallback = nullptr, int32_t timeout = -1) override; - int32_t StopDownloadFile(const std::string &uri, bool needClean = false) override; + int32_t StopDownloadFile(int64_t downloadId, bool needClean = false) override; int32_t StopFileCache(int64_t downloadId, bool needClean = false, int32_t timeout = -1) override; int32_t DownloadThumb() override; - int32_t RegisterDownloadFileCallback(const std::shared_ptr downloadCallback) override; - int32_t RegisterFileCacheCallback(const std::shared_ptr downloadCallback) override; - int32_t UnregisterDownloadFileCallback() override; - int32_t UnregisterFileCacheCallback() override; int32_t GetSyncTime(int64_t &syncTime, const std::string &bundleName = "") override; int32_t CleanCache(const std::string &uri) override; int32_t CleanFileCache(const std::string &uri) override; @@ -105,10 +103,8 @@ private: std::atomic_flag isFirstCall_{false}; sptr deathRecipient_; std::shared_ptr callback_; - std::shared_ptr downloadCallback_; sptr listener_; std::mutex subscribeMutex_; - std::mutex downloadMutex_; std::mutex callbackMutex_; void SubscribeListener(std::string bundleName = ""); }; diff --git a/frameworks/native/cloudsync_kit_inner/src/cloud_sync_manager_impl.cpp b/frameworks/native/cloudsync_kit_inner/src/cloud_sync_manager_impl.cpp index 19c8174a7..74ac45fa6 100644 --- a/frameworks/native/cloudsync_kit_inner/src/cloud_sync_manager_impl.cpp +++ b/frameworks/native/cloudsync_kit_inner/src/cloud_sync_manager_impl.cpp @@ -320,7 +320,9 @@ int32_t CloudSyncManagerImpl::NotifyEventChange( return ret; } -int32_t CloudSyncManagerImpl::StartDownloadFile(const std::string &uri) +int32_t CloudSyncManagerImpl::StartDownloadFile(const std::string &uri, + const std::shared_ptr downloadCallback, + int64_t &downloadId) { LOGI("StartDownloadFile start"); auto CloudSyncServiceProxy = ServiceProxy::GetInstance(); @@ -328,8 +330,13 @@ int32_t CloudSyncManagerImpl::StartDownloadFile(const std::string &uri) LOGE("proxy is null"); return E_SA_LOAD_FAILED; } + if (downloadCallback == nullptr) { + LOGE("The callback is null"); + return E_INVAL_ARG; + } SetDeathRecipient(CloudSyncServiceProxy->AsObject()); - int32_t ret = CloudSyncServiceProxy->StartDownloadFile(uri); + auto dlCallback = sptr::MakeSptr(downloadCallback); + int32_t ret = CloudSyncServiceProxy->StartDownloadFile(uri, dlCallback, downloadId); LOGI("StartDownloadFile ret %{public}d", ret); return ret; } @@ -357,40 +364,19 @@ int32_t CloudSyncManagerImpl::BatchCleanFile(const std::vector &f return CloudSyncServiceProxy->BatchCleanFile(fileInfoObj, failCloudId); } -int32_t CloudSyncManagerImpl::StartFileCache(const std::string &uri) -{ - LOGI("StartFileCache start"); - int64_t downloadId = 0; - auto CloudSyncServiceProxy = ServiceProxy::GetInstance(); - if (!CloudSyncServiceProxy) { - LOGE("proxy is null"); - return E_SA_LOAD_FAILED; - } - SetDeathRecipient(CloudSyncServiceProxy->AsObject()); - std::vector uriVec; - uriVec.push_back(uri); - bool isCallbackValid = false; - int32_t timeout = -1; - sptr dlCallback = sptr(new (std::nothrow) CloudDownloadCallbackClient(nullptr)); - int32_t ret = CloudSyncServiceProxy->StartFileCache(uriVec, downloadId, FIELDKEY_CONTENT, isCallbackValid, - dlCallback, timeout); - LOGI("StartFileCache ret %{public}d", ret); - return ret; -} - int32_t CloudSyncManagerImpl::StartFileCache(const std::vector &uriVec, - int64_t &downloadId, int32_t fieldkey, + int64_t &downloadId, + int32_t fieldkey, const std::shared_ptr downloadCallback, int32_t timeout) { - LOGI("StartFileCache batch start, uriVec size: %{public}zu, fieldKey: %{public}d, Callback is null: %{public}d", - uriVec.size(), fieldkey, (downloadCallback == nullptr)); + LOGI("StartFileCache start, uriVec size: %{public}zu, fieldKey: %{public}d", uriVec.size(), fieldkey); if (uriVec.empty()) { - LOGE("StartFileCache, uri list is empty"); + LOGE("The uri list is empty"); return E_INVAL_ARG; } if (uriVec.size() > MAX_FILE_CACHE_NUM) { - LOGE("StartFileCache, the size of uri list exceeded the maximum limit, size: %{public}zu", uriVec.size()); + LOGE("The size of uri list exceeded the maximum limit, size: %{public}zu", uriVec.size()); return E_EXCEED_MAX_SIZE; } auto CloudSyncServiceProxy = ServiceProxy::GetInstance(); @@ -400,24 +386,16 @@ int32_t CloudSyncManagerImpl::StartFileCache(const std::vector &uri } SetDeathRecipient(CloudSyncServiceProxy->AsObject()); - bool isCallbackValid = false; - sptr dlCallback = sptr(new (std::nothrow) CloudDownloadCallbackClient(nullptr)); - if (downloadCallback != nullptr) { - dlCallback = sptr(new (std::nothrow) CloudDownloadCallbackClient(downloadCallback)); - isCallbackValid = true; - if (dlCallback == nullptr) { - LOGE("register download callback failed"); - isCallbackValid = false; - } + if (downloadCallback == nullptr) { + LOGW("The callback is null, download progress may not be received"); } - - int32_t ret = CloudSyncServiceProxy->StartFileCache(uriVec, downloadId, fieldkey, - isCallbackValid, dlCallback, timeout); - LOGI("StartFileCache batch ret %{public}d", ret); + auto dlCallback = sptr::MakeSptr(downloadCallback); + int32_t ret = CloudSyncServiceProxy->StartFileCache(uriVec, downloadId, fieldkey, dlCallback, timeout); + LOGI("StartFileCache end, ret %{public}d", ret); return ret; } -int32_t CloudSyncManagerImpl::StopDownloadFile(const std::string &uri, bool needClean) +int32_t CloudSyncManagerImpl::StopDownloadFile(int64_t downloadId, bool needClean) { LOGI("StopDownloadFile start"); auto CloudSyncServiceProxy = ServiceProxy::GetInstance(); @@ -426,8 +404,8 @@ int32_t CloudSyncManagerImpl::StopDownloadFile(const std::string &uri, bool need return E_SA_LOAD_FAILED; } SetDeathRecipient(CloudSyncServiceProxy->AsObject()); - int32_t ret = CloudSyncServiceProxy->StopDownloadFile(uri, needClean); - LOGI("StopDownloadFile ret %{public}d", ret); + int32_t ret = CloudSyncServiceProxy->StopDownloadFile(downloadId, needClean); + LOGI("StopDownloadFile end, ret %{public}d", ret); return ret; } @@ -441,7 +419,7 @@ int32_t CloudSyncManagerImpl::StopFileCache(int64_t downloadId, bool needClean, } SetDeathRecipient(CloudSyncServiceProxy->AsObject()); int32_t ret = CloudSyncServiceProxy->StopFileCache(downloadId, needClean, timeout); - LOGI("StopFileCache ret %{public}d", ret); + LOGI("StopFileCache end, ret %{public}d", ret); return ret; } @@ -630,98 +608,6 @@ int32_t CloudSyncManagerImpl::DownloadThumb() return ret; } -int32_t CloudSyncManagerImpl::RegisterDownloadFileCallback( - const std::shared_ptr downloadCallback) -{ - LOGI("RegisterDownloadFileCallback start"); - auto CloudSyncServiceProxy = ServiceProxy::GetInstance(); - if (!CloudSyncServiceProxy) { - LOGE("proxy is null"); - return E_SA_LOAD_FAILED; - } - { - unique_lock lock(downloadMutex_); - auto dlCallback = sptr(new (std::nothrow) CloudDownloadCallbackClient(downloadCallback)); - if (dlCallback == nullptr || - CloudSyncServiceProxy->RegisterDownloadFileCallback(dlCallback) != E_OK) { - LOGE("register download callback failed"); - } else { - downloadCallback_ = downloadCallback; - } - } - SubscribeListener(); - SetDeathRecipient(CloudSyncServiceProxy->AsObject()); - return E_OK; -} - -int32_t CloudSyncManagerImpl::RegisterFileCacheCallback( - const std::shared_ptr downloadCallback) -{ - LOGI("RegisterFileCacheCallback start"); - auto CloudSyncServiceProxy = ServiceProxy::GetInstance(); - if (!CloudSyncServiceProxy) { - LOGE("proxy is null"); - return E_SA_LOAD_FAILED; - } - { - unique_lock lock(downloadMutex_); - auto dlCallback = sptr(new (std::nothrow) CloudDownloadCallbackClient(downloadCallback)); - if (dlCallback == nullptr || - CloudSyncServiceProxy->RegisterFileCacheCallback(dlCallback) != E_OK) { - LOGE("register download callback failed"); - } else { - downloadCallback_ = downloadCallback; - } - } - SubscribeListener(); - SetDeathRecipient(CloudSyncServiceProxy->AsObject()); - return E_OK; -} - -int32_t CloudSyncManagerImpl::UnregisterDownloadFileCallback() -{ - LOGI("UnregisterDownloadFileCallback start"); - auto CloudSyncServiceProxy = ServiceProxy::GetInstance(); - if (!CloudSyncServiceProxy) { - LOGE("proxy is null"); - return E_SA_LOAD_FAILED; - } - int32_t ret = E_OK; - { - unique_lock lock(downloadMutex_); - ret = CloudSyncServiceProxy->UnregisterDownloadFileCallback(); - LOGI("UnregisterDownloadFileCallback ret %{public}d", ret); - if (ret == E_OK) { - downloadCallback_ = nullptr; - } - } - SubscribeListener(); - SetDeathRecipient(CloudSyncServiceProxy->AsObject()); - return ret; -} - -int32_t CloudSyncManagerImpl::UnregisterFileCacheCallback() -{ - LOGI("UnregisterFileCacheCallback start"); - auto CloudSyncServiceProxy = ServiceProxy::GetInstance(); - if (!CloudSyncServiceProxy) { - LOGE("proxy is null"); - return E_SA_LOAD_FAILED; - } - int32_t ret = E_OK; - { - unique_lock lock(downloadMutex_); - ret = CloudSyncServiceProxy->UnregisterFileCacheCallback(); - LOGI("UnregisterFileCacheCallback ret %{public}d", ret); - if (ret == E_OK) { - downloadCallback_ = nullptr; - } - } - SubscribeListener(); - SetDeathRecipient(CloudSyncServiceProxy->AsObject()); - return ret; -} - void CloudSyncManagerImpl::SetDeathRecipient(const sptr &remoteObject) { if (!isFirstCall_.test_and_set()) { @@ -839,7 +725,7 @@ void CloudSyncManagerImpl::SubscribeListener(std::string bundleName) auto ret = samgr->UnSubscribeSystemAbility(FILEMANAGEMENT_CLOUD_SYNC_SERVICE_SA_ID, listener_); LOGI("unsubscribed to systemAbility ret %{public}d", ret); } - if (callback_ != nullptr || downloadCallback_ != nullptr) { + if (callback_ != nullptr) { listener_ = new SystemAbilityStatusChange(bundleName); auto ret = samgr->SubscribeSystemAbility(FILEMANAGEMENT_CLOUD_SYNC_SERVICE_SA_ID, listener_); LOGI("subscribed to systemAbility ret %{public}d", ret); @@ -856,18 +742,6 @@ bool CloudSyncManagerImpl::ResetProxyCallback(uint32_t retryCount, const string return false; } bool hasCallback = false; - { - unique_lock downloadLock(downloadMutex_); - if (downloadCallback_ != nullptr) { - auto dlCallback = sptr(new (std::nothrow) CloudDownloadCallbackClient(downloadCallback_)); - if (dlCallback == nullptr || - cloudSyncServiceProxy->RegisterDownloadFileCallback(dlCallback) != E_OK) { - LOGW("register download callback failed, try time is %{public}d", retryCount); - } else { - hasCallback = true; - } - } - } if (callback_ != nullptr) { auto callback = sptr(new (std::nothrow) CloudSyncCallbackClient(callback_)); if (callback == nullptr || diff --git a/frameworks/native/cloudsync_kit_inner_lite/src/cloud_sync_service_proxy_lite.cpp b/frameworks/native/cloudsync_kit_inner_lite/src/cloud_sync_service_proxy_lite.cpp index 134d9bf27..4337b08fe 100644 --- a/frameworks/native/cloudsync_kit_inner_lite/src/cloud_sync_service_proxy_lite.cpp +++ b/frameworks/native/cloudsync_kit_inner_lite/src/cloud_sync_service_proxy_lite.cpp @@ -243,7 +243,9 @@ int32_t CloudSyncServiceProxy::NotifyEventChange( return E_OK; } -int32_t CloudSyncServiceProxy::StartDownloadFile(const std::string &uri) +int32_t CloudSyncServiceProxy::StartDownloadFile(const std::string &uri, + const std::shared_ptr downloadCallback, + int64_t &downloadId) { return E_OK; } @@ -251,7 +253,6 @@ int32_t CloudSyncServiceProxy::StartDownloadFile(const std::string &uri) int32_t CloudSyncServiceProxy::StartFileCacheWriteParcel(MessageParcel &data, const std::vector &pathVec, int32_t &fieldkey, - bool isCallbackValid, const sptr &downloadCallback, int32_t timeout) { @@ -259,15 +260,15 @@ int32_t CloudSyncServiceProxy::StartFileCacheWriteParcel(MessageParcel &data, } int32_t CloudSyncServiceProxy::StartFileCache(const std::vector &uriVec, - int64_t &downloadId, int32_t fieldkey, - bool isCallbackValid, + int64_t &downloadId, + int32_t fieldkey, const sptr &downloadCallback, int32_t timeout) { return E_OK; } -int32_t CloudSyncServiceProxy::StopDownloadFile(const std::string &uri, bool needClean) +int32_t CloudSyncServiceProxy::StopDownloadFile(int64_t downloadId, bool needClean) { return E_OK; } @@ -282,26 +283,6 @@ int32_t CloudSyncServiceProxy::DownloadThumb() return E_OK; } -int32_t CloudSyncServiceProxy::RegisterDownloadFileCallback(const sptr &downloadCallback) -{ - return E_OK; -} - -int32_t CloudSyncServiceProxy::RegisterFileCacheCallback(const sptr &downloadCallback) -{ - return E_OK; -} - -int32_t CloudSyncServiceProxy::UnregisterDownloadFileCallback() -{ - return E_OK; -} - -int32_t CloudSyncServiceProxy::UnregisterFileCacheCallback() -{ - return E_OK; -} - int32_t CloudSyncServiceProxy::UploadAsset(const int32_t userId, const std::string &request, std::string &result) { return E_OK; diff --git a/interfaces/inner_api/native/cloud_file_kit_inner/data_sync_manager.h b/interfaces/inner_api/native/cloud_file_kit_inner/data_sync_manager.h index 1a4bf8690..aef152d43 100644 --- a/interfaces/inner_api/native/cloud_file_kit_inner/data_sync_manager.h +++ b/interfaces/inner_api/native/cloud_file_kit_inner/data_sync_manager.h @@ -51,21 +51,15 @@ public: virtual void UnRegisterCloudSyncCallback(const std::string &bundleName, const std::string &callerBundleName); virtual int32_t IsSkipSync(const std::string &bundleName, const int32_t userId, bool forceFlag); virtual int32_t StartDownloadFile(const BundleNameUserInfo &bundleNameUserInfo, - const std::vector &pathVec, + const std::vector &uriVec, int64_t &downloadId, int32_t fieldkey, const sptr &downloadCallback, int32_t timeout = -1); virtual int32_t StopDownloadFile(const BundleNameUserInfo &bundleNameUserInfo, - const std::string &path, - bool needClean = false); - virtual int32_t StopFileCache(const BundleNameUserInfo &bundleNameUserInfo, - int64_t downloadId, - bool needClean, - int32_t timeout = -1); - virtual int32_t RegisterDownloadFileCallback(const BundleNameUserInfo &bundleNameUserInfo, - const sptr &downloadCallback); - virtual int32_t UnregisterDownloadFileCallback(const BundleNameUserInfo &bundleNameUserInfo); + int64_t downloadId, + bool needClean, + int32_t timeout = -1); virtual int32_t CleanCloudFile(const int32_t userId, const std::string &bundleName, const int action); virtual int32_t CleanRemainFile(const std::string &bundleName, const int32_t userId); virtual int32_t OptimizeStorage(const std::string &bundleName, const int32_t userId, const int32_t agingDays); @@ -106,6 +100,6 @@ public: bool &isConflict); virtual int32_t ClearFileConflict(const BundleNameUserInfo &bundleNameUserInfo, const std::string &uri); }; -} // namespace OHOS::FileManagement::CloudSync +} // namespace OHOS::FileManagement::CloudFile #endif // OHOS_CLOUD_FILE_DATA_SYNC_MANAGER_H \ No newline at end of file diff --git a/interfaces/inner_api/native/cloudsync_kit_inner/cloud_sync_common.h b/interfaces/inner_api/native/cloudsync_kit_inner/cloud_sync_common.h index 4c8ab81da..c8a9d2fd5 100644 --- a/interfaces/inner_api/native/cloudsync_kit_inner/cloud_sync_common.h +++ b/interfaces/inner_api/native/cloudsync_kit_inner/cloud_sync_common.h @@ -25,10 +25,10 @@ namespace OHOS::FileManagement::CloudSync { #define FIELD_KEY_MAX_SIZE 4 constexpr int32_t CLEAN_FILE_MAX_SIZE = 200; -enum FieldKey { - FIELDKEY_CONTENT = 1 << 0, - FIELDKEY_THUMB = 1 << 1, - FIELDKEY_LCD = 1 << 2, +enum FieldKey : int32_t { + FIELDKEY_CONTENT = 0, + FIELDKEY_THUMB, + FIELDKEY_LCD, }; struct DownloadProgressObj : public Parcelable { diff --git a/interfaces/inner_api/native/cloudsync_kit_inner/cloud_sync_manager.h b/interfaces/inner_api/native/cloudsync_kit_inner/cloud_sync_manager.h index 2d540d36e..c221ba977 100644 --- a/interfaces/inner_api/native/cloudsync_kit_inner/cloud_sync_manager.h +++ b/interfaces/inner_api/native/cloudsync_kit_inner/cloud_sync_manager.h @@ -113,19 +113,17 @@ public: virtual int32_t OptimizeStorage(const OptimizeSpaceOptions &optimizeOptions, const std::shared_ptr optimizeCallback = nullptr) = 0; virtual int32_t StopOptimizeStorage() = 0; - virtual int32_t StartDownloadFile(const std::string &path) = 0; - virtual int32_t StartFileCache(const std::string &path) = 0; - virtual int32_t StartFileCache(const std::vector &pathVec, int64_t &downloadId, - int32_t fieldkey = FIELDKEY_CONTENT, + virtual int32_t StartDownloadFile(const std::string &uri, + const std::shared_ptr downloadCallback, + int64_t &downloadId) = 0; + virtual int32_t StartFileCache(const std::vector &uriVec, + int64_t &downloadId, + int32_t fieldkey = FieldKey::FIELDKEY_CONTENT, const std::shared_ptr downloadCallback = nullptr, int32_t timeout = -1) = 0; - virtual int32_t StopDownloadFile(const std::string &path, bool needClean = false) = 0; + virtual int32_t StopDownloadFile(int64_t downloadId, bool needClean = false) = 0; virtual int32_t StopFileCache(int64_t downloadId, bool needClean = false, int32_t timeout = -1) = 0; virtual int32_t DownloadThumb() = 0; - virtual int32_t RegisterDownloadFileCallback(const std::shared_ptr downloadCallback) = 0; - virtual int32_t RegisterFileCacheCallback(const std::shared_ptr downloadCallback) = 0; - virtual int32_t UnregisterDownloadFileCallback() = 0; - virtual int32_t UnregisterFileCacheCallback() = 0; virtual int32_t GetSyncTime(int64_t &syncTime, const std::string &bundleName = "") = 0; virtual int32_t CleanCache(const std::string &uri) = 0; virtual int32_t CleanFileCache(const std::string &uri) = 0; diff --git a/interfaces/kits/js/ani/file_cloud_sync/BUILD.gn b/interfaces/kits/js/ani/file_cloud_sync/BUILD.gn index 9056abfa2..06058a143 100644 --- a/interfaces/kits/js/ani/file_cloud_sync/BUILD.gn +++ b/interfaces/kits/js/ani/file_cloud_sync/BUILD.gn @@ -35,13 +35,15 @@ ohos_shared_library("cloud_sync_ani") { "${interfaces_js_path}/cloudfilesync/multi_download_progress_core.cpp", "src/bind_function_class.cpp", "src/cloud_download_ani.cpp", - "src/cloud_download_callback_ani.cpp", "src/cloud_file_cache_ani.cpp", "src/cloud_sync_ani.cpp", "src/cloud_sync_callback_ani.cpp", + "src/download_callback_impl_ani.cpp", + "src/download_callback_middle_ani.cpp", "src/download_progress_ani.cpp", "src/file_sync_ani.cpp", "src/multi_download_progress_ani.cpp", + "src/register_callback_manager_ani.cpp", ] sanitize = { integer_overflow = true diff --git a/interfaces/kits/js/ani/file_cloud_sync/include/cloud_download_callback_ani.h b/interfaces/kits/js/ani/file_cloud_sync/include/cloud_download_callback_ani.h deleted file mode 100644 index 5bebbca86..000000000 --- a/interfaces/kits/js/ani/file_cloud_sync/include/cloud_download_callback_ani.h +++ /dev/null @@ -1,41 +0,0 @@ -/* - * Copyright (c) 2025 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef OHOS_FILEMGMT_CLOUD_DOWNLOAD_CALLBACK_ANI_H -#define OHOS_FILEMGMT_CLOUD_DOWNLOAD_CALLBACK_ANI_H - -#include -#include - -#include "cloud_download_callback_middle.h" - -namespace OHOS::FileManagement::CloudSync { - -class CloudDownloadCallbackAniImpl : public CloudDownloadCallbackMiddle, - public std::enable_shared_from_this { -public: - CloudDownloadCallbackAniImpl(ani_env *env, ani_ref fun, bool isBatch = false); - ~CloudDownloadCallbackAniImpl() override = default; - void OnDownloadProcess(const DownloadProgressObj &progress) override; - void DeleteReference() override; - -private: - void GetDownloadProgress(const DownloadProgressObj &progress, const ani_class &cls, ani_object &pg); - ani_env *env_; - ani_ref cbOnRef_ = nullptr; - bool isBatch_; -}; -} // namespace OHOS::FileManagement::CloudSync -#endif // OHOS_FILEMGMT_CLOUD_DOWNLOAD_CALLBACK_ANI_H diff --git a/interfaces/kits/js/ani/file_cloud_sync/include/cloud_download_callback_middle.h b/interfaces/kits/js/ani/file_cloud_sync/include/cloud_download_callback_middle.h deleted file mode 100644 index 53d7b9a05..000000000 --- a/interfaces/kits/js/ani/file_cloud_sync/include/cloud_download_callback_middle.h +++ /dev/null @@ -1,30 +0,0 @@ -/* - * Copyright (c) 2025 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef OHOS_FILEMGMT_CLOUD_DOWNLOAD_CALLBACK_MIDDLE_H -#define OHOS_FILEMGMT_CLOUD_DOWNLOAD_CALLBACK_MIDDLE_H - -#include "cloud_download_callback.h" - -namespace OHOS::FileManagement::CloudSync { - -class CloudDownloadCallbackMiddle : public CloudDownloadCallback { -public: - virtual ~CloudDownloadCallbackMiddle() = default; - virtual void OnDownloadProcess(const DownloadProgressObj &progress) = 0; - virtual void DeleteReference() {}; -}; -} // namespace OHOS::FileManagement::CloudSync -#endif // OHOS_FILEMGMT_CLOUD_DOWNLOAD_CALLBACK_MIDDLE_H diff --git a/interfaces/kits/js/ani/file_cloud_sync/include/cloud_file_cache_ani.h b/interfaces/kits/js/ani/file_cloud_sync/include/cloud_file_cache_ani.h index 181c6d8fb..fc138b4a4 100644 --- a/interfaces/kits/js/ani/file_cloud_sync/include/cloud_file_cache_ani.h +++ b/interfaces/kits/js/ani/file_cloud_sync/include/cloud_file_cache_ani.h @@ -27,7 +27,12 @@ public: static void CloudFileCacheOff0(ani_env *env, ani_object object, ani_string evt, ani_object fun); static void CloudFileCacheOff1(ani_env *env, ani_object object, ani_string evt); static void CloudFileCacheStart(ani_env *env, ani_object object, ani_string uri); + static ani_double CloudFileCacheStartBatch(ani_env *env, + ani_object object, + ani_array_ref uriList, + ani_enum_item fileType); static void CloudFileCacheStop(ani_env *env, ani_object object, ani_string uri, ani_boolean needClean); + static void CloudFileCacheStopBatch(ani_env *env, ani_object object, ani_double taskId, ani_boolean needClean); static void CloudFileCacheCleanCache(ani_env *env, ani_object object, ani_string uri); }; } // namespace OHOS::FileManagement::CloudSync diff --git a/interfaces/kits/js/ani/file_cloud_sync/src/cloud_download_ani.cpp b/interfaces/kits/js/ani/file_cloud_sync/src/cloud_download_ani.cpp index 9f293bb58..ac26f622f 100644 --- a/interfaces/kits/js/ani/file_cloud_sync/src/cloud_download_ani.cpp +++ b/interfaces/kits/js/ani/file_cloud_sync/src/cloud_download_ani.cpp @@ -16,15 +16,14 @@ #include "cloud_download_ani.h" #include "ani_utils.h" +#include "dfsu_access_token_helper.h" +#include "dfs_error.h" #include "error_handler.h" #include "utils_log.h" namespace OHOS::FileManagement::CloudSync { - using namespace arkts::ani_signature; -const int32_t E_IPCSS = 13600001; - static CloudFileCore *CloudDownloadUnwrap(ani_env *env, ani_object object) { ani_long nativePtr; @@ -38,6 +37,19 @@ static CloudFileCore *CloudDownloadUnwrap(ani_env *env, ani_object object) return cloudDownload; } +static int32_t CheckPermissions(const string &permission, bool isSystemApp) +{ + if (!permission.empty() && !DfsuAccessTokenHelper::CheckCallerPermission(permission)) { + LOGE("permission denied"); + return JsErrCode::E_PERMISSION; + } + if (isSystemApp && !DfsuAccessTokenHelper::IsSystemApp()) { + LOGE("caller hap is not system hap"); + return JsErrCode::E_PERMISSION_SYS; + } + return E_OK; +} + void CloudDownloadAni::DownloadConstructor(ani_env *env, ani_object object) { ani_namespace ns {}; @@ -85,87 +97,81 @@ void CloudDownloadAni::DownloadConstructor(ani_env *env, ani_object object) void CloudDownloadAni::DownloadOn(ani_env *env, ani_object object, ani_string evt, ani_object fun) { - ani_ref cbOnRef; - ani_status ret = env->GlobalReference_Create(reinterpret_cast(fun), &cbOnRef); + std::string event; + ani_status ret = ANIUtils::AniString2String(env, evt, event); if (ret != ANI_OK) { - ErrorHandler::Throw(env, E_IPCSS); + ErrorHandler::Throw(env, JsErrCode::E_IPCSS); + return; + } + if (event != "progress") { + LOGE("Invalid argument for event type."); + ErrorHandler::Throw(env, JsErrCode::E_IPCSS); return; } - auto callback = std::make_shared(env, cbOnRef); - std::string event; - ret = ANIUtils::AniString2String(env, evt, event); - if (ret != ANI_OK) { - ErrorHandler::Throw(env, E_IPCSS); + int32_t res = CheckPermissions(PERM_CLOUD_SYNC, true); + if (res != E_OK) { + LOGE("On get progress failed!"); + ErrorHandler::Throw(env, res); return; } auto cloudDownload = CloudDownloadUnwrap(env, object); if (cloudDownload == nullptr) { LOGE("Cannot wrap cloudDownload."); - ErrorHandler::Throw(env, E_IPCSS); + ErrorHandler::Throw(env, JsErrCode::E_IPCSS); return; } - auto data = cloudDownload->DoOn(event, callback); - if (!data.IsSuccess()) { - const auto &err = data.GetError(); - LOGE("cloud download do on failed, ret = %{public}d", err.GetErrNo()); - ErrorHandler::Throw(env, err); + + std::shared_ptr callbackImpl = cloudDownload->GetCallbackImpl(true); + callbackImpl->InitVm(env); + auto status = callbackImpl->RegisterCallback(env, fun); + if (status != ANI_OK) { + LOGE("Failed to register callback, status: %{public}d.", status); + ErrorHandler::Throw(env, JsErrCode::E_IPCSS); + return; } } void CloudDownloadAni::DownloadOff0(ani_env *env, ani_object object, ani_string evt, ani_object fun) { - ani_ref cbOnRef; - ani_status ret = env->GlobalReference_Create(reinterpret_cast(fun), &cbOnRef); + std::string event; + ani_status ret = ANIUtils::AniString2String(env, evt, event); if (ret != ANI_OK) { - ErrorHandler::Throw(env, E_IPCSS); + ErrorHandler::Throw(env, JsErrCode::E_IPCSS); + return; + } + if (event != "progress") { + LOGE("Invalid argument for event type."); + ErrorHandler::Throw(env, JsErrCode::E_IPCSS); return; } - auto callback = std::make_shared(env, cbOnRef); - std::string event; - ret = ANIUtils::AniString2String(env, evt, event); - if (ret != ANI_OK) { - ErrorHandler::Throw(env, E_IPCSS); + int32_t res = CheckPermissions(PERM_CLOUD_SYNC, true); + if (res != E_OK) { + LOGE("On get progress failed!"); + ErrorHandler::Throw(env, res); return; } auto cloudDownload = CloudDownloadUnwrap(env, object); if (cloudDownload == nullptr) { LOGE("Cannot wrap cloudDownload."); - ErrorHandler::Throw(env, E_IPCSS); + ErrorHandler::Throw(env, JsErrCode::E_IPCSS); return; } - auto data = cloudDownload->DoOff(event, callback); - if (!data.IsSuccess()) { - const auto &err = data.GetError(); - LOGE("cloud download do off failed, ret = %{public}d", err.GetErrNo()); - ErrorHandler::Throw(env, err); + + std::shared_ptr callbackImpl = cloudDownload->GetCallbackImpl(false); + if (callbackImpl == nullptr || callbackImpl->UnregisterCallback(env, fun) != ANI_OK) { + LOGE("Failed to unregister callback"); + ErrorHandler::Throw(env, JsErrCode::E_IPCSS); + return; } } void CloudDownloadAni::DownloadOff1(ani_env *env, ani_object object, ani_string evt) { - std::string event; - ani_status ret = ANIUtils::AniString2String(env, evt, event); - if (ret != ANI_OK) { - ErrorHandler::Throw(env, E_IPCSS); - return; - } - - auto cloudDownload = CloudDownloadUnwrap(env, object); - if (cloudDownload == nullptr) { - LOGE("Cannot wrap cloudDownload."); - ErrorHandler::Throw(env, E_IPCSS); - return; - } - auto data = cloudDownload->DoOff(event); - if (!data.IsSuccess()) { - const auto &err = data.GetError(); - LOGE("cloud download do off failed, ret = %{public}d", err.GetErrNo()); - ErrorHandler::Throw(env, err); - } + DownloadOff0(env, object, evt, nullptr); } void CloudDownloadAni::DownloadStart(ani_env *env, ani_object object, ani_string uri) @@ -173,16 +179,18 @@ void CloudDownloadAni::DownloadStart(ani_env *env, ani_object object, ani_string std::string uriInput; ani_status ret = ANIUtils::AniString2String(env, uri, uriInput); if (ret != ANI_OK) { - ErrorHandler::Throw(env, E_PERMISSION); + ErrorHandler::Throw(env, JsErrCode::E_IPCSS); return; } auto cloudDownload = CloudDownloadUnwrap(env, object); if (cloudDownload == nullptr) { LOGE("Cannot wrap cloudDownload."); - ErrorHandler::Throw(env, E_PERMISSION); + ErrorHandler::Throw(env, JsErrCode::E_IPCSS); return; } + std::shared_ptr callbackImpl = cloudDownload->GetCallbackImpl(true); + callbackImpl->InitVm(env); auto data = cloudDownload->DoStart(uriInput); if (!data.IsSuccess()) { const auto &err = data.GetError(); @@ -196,16 +204,23 @@ void CloudDownloadAni::DownloadStop(ani_env *env, ani_object object, ani_string std::string uriInput; ani_status ret = ANIUtils::AniString2String(env, uri, uriInput); if (ret != ANI_OK) { - ErrorHandler::Throw(env, E_PERMISSION); + ErrorHandler::Throw(env, JsErrCode::E_IPCSS); return; } auto cloudDownload = CloudDownloadUnwrap(env, object); if (cloudDownload == nullptr) { LOGE("Cannot wrap cloudDownload."); - ErrorHandler::Throw(env, E_PERMISSION); + ErrorHandler::Throw(env, JsErrCode::E_IPCSS); return; } + std::shared_ptr callbackImpl = cloudDownload->GetCallbackImpl(false); + if (callbackImpl == nullptr) { + LOGE("Cannot get callbackImpl before stop."); + ErrorHandler::Throw(env, JsErrCode::E_IPCSS); + return; + } + auto data = cloudDownload->DoStop(uriInput); if (!data.IsSuccess()) { const auto &err = data.GetError(); @@ -213,4 +228,4 @@ void CloudDownloadAni::DownloadStop(ani_env *env, ani_object object, ani_string ErrorHandler::Throw(env, err); } } -} \ No newline at end of file +} // namespace OHOS::FileManagement::CloudSync \ No newline at end of file diff --git a/interfaces/kits/js/ani/file_cloud_sync/src/cloud_download_callback_ani.cpp b/interfaces/kits/js/ani/file_cloud_sync/src/cloud_download_callback_ani.cpp deleted file mode 100644 index 3e727b17d..000000000 --- a/interfaces/kits/js/ani/file_cloud_sync/src/cloud_download_callback_ani.cpp +++ /dev/null @@ -1,138 +0,0 @@ -/* - * Copyright (c) 2025 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "cloud_download_callback_ani.h" - -#include "ani_utils.h" -#include "utils_log.h" - -namespace OHOS::FileManagement::CloudSync { - -using namespace arkts::ani_signature; -constexpr int32_t ANI_SCOPE_SIZE = 16; - -CloudDownloadCallbackAniImpl::CloudDownloadCallbackAniImpl(ani_env *env, ani_ref fun, bool isBatch) -{ - env_ = env; - if (fun != nullptr) { - cbOnRef_ = fun; - } - isBatch_ = isBatch; -} - -void CloudDownloadCallbackAniImpl::GetDownloadProgress( - const DownloadProgressObj &progress, const ani_class &cls, ani_object &pg) -{ - ani_method ctor; - std::string ct = Builder::BuildConstructorName(); - std::string argSign = Builder::BuildSignatureDescriptor({ - Builder::BuildDouble(), Builder::BuildEnum("@ohos.file.cloudSync.cloudSync.State"), - Builder::BuildDouble(), Builder::BuildDouble(), Builder::BuildClass("std.core.String"), - Builder::BuildEnum("@ohos.file.cloudSync.cloudSync.DownloadErrorType") - }); - ani_status ret = env_->Class_FindMethod(cls, ct.c_str(), argSign.c_str(), &ctor); - if (ret != ANI_OK) { - LOGE("find ctor method failed. ret = %{public}d", ret); - return; - } - ani_string uri = nullptr; - ret = env_->String_NewUTF8(progress.path.c_str(), progress.path.size(), &uri); - if (ret != ANI_OK) { - LOGE("get uri failed. ret = %{public}d", ret); - return; - } - - ani_enum stateEnum; - Type stateSign = Builder::BuildEnum("@ohos.file.cloudSync.cloudSync.State"); - env_->FindEnum(stateSign.Descriptor().c_str(), &stateEnum); - ani_enum downloadErrorEnum; - Type errorSign = Builder::BuildEnum("@ohos.file.cloudSync.cloudSync.DownloadErrorType"); - env_->FindEnum(errorSign.Descriptor().c_str(), &downloadErrorEnum); - - ani_enum_item stateEnumItem; - ani_enum_item downloadErrorEnumItem; - env_->Enum_GetEnumItemByIndex(downloadErrorEnum, progress.downloadErrorType, &downloadErrorEnumItem); - - if (!isBatch_) { - env_->Enum_GetEnumItemByIndex(stateEnum, progress.state, &stateEnumItem); - ret = env_->Object_New(cls, ctor, &pg, static_cast(progress.downloadId), stateEnumItem, - static_cast(progress.downloadedSize), static_cast(progress.totalSize), uri, - downloadErrorEnumItem); - } else { - env_->Enum_GetEnumItemByIndex(stateEnum, progress.batchState, &stateEnumItem); - ret = env_->Object_New(cls, ctor, &pg, static_cast(progress.downloadId), stateEnumItem, - static_cast(progress.batchDownloadSize), static_cast(progress.batchTotalSize), - static_cast(progress.batchSuccNum), static_cast(progress.batchFailNum), - static_cast(progress.batchTotalNum), downloadErrorEnumItem); - } - - if (ret != ANI_OK) { - LOGE("create new object failed. ret = %{public}d", ret); - } -} - -void CloudDownloadCallbackAniImpl::OnDownloadProcess(const DownloadProgressObj &progress) -{ - auto task = [this, progress]() { - LOGI("CloudDownloadCallbackAniImpl OnDownloadProcess"); - ani_env *tmpEnv = env_; - ani_size nr_refs = ANI_SCOPE_SIZE; - ani_status ret = tmpEnv->CreateLocalScope(nr_refs); - if (ret != ANI_OK) { - LOGE("crete local scope failed. ret = %{public}d", ret); - return; - } - ani_namespace ns {}; - Namespace nsSign = Builder::BuildNamespace("@ohos.file.cloudSync.cloudSync"); - ret = tmpEnv->FindNamespace(nsSign.Descriptor().c_str(), &ns); - if (ret != ANI_OK) { - LOGE("find namespace failed. ret = %{public}d", ret); - return; - } - Type clsName = Builder::BuildClass("DownloadProgressInner"); - ani_class cls; - ret = tmpEnv->Namespace_FindClass(ns, clsName.Descriptor().c_str(), &cls); - if (ret != ANI_OK) { - LOGE("find class failed. ret = %{public}d", ret); - return; - } - ani_object pg; - GetDownloadProgress(progress, cls, pg); - ani_ref ref_; - ani_fn_object etsCb = reinterpret_cast(cbOnRef_); - std::vector vec = { pg }; - ret = tmpEnv->FunctionalObject_Call(etsCb, 1, vec.data(), &ref_); - if (ret != ANI_OK) { - LOGE("ani call function failed. ret = %{public}d", ret); - return; - } - ret = tmpEnv->DestroyLocalScope(); - if (ret != ANI_OK) { - LOGE("failed to DestroyLocalScope. ret = %{public}d", ret); - } - }; - if (!ANIUtils::SendEventToMainThread(task)) { - LOGE("failed to send event"); - } -} - -void CloudDownloadCallbackAniImpl::DeleteReference() -{ - if (cbOnRef_ != nullptr) { - env_->GlobalReference_Delete(cbOnRef_); - cbOnRef_ = nullptr; - } -} -} // namespace OHOS::FileManagement::CloudSync \ No newline at end of file diff --git a/interfaces/kits/js/ani/file_cloud_sync/src/cloud_file_cache_ani.cpp b/interfaces/kits/js/ani/file_cloud_sync/src/cloud_file_cache_ani.cpp index a3f654561..16ccb1d01 100644 --- a/interfaces/kits/js/ani/file_cloud_sync/src/cloud_file_cache_ani.cpp +++ b/interfaces/kits/js/ani/file_cloud_sync/src/cloud_file_cache_ani.cpp @@ -16,6 +16,7 @@ #include "cloud_file_cache_ani.h" #include "ani_utils.h" +#include "dfs_error.h" #include "error_handler.h" #include "utils_log.h" @@ -23,8 +24,6 @@ namespace OHOS::FileManagement::CloudSync { using namespace arkts::ani_signature; -const int32_t E_IPCSS = 13600001; - static CloudFileCacheCore *CloudFileCacheUnwrap(ani_env *env, ani_object object) { ani_long nativePtr; @@ -88,112 +87,132 @@ void CloudFileCacheAni::CloudFileCacheOn(ani_env *env, ani_object object, ani_st std::string event; ani_status ret = ANIUtils::AniString2String(env, evt, event); if (ret != ANI_OK) { - ErrorHandler::Throw(env, E_IPCSS); + ErrorHandler::Throw(env, JsErrCode::E_IPCSS); return; } - ani_ref cbOnRef; - ret = env->GlobalReference_Create(reinterpret_cast(fun), &cbOnRef); - if (ret != ANI_OK) { - ErrorHandler::Throw(env, E_IPCSS); - return; + if (event == "multiProgress") { + event = MULTI_PROGRESS; } - std::shared_ptr callback = nullptr; - if (event == "progress") { - callback = std::make_shared(env, cbOnRef); - } else if (event == "multiProgress") { - callback = std::make_shared(env, cbOnRef, true); + if (event != PROGRESS && event != MULTI_PROGRESS) { + LOGE("Invalid argument for event type."); + ErrorHandler::Throw(env, JsErrCode::E_IPCSS); + return; } auto cloudFileCache = CloudFileCacheUnwrap(env, object); if (cloudFileCache == nullptr) { LOGE("Cannot wrap cloudFileCache."); - ErrorHandler::Throw(env, E_IPCSS); + ErrorHandler::Throw(env, JsErrCode::E_IPCSS); return; } - auto data = cloudFileCache->DoOn(event, callback); - if (!data.IsSuccess()) { - const auto &err = data.GetError(); - LOGE("cloudFileCache do on failed, ret = %{public}d", err.GetErrNo()); - ErrorHandler::Throw(env, err); + + std::shared_ptr callbackImpl = cloudFileCache->GetCallbackImpl(event, true); + callbackImpl->InitVm(env); + auto status = callbackImpl->RegisterCallback(env, fun); + if (status != ANI_OK) { + LOGE("Failed to register callback, status: %{public}d.", status); + ErrorHandler::Throw(env, JsErrCode::E_IPCSS); + return; } } void CloudFileCacheAni::CloudFileCacheOff0(ani_env *env, ani_object object, ani_string evt, ani_object fun) { - ani_ref cbOnRef; - ani_status ret = env->GlobalReference_Create(reinterpret_cast(fun), &cbOnRef); + std::string event; + ani_status ret = ANIUtils::AniString2String(env, evt, event); if (ret != ANI_OK) { - ErrorHandler::Throw(env, E_IPCSS); + ErrorHandler::Throw(env, JsErrCode::E_IPCSS); return; } - auto callback = std::make_shared(env, cbOnRef); - std::string event; - ret = ANIUtils::AniString2String(env, evt, event); - if (ret != ANI_OK) { - ErrorHandler::Throw(env, E_IPCSS); + if (event == "multiProgress") { + event = MULTI_PROGRESS; + } + if (event != PROGRESS && event == MULTI_PROGRESS) { + LOGE("Invalid argument for event type."); + ErrorHandler::Throw(env, JsErrCode::E_IPCSS); return; } auto cloudFileCache = CloudFileCacheUnwrap(env, object); if (cloudFileCache == nullptr) { LOGE("Cannot wrap cloudFileCache."); - ErrorHandler::Throw(env, E_IPCSS); + ErrorHandler::Throw(env, JsErrCode::E_IPCSS); return; } - auto data = cloudFileCache->DoOff(event, callback); - if (!data.IsSuccess()) { - const auto &err = data.GetError(); - LOGE("cloudFileCache do off failed, ret = %{public}d", err.GetErrNo()); - ErrorHandler::Throw(env, err); + + std::shared_ptr callbackImpl = cloudFileCache->GetCallbackImpl(event, false); + if (callbackImpl == nullptr || callbackImpl->UnregisterCallback(env, fun) != ANI_OK) { + LOGE("Failed to unregister callback."); + ErrorHandler::Throw(env, JsErrCode::E_IPCSS); + return; } } void CloudFileCacheAni::CloudFileCacheOff1(ani_env *env, ani_object object, ani_string evt) { - std::string event; - ani_status ret = ANIUtils::AniString2String(env, evt, event); + CloudFileCacheOff0(env, object, evt, nullptr); +} + +void CloudFileCacheAni::CloudFileCacheStart(ani_env *env, ani_object object, ani_string uri) +{ + std::string uriInput; + ani_status ret = ANIUtils::AniString2String(env, uri, uriInput); if (ret != ANI_OK) { - ErrorHandler::Throw(env, E_IPCSS); + ErrorHandler::Throw(env, JsErrCode::E_IPCSS); return; } auto cloudFileCache = CloudFileCacheUnwrap(env, object); if (cloudFileCache == nullptr) { LOGE("Cannot wrap cloudFileCache."); - ErrorHandler::Throw(env, E_IPCSS); + ErrorHandler::Throw(env, JsErrCode::E_IPCSS); return; } - auto data = cloudFileCache->DoOff(event); + auto data = cloudFileCache->DoStart(uriInput); if (!data.IsSuccess()) { const auto &err = data.GetError(); - LOGE("cloudFileCache do off failed, ret = %{public}d", err.GetErrNo()); + LOGE("cloudFileCache do start failed, ret = %{public}d", err.GetErrNo()); ErrorHandler::Throw(env, err); } } -void CloudFileCacheAni::CloudFileCacheStart(ani_env *env, ani_object object, ani_string uri) +ani_double CloudFileCacheAni::CloudFileCacheStartBatch(ani_env *env, + ani_object object, + ani_array_ref uriList, + ani_enum_item fileType) { - std::string uriInput; - ani_status ret = ANIUtils::AniString2String(env, uri, uriInput); - if (ret != ANI_OK) { - ErrorHandler::Throw(env, E_IPCSS); - return; + ani_double errResult = 0; + auto [ret, urisInput] = ANIUtils::AniToStringArray(env, uriList); + if (!ret) { + ErrorHandler::Throw(env, JsErrCode::E_IPCSS); + return errResult; + } + + int32_t fieldKey = static_cast(FieldKey::FIELDKEY_CONTENT); + tie(ret, fieldKey) = ANIUtils::EnumToInt32(env, fileType); + if (!ret) { + LOGE("cloudFileCache get fileType failed"); + ErrorHandler::Throw(env, JsErrCode::E_IPCSS); + return errResult; } auto cloudFileCache = CloudFileCacheUnwrap(env, object); if (cloudFileCache == nullptr) { LOGE("Cannot wrap cloudFileCache."); - ErrorHandler::Throw(env, E_IPCSS); - return; + ErrorHandler::Throw(env, JsErrCode::E_IPCSS); + return errResult; } - auto data = cloudFileCache->DoStart(uriInput); + auto data = cloudFileCache->DoStart(urisInput, fieldKey); if (!data.IsSuccess()) { const auto &err = data.GetError(); LOGE("cloudFileCache do start failed, ret = %{public}d", err.GetErrNo()); ErrorHandler::Throw(env, err); + return errResult; } + + return static_cast(data.GetData().value()); } void CloudFileCacheAni::CloudFileCacheStop(ani_env *env, ani_object object, ani_string uri, ani_boolean needClean) @@ -201,14 +220,14 @@ void CloudFileCacheAni::CloudFileCacheStop(ani_env *env, ani_object object, ani_ std::string uriInput; ani_status ret = ANIUtils::AniString2String(env, uri, uriInput); if (ret != ANI_OK) { - ErrorHandler::Throw(env, E_IPCSS); + ErrorHandler::Throw(env, JsErrCode::E_IPCSS); return; } auto cloudFileCache = CloudFileCacheUnwrap(env, object); if (cloudFileCache == nullptr) { LOGE("Cannot wrap cloudFileCache."); - ErrorHandler::Throw(env, E_IPCSS); + ErrorHandler::Throw(env, JsErrCode::E_IPCSS); return; } @@ -222,19 +241,41 @@ void CloudFileCacheAni::CloudFileCacheStop(ani_env *env, ani_object object, ani_ } } +void CloudFileCacheAni::CloudFileCacheStopBatch(ani_env *env, + ani_object object, + ani_double taskId, + ani_boolean needClean) +{ + auto cloudFileCache = CloudFileCacheUnwrap(env, object); + if (cloudFileCache == nullptr) { + LOGE("Cannot wrap cloudFileCache."); + ErrorHandler::Throw(env, JsErrCode::E_IPCSS); + return; + } + + bool needCleanInput = needClean; + + auto data = cloudFileCache->DoStop(static_cast(taskId), needCleanInput); + if (!data.IsSuccess()) { + const auto &err = data.GetError(); + LOGE("cloudFileCache do stop failed, ret = %{public}d", err.GetErrNo()); + ErrorHandler::Throw(env, err); + } +} + void CloudFileCacheAni::CloudFileCacheCleanCache(ani_env *env, ani_object object, ani_string uri) { std::string uriInput; ani_status ret = ANIUtils::AniString2String(env, uri, uriInput); if (ret != ANI_OK) { - ErrorHandler::Throw(env, E_IPCSS); + ErrorHandler::Throw(env, JsErrCode::E_IPCSS); return; } auto cloudFileCache = CloudFileCacheUnwrap(env, object); if (cloudFileCache == nullptr) { LOGE("Cannot wrap cloudFileCache."); - ErrorHandler::Throw(env, E_IPCSS); + ErrorHandler::Throw(env, JsErrCode::E_IPCSS); return; } auto data = cloudFileCache->CleanCache(uriInput); diff --git a/interfaces/kits/js/ani/file_cloud_sync/src/download_callback_impl_ani.cpp b/interfaces/kits/js/ani/file_cloud_sync/src/download_callback_impl_ani.cpp index e554c2e7a..59267ed2a 100644 --- a/interfaces/kits/js/ani/file_cloud_sync/src/download_callback_impl_ani.cpp +++ b/interfaces/kits/js/ani/file_cloud_sync/src/download_callback_impl_ani.cpp @@ -29,7 +29,7 @@ int32_t CloudDownloadCallbackImplAni::StartDownloadInner(const std::string &uri) return ret; } - downloadInfos_.insert(std::make_pair(downloadId, std::make_shared(downloadId))); + downloadInfos_[downloadId] = std::make_shared(downloadId); return ret; } @@ -61,7 +61,7 @@ int32_t CloudFileCacheCallbackImplAni::StartDownloadInner(const std::string &uri LOGE("Start single download failed! ret = %{public}d", ret); return ret; } - downloadInfos_.insert(std::make_pair(downloadId, std::make_shared(downloadId))); + downloadInfos_[downloadId] = std::make_shared(downloadId); return ret; } @@ -94,7 +94,7 @@ int32_t CloudFileCacheCallbackImplAni::StartDownloadInner(const std::vector(downloadId))); + downloadInfos_[downloadId] = std::make_shared(downloadId); return ret; } diff --git a/interfaces/kits/js/cloudfilesync/BUILD.gn b/interfaces/kits/js/cloudfilesync/BUILD.gn index 415e86749..1028950c0 100644 --- a/interfaces/kits/js/cloudfilesync/BUILD.gn +++ b/interfaces/kits/js/cloudfilesync/BUILD.gn @@ -39,7 +39,6 @@ ohos_shared_library("cloudsync") { } sources = [ "cloud_file_cache_napi.cpp", - "cloud_file_download_napi.cpp", "cloud_file_napi.cpp", "cloud_file_version_napi.cpp", "cloud_sync_n_exporter.cpp", diff --git a/interfaces/kits/js/cloudfilesync/cloud_file_cache_core.cpp b/interfaces/kits/js/cloudfilesync/cloud_file_cache_core.cpp index e982b80fb..494b1446a 100644 --- a/interfaces/kits/js/cloudfilesync/cloud_file_cache_core.cpp +++ b/interfaces/kits/js/cloudfilesync/cloud_file_cache_core.cpp @@ -14,151 +14,100 @@ */ #include "cloud_file_cache_core.h" + +#include + #include "cloud_sync_manager.h" #include "dfs_error.h" #include "utils_log.h" namespace OHOS::FileManagement::CloudSync { -const int32_t E_PARAMS = 401; - -bool RegisterManager::HasEvent(const string &eventType) +using namespace ModuleFileIO; +FsResult CloudFileCacheCore::Constructor() { - unique_lock registerMutex_; - bool hasEvent = false; - for (auto &iter : registerInfo_) { - if (iter->eventType == eventType) { - hasEvent = true; - break; - } - } - return hasEvent; + std::unique_ptr cloudFileCachePtr = std::make_unique(); + return FsResult::Success(cloudFileCachePtr.release()); } -bool RegisterManager::AddRegisterInfo(shared_ptr info) +FsResult CloudFileCacheCore::DoOn(const string &event, const shared_ptr callback) { - if (HasEvent(info->eventType)) { - return false; - } - { - unique_lock registerMutex_; - registerInfo_.insert(info); - } - return true; + return FsResult::Success(); } -bool RegisterManager::RemoveRegisterInfo(const string &eventType) +FsResult CloudFileCacheCore::DoOff(const string &event, + const optional> &callback) { - unique_lock registerMutex_; - bool isFound = false; - for (auto iter = registerInfo_.begin(); iter != registerInfo_.end();) { - if ((*iter)->eventType == eventType) { - isFound = true; - iter = registerInfo_.erase(iter); - } else { - iter++; - } - } - return isFound; + return FsResult::Success(); } -FsResult CloudFileCacheCore::Constructor() +std::shared_ptr CloudFileCacheCore::GetCallbackImpl(const std::string &eventType, + bool isInit) { - CloudFileCacheCore *cloudFileCachePtr = new CloudFileCacheCore(); - if (cloudFileCachePtr == nullptr) { - LOGE("Failed to create CloudFileCacheCore object on heap."); - return FsResult::Error(ENOMEM); + std::shared_ptr callbackImpl = nullptr; + std::lock_guard lock(registerMutex_); + auto iter = registerMap_.find(eventType); + if (iter == registerMap_.end() || iter->second == nullptr) { + if (isInit) { + callbackImpl = std::make_shared(); + registerMap_.insert(make_pair(eventType, callbackImpl)); + } + } else { + callbackImpl = iter->second; } - - return FsResult::Success(move(cloudFileCachePtr)); -} - -CloudFileCacheCore::CloudFileCacheCore() -{ - LOGI("Create fileCacheEntity"); - fileCacheEntity = make_unique(); + return callbackImpl; } -FsResult CloudFileCacheCore::DoOn(const string &event, const shared_ptr callback) +FsResult CloudFileCacheCore::DoStart(const string &uri) { - LOGI("On begin"); - if (event != PROGRESS && event != MULTI_PROGRESS) { - LOGE("On get progress failed!"); - return FsResult::Error(E_PARAMS); - } - - if (!fileCacheEntity) { - LOGE("Failed to get file cache entity."); - return FsResult::Error(E_PARAMS); - } - - auto arg = make_shared(); - arg->eventType = event; - arg->callback = callback; - if (!fileCacheEntity->registerMgr.AddRegisterInfo(arg)) { - LOGE("Batch-On register callback fail, callback already exist"); - return FsResult::Error(E_PARAMS); - } - - int32_t ret = CloudSyncManager::GetInstance().RegisterFileCacheCallback(arg->callback); + auto callbackImpl = GetCallbackImpl(PROGRESS, true); + int32_t ret = callbackImpl->StartDownloadInner(uri, FieldKey::FIELDKEY_CONTENT); if (ret != E_OK) { - LOGE("RegisterDownloadFileCallback error, ret: %{public}d", ret); - (void)fileCacheEntity->registerMgr.RemoveRegisterInfo(event); + LOGE("Stop Download failed! ret = %{public}d", ret); return FsResult::Error(Convert2ErrNum(ret)); } return FsResult::Success(); } -FsResult CloudFileCacheCore::DoOff( - const string &event, const optional> &callback) +FsResult CloudFileCacheCore::DoStart(const std::vector &uriList, int32_t fieldKey) { - LOGI("Off begin"); - if (event != PROGRESS && event != MULTI_PROGRESS) { - LOGE("Off get progress failed!"); - return FsResult::Error(E_PARAMS); - } - - if (!fileCacheEntity) { - LOGE("Failed to get file cache entity."); - return FsResult::Error(E_PARAMS); - } - - if (!fileCacheEntity->registerMgr.HasEvent(event)) { - LOGE("Batch-Off no callback is registered for this event type: %{public}s.", event.c_str()); - return FsResult::Error(E_PARAMS); - } - - int32_t ret = CloudSyncManager::GetInstance().UnregisterFileCacheCallback(); + auto callbackImpl = GetCallbackImpl(MULTI_PROGRESS, true); + int64_t downloadId = 0; + int32_t ret = callbackImpl->StartDownloadInner(uriList, downloadId, fieldKey); if (ret != E_OK) { - LOGE("Failed to unregister callback, error: %{public}d", ret); - return FsResult::Error(Convert2ErrNum(ret)); - } - - if (!fileCacheEntity->registerMgr.RemoveRegisterInfo(event)) { - LOGE("Batch-Off remove callback is failed, event type: %{public}s.", event.c_str()); - return FsResult::Error(E_PARAMS); + LOGE("Stop Download failed! ret = %{public}d", ret); + return FsResult::Error(Convert2ErrNum(ret)); } - return FsResult::Success(); + return FsResult::Success(downloadId); } -FsResult CloudFileCacheCore::DoStart(const string &uri) +FsResult CloudFileCacheCore::DoStop(const string &uri, bool needClean) { - int32_t ret = CloudSyncManager::GetInstance().StartFileCache(uri); + auto callbackImpl = GetCallbackImpl(PROGRESS, false); + if (callbackImpl == nullptr) { + LOGE("Failed to stop download, callback is null!"); + return FsResult::Error(E_INVAL_ARG); + } + int32_t ret = callbackImpl->StopDownloadInner(uri, needClean); if (ret != E_OK) { - LOGE("Start Download failed with errormessage: ret = %{public}d", ret); + LOGE("Stop Download failed! ret = %{public}d", ret); return FsResult::Error(Convert2ErrNum(ret)); } - LOGI("Start Download successfully!"); return FsResult::Success(); } -FsResult CloudFileCacheCore::DoStop(const string &uri, const bool needClean) +FsResult CloudFileCacheCore::DoStop(int64_t downloadId, bool needClean) { - int32_t ret = CloudSyncManager::GetInstance().StopDownloadFile(uri, needClean); + auto callbackImpl = GetCallbackImpl(MULTI_PROGRESS, false); + if (callbackImpl == nullptr) { + LOGE("Failed to stop batch download, callback is null!"); + return FsResult::Error(EINVAL); + } + int32_t ret = callbackImpl->StopDownloadInner(downloadId, needClean); if (ret != E_OK) { - LOGE("Stop Download failed! ret = %{public}d", ret); + LOGE("Stop batch download failed! ret = %{public}d", ret); return FsResult::Error(Convert2ErrNum(ret)); } diff --git a/interfaces/kits/js/cloudfilesync/cloud_file_cache_core.h b/interfaces/kits/js/cloudfilesync/cloud_file_cache_core.h index 151f3b962..04b57be45 100644 --- a/interfaces/kits/js/cloudfilesync/cloud_file_cache_core.h +++ b/interfaces/kits/js/cloudfilesync/cloud_file_cache_core.h @@ -20,59 +20,32 @@ #include #include -#include "cloud_download_callback_ani.h" +#include "download_callback_impl_ani.h" #include "filemgmt_libfs.h" namespace OHOS::FileManagement::CloudSync { -using namespace ModuleFileIO; -using namespace std; const std::string PROGRESS = "progress"; -const std::string MULTI_PROGRESS = "multiProgress"; - -struct RegisterInfoArg { - std::string eventType; - std::shared_ptr callback; - ~RegisterInfoArg() - { - if (callback != nullptr) { - callback->DeleteReference(); - callback = nullptr; - } - } -}; - -class RegisterManager { -public: - RegisterManager() = default; - ~RegisterManager() = default; - bool AddRegisterInfo(std::shared_ptr info); - bool RemoveRegisterInfo(const std::string &eventType); - bool HasEvent(const std::string &eventType); - -private: - std::mutex registerMutex_; - std::unordered_set> registerInfo_; -}; - -struct FileCacheEntity { - RegisterManager registerMgr; -}; - +const std::string MULTI_PROGRESS = "batchDownload"; class CloudFileCacheCore { public: - CloudFileCacheCore(); + CloudFileCacheCore() = default; ~CloudFileCacheCore() = default; - static FsResult Constructor(); - FsResult DoOn(const std::string &event, const std::shared_ptr callback); - FsResult DoOff(const string &event, - const std::optional> &callback = std::nullopt); - FsResult DoStart(const string &uri); - FsResult DoStop(const string &uri, bool needClean = false); - FsResult CleanCache(const string &uri); + static ModuleFileIO::FsResult Constructor(); + ModuleFileIO::FsResult DoOn(const std::string &event, + const std::shared_ptr callback); + ModuleFileIO::FsResult DoOff(const std::string &event, + const std::optional> &callback = std::nullopt); + ModuleFileIO::FsResult DoStart(const std::string &uri); + ModuleFileIO::FsResult DoStart(const std::vector &uriList, int32_t fieldKey); + ModuleFileIO::FsResult DoStop(const std::string &uri, bool needClean = false); + ModuleFileIO::FsResult DoStop(int64_t downloadId, bool needClean = false); + ModuleFileIO::FsResult CleanCache(const std::string &uri); + std::shared_ptr GetCallbackImpl(const std::string &eventType, bool isInit); private: - std::unique_ptr fileCacheEntity; + std::mutex registerMutex_; + std::unordered_map> registerMap_; }; } // namespace OHOS::FileManagement::CloudSync diff --git a/interfaces/kits/js/cloudfilesync/cloud_file_cache_napi.cpp b/interfaces/kits/js/cloudfilesync/cloud_file_cache_napi.cpp index a5bed5c39..1d489d03c 100644 --- a/interfaces/kits/js/cloudfilesync/cloud_file_cache_napi.cpp +++ b/interfaces/kits/js/cloudfilesync/cloud_file_cache_napi.cpp @@ -17,6 +17,8 @@ #include #include +#include +#include #include #include "async_work.h" @@ -25,7 +27,6 @@ #include "multi_download_progress_napi.h" #include "register_callback_manager_napi.h" #include "utils_log.h" -#include "uv.h" namespace OHOS::FileManagement::CloudSync { using namespace FileManagement::LibN; @@ -42,7 +43,7 @@ int32_t CloudFileCacheCallbackImplNapi::StartDownloadInner(const std::string &ur LOGE("Start single download failed! ret = %{public}d", ret); return ret; } - downloadInfos_.insert(std::make_pair(downloadId, std::make_shared(downloadId))); + downloadInfos_[downloadId] = std::make_shared(downloadId); return ret; } @@ -75,7 +76,7 @@ int32_t CloudFileCacheCallbackImplNapi::StartDownloadInner(const std::vector(downloadId))); + downloadInfos_[downloadId] = std::make_shared(downloadId); return ret; } @@ -88,59 +89,19 @@ int32_t CloudFileCacheCallbackImplNapi::StopDownloadInner(int64_t downloadId, bo return ret; } -bool RegisterManager::HasEvent(const string &eventType) -{ - unique_lock registerMutex_; - bool hasEvent = false; - for (auto &iter : registerInfo_) { - if (iter->eventType == eventType) { - hasEvent = true; - break; - } - } - return hasEvent; -} - -bool RegisterManager::AddRegisterInfo(shared_ptr info) -{ - if (HasEvent(info->eventType)) { - return false; - } - { - unique_lock registerMutex_; - registerInfo_.insert(info); - } - return true; -} - -bool RegisterManager::RemoveRegisterInfo(const string &eventType) -{ - unique_lock registerMutex_; - bool isFound = false; - for (auto iter = registerInfo_.begin(); iter != registerInfo_.end();) { - if ((*iter)->eventType == eventType) { - isFound = true; - iter = registerInfo_.erase(iter); - } else { - iter++; - } - } - return isFound; -} - napi_value CloudFileCacheNapi::Constructor(napi_env env, napi_callback_info info) { NFuncArg funcArg(env, info); if (!funcArg.InitArgs(NARG_CNT::ZERO)) { LOGE("Start Number of arguments unmatched"); - NError(E_PARAMS).ThrowErr(env); + NError(JsErrCode::E_INNER_FAILED).ThrowErr(env); return nullptr; } auto fileCacheEntity = make_unique(); if (!NClass::SetEntityFor(env, funcArg.GetThisVar(), move(fileCacheEntity))) { LOGE("Failed to set file cache entity."); - NError(E_UNKNOWN_ERR).ThrowErr(env); + NError(JsErrCode::E_INNER_FAILED).ThrowErr(env); return nullptr; } return funcArg.GetThisVar(); @@ -151,14 +112,14 @@ bool CloudFileCacheNapi::ToExport(std::vector props) std::string className = GetClassName(); auto [succ, classValue] = NClass::DefineClass(exports_.env_, className, Constructor, std::move(props)); if (!succ) { - NError(E_UNKNOWN_ERR).ThrowErr(exports_.env_); + NError(JsErrCode::E_INNER_FAILED).ThrowErr(exports_.env_); LOGE("Failed to define GallerySync class"); return false; } succ = NClass::SaveClass(exports_.env_, className, classValue); if (!succ) { - NError(E_UNKNOWN_ERR).ThrowErr(exports_.env_); + NError(JsErrCode::E_INNER_FAILED).ThrowErr(exports_.env_); LOGE("Failed to save GallerySync class"); return false; } @@ -204,7 +165,7 @@ napi_value CloudFileCacheNapi::CleanFileCache(napi_env env, napi_callback_info i { LOGI("CleanCache start"); NFuncArg funcArg(env, info); - + if (!funcArg.InitArgs(NARG_CNT::ONE)) { NError(EINVAL).ThrowErr(env); LOGE("Number of arguments unmatched"); @@ -244,6 +205,38 @@ bool CloudFileCacheNapi::Export() return ToExport(props); } +static std::shared_ptr GetCallbackImpl(napi_env env, NFuncArg &funcArg, + const std::string &eventType, bool isInit) +{ + auto fileCacheEntity = NClass::GetEntityOf(env, funcArg.GetThisVar()); + if (!fileCacheEntity) { + LOGE("Failed to get file cache entity."); + return nullptr; + } + + std::shared_ptr callbackImpl = nullptr; + auto iter = fileCacheEntity->registerMap.find(eventType); + if (iter == fileCacheEntity->registerMap.end() || iter->second == nullptr) { + if (isInit) { + callbackImpl = std::make_shared(env); + fileCacheEntity->registerMap.insert(make_pair(eventType, callbackImpl)); + } + } else { + callbackImpl = iter->second; + } + return callbackImpl; +} + +static std::tuple ParseUriFromParam(napi_env env, NFuncArg &funcArg) +{ + auto [succ, uri, size] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String(); + if (!succ || size == 0) { + LOGE("Off get progress failed!"); + return {E_PARAMS, ""}; + } + return {E_OK, string(uri.get())}; +} + napi_value CloudFileCacheNapi::StartFileCache(napi_env env, napi_callback_info info) { NFuncArg funcArg(env, info); @@ -252,15 +245,19 @@ napi_value CloudFileCacheNapi::StartFileCache(napi_env env, napi_callback_info i NError(E_PARAMS).ThrowErr(env); return nullptr; } - auto [succUri, uri, ignore] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String(); - if (!succUri) { - LOGE("Start get uri parameter failed!"); - NError(E_PARAMS).ThrowErr(env); + + auto [ret, uri] = ParseUriFromParam(env, funcArg); + if (ret != E_OK) { + NError(ret).ThrowErr(env); return nullptr; } - - auto cbExec = [uri = string(uri.get())]() -> NError { - int32_t ret = CloudSyncManager::GetInstance().StartFileCache(uri); + auto callbackImpl = GetCallbackImpl(env, funcArg, PROGRESS, true); + auto cbExec = [uri{uri}, callbackImpl{callbackImpl}]() -> NError { + if (callbackImpl == nullptr) { + LOGE("Failed to get download callback"); + return NError(E_PARAMS); + } + int32_t ret = callbackImpl->StartDownloadInner(uri, FieldKey::FIELDKEY_CONTENT); if (ret != E_OK) { LOGE("Start Download failed! ret = %{public}d", ret); if (ret != E_INVAL_ARG) { @@ -268,7 +265,6 @@ napi_value CloudFileCacheNapi::StartFileCache(napi_env env, napi_callback_info i } return NError(Convert2JsErrNum(ret)); } - LOGI("Start Download Success!"); return NError(ERRNO_NOERR); }; @@ -284,36 +280,51 @@ napi_value CloudFileCacheNapi::StartFileCache(napi_env env, napi_callback_info i return asyncWork == nullptr ? nullptr : asyncWork->Schedule(procedureName, cbExec, cbCompl).val_; } +static tuple GetCleanFlagForStop(napi_env env, NFuncArg &funcArg) +{ + bool succ = false; + bool needClean = false; + size_t maxArgSize = static_cast(NARG_CNT::TWO); + if (funcArg.GetArgc() >= NARG_CNT::TWO) { + NVal option(env, funcArg[NARG_POS::SECOND]); + if (!option.TypeIs(napi_function)) { + tie(succ, needClean) = option.ToBool(); + maxArgSize = static_cast(NARG_CNT::THREE); + } + if (!succ) { + LOGE("Failed to get clean flag!"); + return {EINVAL, false, false}; + } + } + return {E_OK, needClean, maxArgSize}; +} + napi_value CloudFileCacheNapi::StopFileCache(napi_env env, napi_callback_info info) { NFuncArg funcArg(env, info); if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::THREE)) { LOGE("Stop Number of arguments unmatched"); - NError(E_PARAMS).ThrowErr(env); + NError(EINVAL).ThrowErr(env); return nullptr; } - auto [succ, uri, ignore] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String(); - if (!succ) { - LOGE("Stop get uri parameter failed!"); + auto [res, uri] = ParseUriFromParam(env, funcArg); + if (res != E_OK) { + NError(res).ThrowErr(env); + return nullptr; + } + + auto [ret, needClean, maxArgSize] = GetCleanFlagForStop(env, funcArg); + if (ret != E_OK) { NError(E_PARAMS).ThrowErr(env); return nullptr; } - bool needClean = false; - size_t maxArgSize = static_cast(NARG_CNT::TWO); - if (funcArg.GetArgc() >= NARG_CNT::TWO) { - NVal option(env, funcArg[NARG_POS::SECOND]); - if (!option.TypeIs(napi_function)) { - tie(succ, needClean) = option.ToBool(); - if (!succ) { - LOGE("Failed to get clean flag!"); - NError(E_PARAMS).ThrowErr(env); - return nullptr; - } - maxArgSize = static_cast(NARG_CNT::THREE); + auto callbackImpl = GetCallbackImpl(env, funcArg, PROGRESS, false); + auto cbExec = [uri{uri}, needClean{needClean}, callbackImpl{callbackImpl}]() -> NError { + if (callbackImpl == nullptr) { + LOGE("Failed to get download callback"); + return NError(E_PARAMS); } - } - auto cbExec = [uri = string(uri.get()), env = env, needClean]() -> NError { - int32_t ret = CloudSyncManager::GetInstance().StopDownloadFile(uri, needClean); + int32_t ret = callbackImpl->StopDownloadInner(uri, needClean); if (ret != E_OK) { LOGE("Stop Download failed! ret = %{public}d", ret); if (ret != E_INVAL_ARG) { @@ -337,47 +348,80 @@ napi_value CloudFileCacheNapi::StopFileCache(napi_env env, napi_callback_info in } struct FileCacheArg { - vector uriList; - int64_t downloadId; + std::vector uriList; + int64_t downloadId = 0; + std::shared_ptr callbackImpl = nullptr; + int32_t fieldKey = FieldKey::FIELDKEY_CONTENT; }; +static std::tuple, int32_t> FillParamForBatchStart(napi_env env, + NFuncArg &funcArg) +{ + size_t maxArgSize = static_cast(NARG_CNT::TWO); + auto [succ, uriArray, size] = NVal(env, funcArg[NARG_POS::FIRST]).ToStringArray(); + if (!succ || size == 0) { + LOGE("Start get uri array parameter failed!"); + return {EINVAL, nullptr, maxArgSize}; + } + + int32_t fieldKey = 0; + if (funcArg.GetArgc() >= NARG_CNT::TWO) { + NVal option(env, funcArg[NARG_POS::SECOND]); + if (!option.TypeIs(napi_function)) { + tie(succ, fieldKey) = option.ToInt32(); + maxArgSize = static_cast(NARG_CNT::THREE); + } + if (!succ) { + LOGE("Failed to get fileType!"); + return {EINVAL, nullptr, maxArgSize}; + } + } + + auto fileCache = std::make_shared(); + fileCache->uriList.swap(uriArray); + fileCache->fieldKey = fieldKey; + fileCache->callbackImpl = GetCallbackImpl(env, funcArg, MULTI_PROGRESS, true); + return {E_OK, fileCache, maxArgSize}; +} + napi_value CloudFileCacheNapi::StartBatchFileCache(napi_env env, napi_callback_info info) { NFuncArg funcArg(env, info); if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::TWO)) { LOGE("Start Number of arguments unmatched"); - NError(E_PARAMS).ThrowErr(env); + NError(EINVAL).ThrowErr(env); return nullptr; } - auto fileUris = std::make_shared(); - auto [resGetUris, uriArray, ignore] = NVal(env, funcArg[NARG_POS::FIRST]).ToStringArray(); - if (!resGetUris) { - LOGE("Start get uri array parameter failed!"); - NError(E_PARAMS).ThrowErr(env); + auto [ret, fileCache, maxArgSize] = FillParamForBatchStart(env, funcArg); + if (ret != E_OK) { + NError(ret).ThrowErr(env); return nullptr; } - fileUris->uriList = uriArray; - auto cbExec = [fileUris]() -> NError { - int32_t ret = CloudSyncManager::GetInstance().StartFileCache(fileUris->uriList, fileUris->downloadId); + auto cbExec = [fileCache{fileCache}]() -> NError { + if (fileCache == nullptr || fileCache->callbackImpl == nullptr) { + LOGE("Failed to get download callback"); + return NError(JsErrCode::E_INNER_FAILED); + } + int32_t ret = + fileCache->callbackImpl->StartDownloadInner(fileCache->uriList, fileCache->downloadId, fileCache->fieldKey); if (ret != E_OK) { - LOGE("Batch start file cache failed! ret = %{public}d", ret); - ret = (ret == E_CLOUD_SDK) ? E_UNKNOWN_ERR : ret; + ret = (ret == E_CLOUD_SDK) ? E_SERVICE_INNER_ERROR : ret; return NError(Convert2JsErrNum(ret)); } return NError(ERRNO_NOERR); }; - auto cbCompl = [fileUris](napi_env env, NError err) -> NVal { + auto cbCompl = [fileCache{fileCache}](napi_env env, NError err) -> NVal { if (err) { return {env, err.GetNapiErr(env)}; } - return NVal::CreateInt64(env, fileUris->downloadId); + return NVal::CreateInt64(env, fileCache->downloadId); }; string procedureName = "cloudFileCache"; - auto asyncWork = GetPromiseOrCallBackWork(env, funcArg, static_cast(NARG_CNT::TWO)); + auto asyncWork = GetPromiseOrCallBackWork(env, funcArg, maxArgSize); return asyncWork == nullptr ? nullptr : asyncWork->Schedule(procedureName, cbExec, cbCompl).val_; } @@ -386,37 +430,31 @@ napi_value CloudFileCacheNapi::StopBatchFileCache(napi_env env, napi_callback_in NFuncArg funcArg(env, info); if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::THREE)) { LOGE("Start Number of arguments unmatched"); - NError(E_PARAMS).ThrowErr(env); + NError(EINVAL).ThrowErr(env); return nullptr; } auto [succ, downloadId] = NVal(env, funcArg[NARG_POS::FIRST]).ToInt64(); if (!succ || downloadId <= 0) { - LOGE("Start get download ID parameter failed!"); - NError(E_PARAMS).ThrowErr(env); + LOGE("Start get taskId parameter failed!"); + NError(EINVAL).ThrowErr(env); return nullptr; } - bool needClean = false; - size_t maxArgSize = static_cast(NARG_CNT::TWO); - if (funcArg.GetArgc() >= NARG_CNT::TWO) { - NVal option(env, funcArg[NARG_POS::SECOND]); - if (!option.TypeIs(napi_function)) { - tie(succ, needClean) = option.ToBool(); - if (!succ) { - LOGE("Failed to get clean flag!"); - NError(E_PARAMS).ThrowErr(env); - return nullptr; - } - maxArgSize = static_cast(NARG_CNT::THREE); - } + auto [ret, needClean, maxArgSize] = GetCleanFlagForStop(env, funcArg); + if (ret != E_OK) { + NError(ret).ThrowErr(env); + return nullptr; } - - auto cbExec = [downloadId = downloadId, needClean]() -> NError { - int32_t ret = CloudSyncManager::GetInstance().StopFileCache(downloadId, needClean); + auto callbackImpl = GetCallbackImpl(env, funcArg, MULTI_PROGRESS, false); + auto cbExec = [downloadId{downloadId}, needClean{needClean}, callbackImpl{callbackImpl}]() -> NError { + if (callbackImpl == nullptr) { + LOGE("Failed to get download callback"); + return NError(JsErrCode::E_INNER_FAILED); + } + int32_t ret = callbackImpl->StopDownloadInner(downloadId, needClean); if (ret != E_OK) { - LOGE("Batch stop file cache failed! ret = %{public}d", ret); - ret = (ret == E_CLOUD_SDK) ? E_UNKNOWN_ERR : ret; + ret = (ret == E_CLOUD_SDK) ? E_SERVICE_INNER_ERROR : ret; return NError(Convert2JsErrNum(ret)); } return NError(ERRNO_NOERR); @@ -434,55 +472,56 @@ napi_value CloudFileCacheNapi::StopBatchFileCache(napi_env env, napi_callback_in return asyncWork == nullptr ? nullptr : asyncWork->Schedule(procedureName, cbExec, cbCompl).val_; } +static std::tuple ParseEventFromParam(napi_env env, NFuncArg &funcArg) +{ + auto [succProgress, progress, size] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String(); + if (!succProgress || size == 0) { + LOGE("Off get progress failed!"); + NError(EINVAL).ThrowErr(env); + return {EINVAL, ""}; + } + string eventType(progress.get()); + if (eventType == "multiProgress") { + eventType = MULTI_PROGRESS; + } + if ((eventType != PROGRESS && eventType != MULTI_PROGRESS)) { + LOGE("Off get progress failed!"); + return {EINVAL, ""}; + } + return {E_OK, eventType}; +} + napi_value CloudFileCacheNapi::On(napi_env env, napi_callback_info info) { NFuncArg funcArg(env, info); if (!funcArg.InitArgs(NARG_CNT::TWO)) { LOGE("Batch-On Number of arguments unmatched"); - NError(E_PARAMS).ThrowErr(env); + NError(EINVAL).ThrowErr(env); return nullptr; } - auto [succProgress, progress, ignore] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String(); - string eventType(progress.get()); - if (!succProgress || (eventType != PROGRESS && eventType != MULTI_PROGRESS)) { - LOGE("Batch-On get progress failed!"); - NError(E_PARAMS).ThrowErr(env); + auto [ret, eventType] = ParseEventFromParam(env, funcArg); + if (ret != E_OK) { + LOGE("On get event type failed!"); + NError(ret).ThrowErr(env); return nullptr; } if (!NVal(env, funcArg[NARG_POS::SECOND]).TypeIs(napi_function)) { LOGE("Batch-On argument type mismatch"); - NError(E_PARAMS).ThrowErr(env); - return nullptr; - } - - auto fileCacheEntity = NClass::GetEntityOf(env, funcArg.GetThisVar()); - if (!fileCacheEntity) { - LOGE("Failed to get file cache entity."); - NError(E_PARAMS).ThrowErr(env); + NError(EINVAL).ThrowErr(env); return nullptr; } - auto arg = make_shared(); - arg->eventType = eventType; - if (eventType == PROGRESS) { - arg->callback = make_shared(env, NVal(env, funcArg[(int)NARG_POS::SECOND]).val_); - } else { - arg->callback = - make_shared(env, NVal(env, funcArg[(int)NARG_POS::SECOND]).val_, true); - } - - if (!fileCacheEntity->registerMgr.AddRegisterInfo(arg)) { - LOGE("Batch-On register callback fail, callback already exist"); - NError(E_PARAMS).ThrowErr(env); + auto callbackImpl = GetCallbackImpl(env, funcArg, eventType, true); + if (callbackImpl == nullptr) { + LOGE("Failed to init callback"); + NError(JsErrCode::E_INNER_FAILED).ThrowErr(env); return nullptr; } - - int32_t ret = CloudSyncManager::GetInstance().RegisterFileCacheCallback(arg->callback); - if (ret != E_OK) { - LOGE("Failed to register callback, error: %{public}d", ret); - (void)fileCacheEntity->registerMgr.RemoveRegisterInfo(eventType); - NError(Convert2JsErrNum(ret)).ThrowErr(env); + auto status = callbackImpl->RegisterCallback(funcArg[NARG_POS::SECOND]); + if (status != napi_ok) { + LOGE("Failed to register callback, status: %{public}d", status); + NError(JsErrCode::E_INNER_FAILED).ThrowErr(env); return nullptr; } @@ -494,46 +533,30 @@ napi_value CloudFileCacheNapi::Off(napi_env env, napi_callback_info info) NFuncArg funcArg(env, info); if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::TWO)) { LOGE("Off Number of arguments unmatched"); - NError(E_PARAMS).ThrowErr(env); - return nullptr; - } - auto [succProgress, progress, ignore] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String(); - string eventType(progress.get()); - if (!succProgress || (eventType != PROGRESS && eventType != MULTI_PROGRESS)) { - LOGE("Batch-Off get progress failed!"); - NError(E_PARAMS).ThrowErr(env); - return nullptr; - } - - if (funcArg.GetArgc() == (uint)NARG_CNT::TWO && !NVal(env, funcArg[NARG_POS::SECOND]).TypeIs(napi_function)) { - LOGE("Batch-Off argument type mismatch"); - NError(E_PARAMS).ThrowErr(env); - return nullptr; - } - - auto fileCacheEntity = NClass::GetEntityOf(env, funcArg.GetThisVar()); - if (!fileCacheEntity) { - LOGE("Failed to get file cache entity."); - NError(E_PARAMS).ThrowErr(env); + NError(EINVAL).ThrowErr(env); return nullptr; } - - if (!fileCacheEntity->registerMgr.HasEvent(eventType)) { - LOGE("Batch-Off no callback is registered for this event type: %{public}s.", eventType.c_str()); - NError(E_PARAMS).ThrowErr(env); + auto [ret, eventType] = ParseEventFromParam(env, funcArg); + if (ret != E_OK) { + LOGE("Off get event type failed!"); + NError(ret).ThrowErr(env); return nullptr; } - int32_t ret = CloudSyncManager::GetInstance().UnregisterFileCacheCallback(); - if (ret != E_OK) { - LOGE("Failed to unregister callback, error: %{public}d", ret); - NError(Convert2JsErrNum(ret)).ThrowErr(env); - return nullptr; + napi_value callbackVel = nullptr; + if (funcArg.GetArgc() == (uint)NARG_CNT::TWO) { + if (!NVal(env, funcArg[NARG_POS::SECOND]).TypeIs(napi_function)) { + LOGE("Off argument type mismatch"); + NError(EINVAL).ThrowErr(env); + return nullptr; + } + callbackVel = funcArg[NARG_POS::SECOND]; } - if (!fileCacheEntity->registerMgr.RemoveRegisterInfo(eventType)) { - LOGE("Batch-Off no callback is registered for this event type: %{public}s.", eventType.c_str()); - NError(E_PARAMS).ThrowErr(env); + auto callbackImpl = GetCallbackImpl(env, funcArg, eventType, false); + if (callbackImpl == nullptr || callbackImpl->UnregisterCallback(callbackVel) != napi_ok) { + LOGE("Failed to unregister callback, for eventType: %{public}s.", eventType.c_str()); + NError(JsErrCode::E_INNER_FAILED).ThrowErr(env); return nullptr; } diff --git a/interfaces/kits/js/cloudfilesync/cloud_file_cache_napi.h b/interfaces/kits/js/cloudfilesync/cloud_file_cache_napi.h index c1b89de0f..847a0a66a 100644 --- a/interfaces/kits/js/cloudfilesync/cloud_file_cache_napi.h +++ b/interfaces/kits/js/cloudfilesync/cloud_file_cache_napi.h @@ -17,15 +17,16 @@ #define OHOS_FILEMGMT_CLOUD_FILE_CACHE_NAPI_H #include -#include +#include +#include -#include "cloud_file_napi.h" #include "download_callback_middle_napi.h" #include "download_progress_napi.h" +#include "filemgmt_libn.h" namespace OHOS::FileManagement::CloudSync { const std::string PROGRESS = "progress"; -const std::string MULTI_PROGRESS = "multiProgress"; +const std::string MULTI_PROGRESS = "batchDownload"; class CloudFileCacheNapi final : public LibN::NExporter { public: CloudFileCacheNapi(napi_env env, napi_value exports) : NExporter(env, exports) {} @@ -47,30 +48,6 @@ public: private: inline static std::string className_ = "CloudFileCache"; }; -struct RegisterInfoArg { - std::string eventType; - std::shared_ptr callback; - ~RegisterInfoArg() - { - if (callback != nullptr) { - callback->DeleteReference(); - callback = nullptr; - } - } -}; - -class RegisterManager { -public: - RegisterManager() = default; - ~RegisterManager() = default; - bool AddRegisterInfo(std::shared_ptr info); - bool RemoveRegisterInfo(const std::string &eventType); - bool HasEvent(const std::string &eventType); - -private: - std::mutex registerMutex_; - std::unordered_set> registerInfo_; -}; class CloudFileCacheCallbackImplNapi : public CloudDlCallbackMiddleNapi { public: @@ -82,7 +59,7 @@ public: }; struct FileCacheEntity { - RegisterManager registerMgr; + std::unordered_map> registerMap; }; } // namespace OHOS::FileManagement::CloudSync -#endif // OHOS_FILEMGMT_CLOUD_FILE_DOWNLOAD_NAPI_H \ No newline at end of file +#endif // OHOS_FILEMGMT_CLOUD_FILE_CACHE_NAPI_H \ No newline at end of file diff --git a/interfaces/kits/js/cloudfilesync/cloud_file_core.cpp b/interfaces/kits/js/cloudfilesync/cloud_file_core.cpp index ff5e92b66..87f8f500a 100644 --- a/interfaces/kits/js/cloudfilesync/cloud_file_core.cpp +++ b/interfaces/kits/js/cloudfilesync/cloud_file_core.cpp @@ -15,6 +15,7 @@ #include "cloud_file_core.h" +#include #include #include "cloud_sync_manager.h" @@ -23,27 +24,28 @@ namespace OHOS::FileManagement::CloudSync { using namespace std; -const int32_t E_PARAMS = 401; FsResult CloudFileCore::Constructor() { - CloudFileCore *cloudfile = new CloudFileCore(); - if (cloudfile == nullptr) { - LOGE("Failed to create CloudFileCore object on heap."); - return FsResult::Error(ENOMEM); - } - - return FsResult::Success(move(cloudfile)); + std::unique_ptr cloudfile = std::make_unique(); + return FsResult::Success(cloudfile.release()); } -CloudFileCore::CloudFileCore() {} +std::shared_ptr CloudFileCore::GetCallbackImpl(bool isInit) +{ + if (callback_ == nullptr && isInit) { + callback_ = std::make_shared(); + } + return callback_; +} FsResult CloudFileCore::DoStart(const string &uri) { LOGI("Start begin"); - int32_t ret = CloudSyncManager::GetInstance().StartDownloadFile(uri); + auto callbackImpl = GetCallbackImpl(true); + int32_t ret = callbackImpl->StartDownloadInner(uri); if (ret != E_OK) { - LOGE("Start Download failed! ret = %{public}d", ret); + LOGE("Stop Download failed! ret = %{public}d", ret); return FsResult::Error(Convert2ErrNum(ret)); } @@ -51,58 +53,26 @@ FsResult CloudFileCore::DoStart(const string &uri) return FsResult::Success(); } -FsResult CloudFileCore::DoOn(const string &event, const shared_ptr callback) +FsResult CloudFileCore::DoOn(const string &event, const shared_ptr callback) { - LOGI("On begin"); - if (event != "progress") { - LOGE("On get progress failed!"); - return FsResult::Error(E_PARAMS); - } - - if (callback_ != nullptr) { - LOGI("callback already exist"); - return FsResult::Success(); - } - - callback_ = callback; - int32_t ret = CloudSyncManager::GetInstance().RegisterDownloadFileCallback(callback_); - if (ret != E_OK) { - LOGE("RegisterDownloadFileCallback error, ret: %{public}d", ret); - return FsResult::Error(Convert2ErrNum(ret)); - } - return FsResult::Success(); } -FsResult CloudFileCore::DoOff( - const string &event, const optional> &callback) +FsResult CloudFileCore::DoOff(const string &event, + const optional> &callback) { - LOGI("Off begin"); - if (event != "progress") { - LOGE("Off get progress failed!"); - return FsResult::Error(E_PARAMS); - } - - /* callback_ may be nullptr */ - int32_t ret = CloudSyncManager::GetInstance().UnregisterDownloadFileCallback(); - if (ret != E_OK) { - LOGE("UnregisterDownloadFileCallback error, ret: %{public}d", ret); - return FsResult::Error(Convert2ErrNum(ret)); - } - - if (callback_ != nullptr) { - /* delete callback */ - callback_->DeleteReference(); - callback_ = nullptr; - } - return FsResult::Success(); } FsResult CloudFileCore::DoStop(const string &uri, bool needClean) { LOGI("Stop begin"); - int32_t ret = CloudSyncManager::GetInstance().StopDownloadFile(uri, needClean); + auto callbackImpl = GetCallbackImpl(false); + if (callbackImpl == nullptr) { + LOGE("Failed to stop download, callback is null!"); + return FsResult::Error(E_INVAL_ARG); + } + int32_t ret = callbackImpl->StopDownloadInner(uri); if (ret != E_OK) { LOGE("Stop Download failed! ret = %{public}d", ret); return FsResult::Error(Convert2ErrNum(ret)); diff --git a/interfaces/kits/js/cloudfilesync/cloud_file_core.h b/interfaces/kits/js/cloudfilesync/cloud_file_core.h index 5e87dc83b..771de3217 100644 --- a/interfaces/kits/js/cloudfilesync/cloud_file_core.h +++ b/interfaces/kits/js/cloudfilesync/cloud_file_core.h @@ -18,7 +18,7 @@ #include -#include "cloud_download_callback_ani.h" +#include "download_callback_impl_ani.h" #include "filemgmt_libfs.h" namespace OHOS::FileManagement::CloudSync { @@ -26,18 +26,19 @@ using namespace ModuleFileIO; class CloudFileCore { public: - CloudFileCore(); + CloudFileCore() = default; ~CloudFileCore() = default; static FsResult Constructor(); FsResult DoStart(const std::string &uri); - FsResult DoOn(const std::string &event, const std::shared_ptr callback); + FsResult DoOn(const std::string &event, const std::shared_ptr callback); FsResult DoOff(const std::string &event, - const std::optional> &callback = std::nullopt); + const std::optional> &callback = std::nullopt); FsResult DoStop(const std::string &uri, bool needClean = false); + std::shared_ptr GetCallbackImpl(bool isInit); private: - std::shared_ptr callback_; + std::shared_ptr callback_; }; } // namespace OHOS::FileManagement::CloudSync #endif // OHOS_FILEMGMT_CLOUD_FILE_CORE_H \ No newline at end of file diff --git a/interfaces/kits/js/cloudfilesync/cloud_file_download_napi.cpp b/interfaces/kits/js/cloudfilesync/cloud_file_download_napi.cpp deleted file mode 100644 index be31b237b..000000000 --- a/interfaces/kits/js/cloudfilesync/cloud_file_download_napi.cpp +++ /dev/null @@ -1,39 +0,0 @@ -/* - * Copyright (c) 2023 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "cloud_file_download_napi.h" - -#include - -#include "cloud_sync_manager.h" -#include "dfs_error.h" -#include "utils_log.h" -#include "async_work.h" -#include "uv.h" - -namespace OHOS::FileManagement::CloudSync { -using namespace FileManagement::LibN; -using namespace std; - -bool CloudFileDownloadNapi::Export() -{ - SetClassName("Download"); - bool success = CloudFileNapi::Export(); - if (!success) { - return false; - } - return true; -} -} // namespace OHOS::FileManagement::CloudSync \ No newline at end of file diff --git a/interfaces/kits/js/cloudfilesync/cloud_file_download_napi.h b/interfaces/kits/js/cloudfilesync/cloud_file_download_napi.h deleted file mode 100644 index ea22a0070..000000000 --- a/interfaces/kits/js/cloudfilesync/cloud_file_download_napi.h +++ /dev/null @@ -1,30 +0,0 @@ -/* - * Copyright (c) 2023 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef OHOS_FILEMGMT_CLOUD_FILE_DOWNLOAD_NAPI_H -#define OHOS_FILEMGMT_CLOUD_FILE_DOWNLOAD_NAPI_H - -#include "cloud_file_napi.h" - -namespace OHOS::FileManagement::CloudSync { -class CloudFileDownloadNapi final : public CloudFileNapi { -public: - CloudFileDownloadNapi(napi_env env, napi_value exports) : CloudFileNapi(env, exports) {} - ~CloudFileDownloadNapi() = default; - - bool Export() override; -}; -} // namespace OHOS::FileManagement::CloudSync -#endif // OHOS_FILEMGMT_CLOUD_FILE_DOWNLOAD_NAPI_H \ No newline at end of file diff --git a/interfaces/kits/js/cloudfilesync/cloud_file_napi.cpp b/interfaces/kits/js/cloudfilesync/cloud_file_napi.cpp index a100ceae8..ec71850de 100644 --- a/interfaces/kits/js/cloudfilesync/cloud_file_napi.cpp +++ b/interfaces/kits/js/cloudfilesync/cloud_file_napi.cpp @@ -13,32 +13,34 @@ * limitations under the License. */ -#include "cloud_file_download_napi.h" +#include "cloud_file_napi.h" +#include +#include #include #include "async_work.h" -#include "cloud_file_napi.h" #include "cloud_sync_manager.h" #include "dfs_error.h" +#include "dfsu_access_token_helper.h" +#include "filemgmt_libn.h" +#include "n_napi.h" #include "utils_log.h" -#include "uv.h" namespace OHOS::FileManagement::CloudSync { using namespace FileManagement::LibN; using namespace std; -const int32_t ARGS_ONE = 1; int32_t CloudDownloadCallbackImplNapi::StartDownloadInner(const std::string &uri) { int64_t downloadId = 0; std::lock_guard lock(downloadInfoMtx_); - int32_t ret = 0; + int32_t ret = CloudSyncManager::GetInstance().StartDownloadFile(uri, shared_from_this(), downloadId); if (ret != E_OK) { LOGE("Start batch download failed! ret = %{public}d", ret); return ret; } - downloadInfos_.insert(std::make_pair(downloadId, std::make_shared(downloadId))); + downloadInfos_[downloadId] = std::make_shared(downloadId); return ret; } @@ -49,7 +51,7 @@ int32_t CloudDownloadCallbackImplNapi::StopDownloadInner(const std::string &uri) int32_t resErr = E_OK; LOGI("Stop Download downloadId list size: %{public}zu", downloadIdList.size()); for (auto taskId : downloadIdList) { - LOGI("Stop Download downloadId: %{public}lld", static_cast(taskId)); + resErr = CloudSyncManager::GetInstance().StopDownloadFile(taskId, true); if (resErr != E_OK) { ret = resErr; continue; @@ -61,21 +63,40 @@ int32_t CloudDownloadCallbackImplNapi::StopDownloadInner(const std::string &uri) return ret; } -napi_value CloudFileNapi::Constructor(napi_env env, napi_callback_info info) +napi_value CloudFileDownloadNapi::Constructor(napi_env env, napi_callback_info info) { - LOGI("CloudFileNapi::Constructor begin"); + LOGI("CloudFileDownloadNapi::Constructor begin"); NFuncArg funcArg(env, info); if (!funcArg.InitArgs(NARG_CNT::ZERO)) { LOGE("Start Number of arguments unmatched"); - NError(E_PARAMS).ThrowErr(env); + NError(JsErrCode::E_IPCSS).ThrowErr(env); return nullptr; } - isDownloadCallbackRegistered_ = false; - LOGI("CloudFileNapi::Constructor end"); + auto downloadEntity = make_unique(); + if (!NClass::SetEntityFor(env, funcArg.GetThisVar(), move(downloadEntity))) { + LOGE("Failed to set download entity."); + NError(JsErrCode::E_IPCSS).ThrowErr(env); + return nullptr; + } + LOGI("CloudFileDownloadNapi::Constructor end"); return funcArg.GetThisVar(); } -napi_value CloudFileNapi::Start(napi_env env, napi_callback_info info) +static std::shared_ptr GetCallbackImpl(napi_env env, NFuncArg &funcArg, bool isInit) +{ + auto downloadEntity = NClass::GetEntityOf(env, funcArg.GetThisVar()); + if (!downloadEntity) { + LOGE("Failed to get file cache entity."); + return nullptr; + } + + if (downloadEntity->callbackImpl == nullptr && isInit) { + downloadEntity->callbackImpl = std::make_shared(env); + } + return downloadEntity->callbackImpl; +} + +napi_value CloudFileDownloadNapi::Start(napi_env env, napi_callback_info info) { LOGI("Start begin"); NFuncArg funcArg(env, info); @@ -84,25 +105,20 @@ napi_value CloudFileNapi::Start(napi_env env, napi_callback_info info) NError(E_PARAMS).ThrowErr(env); return nullptr; } - auto [succUri, uri, ignore] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String(); - if (!succUri) { + auto [succUri, uri, size] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String(); + if (!succUri || size == 0) { LOGE("Start get uri parameter failed!"); NError(E_PARAMS).ThrowErr(env); return nullptr; } - auto cbExec = [uri = string(uri.get()), env = env]() -> NError { - lock_guard lock(mtx_); - if (callback_ != nullptr && !isDownloadCallbackRegistered_) { - int32_t ret = CloudSyncManager::GetInstance().RegisterDownloadFileCallback(callback_); - if (ret != E_OK) { - LOGE("RegisterDownloadFileCallback error, ret: %{public}d", ret); - return NError(Convert2JsErrNum(ret)); - } - isDownloadCallbackRegistered_ = true; + auto callbackImpl = GetCallbackImpl(env, funcArg, true); + auto cbExec = [uri{string(uri.get())}, callbackImpl{callbackImpl}]() -> NError { + if (callbackImpl == nullptr) { + LOGE("Failed to get download callback"); + return NError(E_PARAMS); } - - int32_t ret = CloudSyncManager::GetInstance().StartDownloadFile(uri); + int32_t ret = callbackImpl->StartDownloadInner(uri); if (ret != E_OK) { LOGE("Start Download failed! ret = %{public}d", ret); return NError(Convert2JsErrNum(ret)); @@ -123,96 +139,20 @@ napi_value CloudFileNapi::Start(napi_env env, napi_callback_info info) return asyncWork == nullptr ? nullptr : asyncWork->Schedule(procedureName, cbExec, cbCompl).val_; } -CloudDownloadCallbackImpl::CloudDownloadCallbackImpl(napi_env env, napi_value fun, bool isBatch) : env_(env) -{ - if (fun != nullptr) { - napi_create_reference(env_, fun, 1, &cbOnRef_); - } - isBatch_ = isBatch; -} - -void CloudDownloadCallbackImpl::OnComplete(UvChangeMsg *msg) -{ - auto downloadcCallback = msg->CloudDownloadCallback_.lock(); - if (downloadcCallback == nullptr || downloadcCallback->cbOnRef_ == nullptr) { - LOGE("downloadcCallback->cbOnRef_ is nullptr"); - return; - } - auto env = downloadcCallback->env_; - auto ref = downloadcCallback->cbOnRef_; - napi_handle_scope scope = nullptr; - napi_open_handle_scope(env, &scope); - napi_value jsCallback = nullptr; - napi_status status = napi_get_reference_value(env, ref, &jsCallback); - if (status != napi_ok) { - LOGE("Create reference failed, status: %{public}d", status); - napi_close_handle_scope(env, scope); - return; - } - NVal obj = NVal::CreateObject(env); - if (!msg->isBatch_) { - obj.AddProp("state", NVal::CreateInt32(env, (int32_t)msg->downloadProgress_.state).val_); - obj.AddProp("processed", NVal::CreateInt64(env, msg->downloadProgress_.downloadedSize).val_); - obj.AddProp("size", NVal::CreateInt64(env, msg->downloadProgress_.totalSize).val_); - obj.AddProp("uri", NVal::CreateUTF8String(env, msg->downloadProgress_.path).val_); - } else { - LOGI("Batch download callback items"); - obj.AddProp("state", NVal::CreateInt32(env, (int32_t)msg->downloadProgress_.batchState).val_); - obj.AddProp("downloadedSize", NVal::CreateInt64(env, msg->downloadProgress_.batchDownloadSize).val_); - obj.AddProp("totalSize", NVal::CreateInt64(env, msg->downloadProgress_.batchTotalSize).val_); - obj.AddProp("successfulNum", NVal::CreateInt64(env, msg->downloadProgress_.batchSuccNum).val_); - obj.AddProp("failedNum", NVal::CreateInt64(env, msg->downloadProgress_.batchFailNum).val_); - obj.AddProp("totalNum", NVal::CreateInt64(env, msg->downloadProgress_.batchTotalNum).val_); - } - obj.AddProp("taskId", NVal::CreateInt64(env, msg->downloadProgress_.downloadId).val_); - obj.AddProp("error", NVal::CreateInt32(env, (int32_t)msg->downloadProgress_.downloadErrorType).val_); - - LOGI("OnComplete callback start for taskId: %{public}lld", - static_cast(msg->downloadProgress_.downloadId)); - napi_value retVal = nullptr; - napi_value global = nullptr; - napi_get_global(env, &global); - status = napi_call_function(env, global, jsCallback, ARGS_ONE, &(obj.val_), &retVal); - if (status != napi_ok) { - LOGE("napi call function failed, status: %{public}d", status); - } - napi_close_handle_scope(env, scope); -} - -void CloudDownloadCallbackImpl::OnDownloadProcess(const DownloadProgressObj &progress) +static int32_t CheckPermissions(const string &permission, bool isSystemApp) { - UvChangeMsg *msg = new (std::nothrow) UvChangeMsg(shared_from_this(), progress, isBatch_); - if (msg == nullptr) { - LOGE("Failed to create uv message object"); - return; - } - auto task = [msg]() { - if (msg->CloudDownloadCallback_.expired()) { - LOGE("CloudDownloadCallback_ is expired"); - delete msg; - return; - } - msg->CloudDownloadCallback_.lock()->OnComplete(msg); - delete msg; - }; - napi_status ret = napi_send_event(env_, task, napi_event_priority::napi_eprio_immediate); - if (ret != napi_ok) { - LOGE("Failed to execute libuv work queue, ret: %{public}d", ret); - delete msg; - return; + if (!permission.empty() && !DfsuAccessTokenHelper::CheckCallerPermission(permission)) { + LOGE("permission denied"); + return JsErrCode::E_PERMISSION; } -} - -void CloudDownloadCallbackImpl::DeleteReference() -{ - if (cbOnRef_ != nullptr) { - napi_delete_reference(env_, cbOnRef_); - cbOnRef_ = nullptr; - return; + if (isSystemApp && !DfsuAccessTokenHelper::IsSystemApp()) { + LOGE("caller hap is not system hap"); + return JsErrCode::E_PERMISSION_SYS; } + return E_OK; } -napi_value CloudFileNapi::On(napi_env env, napi_callback_info info) +napi_value CloudFileDownloadNapi::On(napi_env env, napi_callback_info info) { LOGI("On begin"); NFuncArg funcArg(env, info); @@ -221,6 +161,12 @@ napi_value CloudFileNapi::On(napi_env env, napi_callback_info info) NError(E_PARAMS).ThrowErr(env); return nullptr; } + int32_t ret = CheckPermissions(PERM_CLOUD_SYNC, true); + if (ret != E_OK) { + LOGE("On get progress failed!"); + NError(ret).ThrowErr(env); + return nullptr; + } auto [succProgress, progress, ignore] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String(); if (!succProgress || std::string(progress.get()) != "progress") { LOGE("On get progress failed!"); @@ -233,18 +179,18 @@ napi_value CloudFileNapi::On(napi_env env, napi_callback_info info) NError(E_PARAMS).ThrowErr(env); return nullptr; } - - if (callback_ != nullptr) { - LOGI("callback already exist"); - return NVal::CreateUndefined(env).val_; + auto callbackImpl = GetCallbackImpl(env, funcArg, true); + ret = callbackImpl->RegisterCallback(funcArg[NARG_POS::SECOND]); + if (ret != napi_ok) { + LOGE("On register callback fail, ret: %{public}d", ret); + NError(JsErrCode::E_IPCSS).ThrowErr(env); + return nullptr; } - callback_ = make_shared(env, NVal(env, funcArg[(int)NARG_POS::SECOND]).val_); - return NVal::CreateUndefined(env).val_; } -napi_value CloudFileNapi::Off(napi_env env, napi_callback_info info) +napi_value CloudFileDownloadNapi::Off(napi_env env, napi_callback_info info) { LOGI("Off begin"); NFuncArg funcArg(env, info); @@ -253,6 +199,12 @@ napi_value CloudFileNapi::Off(napi_env env, napi_callback_info info) NError(E_PARAMS).ThrowErr(env); return nullptr; } + int32_t ret = CheckPermissions(PERM_CLOUD_SYNC, true); + if (ret != E_OK) { + LOGE("On get progress failed!"); + NError(ret).ThrowErr(env); + return nullptr; + } auto [succProgress, progress, ignore] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String(); if (!succProgress || std::string(progress.get()) != "progress") { LOGE("Off get progress failed!"); @@ -260,62 +212,53 @@ napi_value CloudFileNapi::Off(napi_env env, napi_callback_info info) return nullptr; } - if (funcArg.GetArgc() == (uint)NARG_CNT::TWO && !NVal(env, funcArg[NARG_POS::SECOND]).TypeIs(napi_function)) { - LOGE("Argument type mismatch"); - NError(E_PARAMS).ThrowErr(env); - return nullptr; + napi_value callbackVel = nullptr; + if (funcArg.GetArgc() == (uint)NARG_CNT::TWO) { + if (!NVal(env, funcArg[NARG_POS::SECOND]).TypeIs(napi_function)) { + LOGE("Off argument type mismatch"); + NError(E_PARAMS).ThrowErr(env); + return nullptr; + } + callbackVel = funcArg[NARG_POS::SECOND]; } - /* callback_ may be nullptr */ - int32_t ret = CloudSyncManager::GetInstance().UnregisterDownloadFileCallback(); - if (ret != E_OK) { - LOGE("UnregisterDownloadFileCallback error, ret: %{public}d", ret); - NError(Convert2JsErrNum(ret)).ThrowErr(env); + auto callbackImpl = GetCallbackImpl(env, funcArg, false); + if (callbackImpl == nullptr || callbackImpl->UnregisterCallback(callbackVel) != napi_ok) { + LOGE("Off no callback is registered for this event type"); + NError(JsErrCode::E_IPCSS).ThrowErr(env); return nullptr; } - if (callback_ != nullptr) { - /* napi delete reference */ - callback_->DeleteReference(); - callback_ = nullptr; - } return NVal::CreateUndefined(env).val_; } -napi_value CloudFileNapi::Stop(napi_env env, napi_callback_info info) +napi_value CloudFileDownloadNapi::Stop(napi_env env, napi_callback_info info) { LOGI("Stop begin"); NFuncArg funcArg(env, info); - if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::THREE)) { + if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::TWO)) { LOGE("Stop Number of arguments unmatched"); NError(E_PARAMS).ThrowErr(env); return nullptr; } - auto [succUri, uri, ignore] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String(); - if (!succUri) { + + auto [succUri, uri, size] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String(); + if (!succUri || size == 0) { LOGE("Stop get uri parameter failed!"); NError(E_PARAMS).ThrowErr(env); return nullptr; } - bool needClean = false; - size_t maxArgSize = static_cast(NARG_CNT::TWO); - if (funcArg.GetArgc() >= NARG_CNT::TWO) { - NVal ui(env, NVal(env, funcArg[(int)NARG_POS::SECOND]).val_); - if (ui.TypeIs(napi_boolean)) { - bool needCleanIgnore; - std::tie(needCleanIgnore, needClean) = NVal(env, funcArg[NARG_POS::SECOND]).ToBool(); - maxArgSize = static_cast(NARG_CNT::THREE); + + auto callbackImpl = GetCallbackImpl(env, funcArg, false); + auto cbExec = [uri{string(uri.get())}, callbackImpl{callbackImpl}]() -> NError { + if (callbackImpl == nullptr) { + LOGE("Failed to get download callback"); + return NError(E_PARAMS); } - } - if (funcArg.GetArgc() == NARG_CNT::THREE) { - maxArgSize = static_cast(NARG_CNT::THREE); - } - auto cbExec = [uri = string(uri.get()), env = env, needClean]() -> NError { - int32_t ret = CloudSyncManager::GetInstance().StopDownloadFile(uri, needClean); + int32_t ret = callbackImpl->StopDownloadInner(uri); if (ret != E_OK) { LOGE("Stop Download failed! ret = %{public}d", ret); return NError(Convert2JsErrNum(ret)); } - LOGI("Stop Download Success!"); return NError(ERRNO_NOERR); }; @@ -327,24 +270,23 @@ napi_value CloudFileNapi::Stop(napi_env env, napi_callback_info info) }; string procedureName = "cloudFileDownload"; - auto asyncWork = GetPromiseOrCallBackWork(env, funcArg, maxArgSize); + auto asyncWork = GetPromiseOrCallBackWork(env, funcArg, static_cast(NARG_CNT::TWO)); return asyncWork == nullptr ? nullptr : asyncWork->Schedule(procedureName, cbExec, cbCompl).val_; } -bool CloudFileNapi::ToExport(std::vector props) +bool CloudFileDownloadNapi::ToExport(std::vector props) { std::string className = GetClassName(); - auto [succ, classValue] = - NClass::DefineClass(exports_.env_, className, Constructor, std::move(props)); + auto [succ, classValue] = NClass::DefineClass(exports_.env_, className, Constructor, std::move(props)); if (!succ) { - NError(E_GETRESULT).ThrowErr(exports_.env_); + NError(JsErrCode::E_IPCSS).ThrowErr(exports_.env_); LOGE("Failed to define GallerySync class"); return false; } succ = NClass::SaveClass(exports_.env_, className, classValue); if (!succ) { - NError(E_GETRESULT).ThrowErr(exports_.env_); + NError(JsErrCode::E_IPCSS).ThrowErr(exports_.env_); LOGE("Failed to save GallerySync class"); return false; } @@ -352,23 +294,23 @@ bool CloudFileNapi::ToExport(std::vector props) return exports_.AddProp(className, classValue); } -bool CloudFileNapi::Export() +bool CloudFileDownloadNapi::Export() { vector props = { - NVal::DeclareNapiFunction("start", CloudFileNapi::Start), - NVal::DeclareNapiFunction("on", CloudFileNapi::On), - NVal::DeclareNapiFunction("off", CloudFileNapi::Off), - NVal::DeclareNapiFunction("stop", CloudFileNapi::Stop), + NVal::DeclareNapiFunction("start", CloudFileDownloadNapi::Start), + NVal::DeclareNapiFunction("on", CloudFileDownloadNapi::On), + NVal::DeclareNapiFunction("off", CloudFileDownloadNapi::Off), + NVal::DeclareNapiFunction("stop", CloudFileDownloadNapi::Stop), }; return ToExport(props); } -void CloudFileNapi::SetClassName(std::string classname) +void CloudFileDownloadNapi::SetClassName(std::string classname) { className_ = classname; } -string CloudFileNapi::GetClassName() +string CloudFileDownloadNapi::GetClassName() { return className_; } diff --git a/interfaces/kits/js/cloudfilesync/cloud_file_napi.h b/interfaces/kits/js/cloudfilesync/cloud_file_napi.h index 54e2e1fbc..8a7b5a954 100644 --- a/interfaces/kits/js/cloudfilesync/cloud_file_napi.h +++ b/interfaces/kits/js/cloudfilesync/cloud_file_napi.h @@ -18,17 +18,15 @@ #include -#include "cloud_download_callback.h" #include "download_callback_middle_napi.h" #include "download_progress_napi.h" #include "filemgmt_libn.h" namespace OHOS::FileManagement::CloudSync { -class CloudDownloadCallbackImpl; -class CloudFileNapi : public LibN::NExporter { +class CloudFileDownloadNapi : public LibN::NExporter { public: - CloudFileNapi(napi_env env, napi_value exports) : NExporter(env, exports) {} - ~CloudFileNapi() = default; + CloudFileDownloadNapi(napi_env env, napi_value exports) : NExporter(env, exports) {} + ~CloudFileDownloadNapi() = default; bool Export() override; bool ToExport(std::vector props); @@ -41,39 +39,7 @@ public: static napi_value Stop(napi_env env, napi_callback_info info); private: - inline static std::mutex mtx_; - inline static bool isDownloadCallbackRegistered_; - static inline std::shared_ptr callback_; - inline static std::string className_ = "CloudFileNapi"; -}; - -class CloudDownloadCallbackImpl : public CloudDownloadCallback, - public std::enable_shared_from_this { -public: - CloudDownloadCallbackImpl(napi_env env, napi_value fun, bool isBatch = false); - ~CloudDownloadCallbackImpl() = default; - void OnDownloadProcess(const DownloadProgressObj &progress) override; - void DeleteReference(); - - class UvChangeMsg { - public: - UvChangeMsg(std::shared_ptr CloudDownloadCallbackIn, - DownloadProgressObj downloadProgress, - bool isBatch) - : CloudDownloadCallback_(CloudDownloadCallbackIn), downloadProgress_(downloadProgress), isBatch_(isBatch) - { - } - ~UvChangeMsg() {} - std::weak_ptr CloudDownloadCallback_; - DownloadProgressObj downloadProgress_; - bool isBatch_; - }; - -private: - static void OnComplete(UvChangeMsg *msg); - napi_env env_; - napi_ref cbOnRef_ = nullptr; - bool isBatch_; + inline static std::string className_ = "Download"; }; class CloudDownloadCallbackImplNapi : public CloudDlCallbackMiddleNapi { @@ -82,5 +48,10 @@ public: int32_t StartDownloadInner(const std::string &uri); int32_t StopDownloadInner(const std::string &uri); }; + +struct DownloadEntity { + std::shared_ptr callbackImpl{nullptr}; +}; + } // namespace OHOS::FileManagement::CloudSync #endif // OHOS_FILEMGMT_CLOUD_FILE_NAPI_H \ No newline at end of file diff --git a/interfaces/kits/js/cloudfilesync/cloud_sync_n_exporter.cpp b/interfaces/kits/js/cloudfilesync/cloud_sync_n_exporter.cpp index 9af5f9933..e3cfc8cbd 100644 --- a/interfaces/kits/js/cloudfilesync/cloud_sync_n_exporter.cpp +++ b/interfaces/kits/js/cloudfilesync/cloud_sync_n_exporter.cpp @@ -15,7 +15,6 @@ #include "cloud_sync_n_exporter.h" #include "cloud_file_cache_napi.h" -#include "cloud_file_download_napi.h" #include "cloud_file_napi.h" #include "cloud_file_version_napi.h" #include "cloud_sync_napi.h" diff --git a/interfaces/kits/js/cloudfilesync/multi_download_progress_napi.cpp b/interfaces/kits/js/cloudfilesync/multi_download_progress_napi.cpp index 29abc4f4d..a2f907462 100644 --- a/interfaces/kits/js/cloudfilesync/multi_download_progress_napi.cpp +++ b/interfaces/kits/js/cloudfilesync/multi_download_progress_napi.cpp @@ -28,10 +28,6 @@ napi_value MultiDlProgressNapi::Constructor(napi_env env, napi_callback_info inf NFuncArg funcArg(env, info); funcArg.InitArgs(NARG_CNT::ZERO); auto progressEntity = make_unique(); - if (progressEntity == nullptr) { - LOGE("Failed to request heap memory."); - return nullptr; - } if (!NClass::SetEntityFor(env, funcArg.GetThisVar(), move(progressEntity))) { LOGE("Failed to set progressEntity."); return nullptr; diff --git a/services/cloudsyncservice/ICloudSyncService.idl b/services/cloudsyncservice/ICloudSyncService.idl index a29a38546..1ffd78972 100644 --- a/services/cloudsyncservice/ICloudSyncService.idl +++ b/services/cloudsyncservice/ICloudSyncService.idl @@ -45,16 +45,12 @@ interface OHOS.FileManagement.CloudSync.ICloudSyncService void NotifyEventChange([in] int userId, [in] String eventId, [in] String extraData); void EnableCloud([in] String accoutId, [in] SwitchDataObj switchData); void DisableCloud([in] String accoutId); - void StartDownloadFile([in] String path); - void StartFileCache([in] String[] pathVec, [out] long downloadId, [in] int fieldkey, [in] boolean isCallbackValid, + void StartDownloadFile([in] String uri, [in] IRemoteObject downloadCallback, [out] long downloadId); + void StartFileCache([in] String[] uriVec, [out] long downloadId, [in] int fieldkey, [in] IRemoteObject downloadCallback, [in] int timeout); - void StopDownloadFile([in] String path, [in] boolean needClean); + void StopDownloadFile([in] long downloadId, [in] boolean needClean); void StopFileCache([in] long downloadId, [in] boolean needClean, [in] int timeout); void DownloadThumb(); - void RegisterDownloadFileCallback([in] IRemoteObject downloadCallback); - void RegisterFileCacheCallback([in] IRemoteObject downloadCallback); - void UnregisterDownloadFileCallback(); - void UnregisterFileCacheCallback(); void UploadAsset([in] int userId, [in] String request, [out] String resultStr); void DownloadFile([in] int userId, [in] String bundleName, [in] AssetInfoObj assetInfoObj); void DownloadFiles([in] int userId, [in] String bundleName, [in] AssetInfoObj[] assetInfoObj, diff --git a/services/cloudsyncservice/include/ipc/cloud_sync_service.h b/services/cloudsyncservice/include/ipc/cloud_sync_service.h index 6642870c6..901236844 100644 --- a/services/cloudsyncservice/include/ipc/cloud_sync_service.h +++ b/services/cloudsyncservice/include/ipc/cloud_sync_service.h @@ -63,20 +63,17 @@ public: ErrCode NotifyEventChange(int32_t userId, const std::string &eventId, const std::string &extraData) override; ErrCode EnableCloud(const std::string &accoutId, const SwitchDataObj &switchData) override; ErrCode DisableCloud(const std::string &accoutId) override; - ErrCode StartDownloadFile(const std::string &path) override; + ErrCode StartDownloadFile(const std::string &uri, + const sptr &downloadCallback, + int64_t &downloadId) override; ErrCode StartFileCache(const std::vector &uriVec, int64_t &downloadId, int32_t fieldkey, - bool isCallbackValid, const sptr &downloadCallback, int32_t timeout = -1) override; - ErrCode StopDownloadFile(const std::string &path, bool needClean = false) override; + ErrCode StopDownloadFile(int64_t downloadId, bool needClean = false) override; ErrCode StopFileCache(int64_t downloadId, bool needClean = false, int32_t timeout = -1) override; ErrCode DownloadThumb() override; - ErrCode RegisterDownloadFileCallback(const sptr &downloadCallback) override; - ErrCode RegisterFileCacheCallback(const sptr &downloadCallback) override; - ErrCode UnregisterDownloadFileCallback() override; - ErrCode UnregisterFileCacheCallback() override; ErrCode UploadAsset(const int32_t userId, const std::string &request, std::string &result) override; ErrCode DownloadFile(const int32_t userId, const std::string &bundleName, const AssetInfoObj &assetInfoObj) override; diff --git a/services/cloudsyncservice/src/ipc/cloud_sync_service.cpp b/services/cloudsyncservice/src/ipc/cloud_sync_service.cpp index c853cec7f..fb377b113 100644 --- a/services/cloudsyncservice/src/ipc/cloud_sync_service.cpp +++ b/services/cloudsyncservice/src/ipc/cloud_sync_service.cpp @@ -800,7 +800,6 @@ int32_t CloudSyncService::Clean(const std::string &accountId, const CleanOptions int32_t CloudSyncService::StartFileCache(const std::vector &uriVec, int64_t &downloadId, int32_t fieldkey, - bool isCallbackValid, const sptr &downloadCallback, int32_t timeout) { @@ -820,16 +819,15 @@ int32_t CloudSyncService::StartFileCache(const std::vector &uriVec, return ret; } - sptr downloadCb = nullptr; - if (isCallbackValid) { - downloadCb = iface_cast(downloadCallback); - } + sptr downloadCb = iface_cast(downloadCallback); ret = dataSyncManager_->StartDownloadFile(bundleNameUserInfo, uriVec, downloadId, fieldkey, downloadCb, timeout); LOGI("End StartFileCache, ret: %{public}d", ret); return ret; } -int32_t CloudSyncService::StartDownloadFile(const std::string &path) +int32_t CloudSyncService::StartDownloadFile(const std::string &uri, + const sptr &downloadCallback, + int64_t &downloadId) { LOGI("Begin StartDownloadFile"); RETURN_ON_ERR(CheckPermissions(PERM_CLOUD_SYNC, true)); @@ -839,16 +837,14 @@ int32_t CloudSyncService::StartDownloadFile(const std::string &path) if (ret != E_OK) { return ret; } - std::vector pathVec; - pathVec.push_back(path); - int64_t downloadId = 0; - ret = dataSyncManager_->StartDownloadFile(bundleNameUserInfo, pathVec, downloadId, CloudSync::FIELDKEY_CONTENT, - nullptr); + sptr downloadCb = iface_cast(downloadCallback); + ret = dataSyncManager_->StartDownloadFile(bundleNameUserInfo, {uri}, downloadId, FieldKey::FIELDKEY_CONTENT, + downloadCb); LOGI("End StartDownloadFile"); return ret; } -int32_t CloudSyncService::StopDownloadFile(const std::string &path, bool needClean) +int32_t CloudSyncService::StopDownloadFile(int64_t downloadId, bool needClean) { LOGI("Begin StopDownloadFile"); RETURN_ON_ERR(CheckPermissions(PERM_CLOUD_SYNC, true)); @@ -859,7 +855,7 @@ int32_t CloudSyncService::StopDownloadFile(const std::string &path, bool needCle return ret; } - ret = dataSyncManager_->StopDownloadFile(bundleNameUserInfo, path, needClean); + ret = dataSyncManager_->StopDownloadFile(bundleNameUserInfo, downloadId, needClean); LOGI("End StopDownloadFile"); return ret; } @@ -875,7 +871,7 @@ int32_t CloudSyncService::StopFileCache(int64_t downloadId, bool needClean, int3 return ret; } - ret = dataSyncManager_->StopFileCache(bundleNameUserInfo, downloadId, needClean, timeout); + ret = dataSyncManager_->StopDownloadFile(bundleNameUserInfo, downloadId, needClean, timeout); LOGI("End StopFileCache, ret: %{public}d", ret); return ret; } @@ -890,66 +886,6 @@ int32_t CloudSyncService::DownloadThumb() return ret; } -int32_t CloudSyncService::RegisterDownloadFileCallback(const sptr &downloadCallback) -{ - LOGI("Begin RegisterDownloadFileCallback"); - RETURN_ON_ERR(CheckPermissions(PERM_CLOUD_SYNC, true)); - - BundleNameUserInfo bundleNameUserInfo; - int ret = GetBundleNameUserInfo(bundleNameUserInfo); - if (ret != E_OK) { - return ret; - } - auto downloadCb = iface_cast(downloadCallback); - ret = dataSyncManager_->RegisterDownloadFileCallback(bundleNameUserInfo, downloadCb); - LOGI("End RegisterDownloadFileCallback"); - return ret; -} - -int32_t CloudSyncService::RegisterFileCacheCallback(const sptr &downloadCallback) -{ - LOGI("Begin RegisterDownloadFileCallback"); - BundleNameUserInfo bundleNameUserInfo; - int ret = GetBundleNameUserInfo(bundleNameUserInfo); - if (ret != E_OK) { - return ret; - } - auto downloadCb = iface_cast(downloadCallback); - ret = dataSyncManager_->RegisterDownloadFileCallback(bundleNameUserInfo, downloadCb); - LOGI("End RegisterDownloadFileCallback"); - return ret; -} - -int32_t CloudSyncService::UnregisterDownloadFileCallback() -{ - LOGI("Begin UnregisterDownloadFileCallback"); - RETURN_ON_ERR(CheckPermissions(PERM_CLOUD_SYNC, true)); - - BundleNameUserInfo bundleNameUserInfo; - int ret = GetBundleNameUserInfo(bundleNameUserInfo); - if (ret != E_OK) { - return ret; - } - - ret = dataSyncManager_->UnregisterDownloadFileCallback(bundleNameUserInfo); - LOGI("End UnregisterDownloadFileCallback"); - return ret; -} - -int32_t CloudSyncService::UnregisterFileCacheCallback() -{ - LOGI("Begin UnregisterFileCacheCallback"); - BundleNameUserInfo bundleNameUserInfo; - int ret = GetBundleNameUserInfo(bundleNameUserInfo); - if (ret != E_OK) { - return ret; - } - - ret = dataSyncManager_->UnregisterDownloadFileCallback(bundleNameUserInfo); - LOGI("End UnregisterFileCacheCallback"); - return ret; -} - int32_t CloudSyncService::UploadAsset(const int32_t userId, const std::string &request, std::string &result) { LOGI("Begin UploadAsset"); diff --git a/test/fuzztest/cloudsyncmanager_fuzzer/cloudsyncmanager_fuzzer.cpp b/test/fuzztest/cloudsyncmanager_fuzzer/cloudsyncmanager_fuzzer.cpp index 8dade56f1..6b50c04f0 100644 --- a/test/fuzztest/cloudsyncmanager_fuzzer/cloudsyncmanager_fuzzer.cpp +++ b/test/fuzztest/cloudsyncmanager_fuzzer/cloudsyncmanager_fuzzer.cpp @@ -27,6 +27,7 @@ namespace OHOS { constexpr size_t U32_AT_SIZE = 4; +constexpr size_t U64_AT_SIZE = 8; constexpr size_t BOOL_AT_SIZE = 1; using namespace OHOS::FileManagement::CloudSync; @@ -122,30 +123,18 @@ void NotifyDataChangeFuzzTest(FuzzData &fuzzData, size_t size) void StartDownloadFileFuzzTest(FuzzData &fuzzData, size_t size) { fuzzData.ResetData(size); + int64_t downloadId = 0; string uri = fuzzData.GetStringFromData(static_cast(size)); - CloudSyncManager::GetInstance().StartDownloadFile(uri); -} - -void StartFileCacheFuzzTest(FuzzData &fuzzData, size_t size) -{ - fuzzData.ResetData(size); - string uri = fuzzData.GetStringFromData(static_cast(size)); - CloudSyncManager::GetInstance().StartFileCache(uri); + auto downloadCallback = make_shared(); + CloudSyncManager::GetInstance().StartDownloadFile(uri, downloadCallback, downloadId); } void StopDownloadFileFuzzTest(FuzzData &fuzzData, size_t size) { fuzzData.ResetData(size); bool needClean = fuzzData.GetData(); - string uri = fuzzData.GetStringFromData(static_cast(size - BOOL_AT_SIZE)); - CloudSyncManager::GetInstance().StopDownloadFile(uri, needClean); -} - -void RegisterDownloadFileCallbackFuzzTest(FuzzData &fuzzData, size_t size) -{ - auto downloadCallback = make_shared(); - CloudSyncManager::GetInstance().RegisterDownloadFileCallback(downloadCallback); - CloudSyncManager::GetInstance().UnregisterDownloadFileCallback(); + int64_t downloadId = fuzzData.GetData(); + CloudSyncManager::GetInstance().StopDownloadFile(downloadId, needClean); } void EnableCloudFuzzTest(FuzzData &fuzzData, size_t size) @@ -209,9 +198,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) OHOS::ChangeAppSwitchFuzzTest(fuzzData, size); OHOS::NotifyDataChangeFuzzTest(fuzzData, size); OHOS::StartDownloadFileFuzzTest(fuzzData, size); - OHOS::StartFileCacheFuzzTest(fuzzData, size); OHOS::StopDownloadFileFuzzTest(fuzzData, size); - OHOS::RegisterDownloadFileCallbackFuzzTest(fuzzData, size); OHOS::EnableCloudFuzzTest(fuzzData, size); OHOS::DisableCloudFuzzTest(fuzzData, size); OHOS::CleanFuzzTest(fuzzData, size); diff --git a/test/fuzztest/cloudsyncservicestub_fuzzer/cloudsyncservicestub_fuzzer.cpp b/test/fuzztest/cloudsyncservicestub_fuzzer/cloudsyncservicestub_fuzzer.cpp index 23b864abf..d1a74c7dc 100644 --- a/test/fuzztest/cloudsyncservicestub_fuzzer/cloudsyncservicestub_fuzzer.cpp +++ b/test/fuzztest/cloudsyncservicestub_fuzzer/cloudsyncservicestub_fuzzer.cpp @@ -292,30 +292,6 @@ void HandleRegisterCallbackInnerFuzzTest(std::shared_ptr c cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option); } -void HandleRegisterDownloadFileCallbackFuzzTest(std::shared_ptr cloudSyncServiceStubStr, - FuzzData &fuzzData, - size_t size) -{ - fuzzData.ResetData(size); - MessageParcel datas; - if (!WriteInterfaceToken(datas)) { - return; - } - sptr callback = new (std::nothrow) ICloudDownloadCallbackTest(); - if (callback == nullptr) { - return; - } - datas.WriteRemoteObject(callback->AsObject().GetRefPtr()); - datas.RewindRead(0); - // SERVICE_CMD_REGISTER_DOWNLOAD_FILE_CALLBACK - uint32_t code = - static_cast(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_REGISTER_DOWNLOAD_FILE_CALLBACK); - MessageParcel reply; - MessageOption option; - - cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option); -} - void HandleStartDownloadFileFuzzTest(std::shared_ptr cloudSyncServiceStubStr, FuzzData &fuzzData, size_t size) @@ -325,8 +301,13 @@ void HandleStartDownloadFileFuzzTest(std::shared_ptr cloud if (!WriteInterfaceToken(datas)) { return; } - string path = fuzzData.GetStringFromData(static_cast(size)); + int64_t downloadId = fuzzData.GetData(); + int len = static_cast(size - U64_AT_SIZE); + string path = fuzzData.GetStringFromData(len); datas.WriteString(path); + sptr callback = new (std::nothrow) ICloudDownloadCallbackTest(); + datas.WriteRemoteObject(callback->AsObject().GetRefPtr()); + datas.WriteInt64(downloadId); datas.RewindRead(0); // SERVICE_CMD_START_DOWNLOAD_FILE uint32_t code = static_cast(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_START_DOWNLOAD_FILE); @@ -367,8 +348,11 @@ void HandleStopDownloadFileFuzzTest(std::shared_ptr cloudS if (!WriteInterfaceToken(datas)) { return; } - string path = fuzzData.GetStringFromData(static_cast(size)); - datas.WriteString(path); + int64_t downloadId = fuzzData.GetData(); + int len = static_cast(size - U64_AT_SIZE); + bool needClean = fuzzData.GetData(); + datas.WriteInt64(downloadId); + datas.WriteBool(needClean); datas.RewindRead(0); // SERVICE_CMD_STOP_DOWNLOAD_FILE uint32_t code = static_cast(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_STOP_DOWNLOAD_FILE); @@ -416,25 +400,6 @@ void HandleUnRegisterCallbackInnerFuzzTest(std::shared_ptr cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option); } -void HandleUnRegisterDownloadFileCallbackFuzzTest(std::shared_ptr cloudSyncServiceStubStr, - const uint8_t *data, - size_t size) -{ - MessageParcel datas; - if (!WriteInterfaceToken(datas)) { - return; - } - datas.WriteBuffer(data, size); - datas.RewindRead(0); - // SERVICE_CMD_UNREGISTER_DOWNLOAD_FILE_CALLBACK - uint32_t code = - static_cast(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_UNREGISTER_DOWNLOAD_FILE_CALLBACK); - MessageParcel reply; - MessageOption option; - - cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option); -} - void HandleUploadAssetFuzzTest(std::shared_ptr cloudSyncServiceStubStr, FuzzData &fuzzData, size_t size) @@ -697,13 +662,11 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) OHOS::HandleEnableCloudFuzzTest(cloudSyncServiceStubStr, fuzzData, size); OHOS::HandleNotifyDataChangeFuzzTest(cloudSyncServiceStubStr, fuzzData, size); OHOS::HandleRegisterCallbackInnerFuzzTest(cloudSyncServiceStubStr, fuzzData, size); - OHOS::HandleRegisterDownloadFileCallbackFuzzTest(cloudSyncServiceStubStr, fuzzData, size); OHOS::HandleStartDownloadFileFuzzTest(cloudSyncServiceStubStr, fuzzData, size); OHOS::HandleStartSyncInnerFuzzTest(cloudSyncServiceStubStr, fuzzData, size); OHOS::HandleStopDownloadFileFuzzTest(cloudSyncServiceStubStr, fuzzData, size); OHOS::HandleStopSyncInnerFuzzTest(cloudSyncServiceStubStr, data, size); OHOS::HandleUnRegisterCallbackInnerFuzzTest(cloudSyncServiceStubStr, fuzzData, size); - OHOS::HandleUnRegisterDownloadFileCallbackFuzzTest(cloudSyncServiceStubStr, data, size); OHOS::HandleUploadAssetFuzzTest(cloudSyncServiceStubStr, fuzzData, size); OHOS::HandleTriggerSyncInnerFuzzTest(cloudSyncServiceStubStr, fuzzData, size); OHOS::HandleNotifyEventChangeFuzzTest(cloudSyncServiceStubStr, fuzzData, size); diff --git a/test/unittests/ani_core/BUILD.gn b/test/unittests/ani_core/BUILD.gn index 68fedd91c..8188e11a6 100644 --- a/test/unittests/ani_core/BUILD.gn +++ b/test/unittests/ani_core/BUILD.gn @@ -20,12 +20,17 @@ ohos_unittest("cloud_sync_core_test") { sources = [ "${interfaces_js_path}/ani/ani_helper/src/ani_utils.cpp", "${interfaces_js_path}/ani/ani_helper/src/error_handler.cpp", - "${interfaces_js_path}/ani/file_cloud_sync/src/cloud_download_callback_ani.cpp", "${interfaces_js_path}/ani/file_cloud_sync/src/cloud_sync_callback_ani.cpp", + "${interfaces_js_path}/ani/file_cloud_sync/src/download_callback_impl_ani.cpp", + "${interfaces_js_path}/ani/file_cloud_sync/src/download_callback_middle_ani.cpp", + "${interfaces_js_path}/ani/file_cloud_sync/src/download_progress_ani.cpp", + "${interfaces_js_path}/ani/file_cloud_sync/src/multi_download_progress_ani.cpp", + "${interfaces_js_path}/ani/file_cloud_sync/src/register_callback_manager_ani.cpp", "${interfaces_js_path}/cloudfilesync/cloud_file_cache_core.cpp", "${interfaces_js_path}/cloudfilesync/cloud_file_core.cpp", "${interfaces_js_path}/cloudfilesync/cloud_sync_core.cpp", "${interfaces_js_path}/cloudfilesync/file_sync_core.cpp", + "${interfaces_js_path}/cloudfilesync/multi_download_progress_core.cpp", "${interfaces_js_path}/cloudsyncmanager/cloud_sync_manager_core.cpp", "cloud_file_cache_core_test.cpp", "cloud_file_core_test.cpp", diff --git a/test/unittests/ani_core/cloud_file_cache_core_test.cpp b/test/unittests/ani_core/cloud_file_cache_core_test.cpp index dbfe6303f..8fba128ec 100644 --- a/test/unittests/ani_core/cloud_file_cache_core_test.cpp +++ b/test/unittests/ani_core/cloud_file_cache_core_test.cpp @@ -22,6 +22,7 @@ #include "cloud_sync_manager.h" #include "dfs_error.h" +#include "download_callback_impl_ani.h" #include "uri.h" #include "utils_log.h" @@ -78,7 +79,7 @@ HWTEST_F(CloudFileCacheCoreTest, ConstructorTest1, TestSize.Level1) HWTEST_F(CloudFileCacheCoreTest, DoOnTest1, TestSize.Level1) { CloudFileCacheCore *cloudFileCache = CloudFileCacheCore::Constructor().GetData().value(); - auto callback = std::make_shared(nullptr, nullptr); + auto callback = std::make_shared(); std::string event = "progress"; auto ret = cloudFileCache->DoOn(event, callback); EXPECT_TRUE(ret.IsSuccess()); @@ -88,86 +89,69 @@ HWTEST_F(CloudFileCacheCoreTest, DoOnTest1, TestSize.Level1) } /** - * @tc.name: DoOn - * @tc.desc: Verify the CloudFileCacheCore::DoOn function - * @tc.type: FUNC - */ -HWTEST_F(CloudFileCacheCoreTest, DoOnTest2, TestSize.Level1) -{ - CloudFileCacheCore *cloudFileCache = CloudFileCacheCore::Constructor().GetData().value(); - auto callback = std::make_shared(nullptr, nullptr); - std::string event = ""; - auto ret = cloudFileCache->DoOn(event, callback); - EXPECT_FALSE(ret.IsSuccess()); - const auto &err = ret.GetError(); - int errorCode = err.GetErrNo(); - EXPECT_EQ(errorCode, E_PARAMS); -} - -/** - * @tc.name: DoOn - * @tc.desc: Verify the CloudFileCacheCore::DoOn function + * @tc.name: DoOff + * @tc.desc: Verify the CloudFileCacheCore::DoOff function * @tc.type: FUNC */ -HWTEST_F(CloudFileCacheCoreTest, DoOnTest3, TestSize.Level1) +HWTEST_F(CloudFileCacheCoreTest, DoOffTest1, TestSize.Level1) { CloudFileCacheCore *cloudFileCache = CloudFileCacheCore::Constructor().GetData().value(); - auto callback = std::make_shared(nullptr, nullptr); std::string event = "progress"; - auto ret = cloudFileCache->DoOn(event, callback); - ret = cloudFileCache->DoOn(event, callback); - EXPECT_FALSE(ret.IsSuccess()); + auto ret = cloudFileCache->DoOff(event); + EXPECT_TRUE(ret.IsSuccess()); const auto &err = ret.GetError(); int errorCode = err.GetErrNo(); - EXPECT_EQ(errorCode, E_PARAMS); + EXPECT_EQ(errorCode, 0); } /** - * @tc.name: DoOff - * @tc.desc: Verify the CloudFileCacheCore::DoOff function + * @tc.name: DoStart + * @tc.desc: Verify the CloudFileCacheCore::DoStart function * @tc.type: FUNC */ -HWTEST_F(CloudFileCacheCoreTest, DoOffTest1, TestSize.Level1) +HWTEST_F(CloudFileCacheCoreTest, DoStartTest1, TestSize.Level1) { CloudFileCacheCore *cloudFileCache = CloudFileCacheCore::Constructor().GetData().value(); - std::string event = "progress"; - auto ret = cloudFileCache->DoOff(event); + std::string uri = "testuri"; + auto ret = cloudFileCache->DoStart(uri); EXPECT_FALSE(ret.IsSuccess()); const auto &err = ret.GetError(); int errorCode = err.GetErrNo(); - EXPECT_EQ(errorCode, E_PARAMS); + EXPECT_EQ(errorCode, OHOS::FileManagement::E_PERMISSION); } /** - * @tc.name: DoOff - * @tc.desc: Verify the CloudFileCacheCore::DoOff function + * @tc.name: DoStart + * @tc.desc: Verify the CloudFileCacheCore::DoStart function * @tc.type: FUNC */ -HWTEST_F(CloudFileCacheCoreTest, DoOffTest2, TestSize.Level1) +HWTEST_F(CloudFileCacheCoreTest, DoStartTest2, TestSize.Level1) { CloudFileCacheCore *cloudFileCache = CloudFileCacheCore::Constructor().GetData().value(); - std::string event = ""; - auto ret = cloudFileCache->DoOff(event); + std::string uri = "testuri"; + int32_t fieldKey = 0; + auto ret = cloudFileCache->DoStart({uri}, fieldKey); EXPECT_FALSE(ret.IsSuccess()); const auto &err = ret.GetError(); int errorCode = err.GetErrNo(); - EXPECT_EQ(errorCode, E_PARAMS); + EXPECT_EQ(errorCode, OHOS::FileManagement::E_PERMISSION); } /** - * @tc.name: DoStart - * @tc.desc: Verify the CloudFileCacheCore::DoStart function + * @tc.name: DoStop + * @tc.desc: Verify the CloudFileCacheCore::DoStop function * @tc.type: FUNC */ -HWTEST_F(CloudFileCacheCoreTest, DoStartTest1, TestSize.Level1) +HWTEST_F(CloudFileCacheCoreTest, DoStopTest1, TestSize.Level1) { CloudFileCacheCore *cloudFileCache = CloudFileCacheCore::Constructor().GetData().value(); std::string uri = "testuri"; - auto ret = cloudFileCache->DoStart(uri); + bool needClean = false; + auto ret = cloudFileCache->DoStop(uri, needClean); EXPECT_FALSE(ret.IsSuccess()); const auto &err = ret.GetError(); int errorCode = err.GetErrNo(); - EXPECT_EQ(errorCode, OHOS::FileManagement::E_PERMISSION); + EXPECT_EQ(errorCode, OHOS::FileManagement::FILEIO_SYS_CAP_TAG + E_INVAL_ARG); } /** @@ -175,15 +159,16 @@ HWTEST_F(CloudFileCacheCoreTest, DoStartTest1, TestSize.Level1) * @tc.desc: Verify the CloudFileCacheCore::DoStop function * @tc.type: FUNC */ -HWTEST_F(CloudFileCacheCoreTest, DoStopTest1, TestSize.Level1) +HWTEST_F(CloudFileCacheCoreTest, DoStopTest2, TestSize.Level1) { CloudFileCacheCore *cloudFileCache = CloudFileCacheCore::Constructor().GetData().value(); - std::string uri = "testuri"; - auto ret = cloudFileCache->DoStop(uri); + int64_t downloadId = 0; + bool needClean = false; + auto ret = cloudFileCache->DoStop(downloadId, needClean); EXPECT_FALSE(ret.IsSuccess()); const auto &err = ret.GetError(); int errorCode = err.GetErrNo(); - EXPECT_EQ(errorCode, OHOS::FileManagement::E_PERMISSION); + EXPECT_EQ(errorCode, OHOS::FileManagement::FILEIO_SYS_CAP_TAG + ModuleFileIo::E_INVAL); } /** diff --git a/test/unittests/ani_core/cloud_file_core_test.cpp b/test/unittests/ani_core/cloud_file_core_test.cpp index 875999620..2307564ad 100644 --- a/test/unittests/ani_core/cloud_file_core_test.cpp +++ b/test/unittests/ani_core/cloud_file_core_test.cpp @@ -78,7 +78,7 @@ HWTEST_F(CloudFileCoreTest, ConstructorTest1, TestSize.Level1) HWTEST_F(CloudFileCoreTest, DoOnTest1, TestSize.Level1) { CloudFileCore *download = CloudFileCore::Constructor().GetData().value(); - auto callback = std::make_shared(nullptr, nullptr); + auto callback = std::make_shared(); std::string event = "progress"; auto ret = download->DoOn(event, callback); EXPECT_TRUE(ret.IsSuccess()); @@ -87,38 +87,6 @@ HWTEST_F(CloudFileCoreTest, DoOnTest1, TestSize.Level1) EXPECT_EQ(errorCode, 0); } -/** - * @tc.name: DoOn - * @tc.desc: Verify the CloudFileCore::DoOn function - * @tc.type: FUNC - */ -HWTEST_F(CloudFileCoreTest, DoOnTest2, TestSize.Level1) -{ - CloudFileCore *download = CloudFileCore::Constructor().GetData().value(); - auto callback = std::make_shared(nullptr, nullptr); - std::string event = ""; - auto ret = download->DoOn(event, callback); - EXPECT_FALSE(ret.IsSuccess()); - const auto &err = ret.GetError(); - int errorCode = err.GetErrNo(); - EXPECT_EQ(errorCode, E_PARAMS); -} - -/** - * @tc.name: DoOn - * @tc.desc: Verify the CloudFileCore::DoOn function - * @tc.type: FUNC - */ -HWTEST_F(CloudFileCoreTest, DoOnTest3, TestSize.Level1) -{ - CloudFileCore *download = CloudFileCore::Constructor().GetData().value(); - auto callback = std::make_shared(nullptr, nullptr); - std::string event = "progress"; - auto ret = download->DoOn(event, callback); - ret = download->DoOn(event, callback); - EXPECT_TRUE(ret.IsSuccess()); -} - /** * @tc.name: DoOff * @tc.desc: Verify the CloudFileCore::DoOff function @@ -138,22 +106,6 @@ HWTEST_F(CloudFileCoreTest, DoOffTest1, TestSize.Level1) } } -/** - * @tc.name: DoOff - * @tc.desc: Verify the CloudFileCore::DoOff function - * @tc.type: FUNC - */ -HWTEST_F(CloudFileCoreTest, DoOffTest2, TestSize.Level1) -{ - CloudFileCore *download = CloudFileCore::Constructor().GetData().value(); - std::string event = ""; - auto ret = download->DoOff(event); - EXPECT_FALSE(ret.IsSuccess()); - const auto &err = ret.GetError(); - int errorCode = err.GetErrNo(); - EXPECT_EQ(errorCode, E_PARAMS); -} - /** * @tc.name: DoStart * @tc.desc: Verify the CloudFileCore::DoStart function @@ -164,10 +116,10 @@ HWTEST_F(CloudFileCoreTest, DoStartTest1, TestSize.Level1) CloudFileCore *download = CloudFileCore::Constructor().GetData().value(); std::string uri = "testuri"; auto ret = download->DoStart(uri); - EXPECT_FALSE(ret.IsSuccess()); + EXPECT_TRUE(ret.IsSuccess()); const auto &err = ret.GetError(); int errorCode = err.GetErrNo(); - EXPECT_EQ(errorCode, OHOS::FileManagement::E_PERMISSION); + EXPECT_EQ(errorCode, 0); } /** @@ -179,7 +131,8 @@ HWTEST_F(CloudFileCoreTest, DoStopTest1, TestSize.Level1) { CloudFileCore *download = CloudFileCore::Constructor().GetData().value(); std::string uri = "testuri"; - auto ret = download->DoStop(uri); + bool needClean = true; + auto ret = download->DoStop(uri, needClean); EXPECT_FALSE(ret.IsSuccess()); const auto &err = ret.GetError(); int errorCode = err.GetErrNo(); diff --git a/test/unittests/cloudsync_api/cloudsync_impl/cloud_sync_manager_impl_test.cpp b/test/unittests/cloudsync_api/cloudsync_impl/cloud_sync_manager_impl_test.cpp index a1e57236f..48e08fa65 100644 --- a/test/unittests/cloudsync_api/cloudsync_impl/cloud_sync_manager_impl_test.cpp +++ b/test/unittests/cloudsync_api/cloudsync_impl/cloud_sync_manager_impl_test.cpp @@ -64,21 +64,19 @@ public: MOCK_METHOD3(NotifyEventChange, int32_t(int32_t userId, const std::string &eventId, const std::string &extraData)); MOCK_METHOD2(EnableCloud, int32_t(const std::string &accoutId, const SwitchDataObj &switchData)); MOCK_METHOD1(DisableCloud, int32_t(const std::string &accoutId)); - MOCK_METHOD1(StartDownloadFile, int32_t(const std::string &uri)); - MOCK_METHOD6(StartFileCache, + MOCK_METHOD3(StartDownloadFile, + int32_t(const std::string &uri, + const sptr &downloadCallback, + int64_t &downloadId)); + MOCK_METHOD5(StartFileCache, int32_t(const std::vector &uriVec, int64_t &downloadId, int32_t fieldkey, - bool isCallbackValid, const sptr &downloadCallback, int32_t timeout)); - MOCK_METHOD2(StopDownloadFile, int32_t(const std::string &uri, bool needClean)); + MOCK_METHOD2(StopDownloadFile, int32_t(int64_t downloadId, bool needClean)); MOCK_METHOD3(StopFileCache, int32_t(int64_t downloadId, bool needClean, int32_t timeout)); MOCK_METHOD0(DownloadThumb, int32_t()); - MOCK_METHOD1(RegisterDownloadFileCallback, int32_t(const sptr &downloadCallback)); - MOCK_METHOD1(RegisterFileCacheCallback, int32_t(const sptr &downloadCallback)); - MOCK_METHOD0(UnregisterDownloadFileCallback, int32_t()); - MOCK_METHOD0(UnregisterFileCacheCallback, int32_t()); MOCK_METHOD3(UploadAsset, int32_t(const int32_t userId, const std::string &request, std::string &result)); MOCK_METHOD3(DownloadFile, int32_t(const int32_t userId, const std::string &bundleName, const AssetInfoObj &assetInfoObj)); @@ -422,90 +420,94 @@ HWTEST_F(CloudSyncManagerImplTest, NotifyEventChangeTest, TestSize.Level1) } /* - * @tc.name: StartDownloadFileTest + * @tc.name: StartDownloadFileTest001 * @tc.desc: Verify the StartDownloadFile function. * @tc.type: FUNC * @tc.require: I6H5MH */ -HWTEST_F(CloudSyncManagerImplTest, StartDownloadFileTest, TestSize.Level1) +HWTEST_F(CloudSyncManagerImplTest, StartDownloadFileTest001, TestSize.Level1) { GTEST_LOG_(INFO) << "NotifyDataChangeTest Start"; try { std::string uri = "uri"; + int64_t downloadId = 0; + shared_ptr callback = make_shared(); EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_)); - EXPECT_CALL(*serviceProxy_, StartDownloadFile(_)).WillOnce(Return(E_PERMISSION_DENIED)); - auto res = CloudSyncManagerImpl::GetInstance().StartDownloadFile(uri); + EXPECT_CALL(*serviceProxy_, StartDownloadFile).WillOnce(Return(E_PERMISSION_DENIED)); + auto res = CloudSyncManagerImpl::GetInstance().StartDownloadFile(uri, callback, downloadId); EXPECT_EQ(res, E_PERMISSION_DENIED); } catch (...) { EXPECT_TRUE(false); - GTEST_LOG_(INFO) << " StartDownloadFileTest FAILED"; + GTEST_LOG_(INFO) << " StartDownloadFileTest001 FAILED"; } - GTEST_LOG_(INFO) << "StartDownloadFileTest End"; + GTEST_LOG_(INFO) << "StartDownloadFileTest001 End"; } /* - * @tc.name: StartFileCacheTest - * @tc.desc: Verify the StartFileCache function. + * @tc.name: StartDownloadFileTest002 + * @tc.desc: Verify the StartDownloadFile function. * @tc.type: FUNC * @tc.require: I6H5MH */ -HWTEST_F(CloudSyncManagerImplTest, StartFileCacheTest, TestSize.Level1) +HWTEST_F(CloudSyncManagerImplTest, StartDownloadFileTest002, TestSize.Level1) { - GTEST_LOG_(INFO) << "StartFileCacheTest Start"; + GTEST_LOG_(INFO) << "NotifyDataChangeTest Start"; try { std::string uri = "uri"; + int64_t downloadId = 0; EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_)); - EXPECT_CALL(*serviceProxy_, StartFileCache(_, _, _, _, _, _)).WillOnce(Return(E_PERMISSION_DENIED)); - auto res = CloudSyncManagerImpl::GetInstance().StartFileCache(uri); - EXPECT_EQ(res, E_PERMISSION_DENIED); + auto res = CloudSyncManagerImpl::GetInstance().StartDownloadFile(uri, nullptr, downloadId); + EXPECT_EQ(res, E_INVAL_ARG); } catch (...) { EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "StartFileCacheTest FAILED"; + GTEST_LOG_(INFO) << " StartDownloadFileTest002 FAILED"; } - GTEST_LOG_(INFO) << "StartFileCacheTest End"; + GTEST_LOG_(INFO) << "StartDownloadFileTest002 End"; } /* - * @tc.name: StopDownloadFileTest - * @tc.desc: Verify the StopDownloadFile function. + * @tc.name: StartFileCacheTest + * @tc.desc: Verify the StartFileCache function. * @tc.type: FUNC * @tc.require: I6H5MH */ -HWTEST_F(CloudSyncManagerImplTest, StopDownloadFileTest, TestSize.Level1) +HWTEST_F(CloudSyncManagerImplTest, StartFileCacheTest, TestSize.Level1) { - GTEST_LOG_(INFO) << "NotifyDataChangeTest Start"; + GTEST_LOG_(INFO) << "StartFileCacheTest Start"; try { std::string uri = "uri"; + int64_t downloadId = 0; EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_)); - EXPECT_CALL(*serviceProxy_, StopDownloadFile(_, _)).WillOnce(Return(E_PERMISSION_DENIED)); - auto res = CloudSyncManagerImpl::GetInstance().StopDownloadFile(uri); + EXPECT_CALL(*serviceProxy_, StartFileCache).WillOnce(Return(E_PERMISSION_DENIED)); + auto res = CloudSyncManagerImpl::GetInstance().StartFileCache({uri}, downloadId); EXPECT_EQ(res, E_PERMISSION_DENIED); } catch (...) { EXPECT_TRUE(false); - GTEST_LOG_(INFO) << " StopDownloadFileTest FAILED"; + GTEST_LOG_(INFO) << "StartFileCacheTest FAILED"; } - GTEST_LOG_(INFO) << "StopDownloadFileTest End"; + GTEST_LOG_(INFO) << "StartFileCacheTest End"; } /* - * @tc.name: UnregisterDownloadFileCallbackTest - * @tc.desc: Verify the UnregisterDownloadFileCallback function. + * @tc.name: StopDownloadFileTest + * @tc.desc: Verify the StopDownloadFile function. * @tc.type: FUNC * @tc.require: I6H5MH */ -HWTEST_F(CloudSyncManagerImplTest, UnregisterDownloadFileCallbackTest, TestSize.Level1) +HWTEST_F(CloudSyncManagerImplTest, StopDownloadFileTest, TestSize.Level1) { - GTEST_LOG_(INFO) << "UnregisterDownloadFileCallbackTest Start"; + GTEST_LOG_(INFO) << "NotifyDataChangeTest Start"; try { + int64_t downloadId = 1; EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_)); - EXPECT_CALL(*serviceProxy_, UnregisterDownloadFileCallback()).WillOnce(Return(E_PERMISSION_DENIED)); - auto res = CloudSyncManagerImpl::GetInstance().UnregisterDownloadFileCallback(); + EXPECT_CALL(*serviceProxy_, StopDownloadFile(_, _)).WillOnce(Return(E_PERMISSION_DENIED)); + auto res = CloudSyncManagerImpl::GetInstance().StopDownloadFile(downloadId, true); EXPECT_EQ(res, E_PERMISSION_DENIED); } catch (...) { EXPECT_TRUE(false); - GTEST_LOG_(INFO) << " UnregisterDownloadFileCallbackTest FAILED"; + GTEST_LOG_(INFO) << " StopDownloadFileTest FAILED"; } - GTEST_LOG_(INFO) << "UnregisterDownloadFileCallbackTest End"; + GTEST_LOG_(INFO) << "StopDownloadFileTest End"; } /* @@ -792,28 +794,6 @@ HWTEST_F(CloudSyncManagerImplTest, NotifyDataChangeTest, TestSize.Level1) GTEST_LOG_(INFO) << "NotifyDataChangeTest End"; } -/* - * @tc.name: RegisterDownloadFileCallbackTest - * @tc.desc: Verify the UnregisterDownloadFileCallback function. - * @tc.type: FUNC - * @tc.require: I6H5MH - */ -HWTEST_F(CloudSyncManagerImplTest, RegisterDownloadFileCallbackTest, TestSize.Level1) -{ - GTEST_LOG_(INFO) << "RegisterDownloadFileCallbackTest Start"; - try { - shared_ptr downloadCallback = make_shared(); - EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_)); - EXPECT_CALL(*serviceProxy_, RegisterDownloadFileCallback(_)).WillOnce(Return(E_OK)); - auto res = CloudSyncManagerImpl::GetInstance().RegisterDownloadFileCallback(downloadCallback); - EXPECT_EQ(res, E_OK); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << " RegisterDownloadFileCallbackTest FAILED"; - } - GTEST_LOG_(INFO) << "RegisterDownloadFileCallbackTest End"; -} - /* * @tc.name: SetDeathRecipientTest * @tc.desc: Verify the SetDeathRecipient function. @@ -1019,27 +999,6 @@ HWTEST_F(CloudSyncManagerImplTest, CleanGalleryDentryFileTest004, TestSize.Level GTEST_LOG_(INFO) << "CleanGalleryDentryFileTest004 End"; } -/* - * @tc.name: ResetProxyCallback - * @tc.desc: Verify the ResetProxyCallback function. - * @tc.type: FUNC - * @tc.require: ICEU6Z - */ -HWTEST_F(CloudSyncManagerImplTest, ResetProxyCallbackTest2, TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ResetProxyCallbackTest2 Start"; - try { - EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_)); - EXPECT_CALL(*serviceProxy_, RegisterDownloadFileCallback(_)).WillOnce(Return(E_OK)); - bool ret = CloudSyncManagerImpl::GetInstance().ResetProxyCallback(1, "testBundle"); - EXPECT_TRUE(ret); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << " ResetProxyCallbackTest2 FAILED"; - } - GTEST_LOG_(INFO) << "ResetProxyCallbackTest2 End"; -} - /* * @tc.name: SubscribeListener * @tc.desc: Verify the SubscribeListener function. diff --git a/test/unittests/cloudsync_api/cloudsync_impl/cloud_sync_manager_impl_unnomal_test.cpp b/test/unittests/cloudsync_api/cloudsync_impl/cloud_sync_manager_impl_unnomal_test.cpp index efa4c7070..42758a695 100644 --- a/test/unittests/cloudsync_api/cloudsync_impl/cloud_sync_manager_impl_unnomal_test.cpp +++ b/test/unittests/cloudsync_api/cloudsync_impl/cloud_sync_manager_impl_unnomal_test.cpp @@ -190,8 +190,9 @@ HWTEST_F(CloudSyncManagerTest, StartDownloadFileTest, TestSize.Level1) GTEST_LOG_(INFO) << "NotifyDataChangeTest Start"; try { std::string uri = "uri"; + int64_t downloadId = 0; EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(nullptr)); - auto res = managePtr_->StartDownloadFile(uri); + auto res = managePtr_->StartDownloadFile(uri, nullptr, downloadId); EXPECT_EQ(res, E_SA_LOAD_FAILED); } catch (...) { EXPECT_TRUE(false); @@ -210,9 +211,9 @@ HWTEST_F(CloudSyncManagerTest, StopDownloadFileTest, TestSize.Level1) { GTEST_LOG_(INFO) << "NotifyDataChangeTest Start"; try { - std::string uri = "uri"; + int64_t downloadId = 0; EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(nullptr)); - auto res = managePtr_->StopDownloadFile(uri); + auto res = managePtr_->StopDownloadFile(downloadId, true); EXPECT_EQ(res, E_SA_LOAD_FAILED); } catch (...) { EXPECT_TRUE(false); @@ -221,26 +222,6 @@ HWTEST_F(CloudSyncManagerTest, StopDownloadFileTest, TestSize.Level1) GTEST_LOG_(INFO) << "StopDownloadFileTest End"; } -/* - * @tc.name: RegisterDownloadFileCallbackTest - * @tc.desc: Verify the UnregisterDownloadFileCallback function. - * @tc.type: FUNC - * @tc.require: I6H5MH - */ -HWTEST_F(CloudSyncManagerTest, RegisterDownloadFileCallbackTest, TestSize.Level1) -{ - GTEST_LOG_(INFO) << "NotifyDataChangeTest Start"; - try { - EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(nullptr)); - auto res = managePtr_->UnregisterDownloadFileCallback(); - EXPECT_EQ(res, E_SA_LOAD_FAILED); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << " RegisterDownloadFileCallbackTest FAILED"; - } - GTEST_LOG_(INFO) << "RegisterDownloadFileCallbackTest End"; -} - /* * @tc.name: EnableCloudTest * @tc.desc: Verify the EnableCloud function. diff --git a/test/unittests/cloudsync_api/cloudsync_impl/cloud_sync_service_proxy_test.cpp b/test/unittests/cloudsync_api/cloudsync_impl/cloud_sync_service_proxy_test.cpp index 267596954..b878df64c 100644 --- a/test/unittests/cloudsync_api/cloudsync_impl/cloud_sync_service_proxy_test.cpp +++ b/test/unittests/cloudsync_api/cloudsync_impl/cloud_sync_service_proxy_test.cpp @@ -613,7 +613,8 @@ HWTEST_F(CloudSyncServiceProxyTest, StartDownloadFile001, TestSize.Level1) { GTEST_LOG_(INFO) << "StartDownloadFile Start"; string uri = "file://media"; - int result = proxy_->StartDownloadFile(uri); + int64_t downloadId = 0; + int result = proxy_->StartDownloadFile(uri, remote_, downloadId); EXPECT_EQ(result, E_OK); GTEST_LOG_(INFO) << "StartDownloadFile End"; } @@ -628,7 +629,8 @@ HWTEST_F(CloudSyncServiceProxyTest, StartDownloadFile002, TestSize.Level1) { GTEST_LOG_(INFO) << "StartDownloadFile Start"; string uri = ""; - int result = proxy_->StartDownloadFile(uri); + int64_t downloadId = 0; + int result = proxy_->StartDownloadFile(uri, remote_, downloadId); EXPECT_EQ(result, E_INVAL_ARG); GTEST_LOG_(INFO) << "StartDownloadFile End"; } @@ -678,10 +680,10 @@ HWTEST_F(CloudSyncServiceProxyTest, StartFileCache002, TestSize.Level1) HWTEST_F(CloudSyncServiceProxyTest, StopDownloadFile001, TestSize.Level1) { GTEST_LOG_(INFO) << "StopDownloadFile Start"; - string uri = "file://media"; + int64_t downloadId = 0; EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(-1)); - int result = proxy_->StopDownloadFile(uri); + int result = proxy_->StopDownloadFile(downloadId, true); EXPECT_EQ(result, E_BROKEN_IPC); GTEST_LOG_(INFO) << "StopDownloadFile End"; } @@ -695,10 +697,10 @@ HWTEST_F(CloudSyncServiceProxyTest, StopDownloadFile001, TestSize.Level1) HWTEST_F(CloudSyncServiceProxyTest, StopDownloadFile002, TestSize.Level1) { GTEST_LOG_(INFO) << "StopDownloadFile Start"; - string uri = "file://media"; + int64_t downloadId = 0; EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(E_OK)); - int result = proxy_->StopDownloadFile(uri); + int result = proxy_->StopDownloadFile(downloadId, true); EXPECT_EQ(result, E_OK); GTEST_LOG_(INFO) << "StopDownloadFile End"; } @@ -712,9 +714,9 @@ HWTEST_F(CloudSyncServiceProxyTest, StopDownloadFile002, TestSize.Level1) HWTEST_F(CloudSyncServiceProxyTest, StopDownloadFile003, TestSize.Level1) { GTEST_LOG_(INFO) << "StopDownloadFile Start"; - string uri = ""; + int64_t downloadId = 0; - int result = proxy_->StopDownloadFile(uri); + int result = proxy_->StopDownloadFile(downloadId, true); EXPECT_EQ(result, E_INVAL_ARG); GTEST_LOG_(INFO) << "StopDownloadFile End"; } @@ -973,86 +975,6 @@ HWTEST_F(CloudSyncServiceProxyTest, DeleteAsset002, TestSize.Level1) GTEST_LOG_(INFO) << "DeleteAsset002 End"; } -/** - * @tc.name: RegisterDownloadFileCallback001 - * @tc.desc: Verify the RegisterDownloadFileCallback function. - * @tc.type: FUNC - * @tc.require: issueI7UYAL - */ -HWTEST_F(CloudSyncServiceProxyTest, RegisterDownloadFileCallback001, TestSize.Level1) -{ - GTEST_LOG_(INFO) << "RegisterDownloadFileCallback Start"; - string bundleName = "com.ohos.photos"; - - int result = proxy_->RegisterDownloadFileCallback(nullptr); - EXPECT_EQ(result, E_INVAL_ARG); - GTEST_LOG_(INFO) << "RegisterDownloadFileCallback End"; -} - -/** - * @tc.name: RegisterDownloadFileCallback002 - * @tc.desc: Verify the RegisterDownloadFileCallback function. - * @tc.type: FUNC - * @tc.require: I6H5MH - */ -HWTEST_F(CloudSyncServiceProxyTest, RegisterDownloadFileCallback002, TestSize.Level1) -{ - GTEST_LOG_(INFO) << "RegisterDownloadFileCallback Start"; - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(-1)); - - int result = proxy_->RegisterDownloadFileCallback(remote_); - EXPECT_EQ(result, E_BROKEN_IPC); - GTEST_LOG_(INFO) << "RegisterDownloadFileCallback End"; -} - -/** - * @tc.name: RegisterDownloadFileCallback003 - * @tc.desc: Verify the RegisterDownloadFileCallback function. - * @tc.type: FUNC - * @tc.require: I6H5MH - */ -HWTEST_F(CloudSyncServiceProxyTest, RegisterDownloadFileCallback003, TestSize.Level1) -{ - GTEST_LOG_(INFO) << "RegisterDownloadFileCallback Start"; - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(E_OK)); - - int result = proxy_->RegisterDownloadFileCallback(remote_); - EXPECT_EQ(result, E_OK); - GTEST_LOG_(INFO) << "RegisterDownloadFileCallback End"; -} - -/** - * @tc.name: UnregisterDownloadFileCallback001 - * @tc.desc: Verify the UnegisterDownloadFileCallback function. - * @tc.type: FUNC - * @tc.require: issueI7UYAL - */ -HWTEST_F(CloudSyncServiceProxyTest, UnregisterDownloadFileCallback001, TestSize.Level1) -{ - GTEST_LOG_(INFO) << "UnregisterDownloadFileCallback Start"; - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(-1)); - int result = proxy_->UnregisterDownloadFileCallback(); - - EXPECT_EQ(result, E_BROKEN_IPC); - GTEST_LOG_(INFO) << "UnregisterDownloadFileCallback End"; -} - -/** - * @tc.name: UnregisterDownloadFileCallback002 - * @tc.desc: Verify the UnegisterDownloadFileCallback function. - * @tc.type: FUNC - * @tc.require: issueI7UYAL - */ -HWTEST_F(CloudSyncServiceProxyTest, UnregisterDownloadFileCallback002, TestSize.Level1) -{ - GTEST_LOG_(INFO) << "UnregisterDownloadFileCallback Start"; - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(E_OK)); - int result = proxy_->UnregisterDownloadFileCallback(); - - EXPECT_EQ(result, E_OK); - GTEST_LOG_(INFO) << "UnregisterDownloadFileCallback End"; -} - /** * @tc.name: BatchCleanFile001 * @tc.desc: Verify the BatchCleanFile function. diff --git a/test/unittests/cloudsync_api/cloudsync_impl/include/i_cloud_sync_service_mock.h b/test/unittests/cloudsync_api/cloudsync_impl/include/i_cloud_sync_service_mock.h index 12ea4340b..bc47da6c9 100644 --- a/test/unittests/cloudsync_api/cloudsync_impl/include/i_cloud_sync_service_mock.h +++ b/test/unittests/cloudsync_api/cloudsync_impl/include/i_cloud_sync_service_mock.h @@ -118,19 +118,20 @@ public: { return E_OK; } - int32_t StartDownloadFile(const std::string &path) + int32_t StartDownloadFile(const std::string &uri, + const sptr &downloadCallback, + int64_t &downloadId) { return E_OK; } int32_t StartFileCache(const std::vector &pathVec, int64_t &downloadId, int32_t fieldkey, - bool isCallbackValid, const sptr &downloadCallback, int32_t timeout = -1) { return E_OK; } - int32_t StopDownloadFile(const std::string &path, bool needClean = false) + int32_t StopDownloadFile(int64_t downloadId, bool needClean = false) { return E_OK; } @@ -138,22 +139,6 @@ public: { return E_OK; } - int32_t RegisterDownloadFileCallback(const sptr &downloadCallback) - { - return E_OK; - } - int32_t RegisterFileCacheCallback(const sptr &downloadCallback) - { - return E_OK; - } - int32_t UnregisterDownloadFileCallback() - { - return E_OK; - } - int32_t UnregisterFileCacheCallback() - { - return E_OK; - } int32_t UploadAsset(const int32_t userId, const std::string &request, std::string &result) { return E_OK; diff --git a/test/unittests/cloudsync_sa/ipc/cloud_sync_service_stub_test.cpp b/test/unittests/cloudsync_sa/ipc/cloud_sync_service_stub_test.cpp index 117394461..a5dd48292 100644 --- a/test/unittests/cloudsync_sa/ipc/cloud_sync_service_stub_test.cpp +++ b/test/unittests/cloudsync_sa/ipc/cloud_sync_service_stub_test.cpp @@ -57,10 +57,6 @@ public: int32_t timeout)); MOCK_METHOD2(StopDownloadFile, int32_t(const std::string &path, bool needClean)); MOCK_METHOD3(StopFileCache, int32_t(int64_t downloadId, bool needClean, int32_t timeout)); - MOCK_METHOD1(RegisterDownloadFileCallback, int32_t(const sptr &downloadCallback)); - MOCK_METHOD1(RegisterFileCacheCallback, int32_t(const sptr &downloadCallback)); - MOCK_METHOD0(UnregisterDownloadFileCallback, int32_t()); - MOCK_METHOD0(UnregisterFileCacheCallback, int32_t()); MOCK_METHOD3(UploadAsset, int32_t(const int32_t userId, const std::string &request, std::string &result)); MOCK_METHOD3(DownloadFile, int32_t(const int32_t userId, const std::string &bundleName, AssetInfoObj &assetInfoObj)); @@ -684,7 +680,7 @@ HWTEST_F(CloudSyncServiceStubTest, HandleStartDownloadFileTest, TestSize.Level1) GTEST_LOG_(INFO) << "HandleStartDownloadFile Start"; try { MockService service; - EXPECT_CALL(service, StartDownloadFile(_)).WillOnce(Return(E_OK)); + EXPECT_CALL(service, StartDownloadFile(_, _, _)).WillOnce(Return(E_OK)); MessageParcel data; MessageParcel reply; MessageOption option; @@ -731,64 +727,6 @@ HWTEST_F(CloudSyncServiceStubTest, HandleStopDownloadFileTest, TestSize.Level1) GTEST_LOG_(INFO) << "HandleStopDownloadFile End"; } -/** - * @tc.name: HandleRegisterDownloadFileCallbackTest - * @tc.desc: Verify the HandleRegisterDownloadFileCallback function. - * @tc.type: FUNC - * @tc.require: I6H5MH - */ -HWTEST_F(CloudSyncServiceStubTest, HandleRegisterDownloadFileCallbackTest, TestSize.Level1) -{ - GTEST_LOG_(INFO) << "HandleRegisterDownloadFileCallback Start"; - try { - MockService service; - EXPECT_CALL(service, RegisterDownloadFileCallback(_)).WillOnce(Return(E_OK)); - MessageParcel data; - MessageParcel reply; - MessageOption option; - EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true)); - EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor())); - - EXPECT_EQ(E_OK, service.OnRemoteRequest( - static_cast( - CloudFileSyncServiceInterfaceCode::SERVICE_CMD_REGISTER_DOWNLOAD_FILE_CALLBACK), - data, reply, option)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << " HandleRegisterDownloadFileCallback ERROR"; - } - GTEST_LOG_(INFO) << "HandleRegisterDownloadFileCallback End"; -} - -/** - * @tc.name: HandleUnregisterDownloadFileCallbackTest - * @tc.desc: Verify the HandleUnregisterDownloadFileCallback function. - * @tc.type: FUNC - * @tc.require: I6H5MH - */ -HWTEST_F(CloudSyncServiceStubTest, HandleUnregisterDownloadFileCallbackTest, TestSize.Level1) -{ - GTEST_LOG_(INFO) << "HandleUnregisterDownloadFileCallback Start"; - try { - MockService service; - EXPECT_CALL(service, UnregisterDownloadFileCallback()).WillOnce(Return(E_OK)); - MessageParcel data; - MessageParcel reply; - MessageOption option; - EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true)); - EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor())); - - EXPECT_EQ(E_OK, service.OnRemoteRequest( - static_cast( - CloudFileSyncServiceInterfaceCode::SERVICE_CMD_UNREGISTER_DOWNLOAD_FILE_CALLBACK), - data, reply, option)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << " HandleUnregisterDownloadFileCallback ERROR"; - } - GTEST_LOG_(INFO) << "HandleUnregisterDownloadFileCallback End"; -} - /** * @tc.name: HandleUploadAssetTest * @tc.desc: Verify the HandleUploadAsset function. @@ -1407,28 +1345,6 @@ HWTEST_F(CloudSyncServiceStubTest, HandleStopFileCacheTest003, TestSize.Level1) EXPECT_EQ(ret, E_OK); } -HWTEST_F(CloudSyncServiceStubTest, HandleRegisterDownloadFileCallbackTest002, TestSize.Level1) -{ - MockService service; - MessageParcel data; - MessageParcel reply; - EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false)); - int32_t ret = service.HandleRegisterDownloadFileCallback(data, reply); - - EXPECT_EQ(ret, E_PERMISSION_SYSTEM); -} - -HWTEST_F(CloudSyncServiceStubTest, HandleUnregisterDownloadFileCallbackTest002, TestSize.Level1) -{ - MockService service; - MessageParcel data; - MessageParcel reply; - EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false)); - int32_t ret = service.HandleUnregisterDownloadFileCallback(data, reply); - - EXPECT_EQ(ret, E_PERMISSION_SYSTEM); -} - HWTEST_F(CloudSyncServiceStubTest, HandleUploadAssetTest001, TestSize.Level1) { MockService service; diff --git a/test/unittests/cloudsync_sa/ipc/cloud_sync_service_test.cpp b/test/unittests/cloudsync_sa/ipc/cloud_sync_service_test.cpp index 7f4921b54..4536c7ab0 100644 --- a/test/unittests/cloudsync_sa/ipc/cloud_sync_service_test.cpp +++ b/test/unittests/cloudsync_sa/ipc/cloud_sync_service_test.cpp @@ -266,10 +266,10 @@ HWTEST_F(CloudSyncServiceTest, StopDownloadFileTest, TestSize.Level1) { GTEST_LOG_(INFO) << "StopDownloadFile start"; try { - std::string path; + int64_t downloadId = 0; bool needClean = false; EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false)); - int ret = servicePtr_->StopDownloadFile(path, needClean); + int ret = servicePtr_->StopDownloadFile(downloadId, needClean); EXPECT_EQ(E_PERMISSION_DENIED, ret); } catch (...) { EXPECT_TRUE(false); @@ -278,47 +278,6 @@ HWTEST_F(CloudSyncServiceTest, StopDownloadFileTest, TestSize.Level1) GTEST_LOG_(INFO) << "StopDownloadFile end"; } -/** - * @tc.name:RegisterDownloadFileCallbackTest - * @tc.desc:Verify the RegisterDownloadFileCallback function. - * @tc.type:FUNC - * @tc.require: I6H5MH - */ -HWTEST_F(CloudSyncServiceTest, RegisterDownloadFileCallbackTest, TestSize.Level1) -{ - GTEST_LOG_(INFO) << "RegisterDownloadFileCallback start"; - try { - sptr downloadCallback = sptr(new CloudDownloadCallbackMock()); - EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false)); - int ret = servicePtr_->RegisterDownloadFileCallback(downloadCallback); - EXPECT_EQ(ret, E_PERMISSION_DENIED); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "RegisterDownloadFileCallback FAILED"; - } - GTEST_LOG_(INFO) << "RegisterDownloadFileCallback end"; -} - -/** - * @tc.name:UnregisterDownloadFileCallbackTest - * @tc.desc:Verify the UnregisterDownloadFileCallback function. - * @tc.type:FUNC - * @tc.require: I6H5MH - */ -HWTEST_F(CloudSyncServiceTest, UnregisterDownloadFileCallbackTest, TestSize.Level1) -{ - GTEST_LOG_(INFO) << "UnregisterDownloadFileCallback start"; - try { - EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false)); - int ret = servicePtr_->UnregisterDownloadFileCallback(); - EXPECT_EQ(ret, E_PERMISSION_DENIED); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "UnregisterDownloadFileCallback FAILED"; - } - GTEST_LOG_(INFO) << "UnregisterDownloadFileCallback end"; -} - /** * @tc.name:UploadAssetTest * @tc.desc:Verify the UploadAsset function. -- Gitee