diff --git a/frameworks/native/backup_ext/include/ext_extension.h b/frameworks/native/backup_ext/include/ext_extension.h
index cbc5b9c492b247f01608a93d73d7b423edc849a9..9dba03d38a6067caa16123ee07d88ade0300fa6c 100644
--- a/frameworks/native/backup_ext/include/ext_extension.h
+++ b/frameworks/native/backup_ext/include/ext_extension.h
@@ -91,7 +91,6 @@ public:
         reportOnProcessRetPool_.Stop();
         doBackupPool_.Stop();
         onReleaseTaskPool_.Stop();
-        onReleaseTimeoutTimer_.Shutdown();
         if (callJsOnProcessThread_.joinable()) {
             callJsOnProcessThread_.join();
         }
@@ -394,9 +393,6 @@ private:
     void UpdateTarStat(uint64_t tarFileSize);
 
     void HandleExtDisconnect();
-    void StartOnReleaseTimeOutTimer(wptr<BackupExtExtension> obj);
-    void CloseOnReleaseTimeOutTimer();
-    void CallJsOnReleaseTask(wptr<BackupExtExtension> obj, int32_t scenario, bool isNeedDisconnect);
     bool HandleGetExtOnRelease();
     void SetAppResultReport(const std::string resultInfo, ErrCode errCode);
     void HandleExtOnRelease();
@@ -450,15 +446,14 @@ private:
     BackupRestoreScenario curScenario_ { BackupRestoreScenario::FULL_BACKUP };
 
     OHOS::ThreadPool onReleaseTaskPool_;
-    Utils::Timer onReleaseTimeoutTimer_ {"onReleaseTimeoutTimer"};
-    uint32_t onReleaseTimeoutTimerId_ { 0 };
     std::atomic<bool> stopWaitOnRelease_ {false};
     std::mutex onReleaseLock_;
     std::condition_variable execOnReleaseCon_;
     std::atomic<bool> needAppResultReport_ {false};
     std::string appResultReportInfo_;
     ErrCode appResultReportErrCode_ { 0 };
-    std::mutex serviceCallReleaseLock_;
+    std::mutex execOnReleaseLock_ {};
+    std::atomic<bool> isOnReleased_ {false};
 
     std::mutex getCompatibilityInfoLock_ {};
     std::condition_variable getCompatibilityInfoCon_ {};
diff --git a/frameworks/native/backup_ext/src/sub_ext_extension.cpp b/frameworks/native/backup_ext/src/sub_ext_extension.cpp
index 1da153964cf7d0353883066166df2ae436cc792d..3f7af178ca7c19f8b41924d65dc79b813b597f90 100644
--- a/frameworks/native/backup_ext/src/sub_ext_extension.cpp
+++ b/frameworks/native/backup_ext/src/sub_ext_extension.cpp
@@ -1746,8 +1746,7 @@ std::function<void(ErrCode, const std::string)> BackupExtExtension::OnReleaseCal
             HILOGE("App onRelease timeout");
             return;
         }
-        std::unique_lock<std::mutex> lock(extPtr->onReleaseLock_);
-        extPtr->CloseOnReleaseTimeOutTimer();
+        std::unique_lock<std::mutex> lock(extPtr->execOnReleaseLock_);
         extPtr->stopWaitOnRelease_.store(true);
         extPtr->execOnReleaseCon_.notify_all();
         HILOGI("Extension onRelease end, errCode: %{public}d, errInfo: %{public}s", errCode, errMsg.c_str());
