diff --git a/BUILD.gn b/BUILD.gn
index 884e744a09f7f85e7d3e2a85a40cfc2b5cc7f9ff..961577316ca7b14e1fff6de4e70a18c5e2adfeb6 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -233,6 +233,7 @@ ohos_shared_library("usagestatservice") {
     "services/common/src/bundle_active_continuous_task_observer.cpp",
     "services/common/src/bundle_active_core.cpp",
     "services/common/src/bundle_active_debug_mode.cpp",
+    "services/common/src/bundle_active_event_reporter.cpp",
     "services/common/src/bundle_active_open_callback.cpp",
     "services/common/src/bundle_active_power_state_callback_service.cpp",
     "services/common/src/bundle_active_service.cpp",
@@ -314,6 +315,7 @@ ohos_static_library("usagestatservice_static") {
     "services/common/src/bundle_active_continuous_task_observer.cpp",
     "services/common/src/bundle_active_core.cpp",
     "services/common/src/bundle_active_debug_mode.cpp",
+    "services/common/src/bundle_active_event_reporter.cpp",
     "services/common/src/bundle_active_open_callback.cpp",
     "services/common/src/bundle_active_power_state_callback_service.cpp",
     "services/common/src/bundle_active_service.cpp",
diff --git a/services/common/include/bundle_active_config_reader.h b/services/common/include/bundle_active_config_reader.h
index a320202146096c69b6ea50461590daae8bd44da0..23dc226de56d15afe1dbd359bf364b28852fbd49 100644
--- a/services/common/include/bundle_active_config_reader.h
+++ b/services/common/include/bundle_active_config_reader.h
@@ -29,11 +29,14 @@ class BundleActiveConfigReader {
 public:
     void LoadConfig();
     AppUsePeriodicallyConfig GetApplicationUsePeriodicallyConfig();
+    uint64_t GetMaxDataSize();
 private:
     void LoadApplicationUsePeriodically(const char* path);
     bool GetJsonFromFile(const char* filePath, cJSON *&root);
     bool ConvertFullPath(const std::string& partialPath, std::string& fullPath);
+    void LoadMaxDataSize(const char *filePath);
     AppUsePeriodicallyConfig appUsePeriodicallyConfig_;
+    uint64_t maxDataSize_ = 0;
 };
 
 }  // namespace DeviceUsageStats
diff --git a/services/common/include/bundle_active_constant.h b/services/common/include/bundle_active_constant.h
index 6276a4d4ed202d83e7669e0914b6c40deb4fdd98..b26848d38e4088d3ff140cfcabe43f8d3b321b7f 100644
--- a/services/common/include/bundle_active_constant.h
+++ b/services/common/include/bundle_active_constant.h
@@ -80,6 +80,7 @@ const int32_t FORM_LAST_TIME_COLUMN_INDEX = 7;
 const int32_t FORM_UID_COLUMN_INDEX = 8;
 const int32_t QUERY_CONDITION_VALID = 0;
 const int32_t QUERY_CONDITION_INVALID = -1;
+const int32_t DEFAULT_DELETE_EVENT_DALIYS = 0;
 const uint32_t BUNDLE_ACTIVE_DB_NAME_MAX_LENGTH = 100;
 const int64_t TWO_SECONDS = 2 * 1000LL;
 const int64_t TEN_MINUTES = 10 * 60 * 1000LL;
diff --git a/services/common/include/bundle_active_core.h b/services/common/include/bundle_active_core.h
index 3c5f46a3690e784082b31f1db04f81a352ae66fa..64bbe3d4b273ff57969f7d1dc690e341cf57ca86 100644
--- a/services/common/include/bundle_active_core.h
+++ b/services/common/include/bundle_active_core.h
@@ -249,11 +249,15 @@ private:
     void OnObserverDiedInner(const wptr<IRemoteObject> &remote);
     void AddbundleUninstalledUid(const int32_t uid);
     void DelayRemoveBundleUninstalledUid(const int32_t uid);
+    bool IsUserSpaceMemoryLimit();
+    void ProcessDataSize();
+    bool IsFolderSizeLimit();
+    void DeleteExcessiveTableData();
     int64_t flushInterval_;
     static const int64_t TIME_CHANGE_THRESHOLD_MILLIS = TEN_MINUTES;
     const int32_t DEFAULT_USER_ID = -1;
     std::map<int32_t, std::string> visibleActivities_;
-
+    double percentUserSpaceLimit_ = 0;
     int64_t systemTimeShot_;
     int64_t realTimeShot_;
     ffrt::mutex mutex_;
diff --git a/services/common/include/bundle_active_event_reporter.h b/services/common/include/bundle_active_event_reporter.h
new file mode 100644
index 0000000000000000000000000000000000000000..75217d91ac1adc1394c8284865196143c2ee447d
--- /dev/null
+++ b/services/common/include/bundle_active_event_reporter.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2025 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.
+ */
+
+#ifndef BUNDLE_ACTIVE_EVENT_REPORTER_H
+#define BUNDLE_ACTIVE_EVENT_REPORTER_H
+
+#include <string>
+#include <unistd.h>
+#include <unordered_set>
+#include <vector>
+
+#include "ffrt.h"
+#include "single_instance.h"
+
+namespace OHOS {
+namespace DeviceUsageStats {
+class BundleActiveEventReporter {
+    DECLARE_SINGLE_INSTANCE(BundleActiveEventReporter);
+public:
+    
+    /**
+    * @brief report file size event,the files must in path '/data'.
+    *
+    */
+    void ReportFileSizeEvent();
+private:
+    void SubmitDelayTask(int64_t delayTime);
+    void ReportFileSizeDaily();
+    void ReportFileSizeInner();
+
+    std::unordered_set<std::string> allFilePaths_;
+    ffrt::mutex mutex_;
+    bool isTaskSubmit_ = false;
+    std::string fileSizeRecorderName_;
+    int64_t lastReportTime_ = -1;
+};
+} // namespace DeviceUsageStats
+} // namespace OHOS
+
+#endif // BUNDLE_ACTIVE_EVENT_REPORTER_H
\ No newline at end of file
diff --git a/services/common/include/bundle_active_usage_database.h b/services/common/include/bundle_active_usage_database.h
index b1439717c7fcd17d763beccf03ff02c69694ff97..b0f429f01fdc8735a24fa1109d602b127eebdaf6 100644
--- a/services/common/include/bundle_active_usage_database.h
+++ b/services/common/include/bundle_active_usage_database.h
@@ -80,6 +80,7 @@ public:
         std::map<std::string, BundleActiveEventStats>& eventStats, int32_t userId);
     void QueryNotificationEventStats(int32_t eventId, int64_t beginTime, int64_t endTime,
         std::map<std::string, BundleActiveEventStats>& notificationEventStats, int32_t userId);
+    void DeleteExcessiveEventTableData(int32_t deleteDays);
 
 private:
     void CheckDatabaseVersion();
