diff --git a/BUILD.gn b/BUILD.gn
index ac948c97d5f4803f8fc62fe764ced458deba90d8..4c82fe12f6cd6f6dbd2ebb29dfc9c73f0d6e1e38 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -43,6 +43,7 @@ group("unittest") {
       "test/unittest:updater_unittest",
       "test/unittest/applypatch_test:applypatch_unittest",
       "test/unittest/common/ring_buffer:ring_buffer_test",
+      "test/unittest/factory_reset_test:factory_reset_unittest",
       "test/unittest/flashd_test:flashd_unittest",
       "test/unittest/flashd_test:flashd_utils_unittest",
       "test/unittest/flow_update/update_bin:bin_flow_update_test",
diff --git a/services/factory_reset/factory_reset.cpp b/services/factory_reset/factory_reset.cpp
index 570690c9d1aa88f8f9dd50dac44bac0ce1485433..88c6ebc7932a632973a595cc3c9ad020e42b9915 100644
--- a/services/factory_reset/factory_reset.cpp
+++ b/services/factory_reset/factory_reset.cpp
@@ -17,6 +17,7 @@
 #include "log/dump.h"
 #include "log/log.h"
 #include "fs_manager/mount.h"
+#include "scope_guard.h"
 
 namespace Updater {
 FactoryResetProcess &FactoryResetProcess::GetInstance()
@@ -46,27 +47,35 @@ int FactoryResetProcess::FactoryResetFunc(FactoryResetMode mode, const std::stri
         LOG(ERROR) << "Invalid factory reset tag: " << mode;
         return 1;
     }
-    if (CommonResetPreFunc_ == nullptr ||
-        CommonResetPreFunc_(mode == MENU_WIPE_DATA || mode == FACTORY_WIPE_DATA) != 0) {
-        LOG(ERROR) << "Failed to erase the security status";
-        return -1;
-    }
-    if (iter->second(path) != 0) {
+    int resetStatus = iter->second(path);
+    ON_SCOPE_EXIT(factoryResetPost) {
+        if (mode == FACTORY_WIPE_DATA &&
+            (FactoryResetPostFunc_ == nullptr || FactoryResetPostFunc_(resetStatus) != 0)) {
+            LOG(ERROR) << "FactoryResetPostFunc_ fail";
+        }
+    };
+    if (resetStatus != 0) {
         LOG(ERROR) << "Do factory reset failed! tag: " << mode;
         return 1;
     }
+    if (CommonResetPostFunc_ == nullptr ||
+        CommonResetPostFunc_(mode == MENU_WIPE_DATA || mode == FACTORY_WIPE_DATA) != 0) {
+        resetStatus = 1;
+        LOG(ERROR) << "CommonResetPostFunc_ fail";
+        return -1;
+    }
     return 0;
 }
 
-static int CommonResetPre(bool flag)
+static int CommonResetPost(bool flag)
 {
-    LOG(INFO) << "CommonResetPre";
+    LOG(INFO) << "CommonResetPost";
     return 0;
 }
 
-void FactoryResetProcess::RegisterCommonResetPreFunc(CommonResetPreFunc ptr)
+void FactoryResetProcess::RegisterCommonResetPostFunc(CommonResetPostFunc ptr)
 {
-    CommonResetPreFunc_ = std::move(ptr);
+    CommonResetPostFunc_ = std::move(ptr);
 }
 
 static int FactoryResetPre()
@@ -122,15 +131,12 @@ int FactoryResetProcess::DoFactoryReset(const std::string &path)
     }
 
     LOG(INFO) << "Factory level FactoryReset status:" << resetStatus;
-    if (FactoryResetPostFunc_ == nullptr || FactoryResetPostFunc_(resetStatus) != 0) {
-        LOG(ERROR) << "FactoryResetPostFunc_ fail";
-    }
     return resetStatus;
 }
 
-extern "C" __attribute__((constructor)) void RegisterCommonResetPreFunc(void)
+extern "C" __attribute__((constructor)) void RegisterCommonResetPostFunc(void)
 {
-    FactoryResetProcess::GetInstance().RegisterCommonResetPreFunc(CommonResetPre);
+    FactoryResetProcess::GetInstance().RegisterCommonResetPostFunc(CommonResetPost);
 }
 
 extern "C" __attribute__((constructor)) void RegisterFactoryResetPreFunc(void)
