diff --git a/brightness_manager/BUILD.gn b/brightness_manager/BUILD.gn
index 145b20e10207e384bda85a9fac7765590c0209a7..ca8ef7533712f4b7fb38ecc8af65bcf2e96435c9 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 3b15b89a3c913cb29bfd9097ec284eb03f78f5c5..a29a0c270c8624c87c59672e098bdec0b8e7190b 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..7338e24aa2d39ae8c4f01c87a02f8da1acdd6b5f 100644
--- a/state_manager/frameworks/native/display_power_mgr_client.cpp
+++ b/state_manager/frameworks/native/display_power_mgr_client.cpp
@@ -33,7 +33,9 @@ namespace OHOS {
 namespace DisplayPowerMgr {
 DisplayPowerMgrClient::DisplayPowerMgrClient() = default;
 DisplayPowerMgrClient::~DisplayPowerMgrClient() = default;
-
+namespace {
+    const int32_t DEFAULT_VALUE = -1;
+}
 sptr<IDisplayPowerMgr> DisplayPowerMgrClient::GetProxy()
 {
     std::lock_guard lock(mutex_);
@@ -89,7 +91,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) {
+        result = false;
+        DISPLAY_HILOGE(COMP_FWK, "SetDisplayState, ret = %{public}d", ret);
+    }
+    return result;
 }
 
 DisplayState DisplayPowerMgrClient::GetDisplayState(uint32_t id)
@@ -98,7 +106,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 +121,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) {
+        id = DEFAULT_MAIN_DISPLAY_ID;
+        DISPLAY_HILOGE(COMP_FWK, "GetMainDisplayId, ret = %{public}d", ret);
+    }
+    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) {
+        result = false;
+        DISPLAY_HILOGE(COMP_FWK, "DiscountBrightness, ret = %{public}d", ret);
+    }
+    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) {
+        result = false;
+        DISPLAY_HILOGE(COMP_FWK, "OverrideBrightness, ret = %{public}d", ret);
+    }
+    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) {
+        result = false;
+        DISPLAY_HILOGE(COMP_FWK, "OverrideDisplayOffDelay, ret = %{public}d", ret);
+    }
+    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) {
+        result = false;
+        DISPLAY_HILOGE(COMP_FWK, "RestoreBrightness, ret = %{public}d", ret);
+    }
+    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) {
+        brightness = BRIGHTNESS_OFF;
+        DISPLAY_HILOGE(COMP_FWK, "GetBrightness, ret = %{public}d", ret);
+    }
+    return brightness;
 }
 
 uint32_t DisplayPowerMgrClient::GetDefaultBrightness()
 {
     auto proxy = GetProxy();
     RETURN_IF_WITH_RET(proxy == nullptr, BRIGHTNESS_DEFAULT);
-    return proxy->GetDefaultBrightness();
+    uint32_t brightness = 0;
+    auto ret = proxy->GetDefaultBrightness(brightness);
+    if (ret != ERR_OK) {
+        brightness = 0;
+        DISPLAY_HILOGE(COMP_FWK, "GetDefaultBrightness, ret = %{public}d", ret);
+    }
+    return brightness;
 }
 
 uint32_t DisplayPowerMgrClient::GetMaxBrightness()
 {
     auto proxy = GetProxy();
     RETURN_IF_WITH_RET(proxy == nullptr, BRIGHTNESS_MAX);
-    return proxy->GetMaxBrightness();
+    uint32_t brightness = 0;
+    auto ret = proxy->GetMaxBrightness(brightness);
+    if (ret != ERR_OK) {
+        brightness = 0;
+        DISPLAY_HILOGE(COMP_FWK, "GetMaxBrightness, ret = %{public}d", ret);
+    }
+    return brightness;
 }
 
 uint32_t DisplayPowerMgrClient::GetMinBrightness()
 {
     auto proxy = GetProxy();
     RETURN_IF_WITH_RET(proxy == nullptr, BRIGHTNESS_MIN);
-    return proxy->GetMinBrightness();
+    uint32_t brightness = 0;
+    auto ret = proxy->GetMinBrightness(brightness);
+    if (ret != ERR_OK) {
+        brightness = 0;
+        DISPLAY_HILOGE(COMP_FWK, "GetMinBrightness, ret = %{public}d", ret);
+    }
+    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) {
+        result = false;
+        DISPLAY_HILOGE(COMP_FWK, "AdjustBrightness, ret = %{public}d", ret);
+    }
+    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) {
+        result = false;
+        DISPLAY_HILOGE(COMP_FWK, "AutoAdjustBrightness, ret = %{public}d", ret);
+    }
+    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) {
+        result = false;
+        DISPLAY_HILOGE(COMP_FWK, "IsAutoAdjustBrightness, ret = %{public}d", ret);
+    }
+    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) {
+        result = false;
+        DISPLAY_HILOGE(COMP_FWK, "SetScreenOnBrightness, ret = %{public}d", ret);
+    }
+    return result;
 }
 
 bool DisplayPowerMgrClient::RegisterCallback(sptr<IDisplayPowerCallback> callback)
