diff --git a/frameworks/native/backup_ext/src/ext_extension.cpp b/frameworks/native/backup_ext/src/ext_extension.cpp
index 72010a892e74f6e647c1b62586948d54a9944a19..8d25b2491ef25d58c599758f5c8ed21ced0a737a 100644
--- a/frameworks/native/backup_ext/src/ext_extension.cpp
+++ b/frameworks/native/backup_ext/src/ext_extension.cpp
@@ -476,9 +476,9 @@ ErrCode BackupExtExtension::IndexFileReady(const TarMap &pkgInfo, sptr<IService>
         HILOGE("get index size fail err:%{public}d", err);
     }
     int fdval = open(INDEX_FILE_BACKUP.data(), O_RDONLY);
-    ErrCode ret =
-       proxy->AppFileReady(string(BConstants::EXT_BACKUP_MANAGE), fdval,
-           ERR_OK);
+    ErrCode ret = fdval < 0 ?
+            proxy->AppFileReadyWithoutFd(string(BConstants::EXT_BACKUP_MANAGE), ERR_OK) :
+            proxy->AppFileReady(string(BConstants::EXT_BACKUP_MANAGE), fdval, ERR_OK);
     if (SUCCEEDED(ret)) {
         HILOGI("The application is packaged successfully");
     } else {
@@ -527,7 +527,8 @@ ErrCode BackupExtExtension::BigFileReady(TarMap &bigFileInfo, sptr<IService> pro
                 continue;
             }
         }
-        ret = proxy->AppFileReady(item.first, fdval, errCode);
+        ret = fdval < 0 ? proxy->AppFileReadyWithoutFd(item.first, errCode) :
+                          proxy->AppFileReady(item.first, fdval, errCode);
         if (SUCCEEDED(ret)) {
             HILOGI("The application is packaged successfully, package name is %{public}s", item.first.c_str());
         } else {
@@ -707,7 +708,8 @@ static ErrCode TarFileReady(const TarMap &tarFileInfo, sptr<IService> proxy)
         HILOGE("TarFileReady open file failed, file name is %{public}s, err = %{public}d", tarName.c_str(), errno);
         errCode = errno;
     }
-    int ret = proxy->AppFileReady(tarName, fdval, errCode);
+    int ret = fdval < 0 ? proxy->AppFileReadyWithoutFd(tarName, errCode) :
+              proxy->AppFileReady(tarName, fdval, errCode);
     if (SUCCEEDED(ret)) {
         HILOGI("TarFileReady: AppFileReady success for %{public}s", tarName.c_str());
         // 删除文件
@@ -2003,75 +2005,6 @@ ErrCode BackupExtExtension::HandleRestore(bool isClearData)
     }
 }
 
-static bool IfEquality(const ReportFileInfo &info, const ReportFileInfo &infoAd)
-{
-    return info.filePath < infoAd.filePath;
-}
-
-static void AdDeduplication(vector<struct ReportFileInfo> &filesList)
-{
-    sort(filesList.begin(), filesList.end(), IfEquality);
-    auto it = unique(filesList.begin(), filesList.end(), [](const ReportFileInfo &info, const ReportFileInfo &infoAd) {
-        return info.filePath == infoAd.filePath;
-        });
-    filesList.erase(it, filesList.end());
-}
-
-void BackupExtExtension::FillFileInfos(UniqueFd incrementalFd,
-                                       UniqueFd manifestFd,
-                                       vector<struct ReportFileInfo> &allFiles,
-                                       vector<struct ReportFileInfo> &smallFiles,
-                                       vector<struct ReportFileInfo> &bigFiles)
-{
-    HILOGI("Begin Compare");
-    BReportEntity cloudRp(move(manifestFd));
-    unordered_map<string, struct ReportFileInfo> cloudFiles;
-    cloudRp.GetReportInfos(cloudFiles);
-    appStatistic_->scanFileSpend_.Start();
-    if (cloudFiles.empty()) {
-        FillFileInfosWithoutCmp(allFiles, smallFiles, bigFiles, move(incrementalFd));
-    } else {
-        FillFileInfosWithCmp(allFiles, smallFiles, bigFiles, cloudFiles, move(incrementalFd));
-    }
-
-    AdDeduplication(allFiles);
-    AdDeduplication(smallFiles);
-    AdDeduplication(bigFiles);
-    appStatistic_->smallFileCount_ = smallFiles.size();
-    appStatistic_->bigFileCount_ = bigFiles.size();
-    appStatistic_->scanFileSpend_.End();
-    HILOGI("End Compare, allfile is %{public}zu, smallfile is %{public}zu, bigfile is %{public}zu",
-        allFiles.size(), smallFiles.size(), bigFiles.size());
-}
-
-ErrCode BackupExtExtension::HandleIncrementalBackup(int incrementalFd, int manifestFd)
-{
-    HILOGI("Start HandleIncrementalBackup. incrementalFd:%{public}d, manifestFd:%{public}d", incrementalFd, manifestFd);
-    UniqueFd incrementalFdUnique(dup(incrementalFd));
-    UniqueFd manifestFdUnique(dup(manifestFd));
-    ErrCode ret = HandleIncrementalBackup(std::move(incrementalFdUnique), std::move(manifestFdUnique));
-    close(incrementalFd);
-    close(manifestFd);
-    return ret;
-}
-
-ErrCode BackupExtExtension::HandleIncrementalBackup(UniqueFd incrementalFd, UniqueFd manifestFd)
-{
-    HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__);
-    try {
-        HILOGI("Start HandleIncrementalBackup");
-        if (!IfAllowToBackupRestore()) {
-            return BError(BError::Codes::EXT_FORBID_BACKUP_RESTORE, "Application does not allow backup or restore")
-                .GetCode();
-        }
-        AsyncTaskDoIncrementalBackup(move(incrementalFd), move(manifestFd));
-        return ERR_OK;
-    } catch (...) {
-        HILOGE("Failed to handle incremental backup");
-        return BError(BError::Codes::EXT_INVAL_ARG).GetCode();
-    }
-}
-
 ErrCode BackupExtExtension::IncrementalOnBackup(bool isClearData)
 {
     HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__);