diff --git a/services/factory_reset/factory_reset.h b/services/factory_reset/factory_reset.h
index 192df9cc06fb933ecd1103f282abeb60ac733858..053631f8bcb696d47f1e4063e33345c27bc9521e 100644
--- a/services/factory_reset/factory_reset.h
+++ b/services/factory_reset/factory_reset.h
@@ -22,7 +22,7 @@
 #include "updater_main.h"
 
 namespace Updater {
-using CommonResetPreFunc = std::function<int(bool)>;
+using CommonResetPostFunc = std::function<int(bool)>;
 using FactoryResetPreFunc = std::function<int(void)>;
 using FactoryResetPostFunc = std::function<int(int)>;
 class FactoryResetProcess {
@@ -33,13 +33,13 @@ public:
 
     static FactoryResetProcess &GetInstance();
     using ResetFunc = std::function<int(const std::string &)>;
-    void RegisterCommonResetPreFunc(CommonResetPreFunc ptr);
+    void RegisterCommonResetPostFunc(CommonResetPostFunc ptr);
     void RegisterFactoryResetPreFunc(FactoryResetPreFunc ptr);
     void RegisterFactoryResetPostFunc(FactoryResetPostFunc ptr);
     int FactoryResetFunc(FactoryResetMode mode, const std::string &path);
 
 private:
-    CommonResetPreFunc CommonResetPreFunc_ = nullptr;
+    CommonResetPostFunc CommonResetPostFunc_ = nullptr;
     FactoryResetPreFunc FactoryResetPreFunc_ = nullptr;
     FactoryResetPostFunc FactoryResetPostFunc_ = nullptr;
     std::unordered_map<FactoryResetMode, ResetFunc> resetTab_;
diff --git a/services/include/applypatch/transfer_manager.h b/services/include/applypatch/transfer_manager.h
index 65b0510188ee1f9ace2208b328eee777815459f7..3956e7ca5bc79183d8dd262999c4fd3fb424bd9a 100644
--- a/services/include/applypatch/transfer_manager.h
+++ b/services/include/applypatch/transfer_manager.h
@@ -51,6 +51,7 @@ struct TransferParams {
     std::string storeBase;
     std::string freeStash;
     std::string retryFile;
+    std::string devPath;
     uint8_t *patchDataBuffer;
     size_t patchDataSize;
 };
diff --git a/services/include/package/pkg_manager.h b/services/include/package/pkg_manager.h
index a455c619bfd6bdf1460fbbe12a55a6526661c30c..4420287b3e572e4de9fd56d1c8eaf2602f7a99cc 100644
--- a/services/include/package/pkg_manager.h
+++ b/services/include/package/pkg_manager.h
@@ -260,6 +260,8 @@ public:
 
     virtual int32_t VerifyAccPackage(const std::string &packagePath, const std::string &keyPath) = 0;
 
+    virtual int32_t VerifyOtaPackage(const std::string &devPath, uint64_t offset, size_t size) = 0;
+
     virtual int32_t VerifyOtaPackage(const std::string &packagePath) = 0;
 
     virtual int32_t VerifyBinFile(const std::string &packagePath, const std::string &keyPath,
diff --git a/services/include/updater/updater.h b/services/include/updater/updater.h
index a51a294ec3421619727a8248ebb4f71ce02d1c63..7c3fd9fa8b7369302de9aff1b6a9c6bd6eb4acbb 100644
--- a/services/include/updater/updater.h
+++ b/services/include/updater/updater.h
@@ -81,7 +81,7 @@ UpdaterStatus DoInstallUpdaterPackage(Hpackage::PkgManager::PkgManagerPtr pkgMan
     UpdaterParams &upParams, PackageUpdateMode updateMode);
 
 UpdaterStatus StartUpdaterProc(Hpackage::PkgManager::PkgManagerPtr pkgManager,
-    UpdaterParams &upParams, int &maxTemperature);
+    UpdaterParams &upParams);
 
 int GetUpdatePackageInfo(Hpackage::PkgManager::PkgManagerPtr pkgManager, const std::string& path);
 
diff --git a/services/include/updater/updater_const.h b/services/include/updater/updater_const.h
index 9466c8bd030a7c5d1e4e7df692e23c30109bd7e6..672f638388dc91b2074ff44b267b6e4de4c86afe 100644
--- a/services/include/updater/updater_const.h
+++ b/services/include/updater/updater_const.h
@@ -51,11 +51,13 @@ constexpr const char *OTA_MODE = "update_package";
 constexpr const char *USB_MODE = "usb_update";
 constexpr const char *SDCARD_INTRAL_MODE = "sdcard_intral_update";
 constexpr const char *UPDATRE_SCRIPT_ZIP = "/etc/updater_script.zip";
+constexpr const char *FACTORY_INTERNAL_MODE = "factory_internal_update";
 
 // sd update ext mode
 constexpr const char *SDCARD_NORMAL_UPDATE = "sdUpdate";
 constexpr const char *SDCARD_UPDATE_FROM_DEV = "sdUpdateFromDev";
 constexpr const char *SDCARD_MAINIMG = "mainUpdate";
+constexpr const char *SDCARD_UPDATE_FROM_DATA = "sdUpdateFromData";
 
 #ifndef UPDATER_UT
 constexpr const char *SDCARD_CARD_PATH = "/sdcard/updater";
diff --git a/services/package/pkg_manager/pkg_managerImpl.cpp b/services/package/pkg_manager/pkg_managerImpl.cpp
index 817c0b002ab932f70fffb736db505cb87b2c1c21..32a73b417e8485c0fa43e40c90bbb940a15c90a7 100644
--- a/services/package/pkg_manager/pkg_managerImpl.cpp
+++ b/services/package/pkg_manager/pkg_managerImpl.cpp
@@ -15,8 +15,10 @@
 #include "pkg_manager_impl.h"
 #include <algorithm>
 #include <cctype>
+#include <cinttypes>
 #include <cstdio>
 #include <cstring>
+#include <fcntl.h>
 #include <functional>
 #include <iterator>
 #include <unistd.h>
@@ -30,6 +32,7 @@
 #include "pkg_upgradefile.h"
 #include "pkg_verify_util.h"
 #include "pkg_zipfile.h"
+#include "scope_guard.h"
 #include "securec.h"
 #include "updater/updater_const.h"
 #include "utils.h"
@@ -987,6 +990,57 @@ int32_t PkgManagerImpl::VerifyAccPackage(const std::string &packagePath, const s
     return PKG_SUCCESS;
 }
 
+int32_t PkgManagerImpl::VerifyOtaPackage(const std::string &devPath, uint64_t offset, size_t size)
+{
+#ifndef DIFF_PATCH_SDK
+    constexpr size_t pageSize = 4096;
+    size_t offsetAligned = (offset / pageSize) * pageSize;
+    if (size == 0 || size + offset < offsetAligned || offset < offsetAligned) {
+        PKG_LOGE("invalid param %zu %" PRIu64 " %zu", size, offset, offsetAligned);
+        return PKG_INVALID_PARAM;
+    }
+    char devRealPath[PATH_MAX + 1] = {};
+    if (realpath(devPath.c_str(), devRealPath) == nullptr) {
+        PKG_LOGE("realPath is nullptr, err %s", strerror(errno));
+        return PKG_INVALID_PARAM;
+    }
+    int fd = open(devRealPath, O_RDONLY | O_LARGEFILE);
+    if (fd < 0) {
+        PKG_LOGE("open %s fail, %s", devRealPath, strerror(errno));
+        return PKG_INVALID_FILE;
+    }
+    ON_SCOPE_EXIT(closePath) {
+        close(fd);
+    };
+    uint8_t *pMap = static_cast<uint8_t *>(mmap64(nullptr, size + offset - offsetAligned, PROT_READ, MAP_PRIVATE,
+        fd, offsetAligned));
+    if (pMap == MAP_FAILED) {
+        PKG_LOGE("mmap64 %s fail, %s %zu %" PRIu64, devRealPath, strerror(errno), size, offset);
+        return PKG_NONE_MEMORY;
+    }
+    ON_SCOPE_EXIT(unmapMem) {
+        munmap(pMap, size + offset - offsetAligned);
+    };
+    PkgBuffer buffer(pMap + (offset - offsetAligned), size);
+    PkgStreamPtr pkgStream = nullptr;
+    int32_t ret = CreatePkgStream(pkgStream, devRealPath, buffer);
+    if (ret != PKG_SUCCESS) {
+        PKG_LOGE("create package stream fail %s %s", devRealPath, strerror(errno));
+        return ret;
+    }
+    ON_SCOPE_EXIT(closeStream) {
+        ClosePkgStream(pkgStream);
+    };
+    PkgVerifyUtil verifyUtil {};
+    ret = verifyUtil.VerifyPackageSign(pkgStream);
+    if (ret != PKG_SUCCESS) {
+        PKG_LOGE("verify pkcs7 signature failed.");
+        return ret;
+    }
+#endif
+    return PKG_SUCCESS;
+}
+
 int32_t PkgManagerImpl::VerifyOtaPackage(const std::string &packagePath)
 {
     PkgStreamPtr pkgStream = nullptr;
diff --git a/services/package/pkg_manager/pkg_manager_impl.h b/services/package/pkg_manager/pkg_manager_impl.h
index 9cab6bd7707abc4c9a2b84ee498358f0f92a86c8..fa421d5393c831cb327aadc4f7d4cd55a922a5bd 100644
--- a/services/package/pkg_manager/pkg_manager_impl.h
+++ b/services/package/pkg_manager/pkg_manager_impl.h
@@ -77,7 +77,7 @@ public:
         uint64_t fileLen, Updater::RingBuffer *buffer) override;
     int32_t VerifyAccPackage(const std::string &packagePath, const std::string &keyPath) override;
     int32_t VerifyOtaPackage(const std::string &packagePath) override;
-
+    int32_t VerifyOtaPackage(const std::string &devPath, uint64_t offset, size_t size) override;
     int32_t VerifyBinFile(const std::string &packagePath, const std::string &keyPath,
         const std::string &version, const PkgBuffer &digest) override;
 
diff --git a/services/ptable_parse/emmc_ptable.cpp b/services/ptable_parse/emmc_ptable.cpp
index 8bce4a2a05592d29f370903c42fe68ea15b0c32d..4c398ee62927476f4557eb0cef805d0672542c47 100644
--- a/services/ptable_parse/emmc_ptable.cpp
+++ b/services/ptable_parse/emmc_ptable.cpp
@@ -123,7 +123,7 @@ bool EmmcPtable::ParsePartitionFromBuffer(uint8_t *ptbImgBuffer, const uint32_t
 bool EmmcPtable::ParseGptHeaderByEmmc(uint8_t *gptImage, const uint32_t len)
 {
     GPTHeaderInfo gptHeaderInfo;
-    uint32_t blockSize = ptableData_.blockSize; // 4096
+    uint32_t blockSize = EMMC_BLOCK_SIZE;
     (void)memset_s(&gptHeaderInfo, sizeof(GPTHeaderInfo), 0, sizeof(GPTHeaderInfo));
     if (!GetPartitionGptHeaderInfo(gptImage + blockSize, blockSize, gptHeaderInfo)) {
         LOG(ERROR) << "GetPartitionGptHeaderInfo fail";
@@ -138,9 +138,15 @@ bool EmmcPtable::ParseGptHeaderByEmmc(uint8_t *gptImage, const uint32_t len)
     return PartitionCheckGptHeader(gptImage, len, lbaNum, blockSize, gptHeaderInfo);
 }
 
-bool EmmcPtable::EmmcReadGpt(uint8_t *ptableData)
+bool EmmcPtable::EmmcReadGpt(uint8_t *ptableData, uint32_t len)
 {
     uint32_t number = 0;
+
+    partitionInfo_.clear();
+    if (!ParseGptHeaderByEmmc(emmcPtnDataInfo_.data, len)) {
+        LOG(ERROR) << "Primary signature invalid";
+        return false;
+    }
     for (uint32_t i = 0; i < MAX_PARTITION_NUM; i++) {
         uint8_t *startLbaOffset = ptableData + GPT_PARTITION_START_LBA_OFFSET;
         uint8_t *endLbaOffset = ptableData + GPT_PARTITION_START_LBA_OFFSET + GPT_PARTITION_END_LBA_OFFSET;
@@ -159,6 +165,8 @@ bool EmmcPtable::EmmcReadGpt(uint8_t *ptableData)
             LOG(ERROR) << "memcpy guid fail";
         }
         newPtnInfo.startAddr = startLba * LBA_LENGTH;
+        newPtnInfo.writePath = MMC_BLOCK_DEV_NAME;
+        newPtnInfo.writeMode = "WRITE_RAW";
         /* General algorithm : calculate partition size by lba */
         newPtnInfo.partitionSize = (endLba - startLba + 1) * LBA_LENGTH;
         ptableData += GPT_PARTITION_INFO_LENGTH;
@@ -176,7 +184,7 @@ bool EmmcPtable::UpdateCommInitializeGptPartition(uint8_t *gptImage, const uint3
         return false;
     }
     uint32_t imgBlockSize = ptableData_.lbaLen; // 512
-    uint32_t deviceBlockSize = ptableData_.blockSize; // 4096
+    uint32_t deviceBlockSize = EMMC_BLOCK_SIZE;
 
     uint8_t *gptHeaderStart = gptImage + imgBlockSize;
     uint8_t *ptableData = gptImage + PROTECTIVE_MBR_SIZE + LBA_LENGTH; /* skip MBR and gpt header */
@@ -204,14 +212,10 @@ bool EmmcPtable::UpdateCommInitializeGptPartition(uint8_t *gptImage, const uint3
         return false;
     }
     emmcPtnDataInfo_.writeDataLen = len;
-    if (!ParseGptHeaderByEmmc(emmcPtnDataInfo_.data, len)) {
-        LOG(ERROR) << "Primary signature invalid";
-        return false;
-    }
     EmmcPatchGptHeader(emmcPtnDataInfo_, deviceBlockSize);
     emmcPtnDataInfo_.isGptVaild = true;
 
-    return EmmcReadGpt(ptableData);
+    return EmmcReadGpt(emmcPtnDataInfo_.data + 2 * deviceBlockSize, len); // 2: skip 2 lba length to set gpt entry
 }
 
 bool EmmcPtable::ReadEmmcGptImageToRam()
@@ -224,7 +228,7 @@ bool EmmcPtable::ReadEmmcGptImageToRam()
     int32_t imgLen = GPT_PARTITION_SIZE;
     auto buf = std::make_unique<uint8_t[]>(imgLen);
     uint8_t *buffer = buf.get();
-    uint32_t deviceBlockSize = ptableData_.blockSize; // 4096
+    uint32_t deviceBlockSize = EMMC_BLOCK_SIZE;
     if (buffer == nullptr) {
         LOG(ERROR) << "new buffer failed!";
         return false;
@@ -251,7 +255,7 @@ bool EmmcPtable::ReadEmmcGptImageToRam()
 
     emmcPtnDataInfo_.isGptVaild = true;
     uint8_t *ptableData = buffer + 2 * deviceBlockSize; /* skip MBR and gpt header */
-    return EmmcReadGpt(ptableData);
+    return EmmcReadGpt(ptableData, imgLen);
 }
 
 bool EmmcPtable::LoadPtableFromDevice()
@@ -282,7 +286,7 @@ bool EmmcPtable::GetPtableImageBuffer(uint8_t *imageBuf, const uint32_t imgBufSi
 
 bool EmmcPtable::EditPartitionBuf(uint8_t *imageBuf, uint64_t imgBufSize, std::vector<PtnInfo> &modifyList)
 {
-    if (imageBuf == nullptr || imgBufSize == 0 || modifyList.empty() == 0) {
+    if (imageBuf == nullptr || imgBufSize == 0 || modifyList.empty()) {
         LOG(ERROR) << "input invalid";
         return false;
     }
@@ -291,9 +295,9 @@ bool EmmcPtable::EditPartitionBuf(uint8_t *imageBuf, uint64_t imgBufSize, std::v
     uint8_t *gptHeader = gptImage + imgBlockSize;
     uint32_t maxPtnCnt = GET_LWORD_FROM_BYTE(&gptHeader[PARTITION_COUNT_OFFSET]);
     uint32_t ptnEntrySize = GET_LWORD_FROM_BYTE(&gptHeader[PENTRY_SIZE_OFFSET]);
-    uint32_t gptHeaderLen = EMMC_BLOCK_SIZE;
-    uint32_t gptSize = static_cast<uint64_t>(maxPtnCnt) * ptnEntrySize + imgBlockSize + gptHeaderLen;
-    uint32_t devDensity = GetDeviceCapacity();
+    uint64_t gptHeaderLen = EMMC_BLOCK_SIZE;
+    uint64_t gptSize = static_cast<uint64_t>(maxPtnCnt) * ptnEntrySize + imgBlockSize + gptHeaderLen;
+    uint64_t devDensity = GetDeviceCapacity();
     if (devDensity == 0) {
         LOG(ERROR) << "get emmc capacity fail";
         return false;
diff --git a/services/ptable_parse/emmc_ptable.h b/services/ptable_parse/emmc_ptable.h
index fcec50f73188981cc2de4d0f004e10c7d5c98865..60963db15c05ab57b6a7aa45dc184fa9781c0aed 100644
--- a/services/ptable_parse/emmc_ptable.h
+++ b/services/ptable_parse/emmc_ptable.h
@@ -42,7 +42,7 @@ private:
     static constexpr uint32_t LBA_LENGTH = 512;
     static constexpr uint32_t GPT_PARTITION_INFO_LENGTH = 128;
     static constexpr uint32_t PROTECTIVE_MBR_SIZE = 512;
-    static constexpr uint32_t MIN_EMMC_WRITE_SIZE = 4096;
+    static constexpr uint32_t MIN_EMMC_WRITE_SIZE = 512;
     static constexpr uint32_t EMMC_BLOCK_SIZE = 512;
 
     struct EmmcPartitionDataInfo {
@@ -53,7 +53,7 @@ private:
 
     struct EmmcPartitionDataInfo emmcPtnDataInfo_;
 
-    bool EmmcReadGpt(uint8_t *ptableData);
+    bool EmmcReadGpt(uint8_t *ptableData, uint32_t len);
     bool UpdateCommInitializeGptPartition(uint8_t *gptImage, const uint32_t len);
     bool ReadEmmcGptImageToRam();
     uint64_t GetDeviceCapacity();
diff --git a/services/sdcard_update/sdcard_update.cpp b/services/sdcard_update/sdcard_update.cpp
index ef0d4766d73d4642ce729a187c47f3141f9b4efd..f13bf526e67039730474d2b04670c7bcc933db58 100644
--- a/services/sdcard_update/sdcard_update.cpp
+++ b/services/sdcard_update/sdcard_update.cpp
@@ -98,6 +98,12 @@ UpdaterStatus CheckSdcardPkgs(UpdaterParams &upParams)
         LOG(INFO) << "get sd card from dev succeed, skip get package from sd card";
         return UPDATE_SUCCESS;
     }
+ 
+    if (GetSdcardInternalPkgs(upParams) == UPDATE_SUCCESS) {
+        LOG(INFO) << "get sdcard internal pkgs succeed";
+        return UPDATE_SUCCESS;
+    }
+ 
     std::string mountPoint = std::string(SDCARD_PATH);
     std::vector<std::string> sdcardStr = GetBlockDevicesByMountPoint(mountPoint);
     if (sdcardStr.empty()) {
@@ -125,4 +131,10 @@ UpdaterStatus CheckSdcardPkgs(UpdaterParams &upParams)
     }
     return UPDATE_SUCCESS;
 }
+
+__attribute__((weak)) UpdaterStatus GetSdcardInternalPkgs(UpdaterParams &upParams)
+{
+    LOG(INFO) << "not implemented get normal update sdcard pkgs";
+    return UPDATE_ERROR;
+}
 } // Updater
diff --git a/services/sdcard_update/sdcard_update.h b/services/sdcard_update/sdcard_update.h
index 5e607594216f6640d668bcc38cead7fa69a3fdc5..9f238b0375ad9bb6e5bd4dbf4546b4256634d464 100644
--- a/services/sdcard_update/sdcard_update.h
+++ b/services/sdcard_update/sdcard_update.h
@@ -29,6 +29,7 @@ extern "C" {
 #endif
 UpdaterStatus GetSdcardPkgsPath(UpdaterParams &upParams);
 UpdaterStatus GetSdcardPkgsFromDev(UpdaterParams &upParams);
+UpdaterStatus GetSdcardInternalPkgs(UpdaterParams &upParams);
 #ifdef __cplusplus
 #if __cplusplus
 }
diff --git a/services/ui/control/event_listener.cpp b/services/ui/control/event_listener.cpp
index 93f6c92de11baa90daddfd1f5318bfa2cfabc19f..14974a9381a38b1f4197bbc6996fb7211f1886e5 100644
--- a/services/ui/control/event_listener.cpp
+++ b/services/ui/control/event_listener.cpp
@@ -154,6 +154,7 @@ bool KeyListener::OnKeyAct(OHOS::UIView &view, const OHOS::KeyEvent &event)
 
 bool KeyListener::ProcessPowerKey(OHOS::UIView &view, const OHOS::KeyEvent &event)
 {
+#ifndef UPDATER_UT
     OHOS::UIView *pView = OHOS::FocusManager::GetInstance()->GetFocusedView();
     if (pView == nullptr) {
         LOG(ERROR) << "focused view is nullptr";
@@ -170,6 +171,7 @@ bool KeyListener::ProcessPowerKey(OHOS::UIView &view, const OHOS::KeyEvent &even
         LOG(DEBUG) << "OnPress";
         pView->OnClickEvent(OHOS::Point { centerX, centerY });
     }
+#endif
     return true;
 }
 
diff --git a/services/ui/view/view_api.cpp b/services/ui/view/view_api.cpp
index c8bf1d481e59be13432e20958344a1fde28fa01a..fb870502480b22618e0b4899009e3b4d723bddd3 100644
--- a/services/ui/view/view_api.cpp
+++ b/services/ui/view/view_api.cpp
@@ -72,7 +72,13 @@ OHOS::ColorType StrToColor(const std::string &hexColor)
     std::size_t startPos = 1uL;
     auto getNextField = [&startPos, &hexColor] () {
         constexpr std::size_t width = 2uL;
-        uint8_t ret = (startPos > hexColor.size()) ? 0 : Utils::String2Int<uint8_t>(hexColor.substr(startPos, width));
+        constexpr uint8_t colorMaxSize = 255;
+        int reset = Utils::String2Int<int>(hexColor.substr(startPos, width));
+        if (reset < 0 || reset > static_cast<int>(colorMaxSize)) {
+            LOG(ERROR) << "String2Int error, reset = " << reset;
+            return colorMaxSize;
+        }
+        uint8_t ret = (startPos > hexColor.size()) ? 0 : static_cast<uint8_t>(reset);
         startPos += width;
         return ret;
     };
diff --git a/services/updater.cpp b/services/updater.cpp
index 36f90f3fbadff6212942b83c52f46e72164280d7..b70463019b32fb1c5a6b014f5d4097d7867f943a 100644
--- a/services/updater.cpp
+++ b/services/updater.cpp
@@ -258,7 +258,8 @@ UpdaterStatus DoInstallUpdaterPackage(PkgManager::PkgManagerPtr pkgManager, Upda
     }
 
     if (SetupPartitions(updateMode != SDCARD_UPDATE || upParams.sdExtMode == SDCARD_UPDATE_FROM_DEV ||
-        Utils::CheckUpdateMode(Updater::SDCARD_INTRAL_MODE)) != 0) {
+        upParams.sdExtMode == SDCARD_UPDATE_FROM_DATA || Utils::CheckUpdateMode(Updater::SDCARD_INTRAL_MODE) ||
+        Utils::CheckUpdateMode(Updater::FACTORY_INTERNAL_MODE)) != 0) {
         UPDATER_UI_INSTANCE.ShowUpdInfo(TR(UPD_SETPART_FAIL), true);
         UPDATER_LAST_WORD(UPDATE_ERROR);
         return UPDATE_ERROR;
@@ -278,8 +279,7 @@ UpdaterStatus DoInstallUpdaterPackage(PkgManager::PkgManagerPtr pkgManager, Upda
     }
 
     g_tmpProgressValue = 0;
-    int maxTemperature;
-    UpdaterStatus updateRet = StartUpdaterProc(pkgManager, upParams, maxTemperature);
+    UpdaterStatus updateRet = StartUpdaterProc(pkgManager, upParams);
     if (updateRet != UPDATE_SUCCESS) {
         UPDATER_UI_INSTANCE.ShowUpdInfo(TR(UPD_INSTALL_FAIL));
         LOG(ERROR) << "Install package failed.";
@@ -402,8 +402,13 @@ UpdaterStatus HandlePipeMsg(UpdaterParams &upParams, int pipeRead, bool &retryUp
         if (pch != nullptr) {
             *pch = '\0';
         }
+        if (strstr(buffer, "subProcessResult") != nullptr) {
+            LOG(INFO) << "subProcessResult: " << buffer;
+            break;
+        }
         HandleChildOutput(buffer, MAX_BUFFER_SIZE, retryUpdate, upParams);
     }
+    LOG(INFO) << "HandlePipeMsg end";
     fclose(fromChild);
     return UPDATE_SUCCESS;
 }
@@ -433,7 +438,7 @@ UpdaterStatus CheckProcStatus(pid_t pid, bool retryUpdate)
     return UPDATE_SUCCESS;
 }
 
-UpdaterStatus StartUpdaterProc(PkgManager::PkgManagerPtr pkgManager, UpdaterParams &upParams, int &maxTemperature)
+UpdaterStatus StartUpdaterProc(PkgManager::PkgManagerPtr pkgManager, UpdaterParams &upParams)
 {
     UPDATER_INIT_RECORD;
     int pfd[DEFAULT_PIPE_NUM]; /* communication between parent and child */
diff --git a/services/updater_binary/update_image_block.cpp b/services/updater_binary/update_image_block.cpp
index 21926f8e4e6f67fd7b1d30646528408936a60af0..16a30ff0df8e4d4e4b0f4b2e5adde09b8080bb2f 100644
--- a/services/updater_binary/update_image_block.cpp
+++ b/services/updater_binary/update_image_block.cpp
@@ -186,13 +186,14 @@ static int32_t GetUpdateBlockInfo(struct UpdateBlockInfo &infos, Uscript::UScrip
 }
 
 static int32_t ExecuteTransferCommand(int fd, const std::vector<std::string> &lines, TransferManagerPtr tm,
-    Uscript::UScriptContext &context, const std::string &partitionName)
+    Uscript::UScriptContext &context, const UpdateBlockInfo &infos)
 {
     auto transferParams = tm->GetTransferParams();
     auto writerThreadInfo = transferParams->writerThreadInfo.get();
 
-    transferParams->storeBase = std::string("/data/updater") + partitionName + "_tmp";
-    transferParams->retryFile = std::string("/data/updater") + partitionName + "_retry";
+    transferParams->storeBase = std::string("/data/updater") + infos.partitionName + "_tmp";
+    transferParams->retryFile = std::string("/data/updater") + infos.partitionName + "_retry";
+    transferParams->devPath = infos.devPath;
     LOG(INFO) << "Store base path is " << transferParams->storeBase;
     int32_t ret = Store::CreateNewSpace(transferParams->storeBase, !transferParams->env->IsRetry());
     if (ret == -1) {
@@ -289,7 +290,7 @@ static int32_t DoExecuteUpdateBlock(const UpdateBlockInfo &infos, TransferManage
         env->GetPkgManager()->ClosePkgStream(outStream);
         return USCRIPT_ERROR_EXECUTE;
     }
-    int32_t ret = ExecuteTransferCommand(fd, lines, tm, context, infos.partitionName);
+    int32_t ret = ExecuteTransferCommand(fd, lines, tm, context, infos);
     fsync(fd);
     close(fd);
     fd = -1;
@@ -471,21 +472,26 @@ int32_t UScriptInstructionBlockCheck::Execute(Uscript::UScriptEnv &env, Uscript:
     return USCRIPT_SUCCESS;
 }
 
+bool UScriptInstructionShaCheck::IsTargetShaDiff(const std::string &devPath, const ShaInfo &shaInfo)
+{
+    std::string tgtResultSha = CalculateBlockSha(devPath, shaInfo.targetPairs);
+    if (tgtResultSha.empty()) {
+        LOG(WARNING) << "target sha is empty";
+        return true;
+    }
+    LOG(INFO) << "tgtResultSha: " << tgtResultSha << ", shaInfo.targetSha: " << shaInfo.targetSha;
+    return (tgtResultSha != shaInfo.targetSha);
+}
+
 int UScriptInstructionShaCheck::ExecReadShaInfo(Uscript::UScriptEnv &env, const std::string &devPath,
     const ShaInfo &shaInfo)
 {
     UPDATER_INIT_RECORD;
     std::string resultSha = CalculateBlockSha(devPath, shaInfo.blockPairs);
-    std::string tgtResultSha = CalculateBlockSha(devPath, shaInfo.targetPairs);
-    if (resultSha.empty() && tgtResultSha.empty()) {
-        LOG(ERROR) << "All sha is empty";
-        return USCRIPT_ERROR_EXECUTE;
-    }
-
-    bool isTargetDiff = tgtResultSha.empty() ? true : (tgtResultSha != shaInfo.targetSha);
-    if (resultSha != shaInfo.contrastSha && isTargetDiff) {
+    if (resultSha != shaInfo.contrastSha && IsTargetShaDiff(devPath, shaInfo)) {
         LOG(ERROR) << "Different sha256, cannot continue";
         LOG(ERROR) << "blockPairs:" << shaInfo.blockPairs;
+        LOG(ERROR) << "resultSha: " << resultSha << ", shaInfo.contrastSha: " << shaInfo.contrastSha;
         PrintAbnormalBlockHash(devPath, shaInfo.blockPairs);
         UPDATER_LAST_WORD(devPath.substr(devPath.find_last_of("/") + 1), USCRIPT_ERROR_EXECUTE);
         env.PostMessage(UPDATER_RETRY_TAG, VERIFY_FAILED_REBOOT);
diff --git a/services/updater_binary/update_image_block.h b/services/updater_binary/update_image_block.h
index 2006b5ae328e5c19ded8c7809312687d83ec5fc4..fe2e39bd5950742640efa54da2a3fd6c62ead45f 100644
--- a/services/updater_binary/update_image_block.h
+++ b/services/updater_binary/update_image_block.h
@@ -53,6 +53,7 @@ private:
     void PrintAbnormalBlockHash(const std::string &devPath, const std::string &blockPairs);
     std::string CalculateBlockSha(const std::string &devPath, const std::string &blockPairs);
     int32_t SetShaInfo(Uscript::UScriptContext &context, ShaInfo &shaInfo);
+    bool IsTargetShaDiff(const std::string &devPath, const ShaInfo &shaInfo);
 };
 }
 
diff --git a/services/updater_binary/update_processor.cpp b/services/updater_binary/update_processor.cpp
index 71242e1540b0598235737a7fb81d6576db8bce86..5045e2df3a7a94f6f7e1b96f8c42b270ac160d15 100644
--- a/services/updater_binary/update_processor.cpp
+++ b/services/updater_binary/update_processor.cpp
@@ -38,6 +38,7 @@
 #include "updater_main.h"
 #include "updater/updater_const.h"
 #include "update_bin/bin_process.h"
+#include "scope_guard.h"
 
 using namespace Uscript;
 using namespace Hpackage;
@@ -460,49 +461,47 @@ int ProcessUpdater(bool retry, int pipeFd, const std::string &packagePath, const
     UPDATER_INIT_RECORD;
     UpdaterInit::GetInstance().InvokeEvent(UPDATER_BINARY_INIT_EVENT);
     Dump::GetInstance().RegisterDump("DumpHelperLog", std::make_unique<DumpHelperLog>());
-    FILE *pipeWrite = fdopen(pipeFd, "w");
+    std::unique_ptr<FILE, decltype(&fclose)> pipeWrite(fdopen(pipeFd, "w"), fclose);
     if (pipeWrite == nullptr) {
         LOG(ERROR) << "Fail to fdopen, err: " << strerror(errno);
         UPDATER_LAST_WORD(EXIT_INVALID_ARGS);
         return EXIT_INVALID_ARGS;
     }
+    int ret = -1;
+    Detail::ScopeGuard guard([&] {
+        (void)fprintf(pipeWrite.get(), "subProcessResult:%d\n", ret);
+        (void)fflush(pipeWrite.get());
+    });
     // line buffered, make sure parent read per line.
-    setlinebuf(pipeWrite);
+    setlinebuf(pipeWrite.get());
     PkgManager::PkgManagerPtr pkgManager = PkgManager::CreatePackageInstance();
     if (pkgManager == nullptr) {
         LOG(ERROR) << "pkgManager is nullptr";
-        fclose(pipeWrite);
-        pipeWrite = nullptr;
         UPDATER_LAST_WORD(EXIT_INVALID_ARGS);
         return EXIT_INVALID_ARGS;
     }
 
     std::vector<std::string> components;
-    int32_t ret = pkgManager->LoadPackage(packagePath, keyPath, components);
+    ret = pkgManager->LoadPackage(packagePath, keyPath, components);
     if (ret != PKG_SUCCESS) {
         LOG(ERROR) << "Fail to load package";
-        fclose(pipeWrite);
-        pipeWrite = nullptr;
         PkgManager::ReleasePackageInstance(pkgManager);
         UPDATER_LAST_WORD(EXIT_INVALID_ARGS);
         return EXIT_INVALID_ARGS;
     }
 #ifdef UPDATER_USE_PTABLE
-    DevicePtable& devicePtb = DevicePtable::GetInstance();
-    devicePtb.LoadPartitionInfo();
+    DevicePtable::GetInstance().LoadPartitionInfo();
 #endif
 
     ret = Updater::ExecUpdate(pkgManager, retry, packagePath,
         [&pipeWrite](const char *cmd, const char *content) {
-            if (pipeWrite != nullptr) {
-                fprintf(pipeWrite, "%s:%s\n", cmd, content);
-                fflush(pipeWrite);
+            if (pipeWrite.get() != nullptr) {
+                (void)fprintf(pipeWrite.get(), "%s:%s\n", cmd, content);
+                (void)fflush(pipeWrite.get());
             }
         });
     PkgManager::ReleasePackageInstance(pkgManager);
 #ifndef UPDATER_UT
-    fclose(pipeWrite);
-    pipeWrite = nullptr;
     if (ret == 0) {
         SetActiveSlot();
     }
diff --git a/services/updater_main.cpp b/services/updater_main.cpp
index b0d12d7da6668b69012280e030260c24c97d1dd2..33643e2d96942d5453fa865965d1793703725638 100644
--- a/services/updater_main.cpp
+++ b/services/updater_main.cpp
@@ -126,7 +126,6 @@ static UpdaterStatus UpdatePreCheck(UpdaterParams &upParams, const std::string p
     UPDATER_INIT_RECORD;
     int32_t ret = PreProcess::GetInstance().DoUpdateAuth(pkgPath);
     if (ret != 0) {
-        UPDATER_LAST_WORD("auth", ret);
         return UPDATE_ERROR;
     }
 
@@ -199,13 +198,13 @@ static UpdaterStatus VerifyPackages(UpdaterParams &upParams)
             UPDATER_UI_INSTANCE.ShowUpdInfo(TR(UPD_VERIFYPKGFAIL), true);
             auto endTime = std::chrono::system_clock::now();
             upParams.installTime[i] = endTime - startTime;
-            UPDATER_LAST_WORD(verifyret);
             return UPDATE_CORRUPT;
         }
         auto endTime = std::chrono::system_clock::now();
         upParams.installTime[i] = endTime - startTime;
     }
     if (VerifySpecialPkgs(upParams) != PKG_SUCCESS) {
+        UPDATER_LAST_WORD(UPDATE_CORRUPT);
         return UPDATE_CORRUPT;
     }
     ProgressSmoothHandler(UPDATER_UI_INSTANCE.GetCurrentPercent(),
@@ -375,7 +374,6 @@ static UpdaterStatus PreUpdatePackages(UpdaterParams &upParams)
 
     // verify packages first
     if (VerifyPackages(upParams) != UPDATE_SUCCESS) {
-        UPDATER_LAST_WORD(UPDATE_CORRUPT);
         return UPDATE_CORRUPT; // verify package failed must return UPDATE_CORRUPT, ux need it !!!
     }
 
@@ -793,7 +791,9 @@ __attribute__((weak)) bool IsNeedWipe()
 
 void RebootAfterUpdateSuccess(const UpdaterParams &upParams)
 {
-    if (IsNeedWipe() || upParams.sdExtMode == SDCARD_UPDATE_FROM_DEV) {
+    if (IsNeedWipe() ||
+        upParams.sdExtMode == SDCARD_UPDATE_FROM_DEV ||
+        upParams.sdExtMode == SDCARD_UPDATE_FROM_DATA) {
         Utils::UpdaterDoReboot("updater", "--user_wipe_data");
         return;
     }
diff --git a/services/updater_main.h b/services/updater_main.h
index f0019166fe3a2c8e61904e321d5532a3bbcc637d..29e0e41e6bc6644d1af4adc2428f75d5b8f84481 100644
--- a/services/updater_main.h
+++ b/services/updater_main.h
@@ -26,6 +26,7 @@ enum FactoryResetMode {
     USER_WIPE_DATA = 0,
     FACTORY_WIPE_DATA,
     MENU_WIPE_DATA,
+    INVALID_MODE,
 };
 
 int UpdaterMain(int argc, char **argv);
diff --git a/services/updater_ui.cpp b/services/updater_ui.cpp
index bc0819327a708a9eb35d661f21f1d477d9aa1fc8..c1fa1cbc0b4d39644fc0c0fbdaa367d83ad06f09 100644
--- a/services/updater_ui.cpp
+++ b/services/updater_ui.cpp
@@ -108,6 +108,7 @@ DEFINE_ASYN_CALLBACK(OnLabelSDCardNoDelayEvt)
     UpdaterParams upParams;
     upParams.updateMode = SDCARD_UPDATE;
     if (auto res = UpdaterFromSdcard(upParams); res != UPDATE_SUCCESS) {
+        Utils::RemoveUpdateInfoFromMisc("sdcard_update");
         GetFacade().ShowLogRes(res == UPDATE_CORRUPT ? TR(LOGRES_VERIFY_FAILED) : TR(LOGRES_UPDATE_FAILED));
         GetFacade().ShowFailedPage();
         Utils::UsSleep(FAIL_DELAY);
diff --git a/test/fuzztest/UpdaterStartUpdaterProc_fuzzer/UpdaterStartUpdaterProc_fuzzer.cpp b/test/fuzztest/UpdaterStartUpdaterProc_fuzzer/UpdaterStartUpdaterProc_fuzzer.cpp
index d59dcd28b0b8e7d36fad9e9c714dc5d2c5a95de8..1a3120b2cf9fd97113b3f1bcfc8ae522a60ce3fa 100644
--- a/test/fuzztest/UpdaterStartUpdaterProc_fuzzer/UpdaterStartUpdaterProc_fuzzer.cpp
+++ b/test/fuzztest/UpdaterStartUpdaterProc_fuzzer/UpdaterStartUpdaterProc_fuzzer.cpp
@@ -160,14 +160,13 @@ static int StartUpdaterProcFun(const std::string &patch)
 {
     UpdaterStatus status;
     std::vector<std::string> components;
-    int maxTemperature;
     PkgManager::PkgManagerPtr pkgManager = PkgManager::CreatePackageInstance();
 
     pkgManager->LoadPackage(patch, GetTestCertName(), components);
     UpdaterParams upParams;
     upParams.updatePackage.push_back(patch);
     upParams.retryCount = 0;
-    status = StartUpdaterProc(pkgManager, upParams, maxTemperature);
+    status = StartUpdaterProc(pkgManager, upParams);
     LOG(INFO) << "[fuzz] status " << status;
     PkgManager::ReleasePackageInstance(pkgManager);
     return status;
diff --git a/test/unittest/factory_reset_test/BUILD.gn b/test/unittest/factory_reset_test/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..ea3120e981c2604fceb7067ce4119f0808e39963
--- /dev/null
+++ b/test/unittest/factory_reset_test/BUILD.gn
@@ -0,0 +1,50 @@
+# Copyright (c) 2024 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import("//base/update/updater/updater_default_cfg.gni")
+import("//build/test.gni")
+
+updater_path = rebase_path("${updater_absolutely_path}", ".")
+
+MODULE_OUTPUT_PATH = "updater/updater_test"
+
+ohos_unittest("factory_reset_unittest") {
+  defines = [ "UPDATER_UT" ]
+  testonly = true
+  module_out_path = MODULE_OUTPUT_PATH
+  sources = [
+    "${updater_path}/services/factory_reset/factory_reset.cpp",
+    "factory_reset_unittest.cpp",
+  ]
+
+  include_dirs = [
+    "${updater_path}/utils/include",
+    "${updater_path}/services",
+    "${updater_path}/services/include",
+    "${updater_path}/services/include/package",
+    "${updater_path}/services/factory_reset/",
+    "${updater_path}/interfaces/kits/include/",
+    "${updater_path}/services/common",
+  ]
+
+  deps = [
+    "${updater_path}/services/fs_manager:libfsmanager",
+    "${updater_path}/services/log:libupdaterlog",
+    "${updater_path}/utils:libutils",
+  ]
+
+  external_deps = [ "init:libbegetutil_static" ]
+  configs = [ "${updater_path}/test/unittest:utest_config" ]
+  install_enable = true
+  part_name = "updater"
+}
diff --git a/test/unittest/factory_reset_test/factory_reset_unittest.cpp b/test/unittest/factory_reset_test/factory_reset_unittest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8a00103076fe30e781a08560812b5f434415b057
--- /dev/null
+++ b/test/unittest/factory_reset_test/factory_reset_unittest.cpp
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2024-2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#define private public
+#include "factory_reset.h"
+#undef private
+
+using namespace Updater;
+using namespace testing::ext;
+
+namespace {
+class FactoryResetUnitTest : public testing::Test {
+public:
+    FactoryResetUnitTest()
+    {
+        std::cout<<"FactoryResetUnitTest()";
+    }
+    ~FactoryResetUnitTest() {}
+    FactoryResetProcess* factoryResetProcess;
+    std::unordered_map<FactoryResetMode, FactoryResetProcess::ResetFunc> resetTab_;
+    std::function<int(bool)> CommonResetPostFunc_;
+
+    static void SetUpTestCase(void) {}
+    static void TearDownTestCase(void) {}
+    void SetUp()
+    {
+        factoryResetProcess = new FactoryResetProcess();
+        factoryResetProcess->resetTab_ = resetTab_;
+        factoryResetProcess->CommonResetPostFunc_ = CommonResetPostFunc_;
+    }
+    void TearDown()
+    {
+        delete factoryResetProcess;
+        factoryResetProcess = nullptr;
+    }
+    void TestBody() {}
+};
+
+HWTEST_F(FactoryResetUnitTest, FactoryResetFunc01, TestSize.Level0)
+{
+    int ret = factoryResetProcess->GetInstance().FactoryResetFunc(FactoryResetMode::INVALID_MODE, "/data");
+    EXPECT_EQ(ret, 1);
+}
+
+HWTEST_F(FactoryResetUnitTest, FactoryResetFunc02, TestSize.Level0)
+{
+    resetTab_[FactoryResetMode::USER_WIPE_DATA] = [](const std::string &) { return 0; };
+    int ret = factoryResetProcess->GetInstance().FactoryResetFunc(FactoryResetMode::USER_WIPE_DATA, "/data");
+    EXPECT_EQ(ret, 1);
+}
+
+HWTEST_F(FactoryResetUnitTest, FactoryResetFunc03, TestSize.Level0)
+{
+    CommonResetPostFunc_ = [](bool) { return 0; };
+    resetTab_[FactoryResetMode::USER_WIPE_DATA] = [](const std::string &) { return 0; };
+    int ret = factoryResetProcess->GetInstance().FactoryResetFunc(FactoryResetMode::USER_WIPE_DATA, "/data");
+    EXPECT_EQ(ret, 1);
+}
+
+HWTEST_F(FactoryResetUnitTest, FactoryResetFunc04, TestSize.Level0)
+{
+    resetTab_[FactoryResetMode::FACTORY_WIPE_DATA] = [](const std::string &) { return 0; };
+    int ret = factoryResetProcess->GetInstance().FactoryResetFunc(FactoryResetMode::FACTORY_WIPE_DATA, "/data");
+    EXPECT_EQ(ret, 1);
+}
+
+HWTEST_F(FactoryResetUnitTest, FactoryResetFunc05, TestSize.Level0)
+{
+    CommonResetPostFunc_ = [](bool) { return 0; };
+    resetTab_[FactoryResetMode::FACTORY_WIPE_DATA] = [](const std::string &) { return 0; };
+    int ret = factoryResetProcess->GetInstance().FactoryResetFunc(FactoryResetMode::FACTORY_WIPE_DATA, "/data");
+    EXPECT_EQ(ret, 1);
+}
+
+HWTEST_F(FactoryResetUnitTest, FactoryResetFunc06, TestSize.Level0)
+{
+    resetTab_[FactoryResetMode::MENU_WIPE_DATA] = [](const std::string &) { return 0; };
+    int ret = factoryResetProcess->GetInstance().FactoryResetFunc(FactoryResetMode::MENU_WIPE_DATA, "/data");
+    EXPECT_EQ(ret, 1);
+}
+
+HWTEST_F(FactoryResetUnitTest, FactoryResetFunc07, TestSize.Level0)
+{
+    CommonResetPostFunc_ = [](bool) { return 0; };
+    resetTab_[FactoryResetMode::MENU_WIPE_DATA] = [](const std::string &) { return 0; };
+    int ret = factoryResetProcess->GetInstance().FactoryResetFunc(FactoryResetMode::MENU_WIPE_DATA, "/data");
+    EXPECT_EQ(ret, 1);
+}
+}
\ No newline at end of file
diff --git a/test/unittest/flashd_test/flashd_unittest.cpp b/test/unittest/flashd_test/flashd_unittest.cpp
index 3d46a2fda070218ce9021e3d5a71894b2454c56a..d5f92db84a2db6f3a46f2563cbecdfa1f4311cd1 100644
--- a/test/unittest/flashd_test/flashd_unittest.cpp
+++ b/test/unittest/flashd_test/flashd_unittest.cpp
@@ -249,11 +249,6 @@ std::unique_ptr<FlashdWriter> GetTestWriter()
     return std::make_unique<FlashdWriterRaw>();
 }
 
-HWTEST_F(FLashServiceUnitTest, FlashdRegisterWriter, TestSize.Level1)
-{
-    FlashdImageWriter::GetInstance().RegisterUserWriter(IsTestImg, GetTestWriter);
-}
-
 HWTEST_F(FLashServiceUnitTest, PartitionDoErase, TestSize.Level1)
 {
     std::string partitionName = "test";
diff --git a/test/unittest/script/script_unittest.h b/test/unittest/script/script_unittest.h
index 34a70a48c8d8b1740b7a812ddac5f7ec95d3e942..c5001bdf81051d960b8b95d11a7d560124c676c5 100644
--- a/test/unittest/script/script_unittest.h
+++ b/test/unittest/script/script_unittest.h
@@ -51,6 +51,10 @@ public:
     {
         return PKG_SUCCESS;
     }
+    int32_t VerifyOtaPackage(const std::string &devPath, uint64_t offset, size_t size) override
+    {
+        return PKG_SUCCESS;
+    }
     int32_t VerifyBinFile(const std::string &packagePath, const std::string &keyPath,
         const std::string &version, const PkgBuffer &digest) override
     {
diff --git a/test/unittest/service_test/updater_service_unittest.cpp b/test/unittest/service_test/updater_service_unittest.cpp
index 9921041470cc7d7785b9f658643a90577bbe8d2b..5b868efc7e12d686ec58ea46536187226c5ae2fc 100644
--- a/test/unittest/service_test/updater_service_unittest.cpp
+++ b/test/unittest/service_test/updater_service_unittest.cpp
@@ -316,9 +316,8 @@ HWTEST_F(UpdaterUtilUnitTest, StartUpdaterProcTest, TestSize.Level1)
 {
     Hpackage::PkgManager::PkgManagerPtr pkgManager = Hpackage::PkgManager::CreatePackageInstance();
     UpdaterParams upParams;
-    int maxTemperature = 0;
-    EXPECT_EQ(StartUpdaterProc(nullptr, upParams, maxTemperature), UPDATE_CORRUPT);
-    EXPECT_EQ(StartUpdaterProc(pkgManager, upParams, maxTemperature), UPDATE_ERROR);
+    EXPECT_EQ(StartUpdaterProc(nullptr, upParams), UPDATE_CORRUPT);
+    EXPECT_EQ(StartUpdaterProc(pkgManager, upParams), UPDATE_ERROR);
 }
 
 HWTEST_F(UpdaterUtilUnitTest, CheckPathNeedMountSD, TestSize.Level0)
@@ -333,4 +332,4 @@ HWTEST_F(UpdaterUtilUnitTest, CheckPathNeedMountSD, TestSize.Level0)
     upParams.updatePackage.push_back("/data/sdcard/updater_full.zip");
     EXPECT_EQ(CheckPathNeedMountSD(upParams), false);
 }
-}
\ No newline at end of file
+}
diff --git a/test/unittest/test_data/ohos_test.xml b/test/unittest/test_data/ohos_test.xml
index 9389c6f674117588ed65a57310907d9d999d956a..65bfbb0db66fb398b44c0f795a21ced6cc28d2b0 100644
--- a/test/unittest/test_data/ohos_test.xml
+++ b/test/unittest/test_data/ohos_test.xml
@@ -203,6 +203,8 @@
             <!-- strategy test -->
             <option name="push" value="ui/strategy/strategy_valid.json -> /data/updater/ui/strategy" src="res"/>
             <option name="push" value="ui/strategy/strategy_invalid.json -> /data/updater/ui/strategy" src="res"/>
+            <option name="push" value="ui/brightness -> /data/updater/ui" src="res"/>
+            <option name="push" value="ui/max_brightness -> /data/updater/ui" src="res"/>
         </preparer>
     </target>
     <target name="flashd_unittest">
diff --git a/test/unittest/test_data/ui/brightness b/test/unittest/test_data/ui/brightness
new file mode 100644
index 0000000000000000000000000000000000000000..52f6c1a7a0e6648b65c77f6cfff32f6b5034ee55
--- /dev/null
+++ b/test/unittest/test_data/ui/brightness
@@ -0,0 +1 @@
+352
\ No newline at end of file
diff --git a/test/unittest/test_data/ui/max_brightness b/test/unittest/test_data/ui/max_brightness
new file mode 100644
index 0000000000000000000000000000000000000000..1746da63124a680dfc544151e3159f323c060489
--- /dev/null
+++ b/test/unittest/test_data/ui/max_brightness
@@ -0,0 +1 @@
+10000
\ No newline at end of file
diff --git a/test/unittest/updater_binary/BUILD.gn b/test/unittest/updater_binary/BUILD.gn
index afeb7670d561166395a9956a1514ad7e81ce970e..443aa6506098d9cf651b1fe818b02949d18b5cee 100644
--- a/test/unittest/updater_binary/BUILD.gn
+++ b/test/unittest/updater_binary/BUILD.gn
@@ -25,7 +25,6 @@ ohos_unittest("binary_unittest") {
     "update_image_patch_unittest.cpp",
     "update_partitions_unittest.cpp",
     "update_processor_unittest.cpp",
-    "updater_binary_unittest.cpp",
   ]
 
   sources += [
diff --git a/test/unittest/updater_binary/update_image_block_test.cpp b/test/unittest/updater_binary/update_image_block_test.cpp
index f7fb622675407208fca9cd1c596fd0dcdd38a7c9..b00ac8c1fe6a8de55a2773b90a752904acb9257e 100755
--- a/test/unittest/updater_binary/update_image_block_test.cpp
+++ b/test/unittest/updater_binary/update_image_block_test.cpp
@@ -38,7 +38,7 @@
 #include "update_processor.h"
 #include "utils.h"
 
-using namespace Updater;
+using namespace Updater;
 using namespace testing::ext;
 using namespace Uscript;
 using namespace std;
@@ -61,7 +61,10 @@ void UpdateImageBlockTest::TearDown()
 HWTEST_F(UpdateImageBlockTest, update_image_block_test_001, TestSize.Level1)
 {
     const string packagePath = "/data/updater/updater/updater_write_miscblock_img.zip";
+    int fd = open("/dev/null", O_RDWR);
+    dup2(fd, STDOUT_FILENO);
     int32_t ret = ProcessUpdater(false, STDOUT_FILENO, packagePath, GetTestCertName());
+    close(fd);
     EXPECT_EQ(ret, 0);
 }
 
@@ -69,7 +72,10 @@ HWTEST_F(UpdateImageBlockTest, update_image_block_test_001, TestSize.Level1)
 HWTEST_F(UpdateImageBlockTest, update_image_block_test_002, TestSize.Level1)
 {
     const string packagePath = "/data/updater/updater/updater_write_diff_miscblock_img.zip";
+    int fd = open("/dev/null", O_RDWR);
+    dup2(fd, STDOUT_FILENO);
     int32_t ret = ProcessUpdater(false, STDOUT_FILENO, packagePath, GetTestCertName());
+    close(fd);
     EXPECT_EQ(ret, 0);
 }
 
@@ -77,7 +83,10 @@ HWTEST_F(UpdateImageBlockTest, update_image_block_test_002, TestSize.Level1)
 HWTEST_F(UpdateImageBlockTest, update_image_block_test_003, TestSize.Level1)
 {
     const string packagePath = "/data/updater/updater/updater_write_diff_miscblock_img.zip";
+    int fd = open("/dev/null", O_RDWR);
+    dup2(fd, STDOUT_FILENO);
     int32_t ret = ProcessUpdater(false, STDOUT_FILENO, packagePath, GetTestCertName());
+    close(fd);
     EXPECT_EQ(ret, USCRIPT_INVALID_PARAM);
 }
 }
diff --git a/test/unittest/updater_binary/update_partitions_unittest.cpp b/test/unittest/updater_binary/update_partitions_unittest.cpp
index 335dc23043904939fa7ab88bf8a1294378b1a6d4..157c727c0beb0dcce14e718fc8d9df8326acbcc2 100755
--- a/test/unittest/updater_binary/update_partitions_unittest.cpp
+++ b/test/unittest/updater_binary/update_partitions_unittest.cpp
@@ -97,6 +97,6 @@ HWTEST_F(UpdatePartitionsUnitTest, UpdatePartitions_Unitest02, TestSize.Level1)
     delete env;
     ScriptManager::ReleaseScriptManager();
     PkgManager::ReleasePackageInstance(pkgManager);
-    EXPECT_EQ(partRet, USCRIPT_ERROR_EXECUTE);
+    EXPECT_EQ(partRet, USCRIPT_SUCCESS);
 }
 } // namespace updater_ut
diff --git a/test/unittest/updater_binary/update_processor_unittest.cpp b/test/unittest/updater_binary/update_processor_unittest.cpp
index 8e79bd7549f3f3b503567294701067d61d4a5f3e..39cb050e9f7330a461f6cedf8768daa4188c1224 100755
--- a/test/unittest/updater_binary/update_processor_unittest.cpp
+++ b/test/unittest/updater_binary/update_processor_unittest.cpp
@@ -72,7 +72,10 @@ void UpdateProcessorUnitTest::TearDownTestCase(void) {}
 HWTEST_F(UpdateProcessorUnitTest, UpdateProcessor_001, TestSize.Level1)
 {
     const string packagePath = "/data/updater/updater/updater_write_misc_img.zip";
+    int fd = open("/dev/null", O_RDWR);
+    dup2(fd, STDOUT_FILENO);
     int32_t ret = ProcessUpdater(false, STDOUT_FILENO, packagePath, GetTestCertName());
+    close(fd);
     EXPECT_EQ(ret, 0);
 }
 
@@ -85,7 +88,10 @@ HWTEST_F(UpdateProcessorUnitTest, UpdateProcessor_002, TestSize.Level1)
     EXPECT_EQ(ret, 0);
 
     const string packagePath = "/data/updater/updater/updater_write_diff_misc_img.zip";
+    int fd = open("/dev/null", O_RDWR);
+    dup2(fd, STDOUT_FILENO);
     ret = ProcessUpdater(false, STDOUT_FILENO, packagePath, GetTestCertName());
+    close(fd);
     EXPECT_EQ(ret, 0);
 }
 
@@ -98,7 +104,10 @@ HWTEST_F(UpdateProcessorUnitTest, UpdateProcessor_003, TestSize.Level1)
     EXPECT_EQ(ret, 0);
 
     const string packagePath = "/data/updater/updater/updater_write_diff_misc_img.zip";
+    int fd = open("/dev/null", O_RDWR);
+    dup2(fd, STDOUT_FILENO);
     ret = ProcessUpdater(false, STDOUT_FILENO, packagePath, GetTestCertName());
+    close(fd);
     EXPECT_EQ(ret, USCRIPT_INVALID_PARAM);
 }
 
diff --git a/test/unittest/updater_test/updater_unittest.cpp b/test/unittest/updater_test/updater_unittest.cpp
index 9e8f0c5e2f4bdbd36a186857054ef4bf48c76246..20ddcd35b581c7f23aa17fc265fa2d8deefe568b 100755
--- a/test/unittest/updater_test/updater_unittest.cpp
+++ b/test/unittest/updater_test/updater_unittest.cpp
@@ -71,28 +71,27 @@ HWTEST_F(UpdaterUnitTest, updater_StartUpdaterProc, TestSize.Level1)
 {
     std::string packagePath = "/data/updater/updater/updater_without_updater_binary.zip";
     PkgManager::PkgManagerPtr pkgManager = PkgManager::CreatePackageInstance();
-    int maxTemperature;
     UpdaterStatus status;
-    status = StartUpdaterProc(pkgManager, packagePath, 0, maxTemperature);
+    status = StartUpdaterProc(pkgManager, packagePath, 0);
     EXPECT_EQ(status, UPDATE_CORRUPT);
 
     packagePath = "/data/updater/updater/updater_with_incorrect_binary.zip";
-    status = StartUpdaterProc(pkgManager, packagePath, 0, maxTemperature);
+    status = StartUpdaterProc(pkgManager, packagePath, 0);
     EXPECT_EQ(status, UPDATE_CORRUPT);
 
     packagePath = "/data/updater/updater/updater.zip";
     std::vector<std::string> components;
     int32_t ret = pkgManager->LoadPackage(packagePath, GetTestCertName(), components);
     EXPECT_EQ(ret, 0);
-    status = StartUpdaterProc(pkgManager, packagePath, 0, maxTemperature);
+    status = StartUpdaterProc(pkgManager, packagePath, 0);
     EXPECT_EQ(status, UPDATE_SUCCESS);
 
     // retrycount is greater than 0.
-    status = StartUpdaterProc(pkgManager, packagePath, 1, maxTemperature);
+    status = StartUpdaterProc(pkgManager, packagePath, 1);
     EXPECT_EQ(status, UPDATE_RETRY);
 
     packagePath = "/data/updater/updater/updater_binary_abnormal.zip";
-    status = StartUpdaterProc(pkgManager, packagePath, 1, maxTemperature);
+    status = StartUpdaterProc(pkgManager, packagePath, 1);
     PkgManager::ReleasePackageInstance(pkgManager);
     EXPECT_EQ(status, UPDATE_ERROR);
 }
diff --git a/test/unittest/updater_ui_test/BUILD.gn b/test/unittest/updater_ui_test/BUILD.gn
index 1471027fa2639ba4f63605636091912293d865c7..559ed68f6d3f80fbec1920952cacbe8152978d17 100644
--- a/test/unittest/updater_ui_test/BUILD.gn
+++ b/test/unittest/updater_ui_test/BUILD.gn
@@ -32,6 +32,7 @@ ohos_unittest("ui_unittest") {
     "ENABLE_VECTOR_FONT = 1",
   ]
   sources = [
+    "control/ui_control_unittest.cpp",
     "driver/fbdev_driver_unittest.cpp",
     "driver/keys_input_device_unittest.cpp",
     "driver/pointers_input_device_unittest.cpp",
@@ -46,6 +47,7 @@ ohos_unittest("ui_unittest") {
     "view/ui_view_proxy_unittest.cpp",
   ]
   sources += [
+    "${updater_path}/services/ui/control/event_listener.cpp",
     "${updater_path}/services/ui/driver/drm_driver.cpp",
     "${updater_path}/services/ui/driver/fbdev_driver.cpp",
     "${updater_path}/services/ui/driver/graphic_engine.cpp",
diff --git a/test/unittest/updater_ui_test/control/ui_control_unittest.cpp b/test/unittest/updater_ui_test/control/ui_control_unittest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f57a51d4ff0fd62744088de249298756b1cd6a9c
--- /dev/null
+++ b/test/unittest/updater_ui_test/control/ui_control_unittest.cpp
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "gtest/gtest.h"
+#include "event_listener.h"
+#include <linux/input.h>
+#include "dock/input_device.h"
+
+using namespace testing::ext;
+using namespace Updater;
+
+namespace {
+class UpdaterUiControlUnittest : public testing::Test {
+public:
+    KeyListener *keyListener;
+    OHOS::UIView *view;
+
+    static void SetUpTestCase(void) {}
+    static void TearDownTestCase(void) {}
+    void SetUp() override
+    {
+        keyListener = new KeyListener();
+        view = new OHOS::UIView();
+    }
+    void TearDown() override
+    {
+        delete keyListener;
+        keyListener = nullptr;
+        delete view;
+        view = nullptr;
+    }
+};
+
+HWTEST_F(UpdaterUiControlUnittest, OnKeyAct01, TestSize.Level0)
+{
+    OHOS::KeyEvent *event = new OHOS::KeyEvent(KEY_POWER, OHOS::InputDevice::STATE_PRESS);
+    bool ret = keyListener->OnKeyAct(*view, *event);
+    EXPECT_EQ(ret, true);
+    if (event != nullptr) {
+        delete event;
+        event = nullptr;
+    }
+}
+
+HWTEST_F(UpdaterUiControlUnittest, OnKeyAct02, TestSize.Level0)
+{
+    OHOS::KeyEvent *event = new OHOS::KeyEvent(KEY_VOLUMEUP, OHOS::InputDevice::STATE_PRESS);
+    bool ret = keyListener->OnKeyAct(*view, *event);
+    EXPECT_EQ(ret, true);
+    if (event != nullptr) {
+        delete event;
+        event = nullptr;
+    }
+}
+
+HWTEST_F(UpdaterUiControlUnittest, OnKeyAct03, TestSize.Level0)
+{
+    OHOS::KeyEvent *event = new OHOS::KeyEvent(KEY_VOLUMEDOWN, OHOS::InputDevice::STATE_PRESS);
+    bool ret = keyListener->OnKeyAct(*view, *event);
+    EXPECT_EQ(ret, true);
+    if (event != nullptr) {
+        delete event;
+        event = nullptr;
+    }
+}
+
+HWTEST_F(UpdaterUiControlUnittest, OnKeyAct04, TestSize.Level0)
+{
+    OHOS::KeyEvent *event = new OHOS::KeyEvent(100, OHOS::InputDevice::STATE_PRESS);
+    bool ret = keyListener->OnKeyAct(*view, *event);
+    EXPECT_EQ(ret, false);
+    if (event != nullptr) {
+        delete event;
+        event = nullptr;
+    }
+}
+}
\ No newline at end of file
diff --git a/test/unittest/updater_ui_test/updater_ui_env_unittest.cpp b/test/unittest/updater_ui_test/updater_ui_env_unittest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d1800186bae597f37da9ba8d24b527d548914f62
--- /dev/null
+++ b/test/unittest/updater_ui_test/updater_ui_env_unittest.cpp
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "gtest/gtest.h"
+#include "updater_ui_env.h"
+#include <unistd.h>
+#include "callback_manager.h"
+#include "common/graphic_startup.h"
+#include "common/screen.h"
+#include "components/root_view.h"
+#include "graphic_engine.h"
+#include "input_event.h"
+#include "language/language_ui.h"
+#include "log/log.h"
+#include "page/page_manager.h"
+#include "updater_ui_config.h"
+
+using namespace testing::ext;
+using namespace Updater;
+
+namespace UpdaterUt {
+class UpdaterUiEnvUnitTest : public testing::Test {
+public:
+    static void SetUpTestCase(void) {}
+    static void TearDownTestCase(void) {}
+    void SetUp() override {}
+    void TearDown() override {}
+};
+
+constexpr std::pair MY_BRIGHTNESS_FILE =
+    std::pair { "/data/updater/ui/brightness", "/data/updater/ui/max_brightness" };
+
+HWTEST_F(UpdaterUiEnvUnitTest, test_updater_ui_env_bright_init, TestSize.Level0)
+{
+    EXPECT_FALSE(UpdaterUiEnv::InitBrightness("/fakebrightness", "/fakemaxbrightness"));
+    EXPECT_FALSE(UpdaterUiEnv::InitBrightness(MY_BRIGHTNESS_FILE.first, "/fakemaxbrightness"));
+    EXPECT_TRUE(UpdaterUiEnv::InitBrightness(MY_BRIGHTNESS_FILE.first, MY_BRIGHTNESS_FILE.second));
+}
+}
\ No newline at end of file
diff --git a/test/unittest/updater_ui_test/updater_ui_facade_unittest.cpp b/test/unittest/updater_ui_test/updater_ui_facade_unittest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..69dc7a48718295c4b29caaec42911e72dd06216c
--- /dev/null
+++ b/test/unittest/updater_ui_test/updater_ui_facade_unittest.cpp
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "gtest/gtest.h"
+#include <thread>
+#include "component/text_label_adapter.h"
+#include "updater_event.h"
+#include "updater_ui_config.h"
+#include "updater_ui_env.h"
+#include "updater_ui_tools.h"
+
+using namespace testing::ext;
+using namespace Updater;
+
+#define UPDATER_UI_INSTANCE UpdaterUiFacade::GetInstance()
+
+namespace UpdaterUt {
+class UpdaterUiFacadeUnitTest : public testing::Test {
+public:
+    static void SetUpTestCase(void) {}
+    static void TearDownTestCase(void) {}
+    void SetUp() override {}
+    void TearDown() override {}
+};
+
+HWTEST_F(UpdaterUiFacadeUnitTest, test_updater_ui_facade_set_mode, Test.Level0)
+{
+    std::string mode = "abc";
+    EXPECT_TRUE(UPDATER_UI_INSTANCE.SetMode(""));
+    EXPECT_TRUE(UPDATER_UI_INSTANCE.SetMode(mode));
+    EXPECT_EQ(UPDATER_UI_INSTANCE.GetMode(), mode);
+}
+
+HWTEST_F(UpdaterUiFacadeUnitTest, test_updater_ui_facade_show_funcs, Test.Level0)
+{
+    std::string log = "log";
+    UPDATER_UI_INSTANCE.ShowLog(log);
+    UPDATER_UI_INSTANCE.ShowLogRes(log);
+    UPDATER_UI_INSTANCE.ShowUpdInfo(log);
+    UPDATER_UI_INSTANCE.ClearText();
+    UPDATER_UI_INSTANCE.ClearLog();
+    UPDATER_UI_INSTANCE.ShowProgress(0.0);
+    UPDATER_UI_INSTANCE.ShowProgressPage();
+    UPDATER_UI_INSTANCE.ShowSuccessPage();
+    UPDATER_UI_INSTANCE.ShowFailedPage();
+    UPDATER_UI_INSTANCE.ShowFactoryConfirmPage();
+    UPDATER_UI_INSTANCE.ShowMainpage();
+    UPDATER_UI_INSTANCE.ShowProgressWarning(false);
+    EXPECT_FALSE(UPDATER_UI_INSTANCE.IsInProgress());
+    EXPECT_TRUE(UPDATER_UI_INSTANCE.SetMode("ota"));
+    UPDATER_UI_INSTANCE.ShowLog(log);
+    UPDATER_UI_INSTANCE.ShowLog(log, true);
+    UPDATER_UI_INSTANCE.ShowLogRes(log);
+    UPDATER_UI_INSTANCE.ShowUpdInfo(log);
+    UPDATER_UI_INSTANCE.ClearText();
+    UPDATER_UI_INSTANCE.ClearLog();
+    UPDATER_UI_INSTANCE.ShowProgress(0.0);
+    UPDATER_UI_INSTANCE.ShowProgressPage();
+    UPDATER_UI_INSTANCE.ShowSuccessPage();
+    UPDATER_UI_INSTANCE.ShowFailedPage();
+    UPDATER_UI_INSTANCE.ShowFactoryConfirmPage();
+    UPDATER_UI_INSTANCE.ShowMainpage();
+    UPDATER_UI_INSTANCE.ShowProgressWarning(false);
+    EXPECT_TRUE(UPDATER_UI_INSTANCE.IsInProgress());
+}
+}
\ No newline at end of file
diff --git a/utils/include/utils.h b/utils/include/utils.h
index 4de915bf0ac9f4be1a1d0278e508e5f4e1519eed..73c656f7903a87192c332d109e8534581fc3c839 100644
--- a/utils/include/utils.h
+++ b/utils/include/utils.h
@@ -40,6 +40,8 @@ constexpr const char* ON_SERVER = "ON_SERVER";
 template<class T>
 T String2Int(const std::string &str, int base = N_HEX)
 {
+    static_assert(std::is_same_v<T, int> || std::is_same_v<T, size_t> || std::is_same_v<T, unsigned long long int>,
+                  "type should be int or size_t or unsigned long long int");
     char *end = nullptr;
     if (str.empty()) {
         errno = EINVAL;
@@ -48,7 +50,14 @@ T String2Int(const std::string &str, int base = N_HEX)
     if (((str[0] == '0') && (str[1] == 'x')) || (str[1] == 'X')) {
         base = N_HEX;
     }
-    T result = strtoull(str.c_str(), &end, base);
+    T result = 0;
+    if constexpr (std::is_same_v<T, int>) {
+        result = strtol(str.c_str(), &end, base);
+    } else if constexpr (std::is_same_v<T, size_t> || std::is_same_v<T, unsigned long long int>) {
+        result = strtoull(str.c_str(), &end, base);
+    } else {
+        errno = EINVAL;
+    }
     return result;
 }
 int32_t DeleteFile(const std::string& filename);
@@ -65,6 +74,7 @@ bool CopyFile(const std::string &src, const std::string &dest, bool isAppend = f
 bool WriteStringToFile(int fd, const std::string& content);
 std::string GetLocalBoardId();
 bool CopyUpdaterLogs(const std::string &sLog, const std::string &dLog);
+void CompressFiles(std::vector<std::string> &files, const std::string &zipFile);
 void CompressLogs(const std::string &name);
 bool CheckResultFail();
 void WriteDumpResult(const std::string &result, const std::string &fileName);
diff --git a/utils/utils.cpp b/utils/utils.cpp
index e5b50430d56939ee6af6c6d4417cf434c7110a17..d92124aaa711af9a2e5c980c5aed6c2ad36ee87b 100644
--- a/utils/utils.cpp
+++ b/utils/utils.cpp
@@ -290,12 +290,14 @@ bool WriteFully(int fd, const uint8_t *data, size_t size)
         do {
             written = write(fd, data, rest);
         } while (written < 0 && errno == EINTR);
-
         if (written < 0) {
             return false;
         }
         data += written;
         rest -= static_cast<size_t>(written);
+        if (rest != 0) {
+            LOG(INFO) << "totalSize =  " << size << ", rest =  " << rest;
+        }
     }
     return true;
 }
@@ -413,6 +415,29 @@ int32_t CreateCompressLogFile(const std::string &pkgName, std::vector<std::pair<
     return ret;
 }
 
+void CompressFiles(std::vector<std::string> &files, const std::string &zipFile)
+{
+    (void)DeleteFile(zipFile);
+    std::vector<std::pair<std::string, ZipFileInfo>> zipFiles {};
+    for (auto path : files) {
+        ZipFileInfo file {};
+        file.fileInfo.identity = path.substr(path.find_last_of("/") + 1);
+        file.fileInfo.packMethod = PKG_COMPRESS_METHOD_ZIP;
+        file.fileInfo.digestMethod = PKG_DIGEST_TYPE_CRC;
+        zipFiles.push_back(std::pair<std::string, ZipFileInfo>(path, file));
+    }
+
+    int32_t ret = CreateCompressLogFile(zipFile, zipFiles);
+    if (ret != 0) {
+        LOG(WARNING) << "CompressFiles failed: " << zipFile;
+        return;
+    }
+    mode_t mode = 0660;
+#ifndef __WIN32
+    SetFileAttributes(zipFile, USER_UPDATE_AUTHORITY, GROUP_SYS_AUTHORITY, mode);
+#endif
+}
+
 void CompressLogs(const std::string &logName)
 {
     std::vector<std::pair<std::string, ZipFileInfo>> files;