diff --git a/services/common/src/bundle_active_config_reader.cpp b/services/common/src/bundle_active_config_reader.cpp
index fe13125f54cd97647ff4c19b7af9ab8320a81521..16777ef32468f21aad129561fa9441172bc7686b 100644
--- a/services/common/src/bundle_active_config_reader.cpp
+++ b/services/common/src/bundle_active_config_reader.cpp
@@ -26,10 +26,12 @@ const static char* APPLICATION_USE_PERIODICALLY_KEY = "application_use_periodica
 const static char* MIN_USE_TIMES = "MinUseTimes";
 const static char* MAX_USE_TIMES = "MaxUseTimes";
 const static char* MIN_USE_DAYS = "MinUseDays";
+const static char* MAX_DATA_SIZE = "MaxDataSize";
 const int32_t DEFAULT_MIN_USE_TIMES = 1;
 const int32_t DEFAULT_MAX_USE_TIMES = 10;
 const int32_t DEFAULT_MIN_USE_DAYS = 3;
 const int32_t MAX_BUFFER = 2048;
+const uint64_t DEFAULT_MAX_DATA_SIZE = 5 * 1024 * 1024;
 
 
 void BundleActiveConfigReader::LoadConfig()
@@ -42,10 +44,12 @@ void BundleActiveConfigReader::LoadConfig()
     }
     for (const auto& filePath : cfgFiles->paths) {
         LoadApplicationUsePeriodically(filePath);
+        LoadMaxDataSize(filePath);
     }
     BUNDLE_ACTIVE_LOGI("appUsePeriodicallyConfig minUseTimes:%{public}d, maxUseTimes:%{public}d,"
-        "minUseDays:%{public}d", appUsePeriodicallyConfig_.minUseTimes,
-        appUsePeriodicallyConfig_.maxUseTimes, appUsePeriodicallyConfig_.minUseDays);
+        "minUseDays:%{public}d maxDataSize:%{public}lu", appUsePeriodicallyConfig_.minUseTimes,
+        appUsePeriodicallyConfig_.maxUseTimes, appUsePeriodicallyConfig_.minUseDays,
+        static_cast<unsigned long>(maxDataSize_));
     FreeCfgFiles(cfgFiles);
 };
 
@@ -132,5 +136,33 @@ AppUsePeriodicallyConfig BundleActiveConfigReader::GetApplicationUsePeriodically
     return appUsePeriodicallyConfig_;
 };
 
+void BundleActiveConfigReader::LoadMaxDataSize(const char *filePath)
+{
+    if (!filePath) {
+        return;
+    }
+    cJSON *root = nullptr;
+    if (!GetJsonFromFile(filePath, root) || !root) {
+        BUNDLE_ACTIVE_LOGE("file is empty %{private}s", filePath);
+        return;
+    }
+    cJSON *maxDataSizeItem = cJSON_GetObjectItem(root, MAX_DATA_SIZE);
+    if (!maxDataSizeItem || !cJSON_IsNumber(maxDataSizeItem)) {
+        BUNDLE_ACTIVE_LOGE("not have max data size key");
+        cJSON_Delete(root);
+        return;
+    }
+    maxDataSize_ = static_cast<uint64_t>(maxDataSizeItem->valueint);
+    cJSON_Delete(root);
+};
+
+uint64_t BundleActiveConfigReader::GetMaxDataSize()
+{
+    if (maxDataSize_ == 0) {
+        return DEFAULT_MAX_DATA_SIZE;
+    }
+    return maxDataSize_;
+};
+
 }  // namespace DeviceUsageStats
 }  // namespace OHOS
\ No newline at end of file
diff --git a/services/common/src/bundle_active_core.cpp b/services/common/src/bundle_active_core.cpp
index b04f42a21cf17b8c667d33ce783f0b2ca391807a..e31432ea25d5aa605e5c718cfba77a3d5837ccd4 100644
--- a/services/common/src/bundle_active_core.cpp
+++ b/services/common/src/bundle_active_core.cpp
@@ -28,6 +28,7 @@
 #include "bundle_constants.h"
 #include "hisysevent.h"
 #include "bundle_active_report_controller.h"
+#include "bundle_active_event_reporter.h"
 
 namespace OHOS {
 namespace DeviceUsageStats {
@@ -36,7 +37,11 @@ const int32_t DEFAULT_OS_ACCOUNT_ID = 0; // 0 is the default id when there is no
 #endif // OS_ACCOUNT_PART_ENABLED
 constexpr int32_t BUNDLE_UNINSTALL_DELAY_TIME = 5 * 1000 * 1000;
 constexpr int32_t MIN_USER_ID = -1;
+constexpr int32_t MAX_DELETE_EVENT_DALIYS = 6;
+constexpr double DEFAULT_PERCENT_USER_SPACE_LIMIT = 0.1;
 static constexpr char RSS[] = "RSS";
+static constexpr char FILEMANAGEMENT[] = "FILEMANAGEMENT";
+static constexpr char DATA_PATH[] = "/data";
 
 BundleActiveReportHandlerObject::BundleActiveReportHandlerObject()
 {
@@ -71,6 +76,7 @@ BundleActiveCore::BundleActiveCore()
         flushInterval_ = THIRTY_MINUTE;
         debugCore_ = false;
     }
+    percentUserSpaceLimit_ = DEFAULT_PERCENT_USER_SPACE_LIMIT;
 }
 
 BundleActiveCore::~BundleActiveCore()
@@ -254,6 +260,7 @@ void BundleActiveCore::Init()
     BUNDLE_ACTIVE_LOGD("system time shot is %{public}lld", (long long)systemTimeShot_);
     bundleActiveConfigReader_ = std::make_shared<BundleActiveConfigReader>();
     bundleActiveConfigReader_->LoadConfig();
+    BundleActiveEventReporter::GetInstance().ReportFileSizeEvent();
 }
 
 void BundleActiveCore::InitBundleGroupController()
@@ -397,6 +404,10 @@ void BundleActiveCore::RestoreAllData()
 
 void BundleActiveCore::RestoreToDatabase(const int32_t userId)
 {
+    if (IsUserSpaceMemoryLimit()) {
+        BUNDLE_ACTIVE_LOGE("The available memory in user space is too low and is not on the disk");
+        return;
+    }
     BUNDLE_ACTIVE_LOGD("RestoreToDatabase called");
     BundleActiveEvent event;
     event.eventId_ = BundleActiveEvent::FLUSH;
@@ -407,6 +418,13 @@ void BundleActiveCore::RestoreToDatabase(const int32_t userId)
         it->second->ReportEvent(event);
     }
     RestoreToDatabaseLocked(userId);
+    std::shared_ptr<BundleActiveCore> bundleActiveCore = shared_from_this();
+    ffrt::submit([bundleActiveCore]() {
+        if (bundleActiveCore == nullptr) {
+            return;
+        }
+        bundleActiveCore->ProcessDataSize();
+        });
 }
 
 void BundleActiveCore::RestoreToDatabaseLocked(const int32_t userId)
@@ -973,6 +991,41 @@ void BundleActiveCore::OnObserverDiedInner(const wptr<IRemoteObject> &remote)
     }
     recipientMap_.erase(objectProxy);
 }
