diff --git a/brightness_manager/BUILD.gn b/brightness_manager/BUILD.gn
index a94c6940043ab650cc98300e0755d6c1074439d2..622cddf1afb5bb3767c1b3fa8176eb1ad9592428 100644
--- a/brightness_manager/BUILD.gn
+++ b/brightness_manager/BUILD.gn
@@ -49,6 +49,7 @@ ohos_static_library("brightness_manager") {
     ":brightness_manager_config",
     "${displaymgr_utils_path}:utils_config",
     "${displaymgr_inner_api}:displaymgr_public_config",
+    "${displaymgr_root_path}/service:displaymgr_public_config",
   ]
 
   external_deps = [
diff --git a/bundle.json b/bundle.json
index 898a2cd39609b1004223e8660659afc0bd7dae5f..97796bd88d1e9cbff3319e55107a4c1595751951 100644
--- a/bundle.json
+++ b/bundle.json
@@ -75,7 +75,7 @@
       "test": [
         "//base/powermgr/display_manager/state_manager/test:displaymgr_coverage_test",
         "//base/powermgr/display_manager/state_manager/test:displaymgr_native_test",
-        "//base/powermgr/display_manager/state_manager/test:fuzztest",
+        "//base/powermgr/display_manager/state_manager/test:displaymgr_fuzztest",
         "//base/powermgr/display_manager/brightness_manager/test:brightness_manager_test"
       ]
     }