@@ -217,35 +322,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) {
+        result = false;
+        DISPLAY_HILOGE(COMP_FWK, "RegisterCallback, ret = %{public}d", ret);
+    }
+    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) {
+        result = false;
+        DISPLAY_HILOGE(COMP_FWK, "BoostBrightness, ret = %{public}d", ret);
+    }
+    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) {
+        result = false;
+        DISPLAY_HILOGE(COMP_FWK, "CancelBoostBrightness, ret = %{public}d", ret);
+    }
+    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) {
+        brightness = BRIGHTNESS_OFF;
+        DISPLAY_HILOGE(COMP_FWK, "GetDeviceBrightness, ret = %{public}d", ret);
+    }
+    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) {
+        result = false;
+        DISPLAY_HILOGE(COMP_FWK, "SetCoordinated, ret = %{public}d", ret);
+    }
+    return result;
 }
 
 uint32_t DisplayPowerMgrClient::SetLightBrightnessThreshold(
@@ -253,41 +388,66 @@ uint32_t DisplayPowerMgrClient::SetLightBrightnessThreshold(
 {
     auto proxy = GetProxy();
     RETURN_IF_WITH_RET(proxy == nullptr, 0);
-    return proxy->SetLightBrightnessThreshold(threshold, callback);
+    uint32_t result = 0;
+    auto ret = proxy->SetLightBrightnessThreshold(threshold, callback, result);
+    if (ret != ERR_OK) {
+        result = 0;
+        DISPLAY_HILOGE(COMP_FWK, "SetLightBrightnessThreshold, ret = %{public}d", ret);
+    }
+    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..686c6b16a15aa60b9862375da2a03f9baf84ff2b 100644
--- a/state_manager/interfaces/inner_api/BUILD.gn
+++ b/state_manager/interfaces/inner_api/BUILD.gn
@@ -26,21 +26,31 @@ 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" ]
+  public_configs = [
+    ":displaymgr_public_config",
+    "${displaymgr_root_path}/service:displaymgr_public_config",
+  ]
 
+  deps = [
+    "${displaymgr_root_path}/service:displaymgr_proxy",
+  ]
   external_deps = [
     "c_utils:utils",
     "hicollie:libhicollie",
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 85ad61e142c389add817b7f1cec35d8a814e7c2c..6afd00518c5d7025ec21e797058b202063ede03f 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",
@@ -99,15 +104,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..d4c70b5ee6d37eba90a93f89d181d067c78843c3
--- /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 {
+    void SetDisplayState([in] unsigned int id, [in] unsigned int state, [in] unsigned int reason,
+        [out] boolean isResult);
+    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 isResult, [out] int retCode);
+    void SetMaxBrightness([in] double value, [in] unsigned int enterTestMode, [out] boolean isResult,
+        [out] int retCode);
+    void SetMaxBrightnessNit([in] unsigned int maxNit, [in] unsigned int enterTestMode, [out] boolean isResult,
+        [out] int retCode);
+    void DiscountBrightness([in] double value, [in] unsigned int displayId, [out] boolean isResult);
+    void OverrideBrightness([in] unsigned int value, [in] unsigned int displayId, [in] unsigned int duration,
+        [out] boolean isResult);
+    void OverrideDisplayOffDelay([in] unsigned int delayMs, [out] boolean isResult);
+    void RestoreBrightness([in] unsigned int displayId, [in] unsigned int duration, [out] boolean isResult);
+    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 isResult);
+    void AutoAdjustBrightness([in] boolean enable, [out] boolean isResult);
+    void IsAutoAdjustBrightness([out] boolean isResult);
+    void BoostBrightness([in] int timeoutMs, [in] unsigned int displayId, [out] boolean isResult);
+    void CancelBoostBrightness([in] unsigned int displayId, [out] boolean isResult);
+    void GetDeviceBrightness([in] unsigned int displayId, [out] unsigned int deviceBrightness);
+    void SetCoordinated([in] boolean coordinated, [in] unsigned int displayId, [out] boolean isResult);
+    void SetLightBrightnessThreshold([in] int[] threshold, [in] IDisplayBrightnessCallback displayBrightnessCallback,
+        [out] unsigned int retCode);
+    void RegisterCallback([in] IDisplayPowerCallback displayPowercallback, [out] boolean isResult);
+    void SetScreenOnBrightness([out] boolean isResult);
+    void NotifyScreenPowerStatus([in] unsigned int displayId, [in] unsigned int displayPowerStatus,
+        [out] int retCode);
+}
\ 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 319e04d4879d99d631a61cab735744257d3cfa78..d089d2838d5275acfb2efa94071320e9fe4c9b12 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,34 +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;
+
+    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();
@@ -79,7 +114,6 @@ public:
     void HandleBootBrightness();
     static uint32_t GetSafeBrightness(uint32_t value);
     static double GetSafeDiscount(double discount, uint32_t brightness);
-    virtual int NotifyScreenPowerStatus(uint32_t displayId, uint32_t displayPowerStatus) override;
 
 private:
     class CallbackDeathRecipient : public IRemoteObject::DeathRecipient {
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 4ce303453953797c3908c295107939660fffb315..55d8ca60556a8d555e2e50b1a3737c286cb9ed09 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();
@@ -130,13 +131,20 @@ 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);
 }
 
@@ -144,13 +152,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()) {
@@ -161,7 +171,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()) {
@@ -179,20 +190,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;
@@ -231,7 +244,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;
@@ -242,7 +255,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;
@@ -279,7 +292,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);
@@ -287,7 +300,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;
@@ -296,7 +309,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_) {
@@ -305,14 +318,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;
@@ -325,7 +338,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;
@@ -337,7 +350,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;
@@ -351,12 +364,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_;
     }