+
+bool BundleActiveCore::IsUserSpaceMemoryLimit()
+{
+    return BundleActiveUtil::GetPercentOfAvailableUserSpace(DATA_PATH) <= percentUserSpaceLimit_;
+}
+
+void BundleActiveCore::ProcessDataSize()
+{
+    if (!bundleActiveConfigReader_ || !IsFolderSizeLimit()) {
+        return;
+    }
+    DeleteExcessiveTableData();
+}
+
+bool BundleActiveCore::IsFolderSizeLimit()
+{
+    return BundleActiveUtil::GetFolderOrFileSize(BUNDLE_ACTIVE_DATABASE_DIR) >=
+        bundleActiveConfigReader_->GetMaxDataSize();
+}
+
+void BundleActiveCore::DeleteExcessiveTableData()
+{
+    std::lock_guard<ffrt::mutex> lock(mutex_);
+    auto it = userStatServices_.find(currentUsedUser_);
+    if (it == userStatServices_.end()) {
+        BUNDLE_ACTIVE_LOGE("currentUsedUser_ is not exit, delete exceeive table data failed");
+        return;
+    }
+    for (int32_t deleteDays = DEFAULT_DELETE_EVENT_DALIYS; deleteDays <= MAX_DELETE_EVENT_DALIYS; deleteDays++) {
+        it->second->DeleteExcessiveEventTableData(deleteDays);
+        if (!IsFolderSizeLimit()) {
+            return;
+        }
+    }
+}
 }  // namespace DeviceUsageStats
 }  // namespace OHOS
 
diff --git a/services/common/src/bundle_active_event_reporter.cpp b/services/common/src/bundle_active_event_reporter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..63853d6b0346fd5e181cdf3deb8a14ec73007e7a
--- /dev/null
+++ b/services/common/src/bundle_active_event_reporter.cpp
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2025 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 "bundle_active_event_reporter.h"
+#include "file_ex.h"
+#include "hisysevent.h"
+#include "bundle_active_log.h"
+#include "bundle_active_util.h"
+#include "bundle_active_constant.h"
+
+
+namespace OHOS {
+namespace DeviceUsageStats {
+namespace {
+static const int64_t FIRST_REPORT_TIME = 10 * 1000 * 1000;
+static const int64_t ONE_DAY_MICRO_SECOND = static_cast<int64_t>(24) * 60 * 60 * 1000 * 1000;
+static const char* DATA_FILE_PATH = "/data";
+static const char* FILE_SIZE_REPORTER_RECORDER = "/data/service/el1/public/bundle_usage/file_size_report_time";
+}
+
+IMPLEMENT_SINGLE_INSTANCE(BundleActiveEventReporter);
+
+void BundleActiveEventReporter::ReportFileSizeEvent()
+{
+    std::lock_guard<ffrt::mutex> autoLock(mutex_);
+    if (!isTaskSubmit_) {
+        fileSizeRecorderName_ = std::string(FILE_SIZE_REPORTER_RECORDER);
+        SubmitDelayTask(FIRST_REPORT_TIME);
+        isTaskSubmit_ = true;
+    }
+}
+
+void BundleActiveEventReporter::SubmitDelayTask(int64_t delayTime)
+{
+    ffrt::submit([]() {
+        BundleActiveEventReporter::GetInstance().ReportFileSizeDaily();
+        }, ffrt::task_attr().delay(delayTime));
+}
+
+void BundleActiveEventReporter::ReportFileSizeDaily()
+{
+    std::string lastReportTime;
+    LoadStringFromFile(fileSizeRecorderName_, lastReportTime);
+    if (lastReportTime.empty()) {
+        ReportFileSizeInner();
+    } else {
+        int64_t lastReportTimeValue = BundleActiveUtil::StringToInt64(lastReportTime);
+        if (lastReportTimeValue <= 0) {
+            ReportFileSizeInner();
+        } else {
+            int64_t nowTime = BundleActiveUtil::GetSteadyTime();
+            if (nowTime - lastReportTimeValue < ONE_DAY_MICRO_SECOND) {
+                int64_t nextReportTime = ONE_DAY_MICRO_SECOND - (nowTime - lastReportTimeValue);
+                SubmitDelayTask(nextReportTime);
+            } else {
+                ReportFileSizeInner();
+            }
+        }
+    }
+}
+
+void BundleActiveEventReporter::ReportFileSizeInner()
+{
+    BUNDLE_ACTIVE_LOGI("ReportFileSizeInner call");
+    std::lock_guard<ffrt::mutex> autoLock(mutex_);
+    std::vector<std::string> filesPath;
+    std::vector<uint64_t> filesPathSize;
+    filesPath.emplace_back(BUNDLE_ACTIVE_DATABASE_DIR);
+    filesPathSize.emplace_back(BundleActiveUtil::GetFolderOrFileSize(BUNDLE_ACTIVE_DATABASE_DIR));
+    double remainSize = BundleActiveUtil::GetDeviceValidSize(DATA_FILE_PATH);
+    HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::FILEMANAGEMENT, "USER_DATA_SIZE",
+        HiviewDFX::HiSysEvent::EventType::STATISTIC,
+        "COMPONENT_NAME", "device_usage_statistics",
+        "PARTITION_NAME", DATA_FILE_PATH,
+        "REMAIN_PARTITION_SIZE", remainSize,
+        "FILE_OR_FOLDER_PATH", filesPath,
+        "FILE_OR_FOLDER_SIZE", filesPathSize);
+    int64_t nowMicroTime = BundleActiveUtil::GetNowMicroTime();
+    SaveStringToFile(fileSizeRecorderName_, std::to_string(nowMicroTime));
+    SubmitDelayTask(ONE_DAY_MICRO_SECOND);
+}
+} // namespace ResourceSchedule
+} // namespace OHOS
\ No newline at end of file
diff --git a/services/common/src/bundle_active_usage_database.cpp b/services/common/src/bundle_active_usage_database.cpp
index e8c4e778eb816258c184160cefa03f0d083d73de..68950e1f9748b914fef5e11ebf864fa8115fb7c6 100644
--- a/services/common/src/bundle_active_usage_database.cpp
+++ b/services/common/src/bundle_active_usage_database.cpp
@@ -1904,5 +1904,30 @@ int32_t BundleActiveUsageDatabase::JudgeQueryCondition(const int64_t beginTime,
     }
     return QUERY_CONDITION_VALID;
 }
+
+void BundleActiveUsageDatabase::DeleteExcessiveEventTableData(int32_t deleteDays)
+{
+    lock_guard<ffrt::mutex> lock(databaseMutex_);
+    // 删除多余event表数据
+    if ((eventTableName_ == UNKNOWN_TABLE_NAME) || (eventBeginTime_ == EVENT_BEGIN_TIME_INITIAL_VALUE)) {
+        return;
+    }
+    int64_t eventTableTime = ParseStartTime(eventTableName_);
+    int64_t deleteTimePoint = eventBeginTime_ - (SIX_DAY_IN_MILLIS_MAX - deleteDays * ONE_DAY_TIME) - eventTableTime;
+    if (deleteTimePoint <= 0) {
+        return;
+    }
+    shared_ptr<NativeRdb::RdbStore> rdbStore = GetBundleActiveRdbStore(EVENT_DATABASE_INDEX);
+    if (rdbStore == nullptr) {
+        BUNDLE_ACTIVE_LOGE("delete excessive tableData fail, rdbStore is nullptr");
+        return;
+    }
+    string deleteEventDataSql = "delete from " + eventTableName_ + " where timeStamp <= " +
+        to_string(deleteTimePoint);
+    int32_t deleteResult = rdbStore->ExecuteSql(deleteEventDataSql);
+    if (deleteResult != NativeRdb::E_OK) {
+        BUNDLE_ACTIVE_LOGE("delete event data failed, rdb error number: %{public}d", deleteResult);
+    }
+}
 }  // namespace DeviceUsageStats
 }  // namespace OHOS