diff --git a/state_manager/frameworks/napi/BUILD.gn b/state_manager/frameworks/napi/BUILD.gn
index 769ffcd86a75a0b570aaf55ad6e12bcb5685bb80..e7b945293c40f2cc5a7c092106bc2c320b67d7f6 100644
--- a/state_manager/frameworks/napi/BUILD.gn
+++ b/state_manager/frameworks/napi/BUILD.gn
@@ -22,6 +22,7 @@ ohos_shared_library("brightness") {
   configs = [
     "${displaymgr_utils_path}:utils_config",
     "${displaymgr_utils_path}:coverage_flags",
+    "${displaymgr_root_path}/service:displaymgr_public_config",
   ]
 
   deps = [
diff --git a/state_manager/frameworks/native/display_power_mgr_client.cpp b/state_manager/frameworks/native/display_power_mgr_client.cpp
index da4d65d9d5b7fd5e5c3c0add98cfb00c4a221dc8..4a07c9e2ee376cd0976c718989c3f53c25354a1f 100644
--- a/state_manager/frameworks/native/display_power_mgr_client.cpp
+++ b/state_manager/frameworks/native/display_power_mgr_client.cpp
@@ -33,7 +33,10 @@ namespace OHOS {
 namespace DisplayPowerMgr {
 DisplayPowerMgrClient::DisplayPowerMgrClient() = default;
 DisplayPowerMgrClient::~DisplayPowerMgrClient() = default;
-
+namespace {
+constexpr int32_t DEFAULT_VALUE = -1;
+constexpr uint32_t BRIGHTNESS_DEFAULT_PROXY = 0;
+}
 sptr<IDisplayPowerMgr> DisplayPowerMgrClient::GetProxy()
 {
     std::lock_guard lock(mutex_);
@@ -89,7 +92,13 @@ bool DisplayPowerMgrClient::SetDisplayState(DisplayState state,
 {
     auto proxy = GetProxy();
     RETURN_IF_WITH_RET(proxy == nullptr, false);
-    return proxy->SetDisplayState(id, state, static_cast<uint32_t>(reason));
+    bool result = false;
+    auto ret = proxy->SetDisplayState(id, static_cast<uint32_t>(state), static_cast<uint32_t>(reason), result);
+    if (ret != ERR_OK) {
+        DISPLAY_HILOGE(COMP_FWK, "SetDisplayState, ret = %{public}d", ret);
+        return false;
+    }
+    return result;
 }
 
 DisplayState DisplayPowerMgrClient::GetDisplayState(uint32_t id)
@@ -98,7 +107,13 @@ DisplayState DisplayPowerMgrClient::GetDisplayState(uint32_t id)
     if (proxy == nullptr) {
         return DisplayState::DISPLAY_UNKNOWN;
     }
-    return proxy->GetDisplayState(id);
+    int32_t displayState = static_cast<int32_t>(DisplayState::DISPLAY_UNKNOWN);
+    auto ret = proxy->GetDisplayState(id, displayState);
+    if (ret != ERR_OK) {
+        DISPLAY_HILOGE(COMP_FWK, "GetDisplayState, ret = %{public}d", ret);
+        return DisplayState::DISPLAY_UNKNOWN;
+    }
+    return static_cast<DisplayState>(displayState);
 }
 
 std::vector<uint32_t> DisplayPowerMgrClient::GetDisplayIds()
@@ -107,105 +122,196 @@ std::vector<uint32_t> DisplayPowerMgrClient::GetDisplayIds()
     if (proxy == nullptr) {
         return {};
     }
-    return proxy->GetDisplayIds();
+    std::vector<uint32_t> ids;
+    auto ret = proxy->GetDisplayIds(ids);
+    if (ret != ERR_OK) {
+        DISPLAY_HILOGE(COMP_FWK, "GetDisplayIds, ret = %{public}d", ret);
+    }
+    return ids;
 }
 
 int32_t DisplayPowerMgrClient::GetMainDisplayId()
 {
     auto proxy = GetProxy();
     RETURN_IF_WITH_RET(proxy == nullptr, INVALID_DISPLAY_ID);
-    return static_cast<int32_t>(proxy->GetMainDisplayId());
+    uint32_t id = DEFAULT_MAIN_DISPLAY_ID;
+    auto ret = proxy->GetMainDisplayId(id);
+    if (ret != ERR_OK) {
+        DISPLAY_HILOGE(COMP_FWK, "GetMainDisplayId, ret = %{public}d", ret);
+        return DEFAULT_MAIN_DISPLAY_ID;
+    }
+    return id;
 }
 
 bool DisplayPowerMgrClient::SetBrightness(uint32_t value, uint32_t displayId, bool continuous)
 {
     auto proxy = GetProxy();
     RETURN_IF_WITH_RET(proxy == nullptr, false);
-    return proxy->SetBrightness(value, displayId, continuous);
+    bool result = false;
+    int32_t displayError = ERR_OK;
+    auto ret = proxy->SetBrightness(value, displayId, continuous, result, displayError);
+    if (ret != ERR_OK) {
+        DISPLAY_HILOGE(COMP_FWK, "SetBrightness, ret = %{public}d", ret);
+        return false;
+    }
+    lastError_ = static_cast<DisplayErrors>(displayError);
+    return result;
 }
 
 bool DisplayPowerMgrClient::DiscountBrightness(double discount, uint32_t displayId)
 {
     auto proxy = GetProxy();
     RETURN_IF_WITH_RET(proxy == nullptr, false);
-    return proxy->DiscountBrightness(discount, displayId);
+    bool result = false;
+    auto ret = proxy->DiscountBrightness(discount, displayId, result);
+    if (ret != ERR_OK) {
+        DISPLAY_HILOGE(COMP_FWK, "DiscountBrightness, ret = %{public}d", ret);
+        return false;
+    }
+    return result;
 }
 
 bool DisplayPowerMgrClient::OverrideBrightness(uint32_t value, uint32_t displayId, uint32_t duration)
 {
     auto proxy = GetProxy();
     RETURN_IF_WITH_RET(proxy == nullptr, false);
-    return proxy->OverrideBrightness(value, displayId, duration);
+    bool result = false;
+    auto ret = proxy->OverrideBrightness(value, displayId, duration, result);
+    if (ret != ERR_OK) {
+        DISPLAY_HILOGE(COMP_FWK, "OverrideBrightness, ret = %{public}d", ret);
+        return false;
+    }
+    return result;
 }
 
 bool DisplayPowerMgrClient::OverrideDisplayOffDelay(uint32_t delayMs)
 {
     auto proxy = GetProxy();
     RETURN_IF_WITH_RET(proxy == nullptr, false);
-    return proxy->OverrideDisplayOffDelay(delayMs);
+    bool result = false;
+    auto ret = proxy->OverrideDisplayOffDelay(delayMs, result);
+    if (ret != ERR_OK) {
+        DISPLAY_HILOGE(COMP_FWK, "OverrideDisplayOffDelay, ret = %{public}d", ret);
+        return false;
+    }
+    return result;
 }
 
 bool DisplayPowerMgrClient::RestoreBrightness(uint32_t displayId, uint32_t duration)
 {
     auto proxy = GetProxy();
     RETURN_IF_WITH_RET(proxy == nullptr, false);
-    return proxy->RestoreBrightness(displayId, duration);
+    bool result = false;
+    auto ret = proxy->RestoreBrightness(displayId, duration, result);
+    if (ret != ERR_OK) {
+        DISPLAY_HILOGE(COMP_FWK, "RestoreBrightness, ret = %{public}d", ret);
+        return false;
+    }
+    return result;
 }
 
 uint32_t DisplayPowerMgrClient::GetBrightness(uint32_t displayId)
 {
     auto proxy = GetProxy();
     RETURN_IF_WITH_RET(proxy == nullptr, BRIGHTNESS_OFF);
-    return proxy->GetBrightness(displayId);
+    uint32_t brightness = BRIGHTNESS_OFF;
+    auto ret = proxy->GetBrightness(displayId, brightness);
+    if (ret != ERR_OK) {
+        DISPLAY_HILOGE(COMP_FWK, "GetBrightness, ret = %{public}d", ret);
+        return BRIGHTNESS_OFF;
+    }
+    return brightness;
 }
 
 uint32_t DisplayPowerMgrClient::GetDefaultBrightness()
 {
     auto proxy = GetProxy();
     RETURN_IF_WITH_RET(proxy == nullptr, BRIGHTNESS_DEFAULT);
-    return proxy->GetDefaultBrightness();
+    uint32_t brightness = BRIGHTNESS_DEFAULT_PROXY;
+    auto ret = proxy->GetDefaultBrightness(brightness);
+    if (ret != ERR_OK) {
+        DISPLAY_HILOGE(COMP_FWK, "GetDefaultBrightness, ret = %{public}d", ret);
+        return BRIGHTNESS_DEFAULT_PROXY;
+    }
+    return brightness;
 }
 
 uint32_t DisplayPowerMgrClient::GetMaxBrightness()
 {
     auto proxy = GetProxy();
     RETURN_IF_WITH_RET(proxy == nullptr, BRIGHTNESS_MAX);
-    return proxy->GetMaxBrightness();
+    uint32_t brightness = BRIGHTNESS_DEFAULT_PROXY;
+    auto ret = proxy->GetMaxBrightness(brightness);
+    if (ret != ERR_OK) {
+        DISPLAY_HILOGE(COMP_FWK, "GetMaxBrightness, ret = %{public}d", ret);
+        return BRIGHTNESS_DEFAULT_PROXY;
+    }
+    return brightness;
 }
 
 uint32_t DisplayPowerMgrClient::GetMinBrightness()
 {
     auto proxy = GetProxy();
     RETURN_IF_WITH_RET(proxy == nullptr, BRIGHTNESS_MIN);
-    return proxy->GetMinBrightness();
+    uint32_t brightness = BRIGHTNESS_DEFAULT_PROXY;
+    auto ret = proxy->GetMinBrightness(brightness);
+    if (ret != ERR_OK) {
+        DISPLAY_HILOGE(COMP_FWK, "GetMinBrightness, ret = %{public}d", ret);
+        return BRIGHTNESS_DEFAULT_PROXY;
+    }
+    return brightness;
 }
 
 bool DisplayPowerMgrClient::AdjustBrightness(uint32_t value, uint32_t duration, uint32_t id)
 {
     auto proxy = GetProxy();
     RETURN_IF_WITH_RET(proxy == nullptr, false);
-    return proxy->AdjustBrightness(id, value, duration);
+    bool result = false;
+    auto ret = proxy->AdjustBrightness(id, value, duration, result);
+    if (ret != ERR_OK) {
+        DISPLAY_HILOGE(COMP_FWK, "AdjustBrightness, ret = %{public}d", ret);
+        return false;
+    }
+    return result;
 }
 
 bool DisplayPowerMgrClient::AutoAdjustBrightness(bool enable)
 {
     auto proxy = GetProxy();
     RETURN_IF_WITH_RET(proxy == nullptr, false);
-    return proxy->AutoAdjustBrightness(enable);
+    bool result = false;
+    auto ret = proxy->AutoAdjustBrightness(enable, result);
+    if (ret != ERR_OK) {
+        DISPLAY_HILOGE(COMP_FWK, "AutoAdjustBrightness, ret = %{public}d", ret);
+        return false;
+    }
+    return result;
 }
 
 bool DisplayPowerMgrClient::IsAutoAdjustBrightness()
 {
     auto proxy = GetProxy();
     RETURN_IF_WITH_RET(proxy == nullptr, false);
-    return proxy->IsAutoAdjustBrightness();
+    bool result = false;
+    auto ret = proxy->IsAutoAdjustBrightness(result);
+    if (ret != ERR_OK) {
+        DISPLAY_HILOGE(COMP_FWK, "IsAutoAdjustBrightness, ret = %{public}d", ret);
+        return false;
+    }
+    return result;
 }
 
 bool DisplayPowerMgrClient::SetScreenOnBrightness()
 {
     auto proxy = GetProxy();
     RETURN_IF_WITH_RET(proxy == nullptr, false);
-    return proxy->SetScreenOnBrightness();
+    bool result = false;
+    auto ret = proxy->SetScreenOnBrightness(result);
+    if (ret != ERR_OK) {
+        DISPLAY_HILOGE(COMP_FWK, "SetScreenOnBrightness, ret = %{public}d", ret);
+        return false;
+    }
+    return result;
 }
 
 bool DisplayPowerMgrClient::RegisterCallback(sptr<IDisplayPowerCallback> callback)
@@ -217,35 +323,65 @@ bool DisplayPowerMgrClient::RegisterCallback(sptr<IDisplayPowerCallback> callbac
 
     auto proxy = GetProxy();
     RETURN_IF_WITH_RET(proxy == nullptr, false);
-    return proxy->RegisterCallback(callback);
+    bool result = false;
+    auto ret = proxy->RegisterCallback(callback, result);
+    if (ret != ERR_OK) {
+        DISPLAY_HILOGE(COMP_FWK, "RegisterCallback, ret = %{public}d", ret);
+        return false;
+    }
+    return result;
 }
 
 bool DisplayPowerMgrClient::BoostBrightness(int32_t timeoutMs, uint32_t displayId)
 {
     auto proxy = GetProxy();
     RETURN_IF_WITH_RET(proxy == nullptr, false);
-    return proxy->BoostBrightness(timeoutMs, displayId);
+    bool result = false;
+    auto ret = proxy->BoostBrightness(timeoutMs, displayId, result);
+    if (ret != ERR_OK) {
+        DISPLAY_HILOGE(COMP_FWK, "BoostBrightness, ret = %{public}d", ret);
+        return false;
+    }
+    return result;
 }
 
 bool DisplayPowerMgrClient::CancelBoostBrightness(uint32_t displayId)
 {
     auto proxy = GetProxy();
     RETURN_IF_WITH_RET(proxy == nullptr, false);
-    return proxy->CancelBoostBrightness(displayId);
+    bool result = false;
+    auto ret = proxy->CancelBoostBrightness(displayId, result);
+    if (ret != ERR_OK) {
+        DISPLAY_HILOGE(COMP_FWK, "CancelBoostBrightness, ret = %{public}d", ret);
+        return false;
+    }
+    return result;
 }
 
 uint32_t DisplayPowerMgrClient::GetDeviceBrightness(uint32_t displayId)
 {
     auto proxy = GetProxy();
     RETURN_IF_WITH_RET(proxy == nullptr, 0);
-    return proxy->GetDeviceBrightness(displayId);
+    uint32_t brightness = BRIGHTNESS_OFF;
+    auto ret = proxy->GetDeviceBrightness(displayId, brightness);
+    if (ret != ERR_OK) {
+        DISPLAY_HILOGE(COMP_FWK, "GetDeviceBrightness, ret = %{public}d", ret);
+        return BRIGHTNESS_OFF;
+    }
+    return brightness;
 }
 
 bool DisplayPowerMgrClient::SetCoordinated(bool coordinated, uint32_t displayId)
 {
     auto proxy = GetProxy();
     RETURN_IF_WITH_RET(proxy == nullptr, 0);
-    return proxy->SetCoordinated(coordinated, displayId);
+    bool result = false;
+    auto ret = proxy->SetCoordinated(coordinated, displayId, result);
+    if (ret != ERR_OK) {
+        DISPLAY_HILOGE(COMP_FWK, "SetCoordinated, ret = %{public}d", ret);
+        return false;
+    }
+    return result;
 }
 
 uint32_t DisplayPowerMgrClient::SetLightBrightnessThreshold(
@@ -253,41 +389,66 @@ uint32_t DisplayPowerMgrClient::SetLightBrightnessThreshold(
 {
     auto proxy = GetProxy();
     RETURN_IF_WITH_RET(proxy == nullptr, 0);
-    return proxy->SetLightBrightnessThreshold(threshold, callback);
+    uint32_t result = BRIGHTNESS_DEFAULT_PROXY;
+    auto ret = proxy->SetLightBrightnessThreshold(threshold, callback, result);
+    if (ret != ERR_OK) {
+        DISPLAY_HILOGE(COMP_FWK, "SetLightBrightnessThreshold, ret = %{public}d", ret);
+        return BRIGHTNESS_DEFAULT_PROXY;
+    }
+    return result;
 }
 
 DisplayErrors DisplayPowerMgrClient::GetError()
 {
+    DisplayErrors tmpError = lastError_;
     if (lastError_ != DisplayErrors::ERR_OK) {
-        DisplayErrors tmpError = lastError_;
         lastError_ = DisplayErrors::ERR_OK;
-        return tmpError;
     }
-    auto proxy = GetProxy();
-    RETURN_IF_WITH_RET(proxy == nullptr, DisplayErrors::ERR_CONNECTION_FAIL);
-    return proxy->GetError();
+    return tmpError;
 }
 
 bool DisplayPowerMgrClient::SetMaxBrightness(double value, uint32_t enterTestMode)
 {
     auto proxy = GetProxy();
     RETURN_IF_WITH_RET(proxy == nullptr, false);
-    return proxy->SetMaxBrightness(value, enterTestMode);
+    bool result = false;
+    int32_t displayError = ERR_OK;
+    auto ret = proxy->SetMaxBrightness(value, enterTestMode, result, displayError);
+    if (ret != ERR_OK) {
+        DISPLAY_HILOGE(COMP_FWK, "SetMaxBrightness, ret = %{public}d", ret);
+        return false;
+    }
+    lastError_ = static_cast<DisplayErrors>(displayError);
+    return result;
 }
 
 bool DisplayPowerMgrClient::SetMaxBrightnessNit(uint32_t maxNit, uint32_t enterTestMode)
 {
     auto proxy = GetProxy();
     RETURN_IF_WITH_RET(proxy == nullptr, false);
-    return proxy->SetMaxBrightnessNit(maxNit, enterTestMode);
+    bool result = false;
+    int32_t displayError = ERR_OK;
+    auto ret = proxy->SetMaxBrightnessNit(maxNit, enterTestMode, result, displayError);
+    if (ret != ERR_OK) {
+        DISPLAY_HILOGE(COMP_FWK, "SetMaxBrightnessNit, ret = %{public}d", ret);
+        return false;
+    }
+    lastError_ = static_cast<DisplayErrors>(displayError);
+    return result;
 }
 
 int DisplayPowerMgrClient::NotifyBrightnessManagerScreenPowerStatus(uint32_t displayId, uint32_t status)
 {
     auto proxy = GetProxy();
     RETURN_IF_WITH_RET(proxy == nullptr, -1); // -1 means failed
-    int ret = proxy->NotifyScreenPowerStatus(displayId, status);
-    return ret;
+    int32_t result = DEFAULT_VALUE;
+    auto ret = proxy->NotifyScreenPowerStatus(displayId, status, result);
+    if (ret != ERR_OK) {
+        DISPLAY_HILOGE(COMP_FWK, "NotifyBrightnessManagerScreenPowerStatus, ret = %{public}d", ret);
+        return DEFAULT_VALUE;
+    }
+    lastError_ = static_cast<DisplayErrors>(result);
+    return result;
 }
 
 }  // namespace DisplayPowerMgr
diff --git a/state_manager/interfaces/inner_api/BUILD.gn b/state_manager/interfaces/inner_api/BUILD.gn
index 8a05721fa5b5f035f8183e6784af95029f59835d..47ac0d99e50662cc70742a5496d6f867972bb04e 100644
--- a/state_manager/interfaces/inner_api/BUILD.gn
+++ b/state_manager/interfaces/inner_api/BUILD.gn
@@ -26,20 +26,29 @@ config("displaymgr_public_config") {
 
 ohos_shared_library("displaymgr") {
   branch_protector_ret = "pac_ret"
-
+  sanitize = {
+    cfi = true
+    cfi_cross_dso = true
+    debug = false
+  }
   sources = [
     "${displaymgr_framework_path}/native/display_power_mgr_client.cpp",
     "${displaymgr_service_zidl}/src/display_brightness_callback_stub.cpp",
     "${displaymgr_service_zidl}/src/display_power_callback_stub.cpp",
-    "${displaymgr_service_zidl}/src/display_power_mgr_proxy.cpp",
   ]
 
   configs = [
     ":displaymgr_private_config",
     "${displaymgr_utils_path}:coverage_flags",
+    "${displaymgr_root_path}/service:displaymgr_public_config",
+  ]
+
+  public_configs = [
+    ":displaymgr_public_config",
+    "${displaymgr_root_path}/service:displaymgr_public_config",
   ]
 
-  public_configs = [ ":displaymgr_public_config" ]
+  deps = [ "${displaymgr_root_path}/service:displaymgr_proxy" ]
 
   external_deps = [
     "c_utils:utils",
diff --git a/state_manager/interfaces/inner_api/native/include/display_power_mgr_client.h b/state_manager/interfaces/inner_api/native/include/display_power_mgr_client.h
index 286dcf2eb061a864683d718bf8692e6da8e90ba2..aa5d0b5a7e64764ba9fa3fa10e4bc4780a981f74 100644
--- a/state_manager/interfaces/inner_api/native/include/display_power_mgr_client.h
+++ b/state_manager/interfaces/inner_api/native/include/display_power_mgr_client.h
@@ -24,6 +24,7 @@
 #include "idisplay_power_callback.h"
 #include "idisplay_power_mgr.h"
 #include "power_state_machine_info.h"
+#include "display_mgr_errors.h"
 
 namespace OHOS {
 namespace DisplayPowerMgr {
@@ -80,6 +81,7 @@ private:
     sptr<IDisplayPowerMgr> GetProxy();
     void OnRemoteDied(const wptr<IRemoteObject>& remote);
     static constexpr int32_t INVALID_DISPLAY_ID {-1};
+    static constexpr int32_t DEFAULT_MAIN_DISPLAY_ID {0};
     static constexpr uint32_t BRIGHTNESS_OFF {0};
     static constexpr uint32_t BRIGHTNESS_DEFAULT {102};
     static constexpr uint32_t BRIGHTNESS_MAX {255};
diff --git a/state_manager/interfaces/inner_api/native/include/idisplay_power_mgr.h b/state_manager/interfaces/inner_api/native/include/idisplay_power_mgr.h
deleted file mode 100644
index 387104f1eb8b66371cc3bd1d2a84185794f7ff29..0000000000000000000000000000000000000000
--- a/state_manager/interfaces/inner_api/native/include/idisplay_power_mgr.h
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
- * Copyright (c) 2021-2023 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 DISPLAYMGR_IDISPLAY_MGR_H
-#define DISPLAYMGR_IDISPLAY_MGR_H
-
-#include <iremote_broker.h>
-#include <vector>
-
-#include "display_mgr_errors.h"
-#include "display_power_info.h"
-#include "idisplay_brightness_callback.h"
-#include "idisplay_power_callback.h"
-
-namespace OHOS {
-namespace DisplayPowerMgr {
-class IDisplayPowerMgr : public IRemoteBroker {
-public:
-    virtual bool SetDisplayState(uint32_t id, DisplayState state, uint32_t reason) = 0;
-    virtual DisplayState GetDisplayState(uint32_t id) = 0;
-    virtual std::vector<uint32_t> GetDisplayIds() = 0;
-    virtual uint32_t GetMainDisplayId() = 0;
-    virtual bool SetBrightness(uint32_t value, uint32_t displayId, bool continuous) = 0;
-    virtual bool SetMaxBrightness(double value, uint32_t enterTestMode) = 0;
-    virtual bool SetMaxBrightnessNit(uint32_t maxNit, uint32_t enterTestMode) = 0;
-    virtual bool DiscountBrightness(double discount, uint32_t displayId) = 0;
-    virtual bool OverrideBrightness(uint32_t value, uint32_t displayId, uint32_t duration = 500) = 0;
-    virtual bool OverrideDisplayOffDelay(uint32_t delayMs) = 0;
-    virtual bool RestoreBrightness(uint32_t displayId, uint32_t duration = 500) = 0;
-    virtual uint32_t GetBrightness(uint32_t displayId) = 0;
-    virtual uint32_t GetDefaultBrightness() = 0;
-    virtual uint32_t GetMaxBrightness() = 0;
-    virtual uint32_t GetMinBrightness() = 0;
-    virtual bool AdjustBrightness(uint32_t id, int32_t value, uint32_t duration) = 0;
-    virtual bool AutoAdjustBrightness(bool enable) = 0;
-    virtual bool IsAutoAdjustBrightness() = 0;
-    virtual bool SetScreenOnBrightness() = 0;
-    virtual bool RegisterCallback(sptr<IDisplayPowerCallback> callback) = 0;
-    virtual bool BoostBrightness(int32_t timeoutMs, uint32_t displayId) = 0;
-    virtual bool CancelBoostBrightness(uint32_t displayId) = 0;
-    virtual uint32_t GetDeviceBrightness(uint32_t displayId) = 0;
-    virtual bool SetCoordinated(bool coordinated, uint32_t displayId) = 0;
-    virtual uint32_t SetLightBrightnessThreshold(
-        std::vector<int32_t> threshold, sptr<IDisplayBrightnessCallback> callback) = 0;
-    virtual DisplayErrors GetError() = 0;
-    virtual int NotifyScreenPowerStatus(uint32_t displayId, uint32_t status) = 0;
-
-    DECLARE_INTERFACE_DESCRIPTOR(u"ohos.displaypowermgr.IDisplayPowerMgr");
-};
-} // namespace DisplayPowerMgr
-} // namespace OHOS
-#endif // DISPLAYMGR_IDISPLAY_MGR_H
diff --git a/state_manager/service/BUILD.gn b/state_manager/service/BUILD.gn
index 820ad3f896b7e3d2d6b1a8b34b2f5c6f28e9796e..1ba2296295662668b6f12227a24cb06eeab72601 100644
--- a/state_manager/service/BUILD.gn
+++ b/state_manager/service/BUILD.gn
@@ -11,6 +11,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import("//build/config/components/idl_tool/idl.gni")
 import("../../displaymgr.gni")
 
 config("displaymgr_private_config") {
@@ -21,6 +22,7 @@ config("displaymgr_public_config") {
   include_dirs = [
     "native/include",
     "zidl/include",
+    "${target_gen_dir}",
   ]
 }
 
@@ -33,6 +35,7 @@ ohos_shared_library("displaymgrservice") {
   branch_protector_ret = "pac_ret"
 
   sources = [
+    "${displaymgr_utils_path}/native/src/display_xcollie.cpp",
     "native/src/display_auto_brightness.cpp",
     "native/src/display_common_event_mgr.cpp",
     "native/src/display_param_helper.cpp",
@@ -44,7 +47,6 @@ ohos_shared_library("displaymgrservice") {
     "native/src/screen_controller.cpp",
     "zidl/src/display_brightness_callback_proxy.cpp",
     "zidl/src/display_power_callback_proxy.cpp",
-    "zidl/src/display_power_mgr_stub.cpp",
   ]
 
   configs = [
@@ -53,6 +55,9 @@ ohos_shared_library("displaymgrservice") {
     "${displaymgr_utils_path}:coverage_flags",
   ]
 
+  deps = [
+    "${displaymgr_root_path}/service:displaymgr_stub",
+  ]
   public_configs = [
     ":displaymgr_public_config",
     "${brightnessmgr_root_path}:brightness_manager_config",
@@ -100,15 +105,65 @@ ohos_shared_library("displaymgrservice") {
   part_name = "${displaymgr_part_name}"
 }
 
-ohos_shared_library("displaymgr_stub") {
-  sources = [ "zidl/src/display_power_mgr_stub.cpp" ]
+idl_gen_interface("displaymgr_interface") {
+  sources = [
+    "IDisplayPowerMgr.idl"
+  ]
+  configs = [
+    "${displaymgr_utils_path}:utils_config",
+    ":displaymgr_private_config",
+    "${displaymgr_utils_path}:coverage_flags",
+  ]
+  log_domainid = "0xD002982"
+  log_tag = "DisplayPowerSvc"
+  part_name = "${displaymgr_part_name}"
+  subsystem_name = "powermgr"
+}
+
+ohos_source_set("displaymgr_proxy") {
+  sanitize = {
+    cfi = true
+    cfi_cross_dso = true
+    debug = false
+  }
+  output_values = get_target_outputs(":displaymgr_interface")
+  sources = filter_include(output_values, [ "*_proxy.cpp" ])
 
   configs = [
     "${displaymgr_utils_path}:utils_config",
     ":displaymgr_private_config",
     "${displaymgr_utils_path}:coverage_flags",
   ]
+  deps = [ ":displaymgr_interface" ]
+  public_configs = [ ":displaymgr_public_config" ]
+
+  external_deps = [
+    "c_utils:utils",
+    "hicollie:libhicollie",
+    "hilog:libhilog",
+    "ipc:ipc_core",
+    "power_manager:power_setting",
+    "safwk:system_ability_fwk",
+  ]
+  part_name = "${displaymgr_part_name}"
+  subsystem_name = "powermgr"
+}
 
+ohos_source_set("displaymgr_stub") {
+  sanitize = {
+    cfi = true
+    cfi_cross_dso = true
+    debug = false
+  }
+  output_values = get_target_outputs(":displaymgr_interface")
+  sources = filter_include(output_values, [ "*_stub.cpp" ])
+  
+  configs = [
+    "${displaymgr_utils_path}:utils_config",
+    ":displaymgr_private_config",
+    "${displaymgr_utils_path}:coverage_flags",
+  ]
+  deps = [ ":displaymgr_interface" ]
   public_configs = [ ":displaymgr_public_config" ]
 
   external_deps = [
diff --git a/state_manager/service/IDisplayPowerMgr.idl b/state_manager/service/IDisplayPowerMgr.idl
new file mode 100644
index 0000000000000000000000000000000000000000..a09a1342f26d20a3a2ac460868140943731bc343
--- /dev/null
+++ b/state_manager/service/IDisplayPowerMgr.idl
@@ -0,0 +1,53 @@
+/*
+ * 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.
+ */
+
+interface OHOS.DisplayPowerMgr.IDisplayBrightnessCallback;
+interface OHOS.DisplayPowerMgr.IDisplayPowerCallback;
+
+interface OHOS.DisplayPowerMgr.IDisplayPowerMgr {
+    [ipccode 0] void SetDisplayState([in] unsigned int id, [in] unsigned int state, [in] unsigned int reason,
+        [out] boolean bResult);
+    void GetDisplayState([in] unsigned int id, [out] int displayState); 
+    void GetDisplayIds([out] unsigned int[] ids);
+    void GetMainDisplayId([out] unsigned int id);
+    void SetBrightness([in] unsigned int value, [in] unsigned int displayId, [in] boolean continuous,
+        [out] boolean bResult, [out] int retCode);
+    void DiscountBrightness([in] double value, [in] unsigned int displayId, [out] boolean bResult);
+    void OverrideBrightness([in] unsigned int value, [in] unsigned int displayId, [in] unsigned int duration,
+        [out] boolean bResult);
+    void OverrideDisplayOffDelay([in] unsigned int delayMs, [out] boolean bResult);
+    void RestoreBrightness([in] unsigned int displayId, [in] unsigned int duration, [out] boolean bResult);
+    void GetBrightness([in] unsigned int displayId, [out] unsigned int brightness);
+    void GetDefaultBrightness([out] unsigned int defaultBrightness);
+    void GetMaxBrightness([out] unsigned int maxBrightness);
+    void GetMinBrightness([out] unsigned int minBrightness);
+    void AdjustBrightness([in] unsigned int id, [in] int value, [in] unsigned int duration, [out] boolean bResult);
+    void AutoAdjustBrightness([in] boolean enable, [out] boolean bResult);
+    void IsAutoAdjustBrightness([out] boolean bResult);
+    void RegisterCallback([in] IDisplayPowerCallback displayPowercallback, [out] boolean bResult);
+    void BoostBrightness([in] int timeoutMs, [in] unsigned int displayId, [out] boolean bResult);
+    void CancelBoostBrightness([in] unsigned int displayId, [out] boolean bResult);
+    void GetDeviceBrightness([in] unsigned int displayId, [out] unsigned int deviceBrightness);
+    void SetCoordinated([in] boolean coordinated, [in] unsigned int displayId, [out] boolean bResult);
+    [ipccode 21] void SetLightBrightnessThreshold([in] int[] threshold,
+        [in] IDisplayBrightnessCallback displayBrightnessCallback, [out] unsigned int retCode);
+    void SetMaxBrightness([in] double value, [in] unsigned int enterTestMode, [out] boolean bResult,
+        [out] int retCode);
+    void SetMaxBrightnessNit([in] unsigned int maxNit, [in] unsigned int enterTestMode, [out] boolean bResult,
+        [out] int retCode);
+    void NotifyScreenPowerStatus([in] unsigned int displayId, [in] unsigned int displayPowerStatus,
+        [out] int retCode);
+    void SetScreenOnBrightness([out] boolean bResult);
+}
\ No newline at end of file
diff --git a/state_manager/service/native/include/display_power_mgr_service.h b/state_manager/service/native/include/display_power_mgr_service.h
index 3f7ea46d274c81bb6138cc37ca1b0a80c8dfde30..e2522ac67fecf49d87204ca568e9cadeea779e06 100644
--- a/state_manager/service/native/include/display_power_mgr_service.h
+++ b/state_manager/service/native/include/display_power_mgr_service.h
@@ -34,6 +34,7 @@
 #include "display_power_info.h"
 #include "display_common.h"
 #include "display_power_mgr_stub.h"
+#include "display_xcollie.h"
 #include "screen_controller.h"
 #include "brightness_manager.h"
 #include "ffrt_utils.h"
@@ -43,35 +44,68 @@ namespace DisplayPowerMgr {
 class DisplayPowerMgrService : public DisplayPowerMgrStub {
 public:
     virtual ~DisplayPowerMgrService() = default;
-    virtual bool SetDisplayState(uint32_t id, DisplayState state, uint32_t reason) override;
-    virtual DisplayState GetDisplayState(uint32_t id) override;
-    virtual std::vector<uint32_t> GetDisplayIds() override;
-    virtual uint32_t GetMainDisplayId() override;
-    virtual bool SetBrightness(uint32_t value, uint32_t displayId, bool continuous = false) override;
-    virtual bool SetMaxBrightness(double value, uint32_t mode) override;
-    virtual bool SetMaxBrightnessNit(uint32_t maxNit, uint32_t mode) override;
-    virtual bool DiscountBrightness(double discount, uint32_t displayId) override;
-    virtual bool OverrideBrightness(uint32_t value, uint32_t displayId, uint32_t duration = 500) override;
-    virtual bool OverrideDisplayOffDelay(uint32_t delayMs) override;
-    virtual bool RestoreBrightness(uint32_t displayId, uint32_t duration = 500) override;
-    virtual uint32_t GetBrightness(uint32_t displayId) override;
-    virtual uint32_t GetDefaultBrightness() override;
-    virtual uint32_t GetMaxBrightness() override;
-    virtual uint32_t GetMinBrightness() override;
-    virtual bool AdjustBrightness(uint32_t id, int32_t value, uint32_t duration) override;
-    virtual bool AutoAdjustBrightness(bool enable) override;
-    virtual bool IsAutoAdjustBrightness() override;
-    virtual bool SetScreenOnBrightness() override;
-    virtual bool RegisterCallback(sptr<IDisplayPowerCallback> callback) override;
-    virtual bool BoostBrightness(int32_t timeoutMs, uint32_t displayId) override;
-    virtual bool CancelBoostBrightness(uint32_t displayId) override;
-    virtual uint32_t GetDeviceBrightness(uint32_t displayId) override;
-    virtual bool SetCoordinated(bool coordinated, uint32_t displayId) override;
-    virtual uint32_t SetLightBrightnessThreshold(
-        std::vector<int32_t> threshold, sptr<IDisplayBrightnessCallback> callback) override;
-    virtual int NotifyScreenPowerStatus(uint32_t displayId, uint32_t displayPowerStatus) override;
+
+    int32_t SetDisplayState(uint32_t id, uint32_t state, uint32_t reason, bool& result) override;
+    int32_t GetDisplayState(uint32_t id, int32_t& displayState) override;
+    int32_t GetDisplayIds(std::vector<uint32_t>& ids) override;
+    int32_t GetMainDisplayId(uint32_t& id) override;
+    int32_t SetBrightness(uint32_t value, uint32_t displayId, bool continuous, bool& result,
+        int32_t& displayError) override;
+    int32_t SetMaxBrightness(double value, uint32_t mode, bool& result, int32_t& displayError) override;
+    int32_t SetMaxBrightnessNit(uint32_t maxNit, uint32_t mode, bool& result, int32_t& displayError) override;
+    int32_t DiscountBrightness(double discount, uint32_t displayId, bool& result) override;
+    int32_t OverrideBrightness(uint32_t value, uint32_t displayId, uint32_t duration, bool& result) override;
+    int32_t OverrideDisplayOffDelay(uint32_t delayMs, bool& result) override;
+
+    int32_t RestoreBrightness(uint32_t displayId, uint32_t duration, bool& result) override;
+
+    int32_t GetBrightness(uint32_t displayId, uint32_t& brightness) override;
+    int32_t GetDefaultBrightness(uint32_t& defaultBrightness) override;
+    int32_t GetMaxBrightness(uint32_t& maxBrightness) override;
+    int32_t GetMinBrightness(uint32_t& minBrightness) override;
+    int32_t AdjustBrightness(uint32_t id, int32_t value, uint32_t duration, bool& result) override;
+    int32_t AutoAdjustBrightness(bool enable, bool& result) override;
+    int32_t IsAutoAdjustBrightness(bool& result) override;
+    int32_t RegisterCallback(const sptr<IDisplayPowerCallback>& callback, bool& result) override;
+    int32_t BoostBrightness(int32_t timeoutMs, uint32_t displayId, bool& result) override;
+    int32_t CancelBoostBrightness(uint32_t displayId, bool& result) override;
+    int32_t GetDeviceBrightness(uint32_t displayId, uint32_t& deviceBrightness) override;
+    int32_t SetCoordinated(bool coordinated, uint32_t displayId, bool& result) override;
+    int32_t SetLightBrightnessThreshold(const std::vector<int32_t>& threshold,
+        const sptr<IDisplayBrightnessCallback>& callback, uint32_t& result) override;
+    int32_t SetScreenOnBrightness(bool& result) override;
+    int32_t NotifyScreenPowerStatus(uint32_t displayId, uint32_t displayPowerStatus, int32_t& result) override;
+private:
+    bool SetDisplayStateInner(uint32_t id, DisplayState state, uint32_t reason);
+    DisplayState GetDisplayStateInner(uint32_t id);
+    std::vector<uint32_t> GetDisplayIdsInner();
+    uint32_t GetMainDisplayIdInner();
+    bool SetBrightnessInner(uint32_t value, uint32_t displayId, bool continuous = false);
+    bool SetMaxBrightnessInner(double value, uint32_t mode);
+    bool SetMaxBrightnessNitInner(uint32_t maxNit, uint32_t mode);
+    bool DiscountBrightnessInner(double discount, uint32_t displayId);
+    bool OverrideBrightnessInner(uint32_t value, uint32_t displayId, uint32_t duration = 500);
+    bool OverrideDisplayOffDelayInner(uint32_t delayMs);
+    bool RestoreBrightnessInner(uint32_t displayId, uint32_t duration = 500);
+    uint32_t GetBrightnessInner(uint32_t displayId);
+    uint32_t GetDefaultBrightnessInner();
+    uint32_t GetMaxBrightnessInner();
+    uint32_t GetMinBrightnessInner();
+    bool AdjustBrightnessInner(uint32_t id, int32_t value, uint32_t duration);
+    bool AutoAdjustBrightnessInner(bool enable);
+    bool IsAutoAdjustBrightnessInner();
+    bool SetScreenOnBrightnessInner();
+    bool RegisterCallbackInner(sptr<IDisplayPowerCallback> callback);
+    bool BoostBrightnessInner(int32_t timeoutMs, uint32_t displayId);
+    bool CancelBoostBrightnessInner(uint32_t displayId);
+    uint32_t GetDeviceBrightnessInner(uint32_t displayId);
+    bool SetCoordinatedInner(bool coordinated, uint32_t displayId);
+    uint32_t SetLightBrightnessThresholdInner(
+        std::vector<int32_t> threshold, sptr<IDisplayBrightnessCallback> callback);
+    int NotifyScreenPowerStatusInner(uint32_t displayId, uint32_t displayPowerStatus);
+public:
+    DisplayErrors GetError();
     virtual int32_t Dump(int32_t fd, const std::vector<std::u16string>& args) override;
-    virtual DisplayErrors GetError() override;
     void NotifyStateChangeCallback(uint32_t displayId, DisplayState state, uint32_t reason);
     void Init();
     void Deinit();
diff --git a/state_manager/service/native/src/display_power_mgr_service.cpp b/state_manager/service/native/src/display_power_mgr_service.cpp
index 3d9fd29a30f4347646ccc02eed613562e7f3b92a..7b4d929c601bcbc6a479b09728c6d2232c3d1b5d 100644
--- a/state_manager/service/native/src/display_power_mgr_service.cpp
+++ b/state_manager/service/native/src/display_power_mgr_service.cpp
@@ -49,6 +49,7 @@ const uint32_t DEFALUT_DISPLAY_ID = 0;
 const uint32_t TEST_MODE = 1;
 const uint32_t NORMAL_MODE = 2;
 const uint32_t BOOTED_COMPLETE_DELAY_TIME = 2000;
+const int32_t ERR_OK = 0;
 }
 
 const uint32_t DisplayPowerMgrService::BRIGHTNESS_MIN = DisplayParamHelper::GetMinBrightness();
@@ -127,13 +128,19 @@ void DisplayPowerMgrService::HandleBootBrightness()
 
 void DisplayPowerMgrService::SetBootCompletedBrightness()
 {
-    uint32_t mainDisplayId = DelayedSpSingleton<DisplayPowerMgrService>::GetInstance()->GetMainDisplayId();
-    uint32_t brightness = DelayedSpSingleton<DisplayPowerMgrService>::GetInstance()->GetBrightness(mainDisplayId);
+    uint32_t mainDisplayId = 0;
+    DelayedSpSingleton<DisplayPowerMgrService>::GetInstance()->GetMainDisplayId(mainDisplayId);
+    uint32_t brightness = BRIGHTNESS_OFF;
+    DelayedSpSingleton<DisplayPowerMgrService>::GetInstance()->GetBrightness(mainDisplayId, brightness);
     uint32_t currentDisplayId = BrightnessManager::Get().GetCurrentDisplayId(mainDisplayId);
-    DisplayState state = DelayedSpSingleton<DisplayPowerMgrService>::GetInstance()->GetDisplayState(mainDisplayId);
+    int32_t state = static_cast<int32_t>(DisplayState::DISPLAY_UNKNOWN);
+    DelayedSpSingleton<DisplayPowerMgrService>::GetInstance()->GetDisplayState(mainDisplayId, state);
     BrightnessManager::Get().SetDisplayId(currentDisplayId);
-    BrightnessManager::Get().SetDisplayState(currentDisplayId, state, 0);
-    DelayedSpSingleton<DisplayPowerMgrService>::GetInstance()->SetBrightness(brightness, mainDisplayId);
+    BrightnessManager::Get().SetDisplayState(currentDisplayId, static_cast<DisplayState>(state), 0);
+    bool result = false;
+    int32_t errCode = 0;
+    DelayedSpSingleton<DisplayPowerMgrService>::GetInstance()->SetBrightness(brightness, mainDisplayId, false,
+        result, errCode);
     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "SetBootCompletedBrightness currentDisplayId=%{public}d", currentDisplayId);
 }
 
@@ -141,13 +148,15 @@ void DisplayPowerMgrService::SetBootCompletedAutoBrightness()
 {
     bool enable = GetSettingAutoBrightness();
     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "SetBootCompletedAutoBrightness enable=%{public}d", enable);
-    DelayedSpSingleton<DisplayPowerMgrService>::GetInstance()->AutoAdjustBrightness(enable);
+    bool result = false;
+    DelayedSpSingleton<DisplayPowerMgrService>::GetInstance()->AutoAdjustBrightness(enable, result);
     BrightnessManager::Get().AutoAdjustBrightness(enable);
 }
 
 void DisplayPowerMgrService::RegisterSettingObservers()
 {
-    uint32_t mainDisplayId = DelayedSpSingleton<DisplayPowerMgrService>::GetInstance()->GetMainDisplayId();
+    uint32_t mainDisplayId = 0;
+    DelayedSpSingleton<DisplayPowerMgrService>::GetInstance()->GetMainDisplayId(mainDisplayId);
     auto controllerMap = DelayedSpSingleton<DisplayPowerMgrService>::GetInstance()->controllerMap_;
     auto iter = controllerMap.find(mainDisplayId);
     if (iter != controllerMap.end()) {
@@ -158,7 +167,8 @@ void DisplayPowerMgrService::RegisterSettingObservers()
 
 void DisplayPowerMgrService::UnregisterSettingObservers()
 {
-    uint32_t mainDisplayId = DelayedSpSingleton<DisplayPowerMgrService>::GetInstance()->GetMainDisplayId();
+    uint32_t mainDisplayId = 0;
+    DelayedSpSingleton<DisplayPowerMgrService>::GetInstance()->GetMainDisplayId(mainDisplayId);
     auto controllerMap = DelayedSpSingleton<DisplayPowerMgrService>::GetInstance()->controllerMap_;
     auto iter = controllerMap.find(mainDisplayId);
     if (iter != controllerMap.end()) {
@@ -176,20 +186,22 @@ void DisplayPowerMgrService::RegisterSettingAutoBrightnessObserver()
 void DisplayPowerMgrService::AutoBrightnessSettingUpdateFunc(const std::string& key)
 {
     bool isSettingEnable = GetSettingAutoBrightness(key);
-    bool isSystemEnable = DelayedSpSingleton<DisplayPowerMgrService>::GetInstance()->IsAutoAdjustBrightness();
+    bool isSystemEnable = false;
+    DelayedSpSingleton<DisplayPowerMgrService>::GetInstance()->IsAutoAdjustBrightness(isSystemEnable);
     if (isSettingEnable == isSystemEnable) {
         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "no need change autoAdjustSwitch");
         return;
     }
     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "AutoBrightnessSettingUpdateFunc isSettingEnable=%{public}d", isSettingEnable);
     BrightnessManager::Get().AutoAdjustBrightness(isSettingEnable);
-    DelayedSpSingleton<DisplayPowerMgrService>::GetInstance()->AutoAdjustBrightness(isSettingEnable);
+    bool result = false;
+    DelayedSpSingleton<DisplayPowerMgrService>::GetInstance()->AutoAdjustBrightness(isSettingEnable, result);
     if (!isSettingEnable) {
         DelayedSpSingleton<DisplayPowerMgrService>::GetInstance()->ClearOffset();
     }
 }
 
-bool DisplayPowerMgrService::SetScreenOnBrightness()
+bool DisplayPowerMgrService::SetScreenOnBrightnessInner()
 {
     if (!Permission::IsSystem()) {
         return false;
@@ -224,7 +236,7 @@ void DisplayPowerMgrService::UnregisterSettingAutoBrightnessObserver()
     DisplaySettingHelper::UnregisterSettingAutoBrightnessObserver();
 }
 
-bool DisplayPowerMgrService::SetDisplayState(uint32_t id, DisplayState state, uint32_t reason)
+bool DisplayPowerMgrService::SetDisplayStateInner(uint32_t id, DisplayState state, uint32_t reason)
 {
     if (!Permission::IsSystem()) {
         return false;
@@ -235,7 +247,7 @@ bool DisplayPowerMgrService::SetDisplayState(uint32_t id, DisplayState state, ui
         if (id != DEFALUT_DISPLAY_ID) {
             return false;
         }
-        id = GetMainDisplayId();
+        id = GetMainDisplayIdInner();
         iterator = controllerMap_.find(id);
         if (iterator == controllerMap_.end()) {
             return false;
@@ -272,7 +284,7 @@ bool DisplayPowerMgrService::SetDisplayState(uint32_t id, DisplayState state, ui
     return iterator->second->UpdateState(state, reason);
 }
 
-DisplayState DisplayPowerMgrService::GetDisplayState(uint32_t id)
+DisplayState DisplayPowerMgrService::GetDisplayStateInner(uint32_t id)
 {
     DISPLAY_HILOGD(COMP_SVC, "GetDisplayState %{public}d", id);
     auto iterator = controllerMap_.find(id);
@@ -280,7 +292,7 @@ DisplayState DisplayPowerMgrService::GetDisplayState(uint32_t id)
         if (id != DEFALUT_DISPLAY_ID) {
             return DisplayState::DISPLAY_UNKNOWN;
         }
-        id = GetMainDisplayId();
+        id = GetMainDisplayIdInner();
         iterator = controllerMap_.find(id);
         if (iterator == controllerMap_.end()) {
             return DisplayState::DISPLAY_UNKNOWN;
@@ -289,7 +301,7 @@ DisplayState DisplayPowerMgrService::GetDisplayState(uint32_t id)
     return iterator->second->GetState();
 }
 
-std::vector<uint32_t> DisplayPowerMgrService::GetDisplayIds()
+std::vector<uint32_t> DisplayPowerMgrService::GetDisplayIdsInner()
 {
     std::vector<uint32_t> ids;
     for (auto& iter: controllerMap_) {
@@ -298,14 +310,14 @@ std::vector<uint32_t> DisplayPowerMgrService::GetDisplayIds()
     return ids;
 }
 
-uint32_t DisplayPowerMgrService::GetMainDisplayId()
+uint32_t DisplayPowerMgrService::GetMainDisplayIdInner()
 {
     uint32_t id = ScreenAction::GetDefaultDisplayId();
     DISPLAY_HILOGD(COMP_SVC, "GetMainDisplayId %{public}d", id);
     return id;
 }
 
-bool DisplayPowerMgrService::SetBrightness(uint32_t value, uint32_t displayId, bool continuous)
+bool DisplayPowerMgrService::SetBrightnessInner(uint32_t value, uint32_t displayId, bool continuous)
 {
     if (!Permission::IsSystem()) {
         lastError_ = DisplayErrors::ERR_SYSTEM_API_DENIED;
@@ -318,7 +330,7 @@ bool DisplayPowerMgrService::SetBrightness(uint32_t value, uint32_t displayId, b
     return BrightnessManager::Get().SetBrightness(brightness, 0, continuous);
 }
 
-bool DisplayPowerMgrService::DiscountBrightness(double discount, uint32_t displayId)
+bool DisplayPowerMgrService::DiscountBrightnessInner(double discount, uint32_t displayId)
 {
     if (!Permission::IsSystem()) {
         return false;
@@ -330,7 +342,7 @@ bool DisplayPowerMgrService::DiscountBrightness(double discount, uint32_t displa
     return BrightnessManager::Get().DiscountBrightness(discount);
 }
 
-bool DisplayPowerMgrService::OverrideBrightness(uint32_t brightness, uint32_t displayId, uint32_t duration)
+bool DisplayPowerMgrService::OverrideBrightnessInner(uint32_t brightness, uint32_t displayId, uint32_t duration)
 {
     if (!Permission::IsSystem()) {
         return false;
@@ -344,12 +356,12 @@ bool DisplayPowerMgrService::OverrideBrightness(uint32_t brightness, uint32_t di
     return BrightnessManager::Get().OverrideBrightness(brightness, duration);
 }
 
-bool DisplayPowerMgrService::OverrideDisplayOffDelay(uint32_t delayMs)
+bool DisplayPowerMgrService::OverrideDisplayOffDelayInner(uint32_t delayMs)
 {
     if (!Permission::IsSystem()) {
         return false;
     }
-    if (GetDisplayState(GetMainDisplayId()) != DisplayState::DISPLAY_ON || delayMs == DELAY_TIME_UNSET) {
+    if (GetDisplayStateInner(GetMainDisplayIdInner()) != DisplayState::DISPLAY_ON || delayMs == DELAY_TIME_UNSET) {
         isDisplayDelayOff_ = false;
         return isDisplayDelayOff_;
     }
@@ -360,7 +372,7 @@ bool DisplayPowerMgrService::OverrideDisplayOffDelay(uint32_t delayMs)
     return isDisplayDelayOff_;
 }
 
-bool DisplayPowerMgrService::RestoreBrightness(uint32_t displayId, uint32_t duration)
+bool DisplayPowerMgrService::RestoreBrightnessInner(uint32_t displayId, uint32_t duration)
 {
     if (!Permission::IsSystem()) {
         return false;
@@ -378,7 +390,7 @@ bool DisplayPowerMgrService::RestoreBrightness(uint32_t displayId, uint32_t dura
     return iter->second->RestoreBrightness();
 }
 
-uint32_t DisplayPowerMgrService::GetBrightness(uint32_t displayId)
+uint32_t DisplayPowerMgrService::GetBrightnessInner(uint32_t displayId)
 {
     DISPLAY_HILOGD(FEAT_BRIGHTNESS, "GetBrightness displayId=%{public}u", displayId);
     auto iter = controllerMap_.find(displayId);
@@ -388,22 +400,22 @@ uint32_t DisplayPowerMgrService::GetBrightness(uint32_t displayId)
     return BrightnessManager::Get().GetBrightness();
 }
 
-uint32_t DisplayPowerMgrService::GetDefaultBrightness()
+uint32_t DisplayPowerMgrService::GetDefaultBrightnessInner()
 {
     return BRIGHTNESS_DEFAULT;
 }
 
-uint32_t DisplayPowerMgrService::GetMaxBrightness()
+uint32_t DisplayPowerMgrService::GetMaxBrightnessInner()
 {
     return BRIGHTNESS_MAX;
 }
 
-uint32_t DisplayPowerMgrService::GetMinBrightness()
+uint32_t DisplayPowerMgrService::GetMinBrightnessInner()
 {
     return BRIGHTNESS_MIN;
 }
 
-bool DisplayPowerMgrService::AdjustBrightness(uint32_t id, int32_t value, uint32_t duration)
+bool DisplayPowerMgrService::AdjustBrightnessInner(uint32_t id, int32_t value, uint32_t duration)
 {
     if (!Permission::IsSystem()) {
         return false;
@@ -426,12 +438,12 @@ bool DisplayPowerMgrService::IsSupportLightSensor(void)
     return BrightnessManager::Get().IsSupportLightSensor();
 }
 
-bool DisplayPowerMgrService::IsAutoAdjustBrightness(void)
+bool DisplayPowerMgrService::IsAutoAdjustBrightnessInner()
 {
     return BrightnessManager::Get().IsAutoAdjustBrightness();
 }
 
-bool DisplayPowerMgrService::AutoAdjustBrightness(bool enable)
+bool DisplayPowerMgrService::AutoAdjustBrightnessInner(bool enable)
 {
     if (!Permission::IsSystem()) {
         return false;
@@ -440,7 +452,7 @@ bool DisplayPowerMgrService::AutoAdjustBrightness(bool enable)
     return BrightnessManager::Get().AutoAdjustBrightness(enable);
 }
 
-bool DisplayPowerMgrService::RegisterCallback(sptr<IDisplayPowerCallback> callback)
+bool DisplayPowerMgrService::RegisterCallbackInner(sptr<IDisplayPowerCallback> callback)
 {
     if (!Permission::IsSystem()) {
         return false;
@@ -464,7 +476,7 @@ bool DisplayPowerMgrService::RegisterCallback(sptr<IDisplayPowerCallback> callba
     return true;
 }
 
-bool DisplayPowerMgrService::BoostBrightness(int32_t timeoutMs, uint32_t displayId)
+bool DisplayPowerMgrService::BoostBrightnessInner(int32_t timeoutMs, uint32_t displayId)
 {
     if (!Permission::IsSystem()) {
         return false;
@@ -476,7 +488,7 @@ bool DisplayPowerMgrService::BoostBrightness(int32_t timeoutMs, uint32_t display
     return BrightnessManager::Get().BoostBrightness(timeoutMs);
 }
 
-bool DisplayPowerMgrService::CancelBoostBrightness(uint32_t displayId)
+bool DisplayPowerMgrService::CancelBoostBrightnessInner(uint32_t displayId)
 {
     if (!Permission::IsSystem()) {
         return false;
@@ -491,7 +503,7 @@ bool DisplayPowerMgrService::CancelBoostBrightness(uint32_t displayId)
     return iter->second->CancelBoostBrightness();
 }
 
-uint32_t DisplayPowerMgrService::GetDeviceBrightness(uint32_t displayId)
+uint32_t DisplayPowerMgrService::GetDeviceBrightnessInner(uint32_t displayId)
 {
     DISPLAY_HILOGD(FEAT_BRIGHTNESS, "GetDeviceBrightness displayId=%{public}u", displayId);
     auto iter = controllerMap_.find(displayId);
@@ -501,7 +513,7 @@ uint32_t DisplayPowerMgrService::GetDeviceBrightness(uint32_t displayId)
     return BrightnessManager::Get().GetDeviceBrightness();
 }
 
-bool DisplayPowerMgrService::SetCoordinated(bool coordinated, uint32_t displayId)
+bool DisplayPowerMgrService::SetCoordinatedInner(bool coordinated, uint32_t displayId)
 {
     if (!Permission::IsSystem()) {
         return false;
@@ -513,7 +525,7 @@ bool DisplayPowerMgrService::SetCoordinated(bool coordinated, uint32_t displayId
     return true;
 }
 
-uint32_t DisplayPowerMgrService::SetLightBrightnessThreshold(
+uint32_t DisplayPowerMgrService::SetLightBrightnessThresholdInner(
     std::vector<int32_t> threshold, sptr<IDisplayBrightnessCallback> callback)
 {
     if (!Permission::IsSystem()) {
@@ -568,13 +580,13 @@ int32_t DisplayPowerMgrService::Dump(int32_t fd, const std::vector<std::u16strin
     result.append("\n");
 
     result.append("Auto Adjust Brightness: ");
-    result.append(IsAutoAdjustBrightness() ? "ON" : "OFF");
+    result.append(IsAutoAdjustBrightnessInner() ? "ON" : "OFF");
     result.append("\n");
 #endif
 
-    result.append("Brightness Limits: ").append("Max=" + std::to_string(GetMaxBrightness()) + " ");
-    result.append("Min=" + std::to_string(GetMinBrightness()) + " ");
-    result.append("Default=" + std::to_string(GetDefaultBrightness())).append("\n");
+    result.append("Brightness Limits: ").append("Max=" + std::to_string(GetMaxBrightnessInner()) + " ");
+    result.append("Min=" + std::to_string(GetMinBrightnessInner()) + " ");
+    result.append("Default=" + std::to_string(GetDefaultBrightnessInner())).append("\n");
 
     if (!SaveStringToFd(fd, result)) {
         DISPLAY_HILOGE(COMP_SVC, "Failed to save dump info to fd");
@@ -644,7 +656,7 @@ void DisplayPowerMgrService::CallbackDeathRecipient::OnRemoteDied(const wptr<IRe
 *               2 = exit testMode
 * @return false = set failed; true = set Sucess
 */
-bool DisplayPowerMgrService::SetMaxBrightness(double value, uint32_t mode)
+bool DisplayPowerMgrService::SetMaxBrightnessInner(double value, uint32_t mode)
 {
     if (!Permission::IsSystem()) {
         lastError_ = DisplayErrors::ERR_SYSTEM_API_DENIED;
@@ -675,7 +687,7 @@ bool DisplayPowerMgrService::SetMaxBrightness(double value, uint32_t mode)
 *               2 = exit testMode
 * @return false = set failed; true = set Sucess
 */
-bool DisplayPowerMgrService::SetMaxBrightnessNit(uint32_t maxNit, uint32_t mode)
+bool DisplayPowerMgrService::SetMaxBrightnessNitInner(uint32_t maxNit, uint32_t mode)
 {
     if (!Permission::IsSystem()) {
         lastError_ = DisplayErrors::ERR_SYSTEM_API_DENIED;
@@ -698,7 +710,7 @@ bool DisplayPowerMgrService::SetMaxBrightnessNit(uint32_t maxNit, uint32_t mode)
     return BrightnessManager::Get().SetMaxBrightnessNit(maxNit);
 }
 
-int DisplayPowerMgrService::NotifyScreenPowerStatus(uint32_t displayId, uint32_t displayPowerStatus)
+int DisplayPowerMgrService::NotifyScreenPowerStatusInner(uint32_t displayId, uint32_t displayPowerStatus)
 {
     if (!Permission::IsSystem()) {
         lastError_ = DisplayErrors::ERR_SYSTEM_API_DENIED;
@@ -709,5 +721,195 @@ int DisplayPowerMgrService::NotifyScreenPowerStatus(uint32_t displayId, uint32_t
     return BrightnessManager::Get().NotifyScreenPowerStatus(displayId, displayPowerStatus);
 }
 
+int32_t DisplayPowerMgrService::SetDisplayState(uint32_t id, uint32_t state, uint32_t reason, bool& result)
+{
+    DisplayXCollie displayXCollie("DisplayPowerMgrService::SetDisplayState");
+    result = SetDisplayStateInner(id, static_cast<DisplayState>(state), reason);
+    return ERR_OK;
+}
+
+int32_t DisplayPowerMgrService::GetDisplayState(uint32_t id, int32_t& displayState)
+{
+    DisplayXCollie displayXCollie("DisplayPowerMgrService::GetDisplayState");
+    displayState = static_cast<int32_t>(GetDisplayStateInner(id));
+    return ERR_OK;
+}
+
+int32_t DisplayPowerMgrService::GetDisplayIds(std::vector<uint32_t>& ids)
+{
+    DisplayXCollie displayXCollie("DisplayPowerMgrService::GetDisplayIds");
+    auto idsTemp = GetDisplayIdsInner();
+    ids = std::move(idsTemp);
+    return ERR_OK;
+}
+
+int32_t DisplayPowerMgrService::GetMainDisplayId(uint32_t& id)
+{
+    DisplayXCollie displayXCollie("DisplayPowerMgrService::GetMainDisplayId");
+    id = GetMainDisplayIdInner();
+    return ERR_OK;
+}
+
+int32_t DisplayPowerMgrService::SetBrightness(uint32_t value, uint32_t displayId, bool continuous, bool& result,
+    int32_t& displayError)
+{
+    DisplayXCollie displayXCollie("DisplayPowerMgrService::SetBrightness");
+    result = SetBrightnessInner(value, displayId, continuous);
+    displayError = static_cast<int32_t>(GetError());
+    return ERR_OK;
+}
+
+int32_t DisplayPowerMgrService::DiscountBrightness(double discount, uint32_t displayId, bool& result)
+{
+    DisplayXCollie displayXCollie("DisplayPowerMgrService::DiscountBrightness");
+    result = DiscountBrightnessInner(discount, displayId);
+    return ERR_OK;
+}
+
+int32_t DisplayPowerMgrService::OverrideBrightness(uint32_t brightness, uint32_t displayId, uint32_t duration,
+    bool& result)
+{
+    DisplayXCollie displayXCollie("DisplayPowerMgrService::OverrideBrightness");
+    result = OverrideBrightnessInner(brightness, displayId, duration);
+    return ERR_OK;
+}
+
+int32_t DisplayPowerMgrService::OverrideDisplayOffDelay(uint32_t delayMs, bool& result)
+{
+    DisplayXCollie displayXCollie("DisplayPowerMgrService::OverrideDisplayOffDelay");
+    result = OverrideDisplayOffDelayInner(delayMs);
+    return ERR_OK;
+}
+
+int32_t DisplayPowerMgrService::RestoreBrightness(uint32_t displayId, uint32_t duration, bool& result)
+{
+    DisplayXCollie displayXCollie("DisplayPowerMgrService::GetBrightness");
+    result = RestoreBrightnessInner(displayId, duration);
+    return ERR_OK;
+}
+
+int32_t DisplayPowerMgrService::GetBrightness(uint32_t displayId, uint32_t& brightness)
+{
+    DisplayXCollie displayXCollie("DisplayPowerMgrService::GetBrightness");
+    brightness = GetBrightnessInner(displayId);
+    return ERR_OK;
+}
+
+int32_t DisplayPowerMgrService::GetDefaultBrightness(uint32_t& defaultBrightness)
+{
+    DisplayXCollie displayXCollie("DisplayPowerMgrService::GetDefaultBrightness");
+    defaultBrightness = GetDefaultBrightnessInner();
+    return ERR_OK;
+}
+
+int32_t DisplayPowerMgrService::GetMaxBrightness(uint32_t& maxBrightness)
+{
+    DisplayXCollie displayXCollie("DisplayPowerMgrService::GetMaxBrightness");
+    maxBrightness = GetMaxBrightnessInner();
+    return ERR_OK;
+}
+
+int32_t DisplayPowerMgrService::GetMinBrightness(uint32_t& minBrightness)
+{
+    DisplayXCollie displayXCollie("DisplayPowerMgrService::GetMinBrightness");
+    minBrightness = GetMinBrightnessInner();
+    return ERR_OK;
+}
+
+int32_t DisplayPowerMgrService::AdjustBrightness(uint32_t id, int32_t value, uint32_t duration, bool& result)
+{
+    DisplayXCollie displayXCollie("DisplayPowerMgrService::AdjustBrightness");
+    result = AdjustBrightnessInner(id, value, duration);
+    return ERR_OK;
+}
+
+int32_t DisplayPowerMgrService::AutoAdjustBrightness(bool enable, bool& result)
+{
+    DisplayXCollie displayXCollie("DisplayPowerMgrService::AutoAdjustBrightness");
+    result = AutoAdjustBrightnessInner(enable);
+    return ERR_OK;
+}
+
+int32_t DisplayPowerMgrService::IsAutoAdjustBrightness(bool& result)
+{
+    DisplayXCollie displayXCollie("DisplayPowerMgrService::IsAutoAdjustBrightness");
+    result = IsAutoAdjustBrightnessInner();
+    return ERR_OK;
+}
+
+int32_t DisplayPowerMgrService::RegisterCallback(const sptr<IDisplayPowerCallback>& callback, bool& result)
+{
+    DisplayXCollie displayXCollie("DisplayPowerMgrService::RegisterCallback");
+    result = RegisterCallbackInner(callback);
+    return ERR_OK;
+}
+
+int32_t DisplayPowerMgrService::BoostBrightness(int32_t timeoutMs, uint32_t displayId, bool& result)
+{
+    DisplayXCollie displayXCollie("DisplayPowerMgrService::BoostBrightness");
+    result = BoostBrightnessInner(timeoutMs, displayId);
+    return ERR_OK;
+}
+
+int32_t DisplayPowerMgrService::CancelBoostBrightness(uint32_t displayId, bool& result)
+{
+    DisplayXCollie displayXCollie("DisplayPowerMgrService::CancelBoostBrightness");
+    result = CancelBoostBrightnessInner(displayId);
+    return ERR_OK;
+}
+
+int32_t DisplayPowerMgrService::GetDeviceBrightness(uint32_t displayId, uint32_t& deviceBrightness)
+{
+    DisplayXCollie displayXCollie("DisplayPowerMgrService::GetDeviceBrightness");
+    deviceBrightness = GetDeviceBrightnessInner(displayId);
+    return ERR_OK;
+}
+
+int32_t DisplayPowerMgrService::SetCoordinated(bool coordinated, uint32_t displayId, bool& result)
+{
+    DisplayXCollie displayXCollie("DisplayPowerMgrService::SetCoordinated");
+    result = SetCoordinatedInner(coordinated, displayId);
+    return ERR_OK;
+}
+
+int32_t DisplayPowerMgrService::SetLightBrightnessThreshold(const std::vector<int32_t>& threshold,
+    const sptr<IDisplayBrightnessCallback>& callback, uint32_t& result)
+{
+    DisplayXCollie displayXCollie("DisplayPowerMgrService::SetLightBrightnessThreshold");
+    result = SetLightBrightnessThresholdInner(threshold, callback);
+    return ERR_OK;
+}
+
+int32_t DisplayPowerMgrService::SetMaxBrightness(double value, uint32_t mode, bool& result, int32_t& displayError)
+{
+    DisplayXCollie displayXCollie("DisplayPowerMgrService::SetMaxBrightness");
+    result = SetMaxBrightnessInner(value, mode);
+    displayError = static_cast<int32_t>(GetError());
+    return ERR_OK;
+}
+
+int32_t DisplayPowerMgrService::SetMaxBrightnessNit(uint32_t maxNit, uint32_t mode, bool& result,
+    int32_t& displayError)
+{
+    DisplayXCollie displayXCollie("DisplayPowerMgrService::SetMaxBrightnessNit");
+    result = SetMaxBrightnessNitInner(maxNit, mode);
+    displayError = static_cast<int32_t>(GetError());
+    return ERR_OK;
+}
+
+int32_t DisplayPowerMgrService::SetScreenOnBrightness(bool& result)
+{
+    DisplayXCollie displayXCollie("DisplayPowerMgrService::SetScreenOnBrightness");
+    result = SetScreenOnBrightnessInner();
+    return ERR_OK;
+}
+
+int32_t DisplayPowerMgrService::NotifyScreenPowerStatus(uint32_t displayId, uint32_t displayPowerStatus,
+    int32_t& result)
+{
+    DisplayXCollie displayXCollie("DisplayPowerMgrService::NotifyScreenPowerStatus");
+    result = NotifyScreenPowerStatusInner(displayId, displayPowerStatus);
+    return ERR_OK;
+}
 } // namespace DisplayPowerMgr
 } // namespace OHOS
diff --git a/state_manager/service/native/src/screen_controller.cpp b/state_manager/service/native/src/screen_controller.cpp
index 6b62c1ca79d14641f408683e6d0b0ef293941c83..c763c1e0129f934e8f61bd499b21b2337d74382d 100644
--- a/state_manager/service/native/src/screen_controller.cpp
+++ b/state_manager/service/native/src/screen_controller.cpp
@@ -292,7 +292,8 @@ void ScreenController::OnStateChanged(DisplayState state, uint32_t reason)
         return;
     }
     if (state == DisplayState::DISPLAY_ON) {
-        pms->SetScreenOnBrightness();
+        bool result = false;
+        pms->SetScreenOnBrightness(result);
         // Restore the brightness before screen off
         uint32_t screenOnBrightness = GetScreenOnBrightness();
         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "OnStateChanged set screenOnBrightness=%{public}d", screenOnBrightness);
diff --git a/state_manager/service/zidl/include/display_power_mgr_proxy.h b/state_manager/service/zidl/include/display_power_mgr_proxy.h
deleted file mode 100644
index 4a0ff390050e0a86bd5ac3e54a179cd844d8aeb0..0000000000000000000000000000000000000000
--- a/state_manager/service/zidl/include/display_power_mgr_proxy.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * Copyright (c) 2021-2023 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 DISPLAYMGR_DISPLAY_MGR_PROXY_H
-#define DISPLAYMGR_DISPLAY_MGR_PROXY_H
-
-#include <cstdint>
-#include <vector>
-#include <functional>
-#include <iremote_proxy.h>
-#include "iremote_broker.h"
-#include "iremote_object.h"
-#include "refbase.h"
-#include "display_power_info.h"
-#include "idisplay_power_callback.h"
-#include "idisplay_power_mgr.h"
-
-namespace OHOS {
-namespace DisplayPowerMgr {
-class DisplayPowerMgrProxy : public IRemoteProxy<IDisplayPowerMgr> {
-public:
-    explicit DisplayPowerMgrProxy(const sptr<IRemoteObject>& impl)
-        : IRemoteProxy<IDisplayPowerMgr>(impl) {}
-    ~DisplayPowerMgrProxy() override = default;
-
-    virtual bool SetDisplayState(uint32_t id, DisplayState state, uint32_t reason) override;
-    virtual DisplayState GetDisplayState(uint32_t id) override;
-    virtual std::vector<uint32_t> GetDisplayIds() override;
-    virtual uint32_t GetMainDisplayId() override;
-
-    virtual bool SetBrightness(uint32_t value, uint32_t displayId, bool continuous) override;
-    virtual bool SetMaxBrightness(double value, uint32_t enterTestMode) override;
-    virtual bool SetMaxBrightnessNit(uint32_t maxNit, uint32_t enterTestMode) override;
-    virtual bool DiscountBrightness(double value, uint32_t displayId) override;
-    virtual bool OverrideBrightness(uint32_t value, uint32_t displayId, uint32_t duration = 500) override;
-    virtual bool OverrideDisplayOffDelay(uint32_t delayMs) override;
-    virtual bool RestoreBrightness(uint32_t displayId, uint32_t duration = 500) override;
-    virtual uint32_t GetBrightness(uint32_t displayId) override;
-    virtual uint32_t GetDefaultBrightness() override;
-    virtual uint32_t GetMaxBrightness() override;
-    virtual uint32_t GetMinBrightness() override;
-    virtual bool AdjustBrightness(uint32_t id, int32_t value, uint32_t duration) override;
-    virtual bool AutoAdjustBrightness(bool enable) override;
-    virtual bool IsAutoAdjustBrightness() override;
-    virtual bool SetScreenOnBrightness() override;
-    virtual bool RegisterCallback(sptr<IDisplayPowerCallback> callback) override;
-    virtual bool BoostBrightness(int32_t timeoutMs, uint32_t displayId) override;
-    virtual bool CancelBoostBrightness(uint32_t displayId) override;
-    virtual uint32_t GetDeviceBrightness(uint32_t displayId) override;
-    virtual bool SetCoordinated(bool coordinated, uint32_t displayId) override;
-    virtual uint32_t SetLightBrightnessThreshold(
-        std::vector<int32_t> threshold, sptr<IDisplayBrightnessCallback> callback) override;
-    virtual DisplayErrors GetError() override;
-    virtual int NotifyScreenPowerStatus(uint32_t displayId, uint32_t status) override;
-
-private:
-    static inline BrokerDelegator<DisplayPowerMgrProxy> delegator_;
-    DisplayErrors lastError_ {DisplayErrors::ERR_OK};
-};
-} // namespace DisplayPowerMgr
-} // namespace OHOS
-#endif // DISPLAYMGR_DISPLAY_MGR_PROXY_H
diff --git a/state_manager/service/zidl/include/display_power_mgr_stub.h b/state_manager/service/zidl/include/display_power_mgr_stub.h
deleted file mode 100644
index 5b330270b2f0311731c576e88c76639a6384b6ca..0000000000000000000000000000000000000000
--- a/state_manager/service/zidl/include/display_power_mgr_stub.h
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
- * Copyright (c) 2021-2023 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 DISPLAYMGR_DISPLAY_MGR_STUB_H
-#define DISPLAYMGR_DISPLAY_MGR_STUB_H
-
-#include <cstdint>
-#include <iremote_stub.h>
-#include "refbase.h"
-#include "message_option.h"
-
-#include "idisplay_power_mgr.h"
-
-namespace OHOS {
-namespace DisplayPowerMgr {
-class DisplayPowerMgrStub : public IRemoteStub<IDisplayPowerMgr> {
-public:
-    int32_t OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) override;
-
-private:
-    int32_t RemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option);
-    int32_t SetDisplayStateStub(MessageParcel& data, MessageParcel& reply);
-    int32_t GetDisplayStateStub(MessageParcel& data, MessageParcel& reply);
-    int32_t GetDisplayIdsStub(MessageParcel& data, MessageParcel& reply);
-    int32_t GetMainDisplayIdStub(MessageParcel& data, MessageParcel& reply);
-    int32_t SetBrightnessStub(MessageParcel& data, MessageParcel& reply);
-    int32_t SetMaxBrightnessStub(MessageParcel& data, MessageParcel& reply);
-    int32_t SetMaxBrightnessNitStub(MessageParcel& data, MessageParcel& reply);
-    int32_t DiscountBrightnessStub(MessageParcel& data, MessageParcel& reply);
-    int32_t OverrideBrightnessStub(MessageParcel& data, MessageParcel& reply);
-    int32_t OverrideDisplayOffDelayStub(MessageParcel& data, MessageParcel& reply);
-    int32_t RestoreBrightnessStub(MessageParcel& data, MessageParcel& reply);
-    int32_t GetBrightnessStub(MessageParcel& data, MessageParcel& reply);
-    int32_t GetDefaultBrightnessStub(MessageParcel& data, MessageParcel& reply);
-    int32_t GetMaxBrightnessStub(MessageParcel& data, MessageParcel& reply);
-    int32_t GetMinBrightnessStub(MessageParcel& data, MessageParcel& reply);
-    int32_t AdjustBrightnessStub(MessageParcel& data, MessageParcel& reply);
-    int32_t AutoAdjustBrightnessStub(MessageParcel& data, MessageParcel& reply);
-    int32_t IsAutoAdjustBrightnessStub(MessageParcel& data, MessageParcel& reply);
-    int32_t SetScreenOnBrightnessStub(MessageParcel& data, MessageParcel& reply);
-    int32_t RegisterCallbackStub(MessageParcel& data, MessageParcel& reply);
-    int32_t BoostBrightnessStub(MessageParcel& data, MessageParcel& reply);
-    int32_t CancelBoostBrightnessStub(MessageParcel& data, MessageParcel& reply);
-    int32_t GetDeviceBrightnessStub(MessageParcel& data, MessageParcel& reply);
-    int32_t SetCoordinatedStub(MessageParcel& data, MessageParcel& reply);
-    int32_t SetLightBrightnessThresholdStub(MessageParcel& data, MessageParcel& reply);
-    int32_t ProcessMessage(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option);
-    int32_t NotifyScreenPowerStatusStub(MessageParcel& data, MessageParcel& reply);
-};
-} // namespace DisplayPowerMgr
-} // namespace OHOS
-#endif // DISPLAYMGR_DISPLAY_MGR_STUB_H
diff --git a/state_manager/service/zidl/src/display_power_callback_proxy.cpp b/state_manager/service/zidl/src/display_power_callback_proxy.cpp
index 0dbfca6bed8e79df03563072f3f6c4a6e7cbaa1e..86d33d820d6eae27d9b1ac81e9f864ac193df638 100644
--- a/state_manager/service/zidl/src/display_power_callback_proxy.cpp
+++ b/state_manager/service/zidl/src/display_power_callback_proxy.cpp
@@ -21,6 +21,7 @@
 #include "display_log.h"
 #include "display_common.h"
 #include "display_power_callback_ipc_interface_code.h"
+#include "display_power_info.h"
 
 namespace OHOS {
 namespace DisplayPowerMgr {
diff --git a/state_manager/service/zidl/src/display_power_mgr_proxy.cpp b/state_manager/service/zidl/src/display_power_mgr_proxy.cpp
deleted file mode 100644
index eb2e194948e59f9ad3283b20380789073d75877f..0000000000000000000000000000000000000000
--- a/state_manager/service/zidl/src/display_power_mgr_proxy.cpp
+++ /dev/null
@@ -1,917 +0,0 @@
-/*
- * Copyright (c) 2021-2023 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 "display_power_mgr_proxy.h"
-
-#include "errors.h"
-#include "message_option.h"
-#include "message_parcel.h"
-#include "display_log.h"
-#include "display_common.h"
-#include "display_power_mgr_ipc_interface_code.h"
-
-namespace OHOS {
-namespace DisplayPowerMgr {
-bool DisplayPowerMgrProxy::SetDisplayState(uint32_t id, DisplayState state, uint32_t reason)
-{
-    sptr<IRemoteObject> remote = Remote();
-    RETURN_IF_WITH_RET(remote == nullptr, false);
-
-    bool result = false;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
-        DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
-        return result;
-    }
-
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, id, false);
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, static_cast<uint32_t>(state), false);
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, reason, false);
-
-    int ret = remote->SendRequest(
-        static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::SET_DISPLAY_STATE),
-        data, reply, option);
-    if (ret != ERR_OK) {
-        DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
-        return result;
-    }
-
-    if (!reply.ReadBool(result)) {
-        DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
-        return result;
-    }
-
-    return result;
-}
-
-DisplayState DisplayPowerMgrProxy::GetDisplayState(uint32_t id)
-{
-    sptr<IRemoteObject> remote = Remote();
-    RETURN_IF_WITH_RET(remote == nullptr, DisplayState::DISPLAY_UNKNOWN);
-
-    uint32_t result = 0;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
-        DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
-        return DisplayState::DISPLAY_UNKNOWN;
-    }
-
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, id, DisplayState::DISPLAY_UNKNOWN);
-
-    int ret = remote->SendRequest(
-        static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::GET_DISPLAY_STATE),
-        data, reply, option);
-    if (ret != ERR_OK) {
-        DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
-        return DisplayState::DISPLAY_UNKNOWN;
-    }
-
-    if (!reply.ReadUint32(result)) {
-        DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
-        return DisplayState::DISPLAY_UNKNOWN;
-    }
-
-    return static_cast<DisplayState>(result);
-}
-
-std::vector<uint32_t> DisplayPowerMgrProxy::GetDisplayIds()
-{
-    sptr<IRemoteObject> remote = Remote();
-    std::vector<uint32_t> result;
-
-    RETURN_IF_WITH_RET(remote == nullptr, result);
-
-    uint32_t count = 0;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
-        DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
-        return result;
-    }
-
-    int ret = remote->SendRequest(
-        static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::GET_DISPLAY_IDS),
-        data, reply, option);
-    if (ret != ERR_OK) {
-        DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
-        return result;
-    }
-
-    if (!reply.ReadUint32(count)) {
-        DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
-        return result;
-    }
-
-    for (uint32_t i = 0; i < count; i++) {
-        uint32_t value;
-        if (reply.ReadUint32(value)) {
-            result.push_back(value);
-        } else {
-            DISPLAY_HILOGE(COMP_FWK, "read value fail: %{public}d", i);
-        }
-    }
-
-    return result;
-}
-
-uint32_t DisplayPowerMgrProxy::GetMainDisplayId()
-{
-    sptr<IRemoteObject> remote = Remote();
-    uint32_t result = 0;
-
-    RETURN_IF_WITH_RET(remote == nullptr, result);
-
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
-        DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
-        return result;
-    }
-
-    int ret = remote->SendRequest(
-        static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::GET_MAIN_DISPLAY_ID),
-        data, reply, option);
-    if (ret != ERR_OK) {
-        DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
-        return result;
-    }
-
-    if (!reply.ReadUint32(result)) {
-        DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
-        return result;
-    }
-
-    return result;
-}
-
-bool DisplayPowerMgrProxy::SetBrightness(uint32_t value, uint32_t displayId, bool continuous)
-{
-    sptr<IRemoteObject> remote = Remote();
-    RETURN_IF_WITH_RET(remote == nullptr, false);
-
-    bool result = false;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
-        DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
-        return result;
-    }
-
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, value, false);
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, displayId, false);
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Bool, continuous, false);
-
-    int ret = remote->SendRequest(
-        static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::SET_BRIGHTNESS),
-        data, reply, option);
-    if (ret != ERR_OK) {
-        DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
-        return result;
-    }
-
-    if (!reply.ReadBool(result)) {
-        DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
-        return result;
-    }
-    int32_t error;
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Int32, error, result);
-    lastError_ = static_cast<DisplayErrors>(error);
-
-    return result;
-}
-
-bool DisplayPowerMgrProxy::SetMaxBrightness(double value, uint32_t enterTestMode)
-{
-    sptr<IRemoteObject> remote = Remote();
-    RETURN_IF_WITH_RET(remote == nullptr, false);
-
-    bool result = false;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
-        DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
-        return result;
-    }
-
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Double, value, false);
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, enterTestMode, false);
-
-    int ret = remote->SendRequest(
-        static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::SET_MAX_BRIGHTNESS),
-        data, reply, option);
-    if (ret != ERR_OK) {
-        DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
-        return result;
-    }
-
-    if (!reply.ReadBool(result)) {
-        DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
-        return result;
-    }
-    int32_t error;
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Int32, error, result);
-    lastError_ = static_cast<DisplayErrors>(error);
-    return result;
-}
-
-bool DisplayPowerMgrProxy::SetMaxBrightnessNit(uint32_t maxNit, uint32_t enterTestMode)
-{
-    sptr<IRemoteObject> remote = Remote();
-    RETURN_IF_WITH_RET(remote == nullptr, false);
-
-    bool result = false;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
-        DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
-        return result;
-    }
-
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, maxNit, false);
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, enterTestMode, false);
-
-    int ret = remote->SendRequest(
-        static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::SET_MAX_BRIGHTNESS_NIT),
-        data, reply, option);
-    if (ret != ERR_OK) {
-        DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
-        return result;
-    }
-
-    if (!reply.ReadBool(result)) {
-        DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
-        return result;
-    }
-    int32_t error;
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Int32, error, result);
-    lastError_ = static_cast<DisplayErrors>(error);
-
-    return result;
-}
-
-bool DisplayPowerMgrProxy::DiscountBrightness(double discount, uint32_t displayId)
-{
-    sptr<IRemoteObject> remote = Remote();
-    RETURN_IF_WITH_RET(remote == nullptr, false);
-
-    bool result = false;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
-        DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
-        return result;
-    }
-
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Double, discount, false);
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, displayId, false);
-
-    int ret = remote->SendRequest(
-        static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::DISCOUNT_BRIGHTNESS),
-        data, reply, option);
-    if (ret != ERR_OK) {
-        DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
-        return false;
-    }
-
-    if (!reply.ReadBool(result)) {
-        DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
-        return false;
-    }
-
-    return result;
-}
-
-bool DisplayPowerMgrProxy::OverrideBrightness(uint32_t value, uint32_t displayId, uint32_t duration)
-{
-    sptr<IRemoteObject> remote = Remote();
-    RETURN_IF_WITH_RET(remote == nullptr, false);
-
-    bool result = false;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
-        DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
-        return result;
-    }
-
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, value, false);
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, displayId, false);
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, duration, false);
-
-    int ret = remote->SendRequest(
-        static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::OVERRIDE_BRIGHTNESS),
-        data, reply, option);
-    if (ret != ERR_OK) {
-        DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
-        return result;
-    }
-
-    if (!reply.ReadBool(result)) {
-        DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
-        return result;
-    }
-
-    return result;
-}
-
-bool DisplayPowerMgrProxy::OverrideDisplayOffDelay(uint32_t delayMs)
-{
-    sptr<IRemoteObject> remote = Remote();
-    RETURN_IF_WITH_RET(remote == nullptr, false);
-
-    bool result = false;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
-        DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
-        return result;
-    }
-
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, delayMs, false);
-
-    int ret = remote->SendRequest(
-        static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::OVERRIDE_DISPLAY_OFF_DELAY),
-        data, reply, option);
-    if (ret != ERR_OK) {
-        DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
-        return result;
-    }
-
-    if (!reply.ReadBool(result)) {
-        DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
-        return result;
-    }
-
-    return result;
-}
-
-bool DisplayPowerMgrProxy::RestoreBrightness(uint32_t displayId, uint32_t duration)
-{
-    sptr<IRemoteObject> remote = Remote();
-    uint32_t result = 0;
-
-    RETURN_IF_WITH_RET(remote == nullptr, result);
-
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
-        DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
-        return result;
-    }
-
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, displayId, false);
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, duration, false);
-
-    int ret = remote->SendRequest(
-        static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::RESTORE_BRIGHTNESS),
-        data, reply, option);
-    if (ret != ERR_OK) {
-        DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
-        return result;
-    }
-
-    if (!reply.ReadUint32(result)) {
-        DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
-        return result;
-    }
-
-    return result;
-}
-
-uint32_t DisplayPowerMgrProxy::GetBrightness(uint32_t displayId)
-{
-    sptr<IRemoteObject> remote = Remote();
-    uint32_t result = 0;
-
-    RETURN_IF_WITH_RET(remote == nullptr, result);
-
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
-        DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
-        return result;
-    }
-
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, displayId, false);
-
-    int ret = remote->SendRequest(static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::GET_BRIGHTNESS),
-                                  data, reply, option);
-    if (ret != ERR_OK) {
-        DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
-        return result;
-    }
-
-    if (!reply.ReadUint32(result)) {
-        DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
-        return result;
-    }
-
-    return result;
-}
-
-uint32_t DisplayPowerMgrProxy::GetDefaultBrightness()
-{
-    sptr<IRemoteObject> remote = Remote();
-    uint32_t result = 0;
-
-    RETURN_IF_WITH_RET(remote == nullptr, result);
-
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
-        DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
-        return result;
-    }
-
-    int ret = remote->SendRequest(
-        static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::GET_DEFAULT_BRIGHTNESS),
-        data, reply, option);
-    if (ret != ERR_OK) {
-        DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
-        return result;
-    }
-
-    if (!reply.ReadUint32(result)) {
-        DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
-        return result;
-    }
-
-    return result;
-}
-
-uint32_t DisplayPowerMgrProxy::GetMaxBrightness()
-{
-    sptr<IRemoteObject> remote = Remote();
-    uint32_t result = 0;
-
-    RETURN_IF_WITH_RET(remote == nullptr, result);
-
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
-        DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
-        return result;
-    }
-
-    int ret = remote->SendRequest(
-        static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::GET_MAX_BRIGHTNESS),
-        data, reply, option);
-    if (ret != ERR_OK) {
-        DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
-        return result;
-    }
-
-    if (!reply.ReadUint32(result)) {
-        DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
-        return result;
-    }
-
-    return result;
-}
-
-uint32_t DisplayPowerMgrProxy::GetMinBrightness()
-{
-    sptr<IRemoteObject> remote = Remote();
-    uint32_t result = 0;
-
-    RETURN_IF_WITH_RET(remote == nullptr, result);
-
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
-        DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
-        return result;
-    }
-
-    int ret = remote->SendRequest(
-        static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::GET_MIN_BRIGHTNESS),
-        data, reply, option);
-    if (ret != ERR_OK) {
-        DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
-        return result;
-    }
-
-    if (!reply.ReadUint32(result)) {
-        DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
-        return result;
-    }
-
-    return result;
-}
-
-bool DisplayPowerMgrProxy::AdjustBrightness(uint32_t id, int32_t value, uint32_t duration)
-{
-    sptr<IRemoteObject> remote = Remote();
-    RETURN_IF_WITH_RET(remote == nullptr, false);
-
-    bool result = false;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
-        DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
-        return result;
-    }
-
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, id, false);
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Int32, value, false);
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Int32, duration, false);
-
-    int ret = remote->SendRequest(
-        static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::ADJUST_BRIGHTNESS),
-        data, reply, option);
-    if (ret != ERR_OK) {
-        DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
-        return result;
-    }
-
-    if (!reply.ReadBool(result)) {
-        DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
-        return result;
-    }
-
-    return result;
-}
-
-bool DisplayPowerMgrProxy::AutoAdjustBrightness(bool enable)
-{
-    sptr<IRemoteObject> remote = Remote();
-    RETURN_IF_WITH_RET(remote == nullptr, false);
-
-    bool result = false;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
-        DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
-        return result;
-    }
-
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Bool, enable, false);
-
-    int ret = remote->SendRequest(
-        static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::AUTO_ADJUST_BRIGHTNESS),
-        data, reply, option);
-    if (ret != ERR_OK) {
-        DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
-        return result;
-    }
-
-    if (!reply.ReadBool(result)) {
-        DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
-        return result;
-    }
-
-    return result;
-}
-
-bool DisplayPowerMgrProxy::IsAutoAdjustBrightness()
-{
-    sptr<IRemoteObject> remote = Remote();
-    RETURN_IF_WITH_RET(remote == nullptr, false);
-
-    bool result = false;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
-        DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
-        return result;
-    }
-
-    int ret = remote->SendRequest(
-        static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::IS_AUTO_ADJUST_BRIGHTNESS),
-        data, reply, option);
-    if (ret != ERR_OK) {
-        DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
-        return result;
-    }
-
-    if (!reply.ReadBool(result)) {
-        DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
-        return result;
-    }
-
-    return result;
-}
-
-bool DisplayPowerMgrProxy::SetScreenOnBrightness()
-{
-    sptr<IRemoteObject> remote = Remote();
-    RETURN_IF_WITH_RET(remote == nullptr, false);
-
-    bool result = false;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
-        DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
-        return result;
-    }
-
-    int ret = remote->SendRequest(
-        static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::SET_SCREEN_ON_BRIGHTNESS),
-        data, reply, option);
-    if (ret != ERR_OK) {
-        DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
-        return result;
-    }
-
-    if (!reply.ReadBool(result)) {
-        DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
-        return result;
-    }
-
-    return result;
-}
-
-bool DisplayPowerMgrProxy::RegisterCallback(sptr<IDisplayPowerCallback> callback)
-{
-    sptr<IRemoteObject> remote = Remote();
-    RETURN_IF_WITH_RET(remote == nullptr, false);
-
-    bool result = false;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
-        DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
-        return result;
-    }
-
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, RemoteObject, callback->AsObject(), false);
-
-    int ret = remote->SendRequest(
-        static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::REGISTER_CALLBACK),
-        data, reply, option);
-    if (ret != ERR_OK) {
-        DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
-        return result;
-    }
-
-    if (!reply.ReadBool(result)) {
-        DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
-        return result;
-    }
-
-    return result;
-}
-
-bool DisplayPowerMgrProxy::BoostBrightness(int32_t timeoutMs, uint32_t displayId)
-{
-    sptr<IRemoteObject> remote = Remote();
-    RETURN_IF_WITH_RET(remote == nullptr, false);
-
-    bool result = false;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
-        DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
-        return result;
-    }
-
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Int32, timeoutMs, false);
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, displayId, false);
-
-    int ret = remote->SendRequest(
-        static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::BOOST_BRIGHTNESS),
-        data, reply, option);
-    if (ret != ERR_OK) {
-        DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
-        return result;
-    }
-
-    if (!reply.ReadBool(result)) {
-        DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
-        return result;
-    }
-
-    return result;
-}
-
-bool DisplayPowerMgrProxy::CancelBoostBrightness(uint32_t displayId)
-{
-    sptr<IRemoteObject> remote = Remote();
-    RETURN_IF_WITH_RET(remote == nullptr, false);
-
-    bool result = false;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
-        DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
-        return result;
-    }
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, displayId, false);
-
-    int ret = remote->SendRequest(
-        static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::CANCEL_BOOST_BRIGHTNESS),
-        data, reply, option);
-    if (ret != ERR_OK) {
-        DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
-        return result;
-    }
-
-    if (!reply.ReadBool(result)) {
-        DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
-        return result;
-    }
-
-    return result;
-}
-
-uint32_t DisplayPowerMgrProxy::GetDeviceBrightness(uint32_t displayId)
-{
-    sptr<IRemoteObject> remote = Remote();
-    uint32_t result = 0;
-
-    RETURN_IF_WITH_RET(remote == nullptr, result);
-
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
-        DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
-        return result;
-    }
-
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, displayId, false);
-
-    int ret = remote->SendRequest(
-        static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::GET_DEVICE_BRIGHTNESS),
-        data, reply, option);
-    if (ret != ERR_OK) {
-        DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
-        return result;
-    }
-
-    if (!reply.ReadUint32(result)) {
-        DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
-        return result;
-    }
-
-    return result;
-}
-
-bool DisplayPowerMgrProxy::SetCoordinated(bool coordinated, uint32_t displayId)
-{
-    sptr<IRemoteObject> remote = Remote();
-    RETURN_IF_WITH_RET(remote == nullptr, false);
-
-    bool result = false;
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
-        DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
-        return result;
-    }
-
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Bool, coordinated, false);
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, displayId, false);
-
-    int ret = remote->SendRequest(
-        static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::SET_COORDINATED),
-        data, reply, option);
-    if (ret != ERR_OK) {
-        DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
-        return result;
-    }
-
-    if (!reply.ReadBool(result)) {
-        DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
-        return result;
-    }
-
-    return result;
-}
-
-uint32_t DisplayPowerMgrProxy::SetLightBrightnessThreshold(
-    std::vector<int32_t> threshold, sptr<IDisplayBrightnessCallback> callback)
-{
-    sptr<IRemoteObject> remote = Remote();
-    uint32_t result = 0;
-    RETURN_IF_WITH_RET(remote == nullptr, result);
-
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
-        DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
-        return result;
-    }
-
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Int32Vector, threshold, result);
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, RemoteObject, callback->AsObject(), result);
-
-    int ret = remote->SendRequest(
-        static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::SET_APS_LIGHT_AND_BRIGHTNESS_THRESOLD), data, reply,
-        option);
-    if (ret != ERR_OK) {
-        DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
-        return result;
-    }
-
-    if (!reply.ReadUint32(result)) {
-        DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
-        return result;
-    }
-
-    return result;
-}
-
-DisplayErrors DisplayPowerMgrProxy::GetError()
-{
-    return lastError_;
-}
-
-int DisplayPowerMgrProxy::NotifyScreenPowerStatus(uint32_t displayId, uint32_t status)
-{
-    sptr<IRemoteObject> remote = Remote();
-    int result = -1;
-    RETURN_IF_WITH_RET(remote == nullptr, result);
-
-    MessageParcel data;
-    MessageParcel reply;
-    MessageOption option;
-
-    if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
-        DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
-        return -1; // -1 means failed
-    }
-
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, displayId, -1); // -1 means failed
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, status, -1); // -1 means failed
-    int ret = remote->SendRequest(
-        static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::NOTIFY_DISPLAY_POWER_STATUS), data, reply, option);
-    if (ret != ERR_OK) {
-        DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
-        return ret;
-    }
-
-    if (!reply.ReadInt32(result)) {
-        DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
-        return result;
-    }
-    int32_t error;
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Int32, error, result);
-    lastError_ = static_cast<DisplayErrors>(error);
-    return result;
-}
-} // namespace DisplayPowerMgr
-} // namespace OHOS
diff --git a/state_manager/service/zidl/src/display_power_mgr_stub.cpp b/state_manager/service/zidl/src/display_power_mgr_stub.cpp
deleted file mode 100644
index d0f28048d85ab627d8be190f83cd993db483e213..0000000000000000000000000000000000000000
--- a/state_manager/service/zidl/src/display_power_mgr_stub.cpp
+++ /dev/null
@@ -1,535 +0,0 @@
-/*
- * Copyright (c) 2021-2023 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 "display_power_mgr_stub.h"
-
-#include <message_parcel.h>
-#include "errors.h"
-#include "ipc_object_stub.h"
-#include "iremote_broker.h"
-#include "iremote_object.h"
-#include "idisplay_power_callback.h"
-#include "display_log.h"
-#include "display_common.h"
-#include "display_mgr_errors.h"
-#include "display_power_info.h"
-#include "display_power_mgr_ipc_interface_code.h"
-#include "xcollie/xcollie.h"
-#include "xcollie/xcollie_define.h"
-
-namespace OHOS {
-namespace DisplayPowerMgr {
-int32_t DisplayPowerMgrStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply,
-    MessageOption &option)
-{
-    DISPLAY_HILOGD(COMP_SVC, "DisplayPowerMgrStub::OnRemoteRequest, cmd = %d, flags= %d",
-        code, option.GetFlags());
-    std::u16string descripter = DisplayPowerMgrStub::GetDescriptor();
-    std::u16string remoteDescripter = data.ReadInterfaceToken();
-    if (descripter != remoteDescripter) {
-        DISPLAY_HILOGE(COMP_SVC, "DisplayPowerMgrStub::OnRemoteRequest failed, descriptor is not matched!");
-        return E_GET_POWER_SERVICE_FAILED;
-    }
-
-    constexpr int dfxDelayS = 60;
-    int id = HiviewDFX::XCollie::GetInstance().SetTimer("DisplayPowerMgrStub", dfxDelayS, nullptr, nullptr,
-        HiviewDFX::XCOLLIE_FLAG_LOG);
-
-    int32_t ret = ProcessMessage(code, data, reply, option);
-    HiviewDFX::XCollie::GetInstance().CancelTimer(id);
-    return ret;
-}
-
-int32_t DisplayPowerMgrStub::ProcessMessage(uint32_t code, MessageParcel &data, MessageParcel &reply,
-    MessageOption &option)
-{
-    int32_t ret = ERR_OK;
-    switch (code) {
-        case static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::SET_DISPLAY_STATE):
-            ret = SetDisplayStateStub(data, reply);
-            break;
-        case static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::GET_DISPLAY_STATE):
-            ret = GetDisplayStateStub(data, reply);
-            break;
-        case static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::GET_DISPLAY_IDS):
-            ret = GetDisplayIdsStub(data, reply);
-            break;
-        case static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::GET_MAIN_DISPLAY_ID):
-            ret = GetMainDisplayIdStub(data, reply);
-            break;
-        case static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::SET_BRIGHTNESS):
-            ret = SetBrightnessStub(data, reply);
-            break;
-        case static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::DISCOUNT_BRIGHTNESS):
-            ret = DiscountBrightnessStub(data, reply);
-            break;
-        case static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::OVERRIDE_BRIGHTNESS):
-            ret = OverrideBrightnessStub(data, reply);
-            break;
-        case static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::OVERRIDE_DISPLAY_OFF_DELAY):
-            ret = OverrideDisplayOffDelayStub(data, reply);
-            break;
-        case static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::SET_APS_LIGHT_AND_BRIGHTNESS_THRESOLD):
-            ret = SetLightBrightnessThresholdStub(data, reply);
-            break;
-        case static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::SET_MAX_BRIGHTNESS):
-            ret = SetMaxBrightnessStub(data, reply);
-            break;
-        case static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::SET_MAX_BRIGHTNESS_NIT):
-            ret = SetMaxBrightnessNitStub(data, reply);
-            break;
-        case static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::NOTIFY_DISPLAY_POWER_STATUS):
-            ret = NotifyScreenPowerStatusStub(data, reply);
-            break;
-        default:
-            ret = RemoteRequest(code, data, reply, option);
-            break;
-    }
-    return ret;
-}
-
-int32_t DisplayPowerMgrStub::RemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply,
-    MessageOption &option)
-{
-    int32_t ret = ERR_OK;
-    switch (code) {
-        case static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::RESTORE_BRIGHTNESS):
-            ret = RestoreBrightnessStub(data, reply);
-            break;
-        case static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::GET_BRIGHTNESS):
-            ret = GetBrightnessStub(data, reply);
-            break;
-        case static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::GET_DEFAULT_BRIGHTNESS):
-            ret = GetDefaultBrightnessStub(data, reply);
-            break;
-        case static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::GET_MAX_BRIGHTNESS):
-            ret = GetMaxBrightnessStub(data, reply);
-            break;
-        case static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::GET_MIN_BRIGHTNESS):
-            ret = GetMinBrightnessStub(data, reply);
-            break;
-        case static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::ADJUST_BRIGHTNESS):
-            ret = AdjustBrightnessStub(data, reply);
-            break;
-        case static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::AUTO_ADJUST_BRIGHTNESS):
-            ret = AutoAdjustBrightnessStub(data, reply);
-            break;
-        case static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::IS_AUTO_ADJUST_BRIGHTNESS):
-            ret = IsAutoAdjustBrightnessStub(data, reply);
-            break;
-        case static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::REGISTER_CALLBACK):
-            ret = RegisterCallbackStub(data, reply);
-            break;
-        case static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::BOOST_BRIGHTNESS):
-            ret = BoostBrightnessStub(data, reply);
-            break;
-        case static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::CANCEL_BOOST_BRIGHTNESS):
-            ret = CancelBoostBrightnessStub(data, reply);
-            break;
-        case static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::GET_DEVICE_BRIGHTNESS):
-            ret = GetDeviceBrightnessStub(data, reply);
-            break;
-        case static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::SET_COORDINATED):
-            ret = SetCoordinatedStub(data, reply);
-            break;
-        case static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::SET_SCREEN_ON_BRIGHTNESS):
-            ret = SetScreenOnBrightnessStub(data, reply);
-            break;
-        default:
-            ret = IPCObjectStub::OnRemoteRequest(code, data, reply, option);
-            break;
-    }
-
-    return ret;
-}
-
-int32_t DisplayPowerMgrStub::SetDisplayStateStub(MessageParcel& data, MessageParcel& reply)
-{
-    uint32_t id = 0;
-    uint32_t state = 0;
-    uint32_t reason = 0;
-
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Uint32, id, E_READ_PARCEL_ERROR);
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Uint32, state, E_READ_PARCEL_ERROR);
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Uint32, reason, E_READ_PARCEL_ERROR);
-
-    bool ret = SetDisplayState(id, static_cast<DisplayState>(state), reason);
-    if (!reply.WriteBool(ret)) {
-        DISPLAY_HILOGE(COMP_SVC, "Failed to write SetDisplayStateStub return value");
-        return E_WRITE_PARCEL_ERROR;
-    }
-    return ERR_OK;
-}
-
-int32_t DisplayPowerMgrStub::GetDisplayStateStub(MessageParcel& data, MessageParcel& reply)
-{
-    uint32_t id = 0;
-
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Uint32, id, E_READ_PARCEL_ERROR);
-
-    DisplayState ret = GetDisplayState(id);
-    if (!reply.WriteUint32(static_cast<uint32_t>(ret))) {
-        DISPLAY_HILOGE(COMP_SVC, "Failed to write GetDisplayStateStub return value");
-        return E_WRITE_PARCEL_ERROR;
-    }
-    return ERR_OK;
-}
-
-int32_t DisplayPowerMgrStub::GetDisplayIdsStub(MessageParcel& data, MessageParcel& reply)
-{
-    std::vector<uint32_t> result = GetDisplayIds();
-    if (!reply.WriteUint32(static_cast<uint32_t>(result.size()))) {
-        DISPLAY_HILOGE(COMP_SVC, "Failed to write GetDisplayIdsStub return value");
-        return E_WRITE_PARCEL_ERROR;
-    }
-    for (uint32_t i = 0; i < result.size(); i++) {
-        if (!reply.WriteUint32(static_cast<uint32_t>(result[i]))) {
-            DISPLAY_HILOGE(COMP_SVC, "Failed to write GetDisplayIdsStub");
-        }
-    }
-    return ERR_OK;
-}
-
-int32_t DisplayPowerMgrStub::GetMainDisplayIdStub(MessageParcel& data, MessageParcel& reply)
-{
-    uint32_t result = GetMainDisplayId();
-    if (!reply.WriteUint32(result)) {
-        DISPLAY_HILOGE(COMP_SVC, "Failed to write GetMainDisplayIdStub return value");
-        return E_WRITE_PARCEL_ERROR;
-    }
-    return ERR_OK;
-}
-
-int32_t DisplayPowerMgrStub::SetBrightnessStub(MessageParcel& data, MessageParcel& reply)
-{
-    uint32_t value = 0;
-    uint32_t displayId = 0;
-    bool continuous = false;
-
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Uint32, value, E_READ_PARCEL_ERROR);
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Uint32, displayId, E_READ_PARCEL_ERROR);
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Bool, continuous, E_READ_PARCEL_ERROR);
-
-    bool ret = SetBrightness(value, displayId, continuous);
-    if (!reply.WriteBool(ret)) {
-        DISPLAY_HILOGE(COMP_SVC, "Failed to write SetBrightness return value");
-        return E_WRITE_PARCEL_ERROR;
-    }
-    int32_t error = static_cast<int32_t>(GetError());
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(reply, Int32, error, E_WRITE_PARCEL_ERROR);
-    return ERR_OK;
-}
-
-int32_t DisplayPowerMgrStub::DiscountBrightnessStub(MessageParcel& data, MessageParcel& reply)
-{
-    double discount = 0;
-    uint32_t displayId = 0;
-
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Double, discount, E_READ_PARCEL_ERROR);
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Uint32, displayId, E_READ_PARCEL_ERROR);
-
-    bool ret = DiscountBrightness(discount, displayId);
-    if (!reply.WriteBool(ret)) {
-        DISPLAY_HILOGE(COMP_SVC, "Failed to wirte DiscountBrightness return value");
-        return E_WRITE_PARCEL_ERROR;
-    }
-    return ERR_OK;
-}
-
-int32_t DisplayPowerMgrStub::OverrideBrightnessStub(MessageParcel& data, MessageParcel& reply)
-{
-    uint32_t value = 0;
-    uint32_t displayId = 0;
-    uint32_t duration = 0;
-
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Uint32, value, E_READ_PARCEL_ERROR);
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Uint32, displayId, E_READ_PARCEL_ERROR);
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Uint32, duration, E_READ_PARCEL_ERROR);
-
-    bool ret = OverrideBrightness(value, displayId, duration);
-    if (!reply.WriteBool(ret)) {
-        DISPLAY_HILOGE(COMP_SVC, "Failed to write OverrideBrightness return value");
-        return E_WRITE_PARCEL_ERROR;
-    }
-    return ERR_OK;
-}
-
-int32_t DisplayPowerMgrStub::OverrideDisplayOffDelayStub(MessageParcel& data, MessageParcel& reply)
-{
-    uint32_t delayMs = 0;
-
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Uint32, delayMs, E_READ_PARCEL_ERROR);
-
-    bool ret = OverrideDisplayOffDelay(delayMs);
-    if (!reply.WriteBool(ret)) {
-        DISPLAY_HILOGE(COMP_SVC, "Failed to write OverrideDisplayOffDelay return value");
-        return E_WRITE_PARCEL_ERROR;
-    }
-    return ERR_OK;
-}
-
-int32_t DisplayPowerMgrStub::RestoreBrightnessStub(MessageParcel& data, MessageParcel& reply)
-{
-    uint32_t displayId = 0;
-    uint32_t duration = 0;
-
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Uint32, displayId, E_READ_PARCEL_ERROR);
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Uint32, duration, E_READ_PARCEL_ERROR);
-
-    bool ret = RestoreBrightness(displayId, duration);
-    if (!reply.WriteBool(ret)) {
-        DISPLAY_HILOGE(COMP_SVC, "Failed to write RestoreBrightness return value");
-        return E_WRITE_PARCEL_ERROR;
-    }
-    return ERR_OK;
-}
-
-int32_t DisplayPowerMgrStub::GetBrightnessStub(MessageParcel& data, MessageParcel& reply)
-{
-    uint32_t displayId = 0;
-
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Uint32, displayId, E_READ_PARCEL_ERROR);
-
-    uint32_t ret = GetBrightness(displayId);
-    if (!reply.WriteUint32(ret)) {
-        DISPLAY_HILOGE(COMP_SVC, "Failed to write GetBrightness return value");
-        return E_WRITE_PARCEL_ERROR;
-    }
-    return ERR_OK;
-}
-
-int32_t DisplayPowerMgrStub::GetDefaultBrightnessStub(MessageParcel& data, MessageParcel& reply)
-{
-    uint32_t ret = GetDefaultBrightness();
-    if (!reply.WriteUint32(ret)) {
-        DISPLAY_HILOGE(COMP_SVC, "Failed to write GetDefaultBrightness return value");
-        return E_WRITE_PARCEL_ERROR;
-    }
-    return ERR_OK;
-}
-
-int32_t DisplayPowerMgrStub::GetMaxBrightnessStub(MessageParcel& data, MessageParcel& reply)
-{
-    uint32_t ret = GetMaxBrightness();
-    if (!reply.WriteUint32(ret)) {
-        DISPLAY_HILOGE(COMP_SVC, "Failed to write GetMaxBrightness return value");
-        return E_WRITE_PARCEL_ERROR;
-    }
-    return ERR_OK;
-}
-
-int32_t DisplayPowerMgrStub::GetMinBrightnessStub(MessageParcel& data, MessageParcel& reply)
-{
-    uint32_t ret = GetMinBrightness();
-    if (!reply.WriteUint32(ret)) {
-        DISPLAY_HILOGE(COMP_SVC, "Failed to write GetMinBrightness return value");
-        return E_WRITE_PARCEL_ERROR;
-    }
-    return ERR_OK;
-}
-
-int32_t DisplayPowerMgrStub::AdjustBrightnessStub(MessageParcel& data, MessageParcel& reply)
-{
-    uint32_t id = 0;
-    int32_t value = 0;
-    uint32_t duration = 0;
-
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Uint32, id, E_READ_PARCEL_ERROR);
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Int32, value, E_READ_PARCEL_ERROR);
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Uint32, duration, E_READ_PARCEL_ERROR);
-
-    bool ret = AdjustBrightness(id, value, duration);
-    if (!reply.WriteBool(ret)) {
-        DISPLAY_HILOGE(COMP_SVC, "Failed to write AdjustBrightnessStub return value");
-        return E_WRITE_PARCEL_ERROR;
-    }
-    return ERR_OK;
-}
-
-int32_t DisplayPowerMgrStub::AutoAdjustBrightnessStub(MessageParcel& data, MessageParcel& reply)
-{
-    bool enable = 0;
-
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Bool, enable, E_READ_PARCEL_ERROR);
-
-    bool ret = AutoAdjustBrightness(enable);
-    if (!reply.WriteBool(ret)) {
-        DISPLAY_HILOGE(COMP_SVC, "Failed to write AutoAdjustBrightnessStub return value");
-        return E_WRITE_PARCEL_ERROR;
-    }
-    return ERR_OK;
-}
-
-int32_t DisplayPowerMgrStub::IsAutoAdjustBrightnessStub(MessageParcel& data, MessageParcel& reply)
-{
-    bool ret = IsAutoAdjustBrightness();
-    if (!reply.WriteBool(ret)) {
-        DISPLAY_HILOGE(COMP_SVC, "Failed to write IsAutoAdjustBrightnessStub return value");
-        return E_WRITE_PARCEL_ERROR;
-    }
-    return ERR_OK;
-}
-
-int32_t DisplayPowerMgrStub::SetScreenOnBrightnessStub(MessageParcel& data, MessageParcel& reply)
-{
-    bool ret = SetScreenOnBrightness();
-    if (!reply.WriteBool(ret)) {
-        DISPLAY_HILOGE(COMP_SVC, "Failed to write SetScreenOnBrightnessStub return value");
-        return E_WRITE_PARCEL_ERROR;
-    }
-    return ERR_OK;
-}
-
-int32_t DisplayPowerMgrStub::RegisterCallbackStub(MessageParcel& data, MessageParcel& reply)
-{
-    sptr<IRemoteObject> obj = data.ReadRemoteObject();
-    RETURN_IF_WITH_RET((obj == nullptr), E_READ_PARCEL_ERROR);
-    sptr<IDisplayPowerCallback> callback = iface_cast<IDisplayPowerCallback>(obj);
-    RETURN_IF_WITH_RET((callback == nullptr), E_READ_PARCEL_ERROR);
-    bool isSucc = RegisterCallback(callback);
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(reply, Bool, isSucc, E_WRITE_PARCEL_ERROR);
-    return ERR_OK;
-}
-
-int32_t DisplayPowerMgrStub::BoostBrightnessStub(MessageParcel& data, MessageParcel& reply)
-{
-    int32_t timeoutMs = -1;
-    uint32_t id = 0;
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Int32, timeoutMs, E_READ_PARCEL_ERROR);
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Uint32, id, E_READ_PARCEL_ERROR);
-
-    bool isScuu = BoostBrightness(timeoutMs, id);
-    if (!reply.WriteBool(isScuu)) {
-        DISPLAY_HILOGW(COMP_SVC, "Failed to write BoostBrightness return value");
-        return E_WRITE_PARCEL_ERROR;
-    }
-    return ERR_OK;
-}
-
-int32_t DisplayPowerMgrStub::CancelBoostBrightnessStub(MessageParcel& data, MessageParcel& reply)
-{
-    uint32_t displayId = 0;
-
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Uint32, displayId, E_READ_PARCEL_ERROR);
-
-    bool isScuu = CancelBoostBrightness(displayId);
-    if (!reply.WriteBool(isScuu)) {
-        DISPLAY_HILOGW(COMP_SVC, "Failed to write CancelBoostBrightness return value");
-        return E_WRITE_PARCEL_ERROR;
-    }
-    return ERR_OK;
-}
-
-int32_t DisplayPowerMgrStub::GetDeviceBrightnessStub(MessageParcel& data, MessageParcel& reply)
-{
-    uint32_t displayId = 0;
-
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Uint32, displayId, E_READ_PARCEL_ERROR);
-
-    uint32_t ret = GetDeviceBrightness(displayId);
-    if (!reply.WriteUint32(ret)) {
-        DISPLAY_HILOGE(COMP_SVC, "Failed to write GetDeviceBrightness return value");
-        return E_WRITE_PARCEL_ERROR;
-    }
-    return ERR_OK;
-}
-
-int32_t DisplayPowerMgrStub::SetCoordinatedStub(MessageParcel& data, MessageParcel& reply)
-{
-    bool coordinated = false;
-    uint32_t displayId = 0;
-
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Bool, coordinated, E_READ_PARCEL_ERROR);
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Uint32, displayId, E_READ_PARCEL_ERROR);
-
-    bool ret = SetCoordinated(coordinated, displayId);
-    if (!reply.WriteBool(ret)) {
-        DISPLAY_HILOGE(COMP_SVC, "Failed to write SetCoordinatedStub return value");
-        return E_WRITE_PARCEL_ERROR;
-    }
-    return ERR_OK;
-}
-
-int32_t DisplayPowerMgrStub::SetLightBrightnessThresholdStub(MessageParcel& data, MessageParcel& reply)
-{
-    std::vector<int32_t> threshold;
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Int32Vector, &threshold, E_READ_PARCEL_ERROR);
-    sptr<IRemoteObject> obj = data.ReadRemoteObject();
-    RETURN_IF_WITH_RET((obj == nullptr), E_READ_PARCEL_ERROR);
-    sptr<IDisplayBrightnessCallback> callback = iface_cast<IDisplayBrightnessCallback>(obj);
-    RETURN_IF_WITH_RET((callback == nullptr), E_READ_PARCEL_ERROR);
-    uint32_t ret = SetLightBrightnessThreshold(threshold, callback);
-    if (!reply.WriteUint32(ret)) {
-        DISPLAY_HILOGE(COMP_SVC, "Failed to write SetLightBrightnessThresholdStub return value");
-        return E_WRITE_PARCEL_ERROR;
-    }
-    return ERR_OK;
-}
-
-int32_t DisplayPowerMgrStub::SetMaxBrightnessStub(MessageParcel& data, MessageParcel& reply)
-{
-    double value = 0;
-    uint32_t enterTestMode = 0;
-
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Double, value, E_READ_PARCEL_ERROR);
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Uint32, enterTestMode, E_READ_PARCEL_ERROR);
-
-    bool ret = SetMaxBrightness(value, enterTestMode);
-    if (!reply.WriteBool(ret)) {
-        DISPLAY_HILOGE(COMP_SVC, "Failed to write SetMaxBrightness return value");
-        return E_WRITE_PARCEL_ERROR;
-    }
-    int32_t error = static_cast<int32_t>(GetError());
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(reply, Int32, error, E_WRITE_PARCEL_ERROR);
-    return ERR_OK;
-}
-
-int32_t DisplayPowerMgrStub::SetMaxBrightnessNitStub(MessageParcel& data, MessageParcel& reply)
-{
-    uint32_t value = 0;
-    uint32_t enterTestMode = 0;
-
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Uint32, value, E_READ_PARCEL_ERROR);
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Uint32, enterTestMode, E_READ_PARCEL_ERROR);
-
-    bool ret = SetMaxBrightnessNit(value, enterTestMode);
-    if (!reply.WriteBool(ret)) {
-        DISPLAY_HILOGE(COMP_SVC, "Failed to write SetMaxBrightness return value");
-        return E_WRITE_PARCEL_ERROR;
-    }
-    int32_t error = static_cast<int32_t>(GetError());
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(reply, Int32, error, E_WRITE_PARCEL_ERROR);
-    return ERR_OK;
-}
-
-int32_t DisplayPowerMgrStub::NotifyScreenPowerStatusStub(MessageParcel& data, MessageParcel& reply)
-{
-    uint32_t displayId = 0;
-    uint32_t displayPowerStatus = 0;
-
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Uint32, displayId, E_READ_PARCEL_ERROR);
-    RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Uint32, displayPowerStatus, E_READ_PARCEL_ERROR);
-
-    int ret = NotifyScreenPowerStatus(displayId, displayPowerStatus);
-    if (!reply.WriteInt32(ret)) {
-        DISPLAY_HILOGE(COMP_SVC, "Failed to write NotifyScreenPowerStatus return value");
-        return E_WRITE_PARCEL_ERROR;
-    }
-    int32_t error = static_cast<int32_t>(GetError());
-    RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(reply, Int32, error, E_WRITE_PARCEL_ERROR);
-    return ERR_OK;
-}
-} // namespace DisplayPowerMgr
-} // namespace OHOS
diff --git a/state_manager/test/BUILD.gn b/state_manager/test/BUILD.gn
index 95570e3e8b55746040f0f4b8380b1b384a51397b..3189ad0647798c6b193ba6395c6d5fccf5b8f517 100644
--- a/state_manager/test/BUILD.gn
+++ b/state_manager/test/BUILD.gn
@@ -24,7 +24,7 @@ group("displaymgr_native_test") {
   deps = [ "unittest:unittest_display_mgr_service" ]
 }
 
-group("fuzztest") {
+group("displaymgr_fuzztest") {
   testonly = true
   deps = [ "fuzztest:fuzztest" ]
 }
diff --git a/state_manager/test/fuzztest/adjustbrightness_fuzzer/BUILD.gn b/state_manager/test/fuzztest/adjustbrightness_fuzzer/BUILD.gn
index 1cda6ac14546af12bd3b7248cbfd471294ce3b8a..def47c2b531d8347fabd5fe20d0e878c12cda187 100644
--- a/state_manager/test/fuzztest/adjustbrightness_fuzzer/BUILD.gn
+++ b/state_manager/test/fuzztest/adjustbrightness_fuzzer/BUILD.gn
@@ -34,9 +34,13 @@ ohos_fuzztest("AdjustBrightnessFuzzTest") {
     "${displaymgr_utils_path}:utils_config",
     "${displaymgr_utils_path}:coverage_flags",
     "${brightnessmgr_root_path}:brightness_manager_config",
+    "${displaymgr_root_path}/service:displaymgr_public_config",
   ]
 
-  deps = [ "${brightnessmgr_root_path}:brightness_manager" ]
+  deps = [
+    "${brightnessmgr_root_path}:brightness_manager",
+    "${displaymgr_root_path}/service:displaymgr_stub",
+  ]
 
   cflags = [
     "-g",
@@ -54,8 +58,7 @@ ohos_fuzztest("AdjustBrightnessFuzzTest") {
     "${displaymgr_root_path}/service/native/src/gradual_animator.cpp",
     "${displaymgr_root_path}/service/native/src/screen_action.cpp",
     "${displaymgr_root_path}/service/native/src/screen_controller.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_callback_proxy.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_mgr_stub.cpp",
+    "${displaymgr_utils_path}/native/src/display_xcollie.cpp",
     "../display_utils/display_fuzzer.cpp",
     "./adjustbrightness_fuzzer_test.cpp",
   ]
diff --git a/state_manager/test/fuzztest/adjustbrightness_fuzzer/adjustbrightness_fuzzer_test.cpp b/state_manager/test/fuzztest/adjustbrightness_fuzzer/adjustbrightness_fuzzer_test.cpp
index 508d9bbca3ac32f82e94a83a978ea9eece987863..e8a95d1f5cfad2fd2ea0c04e78e1eefb392085cb 100644
--- a/state_manager/test/fuzztest/adjustbrightness_fuzzer/adjustbrightness_fuzzer_test.cpp
+++ b/state_manager/test/fuzztest/adjustbrightness_fuzzer/adjustbrightness_fuzzer_test.cpp
@@ -18,9 +18,9 @@
 #define FUZZ_PROJECT_NAME "adjustbrightness_fuzzer"
 
 #include "display_fuzzer.h"
-#include "display_power_mgr_ipc_interface_code.h"
+#include "idisplay_power_mgr.h"
 
-using namespace OHOS::PowerMgr;
+using namespace OHOS::DisplayPowerMgr;
 
 namespace {
 }
@@ -31,6 +31,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     /* Run your code on data */
     DisplayFuzzerTest g_serviceTest;
     g_serviceTest.TestDisplayServiceStub(
-        static_cast<uint32_t>(DisplayPowerMgrInterfaceCode::ADJUST_BRIGHTNESS), data, size);
+        static_cast<uint32_t>(IDisplayPowerMgrIpcCode::COMMAND_ADJUST_BRIGHTNESS), data, size);
     return 0;
 }
diff --git a/state_manager/test/fuzztest/autoadjustbrightness_fuzzer/BUILD.gn b/state_manager/test/fuzztest/autoadjustbrightness_fuzzer/BUILD.gn
index 4b90ef2feaae1d999f2e9c36c9416c0a86ac8cd6..08da0796b90c8296a987e1ecf62e9332da4ac01f 100644
--- a/state_manager/test/fuzztest/autoadjustbrightness_fuzzer/BUILD.gn
+++ b/state_manager/test/fuzztest/autoadjustbrightness_fuzzer/BUILD.gn
@@ -34,9 +34,13 @@ ohos_fuzztest("AutoAdjustBrightnessFuzzTest") {
     "${displaymgr_utils_path}:utils_config",
     "${displaymgr_utils_path}:coverage_flags",
     "${brightnessmgr_root_path}:brightness_manager_config",
+    "${displaymgr_root_path}/service:displaymgr_public_config",
   ]
 
-  deps = [ "${brightnessmgr_root_path}:brightness_manager" ]
+  deps = [
+    "${brightnessmgr_root_path}:brightness_manager",
+    "${displaymgr_root_path}/service:displaymgr_stub",
+  ]
 
   cflags = [
     "-g",
@@ -54,8 +58,7 @@ ohos_fuzztest("AutoAdjustBrightnessFuzzTest") {
     "${displaymgr_root_path}/service/native/src/gradual_animator.cpp",
     "${displaymgr_root_path}/service/native/src/screen_action.cpp",
     "${displaymgr_root_path}/service/native/src/screen_controller.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_callback_proxy.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_mgr_stub.cpp",
+    "${displaymgr_utils_path}/native/src/display_xcollie.cpp",
     "../display_utils/display_fuzzer.cpp",
     "./autoadjustbrightness_fuzzer_test.cpp",
   ]
diff --git a/state_manager/test/fuzztest/autoadjustbrightness_fuzzer/autoadjustbrightness_fuzzer_test.cpp b/state_manager/test/fuzztest/autoadjustbrightness_fuzzer/autoadjustbrightness_fuzzer_test.cpp
index 22c6411cf77e56bb0536e3e306a0f7c7e98ce645..96ead9fcc61e8c835ccdc12afd4ab7b43ca29ce5 100644
--- a/state_manager/test/fuzztest/autoadjustbrightness_fuzzer/autoadjustbrightness_fuzzer_test.cpp
+++ b/state_manager/test/fuzztest/autoadjustbrightness_fuzzer/autoadjustbrightness_fuzzer_test.cpp
@@ -18,9 +18,9 @@
 #define FUZZ_PROJECT_NAME "autoadjustbrightness_fuzzer"
 
 #include "display_fuzzer.h"
-#include "display_power_mgr_ipc_interface_code.h"
+#include "idisplay_power_mgr.h"
 
-using namespace OHOS::PowerMgr;
+using namespace OHOS::DisplayPowerMgr;
 
 namespace {
 }
@@ -31,8 +31,8 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     /* Run your code on data */
     DisplayFuzzerTest g_serviceTest;
     g_serviceTest.TestDisplayServiceStub(
-        static_cast<uint32_t>(DisplayPowerMgrInterfaceCode::AUTO_ADJUST_BRIGHTNESS), data, size);
+        static_cast<uint32_t>(IDisplayPowerMgrIpcCode::COMMAND_AUTO_ADJUST_BRIGHTNESS), data, size);
     g_serviceTest.TestDisplayServiceStub(
-        static_cast<uint32_t>(DisplayPowerMgrInterfaceCode::IS_AUTO_ADJUST_BRIGHTNESS), data, size);
+        static_cast<uint32_t>(IDisplayPowerMgrIpcCode::COMMAND_IS_AUTO_ADJUST_BRIGHTNESS), data, size);
     return 0;
 }
diff --git a/state_manager/test/fuzztest/boostbrightness_fuzzer/BUILD.gn b/state_manager/test/fuzztest/boostbrightness_fuzzer/BUILD.gn
index 120abe7f482376648412aaea9d5131d9eded6638..bfb2f12365eee97223193aedcaf781710a2cf594 100644
--- a/state_manager/test/fuzztest/boostbrightness_fuzzer/BUILD.gn
+++ b/state_manager/test/fuzztest/boostbrightness_fuzzer/BUILD.gn
@@ -34,9 +34,13 @@ ohos_fuzztest("BoostBrightnessFuzzTest") {
     "${displaymgr_utils_path}:utils_config",
     "${displaymgr_utils_path}:coverage_flags",
     "${brightnessmgr_root_path}:brightness_manager_config",
+    "${displaymgr_root_path}/service:displaymgr_public_config",
   ]
 
-  deps = [ "${brightnessmgr_root_path}:brightness_manager" ]
+  deps = [
+    "${brightnessmgr_root_path}:brightness_manager",
+    "${displaymgr_root_path}/service:displaymgr_stub",
+  ]
 
   cflags = [
     "-g",
@@ -54,8 +58,7 @@ ohos_fuzztest("BoostBrightnessFuzzTest") {
     "${displaymgr_root_path}/service/native/src/gradual_animator.cpp",
     "${displaymgr_root_path}/service/native/src/screen_action.cpp",
     "${displaymgr_root_path}/service/native/src/screen_controller.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_callback_proxy.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_mgr_stub.cpp",
+    "${displaymgr_utils_path}/native/src/display_xcollie.cpp",
     "../display_utils/display_fuzzer.cpp",
     "./boostbrightness_fuzzer_test.cpp",
   ]
diff --git a/state_manager/test/fuzztest/boostbrightness_fuzzer/boostbrightness_fuzzer_test.cpp b/state_manager/test/fuzztest/boostbrightness_fuzzer/boostbrightness_fuzzer_test.cpp
index ad5ae0dba18946ce3096c2877c49091153b66135..458013076fa4b4ea652a98741e6f9762012e30a2 100644
--- a/state_manager/test/fuzztest/boostbrightness_fuzzer/boostbrightness_fuzzer_test.cpp
+++ b/state_manager/test/fuzztest/boostbrightness_fuzzer/boostbrightness_fuzzer_test.cpp
@@ -18,9 +18,9 @@
 #define FUZZ_PROJECT_NAME "boostbrightness_fuzzer"
 
 #include "display_fuzzer.h"
-#include "display_power_mgr_ipc_interface_code.h"
+#include "idisplay_power_mgr.h"
 
-using namespace OHOS::PowerMgr;
+using namespace OHOS::DisplayPowerMgr;
 
 namespace {
 }
@@ -31,8 +31,8 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     /* Run your code on data */
     DisplayFuzzerTest g_serviceTest;
     g_serviceTest.TestDisplayServiceStub(
-        static_cast<uint32_t>(DisplayPowerMgrInterfaceCode::BOOST_BRIGHTNESS), data, size);
+        static_cast<uint32_t>(IDisplayPowerMgrIpcCode::COMMAND_BOOST_BRIGHTNESS), data, size);
     g_serviceTest.TestDisplayServiceStub(
-        static_cast<uint32_t>(DisplayPowerMgrInterfaceCode::CANCEL_BOOST_BRIGHTNESS), data, size);
+        static_cast<uint32_t>(IDisplayPowerMgrIpcCode::COMMAND_CANCEL_BOOST_BRIGHTNESS), data, size);
     return 0;
 }
diff --git a/state_manager/test/fuzztest/discountbrightness_fuzzer/BUILD.gn b/state_manager/test/fuzztest/discountbrightness_fuzzer/BUILD.gn
index cca9a4da6ebab5531cfca8f80bfc924c45361786..577d430c3155bb1703e1d1a0742c24751306b52a 100644
--- a/state_manager/test/fuzztest/discountbrightness_fuzzer/BUILD.gn
+++ b/state_manager/test/fuzztest/discountbrightness_fuzzer/BUILD.gn
@@ -34,9 +34,13 @@ ohos_fuzztest("DiscountBrightnessFuzzTest") {
     "${displaymgr_utils_path}:utils_config",
     "${displaymgr_utils_path}:coverage_flags",
     "${brightnessmgr_root_path}:brightness_manager_config",
+    "${displaymgr_root_path}/service:displaymgr_public_config",
   ]
 
-  deps = [ "${brightnessmgr_root_path}:brightness_manager" ]
+  deps = [
+    "${brightnessmgr_root_path}:brightness_manager",
+    "${displaymgr_root_path}/service:displaymgr_stub",
+  ]
 
   cflags = [
     "-g",
@@ -54,8 +58,7 @@ ohos_fuzztest("DiscountBrightnessFuzzTest") {
     "${displaymgr_root_path}/service/native/src/gradual_animator.cpp",
     "${displaymgr_root_path}/service/native/src/screen_action.cpp",
     "${displaymgr_root_path}/service/native/src/screen_controller.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_callback_proxy.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_mgr_stub.cpp",
+    "${displaymgr_utils_path}/native/src/display_xcollie.cpp",
     "../display_utils/display_fuzzer.cpp",
     "./discountbrightness_fuzzer_test.cpp",
   ]
diff --git a/state_manager/test/fuzztest/discountbrightness_fuzzer/discountbrightness_fuzzer_test.cpp b/state_manager/test/fuzztest/discountbrightness_fuzzer/discountbrightness_fuzzer_test.cpp
index da8d4de7dc88e1cb415f920a7830c8b742993439..f909caf71a44b814388cd10a067f9398935e37d9 100644
--- a/state_manager/test/fuzztest/discountbrightness_fuzzer/discountbrightness_fuzzer_test.cpp
+++ b/state_manager/test/fuzztest/discountbrightness_fuzzer/discountbrightness_fuzzer_test.cpp
@@ -18,9 +18,9 @@
 #define FUZZ_PROJECT_NAME "discountbrightness_fuzzer"
 
 #include "display_fuzzer.h"
-#include "display_power_mgr_ipc_interface_code.h"
+#include "idisplay_power_mgr.h"
 
-using namespace OHOS::PowerMgr;
+using namespace OHOS::DisplayPowerMgr;
 
 namespace {
 }
@@ -31,6 +31,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     /* Run your code on data */
     DisplayFuzzerTest g_serviceTest;
     g_serviceTest.TestDisplayServiceStub(
-        static_cast<uint32_t>(DisplayPowerMgrInterfaceCode::DISCOUNT_BRIGHTNESS), data, size);
+        static_cast<uint32_t>(IDisplayPowerMgrIpcCode::COMMAND_DISCOUNT_BRIGHTNESS), data, size);
     return 0;
 }
diff --git a/state_manager/test/fuzztest/displaycoverage_fuzzer/BUILD.gn b/state_manager/test/fuzztest/displaycoverage_fuzzer/BUILD.gn
index 500ea03de0a6c6e9256b7551173a834e5920bd6f..acf5bf1c27980043d8767da099d19c51bf6ff599 100644
--- a/state_manager/test/fuzztest/displaycoverage_fuzzer/BUILD.gn
+++ b/state_manager/test/fuzztest/displaycoverage_fuzzer/BUILD.gn
@@ -34,9 +34,13 @@ ohos_fuzztest("DisplayCoverageFuzzTest") {
     "${displaymgr_utils_path}:utils_config",
     "${displaymgr_utils_path}:coverage_flags",
     "${brightnessmgr_root_path}:brightness_manager_config",
+    "${displaymgr_root_path}/service:displaymgr_public_config",
   ]
 
-  deps = [ "${brightnessmgr_root_path}:brightness_manager" ]
+  deps = [
+    "${brightnessmgr_root_path}:brightness_manager",
+    "${displaymgr_root_path}/service:displaymgr_stub",
+  ]
 
   cflags = [
     "-g",
@@ -54,8 +58,7 @@ ohos_fuzztest("DisplayCoverageFuzzTest") {
     "${displaymgr_root_path}/service/native/src/gradual_animator.cpp",
     "${displaymgr_root_path}/service/native/src/screen_action.cpp",
     "${displaymgr_root_path}/service/native/src/screen_controller.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_callback_proxy.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_mgr_stub.cpp",
+    "${displaymgr_utils_path}/native/src/display_xcollie.cpp",
     "../display_utils/display_fuzzer.cpp",
     "./displaycoverage_fuzzer_test.cpp",
   ]
diff --git a/state_manager/test/fuzztest/displaycoverage_fuzzer/displaycoverage_fuzzer_test.cpp b/state_manager/test/fuzztest/displaycoverage_fuzzer/displaycoverage_fuzzer_test.cpp
index a00ae70e8037ef621cb713ce58ffb27ea88998f5..fd9af449993d0de9356595336fd7398f9f30c5fa 100644
--- a/state_manager/test/fuzztest/displaycoverage_fuzzer/displaycoverage_fuzzer_test.cpp
+++ b/state_manager/test/fuzztest/displaycoverage_fuzzer/displaycoverage_fuzzer_test.cpp
@@ -20,7 +20,6 @@
 #include "display_power_mgr_service.h"
 #include "displaycoverage_fuzzer_test.h"
 
-using namespace OHOS::PowerMgr;
 using namespace OHOS::DisplayPowerMgr;
 
 namespace {
@@ -42,7 +41,8 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     uint32_t reason = 1;
     service->NotifyStateChangeCallback(DISPLAY_ID, state, reason);
     service->HandleBootBrightness();
-    service->SetScreenOnBrightness();
+    bool result = false;
+    service->SetScreenOnBrightness(result);
     service->GetSafeBrightness(BRIGHTNESS_MAX);
     service->GetSafeBrightness(BRIGHTNESS_MIN);
     service->GetSafeDiscount(DISCOUNT_MAX, brightness);
diff --git a/state_manager/test/fuzztest/displaystate_fuzzer/BUILD.gn b/state_manager/test/fuzztest/displaystate_fuzzer/BUILD.gn
index 8212a6219afe4c50cf1655952cfc2b92c57bd0c7..21db9888847459fab42309bf0ad1e6ac8b38483f 100644
--- a/state_manager/test/fuzztest/displaystate_fuzzer/BUILD.gn
+++ b/state_manager/test/fuzztest/displaystate_fuzzer/BUILD.gn
@@ -33,9 +33,13 @@ ohos_fuzztest("DisplayStateFuzzTest") {
     "${displaymgr_utils_path}:utils_config",
     "${displaymgr_utils_path}:coverage_flags",
     "${brightnessmgr_root_path}:brightness_manager_config",
+    "${displaymgr_root_path}/service:displaymgr_public_config",
   ]
 
-  deps = [ "${brightnessmgr_root_path}:brightness_manager" ]
+  deps = [
+    "${brightnessmgr_root_path}:brightness_manager",
+    "${displaymgr_root_path}/service:displaymgr_stub",
+  ]
 
   cflags = [
     "-g",
@@ -53,8 +57,7 @@ ohos_fuzztest("DisplayStateFuzzTest") {
     "${displaymgr_root_path}/service/native/src/gradual_animator.cpp",
     "${displaymgr_root_path}/service/native/src/screen_action.cpp",
     "${displaymgr_root_path}/service/native/src/screen_controller.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_callback_proxy.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_mgr_stub.cpp",
+    "${displaymgr_utils_path}/native/src/display_xcollie.cpp",
     "../display_utils/display_fuzzer.cpp",
     "./displaystate_fuzzer_test.cpp",
   ]
diff --git a/state_manager/test/fuzztest/displaystate_fuzzer/displaystate_fuzzer_test.cpp b/state_manager/test/fuzztest/displaystate_fuzzer/displaystate_fuzzer_test.cpp
index e0b30d219f51866223df633624f752921659d9fd..6f02a49248141943486e4b73bbea04825bccddee 100644
--- a/state_manager/test/fuzztest/displaystate_fuzzer/displaystate_fuzzer_test.cpp
+++ b/state_manager/test/fuzztest/displaystate_fuzzer/displaystate_fuzzer_test.cpp
@@ -18,9 +18,9 @@
 #define FUZZ_PROJECT_NAME "displaystate_fuzzer"
 
 #include "display_fuzzer.h"
-#include "display_power_mgr_ipc_interface_code.h"
+#include "idisplay_power_mgr.h"
 
-using namespace OHOS::PowerMgr;
+using namespace OHOS::DisplayPowerMgr;
 
 namespace {
 }
@@ -31,8 +31,8 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     /* Run your code on data */
     DisplayFuzzerTest g_serviceTest;
     g_serviceTest.TestDisplayServiceStub(
-        static_cast<uint32_t>(DisplayPowerMgrInterfaceCode::SET_DISPLAY_STATE), data, size);
+        static_cast<uint32_t>(IDisplayPowerMgrIpcCode::COMMAND_SET_DISPLAY_STATE), data, size);
     g_serviceTest.TestDisplayServiceStub(
-        static_cast<uint32_t>(DisplayPowerMgrInterfaceCode::GET_DISPLAY_STATE), data, size);
+        static_cast<uint32_t>(IDisplayPowerMgrIpcCode::COMMAND_GET_DISPLAY_STATE), data, size);
     return 0;
 }
diff --git a/state_manager/test/fuzztest/getbrightness_fuzzer/BUILD.gn b/state_manager/test/fuzztest/getbrightness_fuzzer/BUILD.gn
index fd0651f1a774a991cc967deacc4bdab1c9a43b93..487c5101898c3323c65fe9e0715a52c732f2224f 100644
--- a/state_manager/test/fuzztest/getbrightness_fuzzer/BUILD.gn
+++ b/state_manager/test/fuzztest/getbrightness_fuzzer/BUILD.gn
@@ -34,9 +34,13 @@ ohos_fuzztest("GetBrightnessFuzzTest") {
     "${displaymgr_utils_path}:utils_config",
     "${displaymgr_utils_path}:coverage_flags",
     "${brightnessmgr_root_path}:brightness_manager_config",
+    "${displaymgr_root_path}/service:displaymgr_public_config",
   ]
 
-  deps = [ "${brightnessmgr_root_path}:brightness_manager" ]
+  deps = [
+    "${brightnessmgr_root_path}:brightness_manager",
+    "${displaymgr_root_path}/service:displaymgr_stub",
+  ]
 
   cflags = [
     "-g",
@@ -54,8 +58,7 @@ ohos_fuzztest("GetBrightnessFuzzTest") {
     "${displaymgr_root_path}/service/native/src/gradual_animator.cpp",
     "${displaymgr_root_path}/service/native/src/screen_action.cpp",
     "${displaymgr_root_path}/service/native/src/screen_controller.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_callback_proxy.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_mgr_stub.cpp",
+    "${displaymgr_utils_path}/native/src/display_xcollie.cpp",
     "../display_utils/display_fuzzer.cpp",
     "./getbrightness_fuzzer_test.cpp",
   ]
diff --git a/state_manager/test/fuzztest/getbrightness_fuzzer/getbrightness_fuzzer_test.cpp b/state_manager/test/fuzztest/getbrightness_fuzzer/getbrightness_fuzzer_test.cpp
index ee2fe2c00c2fb35b43bd0481148046bba679e55a..b699e07d635869322775c6579c70b7243bbf7616 100644
--- a/state_manager/test/fuzztest/getbrightness_fuzzer/getbrightness_fuzzer_test.cpp
+++ b/state_manager/test/fuzztest/getbrightness_fuzzer/getbrightness_fuzzer_test.cpp
@@ -18,9 +18,9 @@
 #define FUZZ_PROJECT_NAME "getbrightness_fuzzer"
 
 #include "display_fuzzer.h"
-#include "display_power_mgr_ipc_interface_code.h"
+#include "idisplay_power_mgr.h"
 
-using namespace OHOS::PowerMgr;
+using namespace OHOS::DisplayPowerMgr;
 
 namespace {
 }
@@ -31,14 +31,14 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     /* Run your code on data */
     DisplayFuzzerTest g_serviceTest;
     g_serviceTest.TestDisplayServiceStub(
-        static_cast<uint32_t>(DisplayPowerMgrInterfaceCode::GET_BRIGHTNESS), data, size);
+        static_cast<uint32_t>(IDisplayPowerMgrIpcCode::COMMAND_GET_BRIGHTNESS), data, size);
     g_serviceTest.TestDisplayServiceStub(
-        static_cast<uint32_t>(DisplayPowerMgrInterfaceCode::GET_DEFAULT_BRIGHTNESS), data, size);
+        static_cast<uint32_t>(IDisplayPowerMgrIpcCode::COMMAND_GET_DEFAULT_BRIGHTNESS), data, size);
     g_serviceTest.TestDisplayServiceStub(
-        static_cast<uint32_t>(DisplayPowerMgrInterfaceCode::GET_MAX_BRIGHTNESS), data, size);
+        static_cast<uint32_t>(IDisplayPowerMgrIpcCode::COMMAND_GET_MAX_BRIGHTNESS), data, size);
     g_serviceTest.TestDisplayServiceStub(
-        static_cast<uint32_t>(DisplayPowerMgrInterfaceCode::GET_MIN_BRIGHTNESS), data, size);
+        static_cast<uint32_t>(IDisplayPowerMgrIpcCode::COMMAND_GET_MIN_BRIGHTNESS), data, size);
     g_serviceTest.TestDisplayServiceStub(
-        static_cast<uint32_t>(DisplayPowerMgrInterfaceCode::GET_DEVICE_BRIGHTNESS), data, size);
+        static_cast<uint32_t>(IDisplayPowerMgrIpcCode::COMMAND_GET_DEVICE_BRIGHTNESS), data, size);
     return 0;
 }
diff --git a/state_manager/test/fuzztest/getdisplayid_fuzzer/BUILD.gn b/state_manager/test/fuzztest/getdisplayid_fuzzer/BUILD.gn
index cf16e1c8dbfaf74525936d2a7f82e77b468192ca..cb79c96cc2d9aa6ee43508f4a9677e3f2779ca93 100644
--- a/state_manager/test/fuzztest/getdisplayid_fuzzer/BUILD.gn
+++ b/state_manager/test/fuzztest/getdisplayid_fuzzer/BUILD.gn
@@ -33,9 +33,13 @@ ohos_fuzztest("GetDisplayIdFuzzTest") {
     "${displaymgr_utils_path}:utils_config",
     "${displaymgr_utils_path}:coverage_flags",
     "${brightnessmgr_root_path}:brightness_manager_config",
+    "${displaymgr_root_path}/service:displaymgr_public_config",
   ]
 
-  deps = [ "${brightnessmgr_root_path}:brightness_manager" ]
+  deps = [
+    "${brightnessmgr_root_path}:brightness_manager",
+    "${displaymgr_root_path}/service:displaymgr_stub",
+  ]
 
   cflags = [
     "-g",
@@ -53,8 +57,7 @@ ohos_fuzztest("GetDisplayIdFuzzTest") {
     "${displaymgr_root_path}/service/native/src/gradual_animator.cpp",
     "${displaymgr_root_path}/service/native/src/screen_action.cpp",
     "${displaymgr_root_path}/service/native/src/screen_controller.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_callback_proxy.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_mgr_stub.cpp",
+    "${displaymgr_utils_path}/native/src/display_xcollie.cpp",
     "../display_utils/display_fuzzer.cpp",
     "./getdisplayid_fuzzer_test.cpp",
   ]
diff --git a/state_manager/test/fuzztest/getdisplayid_fuzzer/getdisplayid_fuzzer_test.cpp b/state_manager/test/fuzztest/getdisplayid_fuzzer/getdisplayid_fuzzer_test.cpp
index 748387a90ee8a9084008f94847ccd384dbb311cf..f7f5fcc5469021bb69f285e1e0727bd85697a77b 100644
--- a/state_manager/test/fuzztest/getdisplayid_fuzzer/getdisplayid_fuzzer_test.cpp
+++ b/state_manager/test/fuzztest/getdisplayid_fuzzer/getdisplayid_fuzzer_test.cpp
@@ -18,9 +18,10 @@
 #define FUZZ_PROJECT_NAME "getdisplayid_fuzzer"
 
 #include "display_fuzzer.h"
-#include "display_power_mgr_ipc_interface_code.h"
+#include "idisplay_power_mgr.h"
+
+using namespace OHOS::DisplayPowerMgr;
 
-using namespace OHOS::PowerMgr;
 
 namespace {
 }
@@ -31,8 +32,8 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     /* Run your code on data */
     DisplayFuzzerTest g_serviceTest;
     g_serviceTest.TestDisplayServiceStub(
-        static_cast<uint32_t>(DisplayPowerMgrInterfaceCode::GET_DISPLAY_IDS), data, size);
+        static_cast<uint32_t>(IDisplayPowerMgrIpcCode::COMMAND_GET_DISPLAY_IDS), data, size);
     g_serviceTest.TestDisplayServiceStub(
-        static_cast<uint32_t>(DisplayPowerMgrInterfaceCode::GET_MAIN_DISPLAY_ID), data, size);
+        static_cast<uint32_t>(IDisplayPowerMgrIpcCode::COMMAND_GET_MAIN_DISPLAY_ID), data, size);
     return 0;
 }
diff --git a/state_manager/test/fuzztest/notifyscreenpowerstatus_fuzzer/BUILD.gn b/state_manager/test/fuzztest/notifyscreenpowerstatus_fuzzer/BUILD.gn
index 54dc61471edd25091cea9344af4c6fa37b095749..e25be060a5b4e99aa3efdd646b4b339f6a43db67 100644
--- a/state_manager/test/fuzztest/notifyscreenpowerstatus_fuzzer/BUILD.gn
+++ b/state_manager/test/fuzztest/notifyscreenpowerstatus_fuzzer/BUILD.gn
@@ -34,9 +34,13 @@ ohos_fuzztest("NotifyScreenPowerStatusFuzzTest") {
     "${displaymgr_utils_path}:utils_config",
     "${displaymgr_utils_path}:coverage_flags",
     "${brightnessmgr_root_path}:brightness_manager_config",
+    "${displaymgr_root_path}/service:displaymgr_public_config",
   ]
 
-  deps = [ "${brightnessmgr_root_path}:brightness_manager" ]
+  deps = [
+    "${brightnessmgr_root_path}:brightness_manager",
+    "${displaymgr_root_path}/service:displaymgr_stub",
+  ]
 
   cflags = [
     "-g",
@@ -54,8 +58,7 @@ ohos_fuzztest("NotifyScreenPowerStatusFuzzTest") {
     "${displaymgr_root_path}/service/native/src/gradual_animator.cpp",
     "${displaymgr_root_path}/service/native/src/screen_action.cpp",
     "${displaymgr_root_path}/service/native/src/screen_controller.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_callback_proxy.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_mgr_stub.cpp",
+    "${displaymgr_utils_path}/native/src/display_xcollie.cpp",
     "../display_utils/display_fuzzer.cpp",
     "./notifyscreenpowerstatus_fuzzer_test.cpp",
   ]
diff --git a/state_manager/test/fuzztest/notifyscreenpowerstatus_fuzzer/notifyscreenpowerstatus_fuzzer_test.cpp b/state_manager/test/fuzztest/notifyscreenpowerstatus_fuzzer/notifyscreenpowerstatus_fuzzer_test.cpp
index 9fbfcdc90909f3687fc67e28baf635d99fc28aa1..575c37dfe9409beee429e17b9190486aff807441 100644
--- a/state_manager/test/fuzztest/notifyscreenpowerstatus_fuzzer/notifyscreenpowerstatus_fuzzer_test.cpp
+++ b/state_manager/test/fuzztest/notifyscreenpowerstatus_fuzzer/notifyscreenpowerstatus_fuzzer_test.cpp
@@ -18,9 +18,9 @@
 #define FUZZ_PROJECT_NAME "notifyscreenpowerstatus_fuzzer"
 
 #include "display_fuzzer.h"
-#include "display_power_mgr_ipc_interface_code.h"
+#include "idisplay_power_mgr.h"
 
-using namespace OHOS::PowerMgr;
+using namespace OHOS::DisplayPowerMgr;
 
 /* Fuzzer entry point */
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
@@ -28,6 +28,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     /* Run your code on data */
     DisplayFuzzerTest g_serviceTest;
     g_serviceTest.TestDisplayServiceStub(
-        static_cast<uint32_t>(DisplayPowerMgrInterfaceCode::NOTIFY_DISPLAY_POWER_STATUS), data, size);
+        static_cast<uint32_t>(IDisplayPowerMgrIpcCode::COMMAND_NOTIFY_SCREEN_POWER_STATUS), data, size);
     return 0;
 }
diff --git a/state_manager/test/fuzztest/overridebrightness_fuzzer/BUILD.gn b/state_manager/test/fuzztest/overridebrightness_fuzzer/BUILD.gn
index df2a682cffdf73bdc7092376bee752a3cfd6c7f4..0ff2f8b56d6e63afa9c7f37d25bcd8001e6aeeca 100644
--- a/state_manager/test/fuzztest/overridebrightness_fuzzer/BUILD.gn
+++ b/state_manager/test/fuzztest/overridebrightness_fuzzer/BUILD.gn
@@ -34,9 +34,13 @@ ohos_fuzztest("OverrideBrightnessFuzzTest") {
     "${displaymgr_utils_path}:utils_config",
     "${displaymgr_utils_path}:coverage_flags",
     "${brightnessmgr_root_path}:brightness_manager_config",
+    "${displaymgr_root_path}/service:displaymgr_public_config",
   ]
 
-  deps = [ "${brightnessmgr_root_path}:brightness_manager" ]
+  deps = [
+    "${brightnessmgr_root_path}:brightness_manager",
+    "${displaymgr_root_path}/service:displaymgr_stub",
+  ]
 
   cflags = [
     "-g",
@@ -54,8 +58,7 @@ ohos_fuzztest("OverrideBrightnessFuzzTest") {
     "${displaymgr_root_path}/service/native/src/gradual_animator.cpp",
     "${displaymgr_root_path}/service/native/src/screen_action.cpp",
     "${displaymgr_root_path}/service/native/src/screen_controller.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_callback_proxy.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_mgr_stub.cpp",
+    "${displaymgr_utils_path}/native/src/display_xcollie.cpp",
     "../display_utils/display_fuzzer.cpp",
     "./overridebrightness_fuzzer_test.cpp",
   ]
diff --git a/state_manager/test/fuzztest/overridebrightness_fuzzer/overridebrightness_fuzzer_test.cpp b/state_manager/test/fuzztest/overridebrightness_fuzzer/overridebrightness_fuzzer_test.cpp
index df5f681a6eb5d2e6ada6abf5e3fa7d3fdb77ca42..c0a1ae336800a4b81672e5128adfd2e01d19bf5a 100644
--- a/state_manager/test/fuzztest/overridebrightness_fuzzer/overridebrightness_fuzzer_test.cpp
+++ b/state_manager/test/fuzztest/overridebrightness_fuzzer/overridebrightness_fuzzer_test.cpp
@@ -18,9 +18,9 @@
 #define FUZZ_PROJECT_NAME "overridebrightness_fuzzer"
 
 #include "display_fuzzer.h"
-#include "display_power_mgr_ipc_interface_code.h"
+#include "idisplay_power_mgr.h"
 
-using namespace OHOS::PowerMgr;
+using namespace OHOS::DisplayPowerMgr;
 
 namespace {
 }
@@ -31,8 +31,8 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     /* Run your code on data */
     DisplayFuzzerTest g_serviceTest;
     g_serviceTest.TestDisplayServiceStub(
-        static_cast<uint32_t>(DisplayPowerMgrInterfaceCode::OVERRIDE_BRIGHTNESS), data, size);
+        static_cast<uint32_t>(IDisplayPowerMgrIpcCode::COMMAND_OVERRIDE_BRIGHTNESS), data, size);
     g_serviceTest.TestDisplayServiceStub(
-        static_cast<uint32_t>(DisplayPowerMgrInterfaceCode::RESTORE_BRIGHTNESS), data, size);
+        static_cast<uint32_t>(IDisplayPowerMgrIpcCode::COMMAND_RESTORE_BRIGHTNESS), data, size);
     return 0;
 }
diff --git a/state_manager/test/fuzztest/overridedisplayoffdelay_fuzzer/BUILD.gn b/state_manager/test/fuzztest/overridedisplayoffdelay_fuzzer/BUILD.gn
index b06925b72a8d298abebe0be2208e8cbe01673613..01f4d0b68b3b5f8c11b098b1aa13cc6980a79702 100644
--- a/state_manager/test/fuzztest/overridedisplayoffdelay_fuzzer/BUILD.gn
+++ b/state_manager/test/fuzztest/overridedisplayoffdelay_fuzzer/BUILD.gn
@@ -34,9 +34,13 @@ ohos_fuzztest("OverrideDisplayOffDelayFuzzTest") {
     "${displaymgr_utils_path}:utils_config",
     "${displaymgr_utils_path}:coverage_flags",
     "${brightnessmgr_root_path}:brightness_manager_config",
+    "${displaymgr_root_path}/service:displaymgr_public_config",
   ]
 
-  deps = [ "${brightnessmgr_root_path}:brightness_manager" ]
+  deps = [
+    "${brightnessmgr_root_path}:brightness_manager",
+    "${displaymgr_root_path}/service:displaymgr_stub",
+  ]
 
   cflags = [
     "-g",
@@ -54,8 +58,7 @@ ohos_fuzztest("OverrideDisplayOffDelayFuzzTest") {
     "${displaymgr_root_path}/service/native/src/gradual_animator.cpp",
     "${displaymgr_root_path}/service/native/src/screen_action.cpp",
     "${displaymgr_root_path}/service/native/src/screen_controller.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_callback_proxy.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_mgr_stub.cpp",
+    "${displaymgr_utils_path}/native/src/display_xcollie.cpp",
     "../display_utils/display_fuzzer.cpp",
     "./overridedisplayoffdelay_fuzzer_test.cpp",
   ]
diff --git a/state_manager/test/fuzztest/overridedisplayoffdelay_fuzzer/overridedisplayoffdelay_fuzzer_test.cpp b/state_manager/test/fuzztest/overridedisplayoffdelay_fuzzer/overridedisplayoffdelay_fuzzer_test.cpp
index 36c005673705425abbff19d8df862e0f315d1742..cd1880e18663dc8a446588e71ff61eae520c7ebf 100644
--- a/state_manager/test/fuzztest/overridedisplayoffdelay_fuzzer/overridedisplayoffdelay_fuzzer_test.cpp
+++ b/state_manager/test/fuzztest/overridedisplayoffdelay_fuzzer/overridedisplayoffdelay_fuzzer_test.cpp
@@ -18,9 +18,9 @@
 #define FUZZ_PROJECT_NAME "overridedisplayoffdelay_fuzzer"
 
 #include "display_fuzzer.h"
-#include "display_power_mgr_ipc_interface_code.h"
+#include "idisplay_power_mgr.h"
 
-using namespace OHOS::PowerMgr;
+using namespace OHOS::DisplayPowerMgr;
 
 namespace {
 }
@@ -31,6 +31,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     /* Run your code on data */
     DisplayFuzzerTest g_serviceTest;
     g_serviceTest.TestDisplayServiceStub(
-        static_cast<uint32_t>(DisplayPowerMgrInterfaceCode::OVERRIDE_DISPLAY_OFF_DELAY), data, size);
+        static_cast<uint32_t>(IDisplayPowerMgrIpcCode::COMMAND_OVERRIDE_DISPLAY_OFF_DELAY), data, size);
     return 0;
 }
diff --git a/state_manager/test/fuzztest/registercallback_fuzzer/BUILD.gn b/state_manager/test/fuzztest/registercallback_fuzzer/BUILD.gn
index 9a7158f0a56f22e4a7da4de19b6bdba4a4b8a246..a9e80f7f32fd54d8da555cd4c70a45904f1e81c8 100644
--- a/state_manager/test/fuzztest/registercallback_fuzzer/BUILD.gn
+++ b/state_manager/test/fuzztest/registercallback_fuzzer/BUILD.gn
@@ -34,9 +34,15 @@ ohos_fuzztest("RegisterCallbackFuzzTest") {
     "${displaymgr_utils_path}:utils_config",
     "${displaymgr_utils_path}:coverage_flags",
     "${brightnessmgr_root_path}:brightness_manager_config",
+    "${displaymgr_root_path}/service:displaymgr_public_config",
   ]
 
-  deps = [ "${brightnessmgr_root_path}:brightness_manager" ]
+
+  
+  deps = [
+    "${brightnessmgr_root_path}:brightness_manager",
+    "${displaymgr_root_path}/service:displaymgr_stub",
+  ]
 
   cflags = [
     "-g",
@@ -54,8 +60,7 @@ ohos_fuzztest("RegisterCallbackFuzzTest") {
     "${displaymgr_root_path}/service/native/src/gradual_animator.cpp",
     "${displaymgr_root_path}/service/native/src/screen_action.cpp",
     "${displaymgr_root_path}/service/native/src/screen_controller.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_callback_proxy.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_mgr_stub.cpp",
+    "${displaymgr_utils_path}/native/src/display_xcollie.cpp",
     "../display_utils/display_fuzzer.cpp",
     "./registercallback_fuzzer_test.cpp",
   ]
diff --git a/state_manager/test/fuzztest/registercallback_fuzzer/registercallback_fuzzer_test.cpp b/state_manager/test/fuzztest/registercallback_fuzzer/registercallback_fuzzer_test.cpp
index bc87d483b56581cf6c9f91d860773690789fc706..c2e9aa28e4d354c0d73fadafc53e746224be70a6 100644
--- a/state_manager/test/fuzztest/registercallback_fuzzer/registercallback_fuzzer_test.cpp
+++ b/state_manager/test/fuzztest/registercallback_fuzzer/registercallback_fuzzer_test.cpp
@@ -18,9 +18,9 @@
 #define FUZZ_PROJECT_NAME "registercallback_fuzzer"
 
 #include "display_fuzzer.h"
-#include "display_power_mgr_ipc_interface_code.h"
+#include "idisplay_power_mgr.h"
 
-using namespace OHOS::PowerMgr;
+using namespace OHOS::DisplayPowerMgr;
 
 namespace {
 }
@@ -31,6 +31,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     /* Run your code on data */
     DisplayFuzzerTest g_serviceTest;
     g_serviceTest.TestDisplayServiceStub(
-        static_cast<uint32_t>(DisplayPowerMgrInterfaceCode::REGISTER_CALLBACK), data, size);
+        static_cast<uint32_t>(IDisplayPowerMgrIpcCode::COMMAND_REGISTER_CALLBACK), data, size);
     return 0;
 }
diff --git a/state_manager/test/fuzztest/setbrightness_fuzzer/BUILD.gn b/state_manager/test/fuzztest/setbrightness_fuzzer/BUILD.gn
index 88feb5374671c9655c9a7420d917adc45ee6d085..5e9002204a4ef2657c84c24550d8add6bca152f6 100644
--- a/state_manager/test/fuzztest/setbrightness_fuzzer/BUILD.gn
+++ b/state_manager/test/fuzztest/setbrightness_fuzzer/BUILD.gn
@@ -34,9 +34,13 @@ ohos_fuzztest("SetBrightnessFuzzTest") {
     "${displaymgr_utils_path}:utils_config",
     "${displaymgr_utils_path}:coverage_flags",
     "${brightnessmgr_root_path}:brightness_manager_config",
+    "${displaymgr_root_path}/service:displaymgr_public_config",
   ]
 
-  deps = [ "${brightnessmgr_root_path}:brightness_manager" ]
+  deps = [
+    "${brightnessmgr_root_path}:brightness_manager",
+    "${displaymgr_root_path}/service:displaymgr_stub",
+  ]
 
   cflags = [
     "-g",
@@ -54,8 +58,7 @@ ohos_fuzztest("SetBrightnessFuzzTest") {
     "${displaymgr_root_path}/service/native/src/gradual_animator.cpp",
     "${displaymgr_root_path}/service/native/src/screen_action.cpp",
     "${displaymgr_root_path}/service/native/src/screen_controller.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_callback_proxy.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_mgr_stub.cpp",
+    "${displaymgr_utils_path}/native/src/display_xcollie.cpp",
     "../display_utils/display_fuzzer.cpp",
     "./setbrightness_fuzzer_test.cpp",
   ]
diff --git a/state_manager/test/fuzztest/setbrightness_fuzzer/setbrightness_fuzzer_test.cpp b/state_manager/test/fuzztest/setbrightness_fuzzer/setbrightness_fuzzer_test.cpp
index 0eb18caa2ac2a8dca5847781c8d489060f3d7e3e..bb55d4f49daf983157b1d56f3ba3f7e1795f24a8 100644
--- a/state_manager/test/fuzztest/setbrightness_fuzzer/setbrightness_fuzzer_test.cpp
+++ b/state_manager/test/fuzztest/setbrightness_fuzzer/setbrightness_fuzzer_test.cpp
@@ -18,9 +18,9 @@
 #define FUZZ_PROJECT_NAME "setbrightness_fuzzer"
 
 #include "display_fuzzer.h"
-#include "display_power_mgr_ipc_interface_code.h"
+#include "idisplay_power_mgr.h"
 
-using namespace OHOS::PowerMgr;
+using namespace OHOS::DisplayPowerMgr;
 
 namespace {
 }
@@ -31,6 +31,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     /* Run your code on data */
     DisplayFuzzerTest g_serviceTest;
     g_serviceTest.TestDisplayServiceStub(
-        static_cast<uint32_t>(DisplayPowerMgrInterfaceCode::SET_BRIGHTNESS), data, size);
+        static_cast<uint32_t>(IDisplayPowerMgrIpcCode::COMMAND_SET_BRIGHTNESS), data, size);
     return 0;
 }
diff --git a/state_manager/test/fuzztest/setcoordinated_fuzzer/BUILD.gn b/state_manager/test/fuzztest/setcoordinated_fuzzer/BUILD.gn
index 723ff1604d5c8f569cd2fee96a8089f45cf13e22..132f77e768f5b30d004309aa3d334f5ee7689dd2 100644
--- a/state_manager/test/fuzztest/setcoordinated_fuzzer/BUILD.gn
+++ b/state_manager/test/fuzztest/setcoordinated_fuzzer/BUILD.gn
@@ -34,9 +34,13 @@ ohos_fuzztest("SetCoordinatedFuzzTest") {
     "${displaymgr_utils_path}:utils_config",
     "${displaymgr_utils_path}:coverage_flags",
     "${brightnessmgr_root_path}:brightness_manager_config",
+    "${displaymgr_root_path}/service:displaymgr_public_config",
   ]
 
-  deps = [ "${brightnessmgr_root_path}:brightness_manager" ]
+  deps = [
+    "${brightnessmgr_root_path}:brightness_manager",
+    "${displaymgr_root_path}/service:displaymgr_stub",
+  ]
 
   cflags = [
     "-g",
@@ -54,8 +58,7 @@ ohos_fuzztest("SetCoordinatedFuzzTest") {
     "${displaymgr_root_path}/service/native/src/gradual_animator.cpp",
     "${displaymgr_root_path}/service/native/src/screen_action.cpp",
     "${displaymgr_root_path}/service/native/src/screen_controller.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_callback_proxy.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_mgr_stub.cpp",
+    "${displaymgr_utils_path}/native/src/display_xcollie.cpp",
     "../display_utils/display_fuzzer.cpp",
     "./setcoordinated_fuzzer_test.cpp",
   ]
diff --git a/state_manager/test/fuzztest/setcoordinated_fuzzer/setcoordinated_fuzzer_test.cpp b/state_manager/test/fuzztest/setcoordinated_fuzzer/setcoordinated_fuzzer_test.cpp
index 8876e04a03fe8f3b1e5194b32d36d89d2091f11a..c95e3a4207431a2c52acd5a939828d7fa05dd11e 100644
--- a/state_manager/test/fuzztest/setcoordinated_fuzzer/setcoordinated_fuzzer_test.cpp
+++ b/state_manager/test/fuzztest/setcoordinated_fuzzer/setcoordinated_fuzzer_test.cpp
@@ -18,9 +18,9 @@
 #define FUZZ_PROJECT_NAME "setcoordinated_fuzzer"
 
 #include "display_fuzzer.h"
-#include "display_power_mgr_ipc_interface_code.h"
+#include "idisplay_power_mgr.h"
 
-using namespace OHOS::PowerMgr;
+using namespace OHOS::DisplayPowerMgr;
 
 namespace {
 }
@@ -31,6 +31,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     /* Run your code on data */
     DisplayFuzzerTest g_serviceTest;
     g_serviceTest.TestDisplayServiceStub(
-        static_cast<uint32_t>(DisplayPowerMgrInterfaceCode::SET_COORDINATED), data, size);
+        static_cast<uint32_t>(IDisplayPowerMgrIpcCode::COMMAND_SET_COORDINATED), data, size);
     return 0;
 }
diff --git a/state_manager/test/fuzztest/setlightbrightnessthreshold_fuzzer/BUILD.gn b/state_manager/test/fuzztest/setlightbrightnessthreshold_fuzzer/BUILD.gn
index 7954b4a3ced38323ea3c4633df7d6fdf9c65e3ce..554e7a286c359fa25df95765ac435908bf85ad7a 100644
--- a/state_manager/test/fuzztest/setlightbrightnessthreshold_fuzzer/BUILD.gn
+++ b/state_manager/test/fuzztest/setlightbrightnessthreshold_fuzzer/BUILD.gn
@@ -34,9 +34,13 @@ ohos_fuzztest("SetLightBrightnessThresholdFuzzTest") {
     "${displaymgr_utils_path}:utils_config",
     "${displaymgr_utils_path}:coverage_flags",
     "${brightnessmgr_root_path}:brightness_manager_config",
+    "${displaymgr_root_path}/service:displaymgr_public_config",
   ]
 
-  deps = [ "${brightnessmgr_root_path}:brightness_manager" ]
+  deps = [
+    "${brightnessmgr_root_path}:brightness_manager",
+    "${displaymgr_root_path}/service:displaymgr_stub",
+  ]
 
   cflags = [
     "-g",
@@ -54,8 +58,7 @@ ohos_fuzztest("SetLightBrightnessThresholdFuzzTest") {
     "${displaymgr_root_path}/service/native/src/gradual_animator.cpp",
     "${displaymgr_root_path}/service/native/src/screen_action.cpp",
     "${displaymgr_root_path}/service/native/src/screen_controller.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_callback_proxy.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_mgr_stub.cpp",
+    "${displaymgr_utils_path}/native/src/display_xcollie.cpp",
     "../display_utils/display_fuzzer.cpp",
     "./setlightbrightnessthreshold_fuzzer_test.cpp",
   ]
diff --git a/state_manager/test/fuzztest/setlightbrightnessthreshold_fuzzer/setlightbrightnessthreshold_fuzzer_test.cpp b/state_manager/test/fuzztest/setlightbrightnessthreshold_fuzzer/setlightbrightnessthreshold_fuzzer_test.cpp
index 2e87c7c4af6f244948967602f195b155fe8ba48a..6db2386d9a403d8289d91c653701021a91fa6281 100644
--- a/state_manager/test/fuzztest/setlightbrightnessthreshold_fuzzer/setlightbrightnessthreshold_fuzzer_test.cpp
+++ b/state_manager/test/fuzztest/setlightbrightnessthreshold_fuzzer/setlightbrightnessthreshold_fuzzer_test.cpp
@@ -18,9 +18,9 @@
 #define FUZZ_PROJECT_NAME "setlightbrightnessthreshold_fuzzer"
 
 #include "display_fuzzer.h"
-#include "display_power_mgr_ipc_interface_code.h"
+#include "idisplay_power_mgr.h"
 
-using namespace OHOS::PowerMgr;
+using namespace OHOS::DisplayPowerMgr;
 
 namespace {
 }
@@ -31,8 +31,8 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     /* Run your code on data */
     DisplayFuzzerTest g_serviceTest;
     g_serviceTest.TestDisplayServiceStub(
-        static_cast<uint32_t>(DisplayPowerMgrInterfaceCode::SET_MAX_BRIGHTNESS), data, size);
+        static_cast<uint32_t>(IDisplayPowerMgrIpcCode::COMMAND_SET_MAX_BRIGHTNESS), data, size);
     g_serviceTest.TestDisplayServiceStub(
-        static_cast<uint32_t>(DisplayPowerMgrInterfaceCode::SET_MAX_BRIGHTNESS_NIT), data, size);
+        static_cast<uint32_t>(IDisplayPowerMgrIpcCode::COMMAND_SET_MAX_BRIGHTNESS_NIT), data, size);
     return 0;
 }
diff --git a/state_manager/test/fuzztest/setmaxbrightness_fuzzer/BUILD.gn b/state_manager/test/fuzztest/setmaxbrightness_fuzzer/BUILD.gn
index 0b8370e525a614fca4a2fb5fee701e7361f91abc..1433fb53938812be78aa42e8e54a8ae70b110d00 100644
--- a/state_manager/test/fuzztest/setmaxbrightness_fuzzer/BUILD.gn
+++ b/state_manager/test/fuzztest/setmaxbrightness_fuzzer/BUILD.gn
@@ -34,9 +34,13 @@ ohos_fuzztest("SetMaxBrightnessFuzzTest") {
     "${displaymgr_utils_path}:utils_config",
     "${displaymgr_utils_path}:coverage_flags",
     "${brightnessmgr_root_path}:brightness_manager_config",
+    "${displaymgr_root_path}/service:displaymgr_public_config",
   ]
 
-  deps = [ "${brightnessmgr_root_path}:brightness_manager" ]
+  deps = [
+    "${brightnessmgr_root_path}:brightness_manager",
+    "${displaymgr_root_path}/service:displaymgr_stub",
+  ]
 
   cflags = [
     "-g",
@@ -54,8 +58,7 @@ ohos_fuzztest("SetMaxBrightnessFuzzTest") {
     "${displaymgr_root_path}/service/native/src/gradual_animator.cpp",
     "${displaymgr_root_path}/service/native/src/screen_action.cpp",
     "${displaymgr_root_path}/service/native/src/screen_controller.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_callback_proxy.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_mgr_stub.cpp",
+    "${displaymgr_utils_path}/native/src/display_xcollie.cpp",
     "../display_utils/display_fuzzer.cpp",
     "./setmaxbrightness_fuzzer_test.cpp",
   ]
diff --git a/state_manager/test/fuzztest/setmaxbrightness_fuzzer/setmaxbrightness_fuzzer_test.cpp b/state_manager/test/fuzztest/setmaxbrightness_fuzzer/setmaxbrightness_fuzzer_test.cpp
index 71c70c465c19ed880967358a6c82513fb7bda310..0947045963a253d82568c5e83d7b73672fa446f8 100644
--- a/state_manager/test/fuzztest/setmaxbrightness_fuzzer/setmaxbrightness_fuzzer_test.cpp
+++ b/state_manager/test/fuzztest/setmaxbrightness_fuzzer/setmaxbrightness_fuzzer_test.cpp
@@ -18,9 +18,9 @@
 #define FUZZ_PROJECT_NAME "setmaxbrightness_fuzzer"
 
 #include "display_fuzzer.h"
-#include "display_power_mgr_ipc_interface_code.h"
+#include "idisplay_power_mgr.h"
 
-using namespace OHOS::PowerMgr;
+using namespace OHOS::DisplayPowerMgr;
 
 namespace {
 }
@@ -31,6 +31,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     /* Run your code on data */
     DisplayFuzzerTest g_serviceTest;
     g_serviceTest.TestDisplayServiceStub(
-        static_cast<uint32_t>(DisplayPowerMgrInterfaceCode::SET_APS_LIGHT_AND_BRIGHTNESS_THRESOLD), data, size);
+        static_cast<uint32_t>(IDisplayPowerMgrIpcCode::COMMAND_SET_LIGHT_BRIGHTNESS_THRESHOLD), data, size);
     return 0;
 }
diff --git a/state_manager/test/fuzztest/setscreenonbrightness_fuzzer/BUILD.gn b/state_manager/test/fuzztest/setscreenonbrightness_fuzzer/BUILD.gn
index dcb53e97691930e9efe0a9c10f4f209e35099dae..3fb9ad8330d68b4314e8c9eb69b48a3d411c459c 100644
--- a/state_manager/test/fuzztest/setscreenonbrightness_fuzzer/BUILD.gn
+++ b/state_manager/test/fuzztest/setscreenonbrightness_fuzzer/BUILD.gn
@@ -34,9 +34,13 @@ ohos_fuzztest("SetScreenOnBrightnessFuzzTest") {
     "${displaymgr_utils_path}:utils_config",
     "${displaymgr_utils_path}:coverage_flags",
     "${brightnessmgr_root_path}:brightness_manager_config",
+    "${displaymgr_root_path}/service:displaymgr_public_config",
   ]
 
-  deps = [ "${brightnessmgr_root_path}:brightness_manager" ]
+  deps = [
+    "${brightnessmgr_root_path}:brightness_manager",
+    "${displaymgr_root_path}/service:displaymgr_stub",
+  ]
 
   cflags = [
     "-g",
@@ -54,8 +58,7 @@ ohos_fuzztest("SetScreenOnBrightnessFuzzTest") {
     "${displaymgr_root_path}/service/native/src/gradual_animator.cpp",
     "${displaymgr_root_path}/service/native/src/screen_action.cpp",
     "${displaymgr_root_path}/service/native/src/screen_controller.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_callback_proxy.cpp",
-    "${displaymgr_root_path}/service/zidl/src/display_power_mgr_stub.cpp",
+    "${displaymgr_utils_path}/native/src/display_xcollie.cpp",
     "../display_utils/display_fuzzer.cpp",
     "./setscreenonbrightness_fuzzer_test.cpp",
   ]
diff --git a/state_manager/test/fuzztest/setscreenonbrightness_fuzzer/setscreenonbrightness_fuzzer_test.cpp b/state_manager/test/fuzztest/setscreenonbrightness_fuzzer/setscreenonbrightness_fuzzer_test.cpp
index 66ee088a3a7f8bd6fbedc3b8f96d053fd4d4c5f7..93e70a3df64eec7a9a5acdaa4e792ee588eeb5ee 100644
--- a/state_manager/test/fuzztest/setscreenonbrightness_fuzzer/setscreenonbrightness_fuzzer_test.cpp
+++ b/state_manager/test/fuzztest/setscreenonbrightness_fuzzer/setscreenonbrightness_fuzzer_test.cpp
@@ -18,9 +18,9 @@
 #define FUZZ_PROJECT_NAME "setscreenonbrightness_fuzzer"
 
 #include "display_fuzzer.h"
-#include "display_power_mgr_ipc_interface_code.h"
+#include "idisplay_power_mgr.h"
 
-using namespace OHOS::PowerMgr;
+using namespace OHOS::DisplayPowerMgr;
 
 /* Fuzzer entry point */
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
@@ -28,6 +28,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     /* Run your code on data */
     DisplayFuzzerTest g_serviceTest;
     g_serviceTest.TestDisplayServiceStub(
-        static_cast<uint32_t>(DisplayPowerMgrInterfaceCode::SET_SCREEN_ON_BRIGHTNESS), data, size);
+        static_cast<uint32_t>(IDisplayPowerMgrIpcCode::COMMAND_SET_SCREEN_ON_BRIGHTNESS), data, size);
     return 0;
 }
diff --git a/state_manager/test/unittest/BUILD.gn b/state_manager/test/unittest/BUILD.gn
index 1f0bd3910dcefedc1dfe7f4554d88002e7ae43e2..674f62ab282c5d7d667f106340cdad9a3c286e80 100644
--- a/state_manager/test/unittest/BUILD.gn
+++ b/state_manager/test/unittest/BUILD.gn
@@ -25,6 +25,7 @@ config("module_private_config") {
     "include/mock",
     "mock/include",
     "${displaymgr_inner_api}/native/include",
+    "${displaymgr_root_path}/utils/native/include",
     "${displaymgr_service_zidl}/include",
     "${displaymgr_utils_path}/native/include",
   ]
@@ -48,18 +49,33 @@ deps_ex = [
 ohos_unittest("unittest_display_mgr_service") {
   module_out_path = module_output_path
 
+  defines += [ "GTEST" ]
+  sanitize = {
+    cfi = true
+    cfi_cross_dso = true
+    debug = false
+  }
+
   sources = [
+    "mock/src/mock_display_power_mgr_proxy.cpp",
+    "mock/src/mock_display_remote_object.cpp",
     "src/display_power_mgr_brightness_test.cpp",
     "src/display_power_mgr_service_test.cpp",
+    "${displaymgr_root_path}/utils/native/src/display_xcollie.cpp",
   ]
 
   configs = [
     "${displaymgr_utils_path}:utils_config",
     ":module_private_config",
     "${displaymgr_utils_path}:coverage_flags",
+    "${displaymgr_root_path}/service:displaymgr_public_config",
   ]
 
-  deps = [ "${displaymgr_inner_api}:displaymgr" ]
+  deps = [
+    "${displaymgr_inner_api}:displaymgr",
+    "${displaymgr_root_path}/service:displaymgr_proxy",
+    "${displaymgr_root_path}/service:displaymgr_stub",
+  ]
 
   external_deps = [
     "ability_base:want",
@@ -69,6 +85,7 @@ ohos_unittest("unittest_display_mgr_service") {
     "c_utils:utils",
     "data_share:datashare_consumer",
     "googletest:gtest_main",
+    "hicollie:libhicollie",
     "hilog:libhilog",
     "ipc:ipc_core",
     "power_manager:power_setting",
@@ -82,17 +99,28 @@ ohos_unittest("unittest_display_mgr_service") {
 ohos_unittest("display_service_death_test") {
   module_out_path = module_output_path
 
+  sanitize = {
+    cfi = true
+    cfi_cross_dso = true
+    debug = false
+  }
+
   sources = [ "src/display_service_death_test.cpp" ]
 
   configs = [
     "${displaymgr_utils_path}:utils_config",
     ":module_private_config",
     "${displaymgr_utils_path}:coverage_flags",
+    "${displaymgr_root_path}/service:displaymgr_public_config",
   ]
 
   defines += [ "DISPLAY_SERVICE_DEATH_UT" ]
 
-  deps = [ "${displaymgr_inner_api}:displaymgr" ]
+  deps = [
+    "${displaymgr_inner_api}:displaymgr",
+    "${displaymgr_root_path}/service:displaymgr_proxy",
+    "${displaymgr_root_path}/service:displaymgr_stub",
+  ]
 
   external_deps = [ "googletest:gtest_main" ]
   external_deps += deps_ex
@@ -102,6 +130,12 @@ ohos_unittest("display_service_death_test") {
 ohos_unittest("display_mock_parcel_test") {
   module_out_path = module_output_path
 
+  sanitize = {
+    cfi = true
+    cfi_cross_dso = true
+    debug = false
+  }
+
   sources = [
     "mock/src/mock_message_parcel.cpp",
     "mock/src/mock_parcel.cpp",
@@ -112,9 +146,13 @@ ohos_unittest("display_mock_parcel_test") {
     "${displaymgr_utils_path}:utils_config",
     ":module_private_config",
     "${displaymgr_utils_path}:coverage_flags",
+    "${displaymgr_root_path}/service:displaymgr_public_config",
   ]
 
-  deps = [ "${displaymgr_inner_api}:displaymgr" ]
+  deps = [
+    "${displaymgr_inner_api}:displaymgr",
+    "${displaymgr_root_path}/service:displaymgr_proxy",
+  ]
   external_deps = [ "googletest:gtest_main" ]
   external_deps += deps_ex
 }
@@ -123,6 +161,12 @@ ohos_unittest("display_mock_parcel_test") {
 ohos_unittest("display_mock_test") {
   module_out_path = module_output_path
 
+  sanitize = {
+    cfi = true
+    cfi_cross_dso = true
+    debug = false
+  }
+
   sources = [
     "mock/src/mock_display_remote_object.cpp",
     "mock/src/mock_message_parcel.cpp",
@@ -134,6 +178,7 @@ ohos_unittest("display_mock_test") {
     "${displaymgr_utils_path}:utils_config",
     ":module_private_config",
     "${displaymgr_utils_path}:coverage_flags",
+    "${displaymgr_root_path}/service:displaymgr_public_config",
   ]
 
   defines += [
@@ -141,7 +186,10 @@ ohos_unittest("display_mock_test") {
     "MOCK_WRITE_INTERFACE_TOKEN_RETURN_TRUE",
   ]
 
-  deps = [ "${displaymgr_inner_api}:displaymgr" ]
+  deps = [
+    "${displaymgr_inner_api}:displaymgr",
+    "${displaymgr_root_path}/service:displaymgr_proxy",
+  ]
 
   external_deps = [ "googletest:gtest_main" ]
   external_deps += deps_ex
@@ -151,6 +199,12 @@ ohos_unittest("display_mock_test") {
 ohos_unittest("display_mock_object_test") {
   module_out_path = module_output_path
 
+  sanitize = {
+    cfi = true
+    cfi_cross_dso = true
+    debug = false
+  }
+
   sources = [
     "mock/src/mock_display_remote_object.cpp",
     "src/mock/display_mock_object_test.cpp",
@@ -160,14 +214,101 @@ ohos_unittest("display_mock_object_test") {
     "${displaymgr_utils_path}:utils_config",
     ":module_private_config",
     "${displaymgr_utils_path}:coverage_flags",
+    "${displaymgr_root_path}/service:displaymgr_public_config",
   ]
 
-  deps = [ "${displaymgr_inner_api}:displaymgr" ]
+  deps = [
+    "${displaymgr_inner_api}:displaymgr",
+    "${displaymgr_root_path}/service:displaymgr_proxy",
+  ]
 
   external_deps = [ "googletest:gtest_main" ]
   external_deps += deps_ex
 }
 
+############################display_service_test#############################
+ohos_unittest("display_service_test") {
+  module_out_path = module_output_path
+
+  cflags = [
+    "-Dprivate=public",
+    "-Dprotected=public",
+  ]
+
+  sanitize = {
+    cfi = true
+    cfi_cross_dso = true
+    debug = false
+  }
+
+  sources = [
+    "src/display_service_test.cpp",
+    "${displaymgr_utils_path}/native/src/display_xcollie.cpp",
+    "${displaymgr_root_path}/service/native/src/display_auto_brightness.cpp",
+    "${displaymgr_root_path}/service/native/src/display_common_event_mgr.cpp",
+    "${displaymgr_root_path}/service/native/src/display_param_helper.cpp",
+    "${displaymgr_root_path}/service/native/src/display_power_mgr_service.cpp",
+    "${displaymgr_root_path}/service/native/src/display_setting_helper.cpp",
+    "${displaymgr_root_path}/service/native/src/display_system_ability.cpp",
+    "${displaymgr_root_path}/service/native/src/gradual_animator.cpp",
+    "${displaymgr_root_path}/service/native/src/screen_action.cpp",
+    "${displaymgr_root_path}/service/native/src/screen_controller.cpp",
+    "${displaymgr_root_path}/service/zidl/src/display_brightness_callback_proxy.cpp",
+    "${displaymgr_root_path}/service/zidl/src/display_power_callback_proxy.cpp",
+  ]
+
+  configs = [
+    "${displaymgr_utils_path}:utils_config",
+    ":module_private_config",
+    "${displaymgr_utils_path}:coverage_flags",
+    "${displaymgr_root_path}/service:displaymgr_private_config",
+    "${displaymgr_root_path}/service:displaymgr_public_config",
+  ]
+
+  deps = [
+    "${displaymgr_inner_api}:displaymgr",
+    "${displaymgr_root_path}/service:displaymgrservice",
+    "${displaymgr_root_path}/service:displaymgr_stub",
+  ]
+
+  public_deps = [ "${brightnessmgr_root_path}:brightness_manager" ]
+
+  external_deps = [ "power_manager:power_permission" ]
+
+  external_deps += [
+    "ability_base:zuri",
+    "ability_runtime:ability_manager",
+    "cJSON:cjson",
+    "c_utils:utils",
+    "data_share:datashare_consumer",
+    "eventhandler:libeventhandler",
+    "ffrt:libffrt",
+    "googletest:gtest_main",
+    "graphic_2d:librender_service_base",
+    "hicollie:libhicollie",
+    "hilog:libhilog",
+    "image_framework:image_native",
+    "ipc:ipc_core",
+    "power_manager:power_ffrt",
+    "power_manager:power_setting",
+    "power_manager:power_sysparam",
+    "power_manager:powermgr_client",
+    "safwk:system_ability_fwk",
+    "samgr:samgr_proxy",
+    "skia:skia_canvaskit",
+    "window_manager:libdm_lite",
+  ]
+  external_deps += deps_ex
+
+  if (has_sensors_sensor_part) {
+    external_deps += [ "sensor:sensor_interface_native" ]
+    defines += [ "ENABLE_SENSOR_PART" ]
+  }
+  if (has_hiviewdfx_hisysevent_part) {
+    external_deps += [ "hisysevent:libhisysevent" ]
+  }
+}
+
 group("unittest") {
   testonly = true
   deps = [
@@ -175,5 +316,6 @@ group("unittest") {
     ":display_mock_parcel_test",
     ":display_mock_test",
     ":display_service_death_test",
+    ":display_service_test",
   ]
 }
diff --git a/state_manager/test/unittest/include/display_power_mgr_service_test.h b/state_manager/test/unittest/include/display_power_mgr_service_test.h
index 7557d45a10001a6ec54ca4b5ba9cea5f768abda3..45b41a4ca5d3e6cb73b17f57a91a495b9b502b86 100644
--- a/state_manager/test/unittest/include/display_power_mgr_service_test.h
+++ b/state_manager/test/unittest/include/display_power_mgr_service_test.h
@@ -17,6 +17,7 @@
 #define DISPLAYMGR_DISPLAY_MGR_SERVICE_TEST_H
 
 #include <gtest/gtest.h>
+#include "display_power_callback_stub.h"
 
 class DisplayPowerMgrServiceTest : public testing::Test {
 public:
@@ -24,5 +25,12 @@ public:
     static void TearDownTestCase(void) {}
     void SetUp();
     void TearDown();
+    class DisplayPowerMgrTestCallback : public OHOS::DisplayPowerMgr::DisplayPowerCallbackStub {
+    public:
+        DisplayPowerMgrTestCallback() {};
+        virtual ~DisplayPowerMgrTestCallback() {};
+        virtual void OnDisplayStateChanged(
+            uint32_t displayId, OHOS::DisplayPowerMgr::DisplayState state, uint32_t reason) override;
+    };
 };
 #endif // DISPLAYMGR_DISPLAY_MGR_SERVICE_TEST_H
diff --git a/state_manager/interfaces/inner_api/native/include/display_power_mgr_ipc_interface_code.h b/state_manager/test/unittest/include/display_service_test.h
similarity index 38%
rename from state_manager/interfaces/inner_api/native/include/display_power_mgr_ipc_interface_code.h
rename to state_manager/test/unittest/include/display_service_test.h
index 66df8f70ff651ebf8c0578f2baeccc829031a00e..98b0dbc0cfb0eadcfedd72381ec2d6d6858be586 100644
--- a/state_manager/interfaces/inner_api/native/include/display_power_mgr_ipc_interface_code.h
+++ b/state_manager/test/unittest/include/display_service_test.h
@@ -1,53 +1,40 @@
-/*
- * Copyright (c) 2023 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 DISPLAY_POWER_MGR_IPC_INTERFACE_DODE_H
-#define DISPLAY_POWER_MGR_IPC_INTERFACE_DODE_H
-
-/* SAID: 3308 */
-namespace OHOS {
-namespace PowerMgr {
-enum class DisplayPowerMgrInterfaceCode {
-    SET_DISPLAY_STATE = 0,
-    GET_DISPLAY_STATE,
-    GET_DISPLAY_IDS,
-    GET_MAIN_DISPLAY_ID,
-    SET_BRIGHTNESS,
-    DISCOUNT_BRIGHTNESS,
-    OVERRIDE_BRIGHTNESS,
-    OVERRIDE_DISPLAY_OFF_DELAY,
-    RESTORE_BRIGHTNESS,
-    GET_BRIGHTNESS,
-    GET_DEFAULT_BRIGHTNESS,
-    GET_MAX_BRIGHTNESS,
-    GET_MIN_BRIGHTNESS,
-    ADJUST_BRIGHTNESS,
-    AUTO_ADJUST_BRIGHTNESS,
-    IS_AUTO_ADJUST_BRIGHTNESS,
-    REGISTER_CALLBACK,
-    BOOST_BRIGHTNESS,
-    CANCEL_BOOST_BRIGHTNESS,
-    GET_DEVICE_BRIGHTNESS,
-    SET_COORDINATED,
-    SET_APS_LIGHT_AND_BRIGHTNESS_THRESOLD = 21,
-    SET_MAX_BRIGHTNESS,
-    SET_MAX_BRIGHTNESS_NIT,
-    NOTIFY_DISPLAY_POWER_STATUS,
-    SET_SCREEN_ON_BRIGHTNESS,
-};
-} // space PowerMgr
-} // namespace OHOS
-
-#endif // DISPLAY_POWER_MGR_IPC_INTERFACE_DODE_H
\ No newline at end of file
+/*
+ * 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 DISPLAY_SERVICE_TEST_H
+#define DISPLAY_SERVICE_TEST_H
+
+#include <gtest/gtest.h>
+#include "display_power_mgr_proxy.h"
+#include "display_power_callback_stub.h"
+
+namespace OHOS {
+namespace PowerMgr {
+class DisplayServiceTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    static void DisplayServiceInnerTestFunc();
+    class DisplayPowerMgrTestCallback : public OHOS::DisplayPowerMgr::DisplayPowerCallbackStub {
+    public:
+        DisplayPowerMgrTestCallback() {}
+        virtual ~DisplayPowerMgrTestCallback() {}
+        virtual void OnDisplayStateChanged(
+            uint32_t displayId, OHOS::DisplayPowerMgr::DisplayState state, uint32_t reason) override;
+    };
+};
+} // namespace PowerMgr
+} // namespace OHOS
+#endif // DISPLAY_SERVICE_TEST_H
diff --git a/state_manager/test/unittest/include/mock/display_mock_parcel_test.h b/state_manager/test/unittest/include/mock/display_mock_parcel_test.h
index e3e07a766e837c7e0b8de16af3e13fc8fe44a68a..6e728ef6b408090fa3ea23b043b3021b33b27117 100644
--- a/state_manager/test/unittest/include/mock/display_mock_parcel_test.h
+++ b/state_manager/test/unittest/include/mock/display_mock_parcel_test.h
@@ -25,6 +25,8 @@ namespace PowerMgr {
 class DisplayMockParcelTest : public testing::Test {
 public:
     static void DisplayProxyTestFunc(std::shared_ptr<DisplayPowerMgr::DisplayPowerMgrProxy>& sptrDisplayProxy);
+    static void DisplayProxyBrightnessTestFunc(std::shared_ptr<DisplayPowerMgr::DisplayPowerMgrProxy>&
+        sptrDisplayProxy);
     class DisplayPowerMgrTestCallback : public OHOS::DisplayPowerMgr::DisplayPowerCallbackStub {
     public:
         DisplayPowerMgrTestCallback() {};
diff --git a/state_manager/test/unittest/mock/include/mock_display_power_mgr_proxy.h b/state_manager/test/unittest/mock/include/mock_display_power_mgr_proxy.h
new file mode 100644
index 0000000000000000000000000000000000000000..fd220f4e5affb859ec31298bdcf1323ec5d379a8
--- /dev/null
+++ b/state_manager/test/unittest/mock/include/mock_display_power_mgr_proxy.h
@@ -0,0 +1,60 @@
+/*
+ * 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 MOCK_DISPLAY_POWER_MGR_PROXY_H
+#define MOCK_DISPLAY_POWER_MGR_PROXY_H
+
+#include "display_power_mgr_proxy.h"
+
+namespace OHOS {
+namespace DisplayPowerMgr {
+class MockDisplayPowerMgrProxy : public DisplayPowerMgrProxy {
+public:
+    explicit MockDisplayPowerMgrProxy(const sptr<IRemoteObject>& remote)
+        : DisplayPowerMgrProxy(remote)
+    {}
+    ~MockDisplayPowerMgrProxy() {}
+    int32_t SetDisplayState(uint32_t id, uint32_t state, uint32_t reason, bool& bResult) override;
+    int32_t GetDisplayState(uint32_t id, int32_t& displayState) override;
+    int32_t GetDisplayIds(std::vector<uint32_t>& ids) override;
+    int32_t GetMainDisplayId(uint32_t& id) override;
+    int32_t SetBrightness(uint32_t value, uint32_t displayId, bool continuous, bool& bResult,
+        int32_t& retCode) override;
+    int32_t SetMaxBrightness(double value, uint32_t enterTestMode, bool& bResult, int32_t& retCode) override;
+    int32_t SetMaxBrightnessNit(uint32_t maxNit, uint32_t enterTestMode, bool& bResult, int32_t& retCode) override;
+    int32_t DiscountBrightness(double value, uint32_t displayId, bool& bResult) override;
+    int32_t OverrideBrightness(uint32_t value, uint32_t displayId, uint32_t duration, bool& bResult) override;
+    int32_t OverrideDisplayOffDelay(uint32_t delayMs, bool& bResult) override;
+    int32_t RestoreBrightness(uint32_t displayId, uint32_t duration, bool& bResult) override;
+    int32_t GetBrightness(uint32_t displayId, uint32_t& brightness) override;
+    int32_t GetDefaultBrightness(uint32_t& defaultBrightness) override;
+    int32_t GetMaxBrightness(uint32_t& maxBrightness) override;
+    int32_t GetMinBrightness(uint32_t& minBrightness) override;
+    int32_t AdjustBrightness(uint32_t id, int32_t value, uint32_t duration, bool& bResult) override;
+    int32_t AutoAdjustBrightness(bool enable, bool& bResult) override;
+    int32_t IsAutoAdjustBrightness(bool& bResult) override;
+    int32_t BoostBrightness(int32_t timeoutMs, uint32_t displayId, bool& bResult) override;
+    int32_t CancelBoostBrightness(uint32_t displayId, bool& bResult) override;
+    int32_t GetDeviceBrightness(uint32_t displayId, uint32_t& deviceBrightness) override;
+    int32_t SetCoordinated(bool coordinated, uint32_t displayId, bool& bResult) override;
+    int32_t SetLightBrightnessThreshold(const std::vector<int32_t>& threshold,
+        const sptr<IDisplayBrightnessCallback>& displayBrightnessCallback, uint32_t& retCode) override;
+    int32_t RegisterCallback(const sptr<IDisplayPowerCallback>& displayPowercallback, bool& bResult) override;
+    int32_t SetScreenOnBrightness(bool& bResult) override;
+    int32_t NotifyScreenPowerStatus(uint32_t displayId, uint32_t displayPowerStatus, int32_t& retCode) override;
+};
+} // namespace DisplayPowerMgr
+} // namespace OHOS
+#endif // MOCK_DISPLAY_POWER_MGR_PROXY_H
diff --git a/state_manager/test/unittest/mock/src/mock_display_power_mgr_proxy.cpp b/state_manager/test/unittest/mock/src/mock_display_power_mgr_proxy.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..690bf3d093e927978ea06a1b141f45c733446c19
--- /dev/null
+++ b/state_manager/test/unittest/mock/src/mock_display_power_mgr_proxy.cpp
@@ -0,0 +1,160 @@
+/*
+ * 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 "mock_display_power_mgr_proxy.h"
+namespace {
+constexpr int32_t ERR_FAIL = -1;
+}
+namespace OHOS {
+namespace DisplayPowerMgr {
+int32_t MockDisplayPowerMgrProxy::SetDisplayState(uint32_t id, uint32_t state, uint32_t reason, bool& isResult)
+{
+    return ERR_FAIL;
+}
+
+int32_t MockDisplayPowerMgrProxy::GetDisplayState(uint32_t id, int32_t& displayState)
+{
+    return ERR_FAIL;
+}
+
+int32_t MockDisplayPowerMgrProxy::GetDisplayIds(std::vector<uint32_t>& ids)
+{
+    return ERR_FAIL;
+}
+
+int32_t MockDisplayPowerMgrProxy::GetMainDisplayId(uint32_t& id)
+{
+    return ERR_FAIL;
+}
+
+int32_t MockDisplayPowerMgrProxy::SetBrightness(uint32_t value, uint32_t displayId, bool continuous, bool& isResult,
+    int32_t& retCode)
+{
+    return ERR_FAIL;
+}
+
+int32_t MockDisplayPowerMgrProxy::SetMaxBrightness(double value, uint32_t enterTestMode, bool& isResult,
+    int32_t& retCode)
+{
+    return ERR_FAIL;
+}
+
+int32_t MockDisplayPowerMgrProxy::SetMaxBrightnessNit(uint32_t maxNit, uint32_t enterTestMode, bool& isResult,
+    int32_t& retCode)
+{
+    return ERR_FAIL;
+}
+
+int32_t MockDisplayPowerMgrProxy::DiscountBrightness(double value, uint32_t displayId, bool& isResult)
+{
+    return ERR_FAIL;
+}
+
+int32_t MockDisplayPowerMgrProxy::OverrideBrightness(uint32_t value, uint32_t displayId, uint32_t duration,
+    bool& isResult)
+{
+    return ERR_FAIL;
+}
+
+int32_t MockDisplayPowerMgrProxy::OverrideDisplayOffDelay(uint32_t delayMs, bool& isResult)
+{
+    return ERR_FAIL;
+}
+
+int32_t MockDisplayPowerMgrProxy::RestoreBrightness(uint32_t displayId, uint32_t duration, bool& isResult)
+{
+    return ERR_FAIL;
+}
+
+int32_t MockDisplayPowerMgrProxy::GetBrightness(uint32_t displayId, uint32_t& brightness)
+{
+    return ERR_FAIL;
+}
+
+int32_t MockDisplayPowerMgrProxy::GetDefaultBrightness(uint32_t& defaultBrightness)
+{
+    return ERR_FAIL;
+}
+
+int32_t MockDisplayPowerMgrProxy::GetMaxBrightness(uint32_t& maxBrightness)
+{
+    return ERR_FAIL;
+}
+
+int32_t MockDisplayPowerMgrProxy::GetMinBrightness(uint32_t& minBrightness)
+{
+    return ERR_FAIL;
+}
+
+int32_t MockDisplayPowerMgrProxy::AdjustBrightness(uint32_t id, int32_t value, uint32_t duration, bool& isResult)
+{
+    return ERR_FAIL;
+}
+
+int32_t MockDisplayPowerMgrProxy::AutoAdjustBrightness(bool enable, bool& isResult)
+{
+    return ERR_FAIL;
+}
+
+int32_t MockDisplayPowerMgrProxy::IsAutoAdjustBrightness(bool& isResult)
+{
+    return ERR_FAIL;
+}
+
+int32_t MockDisplayPowerMgrProxy::BoostBrightness(int32_t timeoutMs, uint32_t displayId, bool& isResult)
+{
+    return ERR_FAIL;
+}
+
+int32_t MockDisplayPowerMgrProxy::CancelBoostBrightness(uint32_t displayId, bool& isResult)
+{
+    return ERR_FAIL;
+}
+
+int32_t MockDisplayPowerMgrProxy::GetDeviceBrightness(uint32_t displayId, uint32_t& deviceBrightness)
+{
+    return ERR_FAIL;
+}
+
+int32_t MockDisplayPowerMgrProxy::SetCoordinated(bool coordinated, uint32_t displayId, bool& isResult)
+{
+    return ERR_FAIL;
+}
+
+int32_t MockDisplayPowerMgrProxy::SetLightBrightnessThreshold(const std::vector<int32_t>& threshold,
+    const sptr<IDisplayBrightnessCallback>& displayBrightnessCallback, uint32_t& retCode)
+{
+    return ERR_FAIL;
+}
+
+int32_t MockDisplayPowerMgrProxy::RegisterCallback(const sptr<IDisplayPowerCallback>& displayPowercallback,
+    bool& isResult)
+{
+    return ERR_FAIL;
+}
+
+int32_t MockDisplayPowerMgrProxy::SetScreenOnBrightness(bool& isResult)
+{
+    return ERR_FAIL;
+}
+
+int32_t MockDisplayPowerMgrProxy::NotifyScreenPowerStatus(uint32_t displayId, uint32_t displayPowerStatus,
+    int32_t& retCode)
+{
+    return ERR_FAIL;
+}
+
+} // namespace DisplayPowerMgr
+} // namespace OHOS
diff --git a/state_manager/test/unittest/src/display_power_mgr_service_test.cpp b/state_manager/test/unittest/src/display_power_mgr_service_test.cpp
index cf7c2f4cdffc8fe38da0c12414bcd2d6ece3ef21..685ad2c2c12e8d93c9a96d649e8aa1a1c3905d58 100644
--- a/state_manager/test/unittest/src/display_power_mgr_service_test.cpp
+++ b/state_manager/test/unittest/src/display_power_mgr_service_test.cpp
@@ -12,7 +12,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
+#ifdef GTEST
+#define private   public
+#define protected public
+#endif
 #include "display_power_mgr_service_test.h"
 
 #include <iservice_registry.h>
@@ -21,19 +24,36 @@
 
 #include "display_power_mgr_client.h"
 #include "display_log.h"
+#include "display_xcollie.h"
+#include "mock_display_power_mgr_proxy.h"
+#include "mock_display_remote_object.h"
 
 using namespace testing::ext;
 using namespace OHOS;
 using namespace OHOS::DisplayPowerMgr;
+namespace {
+sptr<IRemoteObject> g_testRemoteObj;
+sptr<MockDisplayPowerMgrProxy> g_mockProxy;
+}
 
 void DisplayPowerMgrServiceTest::SetUp()
 {
     DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_ON);
+    g_testRemoteObj = sptr<PowerMgr::MockDisplayRemoteObject>::MakeSptr(u"DisplayPowerMgrServiceTest");
+    g_mockProxy = sptr<MockDisplayPowerMgrProxy>::MakeSptr(g_testRemoteObj);
 }
 
 void DisplayPowerMgrServiceTest::TearDown()
 {
     DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_OFF);
+    g_testRemoteObj = nullptr;
+    g_mockProxy = nullptr;
+}
+
+void DisplayPowerMgrServiceTest::DisplayPowerMgrTestCallback::OnDisplayStateChanged(
+    uint32_t displayId, DisplayPowerMgr::DisplayState state, uint32_t reason)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrTestCallback::OnDisplayStateChanged");
 }
 
 namespace {
@@ -472,4 +492,550 @@ HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrService025, TestSize.Level0)
     DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService025 function end!");
 }
 
+/**
+ * @tc.name: DisplayXCollie001
+ * @tc.desc: Test functions DisplayXCollie default
+ * @tc.type: FUNC
+ */
+HWTEST_F(DisplayPowerMgrServiceTest, DisplayXCollie001, TestSize.Level1)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayXCollie001 function start!");
+    DisplayXCollie displayXCollie("DisplayPowerMgrService::GetDisplayState");
+    EXPECT_FALSE(displayXCollie.isCanceled_.load());
+    displayXCollie.CancelDisplayXCollie();
+    EXPECT_TRUE(displayXCollie.isCanceled_.load());
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayXCollie001 function end!");
+}
+
+/**
+ * @tc.name: DisplayXCollie002
+ * @tc.desc: Test functions DisplayXCollie isRecovery = true
+ * @tc.type: FUNC
+ */
+HWTEST_F(DisplayPowerMgrServiceTest, DisplayXCollie002, TestSize.Level1)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayXCollie002 function start!");
+    DisplayXCollie displayXCollie("DisplayPowerMgrService::GetDisplayState", true);
+    EXPECT_FALSE(displayXCollie.isCanceled_.load());
+    displayXCollie.CancelDisplayXCollie();
+    EXPECT_TRUE(displayXCollie.isCanceled_.load());
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayXCollie002 function end!");
+}
+
+/**
+ * @tc.name: DisplayXCollie003
+ * @tc.desc: Test functions DisplayXCollie empty logtag
+ * @tc.type: FUNC
+ */
+HWTEST_F(DisplayPowerMgrServiceTest, DisplayXCollie003, TestSize.Level1)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayXCollie003 function start!");
+    std::string emptyString;
+    DisplayXCollie displayXCollie(emptyString, true);
+    EXPECT_FALSE(displayXCollie.isCanceled_.load());
+    displayXCollie.CancelDisplayXCollie();
+    EXPECT_TRUE(displayXCollie.isCanceled_.load());
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayXCollie003 function end!");
+}
+
+/**
+ * @tc.name: DisplayPowerMgrClient001
+ * @tc.desc: test SetDisplayState() when proxy return fail
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient001, TestSize.Level0)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient001 function start!");
+    auto& client = DisplayPowerMgrClient::GetInstance();
+    auto proxy = client.proxy_;
+    client.proxy_ = g_mockProxy;
+    bool ret = client.SetDisplayState(DisplayState::DISPLAY_OFF);
+    client.proxy_ = proxy;
+    EXPECT_FALSE(ret);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient001 function end!");
+}
+
+/**
+ * @tc.name: DisplayPowerMgrClient002
+ * @tc.desc: test GetDisplayState() when proxy return fail
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient002, TestSize.Level0)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient002 function start!");
+    auto& client = DisplayPowerMgrClient::GetInstance();
+    auto proxy = client.proxy_;
+    client.proxy_ = g_mockProxy;
+    auto displayState = client.GetDisplayState();
+    client.proxy_ = proxy;
+    EXPECT_EQ(displayState, DisplayState::DISPLAY_UNKNOWN);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient002 function end!");
+}
+
+/**
+ * @tc.name: DisplayPowerMgrClient003
+ * @tc.desc: test GetDisplayIds() when proxy return fail
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient003, TestSize.Level0)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient003 function start!");
+    auto& client = DisplayPowerMgrClient::GetInstance();
+    auto proxy = client.proxy_;
+    client.proxy_ = g_mockProxy;
+    auto ids = client.GetDisplayIds();
+    client.proxy_ = proxy;
+    EXPECT_TRUE(ids.size() == 0);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient003 function end!");
+}
+
+/**
+ * @tc.name: DisplayPowerMgrClient004
+ * @tc.desc: test GetMainDisplayId() when proxy return fail
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient004, TestSize.Level0)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient004 function start!");
+    auto& client = DisplayPowerMgrClient::GetInstance();
+    auto proxy = client.proxy_;
+    client.proxy_ = g_mockProxy;
+    auto id = client.GetMainDisplayId();
+    client.proxy_ = proxy;
+    EXPECT_EQ(id, OHOS::DisplayPowerMgr::DisplayPowerMgrClient::DEFAULT_MAIN_DISPLAY_ID);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient004 function end!");
+}
+
+/**
+ * @tc.name: DisplayPowerMgrClient005
+ * @tc.desc: test SetBrightness() when proxy return fail
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient005, TestSize.Level0)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient004 function start!");
+    auto& client = DisplayPowerMgrClient::GetInstance();
+    auto proxy = client.proxy_;
+    client.proxy_ = g_mockProxy;
+    const uint32_t SET_BRIGHTNESS = 150;
+    auto result = client.SetBrightness(SET_BRIGHTNESS);
+    client.proxy_ = proxy;
+    EXPECT_FALSE(result);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient005 function end!");
+}
+
+/**
+ * @tc.name: DisplayPowerMgrClient006
+ * @tc.desc: test SetMaxBrightness() when proxy return fail
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient006, TestSize.Level0)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient006 function start!");
+    auto& client = DisplayPowerMgrClient::GetInstance();
+    auto proxy = client.proxy_;
+    client.proxy_ = g_mockProxy;
+    const uint32_t SET_MAX_BRIGHTNESS = 231;
+    auto result = client.SetMaxBrightness(SET_MAX_BRIGHTNESS,
+        OHOS::DisplayPowerMgr::DisplayPowerMgrClient::DEFAULT_MAIN_DISPLAY_ID);
+    client.proxy_ = proxy;
+    EXPECT_FALSE(result);
+}
+
+/**
+ * @tc.name: DisplayPowerMgrClient007
+ * @tc.desc: test SetMaxBrightnessNit() when proxy return fail
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient007, TestSize.Level0)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient006 function start!");
+    auto& client = DisplayPowerMgrClient::GetInstance();
+    auto proxy = client.proxy_;
+    client.proxy_ = g_mockProxy;
+    const uint32_t SET_MAX_BRIGHTNESS = 231;
+    auto result = client.SetMaxBrightnessNit(SET_MAX_BRIGHTNESS,
+        OHOS::DisplayPowerMgr::DisplayPowerMgrClient::DEFAULT_MAIN_DISPLAY_ID);
+    client.proxy_ = proxy;
+    EXPECT_FALSE(result);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient007 function end!");
+}
+
+/**
+ * @tc.name: DisplayPowerMgrClient008
+ * @tc.desc: test SetMaxBrightnessNit() when proxy return fail
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient008, TestSize.Level0)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient008 function start!");
+    auto& client = DisplayPowerMgrClient::GetInstance();
+    auto proxy = client.proxy_;
+    client.proxy_ = g_mockProxy;
+    const double NO_DISCOUNT = 1.00;
+    auto result = client.DiscountBrightness(NO_DISCOUNT);
+    client.proxy_ = proxy;
+    EXPECT_FALSE(result);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient008 function end!");
+}
+
+/**
+ * @tc.name: DisplayPowerMgrClient009
+ * @tc.desc: test OverrideBrightness() when proxy return fail
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient009, TestSize.Level0)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient009 function start!");
+    auto& client = DisplayPowerMgrClient::GetInstance();
+    auto proxy = client.proxy_;
+    client.proxy_ = g_mockProxy;
+    const uint32_t SET_OVERRIDE_BRIGHTNESS = 202;
+    auto result = client.OverrideBrightness(SET_OVERRIDE_BRIGHTNESS);
+    client.proxy_ = proxy;
+    EXPECT_FALSE(result);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient009 function end!");
+}
+
+/**
+ * @tc.name: DisplayPowerMgrClient010
+ * @tc.desc: test OverrideDisplayOffDelay() when proxy return fail
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient010, TestSize.Level0)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient010 function start!");
+    auto& client = DisplayPowerMgrClient::GetInstance();
+    auto proxy = client.proxy_;
+    client.proxy_ = g_mockProxy;
+    const uint32_t OVERRIDE_DELAY_TIME = 200;
+    auto result = client.OverrideDisplayOffDelay(OVERRIDE_DELAY_TIME);
+    client.proxy_ = proxy;
+    EXPECT_FALSE(result);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient010 function end!");
+}
+
+/**
+ * @tc.name: DisplayPowerMgrClient011
+ * @tc.desc: test RestoreBrightness() when proxy return fail
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient011, TestSize.Level0)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient011 function start!");
+    auto& client = DisplayPowerMgrClient::GetInstance();
+    auto proxy = client.proxy_;
+    client.proxy_ = g_mockProxy;
+    auto result = client.RestoreBrightness();
+    client.proxy_ = proxy;
+    EXPECT_FALSE(result);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient011 function end!");
+}
+
+/**
+ * @tc.name: DisplayPowerMgrClient012
+ * @tc.desc: test GetBrightness() when proxy return fail
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient012, TestSize.Level0)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient012 function start!");
+    auto& client = DisplayPowerMgrClient::GetInstance();
+    auto proxy = client.proxy_;
+    client.proxy_ = g_mockProxy;
+    auto brightness = client.GetBrightness();
+    client.proxy_ = proxy;
+    EXPECT_EQ(brightness, OHOS::DisplayPowerMgr::DisplayPowerMgrClient::BRIGHTNESS_OFF);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient012 function end!");
+}
+
+/**
+ * @tc.name: DisplayPowerMgrClient013
+ * @tc.desc: test GetDefaultBrightness() when proxy return fail
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient013, TestSize.Level0)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient013 function start!");
+    auto& client = DisplayPowerMgrClient::GetInstance();
+    auto proxy = client.proxy_;
+    client.proxy_ = g_mockProxy;
+    auto brightness = client.GetBrightness();
+    client.proxy_ = proxy;
+    EXPECT_EQ(brightness, OHOS::DisplayPowerMgr::DisplayPowerMgrClient::BRIGHTNESS_OFF);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient013 function end!");
+}
+
+/**
+ * @tc.name: DisplayPowerMgrClient014
+ * @tc.desc: test GetDefaultBrightness() when proxy return fail
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient014, TestSize.Level0)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient013 function start!");
+    auto& client = DisplayPowerMgrClient::GetInstance();
+    auto proxy = client.proxy_;
+    client.proxy_ = g_mockProxy;
+    auto brightness = client.GetDefaultBrightness();
+    client.proxy_ = proxy;
+    EXPECT_EQ(brightness, 0);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient014 function end!");
+}
+
+/**
+ * @tc.name: DisplayPowerMgrClient015
+ * @tc.desc: test GetMaxBrightness() when proxy return fail
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient015, TestSize.Level0)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient015 function start!");
+    auto& client = DisplayPowerMgrClient::GetInstance();
+    auto proxy = client.proxy_;
+    client.proxy_ = g_mockProxy;
+    auto brightness = client.GetMaxBrightness();
+    client.proxy_ = proxy;
+    EXPECT_EQ(brightness, 0);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient015 function end!");
+}
+
+/**
+ * @tc.name: DisplayPowerMgrClient016
+ * @tc.desc: test GetMinBrightness() when proxy return fail
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient016, TestSize.Level0)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient016 function start!");
+    auto& client = DisplayPowerMgrClient::GetInstance();
+    auto proxy = client.proxy_;
+    client.proxy_ = g_mockProxy;
+    auto brightness = client.GetMinBrightness();
+    client.proxy_ = proxy;
+    EXPECT_EQ(brightness, 0);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient016 function end!");
+}
+
+/**
+ * @tc.name: DisplayPowerMgrClient017
+ * @tc.desc: test AdjustBrightness() when proxy return fail
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient017, TestSize.Level0)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient017 function start!");
+    auto& client = DisplayPowerMgrClient::GetInstance();
+    auto proxy = client.proxy_;
+    client.proxy_ = g_mockProxy;
+    const uint32_t ADJUST_BRIGHTNESS = 200;
+    auto ret = client.AdjustBrightness(OHOS::DisplayPowerMgr::DisplayPowerMgrClient::DEFAULT_MAIN_DISPLAY_ID,
+        ADJUST_BRIGHTNESS);
+    client.proxy_ = proxy;
+    EXPECT_FALSE(ret);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient017 function end!");
+}
+
+/**
+ * @tc.name: DisplayPowerMgrClient018
+ * @tc.desc: test AutoAdjustBrightness() when proxy return fail
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient018, TestSize.Level0)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient018 function start!");
+    auto& client = DisplayPowerMgrClient::GetInstance();
+    auto proxy = client.proxy_;
+    client.proxy_ = g_mockProxy;
+    auto ret = client.AutoAdjustBrightness(true);
+    client.proxy_ = proxy;
+    EXPECT_FALSE(ret);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient018 function end!");
+}
+
+/**
+ * @tc.name: DisplayPowerMgrClient019
+ * @tc.desc: test IsAutoAdjustBrightness() when proxy return fail
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient019, TestSize.Level0)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient019 function start!");
+    auto& client = DisplayPowerMgrClient::GetInstance();
+    auto proxy = client.proxy_;
+    client.proxy_ = g_mockProxy;
+    auto ret = client.IsAutoAdjustBrightness();
+    client.proxy_ = proxy;
+    EXPECT_FALSE(ret);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient019 function end!");
+}
+
+/**
+ * @tc.name: DisplayPowerMgrClient020
+ * @tc.desc: test BoostBrightness() when proxy return fail
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient020, TestSize.Level0)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient020 function start!");
+    auto& client = DisplayPowerMgrClient::GetInstance();
+    auto proxy = client.proxy_;
+    client.proxy_ = g_mockProxy;
+    const uint32_t BOOST_TIMEOUT_MS = 200;
+    auto ret = client.BoostBrightness(BOOST_TIMEOUT_MS);
+    client.proxy_ = proxy;
+    EXPECT_FALSE(ret);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient020 function end!");
+}
+
+/**
+ * @tc.name: DisplayPowerMgrClient021
+ * @tc.desc: test CancelBoostBrightness() when proxy return fail
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient021, TestSize.Level0)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient021 function start!");
+    auto& client = DisplayPowerMgrClient::GetInstance();
+    auto proxy = client.proxy_;
+    client.proxy_ = g_mockProxy;
+    auto ret = client.CancelBoostBrightness();
+    client.proxy_ = proxy;
+    EXPECT_FALSE(ret);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient021 function end!");
+}
+
+/**
+ * @tc.name: DisplayPowerMgrClient022
+ * @tc.desc: test GetDeviceBrightness() when proxy return fail
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient022, TestSize.Level0)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient022 function start!");
+    auto& client = DisplayPowerMgrClient::GetInstance();
+    auto proxy = client.proxy_;
+    client.proxy_ = g_mockProxy;
+    auto brightness = client.GetDeviceBrightness();
+    client.proxy_ = proxy;
+    EXPECT_EQ(brightness, OHOS::DisplayPowerMgr::DisplayPowerMgrClient::BRIGHTNESS_OFF);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient022 function end!");
+}
+
+/**
+ * @tc.name: DisplayPowerMgrClient023
+ * @tc.desc: test SetCoordinated() when proxy return fail
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient023, TestSize.Level0)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient023 function start!");
+    auto& client = DisplayPowerMgrClient::GetInstance();
+    auto proxy = client.proxy_;
+    client.proxy_ = g_mockProxy;
+    auto ret = client.SetCoordinated(true);
+    client.proxy_ = proxy;
+    EXPECT_FALSE(ret);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient023 function end!");
+}
+
+/**
+ * @tc.name: DisplayPowerMgrClient024
+ * @tc.desc: test SetLightBrightnessThreshold() when proxy return fail
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient024, TestSize.Level0)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient024 function start!");
+    auto& client = DisplayPowerMgrClient::GetInstance();
+    auto proxy = client.proxy_;
+    client.proxy_ = g_mockProxy;
+    std::vector<int32_t> threshold = {};
+    auto ret = client.SetLightBrightnessThreshold(threshold, nullptr);
+    client.proxy_ = proxy;
+    EXPECT_FALSE(ret);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient024 function end!");
+}
+
+/**
+ * @tc.name: DisplayPowerMgrClient025
+ * @tc.desc: test RegisterCallback() when proxy return fail
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient025, TestSize.Level0)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient025 function start!");
+    auto& client = DisplayPowerMgrClient::GetInstance();
+    auto proxy = client.proxy_;
+    client.proxy_ = g_mockProxy;
+    sptr<IDisplayPowerCallback> callback = new DisplayPowerMgrServiceTest::DisplayPowerMgrTestCallback();
+    auto ret = client.RegisterCallback(callback);
+    client.proxy_ = proxy;
+    EXPECT_FALSE(ret);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient025 function end!");
+}
+
+/**
+ * @tc.name: DisplayPowerMgrClient026
+ * @tc.desc: test SetScreenOnBrightness() when proxy return fail
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient026, TestSize.Level0)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient026 function start!");
+    auto& client = DisplayPowerMgrClient::GetInstance();
+    auto proxy = client.proxy_;
+    client.proxy_ = g_mockProxy;
+    auto ret = client.SetScreenOnBrightness();
+    client.proxy_ = proxy;
+    EXPECT_FALSE(ret);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient026 function end!");
+}
+
+/**
+ * @tc.name: DisplayPowerMgrClient027
+ * @tc.desc: test NotifyBrightnessManagerScreenPowerStatus() when proxy return fail
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrClient027, TestSize.Level0)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient027 function start!");
+    auto& client = DisplayPowerMgrClient::GetInstance();
+    auto proxy = client.proxy_;
+    client.proxy_ = g_mockProxy;
+    auto ret = client.NotifyBrightnessManagerScreenPowerStatus(
+        OHOS::DisplayPowerMgr::DisplayPowerMgrClient::DEFAULT_MAIN_DISPLAY_ID,
+        static_cast<uint32_t>(DisplayState::DISPLAY_ON));
+    client.proxy_ = proxy;
+    static constexpr int32_t DEFAULT_VALUE = -1;
+    EXPECT_EQ(ret, DEFAULT_VALUE);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrClient027 function end!");
+}
 } // namespace
diff --git a/state_manager/test/unittest/src/display_service_test.cpp b/state_manager/test/unittest/src/display_service_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2099b33d86090272a0a8332f3d7bbbc78c889f90
--- /dev/null
+++ b/state_manager/test/unittest/src/display_service_test.cpp
@@ -0,0 +1,601 @@
+/*
+ * 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 "display_service_test.h"
+#include "display_log.h"
+#include "display_mgr_errors.h"
+#include "display_power_mgr_client.h"
+#include "ipc_object_stub.h"
+#include "power_state_machine_info.h"
+#ifdef HAS_HIVIEWDFX_HISYSEVENT_PART
+#include <hisysevent.h>
+#endif
+#include <memory>
+#include <unistd.h>
+#include "display_brightness_callback_stub.h"
+#include "display_power_mgr_service.h"
+
+using namespace testing::ext;
+#ifdef HAS_HIVIEWDFX_HISYSEVENT_PART
+using namespace OHOS::HiviewDFX;
+#endif
+using namespace OHOS::PowerMgr;
+using namespace OHOS::DisplayPowerMgr;
+using namespace OHOS;
+using namespace std;
+
+namespace {
+static constexpr uint32_t BRIGHTNESS_SETTING_VALUE = 50;
+static constexpr uint32_t BRIGHTNESS_OVERRIDE_VALUE = 100;
+static constexpr uint32_t BRIGHTNESS_DURATION = 0;
+static constexpr uint32_t BRIGHTNESS_MIN_VALUE = 1;
+static constexpr uint32_t BRIGHTNESS_MAX_VALUE = 255;
+static constexpr uint32_t BRIGHTNESS_NONE_VALUE = 0;
+static constexpr uint32_t DISPLAY_ID = 0;
+static constexpr uint32_t DISPLAY_MAIN_ID = 0;
+static constexpr uint32_t DISPLAY_INVALID_ID = 211;
+static constexpr uint32_t REASON = 0;
+static constexpr int32_t BRIGHTNESS_ADJUST_VALUE = 150;
+static constexpr int32_t TIMEOUT_MS = 500;
+static constexpr int32_t INVALID_TIMEOUT_MS = 0;
+static constexpr double DISCOUNT_VALUE = 0.30;
+static constexpr uint32_t SET_SUCC = 1;
+static constexpr uint32_t MAX_BRIGHTNESS_SET = 125;
+static constexpr uint32_t TEST_MODE = 1;
+static constexpr uint32_t DEFAULT_DURATION = 500;
+static const uint32_t OVERRIDE_DELAY_TIME = 200;
+static constexpr int32_t DEFAULT_VALUE = -1;
+static constexpr uint32_t BRIGHTNESS_OFF = 0;
+static const uint32_t TEST_DELAY_TIME_UNSET = 0;
+sptr<DisplayPowerMgrService> g_service;
+} // namespace
+
+void DisplayServiceTest::SetUpTestCase()
+{
+    g_service = DelayedSpSingleton<DisplayPowerMgrService>::GetInstance();
+    g_service->Init();
+}
+
+void DisplayServiceTest::TearDownTestCase()
+{
+    g_service->Deinit();
+    g_service->Reset();
+}
+
+void DisplayServiceTest::DisplayServiceInnerTestFunc()
+{
+    EXPECT_TRUE(g_service->SetDisplayStateInner(DISPLAY_ID, DisplayPowerMgr::DisplayState::DISPLAY_ON,
+        REASON));
+    EXPECT_EQ(DisplayPowerMgr::DisplayState::DISPLAY_ON, g_service->GetDisplayStateInner(DISPLAY_ID));
+    auto ret = g_service->GetDisplayIdsInner();
+    EXPECT_TRUE(ret.size() != 0);
+    EXPECT_EQ(DISPLAY_MAIN_ID, g_service->GetMainDisplayIdInner());
+    EXPECT_TRUE(g_service->SetBrightnessInner(BRIGHTNESS_SETTING_VALUE, DISPLAY_ID, false));
+    EXPECT_TRUE(g_service->DiscountBrightnessInner(DISCOUNT_VALUE, DISPLAY_ID));
+    EXPECT_TRUE(g_service->OverrideBrightnessInner(BRIGHTNESS_OVERRIDE_VALUE, DISPLAY_ID));
+    EXPECT_TRUE(g_service->RestoreBrightnessInner(DISPLAY_MAIN_ID));
+    EXPECT_NE(BRIGHTNESS_NONE_VALUE, g_service->GetBrightnessInner(DISPLAY_ID));
+    EXPECT_NE(BRIGHTNESS_NONE_VALUE, g_service->GetDefaultBrightnessInner());
+    EXPECT_EQ(BRIGHTNESS_MAX_VALUE, g_service->GetMaxBrightnessInner());
+    EXPECT_EQ(BRIGHTNESS_MIN_VALUE, g_service->GetMinBrightnessInner());
+    g_service->AdjustBrightnessInner(DISPLAY_MAIN_ID, BRIGHTNESS_ADJUST_VALUE, BRIGHTNESS_DURATION);
+    g_service->AutoAdjustBrightnessInner(false);
+    EXPECT_FALSE(g_service->IsAutoAdjustBrightnessInner());
+    EXPECT_FALSE(g_service->BoostBrightnessInner(INVALID_TIMEOUT_MS, DISPLAY_ID));
+    EXPECT_FALSE(g_service->CancelBoostBrightnessInner(DISPLAY_INVALID_ID));
+    EXPECT_TRUE(g_service->SetDisplayStateInner(DISPLAY_ID, DisplayPowerMgr::DisplayState::DISPLAY_OFF,
+        REASON));
+    EXPECT_EQ(DisplayPowerMgr::DisplayState::DISPLAY_OFF, g_service->GetDisplayStateInner(DISPLAY_ID));
+}
+
+void DisplayServiceTest::DisplayPowerMgrTestCallback::OnDisplayStateChanged(
+    uint32_t displayId, DisplayPowerMgr::DisplayState state, uint32_t reason)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrTestCallback::OnDisplayStateChangedStub");
+}
+
+namespace {
+/**
+ * @tc.name: DisplayServiceInnerTest001
+ * @tc.desc: test DisplayPowerMgrService function
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayServiceTest, DisplayServiceInnerTest001, TestSize.Level1)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceInnerTest001 function start!");
+    EXPECT_TRUE(g_service != nullptr);
+    DisplayServiceTest::DisplayServiceInnerTestFunc();
+    EXPECT_NE(BRIGHTNESS_NONE_VALUE, g_service->GetDeviceBrightnessInner(DISPLAY_ID));
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceInnerTest001 function end!");
+}
+
+/**
+ * @tc.name: DisplayServiceInnerTest002
+ * @tc.desc: test DisplayPowerMgrService function
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayServiceTest, DisplayServiceInnerTest002, TestSize.Level1)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceInnerTest002 function start!");
+    EXPECT_TRUE(g_service != nullptr);
+    sptr<IDisplayPowerCallback> callbackPtr = new DisplayServiceTest::DisplayPowerMgrTestCallback();
+
+    EXPECT_FALSE(g_service->RegisterCallbackInner(callbackPtr));
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceInnerTest002 function end!");
+}
+
+/**
+ * @tc.name: DisplayServiceInnerTest003
+ * @tc.desc: test DisplayPowerMgrService function
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayServiceTest, DisplayServiceInnerTest003, TestSize.Level1)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceInnerTest003 function start!");
+    EXPECT_TRUE(g_service != nullptr);
+    std::vector<int32_t> threshold = {200, 200, 20};
+    sptr<DisplayBrightnessCallbackStub> callback = new DisplayBrightnessCallbackStub();
+    uint32_t result = g_service->SetLightBrightnessThresholdInner(threshold, callback);
+    EXPECT_EQ(result, SET_SUCC);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceInnerTest003 function end!");
+}
+
+/**
+ * @tc.name: DisplayServiceTest001
+ * @tc.desc: test DisplayPowerMgrService function
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayServiceTest, DisplayServiceTest001, TestSize.Level1)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest001 function start!");
+    EXPECT_TRUE(g_service != nullptr);
+    bool ret = false;
+    int32_t errCode = 0;
+    uint32_t result = g_service->SetMaxBrightness(MAX_BRIGHTNESS_SET, TEST_MODE, ret, errCode);
+    uint32_t maxBrightness = 0;
+    g_service->GetMaxBrightness(maxBrightness);
+    EXPECT_TRUE(ret);
+    EXPECT_NE(maxBrightness, MAX_BRIGHTNESS_SET);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest001 function end!");
+}
+
+/**
+ * @tc.name: DisplayServiceTest002
+ * @tc.desc: test DisplayPowerMgrService function SetDisplayState id != DISPLAY_MAIN_ID
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayServiceTest, DisplayServiceTest002, TestSize.Level1)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest002 function start!");
+    EXPECT_TRUE(g_service != nullptr);
+    bool ret = false;
+    g_service->SetDisplayState(DISPLAY_MAIN_ID, static_cast<uint32_t>(DisplayPowerMgr::DisplayState::DISPLAY_ON),
+        REASON, ret);
+    EXPECT_TRUE(ret);
+    int32_t displayState = 0;
+    g_service->GetDisplayState(DISPLAY_MAIN_ID, displayState);
+    EXPECT_EQ(static_cast<int32_t>(DisplayPowerMgr::DisplayState::DISPLAY_ON), displayState);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest002 function end!");
+}
+
+/**
+ * @tc.name: DisplayServiceTest003
+ * @tc.desc: test DisplayPowerMgrService function SetDisplayState id != DISPLAY_MAIN_ID
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayServiceTest, DisplayServiceTest003, TestSize.Level1)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest003 function start!");
+    EXPECT_TRUE(g_service != nullptr);
+    bool ret = false;
+    auto controller = g_service->controllerMap_[DISPLAY_MAIN_ID];
+    g_service->controllerMap_.erase(DISPLAY_MAIN_ID);
+    g_service->SetDisplayState(DISPLAY_MAIN_ID, static_cast<uint32_t>(DisplayPowerMgr::DisplayState::DISPLAY_ON),
+        REASON, ret);
+    EXPECT_FALSE(ret);
+    int32_t displayState = 0;
+    g_service->GetDisplayState(DISPLAY_MAIN_ID, displayState);
+    EXPECT_EQ(static_cast<int32_t>(DisplayPowerMgr::DisplayState::DISPLAY_UNKNOWN), displayState);
+    g_service->controllerMap_.emplace(DISPLAY_MAIN_ID, controller);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest003 function end!");
+}
+
+/**
+ * @tc.name: DisplayServiceTest004
+ * @tc.desc: test DisplayPowerMgrService function GetDisplayIds
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayServiceTest, DisplayServiceTest004, TestSize.Level1)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest004 function start!");
+    EXPECT_TRUE(g_service != nullptr);
+    std::vector<uint32_t> ids;
+    g_service->GetDisplayIds(ids);
+    EXPECT_FALSE(ids.empty());
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest004 function end!");
+}
+
+/**
+ * @tc.name: DisplayServiceTest005
+ * @tc.desc: test DisplayPowerMgrService function SetBrightness
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayServiceTest, DisplayServiceTest005, TestSize.Level1)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest005 function start!");
+    EXPECT_TRUE(g_service != nullptr);
+    bool ret = false;
+    int32_t errCode = 0;
+    g_service->SetBrightness(BRIGHTNESS_SETTING_VALUE, DISPLAY_MAIN_ID, false, ret, errCode);
+    EXPECT_TRUE(ret);
+    EXPECT_EQ(errCode, ERR_OK);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest005 function end!");
+}
+
+/**
+ * @tc.name: DisplayServiceTest006
+ * @tc.desc: test DisplayPowerMgrService function DiscountBrightness
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayServiceTest, DisplayServiceTest006, TestSize.Level1)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest006 function start!");
+    EXPECT_TRUE(g_service != nullptr);
+    bool ret = false;
+    g_service->DiscountBrightness(DISCOUNT_VALUE, DISPLAY_MAIN_ID, ret);
+    EXPECT_TRUE(ret);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest006 function end!");
+}
+
+/**
+ * @tc.name: DisplayServiceTest007
+ * @tc.desc: test DisplayPowerMgrService function OverrideDisplayOffDelay
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayServiceTest, DisplayServiceTest007, TestSize.Level1)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest007 function start!");
+    EXPECT_TRUE(g_service != nullptr);
+    bool ret = false;
+    g_service->OverrideDisplayOffDelay(OVERRIDE_DELAY_TIME, ret);
+    EXPECT_TRUE(ret);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest007 function end!");
+}
+
+/**
+ * @tc.name: DisplayServiceTest008
+ * @tc.desc: test DisplayPowerMgrService function RestoreBrightness
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayServiceTest, DisplayServiceTest008, TestSize.Level1)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest008 function start!");
+    EXPECT_TRUE(g_service != nullptr);
+    bool ret = false;
+    g_service->RestoreBrightness(DISPLAY_MAIN_ID, DEFAULT_DURATION, ret);
+    EXPECT_FALSE(ret);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest008 function end!");
+}
+
+/**
+ * @tc.name: DisplayServiceTest009
+ * @tc.desc: test DisplayPowerMgrService function GetBrightness
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayServiceTest, DisplayServiceTest009, TestSize.Level1)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest009 function start!");
+    EXPECT_TRUE(g_service != nullptr);
+    uint32_t brightness = 0;
+    g_service->GetBrightness(DISPLAY_MAIN_ID, brightness);
+    EXPECT_NE(brightness, BRIGHTNESS_OFF);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest009 function end!");
+}
+
+/**
+ * @tc.name: DisplayServiceTest010
+ * @tc.desc: test DisplayPowerMgrService function GetDefaultBrightness
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayServiceTest, DisplayServiceTest010, TestSize.Level1)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest010 function start!");
+    EXPECT_TRUE(g_service != nullptr);
+    uint32_t brightness = 0;
+    g_service->GetDefaultBrightness(brightness);
+    EXPECT_EQ(brightness, DisplayPowerMgrService::BRIGHTNESS_DEFAULT);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest010 function end!");
+}
+
+/**
+ * @tc.name: DisplayServiceTest011
+ * @tc.desc: test DisplayPowerMgrService function GetMinBrightness
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayServiceTest, DisplayServiceTest011, TestSize.Level1)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest011 function start!");
+    EXPECT_TRUE(g_service != nullptr);
+    uint32_t brightness = 0;
+    g_service->GetMinBrightness(brightness);
+    EXPECT_EQ(brightness, DisplayPowerMgrService::BRIGHTNESS_MIN);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest011 function end!");
+}
+
+/**
+ * @tc.name: DisplayServiceTest012
+ * @tc.desc: test DisplayPowerMgrService function AdjustBrightness
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayServiceTest, DisplayServiceTest012, TestSize.Level1)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest012 function start!");
+    EXPECT_TRUE(g_service != nullptr);
+    bool ret = false;
+    g_service->AdjustBrightness(DISPLAY_MAIN_ID, BRIGHTNESS_ADJUST_VALUE, BRIGHTNESS_DURATION, ret);
+    EXPECT_TRUE(ret);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest012 function end!");
+}
+
+/**
+ * @tc.name: DisplayServiceTest013
+ * @tc.desc: test DisplayPowerMgrService function NotifyScreenPowerStatus
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayServiceTest, DisplayServiceTest013, TestSize.Level1)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest013 function start!");
+    EXPECT_TRUE(g_service != nullptr);
+    int32_t errCode = 0;
+    int32_t displayState = 0;
+    g_service->GetDisplayState(DISPLAY_MAIN_ID, displayState);
+    g_service->NotifyScreenPowerStatus(DISPLAY_MAIN_ID, displayState, errCode);
+    EXPECT_NE(errCode, DEFAULT_VALUE);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest013 function end!");
+}
+
+/**
+ * @tc.name: DisplayServiceTest014
+ * @tc.desc: test DisplayPowerMgrService function IsAutoAdjustBrightness
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayServiceTest, DisplayServiceTest014, TestSize.Level1)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest014 function start!");
+    EXPECT_TRUE(g_service != nullptr);
+    bool ret = false;
+    g_service->AutoAdjustBrightness(false, ret);
+    g_service->IsAutoAdjustBrightness(ret);
+    EXPECT_FALSE(ret);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest014 function end!");
+}
+
+/**
+ * @tc.name: DisplayServiceTest015
+ * @tc.desc: test DisplayPowerMgrService function RegisterCallback
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayServiceTest, DisplayServiceTest015, TestSize.Level1)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest015 function start!");
+    EXPECT_TRUE(g_service != nullptr);
+    bool ret = false;
+    sptr<IDisplayPowerCallback> callbackPtr = new DisplayServiceTest::DisplayPowerMgrTestCallback();
+    g_service->RegisterCallback(callbackPtr, ret);
+    EXPECT_FALSE(ret);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest015 function end!");
+}
+
+/**
+ * @tc.name: DisplayServiceTest016
+ * @tc.desc: test DisplayPowerMgrService function BoostBrightness
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayServiceTest, DisplayServiceTest016, TestSize.Level1)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest016 function start!");
+    EXPECT_TRUE(g_service != nullptr);
+    bool ret = false;
+    g_service->BoostBrightness(TIMEOUT_MS, DISPLAY_MAIN_ID, ret);
+    EXPECT_TRUE(ret);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest016 function end!");
+}
+
+/**
+ * @tc.name: DisplayServiceTest017
+ * @tc.desc: test DisplayPowerMgrService function CancelBoostBrightness
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayServiceTest, DisplayServiceTest017, TestSize.Level1)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest017 function start!");
+    EXPECT_TRUE(g_service != nullptr);
+    bool ret = false;
+    g_service->CancelBoostBrightness(DISPLAY_MAIN_ID, ret);
+    EXPECT_TRUE(ret);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest017 function end!");
+}
+
+/**
+ * @tc.name: DisplayServiceTest018
+ * @tc.desc: test DisplayPowerMgrService function GetDeviceBrightness
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayServiceTest, DisplayServiceTest018, TestSize.Level1)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest018 function start!");
+    EXPECT_TRUE(g_service != nullptr);
+    uint32_t brightness = 0;
+    g_service->GetDeviceBrightness(DISPLAY_MAIN_ID, brightness);
+    EXPECT_NE(brightness, BRIGHTNESS_NONE_VALUE);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest018 function end!");
+}
+
+/**
+ * @tc.name: DisplayServiceTest019
+ * @tc.desc: test DisplayPowerMgrService function SetCoordinated
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayServiceTest, DisplayServiceTest019, TestSize.Level1)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest019 function start!");
+    EXPECT_TRUE(g_service != nullptr);
+    bool ret = false;
+    g_service->SetCoordinated(true, DISPLAY_MAIN_ID, ret);
+    EXPECT_TRUE(ret);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest019 function end!");
+}
+
+/**
+ * @tc.name: DisplayServiceTest020
+ * @tc.desc: test DisplayPowerMgrService function SetLightBrightnessThreshold
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayServiceTest, DisplayServiceTest020, TestSize.Level1)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest020 function start!");
+    EXPECT_TRUE(g_service != nullptr);
+    uint32_t ret = 0;
+    std::vector<int32_t> threshold = {200, 200, 20};
+    sptr<DisplayBrightnessCallbackStub> callback = new DisplayBrightnessCallbackStub();
+    g_service->SetLightBrightnessThreshold(threshold, callback, ret);
+    EXPECT_EQ(ret, SET_SUCC);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest020 function end!");
+}
+
+/**
+ * @tc.name: DisplayServiceTest021
+ * @tc.desc: test DisplayPowerMgrService function SetMaxBrightnessNit
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayServiceTest, DisplayServiceTest021, TestSize.Level1)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest021 function start!");
+    EXPECT_TRUE(g_service != nullptr);
+    bool ret = false;
+    int32_t errCode = 0;
+    uint32_t result = g_service->SetMaxBrightnessNit(MAX_BRIGHTNESS_SET, TEST_MODE, ret, errCode);
+    EXPECT_TRUE(ret);
+    uint32_t maxBrightness = 0;
+    g_service->GetMaxBrightness(maxBrightness);
+    EXPECT_NE(maxBrightness, MAX_BRIGHTNESS_SET);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest021 function end!");
+}
+
+/**
+ * @tc.name: DisplayServiceTest022
+ * @tc.desc: test DisplayPowerMgrService function SetBootCompletedBrightness
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayServiceTest, DisplayServiceTest022, TestSize.Level1)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest022 function start!");
+    EXPECT_TRUE(g_service != nullptr);
+    uint32_t brightnessTemp = BRIGHTNESS_OFF;
+    g_service->GetBrightness(DISPLAY_MAIN_ID, brightnessTemp);
+    bool enable = g_service->GetSettingAutoBrightness();
+    g_service->SetBootCompletedBrightness();
+    g_service->SetBootCompletedAutoBrightness();
+    g_service->RegisterSettingObservers();
+    uint32_t brightness = BRIGHTNESS_OFF;
+    g_service->GetBrightness(DISPLAY_MAIN_ID, brightness);
+    EXPECT_EQ(brightness, brightnessTemp);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest022 function end!");
+}
+
+/**
+ * @tc.name: DisplayServiceTest023
+ * @tc.desc: test DisplayPowerMgrService function OverrideBrightness
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayServiceTest, DisplayServiceTest023, TestSize.Level1)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest023 function start!");
+    EXPECT_TRUE(g_service != nullptr);
+    bool ret = false;
+    g_service->OverrideBrightness(BRIGHTNESS_OVERRIDE_VALUE, DISPLAY_INVALID_ID, DEFAULT_DURATION, ret);
+    EXPECT_FALSE(ret);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest023 function end!");
+}
+
+/**
+ * @tc.name: DisplayServiceTest024
+ * @tc.desc: test DisplayPowerMgrService function Dump
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayServiceTest, DisplayServiceTest024, TestSize.Level1)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest024 function start!");
+    EXPECT_TRUE(g_service != nullptr);
+    int fd = 1;
+    std::vector<std::u16string> args;
+    g_service->isBootCompleted_ = false;
+    auto ret = g_service->Dump(fd, args);
+    EXPECT_EQ(ret, ERR_NO_INIT);
+    g_service->isBootCompleted_ = true;
+    ret = g_service->Dump(fd, args);
+    EXPECT_EQ(ret, ERR_OK);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest024 function end!");
+}
+
+/**
+ * @tc.name: DisplayServiceTest025
+ * @tc.desc: test DisplayPowerMgrService function OverrideDisplayOffDelay
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayServiceTest, DisplayServiceTest025, TestSize.Level1)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest025 function start!");
+    EXPECT_TRUE(g_service != nullptr);
+    bool ret = false;
+    g_service->OverrideDisplayOffDelay(TEST_DELAY_TIME_UNSET, ret);
+    EXPECT_FALSE(g_service->isDisplayDelayOff_);
+    EXPECT_FALSE(ret);
+    g_service->SetDisplayState(DISPLAY_MAIN_ID, static_cast<uint32_t>(DisplayPowerMgr::DisplayState::DISPLAY_OFF),
+        REASON, ret);
+    EXPECT_TRUE(ret);
+    g_service->OverrideDisplayOffDelay(OVERRIDE_DELAY_TIME, ret);
+    EXPECT_FALSE(g_service->isDisplayDelayOff_);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest025 function end!");
+}
+} // namespace
diff --git a/state_manager/test/unittest/src/mock/display_mock_object_test.cpp b/state_manager/test/unittest/src/mock/display_mock_object_test.cpp
index 400e12f5126666cb9a73f19528fc3656b9128bea..35349591f67e26daf529d3f65f21c3c3fb6a87a0 100644
--- a/state_manager/test/unittest/src/mock/display_mock_object_test.cpp
+++ b/state_manager/test/unittest/src/mock/display_mock_object_test.cpp
@@ -37,6 +37,8 @@ static constexpr uint32_t REASON = 0;
 static constexpr int32_t BRIGHTNESS_ADJUST_VALUE = 150;
 static constexpr int32_t TIMEOUT_MS = 500;
 static constexpr double DISCOUNT_VALUE = 0.30;
+static constexpr uint32_t DEFAULT_DURATION = 500;
+static constexpr int32_t ERR_OK = 0;
 } // namespace
 
 void DisplayMockObjectTest::DisplayPowerMgrTestCallback::OnDisplayStateChanged(
@@ -57,27 +59,70 @@ HWTEST_F(DisplayMockObjectTest, DisplayMockObjectTest_001, TestSize.Level0)
     DISPLAY_HILOGI(LABEL_TEST, "DisplayMockObjectTest_001 function start!");
     sptr<MockDisplayRemoteObject> sptrRemoteObj = new MockDisplayRemoteObject();
     auto sptrDisplayProxy = std::make_shared<DisplayPowerMgr::DisplayPowerMgrProxy>(sptrRemoteObj);
-    EXPECT_FALSE(sptrDisplayProxy->SetDisplayState(DISPLAY_ID, DisplayPowerMgr::DisplayState::DISPLAY_ON, REASON));
-    EXPECT_NE(DisplayPowerMgr::DisplayState::DISPLAY_ON, sptrDisplayProxy->GetDisplayState(DISPLAY_ID));
+    bool bRet = false;
+    EXPECT_NE(sptrDisplayProxy->SetDisplayState(DISPLAY_ID,
+        static_cast<uint32_t>(DisplayPowerMgr::DisplayState::DISPLAY_ON), REASON, bRet), ERR_OK);
+    EXPECT_FALSE(bRet);
+    int32_t state = 0;
+    EXPECT_NE(sptrDisplayProxy->GetDisplayState(DISPLAY_ID, state), ERR_OK);
+    EXPECT_NE(DisplayPowerMgr::DisplayState::DISPLAY_ON, DisplayPowerMgr::DisplayState(state));
     std::vector<uint32_t> result;
     result.push_back(DISPLAY_ID);
-    EXPECT_NE(result, sptrDisplayProxy->GetDisplayIds());
-    EXPECT_EQ(MAIN_ID_PROXY, sptrDisplayProxy->GetMainDisplayId());
-    EXPECT_FALSE(sptrDisplayProxy->SetBrightness(BRIGHTNESS_SETTING_VALUE, DISPLAY_ID, false));
-    EXPECT_FALSE(sptrDisplayProxy->DiscountBrightness(DISCOUNT_VALUE, DISPLAY_ID));
-    EXPECT_FALSE(sptrDisplayProxy->OverrideBrightness(BRIGHTNESS_OVERRIDE_VALUE, DISPLAY_ID));
-    EXPECT_FALSE(sptrDisplayProxy->RestoreBrightness(DISPLAY_ID));
-    EXPECT_EQ(BRIGHTNESS_NONE_VALUE, sptrDisplayProxy->GetBrightness(DISPLAY_ID));
-    EXPECT_EQ(BRIGHTNESS_NONE_VALUE, sptrDisplayProxy->GetDeviceBrightness(DISPLAY_ID));
-    EXPECT_EQ(BRIGHTNESS_NONE_VALUE, sptrDisplayProxy->GetDefaultBrightness());
-    EXPECT_EQ(BRIGHTNESS_NONE_VALUE, sptrDisplayProxy->GetMaxBrightness());
-    EXPECT_EQ(BRIGHTNESS_NONE_VALUE, sptrDisplayProxy->GetMinBrightness());
-    EXPECT_FALSE(sptrDisplayProxy->AutoAdjustBrightness(true));
-    EXPECT_FALSE(sptrDisplayProxy->AdjustBrightness(DISPLAY_ID, BRIGHTNESS_ADJUST_VALUE, BRIGHTNESS_DURATION));
-    EXPECT_FALSE(sptrDisplayProxy->AutoAdjustBrightness(false));
-    EXPECT_FALSE(sptrDisplayProxy->IsAutoAdjustBrightness());
-    EXPECT_FALSE(sptrDisplayProxy->BoostBrightness(TIMEOUT_MS, DISPLAY_ID));
-    EXPECT_FALSE(sptrDisplayProxy->CancelBoostBrightness(DISPLAY_ID));
+    std::vector<uint32_t> ids;
+    EXPECT_NE(sptrDisplayProxy->GetDisplayIds(ids), ERR_OK);
+    EXPECT_NE(result, ids);
+    uint32_t id = 0;
+    EXPECT_NE(sptrDisplayProxy->GetMainDisplayId(id), ERR_OK);
+    EXPECT_EQ(MAIN_ID_PROXY, id);
     DISPLAY_HILOGI(LABEL_TEST, "DisplayMockObjectTest_001 function end!");
 }
+
+/**
+ * @tc.name: DisplayMockObjectTest_002
+ * @tc.desc: test DisplayPowerMgrProxy function(IRemoteObject is mock, "SendRequest" function return false)
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayMockObjectTest, DisplayMockObjectTest_002, TestSize.Level0)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayMockObjectTest_002 function start!");
+    sptr<MockDisplayRemoteObject> sptrRemoteObj = new MockDisplayRemoteObject();
+    auto sptrDisplayProxy = std::make_shared<DisplayPowerMgr::DisplayPowerMgrProxy>(sptrRemoteObj);
+    bool bRet = false;
+    uint32_t brightness = 0;
+    int32_t errCode = 0;
+    EXPECT_NE(sptrDisplayProxy->SetBrightness(BRIGHTNESS_SETTING_VALUE, DISPLAY_ID, false, bRet, errCode), ERR_OK);
+    EXPECT_FALSE(bRet);
+    EXPECT_NE(sptrDisplayProxy->DiscountBrightness(DISCOUNT_VALUE, DISPLAY_ID, bRet), ERR_OK);
+    EXPECT_FALSE(bRet);
+    EXPECT_NE(sptrDisplayProxy->OverrideBrightness(BRIGHTNESS_OVERRIDE_VALUE, DISPLAY_ID, DEFAULT_DURATION, bRet),
+        ERR_OK);
+    EXPECT_FALSE(bRet);
+    EXPECT_NE(sptrDisplayProxy->RestoreBrightness(DISPLAY_ID, DEFAULT_DURATION, bRet), ERR_OK);
+    EXPECT_FALSE(bRet);
+    EXPECT_NE(sptrDisplayProxy->GetBrightness(DISPLAY_ID, brightness), ERR_OK);
+    EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness);
+    EXPECT_NE(sptrDisplayProxy->GetDeviceBrightness(DISPLAY_ID, brightness), ERR_OK);
+    EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness);
+    EXPECT_NE(sptrDisplayProxy->GetDefaultBrightness(brightness), ERR_OK);
+    EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness);
+    EXPECT_NE(sptrDisplayProxy->GetMaxBrightness(brightness), ERR_OK);
+    EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness);
+    EXPECT_NE(sptrDisplayProxy->GetMinBrightness(brightness), ERR_OK);
+    EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness);
+    EXPECT_NE(sptrDisplayProxy->AdjustBrightness(DISPLAY_ID, BRIGHTNESS_ADJUST_VALUE, BRIGHTNESS_DURATION, bRet),
+        ERR_OK);
+    EXPECT_FALSE(bRet);
+    EXPECT_NE(sptrDisplayProxy->AutoAdjustBrightness(true, bRet), ERR_OK);
+    EXPECT_FALSE(bRet);
+    EXPECT_NE(sptrDisplayProxy->AutoAdjustBrightness(false, bRet), ERR_OK);
+    EXPECT_FALSE(bRet);
+    EXPECT_NE(sptrDisplayProxy->IsAutoAdjustBrightness(bRet), ERR_OK);
+    EXPECT_FALSE(bRet);
+    EXPECT_NE(sptrDisplayProxy->BoostBrightness(TIMEOUT_MS, DISPLAY_ID, bRet), ERR_OK);
+    EXPECT_FALSE(bRet);
+    EXPECT_NE(sptrDisplayProxy->CancelBoostBrightness(DISPLAY_ID, bRet), ERR_OK);
+    EXPECT_FALSE(bRet);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayMockObjectTest_002 function end!");
+}
 } //namespace
diff --git a/state_manager/test/unittest/src/mock/display_mock_parcel_test.cpp b/state_manager/test/unittest/src/mock/display_mock_parcel_test.cpp
index 5921b4a013372e94ab8a5095464a28e45d329415..f6da9c537c6b585b5b45230e7b1a5b039782b11b 100644
--- a/state_manager/test/unittest/src/mock/display_mock_parcel_test.cpp
+++ b/state_manager/test/unittest/src/mock/display_mock_parcel_test.cpp
@@ -50,30 +50,65 @@ static constexpr int32_t BRIGHTNESS_ADJUST_VALUE = 150;
 static constexpr int32_t MAIN_ID_CLIENT = 0;
 static constexpr int32_t TIMEOUT_MS = 500;
 static constexpr double DISCOUNT_VALUE = 0.30;
+static constexpr uint32_t DEFAULT_DURATION = 500;
+static constexpr uint32_t ERR_OK = 0;
 } // namespace
 
+void DisplayMockParcelTest::DisplayProxyBrightnessTestFunc(std::shared_ptr<DisplayPowerMgrProxy>& sptrDisplayProxy)
+{
+    bool ret = false;
+    int32_t errCode = 0;
+    EXPECT_NE(sptrDisplayProxy->SetBrightness(BRIGHTNESS_SETTING_VALUE, DISPLAY_ID, false, ret, errCode), ERR_OK);
+    EXPECT_FALSE(ret);
+    EXPECT_NE(sptrDisplayProxy->DiscountBrightness(DISCOUNT_VALUE, DISPLAY_ID, ret), ERR_OK);
+    EXPECT_FALSE(ret);
+    EXPECT_NE(sptrDisplayProxy->OverrideBrightness(BRIGHTNESS_OVERRIDE_VALUE, DISPLAY_ID, DEFAULT_DURATION, ret),
+        ERR_OK);
+    EXPECT_FALSE(ret);
+    EXPECT_NE(sptrDisplayProxy->RestoreBrightness(DISPLAY_ID, DEFAULT_DURATION, ret), ERR_OK);
+    EXPECT_FALSE(ret);
+    uint32_t brightness = 0;
+    EXPECT_NE(sptrDisplayProxy->GetBrightness(DISPLAY_ID, brightness), ERR_OK);
+    EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness);
+    EXPECT_NE(sptrDisplayProxy->GetDefaultBrightness(brightness), ERR_OK);
+    EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness);
+    EXPECT_NE(sptrDisplayProxy->GetMaxBrightness(brightness), ERR_OK);
+    EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness);
+    EXPECT_NE(sptrDisplayProxy->GetMinBrightness(brightness), ERR_OK);
+    EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness);
+    EXPECT_NE(sptrDisplayProxy->AdjustBrightness(DISPLAY_ID, BRIGHTNESS_ADJUST_VALUE, BRIGHTNESS_DURATION, ret),
+        ERR_OK);
+    EXPECT_FALSE(ret);
+    EXPECT_NE(sptrDisplayProxy->AutoAdjustBrightness(true, ret), ERR_OK);
+    EXPECT_FALSE(ret);
+    EXPECT_NE(sptrDisplayProxy->AutoAdjustBrightness(false, ret), ERR_OK);
+    EXPECT_FALSE(ret);
+    EXPECT_NE(sptrDisplayProxy->IsAutoAdjustBrightness(ret), ERR_OK);
+    EXPECT_FALSE(ret);
+    EXPECT_NE(sptrDisplayProxy->BoostBrightness(TIMEOUT_MS, DISPLAY_ID, ret), ERR_OK);
+    EXPECT_FALSE(ret);
+    EXPECT_NE(sptrDisplayProxy->CancelBoostBrightness(DISPLAY_ID, ret), ERR_OK);
+    EXPECT_FALSE(ret);
+}
+
 void DisplayMockParcelTest::DisplayProxyTestFunc(std::shared_ptr<DisplayPowerMgrProxy>& sptrDisplayProxy)
 {
     std::vector<uint32_t> result;
     result.push_back(DISPLAY_ID);
-    EXPECT_FALSE(sptrDisplayProxy->SetDisplayState(DISPLAY_ID, DisplayPowerMgr::DisplayState::DISPLAY_ON, REASON));
-    EXPECT_NE(DisplayPowerMgr::DisplayState::DISPLAY_ON, sptrDisplayProxy->GetDisplayState(DISPLAY_ID));
-    EXPECT_NE(result, sptrDisplayProxy->GetDisplayIds());
-    EXPECT_EQ(MAIN_ID_PROXY, sptrDisplayProxy->GetMainDisplayId());
-    EXPECT_FALSE(sptrDisplayProxy->SetBrightness(BRIGHTNESS_SETTING_VALUE, DISPLAY_ID, false));
-    EXPECT_FALSE(sptrDisplayProxy->DiscountBrightness(DISCOUNT_VALUE, DISPLAY_ID));
-    EXPECT_FALSE(sptrDisplayProxy->OverrideBrightness(BRIGHTNESS_OVERRIDE_VALUE, DISPLAY_ID));
-    EXPECT_FALSE(sptrDisplayProxy->RestoreBrightness(DISPLAY_ID));
-    EXPECT_EQ(BRIGHTNESS_NONE_VALUE, sptrDisplayProxy->GetBrightness(DISPLAY_ID));
-    EXPECT_EQ(BRIGHTNESS_NONE_VALUE, sptrDisplayProxy->GetDefaultBrightness());
-    EXPECT_EQ(BRIGHTNESS_NONE_VALUE, sptrDisplayProxy->GetMaxBrightness());
-    EXPECT_EQ(BRIGHTNESS_NONE_VALUE, sptrDisplayProxy->GetMinBrightness());
-    EXPECT_FALSE(sptrDisplayProxy->AdjustBrightness(DISPLAY_ID, BRIGHTNESS_ADJUST_VALUE, BRIGHTNESS_DURATION));
-    EXPECT_FALSE(sptrDisplayProxy->AutoAdjustBrightness(true));
-    EXPECT_FALSE(sptrDisplayProxy->AutoAdjustBrightness(false));
-    EXPECT_FALSE(sptrDisplayProxy->IsAutoAdjustBrightness());
-    EXPECT_FALSE(sptrDisplayProxy->BoostBrightness(TIMEOUT_MS, DISPLAY_ID));
-    EXPECT_FALSE(sptrDisplayProxy->CancelBoostBrightness(DISPLAY_ID));
+    bool ret = false;
+    EXPECT_NE(sptrDisplayProxy->SetDisplayState(DISPLAY_ID,
+        static_cast<uint32_t>(DisplayPowerMgr::DisplayState::DISPLAY_ON), REASON, ret), ERR_OK);
+    EXPECT_FALSE(ret);
+    int32_t state = 0;
+    EXPECT_NE(sptrDisplayProxy->GetDisplayState(DISPLAY_ID, state), ERR_OK);
+    EXPECT_NE(DisplayPowerMgr::DisplayState::DISPLAY_ON, DisplayPowerMgr::DisplayState(state));
+    std::vector<uint32_t> ids;
+    EXPECT_NE(sptrDisplayProxy->GetDisplayIds(ids), ERR_OK);
+    EXPECT_NE(result, ids);
+    uint32_t mainId = MAIN_ID_PROXY;
+    EXPECT_NE(sptrDisplayProxy->GetMainDisplayId(mainId), ERR_OK);
+    EXPECT_EQ(MAIN_ID_PROXY, mainId);
+    DisplayProxyBrightnessTestFunc(sptrDisplayProxy);
 }
 
 void DisplayMockParcelTest::DisplayPowerMgrTestCallback::OnDisplayStateChanged(
@@ -130,10 +165,14 @@ HWTEST_F(DisplayMockParcelTest, DisplayMockParcelTest_002, TestSize.Level0)
     sptr<IDisplayPowerCallback> callbackPtr = nullptr;
 
     DisplayMockParcelTest::DisplayProxyTestFunc(sptrDisplayProxy);
-    EXPECT_EQ(BRIGHTNESS_NONE_VALUE, sptrDisplayProxy->GetDeviceBrightness(DISPLAY_ID));
-
-    EXPECT_FALSE(sptrDisplayProxy->RegisterCallback(callbackPtr));
-    DISPLAY_HILOGI(LABEL_TEST, "DisplayMockParcelTest_002 function end!");
+    uint32_t brightness = BRIGHTNESS_NONE_VALUE;
+    EXPECT_NE(sptrDisplayProxy->GetDeviceBrightness(DISPLAY_ID, brightness), ERR_OK);
+    EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness);
+
+    bool result = false;
+    EXPECT_NE(sptrDisplayProxy->RegisterCallback(callbackPtr, result), ERR_OK);
+    EXPECT_FALSE(result);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayMockParcelTest_002 function is end");
 }
 
 /**
@@ -147,9 +186,10 @@ HWTEST_F(DisplayMockParcelTest, DisplayMockParcelTest_003, TestSize.Level0)
     DISPLAY_HILOGI(LABEL_TEST, "DisplayMockParcelTest_003 function start!");
     auto sptrDisplayProxy = std::make_shared<DisplayPowerMgr::DisplayPowerMgrProxy>(nullptr);
     sptr<IDisplayPowerCallback> callbackPtr = new DisplayMockParcelTest::DisplayPowerMgrTestCallback();
-
-    EXPECT_FALSE(sptrDisplayProxy->RegisterCallback(callbackPtr));
-    DISPLAY_HILOGI(LABEL_TEST, "DisplayMockParcelTest_003 function end!");
+    bool result = false;
+    EXPECT_NE(sptrDisplayProxy->RegisterCallback(callbackPtr, result), ERR_OK);
+    EXPECT_FALSE(result);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayMockParcelTest_003 function end");
 }
 
 /**
@@ -167,10 +207,14 @@ HWTEST_F(DisplayMockParcelTest, DisplayMockParcelTest_004, TestSize.Level0)
     sptr<IDisplayPowerCallback> callbackPtr = new DisplayMockParcelTest::DisplayPowerMgrTestCallback();
 
     DisplayMockParcelTest::DisplayProxyTestFunc(sptrDisplayProxy);
-    EXPECT_EQ(BRIGHTNESS_NONE_VALUE, sptrDisplayProxy->GetDeviceBrightness(DISPLAY_ID));
-
-    EXPECT_FALSE(sptrDisplayProxy->RegisterCallback(callbackPtr));
-    DISPLAY_HILOGI(LABEL_TEST, "DisplayMockParcelTest_004 function end!");
+    uint32_t brightness = 0;
+    EXPECT_NE(sptrDisplayProxy->GetDeviceBrightness(DISPLAY_ID, brightness), ERR_OK);
+    EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness);
+
+    bool result = false;
+    EXPECT_NE(sptrDisplayProxy->RegisterCallback(callbackPtr, result), ERR_OK);
+    EXPECT_FALSE(result);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayMockParcelTest_004 function end");
 }
 
 /**
diff --git a/state_manager/test/unittest/src/mock/display_mock_test.cpp b/state_manager/test/unittest/src/mock/display_mock_test.cpp
index b9146c9f1e5ab1f2c4b83892ff121185dfbb24ef..c08aa861c7914a6c4970c42d1d863a0fc4e99e93 100644
--- a/state_manager/test/unittest/src/mock/display_mock_test.cpp
+++ b/state_manager/test/unittest/src/mock/display_mock_test.cpp
@@ -47,6 +47,8 @@ static constexpr uint32_t REASON = 0;
 static constexpr int32_t BRIGHTNESS_ADJUST_VALUE = 150;
 static constexpr int32_t TIMEOUT_MS = 500;
 static constexpr double DISCOUNT_VALUE = 0.30;
+static constexpr uint32_t DEFAULT_DURATION = 500;
+static constexpr uint32_t ERR_OK = 0;
 } // namespace
 
 void DisplayMockTest::DisplayPowerMgrTestCallback::OnDisplayStateChanged(
@@ -102,27 +104,70 @@ HWTEST_F(DisplayMockTest, DisplayMockTest_003, TestSize.Level0)
     DISPLAY_HILOGI(LABEL_TEST, "DisplayMockTest_003 function start!");
     sptr<MockDisplayRemoteObject> sptrRemoteObj = new MockDisplayRemoteObject();
     auto sptrDisplayProxy = std::make_shared<DisplayPowerMgr::DisplayPowerMgrProxy>(sptrRemoteObj);
-    EXPECT_FALSE(sptrDisplayProxy->SetDisplayState(DISPLAY_ID, DisplayPowerMgr::DisplayState::DISPLAY_ON, REASON));
-    EXPECT_NE(DisplayPowerMgr::DisplayState::DISPLAY_ON, sptrDisplayProxy->GetDisplayState(DISPLAY_ID));
+    bool bRet = false;
+    EXPECT_NE(sptrDisplayProxy->SetDisplayState(DISPLAY_ID,
+        static_cast<uint32_t>(DisplayPowerMgr::DisplayState::DISPLAY_ON), REASON, bRet), ERR_OK);
+    EXPECT_FALSE(bRet);
+    int32_t state = 0;
+    EXPECT_NE(sptrDisplayProxy->GetDisplayState(DISPLAY_ID, state), ERR_OK);
+    EXPECT_NE(DisplayPowerMgr::DisplayState::DISPLAY_ON, DisplayPowerMgr::DisplayState(state));
     std::vector<uint32_t> result;
     result.push_back(DISPLAY_ID);
-    EXPECT_NE(result, sptrDisplayProxy->GetDisplayIds());
-    EXPECT_EQ(MAIN_ID, sptrDisplayProxy->GetMainDisplayId());
-    EXPECT_FALSE(sptrDisplayProxy->SetBrightness(BRIGHTNESS_SETTING_VALUE, DISPLAY_ID, false));
-    EXPECT_FALSE(sptrDisplayProxy->DiscountBrightness(DISCOUNT_VALUE, DISPLAY_ID));
-    EXPECT_FALSE(sptrDisplayProxy->OverrideBrightness(BRIGHTNESS_OVERRIDE_VALUE, DISPLAY_ID));
-    EXPECT_FALSE(sptrDisplayProxy->RestoreBrightness(DISPLAY_ID));
-    EXPECT_EQ(BRIGHTNESS_NONE_VALUE, sptrDisplayProxy->GetBrightness(DISPLAY_ID));
-    EXPECT_EQ(BRIGHTNESS_NONE_VALUE, sptrDisplayProxy->GetDeviceBrightness(DISPLAY_ID));
-    EXPECT_EQ(BRIGHTNESS_NONE_VALUE, sptrDisplayProxy->GetDefaultBrightness());
-    EXPECT_EQ(BRIGHTNESS_NONE_VALUE, sptrDisplayProxy->GetMaxBrightness());
-    EXPECT_EQ(BRIGHTNESS_NONE_VALUE, sptrDisplayProxy->GetMinBrightness());
-    EXPECT_FALSE(sptrDisplayProxy->AdjustBrightness(DISPLAY_ID, BRIGHTNESS_ADJUST_VALUE, BRIGHTNESS_DURATION));
-    EXPECT_FALSE(sptrDisplayProxy->AutoAdjustBrightness(true));
-    EXPECT_FALSE(sptrDisplayProxy->AutoAdjustBrightness(false));
-    EXPECT_FALSE(sptrDisplayProxy->IsAutoAdjustBrightness());
-    EXPECT_FALSE(sptrDisplayProxy->BoostBrightness(TIMEOUT_MS, DISPLAY_ID));
-    EXPECT_FALSE(sptrDisplayProxy->CancelBoostBrightness(DISPLAY_ID));
+    std::vector<uint32_t> ids;
+    EXPECT_NE(sptrDisplayProxy->GetDisplayIds(ids), ERR_OK);
+    EXPECT_NE(result, ids);
+    uint32_t id = 0;
+    EXPECT_NE(sptrDisplayProxy->GetMainDisplayId(id), ERR_OK);
+    EXPECT_EQ(MAIN_ID, id);
     DISPLAY_HILOGI(LABEL_TEST, "DisplayMockTest_003 function end!");
 }
+
+/**
+ * @tc.name: DisplayMockTest_004
+ * @tc.desc: test DisplayPowerMgrProxy function(IRemoteObject and IDisplayPowerCallback is not null)
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DisplayMockTest, DisplayMockTest_004, TestSize.Level0)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayMockTest_004 function start!");
+    sptr<MockDisplayRemoteObject> sptrRemoteObj = new MockDisplayRemoteObject();
+    auto sptrDisplayProxy = std::make_shared<DisplayPowerMgr::DisplayPowerMgrProxy>(sptrRemoteObj);
+    bool bRet = false;
+    uint32_t brightness = 0;
+    int32_t errCode = 0;
+    EXPECT_NE(sptrDisplayProxy->SetBrightness(BRIGHTNESS_SETTING_VALUE, DISPLAY_ID, false, bRet, errCode), ERR_OK);
+    EXPECT_FALSE(bRet);
+    EXPECT_NE(sptrDisplayProxy->DiscountBrightness(DISCOUNT_VALUE, DISPLAY_ID, bRet), ERR_OK);
+    EXPECT_FALSE(bRet);
+    EXPECT_NE(sptrDisplayProxy->OverrideBrightness(BRIGHTNESS_OVERRIDE_VALUE, DISPLAY_ID, DEFAULT_DURATION, bRet),
+        ERR_OK);
+    EXPECT_FALSE(bRet);
+    EXPECT_NE(sptrDisplayProxy->RestoreBrightness(DISPLAY_ID, DEFAULT_DURATION, bRet), ERR_OK);
+    EXPECT_FALSE(bRet);
+    EXPECT_NE(sptrDisplayProxy->GetBrightness(DISPLAY_ID, brightness), ERR_OK);
+    EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness);
+    EXPECT_NE(sptrDisplayProxy->GetDeviceBrightness(DISPLAY_ID, brightness), ERR_OK);
+    EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness);
+    EXPECT_NE(sptrDisplayProxy->GetDefaultBrightness(brightness), ERR_OK);
+    EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness);
+    EXPECT_NE(sptrDisplayProxy->GetMaxBrightness(brightness), ERR_OK);
+    EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness);
+    EXPECT_NE(sptrDisplayProxy->GetMinBrightness(brightness), ERR_OK);
+    EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness);
+    EXPECT_NE(sptrDisplayProxy->AdjustBrightness(DISPLAY_ID, BRIGHTNESS_ADJUST_VALUE, BRIGHTNESS_DURATION, bRet),
+        ERR_OK);
+    EXPECT_FALSE(bRet);
+    EXPECT_NE(sptrDisplayProxy->AutoAdjustBrightness(true, bRet), ERR_OK);
+    EXPECT_FALSE(bRet);
+    EXPECT_NE(sptrDisplayProxy->AutoAdjustBrightness(false, bRet), ERR_OK);
+    EXPECT_FALSE(bRet);
+    EXPECT_NE(sptrDisplayProxy->IsAutoAdjustBrightness(bRet), ERR_OK);
+    EXPECT_FALSE(bRet);
+    EXPECT_NE(sptrDisplayProxy->BoostBrightness(TIMEOUT_MS, DISPLAY_ID, bRet), ERR_OK);
+    EXPECT_FALSE(bRet);
+    EXPECT_NE(sptrDisplayProxy->CancelBoostBrightness(DISPLAY_ID, bRet), ERR_OK);
+    EXPECT_FALSE(bRet);
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayMockTest_004 function end!");
+}
 } // namespace
diff --git a/state_manager/utils/native/include/display_log.h b/state_manager/utils/native/include/display_log.h
index 41a4920324e20c71cd0464312d6ad7bc576c310e..6d702e371adde346c1134482b614423d3f5412e4 100644
--- a/state_manager/utils/native/include/display_log.h
+++ b/state_manager/utils/native/include/display_log.h
@@ -19,6 +19,7 @@
 #define CONFIG_HILOG
 #ifdef CONFIG_HILOG
 
+#include <cstdint>
 #include "hilog/log.h"
 
 namespace OHOS {
diff --git a/state_manager/utils/native/include/display_xcollie.h b/state_manager/utils/native/include/display_xcollie.h
new file mode 100644
index 0000000000000000000000000000000000000000..93b86b755e2dc7f1c024e68c93710e00ec9060f8
--- /dev/null
+++ b/state_manager/utils/native/include/display_xcollie.h
@@ -0,0 +1,37 @@
+/*
+ * 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 DISPLAY_XCOLLIE_H
+#define DISPLAY_XCOLLIE_H
+
+#include <functional>
+#include <string>
+#include <atomic>
+
+namespace OHOS {
+namespace DisplayPowerMgr {
+class DisplayXCollie {
+public:
+    DisplayXCollie(const std::string &logTag, bool isRecovery = false);
+    ~DisplayXCollie();
+private:
+    void CancelDisplayXCollie();
+    int32_t id_;
+    std::string logTag_;
+    std::atomic_bool isCanceled_ = false;
+};
+} // namespace DisplayPowerMgr
+} // namespace OHOS
+#endif // DISPLAY_XCOLLIE_H
\ No newline at end of file
diff --git a/state_manager/utils/native/src/display_xcollie.cpp b/state_manager/utils/native/src/display_xcollie.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fff7ee8fd82692dede00abd3c007a6253177534a
--- /dev/null
+++ b/state_manager/utils/native/src/display_xcollie.cpp
@@ -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
+ * limitations under the License.
+ */
+
+#include "display_log.h"
+#include "display_xcollie.h"
+#include "xcollie/xcollie.h"
+
+namespace OHOS {
+namespace DisplayPowerMgr {
+DisplayXCollie::DisplayXCollie(const std::string &logTag, bool isRecovery)
+{
+    logTag_ = logTag;
+    isCanceled_.store(false, std::memory_order_release);
+    const int DFX_DELAY_S = 60;
+    unsigned int flag = HiviewDFX::XCOLLIE_FLAG_LOG;
+    if (isRecovery) {
+        flag = HiviewDFX::XCOLLIE_FLAG_LOG | HiviewDFX::XCOLLIE_FLAG_RECOVERY;
+    }
+    id_ = HiviewDFX::XCollie::GetInstance().SetTimer(logTag_, DFX_DELAY_S, nullptr, nullptr, flag);
+    if (id_ == HiviewDFX::INVALID_ID) {
+        DISPLAY_HILOGE(COMP_SVC, "Start DisplayXCollie SetTimer fail, tag:%{public}s, timeout(s):%{public}u",
+            logTag_.c_str(), DFX_DELAY_S);
+        return;
+    }
+    DISPLAY_HILOGD(COMP_SVC, "Start DisplayXCollie, id:%{public}d, tag:%{public}s, timeout(s):%{public}u", id_,
+        logTag_.c_str(), DFX_DELAY_S);
+}
+
+DisplayXCollie::~DisplayXCollie()
+{
+    CancelDisplayXCollie();
+}
+
+void DisplayXCollie::CancelDisplayXCollie()
+{
+    if (isCanceled_.load(std::memory_order_acquire)) {
+        return;
+    }
+    if (id_ != HiviewDFX::INVALID_ID) {
+        HiviewDFX::XCollie::GetInstance().CancelTimer(id_);
+        id_ = HiviewDFX::INVALID_ID;
+    }
+    isCanceled_.store(true, std::memory_order_release);
+    DISPLAY_HILOGD(COMP_SVC, "Cancel DisplayXCollie, id:%{public}d, tag:%{public}s", id_, logTag_.c_str());
+}
+} // namespace DisplayPowerMgr
+} // namespace OHOS
\ No newline at end of file