@@ -1759,14 +1758,30 @@ ErrCode BackupExtExtension::HandleOnRelease(int32_t scenario)
     try {
         HILOGI("HandleOnRelease Begin, scenario: %{public}d", scenario);
         VerifyCaller();
-        auto ptr = wptr<BackupExtExtension>(this);
-        onReleaseTimeoutTimer_.Setup();
-        StartOnReleaseTimeOutTimer(ptr);
-        // service主动release场景，等待onRelease完成或超时，备份/恢复完成场景不需等待
-        CallJsOnReleaseTask(ptr, scenario, false);
+        std::unique_lock<std::mutex> onReleaseLock(onReleaseLock_);
+        if (isOnReleased_.load()) {
+            HILOGE("onRelease done, not need to do again");
+            return ERR_OK;
+        }
+        auto task = [obj {wptr<BackupExtExtension>(this)}, scenario]() {
+            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);
+            }
+        };
+        onReleaseTaskPool_.AddTask([task]() { task(); });
         HILOGI("Wait onRelease to do");
-        std::unique_lock<std::mutex> lock(serviceCallReleaseLock_);
-        execOnReleaseCon_.wait(lock, [this] { return stopWaitOnRelease_.load(); });
+        std::unique_lock<std::mutex> lock(execOnReleaseLock_);
+        execOnReleaseCon_.wait_for(lock, std::chrono::milliseconds(BConstants::APP_ON_RELEASE_MAX_TIMEOUT),
+            [this] { return stopWaitOnRelease_.load(); });
+        stopWaitOnRelease_.store(true);
+        isOnReleased_.store(true);
         return ERR_OK;
     } catch (...) {
         HILOGE("Failed to HandleOnRelease");
@@ -1808,60 +1823,6 @@ bool BackupExtExtension::HandleGetExtOnRelease()
     return isExtOnRelease;
 }
 
-void BackupExtExtension::StartOnReleaseTimeOutTimer(wptr<BackupExtExtension> 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<std::mutex> 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<BackupExtExtension> 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<std::mutex> 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");
@@ -1879,10 +1840,37 @@ void BackupExtExtension::HandleExtOnRelease()
         curScenario_ == BackupRestoreScenario::INCREMENTAL_BACKUP) {
         scenario = static_cast<int32_t>(BConstants::ExtensionScenario::BACKUP);
     }
-    auto ptr = wptr<BackupExtExtension>(this);
-    onReleaseTimeoutTimer_.Setup();
-    StartOnReleaseTimeOutTimer(ptr);
-    CallJsOnReleaseTask(ptr, scenario, true);
+    auto task = [obj {wptr<BackupExtExtension>(this)}, scenario]() {
+        auto extPtr = obj.promote();
+        if (extPtr == nullptr || extPtr->extension_ == nullptr) {
+            HILOGE("Call js onRelease failed, extensionPtr is empty");
+            return;
+        }
+        {
+            std::unique_lock<std::mutex> onReleaseLock(extPtr->onReleaseLock_);
+            if (extPtr->isOnReleased_.load()) {
+                HILOGE("onRelease done, not need to do again");
+                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<std::mutex> lock(extPtr->execOnReleaseLock_);
+            extPtr->execOnReleaseCon_.wait_for(lock, std::chrono::milliseconds(BConstants::APP_ON_RELEASE_MAX_TIMEOUT),
+                [extPtr] { return extPtr->stopWaitOnRelease_.load(); });
+            extPtr->stopWaitOnRelease_.store(true);
+            extPtr->isOnReleased_.store(true);
+        }
+        if (extPtr->needAppResultReport_.load()) {
+            extPtr->AppResultReport(extPtr->appResultReportInfo_, extPtr->curScenario_,
+                extPtr->appResultReportErrCode_);
+        }
+        extPtr->HandleExtDisconnect();
+    };
+    onReleaseTaskPool_.AddTask([task]() { task(); });
 }
 
 std::function<void(ErrCode, const std::string)> BackupExtExtension::GetComInfoCallback(wptr<BackupExtExtension> obj)
diff --git a/services/backup_sa/include/module_ipc/svc_session_manager.h b/services/backup_sa/include/module_ipc/svc_session_manager.h
index 63ab2fecc9e5474121163c8c7ba57e3bb72d1d4f..5b3bbbbed4371a5b6f7abd08a595558a53c27443 100644
--- a/services/backup_sa/include/module_ipc/svc_session_manager.h
+++ b/services/backup_sa/include/module_ipc/svc_session_manager.h
@@ -577,6 +577,8 @@ public:
 
     void SetIsReadyLaunch(const std::string &bundleName);
 