diff --git a/services/packageusage/include/bundle_active_report_handler.h b/services/packageusage/include/bundle_active_report_handler.h
index 0956833269cb1473b5f5880d908a24e5706b60aa..bae6532c8295e84a8e4f9f1f1f186b8697c389db 100644
--- a/services/packageusage/include/bundle_active_report_handler.h
+++ b/services/packageusage/include/bundle_active_report_handler.h
@@ -42,6 +42,7 @@ public:
     bool HasEvent(const int32_t& eventId);
     void Init(const std::shared_ptr<BundleActiveCore>& bundleActiveCore);
     void DeInit();
+    
     static const int32_t MSG_REPORT_EVENT;
     static const int32_t MSG_FLUSH_TO_DISK;
     static const int32_t MSG_REMOVE_USER;
diff --git a/services/packageusage/include/bundle_active_user_service.h b/services/packageusage/include/bundle_active_user_service.h
index 299f1c4adc3a202d2335282185e79480f4f31a1c..7fe18d932fc210e0637631f03ffd5d102e845d30 100644
--- a/services/packageusage/include/bundle_active_user_service.h
+++ b/services/packageusage/include/bundle_active_user_service.h
@@ -77,6 +77,7 @@ public:
         std::vector<BundleActiveEventStats>& eventStats, int32_t userId);
     void LoadActiveStats(const int64_t timeStamp, const bool& force, const bool& timeChanged);
     void LoadModuleAndFormStats();
+    void DeleteExcessiveEventTableData(int32_t deleteDays);
 
 private:
     static const int64_t ONE_SECOND_MILLISECONDS = 1000;
diff --git a/services/packageusage/src/bundle_active_user_service.cpp b/services/packageusage/src/bundle_active_user_service.cpp
index 672549c95747b520bc04ca314e33f5cf1f6d22e3..2333d013159d0b257b6b07e1faba8a276a8061ad 100644
--- a/services/packageusage/src/bundle_active_user_service.cpp
+++ b/services/packageusage/src/bundle_active_user_service.cpp
@@ -746,5 +746,13 @@ std::shared_ptr<BundleActiveModuleRecord> BundleActiveUserService::GetOrCreateMo
     }
     return moduleRecords_[combinedInfo];
 }
+
+void BundleActiveUserService::DeleteExcessiveEventTableData(int32_t deleteDays)
+{
+    if (deleteDays < 0) {
+        return;
+    }
+    database_.DeleteExcessiveEventTableData(deleteDays);
+}
 }  // namespace DeviceUsageStats
 }  // namespace OHOS
\ No newline at end of file
diff --git a/test/resource/deviceUsage/deviceUsageConfig.xml b/test/resource/deviceUsage/deviceUsageConfig.xml
index 2dacadb0ee22ee5a03baee42aaf3061cd45f245f..b24a502963632cc7dc3874657c1561a6073ebef0 100644
--- a/test/resource/deviceUsage/deviceUsageConfig.xml
+++ b/test/resource/deviceUsage/deviceUsageConfig.xml
@@ -20,6 +20,13 @@
             <option name="shell" value="target mount"/>
             <option name="shell" value="mkdir /system/variant/phone/base/etc/device_usage_statistics/"/>
             <option name="push" value="parseconfig/device_usage_statistics_config.json -> /system/variant/phone/base/etc/device_usage_statistics/" src="res"/>
+            <option name="push" value="parseconfig/device_usage_statistics_config_test1.json -> /system/variant/phone/base/etc/device_usage_statistics/" src="res"/>
+            <option name="push" value="parseconfig/device_usage_statistics_config_test2.json -> /system/variant/phone/base/etc/device_usage_statistics/" src="res"/>
         </preparer>
+        <cleaner>
+            <option name="shell" value="rm -rf /system/variant/phone/base/etc/device_usage_statistics/device_usage_statistics_config.json"/>
+            <option name="shell" value="rm -rf /system/variant/phone/base/etc/device_usage_statistics/device_usage_statistics_config_test1.json"/>
+            <option name="shell" value="rm -rf /system/variant/phone/base/etc/device_usage_statistics/device_usage_statistics_config_test2.json"/>
+        </cleaner>
     </target>
 </configuration>
\ No newline at end of file
diff --git a/test/resource/deviceUsage/ohos_test.xml b/test/resource/deviceUsage/ohos_test.xml
new file mode 100644
index 0000000000000000000000000000000000000000..60322fffe0563278d823b574140968b6c92b4371
--- /dev/null
+++ b/test/resource/deviceUsage/ohos_test.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ * Copyright (c) 2025 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.
+ -->
+<configuration ver="2.0">
+    <target name="DeviceUsageStatsServiceTest">
+        <preparer>
+            <option name="shell" value="mount -o rw,remount /sys_prod"/>
+            <option name="shell" value="target mount"/>
+            <option name="shell" value="mkdir /sys_prod/etc/device_usage_statistics/"/>
+            <option name="push" value="parseconfig/device_usage_statistics_config.json -> /sys_prod/etc/device_usage_statistics/" src="res"/>
+            <option name="push" value="parseconfig/device_usage_statistics_config_test1.json -> /sys_prod/etc/device_usage_statistics/" src="res"/>
+            <option name="push" value="parseconfig/device_usage_statistics_config_test2.json -> /sys_prod/etc/device_usage_statistics/" src="res"/>
+        </preparer>
+        <cleaner>
+            <option name="shell" value="rm -rf /sys_prod/etc/device_usage_statistics/device_usage_statistics_config.json"/>
+            <option name="shell" value="rm -rf /sys_prod/etc/device_usage_statistics/device_usage_statistics_config_test1.json"/>
+            <option name="shell" value="rm -rf /sys_prod/etc/device_usage_statistics/device_usage_statistics_config_test2.json"/>
+        </cleaner>
+    </target>
+</configuration>
\ No newline at end of file
diff --git a/test/resource/deviceUsage/parseconfig/device_usage_statistics_config.json b/test/resource/deviceUsage/parseconfig/device_usage_statistics_config.json
index 31145c3f472e6a23679a504f84c33042dd306549..f50c21a2bba95720fdc183c39b4525d8a2ba2451 100644
--- a/test/resource/deviceUsage/parseconfig/device_usage_statistics_config.json
+++ b/test/resource/deviceUsage/parseconfig/device_usage_statistics_config.json
@@ -3,5 +3,6 @@
         "MinUseTimes" : 5,
         "MaxUseTimes" : 15,
         "MinUseDays" : 6
-    }
+    },
+    "MaxDataSize": 6
 }
