From 79b5ed2b1cd6a5539b960a59cbbca73b376f4925 Mon Sep 17 00:00:00 2001 From: libo429 Date: Sat, 30 Nov 2024 11:07:02 +0800 Subject: [PATCH] add cancel api Signed-off-by: libo429 --- .../src/b_incremental_backup_session.cpp | 17 ++++ .../src/b_incremental_restore_session.cpp | 17 ++++ .../b_incremental_session_restore_async.cpp | 17 ++++ .../backup_kit_inner/src/b_session_backup.cpp | 17 ++++ .../src/b_session_restore.cpp | 17 ++++ .../src/b_session_restore_async.cpp | 17 ++++ .../src/service_incremental_proxy.cpp | 27 ++++++ .../impl/b_incremental_backup_session.h | 8 ++ .../impl/b_incremental_restore_session.h | 8 ++ .../b_incremental_session_restore_async.h | 8 ++ .../backup_kit_inner/impl/b_session_backup.h | 8 ++ .../backup_kit_inner/impl/b_session_restore.h | 8 ++ .../impl/b_session_restore_async.h | 8 ++ .../native/backup_kit_inner/impl/i_service.h | 1 + .../impl/i_service_ipc_interface_code.h | 1 + .../backup_kit_inner/impl/service_proxy.h | 1 + .../js/backup/session_backup_n_exporter.cpp | 48 ++++++++++ .../js/backup/session_backup_n_exporter.h | 1 + .../session_incremental_backup_n_exporter.cpp | 48 ++++++++++ .../session_incremental_backup_n_exporter.h | 1 + .../js/backup/session_restore_n_exporter.cpp | 55 +++++++++++ .../js/backup/session_restore_n_exporter.h | 1 + .../backup_sa/include/module_ipc/service.h | 3 + .../include/module_ipc/service_stub.h | 1 + .../src/module_ipc/service_incremental.cpp | 93 +++++++++++++++++++ .../backup_sa/src/module_ipc/service_stub.cpp | 17 ++++ .../b_session_backup_mock.cpp | 5 + .../b_session_restore_async_mock.cpp | 5 + .../b_session_restore_mock.cpp | 5 + .../backup_kit_inner/service_proxy_mock.cpp | 6 ++ .../module_ipc/include/service_stub_mock.h | 1 + tests/mock/module_ipc/service_mock.cpp | 8 ++ tests/mock/module_ipc/service_stub_mock.cpp | 15 +++ .../mock/module_ipc/src/service_stub_mock.cpp | 5 + .../b_session_backup_test.cpp | 33 +++++++ .../b_session_restore_async_test.cpp | 31 +++++++ .../b_session_restore_test.cpp | 34 +++++++ .../backup_impl/include/i_service_mock.h | 6 ++ .../backup_impl/service_proxy_test.cpp | 29 ++++++ .../module_ipc/service_incremental_test.cpp | 51 ++++++++++ .../module_ipc/service_other_test.cpp | 6 ++ .../module_ipc/service_stub_test.cpp | 45 +++++++++ .../session/b_incremental_session_test.cpp | 90 ++++++++++++++++++ .../backup_sa/session/service_proxy_mock.cpp | 6 ++ .../backup_sa/session/service_proxy_mock.h | 1 + utils/include/b_error/b_error.h | 6 ++ 46 files changed, 836 insertions(+) diff --git a/frameworks/native/backup_kit_inner/src/b_incremental_backup_session.cpp b/frameworks/native/backup_kit_inner/src/b_incremental_backup_session.cpp index 0d69e9ba8..da21da3e7 100644 --- a/frameworks/native/backup_kit_inner/src/b_incremental_backup_session.cpp +++ b/frameworks/native/backup_kit_inner/src/b_incremental_backup_session.cpp @@ -140,4 +140,21 @@ ErrCode BIncrementalBackupSession::Release() return proxy->Release(); } + +ErrCode BIncrementalBackupSession::Cancel(std::string bundleName) +{ + ErrCode result = BError::BackupErrorCode::E_CANCEL_FAIL; + auto proxy = ServiceProxy::GetInstance(); + if (proxy == nullptr) { + HILOGE("called Cancel, failed to get proxy."); + return result; + } + + ErrCode errCode = proxy->Cancel(bundleName, result); + if (errCode != 0) { + HILOGE("proxy->Cancel failed, errCode:%{public}d.", errCode); + return result; + } + return result; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/frameworks/native/backup_kit_inner/src/b_incremental_restore_session.cpp b/frameworks/native/backup_kit_inner/src/b_incremental_restore_session.cpp index 0999dac1d..6df0589e3 100644 --- a/frameworks/native/backup_kit_inner/src/b_incremental_restore_session.cpp +++ b/frameworks/native/backup_kit_inner/src/b_incremental_restore_session.cpp @@ -165,4 +165,21 @@ void BIncrementalRestoreSession::RegisterBackupServiceDied(function func deathRecipient_ = sptr(new SvcDeathRecipient(callback)); remoteObj->AddDeathRecipient(deathRecipient_); } + +ErrCode BIncrementalRestoreSession::Cancel(std::string bundleName) +{ + ErrCode result = BError::BackupErrorCode::E_CANCEL_FAIL; + auto proxy = ServiceProxy::GetInstance(); + if (proxy == nullptr) { + HILOGE("called Cancel, failed to get proxy."); + return result; + } + + ErrCode errCode = proxy->Cancel(bundleName, result); + if (errCode != 0) { + HILOGE("proxy->Cancel failed, errCode:%{public}d.", errCode); + return result; + } + return result; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/frameworks/native/backup_kit_inner/src/b_incremental_session_restore_async.cpp b/frameworks/native/backup_kit_inner/src/b_incremental_session_restore_async.cpp index cb79d416c..d7431603f 100644 --- a/frameworks/native/backup_kit_inner/src/b_incremental_session_restore_async.cpp +++ b/frameworks/native/backup_kit_inner/src/b_incremental_session_restore_async.cpp @@ -167,4 +167,21 @@ void BIncrementalSessionRestoreAsync::RegisterBackupServiceDied(std::functionAddDeathRecipient(deathRecipient_); } + +ErrCode BIncrementalSessionRestoreAsync::Cancel(std::string bundleName) +{ + ErrCode result = BError::BackupErrorCode::E_CANCEL_FAIL; + auto proxy = ServiceProxy::GetInstance(); + if (proxy == nullptr) { + HILOGE("called Cancel, failed to get proxy."); + return result; + } + + ErrCode errCode = proxy->Cancel(bundleName, result); + if (errCode != 0) { + HILOGE("proxy->Cancel failed, errCode:%{public}d.", errCode); + return result; + } + return result; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/frameworks/native/backup_kit_inner/src/b_session_backup.cpp b/frameworks/native/backup_kit_inner/src/b_session_backup.cpp index 508626269..4f4c7d464 100644 --- a/frameworks/native/backup_kit_inner/src/b_session_backup.cpp +++ b/frameworks/native/backup_kit_inner/src/b_session_backup.cpp @@ -159,4 +159,21 @@ ErrCode BSessionBackup::Release() return proxy->Release(); } + +ErrCode BSessionBackup::Cancel(std::string bundleName) +{ + ErrCode result = BError::BackupErrorCode::E_CANCEL_FAIL; + auto proxy = ServiceProxy::GetInstance(); + if (proxy == nullptr) { + HILOGE("called Cancel, failed to get proxy."); + return result; + } + + ErrCode errCode = proxy->Cancel(bundleName, result); + if (errCode != 0) { + HILOGE("proxy->Cancel failed, errCode:%{public}d.", errCode); + return result; + } + return result; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/frameworks/native/backup_kit_inner/src/b_session_restore.cpp b/frameworks/native/backup_kit_inner/src/b_session_restore.cpp index 9247c39ff..286df4b50 100644 --- a/frameworks/native/backup_kit_inner/src/b_session_restore.cpp +++ b/frameworks/native/backup_kit_inner/src/b_session_restore.cpp @@ -176,4 +176,21 @@ void BSessionRestore::RegisterBackupServiceDied(std::function functor) deathRecipient_ = sptr(new SvcDeathRecipient(callback)); remoteObj->AddDeathRecipient(deathRecipient_); } + +ErrCode BSessionRestore::Cancel(std::string bundleName) +{ + ErrCode result = BError::BackupErrorCode::E_CANCEL_FAIL; + auto proxy = ServiceProxy::GetInstance(); + if (proxy == nullptr) { + HILOGE("called Cancel, failed to get proxy."); + return result; + } + + ErrCode errCode = proxy->Cancel(bundleName, result); + if (errCode != 0) { + HILOGE("proxy->Cancel failed, errCode:%{public}d.", errCode); + return result; + } + return result; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/frameworks/native/backup_kit_inner/src/b_session_restore_async.cpp b/frameworks/native/backup_kit_inner/src/b_session_restore_async.cpp index 12b82a250..68bb81075 100644 --- a/frameworks/native/backup_kit_inner/src/b_session_restore_async.cpp +++ b/frameworks/native/backup_kit_inner/src/b_session_restore_async.cpp @@ -169,4 +169,21 @@ void BSessionRestoreAsync::RegisterBackupServiceDied(std::function funct deathRecipient_ = sptr(new SvcDeathRecipient(callback)); remoteObj->AddDeathRecipient(deathRecipient_); } + +ErrCode BSessionRestoreAsync::Cancel(std::string bundleName) +{ + ErrCode result = BError::BackupErrorCode::E_CANCEL_FAIL; + auto proxy = ServiceProxy::GetInstance(); + if (proxy == nullptr) { + HILOGE("called Cancel, failed to get proxy."); + return result; + } + + ErrCode errCode = proxy->Cancel(bundleName, result); + if (errCode != 0) { + HILOGE("proxy->Cancel failed, errCode:%{public}d.", errCode); + return result; + } + return result; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/frameworks/native/backup_kit_inner/src/service_incremental_proxy.cpp b/frameworks/native/backup_kit_inner/src/service_incremental_proxy.cpp index 7c2bd5c64..ba6ac7798 100644 --- a/frameworks/native/backup_kit_inner/src/service_incremental_proxy.cpp +++ b/frameworks/native/backup_kit_inner/src/service_incremental_proxy.cpp @@ -353,4 +353,31 @@ bool ServiceProxy::WriteParcelableVector(const std::vector &parcelableVector, return true; } + +ErrCode ServiceProxy::Cancel(std::string bundleName, int &result) +{ + HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); + BExcepUltils::BAssert(Remote(), BError::Codes::SDK_INVAL_ARG, "Remote is nullptr"); + MessageParcel data; + if (!data.WriteInterfaceToken(GetDescriptor())) { + return BError(BError::Codes::SDK_INVAL_ARG, "Failed to write descriptor").GetCode(); + } + + if (!data.WriteString(bundleName)) { + return BError(BError::Codes::SDK_INVAL_ARG, "Failed to send the bundleName").GetCode(); + } + + MessageParcel reply; + MessageOption option; + int32_t ret = Remote()->SendRequest( + static_cast(IServiceInterfaceCode::SERVICE_CMD_CANCEL_BUNDLE_NAME), data, reply, option); + if (ret != NO_ERROR) { + string str = "Failed to send out the request because of " + to_string(ret); + return BError(BError::Codes::SDK_INVAL_ARG, str.data()).GetCode(); + } + reply.ReadInt32(result); + HILOGI("serviceProxy Cancel end, result:%{public}d", result); + + return BError(BError::Codes::OK, "success"); +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/interfaces/inner_api/native/backup_kit_inner/impl/b_incremental_backup_session.h b/interfaces/inner_api/native/backup_kit_inner/impl/b_incremental_backup_session.h index c7c40df0a..0ab71f6fd 100644 --- a/interfaces/inner_api/native/backup_kit_inner/impl/b_incremental_backup_session.h +++ b/interfaces/inner_api/native/backup_kit_inner/impl/b_incremental_backup_session.h @@ -73,6 +73,14 @@ public: */ ErrCode Release(); + /** + * @brief 用于结束应用的备份恢复任务 + * + * @param bundleName 要取消的应用包名 + * @return ErrCode 规范错误码 + */ + ErrCode Cancel(std::string bundleName); + /** * @brief 注册备份服务意外死亡时执行的回调函数 * diff --git a/interfaces/inner_api/native/backup_kit_inner/impl/b_incremental_restore_session.h b/interfaces/inner_api/native/backup_kit_inner/impl/b_incremental_restore_session.h index 3a2e2ec5f..502fd1a9c 100644 --- a/interfaces/inner_api/native/backup_kit_inner/impl/b_incremental_restore_session.h +++ b/interfaces/inner_api/native/backup_kit_inner/impl/b_incremental_restore_session.h @@ -104,6 +104,14 @@ public: */ ErrCode Release(); + /** + * @brief 用于结束应用的备份恢复任务 + * + * @param bundleName 要取消的应用包名 + * @return ErrCode 规范错误码 + */ + ErrCode Cancel(std::string bundleName); + /** * @brief 注册备份服务意外死亡时执行的回调函数 * diff --git a/interfaces/inner_api/native/backup_kit_inner/impl/b_incremental_session_restore_async.h b/interfaces/inner_api/native/backup_kit_inner/impl/b_incremental_session_restore_async.h index fc705c6f6..50c47bf7b 100644 --- a/interfaces/inner_api/native/backup_kit_inner/impl/b_incremental_session_restore_async.h +++ b/interfaces/inner_api/native/backup_kit_inner/impl/b_incremental_session_restore_async.h @@ -109,6 +109,14 @@ public: */ ErrCode Release(); + /** + * @brief 用于结束应用的备份恢复任务 + * + * @param bundleName 要取消的应用包名 + * @return ErrCode 规范错误码 + */ + ErrCode Cancel(std::string bundleName); + public: explicit BIncrementalSessionRestoreAsync(Callbacks callbacks) : callbacks_(callbacks) {}; ~BIncrementalSessionRestoreAsync(); diff --git a/interfaces/inner_api/native/backup_kit_inner/impl/b_session_backup.h b/interfaces/inner_api/native/backup_kit_inner/impl/b_session_backup.h index f08c340be..619c0afc2 100644 --- a/interfaces/inner_api/native/backup_kit_inner/impl/b_session_backup.h +++ b/interfaces/inner_api/native/backup_kit_inner/impl/b_session_backup.h @@ -87,6 +87,14 @@ public: */ ErrCode Release(); + /** + * @brief 用于结束应用的备份恢复任务 + * + * @param bundleName 要取消的应用包名 + * @return ErrCode 规范错误码 + */ + ErrCode Cancel(std::string bundleName); + /** * @brief 注册备份服务意外死亡时执行的回调函数 * diff --git a/interfaces/inner_api/native/backup_kit_inner/impl/b_session_restore.h b/interfaces/inner_api/native/backup_kit_inner/impl/b_session_restore.h index cdb72d326..c831dead3 100644 --- a/interfaces/inner_api/native/backup_kit_inner/impl/b_session_restore.h +++ b/interfaces/inner_api/native/backup_kit_inner/impl/b_session_restore.h @@ -105,6 +105,14 @@ public: */ ErrCode Release(); + /** + * @brief 用于结束应用的备份恢复任务 + * + * @param bundleName 要取消的应用包名 + * @return ErrCode 规范错误码 + */ + ErrCode Cancel(std::string bundleName); + /** * @brief 注册备份服务意外死亡时执行的回调函数 * diff --git a/interfaces/inner_api/native/backup_kit_inner/impl/b_session_restore_async.h b/interfaces/inner_api/native/backup_kit_inner/impl/b_session_restore_async.h index 482c6409e..64615acb2 100644 --- a/interfaces/inner_api/native/backup_kit_inner/impl/b_session_restore_async.h +++ b/interfaces/inner_api/native/backup_kit_inner/impl/b_session_restore_async.h @@ -110,6 +110,14 @@ public: */ ErrCode Release(); + /** + * @brief 用于结束应用的备份恢复任务 + * + * @param bundleName 要取消的应用包名 + * @return ErrCode 规范错误码 + */ + ErrCode Cancel(std::string bundleName); + public: explicit BSessionRestoreAsync(Callbacks callbacks) : callbacks_(callbacks) {}; ~BSessionRestoreAsync(); diff --git a/interfaces/inner_api/native/backup_kit_inner/impl/i_service.h b/interfaces/inner_api/native/backup_kit_inner/impl/i_service.h index 6dee18fc3..86cbafd60 100644 --- a/interfaces/inner_api/native/backup_kit_inner/impl/i_service.h +++ b/interfaces/inner_api/native/backup_kit_inner/impl/i_service.h @@ -69,6 +69,7 @@ public: const std::vector &bundleInfos) = 0; virtual ErrCode Finish() = 0; virtual ErrCode Release() = 0; + virtual ErrCode Cancel(std::string bundleName, int &result) = 0; virtual UniqueFd GetLocalCapabilitiesIncremental(const std::vector &bundleNames) = 0; virtual ErrCode GetAppLocalListAndDoIncrementalBackup() = 0; virtual ErrCode InitIncrementalBackupSession(sptr remotse) = 0; diff --git a/interfaces/inner_api/native/backup_kit_inner/impl/i_service_ipc_interface_code.h b/interfaces/inner_api/native/backup_kit_inner/impl/i_service_ipc_interface_code.h index 9175e2295..11a332243 100644 --- a/interfaces/inner_api/native/backup_kit_inner/impl/i_service_ipc_interface_code.h +++ b/interfaces/inner_api/native/backup_kit_inner/impl/i_service_ipc_interface_code.h @@ -50,6 +50,7 @@ enum class IServiceInterfaceCode { SERVICE_CMD_UPDATE_SENDRATE, SERVICE_CMD_GET_APP_LOCAL_LIST_AND_DO_INCREMENTAL_BACKUP, SERVICE_CMD_REPORT_APP_PROCESS_INFO, + SERVICE_CMD_CANCEL_BUNDLE_NAME, }; } // namespace OHOS::FileManagement::Backup diff --git a/interfaces/inner_api/native/backup_kit_inner/impl/service_proxy.h b/interfaces/inner_api/native/backup_kit_inner/impl/service_proxy.h index 21c676d85..686c7f6a2 100644 --- a/interfaces/inner_api/native/backup_kit_inner/impl/service_proxy.h +++ b/interfaces/inner_api/native/backup_kit_inner/impl/service_proxy.h @@ -52,6 +52,7 @@ public: const std::vector &detailInfos) override; ErrCode Finish() override; ErrCode Release() override; + ErrCode Cancel(std::string bundleName, int &result) override; UniqueFd GetLocalCapabilitiesIncremental(const std::vector &bundleNames) override; ErrCode GetAppLocalListAndDoIncrementalBackup() override; ErrCode InitIncrementalBackupSession(sptr remote) override; diff --git a/interfaces/kits/js/backup/session_backup_n_exporter.cpp b/interfaces/kits/js/backup/session_backup_n_exporter.cpp index cbcd9fbcc..68990daa6 100644 --- a/interfaces/kits/js/backup/session_backup_n_exporter.cpp +++ b/interfaces/kits/js/backup/session_backup_n_exporter.cpp @@ -487,12 +487,60 @@ napi_value SessionBackupNExporter::Release(napi_env env, napi_callback_info cbin return NAsyncWorkPromise(env, thisVar).Schedule(className, cbExec, cbCompl).val_; } +napi_value SessionBackupNExporter::Cancel(napi_env env, napi_callback_info info) +{ + HILOGI("called SessionBackup::Cancel begin"); + if (!SAUtils::CheckBackupPermission()) { + HILOGE("Has not permission!"); + NError(E_PERMISSION).ThrowErr(env); + return nullptr; + } + if (!SAUtils::IsSystemApp()) { + HILOGE("System App check fail!"); + NError(E_PERMISSION_SYS).ThrowErr(env); + return nullptr; + } + NFuncArg funcArg(env, info); + if (!funcArg.InitArgs(NARG_CNT::ONE)) { + HILOGE("Number of arguments unmatched."); + NError(E_PARAMS).ThrowErr(env); + return nullptr; + } + NVal jsBundleStr(env, funcArg[NARG_POS::FIRST]); + auto [succStr, bundle, sizeStr] = jsBundleStr.ToUTF8String(); + if (!succStr) { + HILOGE("First argument is not bundleName."); + NError(E_PARAMS).ThrowErr(env); + return nullptr; + } + std::string bundleName = bundle.get(); + + auto backupEntity = NClass::GetEntityOf(env, funcArg.GetThisVar()); + if (!(backupEntity && backupEntity->session)) { + HILOGE("Failed to get backupSession entity."); + NError(BError(BError::Codes::SDK_INVAL_ARG, "Failed to get backupSession entity.").GetCode()).ThrowErr(env); + return nullptr; + } + + auto session = backupEntity->session.get(); + int result = session->Cancel(bundleName); + napi_value nResult; + napi_status status = napi_create_int32(env, result, &nResult); + if (status != napi_ok) { + HILOGE("napi_create_int32 faild."); + return nullptr; + } + HILOGI("Cancel success with result: %{public}d", result); + return nResult; +} + bool SessionBackupNExporter::Export() { HILOGD("called SessionBackupNExporter::Export begin"); vector props = { NVal::DeclareNapiFunction("appendBundles", AppendBundles), NVal::DeclareNapiFunction("release", Release), + NVal::DeclareNapiFunction("cancel", Cancel), }; auto [succ, classValue] = NClass::DefineClass(exports_.env_, className, Constructor, std::move(props)); diff --git a/interfaces/kits/js/backup/session_backup_n_exporter.h b/interfaces/kits/js/backup/session_backup_n_exporter.h index 1c95b7df6..b8dd9f8a0 100644 --- a/interfaces/kits/js/backup/session_backup_n_exporter.h +++ b/interfaces/kits/js/backup/session_backup_n_exporter.h @@ -28,6 +28,7 @@ public: static napi_value Constructor(napi_env env, napi_callback_info cbinfo); static napi_value AppendBundles(napi_env env, napi_callback_info cbinfo); static napi_value Release(napi_env env, napi_callback_info cbinfo); + static napi_value Cancel(napi_env env, napi_callback_info cbinfo); SessionBackupNExporter(napi_env env, napi_value exports); ~SessionBackupNExporter() override; diff --git a/interfaces/kits/js/backup/session_incremental_backup_n_exporter.cpp b/interfaces/kits/js/backup/session_incremental_backup_n_exporter.cpp index d33e0c5e8..e242bcf12 100644 --- a/interfaces/kits/js/backup/session_incremental_backup_n_exporter.cpp +++ b/interfaces/kits/js/backup/session_incremental_backup_n_exporter.cpp @@ -547,12 +547,60 @@ napi_value SessionIncrementalBackupNExporter::Release(napi_env env, napi_callbac return NAsyncWorkPromise(env, thisVar).Schedule(className, cbExec, cbCompl).val_; } +napi_value SessionIncrementalBackupNExporter::Cancel(napi_env env, napi_callback_info info) +{ + HILOGI("called SessionIncrementalBackup::Cancel begin"); + if (!SAUtils::CheckBackupPermission()) { + HILOGE("Has not permission!"); + NError(E_PERMISSION).ThrowErr(env); + return nullptr; + } + if (!SAUtils::IsSystemApp()) { + HILOGE("System App check fail!"); + NError(E_PERMISSION_SYS).ThrowErr(env); + return nullptr; + } + NFuncArg funcArg(env, info); + if (!funcArg.InitArgs(NARG_CNT::ONE)) { + HILOGE("Number of arguments unmatched."); + NError(E_PARAMS).ThrowErr(env); + return nullptr; + } + NVal jsBundleStr(env, funcArg[NARG_POS::FIRST]); + auto [succStr, bundle, sizeStr] = jsBundleStr.ToUTF8String(); + if (!succStr) { + HILOGE("First argument is not bundleName."); + NError(E_PARAMS).ThrowErr(env); + return nullptr; + } + std::string bundleName = bundle.get(); + + auto backupEntity = NClass::GetEntityOf(env, funcArg.GetThisVar()); + if (!(backupEntity && backupEntity->session)) { + HILOGE("Failed to get backupSession entity."); + NError(BError(BError::Codes::SDK_INVAL_ARG, "Failed to get backupSession entity.").GetCode()).ThrowErr(env); + return nullptr; + } + + auto session = backupEntity->session.get(); + int result = session->Cancel(bundleName); + napi_value nResult; + napi_status status = napi_create_int32(env, result, &nResult); + if (status != napi_ok) { + HILOGE("napi_create_int32 faild."); + return nullptr; + } + HILOGI("Cancel success with result: %{public}d", result); + return nResult; +} + bool SessionIncrementalBackupNExporter::Export() { HILOGD("called SessionIncrementalBackupNExporter::Export begin"); vector props = { NVal::DeclareNapiFunction("appendBundles", AppendBundles), NVal::DeclareNapiFunction("release", Release), + NVal::DeclareNapiFunction("cancel", Cancel), }; auto [succ, classValue] = NClass::DefineClass(exports_.env_, className, Constructor, std::move(props)); diff --git a/interfaces/kits/js/backup/session_incremental_backup_n_exporter.h b/interfaces/kits/js/backup/session_incremental_backup_n_exporter.h index 9508630b4..2790b9400 100644 --- a/interfaces/kits/js/backup/session_incremental_backup_n_exporter.h +++ b/interfaces/kits/js/backup/session_incremental_backup_n_exporter.h @@ -28,6 +28,7 @@ public: static napi_value Constructor(napi_env env, napi_callback_info cbinfo); static napi_value AppendBundles(napi_env env, napi_callback_info cbinfo); static napi_value Release(napi_env env, napi_callback_info cbinfo); + static napi_value Cancel(napi_env env, napi_callback_info cbinfo); SessionIncrementalBackupNExporter(napi_env env, napi_value exports); ~SessionIncrementalBackupNExporter() override; diff --git a/interfaces/kits/js/backup/session_restore_n_exporter.cpp b/interfaces/kits/js/backup/session_restore_n_exporter.cpp index 6257637ef..841b49f34 100644 --- a/interfaces/kits/js/backup/session_restore_n_exporter.cpp +++ b/interfaces/kits/js/backup/session_restore_n_exporter.cpp @@ -729,6 +729,60 @@ napi_value SessionRestoreNExporter::Release(napi_env env, napi_callback_info cbi return NAsyncWorkPromise(env, thisVar).Schedule(className, cbExec, cbCompl).val_; } +napi_value SessionRestoreNExporter::Cancel(napi_env env, napi_callback_info info) +{ + HILOGD("called SessionRestore::Cancel begin"); + if (!SAUtils::CheckBackupPermission()) { + HILOGE("Has not permission!"); + NError(E_PERMISSION).ThrowErr(env); + return nullptr; + } + if (!SAUtils::IsSystemApp()) { + HILOGE("System App check fail!"); + NError(E_PERMISSION_SYS).ThrowErr(env); + return nullptr; + } + NFuncArg funcArg(env, info); + if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::TWO)) { + HILOGE("Number of arguments unmatched."); + NError(E_PARAMS).ThrowErr(env); + return nullptr; + } + NVal jsBundleStr(env, funcArg[NARG_POS::FIRST]); + auto [succStr, bundle, sizeStr] = jsBundleStr.ToUTF8String(); + if (!succStr) { + HILOGE("First argument is not bundleName."); + NError(E_PARAMS).ThrowErr(env); + return nullptr; + } + std::string bundleName = bundle.get(); + + auto restoreEntity = NClass::GetEntityOf(env, funcArg.GetThisVar()); + if (!(restoreEntity && (restoreEntity->sessionWhole || restoreEntity->sessionSheet))) { + HILOGE("Failed to get restoreSession entity."); + NError(BError(BError::Codes::SDK_INVAL_ARG, "Failed to get restoreSession entity.").GetCode()).ThrowErr(env); + return nullptr; + } + + int result = BError(BError::Codes::OK); + if (restoreEntity->sessionWhole) { + auto session = restoreEntity->sessionWhole.get(); + result = session->Cancel(bundleName); + } else { + auto session = restoreEntity->sessionSheet.get(); + result = session->Cancel(bundleName); + } + + napi_value nResult; + napi_status status = napi_create_int32(env, result, &nResult); + if (status != napi_ok) { + HILOGE("napi_create_int32 faild."); + return nullptr; + } + HILOGI("Cancel success with result: %{public}d", result); + return nResult; +} + bool SessionRestoreNExporter::Export() { HILOGD("called SessionRestoreNExporter::Export begin"); @@ -737,6 +791,7 @@ bool SessionRestoreNExporter::Export() NVal::DeclareNapiFunction("publishFile", PublishFile), NVal::DeclareNapiFunction("getFileHandle", GetFileHandle), NVal::DeclareNapiFunction("release", Release), + NVal::DeclareNapiFunction("cancel", Cancel), }; auto [succ, classValue] = NClass::DefineClass(exports_.env_, className, Constructor, std::move(props)); diff --git a/interfaces/kits/js/backup/session_restore_n_exporter.h b/interfaces/kits/js/backup/session_restore_n_exporter.h index 49e1f6388..422269447 100644 --- a/interfaces/kits/js/backup/session_restore_n_exporter.h +++ b/interfaces/kits/js/backup/session_restore_n_exporter.h @@ -33,6 +33,7 @@ public: static napi_value PublishFile(napi_env env, napi_callback_info cbinfo); static napi_value GetFileHandle(napi_env env, napi_callback_info cbinfo); static napi_value Release(napi_env env, napi_callback_info cbinfo); + static napi_value Cancel(napi_env env, napi_callback_info cbinfo); SessionRestoreNExporter(napi_env env, napi_value exports); ~SessionRestoreNExporter() override; diff --git a/services/backup_sa/include/module_ipc/service.h b/services/backup_sa/include/module_ipc/service.h index 1b92cc342..f86c386ff 100644 --- a/services/backup_sa/include/module_ipc/service.h +++ b/services/backup_sa/include/module_ipc/service.h @@ -72,6 +72,7 @@ public: const std::vector &bundleInfos) override; ErrCode Finish() override; ErrCode Release() override; + ErrCode Cancel(std::string bundleName, int &result) override; UniqueFd GetLocalCapabilitiesIncremental(const std::vector &bundleNames) override; ErrCode GetAppLocalListAndDoIncrementalBackup() override; @@ -559,6 +560,8 @@ private: void SetBundleIncDataInfo(const std::vector &bundlesToBackup, std::vector &supportBundleNames); + + void StopApp(std::string bundleName, wptr ptr); private: static sptr instance_; static std::mutex instanceLock_; diff --git a/services/backup_sa/include/module_ipc/service_stub.h b/services/backup_sa/include/module_ipc/service_stub.h index 5aeba2752..6cabc844b 100644 --- a/services/backup_sa/include/module_ipc/service_stub.h +++ b/services/backup_sa/include/module_ipc/service_stub.h @@ -49,6 +49,7 @@ private: int32_t CmdAppendBundlesDetailsBackupSession(MessageParcel &data, MessageParcel &reply); int32_t CmdFinish(MessageParcel &data, MessageParcel &reply); int32_t CmdRelease(MessageParcel &data, MessageParcel &reply); + int32_t CmdCancel(MessageParcel &data, MessageParcel &reply); int32_t CmdGetLocalCapabilitiesIncremental(MessageParcel &data, MessageParcel &reply); int32_t CmdGetAppLocalListAndDoIncrementalBackup(MessageParcel &data, MessageParcel &reply); int32_t CmdInitIncrementalBackupSession(MessageParcel &data, MessageParcel &reply); diff --git a/services/backup_sa/src/module_ipc/service_incremental.cpp b/services/backup_sa/src/module_ipc/service_incremental.cpp index 8583f06e2..700085233 100644 --- a/services/backup_sa/src/module_ipc/service_incremental.cpp +++ b/services/backup_sa/src/module_ipc/service_incremental.cpp @@ -758,4 +758,97 @@ void Service::SetBundleIncDataInfo(const std::vector& bundlesT session_->SetIncrementalData(bundleInfo); } } +void Service::StopApp(std::string bundleName, wptr ptr) +{ + HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); + auto thisPtr = ptr.promote(); + if (!thisPtr) { + HILOGE("this pointer is null"); + return; + } + auto session = thisPtr->session_; + if (session == nullptr) { + HILOGE("session is nullptr"); + return; + } + HILOGI("Service StopApp start, bundleName is %{public}s", bundleName.c_str()); + std::shared_ptr mutexPtr = thisPtr->GetExtensionMutex(bundleName); + if (mutexPtr == nullptr) { + HILOGE("extension mutex ptr is nullptr"); + return; + } + { + std::lock_guard lock(mutexPtr->callbackMutex); + auto tempBackUpConnection = session->GetExtConnection(bundleName); + auto backUpConnection = tempBackUpConnection.promote(); + if (backUpConnection == nullptr) { + HILOGE("Promote backUpConnection ptr is null."); + return; + } + auto proxy = backUpConnection->GetBackupExtProxy(); + if (!proxy) { + HILOGE("Extension backup Proxy is empty."); + return; + } + proxy->HandleClear(); + session->StopFwkTimer(bundleName); + session->StopExtTimer(bundleName); + backUpConnection->DisconnectBackupExtAbility(); + thisPtr->ClearSessionAndSchedInfo(bundleName); + IServiceReverse::Scenario scenario = session->GetScenario(); + if ((scenario == IServiceReverse::Scenario::BACKUP && session->GetIsIncrementalBackup()) || + (scenario == IServiceReverse::Scenario::RESTORE && + session->ValidRestoreDataType(RestoreTypeEnum::RESTORE_DATA_WAIT_SEND))) { + thisPtr->NotifyCallerCurAppIncrementDone(BError(BError::Codes::OK), bundleName); + } else { + thisPtr->NotifyCallerCurAppDone(BError(BError::Codes::OK), bundleName); + } + } + thisPtr->RemoveExtensionMutex(bundleName); + thisPtr->OnAllBundlesFinished(BError(BError::Codes::OK)); + return; +} + +ErrCode Service::Cancel(std::string bundleName, int &result) +{ + HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); + HILOGI("Begin, bundle name:%{public}s", bundleName.c_str()); + if (session_ == nullptr) { + HILOGE("Cancel error, session is null"); + return BError(BError::BackupErrorCode::E_CANCEL_FAIL); + } + IServiceReverse::Scenario scenario = session_->GetScenario(); + VerifyCaller(scenario); + auto impl = session_->GetImpl(); + auto it = impl.backupExtNameMap.find(bundleName); + if (it == impl.backupExtNameMap.end()) { + result = BError::BackupErrorCode::E_CANCEL_NOT_TASK; + return BError(BError::Codes::OK); + } + auto action = session_->GetServiceSchedAction(bundleName); + if (action == BConstants::ServiceSchedAction::RUNNING) { + auto task = [this, bundleName]() { + StopApp(bundleName, wptr(this)); + }; + threadPool_.AddTask([task]() { + try { + task(); + } catch (const BError &e) { + HILOGE("Cancel failed, errCode = %{public}d", e.GetCode()); + } catch (const exception &e) { + HILOGI("Catched an unexpected low-level exception %{public}s", e.what()); + } catch (...) { + HILOGI("Unexpected exception"); + } + }); + result = BError(BError::Codes::OK); + return BError(BError::Codes::OK); + } else if (action == BConstants::ServiceSchedAction::CLEAN) { + result = BError::BackupErrorCode::E_CANCEL_NOT_TASK; + return BError(BError::Codes::OK); + } else { + result = BError::BackupErrorCode::E_CANCEL_FAIL; + return BError(BError::Codes::OK); + } +} } // namespace OHOS::FileManagement::Backup diff --git a/services/backup_sa/src/module_ipc/service_stub.cpp b/services/backup_sa/src/module_ipc/service_stub.cpp index 20dedbbba..ab26aaf9d 100644 --- a/services/backup_sa/src/module_ipc/service_stub.cpp +++ b/services/backup_sa/src/module_ipc/service_stub.cpp @@ -50,6 +50,8 @@ void ServiceStub::ServiceStubSupplement() &ServiceStub::CmdStartExtTimer; opToInterfaceMap_[static_cast(IServiceInterfaceCode::SERVICE_CMD_START_FWK_TIMER)] = &ServiceStub::CmdStartFwkTimer; + opToInterfaceMap_[static_cast(IServiceInterfaceCode::SERVICE_CMD_CANCEL_BUNDLE_NAME)] = + &ServiceStub::CmdCancel; } void ServiceStub::ServiceStubSuppAppendBundles() @@ -697,4 +699,19 @@ bool ServiceStub::ReadParcelableVector(std::vector &parcelableInfos, MessageP return true; } + +int32_t ServiceStub::CmdCancel(MessageParcel &data, MessageParcel &reply) +{ + HILOGI("ServiceStub::CmdCancel Begin."); + string bundleName; + if (!data.ReadString(bundleName)) { + return BError(BError::Codes::SA_INVAL_ARG, "Failed to receive bundleName").GetCode(); + } + int result = BError::BackupErrorCode::E_CANCEL_FAIL; + ErrCode res = Cancel(bundleName, result); + if (!reply.WriteInt32(result)) { + return BError(BError::Codes::SA_BROKEN_IPC, string("Failed to send the result ") + to_string(res)); + } + return res; +} } // namespace OHOS::FileManagement::Backup diff --git a/tests/mock/backup_kit_inner/b_session_backup_mock.cpp b/tests/mock/backup_kit_inner/b_session_backup_mock.cpp index e06d1fb42..0fe6a3e7c 100644 --- a/tests/mock/backup_kit_inner/b_session_backup_mock.cpp +++ b/tests/mock/backup_kit_inner/b_session_backup_mock.cpp @@ -97,4 +97,9 @@ ErrCode BSessionBackup::Release() { return BError(BError::Codes::OK); } + +ErrCode BSessionBackup::Cancel(std::string bundleName) +{ + return BError(BError::Codes::OK); +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/mock/backup_kit_inner/b_session_restore_async_mock.cpp b/tests/mock/backup_kit_inner/b_session_restore_async_mock.cpp index 9e680cd34..b6c03de3a 100644 --- a/tests/mock/backup_kit_inner/b_session_restore_async_mock.cpp +++ b/tests/mock/backup_kit_inner/b_session_restore_async_mock.cpp @@ -136,4 +136,9 @@ ErrCode BSessionRestoreAsync::Release() } void BSessionRestoreAsync::RegisterBackupServiceDied(function functor) {} + +ErrCode BSessionRestoreAsync::Cancel(std::string bundleName) +{ + return BError(BError::Codes::OK); +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/mock/backup_kit_inner/b_session_restore_mock.cpp b/tests/mock/backup_kit_inner/b_session_restore_mock.cpp index b3138a19e..164500fe3 100644 --- a/tests/mock/backup_kit_inner/b_session_restore_mock.cpp +++ b/tests/mock/backup_kit_inner/b_session_restore_mock.cpp @@ -109,4 +109,9 @@ ErrCode BSessionRestore::Release() } void BSessionRestore::RegisterBackupServiceDied(function functor) {} + +ErrCode BSessionRestore::Cancel(std::string bundleName) +{ + return BError(BError::Codes::OK); +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/mock/backup_kit_inner/service_proxy_mock.cpp b/tests/mock/backup_kit_inner/service_proxy_mock.cpp index 04c6afe8a..184d574a0 100644 --- a/tests/mock/backup_kit_inner/service_proxy_mock.cpp +++ b/tests/mock/backup_kit_inner/service_proxy_mock.cpp @@ -124,6 +124,12 @@ ErrCode ServiceProxy::Release() return BError(BError::Codes::OK); } +ErrCode ServiceProxy::Cancel(std::string bundleName, int &result) +{ + result = BError(BError::Codes::OK); + return BError(BError::Codes::OK); +} + UniqueFd ServiceProxy::GetLocalCapabilitiesIncremental(const vector &bundleNames) { return UniqueFd(-1); diff --git a/tests/mock/module_ipc/include/service_stub_mock.h b/tests/mock/module_ipc/include/service_stub_mock.h index 85a71336f..bdcbc8730 100644 --- a/tests/mock/module_ipc/include/service_stub_mock.h +++ b/tests/mock/module_ipc/include/service_stub_mock.h @@ -37,6 +37,7 @@ public: virtual int32_t CmdAppendBundlesDetailsBackupSession(MessageParcel&, MessageParcel&) = 0; virtual int32_t CmdFinish(MessageParcel&, MessageParcel&) = 0; virtual int32_t CmdRelease(MessageParcel&, MessageParcel&) = 0; + virtual int32_t CmdCancel(MessageParcel&, MessageParcel&) = 0; virtual int32_t CmdGetLocalCapabilitiesIncremental(MessageParcel&, MessageParcel&) = 0; virtual int32_t CmdGetAppLocalListAndDoIncrementalBackup(MessageParcel&, MessageParcel&) = 0; virtual int32_t CmdInitIncrementalBackupSession(MessageParcel&, MessageParcel&) = 0; diff --git a/tests/mock/module_ipc/service_mock.cpp b/tests/mock/module_ipc/service_mock.cpp index 4f6a1d0d1..ee95b5ce0 100644 --- a/tests/mock/module_ipc/service_mock.cpp +++ b/tests/mock/module_ipc/service_mock.cpp @@ -160,6 +160,12 @@ ErrCode Service::Release() return BError(BError::Codes::OK); } +ErrCode Service::Cancel(std::string bundleName, int &result) +{ + result = BError(BError::Codes::OK); + return BError(BError::Codes::OK); +} + UniqueFd Service::GetLocalCapabilitiesIncremental(const std::vector &bundleNames) { return UniqueFd(-1); @@ -300,4 +306,6 @@ std::vector Service::GetSupportBackupBundleNames(vector&, vector&, bool) {} void Service::SetBundleIncDataInfo(const std::vector&, std::vector&) {} + +void Service::StopApp(std::string bundleName, wptr ptr) {} } // namespace OHOS::FileManagement::Backup diff --git a/tests/mock/module_ipc/service_stub_mock.cpp b/tests/mock/module_ipc/service_stub_mock.cpp index 101f2fdfb..3de75ffdd 100644 --- a/tests/mock/module_ipc/service_stub_mock.cpp +++ b/tests/mock/module_ipc/service_stub_mock.cpp @@ -81,6 +81,8 @@ void ServiceStub::ServiceStubSupplement() &ServiceStub::CmdUpdateSendRate; opToInterfaceMap_[static_cast(IServiceInterfaceCode::SERVICE_CMD_REPORT_APP_PROCESS_INFO)] = &ServiceStub::CmdReportAppProcessInfo; + opToInterfaceMap_[static_cast(IServiceInterfaceCode::SERVICE_CMD_CANCEL_BUNDLE_NAME)] = + &ServiceStub::CmdCancel; } int32_t ServiceStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) @@ -272,6 +274,19 @@ int32_t ServiceStub::CmdRelease(MessageParcel &data, MessageParcel &reply) return BError(BError::Codes::OK); } +int32_t ServiceStub::CmdCancel(MessageParcel &data, MessageParcel &reply) +{ + int ret = ERR_OK; + string bundleName; + if (!data.ReadString(bundleName)) { + return BError(BError::Codes::SA_INVAL_ARG, "Failed to receive bundleName"); + } + int result = BError::BackupErrorCode::E_CANCEL_FAIL; + ret = Cancel(bundleName, result); + reply.WriteInt32(result); + return ret; +} + int32_t ServiceStub::CmdGetLocalCapabilitiesIncremental(MessageParcel &data, MessageParcel &reply) { return BError(BError::Codes::OK); diff --git a/tests/mock/module_ipc/src/service_stub_mock.cpp b/tests/mock/module_ipc/src/service_stub_mock.cpp index df67aac7d..7272d6359 100644 --- a/tests/mock/module_ipc/src/service_stub_mock.cpp +++ b/tests/mock/module_ipc/src/service_stub_mock.cpp @@ -117,6 +117,11 @@ int32_t ServiceStub::CmdRelease(MessageParcel &data, MessageParcel &reply) return BServiceStub::stub->CmdRelease(data, reply); } +int32_t ServiceStub::CmdCancel(MessageParcel &data, MessageParcel &reply) +{ + return BServiceStub::stub->CmdCancel(data, reply); +} + int32_t ServiceStub::CmdGetLocalCapabilitiesIncremental(MessageParcel &data, MessageParcel &reply) { return BServiceStub::stub->CmdGetLocalCapabilitiesIncremental(data, reply); diff --git a/tests/moduletests/backup_kit_inner/b_session_backup_test.cpp b/tests/moduletests/backup_kit_inner/b_session_backup_test.cpp index 10b69da7d..b71d7be11 100644 --- a/tests/moduletests/backup_kit_inner/b_session_backup_test.cpp +++ b/tests/moduletests/backup_kit_inner/b_session_backup_test.cpp @@ -375,4 +375,37 @@ HWTEST_F(BSessionBackupTest, SUB_backup_b_session_backup_0900, testing::ext::Tes } GTEST_LOG_(INFO) << "BSessionBackupTest-end SUB_backup_b_session_backup_0900"; } + +/** + * @tc.number: SUB_backup_b_session_backup_1000 + * @tc.name: SUB_backup_b_session_backup_1000 + * @tc.desc: 测试Cancel接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(BSessionBackupTest, SUB_backup_b_session_backup_1000, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "BSessionBackupTest-Cancel SUB_backup_b_session_backup_1000"; + try { + if (backupPtr_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_b_session_backup_1000 backupPtr_ == nullptr"; + return; + } + BundleName bundleName; + GTEST_LOG_(INFO) << "GetInstance is true"; + SetMockGetInstance(true); + auto ret = backupPtr_->Cancel(bundleName); + EXPECT_EQ(ret, ErrCode(BError::Codes::OK)); + GTEST_LOG_(INFO) << "GetInstance is false"; + SetMockGetInstance(false); + ret = backupPtr_->Cancel(bundleName); + EXPECT_NE(ret, ErrCode(BError::Codes::OK)); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BSessionBackupTest-an exception occurred by Cancel."; + } + GTEST_LOG_(INFO) << "BSessionBackupTest-end SUB_backup_b_session_backup_1000"; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/moduletests/backup_kit_inner/b_session_restore_async_test.cpp b/tests/moduletests/backup_kit_inner/b_session_restore_async_test.cpp index 9d6d8e81a..aa3f5a3ed 100644 --- a/tests/moduletests/backup_kit_inner/b_session_restore_async_test.cpp +++ b/tests/moduletests/backup_kit_inner/b_session_restore_async_test.cpp @@ -338,4 +338,35 @@ HWTEST_F(BSessionRestoreAsyncTest, SUB_backup_b_session_restore_async_0700, test } GTEST_LOG_(INFO) << "BSessionRestoreAsyncTest-end SUB_backup_b_session_restore_async_0700"; } + +/** + * @tc.number: SUB_backup_b_session_restore_async_0800 + * @tc.name: SUB_backup_b_session_restore_async_0800 + * @tc.desc: 测试Cancel接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I7L7A6 + */ +HWTEST_F(BSessionRestoreAsyncTest, SUB_backup_b_session_restore_async_0800, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "BSessionRestoreAsyncTest-begin SUB_backup_b_session_restore_async_0800"; + try { + if (restorePtr_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_b_session_restore_async_0800 restorePtr_ == nullptr"; + return; + } + BundleName bundleName; + SetMockGetInstance(false); + ErrCode ret = restorePtr_->Cancel(bundleName); + EXPECT_NE(ret, ErrCode(BError::Codes::OK)); + SetMockGetInstance(true); + ret = restorePtr_->Cancel(bundleName); + EXPECT_EQ(ret, ErrCode(BError::Codes::OK)); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BSessionRestoreAsyncTest-an exception occurred by Cancel."; + } + GTEST_LOG_(INFO) << "BSessionRestoreAsyncTest-end SUB_backup_b_session_restore_async_0800"; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/moduletests/backup_kit_inner/b_session_restore_test.cpp b/tests/moduletests/backup_kit_inner/b_session_restore_test.cpp index 1ab1115b1..0c2b9b32c 100644 --- a/tests/moduletests/backup_kit_inner/b_session_restore_test.cpp +++ b/tests/moduletests/backup_kit_inner/b_session_restore_test.cpp @@ -479,4 +479,38 @@ HWTEST_F(BSessionRestoreTest, SUB_backup_b_session_restore_1000, testing::ext::T } GTEST_LOG_(INFO) << "BSessionRestoreTest-end SUB_backup_b_session_restore_1000"; } + +/** + * @tc.number: SUB_backup_b_session_restore_1100 + * @tc.name: SUB_backup_b_session_restore_1100 + * @tc.desc: 测试Cancel接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(BSessionRestoreTest, SUB_backup_b_session_restore_1100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "BSessionRestoreTest-begin SUB_backup_b_session_restore_1100"; + try { + if (restorePtr_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_b_session_restore_1100 restorePtr_ == nullptr"; + return; + } + GTEST_LOG_(INFO) << "GetInstance is false"; + BundleName bundleName; + SetMockGetInstance(false); + auto ret = restorePtr_->Cancel(bundleName); + EXPECT_NE(ret, ErrCode(BError::Codes::OK)); + + GTEST_LOG_(INFO) << "GetInstance is true"; + SetMockGetInstance(true); + ret = restorePtr_->Cancel(bundleName); + EXPECT_EQ(ret, ErrCode(BError::Codes::OK)); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BSessionRestoreTest-an exception occurred by Cancel."; + } + GTEST_LOG_(INFO) << "BSessionRestoreTest-end SUB_backup_b_session_restore_1100"; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/unittests/backup_api/backup_impl/include/i_service_mock.h b/tests/unittests/backup_api/backup_impl/include/i_service_mock.h index a0da61edc..4c814b492 100644 --- a/tests/unittests/backup_api/backup_impl/include/i_service_mock.h +++ b/tests/unittests/backup_api/backup_impl/include/i_service_mock.h @@ -163,6 +163,12 @@ public: return BError(BError::Codes::OK); } + ErrCode Cancel(std::string bundleName, int &result) override + { + result = BError(BError::Codes::OK); + return BError(BError::Codes::OK); + } + UniqueFd GetLocalCapabilitiesIncremental(const std::vector &bundleNames) override { return UniqueFd(-1); diff --git a/tests/unittests/backup_api/backup_impl/service_proxy_test.cpp b/tests/unittests/backup_api/backup_impl/service_proxy_test.cpp index 63ad75d97..d1fb27bb8 100644 --- a/tests/unittests/backup_api/backup_impl/service_proxy_test.cpp +++ b/tests/unittests/backup_api/backup_impl/service_proxy_test.cpp @@ -1326,4 +1326,33 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_StartFwkTimer_0100, testing::ext::T EXPECT_NE(ret, BError(BError::Codes::OK)); GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_StartFwkTimer_0100"; } + +/** + * @tc.number: SUB_Service_proxy_Cancel_0100 + * @tc.name: SUB_Service_proxy_Cancel_0100 + * @tc.desc: 测试 Cancel 调用成功和失败 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I90ZV5 + */ +HWTEST_F(ServiceProxyTest, SUB_Service_proxy_Cancel_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_Cancel_0100"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_Cancel_0100 proxy_ == nullptr"; + return; + } + EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) + .Times(2) + .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest)) + .WillOnce(Return(EPERM)); + std::string bundleName; + int result; + ErrCode ret = proxy_->Cancel(bundleName, result); + EXPECT_EQ(ret, BError(BError::Codes::OK)); + ret = proxy_->Cancel(bundleName, result); + EXPECT_NE(ret, BError(BError::Codes::OK)); + GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_Cancel_0100"; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp b/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp index 9d43383b8..4616dedce 100644 --- a/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp @@ -184,6 +184,8 @@ void Service::OnSABackup(const std::string &bundleName, void Service::OnSARestore(const std::string &bundleName, const std::string &result, const ErrCode &errCode) {} +void Service::NotifyCallerCurAppDone(ErrCode errCode, const std::string &callerName) {} + void Service::SendEndAppGalleryNotify(const BundleName &bundleName) { } @@ -1077,4 +1079,53 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_SetCurrentBackupSessProp } GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_SetCurrentBackupSessProperties_0200"; } + +/** + * @tc.number: SUB_ServiceIncremental_Cancel_0000 + * @tc.name: SUB_ServiceIncremental_Cancel_0000 + * @tc.desc: 测试 Cancel 的正常/异常分支 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: issueIAKC3I + */ +HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_Cancel_0000, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_Cancel_0000"; + try { + string bundleName = "com.example.app2backup"; + BackupExtInfo info {}; + info.backupExtName = "com.example.app2backup"; + SvcSessionManager::Impl impl; + impl.backupExtNameMap.insert(make_pair(bundleName, info)); + int32_t result; + + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + service->Cancel(bundleName, result); + EXPECT_EQ(result, BError(BError::BackupErrorCode::E_CANCEL_NOT_TASK).GetCode()); + + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetImpl()).WillOnce(Return(impl)); + EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::CLEAN)); + service->Cancel(bundleName, result); + EXPECT_EQ(result, BError(BError::BackupErrorCode::E_CANCEL_NOT_TASK).GetCode()); + + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetImpl()).WillOnce(Return(impl)); + EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::START)); + service->Cancel(bundleName, result); + EXPECT_EQ(result, BError(BError::BackupErrorCode::E_CANCEL_FAIL).GetCode()); + + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)) + .WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetImpl()).WillOnce(Return(impl)); + EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING)); + service->Cancel(bundleName, result); + EXPECT_EQ(result, BError(BError::Codes::OK).GetCode()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by Cancel."; + } + GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_Cancel_0000"; +} } \ No newline at end of file diff --git a/tests/unittests/backup_sa/module_ipc/service_other_test.cpp b/tests/unittests/backup_sa/module_ipc/service_other_test.cpp index e59fd30f2..db5709b68 100644 --- a/tests/unittests/backup_sa/module_ipc/service_other_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/service_other_test.cpp @@ -44,6 +44,12 @@ ErrCode Service::Release() return BError(BError::Codes::OK); } +ErrCode Service::Cancel(std::string bundleName, int &result) +{ + result = BError(BError::Codes::OK); + return BError(BError::Codes::OK); +} + UniqueFd Service::GetLocalCapabilitiesIncremental(const std::vector&) { return UniqueFd(-1); diff --git a/tests/unittests/backup_sa/module_ipc/service_stub_test.cpp b/tests/unittests/backup_sa/module_ipc/service_stub_test.cpp index 632d7def5..8d5e81697 100644 --- a/tests/unittests/backup_sa/module_ipc/service_stub_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/service_stub_test.cpp @@ -65,6 +65,7 @@ public: ErrCode(const std::vector &bundleNames, const std::vector &bundleInfos)); MOCK_METHOD0(Finish, ErrCode()); MOCK_METHOD0(Release, ErrCode()); + MOCK_METHOD2(Cancel, ErrCode(std::string bundleName, int &result)); MOCK_METHOD1(GetLocalCapabilitiesIncremental, UniqueFd(const std::vector &bundleNames)); MOCK_METHOD0(GetAppLocalListAndDoIncrementalBackup, ErrCode()); MOCK_METHOD1(InitIncrementalBackupSession, ErrCode(sptr remote)); @@ -709,6 +710,50 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_Release_0100, testing::ext:: GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_Release_0100"; } +/** + * @tc.number: SUB_backup_sa_ServiceStub_Cancel_0100 + * @tc.name: SUB_backup_sa_ServiceStub_Cancel_0100 + * @tc.desc: Test function of Cancel interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6URNZ + */ +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_Cancel_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_Cancel_0100"; + try { + MessageParcel data; + MessageParcel reply; + EXPECT_TRUE(service != nullptr); + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false)); + auto err = service->CmdCancel(data, reply); + EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG)); + + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)); + EXPECT_CALL(*service, Cancel(_, _)).WillOnce(Return(BError::BackupErrorCode::E_CANCEL_FAIL)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); + err = service->CmdCancel(data, reply); + EXPECT_EQ(err, BError(BError::BackupErrorCode::E_CANCEL_FAIL)); + + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)); + EXPECT_CALL(*service, Cancel(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); + err = service->CmdCancel(data, reply); + EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC)); + + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)); + EXPECT_CALL(*service, Cancel(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); + err = service->CmdCancel(data, reply); + EXPECT_EQ(err, BError(BError::Codes::OK)); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by Cancel."; + } + GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_Cancel_0100"; +} + /** * @tc.number: SUB_backup_sa_ServiceStub_GetBackupInfo_0100 * @tc.name: SUB_backup_sa_ServiceStub_GetBackupInfo_0100 diff --git a/tests/unittests/backup_sa/session/b_incremental_session_test.cpp b/tests/unittests/backup_sa/session/b_incremental_session_test.cpp index 8c0cfb086..6224dd2a6 100644 --- a/tests/unittests/backup_sa/session/b_incremental_session_test.cpp +++ b/tests/unittests/backup_sa/session/b_incremental_session_test.cpp @@ -673,4 +673,94 @@ HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_2000, testing::e } GTEST_LOG_(INFO) << "IncrementalSessionTest-end SUB_b_incremental_session_test_2000"; } + +/** + * @tc.number: SUB_b_incremental_session_test_2100 + * @tc.name: SUB_b_incremental_session_test_2100 + * @tc.desc: 测试 Cancel 接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: issuesI9KPRL + */ +HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_2100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "IncrementalSessionTest-begin SUB_b_incremental_session_test_2100"; + try { + ServiceProxy::serviceProxy_ = nullptr; + std::string bundleName; + EXPECT_TRUE(backupSession != nullptr); + auto err = backupSession->Cancel(bundleName); + EXPECT_EQ(err, BError(BError::BackupErrorCode::E_CANCEL_FAIL).GetCode()); + + EXPECT_CALL(*proxy, Cancel(_, _)).WillOnce(DoAll(SetArgReferee<1>(0), Return(0))); + ServiceProxy::serviceProxy_ = proxy; + err = backupSession->Cancel(bundleName); + EXPECT_EQ(err, BError(BError::Codes::OK).GetCode()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "IncrementalSessionTest-an exception occurred by Cancel."; + } + GTEST_LOG_(INFO) << "IncrementalSessionTest-end SUB_b_incremental_session_test_2100"; +} + +/** + * @tc.number: SUB_b_incremental_session_test_2200 + * @tc.name: SUB_b_incremental_session_test_2200 + * @tc.desc: 测试 Cancel 接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: issuesI9KPRL + */ +HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_2200, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "IncrementalSessionTest-begin SUB_b_incremental_session_test_2200"; + try { + ServiceProxy::serviceProxy_ = nullptr; + std::string bundleName; + EXPECT_TRUE(restoreSession != nullptr); + auto err = restoreSession->Cancel(bundleName); + EXPECT_EQ(err, BError(BError::BackupErrorCode::E_CANCEL_FAIL).GetCode()); + + EXPECT_CALL(*proxy, Cancel(_, _)).WillOnce(DoAll(SetArgReferee<1>(0), Return(0))); + ServiceProxy::serviceProxy_ = proxy; + err = restoreSession->Cancel(bundleName); + EXPECT_EQ(err, BError(BError::Codes::OK).GetCode()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "IncrementalSessionTest-an exception occurred by Cancel."; + } + GTEST_LOG_(INFO) << "IncrementalSessionTest-end SUB_b_incremental_session_test_2200"; +} + +/** + * @tc.number: SUB_b_incremental_session_test_2300 + * @tc.name: SUB_b_incremental_session_test_2300 + * @tc.desc: 测试 Cancel 接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: issuesI9KPRL + */ +HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_2300, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "IncrementalSessionTest-begin SUB_b_incremental_session_test_2300"; + try { + ServiceProxy::serviceProxy_ = nullptr; + std::string bundleName; + EXPECT_TRUE(restoreAsyncSession != nullptr); + auto err = restoreAsyncSession->Cancel(bundleName); + EXPECT_EQ(err, BError(BError::BackupErrorCode::E_CANCEL_FAIL).GetCode()); + + EXPECT_CALL(*proxy, Cancel(_, _)).WillOnce(DoAll(SetArgReferee<1>(0), Return(0))); + ServiceProxy::serviceProxy_ = proxy; + err = restoreAsyncSession->Cancel(bundleName); + EXPECT_EQ(err, BError(BError::Codes::OK).GetCode()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "IncrementalSessionTest-an exception occurred by Cancel."; + } + GTEST_LOG_(INFO) << "IncrementalSessionTest-end SUB_b_incremental_session_test_2300"; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/unittests/backup_sa/session/service_proxy_mock.cpp b/tests/unittests/backup_sa/session/service_proxy_mock.cpp index ebcf680de..ef501445d 100644 --- a/tests/unittests/backup_sa/session/service_proxy_mock.cpp +++ b/tests/unittests/backup_sa/session/service_proxy_mock.cpp @@ -101,6 +101,12 @@ ErrCode ServiceProxy::Release() return BError(BError::Codes::OK); } +ErrCode ServiceProxy::Cancel(std::string bundleName, int &result) +{ + result = BError(BError::Codes::OK); + return BError(BError::Codes::OK); +} + UniqueFd ServiceProxy::GetLocalCapabilitiesIncremental(const vector &bundleNames) { return UniqueFd(-1); diff --git a/tests/unittests/backup_sa/session/service_proxy_mock.h b/tests/unittests/backup_sa/session/service_proxy_mock.h index 521d3904a..651451b0a 100644 --- a/tests/unittests/backup_sa/session/service_proxy_mock.h +++ b/tests/unittests/backup_sa/session/service_proxy_mock.h @@ -45,6 +45,7 @@ public: MOCK_METHOD1(AppendBundlesBackupSession, ErrCode(const std::vector &bundleNames)); MOCK_METHOD0(Finish, ErrCode()); MOCK_METHOD0(Release, ErrCode()); + MOCK_METHOD2(Cancel, ErrCode(std::string bundleName, int &result)); MOCK_METHOD1(GetLocalCapabilitiesIncremental, UniqueFd(const std::vector &bundleNames)); MOCK_METHOD1(InitIncrementalBackupSession, ErrCode(sptr remote)); MOCK_METHOD1(AppendBundlesIncrementalBackupSession, ErrCode(const std::vector &bundlesToBackup)); diff --git a/utils/include/b_error/b_error.h b/utils/include/b_error/b_error.h index 3863761c7..8fe3c9257 100644 --- a/utils/include/b_error/b_error.h +++ b/utils/include/b_error/b_error.h @@ -117,6 +117,8 @@ public: E_UNPACKET = 13500008, E_BEF = 13500009, E_TASKFAIL = 13500010, + E_CANCEL_FAIL = 13500011, + E_CANCEL_NOT_TASK = 13500012, }; public: @@ -317,6 +319,8 @@ private: {BackupErrorCode::E_EXCEPTION, BackupErrorCode::E_EXCEPTION}, {BackupErrorCode::E_UNPACKET, BackupErrorCode::E_UNPACKET}, {BackupErrorCode::E_BEF, BackupErrorCode::E_BEF}, + {BackupErrorCode::E_CANCEL_FAIL, BackupErrorCode::E_CANCEL_FAIL}, + {BackupErrorCode::E_CANCEL_NOT_TASK, BackupErrorCode::E_CANCEL_NOT_TASK}, }; static inline const std::map sysErrnoCodeTable_ { @@ -352,6 +356,8 @@ private: {BackupErrorCode::E_EXCEPTION, "Extension throw exception"}, {BackupErrorCode::E_UNPACKET, "Untar failed"}, {BackupErrorCode::E_BEF, "SA failed to boot application extension"}, + {BackupErrorCode::E_CANCEL_FAIL, "Cancel backup or restore task fail"}, + {BackupErrorCode::E_CANCEL_NOT_TASK, "Cancel a backup or restore task that does not exist"}, }; private: -- Gitee