From 82db2ccda2502d0c56f02ef50fe1666ddc8ba36f Mon Sep 17 00:00:00 2001 From: libo429 Date: Mon, 23 Dec 2024 17:03:30 +0800 Subject: [PATCH] add cancel api part1 Signed-off-by: libo429 --- .../backup_kit_inner/src/b_session_backup.cpp | 17 ++++ .../src/service_incremental_proxy.cpp | 29 ++++++ .../backup_kit_inner/impl/b_session_backup.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 | 46 +++++++++ .../js/backup/session_backup_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 | 97 +++++++++++++++++++ .../backup_sa/src/module_ipc/service_stub.cpp | 17 ++++ .../backup_kit_inner/service_proxy_mock.cpp | 6 ++ tests/mock/module_ipc/service_mock.cpp | 8 ++ .../backup_impl/include/i_service_mock.h | 6 ++ .../module_ipc/service_incremental_test.cpp | 2 + .../module_ipc/service_other_test.cpp | 6 ++ .../module_ipc/service_stub_test.cpp | 1 + .../backup_sa/session/service_proxy_mock.cpp | 6 ++ .../backup_sa/session/service_proxy_mock.h | 1 + utils/include/b_error/b_error.h | 6 ++ 21 files changed, 264 insertions(+) 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..48ec7869f 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_UNSTARTED_TASK; + 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..e53444850 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,33 @@ bool ServiceProxy::WriteParcelableVector(const std::vector &parcelableVector, return true; } + +ErrCode ServiceProxy::Cancel(std::string bundleName, int32_t &result) +{ + HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); + if (!Remote()) { + return BError(BError::Codes::SDK_INVAL_ARG, "Remote is nullptr").GetCode(); + } + 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), 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_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/i_service.h b/interfaces/inner_api/native/backup_kit_inner/impl/i_service.h index 16ddf4c62..630867b95 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, int32_t &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 c4ab2d359..f6027fab4 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, SERVICE_CMD_STOP_EXT_TIMER, SERVICE_CMD_REFRESH_DATA_SIZE, }; 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 94271d4bc..07071b41b 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, int32_t &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 bfbb9c34a..c39d3196a 100644 --- a/interfaces/kits/js/backup/session_backup_n_exporter.cpp +++ b/interfaces/kits/js/backup/session_backup_n_exporter.cpp @@ -493,12 +493,58 @@ 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."); + return nullptr; + } + + int result = backupEntity->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/services/backup_sa/include/module_ipc/service.h b/services/backup_sa/include/module_ipc/service.h index 5319faf48..8e20ddec8 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, int32_t &result) override; UniqueFd GetLocalCapabilitiesIncremental(const std::vector &bundleNames) override; ErrCode GetAppLocalListAndDoIncrementalBackup() override; @@ -563,6 +564,8 @@ private: void SetBundleIncDataInfo(const std::vector &bundlesToBackup, std::vector &supportBundleNames); + + void CancelTask(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 09dc21490..8ccaddf56 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 bf63988a9..cb535cb74 100644 --- a/services/backup_sa/src/module_ipc/service_incremental.cpp +++ b/services/backup_sa/src/module_ipc/service_incremental.cpp @@ -815,4 +815,101 @@ void Service::SetBundleIncDataInfo(const std::vector& bundlesT session_->SetIncrementalData(bundleInfo); } } + +void Service::CancelTask(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 CancelTask 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; + } + do { + std::lock_guard lock(mutexPtr->callbackMutex); + auto tempBackUpConnection = session->GetExtConnection(bundleName); + auto backUpConnection = tempBackUpConnection.promote(); + if (backUpConnection == nullptr) { + HILOGE("Promote backUpConnection ptr is null."); + break; + } + auto proxy = backUpConnection->GetBackupExtProxy(); + if (!proxy) { + HILOGE("Extension backup Proxy is empty."); + break; + } + 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); + } + } while (0); + thisPtr->RemoveExtensionMutex(bundleName); + thisPtr->OnAllBundlesFinished(BError(BError::Codes::OK)); +} + +ErrCode Service::Cancel(std::string bundleName, int32_t &result) +{ + HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); + HILOGI("Begin, bundle name:%{public}s", bundleName.c_str()); + try { + if (session_ == nullptr) { + HILOGE("Cancel error, session is null"); + return BError(BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK); + } + 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_NO_TASK; + return BError(BError::Codes::OK); + } + auto action = session_->GetServiceSchedAction(bundleName); + auto task = [this, bundleName]() { + try { + CancelTask(bundleName, wptr(this)); + } catch (const BError &e) { + HILOGE("CancelTask failed, errCode = %{public}d", e.GetCode()); + } catch (...) { + HILOGI("Unexpected exception"); + } + }; + if (action == BConstants::ServiceSchedAction::RUNNING) { + threadPool_.AddTask(task); + result = BError(BError::Codes::OK); + return BError(BError::Codes::OK); + } + if (action == BConstants::ServiceSchedAction::CLEAN) { + result = BError::BackupErrorCode::E_CANCEL_NO_TASK; + } else { + result = BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK; + } + return BError(BError::Codes::OK); + } catch (const BError &e) { + HILOGE("Cancel failed, errCode = %{public}d", e.GetCode()); + return e.GetCode(); + } catch (...) { + HILOGI("Unexpected exception"); + return EPERM; + } +} } // 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 abf1a4563..89eda115d 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)] = + &ServiceStub::CmdCancel; opToInterfaceMap_[static_cast(IServiceInterfaceCode::SERVICE_CMD_STOP_EXT_TIMER)] = &ServiceStub::CmdStopExtTimer; } @@ -735,4 +737,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_UNSTARTED_TASK; + 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/service_proxy_mock.cpp b/tests/mock/backup_kit_inner/service_proxy_mock.cpp index 7b5340c0b..4ed01cd8f 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, int32_t &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/service_mock.cpp b/tests/mock/module_ipc/service_mock.cpp index 99bcabc99..4172f6d0d 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, int32_t &result) +{ + result = BError(BError::Codes::OK); + return BError(BError::Codes::OK); +} + UniqueFd Service::GetLocalCapabilitiesIncremental(const std::vector &bundleNames) { return UniqueFd(-1); @@ -310,4 +316,6 @@ std::vector Service::GetSupportBackupBundleNames(vector&, vector&, bool) {} void Service::SetBundleIncDataInfo(const std::vector&, std::vector&) {} + +void Service::CancelTask(std::string bundleName, wptr ptr) {} } // namespace OHOS::FileManagement::Backup 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 20ebe6b6e..d0600cbc6 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 @@ -173,6 +173,12 @@ public: return BError(BError::Codes::OK); } + ErrCode Cancel(std::string bundleName, int32_t &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_sa/module_ipc/service_incremental_test.cpp b/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp index bb1d1fb06..0c3dea1d1 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) { } 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 814af6549..b4e1412c4 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, int32_t &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 015a5c0b0..1748c482f 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, int32_t &result)); MOCK_METHOD1(GetLocalCapabilitiesIncremental, UniqueFd(const std::vector &bundleNames)); MOCK_METHOD0(GetAppLocalListAndDoIncrementalBackup, ErrCode()); MOCK_METHOD1(InitIncrementalBackupSession, ErrCode(sptr remote)); diff --git a/tests/unittests/backup_sa/session/service_proxy_mock.cpp b/tests/unittests/backup_sa/session/service_proxy_mock.cpp index c27b68417..d41b0a5b8 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, int32_t &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 9d213bcd6..18df7af1a 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, int32_t &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 5056c0ba4..9e685afd8 100644 --- a/utils/include/b_error/b_error.h +++ b/utils/include/b_error/b_error.h @@ -118,6 +118,8 @@ public: E_UNPACKET = 13500008, E_BEF = 13500009, E_TASKFAIL = 13500010, + E_CANCEL_UNSTARTED_TASK = 13500011, + E_CANCEL_NO_TASK = 13500012, }; public: @@ -318,6 +320,8 @@ private: {BackupErrorCode::E_EXCEPTION, BackupErrorCode::E_EXCEPTION}, {BackupErrorCode::E_UNPACKET, BackupErrorCode::E_UNPACKET}, {BackupErrorCode::E_BEF, BackupErrorCode::E_BEF}, + {BackupErrorCode::E_CANCEL_UNSTARTED_TASK, BackupErrorCode::E_CANCEL_UNSTARTED_TASK}, + {BackupErrorCode::E_CANCEL_NO_TASK, BackupErrorCode::E_CANCEL_NO_TASK}, }; static inline const std::map sysErrnoCodeTable_ { @@ -353,6 +357,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_UNSTARTED_TASK, "Cancel unstarted backup or restore task "}, + {BackupErrorCode::E_CANCEL_NO_TASK, "Cancel a backup or restore task that does not exist"}, }; private: -- Gitee