\ No newline at end of file
diff --git a/test/resource/deviceUsage/parseconfig/device_usage_statistics_config_test1.json b/test/resource/deviceUsage/parseconfig/device_usage_statistics_config_test1.json
new file mode 100644
index 0000000000000000000000000000000000000000..a1f91f2de59f29de31e23c400cb9b96d6acd38a0
--- /dev/null
+++ b/test/resource/deviceUsage/parseconfig/device_usage_statistics_config_test1.json
@@ -0,0 +1,8 @@
+{
+    "application_use_periodically": {
+        "MinUseTimes" : 5,
+        "MaxUseTimes" : 15,
+        "MinUseDays" : 6
+    },
+    "MaxDataSize": "abc"
+}
\ No newline at end of file
diff --git a/test/resource/deviceUsage/parseconfig/device_usage_statistics_config_test2.json b/test/resource/deviceUsage/parseconfig/device_usage_statistics_config_test2.json
new file mode 100644
index 0000000000000000000000000000000000000000..31145c3f472e6a23679a504f84c33042dd306549
--- /dev/null
+++ b/test/resource/deviceUsage/parseconfig/device_usage_statistics_config_test2.json
@@ -0,0 +1,7 @@
+{
+    "application_use_periodically": {
+        "MinUseTimes" : 5,
+        "MaxUseTimes" : 15,
+        "MinUseDays" : 6
+    }
+}
\ No newline at end of file
diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn
index c4626fcd8d1a3e8da89957209e5b0b7b0f8031d5..40526736978b9a26ce550ef8d2e9ee4448c402e2 100644
--- a/test/unittest/BUILD.gn
+++ b/test/unittest/BUILD.gn
@@ -204,6 +204,8 @@ ohos_unittest("DeviceUsageStatsServiceTest") {
   sources = [ "device_usage_statistics_service_test.cpp" ]
 
   configs = [ ":module_private_config" ]
+  resource_config_file =
+      "${usage_statistics_path}/test/resource/deviceUsage/ohos_test.xml"
 
   deps = [
     "../../:usagestatservice_static",
@@ -360,9 +362,61 @@ ohos_unittest("DeviceUsagePackageUsageTest") {
   }
 }
 
+ohos_unittest("BundleActiveEventReporterTest") {
+  module_out_path = module_output_path
+  cflags = [
+    "-Dprivate=public",
+    "-Dprotected=public",
+  ]
+
+  sources = [ "bundle_active_event_reporter_test.cpp" ]
+
+  configs = [ ":module_private_config" ]
+
+  deps = [
+    "../../:usagestatservice_static",
+    "../../:usagestatsinner",
+    "../../:usagestatsutils",
+  ]
+
+  external_deps = [
+    "ability_runtime:app_manager",
+    "ability_runtime:wantagent_innerkits",
+    "access_token:libaccesstoken_sdk",
+    "cJSON:cjson",
+    "ffrt:libffrt",
+    "hilog:libhilog",
+    "ipc:ipc_single",
+    "relational_store:native_rdb",
+    "safwk:system_ability_fwk",
+    "samgr:samgr_proxy",
+    "time_service:time_client",
+  ]
+  defines = []
+  if (device_usage_statistics_with_powermgr_power_manager_enable) {
+    defines += [ "DEVICE_USAGES_STATISTICS_POWERMANGER_ENABLE" ]
+    external_deps += [ "power_manager:powermgr_client" ]
+  }
+  if (os_account_part_enabled) {
+    external_deps += [ "os_account:os_account_innerkits" ]
+  }
+  if (bgtaskmgr_enable) {
+    external_deps += [ "background_task_mgr:bgtaskmgr_innerkits" ]
+    defines += [ "BGTASKMGR_ENABLE" ]
+  }
+  branch_protector_ret = "pac_ret"
+
+  sanitize = {
+    cfi = true
+    cfi_cross_dso = true
+    debug = false
+  }
+}
+
 group("unittest") {
   testonly = true
   deps = [
+    ":BundleActiveEventReporterTest",
     ":BundleActiveTotalTest",
     ":DeviceUsagePackageUsageTest",
     ":DeviceUsageStatsMockTest",
diff --git a/test/unittest/bundle_active_event_reporter_test.cpp b/test/unittest/bundle_active_event_reporter_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..026219290b1d6409505d2351730f33d72f8ca8a5
--- /dev/null
+++ b/test/unittest/bundle_active_event_reporter_test.cpp
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2025  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 <string>
+#include <gtest/gtest.h>
+#include "bundle_active_event_reporter.h"
+#include "file_ex.h"
+
+using namespace testing::ext;
+
+namespace OHOS {
+namespace DeviceUsageStats {
+
+class BundleActiveEventReporterTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp();
+    void TearDown();
+};
+
+void BundleActiveEventReporterTest::SetUpTestCase(void)
+{
+}
+
+void BundleActiveEventReporterTest::TearDownTestCase(void)
+{
+}
+
+void BundleActiveEventReporterTest::SetUp(void)
+{
+}
+
+void BundleActiveEventReporterTest::TearDown(void)
+{
+}
+
+/*
+ * @tc.name: ReportFileSizeEvent_001
+ * @tc.desc: test the interface of bundle_active_event_reporter
+ * @tc.type: FUNC
+ * @tc.require: issuesIC2FBU
+ */
+HWTEST_F(BundleActiveEventReporterTest, ReportFileSizeEvent_001, Function | MediumTest | Level0)
+{
+    BundleActiveEventReporter::GetInstance().isTaskSubmit_ = false;
+    BundleActiveEventReporter::GetInstance().ReportFileSizeEvent();
+    BundleActiveEventReporter::GetInstance().ReportFileSizeEvent();
+    EXPECT_TRUE(BundleActiveEventReporter::GetInstance().isTaskSubmit_);
+}
+
+/*
+ * @tc.name: ReportFileSizeDaily_001
+ * @tc.desc: test the interface of bundle_active_event_reporter
+ * @tc.type: FUNC
+ * @tc.require: issuesIC2FBU
+ */
+HWTEST_F(BundleActiveEventReporterTest, ReportFileSizeDaily_001, Function | MediumTest | Level0)
+{
+    BundleActiveEventReporter::GetInstance().fileSizeRecorderName_ = "test";
+    BundleActiveEventReporter::GetInstance().ReportFileSizeDaily();
+    BundleActiveEventReporter::GetInstance().fileSizeRecorderName_ =
+        "/data/service/el1/public/bundle_usage/file_size_report_time";
+    BundleActiveEventReporter::GetInstance().ReportFileSizeDaily();
+    BundleActiveEventReporter::GetInstance().ReportFileSizeDaily();
+    SaveStringToFile(BundleActiveEventReporter::GetInstance().fileSizeRecorderName_, std::to_string(-1));
+    BundleActiveEventReporter::GetInstance().ReportFileSizeDaily();
+    SaveStringToFile(BundleActiveEventReporter::GetInstance().fileSizeRecorderName_, std::to_string(1));
+    BundleActiveEventReporter::GetInstance().ReportFileSizeDaily();
+    std::string lastReportTime;
+    LoadStringFromFile(BundleActiveEventReporter::GetInstance().fileSizeRecorderName_, lastReportTime);
+    EXPECT_TRUE(!lastReportTime.empty());
+}
+
+/*
+ * @tc.name: ReportFileSizeDaily_002
+ * @tc.desc: test the interface of bundle_active_event_reporter
+ * @tc.type: FUNC
+ * @tc.require: issuesIC2FBU
+ */
+HWTEST_F(BundleActiveEventReporterTest, ReportFileSizeDaily_002, Function | MediumTest | Level0)
+{
+    BundleActiveEventReporter::GetInstance().ReportFileSizeInner();
+    std::string lastReportTime;
+    LoadStringFromFile(BundleActiveEventReporter::GetInstance().fileSizeRecorderName_, lastReportTime);
+    EXPECT_TRUE(!lastReportTime.empty());
+}
+}
+}
\ No newline at end of file
diff --git a/test/unittest/bundle_active_total_test.cpp b/test/unittest/bundle_active_total_test.cpp
index bcfa474b5781d480d1e057c1111acedd70755ac0..554aab19eb42f5fb4988217cb29da56593c9f99e 100644
--- a/test/unittest/bundle_active_total_test.cpp
+++ b/test/unittest/bundle_active_total_test.cpp
@@ -34,6 +34,8 @@
 #include "bundle_active_debug_mode.h"
 #include "bundle_active_report_controller.h"
 #include "bundle_active_test_util.h"
+#include "bundle_active_event_reporter.h"
+#include "file_ex.h"
 
 using namespace testing::ext;
 
diff --git a/test/unittest/bundle_active_usage_database_test.cpp b/test/unittest/bundle_active_usage_database_test.cpp
index 6baab04936e182cd57c97810671cad3bf6eae7ff..6e325a1b6c47fcff357c0f11e34418ab90eb31d3 100644
--- a/test/unittest/bundle_active_usage_database_test.cpp
+++ b/test/unittest/bundle_active_usage_database_test.cpp
@@ -307,5 +307,92 @@ HWTEST_F(BundleActiveUsageDatabaseTest, UpdateFirstUseTime_002,
     database->UpdateFirstUseTime(rdb, BUNDLE_HISTORY_LOG_TABLE, 100);
     EXPECT_NE(database, nullptr);
 }
+
+/*
+ * @tc.name: BundleActiveUsageDatabaseTest_DeleteExcessiveEventTableData_001
+ * @tc.desc: DeleteExcessiveEventTableData
+ * @tc.type: FUNC
+ * @tc.require: issuesIC2FBU
+ */
+HWTEST_F(BundleActiveUsageDatabaseTest, BundleActiveUsageDatabaseTest_DeleteExcessiveEventTableData_001,
+    Function | MediumTest | Level0)
+{
+    auto database = std::make_shared<BundleActiveUsageDatabase>();
+    database->DeleteExcessiveEventTableData(0);
+    database->eventTableName_ = "a123";
+    database->DeleteExcessiveEventTableData(0);
+    database->eventBeginTime_  = 0;
+    database->DeleteExcessiveEventTableData(0);
+    database->eventBeginTime_  = MAX_END_TIME;
+    database->DeleteExcessiveEventTableData(0);
+    database->InitDatabaseTableInfo(100);
+    database->DeleteExcessiveEventTableData(0);
+    EXPECT_EQ(database->eventTableName_, "a123");
+}
+
+/*
+ * @tc.name: GetSteadyTime_001
+ * @tc.desc: BundleActiveUtil Test
+ * @tc.type: FUNC
+ * @tc.require: issuesIC2FBU
+ */
+HWTEST_F(BundleActiveUsageDatabaseTest, GetSteadyTime_001,
+    Function | MediumTest | Level0)
+{
+    EXPECT_TRUE(BundleActiveUtil::GetSteadyTime() > 0);
+}
+
+/*
+ * @tc.name: GetFolderOrFileSize_001
+ * @tc.desc: BundleActiveUtil Test
+ * @tc.type: FUNC
+ * @tc.require: issuesIC2FBU
+ */
+HWTEST_F(BundleActiveUsageDatabaseTest, GetFolderOrFileSize_001,
+    Function | MediumTest | Level0)
+{
+    EXPECT_EQ(BundleActiveUtil::GetFolderOrFileSize(""), 0);
+    EXPECT_TRUE(BundleActiveUtil::GetFolderOrFileSize(BUNDLE_ACTIVE_DATABASE_DIR) > 0);
+}
+
+/*
+ * @tc.name: GetPartitionName_001
+ * @tc.desc: BundleActiveUtil Test
+ * @tc.type: FUNC
+ * @tc.require: issuesIC2FBU
+ */
+HWTEST_F(BundleActiveUsageDatabaseTest, GetPartitionName_001,
+    Function | MediumTest | Level0)
+{
+    EXPECT_EQ(BundleActiveUtil::GetPartitionName(""), "/");
+    EXPECT_EQ(BundleActiveUtil::GetPartitionName(BUNDLE_ACTIVE_DATABASE_DIR), "/data");
+    EXPECT_EQ(BundleActiveUtil::GetPartitionName("/data"), "/data");
+}
+
+/*
+ * @tc.name: GetDeviceValidSize_001
+ * @tc.desc: BundleActiveUtil Test
+ * @tc.type: FUNC
+ * @tc.require: issuesIC2FBU
+ */
+HWTEST_F(BundleActiveUsageDatabaseTest, GetDeviceValidSize_001,
+    Function | MediumTest | Level0)
+{
+    EXPECT_EQ(BundleActiveUtil::GetDeviceValidSize(""), 0);
+    EXPECT_TRUE(BundleActiveUtil::GetDeviceValidSize(BUNDLE_ACTIVE_DATABASE_DIR) > 0);
+}
+
+/*
+ * @tc.name: GetPercentOfAvailableUserSpace_001
+ * @tc.desc: BundleActiveUtil Test
+ * @tc.type: FUNC
+ * @tc.require: issuesIC2FBU
+ */
+HWTEST_F(BundleActiveUsageDatabaseTest, GetPercentOfAvailableUserSpace_001,
+    Function | MediumTest | Level0)
+{
+    EXPECT_EQ(BundleActiveUtil::GetPercentOfAvailableUserSpace(""), 0);
+    EXPECT_TRUE(BundleActiveUtil::GetPercentOfAvailableUserSpace(BUNDLE_ACTIVE_DATABASE_DIR) > 0);
+}
 }  // namespace DeviceUsageStats
 }  // namespace OHOS
