From 183e3020f071ec5f992fc6d5b866e427dc041e67 Mon Sep 17 00:00:00 2001 From: xuedong Date: Fri, 31 May 2024 18:02:22 +0800 Subject: [PATCH] fix: max_brightness_limit Signed-off-by: xuedong --- .../include/brightness_manager.h | 4 +- .../include/brightness_manager_ext.h | 6 +- .../include/brightness_service.h | 9 +- brightness_manager/src/brightness_manager.cpp | 24 +++- .../src/brightness_manager_ext.cpp | 35 +++++- brightness_manager/src/brightness_service.cpp | 91 ++++++++++++-- .../unittest/src/brightness_manager_test.cpp | 4 +- .../native/display_power_mgr_client.cpp | 14 +++ .../native/include/display_power_mgr_client.h | 2 + .../display_power_mgr_ipc_interface_code.h | 2 + .../native/include/idisplay_power_mgr.h | 2 + state_manager/service/etc/display.para | 2 +- .../include/display_power_mgr_service.h | 3 + .../native/src/display_power_mgr_service.cpp | 66 +++++++++- .../zidl/include/display_power_mgr_proxy.h | 2 + .../zidl/include/display_power_mgr_stub.h | 3 + .../zidl/src/display_power_mgr_proxy.cpp | 73 +++++++++++ .../zidl/src/display_power_mgr_stub.cpp | 52 +++++++- .../src/display_power_mgr_brightness_test.cpp | 117 +++++++++++++++++- 19 files changed, 484 insertions(+), 27 deletions(-) diff --git a/brightness_manager/include/brightness_manager.h b/brightness_manager/include/brightness_manager.h index 2094c62..f3316bd 100644 --- a/brightness_manager/include/brightness_manager.h +++ b/brightness_manager/include/brightness_manager.h @@ -30,7 +30,7 @@ public: static BrightnessManager& Get(); - void Init(); + void Init(uint32_t defaultMax, uint32_t defaultMin); void DeInit(); void SetDisplayState(uint32_t id, DisplayState state); DisplayState GetState(); @@ -52,6 +52,8 @@ public: uint32_t SetLightBrightnessThreshold(std::vector threshold, sptr callback); uint32_t GetCurrentDisplayId(uint32_t defaultId) const; void SetDisplayId(uint32_t id = 0); + bool SetMaxBrightness(double value); + bool SetMaxBrightnessNit(uint32_t nit); private: BrightnessManager() = default; diff --git a/brightness_manager/include/brightness_manager_ext.h b/brightness_manager/include/brightness_manager_ext.h index 56cd02b..0293d24 100644 --- a/brightness_manager/include/brightness_manager_ext.h +++ b/brightness_manager/include/brightness_manager_ext.h @@ -30,7 +30,7 @@ public: BrightnessManagerExt(BrightnessManagerExt&&) = delete; BrightnessManagerExt& operator=(BrightnessManagerExt&&) = delete; - void Init(); + void Init(uint32_t defaultMax, uint32_t defaultMin); void DeInit(); void SetDisplayState(uint32_t id, DisplayState state); DisplayState GetState(); @@ -52,6 +52,8 @@ public: uint32_t GetCurrentDisplayId(uint32_t defaultId) const; void SetDisplayId(uint32_t id = 0); uint32_t SetLightBrightnessThreshold(std::vector threshold, sptr callback); + bool SetMaxBrightness(double value); + bool SetMaxBrightnessNit(uint32_t maxNit); private: bool LoadBrightnessExtLibrary(); @@ -85,6 +87,8 @@ private: void* mGetCurrentDisplayIdFunc = nullptr; void* mSetDisplayIdFunc = nullptr; void* mSetLightBrightnessThresholdFunc = nullptr; + void* mSetMaxBrightnessFunc = nullptr; + void* mSetMaxBrightnessNitFunc = nullptr; }; } // namespace DisplayPowerMgr } // namespace OHOS diff --git a/brightness_manager/include/brightness_service.h b/brightness_manager/include/brightness_service.h index 842d5a6..fc8a825 100644 --- a/brightness_manager/include/brightness_service.h +++ b/brightness_manager/include/brightness_service.h @@ -104,7 +104,7 @@ public: static void SetSettingAutoBrightness(bool enable); static bool GetSettingAutoBrightness(const std::string& key = SETTING_AUTO_ADJUST_BRIGHTNESS_KEY); - void Init(); + void Init(uint32_t defaultMax, uint32_t defaultMin); void DeInit(); void SetDisplayState(uint32_t id, DisplayState state); DisplayState GetDisplayState(); @@ -122,6 +122,7 @@ public: uint32_t GetBrightnessLevel(float lux); uint32_t GetBrightnessHighLevel(uint32_t level); uint32_t GetMappingBrightnessNit(uint32_t level); + uint32_t GetBrightnessLevelFromNit(uint32_t nit); uint32_t GetMappingHighBrightnessLevel(uint32_t level); bool SetBrightness(uint32_t value, uint32_t gradualDuration = 0, bool continuous = false); void SetScreenOnBrightness(); @@ -151,6 +152,9 @@ public: uint32_t GetCurrentSensorId(); void SetCurrentSensorId(uint32_t sensorId); + static uint32_t GetSafeBrightness(uint32_t value); + bool SetMaxBrightness(double value); + bool SetMaxBrightnessNit(uint32_t maxNit); private: static const constexpr char* SETTING_BRIGHTNESS_KEY{"settings.display.screen_brightness_status"}; static const uint32_t SAMPLING_RATE = 100000000; @@ -162,6 +166,8 @@ private: static const uint32_t AMBIENT_LUX_LEVELS[LUX_LEVEL_LENGTH]; static const uint32_t WAIT_FOR_FIRST_LUX_MAX_TIME = 200; static const uint32_t WAIT_FOR_FIRST_LUX_STEP = 10; + static uint32_t brightnessValueMin; + static uint32_t brightnessValueMax; BrightnessService(); virtual ~BrightnessService() = default; @@ -232,6 +238,7 @@ private: time_t mLastCallApsTime {0}; std::atomic mIsDisplayOnWhenFirstLuxReport{false}; std::atomic mWaitForFirstLux{false}; + std::atomic mCurrentBrightness{DEFAULT_BRIGHTNESS}; }; } // namespace DisplayPowerMgr } // namespace OHOS diff --git a/brightness_manager/src/brightness_manager.cpp b/brightness_manager/src/brightness_manager.cpp index cc4d1ad..e14ad2c 100644 --- a/brightness_manager/src/brightness_manager.cpp +++ b/brightness_manager/src/brightness_manager.cpp @@ -23,12 +23,12 @@ BrightnessManager& BrightnessManager::Get() return brightnessManager; } -void BrightnessManager::Init() +void BrightnessManager::Init(uint32_t defaultMax, uint32_t defaultMin) { #ifdef OHOS_BUILD_ENABLE_BRIGHTNESS_WRAPPER - mBrightnessManagerExt.Init(); + mBrightnessManagerExt.Init(defaultMax, defaultMin); #else - BrightnessService::Get().Init(); + BrightnessService::Get().Init(defaultMax, defaultMin); #endif } @@ -225,5 +225,23 @@ void BrightnessManager::SetDisplayId(uint32_t id) BrightnessService::Get().SetDisplayId(id); #endif } + +bool BrightnessManager::SetMaxBrightness(double value) +{ +#ifdef OHOS_BUILD_ENABLE_BRIGHTNESS_WRAPPER + return mBrightnessManagerExt.SetMaxBrightness(value); +#else + return BrightnessService::Get().SetMaxBrightness(value); +#endif +} + +bool BrightnessManager::SetMaxBrightnessNit(uint32_t nit) +{ +#ifdef OHOS_BUILD_ENABLE_BRIGHTNESS_WRAPPER + return mBrightnessManagerExt.SetMaxBrightnessNit(nit); +#else + return BrightnessService::Get().SetMaxBrightnessNit(nit); +#endif +} } // namespace DisplayPowerMgr } // namespace OHOS diff --git a/brightness_manager/src/brightness_manager_ext.cpp b/brightness_manager/src/brightness_manager_ext.cpp index d4f248c..c04cc59 100644 --- a/brightness_manager/src/brightness_manager_ext.cpp +++ b/brightness_manager/src/brightness_manager_ext.cpp @@ -27,13 +27,13 @@ BrightnessManagerExt::~BrightnessManagerExt() CloseBrightnessExtLibrary(); } -void BrightnessManagerExt::Init() +void BrightnessManagerExt::Init(uint32_t defaultMax, uint32_t defaultMin) { if (!LoadBrightnessExtLibrary()) { return; } - auto init = reinterpret_cast(mBrightnessManagerInitFunc); - init(); + auto init = reinterpret_cast(mBrightnessManagerInitFunc); + init(defaultMax, defaultMin); } void BrightnessManagerExt::DeInit() @@ -84,6 +84,16 @@ bool BrightnessManagerExt::LoadBrightnessOps() DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym SetLightBrightnessThreshold func failed!"); return false; } + mSetMaxBrightnessFunc = dlsym(mBrightnessManagerExtHandle, "SetMaxBrightness"); + if (!mSetMaxBrightnessFunc) { + DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym SetMaxBrightness func failed!"); + return false; + } + mSetMaxBrightnessNitFunc = dlsym(mBrightnessManagerExtHandle, "SetMaxBrightnessNit"); + if (!mSetMaxBrightnessNitFunc) { + DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym SetMaxBrightnessNit func failed!"); + return false; + } return true; } @@ -211,6 +221,8 @@ void BrightnessManagerExt::CloseBrightnessExtLibrary() mClearOffsetFunc = nullptr; mGetCurrentDisplayIdFunc = nullptr; mSetDisplayIdFunc = nullptr; + mSetMaxBrightnessFunc = nullptr; + mSetMaxBrightnessNitFunc = nullptr; } void BrightnessManagerExt::SetDisplayState(uint32_t id, DisplayState state) @@ -400,5 +412,22 @@ uint32_t BrightnessManagerExt::SetLightBrightnessThreshold( return setLightBrightnessThresholdFunc(threshold, callback); } +bool BrightnessManagerExt::SetMaxBrightness(double value) +{ + if (!mBrightnessManagerExtEnable) { + return false; + } + auto setMaxBrightnessFunc = reinterpret_cast(mSetMaxBrightnessFunc); + return setMaxBrightnessFunc(value); +} + +bool BrightnessManagerExt::SetMaxBrightnessNit(uint32_t nit) +{ + if (!mBrightnessManagerExtEnable) { + return false; + } + auto setMaxBrightnessNitFunc = reinterpret_cast(mSetMaxBrightnessNitFunc); + return setMaxBrightnessNitFunc(nit); +} } // namespace DisplayPowerMgr } // namespace OHOS \ No newline at end of file diff --git a/brightness_manager/src/brightness_service.cpp b/brightness_manager/src/brightness_service.cpp index 5589e99..f01d91b 100644 --- a/brightness_manager/src/brightness_service.cpp +++ b/brightness_manager/src/brightness_service.cpp @@ -46,9 +46,9 @@ namespace OHOS { namespace DisplayPowerMgr { namespace { constexpr uint32_t MAX_DEFAULT_BRGIHTNESS_LEVEL = 255; -constexpr uint32_t MIN_DEFAULT_BRGIHTNESS_LEVEL = 4; +constexpr uint32_t MIN_DEFAULT_BRGIHTNESS_LEVEL = 1; constexpr uint32_t MAX_MAPPING_BRGIHTNESS_LEVEL = 223; -constexpr uint32_t MIN_MAPPING_BRGIHTNESS_LEVEL = 4; +constexpr uint32_t MIN_MAPPING_BRGIHTNESS_LEVEL = 1; constexpr uint32_t MAX_HBM_BRGIHTNESS_NIT = 1000; constexpr uint32_t MAX_DEFAULT_BRGIHTNESS_NIT = 600; constexpr uint32_t MIN_DEFAULT_BRGIHTNESS_NIT = 2; @@ -57,6 +57,7 @@ constexpr uint32_t MIN_DEFAULT_HIGH_BRGIHTNESS_LEVEL = 156; constexpr uint32_t DEFAULT_ANIMATING_DURATION = 500; constexpr uint32_t DEFAULT_BRIGHTEN_DURATION = 2000; constexpr uint32_t DEFAULT_DARKEN_DURATION = 5000; +constexpr uint32_t DEFAULT_MAX_BRIGHTNESS_DURATION = 3000; constexpr uint32_t BRIGHTNESS_TYPE = 0; constexpr uint32_t AMBIENT_LIGHT_TYPE = 1; constexpr uint32_t APS_LISTEN_PARAMS_LENGHT = 3; @@ -71,6 +72,9 @@ const uint32_t BrightnessService::AMBIENT_LUX_LEVELS[BrightnessService::LUX_LEVE using namespace OHOS::PowerMgr; +uint32_t BrightnessService::brightnessValueMax = MAX_DEFAULT_BRGIHTNESS_LEVEL; +uint32_t BrightnessService::brightnessValueMin = MIN_DEFAULT_BRGIHTNESS_LEVEL; + BrightnessService::BrightnessService() { DISPLAY_HILOGI(FEAT_BRIGHTNESS, "BrightnessService created for displayId=%{public}d", mDisplayId); @@ -96,7 +100,7 @@ BrightnessService& BrightnessService::Get() return brightnessManager; } -void BrightnessService::Init() +void BrightnessService::Init(uint32_t defaultMax, uint32_t defaultMin) { queue_ = std::make_shared ("brightness_manager"); if (queue_ == nullptr) { @@ -115,7 +119,10 @@ void BrightnessService::Init() mBrightnessCalculationManager.InitParameters(); bool isFoldable = Rosen::DisplayManager::GetInstance().IsFoldable(); - DISPLAY_HILOGI(FEAT_BRIGHTNESS, "BrightnessService::init isFoldable=%{public}d", isFoldable); + brightnessValueMax = defaultMax; + brightnessValueMin = defaultMin; + DISPLAY_HILOGI(FEAT_BRIGHTNESS, "BrightnessService::init isFoldable=%{public}d, max=%{public}u, min=%{public}u", + isFoldable, brightnessValueMax, brightnessValueMin); if (isFoldable) { RegisterFoldStatusListener(); } @@ -705,6 +712,7 @@ void BrightnessService::UpdateCurrentBrightnessLevel(float lux, bool isFastDurat DISPLAY_HILOGI(FEAT_BRIGHTNESS, "UpdateCurrentBrightnessLevel lux=%{public}f, mBrightnessLevel=%{public}d, "\ "brightnessLevel=%{public}d, duration=%{public}d", lux, mBrightnessLevel, brightnessLevel, duration); mBrightnessLevel = brightnessLevel; + mCurrentBrightness.store(brightnessLevel); if (mWaitForFirstLux) { FFRTUtils::CancelTask(g_waitForFirstLuxTaskHandle, queue_); mWaitForFirstLux = false; @@ -756,6 +764,7 @@ bool BrightnessService::SetBrightness(uint32_t value, uint32_t gradualDuration, } } mBrightnessTarget.store(value); + mCurrentBrightness.store(value); NotifyLightChangeToAps(BRIGHTNESS_TYPE, static_cast(value)); bool isSuccess = UpdateBrightness(value, gradualDuration, !continuous); DISPLAY_HILOGD(FEAT_BRIGHTNESS, "SetBrightness val=%{public}d, isSuccess=%{public}d", value, isSuccess); @@ -962,25 +971,26 @@ bool BrightnessService::CanBoostBrightness() bool BrightnessService::UpdateBrightness(uint32_t value, uint32_t gradualDuration, bool updateSetting) { - DISPLAY_HILOGD(FEAT_BRIGHTNESS, "UpdateBrightness, value=%{public}u, discount=%{public}lf,"\ + DISPLAY_HILOGD(FEAT_BRIGHTNESS, "UpdateBrightness, value=%{public}u, discount=%{public}f,"\ "duration=%{public}u, updateSetting=%{public}d", value, mDiscount, gradualDuration, updateSetting); mWaitForFirstLux = false; + auto safeBrightness = GetSafeBrightness(value); if (mDimming->IsDimming()) { DISPLAY_HILOGI(FEAT_BRIGHTNESS, "UpdateBrightness StopDimming"); mDimming->StopDimming(); } if (gradualDuration > 0) { - mDimming->StartDimming(GetSettingBrightness(), value, gradualDuration); + mDimming->StartDimming(GetSettingBrightness(), safeBrightness, gradualDuration); return true; } - auto brightness = static_cast(value * mDiscount); + auto brightness = static_cast(safeBrightness * mDiscount); brightness = GetMappingBrightnessLevel(brightness); bool isSuccess = mAction->SetBrightness(brightness); DISPLAY_HILOGD(FEAT_BRIGHTNESS, "UpdateBrightness is %{public}s, brightness: %{public}u", isSuccess ? "succ" : "failed", brightness); if (isSuccess && updateSetting) { - DISPLAY_HILOGI(FEAT_BRIGHTNESS, "UpdateBrightness, settings, value=%{public}u", value); - FFRTUtils::SubmitTask(std::bind(&BrightnessService::SetSettingBrightness, this, value)); + DISPLAY_HILOGI(FEAT_BRIGHTNESS, "UpdateBrightness, settings, value=%{public}u", safeBrightness); + FFRTUtils::SubmitTask(std::bind(&BrightnessService::SetSettingBrightness, this, safeBrightness)); } if (isSuccess) { ReportBrightnessBigData(brightness); @@ -1102,6 +1112,21 @@ uint32_t BrightnessService::GetMappingBrightnessNit(uint32_t level) return round(nitOut); } +uint32_t BrightnessService::GetBrightnessLevelFromNit(uint32_t nit) +{ + uint32_t nitIn = nit; + if (nitIn < MIN_DEFAULT_BRGIHTNESS_NIT) { + nitIn = MIN_DEFAULT_BRGIHTNESS_NIT; + } + if (nitIn > MAX_DEFAULT_BRGIHTNESS_NIT) { + nitIn = MAX_DEFAULT_BRGIHTNESS_NIT; + } + double levelOut = (double)(nitIn - MIN_DEFAULT_BRGIHTNESS_NIT) + * (MAX_DEFAULT_BRGIHTNESS_LEVEL - MIN_DEFAULT_BRGIHTNESS_LEVEL) + / (MAX_DEFAULT_BRGIHTNESS_NIT - MIN_DEFAULT_BRGIHTNESS_NIT) + MIN_DEFAULT_BRGIHTNESS_LEVEL; + return round(levelOut); +} + uint32_t BrightnessService::GetMappingHighBrightnessLevel(uint32_t level) { uint32_t levelIn = level; @@ -1202,5 +1227,53 @@ int BrightnessService::GetSensorIdWithDisplayMode(Rosen::FoldDisplayMode mode) { return mBrightnessCalculationManager.GetSensorIdWithDisplayMode(static_cast(mode)); } + +bool BrightnessService::SetMaxBrightness(double value) +{ + int32_t intMaxValue = round(value * MAX_DEFAULT_BRGIHTNESS_LEVEL); + if (intMaxValue < 0) { + intMaxValue = brightnessValueMin; + } + DISPLAY_HILOGI(FEAT_BRIGHTNESS, "SetMaxBrightness value=%{public}u, oldMax=%{public}u", + intMaxValue, brightnessValueMax); + brightnessValueMax = + (intMaxValue > MAX_DEFAULT_BRGIHTNESS_LEVEL ? MAX_DEFAULT_BRGIHTNESS_LEVEL : intMaxValue); + uint32_t currentBrightness = GetSettingBrightness(); + if (brightnessValueMax < currentBrightness) { + DISPLAY_HILOGI(FEAT_BRIGHTNESS, "SetMaxBrightness currentBrightness=%{public}u", currentBrightness); + return UpdateBrightness(brightnessValueMax, DEFAULT_MAX_BRIGHTNESS_DURATION, true); + } + return UpdateBrightness(mCurrentBrightness.load(), DEFAULT_MAX_BRIGHTNESS_DURATION, true); +} + +bool BrightnessService::SetMaxBrightnessNit(uint32_t maxNit) +{ + uint32_t max_value = GetBrightnessLevelFromNit(maxNit); + DISPLAY_HILOGI(FEAT_BRIGHTNESS, "SetMaxBrightnessNit nitIn=%{public}u, levelOut=%{public}u", + maxNit, max_value); + brightnessValueMax = + (max_value > MAX_DEFAULT_BRGIHTNESS_LEVEL ? MAX_DEFAULT_BRGIHTNESS_LEVEL : max_value); + uint32_t currentBrightness = GetSettingBrightness(); + if (brightnessValueMax < currentBrightness) { + DISPLAY_HILOGI(FEAT_BRIGHTNESS, "SetMaxBrightnessNit currentBrightness=%{public}u", currentBrightness); + return UpdateBrightness(brightnessValueMax, DEFAULT_MAX_BRIGHTNESS_DURATION, true); + } + return UpdateBrightness(mCurrentBrightness.load(), DEFAULT_MAX_BRIGHTNESS_DURATION, true); +} + +uint32_t BrightnessService::GetSafeBrightness(uint32_t value) +{ + auto brightnessValue = value; + if (brightnessValue > brightnessValueMax) { + DISPLAY_HILOGI(FEAT_BRIGHTNESS, "value is bigger than max=%{public}u, value=%{public}u", + brightnessValueMax, value); + brightnessValue = brightnessValueMax; + } + if (brightnessValue < brightnessValueMin) { + DISPLAY_HILOGI(FEAT_BRIGHTNESS, "brightness value is less than min, value=%{public}u", value); + brightnessValue = brightnessValueMin; + } + return brightnessValue; +} } // namespace DisplayPowerMgr } // namespace OHOS diff --git a/brightness_manager/test/unittest/src/brightness_manager_test.cpp b/brightness_manager/test/unittest/src/brightness_manager_test.cpp index 02b99ad..6f632bb 100644 --- a/brightness_manager/test/unittest/src/brightness_manager_test.cpp +++ b/brightness_manager/test/unittest/src/brightness_manager_test.cpp @@ -54,7 +54,9 @@ namespace { HWTEST_F(BrightnessManagerTest, BrightnessManagerTest001, TestSize.Level0) { DISPLAY_HILOGI(LABEL_TEST, "BrightnessManagerTest001: fun is start"); - BrightnessManager::Get().Init(); + const uint32_t maxBrightness = 255; + const uint32_t minBrightness = 1; + BrightnessManager::Get().Init(maxBrightness, minBrightness); DISPLAY_HILOGI(LABEL_TEST, "BrightnessManagerTest001: fun is end"); } } // namespace diff --git a/state_manager/frameworks/native/display_power_mgr_client.cpp b/state_manager/frameworks/native/display_power_mgr_client.cpp index 77869a4..d7760d1 100644 --- a/state_manager/frameworks/native/display_power_mgr_client.cpp +++ b/state_manager/frameworks/native/display_power_mgr_client.cpp @@ -259,5 +259,19 @@ DisplayErrors DisplayPowerMgrClient::GetError() RETURN_IF_WITH_RET(proxy == nullptr, DisplayErrors::ERR_CONNECTION_FAIL); return proxy->GetError(); } + +bool DisplayPowerMgrClient::SetMaxBrightness(double value, uint32_t enterTestMode) +{ + auto proxy = GetProxy(); + RETURN_IF_WITH_RET(proxy == nullptr, false); + return proxy->SetMaxBrightness(value, enterTestMode); +} + +bool DisplayPowerMgrClient::SetMaxBrightnessNit(uint32_t maxNit, uint32_t enterTestMode) +{ + auto proxy = GetProxy(); + RETURN_IF_WITH_RET(proxy == nullptr, false); + return proxy->SetMaxBrightnessNit(maxNit, enterTestMode); +} } // namespace DisplayPowerMgr } // namespace OHOS 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 9e17fbd..f9cb250 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 @@ -38,6 +38,8 @@ public: std::vector GetDisplayIds(); int32_t GetMainDisplayId(); bool SetBrightness(uint32_t value, uint32_t displayId = 0, bool continuous = false); + bool SetMaxBrightness(double value, uint32_t enterTestMode = 0); + bool SetMaxBrightnessNit(uint32_t maxNit, uint32_t enterTestMode = 0); bool DiscountBrightness(double discount, uint32_t displayId = 0); bool OverrideBrightness(uint32_t value, uint32_t displayId = 0); bool OverrideDisplayOffDelay(uint32_t delayMs); diff --git a/state_manager/interfaces/inner_api/native/include/display_power_mgr_ipc_interface_code.h b/state_manager/interfaces/inner_api/native/include/display_power_mgr_ipc_interface_code.h index e811616..3dca492 100644 --- a/state_manager/interfaces/inner_api/native/include/display_power_mgr_ipc_interface_code.h +++ b/state_manager/interfaces/inner_api/native/include/display_power_mgr_ipc_interface_code.h @@ -42,6 +42,8 @@ enum class DisplayPowerMgrInterfaceCode { GET_DEVICE_BRIGHTNESS, SET_COORDINATED, SET_APS_LIGHT_AND_BRIGHTNESS_THRESOLD = 21, + SET_MAX_BRIGHTNESS, + SET_MAX_BRIGHTNESS_NIT }; } // space PowerMgr } // namespace OHOS 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 index 7b6116b..94c7ce2 100644 --- a/state_manager/interfaces/inner_api/native/include/idisplay_power_mgr.h +++ b/state_manager/interfaces/inner_api/native/include/idisplay_power_mgr.h @@ -33,6 +33,8 @@ public: 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) = 0; virtual bool OverrideDisplayOffDelay(uint32_t delayMs) = 0; diff --git a/state_manager/service/etc/display.para b/state_manager/service/etc/display.para index 3d44958..3847c7a 100644 --- a/state_manager/service/etc/display.para +++ b/state_manager/service/etc/display.para @@ -12,6 +12,6 @@ # limitations under the License. # Brightness limits is 0-255. -const.display.brightness.min=5 +const.display.brightness.min=1 const.display.brightness.default=102 const.display.brightness.max=255 \ 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 a544b0e..6793917 100644 --- a/state_manager/service/native/include/display_power_mgr_service.h +++ b/state_manager/service/native/include/display_power_mgr_service.h @@ -49,6 +49,8 @@ public: 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) override; virtual bool OverrideDisplayOffDelay(uint32_t delayMs) override; @@ -154,6 +156,7 @@ private: DisplayState tempState_ {DisplayState::DISPLAY_UNKNOWN}; uint32_t displayReason_ {0}; std::shared_ptr queue_; + bool isInTestMode_ {false}; }; } // namespace DisplayPowerMgr } // namespace OHOS 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 7a7a4d4..93666a2 100644 --- a/state_manager/service/native/src/display_power_mgr_service.cpp +++ b/state_manager/service/native/src/display_power_mgr_service.cpp @@ -44,6 +44,8 @@ const uint32_t GET_DISPLAY_ID_DELAY_MS = 50; const uint32_t US_PER_MS = 1000; const uint32_t GET_DISPLAY_ID_RETRY_COUNT = 3; const uint32_t DEFALUT_DISPLAY_ID = 0; +const uint32_t TEST_MODE = 1; +const uint32_t NORMAL_MODE = 2; } const uint32_t DisplayPowerMgrService::BRIGHTNESS_MIN = DisplayParamHelper::GetMinBrightness(); @@ -70,7 +72,7 @@ void DisplayPowerMgrService::Init() DISPLAY_HILOGE(COMP_SVC, "cannot find any display id after max retry, fill with 0"); } } - BrightnessManager::Get().Init(); + BrightnessManager::Get().Init(BRIGHTNESS_MAX, BRIGHTNESS_MIN); for (const auto& id: displayIds) { DISPLAY_HILOGI(COMP_SVC, "find display, id=%{public}u", id); controllerMap_.emplace(id, std::make_shared(id)); @@ -830,5 +832,67 @@ void DisplayPowerMgrService::CallbackDeathRecipient::OnRemoteDied(const wptrcallback_ = nullptr; } + +/** +* @brief Function to limit maximum screen brightness +* @param value The max brightness level that needs to be restricted +* @param mode 0 = default mode, set param value as maxBrightness; +* 1 = enter testMode, when running unittest set maxBrightness to default value; +* 2 = exit testMode +* @return false = set failed; true = set Sucess +*/ +bool DisplayPowerMgrService::SetMaxBrightness(double value, uint32_t mode) +{ + if (!Permission::IsSystem()) { + lastError_ = DisplayErrors::ERR_SYSTEM_API_DENIED; + DISPLAY_HILOGE(COMP_SVC, "SetMaxBrightness Permission Error!"); + return false; + } + if (mode == TEST_MODE) { + isInTestMode_ = true; + DISPLAY_HILOGI(COMP_SVC, "SetMaxBrightness enter TestMode"); + } + if (mode == NORMAL_MODE) { + isInTestMode_ = false; + DISPLAY_HILOGI(COMP_SVC, "SetMaxBrightness cancel TestMode"); + } + if (isInTestMode_) { + DISPLAY_HILOGI(COMP_SVC, "in the TestMode SetMaxBrightness to Default Value!"); + double maxBrightness = 1.0; + return BrightnessManager::Get().SetMaxBrightness(maxBrightness); + } + return BrightnessManager::Get().SetMaxBrightness(value); +} + +/** +* @brief Function to limit maximum screen brightness +* @param maxNit The max brightness Nit that needs to be restricted +* @param mode 0 = default mode, set param value as maxBrightness; +* 1 = enter testMode, when running unittest set maxBrightness to default value; +* 2 = exit testMode +* @return false = set failed; true = set Sucess +*/ +bool DisplayPowerMgrService::SetMaxBrightnessNit(uint32_t maxNit, uint32_t mode) +{ + if (!Permission::IsSystem()) { + lastError_ = DisplayErrors::ERR_SYSTEM_API_DENIED; + DISPLAY_HILOGE(COMP_SVC, "SetMaxBrightness Permission Error!"); + return false; + } + if (mode == TEST_MODE) { + isInTestMode_ = true; + DISPLAY_HILOGI(COMP_SVC, "SetMaxBrightness enter TestMode"); + } + if (mode == NORMAL_MODE) { + isInTestMode_ = false; + DISPLAY_HILOGI(COMP_SVC, "SetMaxBrightness cancel TestMode"); + } + if (isInTestMode_) { + DISPLAY_HILOGI(COMP_SVC, "in the TestMode SetMaxBrightness to Default Value!"); + uint32_t default_max_nit = 600; + return BrightnessManager::Get().SetMaxBrightnessNit(default_max_nit); + } + return BrightnessManager::Get().SetMaxBrightnessNit(maxNit); +} } // 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 index c6f8d51..52de9d0 100644 --- a/state_manager/service/zidl/include/display_power_mgr_proxy.h +++ b/state_manager/service/zidl/include/display_power_mgr_proxy.h @@ -41,6 +41,8 @@ public: 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) override; virtual bool OverrideDisplayOffDelay(uint32_t delayMs) override; diff --git a/state_manager/service/zidl/include/display_power_mgr_stub.h b/state_manager/service/zidl/include/display_power_mgr_stub.h index 81a3943..c867e59 100644 --- a/state_manager/service/zidl/include/display_power_mgr_stub.h +++ b/state_manager/service/zidl/include/display_power_mgr_stub.h @@ -36,6 +36,8 @@ private: 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); @@ -53,6 +55,7 @@ private: 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); }; } // namespace DisplayPowerMgr } // namespace OHOS diff --git a/state_manager/service/zidl/src/display_power_mgr_proxy.cpp b/state_manager/service/zidl/src/display_power_mgr_proxy.cpp index b9e7b87..c62c6f8 100644 --- a/state_manager/service/zidl/src/display_power_mgr_proxy.cpp +++ b/state_manager/service/zidl/src/display_power_mgr_proxy.cpp @@ -204,6 +204,79 @@ bool DisplayPowerMgrProxy::SetBrightness(uint32_t value, uint32_t displayId, boo 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(); diff --git a/state_manager/service/zidl/src/display_power_mgr_stub.cpp b/state_manager/service/zidl/src/display_power_mgr_stub.cpp index 88232ab..b0a6c6b 100644 --- a/state_manager/service/zidl/src/display_power_mgr_stub.cpp +++ b/state_manager/service/zidl/src/display_power_mgr_stub.cpp @@ -46,6 +46,15 @@ int32_t DisplayPowerMgrStub::OnRemoteRequest(uint32_t code, MessageParcel &data, constexpr int dfxDelayMs = 10000; int id = HiviewDFX::XCollie::GetInstance().SetTimer("DisplayPowerMgrStub", dfxDelayMs, nullptr, nullptr, HiviewDFX::XCOLLIE_FLAG_NOOP); + + 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): @@ -75,12 +84,16 @@ int32_t DisplayPowerMgrStub::OnRemoteRequest(uint32_t code, MessageParcel &data, 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; default: ret = RemoteRequest(code, data, reply, option); break; } - - HiviewDFX::XCollie::GetInstance().CancelTimer(id); return ret; } @@ -445,5 +458,40 @@ int32_t DisplayPowerMgrStub::SetLightBrightnessThresholdStub(MessageParcel& data 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; +} } // namespace DisplayPowerMgr } // namespace OHOS diff --git a/state_manager/test/unittest/src/display_power_mgr_brightness_test.cpp b/state_manager/test/unittest/src/display_power_mgr_brightness_test.cpp index 0881195..cb4efb5 100644 --- a/state_manager/test/unittest/src/display_power_mgr_brightness_test.cpp +++ b/state_manager/test/unittest/src/display_power_mgr_brightness_test.cpp @@ -28,6 +28,9 @@ using namespace OHOS::DisplayPowerMgr; namespace { const std::string SETTING_BRIGHTNESS_KEY {"settings.display.screen_brightness_status"}; const double NO_DISCOUNT = 1.00; +const uint32_t MAX_DEFAULT_BRIGHTNESS_LEVEL = 255; +const uint32_t TEST_MODE = 1; +const uint32_t NORMAL_MODE = 2; } class DisplayPowerMgrBrightnessTest : public Test { @@ -36,12 +39,18 @@ public: { DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_ON); DisplayPowerMgrClient::GetInstance().DiscountBrightness(NO_DISCOUNT); + uint32_t maxBrightness = DisplayPowerMgrClient::GetInstance().GetMaxBrightness(); + DisplayPowerMgrClient::GetInstance().SetMaxBrightness((double)maxBrightness / MAX_DEFAULT_BRIGHTNESS_LEVEL, + TEST_MODE); } void TearDown() { DisplayPowerMgrClient::GetInstance().RestoreBrightness(); DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(); + uint32_t maxBrightness = DisplayPowerMgrClient::GetInstance().GetMaxBrightness(); + DisplayPowerMgrClient::GetInstance().SetMaxBrightness((double)maxBrightness / MAX_DEFAULT_BRIGHTNESS_LEVEL, + NORMAL_MODE); } }; @@ -246,7 +255,7 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightness001, Te uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); EXPECT_EQ(value, static_cast(DISCOUNT_VALUE * SET_BRIGHTNESS)); - const uint32_t SET_OVERRIDE_BRIGHTNESS = 200; + const uint32_t SET_OVERRIDE_BRIGHTNESS = 202; DisplayPowerMgrClient::GetInstance().OverrideBrightness(SET_OVERRIDE_BRIGHTNESS); value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); EXPECT_EQ(value, static_cast(DISCOUNT_VALUE * SET_OVERRIDE_BRIGHTNESS)); @@ -270,7 +279,7 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightness002, Te DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); const int32_t SLEEP_TIME = 200000; usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness - const uint32_t SET_OVERRIDE_BRIGHTNESS = 200; + const uint32_t SET_OVERRIDE_BRIGHTNESS = 202; DisplayPowerMgrClient::GetInstance().OverrideBrightness(SET_OVERRIDE_BRIGHTNESS); const double DISCOUNT_VALUE = 0.7; @@ -491,7 +500,7 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrOverrideBrightness007, Te { DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrOverrideBrightness007: fun is start"); uint32_t overrideValue = 0; - uint32_t brightnessMin = 5; + uint32_t brightnessMin = DisplayPowerMgrClient::GetInstance().GetMinBrightness(); EXPECT_TRUE(DisplayPowerMgrClient::GetInstance().OverrideBrightness(overrideValue)); uint32_t deviceBrightness = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); EXPECT_EQ(brightnessMin, deviceBrightness); @@ -963,4 +972,104 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetLightBrightnessThresho DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetLightBrightnessThreshold002: fun is end"); } -} // namespace +/** + * @tc.name: DisplayPowerMgrSetMaxBrightnessNit001 + * @tc.desc: Test if SetMaxBrightness is less than the current screen brightness, + * then turn down the screen brightness to the set value. + * @tc.type: FUNC + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetMaxBrightnessNit001, TestSize.Level0) +{ + DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetMaxBrightnessNit001: fun is start"); + const uint32_t SET_BRIGHTNESS = 150; // mapping nit = 350 + const uint32_t SET_BRIGHTNESS_NIT = 350; + DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); + const int32_t SLEEP_TIME = 200000; + usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness + + const uint32_t SET_MAX_BRIGHTNESS = 98; // mapping nit = 231 + const uint32_t SET_MAX_BRIGHTNESS_NIT = 231; + bool ret = DisplayPowerMgrClient::GetInstance().SetMaxBrightnessNit(SET_MAX_BRIGHTNESS_NIT, 2); + EXPECT_TRUE(ret); + const int32_t SLEEP_TIME_BRIGHTNESS = 10000000; + usleep(SLEEP_TIME_BRIGHTNESS); // sleep 10s, wait for setBrightness + uint32_t brightness = DisplayPowerMgrClient::GetInstance().GetBrightness(); + EXPECT_EQ(SET_MAX_BRIGHTNESS, brightness); + DisplayPowerMgrClient::GetInstance().SetMaxBrightnessNit(SET_BRIGHTNESS_NIT, 1); + DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetMaxBrightnessNit001: fun is end"); +} + +/** + * @tc.name: DisplayPowerMgrSetMaxBrightnessNit002 + * @tc.desc: Test if SetMaxBrightness is higher than the current screen brightness, just set the max range + * @tc.type: FUNC + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetMaxBrightnessNit002, TestSize.Level0) +{ + DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetMaxBrightnessNit002: fun is start"); + const uint32_t SET_BRIGHTNESS = 150; // mapping nit = 350 + const uint32_t SET_BRIGHTNESS_NIT = 350; + DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); + const int32_t SLEEP_TIME = 200000; + usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness + + const uint32_t SET_MAX_BRIGHTNESS_NIT = 469; // mapping level = 200; + bool ret = DisplayPowerMgrClient::GetInstance().SetMaxBrightnessNit(SET_MAX_BRIGHTNESS_NIT, 2); + EXPECT_TRUE(ret); + const int32_t SLEEP_TIME_BRIGHTNESS = 10000000; + usleep(SLEEP_TIME_BRIGHTNESS); // sleep 10s, wait for setBrightness + uint32_t brightness = DisplayPowerMgrClient::GetInstance().GetBrightness(); + EXPECT_EQ(SET_BRIGHTNESS, brightness); + DisplayPowerMgrClient::GetInstance().SetMaxBrightnessNit(SET_BRIGHTNESS_NIT, 1); + DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetMaxBrightnessNit002: fun is end"); +} + +/** + * @tc.name: DisplayPowerMgrSetMaxBrightness001 + * @tc.desc: Test if SetMaxBrightness is less than the current screen brightness, + * then turn down the screen brightness to the set value. + * @tc.type: FUNC + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetMaxBrightness001, TestSize.Level0) +{ + DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetMaxBrightness001: fun is start"); + const uint32_t SET_BRIGHTNESS = 150; + DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); + const int32_t SLEEP_TIME = 200000; + usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness + + const uint32_t SET_MAX_BRIGHTNESS = 100; + bool ret = DisplayPowerMgrClient::GetInstance().SetMaxBrightness((double)SET_MAX_BRIGHTNESS / 255, 2); + EXPECT_TRUE(ret); + const int32_t SLEEP_TIME_BRIGHTNESS = 10000000; + usleep(SLEEP_TIME_BRIGHTNESS); // sleep 10s, wait for setBrightness + uint32_t brightness = DisplayPowerMgrClient::GetInstance().GetBrightness(); + EXPECT_EQ(SET_MAX_BRIGHTNESS, brightness); + DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS, 1); + DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetMaxBrightness001: fun is end"); +} + +/** + * @tc.name: DisplayPowerMgrSetMaxBrightness002 + * @tc.desc: Test if SetMaxBrightness is higher than the current screen brightness, just set the max range + * @tc.type: FUNC + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetMaxBrightness002, TestSize.Level0) +{ + DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetMaxBrightness002: fun is start"); + const uint32_t SET_BRIGHTNESS = 150; + DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS); + const int32_t SLEEP_TIME = 200000; + usleep(SLEEP_TIME); // sleep 200ms, wait for setBrightness + + const uint32_t SET_MAX_BRIGHTNESS = 200; + bool ret = DisplayPowerMgrClient::GetInstance().SetMaxBrightness((double)SET_MAX_BRIGHTNESS / 255, 2); + EXPECT_TRUE(ret); + const int32_t SLEEP_TIME_BRIGHTNESS = 10000000; + usleep(SLEEP_TIME_BRIGHTNESS); // sleep 10s, wait for setBrightness + uint32_t brightness = DisplayPowerMgrClient::GetInstance().GetBrightness(); + EXPECT_EQ(SET_BRIGHTNESS, brightness); + DisplayPowerMgrClient::GetInstance().SetMaxBrightness(SET_BRIGHTNESS, 1); + DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSetMaxBrightness002: fun is end"); +} +} // namespace \ No newline at end of file -- Gitee