+    void HandleOnRelease(sptr<IExtension> proxy);
+    
 private:
     /**
      * @brief 获取backup extension ability
diff --git a/services/backup_sa/src/module_ipc/service.cpp b/services/backup_sa/src/module_ipc/service.cpp
index 8f02bc0544d3250e4523aa24f30c481fe3b02829..9a64d35c3454f239cfb8d220f9f87d944715a49b 100644
--- a/services/backup_sa/src/module_ipc/service.cpp
+++ b/services/backup_sa/src/module_ipc/service.cpp
@@ -1595,7 +1595,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<int32_t>(session_->GetScenario()));
+        session_->HandleOnRelease(proxy);
         backUpConnection->DisconnectBackupExtAbility();
     }
     ClearSessionAndSchedInfo(bundleName);
diff --git a/services/backup_sa/src/module_ipc/service_incremental.cpp b/services/backup_sa/src/module_ipc/service_incremental.cpp
index 7a4a2af69db762a97aa29e18e88d3a7615e96d4c..f223767e35240d2dd2691513a46b27ae02a8a8e4 100644
--- a/services/backup_sa/src/module_ipc/service_incremental.cpp
+++ b/services/backup_sa/src/module_ipc/service_incremental.cpp
@@ -1020,7 +1020,7 @@ bool Service::CancelSessionClean(sptr<SvcSessionManager> session, std::string bu
     proxy->HandleClear();
     session->StopFwkTimer(bundleName);
     session->StopExtTimer(bundleName);
-    proxy->HandleOnRelease(static_cast<int32_t>(session->GetScenario()));
+    session->HandleOnRelease(proxy);
     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 d26e879c5aad864d037acef05d70a9cdcb59809d..59cbdb35a6f8f7e2a969c6325acf1ccdd788e950 100644
--- a/services/backup_sa/src/module_ipc/sub_service.cpp
+++ b/services/backup_sa/src/module_ipc/sub_service.cpp
@@ -1529,7 +1529,7 @@ void Service::HandleOnReleaseAndDisconnect(sptr<SvcSessionManager> sessionPtr, c
         HILOGE("Extension backup Proxy is empty");
         return;
     }
-    proxy->HandleOnRelease(static_cast<int32_t>(sessionPtr->GetScenario()));
+    sessionPtr->HandleOnRelease(proxy);
     sessionConnection->DisconnectBackupExtAbility();
 }
 
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 943cb495448b54d0a76dec9f60a30d174507b78d..4dccce6be477d503996a38eb55cc23d65dc13e26 100644
--- a/services/backup_sa/src/module_ipc/svc_session_manager.cpp
+++ b/services/backup_sa/src/module_ipc/svc_session_manager.cpp
@@ -1079,7 +1079,7 @@ ErrCode SvcSessionManager::ClearSessionData()
             if (impl_.restoreDataType != RestoreTypeEnum::RESTORE_DATA_READDY) {
                 ret = proxy->HandleClear();
             }
-            proxy->HandleOnRelease(static_cast<int32_t>(impl_.scenario));
+            HandleOnRelease(proxy);
             backUpConnection->DisconnectBackupExtAbility();
         }
         if (ret != BError(BError::Codes::OK)) {
@@ -1245,7 +1245,7 @@ bool SvcSessionManager::CleanAndCheckIfNeedWait(ErrCode &ret, std::vector<std::s
             } else {
                 ret = retTmp;
             }
-            proxy->HandleOnRelease(static_cast<int32_t>(impl_.scenario));
+            HandleOnRelease(proxy);
             backUpConnection->DisconnectBackupExtAbility();
             HILOGI("Disconnect extensionAbility, bundleName: %{public}s", it->first.c_str());
             it = impl_.backupExtNameMap.erase(it);
@@ -1317,4 +1317,19 @@ void SvcSessionManager::SetIsReadyLaunch(const std::string &bundleName)
     it->second.isReadyLaunch = true;
     HILOGE("SetIsReadyLaunch success, bundleName = %{public}s", bundleName.c_str());
 }
+
+void SvcSessionManager::HandleOnRelease(sptr<IExtension> proxy)
+{
+    if (proxy == nullptr) {
+        HILOGE("HandleOnRelease error, proxy is empty");
+        return;
+    }
+    if (impl_.scenario == IServiceReverseType::Scenario::UNDEFINED ||
+        impl_.scenario == IServiceReverseType::Scenario::CLEAN) {
+        HILOGE("scenario is %{public}d, not need to HandleOnRelease", impl_.scenario);
+        return;
+    }
+    HILOGI("HandleOnRelease begin");
+    proxy->HandleOnRelease(static_cast<int32_t>(impl_.scenario));
+}
 } // namespace OHOS::FileManagement::Backup
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 e8cf5e60c7befb18ca20e3a19e66f0840171497c..80b8e1690094dd3bb3b11851c9237e4530086b1c 100644
--- a/tests/mock/backup_ext/include/ext_backup_js_mock.h
+++ b/tests/mock/backup_ext/include/ext_backup_js_mock.h
@@ -50,11 +50,11 @@ public:
     virtual ErrCode CallJsOnBackupEx() = 0;
     virtual ErrCode CallJsOnBackup() = 0;
     virtual void ExportJsContext() = 0;
-    virtual ErrCode OnRelease(std::function<void(ErrCode, std::string)>, int32_t scenario) = 0;
-    virtual std::function<bool(napi_env, std::vector<napi_value> &argv) ParseReleaseInfo() = 0;
+    virtual ErrCode OnRelease(std::function<void(ErrCode, std::string)>, int32_t) = 0;
+    virtual std::function<bool(napi_env, std::vector<napi_value> &argv)> ParseReleaseInfo() = 0;
     virtual ErrCode GetBackupCompatibilityInfo(std::function<void(ErrCode, const std::string)>, std::string) = 0;
     virtual ErrCode GetRestoreCompatibilityInfo(std::function<void(ErrCode, const std::string)>, std::string) = 0;
-    virtual std::function<bool(napi_env, std::vector<napi_value> &argv) ParseCompatibilityInfo() = 0;
+    virtual std::function<bool(napi_env, std::vector<napi_value> &argv)> ParseCompatibilityInfo() = 0;
 public:
     virtual bool GetProfileFromAbility(const OHOS::AppExecFwk::AbilityInfo &, const std::string &,
         std::vector<std::string> &) const = 0;
@@ -88,6 +88,11 @@ public:
     MOCK_METHOD(ErrCode, CallJsOnBackupEx, ());
     MOCK_METHOD(ErrCode, CallJsOnBackup, ());
     MOCK_METHOD(void, ExportJsContext, ());
+    MOCK_METHOD(ErrCode, OnRelease, (std::function<void(ErrCode, std::string)>, int32_t));
+    MOCK_METHOD((std::function<bool(napi_env env, std::vector<napi_value> &argv)>), ParseReleaseInfo, ());
+    MOCK_METHOD(ErrCode, GetBackupCompatibilityInfo, (std::function<void(ErrCode, const std::string)>, std::string));
+    MOCK_METHOD(ErrCode, GetRestoreCompatibilityInfo, (std::function<void(ErrCode, const std::string)>, std::string));
+    MOCK_METHOD((std::function<bool(napi_env env, std::vector<napi_value> &argv)>), ParseCompatibilityInfo, ());
 public:
     MOCK_METHOD(bool, GetProfileFromAbility, (const OHOS::AppExecFwk::AbilityInfo&, const std::string&,
         std::vector<std::string>&), (const));
diff --git a/tests/mock/module_ipc/include/svc_session_manager_mock.h b/tests/mock/module_ipc/include/svc_session_manager_mock.h
index 99fc754eebe0f71a5249010e01842521916ee5d9..d5e982a602961df3008040dcf09c8a67a29325f6 100644
--- a/tests/mock/module_ipc/include/svc_session_manager_mock.h
+++ b/tests/mock/module_ipc/include/svc_session_manager_mock.h
@@ -63,6 +63,7 @@ public:
     virtual SvcSessionManager::Impl GetImpl() = 0;
     virtual std::string GetOldBackupVersion() = 0;
     virtual void UpdateDfxInfo(const BundleName &bundleName, uint64_t uniqId) = 0;
+    virtual void HandleOnRelease(sptr<IExtension> proxy) = 0;
 public:
     BSvcSessionManager() = default;
     virtual ~BSvcSessionManager() = default;
@@ -112,6 +113,7 @@ public:
     MOCK_METHOD(SvcSessionManager::Impl, GetImpl, ());
     MOCK_METHOD(std::string, GetOldBackupVersion, ());
     MOCK_METHOD(void, UpdateDfxInfo, (const std::string &, uint64_t));
+    MOCK_METHOD(void, HandleOnRelease, (sptr<IExtension>));
 };
 } // namespace OHOS::FileManagement::Backup
 #endif // OHOS_FILEMGMT_BACKUP_SVC_SESSION_MANAGER_MOCK_H
diff --git a/tests/mock/module_ipc/src/svc_session_manager_mock.cpp b/tests/mock/module_ipc/src/svc_session_manager_mock.cpp
index 017a8e9b48d43aa9a0f600eea4d8db4695ed13f7..05413708f069b91ae6295617a2fc80e9ea54f616 100644
--- a/tests/mock/module_ipc/src/svc_session_manager_mock.cpp
+++ b/tests/mock/module_ipc/src/svc_session_manager_mock.cpp
@@ -306,4 +306,8 @@ std::string SvcSessionManager::GetOldBackupVersion()
 {
     return BSvcSessionManager::sessionManager->GetOldBackupVersion();
 }
+
+void SvcSessionManager::HandleOnRelease(sptr<IExtension> proxy)
+{
+}
 } // namespace OHOS::FileManagement::Backup
diff --git a/tests/mock/module_ipc/svc_session_manager_mock.cpp b/tests/mock/module_ipc/svc_session_manager_mock.cpp
index ce966d25725f77a76c63f7b79ef4062f3ba8248e..26060dfccef3281dc1b6dc0b9188dbd24685410b 100644
--- a/tests/mock/module_ipc/svc_session_manager_mock.cpp
+++ b/tests/mock/module_ipc/svc_session_manager_mock.cpp
@@ -530,4 +530,8 @@ std::string SvcSessionManager::GetOldBackupVersion()
 void SvcSessionManager::UpdateDfxInfo(const std::string &bundleName, uint64_t uniqId)
 {
 }
+
+void SvcSessionManager::HandleOnRelease(sptr<IExtension> proxy)
+{
+}
 } // namespace OHOS::FileManagement::Backup
diff --git a/tests/mock/module_ipc/svc_session_manager_throw_mock.cpp b/tests/mock/module_ipc/svc_session_manager_throw_mock.cpp
index 3ff1375656801660d7d17130c845a60303b01668..2fb2f741ecb1e7449bdbfbd5ecb1516379804d3f 100644
--- a/tests/mock/module_ipc/svc_session_manager_throw_mock.cpp
+++ b/tests/mock/module_ipc/svc_session_manager_throw_mock.cpp
@@ -362,4 +362,6 @@ std::string SvcSessionManager::GetOldBackupVersion()
 {
     return BackupSvcSessionManager::session->GetOldBackupVersion();
 }
+
+void SvcSessionManager::HandleOnRelease(sptr<IExtension> proxy) {}
 } // namespace OHOS::FileManagement::Backup
diff --git a/tests/mock/module_ipc/svc_session_manager_throw_mock.h b/tests/mock/module_ipc/svc_session_manager_throw_mock.h
index 0c0df92f8ff47af7c76563fd4d311d962c62b591..65fd948bdfcc0d5d09ce7da3334ff82211a97615 100644
--- a/tests/mock/module_ipc/svc_session_manager_throw_mock.h
+++ b/tests/mock/module_ipc/svc_session_manager_throw_mock.h
@@ -99,6 +99,7 @@ public:
     virtual void SetOldBackupVersion(const std::string &backupVersion) = 0;
     virtual std::string GetOldBackupVersion() = 0;
     virtual void UpdateDfxInfo(const BundleName &bundleName, uint64_t uniqId) = 0;
+    virtual void HandleOnRelease(sptr<IExtension> proxy) = 0;
 public:
     static inline std::shared_ptr<BackupSvcSessionManager> session = nullptr;
 };
@@ -177,6 +178,7 @@ public:
     MOCK_METHOD(void, SetOldBackupVersion, (const std::string &));
     MOCK_METHOD(std::string, GetOldBackupVersion, ());
     MOCK_METHOD(void, UpdateDfxInfo, (const std::string &, uint64_t));
+    MOCK_METHOD(void, HandleOnRelease, (sptr<IExtension>));
 };
 
 } // namespace OHOS::FileManagement::Backup
diff --git a/tests/unittests/backup_ext/BUILD.gn b/tests/unittests/backup_ext/BUILD.gn
index 6cdcee1cb719e56ca2b7929842b859aedd27d220..0e44de2a650a9793130a5caa630a864d3175d2b5 100644
--- a/tests/unittests/backup_ext/BUILD.gn
+++ b/tests/unittests/backup_ext/BUILD.gn
@@ -504,6 +504,7 @@ ohos_unittest("ext_extension_sub_test") {
 
   sources = [
     "${path_backup}/tests/mock/backup_ext/src/ext_backup_mock.cpp",
+    "${path_backup}/tests/mock/backup_ext/src/ext_backup_js_mock.cpp",
     "${path_backup}/tests/mock/backup_ext/src/ext_extension_mock.cpp",
     "${path_backup}/tests/mock/backup_kit_inner/service_proxy_mock.cpp",
     "${path_backup}/tests/mock/utils_mock/src/utils_mock_global_variable.cpp",
diff --git a/tests/unittests/backup_ext/ext_extension_sub_test.cpp b/tests/unittests/backup_ext/ext_extension_sub_test.cpp
index ea5461cb823ca66720c131b17c4532673fbad32c..243ed250597242be372a786a74710f318a108d16 100644
--- a/tests/unittests/backup_ext/ext_extension_sub_test.cpp
+++ b/tests/unittests/backup_ext/ext_extension_sub_test.cpp
@@ -220,4 +220,90 @@ HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_HandleGetCompatibilityInfo_Test_
     }
     GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_HandleGetCompatibilityInfo_Test_0100";
 }
+
+/**
+ * @tc.number: Ext_Extension_Sub_HandleOnRelease_Test_0100
+ * @tc.name: Ext_Extension_Sub_HandleOnRelease_Test_0100
+ * @tc.desc: 测试HandleOnRelease
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: I9P3Y3
+ */
+HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_HandleOnRelease_Test_0100, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_HandleOnRelease_Test_0100";
+    try {
+        int32_t scenario = 1;
+        bool isOnReleased = extExtension->isOnReleased_.load();
+        extExtension->isOnReleased_.store(true);
+        auto ret = extExtension->HandleOnRelease(scenario);
+        EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
+
+        extExtension->isOnReleased_.store(false);
+        auto ext = extExtension->extension_;
+        extExtension->extension_ = nullptr;
+        ret = extExtension->HandleOnRelease(scenario);
+        extExtension->extension_ = ext;
+        EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
+
+        ret = extExtension->HandleOnRelease(scenario);
+        extExtension->isOnReleased_.store(isOnReleased);
+        EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
+    }
+    GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_HandleOnRelease_Test_0100";
+}
+
+/**
+ * @tc.number: Ext_Extension_Sub_HandleExtOnRelease_Test_0100
+ * @tc.name: Ext_Extension_Sub_HandleExtOnRelease_Test_0100
+ * @tc.desc: 测试HandleExtOnRelease
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: I9P3Y3
+ */
+HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_HandleExtOnRelease_Test_0100, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_HandleExtOnRelease_Test_0100";
+    try {
+        auto curScenario = extExtension->curScenario_;
+        extExtension->curScenario_ = BackupRestoreScenario::FULL_BACKUP;
+        auto ext = extExtension->extension_;
+        extExtension->extension_ = nullptr;
+        extExtension->HandleExtOnRelease();
+        EXPECT_TRUE(true);
+
+        extExtension->curScenario_ = BackupRestoreScenario::FULL_RESTORE;
+        extExtension->HandleExtOnRelease();
+        EXPECT_TRUE(true);
+
+        extExtension->extension_ = ext;
+        EXPECT_NE(extExtension->extension_, nullptr);
+        bool isOnReleased = extExtension->isOnReleased_.load();
+        extExtension->isOnReleased_.store(true);
+        extExtension->HandleExtOnRelease();
+        EXPECT_TRUE(true);
+
+        extExtension->isOnReleased_.store(false);
+        EXPECT_CALL(*extBackupMock, OnRelease(_, _)).WillOnce(Return(BError(BError::Codes::EXT_INVAL_ARG).GetCode()));
+        extExtension->HandleExtOnRelease();
+        EXPECT_TRUE(true);
+
+        EXPECT_CALL(*extBackupMock, OnRelease(_, _)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
+        extExtension->needAppResultReport_.store(false);
+        extExtension->HandleExtOnRelease();
+        EXPECT_TRUE(true);
+
+        extExtension->isOnReleased_.store(isOnReleased);
+        extExtension->curScenario_ = curScenario;
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
+    }
+    GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_HandleExtOnRelease_Test_0100";
+}
 }
