From 3ab17e9a1b363573438acf3b888f4474e36102a5 Mon Sep 17 00:00:00 2001 From: yangziyong Date: Thu, 20 Oct 2022 09:35:54 +0800 Subject: [PATCH] feat: supports multi-screen control Signed-off-by: yangziyong --- .../native/include/idisplay_power_mgr.h | 4 +- service/BUILD.gn | 2 + .../include/display_power_mgr_service.h | 2 + service/native/include/mock_screen_action.h | 51 ++ .../native/include/mock_screen_controller.h | 90 +++ service/native/include/screen_action.h | 12 +- service/native/include/screen_controller.h | 34 +- .../native/src/display_power_mgr_service.cpp | 22 +- service/native/src/mock_screen_action.cpp | 84 +++ service/native/src/mock_screen_controller.cpp | 370 ++++++++++ service/native/src/screen_controller.cpp | 3 +- .../zidl/include/display_power_mgr_proxy.h | 1 + service/zidl/include/display_power_mgr_stub.h | 1 + service/zidl/src/display_power_mgr_proxy.cpp | 34 + service/zidl/src/display_power_mgr_stub.cpp | 18 + test/unittest/common/native/BUILD.gn | 1 + .../src/display_power_mgr_brightness_test.cpp | 645 ++++++++++++++++++ utils/BUILD.gn | 24 + .../include/mock_display_power_mgr_client.h | 57 ++ .../src/mock_display_power_mgr_client.cpp | 88 +++ 20 files changed, 1513 insertions(+), 30 deletions(-) create mode 100644 service/native/include/mock_screen_action.h create mode 100644 service/native/include/mock_screen_controller.h create mode 100644 service/native/src/mock_screen_action.cpp create mode 100644 service/native/src/mock_screen_controller.cpp create mode 100644 utils/native/mock/include/mock_display_power_mgr_client.h create mode 100644 utils/native/mock/src/mock_display_power_mgr_client.cpp diff --git a/interfaces/innerkits/native/include/idisplay_power_mgr.h b/interfaces/innerkits/native/include/idisplay_power_mgr.h index 8f50efb..0821fe2 100644 --- a/interfaces/innerkits/native/include/idisplay_power_mgr.h +++ b/interfaces/innerkits/native/include/idisplay_power_mgr.h @@ -46,7 +46,8 @@ public: REGISTER_CALLBACK, BOOST_BRIGHTNESS, CANCEL_BOOST_BRIGHTNESS, - GET_DEVICE_BRIGHTNESS + GET_DEVICE_BRIGHTNESS, + ADD_MOCK_SCREEN }; virtual bool SetDisplayState(uint32_t id, DisplayState state, uint32_t reason) = 0; @@ -62,6 +63,7 @@ public: 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 AddMockScreen(uint32_t displayId) = 0; virtual bool AutoAdjustBrightness(bool enable) = 0; virtual bool IsAutoAdjustBrightness() = 0; virtual bool RegisterCallback(sptr callback) = 0; diff --git a/service/BUILD.gn b/service/BUILD.gn index 6150504..f3f105a 100644 --- a/service/BUILD.gn +++ b/service/BUILD.gn @@ -38,6 +38,8 @@ ohos_shared_library("displaymgrservice") { "native/src/display_power_mgr_service.cpp", "native/src/display_system_ability.cpp", "native/src/gradual_animator.cpp", + "native/src/mock_screen_action.cpp", + "native/src/mock_screen_controller.cpp", "native/src/screen_action.cpp", "native/src/screen_controller.cpp", "zidl/src/display_power_callback_proxy.cpp", diff --git a/service/native/include/display_power_mgr_service.h b/service/native/include/display_power_mgr_service.h index aa51a65..d345fb9 100644 --- a/service/native/include/display_power_mgr_service.h +++ b/service/native/include/display_power_mgr_service.h @@ -33,6 +33,7 @@ #include "display_event_handler.h" #include "display_common.h" #include "display_power_mgr_stub.h" +#include "mock_screen_controller.h" #include "screen_controller.h" namespace OHOS { @@ -58,6 +59,7 @@ public: virtual bool RegisterCallback(sptr callback) override; virtual bool BoostBrightness(int32_t timeoutMs, uint32_t displayId) override; virtual bool CancelBoostBrightness(uint32_t displayId) override; + virtual bool AddMockScreen(uint32_t displayId) override; virtual uint32_t GetDeviceBrightness(uint32_t displayId) override; virtual int32_t Dump(int32_t fd, const std::vector& args) override; virtual DisplayErrors GetError() override; diff --git a/service/native/include/mock_screen_action.h b/service/native/include/mock_screen_action.h new file mode 100644 index 0000000..24d1cdb --- /dev/null +++ b/service/native/include/mock_screen_action.h @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2022 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_MOCK_SCREEN_ACTION_H +#define DISPLAYMGR_MOCK_SCREEN_ACTION_H + +#include +#include +#include +#include +#include + +#include "display_power_info.h" +#include "screen_action.h" + +namespace OHOS { +namespace DisplayPowerMgr { +class MockScreenAction : public ScreenAction{ +public: + MockScreenAction(uint32_t displayId); + ~MockScreenAction() = default; + + uint32_t GetDisplayId() override; + DisplayState GetDisplayState() override; + bool SetDisplayState(DisplayState state); + bool SetDisplayPower(DisplayState state, uint32_t reason) override; + uint32_t GetBrightness() override; + bool SetBrightness(uint32_t value) override; + +private: + static constexpr uint32_t DEFAULT_DISPLAY_ID = 0; + std::mutex mockMutexBrightness_; + uint32_t mockBrightness_ {102}; + uint32_t mockDisplayId_ {DEFAULT_DISPLAY_ID}; + DisplayState mockDisplayState_ {DisplayState::DISPLAY_UNKNOWN}; +}; +} // namespace DisplayPowerMgr +} // namespace OHOS +#endif // DISPLAYMGR_MOCK_SCREEN_ACTION_H \ No newline at end of file diff --git a/service/native/include/mock_screen_controller.h b/service/native/include/mock_screen_controller.h new file mode 100644 index 0000000..27caa0e --- /dev/null +++ b/service/native/include/mock_screen_controller.h @@ -0,0 +1,90 @@ +/* + * Copyright (c) 2022 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_MOCK_SCREEN_CONTROLLER_H +#define DISPLAYMGR_MOCK_SCREEN_CONTROLLER_H + +#include +#include +#include +#include + +#include "display_event_handler.h" +#include "display_power_info.h" +#include "gradual_animator.h" +#include "mock_screen_action.h" +#include "screen_controller.h" + +namespace OHOS { +namespace DisplayPowerMgr { +class MockScreenController : public ScreenController { +public: + MockScreenController(uint32_t displayId, const std::shared_ptr& handler); + ~MockScreenController() = default; + + DisplayState GetState() override; + bool UpdateState(DisplayState state, uint32_t reason) override; + bool IsScreenOn() override; + + bool SetBrightness(uint32_t value, uint32_t gradualDuration = 0) override; + uint32_t GetBrightness() override; + uint32_t GetDeviceBrightness() override; + + bool DiscountBrightness(double discount, uint32_t gradualDuration = 0) override; + bool OverrideBrightness(uint32_t value, uint32_t gradualDuration = 0) override; + bool RestoreBrightness(uint32_t gradualDuration = 0) override; + bool IsBrightnessOverridden() const override; + + bool BoostBrightness(uint32_t timeoutMs, uint32_t gradualDuration = 0) override; + bool CancelBoostBrightness(uint32_t gradualDuration = 0) override; + bool IsBrightnessBoosted() const override; + + uint32_t GetScreenOnBrightness() const override; + + void RegisterSettingBrightnessObserver() override; + void UnregisterSettingBrightnessObserver() override; + double GetDiscount() const override; + + uint32_t GetAnimationUpdateTime() const; +private: + void OnStateChanged(DisplayState state); + + bool CanSetBrightness(); + bool CanDiscountBrightness(); + bool CanOverrideBrightness(); + bool CanBoostBrightness(); + bool UpdateBrightness(uint32_t value, uint32_t gradualDuration = 0, bool updateSetting = false); + 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"}; + DisplayState state_; + std::mutex mutexState_; + uint32_t stateChangeReason_ {0}; + double discount_ {1.0}; + + std::atomic isBrightnessOverridden_ {false}; + std::atomic isBrightnessBoosted_ {false}; + uint32_t cachedSettingBrightness_ {102}; + uint32_t overriddenBrightness_ {102}; + std::shared_ptr action_ {nullptr}; + std::shared_ptr animateCallback_ {nullptr}; + std::shared_ptr animator_; + const std::shared_ptr& handler_; +}; +} // namespace DisplayPowerMgr +} // namespace OHOS +#endif // DISPLAYMGR_MOCK_SCREEN_CONTROLLER_H \ No newline at end of file diff --git a/service/native/include/screen_action.h b/service/native/include/screen_action.h index 5e88bfa..0554d6b 100644 --- a/service/native/include/screen_action.h +++ b/service/native/include/screen_action.h @@ -29,17 +29,17 @@ namespace DisplayPowerMgr { class ScreenAction { public: ScreenAction(uint32_t displayId); - ~ScreenAction() = default; + virtual ~ScreenAction() = default; static uint32_t GetDefaultDisplayId(); static std::vector GetAllDisplayId(); - uint32_t GetDisplayId(); - DisplayState GetDisplayState(); + virtual uint32_t GetDisplayId(); + virtual DisplayState GetDisplayState(); bool SetDisplayState(DisplayState state, const std::function& callback); - bool SetDisplayPower(DisplayState state, uint32_t reason); - uint32_t GetBrightness(); - bool SetBrightness(uint32_t value); + virtual bool SetDisplayPower(DisplayState state, uint32_t reason); + virtual uint32_t GetBrightness(); + virtual bool SetBrightness(uint32_t value); private: static constexpr uint32_t DEFAULT_DISPLAY_ID = 0; diff --git a/service/native/include/screen_controller.h b/service/native/include/screen_controller.h index d0ad30b..544f4f6 100644 --- a/service/native/include/screen_controller.h +++ b/service/native/include/screen_controller.h @@ -48,28 +48,28 @@ public: double discount_ {1.0}; }; - DisplayState GetState(); - bool UpdateState(DisplayState state, uint32_t reason); - bool IsScreenOn(); + virtual DisplayState GetState(); + virtual bool UpdateState(DisplayState state, uint32_t reason); + virtual bool IsScreenOn(); - bool SetBrightness(uint32_t value, uint32_t gradualDuration = 0); - uint32_t GetBrightness(); - uint32_t GetDeviceBrightness(); + virtual bool SetBrightness(uint32_t value, uint32_t gradualDuration); + virtual uint32_t GetBrightness(); + virtual uint32_t GetDeviceBrightness(); - bool DiscountBrightness(double discount, uint32_t gradualDuration = 0); - bool OverrideBrightness(uint32_t value, uint32_t gradualDuration = 0); - bool RestoreBrightness(uint32_t gradualDuration = 0); - bool IsBrightnessOverridden() const; + virtual bool DiscountBrightness(double discount, uint32_t gradualDuration); + virtual bool OverrideBrightness(uint32_t value, uint32_t gradualDuration); + virtual bool RestoreBrightness(uint32_t gradualDuration = 0); + virtual bool IsBrightnessOverridden() const; - bool BoostBrightness(uint32_t timeoutMs, uint32_t gradualDuration = 0); - bool CancelBoostBrightness(uint32_t gradualDuration = 0); - bool IsBrightnessBoosted() const; + virtual bool BoostBrightness(uint32_t timeoutMs, uint32_t gradualDuration); + virtual bool CancelBoostBrightness(uint32_t gradualDuration); + virtual bool IsBrightnessBoosted() const; - uint32_t GetScreenOnBrightness() const; + virtual uint32_t GetScreenOnBrightness() const; - void RegisterSettingBrightnessObserver(); - void UnregisterSettingBrightnessObserver(); - double GetDiscount() const; + virtual void RegisterSettingBrightnessObserver(); + virtual void UnregisterSettingBrightnessObserver(); + virtual double GetDiscount() const; uint32_t GetAnimationUpdateTime() const; private: diff --git a/service/native/src/display_power_mgr_service.cpp b/service/native/src/display_power_mgr_service.cpp index da2d6f9..7445f5b 100644 --- a/service/native/src/display_power_mgr_service.cpp +++ b/service/native/src/display_power_mgr_service.cpp @@ -233,6 +233,7 @@ uint32_t DisplayPowerMgrService::GetMainDisplayId() bool DisplayPowerMgrService::SetBrightness(uint32_t value, uint32_t displayId) { + uint32_t gradualDuration = 0; if (!Permission::IsSystem()) { lastError_ = DisplayErrors::ERR_PERMISSION_DENIED; return false; @@ -243,11 +244,12 @@ bool DisplayPowerMgrService::SetBrightness(uint32_t value, uint32_t displayId) if (iter == controllerMap_.end()) { return false; } - return iter->second->SetBrightness(brightness); + return iter->second->SetBrightness(brightness, gradualDuration); } bool DisplayPowerMgrService::DiscountBrightness(double discount, uint32_t displayId) { + uint32_t gradualDuration = 0; auto iter = controllerMap_.find(displayId); if (iter == controllerMap_.end()) { return false; @@ -258,18 +260,19 @@ bool DisplayPowerMgrService::DiscountBrightness(double discount, uint32_t displa displayId, safeDiscount); HiviewDFX::HiSysEvent::Write("DISPLAY", "BACKLIGHT_DISCOUNT", HiviewDFX::HiSysEvent::EventType::STATISTIC, "RATIO", safeDiscount); - return iter->second->DiscountBrightness(safeDiscount); + return iter->second->DiscountBrightness(safeDiscount, gradualDuration); } bool DisplayPowerMgrService::OverrideBrightness(uint32_t value, uint32_t displayId) { + uint32_t gradualDuration = 0; auto brightness = GetSafeBrightness(value); DISPLAY_HILOGI(COMP_SVC, "OverrideBrightness displayId=%{public}u, value=%{public}u", displayId, brightness); auto iter = controllerMap_.find(displayId); if (iter == controllerMap_.end()) { return false; } - return iter->second->OverrideBrightness(brightness); + return iter->second->OverrideBrightness(brightness, gradualDuration); } bool DisplayPowerMgrService::RestoreBrightness(uint32_t displayId) @@ -411,19 +414,28 @@ bool DisplayPowerMgrService::RegisterCallback(sptr callba bool DisplayPowerMgrService::BoostBrightness(int32_t timeoutMs, uint32_t displayId) { + uint32_t gradualDuration = 0; DISPLAY_HILOGD(FEAT_BRIGHTNESS, "Timing boost brightness: %{public}d, id: %{public}d", timeoutMs, displayId); RETURN_IF_WITH_RET(timeoutMs <= 0, false); auto iter = controllerMap_.find(displayId); RETURN_IF_WITH_RET(iter == controllerMap_.end(), false); - return iter->second->BoostBrightness(timeoutMs); + return iter->second->BoostBrightness(timeoutMs, gradualDuration); } bool DisplayPowerMgrService::CancelBoostBrightness(uint32_t displayId) { + uint32_t gradualDuration = 0; DISPLAY_HILOGD(FEAT_BRIGHTNESS, "Cancel boost brightness, id: %{public}d", displayId); auto iter = controllerMap_.find(displayId); RETURN_IF_WITH_RET(iter == controllerMap_.end(), false); - return iter->second->CancelBoostBrightness(); + return iter->second->CancelBoostBrightness(gradualDuration); +} + +bool DisplayPowerMgrService::AddMockScreen(uint32_t displayId) +{ + DISPLAY_HILOGD(COMP_SVC, "enter AddMockScreen service id= %{public}d", displayId); + controllerMap_.emplace(displayId, std::make_shared(displayId, handler_)); + return true; } uint32_t DisplayPowerMgrService::GetDeviceBrightness(uint32_t displayId) diff --git a/service/native/src/mock_screen_action.cpp b/service/native/src/mock_screen_action.cpp new file mode 100644 index 0000000..aa91444 --- /dev/null +++ b/service/native/src/mock_screen_action.cpp @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2022 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 "mock_screen_action.h" + +#include +#include + +#include "dm_common.h" +#include "display_manager.h" +#include "display_log.h" +#include "screen_manager.h" + +namespace OHOS { +namespace DisplayPowerMgr { +MockScreenAction::MockScreenAction(uint32_t displayId) : ScreenAction(displayId), mockDisplayId_(displayId) +{ +} + +uint32_t MockScreenAction::GetDisplayId() +{ + return mockDisplayId_; +} + +DisplayState MockScreenAction::GetDisplayState() +{ + DisplayState state = DisplayState::DISPLAY_UNKNOWN; + state = mockDisplayState_; + + DISPLAY_HILOGD(FEAT_STATE, "state=%{public}u displayId=%{public}u", state, mockDisplayId_); + return state; +} + +bool MockScreenAction::SetDisplayState(DisplayState state) +{ + DISPLAY_HILOGD(FEAT_STATE, "SetDisplayState: displayId=%{public}u, state=%{public}u", + mockDisplayId_, state); + bool ret = true; + // Notify screen state change event to battery statistics + HiviewDFX::HiSysEvent::Write("DISPLAY", "SCREEN_STATE", + HiviewDFX::HiSysEvent::EventType::STATISTIC, "STATE", static_cast(state)); + DISPLAY_HILOGD(FEAT_STATE, "SetDisplayState:%{public}d", ret); + return ret; +} + +bool MockScreenAction::SetDisplayPower(DisplayState state, uint32_t reason) +{ + DISPLAY_HILOGD(FEAT_STATE, "SetDisplayPower: displayId=%{public}u, state=%{public}u, state=%{public}u", + mockDisplayId_, state, reason); + return true; +} + +uint32_t MockScreenAction::GetBrightness() +{ + std::lock_guard lock(mockMutexBrightness_); + + DISPLAY_HILOGD(FEAT_BRIGHTNESS, "displayId=%{public}u, brightness=%{public}u", mockDisplayId_, mockBrightness_); + return mockBrightness_; +} + +bool MockScreenAction::SetBrightness(uint32_t value) +{ + DISPLAY_HILOGD(FEAT_BRIGHTNESS, "displayId=%{public}u, brightness=%{public}u", mockDisplayId_, value); + // Notify screen brightness change event to battery statistics + HiviewDFX::HiSysEvent::Write("DISPLAY", "BRIGHTNESS_NIT", + HiviewDFX::HiSysEvent::EventType::STATISTIC, "BRIGHTNESS", value); + mockBrightness_ = value; + std::lock_guard lock(mockMutexBrightness_); + return true; +} +} // namespace DisplayPowerMgr +} // namespace OHOS \ No newline at end of file diff --git a/service/native/src/mock_screen_controller.cpp b/service/native/src/mock_screen_controller.cpp new file mode 100644 index 0000000..55cfa16 --- /dev/null +++ b/service/native/src/mock_screen_controller.cpp @@ -0,0 +1,370 @@ +/* + * Copyright (c) 2022 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 "mock_screen_controller.h" + +#include "delayed_sp_singleton.h" +#include "refbase.h" +#include "display_power_mgr_service.h" +#include "display_param_helper.h" +#include "setting_provider.h" +#include "system_ability_definition.h" +#include "display_common.h" +#include "display_log.h" + +using namespace std; +using namespace OHOS::PowerMgr; + +namespace OHOS { +namespace DisplayPowerMgr { +namespace { +sptr g_brightnessObserver; +} + +MockScreenController::MockScreenController(uint32_t displayId, const shared_ptr& handler) + : ScreenController(displayId, handler), handler_(handler) +{ + DISPLAY_HILOGD(COMP_SVC, "MockScreenController created for displayId=%{public}u", displayId); + action_ = make_shared(displayId); + state_ = action_->GetDisplayState(); + uint32_t gradualDuration = 0; + + string name = "BrightnessController_" + to_string(displayId); + if (animateCallback_ == nullptr) { + animateCallback_ = make_shared(action_, handler_); + } + animator_ = make_shared(name, animateCallback_); + + DisplayEventHandler::EventCallback cancelBoostCallback = [&](int64_t) { CancelBoostBrightness(gradualDuration); }; + handler_->EmplaceCallBack(DisplayEventHandler::Event::EVENT_CANCEL_BOOST_BRIGHTNESS, cancelBoostCallback); + DisplayEventHandler::EventCallback setSettingBrightnessCallback = + [&](int64_t brightness) { SetSettingBrightness(static_cast(brightness)); }; + handler->EmplaceCallBack(DisplayEventHandler::Event::EVENT_SET_SETTING_BRIGHTNESS, setSettingBrightnessCallback); +} + +DisplayState MockScreenController::GetState() +{ + return state_; +} + +bool MockScreenController::UpdateState(DisplayState state, uint32_t reason) +{ + DISPLAY_HILOGI(FEAT_STATE, "UpdateState, state=%{public}u, current state=%{public}u", + static_cast(state), static_cast(state_)); + RETURN_IF_WITH_RET(state == state_, true); + + switch (state) { + case DisplayState::DISPLAY_ON: + case DisplayState::DISPLAY_OFF: { + bool ret = action_->SetDisplayState(state); + if (!ret) { + DISPLAY_HILOGW(FEAT_STATE, "SetDisplayState failed state=%{public}d", state); + return ret; + } + break; + } + case DisplayState::DISPLAY_DIM: + case DisplayState::DISPLAY_SUSPEND: { + bool ret = action_->SetDisplayPower(state, stateChangeReason_); + if (!ret) { + DISPLAY_HILOGW(FEAT_STATE, "SetDisplayPower failed state=%{public}d", state); + return ret; + } + break; + } + default: + break; + } + + lock_guard lock(mutexState_); + state_ = state; + stateChangeReason_ = reason; + + DISPLAY_HILOGI(FEAT_STATE, "Update screen state to %{public}u", state); + return true; +} + +bool MockScreenController::IsScreenOn() +{ + lock_guard lock(mutexState_); + return (state_ == DisplayState::DISPLAY_ON || state_ == DisplayState::DISPLAY_DIM); +} + +bool MockScreenController::SetBrightness(uint32_t value, uint32_t gradualDuration) +{ + if (!CanSetBrightness()) { + DISPLAY_HILOGW(FEAT_BRIGHTNESS, "Cannot set brightness, ignore the change"); + return false; + } + return UpdateBrightness(value, gradualDuration, true); +} + +uint32_t MockScreenController::GetBrightness() +{ + return GetSettingBrightness(); +} + +uint32_t MockScreenController::GetDeviceBrightness() +{ + return action_->GetBrightness(); +} + +bool MockScreenController::DiscountBrightness(double discount, uint32_t gradualDuration) +{ + if (!CanDiscountBrightness()) { + DISPLAY_HILOGW(FEAT_BRIGHTNESS, "Cannot discount brightness, ignore the change"); + return false; + } + DISPLAY_HILOGI(FEAT_BRIGHTNESS, "Discount brightness, discount=%{public}lf", discount); + discount_ = discount; + if (animateCallback_) { + animateCallback_->DiscountBrightness(discount); + } + uint32_t screenOnBrightness = GetScreenOnBrightness(); + return UpdateBrightness(screenOnBrightness, gradualDuration); +} + +bool MockScreenController::OverrideBrightness(uint32_t value, uint32_t gradualDuration) +{ + if (!CanOverrideBrightness()) { + DISPLAY_HILOGW(FEAT_BRIGHTNESS, "Cannot override brightness, ignore the change"); + return false; + } + DISPLAY_HILOGI(FEAT_BRIGHTNESS, "Override brightness, value=%{public}u", value); + if (!isBrightnessOverridden_) { + isBrightnessOverridden_ = true; + } + overriddenBrightness_ = value; + return UpdateBrightness(value, gradualDuration); +} + +bool MockScreenController::RestoreBrightness(uint32_t gradualDuration) +{ + if (!IsBrightnessOverridden()) { + DISPLAY_HILOGD(FEAT_BRIGHTNESS, "Brightness is not override, no need to restore"); + return false; + } + isBrightnessOverridden_ = false; + uint32_t settingBrightness = GetSettingBrightness(); + return UpdateBrightness(settingBrightness, gradualDuration); +} + +bool MockScreenController::IsBrightnessOverridden() const +{ + return isBrightnessOverridden_; +} + +bool MockScreenController::BoostBrightness(uint32_t timeoutMs, uint32_t gradualDuration) +{ + if (!CanBoostBrightness()) { + DISPLAY_HILOGW(FEAT_BRIGHTNESS, "Cannot boost brightness, ignore the change"); + return false; + } + bool ret = true; + if (!isBrightnessBoosted_) { + uint32_t maxBrightness = DisplayParamHelper::GetMaxBrightness(); + DISPLAY_HILOGI(FEAT_BRIGHTNESS, "Boost brightness, maxBrightness: %{public}d", maxBrightness); + isBrightnessBoosted_ = true; + 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, static_cast(timeoutMs)); + DISPLAY_HILOGD(FEAT_BRIGHTNESS, "BoostBrightness update timeout=%{public}u, ret=%{public}d", timeoutMs, ret); + return ret; +} + +bool MockScreenController::CancelBoostBrightness(uint32_t gradualDuration) +{ + DISPLAY_HILOGD(FEAT_BRIGHTNESS, "Cancel boost brightness"); + if (!IsBrightnessBoosted()) { + DISPLAY_HILOGD(FEAT_BRIGHTNESS, "Brightness is not boost, no need to restore"); + return false; + } + handler_->RemoveEvent(DisplayEventHandler::Event::EVENT_CANCEL_BOOST_BRIGHTNESS); + isBrightnessBoosted_ = false; + uint32_t settingBrightness = GetSettingBrightness(); + return UpdateBrightness(settingBrightness, gradualDuration); +} + +bool MockScreenController::IsBrightnessBoosted() const +{ + return isBrightnessBoosted_; +} + +void MockScreenController::OnStateChanged(DisplayState state) +{ + auto pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + DISPLAY_HILOGW(FEAT_STATE, "pms is nullptr"); + return; + } + + bool ret = action_->SetDisplayPower(state, stateChangeReason_); + if (state == DisplayState::DISPLAY_ON) { + // Restore the brightness before screen off + uint32_t screenOnBrightness = GetScreenOnBrightness(); + UpdateBrightness(screenOnBrightness); + } + + if (ret) { + pms->NotifyStateChangeCallback(action_->GetDisplayId(), state); + } +} + +bool MockScreenController::CanSetBrightness() +{ + return IsScreenOn() && !IsBrightnessOverridden() && !IsBrightnessBoosted(); +} + +bool MockScreenController::CanDiscountBrightness() +{ + return IsScreenOn(); +} + +bool MockScreenController::CanOverrideBrightness() +{ + return IsScreenOn() && !IsBrightnessBoosted(); +} + +bool MockScreenController::CanBoostBrightness() +{ + return IsScreenOn() && !IsBrightnessOverridden(); +} + +bool MockScreenController::UpdateBrightness(uint32_t value, uint32_t gradualDuration, bool updateSetting) +{ + DISPLAY_HILOGD(FEAT_BRIGHTNESS, "Update brightness, value=%{public}u, discount=%{public}lf,"\ + " duration=%{public}u, updateSetting=%{public}d", value, discount_, gradualDuration, updateSetting); + + if (animator_->IsAnimating()) { + animator_->StopAnimation(); + } + if (gradualDuration > 0) { + animator_->StartAnimation(GetSettingBrightness(), value, gradualDuration); + return true; + } + auto brightness = DisplayPowerMgrService::GetSafeBrightness(static_cast(value * discount_)); + bool isSucc = action_->SetBrightness(brightness); + DISPLAY_HILOGD(FEAT_BRIGHTNESS, "Updated brightness is %{public}s, brightness: %{public}u", + isSucc ? "succ" : "failed", brightness); + if (isSucc && updateSetting) { + handler_->SendImmediateEvent(DisplayEventHandler::Event::EVENT_SET_SETTING_BRIGHTNESS, + static_cast(value)); + } + return isSucc; +} + +uint32_t MockScreenController::GetSettingBrightness(const std::string& key) const +{ + SettingProvider& provider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_ID); + int32_t value; + ErrCode ret = provider.GetIntValue(key, value); + if (ret != ERR_OK) { + DISPLAY_HILOGW(FEAT_BRIGHTNESS, "get setting brightness failed, return cachedBrightness_=%{public}u,"\ + " key=%{public}s, ret=%{public}d", cachedSettingBrightness_, key.c_str(), ret); + return cachedSettingBrightness_; + } + return static_cast(value); +} + +void MockScreenController::SetSettingBrightness(uint32_t value) +{ + uint32_t settingBrightness = GetSettingBrightness(); + if (value == static_cast(settingBrightness)) { + DISPLAY_HILOGD(FEAT_BRIGHTNESS, "no need to set setting brightness"); + return; + } + SettingProvider& provider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_ID); + ErrCode ret = provider.PutIntValue(SETTING_BRIGHTNESS_KEY, static_cast(value)); + if (ret != ERR_OK) { + DISPLAY_HILOGW(FEAT_BRIGHTNESS, "set setting brightness failed, ret=%{public}d", ret); + return; + } + cachedSettingBrightness_ = value; +} + +uint32_t MockScreenController::GetScreenOnBrightness() const +{ + if (IsBrightnessBoosted()) { + DISPLAY_HILOGD(FEAT_BRIGHTNESS, "Brightness is boosted, return max brightness"); + return DisplayParamHelper::GetMaxBrightness(); + } else if (IsBrightnessOverridden()) { + DISPLAY_HILOGD(FEAT_BRIGHTNESS, "Brightness is overridden, return overridden brightness=%{public}u", + overriddenBrightness_); + return overriddenBrightness_; + } else { + return GetSettingBrightness(); + } +} + +void MockScreenController::RegisterSettingBrightnessObserver() +{ + if (g_brightnessObserver) { + DISPLAY_HILOGD(FEAT_BRIGHTNESS, "setting brightness observer is already registered"); + return; + } + SettingProvider& provider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_ID); + SettingObserver::UpdateFunc updateFunc = [&](const std::string& key) { BrightnessSettingUpdateFunc(key); }; + g_brightnessObserver = provider.CreateObserver(SETTING_BRIGHTNESS_KEY, updateFunc); + ErrCode ret = provider.RegisterObserver(g_brightnessObserver); + if (ret != ERR_OK) { + DISPLAY_HILOGW(FEAT_BRIGHTNESS, "register setting brightness observer failed, ret=%{public}d", ret); + g_brightnessObserver = nullptr; + } +} + +void MockScreenController::BrightnessSettingUpdateFunc(const string& key) +{ + if (animator_->IsAnimating()) { + return; + } + uint32_t settingBrightness = GetSettingBrightness(key); + if (cachedSettingBrightness_ == settingBrightness) { + DISPLAY_HILOGD(FEAT_BRIGHTNESS, "no need to set setting brightness"); + return; + } + DISPLAY_HILOGD(FEAT_BRIGHTNESS, "setting brightness updated, brightness %{public}u -> %{public}u", + cachedSettingBrightness_, settingBrightness); + cachedSettingBrightness_ = settingBrightness; + UpdateBrightness(settingBrightness); +} + +void MockScreenController::UnregisterSettingBrightnessObserver() +{ + if (g_brightnessObserver == nullptr) { + DISPLAY_HILOGD(FEAT_BRIGHTNESS, "g_brightnessObserver is nullptr, no need to unregister"); + return; + } + SettingProvider& provider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_ID); + ErrCode ret = provider.UnregisterObserver(g_brightnessObserver); + if (ret != ERR_OK) { + DISPLAY_HILOGW(FEAT_BRIGHTNESS, "unregister setting brightness observer failed, ret=%{public}d", ret); + } + g_brightnessObserver = nullptr; +} + +double MockScreenController::GetDiscount() const +{ + return discount_; +} + +uint32_t MockScreenController::GetAnimationUpdateTime() const +{ + return animator_->GetAnimationUpdateTime(); +} +} // namespace DisplayPowerMgr +} // namespace OHOS \ No newline at end of file diff --git a/service/native/src/screen_controller.cpp b/service/native/src/screen_controller.cpp index 21e7957..1126025 100644 --- a/service/native/src/screen_controller.cpp +++ b/service/native/src/screen_controller.cpp @@ -39,6 +39,7 @@ ScreenController::ScreenController(uint32_t displayId, const shared_ptr(displayId); state_ = action_->GetDisplayState(); + uint32_t gradualDuration = 0; string name = "BrightnessController_" + to_string(displayId); if (animateCallback_ == nullptr) { @@ -46,7 +47,7 @@ ScreenController::ScreenController(uint32_t displayId, const shared_ptr(name, animateCallback_); - DisplayEventHandler::EventCallback cancelBoostCallback = [&](int64_t) { CancelBoostBrightness(); }; + DisplayEventHandler::EventCallback cancelBoostCallback = [&](int64_t) { CancelBoostBrightness(gradualDuration); }; handler_->EmplaceCallBack(DisplayEventHandler::Event::EVENT_CANCEL_BOOST_BRIGHTNESS, cancelBoostCallback); DisplayEventHandler::EventCallback setSettingBrightnessCallback = [&](int64_t brightness) { SetSettingBrightness(static_cast(brightness)); }; diff --git a/service/zidl/include/display_power_mgr_proxy.h b/service/zidl/include/display_power_mgr_proxy.h index 3d254b1..64ea3f9 100644 --- a/service/zidl/include/display_power_mgr_proxy.h +++ b/service/zidl/include/display_power_mgr_proxy.h @@ -54,6 +54,7 @@ public: virtual bool RegisterCallback(sptr callback) override; virtual bool BoostBrightness(int32_t timeoutMs, uint32_t displayId) override; virtual bool CancelBoostBrightness(uint32_t displayId) override; + virtual bool AddMockScreen(uint32_t displayId) override; virtual uint32_t GetDeviceBrightness(uint32_t displayId) override; virtual DisplayErrors GetError() override; diff --git a/service/zidl/include/display_power_mgr_stub.h b/service/zidl/include/display_power_mgr_stub.h index 1709bf0..8b3672c 100644 --- a/service/zidl/include/display_power_mgr_stub.h +++ b/service/zidl/include/display_power_mgr_stub.h @@ -49,6 +49,7 @@ private: int32_t BoostBrightnessStub(MessageParcel& data, MessageParcel& reply); int32_t CancelBoostBrightnessStub(MessageParcel& data, MessageParcel& reply); int32_t GetDeviceBrightnessStub(MessageParcel& data, MessageParcel& reply); + int32_t AddMockScreenStub(MessageParcel& data, MessageParcel& reply); }; } // namespace DisplayPowerMgr } // namespace OHOS diff --git a/service/zidl/src/display_power_mgr_proxy.cpp b/service/zidl/src/display_power_mgr_proxy.cpp index cf7b0c3..70e53bc 100644 --- a/service/zidl/src/display_power_mgr_proxy.cpp +++ b/service/zidl/src/display_power_mgr_proxy.cpp @@ -646,6 +646,40 @@ uint32_t DisplayPowerMgrProxy::GetDeviceBrightness(uint32_t displayId) return result; } +bool DisplayPowerMgrProxy::AddMockScreen(uint32_t displayId) +{ + DISPLAY_HILOGD(COMP_FWK, "enter proxy add mock screen id= %{public}d", displayId); + sptr remote = Remote(); + bool result = false; + + RETURN_IF_WITH_RET(remote == nullptr, result); + + MessageParcel data; + MessageParcel reply; + MessageOption option; + + if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) { + DISPLAY_HILOGE(COMP_FWK, "DisplayPowerMgrClient::%{public}s write descriptor failed!", __func__); + return result; + } + + WRITE_PARCEL_WITH_RET(data, Uint32, displayId, false); + + int ret = remote->SendRequest(static_cast(IDisplayPowerMgr::ADD_MOCK_SCREEN), + data, reply, option); + if (ret != ERR_OK) { + DISPLAY_HILOGE(COMP_FWK, "DisplayPowerMgrProxy::%{public}s SendRequest is failed,%d", __func__, ret); + return result; + } + + if (!reply.ReadBool(result)) { + DISPLAY_HILOGE(COMP_FWK, "Readback fail!"); + return result; + } + + return result; +} + DisplayErrors DisplayPowerMgrProxy::GetError() { return lastError_; diff --git a/service/zidl/src/display_power_mgr_stub.cpp b/service/zidl/src/display_power_mgr_stub.cpp index 53b31e1..e57ce65 100644 --- a/service/zidl/src/display_power_mgr_stub.cpp +++ b/service/zidl/src/display_power_mgr_stub.cpp @@ -101,6 +101,9 @@ int32_t DisplayPowerMgrStub::OnRemoteRequest(uint32_t code, MessageParcel &data, case static_cast(IDisplayPowerMgr::GET_DEVICE_BRIGHTNESS): ret = GetDeviceBrightnessStub(data, reply); break; + case static_cast(IDisplayPowerMgr::ADD_MOCK_SCREEN): + ret = AddMockScreenStub(data, reply); + break; default: ret = IPCObjectStub::OnRemoteRequest(code, data, reply, option); break; @@ -369,5 +372,20 @@ int32_t DisplayPowerMgrStub::GetDeviceBrightnessStub(MessageParcel& data, Messag } return ERR_OK; } + +int32_t DisplayPowerMgrStub::AddMockScreenStub(MessageParcel& data, MessageParcel& reply) +{ + DISPLAY_HILOGD(COMP_SVC, "enter add mock screen stub"); + uint32_t displayId = 0; + + READ_PARCEL_WITH_RET(data, Uint32, displayId, E_READ_PARCEL_ERROR); + DISPLAY_HILOGD(COMP_SVC, "id= %{public}d", displayId); + bool isScuu = AddMockScreen(displayId); + if (!reply.WriteBool(isScuu)) { + DISPLAY_HILOGE(COMP_SVC, "Failed to add mock return value"); + return E_WRITE_PARCEL_ERROR; + } + return ERR_OK; +} } // namespace DisplayPowerMgr } // namespace OHOS diff --git a/test/unittest/common/native/BUILD.gn b/test/unittest/common/native/BUILD.gn index 112cc31..d7c67f9 100644 --- a/test/unittest/common/native/BUILD.gn +++ b/test/unittest/common/native/BUILD.gn @@ -40,6 +40,7 @@ ohos_unittest("unittest_display_mgr_service") { deps = [ "${displaymgr_innerkits}:displaymgr", + "${displaymgr_utils_path}:mockdisplaymgr", "${powermgr_utils_path}/setting:power_setting", "//third_party/googletest:gtest_main", ] 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 2228abe..d8894c9 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 @@ -15,6 +15,7 @@ #include #include "display_power_mgr_client.h" +#include "mock_display_power_mgr_client.h" #include "setting_provider.h" #include "system_ability_definition.h" #include "display_log.h" @@ -27,20 +28,29 @@ 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 MOCK_DISPLAY_ID = 1; } class DisplayPowerMgrBrightnessTest : public Test { public: + static void SetUpTestCase(void) { + MockDisplayPowerMgrClient::GetInstance().AddMockScreen(MOCK_DISPLAY_ID); + } void SetUp() { DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_ON); + auto reason = PowerMgr::StateChangeReason::STATE_CHANGE_REASON_UNKNOWN; + DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_ON, reason, MOCK_DISPLAY_ID); DisplayPowerMgrClient::GetInstance().DiscountBrightness(NO_DISCOUNT); + DisplayPowerMgrClient::GetInstance().DiscountBrightness(NO_DISCOUNT, MOCK_DISPLAY_ID); } void TearDown() { DisplayPowerMgrClient::GetInstance().RestoreBrightness(); + DisplayPowerMgrClient::GetInstance().RestoreBrightness(MOCK_DISPLAY_ID); DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(); + DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(MOCK_DISPLAY_ID); } }; @@ -741,4 +751,639 @@ HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrAdjustBrightness002, Test EXPECT_FALSE(ret); } } + +/** + * @tc.name: MultiScreenMgrSetBrightness001 + * @tc.desc: Test SetBrightness + * @tc.type: FUNC + * @tc.require: issuesI5I9FM + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, MultiScreenMgrSetBrightness001, TestSize.Level0) +{ + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrBrightness001: fun is start"); + bool ret = DisplayPowerMgrClient::GetInstance().SetBrightness(200, MOCK_DISPLAY_ID); + EXPECT_TRUE(ret); + uint32_t deviceBrightness = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(MOCK_DISPLAY_ID); + EXPECT_EQ(deviceBrightness, 200); + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrBrightness001: fun is end"); +} + +/** + * @tc.name: MultiScreenMgrDiscountBrightnessNormal + * @tc.desc: Test DiscountBrightness the normal test + * @tc.type: FUNC + * @tc.require: issuesI5I9FM + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, MultiScreenMgrDiscountBrightnessNormal, TestSize.Level0) +{ + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrDiscountBrightnessNormal: fun is start"); + const uint32_t SET_BRIGHTNESS = 100; + DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS, MOCK_DISPLAY_ID); + const double DISCOUNT_NORMAL = 0.8; + bool ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_NORMAL, MOCK_DISPLAY_ID); + EXPECT_TRUE(ret); + + uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(MOCK_DISPLAY_ID); + EXPECT_EQ(value, static_cast(SET_BRIGHTNESS * DISCOUNT_NORMAL)); + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrDiscountBrightnessNormal: fun is end"); +} + +/** + * @tc.name: MultiScreenMgrDiscountBrightnessNormal + * @tc.desc: Test DiscountBrightness when screen is off + * @tc.type: FUNC + * @tc.require: issuesI5I9FM + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, MultiScreenMgrDiscountBrightnessScreenOff, TestSize.Level0) +{ + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrDiscountBrightnessScreenOff: fun is start"); + auto reason = PowerMgr::StateChangeReason::STATE_CHANGE_REASON_UNKNOWN; + DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_OFF, reason, MOCK_DISPLAY_ID); + const double DISCOUNT_VALUE = 0.8; + bool ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_VALUE, MOCK_DISPLAY_ID); + EXPECT_FALSE(ret); + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrDiscountBrightnessScreenOff: fun is end"); +} + +/** + * @tc.name: MultiScreenMgrDiscountBrightnessBoundary001 + * @tc.desc: Test DiscountBrightness the boundary test + * @tc.type: FUNC + * @tc.require: issuesI5I9FM + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, MultiScreenMgrDiscountBrightnessBoundary001, TestSize.Level0) +{ + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrDiscountBrightnessBoundary001: fun is start"); + const uint32_t SET_BRIGHTNESS = 100; + DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS, MOCK_DISPLAY_ID); + const double DISCOUNT_LOWER_BOUNDARY = 0.01; + bool ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_LOWER_BOUNDARY, MOCK_DISPLAY_ID); + EXPECT_TRUE(ret); + + uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(MOCK_DISPLAY_ID); + uint32_t minBrightness = DisplayPowerMgrClient::GetInstance().GetMinBrightness(); + EXPECT_EQ(value, minBrightness); + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrDiscountBrightnessBoundary001: fun is end"); +} + +/** + * @tc.name: MultiScreenMgrDiscountBrightnessBoundary002 + * @tc.desc: Test DiscountBrightness the boundary test + * @tc.type: FUNC + * @tc.require: issuesI5I9FM + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, MultiScreenMgrDiscountBrightnessBoundary002, TestSize.Level0) +{ + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrDiscountBrightnessBoundary002: fun is start"); + const uint32_t SET_BRIGHTNESS = 100; + DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS, MOCK_DISPLAY_ID); + const double DISCOUNT_UPPER_BOUNDARY = 1.0; + bool ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_UPPER_BOUNDARY, MOCK_DISPLAY_ID); + EXPECT_TRUE(ret); + + uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(MOCK_DISPLAY_ID); + EXPECT_EQ(value, static_cast(SET_BRIGHTNESS * DISCOUNT_UPPER_BOUNDARY)); + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrDiscountBrightnessBoundary002: fun is end"); +} + +/** + * @tc.name: MultiScreenMgrDiscountBrightnessAbnormal001 + * @tc.desc: Test DiscountBrightness the abnormal test + * @tc.type: FUNC + * @tc.require: issuesI5I9FM + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, MultiScreenMgrDiscountBrightnessAbnormal001, TestSize.Level0) +{ + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrDiscountBrightnessAbnormal001: fun is start"); + const uint32_t SET_BRIGHTNESS = 100; + DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS, MOCK_DISPLAY_ID); + const double DISCOUNT_BEYOND_LOWER_BOUNDARY = 0.0; + bool ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_BEYOND_LOWER_BOUNDARY, MOCK_DISPLAY_ID); + EXPECT_TRUE(ret); + + uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(MOCK_DISPLAY_ID); + uint32_t minBrightness = DisplayPowerMgrClient::GetInstance().GetMinBrightness(); + EXPECT_EQ(value, minBrightness); + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrDiscountBrightnessAbnormal001: fun is end"); +} + +/** + * @tc.name: MultiScreenMgrDiscountBrightnessAbnormal002 + * @tc.desc: Test DiscountBrightness the abnormal test + * @tc.type: FUNC + * @tc.require: issuesI5I9FM + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, MultiScreenMgrDiscountBrightnessAbnormal002, TestSize.Level0) +{ + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrDiscountBrightnessAbnormal002: fun is start"); + const uint32_t SET_BRIGHTNESS = 100; + DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS, MOCK_DISPLAY_ID); + const double DISCOUNT_BEYOND_UPPER_BOUNDARY = 2.0; + bool ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_BEYOND_UPPER_BOUNDARY, MOCK_DISPLAY_ID); + EXPECT_TRUE(ret); + + uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(MOCK_DISPLAY_ID); + const double DISCOUNT_MAX_VALUE = 1.0; + EXPECT_EQ(value, static_cast(SET_BRIGHTNESS * DISCOUNT_MAX_VALUE)); + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrDiscountBrightnessAbnormal002: fun is end"); +} + +/** + * @tc.name: MultiScreenMgrDiscountBrightnessAbnormal003 + * @tc.desc: Test DiscountBrightness the abnormal test + * @tc.type: FUNC + * @tc.require: issuesI5I9FM + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, MultiScreenMgrDiscountBrightnessAbnormal003, TestSize.Level0) +{ + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrDiscountBrightnessAbnormal003: fun is start"); + const uint32_t SET_BRIGHTNESS = 100; + DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS, MOCK_DISPLAY_ID); + const double DISCOUNT_NEGATIVE_VALUE = -1.0; + bool ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_NEGATIVE_VALUE, MOCK_DISPLAY_ID); + EXPECT_TRUE(ret); + + uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(MOCK_DISPLAY_ID); + uint32_t minBrightness = DisplayPowerMgrClient::GetInstance().GetMinBrightness(); + EXPECT_EQ(value, minBrightness); + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrDiscountBrightnessAbnormal003: fun is end"); +} + +/** + * @tc.name: MultiScreenMgrDiscountBrightness001 + * @tc.desc: Test OverrideBrightness after DiscountBrightness, then RestoreBrightness + * @tc.type: FUNC + * @tc.require: issuesI5I9FM + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, MultiScreenMgrDiscountBrightness001, TestSize.Level0) +{ + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrDiscountBrightness001: fun is start"); + const uint32_t SET_BRIGHTNESS = 100; + DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS, MOCK_DISPLAY_ID); + const double DISCOUNT_VALUE = 0.8; + bool ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_VALUE, MOCK_DISPLAY_ID); + EXPECT_TRUE(ret); + + uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(MOCK_DISPLAY_ID); + EXPECT_EQ(value, static_cast(DISCOUNT_VALUE * SET_BRIGHTNESS)); + + const uint32_t SET_OVERRIDE_BRIGHTNESS = 200; + DisplayPowerMgrClient::GetInstance().OverrideBrightness(SET_OVERRIDE_BRIGHTNESS, MOCK_DISPLAY_ID); + value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(MOCK_DISPLAY_ID); + EXPECT_EQ(value, static_cast(DISCOUNT_VALUE * SET_OVERRIDE_BRIGHTNESS)); + + DisplayPowerMgrClient::GetInstance().RestoreBrightness(MOCK_DISPLAY_ID); + value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(MOCK_DISPLAY_ID); + EXPECT_EQ(value, static_cast(DISCOUNT_VALUE * SET_BRIGHTNESS)); + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrDiscountBrightness001: fun is end"); +} + +/** + * @tc.name: MultiScreenMgrDiscountBrightness002 + * @tc.desc: Test DiscountBrightness after OverrideBrightness, then RestoreBrightness + * @tc.type: FUNC + * @tc.require: issuesI5I9FM + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, MultiScreenMgrDiscountBrightness002, TestSize.Level0) +{ + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrDiscountBrightness002: fun is start"); + const uint32_t SET_BRIGHTNESS = 100; + DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS, MOCK_DISPLAY_ID); + const uint32_t SET_OVERRIDE_BRIGHTNESS = 200; + DisplayPowerMgrClient::GetInstance().OverrideBrightness(SET_OVERRIDE_BRIGHTNESS, MOCK_DISPLAY_ID); + + const double DISCOUNT_VALUE = 0.8; + double ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_VALUE, MOCK_DISPLAY_ID); + EXPECT_TRUE(ret); + uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(MOCK_DISPLAY_ID); + EXPECT_EQ(value, static_cast(DISCOUNT_VALUE * SET_OVERRIDE_BRIGHTNESS)); + + ret = DisplayPowerMgrClient::GetInstance().RestoreBrightness(MOCK_DISPLAY_ID); + EXPECT_TRUE(ret); + + value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(MOCK_DISPLAY_ID); + EXPECT_EQ(value, static_cast(DISCOUNT_VALUE * SET_BRIGHTNESS)); + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrDiscountBrightness002: fun is end"); +} + +/** + * @tc.name: MultiScreenMgrDiscountBrightness003 + * @tc.desc: Test DisconutBrightness after BoostBrightness and CancelBoostBrightness + * @tc.type: FUNC + * @tc.require: issuesI5I9FM + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, MultiScreenMgrDiscountBrightness003, TestSize.Level0) +{ + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrDiscountBrightness003: fun is start"); + const uint32_t SET_BRIGHTNESS = 100; + DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS, MOCK_DISPLAY_ID); + const uint32_t SET_BOOST_BRIGHTNESS = 10000; + DisplayPowerMgrClient::GetInstance().BoostBrightness(SET_BOOST_BRIGHTNESS, MOCK_DISPLAY_ID); + + const double DISCOUNT_VALUE = 0.8; + bool ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_VALUE, MOCK_DISPLAY_ID); + EXPECT_TRUE(ret); + + + uint32_t maxBrightness = DisplayPowerMgrClient::GetInstance().GetMaxBrightness(); + uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(MOCK_DISPLAY_ID); + EXPECT_EQ(value, static_cast(DISCOUNT_VALUE * maxBrightness)); + + DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(MOCK_DISPLAY_ID); + + value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(MOCK_DISPLAY_ID); + EXPECT_EQ(value, static_cast(DISCOUNT_VALUE * SET_BRIGHTNESS)); + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrDiscountBrightness003: fun is end"); +} + +/** + * @tc.name: MultiScreenMgrDiscountBrightness004 + * @tc.desc: Test BoostBrightness after DiscountBrightness, then CancelBoostBrightness + * @tc.type: FUNC + * @tc.require: issuesI5I9FM + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, MultiScreenMgrDiscountBrightness004, TestSize.Level0) +{ + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrDiscountBrightness004: fun is start"); + const uint32_t SET_BRIGHTNESS = 100; + DisplayPowerMgrClient::GetInstance().SetBrightness(SET_BRIGHTNESS, MOCK_DISPLAY_ID); + const double DISCOUNT_VALUE = 0.8; + bool ret = DisplayPowerMgrClient::GetInstance().DiscountBrightness(DISCOUNT_VALUE, MOCK_DISPLAY_ID); + EXPECT_TRUE(ret); + + const uint32_t SET_BOOST_BRIGHTNESS = 10000; + DisplayPowerMgrClient::GetInstance().BoostBrightness(SET_BOOST_BRIGHTNESS, MOCK_DISPLAY_ID); + uint32_t maxBrightness = DisplayPowerMgrClient::GetInstance().GetMaxBrightness(); + uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(MOCK_DISPLAY_ID); + EXPECT_EQ(value, static_cast(DISCOUNT_VALUE * maxBrightness)); + + DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(MOCK_DISPLAY_ID); + + value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(MOCK_DISPLAY_ID); + EXPECT_EQ(value, static_cast(DISCOUNT_VALUE * SET_BRIGHTNESS)); + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrDiscountBrightness004: fun is end"); +} + +/** + * @tc.name: MultiScreenMgrOverrideBrightness001 + * @tc.desc: Test OverrideBrightness + * @tc.type: FUNC + * @tc.require: issuesI5I9FM + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, MultiScreenMgrOverrideBrightness001, TestSize.Level0) +{ + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrBrightness002: fun is start"); + bool ret = DisplayPowerMgrClient::GetInstance().OverrideBrightness(255, MOCK_DISPLAY_ID); + EXPECT_TRUE(ret); + sleep(1); // wait for gradual animation + uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(MOCK_DISPLAY_ID); + EXPECT_EQ(value, 255); + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrBrightness002: fun is end"); +} + +/** + * @tc.name: MultiScreenMgrOverrideBrightness003 + * @tc.desc: Test SetBrightness after OverrideBrightness + * @tc.type: FUNC + * @tc.require: issuesI5I9FM + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, MultiScreenMgrOverrideBrightness003, TestSize.Level0) +{ + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrBrightness004: fun is start"); + bool ret = DisplayPowerMgrClient::GetInstance().OverrideBrightness(255, MOCK_DISPLAY_ID); + EXPECT_TRUE(ret); + sleep(1); // wait for gradual animation + ret = DisplayPowerMgrClient::GetInstance().SetBrightness(100, MOCK_DISPLAY_ID); + EXPECT_FALSE(ret); + sleep(1); // wait for gradual animation + uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(MOCK_DISPLAY_ID); + EXPECT_EQ(value, 255); + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrBrightness004: fun is end"); +} + +/** + * @tc.name: MultiScreenMgrOverrideBrightness005 + * @tc.desc: Test OverrideBrightness off Disable the call + * @tc.type: FUNC + * @tc.require: issuesI5I9FM + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, MultiScreenMgrOverrideBrightness005, TestSize.Level0) +{ + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrBrightness006: fun is start"); + auto reason = PowerMgr::StateChangeReason::STATE_CHANGE_REASON_UNKNOWN; + DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_OFF, reason, MOCK_DISPLAY_ID); + bool isBoost = DisplayPowerMgrClient::GetInstance().OverrideBrightness(200, MOCK_DISPLAY_ID); + EXPECT_FALSE(isBoost); + bool isRestore = DisplayPowerMgrClient::GetInstance().RestoreBrightness(MOCK_DISPLAY_ID); + EXPECT_FALSE(isRestore); + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrBrightness006: fun is end"); +} + +/** + * @tc.name: MultiScreenMgrMaxBrightness001 + * @tc.desc: Test GetMaxBrightness less equals 255 + * @tc.type: FUNC + * @tc.require: issuesI5I9FM + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, MultiScreenMgrMaxBrightness001, TestSize.Level0) +{ + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrMaxBrightness001: fun is start"); + uint32_t max = DisplayPowerMgrClient::GetInstance().GetMaxBrightness(); + EXPECT_LE(max, 255); + bool ret = DisplayPowerMgrClient::GetInstance().SetBrightness((max + 100), MOCK_DISPLAY_ID); + EXPECT_TRUE(ret); + sleep(1); // wait for gradual animation + uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(MOCK_DISPLAY_ID); + EXPECT_EQ(value, max); + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrMaxBrightness001: fun is end"); +} + +/** + * @tc.name: MultiScreenMgrMinBrightness001 + * @tc.desc: Test GetMinBrightness greater equals 0 + * @tc.type: FUNC + * @tc.require: issuesI5I9FM + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, MultiScreenMgrMinBrightness001, TestSize.Level0) +{ + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrMinBrightness001: fun is start"); + uint32_t min = DisplayPowerMgrClient::GetInstance().GetMinBrightness(); + EXPECT_GE(min, 0); + bool ret = DisplayPowerMgrClient::GetInstance().SetBrightness(0, MOCK_DISPLAY_ID); + EXPECT_TRUE(ret); + sleep(1); // wait for gradual animation + uint32_t value = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(MOCK_DISPLAY_ID); + EXPECT_EQ(value, min); + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrMinBrightness001: fun is end"); +} + +/** + * @tc.name: MultiScreenMgrDefaultBrightness001 + * @tc.desc: Test GetDefaultnBrightness greater equals 0 and less equals 255 + * @tc.type: FUNC + * @tc.require: issuesI5I9FM + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, MultiScreenMgrDefaultBrightness001, TestSize.Level0) +{ + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrDefaultBrightness001: fun is start"); + uint32_t value = DisplayPowerMgrClient::GetInstance().GetDefaultBrightness(); + EXPECT_GE(value, 0); + EXPECT_LE(value, 255); + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrDefaultBrightness001: fun is end"); +} + +/** + * @tc.name: MultiScreenMgrBoostBrightnessNormal + * @tc.desc: Test BoostBrightness the normal test + * @tc.type: FUNC + * @tc.require: issuesI5I9FM + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, MultiScreenMgrBoostBrightnessNormal, TestSize.Level0) +{ + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrBoostBrightnessNormal: fun is start"); + bool isSucc = DisplayPowerMgrClient::GetInstance().BoostBrightness(1000, MOCK_DISPLAY_ID); + EXPECT_TRUE(isSucc); + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrBoostBrightnessNormal: fun is end"); +} + +/** + * @tc.name: MultiScreenMgrBoostBrightnessAbnormal + * @tc.desc: Test BoostBrightness the abnormal value + * @tc.type: FUNC + * @tc.require: issuesI5I9FM + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, MultiScreenMgrBoostBrightnessAbnormal, TestSize.Level0) +{ + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrBoostBrightnessAbnormal: fun is start"); + bool isSucc = DisplayPowerMgrClient::GetInstance().BoostBrightness(-1, MOCK_DISPLAY_ID); + EXPECT_FALSE(isSucc); + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrBoostBrightnessAbnormal: fun is end"); +} + +/** + * @tc.name: MultiScreenMgrCancelBoostBrightnessNormal + * @tc.desc: Test CancelBoostBrightness the normal test + * @tc.type: FUNC + * @tc.require: issuesI5I9FM + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, MultiScreenMgrCancelBoostBrightnessNormal, TestSize.Level0) +{ + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrCancelBoostBrightnessNormal: fun is start"); + bool isSucc = DisplayPowerMgrClient::GetInstance().BoostBrightness(50000, MOCK_DISPLAY_ID); + EXPECT_TRUE(isSucc); + sleep(1); + bool isCancel = DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(MOCK_DISPLAY_ID); + EXPECT_TRUE(isCancel); + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrCancelBoostBrightnessNormal: fun is end"); +} + +/** + * @tc.name: MultiScreenBoostAndOverrideMutuallyExclusive1 + * @tc.desc: Test BoostBrightness and OverrideBrightness are mutually exclusive + * @tc.type: FUNC + * @tc.require: issuesI5I9FM + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, MultiScreenBoostAndOverrideMutuallyExclusive1, TestSize.Level0) +{ + DISPLAY_HILOGD(LABEL_TEST, "BoostAndOverrideMutuallyExclusive: fun is start"); + bool isBoost = DisplayPowerMgrClient::GetInstance().BoostBrightness(50000, MOCK_DISPLAY_ID); + EXPECT_TRUE(isBoost); + sleep(1); + bool isOverride = DisplayPowerMgrClient::GetInstance().OverrideBrightness(200, MOCK_DISPLAY_ID); + EXPECT_FALSE(isOverride); + bool isRestore = DisplayPowerMgrClient::GetInstance().RestoreBrightness(MOCK_DISPLAY_ID); + EXPECT_FALSE(isRestore); + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenBoostAndOverrideMutuallyExclusive: fun is end"); +} + +/** + * @tc.name: MultiScreenBoostAndOverrideMutuallyExclusive2 + * @tc.desc: Test BoostBrightness and OverrideBrightness are mutually exclusive + * @tc.type: FUNC + * @tc.require: issuesI5I9FM + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, MultiScreenBoostAndOverrideMutuallyExclusive2, TestSize.Level0) +{ + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenBoostAndOverrideMutuallyExclusive2: fun is start"); + bool isOverride = DisplayPowerMgrClient::GetInstance().OverrideBrightness(200, MOCK_DISPLAY_ID); + EXPECT_TRUE(isOverride); + sleep(1); + bool isBoost = DisplayPowerMgrClient::GetInstance().BoostBrightness(50000, MOCK_DISPLAY_ID); + EXPECT_FALSE(isBoost); + bool isCancel = DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(MOCK_DISPLAY_ID); + EXPECT_FALSE(isCancel); + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenBoostAndOverrideMutuallyExclusive2: fun is end"); +} + +/** + * @tc.name: MultiScreenMgrBoostBrightnessCancel1 + * @tc.desc: Test BoostBrightness Cancel restore system brightness + * @tc.type: FUNC + * @tc.require: issuesI5I9FM + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, MultiScreenMgrBoostBrightnessCancel1, TestSize.Level0) +{ + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrBoostBrightnessCancel1: fun is start"); + uint32_t beforeValue = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(MOCK_DISPLAY_ID); + bool isBoost = DisplayPowerMgrClient::GetInstance().BoostBrightness(10000, MOCK_DISPLAY_ID); + EXPECT_TRUE(isBoost); + sleep(1); + bool isCancel = DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(MOCK_DISPLAY_ID); + EXPECT_TRUE(isCancel); + sleep(1); + uint32_t currentValue = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(MOCK_DISPLAY_ID); + EXPECT_EQ(beforeValue, currentValue) << "beforeValue: " << beforeValue << " currentVal: " << currentValue; + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrBoostBrightnessCancel1: fun is end"); +} + +/** + * @tc.name: MultiScreenMgrBoostBrightnessCancel2 + * @tc.desc: Test BoostBrightness Cancel brightness adjustment can be called + * @tc.type: FUNC + * @tc.require: issuesI5I9FM + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, MultiScreenMgrBoostBrightnessCancel2, TestSize.Level0) +{ + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrBoostBrightnessCancel2: fun is start"); + bool isBoost = DisplayPowerMgrClient::GetInstance().BoostBrightness(10000, MOCK_DISPLAY_ID); + EXPECT_TRUE(isBoost); + sleep(1); + bool isCancel = DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(MOCK_DISPLAY_ID); + EXPECT_TRUE(isCancel); + bool isSet = DisplayPowerMgrClient::GetInstance().SetBrightness(222, MOCK_DISPLAY_ID); + EXPECT_TRUE(isSet); + uint32_t currentValue = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(MOCK_DISPLAY_ID); + EXPECT_EQ(222, currentValue); + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrBoostBrightnessCancel2: fun is end"); +} + +/** + * @tc.name: MultiScreenMgrBoostBrightnessNotAdjust + * @tc.desc: Test BoostBrightness do not adjust brightness + * @tc.type: FUNC + * @tc.require: issuesI5I9FM + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, MultiScreenMgrBoostBrightnessNotAdjust, TestSize.Level0) +{ + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrBoostBrightnessNotAdjust: fun is start"); + bool isBoost = DisplayPowerMgrClient::GetInstance().BoostBrightness(10000, MOCK_DISPLAY_ID); + EXPECT_TRUE(isBoost); + sleep(1); + bool isSet = DisplayPowerMgrClient::GetInstance().SetBrightness(100, MOCK_DISPLAY_ID); + EXPECT_FALSE(isSet); + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrBoostBrightnessNotAdjust: fun is end"); +} + +/** + * @tc.name: MultiScreenMgrBoostBrightnessScreenOff + * @tc.desc: Test BoostBrightness off Disable the call + * @tc.type: FUNC + * @tc.require: issuesI5I9FM + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, MultiScreenMgrBoostBrightnessScreenOff, TestSize.Level0) +{ + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrBoostBrightnessScreenOff: fun is start"); + auto reason = PowerMgr::StateChangeReason::STATE_CHANGE_REASON_UNKNOWN; + + DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_OFF, reason, MOCK_DISPLAY_ID); + bool isBoost = DisplayPowerMgrClient::GetInstance().BoostBrightness(10000, MOCK_DISPLAY_ID); + EXPECT_FALSE(isBoost); + bool isCancel = DisplayPowerMgrClient::GetInstance().CancelBoostBrightness(MOCK_DISPLAY_ID); + EXPECT_FALSE(isCancel); + DISPLAY_HILOGD(LABEL_TEST, "MultiScreenMgrBoostBrightnessScreenOff: fun is end"); +} + +/** + * @tc.name: DisplayPowerMgrMultiScreenSetBrightness001 + * @tc.desc: Test MultiScreenSetBrightness + * @tc.type: FUNC + * @tc.require: issuesI5I9FM + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrMultiScreenSetBrightness001, TestSize.Level0) +{ + DISPLAY_HILOGD(LABEL_TEST, "DisplayPowerMgrMultiScreenSetBrightness001: fun is start"); + uint32_t brightness = 100; + bool ret = DisplayPowerMgrClient::GetInstance().SetBrightness(brightness, MOCK_DISPLAY_ID); + EXPECT_TRUE(ret); + uint32_t deviceBrightness = DisplayPowerMgrClient::GetInstance().GetDeviceBrightness(MOCK_DISPLAY_ID); + EXPECT_EQ(deviceBrightness, brightness); + DISPLAY_HILOGD(LABEL_TEST, "DisplayPowerMgrMultiScreenSetBrightness001: fun is end"); +} + +/** + * @tc.name: DisplayPowerMgrMultiScreenSetBrightness002 + * @tc.desc: Test MultiScreenSetBrightness when passing a inexisten display ID + * @tc.type: FUNC + * @tc.require: issuesI5I9FM + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrMultiScreenSetBrightness002, TestSize.Level0) +{ + DISPLAY_HILOGD(LABEL_TEST, "DisplayPowerMgrMultiScreenSetBrightness002: fun is start"); + uint32_t MOCK_DISPLAY_ID = 99; + uint32_t brightness = 100; + std::vector ids = DisplayPowerMgrClient::GetInstance().GetDisplayIds(); + int32_t num = count(ids.begin(), ids.end(), MOCK_DISPLAY_ID); + EXPECT_EQ(num, 0); + bool ret = DisplayPowerMgrClient::GetInstance().SetBrightness(brightness, MOCK_DISPLAY_ID); + EXPECT_FALSE(ret); + DISPLAY_HILOGD(LABEL_TEST, "DisplayPowerMgrMultiScreenSetBrightness002: fun is end"); +} + +/** + * @tc.name: DisplayPowerMgrMultiScreenDisplayState001 + * @tc.desc: Test DisplayPowerMgrMultiScreenDisplayState when screen is on + * @tc.type: FUNC + * @tc.require: issuesI5I9FM + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrMultiScreenDisplayState001, TestSize.Level0) +{ + DISPLAY_HILOGD(LABEL_TEST, "DisplayPowerMgrMultiScreenDisplayState001: fun is start"); + auto reason = PowerMgr::StateChangeReason::STATE_CHANGE_REASON_UNKNOWN; + DisplayState state1 = DisplayPowerMgrClient::GetInstance().GetDisplayState(MOCK_DISPLAY_ID); + EXPECT_TRUE(state1 == DisplayState::DISPLAY_ON); + auto ret = DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_OFF, reason, MOCK_DISPLAY_ID); + EXPECT_TRUE(ret); + DisplayState state2 = DisplayPowerMgrClient::GetInstance().GetDisplayState(MOCK_DISPLAY_ID); + EXPECT_TRUE(state2 == DisplayState::DISPLAY_OFF); + DISPLAY_HILOGD(LABEL_TEST, "DisplayPowerMgrMultiScreenDisplayState001: fun is end"); +} + +/** + * @tc.name: DisplayPowerMgrMultiScreenDisplayState002 + * @tc.desc: Test DisplayPowerMgrMultiScreenDisplayState when screen is off + * @tc.type: FUNC + * @tc.require: issuesI5I9FM + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrMultiScreenDisplayState002, TestSize.Level0) +{ + DISPLAY_HILOGD(LABEL_TEST, "DisplayPowerMgrMultiScreenDisplayState002: fun is start"); + auto reason = PowerMgr::StateChangeReason::STATE_CHANGE_REASON_UNKNOWN; + DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_OFF, reason, MOCK_DISPLAY_ID); + DisplayState state1 = DisplayPowerMgrClient::GetInstance().GetDisplayState(MOCK_DISPLAY_ID); + EXPECT_TRUE(state1 == DisplayState::DISPLAY_OFF); + auto ret = DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_ON, reason, MOCK_DISPLAY_ID); + EXPECT_TRUE(ret); + DisplayState state2 = DisplayPowerMgrClient::GetInstance().GetDisplayState(MOCK_DISPLAY_ID); + EXPECT_TRUE(state2 == DisplayState::DISPLAY_ON); + DISPLAY_HILOGD(LABEL_TEST, "DisplayPowerMgrMultiScreenDisplayState002: fun is end"); +} + +/** + * @tc.name: DisplayPowerMgrMultiScreenDisplayState003 + * @tc.desc: Test DisplayPowerMgrMultiScreenDisplayState when passing a inexisten display ID + * @tc.type: FUNC + * @tc.require: issuesI5I9FM + */ +HWTEST_F(DisplayPowerMgrBrightnessTest, DisplayPowerMgrMultiScreenDisplayState003, TestSize.Level0) +{ + DISPLAY_HILOGD(LABEL_TEST, "DisplayPowerMgrMultiScreenDisplayState003: fun is start"); + uint32_t MOCK_DISPLAY_ID = 99; + auto reason = PowerMgr::StateChangeReason::STATE_CHANGE_REASON_UNKNOWN; + std::vector ids = DisplayPowerMgrClient::GetInstance().GetDisplayIds(); + int32_t num = count(ids.begin(), ids.end(), MOCK_DISPLAY_ID); + EXPECT_EQ(num, 0); + auto ret = DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayState::DISPLAY_ON, reason, MOCK_DISPLAY_ID); + EXPECT_FALSE(ret); + DISPLAY_HILOGD(LABEL_TEST, "DisplayPowerMgrMultiScreenDisplayState003: fun is end"); +} } \ No newline at end of file diff --git a/utils/BUILD.gn b/utils/BUILD.gn index d83c63a..61bfd82 100644 --- a/utils/BUILD.gn +++ b/utils/BUILD.gn @@ -19,3 +19,27 @@ config("utils_config") { "//commonlibrary/c_utils/base/include", ] } + +config("mock_displaymgr_private_config") { + include_dirs = [ + "native/mock/include", + "//base/powermgr/display_manager/interfaces/innerkits/native/include", + ] +} + +ohos_source_set("mockdisplaymgr") { + sources = [ "native/mock/src/mock_display_power_mgr_client.cpp" ] + + configs = [ "${displaymgr_utils_path}:utils_config" ] + + public_configs = [ ":mock_displaymgr_private_config" ] + + external_deps = [ + "c_utils:utils", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + "samgr:samgr_proxy", + ] + + part_name = "${displaymgr_part_name}" +} diff --git a/utils/native/mock/include/mock_display_power_mgr_client.h b/utils/native/mock/include/mock_display_power_mgr_client.h new file mode 100644 index 0000000..5bf7804 --- /dev/null +++ b/utils/native/mock/include/mock_display_power_mgr_client.h @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2021-2022 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 MOCK_DISPLAYMGR_DISPLAY_MGR_CLIENT_H +#define MOCK_DISPLAYMGR_DISPLAY_MGR_CLIENT_H + +#include +#include +#include + +#include "idisplay_power_mgr.h" + +namespace OHOS { +namespace DisplayPowerMgr { +class MockDisplayPowerMgrClient : public DelayedRefSingleton { + DECLARE_DELAYED_REF_SINGLETON(MockDisplayPowerMgrClient); + +public: + bool AddMockScreen(uint32_t displayId = 0); + +private: + class DisplayDeathRecipient : public IRemoteObject::DeathRecipient { + public: + explicit DisplayDeathRecipient(MockDisplayPowerMgrClient& client) : client_(client) {} + ~DisplayDeathRecipient() override = default; + void OnRemoteDied(const wptr& remote) override + { + client_.OnRemoteDied(remote); + } + + private: + MockDisplayPowerMgrClient& client_; + }; + + sptr GetProxy(); + + void OnRemoteDied(const wptr& remote); + + std::mutex mutex_; + sptr proxy_ {nullptr}; + sptr deathRecipient_ {nullptr}; +}; +} // namespace DisplayPowerMgr +} // namespace OHOS +#endif // MOCK_DISPLAYMGR_DISPLAY_MGR_CLIENT_H diff --git a/utils/native/mock/src/mock_display_power_mgr_client.cpp b/utils/native/mock/src/mock_display_power_mgr_client.cpp new file mode 100644 index 0000000..aedd481 --- /dev/null +++ b/utils/native/mock/src/mock_display_power_mgr_client.cpp @@ -0,0 +1,88 @@ +/* + * Copyright (c) 2021-2022 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 "mock_display_power_mgr_client.h" + +#include +#include +#include +#include "new" +#include "refbase.h" +#include "iremote_broker.h" +#include "iremote_object.h" + +#include "display_common.h" +#include "idisplay_power_mgr.h" + +namespace OHOS { +namespace DisplayPowerMgr { +MockDisplayPowerMgrClient::MockDisplayPowerMgrClient() = default; +MockDisplayPowerMgrClient::~MockDisplayPowerMgrClient() = default; + +sptr MockDisplayPowerMgrClient::GetProxy() +{ + std::lock_guard lock(mutex_); + if (proxy_ != nullptr) { + return proxy_; + } + + sptr sam = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + if (sam == nullptr) { + DISPLAY_HILOGE(COMP_FWK, "Failed to get system ability manager"); + return nullptr; + } + sptr obj = sam->CheckSystemAbility(DISPLAY_MANAGER_SERVICE_ID); + if (obj == nullptr) { + DISPLAY_HILOGE(COMP_FWK, "Failed to get display manager service"); + return nullptr; + } + sptr dr = new DisplayDeathRecipient(*this); + if ((obj->IsProxyObject()) && (!obj->AddDeathRecipient(dr))) { + DISPLAY_HILOGE(COMP_FWK, "Failed to add death recipient"); + return nullptr; + } + + proxy_ = iface_cast(obj); + deathRecipient_ = dr; + DISPLAY_HILOGI(COMP_FWK, "Succeed to connect display manager service"); + return proxy_; +} + +void MockDisplayPowerMgrClient::OnRemoteDied(const wptr& remote) +{ + if (remote == nullptr) { + DISPLAY_HILOGE(COMP_FWK, "remote is nullptr"); + return; + } + + std::lock_guard lock(mutex_); + RETURN_IF(proxy_ == nullptr); + + auto serviceRemote = proxy_->AsObject(); + if ((serviceRemote != nullptr) && (serviceRemote == remote.promote())) { + serviceRemote->RemoveDeathRecipient(deathRecipient_); + proxy_ = nullptr; + } +} + +bool MockDisplayPowerMgrClient::AddMockScreen(uint32_t displayId) +{ + DISPLAY_HILOGD(COMP_FWK, "enter add mock screen id= %{public}d", displayId); + auto proxy = GetProxy(); + RETURN_IF_WITH_RET(proxy == nullptr, false); + return proxy->AddMockScreen(displayId); +} +} // namespace DisplayPowerMgr +} // namespace OHOS -- Gitee