@@ -2125,7 +2058,9 @@ ErrCode BackupExtExtension::IncrementalTarFileReady(const TarMap &bigFileInfo,
     string tarName = string(INDEX_FILE_INCREMENTAL_BACKUP).append(tarFile);
     int fd = open(tarName.data(), O_RDONLY);
     int manifestFd = open(file.data(), O_RDONLY);
-    ErrCode ret = proxy->AppIncrementalFileReady(tarFile, fd, manifestFd, ERR_OK);
+    ErrCode ret = (fd < 0 || manifestFd < 0) ?
+                  proxy->AppIncrementalFileReadyWithoutFd(tarFile, ERR_OK) :
+                  proxy->AppIncrementalFileReady(tarFile, fd, manifestFd, ERR_OK);
     if (SUCCEEDED(ret)) {
         HILOGI("IncrementalTarFileReady: The application is packaged successfully");
         // 删除文件
@@ -2175,7 +2110,9 @@ ErrCode BackupExtExtension::IncrementalBigFileReady(TarMap &pkgInfo,
         string file = GetReportFileName(string(INDEX_FILE_INCREMENTAL_BACKUP).append(item.first));
         WriteFile(file, bigInfo);
         int manifestFdval = open(file.data(), O_RDONLY);
-        ret = proxy->AppIncrementalFileReady(item.first, fdval, manifestFdval, errCode);
+        bool fdFlag = (fdval < 0 || manifestFdval < 0) ? false : true;
+        ErrCode ret = fdFlag ? proxy->AppIncrementalFileReady(item.first, fdval, manifestFdval, errCode) :
+                      proxy->AppIncrementalFileReadyWithoutFd(item.first, errCode);
         if (SUCCEEDED(ret)) {
             HILOGI("IncrementalBigFileReady: The application is packaged successfully, package name is %{public}s",
                    item.first.c_str());
@@ -2209,9 +2146,9 @@ ErrCode BackupExtExtension::IncrementalAllFileReady(const TarMap &pkgInfo,
     WriteFile(file, srcFiles);
     int fdval = open(INDEX_FILE_BACKUP.data(), O_RDONLY);
     int manifestFdval = open(file.data(), O_RDONLY);
-    ErrCode ret =
-        proxy->AppIncrementalFileReady(string(BConstants::EXT_BACKUP_MANAGE), fdval,
-            manifestFdval, ERR_OK);
+    ErrCode ret = fdval < 0 ?
+            proxy->AppIncrementalFileReadyWithoutFd(string(BConstants::EXT_BACKUP_MANAGE), ERR_OK) :
+            proxy->AppIncrementalFileReady(string(BConstants::EXT_BACKUP_MANAGE), fdval, manifestFdval, ERR_OK);
     if (SUCCEEDED(ret)) {
         HILOGI("IncrementalAllFileReady successfully");
         RemoveFile(file);
diff --git a/frameworks/native/backup_ext/src/sub_ext_extension.cpp b/frameworks/native/backup_ext/src/sub_ext_extension.cpp
index b771262fe9607f5be56045047506b76b50142a1e..6cbecd9418790964f0d0f7cf36f37b6b2ba4589d 100644
--- a/frameworks/native/backup_ext/src/sub_ext_extension.cpp
+++ b/frameworks/native/backup_ext/src/sub_ext_extension.cpp
@@ -1681,4 +1681,73 @@ tuple<UniqueFd, UniqueFd> BackupExtExtension::GetIncrementalBackupFileHandle()
     HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__);
     return {UniqueFd(BConstants::INVALID_FD_NUM), UniqueFd(BConstants::INVALID_FD_NUM)};
 }
+
+static bool IfEquality(const ReportFileInfo &info, const ReportFileInfo &infoAd)
+{
+    return info.filePath < infoAd.filePath;
+}
+
+static void AdDeduplication(vector<struct ReportFileInfo> &filesList)
+{
+    sort(filesList.begin(), filesList.end(), IfEquality);
+    auto it = unique(filesList.begin(), filesList.end(), [](const ReportFileInfo &info, const ReportFileInfo &infoAd) {
+        return info.filePath == infoAd.filePath;
+        });
+    filesList.erase(it, filesList.end());
+}
+
+void BackupExtExtension::FillFileInfos(UniqueFd incrementalFd,
+                                       UniqueFd manifestFd,
+                                       vector<struct ReportFileInfo> &allFiles,
+                                       vector<struct ReportFileInfo> &smallFiles,
+                                       vector<struct ReportFileInfo> &bigFiles)
+{
+    HILOGI("Begin Compare");
+    BReportEntity cloudRp(move(manifestFd));
+    unordered_map<string, struct ReportFileInfo> cloudFiles;
+    cloudRp.GetReportInfos(cloudFiles);
+    appStatistic_->scanFileSpend_.Start();
+    if (cloudFiles.empty()) {
+        FillFileInfosWithoutCmp(allFiles, smallFiles, bigFiles, move(incrementalFd));
+    } else {
+        FillFileInfosWithCmp(allFiles, smallFiles, bigFiles, cloudFiles, move(incrementalFd));
+    }
+
+    AdDeduplication(allFiles);
+    AdDeduplication(smallFiles);
+    AdDeduplication(bigFiles);
+    appStatistic_->smallFileCount_ = smallFiles.size();
+    appStatistic_->bigFileCount_ = bigFiles.size();
+    appStatistic_->scanFileSpend_.End();
+    HILOGI("End Compare, allfile is %{public}zu, smallfile is %{public}zu, bigfile is %{public}zu",
+        allFiles.size(), smallFiles.size(), bigFiles.size());
+}
+
+ErrCode BackupExtExtension::HandleIncrementalBackup(int incrementalFd, int manifestFd)
+{
+    HILOGI("Start HandleIncrementalBackup. incrementalFd:%{public}d, manifestFd:%{public}d", incrementalFd, manifestFd);
+    UniqueFd incrementalFdUnique(dup(incrementalFd));
+    UniqueFd manifestFdUnique(dup(manifestFd));
+    ErrCode ret = HandleIncrementalBackup(std::move(incrementalFdUnique), std::move(manifestFdUnique));
+    close(incrementalFd);
+    close(manifestFd);
+    return ret;
+}
+
+ErrCode BackupExtExtension::HandleIncrementalBackup(UniqueFd incrementalFd, UniqueFd manifestFd)
+{
+    HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__);
+    try {
+        HILOGI("Start HandleIncrementalBackup");
+        if (!IfAllowToBackupRestore()) {
+            return BError(BError::Codes::EXT_FORBID_BACKUP_RESTORE, "Application does not allow backup or restore")
+                .GetCode();
+        }
+        AsyncTaskDoIncrementalBackup(move(incrementalFd), move(manifestFd));
+        return ERR_OK;
+    } catch (...) {
+        HILOGE("Failed to handle incremental backup");
+        return BError(BError::Codes::EXT_INVAL_ARG).GetCode();
+    }
+}
 } // namespace OHOS::FileManagement::Backup
diff --git a/frameworks/native/backup_kit_inner/include/service_reverse.h b/frameworks/native/backup_kit_inner/include/service_reverse.h
index 90b51874e96a7cad33d6527e1d09c88b759230b2..ec905ec3c5324b3306a8b1d839d74e02aed0e487 100644
--- a/frameworks/native/backup_kit_inner/include/service_reverse.h
+++ b/frameworks/native/backup_kit_inner/include/service_reverse.h
@@ -32,6 +32,9 @@ public:
                               const std::string &fileName,
                               int fd,
                               int32_t errCode) override;
+    ErrCode BackupOnFileReadyWithoutFd(const std::string &bundleName,
+                                       const std::string &fileName,
+                                       int32_t errCode) override;
     ErrCode BackupOnBundleStarted(int32_t errCode, const std::string &bundleName) override;
     ErrCode BackupOnResultReport(const std::string &result, const std::string &bundleName) override;
     ErrCode BackupOnBundleFinished(int32_t errCode, const std::string &bundleName) override;
@@ -46,6 +49,9 @@ public:
                                const std::string &fileName,
                                int fd,
                                int32_t errCode) override;
+    ErrCode RestoreOnFileReadyWithoutFd(const std::string &bundleName,
+                                        const std::string &fileName,
+                                        int32_t errCode) override;
     ErrCode RestoreOnResultReport(const std::string &result,
                                   const std::string &bundleName,
                                   ErrCode errCode = 0) override;
@@ -58,6 +64,9 @@ public:
                                          int32_t errCode) override;
     ErrCode IncrementalSaBackupOnFileReady(const std::string &bundleName, const std::string &fileName,
                                            int fd, int32_t errCode) override;
+    ErrCode IncrementalBackupOnFileReadyWithoutFd(const std::string &bundleName,
+                                         const std::string &fileName,
+                                         int32_t errCode) override;
     ErrCode IncrementalBackupOnBundleStarted(int32_t errCode, const std::string &bundleName) override;
     ErrCode IncrementalBackupOnResultReport(const std::string &result, const std::string &bundleName) override;
     ErrCode IncrementalBackupOnBundleFinished(int32_t errCode, const std::string &bundleName) override;
diff --git a/frameworks/native/backup_kit_inner/src/b_incremental_backup_session.cpp b/frameworks/native/backup_kit_inner/src/b_incremental_backup_session.cpp
index a3f98f0b676b5a085b104e9ff9ba7556cc5c6b76..be5413d5d0d0b98c5a53d04c78b008b1b3743bb2 100644
--- a/frameworks/native/backup_kit_inner/src/b_incremental_backup_session.cpp
+++ b/frameworks/native/backup_kit_inner/src/b_incremental_backup_session.cpp
@@ -202,11 +202,7 @@ ErrCode BIncrementalBackupSession::Cancel(std::string bundleName)
         return result;
     }
 
-    ErrCode errCode = proxy->Cancel(bundleName, result);
-    if (errCode != 0) {
-        HILOGE("proxy->Cancel failed, errCode:%{public}d.", errCode);
-        return result;
-    }
+    proxy->CancelForResult(bundleName, result);
     return result;
 }
 
diff --git a/frameworks/native/backup_kit_inner/src/b_incremental_restore_session.cpp b/frameworks/native/backup_kit_inner/src/b_incremental_restore_session.cpp
index 2216b47d40a1ce1e324957d8a6d61c44472dddab..78b92c231dd36323d6dd594e662ce6c5e9dbca6d 100644
--- a/frameworks/native/backup_kit_inner/src/b_incremental_restore_session.cpp
+++ b/frameworks/native/backup_kit_inner/src/b_incremental_restore_session.cpp
@@ -224,11 +224,7 @@ ErrCode BIncrementalRestoreSession::Cancel(std::string bundleName)
         return result;
     }
 