\ No newline at end of file
diff --git a/test/unittest/device_usage_statistics_service_test.cpp b/test/unittest/device_usage_statistics_service_test.cpp
index fb4411358db3f3f3f56a474c8197eda5e3afc010..f4b7655130da650deb60ef23ba56a770c679d250 100644
--- a/test/unittest/device_usage_statistics_service_test.cpp
+++ b/test/unittest/device_usage_statistics_service_test.cpp
@@ -42,6 +42,12 @@ using namespace testing::ext;
 namespace OHOS {
 namespace DeviceUsageStats {
 using namespace Security::AccessToken;
+const char* CONFIG_PATH =
+    "/sys_prod/etc/device_usage_statistics/device_usage_statistics_config.json";
+const char* CONFIG_TEST1_PATH =
+    "/sys_prod/etc/device_usage_statistics/device_usage_statistics_config_test1.json";
+const char* CONFIG_TEST2_PATH =
+    "/sys_prod/etc/device_usage_statistics/device_usage_statistics_config_test2.json";
 class DeviceUsageStatisticsServiceTest : public testing::Test {
 public:
     static void SetUpTestCase(void);
@@ -1637,5 +1643,174 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_GetF
     EXPECT_EQ(bundleUserHistory->GetFirstUseTime(bundleName, userId), 100);
 }
 
+/*
+ * @tc.name: DeviceUsageStatisticsServiceTest_LoadMaxDataSize_001
+ * @tc.desc: ConfigReader
+ * @tc.type: FUNC
+ * @tc.require: issuesIC2FBU
+ */
+HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_LoadMaxDataSize_001,
+    Function | MediumTest | Level0)
+{
+    auto bundleActiveConfigReader = std::make_shared<BundleActiveConfigReader>();
+    bundleActiveConfigReader->maxDataSize_ = 1;
+    EXPECT_NE(bundleActiveConfigReader, nullptr);
+    std::string path = "test";
+    bundleActiveConfigReader->LoadMaxDataSize(path.c_str());
+    EXPECT_EQ(bundleActiveConfigReader->maxDataSize_, 1);
+}
+
+/*
+ * @tc.name: DeviceUsageStatisticsServiceTest_LoadMaxDataSize_002
+ * @tc.desc: ConfigReader
+ * @tc.type: FUNC
+ * @tc.require: issuesIC2FBU
+ */
+HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_LoadMaxDataSize_002,
+    Function | MediumTest | Level0)
+{
+    auto bundleActiveConfigReader = std::make_shared<BundleActiveConfigReader>();
+    bundleActiveConfigReader->maxDataSize_ = 0;
+    EXPECT_NE(bundleActiveConfigReader, nullptr);
+    bundleActiveConfigReader->LoadMaxDataSize(CONFIG_PATH);
+    EXPECT_EQ(bundleActiveConfigReader->maxDataSize_, 6);
+}
+
+/*
+ * @tc.name: DeviceUsageStatisticsServiceTest_LoadMaxDataSize_003
+ * @tc.desc: ConfigReader
+ * @tc.type: FUNC
+ * @tc.require: issuesIC2FBU
+ */
+HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_LoadMaxDataSize_003,
+    Function | MediumTest | Level0)
+{
+    auto bundleActiveConfigReader = std::make_shared<BundleActiveConfigReader>();
+    bundleActiveConfigReader->maxDataSize_ = 0;
+    EXPECT_NE(bundleActiveConfigReader, nullptr);
+    bundleActiveConfigReader->LoadMaxDataSize(CONFIG_TEST1_PATH);
+    EXPECT_EQ(bundleActiveConfigReader->maxDataSize_, 0);
+}
+
+/*
+ * @tc.name: DeviceUsageStatisticsServiceTest_LoadMaxDataSize_004
+ * @tc.desc: ConfigReader
+ * @tc.type: FUNC
+ * @tc.require: issuesIC2FBU
+ */
+HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_LoadMaxDataSize_004,
+    Function | MediumTest | Level0)
+{
+    auto bundleActiveConfigReader = std::make_shared<BundleActiveConfigReader>();
+    bundleActiveConfigReader->maxDataSize_ = 0;
+    EXPECT_NE(bundleActiveConfigReader, nullptr);
+    bundleActiveConfigReader->LoadMaxDataSize(CONFIG_TEST2_PATH);
+    EXPECT_EQ(bundleActiveConfigReader->maxDataSize_, 0);
+}
+
+/*
+ * @tc.name: DeviceUsageStatisticsServiceTest_GetMaxDataSize_001
+ * @tc.desc: ConfigReader
+ * @tc.type: FUNC
+ * @tc.require: issuesIC2FBU
+ */
+HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_GetMaxDataSize_001,
+    Function | MediumTest | Level0)
+{
+    auto bundleActiveConfigReader = std::make_shared<BundleActiveConfigReader>();
+    bundleActiveConfigReader->maxDataSize_ = 0;
+    EXPECT_NE(bundleActiveConfigReader, nullptr);
+    EXPECT_EQ(bundleActiveConfigReader->GetMaxDataSize(), 5 * 1024 * 1024);
+}
+
+/*
+ * @tc.name: DeviceUsageStatisticsServiceTest_GetMaxDataSize_002
+ * @tc.desc: ConfigReader
+ * @tc.type: FUNC
+ * @tc.require: issuesIC2FBU
+ */
+HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_GetMaxDataSize_002,
+    Function | MediumTest | Level0)
+{
+    auto bundleActiveConfigReader = std::make_shared<BundleActiveConfigReader>();
+    bundleActiveConfigReader->maxDataSize_ = 10;
+    EXPECT_NE(bundleActiveConfigReader, nullptr);
+    EXPECT_EQ(bundleActiveConfigReader->GetMaxDataSize(), 10);
+}
+
+/*
+ * @tc.name: DeviceUsageStatisticsServiceTest_RestoreToDatabase_002
+ * @tc.desc: RestoreToDatabase
+ * @tc.type: FUNC
+ * @tc.require: issuesIC2FBU
+ */
+HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_RestoreToDatabase_002,
+    Function | MediumTest | Level0)
+{
+    auto bundleActiveCore = std::make_shared<BundleActiveCore>();
+    bundleActiveCore->Init();
+    bundleActiveCore->InitBundleGroupController();
+    int userId = 100;
+    auto userService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), false);
+    int64_t timeStamp = 20000000000000;
+    userService->Init(timeStamp);
+    BundleActiveEvent event;
+    userService->currentStats_[BundleActivePeriodStats::PERIOD_DAILY]->events_.Clear();
+    userService->currentStats_[BundleActivePeriodStats::PERIOD_DAILY]->events_.Insert(event);
+    EXPECT_EQ(userService->currentStats_[BundleActivePeriodStats::PERIOD_DAILY]->events_.Size(), 1);
+    bundleActiveCore->userStatServices_[userId] = userService;
+    bundleActiveCore->RestoreToDatabase(userId);
+    bundleActiveCore->percentUserSpaceLimit_ = 0;
+    bundleActiveCore->RestoreToDatabase(userId);
+    EXPECT_EQ(userService->currentStats_[BundleActivePeriodStats::PERIOD_DAILY]->events_.Size(), 1);
+    bundleActiveCore->percentUserSpaceLimit_ = 1;
+    bundleActiveCore->RestoreToDatabase(userId);
+    EXPECT_NE(bundleActiveCore, nullptr);
+}
+
+/*
+ * @tc.name: DeviceUsageStatisticsServiceTest_ProcessDataSize_001
+ * @tc.desc: RestoreToDatabase
+ * @tc.type: FUNC
+ * @tc.require: issuesIC2FBU
+ */
+HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_ProcessDataSize_001,
+    Function | MediumTest | Level0)
+{
+    auto bundleActiveCore = std::make_shared<BundleActiveCore>();
+    bundleActiveCore->Init();
+    bundleActiveCore->ProcessDataSize();
+    bundleActiveCore->bundleActiveConfigReader_->maxDataSize_ = 0;
+    bundleActiveCore->ProcessDataSize();
+    EXPECT_NE(bundleActiveCore, nullptr);
+}
+
+/*
+ * @tc.name: DeviceUsageStatisticsServiceTest_DeleteExcessiveTableData_001
+ * @tc.desc: RestoreToDatabase
+ * @tc.type: FUNC
+ * @tc.require: issuesIC2FBU
+ */
+HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_DeleteExcessiveTableData_001,
+    Function | MediumTest | Level0)
+{
+    auto bundleActiveCore = std::make_shared<BundleActiveCore>();
+    bundleActiveCore->DeleteExcessiveTableData();
+    bundleActiveCore->ProcessDataSize();
+    bundleActiveCore->Init();
+    bundleActiveCore->InitBundleGroupController();
+    int userId = 100;
+    auto userService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), false);
+    int64_t timeStamp = 20000000000000;
+    userService->Init(timeStamp);
+    bundleActiveCore->userStatServices_[userId] = userService;
+    bundleActiveCore->currentUsedUser_ = userId;
+    bundleActiveCore->bundleActiveConfigReader_->maxDataSize_ = 1;
+    bundleActiveCore->DeleteExcessiveTableData();
+    bundleActiveCore->bundleActiveConfigReader_->maxDataSize_ = 10 * 1024 * 1024;
+    bundleActiveCore->DeleteExcessiveTableData();
+    EXPECT_NE(bundleActiveCore, nullptr);
+}
+
 }  // namespace DeviceUsageStats
 }  // namespace OHOS