@@ -367,7 +380,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;
@@ -385,7 +398,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);
@@ -395,22 +408,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;
@@ -428,7 +441,7 @@ bool DisplayPowerMgrService::AdjustBrightness(uint32_t id, int32_t value, uint32
     return iterator->second->SetBrightness(value, duration);
 }
 
-bool DisplayPowerMgrService::AutoAdjustBrightness(bool enable)
+bool DisplayPowerMgrService::AutoAdjustBrightnessInner(bool enable)
 {
     if (!Permission::IsSystem()) {
         return false;
@@ -497,12 +510,12 @@ void DisplayPowerMgrService::DeactivateAmbientSensor()
 }
 #endif
 
-bool DisplayPowerMgrService::IsAutoAdjustBrightness()
+bool DisplayPowerMgrService::IsAutoAdjustBrightnessInner()
 {
     return autoBrightness_;
 }
 
-bool DisplayPowerMgrService::RegisterCallback(sptr<IDisplayPowerCallback> callback)
+bool DisplayPowerMgrService::RegisterCallbackInner(sptr<IDisplayPowerCallback> callback)
 {
     if (!Permission::IsSystem()) {
         return false;
@@ -526,7 +539,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;
@@ -538,7 +551,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;
@@ -553,7 +566,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);
@@ -563,7 +576,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;
@@ -575,7 +588,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()) {
@@ -642,9 +655,9 @@ int32_t DisplayPowerMgrService::Dump(int32_t fd, const std::vector<std::u16strin
     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");
@@ -688,7 +701,8 @@ void DisplayPowerMgrService::AmbientLightCallback(SensorEvent* event)
         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "Sensor Callback no service");
         return;
     }
-    uint32_t mainDispId = pms->GetMainDisplayId();
+    uint32_t mainDispId = 0;
+    pms->GetMainDisplayId(mainDispId);
     auto mainDisp = pms->controllerMap_.find(mainDispId);
     if (mainDisp == pms->controllerMap_.end()) {
         return;
@@ -704,7 +718,8 @@ void DisplayPowerMgrService::AmbientLightCallback(SensorEvent* event)
     if (pms->CalculateBrightness(data->intensity, brightness, changeBrightness)) {
         double discountStride = static_cast<double>(AUTO_ADJUST_BRIGHTNESS_STRIDE / mainDisp->second->GetDiscount());
         uint32_t gradualDuration = floor(changeBrightness / discountStride) * animationUpdateTime;
-        pms->AdjustBrightness(mainDispId, brightness, gradualDuration);
+        bool result = false;
+        pms->AdjustBrightness(mainDispId, brightness, gradualDuration, result);
     }
 }
 
@@ -853,7 +868,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;
@@ -884,7 +899,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;
@@ -907,7 +922,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;
@@ -918,5 +933,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 561d7842b6fab126abf2e05dee90dd9c192d4348..61cb9ec089f46766cfe04c97e825dd4c6d98c06d 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 87ee95998fb4dcdf9a1286d08684b1bd6a276d91..0395c504a69d72169e6a617ba92df7a9ddf02163 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 ac54ba24cb4cf0cea258a00fea26b296e92bb719..f96b3c4115e3f852c083d9632f59691d2cc32bf9 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 da49b44271283d0aed6a2b764983a3e59afbb650..209722e1dee47e08bd134c6f09805f61cf0dce29 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 c53f84b33d2f4457fc3611713921f6fe875c4e2d..e9be0f9bdbfedc22eec1a04fa0bf21497ffefe3d 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 d5fd071b6e57a41ae77902df20215fdcb95fe8b3..d4cc2eb7898d712a16894e56d005ab4f1b184b9c 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 c2c3babef69eb697b501bf33a46f6cf5945b4b96..d733f62559242fb4c28a7cce0bbff969bd9270c0 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 b189fb1984e80bfbe0036a5573b1a2cf04ba1779..1e526ba35ccdb65bc53e6913b36b323f9baf8e86 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/overridebrightness_fuzzer/BUILD.gn b/state_manager/test/fuzztest/overridebrightness_fuzzer/BUILD.gn
index b0bd5e24cb72e2c49106a0bff6c5233d2fedd016..e67277a9abdd6233e53100f7e2b2f8010c10995f 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 787a70499738aa8873ecd5c6f500503df9f51ff7..f55bd856df35dfbfe1586c09f7f12e8e46ec966e 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 6095b5f14cbe116ca8074352b8d7d5ef19803129..f9bf14d11a5a9de5f40900fddfeec3af9b4c0e40 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 0bbcd31690df9d00bb435a1a0a533a6677ed6918..ffd3818109c9a23198e3a231a1f15839c7b5a47d 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 c05780051090a5bb0804f04b09cd7ff3f0bb4bed..4637d5e682c511cef6da0e796463fcff7b18fdd0 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 e9801ca2914a9ecd9ae82b8f41f7f84c0da8d78f..46186ba2d8d68acaed35c775c39af54ebc455fd0 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 e14681c9187aaa052f026f8734873ae979b77419..f6c42f18db798603e09e71916111648c64f8802e 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/unittest/BUILD.gn b/state_manager/test/unittest/BUILD.gn
index 4a8512af18cfdc695d735707c65a4bd414077c05..c58a6c7cf6b2f11379f44eb5b30108535f59dfcf 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,31 @@ 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 = [
     "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",
@@ -68,6 +82,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",
@@ -81,17 +96,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
@@ -101,6 +127,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",
@@ -111,9 +143,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
 }
@@ -122,6 +158,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",
@@ -133,6 +175,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 += [
@@ -140,7 +183,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
@@ -150,6 +196,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",
@@ -159,14 +211,100 @@ 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",
+    "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 = [
@@ -174,5 +312,6 @@ group("unittest") {
     ":display_mock_parcel_test",
     ":display_mock_test",
     ":display_service_death_test",
+    ":display_service_test",
   ]
 }
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..d51dec38eeef59e13d8ea432fa90a8691b30bdd4 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/src/display_power_mgr_service_test.cpp b/state_manager/test/unittest/src/display_power_mgr_service_test.cpp
index cf7c2f4cdffc8fe38da0c12414bcd2d6ece3ef21..28a7412a1e92596f4a61e265d3f8dfa149f5d230 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
@@ -21,6 +21,11 @@
 
 #include "display_power_mgr_client.h"
 #include "display_log.h"
+#ifdef GTEST
+#define private   public
+#define protected public
+#endif
+#include "display_xcollie.h"
 
 using namespace testing::ext;
 using namespace OHOS;
@@ -472,4 +477,18 @@ HWTEST_F(DisplayPowerMgrServiceTest, DisplayPowerMgrService025, TestSize.Level0)
     DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrService025 function end!");
 }
 