-    ErrCode errCode = proxy->Cancel(bundleName, result);
-    if (errCode != 0) {
-        HILOGE("proxy->Cancel failed, errCode:%{public}d.", errCode);
-        return result;
-    }
+    proxy->CancelForResult(bundleName, result);
     return result;
 }
 
diff --git a/frameworks/native/backup_kit_inner/src/b_incremental_session_restore_async.cpp b/frameworks/native/backup_kit_inner/src/b_incremental_session_restore_async.cpp
index d812f6beef2b95da9ed56c6d1498b331cedd2488..64591a0e2f6157183eefe1029be1ef2cf1f95edd 100644
--- a/frameworks/native/backup_kit_inner/src/b_incremental_session_restore_async.cpp
+++ b/frameworks/native/backup_kit_inner/src/b_incremental_session_restore_async.cpp
@@ -175,11 +175,7 @@ ErrCode BIncrementalSessionRestoreAsync::Cancel(std::string bundleName)
         return result;
     }
 
-    ErrCode errCode = proxy->Cancel(bundleName, result);
-    if (errCode != 0) {
-        HILOGE("proxy->Cancel failed, errCode:%{public}d.", errCode);
-        return result;
-    }
+    proxy->CancelForResult(bundleName, result);
     return result;
 }
 } // namespace OHOS::FileManagement::Backup
\ No newline at end of file
diff --git a/frameworks/native/backup_kit_inner/src/b_session_backup.cpp b/frameworks/native/backup_kit_inner/src/b_session_backup.cpp
index 1a7a1ba5758d1dd4481e51ce5e8751bfa6bb2acd..992125a31fa55a961dd1378d356e66339eeb00c6 100644
--- a/frameworks/native/backup_kit_inner/src/b_session_backup.cpp
+++ b/frameworks/native/backup_kit_inner/src/b_session_backup.cpp
@@ -221,11 +221,7 @@ ErrCode BSessionBackup::Cancel(std::string bundleName)
         return result;
     }
 
-    ErrCode errCode = proxy->Cancel(bundleName, result);
-    if (errCode != 0) {
-        HILOGE("proxy->Cancel failed, errCode:%{public}d.", errCode);
-        return result;
-    }
+    proxy->CancelForResult(bundleName, result);
     return result;
 }
 
diff --git a/frameworks/native/backup_kit_inner/src/b_session_restore.cpp b/frameworks/native/backup_kit_inner/src/b_session_restore.cpp
index 703ac92ad28470c534c4ec85069edd53a7e86d87..34dfc57c322d5556b26677ea07bbfe614ee65148 100644
--- a/frameworks/native/backup_kit_inner/src/b_session_restore.cpp
+++ b/frameworks/native/backup_kit_inner/src/b_session_restore.cpp
@@ -202,11 +202,7 @@ ErrCode BSessionRestore::Cancel(std::string bundleName)
         return result;
     }
 
-    ErrCode errCode = proxy->Cancel(bundleName, result);
-    if (errCode != 0) {
-        HILOGE("proxy->Cancel failed, errCode:%{public}d.", errCode);
-        return result;
-    }
+    proxy->CancelForResult(bundleName, result);
     return result;
 }
 
diff --git a/frameworks/native/backup_kit_inner/src/b_session_restore_async.cpp b/frameworks/native/backup_kit_inner/src/b_session_restore_async.cpp
index 8cc600b95df81a125bcc2b91d181641410eac516..22fda54f51e37d418243381869c4436514ef6a9e 100644
--- a/frameworks/native/backup_kit_inner/src/b_session_restore_async.cpp
+++ b/frameworks/native/backup_kit_inner/src/b_session_restore_async.cpp
@@ -175,11 +175,7 @@ ErrCode BSessionRestoreAsync::Cancel(std::string bundleName)
         return result;
     }
 
-    ErrCode errCode = proxy->Cancel(bundleName, result);
-    if (errCode != 0) {
-        HILOGE("proxy->Cancel failed, errCode:%{public}d.", errCode);
-        return result;
-    }
+    proxy->CancelForResult(bundleName, result);
     return result;
 }
 } // namespace OHOS::FileManagement::Backup
\ No newline at end of file
diff --git a/frameworks/native/backup_kit_inner/src/service_incremental_reverse.cpp b/frameworks/native/backup_kit_inner/src/service_incremental_reverse.cpp
index 7cc6458570aac10c339c4031051c59b07a4ce314..e27ac60ac066122f8f8e59651f57e39cf0213a6b 100644
--- a/frameworks/native/backup_kit_inner/src/service_incremental_reverse.cpp
+++ b/frameworks/native/backup_kit_inner/src/service_incremental_reverse.cpp
@@ -49,6 +49,19 @@ ErrCode ServiceReverse::IncrementalSaBackupOnFileReady(const std::string &bundle
     return BError(BError::Codes::OK);
 }
 