\ No newline at end of file
diff --git a/utils/include/bundle_active_util.h b/utils/include/bundle_active_util.h
index e9b669086f580676f9e0eedd6597f42303e1b8ab..8481925a048cfca9cc8f99190e9e5d30e4872195 100644
--- a/utils/include/bundle_active_util.h
+++ b/utils/include/bundle_active_util.h
@@ -33,6 +33,12 @@ public:
     static int32_t StringToInt32(const std::string& str);
     static int64_t StringToInt64(const std::string& str);
     static int64_t GetSystemTimeMs();
+    static int64_t GetNowMicroTime();
+    static int64_t GetSteadyTime();
+    static uint64_t GetFolderOrFileSize(const std::string& path);
+    static double GetDeviceValidSize(const std::string& path);
+    static std::string GetPartitionName(const std::string& path);
+    static double GetPercentOfAvailableUserSpace(const std::string& path);
 };
 }  // namespace DeviceUsageStats
 }  // namespace OHOS
diff --git a/utils/src/bundle_active_util.cpp b/utils/src/bundle_active_util.cpp
index 8c6b6756e10eb68e488404bfe1d30cf62c9d27db..7be77776fecd96edc5c01be2669e2ec1d9b09b0c 100644
--- a/utils/src/bundle_active_util.cpp
+++ b/utils/src/bundle_active_util.cpp
@@ -17,6 +17,9 @@
 #include <limits>
 #include "bundle_active_util.h"
 #include "bundle_active_log.h"