+/**
+ * @tc.name: CancelDisplayXCollie001
+ * @tc.desc: Test functions CancelDisplayXCollie
+ * @tc.type: FUNC
+ */
+HWTEST_F(DisplayPowerMgrServiceTest, CancelDisplayXCollie001, TestSize.Level1)
+{
+    DISPLAY_HILOGI(LABEL_TEST, "CancelDisplayXCollie001 function start!");
+    DisplayXCollie displayXCollie("DisplayPowerMgrService::GetDisplayState");
+    EXPECT_FALSE(displayXCollie.isCanceled_.load());
+    displayXCollie.CancelDisplayXCollie();
+    EXPECT_TRUE(displayXCollie.isCanceled_.load());
+    DISPLAY_HILOGI(LABEL_TEST, "CancelDisplayXCollie001 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..ae063e1b05b4d859eb5163be0c73c6ac61df6a87
--- /dev/null
+++ b/state_manager/test/unittest/src/display_service_test.cpp
@@ -0,0 +1,176 @@
+/*
+ * 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_DEFAULT_VALUE = 102;
+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 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 SET_SUCC = 1;
+static constexpr uint32_t MAX_BRIGHTNESS_SET = 125;
+static constexpr uint32_t TEST_MODE = 1;
+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_EQ(BRIGHTNESS_DEFAULT_VALUE, g_service->GetDefaultBrightnessInner());
+    EXPECT_EQ(BRIGHTNESS_MAX_VALUE, g_service->GetMaxBrightnessInner());
+    EXPECT_EQ(BRIGHTNESS_MIN_VALUE, g_service->GetMinBrightnessInner());
+    EXPECT_TRUE(g_service->AdjustBrightnessInner(DISPLAY_MAIN_ID, BRIGHTNESS_ADJUST_VALUE, BRIGHTNESS_DURATION));
+    EXPECT_FALSE(g_service->AutoAdjustBrightnessInner(true));
+    EXPECT_FALSE(g_service->AutoAdjustBrightnessInner(false));
+    EXPECT_FALSE(g_service->IsAutoAdjustBrightnessInner());
+    EXPECT_TRUE(g_service->BoostBrightnessInner(TIMEOUT_MS, DISPLAY_ID));
+    EXPECT_TRUE(g_service->CancelBoostBrightnessInner(DISPLAY_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.Level0)
+{
+    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.Level0)
+{
+    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.Level0)
+{
+    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.Level0)
+{
+    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);
+    g_service->SetDisplayState(DISPLAY_ID, static_cast<uint32_t>(DisplayPowerMgr::DisplayState::DISPLAY_ON),
+        REASON, ret);
+    EXPECT_TRUE(ret);
+    EXPECT_EQ(DisplayPowerMgr::DisplayState::DISPLAY_ON, g_service->GetDisplayStateInner(DISPLAY_ID));
+    DISPLAY_HILOGI(LABEL_TEST, "DisplayServiceTest001 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..eec91a74faf1227f6a2403dd097ec2a801db40c5
--- /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..071b99d0faeddea8b6ff407b5c94971f9f8372e1
--- /dev/null
+++ b/state_manager/utils/native/src/display_xcollie.cpp
@@ -0,0 +1,48 @@
+/*
+ * 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_relaxed);
+    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()) {
+        return;
+    }
+    HiviewDFX::XCollie::GetInstance().CancelTimer(id_);
+    isCanceled_.store(true, std::memory_order_relaxed);
+    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