+ErrCode ServiceReverse::IncrementalBackupOnFileReadyWithoutFd(const std::string &bundleName,
+                                                              const std::string &fileName,
+                                                              int32_t errCode)
+{
+    if (scenario_ != Scenario::BACKUP || !callbacksIncrementalBackup_.onFileReady) {
+        HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
+        return BError(BError::Codes::OK);
+    }
+    BFileInfo bFileInfo(bundleName, fileName, 0);
+    callbacksIncrementalBackup_.onFileReady(bFileInfo, UniqueFd(INVALID_FD), UniqueFd(INVALID_FD), errCode);
+    return BError(BError::Codes::OK);
+}
+
 ErrCode ServiceReverse::IncrementalBackupOnBundleStarted(int32_t errCode, const std::string &bundleName)
 {
     if (scenario_ != Scenario::BACKUP || !callbacksIncrementalBackup_.onBundleStarted) {
diff --git a/frameworks/native/backup_kit_inner/src/service_reverse.cpp b/frameworks/native/backup_kit_inner/src/service_reverse.cpp
index 0db73caec36d071d4a0b7954cfddbf1d1d0dfa0c..a985150d83a0e5c75bbaf6bcfa2d2d328d4c01da 100644
--- a/frameworks/native/backup_kit_inner/src/service_reverse.cpp
+++ b/frameworks/native/backup_kit_inner/src/service_reverse.cpp
@@ -35,6 +35,19 @@ ErrCode ServiceReverse::BackupOnFileReady(const std::string &bundleName,
     return BError(BError::Codes::OK);
 }
 
+ErrCode ServiceReverse::BackupOnFileReadyWithoutFd(const std::string &bundleName,
+                                                   const std::string &fileName,
+                                                   int32_t errCode)
+{
+    if (scenario_ != Scenario::BACKUP || !callbacksBackup_.onFileReady) {
+        HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
+        return BError(BError::Codes::OK);
+    }
+    BFileInfo bFileInfo(bundleName, fileName, 0);
+    callbacksBackup_.onFileReady(bFileInfo, UniqueFd(INVALID_FD), errCode);
+    return BError(BError::Codes::OK);
+}
+
 ErrCode ServiceReverse::BackupOnBundleStarted(int32_t errCode, const std::string &bundleName)
 {
     if (scenario_ != Scenario::BACKUP || !callbacksBackup_.onBundleStarted) {
@@ -145,6 +158,20 @@ ErrCode ServiceReverse::RestoreOnFileReady(const std::string &bundleName,
     return BError(BError::Codes::OK);
 }
 
+ErrCode ServiceReverse::RestoreOnFileReadyWithoutFd(const std::string &bundleName,
+                                                    const std::string &fileName,
+                                                    int32_t errCode)
+{
+    HILOGD("begin, bundleName is:%{public}s", bundleName.c_str());
+    if (scenario_ != Scenario::RESTORE || !callbacksRestore_.onFileReady) {
+        HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
+        return BError(BError::Codes::OK);
+    }
+    BFileInfo bFileInfo(bundleName, fileName, 0);
+    callbacksRestore_.onFileReady(bFileInfo, UniqueFd(INVALID_FD), errCode);
+    return BError(BError::Codes::OK);
+}
+
 ErrCode ServiceReverse::RestoreOnResultReport(const std::string &result, const std::string &bundleName, ErrCode errCode)
 {
     HILOGI("ServiceReverse RestoreOnResultReport bundle %{public}s begin with result: %{public}s", bundleName.c_str(),
diff --git a/services/backup_sa/IService.idl b/services/backup_sa/IService.idl
index 8d03b1f91ff30fc7380cb08d2bf9bef9008019f8..ff63f3daaad790482b41f2166ee7c1a2e0673787 100644
--- a/services/backup_sa/IService.idl
+++ b/services/backup_sa/IService.idl
@@ -43,7 +43,7 @@ interface OHOS.FileManagement.Backup.IService{
     [ipccode 12] void AppendBundlesDetailsBackupSession([in] String[] bundleNames, [in] String[] bundleInfos);
     [ipccode 13] void Finish();
     [ipccode 14] void Release();
-    [ipccode 15] void Cancel([in] String bundleName, [out] int cancelResult);
+    [ipccode 15] void CancelForResult([in] String bundleName, [out] int cancelResult);
     [ipccode 16] void GetAppLocalListAndDoIncrementalBackup();
     [ipccode 17] void GetIncrementalFileHandle([in] String bundleName, [in] String fileName);
     [ipccode 18] void GetBackupInfo([in] String bundleName, [out] String getBackupInfoResult);
@@ -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 AppFileReadyWithoutFd([in]String fileName, [in] int appFileReadyErrCode);
+    [ipccode 42] void AppIncrementalFileReadyWithoutFd([in] String fileName, [in] int appIncrementalFileReadyErrCode);
  }
\ No newline at end of file
diff --git a/services/backup_sa/IServiceReverse.idl b/services/backup_sa/IServiceReverse.idl
index 3079109145798c48ca3577b0b650ffb300f6f619..55bf06191f0075e4250f8696ec4f99a500d88875 100644
--- a/services/backup_sa/IServiceReverse.idl
+++ b/services/backup_sa/IServiceReverse.idl
@@ -62,4 +62,11 @@ interface OHOS.FileManagement.Backup.IServiceReverse{
         [in] String bundleName);
     [ipccode 24] void IncrementalRestoreOnAllBundlesFinished([in] int incrementalRestoreOnAllBundlesFinishedErrCode);
     [ipccode 25] void IncrementalRestoreOnProcessInfo( [in] String bundleName, [in] String processInfo);
-}
+    [ipccode 27] void BackupOnFileReadyWithoutFd([in] String bundleName, [in] String fileName,
+                                                 [in] int backupOnFileReadyErrCode);
+    [ipccode 28] void RestoreOnFileReadyWithoutFd([in] String bundleName, [in] String fileName,
+                                                  [in] int restoreOnFileReadyErrCode);
+    [ipccode 29] void IncrementalBackupOnFileReadyWithoutFd([in] String bundleName,
+                                                            [in] String fileName,
+                                                            [in] int incrementalBackupOnFileReadyErrCode);
+}
diff --git a/services/backup_sa/include/module_ipc/service.h b/services/backup_sa/include/module_ipc/service.h
index 193698546fcc3ca8a116db80250d5a13f7c3ee8e..9228595b7a93ea028c671b4f51b290967442d432 100644
--- a/services/backup_sa/include/module_ipc/service.h
+++ b/services/backup_sa/include/module_ipc/service.h
@@ -65,6 +65,7 @@ public:
     ErrCode GetLocalCapabilitiesForBundleInfos(int& fd) override;
     ErrCode PublishFile(const BFileInfo &fileInfo) override;
     ErrCode AppFileReady(const std::string &fileName, int fd, int32_t errCode) override;
+    ErrCode AppFileReadyWithoutFd(const std::string &fileName, int32_t errCode) override;
     ErrCode AppDone(ErrCode errCode) override;
     ErrCode ServiceResultReport(const std::string& restoreRetInfo,
         BackupRestoreScenario sennario, ErrCode errCode) override;
@@ -84,7 +85,7 @@ public:
                                               const std::vector<std::string> &bundleInfos) override;
     ErrCode Finish() override;
     ErrCode Release() override;
-    ErrCode Cancel(const std::string& bundleName, int32_t &result) override;
+    ErrCode CancelForResult(const std::string& bundleName, int32_t &result) override;
     ErrCode GetLocalCapabilitiesIncremental(const std::vector<BIncrementalData>& bundleNames, int& fd) override;
     ErrCode GetAppLocalListAndDoIncrementalBackup() override;
     ErrCode InitIncrementalBackupSession(const sptr<IServiceReverse>& remote) override;
@@ -98,6 +99,8 @@ public:
     ErrCode PublishSAIncrementalFile(const BFileInfo &fileInfo, UniqueFd fd);
     ErrCode AppIncrementalFileReady(const std::string& fileName, int fd, int manifestFd,
                                     int32_t appIncrementalFileReadyErrCode) override;
+    ErrCode AppIncrementalFileReadyWithoutFd(const std::string& fileName,
+                                             int32_t appIncrementalFileReadyErrCode) override;
     ErrCode AppIncrementalDone(ErrCode errCode) override;
     ErrCode GetIncrementalFileHandle(const std::string &bundleName, const std::string &fileName) override;
     ErrCode GetBackupInfo(const BundleName &bundleName, std::string &result) override;
@@ -685,6 +688,7 @@ private:
 
     void SetScanningInfo(string &scanning, string name);
 
+    ErrCode Cancel(const std::string& bundleName, int32_t &result);
     ErrCode InitRestoreSession(const sptr<IServiceReverse>& remote, std::string &errMsg);
     ErrCode InitBackupSession(const sptr<IServiceReverse>& remote, std::string &errMsg);
     ErrCode InitIncrementalBackupSession(const sptr<IServiceReverse>& remote, std::string &errMsg);
diff --git a/services/backup_sa/src/module_ipc/service.cpp b/services/backup_sa/src/module_ipc/service.cpp
index dfe4d5d5328efb00f1a30cd5ed9cace33662667e..2cc7b475c95ae7a150a5681a05be83262a9febfa 100644
--- a/services/backup_sa/src/module_ipc/service.cpp
+++ b/services/backup_sa/src/module_ipc/service.cpp
@@ -1156,7 +1156,9 @@ void Service::StartCurBundleBackupOrRestore(const std::string &bundleName)
             int fdCode = 0;
             proxy->GetFileHandleWithUniqueFd(fileName, errCode, fdCode);
             UniqueFd fd(fdCode);
-            session_->GetServiceReverseProxy()->RestoreOnFileReady(bundleName, fileName, move(fd), errCode);
+            bool fdFlag = fd < 0 ? false : true;
+            fdFlag ? session_->GetServiceReverseProxy()->RestoreOnFileReady(bundleName, fileName, move(fd), errCode) :
+                     session_->GetServiceReverseProxy()->BackupOnFileReadyWithoutFd(bundleName, fileName, errCode);
             FileReadyRadarReport(bundleName, fileName, errCode, scenario);
         }
     }
@@ -1855,10 +1857,16 @@ void Service::OnSABackup(const std::string &bundleName, const int &fd, const std
         BackupRestoreScenario scenario = BackupRestoreScenario::FULL_BACKUP;
         if (session_->GetIsIncrementalBackup()) {
             scenario = BackupRestoreScenario::INCREMENTAL_BACKUP;
-            session_->GetServiceReverseProxy()->IncrementalSaBackupOnFileReady(bundleName, "", move(fd), errCode);
+            bool fdFlag = fd < 0  ? false : true;
+            fdFlag ? session_->GetServiceReverseProxy()->IncrementalSaBackupOnFileReady(bundleName, "",
+                                                                                        move(fd), errCode) :
+                     session_->GetServiceReverseProxy()->IncrementalBackupOnFileReadyWithoutFd(bundleName, "",
+                                                                                               errCode);
         } else {
             scenario = BackupRestoreScenario::FULL_BACKUP;
-            session_->GetServiceReverseProxy()->BackupOnFileReady(bundleName, "", move(fd), errCode);
+            bool fdFlag = fd < 0 ? false : true;
+            fdFlag ? session_->GetServiceReverseProxy()->BackupOnFileReady(bundleName, "", move(fd), errCode) :
+                     session_->GetServiceReverseProxy()->BackupOnFileReadyWithoutFd(bundleName, "", errCode);
         }
         FileReadyRadarReport(bundleName, "", errCode, IServiceReverseType::Scenario::BACKUP);
         SAResultReport(bundleName, result, errCode, scenario);
diff --git a/services/backup_sa/src/module_ipc/service_incremental.cpp b/services/backup_sa/src/module_ipc/service_incremental.cpp
index 4c5db0ee539bbae2b2bb0507591003503c17e105..c8c2002f6c91867fa2ccf196b5289be012d3e2ce 100644
--- a/services/backup_sa/src/module_ipc/service_incremental.cpp
+++ b/services/backup_sa/src/module_ipc/service_incremental.cpp
@@ -126,7 +126,7 @@ ErrCode Service::GetLocalCapabilitiesIncremental(const std::vector<BIncrementalD
 {
     HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__);
     UniqueFd fdResult(GetLocalCapabilitiesIncremental(bundleNames));
-    fd = fdResult.Release();
+    fd = dup(fdResult.Get());
     return BError(BError::Codes::OK); // anytime return OK
 }
 
@@ -601,8 +601,11 @@ ErrCode Service::AppIncrementalFileReady(const std::string &bundleName, const st
         if (fileName == BConstants::EXT_BACKUP_MANAGE) {
             fd = session_->OnBundleExtManageInfo(bundleName, move(fd));
         }
-        session_->GetServiceReverseProxy()->IncrementalBackupOnFileReady(bundleName, fileName, move(fd),
-            move(manifestFd), errCode);
+        bool fdFlag = (fd < 0 || manifestFd < 0) ? false : true;
+        fdFlag ? session_->GetServiceReverseProxy()->IncrementalBackupOnFileReady(bundleName, fileName, move(fd),
+                                                                                  move(manifestFd), errCode) :
+                 session_->GetServiceReverseProxy()->IncrementalBackupOnFileReadyWithoutFd(bundleName, fileName,
+                                                                                           errCode);
         FileReadyRadarReport(bundleName, fileName, errCode, IServiceReverseType::Scenario::BACKUP);
         if (session_->OnBundleFileReady(bundleName, fileName)) {
             ErrCode ret = HandleCurBundleFileReady(bundleName, fileName, true);
@@ -634,6 +637,13 @@ ErrCode Service::AppIncrementalFileReady(const std::string &fileName, int fd, in
                                    appIncrementalFileReadyErrCode);
 }
 
+ErrCode Service::AppIncrementalFileReadyWithoutFd(const std::string &fileName, int32_t appIncrementalFileReadyErrCode)
+{
+    return AppIncrementalFileReady(fileName, UniqueFd(BConstants::INVALID_FD_NUM),
+                                   UniqueFd(BConstants::INVALID_FD_NUM),
+                                   appIncrementalFileReadyErrCode);
+}
+
 ErrCode Service::AppIncrementalFileReady(const std::string &fileName, UniqueFd fd, UniqueFd manifestFd, int32_t errCode)
 {
     HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__);
@@ -653,8 +663,11 @@ ErrCode Service::AppIncrementalFileReady(const std::string &fileName, UniqueFd f
         if (fileName == BConstants::EXT_BACKUP_MANAGE) {
             fd = session_->OnBundleExtManageInfo(callerName, move(fd));
         }
-        session_->GetServiceReverseProxy()->IncrementalBackupOnFileReady(callerName, fileName, move(fd),
-            move(manifestFd), errCode);
+        bool fdFlag = (fd < 0 || manifestFd < 0) ? false : true;
+        fdFlag ? session_->GetServiceReverseProxy()->IncrementalBackupOnFileReady(callerName, fileName, move(fd),
+                                                                                  move(manifestFd), errCode) :
+                 session_->GetServiceReverseProxy()->IncrementalBackupOnFileReadyWithoutFd(callerName, fileName,
+                                                                                           errCode);
         FileReadyRadarReport(callerName, fileName, errCode, IServiceReverseType::Scenario::BACKUP);
         if (session_->OnBundleFileReady(callerName, fileName)) {
             ErrCode ret = HandleCurBundleFileReady(callerName, fileName, true);
@@ -1042,6 +1055,15 @@ void Service::CancelTask(std::string bundleName, wptr<Service> ptr)
     thisPtr->OnAllBundlesFinished(BError(BError::Codes::OK));
 }
 
+ErrCode Service::CancelForResult(const std::string& bundleName, int32_t &result)
+{
+    ErrCode errCode = Cancel(bundleName, result);
+    if (errCode != 0) {
+        HILOGE("Cancel failed, errCode:%{public}d.", errCode);
+    }
+    return BError(BError::Codes::OK);
+}
+
 ErrCode Service::Cancel(const std::string& bundleName, int32_t &result)
 {
     HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__);
diff --git a/services/backup_sa/src/module_ipc/sub_service.cpp b/services/backup_sa/src/module_ipc/sub_service.cpp
index 33ad9905adf9dc5de97c2f847eed04556359d5dc..cc297c7c4f53361b92687000288e7928eb6eac3d 100644
--- a/services/backup_sa/src/module_ipc/sub_service.cpp
+++ b/services/backup_sa/src/module_ipc/sub_service.cpp
@@ -320,6 +320,11 @@ ErrCode Service::AppFileReady(const std::string &fileName, int fd, int32_t errCo
     return AppFileReady(fileName, std::move(fdUnique), errCode);
 }
 
+ErrCode Service::AppFileReadyWithoutFd(const std::string &fileName, int32_t errCode)
+{
+    return AppFileReady(fileName, UniqueFd(INVALID_FD), errCode);
+}
+
 ErrCode Service::AppFileReady(const string &fileName, UniqueFd fd, int32_t errCode)
 {
     HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__);
@@ -341,7 +346,9 @@ ErrCode Service::AppFileReady(const string &fileName, UniqueFd fd, int32_t errCo
         if (fileName == BConstants::EXT_BACKUP_MANAGE) {
             fd = session_->OnBundleExtManageInfo(callerName, move(fd));
         }
-        session_->GetServiceReverseProxy()->BackupOnFileReady(callerName, fileName, move(fd), errCode);
+        bool fdFlag = fd < 0 ? false : true;
+        fdFlag ? session_->GetServiceReverseProxy()->BackupOnFileReady(callerName, fileName, move(fd), errCode) :
+                 session_->GetServiceReverseProxy()->BackupOnFileReadyWithoutFd(callerName, fileName, errCode);
         FileReadyRadarReport(callerName, fileName, errCode, session_->GetScenario());
         if (session_->OnBundleFileReady(callerName, fileName)) {
             ret = HandleCurBundleFileReady(callerName, fileName, false);
diff --git a/tests/mock/backup_kit_inner/service_proxy_mock.cpp b/tests/mock/backup_kit_inner/service_proxy_mock.cpp
index 96fa0647aec8f048eafc5b01b9148570fbfeda62..84a9006fe9ac26a48da85c62def113790b8bcf1a 100644
--- a/tests/mock/backup_kit_inner/service_proxy_mock.cpp
+++ b/tests/mock/backup_kit_inner/service_proxy_mock.cpp
@@ -91,6 +91,11 @@ ErrCode ServiceProxy::AppFileReady(const string &fileName, int fd, int32_t errCo
     return BError(BError::Codes::OK);
 }
 
+ErrCode ServiceProxy::AppFileReadyWithoutFd(const string &fileName, int32_t errCode)
+{
+    return BError(BError::Codes::OK);
+}
+
 ErrCode ServiceProxy::AppDone(ErrCode errCode)
 {
     return BError(BError::Codes::OK);
@@ -145,7 +150,7 @@ ErrCode ServiceProxy::Release()
     return BError(BError::Codes::OK);
 }
 
-ErrCode ServiceProxy::Cancel(const std::string &bundleName, int32_t &result)
+ErrCode ServiceProxy::CancelForResult(const std::string &bundleName, int32_t &result)
 {
     result = BError(BError::Codes::OK);
     return BError(BError::Codes::OK);
@@ -201,6 +206,11 @@ ErrCode ServiceProxy::AppIncrementalFileReady(const string &fileName, int fd, in
     return BError(BError::Codes::OK);
 }
 
+ErrCode ServiceProxy::AppIncrementalFileReadyWithoutFd(const string &fileName, int32_t errCode)
+{
+    return BError(BError::Codes::OK);
+}
+
 ErrCode ServiceProxy::AppIncrementalDone(ErrCode errCode)
 {
     return BError(BError::Codes::OK);
diff --git a/tests/mock/module_ipc/include/service_reverse_proxy_mock.h b/tests/mock/module_ipc/include/service_reverse_proxy_mock.h
index 8e6b6b17fa7273d210951476b1443fd95f7ca400..288070014880976b03d99172f978b600e09bda24 100644
--- a/tests/mock/module_ipc/include/service_reverse_proxy_mock.h
+++ b/tests/mock/module_ipc/include/service_reverse_proxy_mock.h
@@ -26,6 +26,7 @@ class ServiceReverseProxyMock : public IRemoteProxy<IServiceReverse> {
 public:
     MOCK_METHOD(int, SendRequest, (uint32_t, MessageParcel &, MessageParcel &, MessageOption &));
     MOCK_METHOD(ErrCode, BackupOnFileReady, (const std::string &, const std::string &, int, int32_t));
+    MOCK_METHOD(ErrCode, BackupOnFileReadyWithoutFd, (const std::string &, const std::string &, int32_t));
     MOCK_METHOD(ErrCode, BackupOnBundleStarted, (int32_t, const std::string &));
     MOCK_METHOD(ErrCode, BackupOnResultReport, (const std::string &, const std::string &));
     ;
@@ -38,11 +39,13 @@ public:
     MOCK_METHOD(ErrCode, RestoreOnBundleFinished, (int32_t, const std::string &));
     MOCK_METHOD(ErrCode, RestoreOnAllBundlesFinished, (int32_t));
     MOCK_METHOD(ErrCode, RestoreOnFileReady, (const std::string &, const std::string &, int32_t, int32_t));
+    MOCK_METHOD(ErrCode, RestoreOnFileReadyWithoutFd, (const std::string &, const std::string &, int32_t));
     MOCK_METHOD(ErrCode, RestoreOnResultReport, (const std::string &, const std::string &, ErrCode));
     MOCK_METHOD(ErrCode, RestoreOnProcessInfo, (const std::string &, const std::string &));
 
     MOCK_METHOD(ErrCode, IncrementalBackupOnFileReady, (const std::string &, const std::string &, int, int, int32_t));
     MOCK_METHOD(ErrCode, IncrementalSaBackupOnFileReady, (const std::string &, const std::string &, int, int32_t));
+    MOCK_METHOD(ErrCode, IncrementalBackupOnFileReadyWithoutFd, (const std::string &, const std::string &, int32_t));
     MOCK_METHOD(ErrCode, IncrementalBackupOnBundleStarted, (int32_t, const std::string &));
     MOCK_METHOD(ErrCode, IncrementalBackupOnResultReport, (const std::string &, const std::string &));
     MOCK_METHOD(ErrCode, IncrementalBackupOnBundleFinished, (int32_t, const std::string &));
diff --git a/tests/mock/module_ipc/service_mock.cpp b/tests/mock/module_ipc/service_mock.cpp
index e94ff4c32af643f8220a5ac32ca5e94083add992..a3ea7b384dd63c0f655c0e457464508a7eef26b2 100644
--- a/tests/mock/module_ipc/service_mock.cpp
+++ b/tests/mock/module_ipc/service_mock.cpp
@@ -91,6 +91,11 @@ ErrCode Service::AppFileReady(const string &fileName, int fd, int32_t errCode)
     return BError(BError::Codes::OK);
 }
 
+ErrCode Service::AppFileReadyWithoutFd(const string &fileName, int32_t errCode)
+{
+    return BError(BError::Codes::OK);
+}
+
 ErrCode Service::AppDone(ErrCode errCode)
 {
     return BError(BError::Codes::OK);
@@ -193,7 +198,7 @@ ErrCode Service::Release()
     return BError(BError::Codes::OK);
 }
 
-ErrCode Service::Cancel(const std::string &bundleName, int32_t &result)
+ErrCode Service::CancelForResult(const std::string &bundleName, int32_t &result)
 {
     result = BError(BError::Codes::OK);
     return BError(BError::Codes::OK);
@@ -251,6 +256,12 @@ ErrCode Service::AppIncrementalFileReady(const std::string &fileName,
     return BError(BError::Codes::OK);
 }
 
+ErrCode Service::AppIncrementalFileReadyWithoutFd(const std::string &fileName,
+                                                  int32_t appIncrementalFileReadyErrCode)
+{
+    return BError(BError::Codes::OK);
+}
+
 ErrCode Service::AppIncrementalDone(ErrCode errCode)
 {
     return BError(BError::Codes::OK);
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 be238cc15966325658fdaf54069542a4e4bb5fb0..7f2c4e24ae912d733a313de1fb38a56a53da273e 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
@@ -107,6 +107,11 @@ public:
         return BError(BError::Codes::OK);
     }
 
+    ErrCode AppFileReadyWithoutFd(const std::string &fileName, int32_t errCode) override
+    {
+        return BError(BError::Codes::OK);
+    }
+
     ErrCode AppDone(ErrCode errCode) override
     {
         return BError(BError::Codes::OK);
@@ -196,7 +201,7 @@ public:
         return BError(BError::Codes::OK);
     }
 
-    ErrCode Cancel(std::string bundleName, int32_t &result) override
+    ErrCode CancelForResult(std::string bundleName, int32_t &result) override
     {
         result = BError(BError::Codes::OK);
         return BError(BError::Codes::OK);
@@ -248,6 +253,11 @@ public:
         return BError(BError::Codes::OK);
     }
 
+    ErrCode AppIncrementalFileReadyWithoutFd(const std::string &fileName, int32_t errCode)
+    {
+        return BError(BError::Codes::OK);
+    }
+
     ErrCode AppIncrementalDone(ErrCode errCode)
     {
         return BError(BError::Codes::OK);
diff --git a/tests/unittests/backup_api/backup_impl/include/service_reverse_mock.h b/tests/unittests/backup_api/backup_impl/include/service_reverse_mock.h
index 3a0474f0ccd6d56e99c1eb716da375decb08f02f..fdd970fddfa80c12143c156acc7a876ede7fb703 100644
--- a/tests/unittests/backup_api/backup_impl/include/service_reverse_mock.h
+++ b/tests/unittests/backup_api/backup_impl/include/service_reverse_mock.h
@@ -43,6 +43,12 @@ public:
     {
         return BError(BError::Codes::OK);
     }
+    ErrCode BackupOnFileReadyWithoutFd(const std::string &bundleName,
+                                       const std::string &fileName,
+                                       int32_t errCode) override
+    {
+        return BError(BError::Codes::OK);
+    }
 
     ErrCode BackupOnBundleStarted(int32_t errCode, const std::string &bundleName) override
     {
@@ -97,6 +103,13 @@ public:
         return BError(BError::Codes::OK);
     }
 
+    ErrCode RestoreOnFileReadyWithoutFd(const std::string &bundleName,
+                                        const std::string &fileName,
+                                        int32_t errCode) override
+    {
+        return BError(BError::Codes::OK);
+    }
+
     ErrCode RestoreOnResultReport(const std::string &result, const std::string &bundleName, ErrCode errCode) override
     {
         return BError(BError::Codes::OK);
@@ -124,6 +137,13 @@ public:
         return BError(BError::Codes::OK);
     }
     
+    ErrCode IncrementalBackupOnFileReadyWithoutFd(const std::string &bundleName,
+                                                  const std::string &fileName,
+                                                  int32_t errCode) override
+    {
+        return BError(BError::Codes::OK);
+    }
+
     ErrCode IncrementalBackupOnBundleStarted(int32_t errCode, const std::string &bundleName) override
     {
         return BError(BError::Codes::OK);
diff --git a/tests/unittests/backup_sa/module_client/service_client_test.cpp b/tests/unittests/backup_sa/module_client/service_client_test.cpp
index 3779c0e5e9fb8b052c7949d60ca03763728e371c..b8e94f26388014033e2fc7bb156e748a3c9e09ef 100644
--- a/tests/unittests/backup_sa/module_client/service_client_test.cpp
+++ b/tests/unittests/backup_sa/module_client/service_client_test.cpp
@@ -95,14 +95,8 @@ HWTEST_F(ServiceClientTest, SUB_service_client_test_0300, testing::ext::TestSize
     EXPECT_NE(proxy, nullptr);
     std::string bundleName;
     int32_t result = -1;
-    ErrCode ret = proxy->Cancel(bundleName, result);
-    EXPECT_EQ(ret, BError(BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK));
-    bundleName = "";
-    ret = proxy->Cancel(bundleName, result);
-    EXPECT_EQ(ret, BError(BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK));
     bundleName = "test";
-    ret = proxy->Cancel(bundleName, result);
-    EXPECT_EQ(ret, BError(BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK));
+    proxy->CancelForResult(bundleName, result);
     EXPECT_NE(result, 0);
     GTEST_LOG_(INFO) << "ServiceClientTest-end SUB_service_client_test_0300";
 }
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..abad527f7d3af38333b02e1555a0f91b9c5bcb41 100644
--- a/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp
+++ b/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp
@@ -42,6 +42,7 @@ public:
     virtual ErrCode Start() = 0;
     virtual ErrCode PublishFile(const BFileInfo&) = 0;
     virtual ErrCode AppFileReady(const std::string &, int, int32_t) = 0;
+    virtual ErrCode AppFileReadyWithoutFd(const std::string &, int32_t) = 0;
     virtual ErrCode AppDone(ErrCode) = 0;
     virtual ErrCode ServiceResultReport(const std::string, BackupRestoreScenario, ErrCode) = 0;
     virtual ErrCode AppendBundlesRestoreSessionDataByDetail(int, const std::vector<std::string>&,
@@ -96,6 +97,7 @@ public:
     MOCK_METHOD(ErrCode, Start, ());
     MOCK_METHOD(ErrCode, PublishFile, (const BFileInfo&));
     MOCK_METHOD(ErrCode, AppFileReady, (const string&, int, int32_t));
+    MOCK_METHOD(ErrCode, AppFileReadyWithoutFd, (const string&, int32_t));
     MOCK_METHOD(ErrCode, AppDone, (ErrCode));
     MOCK_METHOD(ErrCode, ServiceResultReport, (const std::string, BackupRestoreScenario, ErrCode));
     MOCK_METHOD(ErrCode, AppendBundlesRestoreSessionDataByDetail, (int, (const std::vector<std::string>&),
@@ -193,6 +195,11 @@ ErrCode Service::AppFileReady(const std::string &fileName, int fd, int32_t appFi
     return BService::serviceMock->AppFileReady(fileName, fd, appFileReadyErrCode);
 }
 
+ErrCode Service::AppFileReadyWithoutFd(const std::string &fileName, int32_t appFileReadyErrCode)
+{
+    return BService::serviceMock->AppFileReadyWithoutFd(fileName, appFileReadyErrCode);
+}
+
 ErrCode Service::AppDone(int32_t appDoneErrCode)
 {
     return BService::serviceMock->AppDone(appDoneErrCode);
@@ -538,7 +545,7 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_GetLocalCapabilitiesIncr
         int fd = -1;
         service->GetLocalCapabilitiesIncremental({}, fd);
         service->session_ = session_;
-        EXPECT_EQ(static_cast<int>(fd), -ENOENT);
+        EXPECT_EQ(static_cast<int>(fd), BConstants::INVALID_FD_NUM);
 
         service->isOccupyingSession_ = true;
         fd = service->GetLocalCapabilitiesIncremental({});
@@ -1884,20 +1891,10 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_Cancel_0000, TestSize.Le
         int32_t result;
 
         auto session_ = service->session_;
-        service->session_ = nullptr;
-        EXPECT_EQ(service->Cancel(bundleName, result),
-            BError(BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK).GetCode());
-        service->session_ = session_;
-
-        EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE));
-        EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::EXT_INVAL_ARG).GetCode()));
-        auto ret = service->Cancel(bundleName, result);
-        EXPECT_EQ(ret, BError(BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK).GetCode());
-
         EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE));
         EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
         EXPECT_CALL(*session, GetImpl()).WillOnce(Return(impl));
-        service->Cancel(bundleName, result);
+        service->CancelForResult(bundleName, result);
         EXPECT_EQ(result, BError(BError::BackupErrorCode::E_CANCEL_NO_TASK).GetCode());
 
         impl.backupExtNameMap.insert(make_pair(bundleName, info));
@@ -1905,14 +1902,14 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_Cancel_0000, TestSize.Le
         EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
         EXPECT_CALL(*session, GetImpl()).WillOnce(Return(impl));
         EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::UNKNOWN));
-        service->Cancel(bundleName, result);
+        service->CancelForResult(bundleName, result);
         EXPECT_EQ(result, BError(BError::BackupErrorCode::E_CANCEL_NO_TASK).GetCode());
 
         EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE));
         EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
         EXPECT_CALL(*session, GetImpl()).WillOnce(Return(impl));
         EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::CLEAN));
-        service->Cancel(bundleName, result);
+        service->CancelForResult(bundleName, result);
         EXPECT_EQ(result, BError(BError::BackupErrorCode::E_CANCEL_NO_TASK).GetCode());
     } catch (...) {
         EXPECT_TRUE(false);
@@ -1945,14 +1942,14 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_Cancel_0100, TestSize.Le
         EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
         EXPECT_CALL(*session, GetImpl()).WillOnce(Return(impl));
         EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::START));