+#include <dirent.h>
+#include <sys/stat.h>
+#include <sys/statfs.h>
 
 namespace OHOS {
 namespace DeviceUsageStats {
@@ -118,6 +121,107 @@ int64_t BundleActiveUtil::GetSystemTimeMs()
     }
     return static_cast<int64_t>(tarDate);
 }
+
+int64_t BundleActiveUtil::GetSteadyTime()
+{
+    std::chrono::seconds secs = std::chrono::duration_cast<std::chrono::seconds>(
+        std::chrono::steady_clock::now().time_since_epoch());
+    return static_cast<int64_t>(secs.count());
+}
+
+int64_t BundleActiveUtil::GetNowMicroTime()
+{
+    std::chrono::microseconds microSecs;
+    // get system time, it can change.
+    microSecs = std::chrono::duration_cast<std::chrono::microseconds>(
+    std::chrono::system_clock::now().time_since_epoch());
+    return static_cast<int64_t>(microSecs.count());
+}
+
+uint64_t BundleActiveUtil::GetFolderOrFileSize(const std::string& path)
+{
+    struct stat st;
+    if (stat(path.c_str(), &st) != 0) {
+        return 0;
+    }
+    if (!S_ISDIR(st.st_mode)) {
+        return static_cast<uint64_t>(st.st_size);
+    }
+    uint64_t totalSize = 0;
+    DIR *dir = opendir(path.c_str());
+    // input invaild, open failed
+    if (dir == nullptr) {
+        return 0;
+    }
+    struct dirent *entry;
+    while ((entry = readdir(dir)) != nullptr) {
+        // current dir is path of '.' or '..'
+        std::string entryPath = path + "/" + entry->d_name;
+        if (entry->d_name[0] == '.') {
+            continue;
+        }
+
+        struct stat entryStat;
+        if (stat(entryPath.c_str(), &entryStat) != 0) {
+            continue;
+        }
+        if (S_ISDIR(entryStat.st_mode)) {
+            uint64_t subDirSize = GetFolderOrFileSize(entryPath);
+            totalSize += subDirSize;
+        } else {
+            totalSize += static_cast<uint64_t>(entryStat.st_size);
+        }
+    }
+    closedir(dir);
+    return totalSize;
+}
+
+std::string BundleActiveUtil::GetPartitionName(const std::string& path)
+{
+    std::string partition;
+    std::size_t first = path.find_first_of("/");
+    if (first == std::string::npos) {
+        partition = "/" + path;
+        return partition;
+    }
+    std::size_t second = path.find_first_of("/", first + 1);
+    if (second == std::string::npos) {
+        if (path.at(0) != '/') {
+            partition = "/" + path.substr(0, first);
+        } else {
+            partition = path;
+        }
+        return partition;
+    }
+    partition = path.substr(0, second - first);
+    return partition;
+}
+
+double BundleActiveUtil::GetDeviceValidSize(const std::string& path)
+{
+    std::string partitionName = GetPartitionName(path);
+    struct statfs stat;
+    if (statfs(partitionName.c_str(), &stat) != 0) {
+        return 0;
+    }
+    constexpr double units = 1024.0;
+    return (static_cast<double>(stat.f_bfree) / units) * (static_cast<double>(stat.f_bsize) / units);
+}
+
+double BundleActiveUtil::GetPercentOfAvailableUserSpace(const std::string& path)
+{
+    std::string partitionName = GetPartitionName(path);
+    struct statfs stat;
+    if (statfs(partitionName.c_str(), &stat) != 0) {
+        return 0;
+    }
+    uint64_t totalBytes = static_cast<uint64_t>(stat.f_blocks) * stat.f_bsize;
+    uint64_t availableBytes = static_cast<uint64_t>(stat.f_bfree) * stat.f_bsize;
+    if (totalBytes == 0 || availableBytes == 0) {
+        return 0;
+    }
+    return static_cast<double>(availableBytes) / static_cast<double>(totalBytes);
+}
 } // namespace DeviceUsageStats
 }  // namespace OHOS