\ No newline at end of file
diff --git a/tests/unittests/backup_sa/module_ipc/BUILD.gn b/tests/unittests/backup_sa/module_ipc/BUILD.gn
index 676ad460b0ce4a6c041113e964b1cde72d0e01e8..3c8a43658c1d1cd7a7df72676949584e1cc23588 100644
--- a/tests/unittests/backup_sa/module_ipc/BUILD.gn
+++ b/tests/unittests/backup_sa/module_ipc/BUILD.gn
@@ -264,6 +264,7 @@ ohos_unittest("backup_service_session_test") {
     "${path_backup}/interfaces/inner_api/native/backup_kit_inner/impl",
     "${path_backup}/tests/unittests/backup_api/backup_impl/include",
     "${path_backup_mock}/bundle_manager/include",
+    "${path_backup_mock}/module_ipc/include",
   ]
 
   deps = [
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 918949c97432deda9e0e93aaf39ada7d2b451bdf..cfedb16ce10bac2d4379c4a44e4b5cbe90dc1fc8 100644
--- a/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp
+++ b/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp
@@ -1917,6 +1917,8 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_CancelTask_0100, TestSiz
         EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP))
             .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED));
         EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(true));
+        EXPECT_CALL(*session, GetServiceReverseProxy()).WillRepeatedly(Return(srProxy));
+        EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleFinished(_, _)).WillRepeatedly(Return(0));
         service->CancelTask("", service);
         EXPECT_TRUE(true);
 
