From 5db1f5f385df988568e4afe816732818bb150bc1 Mon Sep 17 00:00:00 2001 From: yxj Date: Mon, 12 May 2025 15:06:16 +0800 Subject: [PATCH 1/3] =?UTF-8?q?style:=20display=5Fmanager=E4=BB=93IDL?= =?UTF-8?q?=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: yxj --- brightness_manager/BUILD.gn | 1 + brightness_manager/test/unittest/BUILD.gn | 9 + bundle.json | 2 +- state_manager/frameworks/napi/BUILD.gn | 1 + .../native/display_power_mgr_client.cpp | 109 ++- state_manager/interfaces/inner_api/BUILD.gn | 23 +- .../native/include/display_power_mgr_client.h | 1 + .../native/include/idisplay_power_mgr.h | 64 -- state_manager/service/BUILD.gn | 71 +- state_manager/service/IDisplayPowerMgr.idl | 52 + .../include/display_power_mgr_service.h | 87 +- .../native/src/display_power_mgr_service.cpp | 194 +++- .../zidl/include/display_power_mgr_proxy.h | 74 -- .../zidl/include/display_power_mgr_stub.h | 64 -- .../zidl/src/display_power_callback_proxy.cpp | 1 + .../zidl/src/display_power_mgr_proxy.cpp | 917 ------------------ .../zidl/src/display_power_mgr_stub.cpp | 535 ---------- state_manager/test/BUILD.gn | 2 +- .../fuzztest/adjustbrightness_fuzzer/BUILD.gn | 9 +- .../adjustbrightness_fuzzer_test.cpp | 6 +- .../autoadjustbrightness_fuzzer/BUILD.gn | 9 +- .../autoadjustbrightness_fuzzer_test.cpp | 8 +- .../fuzztest/boostbrightness_fuzzer/BUILD.gn | 9 +- .../boostbrightness_fuzzer_test.cpp | 8 +- .../discountbrightness_fuzzer/BUILD.gn | 9 +- .../discountbrightness_fuzzer_test.cpp | 6 +- .../fuzztest/displaycoverage_fuzzer/BUILD.gn | 9 +- .../displaycoverage_fuzzer_test.cpp | 1 - .../fuzztest/displaystate_fuzzer/BUILD.gn | 9 +- .../displaystate_fuzzer_test.cpp | 8 +- .../fuzztest/getbrightness_fuzzer/BUILD.gn | 9 +- .../getbrightness_fuzzer_test.cpp | 14 +- .../fuzztest/getdisplayid_fuzzer/BUILD.gn | 9 +- .../getdisplayid_fuzzer_test.cpp | 9 +- .../overridebrightness_fuzzer/BUILD.gn | 9 +- .../overridebrightness_fuzzer_test.cpp | 8 +- .../overridedisplayoffdelay_fuzzer/BUILD.gn | 9 +- .../overridedisplayoffdelay_fuzzer_test.cpp | 6 +- .../fuzztest/registercallback_fuzzer/BUILD.gn | 11 +- .../registercallback_fuzzer_test.cpp | 6 +- .../fuzztest/setbrightness_fuzzer/BUILD.gn | 9 +- .../setbrightness_fuzzer_test.cpp | 6 +- .../fuzztest/setcoordinated_fuzzer/BUILD.gn | 9 +- .../setcoordinated_fuzzer_test.cpp | 6 +- .../BUILD.gn | 9 +- ...etlightbrightnessthreshold_fuzzer_test.cpp | 8 +- .../fuzztest/setmaxbrightness_fuzzer/BUILD.gn | 9 +- .../setmaxbrightness_fuzzer_test.cpp | 6 +- state_manager/test/unittest/BUILD.gn | 42 + .../src/mock/display_mock_object_test.cpp | 64 +- .../src/mock/display_mock_parcel_test.cpp | 82 +- .../unittest/src/mock/display_mock_test.cpp | 66 +- .../utils/native/include/display_log.h | 1 + .../native/include/display_xcollie.h} | 89 +- .../utils/native/src/display_xcollie.cpp | 42 + 55 files changed, 897 insertions(+), 1939 deletions(-) delete mode 100644 state_manager/interfaces/inner_api/native/include/idisplay_power_mgr.h create mode 100644 state_manager/service/IDisplayPowerMgr.idl delete mode 100644 state_manager/service/zidl/include/display_power_mgr_proxy.h delete mode 100644 state_manager/service/zidl/include/display_power_mgr_stub.h delete mode 100644 state_manager/service/zidl/src/display_power_mgr_proxy.cpp delete mode 100644 state_manager/service/zidl/src/display_power_mgr_stub.cpp rename state_manager/{interfaces/inner_api/native/include/display_power_mgr_ipc_interface_code.h => utils/native/include/display_xcollie.h} (36%) create mode 100644 state_manager/utils/native/src/display_xcollie.cpp diff --git a/brightness_manager/BUILD.gn b/brightness_manager/BUILD.gn index 145b20e..ca8ef75 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/brightness_manager/test/unittest/BUILD.gn b/brightness_manager/test/unittest/BUILD.gn index 9fd92c6..bd204fb 100644 --- a/brightness_manager/test/unittest/BUILD.gn +++ b/brightness_manager/test/unittest/BUILD.gn @@ -26,8 +26,15 @@ config("module_private_config") { set_defaults("ohos_unittest") { module_out_path = "display_manager/display_brightness_manager" + sanitize = { + cfi = true + cfi_cross_dso = true + debug = false + } + configs = [ "${brightnessmgr_root_path}:brightness_manager_config", + "${displaymgr_root_path}/service:displaymgr_public_config", "${displaymgr_utils_path}:coverage_flags", "${displaymgr_utils_path}:utils_config", ":module_private_config", @@ -36,6 +43,8 @@ set_defaults("ohos_unittest") { deps = [ "${displaymgr_inner_api}:displaymgr", "//third_party/googletest:gtest_main", + "${displaymgr_root_path}/service:displaymgr_proxy", + "${displaymgr_root_path}/service:displaymgr_stub", ] external_deps = [ diff --git a/bundle.json b/bundle.json index 3b15b89..a29a0c2 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 769ffcd..e7b9452 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 da4d65d..a4ac1a1 100644 --- a/state_manager/frameworks/native/display_power_mgr_client.cpp +++ b/state_manager/frameworks/native/display_power_mgr_client.cpp @@ -89,7 +89,9 @@ bool DisplayPowerMgrClient::SetDisplayState(DisplayState state, { auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, false); - return proxy->SetDisplayState(id, state, static_cast(reason)); + bool result = false; + proxy->SetDisplayState(id, static_cast(state), static_cast(reason), result); + return result; } DisplayState DisplayPowerMgrClient::GetDisplayState(uint32_t id) @@ -98,7 +100,9 @@ DisplayState DisplayPowerMgrClient::GetDisplayState(uint32_t id) if (proxy == nullptr) { return DisplayState::DISPLAY_UNKNOWN; } - return proxy->GetDisplayState(id); + int32_t displayState = 0; + proxy->GetDisplayState(id, displayState); + return static_cast(displayState); } std::vector DisplayPowerMgrClient::GetDisplayIds() @@ -107,105 +111,135 @@ std::vector DisplayPowerMgrClient::GetDisplayIds() if (proxy == nullptr) { return {}; } - return proxy->GetDisplayIds(); + std::vector ids; + proxy->GetDisplayIds(ids); + return ids; } int32_t DisplayPowerMgrClient::GetMainDisplayId() { auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, INVALID_DISPLAY_ID); - return static_cast(proxy->GetMainDisplayId()); + uint32_t id = INVALID_DISPLAY_ID; + proxy->GetMainDisplayId(id); + return id; } bool DisplayPowerMgrClient::SetBrightness(uint32_t value, uint32_t displayId, bool continuous) { auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, false); - return proxy->SetBrightness(value, displayId, continuous); + bool result = false; + proxy->SetBrightness(value, displayId, continuous, result); + 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; + proxy->DiscountBrightness(discount, displayId, result); + 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; + proxy->OverrideBrightness(value, displayId, duration, result); + 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; + proxy->OverrideDisplayOffDelay(delayMs, result); + 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; + proxy->RestoreBrightness(displayId, duration, result); + 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; + proxy->GetBrightness(displayId, brightness); + return brightness; } uint32_t DisplayPowerMgrClient::GetDefaultBrightness() { auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, BRIGHTNESS_DEFAULT); - return proxy->GetDefaultBrightness(); + uint32_t brightness = BRIGHTNESS_DEFAULT; + proxy->GetDefaultBrightness(brightness); + return brightness; } uint32_t DisplayPowerMgrClient::GetMaxBrightness() { auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, BRIGHTNESS_MAX); - return proxy->GetMaxBrightness(); + uint32_t brightness = BRIGHTNESS_MAX; + proxy->GetMaxBrightness(brightness); + return brightness; } uint32_t DisplayPowerMgrClient::GetMinBrightness() { auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, BRIGHTNESS_MIN); - return proxy->GetMinBrightness(); + uint32_t brightness = BRIGHTNESS_MIN; + proxy->GetMinBrightness(brightness); + 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; + proxy->AdjustBrightness(id, value, duration, result); + return result; } bool DisplayPowerMgrClient::AutoAdjustBrightness(bool enable) { auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, false); - return proxy->AutoAdjustBrightness(enable); + bool result = false; + proxy->AutoAdjustBrightness(enable, result); + return result; } bool DisplayPowerMgrClient::IsAutoAdjustBrightness() { auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, false); - return proxy->IsAutoAdjustBrightness(); + bool result = false; + proxy->IsAutoAdjustBrightness(result); + return result; } bool DisplayPowerMgrClient::SetScreenOnBrightness() { auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, false); - return proxy->SetScreenOnBrightness(); + bool result = false; + proxy->SetScreenOnBrightness(result); + return result; } bool DisplayPowerMgrClient::RegisterCallback(sptr callback) @@ -217,35 +251,45 @@ bool DisplayPowerMgrClient::RegisterCallback(sptr callbac auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, false); - return proxy->RegisterCallback(callback); + bool result = false; + proxy->RegisterCallback(callback, result); + 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; + proxy->BoostBrightness(timeoutMs, displayId, result); + 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; + proxy->CancelBoostBrightness(displayId, result); + 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; + proxy->GetDeviceBrightness(displayId, brightness); + 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; + proxy->SetCoordinated(coordinated, displayId, result); + return result; } uint32_t DisplayPowerMgrClient::SetLightBrightnessThreshold( @@ -253,7 +297,9 @@ uint32_t DisplayPowerMgrClient::SetLightBrightnessThreshold( { auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, 0); - return proxy->SetLightBrightnessThreshold(threshold, callback); + uint32_t result = 0; + proxy->SetLightBrightnessThreshold(threshold, callback, result); + return result; } DisplayErrors DisplayPowerMgrClient::GetError() @@ -265,29 +311,36 @@ DisplayErrors DisplayPowerMgrClient::GetError() } auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, DisplayErrors::ERR_CONNECTION_FAIL); - return proxy->GetError(); + int32_t errCode = ERR_OK; + proxy->GetError(errCode); + return static_cast(errCode); } 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; + proxy->SetMaxBrightness(value, enterTestMode, result); + 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; + proxy->SetMaxBrightnessNit(maxNit, enterTestMode, result); + 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 = 0; + proxy->NotifyScreenPowerStatus(displayId, status, result); + return result; } } // namespace DisplayPowerMgr diff --git a/state_manager/interfaces/inner_api/BUILD.gn b/state_manager/interfaces/inner_api/BUILD.gn index 8a05721..df2af05 100644 --- a/state_manager/interfaces/inner_api/BUILD.gn +++ b/state_manager/interfaces/inner_api/BUILD.gn @@ -26,21 +26,28 @@ config("displaymgr_public_config") { ohos_shared_library("displaymgr") { branch_protector_ret = "pac_ret" - - 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", - ] + sanitize = { + cfi = true + cfi_cross_dso = true + debug = false + } + sources = [ "${displaymgr_framework_path}/native/display_power_mgr_client.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", + "${displaymgr_root_path}/service:displaymgr_stub", + ] 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 286dcf2..926c27b 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 { 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 387104f..0000000 --- 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 -#include - -#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 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 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 threshold, sptr 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 85ad61e..120add9 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,75 @@ 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" ]) + + sources += [ + "zidl/src/display_brightness_callback_proxy.cpp", + "zidl/src/display_power_callback_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" ]) + sources += [ + "zidl/src/display_brightness_callback_stub.cpp", + "zidl/src/display_power_callback_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 0000000..2dd74d8 --- /dev/null +++ b/state_manager/service/IDisplayPowerMgr.idl @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +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); + void SetMaxBrightness([in] double value, [in] unsigned int enterTestMode, [out] boolean isResult); + void SetMaxBrightnessNit([in] unsigned int maxNit, [in] unsigned int enterTestMode, [out] boolean isResult); + 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 GetError([out] int errorCode); + 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 319e04d..c38649a 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,66 @@ 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 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 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; + + 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& ids) override; + int32_t GetMainDisplayId(uint32_t& id) override; + int32_t SetBrightness(uint32_t value, uint32_t displayId, bool continuous, bool& result) override; + int32_t SetMaxBrightness(double value, uint32_t mode, bool& result) override; + int32_t SetMaxBrightnessNit(uint32_t maxNit, uint32_t mode, bool& result) 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& 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& threshold, + const sptr& callback, uint32_t& result) override; + int32_t GetError(int32_t& errorCode) override; + int32_t SetScreenOnBrightness(bool& result) override; + int32_t NotifyScreenPowerStatus(uint32_t displayId, uint32_t displayPowerStatus, int32_t& result) override; + + virtual bool SetDisplayState(uint32_t id, DisplayState state, uint32_t reason); + virtual DisplayState GetDisplayState(uint32_t id); + virtual std::vector GetDisplayIds(); + virtual uint32_t GetMainDisplayId(); + virtual bool SetBrightness(uint32_t value, uint32_t displayId, bool continuous = false); + virtual bool SetMaxBrightness(double value, uint32_t mode); + virtual bool SetMaxBrightnessNit(uint32_t maxNit, uint32_t mode); + virtual bool DiscountBrightness(double discount, uint32_t displayId); + virtual bool OverrideBrightness(uint32_t value, uint32_t displayId, uint32_t duration = 500); + virtual bool OverrideDisplayOffDelay(uint32_t delayMs); + virtual bool RestoreBrightness(uint32_t displayId, uint32_t duration = 500); + virtual uint32_t GetBrightness(uint32_t displayId); + virtual uint32_t GetDefaultBrightness(); + virtual uint32_t GetMaxBrightness(); + virtual uint32_t GetMinBrightness(); + virtual bool AdjustBrightness(uint32_t id, int32_t value, uint32_t duration); + virtual bool AutoAdjustBrightness(bool enable); + virtual bool IsAutoAdjustBrightness(); + virtual bool SetScreenOnBrightness(); + virtual bool RegisterCallback(sptr callback); + virtual bool BoostBrightness(int32_t timeoutMs, uint32_t displayId); + virtual bool CancelBoostBrightness(uint32_t displayId); + virtual uint32_t GetDeviceBrightness(uint32_t displayId); + virtual bool SetCoordinated(bool coordinated, uint32_t displayId); virtual uint32_t SetLightBrightnessThreshold( - std::vector threshold, sptr callback) override; + std::vector threshold, sptr callback); + virtual DisplayErrors GetError(); virtual int32_t Dump(int32_t fd, const std::vector& args) override; - virtual DisplayErrors GetError() override; void NotifyStateChangeCallback(uint32_t displayId, DisplayState state, uint32_t reason); void Init(); void Deinit(); @@ -79,7 +112,7 @@ 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; + virtual int NotifyScreenPowerStatus(uint32_t displayId, uint32_t displayPowerStatus); 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 a9a32ff..12b1457 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(); @@ -296,8 +297,9 @@ DisplayState DisplayPowerMgrService::GetDisplayState(uint32_t id) std::vector DisplayPowerMgrService::GetDisplayIds() { std::vector ids; - for (auto& iter: controllerMap_) { - ids.push_back(iter.first); + auto ret = GetDisplayIds(ids); + if (ret != ERR_OK) { + DISPLAY_HILOGI(COMP_SVC, "[UL_POWER] GetDisplayIds ret = %{public}d", ret); } return ids; } @@ -915,5 +917,193 @@ 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", false); + result = SetDisplayState(id, static_cast(state), reason); + return ERR_OK; +} + +int32_t DisplayPowerMgrService::GetDisplayState(uint32_t id, int32_t& displayState) +{ + DisplayXCollie displayXCollie("DisplayPowerMgrService::GetDisplayState", false); + displayState = static_cast(GetDisplayState(id)); + return ERR_OK; +} + +int32_t DisplayPowerMgrService::GetDisplayIds(std::vector& ids) +{ + DisplayXCollie displayXCollie("DisplayPowerMgrService::GetDisplayIds", false); + for (auto& iter: controllerMap_) { + ids.push_back(iter.first); + } + return ERR_OK; +} + +int32_t DisplayPowerMgrService::GetMainDisplayId(uint32_t& id) +{ + DisplayXCollie displayXCollie("DisplayPowerMgrService::GetMainDisplayId", false); + id = GetMainDisplayId(); + return ERR_OK; +} + +int32_t DisplayPowerMgrService::SetBrightness(uint32_t value, uint32_t displayId, bool continuous, bool& result) +{ + DisplayXCollie displayXCollie("DisplayPowerMgrService::SetBrightness", false); + result = SetBrightness(value, displayId, continuous); + return ERR_OK; +} + +int32_t DisplayPowerMgrService::DiscountBrightness(double discount, uint32_t displayId, bool& result) +{ + DisplayXCollie displayXCollie("DisplayPowerMgrService::DiscountBrightness", false); + result = DiscountBrightness(discount, displayId); + return ERR_OK; +} + +int32_t DisplayPowerMgrService::OverrideBrightness(uint32_t brightness, uint32_t displayId, uint32_t duration, + bool& result) +{ + DisplayXCollie displayXCollie("DisplayPowerMgrService::OverrideBrightness", false); + result = OverrideBrightness(brightness, displayId, duration); + return ERR_OK; +} + +int32_t DisplayPowerMgrService::OverrideDisplayOffDelay(uint32_t delayMs, bool& result) +{ + DisplayXCollie displayXCollie("DisplayPowerMgrService::OverrideDisplayOffDelay", false); + result = OverrideDisplayOffDelay(delayMs); + return ERR_OK; +} + +int32_t DisplayPowerMgrService::RestoreBrightness(uint32_t displayId, uint32_t duration, bool& result) +{ + DisplayXCollie displayXCollie("DisplayPowerMgrService::GetBrightness", false); + result = RestoreBrightness(displayId, duration); + return ERR_OK; +} + +int32_t DisplayPowerMgrService::GetBrightness(uint32_t displayId, uint32_t& brightness) +{ + DisplayXCollie displayXCollie("DisplayPowerMgrService::GetBrightness", false); + brightness = GetBrightness(displayId); + return ERR_OK; +} + +int32_t DisplayPowerMgrService::GetDefaultBrightness(uint32_t& defaultBrightness) +{ + defaultBrightness = GetDefaultBrightness(); + return ERR_OK; +} + +int32_t DisplayPowerMgrService::GetMaxBrightness(uint32_t& maxBrightness) +{ + maxBrightness = GetMaxBrightness(); + return ERR_OK; +} + +int32_t DisplayPowerMgrService::GetMinBrightness(uint32_t& minBrightness) +{ + minBrightness = GetMinBrightness(); + return ERR_OK; +} + +int32_t DisplayPowerMgrService::AdjustBrightness(uint32_t id, int32_t value, uint32_t duration, bool& result) +{ + DisplayXCollie displayXCollie("DisplayPowerMgrService::AdjustBrightness"); + result = AdjustBrightness(id, value, duration); + return ERR_OK; +} + +int32_t DisplayPowerMgrService::AutoAdjustBrightness(bool enable, bool& result) +{ + DisplayXCollie displayXCollie("DisplayPowerMgrService::AutoAdjustBrightness"); + result = AutoAdjustBrightness(enable); + return ERR_OK; +} + +int32_t DisplayPowerMgrService::IsAutoAdjustBrightness(bool& result) +{ + result = IsAutoAdjustBrightness(); + return ERR_OK; +} + +int32_t DisplayPowerMgrService::RegisterCallback(const sptr& callback, bool& result) +{ + DisplayXCollie displayXCollie("DisplayPowerMgrService::RegisterCallback"); + result = RegisterCallback(callback); + return ERR_OK; +} + +int32_t DisplayPowerMgrService::BoostBrightness(int32_t timeoutMs, uint32_t displayId, bool& result) +{ + DisplayXCollie displayXCollie("DisplayPowerMgrService::BoostBrightness"); + result = BoostBrightness(timeoutMs, displayId); + return ERR_OK; +} + +int32_t DisplayPowerMgrService::CancelBoostBrightness(uint32_t displayId, bool& result) +{ + DisplayXCollie displayXCollie("DisplayPowerMgrService::CancelBoostBrightness"); + result = CancelBoostBrightness(displayId); + return ERR_OK; +} + +int32_t DisplayPowerMgrService::GetDeviceBrightness(uint32_t displayId, uint32_t& deviceBrightness) +{ + DisplayXCollie displayXCollie("DisplayPowerMgrService::GetDeviceBrightness"); + deviceBrightness = GetDeviceBrightness(displayId); + return ERR_OK; +} + +int32_t DisplayPowerMgrService::SetCoordinated(bool coordinated, uint32_t displayId, bool& result) +{ + DisplayXCollie displayXCollie("DisplayPowerMgrService::SetCoordinated"); + result = SetCoordinated(coordinated, displayId); + return ERR_OK; +} + +int32_t DisplayPowerMgrService::SetLightBrightnessThreshold(const std::vector& threshold, + const sptr& callback, uint32_t& result) +{ + DisplayXCollie displayXCollie("DisplayPowerMgrService::SetLightBrightnessThreshold"); + result = SetLightBrightnessThreshold(threshold, callback); + return ERR_OK; +} + +int32_t DisplayPowerMgrService::GetError(int32_t& errorCode) +{ + errorCode = static_cast(GetError()); + return ERR_OK; +} + +int32_t DisplayPowerMgrService::SetMaxBrightness(double value, uint32_t mode, bool& result) +{ + DisplayXCollie displayXCollie("DisplayPowerMgrService::SetMaxBrightness"); + result = SetMaxBrightness(value, mode); + return ERR_OK; +} + +int32_t DisplayPowerMgrService::SetMaxBrightnessNit(uint32_t maxNit, uint32_t mode, bool& result) +{ + DisplayXCollie displayXCollie("DisplayPowerMgrService::SetMaxBrightnessNit"); + result = SetMaxBrightnessNit(maxNit, mode); + return ERR_OK; +} + +int32_t DisplayPowerMgrService::SetScreenOnBrightness(bool& result) +{ + DisplayXCollie displayXCollie("DisplayPowerMgrService::SetScreenOnBrightness"); + result = SetScreenOnBrightness(); + return ERR_OK; +} + +int32_t DisplayPowerMgrService::NotifyScreenPowerStatus(uint32_t displayId, uint32_t displayPowerStatus, + int32_t& result) +{ + DisplayXCollie displayXCollie("DisplayPowerMgrService::NotifyScreenPowerStatus"); + result = NotifyScreenPowerStatus(displayId, displayPowerStatus); + return ERR_OK; +} } // namespace DisplayPowerMgr } // namespace OHOS 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 4a0ff39..0000000 --- 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 -#include -#include -#include -#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 { -public: - explicit DisplayPowerMgrProxy(const sptr& impl) - : IRemoteProxy(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 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 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 threshold, sptr callback) override; - virtual DisplayErrors GetError() override; - virtual int NotifyScreenPowerStatus(uint32_t displayId, uint32_t status) override; - -private: - static inline BrokerDelegator 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 5b33027..0000000 --- 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 -#include -#include "refbase.h" -#include "message_option.h" - -#include "idisplay_power_mgr.h" - -namespace OHOS { -namespace DisplayPowerMgr { -class DisplayPowerMgrStub : public IRemoteStub { -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 0dbfca6..86d33d8 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 eb2e194..0000000 --- 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 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(state), false); - RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, reason, false); - - int ret = remote->SendRequest( - static_cast(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 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(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(result); -} - -std::vector DisplayPowerMgrProxy::GetDisplayIds() -{ - sptr remote = Remote(); - std::vector 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(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 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(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 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(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(error); - - return result; -} - -bool DisplayPowerMgrProxy::SetMaxBrightness(double value, uint32_t enterTestMode) -{ - sptr 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(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(error); - return result; -} - -bool DisplayPowerMgrProxy::SetMaxBrightnessNit(uint32_t maxNit, uint32_t enterTestMode) -{ - sptr 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(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(error); - - return result; -} - -bool DisplayPowerMgrProxy::DiscountBrightness(double discount, uint32_t displayId) -{ - sptr 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(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 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(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 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(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 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(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 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(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 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(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 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(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 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(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 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(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 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(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 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(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 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(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 callback) -{ - sptr 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(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 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(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 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(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 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(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 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(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 threshold, sptr callback) -{ - sptr 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(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 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(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(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 d0f2804..0000000 --- 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 -#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(PowerMgr::DisplayPowerMgrInterfaceCode::SET_DISPLAY_STATE): - ret = SetDisplayStateStub(data, reply); - break; - case static_cast(PowerMgr::DisplayPowerMgrInterfaceCode::GET_DISPLAY_STATE): - ret = GetDisplayStateStub(data, reply); - break; - case static_cast(PowerMgr::DisplayPowerMgrInterfaceCode::GET_DISPLAY_IDS): - ret = GetDisplayIdsStub(data, reply); - break; - case static_cast(PowerMgr::DisplayPowerMgrInterfaceCode::GET_MAIN_DISPLAY_ID): - ret = GetMainDisplayIdStub(data, reply); - break; - case static_cast(PowerMgr::DisplayPowerMgrInterfaceCode::SET_BRIGHTNESS): - ret = SetBrightnessStub(data, reply); - break; - case static_cast(PowerMgr::DisplayPowerMgrInterfaceCode::DISCOUNT_BRIGHTNESS): - ret = DiscountBrightnessStub(data, reply); - break; - case static_cast(PowerMgr::DisplayPowerMgrInterfaceCode::OVERRIDE_BRIGHTNESS): - ret = OverrideBrightnessStub(data, reply); - break; - case static_cast(PowerMgr::DisplayPowerMgrInterfaceCode::OVERRIDE_DISPLAY_OFF_DELAY): - ret = OverrideDisplayOffDelayStub(data, reply); - break; - case static_cast(PowerMgr::DisplayPowerMgrInterfaceCode::SET_APS_LIGHT_AND_BRIGHTNESS_THRESOLD): - ret = SetLightBrightnessThresholdStub(data, reply); - break; - case static_cast(PowerMgr::DisplayPowerMgrInterfaceCode::SET_MAX_BRIGHTNESS): - ret = SetMaxBrightnessStub(data, reply); - break; - case static_cast(PowerMgr::DisplayPowerMgrInterfaceCode::SET_MAX_BRIGHTNESS_NIT): - ret = SetMaxBrightnessNitStub(data, reply); - break; - case static_cast(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(PowerMgr::DisplayPowerMgrInterfaceCode::RESTORE_BRIGHTNESS): - ret = RestoreBrightnessStub(data, reply); - break; - case static_cast(PowerMgr::DisplayPowerMgrInterfaceCode::GET_BRIGHTNESS): - ret = GetBrightnessStub(data, reply); - break; - case static_cast(PowerMgr::DisplayPowerMgrInterfaceCode::GET_DEFAULT_BRIGHTNESS): - ret = GetDefaultBrightnessStub(data, reply); - break; - case static_cast(PowerMgr::DisplayPowerMgrInterfaceCode::GET_MAX_BRIGHTNESS): - ret = GetMaxBrightnessStub(data, reply); - break; - case static_cast(PowerMgr::DisplayPowerMgrInterfaceCode::GET_MIN_BRIGHTNESS): - ret = GetMinBrightnessStub(data, reply); - break; - case static_cast(PowerMgr::DisplayPowerMgrInterfaceCode::ADJUST_BRIGHTNESS): - ret = AdjustBrightnessStub(data, reply); - break; - case static_cast(PowerMgr::DisplayPowerMgrInterfaceCode::AUTO_ADJUST_BRIGHTNESS): - ret = AutoAdjustBrightnessStub(data, reply); - break; - case static_cast(PowerMgr::DisplayPowerMgrInterfaceCode::IS_AUTO_ADJUST_BRIGHTNESS): - ret = IsAutoAdjustBrightnessStub(data, reply); - break; - case static_cast(PowerMgr::DisplayPowerMgrInterfaceCode::REGISTER_CALLBACK): - ret = RegisterCallbackStub(data, reply); - break; - case static_cast(PowerMgr::DisplayPowerMgrInterfaceCode::BOOST_BRIGHTNESS): - ret = BoostBrightnessStub(data, reply); - break; - case static_cast(PowerMgr::DisplayPowerMgrInterfaceCode::CANCEL_BOOST_BRIGHTNESS): - ret = CancelBoostBrightnessStub(data, reply); - break; - case static_cast(PowerMgr::DisplayPowerMgrInterfaceCode::GET_DEVICE_BRIGHTNESS): - ret = GetDeviceBrightnessStub(data, reply); - break; - case static_cast(PowerMgr::DisplayPowerMgrInterfaceCode::SET_COORDINATED): - ret = SetCoordinatedStub(data, reply); - break; - case static_cast(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(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(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 result = GetDisplayIds(); - if (!reply.WriteUint32(static_cast(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(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(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 obj = data.ReadRemoteObject(); - RETURN_IF_WITH_RET((obj == nullptr), E_READ_PARCEL_ERROR); - sptr callback = iface_cast(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 threshold; - RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Int32Vector, &threshold, E_READ_PARCEL_ERROR); - sptr obj = data.ReadRemoteObject(); - RETURN_IF_WITH_RET((obj == nullptr), E_READ_PARCEL_ERROR); - sptr callback = iface_cast(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(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(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(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 95570e3..3189ad0 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 561d784..61cb9ec 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 508d9bb..e8a95d1 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(DisplayPowerMgrInterfaceCode::ADJUST_BRIGHTNESS), data, size); + static_cast(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 87ee959..0395c50 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 22c6411..96ead9f 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(DisplayPowerMgrInterfaceCode::AUTO_ADJUST_BRIGHTNESS), data, size); + static_cast(IDisplayPowerMgrIpcCode::COMMAND_AUTO_ADJUST_BRIGHTNESS), data, size); g_serviceTest.TestDisplayServiceStub( - static_cast(DisplayPowerMgrInterfaceCode::IS_AUTO_ADJUST_BRIGHTNESS), data, size); + static_cast(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 ac54ba2..f96b3c4 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 ad5ae0d..4580130 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(DisplayPowerMgrInterfaceCode::BOOST_BRIGHTNESS), data, size); + static_cast(IDisplayPowerMgrIpcCode::COMMAND_BOOST_BRIGHTNESS), data, size); g_serviceTest.TestDisplayServiceStub( - static_cast(DisplayPowerMgrInterfaceCode::CANCEL_BOOST_BRIGHTNESS), data, size); + static_cast(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 da49b44..209722e 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 da8d4de..f909caf 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(DisplayPowerMgrInterfaceCode::DISCOUNT_BRIGHTNESS), data, size); + static_cast(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 c53f84b..e9be0f9 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 a00ae70..77a1c2d 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 { diff --git a/state_manager/test/fuzztest/displaystate_fuzzer/BUILD.gn b/state_manager/test/fuzztest/displaystate_fuzzer/BUILD.gn index d5fd071..d4cc2eb 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 e0b30d2..6f02a49 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(DisplayPowerMgrInterfaceCode::SET_DISPLAY_STATE), data, size); + static_cast(IDisplayPowerMgrIpcCode::COMMAND_SET_DISPLAY_STATE), data, size); g_serviceTest.TestDisplayServiceStub( - static_cast(DisplayPowerMgrInterfaceCode::GET_DISPLAY_STATE), data, size); + static_cast(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 c2c3bab..d733f62 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 ee2fe2c..b699e07 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(DisplayPowerMgrInterfaceCode::GET_BRIGHTNESS), data, size); + static_cast(IDisplayPowerMgrIpcCode::COMMAND_GET_BRIGHTNESS), data, size); g_serviceTest.TestDisplayServiceStub( - static_cast(DisplayPowerMgrInterfaceCode::GET_DEFAULT_BRIGHTNESS), data, size); + static_cast(IDisplayPowerMgrIpcCode::COMMAND_GET_DEFAULT_BRIGHTNESS), data, size); g_serviceTest.TestDisplayServiceStub( - static_cast(DisplayPowerMgrInterfaceCode::GET_MAX_BRIGHTNESS), data, size); + static_cast(IDisplayPowerMgrIpcCode::COMMAND_GET_MAX_BRIGHTNESS), data, size); g_serviceTest.TestDisplayServiceStub( - static_cast(DisplayPowerMgrInterfaceCode::GET_MIN_BRIGHTNESS), data, size); + static_cast(IDisplayPowerMgrIpcCode::COMMAND_GET_MIN_BRIGHTNESS), data, size); g_serviceTest.TestDisplayServiceStub( - static_cast(DisplayPowerMgrInterfaceCode::GET_DEVICE_BRIGHTNESS), data, size); + static_cast(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 b189fb1..1e526ba 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 748387a..f7f5fcc 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(DisplayPowerMgrInterfaceCode::GET_DISPLAY_IDS), data, size); + static_cast(IDisplayPowerMgrIpcCode::COMMAND_GET_DISPLAY_IDS), data, size); g_serviceTest.TestDisplayServiceStub( - static_cast(DisplayPowerMgrInterfaceCode::GET_MAIN_DISPLAY_ID), data, size); + static_cast(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 b0bd5e2..e67277a 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 df5f681..c0a1ae3 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(DisplayPowerMgrInterfaceCode::OVERRIDE_BRIGHTNESS), data, size); + static_cast(IDisplayPowerMgrIpcCode::COMMAND_OVERRIDE_BRIGHTNESS), data, size); g_serviceTest.TestDisplayServiceStub( - static_cast(DisplayPowerMgrInterfaceCode::RESTORE_BRIGHTNESS), data, size); + static_cast(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 787a704..f55bd85 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 36c0056..cd1880e 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(DisplayPowerMgrInterfaceCode::OVERRIDE_DISPLAY_OFF_DELAY), data, size); + static_cast(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 6095b5f..f9bf14d 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 bc87d48..c2e9aa2 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(DisplayPowerMgrInterfaceCode::REGISTER_CALLBACK), data, size); + static_cast(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 0bbcd31..ffd3818 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 0eb18ca..bb55d4f 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(DisplayPowerMgrInterfaceCode::SET_BRIGHTNESS), data, size); + static_cast(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 c057800..4637d5e 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 8876e04..c95e3a4 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(DisplayPowerMgrInterfaceCode::SET_COORDINATED), data, size); + static_cast(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 e9801ca..46186ba 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 2e87c7c..6db2386 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(DisplayPowerMgrInterfaceCode::SET_MAX_BRIGHTNESS), data, size); + static_cast(IDisplayPowerMgrIpcCode::COMMAND_SET_MAX_BRIGHTNESS), data, size); g_serviceTest.TestDisplayServiceStub( - static_cast(DisplayPowerMgrInterfaceCode::SET_MAX_BRIGHTNESS_NIT), data, size); + static_cast(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 e14681c..f6c42f1 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 71c70c4..0947045 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(DisplayPowerMgrInterfaceCode::SET_APS_LIGHT_AND_BRIGHTNESS_THRESOLD), data, size); + static_cast(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 d9f1af7..8277189 100644 --- a/state_manager/test/unittest/BUILD.gn +++ b/state_manager/test/unittest/BUILD.gn @@ -48,6 +48,12 @@ deps_ex = [ ohos_unittest("unittest_display_mgr_service") { module_out_path = module_output_path + sanitize = { + cfi = true + cfi_cross_dso = true + debug = false + } + sources = [ "src/display_power_mgr_brightness_test.cpp", "src/display_power_mgr_service_test.cpp", @@ -57,11 +63,14 @@ ohos_unittest("unittest_display_mgr_service") { "${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", "//third_party/googletest:gtest_main", + "${displaymgr_root_path}/service:displaymgr_proxy", + "${displaymgr_root_path}/service:displaymgr_stub", ] external_deps = [ @@ -83,12 +92,19 @@ 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" ] @@ -96,6 +112,8 @@ ohos_unittest("display_service_death_test") { deps = [ "${displaymgr_inner_api}:displaymgr", "//third_party/googletest:gtest_main", + "${displaymgr_root_path}/service:displaymgr_proxy", + "${displaymgr_root_path}/service:displaymgr_stub", ] external_deps = deps_ex @@ -105,6 +123,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", @@ -115,11 +139,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", "//third_party/googletest:gtest_main", + "${displaymgr_root_path}/service:displaymgr_proxy", ] external_deps = deps_ex @@ -129,6 +155,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", @@ -140,6 +172,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 += [ @@ -150,6 +183,7 @@ ohos_unittest("display_mock_test") { deps = [ "${displaymgr_inner_api}:displaymgr", "//third_party/googletest:gtest_main", + "${displaymgr_root_path}/service:displaymgr_proxy", ] external_deps = deps_ex @@ -159,6 +193,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", @@ -168,11 +208,13 @@ 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", "//third_party/googletest:gtest_main", + "${displaymgr_root_path}/service:displaymgr_proxy", ] external_deps = deps_ex 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 39d7e1f..fd26907 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,7 @@ 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; } // namespace void DisplayMockObjectTest::DisplayPowerMgrTestCallback::OnDisplayStateChanged( @@ -56,26 +57,51 @@ HWTEST_F(DisplayMockObjectTest, DisplayMockObjectTest_001, TestSize.Level0) { sptr sptrRemoteObj = new MockDisplayRemoteObject(); auto sptrDisplayProxy = std::make_shared(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; + sptrDisplayProxy->SetDisplayState(DISPLAY_ID, static_cast(DisplayPowerMgr::DisplayState::DISPLAY_ON), + REASON, bRet); + EXPECT_FALSE(bRet); + int32_t state = 0; + sptrDisplayProxy->GetDisplayState(DISPLAY_ID, state); + EXPECT_NE(DisplayPowerMgr::DisplayState::DISPLAY_ON, DisplayPowerMgr::DisplayState(state)); std::vector 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 ids; + sptrDisplayProxy->GetDisplayIds(ids); + EXPECT_NE(result, ids); + uint32_t id = 0; + sptrDisplayProxy->GetMainDisplayId(id); + EXPECT_EQ(MAIN_ID_PROXY, id); + sptrDisplayProxy->SetBrightness(BRIGHTNESS_SETTING_VALUE, DISPLAY_ID, false, bRet); + EXPECT_FALSE(bRet); + sptrDisplayProxy->DiscountBrightness(DISCOUNT_VALUE, DISPLAY_ID, bRet); + EXPECT_FALSE(bRet); + sptrDisplayProxy->OverrideBrightness(BRIGHTNESS_OVERRIDE_VALUE, DISPLAY_ID, DEFAULT_DURATION, bRet); + EXPECT_FALSE(bRet); + sptrDisplayProxy->RestoreBrightness(DISPLAY_ID, DEFAULT_DURATION, bRet); + EXPECT_FALSE(bRet); + uint32_t brightness = 0; + sptrDisplayProxy->GetBrightness(DISPLAY_ID, brightness); + EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness); + sptrDisplayProxy->GetDeviceBrightness(DISPLAY_ID, brightness); + EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness); + sptrDisplayProxy->GetDefaultBrightness(brightness); + EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness); + sptrDisplayProxy->GetMaxBrightness(brightness); + EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness); + sptrDisplayProxy->GetMinBrightness(brightness); + EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness); + sptrDisplayProxy->AdjustBrightness(DISPLAY_ID, BRIGHTNESS_ADJUST_VALUE, BRIGHTNESS_DURATION, bRet); + EXPECT_FALSE(bRet); + sptrDisplayProxy->AutoAdjustBrightness(true, bRet); + EXPECT_FALSE(bRet); + sptrDisplayProxy->AutoAdjustBrightness(false, bRet); + EXPECT_FALSE(bRet); + sptrDisplayProxy->IsAutoAdjustBrightness(bRet); + EXPECT_FALSE(bRet); + sptrDisplayProxy->BoostBrightness(TIMEOUT_MS, DISPLAY_ID, bRet); + EXPECT_FALSE(bRet); + sptrDisplayProxy->CancelBoostBrightness(DISPLAY_ID, bRet); + EXPECT_FALSE(bRet); } } //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 4c5ece2..36b83b6 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,55 @@ 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; } // namespace void DisplayMockParcelTest::DisplayProxyTestFunc(std::shared_ptr& sptrDisplayProxy) { std::vector 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; + sptrDisplayProxy->SetDisplayState(DISPLAY_ID, + static_cast(DisplayPowerMgr::DisplayState::DISPLAY_ON), REASON, ret); + EXPECT_FALSE(ret); + int32_t state = 0; + sptrDisplayProxy->GetDisplayState(DISPLAY_ID, state); + EXPECT_NE(DisplayPowerMgr::DisplayState::DISPLAY_ON, DisplayPowerMgr::DisplayState(state)); + std::vector ids; + sptrDisplayProxy->GetDisplayIds(ids); + EXPECT_NE(result, ids); + uint32_t mainId = MAIN_ID_PROXY; + sptrDisplayProxy->GetMainDisplayId(mainId); + EXPECT_EQ(MAIN_ID_PROXY, mainId); + sptrDisplayProxy->SetBrightness(BRIGHTNESS_SETTING_VALUE, DISPLAY_ID, false, ret); + EXPECT_FALSE(ret); + sptrDisplayProxy->DiscountBrightness(DISCOUNT_VALUE, DISPLAY_ID, ret); + EXPECT_FALSE(ret); + sptrDisplayProxy->OverrideBrightness(BRIGHTNESS_OVERRIDE_VALUE, DISPLAY_ID, DEFAULT_DURATION, ret); + EXPECT_FALSE(ret); + sptrDisplayProxy->RestoreBrightness(DISPLAY_ID, DEFAULT_DURATION, ret); + EXPECT_FALSE(ret); + uint32_t brightness = 0; + sptrDisplayProxy->GetBrightness(DISPLAY_ID, brightness); + EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness); + sptrDisplayProxy->GetDefaultBrightness(brightness); + EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness); + sptrDisplayProxy->GetMaxBrightness(brightness); + EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness); + sptrDisplayProxy->GetMinBrightness(brightness); + EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness); + sptrDisplayProxy->AdjustBrightness(DISPLAY_ID, BRIGHTNESS_ADJUST_VALUE, BRIGHTNESS_DURATION, ret); + EXPECT_FALSE(ret); + sptrDisplayProxy->AutoAdjustBrightness(true, ret); + EXPECT_FALSE(ret); + sptrDisplayProxy->AutoAdjustBrightness(false, ret); + EXPECT_FALSE(ret); + sptrDisplayProxy->IsAutoAdjustBrightness(ret); + EXPECT_FALSE(ret); + sptrDisplayProxy->BoostBrightness(TIMEOUT_MS, DISPLAY_ID, ret); + EXPECT_FALSE(ret); + sptrDisplayProxy->CancelBoostBrightness(DISPLAY_ID, ret); + EXPECT_FALSE(ret); } void DisplayMockParcelTest::DisplayPowerMgrTestCallback::OnDisplayStateChanged( @@ -130,9 +155,13 @@ HWTEST_F(DisplayMockParcelTest, DisplayMockParcelTest_002, TestSize.Level0) sptr callbackPtr = nullptr; DisplayMockParcelTest::DisplayProxyTestFunc(sptrDisplayProxy); - EXPECT_EQ(BRIGHTNESS_NONE_VALUE, sptrDisplayProxy->GetDeviceBrightness(DISPLAY_ID)); + uint32_t brightness = BRIGHTNESS_NONE_VALUE; + sptrDisplayProxy->GetDeviceBrightness(DISPLAY_ID, brightness); + EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness); - EXPECT_FALSE(sptrDisplayProxy->RegisterCallback(callbackPtr)); + bool result = false; + sptrDisplayProxy->RegisterCallback(callbackPtr, result); + EXPECT_FALSE(result); DISPLAY_HILOGD(LABEL_TEST, "DisplayMockParcelTest_002: fun is end"); } @@ -147,8 +176,9 @@ HWTEST_F(DisplayMockParcelTest, DisplayMockParcelTest_003, TestSize.Level0) DISPLAY_HILOGD(LABEL_TEST, "DisplayMockParcelTest_003: fun is start"); auto sptrDisplayProxy = std::make_shared(nullptr); sptr callbackPtr = new DisplayMockParcelTest::DisplayPowerMgrTestCallback(); - - EXPECT_FALSE(sptrDisplayProxy->RegisterCallback(callbackPtr)); + bool result = false; + sptrDisplayProxy->RegisterCallback(callbackPtr, result); + EXPECT_FALSE(result); DISPLAY_HILOGD(LABEL_TEST, "DisplayMockParcelTest_003: fun is end"); } @@ -167,9 +197,13 @@ HWTEST_F(DisplayMockParcelTest, DisplayMockParcelTest_004, TestSize.Level0) sptr callbackPtr = new DisplayMockParcelTest::DisplayPowerMgrTestCallback(); DisplayMockParcelTest::DisplayProxyTestFunc(sptrDisplayProxy); - EXPECT_EQ(BRIGHTNESS_NONE_VALUE, sptrDisplayProxy->GetDeviceBrightness(DISPLAY_ID)); + uint32_t brightness = 0; + sptrDisplayProxy->GetDeviceBrightness(DISPLAY_ID, brightness); + EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness); - EXPECT_FALSE(sptrDisplayProxy->RegisterCallback(callbackPtr)); + bool result = false; + sptrDisplayProxy->RegisterCallback(callbackPtr, result); + EXPECT_FALSE(result); DISPLAY_HILOGD(LABEL_TEST, "DisplayMockParcelTest_004: fun is 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 f981c72..68c684b 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,7 @@ 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; } // namespace void DisplayMockTest::DisplayPowerMgrTestCallback::OnDisplayStateChanged( @@ -99,30 +100,53 @@ HWTEST_F(DisplayMockTest, DisplayMockTest_002, TestSize.Level0) */ HWTEST_F(DisplayMockTest, DisplayMockTest_003, TestSize.Level0) { - DISPLAY_HILOGD(LABEL_TEST, "DisplayMockTest_003: fun is start"); sptr sptrRemoteObj = new MockDisplayRemoteObject(); auto sptrDisplayProxy = std::make_shared(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; + sptrDisplayProxy->SetDisplayState(DISPLAY_ID, static_cast(DisplayPowerMgr::DisplayState::DISPLAY_ON), + REASON, bRet); + EXPECT_FALSE(bRet); + int32_t state = 0; + sptrDisplayProxy->GetDisplayState(DISPLAY_ID, state); + EXPECT_NE(DisplayPowerMgr::DisplayState::DISPLAY_ON, DisplayPowerMgr::DisplayState(state)); std::vector 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)); - DISPLAY_HILOGD(LABEL_TEST, "DisplayMockTest_003: fun is end"); + std::vector ids; + sptrDisplayProxy->GetDisplayIds(ids); + EXPECT_NE(result, ids); + uint32_t id = 0; + sptrDisplayProxy->GetMainDisplayId(id); + EXPECT_EQ(MAIN_ID, id); + sptrDisplayProxy->SetBrightness(BRIGHTNESS_SETTING_VALUE, DISPLAY_ID, false, bRet); + EXPECT_FALSE(bRet); + sptrDisplayProxy->DiscountBrightness(DISCOUNT_VALUE, DISPLAY_ID, bRet); + EXPECT_FALSE(bRet); + sptrDisplayProxy->OverrideBrightness(BRIGHTNESS_OVERRIDE_VALUE, DISPLAY_ID, DEFAULT_DURATION, bRet); + EXPECT_FALSE(bRet); + sptrDisplayProxy->RestoreBrightness(DISPLAY_ID, DEFAULT_DURATION, bRet); + EXPECT_FALSE(bRet); + uint32_t brightness = 0; + sptrDisplayProxy->GetBrightness(DISPLAY_ID, brightness); + EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness); + sptrDisplayProxy->GetDeviceBrightness(DISPLAY_ID, brightness); + EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness); + sptrDisplayProxy->GetDefaultBrightness(brightness); + EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness); + sptrDisplayProxy->GetMaxBrightness(brightness); + EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness); + sptrDisplayProxy->GetMinBrightness(brightness); + EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness); + sptrDisplayProxy->AdjustBrightness(DISPLAY_ID, BRIGHTNESS_ADJUST_VALUE, BRIGHTNESS_DURATION, bRet); + EXPECT_FALSE(bRet); + sptrDisplayProxy->AutoAdjustBrightness(true, bRet); + EXPECT_FALSE(bRet); + sptrDisplayProxy->AutoAdjustBrightness(false, bRet); + EXPECT_FALSE(bRet); + sptrDisplayProxy->IsAutoAdjustBrightness(bRet); + EXPECT_FALSE(bRet); + sptrDisplayProxy->BoostBrightness(TIMEOUT_MS, DISPLAY_ID, bRet); + EXPECT_FALSE(bRet); + sptrDisplayProxy->CancelBoostBrightness(DISPLAY_ID, bRet); + EXPECT_FALSE(bRet); } } // namespace diff --git a/state_manager/utils/native/include/display_log.h b/state_manager/utils/native/include/display_log.h index 41a4920..6d702e3 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 #include "hilog/log.h" namespace OHOS { diff --git a/state_manager/interfaces/inner_api/native/include/display_power_mgr_ipc_interface_code.h b/state_manager/utils/native/include/display_xcollie.h similarity index 36% rename from state_manager/interfaces/inner_api/native/include/display_power_mgr_ipc_interface_code.h rename to state_manager/utils/native/include/display_xcollie.h index 66df8f7..32c1fcb 100644 --- a/state_manager/interfaces/inner_api/native/include/display_power_mgr_ipc_interface_code.h +++ b/state_manager/utils/native/include/display_xcollie.h @@ -1,53 +1,36 @@ -/* - * 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_XCOLLIE_H +#define DISPLAY_XCOLLIE_H + +#include +#include + +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_; + bool isCanceled_; +}; +} // 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 0000000..e2f61e5 --- /dev/null +++ b/state_manager/utils/native/src/display_xcollie.cpp @@ -0,0 +1,42 @@ +/* + * 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_ = false; + 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); + 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_) { + HiviewDFX::XCollie::GetInstance().CancelTimer(id_); + isCanceled_ = true; + 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 -- Gitee From ff0bb7ba107b35240d6ccdd8ed63ad95ece4a653 Mon Sep 17 00:00:00 2001 From: yxj Date: Mon, 19 May 2025 15:29:49 +0800 Subject: [PATCH 2/3] =?UTF-8?q?fix:=20code=20review=20Signed-off-by:=20?= =?UTF-8?q?=E5=BC=A0=E5=85=A8=E8=B6=85=20?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- brightness_manager/test/unittest/BUILD.gn | 13 +- .../native/display_power_mgr_client.cpp | 146 +++++++++++--- state_manager/interfaces/inner_api/BUILD.gn | 7 +- state_manager/service/BUILD.gn | 12 +- .../include/display_power_mgr_service.h | 57 +++--- .../native/src/display_power_mgr_service.cpp | 190 ++++++++++-------- .../service/native/src/screen_controller.cpp | 3 +- .../displaycoverage_fuzzer_test.cpp | 3 +- state_manager/test/unittest/BUILD.gn | 2 +- .../include/mock/display_mock_parcel_test.h | 2 + .../src/mock/display_mock_object_test.cpp | 58 ++++-- .../src/mock/display_mock_parcel_test.cpp | 77 +++---- .../unittest/src/mock/display_mock_test.cpp | 58 ++++-- .../utils/native/src/display_xcollie.cpp | 9 +- 14 files changed, 383 insertions(+), 254 deletions(-) diff --git a/brightness_manager/test/unittest/BUILD.gn b/brightness_manager/test/unittest/BUILD.gn index 19490e3..aab1105 100644 --- a/brightness_manager/test/unittest/BUILD.gn +++ b/brightness_manager/test/unittest/BUILD.gn @@ -26,25 +26,14 @@ config("module_private_config") { set_defaults("ohos_unittest") { module_out_path = "display_manager/display_brightness_manager" - sanitize = { - cfi = true - cfi_cross_dso = true - debug = false - } - configs = [ "${brightnessmgr_root_path}:brightness_manager_config", - "${displaymgr_root_path}/service:displaymgr_public_config", "${displaymgr_utils_path}:coverage_flags", "${displaymgr_utils_path}:utils_config", ":module_private_config", ] - deps = [ - "${displaymgr_inner_api}:displaymgr", - "${displaymgr_root_path}/service:displaymgr_proxy", - "${displaymgr_root_path}/service:displaymgr_stub", - ] + deps = [ "${displaymgr_inner_api}:displaymgr" ] external_deps = [ "ability_base:want", diff --git a/state_manager/frameworks/native/display_power_mgr_client.cpp b/state_manager/frameworks/native/display_power_mgr_client.cpp index a4ac1a1..d3cda3e 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 RETCODE_FAIL = -1; +} sptr DisplayPowerMgrClient::GetProxy() { std::lock_guard lock(mutex_); @@ -90,7 +92,10 @@ bool DisplayPowerMgrClient::SetDisplayState(DisplayState state, auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, false); bool result = false; - proxy->SetDisplayState(id, static_cast(state), static_cast(reason), result); + auto ret = proxy->SetDisplayState(id, static_cast(state), static_cast(reason), result); + if (ret != ERR_OK) { + DISPLAY_HILOGE(COMP_FWK, "SetDisplayState, ret = %{public}d", ret); + } return result; } @@ -100,8 +105,11 @@ DisplayState DisplayPowerMgrClient::GetDisplayState(uint32_t id) if (proxy == nullptr) { return DisplayState::DISPLAY_UNKNOWN; } - int32_t displayState = 0; - proxy->GetDisplayState(id, displayState); + int32_t displayState = static_cast(DisplayState::DISPLAY_UNKNOWN); + auto ret = proxy->GetDisplayState(id, displayState); + if (ret != ERR_OK) { + DISPLAY_HILOGE(COMP_FWK, "GetDisplayState, ret = %{public}d", ret); + } return static_cast(displayState); } @@ -112,7 +120,10 @@ std::vector DisplayPowerMgrClient::GetDisplayIds() return {}; } std::vector ids; - proxy->GetDisplayIds(ids); + auto ret = proxy->GetDisplayIds(ids); + if (ret != ERR_OK) { + DISPLAY_HILOGE(COMP_FWK, "GetDisplayIds, ret = %{public}d", ret); + } return ids; } @@ -120,8 +131,11 @@ int32_t DisplayPowerMgrClient::GetMainDisplayId() { auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, INVALID_DISPLAY_ID); - uint32_t id = INVALID_DISPLAY_ID; - proxy->GetMainDisplayId(id); + uint32_t id = 0; + auto ret = proxy->GetMainDisplayId(id); + if (ret != ERR_OK) { + DISPLAY_HILOGE(COMP_FWK, "GetMainDisplayId, ret = %{public}d", ret); + } return id; } @@ -130,7 +144,10 @@ bool DisplayPowerMgrClient::SetBrightness(uint32_t value, uint32_t displayId, bo auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, false); bool result = false; - proxy->SetBrightness(value, displayId, continuous, result); + auto ret = proxy->SetBrightness(value, displayId, continuous, result); + if (ret != ERR_OK) { + DISPLAY_HILOGE(COMP_FWK, "SetBrightness, ret = %{public}d", ret); + } return result; } @@ -139,7 +156,10 @@ bool DisplayPowerMgrClient::DiscountBrightness(double discount, uint32_t display auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, false); bool result = false; - proxy->DiscountBrightness(discount, displayId, result); + auto ret = proxy->DiscountBrightness(discount, displayId, result); + if (ret != ERR_OK) { + DISPLAY_HILOGE(COMP_FWK, "DiscountBrightness, ret = %{public}d", ret); + } return result; } @@ -148,7 +168,10 @@ bool DisplayPowerMgrClient::OverrideBrightness(uint32_t value, uint32_t displayI auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, false); bool result = false; - proxy->OverrideBrightness(value, displayId, duration, result); + auto ret = proxy->OverrideBrightness(value, displayId, duration, result); + if (ret != ERR_OK) { + DISPLAY_HILOGE(COMP_FWK, "OverrideBrightness, ret = %{public}d", ret); + } return result; } @@ -157,7 +180,10 @@ bool DisplayPowerMgrClient::OverrideDisplayOffDelay(uint32_t delayMs) auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, false); bool result = false; - proxy->OverrideDisplayOffDelay(delayMs, result); + auto ret = proxy->OverrideDisplayOffDelay(delayMs, result); + if (ret != ERR_OK) { + DISPLAY_HILOGE(COMP_FWK, "OverrideDisplayOffDelay, ret = %{public}d", ret); + } return result; } @@ -166,7 +192,10 @@ bool DisplayPowerMgrClient::RestoreBrightness(uint32_t displayId, uint32_t durat auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, false); bool result = false; - proxy->RestoreBrightness(displayId, duration, result); + auto ret = proxy->RestoreBrightness(displayId, duration, result); + if (ret != ERR_OK) { + DISPLAY_HILOGE(COMP_FWK, "RestoreBrightness, ret = %{public}d", ret); + } return result; } @@ -175,7 +204,10 @@ uint32_t DisplayPowerMgrClient::GetBrightness(uint32_t displayId) auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, BRIGHTNESS_OFF); uint32_t brightness = BRIGHTNESS_OFF; - proxy->GetBrightness(displayId, brightness); + auto ret = proxy->GetBrightness(displayId, brightness); + if (ret != ERR_OK) { + DISPLAY_HILOGE(COMP_FWK, "GetBrightness, ret = %{public}d", ret); + } return brightness; } @@ -184,7 +216,10 @@ uint32_t DisplayPowerMgrClient::GetDefaultBrightness() auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, BRIGHTNESS_DEFAULT); uint32_t brightness = BRIGHTNESS_DEFAULT; - proxy->GetDefaultBrightness(brightness); + auto ret = proxy->GetDefaultBrightness(brightness); + if (ret != ERR_OK) { + DISPLAY_HILOGE(COMP_FWK, "GetDefaultBrightness, ret = %{public}d", ret); + } return brightness; } @@ -193,7 +228,10 @@ uint32_t DisplayPowerMgrClient::GetMaxBrightness() auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, BRIGHTNESS_MAX); uint32_t brightness = BRIGHTNESS_MAX; - proxy->GetMaxBrightness(brightness); + auto ret = proxy->GetMaxBrightness(brightness); + if (ret != ERR_OK) { + DISPLAY_HILOGE(COMP_FWK, "GetMaxBrightness, ret = %{public}d", ret); + } return brightness; } @@ -202,7 +240,10 @@ uint32_t DisplayPowerMgrClient::GetMinBrightness() auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, BRIGHTNESS_MIN); uint32_t brightness = BRIGHTNESS_MIN; - proxy->GetMinBrightness(brightness); + auto ret = proxy->GetMinBrightness(brightness); + if (ret != ERR_OK) { + DISPLAY_HILOGE(COMP_FWK, "GetMinBrightness, ret = %{public}d", ret); + } return brightness; } @@ -211,7 +252,10 @@ bool DisplayPowerMgrClient::AdjustBrightness(uint32_t value, uint32_t duration, auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, false); bool result = false; - proxy->AdjustBrightness(id, value, duration, result); + auto ret = proxy->AdjustBrightness(id, value, duration, result); + if (ret != ERR_OK) { + DISPLAY_HILOGE(COMP_FWK, "AdjustBrightness, ret = %{public}d", ret); + } return result; } @@ -220,7 +264,10 @@ bool DisplayPowerMgrClient::AutoAdjustBrightness(bool enable) auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, false); bool result = false; - proxy->AutoAdjustBrightness(enable, result); + auto ret = proxy->AutoAdjustBrightness(enable, result); + if (ret != ERR_OK) { + DISPLAY_HILOGE(COMP_FWK, "AutoAdjustBrightness, ret = %{public}d", ret); + } return result; } @@ -229,7 +276,10 @@ bool DisplayPowerMgrClient::IsAutoAdjustBrightness() auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, false); bool result = false; - proxy->IsAutoAdjustBrightness(result); + auto ret = proxy->IsAutoAdjustBrightness(result); + if (ret != ERR_OK) { + DISPLAY_HILOGE(COMP_FWK, "IsAutoAdjustBrightness, ret = %{public}d", ret); + } return result; } @@ -238,7 +288,10 @@ bool DisplayPowerMgrClient::SetScreenOnBrightness() auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, false); bool result = false; - proxy->SetScreenOnBrightness(result); + auto ret = proxy->SetScreenOnBrightness(result); + if (ret != ERR_OK) { + DISPLAY_HILOGE(COMP_FWK, "SetScreenOnBrightness, ret = %{public}d", ret); + } return result; } @@ -252,7 +305,10 @@ bool DisplayPowerMgrClient::RegisterCallback(sptr callbac auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, false); bool result = false; - proxy->RegisterCallback(callback, result); + auto ret = proxy->RegisterCallback(callback, result); + if (ret != ERR_OK) { + DISPLAY_HILOGE(COMP_FWK, "RegisterCallback, ret = %{public}d", ret); + } return result; } @@ -261,7 +317,10 @@ bool DisplayPowerMgrClient::BoostBrightness(int32_t timeoutMs, uint32_t displayI auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, false); bool result = false; - proxy->BoostBrightness(timeoutMs, displayId, result); + auto ret = proxy->BoostBrightness(timeoutMs, displayId, result); + if (ret != ERR_OK) { + DISPLAY_HILOGE(COMP_FWK, "BoostBrightness, ret = %{public}d", ret); + } return result; } @@ -270,7 +329,10 @@ bool DisplayPowerMgrClient::CancelBoostBrightness(uint32_t displayId) auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, false); bool result = false; - proxy->CancelBoostBrightness(displayId, result); + auto ret = proxy->CancelBoostBrightness(displayId, result); + if (ret != ERR_OK) { + DISPLAY_HILOGE(COMP_FWK, "CancelBoostBrightness, ret = %{public}d", ret); + } return result; } @@ -279,7 +341,10 @@ uint32_t DisplayPowerMgrClient::GetDeviceBrightness(uint32_t displayId) auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, 0); uint32_t brightness = BRIGHTNESS_OFF; - proxy->GetDeviceBrightness(displayId, brightness); + auto ret = proxy->GetDeviceBrightness(displayId, brightness); + if (ret != ERR_OK) { + DISPLAY_HILOGE(COMP_FWK, "GetDeviceBrightness, ret = %{public}d", ret); + } return brightness; } @@ -288,7 +353,10 @@ bool DisplayPowerMgrClient::SetCoordinated(bool coordinated, uint32_t displayId) auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, 0); bool result = false; - proxy->SetCoordinated(coordinated, displayId, result); + auto ret = proxy->SetCoordinated(coordinated, displayId, result); + if (ret != ERR_OK) { + DISPLAY_HILOGE(COMP_FWK, "SetCoordinated, ret = %{public}d", ret); + } return result; } @@ -298,7 +366,10 @@ uint32_t DisplayPowerMgrClient::SetLightBrightnessThreshold( auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, 0); uint32_t result = 0; - proxy->SetLightBrightnessThreshold(threshold, callback, result); + auto ret = proxy->SetLightBrightnessThreshold(threshold, callback, result); + if (ret != ERR_OK) { + DISPLAY_HILOGE(COMP_FWK, "SetLightBrightnessThreshold, ret = %{public}d", ret); + } return result; } @@ -312,7 +383,10 @@ DisplayErrors DisplayPowerMgrClient::GetError() auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, DisplayErrors::ERR_CONNECTION_FAIL); int32_t errCode = ERR_OK; - proxy->GetError(errCode); + auto ret = proxy->GetError(errCode); + if (ret != ERR_OK) { + DISPLAY_HILOGE(COMP_FWK, "GetError, ret = %{public}d", ret); + } return static_cast(errCode); } @@ -321,7 +395,10 @@ bool DisplayPowerMgrClient::SetMaxBrightness(double value, uint32_t enterTestMod auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, false); bool result = false; - proxy->SetMaxBrightness(value, enterTestMode, result); + auto ret = proxy->SetMaxBrightness(value, enterTestMode, result); + if (ret != ERR_OK) { + DISPLAY_HILOGE(COMP_FWK, "SetMaxBrightness, ret = %{public}d", ret); + } return result; } @@ -330,7 +407,10 @@ bool DisplayPowerMgrClient::SetMaxBrightnessNit(uint32_t maxNit, uint32_t enterT auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, false); bool result = false; - proxy->SetMaxBrightnessNit(maxNit, enterTestMode, result); + auto ret = proxy->SetMaxBrightnessNit(maxNit, enterTestMode, result); + if (ret != ERR_OK) { + DISPLAY_HILOGE(COMP_FWK, "SetMaxBrightnessNit, ret = %{public}d", ret); + } return result; } @@ -338,8 +418,12 @@ int DisplayPowerMgrClient::NotifyBrightnessManagerScreenPowerStatus(uint32_t dis { auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, -1); // -1 means failed - int32_t result = 0; - proxy->NotifyScreenPowerStatus(displayId, status, result); + int32_t result = RETCODE_FAIL; + auto ret = proxy->NotifyScreenPowerStatus(displayId, status, result); + if (ret != ERR_OK) { + DISPLAY_HILOGE(COMP_FWK, "NotifyBrightnessManagerScreenPowerStatus, ret = %{public}d", ret); + lastError_ = static_cast(result); + } return result; } diff --git a/state_manager/interfaces/inner_api/BUILD.gn b/state_manager/interfaces/inner_api/BUILD.gn index df2af05..686c6b1 100644 --- a/state_manager/interfaces/inner_api/BUILD.gn +++ b/state_manager/interfaces/inner_api/BUILD.gn @@ -31,7 +31,11 @@ ohos_shared_library("displaymgr") { cfi_cross_dso = true debug = false } - sources = [ "${displaymgr_framework_path}/native/display_power_mgr_client.cpp" ] + 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", + ] configs = [ ":displaymgr_private_config", @@ -46,7 +50,6 @@ ohos_shared_library("displaymgr") { deps = [ "${displaymgr_root_path}/service:displaymgr_proxy", - "${displaymgr_root_path}/service:displaymgr_stub", ] external_deps = [ "c_utils:utils", diff --git a/state_manager/service/BUILD.gn b/state_manager/service/BUILD.gn index 120add9..6afd005 100644 --- a/state_manager/service/BUILD.gn +++ b/state_manager/service/BUILD.gn @@ -128,11 +128,6 @@ ohos_source_set("displaymgr_proxy") { output_values = get_target_outputs(":displaymgr_interface") sources = filter_include(output_values, [ "*_proxy.cpp" ]) - sources += [ - "zidl/src/display_brightness_callback_proxy.cpp", - "zidl/src/display_power_callback_proxy.cpp", - ] - configs = [ "${displaymgr_utils_path}:utils_config", ":displaymgr_private_config", @@ -161,12 +156,7 @@ ohos_source_set("displaymgr_stub") { } output_values = get_target_outputs(":displaymgr_interface") sources = filter_include(output_values, [ "*_stub.cpp" ]) - sources += [ - "zidl/src/display_brightness_callback_stub.cpp", - "zidl/src/display_power_callback_stub.cpp", - ] - - + configs = [ "${displaymgr_utils_path}:utils_config", ":displaymgr_private_config", 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 c38649a..14e6abc 100644 --- a/state_manager/service/native/include/display_power_mgr_service.h +++ b/state_manager/service/native/include/display_power_mgr_service.h @@ -75,34 +75,36 @@ public: int32_t GetError(int32_t& errorCode) override; int32_t SetScreenOnBrightness(bool& result) override; int32_t NotifyScreenPowerStatus(uint32_t displayId, uint32_t displayPowerStatus, int32_t& result) override; - - virtual bool SetDisplayState(uint32_t id, DisplayState state, uint32_t reason); - virtual DisplayState GetDisplayState(uint32_t id); - virtual std::vector GetDisplayIds(); - virtual uint32_t GetMainDisplayId(); - virtual bool SetBrightness(uint32_t value, uint32_t displayId, bool continuous = false); - virtual bool SetMaxBrightness(double value, uint32_t mode); - virtual bool SetMaxBrightnessNit(uint32_t maxNit, uint32_t mode); - virtual bool DiscountBrightness(double discount, uint32_t displayId); - virtual bool OverrideBrightness(uint32_t value, uint32_t displayId, uint32_t duration = 500); - virtual bool OverrideDisplayOffDelay(uint32_t delayMs); - virtual bool RestoreBrightness(uint32_t displayId, uint32_t duration = 500); - virtual uint32_t GetBrightness(uint32_t displayId); - virtual uint32_t GetDefaultBrightness(); - virtual uint32_t GetMaxBrightness(); - virtual uint32_t GetMinBrightness(); - virtual bool AdjustBrightness(uint32_t id, int32_t value, uint32_t duration); - virtual bool AutoAdjustBrightness(bool enable); - virtual bool IsAutoAdjustBrightness(); - virtual bool SetScreenOnBrightness(); - virtual bool RegisterCallback(sptr callback); - virtual bool BoostBrightness(int32_t timeoutMs, uint32_t displayId); - virtual bool CancelBoostBrightness(uint32_t displayId); - virtual uint32_t GetDeviceBrightness(uint32_t displayId); - virtual bool SetCoordinated(bool coordinated, uint32_t displayId); - virtual uint32_t SetLightBrightnessThreshold( +private: + bool SetDisplayStateInner(uint32_t id, DisplayState state, uint32_t reason); + DisplayState GetDisplayStateInner(uint32_t id); + std::vector 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 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 threshold, sptr callback); - virtual DisplayErrors GetError(); + DisplayErrors GetErrorInner(); + int NotifyScreenPowerStatusInner(uint32_t displayId, uint32_t displayPowerStatus); +public: virtual int32_t Dump(int32_t fd, const std::vector& args) override; void NotifyStateChangeCallback(uint32_t displayId, DisplayState state, uint32_t reason); void Init(); @@ -112,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); 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 12b1457..0d0b648 100644 --- a/state_manager/service/native/src/display_power_mgr_service.cpp +++ b/state_manager/service/native/src/display_power_mgr_service.cpp @@ -131,13 +131,19 @@ void DisplayPowerMgrService::HandleBootBrightness() void DisplayPowerMgrService::SetBootCompletedBrightness() { - uint32_t mainDisplayId = DelayedSpSingleton::GetInstance()->GetMainDisplayId(); - uint32_t brightness = DelayedSpSingleton::GetInstance()->GetBrightness(mainDisplayId); + uint32_t mainDisplayId = 0; + DelayedSpSingleton::GetInstance()->GetMainDisplayId(mainDisplayId); + uint32_t brightness = BRIGHTNESS_OFF; + DelayedSpSingleton::GetInstance()->GetBrightness(mainDisplayId, brightness); uint32_t currentDisplayId = BrightnessManager::Get().GetCurrentDisplayId(mainDisplayId); - DisplayState state = DelayedSpSingleton::GetInstance()->GetDisplayState(mainDisplayId); + int32_t state = static_cast(DisplayState::DISPLAY_UNKNOWN); + DelayedSpSingleton::GetInstance()->GetDisplayState(mainDisplayId, state); + BrightnessManager::Get().SetDisplayId(currentDisplayId); - BrightnessManager::Get().SetDisplayState(currentDisplayId, state, 0); - DelayedSpSingleton::GetInstance()->SetBrightness(brightness, mainDisplayId); + BrightnessManager::Get().SetDisplayState(currentDisplayId, static_cast(state), 0); + bool result = false; + DelayedSpSingleton::GetInstance()->SetBrightness(brightness, mainDisplayId, false, + result); DISPLAY_HILOGI(FEAT_BRIGHTNESS, "SetBootCompletedBrightness currentDisplayId=%{public}d", currentDisplayId); } @@ -145,13 +151,15 @@ void DisplayPowerMgrService::SetBootCompletedAutoBrightness() { bool enable = GetSettingAutoBrightness(); DISPLAY_HILOGI(FEAT_BRIGHTNESS, "SetBootCompletedAutoBrightness enable=%{public}d", enable); - DelayedSpSingleton::GetInstance()->AutoAdjustBrightness(enable); + bool result = false; + DelayedSpSingleton::GetInstance()->AutoAdjustBrightness(enable, result); BrightnessManager::Get().AutoAdjustBrightness(enable); } void DisplayPowerMgrService::RegisterSettingObservers() { - uint32_t mainDisplayId = DelayedSpSingleton::GetInstance()->GetMainDisplayId(); + uint32_t mainDisplayId = 0; + DelayedSpSingleton::GetInstance()->GetMainDisplayId(mainDisplayId); auto controllerMap = DelayedSpSingleton::GetInstance()->controllerMap_; auto iter = controllerMap.find(mainDisplayId); if (iter != controllerMap.end()) { @@ -162,7 +170,8 @@ void DisplayPowerMgrService::RegisterSettingObservers() void DisplayPowerMgrService::UnregisterSettingObservers() { - uint32_t mainDisplayId = DelayedSpSingleton::GetInstance()->GetMainDisplayId(); + uint32_t mainDisplayId = 0; + DelayedSpSingleton::GetInstance()->GetMainDisplayId(mainDisplayId); auto controllerMap = DelayedSpSingleton::GetInstance()->controllerMap_; auto iter = controllerMap.find(mainDisplayId); if (iter != controllerMap.end()) { @@ -180,20 +189,22 @@ void DisplayPowerMgrService::RegisterSettingAutoBrightnessObserver() void DisplayPowerMgrService::AutoBrightnessSettingUpdateFunc(const std::string& key) { bool isSettingEnable = GetSettingAutoBrightness(key); - bool isSystemEnable = DelayedSpSingleton::GetInstance()->IsAutoAdjustBrightness(); + bool isSystemEnable = false; + DelayedSpSingleton::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::GetInstance()->AutoAdjustBrightness(isSettingEnable); + bool result = false; + DelayedSpSingleton::GetInstance()->AutoAdjustBrightness(isSettingEnable, result); if (!isSettingEnable) { DelayedSpSingleton::GetInstance()->ClearOffset(); } } -bool DisplayPowerMgrService::SetScreenOnBrightness() +bool DisplayPowerMgrService::SetScreenOnBrightnessInner() { BrightnessManager::Get().SetScreenOnBrightness(); return true; @@ -229,7 +240,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; @@ -240,7 +251,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; @@ -277,7 +288,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); @@ -285,7 +296,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; @@ -294,24 +305,23 @@ DisplayState DisplayPowerMgrService::GetDisplayState(uint32_t id) return iterator->second->GetState(); } -std::vector DisplayPowerMgrService::GetDisplayIds() +std::vector DisplayPowerMgrService::GetDisplayIdsInner() { std::vector ids; - auto ret = GetDisplayIds(ids); - if (ret != ERR_OK) { - DISPLAY_HILOGI(COMP_SVC, "[UL_POWER] GetDisplayIds ret = %{public}d", ret); + for (auto& iter: controllerMap_) { + ids.push_back(iter.first); } 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; @@ -324,7 +334,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; @@ -336,7 +346,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; @@ -350,12 +360,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_; } @@ -366,7 +376,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; @@ -384,7 +394,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); @@ -394,22 +404,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; @@ -427,7 +437,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; @@ -496,12 +506,12 @@ void DisplayPowerMgrService::DeactivateAmbientSensor() } #endif -bool DisplayPowerMgrService::IsAutoAdjustBrightness() +bool DisplayPowerMgrService::IsAutoAdjustBrightnessInner() { return autoBrightness_; } -bool DisplayPowerMgrService::RegisterCallback(sptr callback) +bool DisplayPowerMgrService::RegisterCallbackInner(sptr callback) { if (!Permission::IsSystem()) { return false; @@ -525,7 +535,7 @@ bool DisplayPowerMgrService::RegisterCallback(sptr 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; @@ -537,7 +547,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; @@ -552,7 +562,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); @@ -562,7 +572,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; @@ -574,7 +584,7 @@ bool DisplayPowerMgrService::SetCoordinated(bool coordinated, uint32_t displayId return true; } -uint32_t DisplayPowerMgrService::SetLightBrightnessThreshold( +uint32_t DisplayPowerMgrService::SetLightBrightnessThresholdInner( std::vector threshold, sptr callback) { if (!Permission::IsSystem()) { @@ -641,9 +651,9 @@ int32_t DisplayPowerMgrService::Dump(int32_t fd, const std::vectorGetMainDisplayId(); + uint32_t mainDispId = 0; + pms->GetMainDisplayId(mainDispId); auto mainDisp = pms->controllerMap_.find(mainDispId); if (mainDisp == pms->controllerMap_.end()) { return; @@ -703,7 +714,8 @@ void DisplayPowerMgrService::AmbientLightCallback(SensorEvent* event) if (pms->CalculateBrightness(data->intensity, brightness, changeBrightness)) { double discountStride = static_cast(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); } } @@ -824,7 +836,7 @@ int32_t DisplayPowerMgrService::GetBrightnessFromLightScalar(float scalar) return static_cast(brightness); } -DisplayErrors DisplayPowerMgrService::GetError() +DisplayErrors DisplayPowerMgrService::GetErrorInner() { DisplayErrors tmpError = lastError_; lastError_ = DisplayErrors::ERR_OK; @@ -852,7 +864,7 @@ void DisplayPowerMgrService::CallbackDeathRecipient::OnRemoteDied(const wptr(state), reason); + DisplayXCollie displayXCollie("DisplayPowerMgrService::SetDisplayState"); + result = SetDisplayStateInner(id, static_cast(state), reason); return ERR_OK; } int32_t DisplayPowerMgrService::GetDisplayState(uint32_t id, int32_t& displayState) { - DisplayXCollie displayXCollie("DisplayPowerMgrService::GetDisplayState", false); - displayState = static_cast(GetDisplayState(id)); + DisplayXCollie displayXCollie("DisplayPowerMgrService::GetDisplayState"); + displayState = static_cast(GetDisplayStateInner(id)); return ERR_OK; } int32_t DisplayPowerMgrService::GetDisplayIds(std::vector& ids) { - DisplayXCollie displayXCollie("DisplayPowerMgrService::GetDisplayIds", false); - for (auto& iter: controllerMap_) { - ids.push_back(iter.first); - } + 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", false); - id = GetMainDisplayId(); + DisplayXCollie displayXCollie("DisplayPowerMgrService::GetMainDisplayId"); + id = GetMainDisplayIdInner(); return ERR_OK; } int32_t DisplayPowerMgrService::SetBrightness(uint32_t value, uint32_t displayId, bool continuous, bool& result) { - DisplayXCollie displayXCollie("DisplayPowerMgrService::SetBrightness", false); - result = SetBrightness(value, displayId, continuous); + DisplayXCollie displayXCollie("DisplayPowerMgrService::SetBrightness"); + result = SetBrightnessInner(value, displayId, continuous); return ERR_OK; } int32_t DisplayPowerMgrService::DiscountBrightness(double discount, uint32_t displayId, bool& result) { - DisplayXCollie displayXCollie("DisplayPowerMgrService::DiscountBrightness", false); - result = DiscountBrightness(discount, displayId); + 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", false); - result = OverrideBrightness(brightness, displayId, duration); + 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", false); - result = OverrideDisplayOffDelay(delayMs); + 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", false); - result = RestoreBrightness(displayId, duration); + 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", false); - brightness = GetBrightness(displayId); + DisplayXCollie displayXCollie("DisplayPowerMgrService::GetBrightness"); + brightness = GetBrightnessInner(displayId); return ERR_OK; } int32_t DisplayPowerMgrService::GetDefaultBrightness(uint32_t& defaultBrightness) { - defaultBrightness = GetDefaultBrightness(); + DisplayXCollie displayXCollie("DisplayPowerMgrService::GetDefaultBrightness"); + defaultBrightness = GetDefaultBrightnessInner(); return ERR_OK; } int32_t DisplayPowerMgrService::GetMaxBrightness(uint32_t& maxBrightness) { - maxBrightness = GetMaxBrightness(); + DisplayXCollie displayXCollie("DisplayPowerMgrService::GetMaxBrightness"); + maxBrightness = GetMaxBrightnessInner(); return ERR_OK; } int32_t DisplayPowerMgrService::GetMinBrightness(uint32_t& minBrightness) { - minBrightness = GetMinBrightness(); + 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 = AdjustBrightness(id, value, duration); + result = AdjustBrightnessInner(id, value, duration); return ERR_OK; } int32_t DisplayPowerMgrService::AutoAdjustBrightness(bool enable, bool& result) { DisplayXCollie displayXCollie("DisplayPowerMgrService::AutoAdjustBrightness"); - result = AutoAdjustBrightness(enable); + result = AutoAdjustBrightnessInner(enable); return ERR_OK; } int32_t DisplayPowerMgrService::IsAutoAdjustBrightness(bool& result) { - result = IsAutoAdjustBrightness(); + DisplayXCollie displayXCollie("DisplayPowerMgrService::IsAutoAdjustBrightness"); + result = IsAutoAdjustBrightnessInner(); return ERR_OK; } int32_t DisplayPowerMgrService::RegisterCallback(const sptr& callback, bool& result) { DisplayXCollie displayXCollie("DisplayPowerMgrService::RegisterCallback"); - result = RegisterCallback(callback); + result = RegisterCallbackInner(callback); return ERR_OK; } int32_t DisplayPowerMgrService::BoostBrightness(int32_t timeoutMs, uint32_t displayId, bool& result) { DisplayXCollie displayXCollie("DisplayPowerMgrService::BoostBrightness"); - result = BoostBrightness(timeoutMs, displayId); + result = BoostBrightnessInner(timeoutMs, displayId); return ERR_OK; } int32_t DisplayPowerMgrService::CancelBoostBrightness(uint32_t displayId, bool& result) { DisplayXCollie displayXCollie("DisplayPowerMgrService::CancelBoostBrightness"); - result = CancelBoostBrightness(displayId); + result = CancelBoostBrightnessInner(displayId); return ERR_OK; } int32_t DisplayPowerMgrService::GetDeviceBrightness(uint32_t displayId, uint32_t& deviceBrightness) { DisplayXCollie displayXCollie("DisplayPowerMgrService::GetDeviceBrightness"); - deviceBrightness = GetDeviceBrightness(displayId); + deviceBrightness = GetDeviceBrightnessInner(displayId); return ERR_OK; } int32_t DisplayPowerMgrService::SetCoordinated(bool coordinated, uint32_t displayId, bool& result) { DisplayXCollie displayXCollie("DisplayPowerMgrService::SetCoordinated"); - result = SetCoordinated(coordinated, displayId); + result = SetCoordinatedInner(coordinated, displayId); return ERR_OK; } @@ -1067,34 +1082,35 @@ int32_t DisplayPowerMgrService::SetLightBrightnessThreshold(const std::vector& callback, uint32_t& result) { DisplayXCollie displayXCollie("DisplayPowerMgrService::SetLightBrightnessThreshold"); - result = SetLightBrightnessThreshold(threshold, callback); + result = SetLightBrightnessThresholdInner(threshold, callback); return ERR_OK; } int32_t DisplayPowerMgrService::GetError(int32_t& errorCode) { - errorCode = static_cast(GetError()); + DisplayXCollie displayXCollie("DisplayPowerMgrService::GetError"); + errorCode = static_cast(GetErrorInner()); return ERR_OK; } int32_t DisplayPowerMgrService::SetMaxBrightness(double value, uint32_t mode, bool& result) { DisplayXCollie displayXCollie("DisplayPowerMgrService::SetMaxBrightness"); - result = SetMaxBrightness(value, mode); + result = SetMaxBrightnessInner(value, mode); return ERR_OK; } int32_t DisplayPowerMgrService::SetMaxBrightnessNit(uint32_t maxNit, uint32_t mode, bool& result) { DisplayXCollie displayXCollie("DisplayPowerMgrService::SetMaxBrightnessNit"); - result = SetMaxBrightnessNit(maxNit, mode); + result = SetMaxBrightnessNitInner(maxNit, mode); return ERR_OK; } int32_t DisplayPowerMgrService::SetScreenOnBrightness(bool& result) { DisplayXCollie displayXCollie("DisplayPowerMgrService::SetScreenOnBrightness"); - result = SetScreenOnBrightness(); + result = SetScreenOnBrightnessInner(); return ERR_OK; } @@ -1102,7 +1118,7 @@ int32_t DisplayPowerMgrService::NotifyScreenPowerStatus(uint32_t displayId, uint int32_t& result) { DisplayXCollie displayXCollie("DisplayPowerMgrService::NotifyScreenPowerStatus"); - result = NotifyScreenPowerStatus(displayId, displayPowerStatus); + result = NotifyScreenPowerStatusInner(displayId, displayPowerStatus); return ERR_OK; } } // namespace DisplayPowerMgr diff --git a/state_manager/service/native/src/screen_controller.cpp b/state_manager/service/native/src/screen_controller.cpp index 6b62c1c..c763c1e 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/test/fuzztest/displaycoverage_fuzzer/displaycoverage_fuzzer_test.cpp b/state_manager/test/fuzztest/displaycoverage_fuzzer/displaycoverage_fuzzer_test.cpp index 77a1c2d..fd9af44 100644 --- a/state_manager/test/fuzztest/displaycoverage_fuzzer/displaycoverage_fuzzer_test.cpp +++ b/state_manager/test/fuzztest/displaycoverage_fuzzer/displaycoverage_fuzzer_test.cpp @@ -41,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/unittest/BUILD.gn b/state_manager/test/unittest/BUILD.gn index 6168992..f2c2262 100644 --- a/state_manager/test/unittest/BUILD.gn +++ b/state_manager/test/unittest/BUILD.gn @@ -147,7 +147,7 @@ ohos_unittest("display_mock_parcel_test") { "${displaymgr_root_path}/service:displaymgr_proxy", ] external_deps = [ "googletest:gtest_main" ] - external_deps = deps_ex + external_deps += deps_ex } ############################display_mock_test############################# 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 e3e07a7..6e728ef 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& sptrDisplayProxy); + static void DisplayProxyBrightnessTestFunc(std::shared_ptr& + sptrDisplayProxy); class DisplayPowerMgrTestCallback : public OHOS::DisplayPowerMgr::DisplayPowerCallbackStub { public: DisplayPowerMgrTestCallback() {}; 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 fd26907..48fce0e 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 @@ -38,6 +38,7 @@ 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( @@ -58,50 +59,65 @@ HWTEST_F(DisplayMockObjectTest, DisplayMockObjectTest_001, TestSize.Level0) sptr sptrRemoteObj = new MockDisplayRemoteObject(); auto sptrDisplayProxy = std::make_shared(sptrRemoteObj); bool bRet = false; - sptrDisplayProxy->SetDisplayState(DISPLAY_ID, static_cast(DisplayPowerMgr::DisplayState::DISPLAY_ON), - REASON, bRet); + EXPECT_NE(sptrDisplayProxy->SetDisplayState(DISPLAY_ID, + static_cast(DisplayPowerMgr::DisplayState::DISPLAY_ON), REASON, bRet), ERR_OK); EXPECT_FALSE(bRet); int32_t state = 0; - sptrDisplayProxy->GetDisplayState(DISPLAY_ID, state); + EXPECT_NE(sptrDisplayProxy->GetDisplayState(DISPLAY_ID, state), ERR_OK); EXPECT_NE(DisplayPowerMgr::DisplayState::DISPLAY_ON, DisplayPowerMgr::DisplayState(state)); std::vector result; result.push_back(DISPLAY_ID); std::vector ids; - sptrDisplayProxy->GetDisplayIds(ids); + EXPECT_NE(sptrDisplayProxy->GetDisplayIds(ids), ERR_OK); EXPECT_NE(result, ids); uint32_t id = 0; - sptrDisplayProxy->GetMainDisplayId(id); + EXPECT_NE(sptrDisplayProxy->GetMainDisplayId(id), ERR_OK); EXPECT_EQ(MAIN_ID_PROXY, id); - sptrDisplayProxy->SetBrightness(BRIGHTNESS_SETTING_VALUE, DISPLAY_ID, false, bRet); +} + +/** + * @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) +{ + sptr sptrRemoteObj = new MockDisplayRemoteObject(); + auto sptrDisplayProxy = std::make_shared(sptrRemoteObj); + bool bRet = false; + uint32_t brightness = 0; + EXPECT_NE(sptrDisplayProxy->SetBrightness(BRIGHTNESS_SETTING_VALUE, DISPLAY_ID, false, bRet), ERR_OK); EXPECT_FALSE(bRet); - sptrDisplayProxy->DiscountBrightness(DISCOUNT_VALUE, DISPLAY_ID, bRet); + EXPECT_NE(sptrDisplayProxy->DiscountBrightness(DISCOUNT_VALUE, DISPLAY_ID, bRet), ERR_OK); EXPECT_FALSE(bRet); - sptrDisplayProxy->OverrideBrightness(BRIGHTNESS_OVERRIDE_VALUE, DISPLAY_ID, DEFAULT_DURATION, bRet); + EXPECT_NE(sptrDisplayProxy->OverrideBrightness(BRIGHTNESS_OVERRIDE_VALUE, DISPLAY_ID, DEFAULT_DURATION, bRet), + ERR_OK); EXPECT_FALSE(bRet); - sptrDisplayProxy->RestoreBrightness(DISPLAY_ID, DEFAULT_DURATION, bRet); + EXPECT_NE(sptrDisplayProxy->RestoreBrightness(DISPLAY_ID, DEFAULT_DURATION, bRet), ERR_OK); EXPECT_FALSE(bRet); - uint32_t brightness = 0; - sptrDisplayProxy->GetBrightness(DISPLAY_ID, brightness); + EXPECT_NE(sptrDisplayProxy->GetBrightness(DISPLAY_ID, brightness), ERR_OK); EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness); - sptrDisplayProxy->GetDeviceBrightness(DISPLAY_ID, brightness); + EXPECT_NE(sptrDisplayProxy->GetDeviceBrightness(DISPLAY_ID, brightness), ERR_OK); EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness); - sptrDisplayProxy->GetDefaultBrightness(brightness); + EXPECT_NE(sptrDisplayProxy->GetDefaultBrightness(brightness), ERR_OK); EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness); - sptrDisplayProxy->GetMaxBrightness(brightness); + EXPECT_NE(sptrDisplayProxy->GetMaxBrightness(brightness), ERR_OK); EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness); - sptrDisplayProxy->GetMinBrightness(brightness); + EXPECT_NE(sptrDisplayProxy->GetMinBrightness(brightness), ERR_OK); EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness); - sptrDisplayProxy->AdjustBrightness(DISPLAY_ID, BRIGHTNESS_ADJUST_VALUE, BRIGHTNESS_DURATION, bRet); + EXPECT_NE(sptrDisplayProxy->AdjustBrightness(DISPLAY_ID, BRIGHTNESS_ADJUST_VALUE, BRIGHTNESS_DURATION, bRet), + ERR_OK); EXPECT_FALSE(bRet); - sptrDisplayProxy->AutoAdjustBrightness(true, bRet); + EXPECT_NE(sptrDisplayProxy->AutoAdjustBrightness(true, bRet), ERR_OK); EXPECT_FALSE(bRet); - sptrDisplayProxy->AutoAdjustBrightness(false, bRet); + EXPECT_NE(sptrDisplayProxy->AutoAdjustBrightness(false, bRet), ERR_OK); EXPECT_FALSE(bRet); - sptrDisplayProxy->IsAutoAdjustBrightness(bRet); + EXPECT_NE(sptrDisplayProxy->IsAutoAdjustBrightness(bRet), ERR_OK); EXPECT_FALSE(bRet); - sptrDisplayProxy->BoostBrightness(TIMEOUT_MS, DISPLAY_ID, bRet); + EXPECT_NE(sptrDisplayProxy->BoostBrightness(TIMEOUT_MS, DISPLAY_ID, bRet), ERR_OK); EXPECT_FALSE(bRet); - sptrDisplayProxy->CancelBoostBrightness(DISPLAY_ID, bRet); + EXPECT_NE(sptrDisplayProxy->CancelBoostBrightness(DISPLAY_ID, bRet), ERR_OK); EXPECT_FALSE(bRet); } } //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 36b83b6..e904040 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 @@ -51,54 +51,63 @@ 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::DisplayProxyTestFunc(std::shared_ptr& sptrDisplayProxy) +void DisplayMockParcelTest::DisplayProxyBrightnessTestFunc(std::shared_ptr& sptrDisplayProxy) { - std::vector result; - result.push_back(DISPLAY_ID); bool ret = false; - sptrDisplayProxy->SetDisplayState(DISPLAY_ID, - static_cast(DisplayPowerMgr::DisplayState::DISPLAY_ON), REASON, ret); - EXPECT_FALSE(ret); - int32_t state = 0; - sptrDisplayProxy->GetDisplayState(DISPLAY_ID, state); - EXPECT_NE(DisplayPowerMgr::DisplayState::DISPLAY_ON, DisplayPowerMgr::DisplayState(state)); - std::vector ids; - sptrDisplayProxy->GetDisplayIds(ids); - EXPECT_NE(result, ids); - uint32_t mainId = MAIN_ID_PROXY; - sptrDisplayProxy->GetMainDisplayId(mainId); - EXPECT_EQ(MAIN_ID_PROXY, mainId); - sptrDisplayProxy->SetBrightness(BRIGHTNESS_SETTING_VALUE, DISPLAY_ID, false, ret); + EXPECT_NE(sptrDisplayProxy->SetBrightness(BRIGHTNESS_SETTING_VALUE, DISPLAY_ID, false, ret), ERR_OK); EXPECT_FALSE(ret); - sptrDisplayProxy->DiscountBrightness(DISCOUNT_VALUE, DISPLAY_ID, ret); + EXPECT_NE(sptrDisplayProxy->DiscountBrightness(DISCOUNT_VALUE, DISPLAY_ID, ret), ERR_OK); EXPECT_FALSE(ret); - sptrDisplayProxy->OverrideBrightness(BRIGHTNESS_OVERRIDE_VALUE, DISPLAY_ID, DEFAULT_DURATION, ret); + EXPECT_NE(sptrDisplayProxy->OverrideBrightness(BRIGHTNESS_OVERRIDE_VALUE, DISPLAY_ID, DEFAULT_DURATION, ret), + ERR_OK); EXPECT_FALSE(ret); - sptrDisplayProxy->RestoreBrightness(DISPLAY_ID, DEFAULT_DURATION, ret); + EXPECT_NE(sptrDisplayProxy->RestoreBrightness(DISPLAY_ID, DEFAULT_DURATION, ret), ERR_OK); EXPECT_FALSE(ret); uint32_t brightness = 0; - sptrDisplayProxy->GetBrightness(DISPLAY_ID, brightness); + EXPECT_NE(sptrDisplayProxy->GetBrightness(DISPLAY_ID, brightness), ERR_OK); EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness); - sptrDisplayProxy->GetDefaultBrightness(brightness); + EXPECT_NE(sptrDisplayProxy->GetDefaultBrightness(brightness), ERR_OK); EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness); - sptrDisplayProxy->GetMaxBrightness(brightness); + EXPECT_NE(sptrDisplayProxy->GetMaxBrightness(brightness), ERR_OK); EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness); - sptrDisplayProxy->GetMinBrightness(brightness); + EXPECT_NE(sptrDisplayProxy->GetMinBrightness(brightness), ERR_OK); EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness); - sptrDisplayProxy->AdjustBrightness(DISPLAY_ID, BRIGHTNESS_ADJUST_VALUE, BRIGHTNESS_DURATION, ret); + 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); - sptrDisplayProxy->AutoAdjustBrightness(true, ret); + EXPECT_NE(sptrDisplayProxy->AutoAdjustBrightness(false, ret), ERR_OK); EXPECT_FALSE(ret); - sptrDisplayProxy->AutoAdjustBrightness(false, ret); + EXPECT_NE(sptrDisplayProxy->IsAutoAdjustBrightness(ret), ERR_OK); EXPECT_FALSE(ret); - sptrDisplayProxy->IsAutoAdjustBrightness(ret); + EXPECT_NE(sptrDisplayProxy->BoostBrightness(TIMEOUT_MS, DISPLAY_ID, ret), ERR_OK); EXPECT_FALSE(ret); - sptrDisplayProxy->BoostBrightness(TIMEOUT_MS, DISPLAY_ID, ret); + EXPECT_NE(sptrDisplayProxy->CancelBoostBrightness(DISPLAY_ID, ret), ERR_OK); EXPECT_FALSE(ret); - sptrDisplayProxy->CancelBoostBrightness(DISPLAY_ID, ret); +} + +void DisplayMockParcelTest::DisplayProxyTestFunc(std::shared_ptr& sptrDisplayProxy) +{ + std::vector result; + result.push_back(DISPLAY_ID); + bool ret = false; + EXPECT_NE(sptrDisplayProxy->SetDisplayState(DISPLAY_ID, + static_cast(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 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( @@ -156,11 +165,11 @@ HWTEST_F(DisplayMockParcelTest, DisplayMockParcelTest_002, TestSize.Level0) DisplayMockParcelTest::DisplayProxyTestFunc(sptrDisplayProxy); uint32_t brightness = BRIGHTNESS_NONE_VALUE; - sptrDisplayProxy->GetDeviceBrightness(DISPLAY_ID, brightness); + EXPECT_NE(sptrDisplayProxy->GetDeviceBrightness(DISPLAY_ID, brightness), ERR_OK); EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness); bool result = false; - sptrDisplayProxy->RegisterCallback(callbackPtr, result); + EXPECT_NE(sptrDisplayProxy->RegisterCallback(callbackPtr, result), ERR_OK); EXPECT_FALSE(result); DISPLAY_HILOGD(LABEL_TEST, "DisplayMockParcelTest_002: fun is end"); } @@ -177,7 +186,7 @@ HWTEST_F(DisplayMockParcelTest, DisplayMockParcelTest_003, TestSize.Level0) auto sptrDisplayProxy = std::make_shared(nullptr); sptr callbackPtr = new DisplayMockParcelTest::DisplayPowerMgrTestCallback(); bool result = false; - sptrDisplayProxy->RegisterCallback(callbackPtr, result); + EXPECT_NE(sptrDisplayProxy->RegisterCallback(callbackPtr, result), ERR_OK); EXPECT_FALSE(result); DISPLAY_HILOGD(LABEL_TEST, "DisplayMockParcelTest_003: fun is end"); } @@ -198,11 +207,11 @@ HWTEST_F(DisplayMockParcelTest, DisplayMockParcelTest_004, TestSize.Level0) DisplayMockParcelTest::DisplayProxyTestFunc(sptrDisplayProxy); uint32_t brightness = 0; - sptrDisplayProxy->GetDeviceBrightness(DISPLAY_ID, brightness); + EXPECT_NE(sptrDisplayProxy->GetDeviceBrightness(DISPLAY_ID, brightness), ERR_OK); EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness); bool result = false; - sptrDisplayProxy->RegisterCallback(callbackPtr, result); + EXPECT_NE(sptrDisplayProxy->RegisterCallback(callbackPtr, result), ERR_OK); EXPECT_FALSE(result); DISPLAY_HILOGD(LABEL_TEST, "DisplayMockParcelTest_004: fun is 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 68c684b..2562294 100644 --- a/state_manager/test/unittest/src/mock/display_mock_test.cpp +++ b/state_manager/test/unittest/src/mock/display_mock_test.cpp @@ -48,6 +48,7 @@ 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( @@ -103,50 +104,65 @@ HWTEST_F(DisplayMockTest, DisplayMockTest_003, TestSize.Level0) sptr sptrRemoteObj = new MockDisplayRemoteObject(); auto sptrDisplayProxy = std::make_shared(sptrRemoteObj); bool bRet = false; - sptrDisplayProxy->SetDisplayState(DISPLAY_ID, static_cast(DisplayPowerMgr::DisplayState::DISPLAY_ON), - REASON, bRet); + EXPECT_NE(sptrDisplayProxy->SetDisplayState(DISPLAY_ID, + static_cast(DisplayPowerMgr::DisplayState::DISPLAY_ON), REASON, bRet), ERR_OK); EXPECT_FALSE(bRet); int32_t state = 0; - sptrDisplayProxy->GetDisplayState(DISPLAY_ID, state); + EXPECT_NE(sptrDisplayProxy->GetDisplayState(DISPLAY_ID, state), ERR_OK); EXPECT_NE(DisplayPowerMgr::DisplayState::DISPLAY_ON, DisplayPowerMgr::DisplayState(state)); std::vector result; result.push_back(DISPLAY_ID); std::vector ids; - sptrDisplayProxy->GetDisplayIds(ids); + EXPECT_NE(sptrDisplayProxy->GetDisplayIds(ids), ERR_OK); EXPECT_NE(result, ids); uint32_t id = 0; - sptrDisplayProxy->GetMainDisplayId(id); + EXPECT_NE(sptrDisplayProxy->GetMainDisplayId(id), ERR_OK); EXPECT_EQ(MAIN_ID, id); - sptrDisplayProxy->SetBrightness(BRIGHTNESS_SETTING_VALUE, DISPLAY_ID, false, bRet); +} + +/** + * @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) +{ + sptr sptrRemoteObj = new MockDisplayRemoteObject(); + auto sptrDisplayProxy = std::make_shared(sptrRemoteObj); + bool bRet = false; + uint32_t brightness = 0; + EXPECT_NE(sptrDisplayProxy->SetBrightness(BRIGHTNESS_SETTING_VALUE, DISPLAY_ID, false, bRet), ERR_OK); EXPECT_FALSE(bRet); - sptrDisplayProxy->DiscountBrightness(DISCOUNT_VALUE, DISPLAY_ID, bRet); + EXPECT_NE(sptrDisplayProxy->DiscountBrightness(DISCOUNT_VALUE, DISPLAY_ID, bRet), ERR_OK); EXPECT_FALSE(bRet); - sptrDisplayProxy->OverrideBrightness(BRIGHTNESS_OVERRIDE_VALUE, DISPLAY_ID, DEFAULT_DURATION, bRet); + EXPECT_NE(sptrDisplayProxy->OverrideBrightness(BRIGHTNESS_OVERRIDE_VALUE, DISPLAY_ID, DEFAULT_DURATION, bRet), + ERR_OK); EXPECT_FALSE(bRet); - sptrDisplayProxy->RestoreBrightness(DISPLAY_ID, DEFAULT_DURATION, bRet); + EXPECT_NE(sptrDisplayProxy->RestoreBrightness(DISPLAY_ID, DEFAULT_DURATION, bRet), ERR_OK); EXPECT_FALSE(bRet); - uint32_t brightness = 0; - sptrDisplayProxy->GetBrightness(DISPLAY_ID, brightness); + EXPECT_NE(sptrDisplayProxy->GetBrightness(DISPLAY_ID, brightness), ERR_OK); EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness); - sptrDisplayProxy->GetDeviceBrightness(DISPLAY_ID, brightness); + EXPECT_NE(sptrDisplayProxy->GetDeviceBrightness(DISPLAY_ID, brightness), ERR_OK); EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness); - sptrDisplayProxy->GetDefaultBrightness(brightness); + EXPECT_NE(sptrDisplayProxy->GetDefaultBrightness(brightness), ERR_OK); EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness); - sptrDisplayProxy->GetMaxBrightness(brightness); + EXPECT_NE(sptrDisplayProxy->GetMaxBrightness(brightness), ERR_OK); EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness); - sptrDisplayProxy->GetMinBrightness(brightness); + EXPECT_NE(sptrDisplayProxy->GetMinBrightness(brightness), ERR_OK); EXPECT_EQ(BRIGHTNESS_NONE_VALUE, brightness); - sptrDisplayProxy->AdjustBrightness(DISPLAY_ID, BRIGHTNESS_ADJUST_VALUE, BRIGHTNESS_DURATION, bRet); + EXPECT_NE(sptrDisplayProxy->AdjustBrightness(DISPLAY_ID, BRIGHTNESS_ADJUST_VALUE, BRIGHTNESS_DURATION, bRet), + ERR_OK); EXPECT_FALSE(bRet); - sptrDisplayProxy->AutoAdjustBrightness(true, bRet); + EXPECT_NE(sptrDisplayProxy->AutoAdjustBrightness(true, bRet), ERR_OK); EXPECT_FALSE(bRet); - sptrDisplayProxy->AutoAdjustBrightness(false, bRet); + EXPECT_NE(sptrDisplayProxy->AutoAdjustBrightness(false, bRet), ERR_OK); EXPECT_FALSE(bRet); - sptrDisplayProxy->IsAutoAdjustBrightness(bRet); + EXPECT_NE(sptrDisplayProxy->IsAutoAdjustBrightness(bRet), ERR_OK); EXPECT_FALSE(bRet); - sptrDisplayProxy->BoostBrightness(TIMEOUT_MS, DISPLAY_ID, bRet); + EXPECT_NE(sptrDisplayProxy->BoostBrightness(TIMEOUT_MS, DISPLAY_ID, bRet), ERR_OK); EXPECT_FALSE(bRet); - sptrDisplayProxy->CancelBoostBrightness(DISPLAY_ID, bRet); + EXPECT_NE(sptrDisplayProxy->CancelBoostBrightness(DISPLAY_ID, bRet), ERR_OK); EXPECT_FALSE(bRet); } } // namespace diff --git a/state_manager/utils/native/src/display_xcollie.cpp b/state_manager/utils/native/src/display_xcollie.cpp index e2f61e5..d480f44 100644 --- a/state_manager/utils/native/src/display_xcollie.cpp +++ b/state_manager/utils/native/src/display_xcollie.cpp @@ -32,11 +32,12 @@ DisplayXCollie::~DisplayXCollie() void DisplayXCollie::CancelDisplayXCollie() { - if (!isCanceled_) { - HiviewDFX::XCollie::GetInstance().CancelTimer(id_); - isCanceled_ = true; - DISPLAY_HILOGD(COMP_SVC, "Cancel DisplayXCollie, id:%{public}d, tag:%{public}s", id_, logTag_.c_str()); + if (isCanceled_) { + return; } + HiviewDFX::XCollie::GetInstance().CancelTimer(id_); + isCanceled_ = true; + 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 -- Gitee From 1a2bf4d556a6d9799912f517706fe8c985b36204 Mon Sep 17 00:00:00 2001 From: yxj Date: Tue, 3 Jun 2025 10:00:49 +0800 Subject: [PATCH 3/3] =?UTF-8?q?fix:=20code=20ai=20review=20Signed-off-by:?= =?UTF-8?q?=20=E5=BC=A0=E5=85=A8=E8=B6=85=20?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../native/display_power_mgr_client.cpp | 63 +++++-- .../native/include/display_power_mgr_client.h | 1 + state_manager/service/IDisplayPowerMgr.idl | 9 +- .../include/display_power_mgr_service.h | 10 +- .../native/src/display_power_mgr_service.cpp | 23 ++- state_manager/test/unittest/BUILD.gn | 87 +++++++++ .../unittest/include/display_service_test.h | 40 ++++ .../src/display_power_mgr_service_test.cpp | 19 ++ .../unittest/src/display_service_test.cpp | 176 ++++++++++++++++++ .../src/mock/display_mock_object_test.cpp | 3 +- .../src/mock/display_mock_parcel_test.cpp | 3 +- .../unittest/src/mock/display_mock_test.cpp | 3 +- .../utils/native/include/display_xcollie.h | 5 +- .../utils/native/src/display_xcollie.cpp | 11 +- 14 files changed, 404 insertions(+), 49 deletions(-) create mode 100644 state_manager/test/unittest/include/display_service_test.h create mode 100644 state_manager/test/unittest/src/display_service_test.cpp diff --git a/state_manager/frameworks/native/display_power_mgr_client.cpp b/state_manager/frameworks/native/display_power_mgr_client.cpp index d3cda3e..7338e24 100644 --- a/state_manager/frameworks/native/display_power_mgr_client.cpp +++ b/state_manager/frameworks/native/display_power_mgr_client.cpp @@ -34,7 +34,7 @@ namespace DisplayPowerMgr { DisplayPowerMgrClient::DisplayPowerMgrClient() = default; DisplayPowerMgrClient::~DisplayPowerMgrClient() = default; namespace { - const int32_t RETCODE_FAIL = -1; + const int32_t DEFAULT_VALUE = -1; } sptr DisplayPowerMgrClient::GetProxy() { @@ -94,6 +94,7 @@ bool DisplayPowerMgrClient::SetDisplayState(DisplayState state, bool result = false; auto ret = proxy->SetDisplayState(id, static_cast(state), static_cast(reason), result); if (ret != ERR_OK) { + result = false; DISPLAY_HILOGE(COMP_FWK, "SetDisplayState, ret = %{public}d", ret); } return result; @@ -109,6 +110,7 @@ DisplayState DisplayPowerMgrClient::GetDisplayState(uint32_t id) 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); } @@ -131,9 +133,10 @@ int32_t DisplayPowerMgrClient::GetMainDisplayId() { auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, INVALID_DISPLAY_ID); - uint32_t id = 0; + 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; @@ -144,10 +147,13 @@ bool DisplayPowerMgrClient::SetBrightness(uint32_t value, uint32_t displayId, bo auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, false); bool result = false; - auto ret = proxy->SetBrightness(value, displayId, continuous, result); + 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(displayError); return result; } @@ -158,6 +164,7 @@ bool DisplayPowerMgrClient::DiscountBrightness(double discount, uint32_t display 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; @@ -170,6 +177,7 @@ bool DisplayPowerMgrClient::OverrideBrightness(uint32_t value, uint32_t displayI 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; @@ -182,6 +190,7 @@ bool DisplayPowerMgrClient::OverrideDisplayOffDelay(uint32_t 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; @@ -194,6 +203,7 @@ bool DisplayPowerMgrClient::RestoreBrightness(uint32_t displayId, uint32_t durat 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; @@ -206,6 +216,7 @@ uint32_t DisplayPowerMgrClient::GetBrightness(uint32_t 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; @@ -215,9 +226,10 @@ uint32_t DisplayPowerMgrClient::GetDefaultBrightness() { auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, BRIGHTNESS_DEFAULT); - uint32_t brightness = BRIGHTNESS_DEFAULT; + 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; @@ -227,9 +239,10 @@ uint32_t DisplayPowerMgrClient::GetMaxBrightness() { auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, BRIGHTNESS_MAX); - uint32_t brightness = BRIGHTNESS_MAX; + 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; @@ -239,9 +252,10 @@ uint32_t DisplayPowerMgrClient::GetMinBrightness() { auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, BRIGHTNESS_MIN); - uint32_t brightness = BRIGHTNESS_MIN; + 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; @@ -254,6 +268,7 @@ bool DisplayPowerMgrClient::AdjustBrightness(uint32_t value, uint32_t 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; @@ -266,6 +281,7 @@ bool DisplayPowerMgrClient::AutoAdjustBrightness(bool 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; @@ -278,6 +294,7 @@ bool DisplayPowerMgrClient::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; @@ -290,6 +307,7 @@ bool DisplayPowerMgrClient::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; @@ -307,6 +325,7 @@ bool DisplayPowerMgrClient::RegisterCallback(sptr callbac 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; @@ -319,6 +338,7 @@ bool DisplayPowerMgrClient::BoostBrightness(int32_t timeoutMs, uint32_t displayI 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; @@ -331,6 +351,7 @@ bool DisplayPowerMgrClient::CancelBoostBrightness(uint32_t 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; @@ -343,6 +364,7 @@ uint32_t DisplayPowerMgrClient::GetDeviceBrightness(uint32_t 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; @@ -355,6 +377,7 @@ bool DisplayPowerMgrClient::SetCoordinated(bool coordinated, uint32_t 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; @@ -368,6 +391,7 @@ uint32_t DisplayPowerMgrClient::SetLightBrightnessThreshold( 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; @@ -375,19 +399,11 @@ uint32_t DisplayPowerMgrClient::SetLightBrightnessThreshold( 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); - int32_t errCode = ERR_OK; - auto ret = proxy->GetError(errCode); - if (ret != ERR_OK) { - DISPLAY_HILOGE(COMP_FWK, "GetError, ret = %{public}d", ret); - } - return static_cast(errCode); + return tmpError; } bool DisplayPowerMgrClient::SetMaxBrightness(double value, uint32_t enterTestMode) @@ -395,10 +411,13 @@ bool DisplayPowerMgrClient::SetMaxBrightness(double value, uint32_t enterTestMod auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, false); bool result = false; - auto ret = proxy->SetMaxBrightness(value, enterTestMode, result); + 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(displayError); return result; } @@ -407,10 +426,13 @@ bool DisplayPowerMgrClient::SetMaxBrightnessNit(uint32_t maxNit, uint32_t enterT auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, false); bool result = false; - auto ret = proxy->SetMaxBrightnessNit(maxNit, enterTestMode, result); + 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(displayError); return result; } @@ -418,12 +440,13 @@ int DisplayPowerMgrClient::NotifyBrightnessManagerScreenPowerStatus(uint32_t dis { auto proxy = GetProxy(); RETURN_IF_WITH_RET(proxy == nullptr, -1); // -1 means failed - int32_t result = RETCODE_FAIL; + 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); - lastError_ = static_cast(result); + return DEFAULT_VALUE; } + lastError_ = static_cast(result); return result; } 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 926c27b..aa5d0b5 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 @@ -81,6 +81,7 @@ private: sptr GetProxy(); void OnRemoteDied(const wptr& 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/service/IDisplayPowerMgr.idl b/state_manager/service/IDisplayPowerMgr.idl index 2dd74d8..d4c70b5 100644 --- a/state_manager/service/IDisplayPowerMgr.idl +++ b/state_manager/service/IDisplayPowerMgr.idl @@ -23,9 +23,11 @@ interface OHOS.DisplayPowerMgr.IDisplayPowerMgr { 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); - void SetMaxBrightness([in] double value, [in] unsigned int enterTestMode, [out] boolean isResult); - void SetMaxBrightnessNit([in] unsigned int maxNit, [in] unsigned int enterTestMode, [out] boolean isResult); + [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); @@ -42,7 +44,6 @@ interface OHOS.DisplayPowerMgr.IDisplayPowerMgr { 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 GetError([out] int errorCode); void SetLightBrightnessThreshold([in] int[] threshold, [in] IDisplayBrightnessCallback displayBrightnessCallback, [out] unsigned int retCode); void RegisterCallback([in] IDisplayPowerCallback displayPowercallback, [out] boolean isResult); 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 14e6abc..d089d28 100644 --- a/state_manager/service/native/include/display_power_mgr_service.h +++ b/state_manager/service/native/include/display_power_mgr_service.h @@ -49,9 +49,10 @@ public: int32_t GetDisplayState(uint32_t id, int32_t& displayState) override; int32_t GetDisplayIds(std::vector& ids) override; int32_t GetMainDisplayId(uint32_t& id) override; - int32_t SetBrightness(uint32_t value, uint32_t displayId, bool continuous, bool& result) override; - int32_t SetMaxBrightness(double value, uint32_t mode, bool& result) override; - int32_t SetMaxBrightnessNit(uint32_t maxNit, uint32_t mode, bool& result) 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; @@ -72,7 +73,6 @@ public: int32_t SetCoordinated(bool coordinated, uint32_t displayId, bool& result) override; int32_t SetLightBrightnessThreshold(const std::vector& threshold, const sptr& callback, uint32_t& result) override; - int32_t GetError(int32_t& errorCode) override; int32_t SetScreenOnBrightness(bool& result) override; int32_t NotifyScreenPowerStatus(uint32_t displayId, uint32_t displayPowerStatus, int32_t& result) override; private: @@ -102,9 +102,9 @@ private: bool SetCoordinatedInner(bool coordinated, uint32_t displayId); uint32_t SetLightBrightnessThresholdInner( std::vector threshold, sptr callback); - DisplayErrors GetErrorInner(); int NotifyScreenPowerStatusInner(uint32_t displayId, uint32_t displayPowerStatus); public: + DisplayErrors GetError(); virtual int32_t Dump(int32_t fd, const std::vector& args) override; void NotifyStateChangeCallback(uint32_t displayId, DisplayState state, uint32_t reason); void Init(); 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 3d6ef28..55d8ca6 100644 --- a/state_manager/service/native/src/display_power_mgr_service.cpp +++ b/state_manager/service/native/src/display_power_mgr_service.cpp @@ -142,8 +142,9 @@ void DisplayPowerMgrService::SetBootCompletedBrightness() BrightnessManager::Get().SetDisplayId(currentDisplayId); BrightnessManager::Get().SetDisplayState(currentDisplayId, static_cast(state), 0); bool result = false; + int32_t errCode = 0; DelayedSpSingleton::GetInstance()->SetBrightness(brightness, mainDisplayId, false, - result); + result, errCode); DISPLAY_HILOGI(FEAT_BRIGHTNESS, "SetBootCompletedBrightness currentDisplayId=%{public}d", currentDisplayId); } @@ -839,7 +840,7 @@ int32_t DisplayPowerMgrService::GetBrightnessFromLightScalar(float scalar) return static_cast(brightness); } -DisplayErrors DisplayPowerMgrService::GetErrorInner() +DisplayErrors DisplayPowerMgrService::GetError() { DisplayErrors tmpError = lastError_; lastError_ = DisplayErrors::ERR_OK; @@ -961,10 +962,12 @@ int32_t DisplayPowerMgrService::GetMainDisplayId(uint32_t& id) return ERR_OK; } -int32_t DisplayPowerMgrService::SetBrightness(uint32_t value, uint32_t displayId, bool continuous, bool& result) +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(GetError()); return ERR_OK; } @@ -1089,24 +1092,20 @@ int32_t DisplayPowerMgrService::SetLightBrightnessThreshold(const std::vector(GetErrorInner()); - return ERR_OK; -} - -int32_t DisplayPowerMgrService::SetMaxBrightness(double value, uint32_t mode, bool& result) +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(GetError()); return ERR_OK; } -int32_t DisplayPowerMgrService::SetMaxBrightnessNit(uint32_t maxNit, uint32_t mode, bool& result) +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(GetError()); return ERR_OK; } diff --git a/state_manager/test/unittest/BUILD.gn b/state_manager/test/unittest/BUILD.gn index f2c2262..c58a6c7 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,6 +49,7 @@ deps_ex = [ ohos_unittest("unittest_display_mgr_service") { module_out_path = module_output_path + defines += [ "GTEST" ] sanitize = { cfi = true cfi_cross_dso = true @@ -57,6 +59,7 @@ ohos_unittest("unittest_display_mgr_service") { 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 = [ @@ -79,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", @@ -219,6 +223,88 @@ ohos_unittest("display_mock_object_test") { 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 = [ @@ -226,5 +312,6 @@ group("unittest") { ":display_mock_parcel_test", ":display_mock_test", ":display_service_death_test", + ":display_service_test", ] } diff --git a/state_manager/test/unittest/include/display_service_test.h b/state_manager/test/unittest/include/display_service_test.h new file mode 100644 index 0000000..d51dec3 --- /dev/null +++ b/state_manager/test/unittest/include/display_service_test.h @@ -0,0 +1,40 @@ +/* + * 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 +#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/src/display_power_mgr_service_test.cpp b/state_manager/test/unittest/src/display_power_mgr_service_test.cpp index cf7c2f4..28a7412 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 0000000..ae063e1 --- /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 +#endif +#include +#include +#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 g_service; +} // namespace + +void DisplayServiceTest::SetUpTestCase() +{ + g_service = DelayedSpSingleton::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 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 threshold = {200, 200, 20}; + sptr 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(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 b403170..3534959 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 @@ -90,7 +90,8 @@ HWTEST_F(DisplayMockObjectTest, DisplayMockObjectTest_002, TestSize.Level0) auto sptrDisplayProxy = std::make_shared(sptrRemoteObj); bool bRet = false; uint32_t brightness = 0; - EXPECT_NE(sptrDisplayProxy->SetBrightness(BRIGHTNESS_SETTING_VALUE, DISPLAY_ID, false, bRet), ERR_OK); + 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); 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 48db6c0..f6da9c5 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 @@ -57,7 +57,8 @@ static constexpr uint32_t ERR_OK = 0; void DisplayMockParcelTest::DisplayProxyBrightnessTestFunc(std::shared_ptr& sptrDisplayProxy) { bool ret = false; - EXPECT_NE(sptrDisplayProxy->SetBrightness(BRIGHTNESS_SETTING_VALUE, DISPLAY_ID, false, ret), ERR_OK); + 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); 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 94ebedd..c08aa86 100644 --- a/state_manager/test/unittest/src/mock/display_mock_test.cpp +++ b/state_manager/test/unittest/src/mock/display_mock_test.cpp @@ -135,7 +135,8 @@ HWTEST_F(DisplayMockTest, DisplayMockTest_004, TestSize.Level0) auto sptrDisplayProxy = std::make_shared(sptrRemoteObj); bool bRet = false; uint32_t brightness = 0; - EXPECT_NE(sptrDisplayProxy->SetBrightness(BRIGHTNESS_SETTING_VALUE, DISPLAY_ID, false, bRet), ERR_OK); + 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); diff --git a/state_manager/utils/native/include/display_xcollie.h b/state_manager/utils/native/include/display_xcollie.h index 32c1fcb..eec91a7 100644 --- a/state_manager/utils/native/include/display_xcollie.h +++ b/state_manager/utils/native/include/display_xcollie.h @@ -18,7 +18,8 @@ #include #include - +#include + namespace OHOS { namespace DisplayPowerMgr { class DisplayXCollie { @@ -29,7 +30,7 @@ private: void CancelDisplayXCollie(); int32_t id_; std::string logTag_; - bool isCanceled_; + std::atomic_bool isCanceled_ = false; }; } // namespace DisplayPowerMgr } // namespace OHOS diff --git a/state_manager/utils/native/src/display_xcollie.cpp b/state_manager/utils/native/src/display_xcollie.cpp index d480f44..071b99d 100644 --- a/state_manager/utils/native/src/display_xcollie.cpp +++ b/state_manager/utils/native/src/display_xcollie.cpp @@ -14,13 +14,18 @@ namespace DisplayPowerMgr { DisplayXCollie::DisplayXCollie(const std::string &logTag, bool isRecovery) { logTag_ = logTag; - isCanceled_ = false; + 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); } @@ -32,11 +37,11 @@ DisplayXCollie::~DisplayXCollie() void DisplayXCollie::CancelDisplayXCollie() { - if (isCanceled_) { + if (isCanceled_.load()) { return; } HiviewDFX::XCollie::GetInstance().CancelTimer(id_); - isCanceled_ = true; + 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 -- Gitee