diff --git a/frameworks/native/backup_ext/include/ext_backup.h b/frameworks/native/backup_ext/include/ext_backup.h index 395290b8ec3ca2ae7c03fda0216a30ef3a1504c9..c0599ba3e1296e4bacbe506ffddd4a4fecc6d64a 100644 --- a/frameworks/native/backup_ext/include/ext_backup.h +++ b/frameworks/native/backup_ext/include/ext_backup.h @@ -152,6 +152,11 @@ public: */ virtual ErrCode OnProcess(std::function callback); + /* + * @brief Called do onRelease. + */ + virtual ErrCode OnRelease(std::function callback, int32_t scenario); + /** * @brief 数据迁移判断 * diff --git a/frameworks/native/backup_ext/include/ext_backup_js.h b/frameworks/native/backup_ext/include/ext_backup_js.h index c69cc77a0c9e3bfcf02d46cfb9f8337cd71a41f7..f7f0c14f1e9ee6a96908427e7a5f98e8a019995e 100644 --- a/frameworks/native/backup_ext/include/ext_backup_js.h +++ b/frameworks/native/backup_ext/include/ext_backup_js.h @@ -137,6 +137,14 @@ public: */ ErrCode OnProcess(std::function callback) override; + /** + * @brief Call the app's onRelease + * + * @param callback The callBack. + * @param scenario The scenario: backup = 1, restore = 2. + */ + ErrCode OnRelease(std::function callback, int32_t scenario) override; + public: explicit ExtBackupJs(AbilityRuntime::JsRuntime &jsRuntime); ~ExtBackupJs(); @@ -152,6 +160,8 @@ private: std::function &argv)> ParseBackupExInfo(); + std::function &argv)> ParseReleaseInfo(); + ErrCode CallJSRestoreEx(); ErrCode CallJSRestore(); ErrCode CallJsOnBackupEx(); @@ -166,10 +176,12 @@ private: std::shared_ptr callbackInfoEx_; std::shared_ptr callbackInfo_; std::shared_ptr onProcessCallback_; + std::shared_ptr onReleaseCallback_; std::condition_variable callJsCon_; std::mutex callJsMutex_; std::atomic callExtDefaultFunc_ {false}; // extension default method, onBackup or onRestore std::atomic callJsExMethodDone_ {false}; + int32_t scenario_ { 0 }; }; } // namespace OHOS::FileManagement::Backup diff --git a/frameworks/native/backup_ext/include/ext_extension.h b/frameworks/native/backup_ext/include/ext_extension.h index 1a0086f2e7679b276d042f4c0a8f6e20641f2875..e41e31346bb35532ea87a6e97c48878a4ecdc20e 100644 --- a/frameworks/native/backup_ext/include/ext_extension.h +++ b/frameworks/native/backup_ext/include/ext_extension.h @@ -64,6 +64,7 @@ public: ErrCode User0OnBackup() override; ErrCode UpdateDfxInfo(int64_t uniqId, uint32_t extConnectSpend, const std::string &bundleName) override; ErrCode CleanBundleTempDir() override; + ErrCode HandleOnRelease(int32_t scenario) override; public: explicit BackupExtExtension(const std::shared_ptr &extension, @@ -77,6 +78,7 @@ public: onProcessTaskPool_.Start(BConstants::EXTENSION_THREAD_POOL_COUNT); reportOnProcessRetPool_.Start(BConstants::EXTENSION_THREAD_POOL_COUNT); doBackupPool_.Start(BConstants::EXTENSION_THREAD_POOL_COUNT); + onReleaseTaskPool_.Start(BConstants::EXTENSION_THREAD_POOL_COUNT); SetStagingPathProperties(); appStatistic_ = std::make_shared(); } @@ -87,6 +89,8 @@ public: onProcessTaskPool_.Stop(); reportOnProcessRetPool_.Stop(); doBackupPool_.Stop(); + onReleaseTaskPool_.Stop(); + onReleaseTimeoutTimer_.Shutdown(); if (callJsOnProcessThread_.joinable()) { callJsOnProcessThread_.join(); } @@ -386,6 +390,15 @@ private: template map MatchFiles(map files, vector endExcludes); void UpdateTarStat(uint64_t tarFileSize); + + void HandleExtDisconnect(); + void StartOnReleaseTimeOutTimer(wptr obj); + void CloseOnReleaseTimeOutTimer(); + void CallJsOnReleaseTask(wptr obj, int32_t scenario, bool isNeedDisconnect); + bool HandleGetExtOnRelease(); + void SetAppResultReport(const std::string resultInfo, ErrCode errCode); + void HandleExtOnRelease(); + std::function OnReleaseCallback(wptr obj); private: pair> GetFileInfos(const vector &includes, const vector &excludes); TarMap GetIncrmentBigInfos(const vector &files); @@ -432,6 +445,17 @@ private: std::shared_ptr appStatistic_ = nullptr; BackupRestoreScenario curScenario_ { BackupRestoreScenario::FULL_BACKUP }; + + OHOS::ThreadPool onReleaseTaskPool_; + Utils::Timer onReleaseTimeoutTimer_ {"onReleaseTimeoutTimer"}; + uint32_t onReleaseTimeoutTimerId_ { 0 }; + std::atomic stopWaitOnRelease_ {false}; + std::mutex onReleaseLock_; + std::condition_variable execOnReleaseCon_; + std::atomic needAppResultReport_ {false}; + std::string appResultReportInfo_; + ErrCode appResultReportErrCode_ { 0 }; + std::mutex serviceCallReleaseLock_; }; } // namespace OHOS::FileManagement::Backup diff --git a/frameworks/native/backup_ext/src/ext_backup.cpp b/frameworks/native/backup_ext/src/ext_backup.cpp index fc37b3296bfde94427df8120e971e2fb95ca5e7c..708312d533b49db45d3b895d0f3888725bdadef9 100644 --- a/frameworks/native/backup_ext/src/ext_backup.cpp +++ b/frameworks/native/backup_ext/src/ext_backup.cpp @@ -317,4 +317,10 @@ ErrCode ExtBackup::OnProcess(std::function callback) return ERR_OK; } +ErrCode ExtBackup::OnRelease(std::function callback, int32_t scenario) +{ + HILOGI("BackupExtensionAbility(base) OnRelease."); + return ERR_OK; +} + } // namespace OHOS::FileManagement::Backup diff --git a/frameworks/native/backup_ext/src/ext_backup_js.cpp b/frameworks/native/backup_ext/src/ext_backup_js.cpp index 23dedf3d3e33d0c593c0b1ceb28a9ef16c78dd17..f8b190796ade4eda17638bb962b568b7c8e215e0 100644 --- a/frameworks/native/backup_ext/src/ext_backup_js.cpp +++ b/frameworks/native/backup_ext/src/ext_backup_js.cpp @@ -1018,6 +1018,58 @@ ErrCode ExtBackupJs::OnProcess(std::function c return errCode; } +ErrCode ExtBackupJs::OnRelease(std::function callback, int32_t scenario) +{ + HILOGI("BackupExtensionAbility(JS) OnRelease begin."); + BExcepUltils::BAssert(jsObj_, BError::Codes::EXT_BROKEN_FRAMEWORK, + "The app does not provide the OnProcess interface."); + scenario_ = scenario; + onReleaseCallback_ = std::make_shared(callback); + auto retParser = [jsRuntime {&jsRuntime_}, callbackInfo {onReleaseCallback_}](napi_env env, + napi_value result) -> bool { + if (!CheckPromise(env, result)) { + string str; + bool isExceptionPending; + napi_is_exception_pending(env, &isExceptionPending); + HILOGI("napi exception pending = %{public}d.", isExceptionPending); + if (!callbackInfo) { + HILOGE("callbackInfo is nullptr"); + return false; + } + if (isExceptionPending) { + napi_value exception; + DealNapiException(env, exception, str); + napi_fatal_exception(env, exception); + callbackInfo->callback(BError(BError::Codes::EXT_THROW_EXCEPTION), str); + } else { + callbackInfo->callback(BError(BError::Codes::OK), str); + } + return true; + } + HILOGI("CheckPromise Js Method onRelease ok."); + return CallPromise(*jsRuntime, result, callbackInfo.get()); + }; + auto errCode = CallJsMethod("onRelease", jsRuntime_, jsObj_.get(), ParseReleaseInfo(), retParser); + if (errCode != ERR_OK) { + HILOGE("CallJsMethod error, code:%{public}d.", errCode); + } + HILOGI("BackupExtensionAbility(JS) OnRelease end."); + return errCode; +} + +std::function &argv)> ExtBackupJs::ParseReleaseInfo() +{ + auto onReleaseFun = [scenario(scenario_)](napi_env env, vector &argv) -> bool { + int32_t scenarioFlag = scenario; + HILOGI("ParseReleaseInfo, scenario:%{public}d", scenarioFlag); + napi_value scenarioValue = nullptr; + napi_create_int32(env, scenarioFlag, &scenarioValue); + argv.emplace_back(scenarioValue); + return true; + }; + return onReleaseFun; +} + void ExtBackupJs::InitTempPath(const std::string &bundleName) { std::string el2BackupDir(BConstants::PATH_BUNDLE_BACKUP_HOME); diff --git a/frameworks/native/backup_ext/src/ext_extension.cpp b/frameworks/native/backup_ext/src/ext_extension.cpp index 8f67b82de713a3331a29ff6b0662a0e85da65ede..4c203535dee20b882871b8123efa20aba8c6204d 100644 --- a/frameworks/native/backup_ext/src/ext_extension.cpp +++ b/frameworks/native/backup_ext/src/ext_extension.cpp @@ -1861,6 +1861,9 @@ void BackupExtExtension::AppDone(ErrCode errCode) if (ret != ERR_OK) { HILOGE("Failed to notify the app done. err = %{public}d", ret); } + if (HandleGetExtOnRelease()) { + HandleExtOnRelease(); + } } void BackupExtExtension::AppResultReport(const std::string restoreRetInfo, diff --git a/frameworks/native/backup_ext/src/sub_ext_extension.cpp b/frameworks/native/backup_ext/src/sub_ext_extension.cpp index ed31e9d1d6c4957c549668c0eb57ebbfdf08e271..4cd89419b4a63e7e3af065837a8902bd147ef4ad 100644 --- a/frameworks/native/backup_ext/src/sub_ext_extension.cpp +++ b/frameworks/native/backup_ext/src/sub_ext_extension.cpp @@ -271,7 +271,7 @@ std::function BackupExtExtension::OnRestoreCallback( std::string errInfo; BJsonUtil::BuildExtensionErrInfo(errInfo, errCode, errMsg); extensionPtr->ReportAppStatistic("OnRestoreCallback", errCode); - extensionPtr->AppResultReport(errInfo, BackupRestoreScenario::FULL_RESTORE, errCode); + extensionPtr->SetAppResultReport(errInfo, errCode); } extensionPtr->DoClear(); }; @@ -311,7 +311,7 @@ std::function BackupExtExtension::OnRestoreExCallbac if (restoreRetInfo.size()) { HILOGI("Will notify restore result report"); extensionPtr->ReportAppStatistic("OnRestoreExCallback1", errCode); - extensionPtr->AppResultReport(restoreRetInfo, BackupRestoreScenario::FULL_RESTORE); + extensionPtr->SetAppResultReport(restoreRetInfo, errCode); } return; } @@ -322,7 +322,7 @@ std::function BackupExtExtension::OnRestoreExCallbac std::string errInfo; BJsonUtil::BuildExtensionErrInfo(errInfo, errCode, restoreRetInfo); extensionPtr->ReportAppStatistic("OnRestoreExCallback2", errCode); - extensionPtr->AppResultReport(errInfo, BackupRestoreScenario::FULL_RESTORE, errCode); + extensionPtr->SetAppResultReport(errInfo, errCode); extensionPtr->DoClear(); } }; @@ -377,7 +377,7 @@ std::function BackupExtExtension::IncreOnRestoreExCa if (errCode == ERR_OK) { if (restoreRetInfo.size()) { extensionPtr->ReportAppStatistic("IncreOnRestoreExCallback1", errCode); - extensionPtr->AppResultReport(restoreRetInfo, BackupRestoreScenario::INCREMENTAL_RESTORE); + extensionPtr->SetAppResultReport(restoreRetInfo, errCode); } return; } @@ -388,7 +388,7 @@ std::function BackupExtExtension::IncreOnRestoreExCa std::string errInfo; BJsonUtil::BuildExtensionErrInfo(errInfo, errCode, restoreRetInfo); extensionPtr->ReportAppStatistic("IncreOnRestoreExCallback2", errCode); - extensionPtr->AppResultReport(errInfo, BackupRestoreScenario::INCREMENTAL_RESTORE, errCode); + extensionPtr->SetAppResultReport(errInfo, errCode); extensionPtr->DoClear(); } }; @@ -425,7 +425,7 @@ std::function BackupExtExtension::IncreOnRestoreCall std::string errInfo; BJsonUtil::BuildExtensionErrInfo(errInfo, errCode, errMsg); extensionPtr->ReportAppStatistic("IncreOnRestoreCallback", errCode); - extensionPtr->AppResultReport(errInfo, BackupRestoreScenario::INCREMENTAL_RESTORE, errCode); + extensionPtr->SetAppResultReport(errInfo, errCode); } extensionPtr->DoClear(); }; @@ -835,6 +835,9 @@ void BackupExtExtension::AppIncrementalDone(ErrCode errCode) if (ret != ERR_OK) { HILOGE("Failed to notify the app done. err = %{public}d", ret); } + if (HandleGetExtOnRelease()) { + HandleExtOnRelease(); + } } ErrCode BackupExtExtension::GetBackupInfo(std::string &result) @@ -1724,4 +1727,161 @@ tuple BackupExtExtension::GetIncrementalBackupFileHandle() HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); return {UniqueFd(BConstants::INVALID_FD_NUM), UniqueFd(BConstants::INVALID_FD_NUM)}; } + +std::function BackupExtExtension::OnReleaseCallback(wptr obj) +{ + HILOGI("Begin get HandleOnReleaseCallback"); + return [obj](ErrCode errCode, std::string errMsg) { + HILOGI("OnReleaseCallback: App onRelease end"); + auto extPtr = obj.promote(); + if (extPtr == nullptr) { + HILOGE("Ext extension handle have been released"); + return; + } + if (extPtr->extension_ == nullptr) { + HILOGE("Extension handle have been released"); + return; + } + if (extPtr->stopWaitOnRelease_.load()) { + HILOGE("App onRelease timeout"); + return; + } + std::unique_lock lock(extPtr->onReleaseLock_); + extPtr->CloseOnReleaseTimeOutTimer(); + extPtr->stopWaitOnRelease_.store(true); + extPtr->execOnReleaseCon_.notify_all(); + HILOGI("Extension onRelease end, errCode: %{public}d, errInfo: %{public}s", errCode, errMsg.c_str()); + }; +} + +ErrCode BackupExtExtension::HandleOnRelease(int32_t scenario) +{ + try { + HILOGI("HandleOnRelease Begin, scenario: %{public}d", scenario); + VerifyCaller(); + auto ptr = wptr(this); + onReleaseTimeoutTimer_.Setup(); + StartOnReleaseTimeOutTimer(ptr); + // service主动release场景，等待onRelease完成或超时，备份/恢复完成场景不需等待 + CallJsOnReleaseTask(ptr, scenario, false); + HILOGI("Wait onRelease to do"); + std::unique_lock lock(serviceCallReleaseLock_); + execOnReleaseCon_.wait(lock, [this] { return stopWaitOnRelease_.load(); }); + return ERR_OK; + } catch (...) { + HILOGE("Failed to HandleOnRelease"); + return BError(BError::Codes::EXT_BROKEN_IPC).GetCode(); + } +} + +void BackupExtExtension::HandleExtDisconnect() +{ + HILOGI("Begin, curScenario:%{public}d", curScenario_); + auto proxy = ServiceClient::GetInstance(); + if (proxy == nullptr) { + HILOGE("Failed to obtain the ServiceClient handle"); + return; + } + bool isIncBackup = true; + if (curScenario_ == BackupRestoreScenario::FULL_BACKUP || curScenario_ == BackupRestoreScenario::FULL_RESTORE) { + isIncBackup = false; + } + auto ret = proxy->HandleExtDisconnect(isIncBackup); + if (ret != ERR_OK) { + HILOGE("Failed to HandleExtDisconnect. err = %{public}d", ret); + } +} + +bool BackupExtExtension::HandleGetExtOnRelease() +{ + HILOGI("HandleGetExtOnRelease begin"); + auto proxy = ServiceClient::GetInstance(); + if (proxy == nullptr) { + HILOGE("Failed to obtain the ServiceClient handle"); + return false; + } + bool isExtOnRelease = false; + auto ret = proxy->GetExtOnRelease(isExtOnRelease); + if (ret != ERR_OK) { + HILOGE("Failed to GetExtOnRelease. err = %{public}d", ret); + } + return isExtOnRelease; +} + +void BackupExtExtension::StartOnReleaseTimeOutTimer(wptr obj) +{ + HILOGI("StartOnReleaseTimeOutTimer begin"); + int timeout = BConstants::APP_ON_RELEASE_MAX_TIMEOUT; + auto timeoutCallback = [obj]() { + auto extPtr = obj.promote(); + if (extPtr == nullptr) { + HILOGE("Start Create timeout callback failed, extPtr is empty"); + return; + } + HILOGI("OnRelease time out, need to stop wait"); + std::unique_lock lock(extPtr->onReleaseLock_); + extPtr->stopWaitOnRelease_.store(true); + extPtr->execOnReleaseCon_.notify_all(); + extPtr->CloseOnReleaseTimeOutTimer(); + return; + }; + uint32_t timerId = onReleaseTimeoutTimer_.Register(timeoutCallback, timeout, true); + onReleaseTimeoutTimerId_ = timerId; +} + +void BackupExtExtension::CloseOnReleaseTimeOutTimer() +{ + HILOGI("CloseOnReleaseTimeOutTimer begin"); + onReleaseTimeoutTimer_.Unregister(onReleaseTimeoutTimerId_); +} + +void BackupExtExtension::CallJsOnReleaseTask(wptr obj, int32_t scenario, bool isNeedDisconnect) +{ + HILOGI("Begin CallJsOnReleaseTask, scenario: %{public}d", scenario); + auto task = [obj, scenario, isNeedDisconnect]() { + auto extPtr = obj.promote(); + if (extPtr == nullptr || extPtr->extension_ == nullptr) { + HILOGE("Call js onRelease failed, extensionPtr is empty"); + return; + } + auto callback = extPtr->OnReleaseCallback(obj); + ErrCode ret = extPtr->extension_->OnRelease(callback, scenario); + if (ret != ERR_OK) { + HILOGE("Call onRelease failed, ret = %{public}d", ret); + return; + } + std::unique_lock lock(extPtr->onReleaseLock_); + extPtr->execOnReleaseCon_.wait(lock, [extPtr] { return extPtr->stopWaitOnRelease_.load(); }); + if (extPtr->needAppResultReport_.load()) { + extPtr->AppResultReport(extPtr->appResultReportInfo_, extPtr->curScenario_, + extPtr->appResultReportErrCode_); + } else if (isNeedDisconnect) { + extPtr->HandleExtDisconnect(); + } + }; + onReleaseTaskPool_.AddTask([task]() { task(); }); +} + +void BackupExtExtension::SetAppResultReport(const std::string resultInfo, ErrCode errCode) +{ + HILOGI("SetAppResultReport begin"); + needAppResultReport_.store(true); + appResultReportInfo_ = resultInfo; + appResultReportErrCode_ = errCode; + HandleExtOnRelease(); +} + +void BackupExtExtension::HandleExtOnRelease() +{ + HILOGI("HandleExtOnRelease begin"); + int32_t scenario = static_cast(BConstants::ExtensionScenario::RESTORE); + if (curScenario_ == BackupRestoreScenario::FULL_BACKUP || + curScenario_ == BackupRestoreScenario::INCREMENTAL_BACKUP) { + scenario = static_cast(BConstants::ExtensionScenario::BACKUP); + } + auto ptr = wptr(this); + onReleaseTimeoutTimer_.Setup(); + StartOnReleaseTimeOutTimer(ptr); + CallJsOnReleaseTask(ptr, scenario, true); +} } // namespace OHOS::FileManagement::Backup diff --git a/interfaces/api/js/napi/backup_ext/backup_extension_ability.js b/interfaces/api/js/napi/backup_ext/backup_extension_ability.js index a4fdf706d28eecdb68227b6a47079f6ab71e4787..a6d51a71bc4fff5d1e428f8339560ead396cc09b 100644 --- a/interfaces/api/js/napi/backup_ext/backup_extension_ability.js +++ b/interfaces/api/js/napi/backup_ext/backup_extension_ability.js @@ -33,6 +33,10 @@ class BackupExtensionAbility { onProcess() { console.log(); } + + onRelease(scenario) { + console.log(); + } } export default BackupExtensionAbility; \ No newline at end of file diff --git a/services/backup_sa/IExtension.idl b/services/backup_sa/IExtension.idl index c9c88cd95628a6f5fd1b8ca0dd3fa4f06476510f..eb1b0f34ab2c413c94a9143d8250eea1663f7b23 100644 --- a/services/backup_sa/IExtension.idl +++ b/services/backup_sa/IExtension.idl @@ -30,4 +30,5 @@ interface OHOS.FileManagement.Backup.IExtension{ [ipccode 13] void User0OnBackup(); [ipccode 14] void UpdateDfxInfo([in] long uniqId, [in] unsigned int extConnectSpend, [in] String bundleName); [ipccode 15] void CleanBundleTempDir(); + [ipccode 16] void HandleOnRelease([in] int scenario); } \ No newline at end of file diff --git a/services/backup_sa/IService.idl b/services/backup_sa/IService.idl index 8d03b1f91ff30fc7380cb08d2bf9bef9008019f8..7375331333e311101ee26fe07688049d9b675e81 100644 --- a/services/backup_sa/IService.idl +++ b/services/backup_sa/IService.idl @@ -72,4 +72,6 @@ interface OHOS.FileManagement.Backup.IService{ [in] int serviceResultReportErrCode); [ipccode 38] void GetBackupDataSize([in] boolean isPreciseScan,[in] BIncrementalData[] bundleNameList); [ipccode 40] void CleanBundleTempDir([in] String bundleName); + [ipccode 41] void HandleExtDisconnect([in] boolean isIncBackup); + [ipccode 42] void GetExtOnRelease([out] boolean isExtOnRelease); } \ No newline at end of file diff --git a/services/backup_sa/include/module_ipc/service.h b/services/backup_sa/include/module_ipc/service.h index 6f92ac6ae5190ce14d45b00ac6ab5d0499e35e2e..59e6230084e5bb3c93968b2895888923e2424927 100644 --- a/services/backup_sa/include/module_ipc/service.h +++ b/services/backup_sa/include/module_ipc/service.h @@ -115,6 +115,8 @@ public: ErrCode GetBackupDataSize(bool isPreciseScan, const std::vector& bundleNameList) override; ErrCode CleanBundleTempDir(const std::string &bundleName) override; + ErrCode HandleExtDisconnect(bool isIncBackup) override; + ErrCode GetExtOnRelease(bool &isExtOnRelease) override; // 以下都是非IPC接口 public: @@ -329,6 +331,8 @@ public: UniqueFd manifestFd, int32_t errCode); ErrCode SendFileHandle(const std::string &bundleName, const std::string &fileName); ErrCode SendIncrementalFileHandle(const std::string &bundleName, const std::string &fileName); + void SetExtOnRelease(const BundleName &bundleName, bool isOnRelease); + void RemoveExtOnRelease(const BundleName &bundleName); public: explicit Service(int32_t saID, bool runOnCreate = false) : SystemAbility(saID, runOnCreate) { @@ -685,6 +689,8 @@ private: void SetScanningInfo(string &scanning, string name); + void HandleOnReleaseAndDisconnect(sptr sessionPtr, const std::string &bundleName); + ErrCode InitRestoreSession(const sptr& remote, std::string &errMsg); ErrCode InitBackupSession(const sptr& remote, std::string &errMsg); ErrCode InitIncrementalBackupSession(const sptr& remote, std::string &errMsg); @@ -776,6 +782,7 @@ private: std::shared_ptr totalStatistic_ = nullptr; std::shared_mutex statMapMutex_; std::map> saStatisticMap_; + std::map> backupExtOnReleaseMap_; public: std::map> backupExtMutexMap_; std::map failedBundles_; diff --git a/services/backup_sa/src/module_ipc/service.cpp b/services/backup_sa/src/module_ipc/service.cpp index fd3842601e5091a03e7fdb8c5e6e87e9a976e52c..8c84dc460753182994e1115bb185729eda0a50f0 100644 --- a/services/backup_sa/src/module_ipc/service.cpp +++ b/services/backup_sa/src/module_ipc/service.cpp @@ -1593,6 +1593,7 @@ ErrCode Service::ClearResidualBundleData(const std::string &bundleName) HILOGI("Current bundle will clean extension data, bundleName:%{public}s", bundleName.c_str()); ErrCode res = proxy->HandleClear(); if (backUpConnection->IsExtAbilityConnected()) { + proxy->HandleOnRelease(static_cast(session_->GetScenario())); backUpConnection->DisconnectBackupExtAbility(); } ClearSessionAndSchedInfo(bundleName); @@ -2020,12 +2021,7 @@ void Service::DoTimeout(wptr ptr, std::string bundleName) } saConnection->DisconnectBackupSAExt(); } else { - auto sessionConnection = sessionPtr->GetExtConnection(bundleName); - if (sessionConnection == nullptr) { - HILOGE("Error, sessionConnection is empty, bundleName:%{public}s", bundleName.c_str()); - return; - } - sessionConnection->DisconnectBackupExtAbility(); + HandleOnReleaseAndDisconnect(sessionPtr, bundleName); } TimeoutRadarReport(scenario, bundleName); sessionPtr->StopFwkTimer(bundleName); diff --git a/services/backup_sa/src/module_ipc/service_incremental.cpp b/services/backup_sa/src/module_ipc/service_incremental.cpp index 2490928f77b998d36192d8bf4d7ef1b6e746358b..ee5cae2954d8c7c21a181434005f33dfe8ecb1ee 100644 --- a/services/backup_sa/src/module_ipc/service_incremental.cpp +++ b/services/backup_sa/src/module_ipc/service_incremental.cpp @@ -700,11 +700,8 @@ ErrCode Service::AppIncrementalDone(ErrCode errCode) return BError(BError::Codes::SA_INVAL_ARG); } std::lock_guard lock(mutexPtr->callbackMutex); - ret = HandleCurAppDone(errCode, callerName, true); - if (ret != ERR_OK) { - HILOGE("Handle current app done error, bundleName:%{public}s", callerName.c_str()); - return ret; - } + SetExtOnRelease(callerName, true); + return BError(BError::Codes::OK); } RemoveExtensionMutex(callerName); OnAllBundlesFinished(BError(BError::Codes::OK)); @@ -1004,6 +1001,7 @@ bool Service::CancelSessionClean(sptr session, std::string bu proxy->HandleClear(); session->StopFwkTimer(bundleName); session->StopExtTimer(bundleName); + proxy->HandleOnRelease(static_cast(session->GetScenario())); backUpConnection->DisconnectBackupExtAbility(); return true; } diff --git a/services/backup_sa/src/module_ipc/sub_service.cpp b/services/backup_sa/src/module_ipc/sub_service.cpp index 20ffa365a4ce0b0bfd8cc2d49f48529004931299..f1c5780ec9ebe1737537fdacaad0c3162cfec1d8 100644 --- a/services/backup_sa/src/module_ipc/sub_service.cpp +++ b/services/backup_sa/src/module_ipc/sub_service.cpp @@ -383,11 +383,8 @@ ErrCode Service::AppDone(ErrCode errCode) return BError(BError::Codes::SA_INVAL_ARG); } std::lock_guard lock(mutexPtr->callbackMutex); - ret = HandleCurAppDone(errCode, callerName, false); - if (ret != ERR_OK) { - HILOGE("Handle current app done error, bundleName:%{public}s", callerName.c_str()); - return ret; - } + SetExtOnRelease(callerName, true); + return BError(BError::Codes::OK); } RemoveExtensionMutex(callerName); OnAllBundlesFinished(BError(BError::Codes::OK)); @@ -1437,4 +1434,91 @@ ErrCode Service::CleanBundleTempDir(const string &bundleName) session_->DecreaseSessionCnt(__PRETTY_FUNCTION__); return BError(BError::Codes::OK); } + +ErrCode Service::HandleExtDisconnect(bool isIncBackup) +{ + HILOGI("begin, isIncBackup: %{public}d", isIncBackup); + std::string callerName; + auto ret = VerifyCallerAndGetCallerName(callerName); + if (ret != ERR_OK) { + HILOGE("HandleExtDisconnect VerifyCaller failed, get bundle failed, ret:%{public}d", ret); + return ret; + } + std::shared_ptr mutexPtr = GetExtensionMutex(callerName); + if (mutexPtr == nullptr) { + HILOGE("extension mutex ptr is nullptr, bundleName:%{public}s", callerName.c_str()); + return BError(BError::Codes::SA_INVAL_ARG); + } + std::lock_guard lock(mutexPtr->callbackMutex); + ret = HandleCurAppDone(ret, callerName, isIncBackup); + if (ret != ERR_OK) { + HILOGE("Handle current app done error, bundleName:%{public}s", callerName.c_str()); + return ret; + } + RemoveExtensionMutex(callerName); + RemoveExtOnRelease(callerName); + OnAllBundlesFinished(BError(BError::Codes::OK)); + return ret; +} + +ErrCode Service::GetExtOnRelease(bool &isExtOnRelease) +{ + std::string bundleName; + auto ret = VerifyCallerAndGetCallerName(bundleName); + if (ret != ERR_OK) { + HILOGE("GetExtOnRelease VerifyCaller failed, get bundle failed, ret:%{public}d", ret); + return ret; + } + auto it = backupExtOnReleaseMap_.find(bundleName); + if (it == backupExtOnReleaseMap_.end()) { + HILOGI("BackupExtOnReleaseMap not contain %{public}s", bundleName.c_str()); + backupExtOnReleaseMap_[bundleName] = false; + isExtOnRelease = backupExtOnReleaseMap_[bundleName].load(); + return ret; + } + HILOGI("BackupExtOnReleaseMap contain %{public}s", bundleName.c_str()); + isExtOnRelease = backupExtOnReleaseMap_[bundleName].load(); + return ret; +} + +void Service::SetExtOnRelease(const BundleName &bundleName, bool isOnRelease) +{ + HILOGI("Set bundleName:%{public}s isOnRelease:%{public}d", bundleName.c_str(), isOnRelease); + auto it = backupExtOnReleaseMap_.find(bundleName); + if (it == backupExtOnReleaseMap_.end()) { + backupExtOnReleaseMap_[bundleName] = isOnRelease; + return; + } + it->second.store(isOnRelease); +} + +void Service::RemoveExtOnRelease(const BundleName &bundleName) +{ + auto it = backupExtOnReleaseMap_.find(bundleName); + if (it == backupExtOnReleaseMap_.end()) { + HILOGI("BackupExtOnReleaseMap not contain %{public}s", bundleName.c_str()); + return; + } + backupExtOnReleaseMap_.erase(it); +} + +void Service::HandleOnReleaseAndDisconnect(sptr sessionPtr, const std::string &bundleName) +{ + if (sessionPtr == nullptr) { + HILOGE("SessionPtr is nullptr."); + return; + } + auto sessionConnection = sessionPtr->GetExtConnection(bundleName); + if (sessionConnection == nullptr) { + HILOGE("Error, sessionConnection is empty, bundleName:%{public}s", bundleName.c_str()); + return; + } + auto proxy = sessionConnection->GetBackupExtProxy(); + if (!proxy) { + HILOGE("Extension backup Proxy is empty"); + return; + } + proxy->HandleOnRelease(static_cast(sessionPtr->GetScenario())); + sessionConnection->DisconnectBackupExtAbility(); +} } \ No newline at end of file diff --git a/services/backup_sa/src/module_ipc/svc_session_manager.cpp b/services/backup_sa/src/module_ipc/svc_session_manager.cpp index 81d3b3d5d3d2a1044e2654efa282524ef16a7963..907b2f61b171160925cebcc2cad4cc80084bd592 100644 --- a/services/backup_sa/src/module_ipc/svc_session_manager.cpp +++ b/services/backup_sa/src/module_ipc/svc_session_manager.cpp @@ -1079,6 +1079,7 @@ ErrCode SvcSessionManager::ClearSessionData() if (impl_.restoreDataType != RestoreTypeEnum::RESTORE_DATA_READDY) { ret = proxy->HandleClear(); } + proxy->HandleOnRelease(static_cast(GetScenario())); backUpConnection->DisconnectBackupExtAbility(); } if (ret != BError(BError::Codes::OK)) { @@ -1244,6 +1245,7 @@ bool SvcSessionManager::CleanAndCheckIfNeedWait(ErrCode &ret, std::vectorHandleOnRelease(static_cast(GetScenario())); backUpConnection->DisconnectBackupExtAbility(); HILOGI("Disconnect extensionAbility, bundleName: %{public}s", it->first.c_str()); it = impl_.backupExtNameMap.erase(it); diff --git a/tests/mock/backup_ext/include/ext_backup_js_mock.h b/tests/mock/backup_ext/include/ext_backup_js_mock.h index 001051de586a286c9ecedc3f125af49c546a8632..5838cdaf7769ff70174ebcd04a137706f7636707 100644 --- a/tests/mock/backup_ext/include/ext_backup_js_mock.h +++ b/tests/mock/backup_ext/include/ext_backup_js_mock.h @@ -50,6 +50,8 @@ public: virtual ErrCode CallJsOnBackupEx() = 0; virtual ErrCode CallJsOnBackup() = 0; virtual void ExportJsContext() = 0; + virtual ErrCode OnRelease(std::function, int32_t scenario) = 0; + virtual std::function &argv) ParseReleaseInfo() = 0; public: virtual bool GetProfileFromAbility(const OHOS::AppExecFwk::AbilityInfo &, const std::string &, std::vector &) const = 0; diff --git a/tests/mock/backup_ext/include/ext_backup_mock.h b/tests/mock/backup_ext/include/ext_backup_mock.h index 76826057ba1cb173b13d8003330277e47cf5959b..bee304753dcd2b46d25cc3e8073efa2083b1715c 100644 --- a/tests/mock/backup_ext/include/ext_backup_mock.h +++ b/tests/mock/backup_ext/include/ext_backup_mock.h @@ -52,6 +52,7 @@ public: std::shared_ptr) = 0; virtual ErrCode GetParament(const AAFwk::Want &) = 0; virtual ErrCode OnProcess(std::function callback) = 0; + virtual ErrCode OnRelease(std::function callback, int32_t scenario) = 0; public: virtual std::unique_ptr LoadSystemModuleByEngine(napi_env, const std::string&, const napi_value*, size_t) = 0; @@ -97,6 +98,7 @@ public: std::shared_ptr)); MOCK_METHOD(ErrCode, GetParament, (const AAFwk::Want &)); MOCK_METHOD(napi_value, CreateExtBackupJsContext, (napi_env, std::shared_ptr)); + MOCK_METHOD(ErrCode, OnRelease, (std::function, int32_t)); public: MOCK_METHOD((std::unique_ptr), LoadSystemModuleByEngine, (napi_env, const std::string&, const napi_value*, size_t)); diff --git a/tests/mock/backup_ext/include/ext_extension_mock.h b/tests/mock/backup_ext/include/ext_extension_mock.h index c57e10ae2828e5cd3cde4fa500a5c30168d823f6..a92a98bb1fd6abefd8b09f0303fec79c036670f0 100644 --- a/tests/mock/backup_ext/include/ext_extension_mock.h +++ b/tests/mock/backup_ext/include/ext_extension_mock.h @@ -67,6 +67,7 @@ public: virtual std::function HandleTaskBackupEx(wptr) = 0; virtual void WaitToSendFd(std::chrono::system_clock::time_point&, int&) = 0; virtual void RefreshTimeInfo(std::chrono::system_clock::time_point&, int&) = 0; + virtual ErrCode HandleOnRelease(int32_t) = 0; public: BExtExtension() = default; virtual ~BExtExtension() = default; @@ -121,6 +122,7 @@ public: MOCK_METHOD(void, WaitToSendFd, ((std::chrono::system_clock::time_point&), int&)); MOCK_METHOD(void, RefreshTimeInfo, ((std::chrono::system_clock::time_point&), int&)); MOCK_METHOD(ErrCode, CleanBundleTempDir, ()); + MOCK_METHOD(ErrCode, HandleOnRelease, (int32_t)); }; } // namespace OHOS::FileManagement::Backup #endif // OHOS_FILEMGMT_BACKUP_EXT_EXTENSION_MOCK_H \ No newline at end of file diff --git a/tests/mock/backup_ext/src/ext_backup_js_mock.cpp b/tests/mock/backup_ext/src/ext_backup_js_mock.cpp index 1f97308fde56108e621e345b18289b508d09a9dc..3d64f12e9509bbf31b8af2aeb5e43499c688a733 100644 --- a/tests/mock/backup_ext/src/ext_backup_js_mock.cpp +++ b/tests/mock/backup_ext/src/ext_backup_js_mock.cpp @@ -98,4 +98,14 @@ ErrCode ExtBackupJs::InvokeAppExtMethod(ErrCode errCode, const string result) { return BExtBackupJs::extBackupJs->InvokeAppExtMethod(errCode, result); } + +function &argv)> ExtBackupJs::ParseReleaseInfo() +{ + return BExtBackupJs::extBackupJs->ParseReleaseInfo(); +} + +ErrCode ExtBackupJs::OnRelease(function callback, int32_t scenario) +{ + return BExtBackupJs::extBackupJs->OnRelease(callback, scenario); +} } // namespace OHOS::FileManagement::Backup diff --git a/tests/mock/backup_ext/src/ext_backup_mock.cpp b/tests/mock/backup_ext/src/ext_backup_mock.cpp index 16d6f55b5f87d21699d7fc81342b68ce95755ff5..43f091594b0e31ebf068591f64fcb7af8e57e9fa 100644 --- a/tests/mock/backup_ext/src/ext_backup_mock.cpp +++ b/tests/mock/backup_ext/src/ext_backup_mock.cpp @@ -138,4 +138,9 @@ ErrCode ExtBackup::OnProcess(function callback) { return BExtBackup::extBackup->OnProcess(callback); } + +ErrCode ExtBackup::OnRelease(function callback, int32_t scenario) +{ + return BExtBackup::extBackup->OnRelease(callback, scenario); +} } // namespace OHOS::FileManagement::Backup diff --git a/tests/mock/backup_ext/src/ext_extension_mock.cpp b/tests/mock/backup_ext/src/ext_extension_mock.cpp index f5bf98f3442f0b94de30bcc2d12ae6b22f8c7f4f..b38cd0573152fcb7d7ba4fd9b0363ffe5c2de94c 100644 --- a/tests/mock/backup_ext/src/ext_extension_mock.cpp +++ b/tests/mock/backup_ext/src/ext_extension_mock.cpp @@ -222,4 +222,9 @@ ErrCode BackupExtExtension::CleanBundleTempDir() { return BExtExtension::extExtension->CleanBundleTempDir(); } + +ErrCode BackupExtExtension::HandleOnRelease(int32_t scenario) +{ + return BExtExtension::extExtension->HandleOnRelease(scenario); +} } // 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 96fa0647aec8f048eafc5b01b9148570fbfeda62..b29e0f628fa4b66aae8865aae312516195a7c59f 100644 --- a/tests/mock/backup_kit_inner/service_proxy_mock.cpp +++ b/tests/mock/backup_kit_inner/service_proxy_mock.cpp @@ -266,4 +266,14 @@ ErrCode ServiceProxy::CleanBundleTempDir(const std::string& bundleName) { return BError(BError::Codes::OK); } + +ErrCode ServiceProxy::HandleExtDisconnect(bool isIncBackup) +{ + return BError(BError::Codes::OK); +} + +ErrCode ServiceProxy::GetExtOnRelease(bool &isExtOnRelease) +{ + return BError(BError::Codes::OK); +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/mock/module_ipc/include/svc_extension_proxy_mock.h b/tests/mock/module_ipc/include/svc_extension_proxy_mock.h index 912fb53c72f5ff3fa25a4a34b595d433da04e535..eb5600d4f5a113ea18caef96efd8562b4d26e950 100644 --- a/tests/mock/module_ipc/include/svc_extension_proxy_mock.h +++ b/tests/mock/module_ipc/include/svc_extension_proxy_mock.h @@ -40,6 +40,7 @@ MOCK_METHOD(ErrCode, UpdateFdSendRate, (const std::string &, int32_t)); MOCK_METHOD(ErrCode, User0OnBackup, ()); MOCK_METHOD(ErrCode, UpdateDfxInfo, (int64_t, uint32_t, const std::string &)); MOCK_METHOD(ErrCode, CleanBundleTempDir, ()); +MOCK_METHOD(ErrCode, HandleOnRelease, (int32_t)); }; } // namespace OHOS::FileManagement::Backup #endif // OHOS_FILEMGMT_BACKUP_SVC_BACKUP_CONNECTION_MOCK_H \ No newline at end of file diff --git a/tests/mock/module_ipc/service_mock.cpp b/tests/mock/module_ipc/service_mock.cpp index e94ff4c32af643f8220a5ac32ca5e94083add992..7ba793b34436416be762f61d4f9e629b39b4ff5a 100644 --- a/tests/mock/module_ipc/service_mock.cpp +++ b/tests/mock/module_ipc/service_mock.cpp @@ -429,4 +429,14 @@ bool Service::GetScanningInfo(wptr obj, size_t scannedSize, string &sca } void Service::SetScanningInfo(string &scanning, string name) {} + +ErrCode Service::HandleExtDisconnect(bool isIncBackup) +{ + return BError(BError::Codes::OK); +} + +ErrCode Service::GetExtOnRelease(bool &isExtOnRelease) +{ + return BError(BError::Codes::OK); +} } // namespace OHOS::FileManagement::Backup diff --git a/tests/mock/module_ipc/svc_extension_proxy_mock.cpp b/tests/mock/module_ipc/svc_extension_proxy_mock.cpp index e73ee49e1927e317eb7833bc0c464c54d03ba54b..00a120b78a6f4a329059a74f869a17a000daeb72 100644 --- a/tests/mock/module_ipc/svc_extension_proxy_mock.cpp +++ b/tests/mock/module_ipc/svc_extension_proxy_mock.cpp @@ -93,4 +93,9 @@ ErrCode ExtensionProxy::CleanBundleTempDir() { return 0; } + +ErrCode ExtensionProxy::HandleOnRelease(int32_t scenario) +{ + return 0; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/unittests/backup_api/backup_impl/include/ext_extension_mock.h b/tests/unittests/backup_api/backup_impl/include/ext_extension_mock.h index 4955834735cb887cbb673159732ddfa04bd41def..79604825a7f9442abf04d1dc896e5dffef07d89b 100644 --- a/tests/unittests/backup_api/backup_impl/include/ext_extension_mock.h +++ b/tests/unittests/backup_api/backup_impl/include/ext_extension_mock.h @@ -174,6 +174,11 @@ public: { return BError(BError::Codes::OK); }; + + ErrCode HandleOnRelease(int32_t scenario) + { + return BError(BError::Codes::OK); + }; private: int32_t nHandleBackupNum_ = 0; }; diff --git a/tests/unittests/backup_ext/ext_backup_js_test.cpp b/tests/unittests/backup_ext/ext_backup_js_test.cpp index c55a76ae435d229614bfae6bfa56ae9f0c49f666..df44d0ac8cfdec2c2ada82bf22803e18d81baff4 100644 --- a/tests/unittests/backup_ext/ext_backup_js_test.cpp +++ b/tests/unittests/backup_ext/ext_backup_js_test.cpp @@ -1605,4 +1605,65 @@ HWTEST_F(ExtBackupJsTest, SUB_backup_ext_js_InitTempPath_0100, testing::ext::Tes } GTEST_LOG_(INFO) << "ExtBackupJsTest-end SUB_backup_ext_js_InitTempPath_0100"; } + +/** + * @tc.number: SUB_backup_ext_js_OnRelease_0100 + * @tc.name: SUB_backup_ext_js_OnRelease_0100 + * @tc.desc: 测试 OnRelease 各个分支成功与失败 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: issuesIAFBOS + */ +HWTEST_F(ExtBackupJsTest, SUB_backup_ext_js_OnRelease_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ExtBackupJsTest-begin SUB_backup_ext_js_OnRelease_0100"; + try { + int32_t scenario = 1; + EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr)).WillOnce(Return(nullptr)); + EXPECT_CALL(*napiMock, napi_is_exception_pending(_, _)).WillOnce(Return(napi_ok)); + EXPECT_CALL(*napiMock, napi_get_value_string_utf8(_, _, _, _, _)).WillOnce(Return(napi_invalid_arg)); + EXPECT_CALL(*napiMock, napi_send_cancelable_event(_, _, _, _, _, _)).WillOnce(Return(napi_invalid_arg)); + auto ret = extBackupJs->OnRelease([](ErrCode, std::string){}, scenario); + EXPECT_EQ(ret, EINVAL); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ExtBackupJsTest-an exception occurred by OnRelease."; + } + GTEST_LOG_(INFO) << "ExtBackupJsTest-end SUB_backup_ext_js_OnRelease_0100"; +} + +/** + * @tc.number: SUB_backup_ext_js_OnRelease_0200 + * @tc.name: SUB_backup_ext_js_OnRelease_0200 + * @tc.desc: 测试 OnRelease 各个分支成功与失败 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: issuesIAFBOS + */ +HWTEST_F(ExtBackupJsTest, SUB_backup_ext_js_OnRelease_0200, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ExtBackupJsTest-begin SUB_backup_ext_js_OnRelease_0200"; + try { + int32_t scenario = 1; + EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr)).WillOnce(Return(nullptr)); + EXPECT_CALL(*napiMock, napi_is_exception_pending(_, _)).WillOnce(Return(napi_ok)); + EXPECT_CALL(*napiMock, napi_get_value_string_utf8(_, _, _, _, _)).WillOnce(Return(napi_ok)) + .WillOnce(Return(napi_ok)); + EXPECT_CALL(*napiMock, napi_send_cancelable_event(_, _, _, _, _, _)).WillOnce(Return(napi_invalid_arg)); + auto ret = extBackupJs->OnRelease([](ErrCode, std::string){}, scenario); + EXPECT_EQ(ret, EINVAL); + + EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr)).WillOnce(Return(nullptr)); + EXPECT_CALL(*napiMock, napi_is_exception_pending(_, _)).WillOnce(Return(napi_ok)); + EXPECT_CALL(*napiMock, napi_send_cancelable_event(_, _, _, _, _, _)).WillOnce(Return(napi_invalid_arg)); + ret = extBackupJs->OnRelease([](ErrCode, std::string){}, scenario); + EXPECT_EQ(ret, EINVAL); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ExtBackupJsTest-an exception occurred by OnRelease."; + } + GTEST_LOG_(INFO) << "ExtBackupJsTest-end SUB_backup_ext_js_OnRelease_0200"; +} } // 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 e8f772d269d82864f7f10c5b0ceae06254d38947..f016aa397084acb129a9b13a73957e03dfe82763 100644 --- a/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp @@ -76,6 +76,10 @@ public: virtual UniqueFd GetLocalCapabilitiesForBundleInfos() = 0; virtual ErrCode GetBackupDataSize(bool, const std::vector&) = 0; virtual ErrCode CleanBundleTempDir(const std::string& bundleName) = 0; + virtual ErrCode HandleExtDisconnect(bool) = 0; + virtual ErrCode GetExtOnRelease(bool&) = 0; + virtual void SetExtOnRelease(const BundleName&, bool) = 0; + virtual void RemoveExtOnRelease(const BundleName&) = 0; public: virtual bool UpdateToRestoreBundleMap(const string&, const string&) = 0; public: @@ -131,6 +135,10 @@ public: MOCK_METHOD(UniqueFd, GetLocalCapabilitiesForBundleInfos, ()); MOCK_METHOD(ErrCode, GetBackupDataSize, (bool, const std::vector&)); MOCK_METHOD(ErrCode, CleanBundleTempDir, (const std::string&)); + MOCK_METHOD(ErrCode, HandleExtDisconnect, (bool)); + MOCK_METHOD(ErrCode, GetExtOnRelease, (bool&)); + MOCK_METHOD(void, SetExtOnRelease, (const BundleName&, bool)); + MOCK_METHOD(void, RemoveExtOnRelease, (const BundleName&)); public: MOCK_METHOD(bool, UpdateToRestoreBundleMap, (const string&, const string&)); }; @@ -443,6 +451,26 @@ ErrCode Service::CleanBundleTempDir(const std::string& bundleName) { return BService::serviceMock->CleanBundleTempDir(bundleName); } + +ErrCode Service::HandleExtDisconnect(bool isIncBackup) +{ + return BService::serviceMock->HandleExtDisconnect(isIncBackup); +} + +ErrCode Service::GetExtOnRelease(bool &isExtOnRelease) +{ + return BService::serviceMock->GetExtOnRelease(isExtOnRelease); +} + +void Service::SetExtOnRelease(const BundleName &bundleName, bool isOnRelease) +{ + return BService::serviceMock->SetExtOnRelease(bundleName, isOnRelease); +} + +void Service::RemoveExtOnRelease(const BundleName &bundleName) +{ + return BService::serviceMock->RemoveExtOnRelease(bundleName); +} } // namespace OHOS::FileManagement::Backup namespace OHOS::FileManagement::Backup { @@ -1266,21 +1294,11 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalDone_0000, service->backupExtMutexMap_.clear(); EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)); - EXPECT_CALL(*srvMock, HandleCurAppDone(_, _, _)) - .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode())); - ret = service->AppIncrementalDone(BError(BError::Codes::SA_INVAL_ARG).GetCode()); - EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); - - service->backupExtMutexMap_.clear(); - EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); - EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)); - EXPECT_CALL(*srvMock, HandleCurAppDone(_, _, _)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); ret = service->AppIncrementalDone(BError(BError::Codes::SA_INVAL_ARG).GetCode()); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true)); - EXPECT_CALL(*srvMock, HandleCurAppDone(_, _, _)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); ret = service->AppIncrementalDone(errCode); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); } catch (...) { @@ -1784,7 +1802,8 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_CancelTask_0000, TestSiz EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(false)); EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(false)); EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)) + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); service->CancelTask("", service); EXPECT_TRUE(true); @@ -1794,7 +1813,8 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_CancelTask_0000, TestSiz EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(false)); EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(false)); EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)) + .WillOnce(Return(IServiceReverseType::Scenario::BACKUP)); EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(false)); service->CancelTask("", service); EXPECT_TRUE(true); @@ -1841,7 +1861,8 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_CancelTask_0100, TestSiz EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(false)); EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(false)); EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)) + .WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(false)); service->CancelTask("", service); EXPECT_TRUE(true); @@ -1853,6 +1874,7 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_CancelTask_0100, TestSiz EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(false)); EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)) + .WillOnce(Return(IServiceReverseType::Scenario::RESTORE)) .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(true)); service->CancelTask("", service); 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 01e289711e9ea79793565892fe04d7c216af16db..47eddbfe7c909363844ebeaa28df9b6701e5d83b 100644 --- a/tests/unittests/backup_sa/module_ipc/service_other_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/service_other_test.cpp @@ -1308,19 +1308,16 @@ HWTEST_F(ServiceTest, SUB_Service_AppDone_0200, TestSize.Level1) EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0)); EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)); - EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr)); auto ret = service->AppDone(errCode); - EXPECT_NE(ret, BError(BError::Codes::OK)); + EXPECT_EQ(ret, BError(BError::Codes::OK)); EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP)); EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0)); EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true)); - EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); - EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr)); ret = service->AppDone(errCode); - EXPECT_NE(ret, BError(BError::Codes::OK)); + EXPECT_EQ(ret, BError(BError::Codes::OK)); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by AppDone."; @@ -1931,10 +1928,12 @@ HWTEST_F(ServiceTest, SUB_Service_DoTimeout_0000, TestSize.Level1) EXPECT_TRUE(true); EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)) + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)) .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)) .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)).WillOnce(Return(true)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); + EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(true)); EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(true)); @@ -2516,4 +2515,209 @@ HWTEST_F(ServiceTest, SUB_Service_CleanBundleTempDir_0100, testing::ext::TestSiz } GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_CleanBundleTempDir_0100"; } + +/** + * @tc.number: SUB_Service_HandleExtDisconnect_0000 + * @tc.name: SUB_Service_HandleExtDisconnect_0000 + * @tc.desc: 测试 HandleExtDisconnect 的正常/异常分支 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: IC7RHQ + */ +HWTEST_F(ServiceTest, SUB_Service_HandleExtDisconnect_0000, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_HandleExtDisconnect_0000"; + try { + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP)); + EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(1)); + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()).WillOnce(Return(make_pair(false, -1))); + EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); + auto ret = service->HandleExtDisconnect(true); + EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by HandleExtDisconnect."; + } + GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_HandleExtDisconnect_0000"; +} + +/** + * @tc.number: SUB_Service_HandleExtDisconnect_0100 + * @tc.name: SUB_Service_HandleExtDisconnect_0100 + * @tc.desc: 测试 HandleExtDisconnect 的正常/异常分支 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: IC7RHQ + */ +HWTEST_F(ServiceTest, SUB_Service_HandleExtDisconnect_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_HandleExtDisconnect_0100"; + try { + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP)); + EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")); + EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr)); + auto ret = service->HandleExtDisconnect(true); + EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by HandleExtDisconnect."; + } + GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_HandleExtDisconnect_0100"; +} + +/** + * @tc.number: SUB_Service_HandleExtDisconnect_0200 + * @tc.name: SUB_Service_HandleExtDisconnect_0200 + * @tc.desc: 测试 HandleExtDisconnect 的正常/异常分支 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: IC7RHQ + */ +HWTEST_F(ServiceTest, SUB_Service_HandleExtDisconnect_0200, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_HandleExtDisconnect_0200"; + try { + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP)); + EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")); + EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); + EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr)); + auto ret = service->HandleExtDisconnect(true); + EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by HandleExtDisconnect."; + } + GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_HandleExtDisconnect_0200"; +} + +/** + * @tc.number: SUB_Service_HandleExtDisconnect_0300 + * @tc.name: SUB_Service_HandleExtDisconnect_0300 + * @tc.desc: 测试 HandleExtDisconnect 的正常/异常分支 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: IC7RHQ + */ +HWTEST_F(ServiceTest, SUB_Service_HandleExtDisconnect_0300, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_HandleExtDisconnect_0300"; + try { + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP)); + EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")); + EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); + EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); + EXPECT_CALL(*svcProxy, HandleClear()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); + EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(true)); + EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(true)); + EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); + EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); + EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(false)); + EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); + auto ret = service->HandleExtDisconnect(true); + EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by HandleExtDisconnect."; + } + GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_HandleExtDisconnect_0300"; +} + +/** + * @tc.number: SUB_Service_GetExtOnRelease_0000 + * @tc.name: SUB_Service_GetExtOnRelease_0000 + * @tc.desc: 测试 GetExtOnRelease 的正常/异常分支 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: IC7RHQ + */ +HWTEST_F(ServiceTest, SUB_Service_GetExtOnRelease_0000, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_GetExtOnRelease_0000"; + try { + bool isExtOnRelease = false; + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP)); + EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(1)); + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()).WillOnce(Return(make_pair(false, -1))); + EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); + auto ret = service->GetExtOnRelease(isExtOnRelease); + EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); + EXPECT_EQ(isExtOnRelease, false); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by GetExtOnRelease."; + } + GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_GetExtOnRelease_0000"; +} + +/** + * @tc.number: SUB_Service_GetExtOnRelease_0100 + * @tc.name: SUB_Service_GetExtOnRelease_0100 + * @tc.desc: 测试 GetExtOnRelease 的正常/异常分支 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: IC7RHQ + */ +HWTEST_F(ServiceTest, SUB_Service_GetExtOnRelease_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_GetExtOnRelease_0100"; + try { + bool isExtOnRelease = false; + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP)); + EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")); + auto ret = service->GetExtOnRelease(isExtOnRelease); + EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); + EXPECT_EQ(isExtOnRelease, false); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by GetExtOnRelease."; + } + GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_GetExtOnRelease_0100"; +} + +/** + * @tc.number: SUB_Service_GetExtOnRelease_0200 + * @tc.name: SUB_Service_GetExtOnRelease_0200 + * @tc.desc: 测试 GetExtOnRelease 的正常/异常分支 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: IC7RHQ + */ +HWTEST_F(ServiceTest, SUB_Service_GetExtOnRelease_0200, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_GetExtOnRelease_0200"; + try { + bool isExtOnRelease = false; + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP)); + EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("bundleName")); + service->SetExtOnRelease("bundleName", true); + auto ret = service->GetExtOnRelease(isExtOnRelease); + EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); + EXPECT_EQ(isExtOnRelease, true); + service->RemoveExtOnRelease("bundleName"); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by GetExtOnRelease."; + } + GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_GetExtOnRelease_0200"; +} } \ 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 c2050aa24c3b57376ce42ca25864260aead91ffa..342a934e1be8e0857ae67f38662826eee24db525 100644 --- a/tests/unittests/backup_sa/session/service_proxy_mock.cpp +++ b/tests/unittests/backup_sa/session/service_proxy_mock.cpp @@ -240,4 +240,14 @@ ErrCode ServiceProxy::CleanBundleTempDir(const std::string& bundleName) { return BError(BError::Codes::OK); } + +ErrCode ServiceProxy::HandleExtDisconnect(bool isIncBackup) +{ + return BError(BError::Codes::OK); +} + +ErrCode ServiceProxy::GetExtOnRelease(bool &isExtOnRelease) +{ + return BError(BError::Codes::OK); +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/unittests/backup_sa/session/service_proxy_mock.h b/tests/unittests/backup_sa/session/service_proxy_mock.h index 3ee48b1abc261523447ed16bdaeb4c981b9a5e10..3de5ed7b54867a979f7f7bfd8889c7a97cee7fde 100644 --- a/tests/unittests/backup_sa/session/service_proxy_mock.h +++ b/tests/unittests/backup_sa/session/service_proxy_mock.h @@ -73,6 +73,8 @@ public: ErrCode(int32_t, const std::vector &, int32_t, int32_t)); MOCK_METHOD2(GetBackupDataSize, ErrCode(bool isPreciseScan, const std::vector &bundleNameList)); MOCK_METHOD1(CleanBundleTempDir, ErrCode(const std::string &bundleName)); + MOCK_METHOD1(HandleExtDisconnect, ErrCode(bool isIncBackup)); + MOCK_METHOD1(GetExtOnRelease, ErrCode(bool &isExtOnRelease)); }; } // End of namespace OHOS::FileManagement::Backup #endif // TEST_UNITTEST_SERVICE_PROXY_MOCK_H diff --git a/utils/include/b_resources/b_constants.h b/utils/include/b_resources/b_constants.h index 59ee1ccbf141d5c15adf0a8a763206276cd0e592..2687c38e0cb48c1db43ad2e757bbcef9ebc15e6e 100644 --- a/utils/include/b_resources/b_constants.h +++ b/utils/include/b_resources/b_constants.h @@ -48,6 +48,12 @@ enum ServiceSchedAction { UNKNOWN = 5, }; +enum ExtensionScenario { + INVALID = 0, + BACKUP = 1, + RESTORE = 2, +}; + constexpr int SPAN_USERID_UID = 200000; constexpr int SYSTEM_UID = 0; constexpr int XTS_UID = 1; @@ -96,6 +102,8 @@ constexpr int APP_ON_PROCESS_MAX_TIMEOUT = 1000; // 应用的onProcess接口最 constexpr int FIRST_CALL_APP_ON_PROCESS_MAX_TIMEOUT = 15000; // 首次调用应用的onProcess接口最大超时时间为15秒 constexpr int APP_ON_PROCESS_TIMEOUT_MAX_COUNT = 3; // 应用的onProcess接口超时的上限次数 +constexpr int APP_ON_RELEASE_MAX_TIMEOUT = 5000; // 应用的onRelease接口最大超时时间为5秒 + // backup.para内配置项的名称，该配置项值为true时可在不更新hap包的情况下，可以读取包管理元数据配置文件的内容 static inline std::string BACKUP_DEBUG_OVERRIDE_EXTENSION_CONFIG_KEY = "backup.debug.overrideExtensionConfig"; static const bool BACKUP_DEBUG_OVERRIDE_EXTENSION_CONFIG_DEFAULT_VALUE = false;