diff --git a/tests/unittests/backup_sa/module_ipc/sub_service_test.cpp b/tests/unittests/backup_sa/module_ipc/sub_service_test.cpp
index 161dfe7c5ff79f2dcb8683ec330bb6458dc1a65d..01c51ed5f193b1b961913fb0c1215f6322835eaf 100644
--- a/tests/unittests/backup_sa/module_ipc/sub_service_test.cpp
+++ b/tests/unittests/backup_sa/module_ipc/sub_service_test.cpp
@@ -2304,6 +2304,7 @@ HWTEST_F(ServiceTest, SUB_Service_GetCompatibilityInfo_0200, testing::ext::TestS
         res = service->GetCompatibilityInfo(bundleName, extInfo, compatInfo);
         EXPECT_EQ(res, BError(BError::Codes::SA_INVAL_ARG).GetCode());
 
+        EXPECT_CALL(*session, GetScenario()).WillRepeatedly(Return(IServiceReverseType::Scenario::RESTORE));
         EXPECT_CALL(*svcProxy, HandleGetCompatibilityInfo(_, _, _))
             .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
         res = service->GetCompatibilityInfo(bundleName, extInfo, compatInfo);
diff --git a/tests/unittests/backup_sa/module_ipc/svc_session_manager_ex_test.cpp b/tests/unittests/backup_sa/module_ipc/svc_session_manager_ex_test.cpp
index 8fb3a0735166d23133184b3f03dfe16d6367c8f3..5392951f59177021998f2de8e735d607fa0d18ef 100644
--- a/tests/unittests/backup_sa/module_ipc/svc_session_manager_ex_test.cpp
+++ b/tests/unittests/backup_sa/module_ipc/svc_session_manager_ex_test.cpp
@@ -293,4 +293,37 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_CleanAndCheckIfNeedWait_03
         GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by CleanAndCheckIfNeedWait.";
     }
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_CleanAndCheckIfNeedWait_0300";
+}
+
+/**
+ * @tc.number: SUB_backup_sa_session_HandleOnRelease_0100
+ * @tc.name: SUB_backup_sa_session_HandleOnRelease_0100
+ * @tc.desc: 测试 HandleOnRelease
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: I6F3GV
+ */
+HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_HandleOnRelease_0100, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_HandleOnRelease_0100";
+    try {
+        sptr<SvcExtensionProxyMock> svcProxy = nullptr;
+        sessionManagerPtr_->HandleOnRelease(svcProxy);
+
+        svcProxy = sptr(new SvcExtensionProxyMock());
+        EXPECT_NE(svcProxy, nullptr);
+        sessionManagerPtr_->impl_.scenario = IServiceReverseType::Scenario::UNDEFINED;
+        sessionManagerPtr_->HandleOnRelease(svcProxy);
+
+        sessionManagerPtr_->impl_.scenario = IServiceReverseType::Scenario::CLEAN;
+        sessionManagerPtr_->HandleOnRelease(svcProxy);
+
+        sessionManagerPtr_->impl_.scenario = IServiceReverseType::Scenario::BACKUP;
+        sessionManagerPtr_->HandleOnRelease(svcProxy);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by HandleOnRelease.";
+    }
+    GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_HandleOnRelease_0100";
 }
\ No newline at end of file
diff --git a/tests/unittests/backup_sa/module_ipc/svc_session_manager_test.cpp b/tests/unittests/backup_sa/module_ipc/svc_session_manager_test.cpp
index bd61dd570f072815d00ce70f10069cca88ec6cdb..2802450cfbc181d9ab2ab58d90f0be78e213a5c5 100644
--- a/tests/unittests/backup_sa/module_ipc/svc_session_manager_test.cpp
+++ b/tests/unittests/backup_sa/module_ipc/svc_session_manager_test.cpp
@@ -24,6 +24,7 @@
 #include "module_ipc/service.h"
 #include "module_ipc/svc_session_manager.h"
 #include "service_reverse_mock.h"
+#include "svc_extension_proxy_mock.h"
 #include "test_manager.h"
 
 namespace OHOS::FileManagement::Backup {