diff --git a/brightness_manager/BUILD.gn b/brightness_manager/BUILD.gn index 145b20e10207e384bda85a9fac7765590c0209a7..ca8ef7533712f4b7fb38ecc8af65bcf2e96435c9 100644 --- a/brightness_manager/BUILD.gn +++ b/brightness_manager/BUILD.gn @@ -49,6 +49,7 @@ ohos_static_library("brightness_manager") { ":brightness_manager_config", "${displaymgr_utils_path}:utils_config", "${displaymgr_inner_api}:displaymgr_public_config", + "${displaymgr_root_path}/service:displaymgr_public_config", ] external_deps = [ diff --git a/brightness_manager/test/unittest/BUILD.gn b/brightness_manager/test/unittest/BUILD.gn index 9fd92c620d1c8ceb7b9a178c9abfb2a4ce2e486d..bd204fb248af88505f359cba7dc78db4e6482411 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 3b15b89a3c913cb29bfd9097ec284eb03f78f5c5..a29a0c270c8624c87c59672e098bdec0b8e7190b 100644 --- a/bundle.json +++ b/bundle.json @@ -75,7 +75,7 @@ "test": [ "//base/powermgr/display_manager/state_manager/test:displaymgr_coverage_test", "//base/powermgr/display_manager/state_manager/test:displaymgr_native_test", - "//base/powermgr/display_manager/state_manager/test:fuzztest", + "//base/powermgr/display_manager/state_manager/test:displaymgr_fuzztest", "//base/powermgr/display_manager/brightness_manager/test:brightness_manager_test" ] } diff --git a/state_manager/frameworks/napi/BUILD.gn b/state_manager/frameworks/napi/BUILD.gn index 769ffcd86a75a0b570aaf55ad6e12bcb5685bb80..e7b945293c40f2cc5a7c092106bc2c320b67d7f6 100644 --- a/state_manager/frameworks/napi/BUILD.gn +++ b/state_manager/frameworks/napi/BUILD.gn @@ -22,6 +22,7 @@ ohos_shared_library("brightness") { configs = [ "${displaymgr_utils_path}:utils_config", "${displaymgr_utils_path}:coverage_flags", + "${displaymgr_root_path}/service:displaymgr_public_config", ] deps = [ diff --git a/state_manager/frameworks/native/display_power_mgr_client.cpp b/state_manager/frameworks/native/display_power_mgr_client.cpp index da4d65d9d5b7fd5e5c3c0add98cfb00c4a221dc8..a4ac1a1d47e43231920b24276d3ab7fe33739e8d 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 8a05721fa5b5f035f8183e6784af95029f59835d..df2af05254a42de736088d88b48562f54731c083 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 286dcf2eb061a864683d718bf8692e6da8e90ba2..926c27bead599de8aff3dac9db96813e40044d88 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 387104f1eb8b66371cc3bd1d2a84185794f7ff29..0000000000000000000000000000000000000000 --- a/state_manager/interfaces/inner_api/native/include/idisplay_power_mgr.h +++ /dev/null @@ -1,64 +0,0 @@ -/* - * Copyright (c) 2021-2023 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef DISPLAYMGR_IDISPLAY_MGR_H -#define DISPLAYMGR_IDISPLAY_MGR_H - -#include -#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 85ad61e142c389add817b7f1cec35d8a814e7c2c..120add98bcfc99040f443295fa4c31e806f91df9 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 0000000000000000000000000000000000000000..2dd74d8f1206755b9d9d4e3f0116d4cc1494570b --- /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 319e04d4879d99d631a61cab735744257d3cfa78..c38649ae19f7b727e6966ff9951a2421675ae36c 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 a9a32ff3edf79bf149143b24270604e6f5274fca..12b145771a7c90a8acb99ba71e7efb0eb3dd8506 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 4a0ff390050e0a86bd5ac3e54a179cd844d8aeb0..0000000000000000000000000000000000000000 --- a/state_manager/service/zidl/include/display_power_mgr_proxy.h +++ /dev/null @@ -1,74 +0,0 @@ -/* - * Copyright (c) 2021-2023 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef DISPLAYMGR_DISPLAY_MGR_PROXY_H -#define DISPLAYMGR_DISPLAY_MGR_PROXY_H - -#include -#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 5b330270b2f0311731c576e88c76639a6384b6ca..0000000000000000000000000000000000000000 --- a/state_manager/service/zidl/include/display_power_mgr_stub.h +++ /dev/null @@ -1,64 +0,0 @@ -/* - * Copyright (c) 2021-2023 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef DISPLAYMGR_DISPLAY_MGR_STUB_H -#define DISPLAYMGR_DISPLAY_MGR_STUB_H - -#include -#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 0dbfca6bed8e79df03563072f3f6c4a6e7cbaa1e..86d33d820d6eae27d9b1ac81e9f864ac193df638 100644 --- a/state_manager/service/zidl/src/display_power_callback_proxy.cpp +++ b/state_manager/service/zidl/src/display_power_callback_proxy.cpp @@ -21,6 +21,7 @@ #include "display_log.h" #include "display_common.h" #include "display_power_callback_ipc_interface_code.h" +#include "display_power_info.h" namespace OHOS { namespace DisplayPowerMgr { diff --git a/state_manager/service/zidl/src/display_power_mgr_proxy.cpp b/state_manager/service/zidl/src/display_power_mgr_proxy.cpp deleted file mode 100644 index eb2e194948e59f9ad3283b20380789073d75877f..0000000000000000000000000000000000000000 --- a/state_manager/service/zidl/src/display_power_mgr_proxy.cpp +++ /dev/null @@ -1,917 +0,0 @@ -/* - * Copyright (c) 2021-2023 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "display_power_mgr_proxy.h" - -#include "errors.h" -#include "message_option.h" -#include "message_parcel.h" -#include "display_log.h" -#include "display_common.h" -#include "display_power_mgr_ipc_interface_code.h" - -namespace OHOS { -namespace DisplayPowerMgr { -bool DisplayPowerMgrProxy::SetDisplayState(uint32_t id, DisplayState state, uint32_t reason) -{ - sptr 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 d0f28048d85ab627d8be190f83cd993db483e213..0000000000000000000000000000000000000000 --- a/state_manager/service/zidl/src/display_power_mgr_stub.cpp +++ /dev/null @@ -1,535 +0,0 @@ -/* - * Copyright (c) 2021-2023 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "display_power_mgr_stub.h" - -#include -#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 95570e3e8b55746040f0f4b8380b1b384a51397b..3189ad0647798c6b193ba6395c6d5fccf5b8f517 100644 --- a/state_manager/test/BUILD.gn +++ b/state_manager/test/BUILD.gn @@ -24,7 +24,7 @@ group("displaymgr_native_test") { deps = [ "unittest:unittest_display_mgr_service" ] } -group("fuzztest") { +group("displaymgr_fuzztest") { testonly = true deps = [ "fuzztest:fuzztest" ] } diff --git a/state_manager/test/fuzztest/adjustbrightness_fuzzer/BUILD.gn b/state_manager/test/fuzztest/adjustbrightness_fuzzer/BUILD.gn index 561d7842b6fab126abf2e05dee90dd9c192d4348..20658492bd9c051c9054d0a12923721a22da88f9 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,6 @@ 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", "../display_utils/display_fuzzer.cpp", "./adjustbrightness_fuzzer_test.cpp", ] diff --git a/state_manager/test/fuzztest/adjustbrightness_fuzzer/adjustbrightness_fuzzer_test.cpp b/state_manager/test/fuzztest/adjustbrightness_fuzzer/adjustbrightness_fuzzer_test.cpp index 508d9bbca3ac32f82e94a83a978ea9eece987863..e8a95d1f5cfad2fd2ea0c04e78e1eefb392085cb 100644 --- a/state_manager/test/fuzztest/adjustbrightness_fuzzer/adjustbrightness_fuzzer_test.cpp +++ b/state_manager/test/fuzztest/adjustbrightness_fuzzer/adjustbrightness_fuzzer_test.cpp @@ -18,9 +18,9 @@ #define FUZZ_PROJECT_NAME "adjustbrightness_fuzzer" #include "display_fuzzer.h" -#include "display_power_mgr_ipc_interface_code.h" +#include "idisplay_power_mgr.h" -using namespace OHOS::PowerMgr; +using namespace OHOS::DisplayPowerMgr; namespace { } @@ -31,6 +31,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) /* Run your code on data */ DisplayFuzzerTest g_serviceTest; g_serviceTest.TestDisplayServiceStub( - static_cast(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 87ee95998fb4dcdf9a1286d08684b1bd6a276d91..8e18bcf9df2ef2ca52ef0e3ec7bc4c352be9a911 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,6 @@ 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", "../display_utils/display_fuzzer.cpp", "./autoadjustbrightness_fuzzer_test.cpp", ] diff --git a/state_manager/test/fuzztest/autoadjustbrightness_fuzzer/autoadjustbrightness_fuzzer_test.cpp b/state_manager/test/fuzztest/autoadjustbrightness_fuzzer/autoadjustbrightness_fuzzer_test.cpp index 22c6411cf77e56bb0536e3e306a0f7c7e98ce645..96ead9fcc61e8c835ccdc12afd4ab7b43ca29ce5 100644 --- a/state_manager/test/fuzztest/autoadjustbrightness_fuzzer/autoadjustbrightness_fuzzer_test.cpp +++ b/state_manager/test/fuzztest/autoadjustbrightness_fuzzer/autoadjustbrightness_fuzzer_test.cpp @@ -18,9 +18,9 @@ #define FUZZ_PROJECT_NAME "autoadjustbrightness_fuzzer" #include "display_fuzzer.h" -#include "display_power_mgr_ipc_interface_code.h" +#include "idisplay_power_mgr.h" -using namespace OHOS::PowerMgr; +using namespace OHOS::DisplayPowerMgr; namespace { } @@ -31,8 +31,8 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) /* Run your code on data */ DisplayFuzzerTest g_serviceTest; g_serviceTest.TestDisplayServiceStub( - static_cast(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 ac54ba24cb4cf0cea258a00fea26b296e92bb719..e4ad2384e0d9a99e62ce6d4ca71647f4191ebd8f 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,6 @@ 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", "../display_utils/display_fuzzer.cpp", "./boostbrightness_fuzzer_test.cpp", ] diff --git a/state_manager/test/fuzztest/boostbrightness_fuzzer/boostbrightness_fuzzer_test.cpp b/state_manager/test/fuzztest/boostbrightness_fuzzer/boostbrightness_fuzzer_test.cpp index ad5ae0dba18946ce3096c2877c49091153b66135..458013076fa4b4ea652a98741e6f9762012e30a2 100644 --- a/state_manager/test/fuzztest/boostbrightness_fuzzer/boostbrightness_fuzzer_test.cpp +++ b/state_manager/test/fuzztest/boostbrightness_fuzzer/boostbrightness_fuzzer_test.cpp @@ -18,9 +18,9 @@ #define FUZZ_PROJECT_NAME "boostbrightness_fuzzer" #include "display_fuzzer.h" -#include "display_power_mgr_ipc_interface_code.h" +#include "idisplay_power_mgr.h" -using namespace OHOS::PowerMgr; +using namespace OHOS::DisplayPowerMgr; namespace { } @@ -31,8 +31,8 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) /* Run your code on data */ DisplayFuzzerTest g_serviceTest; g_serviceTest.TestDisplayServiceStub( - static_cast(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 da49b44271283d0aed6a2b764983a3e59afbb650..2c790d9bc1435d92b0dbcec1aa18498226c84ac7 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,6 @@ 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", "../display_utils/display_fuzzer.cpp", "./discountbrightness_fuzzer_test.cpp", ] diff --git a/state_manager/test/fuzztest/discountbrightness_fuzzer/discountbrightness_fuzzer_test.cpp b/state_manager/test/fuzztest/discountbrightness_fuzzer/discountbrightness_fuzzer_test.cpp index da8d4de7dc88e1cb415f920a7830c8b742993439..f909caf71a44b814388cd10a067f9398935e37d9 100644 --- a/state_manager/test/fuzztest/discountbrightness_fuzzer/discountbrightness_fuzzer_test.cpp +++ b/state_manager/test/fuzztest/discountbrightness_fuzzer/discountbrightness_fuzzer_test.cpp @@ -18,9 +18,9 @@ #define FUZZ_PROJECT_NAME "discountbrightness_fuzzer" #include "display_fuzzer.h" -#include "display_power_mgr_ipc_interface_code.h" +#include "idisplay_power_mgr.h" -using namespace OHOS::PowerMgr; +using namespace OHOS::DisplayPowerMgr; namespace { } @@ -31,6 +31,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) /* Run your code on data */ DisplayFuzzerTest g_serviceTest; g_serviceTest.TestDisplayServiceStub( - static_cast(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 c53f84b33d2f4457fc3611713921f6fe875c4e2d..8678e279e8e90b10856ad2c12c5b1ba8897fa9ef 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,6 @@ 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", "../display_utils/display_fuzzer.cpp", "./displaycoverage_fuzzer_test.cpp", ] diff --git a/state_manager/test/fuzztest/displaycoverage_fuzzer/displaycoverage_fuzzer_test.cpp b/state_manager/test/fuzztest/displaycoverage_fuzzer/displaycoverage_fuzzer_test.cpp index a00ae70e8037ef621cb713ce58ffb27ea88998f5..77a1c2d7d19741af934ef926220243e709ea45d3 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 d5fd071b6e57a41ae77902df20215fdcb95fe8b3..23345c303a947166288026c1fb195466baa8e74a 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,6 @@ 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", "../display_utils/display_fuzzer.cpp", "./displaystate_fuzzer_test.cpp", ] diff --git a/state_manager/test/fuzztest/displaystate_fuzzer/displaystate_fuzzer_test.cpp b/state_manager/test/fuzztest/displaystate_fuzzer/displaystate_fuzzer_test.cpp index e0b30d219f51866223df633624f752921659d9fd..6f02a49248141943486e4b73bbea04825bccddee 100644 --- a/state_manager/test/fuzztest/displaystate_fuzzer/displaystate_fuzzer_test.cpp +++ b/state_manager/test/fuzztest/displaystate_fuzzer/displaystate_fuzzer_test.cpp @@ -18,9 +18,9 @@ #define FUZZ_PROJECT_NAME "displaystate_fuzzer" #include "display_fuzzer.h" -#include "display_power_mgr_ipc_interface_code.h" +#include "idisplay_power_mgr.h" -using namespace OHOS::PowerMgr; +using namespace OHOS::DisplayPowerMgr; namespace { } @@ -31,8 +31,8 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) /* Run your code on data */ DisplayFuzzerTest g_serviceTest; g_serviceTest.TestDisplayServiceStub( - static_cast(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 c2c3babef69eb697b501bf33a46f6cf5945b4b96..d8165fdb928281fc288ba7bb722b2d165078886c 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,6 @@ 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", "../display_utils/display_fuzzer.cpp", "./getbrightness_fuzzer_test.cpp", ] diff --git a/state_manager/test/fuzztest/getbrightness_fuzzer/getbrightness_fuzzer_test.cpp b/state_manager/test/fuzztest/getbrightness_fuzzer/getbrightness_fuzzer_test.cpp index ee2fe2c00c2fb35b43bd0481148046bba679e55a..b699e07d635869322775c6579c70b7243bbf7616 100644 --- a/state_manager/test/fuzztest/getbrightness_fuzzer/getbrightness_fuzzer_test.cpp +++ b/state_manager/test/fuzztest/getbrightness_fuzzer/getbrightness_fuzzer_test.cpp @@ -18,9 +18,9 @@ #define FUZZ_PROJECT_NAME "getbrightness_fuzzer" #include "display_fuzzer.h" -#include "display_power_mgr_ipc_interface_code.h" +#include "idisplay_power_mgr.h" -using namespace OHOS::PowerMgr; +using namespace OHOS::DisplayPowerMgr; namespace { } @@ -31,14 +31,14 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) /* Run your code on data */ DisplayFuzzerTest g_serviceTest; g_serviceTest.TestDisplayServiceStub( - static_cast(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 b189fb1984e80bfbe0036a5573b1a2cf04ba1779..9f0192fa92d81bef0efdc66a512f2793a9de7078 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,6 @@ 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", "../display_utils/display_fuzzer.cpp", "./getdisplayid_fuzzer_test.cpp", ] diff --git a/state_manager/test/fuzztest/getdisplayid_fuzzer/getdisplayid_fuzzer_test.cpp b/state_manager/test/fuzztest/getdisplayid_fuzzer/getdisplayid_fuzzer_test.cpp index 748387a90ee8a9084008f94847ccd384dbb311cf..f7f5fcc5469021bb69f285e1e0727bd85697a77b 100644 --- a/state_manager/test/fuzztest/getdisplayid_fuzzer/getdisplayid_fuzzer_test.cpp +++ b/state_manager/test/fuzztest/getdisplayid_fuzzer/getdisplayid_fuzzer_test.cpp @@ -18,9 +18,10 @@ #define FUZZ_PROJECT_NAME "getdisplayid_fuzzer" #include "display_fuzzer.h" -#include "display_power_mgr_ipc_interface_code.h" +#include "idisplay_power_mgr.h" + +using namespace OHOS::DisplayPowerMgr; -using namespace OHOS::PowerMgr; namespace { } @@ -31,8 +32,8 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) /* Run your code on data */ DisplayFuzzerTest g_serviceTest; g_serviceTest.TestDisplayServiceStub( - static_cast(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 b0bd5e24cb72e2c49106a0bff6c5233d2fedd016..35b38b14a52f3491eee42de3c8db3b2fb5aefe4b 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,6 @@ 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", "../display_utils/display_fuzzer.cpp", "./overridebrightness_fuzzer_test.cpp", ] diff --git a/state_manager/test/fuzztest/overridebrightness_fuzzer/overridebrightness_fuzzer_test.cpp b/state_manager/test/fuzztest/overridebrightness_fuzzer/overridebrightness_fuzzer_test.cpp index df5f681a6eb5d2e6ada6abf5e3fa7d3fdb77ca42..c0a1ae336800a4b81672e5128adfd2e01d19bf5a 100644 --- a/state_manager/test/fuzztest/overridebrightness_fuzzer/overridebrightness_fuzzer_test.cpp +++ b/state_manager/test/fuzztest/overridebrightness_fuzzer/overridebrightness_fuzzer_test.cpp @@ -18,9 +18,9 @@ #define FUZZ_PROJECT_NAME "overridebrightness_fuzzer" #include "display_fuzzer.h" -#include "display_power_mgr_ipc_interface_code.h" +#include "idisplay_power_mgr.h" -using namespace OHOS::PowerMgr; +using namespace OHOS::DisplayPowerMgr; namespace { } @@ -31,8 +31,8 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) /* Run your code on data */ DisplayFuzzerTest g_serviceTest; g_serviceTest.TestDisplayServiceStub( - static_cast(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 787a70499738aa8873ecd5c6f500503df9f51ff7..986b80f20178af3fe22eeb257167cbc771c704fd 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,6 @@ 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", "../display_utils/display_fuzzer.cpp", "./overridedisplayoffdelay_fuzzer_test.cpp", ] diff --git a/state_manager/test/fuzztest/overridedisplayoffdelay_fuzzer/overridedisplayoffdelay_fuzzer_test.cpp b/state_manager/test/fuzztest/overridedisplayoffdelay_fuzzer/overridedisplayoffdelay_fuzzer_test.cpp index 36c005673705425abbff19d8df862e0f315d1742..cd1880e18663dc8a446588e71ff61eae520c7ebf 100644 --- a/state_manager/test/fuzztest/overridedisplayoffdelay_fuzzer/overridedisplayoffdelay_fuzzer_test.cpp +++ b/state_manager/test/fuzztest/overridedisplayoffdelay_fuzzer/overridedisplayoffdelay_fuzzer_test.cpp @@ -18,9 +18,9 @@ #define FUZZ_PROJECT_NAME "overridedisplayoffdelay_fuzzer" #include "display_fuzzer.h" -#include "display_power_mgr_ipc_interface_code.h" +#include "idisplay_power_mgr.h" -using namespace OHOS::PowerMgr; +using namespace OHOS::DisplayPowerMgr; namespace { } @@ -31,6 +31,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) /* Run your code on data */ DisplayFuzzerTest g_serviceTest; g_serviceTest.TestDisplayServiceStub( - static_cast(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 6095b5f14cbe116ca8074352b8d7d5ef19803129..e5d3cedae8513d95f3c2cee5d0234a7cb52b83e9 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,6 @@ 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", "../display_utils/display_fuzzer.cpp", "./registercallback_fuzzer_test.cpp", ] diff --git a/state_manager/test/fuzztest/registercallback_fuzzer/registercallback_fuzzer_test.cpp b/state_manager/test/fuzztest/registercallback_fuzzer/registercallback_fuzzer_test.cpp index bc87d483b56581cf6c9f91d860773690789fc706..c2e9aa28e4d354c0d73fadafc53e746224be70a6 100644 --- a/state_manager/test/fuzztest/registercallback_fuzzer/registercallback_fuzzer_test.cpp +++ b/state_manager/test/fuzztest/registercallback_fuzzer/registercallback_fuzzer_test.cpp @@ -18,9 +18,9 @@ #define FUZZ_PROJECT_NAME "registercallback_fuzzer" #include "display_fuzzer.h" -#include "display_power_mgr_ipc_interface_code.h" +#include "idisplay_power_mgr.h" -using namespace OHOS::PowerMgr; +using namespace OHOS::DisplayPowerMgr; namespace { } @@ -31,6 +31,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) /* Run your code on data */ DisplayFuzzerTest g_serviceTest; g_serviceTest.TestDisplayServiceStub( - static_cast(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 0bbcd31690df9d00bb435a1a0a533a6677ed6918..132c770a6b9cd105a002bf02130dad7d15134a74 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,6 @@ 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", "../display_utils/display_fuzzer.cpp", "./setbrightness_fuzzer_test.cpp", ] diff --git a/state_manager/test/fuzztest/setbrightness_fuzzer/setbrightness_fuzzer_test.cpp b/state_manager/test/fuzztest/setbrightness_fuzzer/setbrightness_fuzzer_test.cpp index 0eb18caa2ac2a8dca5847781c8d489060f3d7e3e..bb55d4f49daf983157b1d56f3ba3f7e1795f24a8 100644 --- a/state_manager/test/fuzztest/setbrightness_fuzzer/setbrightness_fuzzer_test.cpp +++ b/state_manager/test/fuzztest/setbrightness_fuzzer/setbrightness_fuzzer_test.cpp @@ -18,9 +18,9 @@ #define FUZZ_PROJECT_NAME "setbrightness_fuzzer" #include "display_fuzzer.h" -#include "display_power_mgr_ipc_interface_code.h" +#include "idisplay_power_mgr.h" -using namespace OHOS::PowerMgr; +using namespace OHOS::DisplayPowerMgr; namespace { } @@ -31,6 +31,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) /* Run your code on data */ DisplayFuzzerTest g_serviceTest; g_serviceTest.TestDisplayServiceStub( - static_cast(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 c05780051090a5bb0804f04b09cd7ff3f0bb4bed..432a01ca38aa2934337553e171d0af1d54ad9f21 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,6 @@ 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", "../display_utils/display_fuzzer.cpp", "./setcoordinated_fuzzer_test.cpp", ] diff --git a/state_manager/test/fuzztest/setcoordinated_fuzzer/setcoordinated_fuzzer_test.cpp b/state_manager/test/fuzztest/setcoordinated_fuzzer/setcoordinated_fuzzer_test.cpp index 8876e04a03fe8f3b1e5194b32d36d89d2091f11a..c95e3a4207431a2c52acd5a939828d7fa05dd11e 100644 --- a/state_manager/test/fuzztest/setcoordinated_fuzzer/setcoordinated_fuzzer_test.cpp +++ b/state_manager/test/fuzztest/setcoordinated_fuzzer/setcoordinated_fuzzer_test.cpp @@ -18,9 +18,9 @@ #define FUZZ_PROJECT_NAME "setcoordinated_fuzzer" #include "display_fuzzer.h" -#include "display_power_mgr_ipc_interface_code.h" +#include "idisplay_power_mgr.h" -using namespace OHOS::PowerMgr; +using namespace OHOS::DisplayPowerMgr; namespace { } @@ -31,6 +31,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) /* Run your code on data */ DisplayFuzzerTest g_serviceTest; g_serviceTest.TestDisplayServiceStub( - static_cast(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 e9801ca2914a9ecd9ae82b8f41f7f84c0da8d78f..97713f5a6aa75d666114c818d82ea81f33aee5d8 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,6 @@ 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", "../display_utils/display_fuzzer.cpp", "./setlightbrightnessthreshold_fuzzer_test.cpp", ] diff --git a/state_manager/test/fuzztest/setlightbrightnessthreshold_fuzzer/setlightbrightnessthreshold_fuzzer_test.cpp b/state_manager/test/fuzztest/setlightbrightnessthreshold_fuzzer/setlightbrightnessthreshold_fuzzer_test.cpp index 2e87c7c4af6f244948967602f195b155fe8ba48a..6db2386d9a403d8289d91c653701021a91fa6281 100644 --- a/state_manager/test/fuzztest/setlightbrightnessthreshold_fuzzer/setlightbrightnessthreshold_fuzzer_test.cpp +++ b/state_manager/test/fuzztest/setlightbrightnessthreshold_fuzzer/setlightbrightnessthreshold_fuzzer_test.cpp @@ -18,9 +18,9 @@ #define FUZZ_PROJECT_NAME "setlightbrightnessthreshold_fuzzer" #include "display_fuzzer.h" -#include "display_power_mgr_ipc_interface_code.h" +#include "idisplay_power_mgr.h" -using namespace OHOS::PowerMgr; +using namespace OHOS::DisplayPowerMgr; namespace { } @@ -31,8 +31,8 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) /* Run your code on data */ DisplayFuzzerTest g_serviceTest; g_serviceTest.TestDisplayServiceStub( - static_cast(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 e14681c9187aaa052f026f8734873ae979b77419..f7b0c304aa840f1add7c23768b49dcd39a61bef9 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,6 @@ 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", "../display_utils/display_fuzzer.cpp", "./setmaxbrightness_fuzzer_test.cpp", ] diff --git a/state_manager/test/fuzztest/setmaxbrightness_fuzzer/setmaxbrightness_fuzzer_test.cpp b/state_manager/test/fuzztest/setmaxbrightness_fuzzer/setmaxbrightness_fuzzer_test.cpp index 71c70c465c19ed880967358a6c82513fb7bda310..0947045963a253d82568c5e83d7b73672fa446f8 100644 --- a/state_manager/test/fuzztest/setmaxbrightness_fuzzer/setmaxbrightness_fuzzer_test.cpp +++ b/state_manager/test/fuzztest/setmaxbrightness_fuzzer/setmaxbrightness_fuzzer_test.cpp @@ -18,9 +18,9 @@ #define FUZZ_PROJECT_NAME "setmaxbrightness_fuzzer" #include "display_fuzzer.h" -#include "display_power_mgr_ipc_interface_code.h" +#include "idisplay_power_mgr.h" -using namespace OHOS::PowerMgr; +using namespace OHOS::DisplayPowerMgr; namespace { } @@ -31,6 +31,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) /* Run your code on data */ DisplayFuzzerTest g_serviceTest; g_serviceTest.TestDisplayServiceStub( - static_cast(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 d9f1af7cdfa64b0c2d89eb3d190098c7570547b9..82771893522d6405ce4e57b9d208ab15a203bf4d 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 39d7e1f43928ce777ae2b190affd20bee02ab0bc..fd2690779b492f822f4271502ce072e5a7414f18 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 4c5ece28ca84519cc316b7e33e709910d7e754bf..36b83b63af6b8c3719ed72b396275879ead6cc41 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 f981c72f27ac51c24edf3ca5bbfaf42d42e329c9..68c684bec0af4e61caeaf183cae81f05bc35dedf 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 41a4920324e20c71cd0464312d6ad7bc576c310e..6d702e371adde346c1134482b614423d3f5412e4 100644 --- a/state_manager/utils/native/include/display_log.h +++ b/state_manager/utils/native/include/display_log.h @@ -19,6 +19,7 @@ #define CONFIG_HILOG #ifdef CONFIG_HILOG +#include #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 66df8f70ff651ebf8c0578f2baeccc829031a00e..32c1fcb248625c85e5d8a96f1aaf74ce2cb2e7fe 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 0000000000000000000000000000000000000000..e2f61e5fdbd0bbdd947a446bd8bee2dd044e58f2 --- /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