-        service->Cancel(bundleName, result);
+        service->CancelForResult(bundleName, result);
         EXPECT_EQ(result, BError(BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK).GetCode());
 
         EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE));
         EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
         EXPECT_CALL(*session, GetImpl()).WillOnce(Return(impl));
         EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING));
-        service->Cancel(bundleName, result);
+        service->CancelForResult(bundleName, result);
         EXPECT_EQ(result, BError(BError::Codes::OK).GetCode());
     } catch (...) {
         EXPECT_TRUE(false);
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..d97e2d158b94db026d943e2051b51ed793068ef5 100644
--- a/tests/unittests/backup_sa/module_ipc/service_other_test.cpp
+++ b/tests/unittests/backup_sa/module_ipc/service_other_test.cpp
@@ -58,12 +58,18 @@ ErrCode Service::AppIncrementalFileReady(const std::string &fileName,
     return BError(BError::Codes::OK);
 }
 
+ErrCode Service::AppIncrementalFileReadyWithoutFd(const std::string &fileName,
+                                                  int32_t appIncrementalFileReadyErrCode)
+{
+    return BError(BError::Codes::OK);
+}
+
 ErrCode Service::Release()
 {
     return BError(BError::Codes::OK);
 }
 
-ErrCode Service::Cancel(const std::string& bundleName, int32_t &result)
+ErrCode Service::CancelForResult(const std::string& bundleName, int32_t &result)
 {
     result = BError(BError::Codes::OK);
     return BError(BError::Codes::OK);
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 e1e3c155b740b78eab104536d470e95dee6b7447..db4f1931e95b169b41a632cf1cca63f39072cee3 100644
--- a/tests/unittests/backup_sa/module_ipc/service_stub_test.cpp
+++ b/tests/unittests/backup_sa/module_ipc/service_stub_test.cpp
@@ -81,6 +81,7 @@ public:
     MOCK_METHOD2(PublishSAIncrementalFile, ErrCode(const BFileInfo &fileInfo, UniqueFd fd));
     MOCK_METHOD4(AppIncrementalFileReady, ErrCode(const std::string &fileName, UniqueFd fd, UniqueFd manifestFd,
         int32_t errCode));
+    MOCK_METHOD2(AppIncrementalFileReadyWithoutFd, ErrCode(const std::string &fileName, int32_t errCode));
     MOCK_METHOD1(AppIncrementalDone, ErrCode(ErrCode errCode));
     MOCK_METHOD2(GetIncrementalFileHandle, ErrCode(const std::string &bundleName, const std::string &fileName));
     MOCK_METHOD2(GetBackupInfo, ErrCode(string &bundleName, string &result));
@@ -832,19 +833,13 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_Cancel_0100, testing::ext::T
         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
 
         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
-        EXPECT_CALL(*service, Cancel(_, _)).WillOnce(Return(BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK));
-        EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
-        err = service->CmdCancel(data, reply);
-        EXPECT_EQ(err, BError(BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK));
-
-        EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
-        EXPECT_CALL(*service, Cancel(_, _)).WillOnce(Return(0));
+        EXPECT_CALL(*service, CancelForResult(_, _)).WillOnce(Return(0));
         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
         err = service->CmdCancel(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
 
         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
-        EXPECT_CALL(*service, Cancel(_, _)).WillOnce(Return(0));
+        EXPECT_CALL(*service, CancelForResult(_, _)).WillOnce(Return(0));
         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
         err = service->CmdCancel(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::OK));
diff --git a/tests/unittests/backup_sa/module_ipc/service_throw_test.cpp b/tests/unittests/backup_sa/module_ipc/service_throw_test.cpp
index 8fa22a9a9e77ae26e911979147804da18740e159..781aa477ba67587339b9a185f59549199f3335e9 100644
--- a/tests/unittests/backup_sa/module_ipc/service_throw_test.cpp
+++ b/tests/unittests/backup_sa/module_ipc/service_throw_test.cpp
@@ -871,7 +871,7 @@ HWTEST_F(ServiceThrowTest, SUB_Service_throw_GetLocalCapabilitiesIncremental_010
         EXPECT_CALL(*sessionMock, DecreaseSessionCnt(_)).WillOnce(Return());
         int fd = -1;
         ErrCode ret = service->GetLocalCapabilitiesIncremental(bundleNames, fd);
-        EXPECT_EQ(-fd, BError(BError::Codes::EXT_THROW_EXCEPTION).GetCode());
+        EXPECT_EQ(fd, BConstants::INVALID_FD_NUM);
 
         EXPECT_CALL(*sessionMock, IncreaseSessionCnt(_)).WillOnce(Invoke([]() {
             throw runtime_error("运行时错误");
diff --git a/tests/unittests/backup_sa/session/b_incremental_session_test.cpp b/tests/unittests/backup_sa/session/b_incremental_session_test.cpp
index 4e93edd35bd295516880ddac88ffefd1b4bddb8c..6cfb25ca466152cf04c04a4d9d4722d6afe078c8 100644
--- a/tests/unittests/backup_sa/session/b_incremental_session_test.cpp
+++ b/tests/unittests/backup_sa/session/b_incremental_session_test.cpp
@@ -694,7 +694,7 @@ HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_2100, testing::e
         auto err = backupSession->Cancel(bundleName);
         EXPECT_EQ(err, BError(BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK).GetCode());
 
-        EXPECT_CALL(*proxy, Cancel(_, _)).WillOnce(DoAll(SetArgReferee<1>(0), Return(0)));
+        EXPECT_CALL(*proxy, CancelForResult(_, _)).WillOnce(DoAll(SetArgReferee<1>(0), Return(0)));
         ServiceClient::serviceProxy_ = proxy;
         err = backupSession->Cancel(bundleName);
         EXPECT_EQ(err, BError(BError::Codes::OK).GetCode());
@@ -724,7 +724,7 @@ HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_2200, testing::e
         auto err = restoreSession->Cancel(bundleName);
         EXPECT_EQ(err, BError(BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK).GetCode());
 
-        EXPECT_CALL(*proxy, Cancel(_, _)).WillOnce(DoAll(SetArgReferee<1>(0), Return(0)));
+        EXPECT_CALL(*proxy, CancelForResult(_, _)).WillOnce(DoAll(SetArgReferee<1>(0), Return(0)));
         ServiceClient::serviceProxy_ = proxy;
         err = restoreSession->Cancel(bundleName);
         EXPECT_EQ(err, BError(BError::Codes::OK).GetCode());
@@ -754,7 +754,7 @@ HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_2300, testing::e
         auto err = restoreAsyncSession->Cancel(bundleName);
         EXPECT_EQ(err, BError(BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK).GetCode());
 
-        EXPECT_CALL(*proxy, Cancel(_, _)).WillOnce(DoAll(SetArgReferee<1>(0), Return(0)));
+        EXPECT_CALL(*proxy, CancelForResult(_, _)).WillOnce(DoAll(SetArgReferee<1>(0), Return(0)));
         ServiceClient::serviceProxy_ = proxy;
         err = restoreAsyncSession->Cancel(bundleName);
         EXPECT_EQ(err, BError(BError::Codes::OK).GetCode());
diff --git a/tests/unittests/backup_sa/session/service_proxy_mock.cpp b/tests/unittests/backup_sa/session/service_proxy_mock.cpp
index c2050aa24c3b57376ce42ca25864260aead91ffa..2d361cf5ab27ce03d386aa5ed2484bf5be8fa0f1 100644
--- a/tests/unittests/backup_sa/session/service_proxy_mock.cpp
+++ b/tests/unittests/backup_sa/session/service_proxy_mock.cpp
@@ -25,6 +25,11 @@ ErrCode ServiceProxy::AppFileReady(const std::string &fileName, int fd, int32_t
     return BError(BError::Codes::OK);
 }
 
+ErrCode ServiceProxy::AppFileReadyWithoutFd(const std::string &fileName, int32_t appFileReadyErrCode)
+{
+    return BError(BError::Codes::OK);
+}
+
 ErrCode ServiceProxy::AppDone(int32_t appDoneErrCode)
 {
     return BError(BError::Codes::OK);
@@ -45,6 +50,11 @@ ErrCode ServiceProxy::AppIncrementalFileReady(const std::string &fileName, int f
     return BError(BError::Codes::OK);
 }
 
+ErrCode ServiceProxy::AppIncrementalFileReadyWithoutFd(const std::string &fileName, int32_t errCode)
+{
+    return BError(BError::Codes::OK);
+}
+
 ErrCode ServiceProxy::PublishSAIncrementalFile(const BFileInfo &fileInfo, int fd)
 {
     return BError(BError::Codes::OK);
@@ -93,7 +103,7 @@ ErrCode ServiceProxy::AppendBundlesIncrementalBackupSession(const std::vector<BI
     return BError(BError::Codes::OK);
 }
 
-ErrCode ServiceProxy::Cancel(const std::string &bundleName, int32_t &cancelResult)
+ErrCode ServiceProxy::CancelForResult(const std::string &bundleName, int32_t &cancelResult)
 {
     return BError(BError::Codes::OK);
 }
diff --git a/tests/unittests/backup_sa/session/service_proxy_mock.h b/tests/unittests/backup_sa/session/service_proxy_mock.h
index 3ee48b1abc261523447ed16bdaeb4c981b9a5e10..b5ffa5da797106d2128347db7a368000fbbb37c5 100644
--- a/tests/unittests/backup_sa/session/service_proxy_mock.h
+++ b/tests/unittests/backup_sa/session/service_proxy_mock.h
@@ -46,7 +46,7 @@ public:
     MOCK_METHOD1(AppendBundlesBackupSession, ErrCode(const std::vector<BundleName> &bundleNames));
     MOCK_METHOD0(Finish, ErrCode());
     MOCK_METHOD0(Release, ErrCode());
-    MOCK_METHOD2(Cancel, ErrCode(const std::string &bundleName, int32_t &result));
+    MOCK_METHOD2(CancelForResult, ErrCode(const std::string &bundleName, int32_t &result));
     MOCK_METHOD2(GetLocalCapabilitiesIncremental, ErrCode(const std::vector<BIncrementalData> &bundleNames, int &fd));
     MOCK_METHOD1(InitIncrementalBackupSession, ErrCode(const sptr<IServiceReverse> &remote));
     MOCK_METHOD3(InitIncrementalBackupSessionWithErrMsg,
@@ -59,6 +59,8 @@ public:
     MOCK_METHOD3(AppIncrementalFileReady, ErrCode(const std::string &fileName, int fd, int manifestFd));
     MOCK_METHOD4(AppIncrementalFileReady,
                  ErrCode(const std::string &fileName, int fd, int manifestFd, int32_t errCode));
+    MOCK_METHOD2(AppIncrementalFileReadyWithoutFd,
+                 ErrCode(const std::string &fileName, int32_t errCode));
     MOCK_METHOD1(AppIncrementalDone, ErrCode(int32_t errCode));
     MOCK_METHOD2(GetIncrementalFileHandle, ErrCode(const std::string &bundleName, const std::string &fileName));
     MOCK_METHOD2(GetBackupInfo, ErrCode(const BundleName &bundleName, std::string &result));