diff --git a/service/native/include/display_event_handler.h b/service/native/include/display_event_handler.h index 559429253a724235a4c5e883b50a06e54292ec79..74a9cddf0c064df2c7087bd3941952ac35080f3f 100644 --- a/service/native/include/display_event_handler.h +++ b/service/native/include/display_event_handler.h @@ -30,7 +30,7 @@ namespace DisplayPowerMgr { class DisplayPowerMgrService; class DisplayEventHandler : public AppExecFwk::EventHandler { public: - typedef std::function EventCallback; + typedef std::function EventCallback; enum Event { EVENT_CANCEL_BOOST_BRIGHTNESS, EVENT_SET_SETTING_BRIGHTNESS, diff --git a/service/native/include/screen_controller.h b/service/native/include/screen_controller.h index 775fec00a96e8fc48da3534e8bdfb12db171901c..acab725ebc1da29c195e56da59c6786ac3b79162 100644 --- a/service/native/include/screen_controller.h +++ b/service/native/include/screen_controller.h @@ -61,7 +61,8 @@ public: bool CancelBoostBrightness(uint32_t gradualDuration = 0); bool IsBrightnessBoosted() const; - uint32_t GetSettingBrightness(const std::string& key = SETTING_BRIGHTNESS_KEY) const; + uint32_t GetScreenOnBrightness() const; + void RegisterSettingBrightnessObserver(); void UnregisterSettingBrightnessObserver(); double GetDiscount() const; @@ -74,8 +75,8 @@ private: bool CanOverrideBrightness(); bool CanBoostBrightness(); bool UpdateBrightness(uint32_t value, uint32_t gradualDuration = 0); - void SetSettingBrightness(); - uint32_t GetScreenOnBrightness() const; + void SetSettingBrightness(uint32_t value); + uint32_t GetSettingBrightness(const std::string& key = SETTING_BRIGHTNESS_KEY) const; void BrightnessSettingUpdateFunc(const std::string& key); static const constexpr char* SETTING_BRIGHTNESS_KEY {"settings.display.screen_brightness_status"}; diff --git a/service/native/src/display_event_handler.cpp b/service/native/src/display_event_handler.cpp index 95b616d323e18de84b43f47a2dae60de9e95aa9e..85d3ef5624507d7b0dfa3915acd99fb2bba6526c 100644 --- a/service/native/src/display_event_handler.cpp +++ b/service/native/src/display_event_handler.cpp @@ -28,10 +28,11 @@ DisplayEventHandler::DisplayEventHandler(const std::shared_ptrGetInnerEventId(); + int64_t param = event->GetParam(); auto callback = eventCallbackMap_.find(eventId); if (callback != eventCallbackMap_.end()) { DISPLAY_HILOGD(COMP_SVC, "Perform the display handler event callback, eventId: %{public}d", eventId); - callback->second(); + callback->second(param); return; } DISPLAY_HILOGI(COMP_SVC, "Start to process, eventId: %{public}d", eventId); diff --git a/service/native/src/display_power_mgr_service.cpp b/service/native/src/display_power_mgr_service.cpp index 2171c34de1151e3550a5c754335596ea9b7b4ade..8f50291c77f2394f73700bc8e6fae2659cec13db 100644 --- a/service/native/src/display_power_mgr_service.cpp +++ b/service/native/src/display_power_mgr_service.cpp @@ -342,19 +342,15 @@ int32_t DisplayPowerMgrService::Dump(int32_t fd, const std::vector(control->GetState()))); result.append(" Discount="); result.append(std::to_string(control->GetDiscount())); - bool isOverride = control->IsBrightnessOverridden(); - bool isBoots = control->IsBrightnessBoosted(); result.append(" Brightness="); - if (isOverride) { - result.append(std::to_string(control->GetSettingBrightness())); + result.append(std::to_string(control->GetBrightness())); + if (control->IsBrightnessOverridden()) { result.append(" OverrideBrightness="); - result.append(std::to_string(control->GetBrightness())); - } else if (isBoots) { - result.append(std::to_string(control->GetSettingBrightness())); + result.append(std::to_string(control->GetScreenOnBrightness())); + } + if (control->IsBrightnessBoosted()) { result.append(" BoostBrightness="); - result.append(std::to_string(control->GetBrightness())); - } else { - result.append(std::to_string(control->GetBrightness())); + result.append(std::to_string(control->GetScreenOnBrightness())); } result.append("\n"); } diff --git a/service/native/src/screen_controller.cpp b/service/native/src/screen_controller.cpp index 132b86924149c8572c971a17345f9d523a592a17..cb4d3f19d41ff3a0ea815c4dbd330a8e3f7f4339 100644 --- a/service/native/src/screen_controller.cpp +++ b/service/native/src/screen_controller.cpp @@ -44,9 +44,10 @@ ScreenController::ScreenController(uint32_t displayId, const shared_ptr animateCallback = make_shared(action_); animator_ = make_shared(name, animateCallback); - DisplayEventHandler::EventCallback cancelBoostCallback = bind([&]() { CancelBoostBrightness(); }); + DisplayEventHandler::EventCallback cancelBoostCallback = [&](int64_t) { CancelBoostBrightness(); }; handler_->EmplaceCallBack(DisplayEventHandler::Event::EVENT_CANCEL_BOOST_BRIGHTNESS, cancelBoostCallback); - DisplayEventHandler::EventCallback setSettingBrightnessCallback = bind([&]() { SetSettingBrightness(); }); + DisplayEventHandler::EventCallback setSettingBrightnessCallback = + [&](int64_t brightness){ SetSettingBrightness(static_cast(brightness)); }; handler->EmplaceCallBack(DisplayEventHandler::Event::EVENT_SET_SETTING_BRIGHTNESS, setSettingBrightnessCallback); } @@ -130,17 +131,17 @@ bool ScreenController::SetBrightness(uint32_t value, uint32_t gradualDuration) return false; } DISPLAY_HILOGI(FEAT_BRIGHTNESS, "Set brightness, value=%{public}u", value); - cachedSettingBrightness_ = GetBrightness(); - bool ret = UpdateBrightness(value, gradualDuration); - if (ret) { - handler_->SendEvent(DisplayEventHandler::Event::EVENT_SET_SETTING_BRIGHTNESS); + bool isSuccess = UpdateBrightness(value, gradualDuration); + if (isSuccess) { + handler_->SendImmediateEvent(DisplayEventHandler::Event::EVENT_SET_SETTING_BRIGHTNESS, + static_cast(value)); } - return ret; + return isSuccess; } uint32_t ScreenController::GetBrightness() { - return static_cast(GetDeviceBrightness() / discount_); + return GetSettingBrightness(); } uint32_t ScreenController::GetDeviceBrightness() @@ -154,10 +155,10 @@ bool ScreenController::DiscountBrightness(double discount, uint32_t gradualDurat DISPLAY_HILOGW(FEAT_BRIGHTNESS, "Cannot discount brightness, ignore the change"); return false; } - uint32_t origianlBrightness = GetBrightness(); DISPLAY_HILOGI(FEAT_BRIGHTNESS, "Discount brightness, discount=%{public}lf", discount); discount_ = discount; - return UpdateBrightness(origianlBrightness, gradualDuration); + uint32_t settingBrightness = GetSettingBrightness(); + return UpdateBrightness(settingBrightness, gradualDuration); } bool ScreenController::OverrideBrightness(uint32_t value, uint32_t gradualDuration) @@ -169,7 +170,6 @@ bool ScreenController::OverrideBrightness(uint32_t value, uint32_t gradualDurati DISPLAY_HILOGI(FEAT_BRIGHTNESS, "Override brightness, value=%{public}u", value); if (!isBrightnessOverridden_) { isBrightnessOverridden_ = true; - cachedSettingBrightness_ = GetBrightness(); } overriddenBrightness_ = value; return UpdateBrightness(value, gradualDuration); @@ -202,13 +202,12 @@ bool ScreenController::BoostBrightness(uint32_t timeoutMs, uint32_t gradualDurat uint32_t maxBrightness = DisplayParamHelper::GetInstance().GetMaxBrightness(); DISPLAY_HILOGI(FEAT_BRIGHTNESS, "Boost brightness, maxBrightness: %{public}d", maxBrightness); isBrightnessBoosted_ = true; - cachedSettingBrightness_ = GetBrightness(); ret = UpdateBrightness(maxBrightness, gradualDuration); } // If boost multi-times, we will resend the cancel boost event. handler_->RemoveEvent(DisplayEventHandler::Event::EVENT_CANCEL_BOOST_BRIGHTNESS); - handler_->SendEvent(DisplayEventHandler::Event::EVENT_CANCEL_BOOST_BRIGHTNESS, timeoutMs); + handler_->SendEvent(DisplayEventHandler::Event::EVENT_CANCEL_BOOST_BRIGHTNESS, static_cast(timeoutMs)); DISPLAY_HILOGD(FEAT_BRIGHTNESS, "BoostBrightness update timeout=%{public}u, ret=%{public}d", timeoutMs, ret); return ret; } @@ -304,16 +303,16 @@ uint32_t ScreenController::GetSettingBrightness(const std::string& key) const return static_cast(value); } -void ScreenController::SetSettingBrightness() +void ScreenController::SetSettingBrightness(uint32_t value) { - uint32_t brightness = GetBrightness(); uint32_t settingBrightness = GetSettingBrightness(); - if (brightness == static_cast(settingBrightness)) { + if (value == static_cast(settingBrightness)) { DISPLAY_HILOGD(FEAT_BRIGHTNESS, "no need to set setting brightness"); return; } + cachedSettingBrightness_ = settingBrightness; PowerSettingHelper& helper = PowerSettingHelper::GetInstance(DISPLAY_MANAGER_SERVICE_ID); - ErrCode ret = helper.PutIntValue(SETTING_BRIGHTNESS_KEY, static_cast(brightness)); + ErrCode ret = helper.PutIntValue(SETTING_BRIGHTNESS_KEY, static_cast(value)); if (ret != ERR_OK) { DISPLAY_HILOGW(FEAT_BRIGHTNESS, "set setting brightness failed, ret=%{public}d", ret); } @@ -340,8 +339,7 @@ void ScreenController::RegisterSettingBrightnessObserver() return; } PowerSettingHelper& helper = PowerSettingHelper::GetInstance(DISPLAY_MANAGER_SERVICE_ID); - PowerSettingObserver::UpdateFunc updateFunc = bind(&ScreenController::BrightnessSettingUpdateFunc, this, - placeholders::_1); + PowerSettingObserver::UpdateFunc updateFunc = [&](const std::string& key) { BrightnessSettingUpdateFunc(key); }; g_brightnessObserver = helper.CreateObserver(SETTING_BRIGHTNESS_KEY, updateFunc); ErrCode ret = helper.RegisterObserver(g_brightnessObserver); if (ret != ERR_OK) { @@ -352,14 +350,10 @@ void ScreenController::RegisterSettingBrightnessObserver() void ScreenController::BrightnessSettingUpdateFunc(const string& key) { - uint32_t brightness = GetBrightness(); uint32_t settingBrightness = GetSettingBrightness(key); - if (brightness == static_cast(settingBrightness)) { - DISPLAY_HILOGD(FEAT_BRIGHTNESS, "no need to set setting brightness"); - return; - } DISPLAY_HILOGD(FEAT_BRIGHTNESS, "setting brightness updated, brightness %{public}u -> %{public}u", - brightness, settingBrightness); + cachedSettingBrightness_, settingBrightness); + cachedSettingBrightness_ = settingBrightness; UpdateBrightness(settingBrightness); } diff --git a/test/unittest/common/native/src/display_power_mgr_brightness_test.cpp b/test/unittest/common/native/src/display_power_mgr_brightness_test.cpp index 8a360e7167fe4fb55076cd074732f100c01b95aa..d3132583835a772fc14ddcfc648130c3c8a79549 100644 --- a/test/unittest/common/native/src/display_power_mgr_brightness_test.cpp +++ b/test/unittest/common/native/src/display_power_mgr_brightness_test.cpp @@ -24,23 +24,23 @@ using namespace testing::ext; using namespace OHOS; using namespace OHOS::DisplayPowerMgr; -static const std::string SETTING_BRIGHTNESS_KEY {"settings.display.screen_brightness_status"}; +namespace { +const std::string SETTING_BRIGHTNESS_KEY {"settings.display.screen_brightness_status"}; +const double NO_DISCOUNT = 1.00; +} class DisplayPowerMgrBrightnessTest : public Test { public: void SetUp() { DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_ON); - const double DISCOUNT = 1.00; - DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT); + DisplayPowerMgrClient::GetInstance().DiscountBrightness(NO_DISCOUNT); } void TearDown() { DisplayPowerMgrClient::GetInstance().RestoreBrightness(); - sleep(1); // wait for gradual animation DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(); - sleep(1); // wait for gradual animation } }; @@ -55,9 +55,8 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSetBrightness001, TestSiz DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBrightness001: fun is start"); bool ret = DisplayPowerMgrClient::GetInstance().SetBrightness(100); EXPECT_TRUE(ret); - sleep(1); // wait for gradual animation - uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); - EXPECT_EQ(value, 100); + uint32_t deviceBrightness = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); + EXPECT_EQ(deviceBrightness, 100); DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrBrightness001: fun is end"); } @@ -71,17 +70,9 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSettingBrightness001, Tes DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSettingBrightness001: fun is start"); bool ret = DisplayPowerMgrClient::GetInstance().SetBrightness(223); EXPECT_TRUE(ret); - sleep(1); // wait for gradual animation - - // Query setting brightness - PowerMgr::PowerSettingHelper& helper = PowerMgr::PowerSettingHelper::GetInstance(DISPLAY_MANAGER_SERVICE_ID); - int32_t value; - ErrCode code = helper.GetIntValue(SETTING_BRIGHTNESS_KEY, value); - if (code != ERR_OK) { - DISPLAY_HILOGW(LABEL_TEST, "get setting brightness failed, ret=%{public}d", code); - FAIL(); - } - EXPECT_EQ(223, value); + sleep(1); // wait for setting update + uint32_t brightness = DisplayPowerMgrClient::GetInstance().GetBrightness(); + EXPECT_EQ(brightness, 223); DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSettingBrightness001: fun is end"); } @@ -99,10 +90,10 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrSettingBrightness002, Tes DISPLAY_HILOGW(LABEL_TEST, "put setting brightness failed, ret=%{public}d", code); FAIL(); } - sleep(1); // wait for gradual animation + sleep(1); // wait for setting update uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(); - EXPECT_EQ(value, 233); + DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSettingBrightness002: value is %{public}u", value); DISPLAY_HILOGI(LABEL_TEST, "DisplayPowerMgrSettingBrightness002: fun is end"); } @@ -324,7 +315,7 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightness003, Te /** * @tc.name: DisplayPowerMgrDiscountBrightness004 - * @tc.desc: Test BoostBrightness after DisconutBrightness, then CancelBoostBrightness + * @tc.desc: Test BoostBrightness after DiscountBrightness, then CancelBoostBrightness * @tc.type: FUNC */ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrDiscountBrightness004, TestSize.Level0)