From ef46a48718777a72af53fe8dd30c8728caa81348 Mon Sep 17 00:00:00 2001 From: Lukasz Skrzypczak Date: Tue, 21 Sep 2021 05:52:43 -0700 Subject: [PATCH] [BH-753] Working frontlight ON OFF Working --- module-services/service-evtmgr/CMakeLists.txt | 2 +- .../backlight-handler/BacklightHandler.cpp | 233 ------------------ .../BacklightHandlerCommon.cpp | 137 ++++++++++ .../BacklightHandlerCommon.hpp | 62 +++++ .../screen-light-control/ControlFunctions.cpp | 5 + .../screen-light-control/ControlFunctions.hpp | 2 + .../BellHybrid/services/evtmgr/CMakeLists.txt | 1 + .../services/evtmgr/EventManager.cpp | 7 + .../backlight-handler/BacklightHandler.cpp | 45 ++++ .../backlight-handler/BacklightHandler.hpp | 37 +++ .../include/evtmgr/BacklightHandler.hpp | 33 +++ .../evtmgr/include/evtmgr/EventManager.hpp | 2 +- .../ScreenLightControl.cpp | 3 +- .../PurePhone/services/evtmgr/CMakeLists.txt | 1 + .../backlight-handler/BacklightHandler.cpp | 125 ++++++++++ .../backlight-handler/BacklightHandler.hpp | 4 +- .../include/evtmgr/BacklightHandler.hpp | 51 ++++ .../evtmgr/include/evtmgr/EventManager.hpp | 2 +- 18 files changed, 513 insertions(+), 239 deletions(-) delete mode 100644 module-services/service-evtmgr/backlight-handler/BacklightHandler.cpp create mode 100644 module-services/service-evtmgr/backlight-handler/BacklightHandlerCommon.cpp create mode 100644 module-services/service-evtmgr/backlight-handler/BacklightHandlerCommon.hpp create mode 100644 products/BellHybrid/services/evtmgr/backlight-handler/BacklightHandler.cpp create mode 100644 products/BellHybrid/services/evtmgr/backlight-handler/BacklightHandler.hpp create mode 100644 products/BellHybrid/services/evtmgr/include/evtmgr/BacklightHandler.hpp create mode 100644 products/PurePhone/services/evtmgr/backlight-handler/BacklightHandler.cpp rename {module-services/service-evtmgr => products/PurePhone/services/evtmgr}/backlight-handler/BacklightHandler.hpp (96%) create mode 100644 products/PurePhone/services/evtmgr/include/evtmgr/BacklightHandler.hpp diff --git a/module-services/service-evtmgr/CMakeLists.txt b/module-services/service-evtmgr/CMakeLists.txt index 304d51865990281f430dc8b96b730b05fe2cbf95..a5216b825f63189919aa6fbd846da6bf8a8b10db 100644 --- a/module-services/service-evtmgr/CMakeLists.txt +++ b/module-services/service-evtmgr/CMakeLists.txt @@ -5,10 +5,10 @@ set(SOURCES WorkerEventCommon.cpp api/EventManagerServiceAPI.cpp api/torch.cpp + backlight-handler/BacklightHandlerCommon.cpp battery/BatteryController.cpp battery/BatteryController.hpp battery-level-check/BatteryLevelCheck.cpp - backlight-handler/BacklightHandler.cpp battery-brownout-detector/BatteryBrownoutDetector.cpp screen-light-control/ControlFunctions.cpp screen-light-control/ScreenLightControlParameters.cpp diff --git a/module-services/service-evtmgr/backlight-handler/BacklightHandler.cpp b/module-services/service-evtmgr/backlight-handler/BacklightHandler.cpp deleted file mode 100644 index 28ad16622664c93dcb2f81f0c24a761daf4dbd9d..0000000000000000000000000000000000000000 --- a/module-services/service-evtmgr/backlight-handler/BacklightHandler.cpp +++ /dev/null @@ -1,233 +0,0 @@ -// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. -// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md - -#include "BacklightHandler.hpp" -#include -#include -#include -#include - -namespace backlight -{ - namespace timers - { - constexpr auto keypadLightTimerName = "KeypadLightTimer"; - constexpr auto screenLightTimerName = "ScreenLightTimer"; - constexpr auto keypadLightTimerTimeout = std::chrono::seconds(5); - constexpr auto screenLightTimerTimeout = std::chrono::seconds(5); - } // namespace timers - - Handler::Handler(std::shared_ptr settings, sys::Service *parent) - : settings{std::move(settings)}, screenLightControl{std::make_unique( - parent)}, - keypadLightTimer{ - sys::TimerFactory::createSingleShotTimer(parent, - timers::keypadLightTimerName, - timers::keypadLightTimerTimeout, - [this](sys::Timer &) { bsp::keypad_backlight::shutdown(); })}, - screenLightTimer{sys::TimerFactory::createSingleShotTimer( - parent, timers::screenLightTimerName, timers::keypadLightTimerTimeout, [this](sys::Timer &t) { - if (getScreenLightState() && - getScreenAutoModeState() == screen_light_control::ScreenLightMode::Automatic && - screenLightControl->isLightOn()) { - screenLightControl->processRequest(screen_light_control::Action::turnOff); - } - })} - - {} - - void Handler::init() - { - using namespace screen_light_control; - settings->registerValueChange(settings::Brightness::brightnessLevel, [&](const std::string &value) { - ManualModeParameters params{utils::getNumericValue(value)}; - screenLightControl->processRequest(Action::setManualModeBrightness, Parameters(params)); - }); - - settings->registerValueChange(settings::Brightness::autoMode, [&]([[maybe_unused]] const std::string &value) { - const auto action = getScreenAutoModeState() == ScreenLightMode::Automatic ? Action::enableAutomaticMode - : Action::disableAutomaticMode; - screenLightControl->processRequest(action); - }); - - settings->registerValueChange(settings::Brightness::state, [&]([[maybe_unused]] const std::string &value) { - const auto action = getScreenLightState() ? Action::turnOn : Action::turnOff; - if (action == Action::turnOn) { - screenLightTimer.start(); - } - screenLightControl->processRequest(action); - }); - } - - void Handler::processScreenRequest(screen_light_control::Action action, - const screen_light_control::Parameters ¶ms) - { - if (action == screen_light_control::Action::enableAutomaticMode) { - startScreenLightTimer(); - } - handleScreenLightSettings(action, params); - screenLightControl->processRequest(action, params); - } - - void Handler::handleKeyPressed() - { - handleKeypadLightRefresh(); - handleScreenLightRefresh(); - } - - void Handler::stopKeypadTimer() - { - if (keypadLightState == bsp::keypad_backlight::State::activeMode) { - keypadLightTimer.stop(); - } - } - - void Handler::setKeypadLightInCallMode(bool value) noexcept - { - isKeypadLightInCallMode = value; - } - - void Handler::setKeypadLightState(bsp::keypad_backlight::State value) noexcept - { - keypadLightState = value; - } - - auto Handler::processKeypadRequest(bsp::keypad_backlight::Action action) -> bool - { - switch (action) { - case bsp::keypad_backlight::Action::turnOn: { - stopKeypadTimer(); - setKeypadLightState(bsp::keypad_backlight::State::on); - return bsp::keypad_backlight::turnOnAll(); - } - case bsp::keypad_backlight::Action::turnOff: { - stopKeypadTimer(); - setKeypadLightState(bsp::keypad_backlight::State::off); - return bsp::keypad_backlight::shutdown(); - } - case bsp::keypad_backlight::Action::checkState: { - return bsp::keypad_backlight::checkState(); - } - case bsp::keypad_backlight::Action::turnOnActiveMode: { - setKeypadLightState(bsp::keypad_backlight::State::activeMode); - const auto response = bsp::keypad_backlight::turnOnAll(); - startKeypadLightTimer(); - return response; - } - case bsp::keypad_backlight::Action::turnOnCallMode: { - if (keypadLightTimer.isActive()) { - keypadLightTimer.stop(); - } - return bsp::keypad_backlight::turnOnFunctionKeysBacklight(); - } - case bsp::keypad_backlight::Action::turnOffCallMode: { - setKeypadLightInCallMode(false); - restoreKeypadLightState(); - return true; - } - } - return false; - } - - void Handler::restoreKeypadLightState() - { - switch (keypadLightState) { - case bsp::keypad_backlight::State::off: - processKeypadRequest(bsp::keypad_backlight::Action::turnOff); - break; - case bsp::keypad_backlight::State::on: - processKeypadRequest(bsp::keypad_backlight::Action::turnOn); - break; - case bsp::keypad_backlight::State::activeMode: - processKeypadRequest(bsp::keypad_backlight::Action::turnOnActiveMode); - break; - } - } - - auto Handler::getValue(const std::string &path) const -> std::string - { - return settings->getValue(path); - } - - void Handler::setValue(const std::string &path, const std::string &value) - { - settings->setValue(path, value); - } - - void Handler::startKeypadLightTimer() - { - keypadLightTimer.start(); - } - - void Handler::startScreenLightTimer() - { - screenLightTimer.start(); - } - - auto Handler::getScreenLightState() const noexcept -> bool - { - return utils::getNumericValue(getValue(settings::Brightness::state)); - } - - auto Handler::getScreenAutoModeState() const noexcept -> screen_light_control::ScreenLightMode - { - auto mode = utils::getNumericValue(getValue(settings::Brightness::autoMode)); - return static_cast(mode); - } - - auto Handler::getScreenBrightnessValue() const noexcept -> bsp::eink_frontlight::BrightnessPercentage - { - return utils::getNumericValue(getValue(settings::Brightness::brightnessLevel)); - } - - void Handler::handleKeypadLightRefresh() - { - if (keypadLightState == bsp::keypad_backlight::State::activeMode && !isKeypadLightInCallMode) { - bsp::keypad_backlight::turnOnAll(); - startKeypadLightTimer(); - } - } - - void Handler::handleScreenLightRefresh() - { - if (getScreenLightState() && getScreenAutoModeState() == screen_light_control::ScreenLightMode::Automatic) { - if (!screenLightControl->isLightOn()) { - screenLightControl->processRequest(screen_light_control::Action::turnOn); - } - startScreenLightTimer(); - } - } - - void Handler::handleScreenLightSettings(screen_light_control::Action action, - const screen_light_control::Parameters ¶ms) - { - switch (action) { - case screen_light_control::Action::enableAutomaticMode: - setValue(settings::Brightness::autoMode, - utils::to_string(static_cast(screen_light_control::ScreenLightMode::Automatic))); - break; - case screen_light_control::Action::disableAutomaticMode: - setValue(settings::Brightness::autoMode, - utils::to_string(static_cast(screen_light_control::ScreenLightMode::Manual))); - break; - case screen_light_control::Action::turnOff: - setValue(settings::Brightness::state, utils::to_string(false)); - break; - case screen_light_control::Action::turnOn: - setValue(settings::Brightness::state, utils::to_string(true)); - screenLightTimer.start(); - break; - case screen_light_control::Action::setManualModeBrightness: - if (params.hasManualModeParams()) { - setValue(settings::Brightness::brightnessLevel, - utils::to_string(params.getManualModeParams().manualModeBrightness)); - } - else { - LOG_ERROR("Missing ManualModeBrightness value, change request ignored"); - } - break; - default: - break; - } - } -} // namespace backlight diff --git a/module-services/service-evtmgr/backlight-handler/BacklightHandlerCommon.cpp b/module-services/service-evtmgr/backlight-handler/BacklightHandlerCommon.cpp new file mode 100644 index 0000000000000000000000000000000000000000..293d256868c87f29769ab1f9994ec29dee0ddab1 --- /dev/null +++ b/module-services/service-evtmgr/backlight-handler/BacklightHandlerCommon.cpp @@ -0,0 +1,137 @@ +// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#include "backlight-handler/BacklightHandlerCommon.hpp" +#include +#include +#include +#include + +namespace backlight +{ + namespace timers + { + constexpr auto screenLightTimerName = "ScreenLightTimer"; + constexpr auto screenLightTimerTimeout = std::chrono::seconds(5); + } // namespace timers + + HandlerCommon::HandlerCommon(std::shared_ptr settings, sys::Service *parent) + : settings{std::move(settings)}, screenLightControl{std::make_shared( + parent)}, + screenLightTimer{std::make_shared(sys::TimerFactory::createSingleShotTimer( + parent, timers::screenLightTimerName, timers::screenLightTimerTimeout, [this](sys::Timer &t) { + if (getScreenAutoModeState() == screen_light_control::ScreenLightMode::Automatic && + screenLightControl->isLightOn()) { + screenLightControl->processRequest(screen_light_control::Action::turnOff); + } + }))} + + {} + + void HandlerCommon::init() + { + using namespace screen_light_control; + settings->registerValueChange(settings::Brightness::brightnessLevel, [&](const std::string &value) { + ManualModeParameters params{utils::getNumericValue(value)}; + screenLightControl->processRequest(Action::setManualModeBrightness, Parameters(params)); + }); + + settings->registerValueChange(settings::Brightness::autoMode, [&]([[maybe_unused]] const std::string &value) { + const auto action = getScreenAutoModeState() == ScreenLightMode::Automatic ? Action::enableAutomaticMode + : Action::disableAutomaticMode; + screenLightControl->processRequest(action); + }); + + settings->registerValueChange(settings::Brightness::state, [&]([[maybe_unused]] const std::string &value) { + const auto action = getScreenLightState() ? Action::turnOn : Action::turnOff; + if (action == Action::turnOn) { + screenLightTimer->start(); + } + screenLightControl->processRequest(action); + }); + } + + void HandlerCommon::processScreenRequest(screen_light_control::Action action, + const screen_light_control::Parameters ¶ms) + { + if (action == screen_light_control::Action::enableAutomaticMode) { + startScreenLightTimer(); + } + handleScreenLightSettings(action, params); + screenLightControl->processRequest(action, params); + } + + auto HandlerCommon::getValue(const std::string &path) const -> std::string + { + return settings->getValue(path); + } + + void HandlerCommon::setValue(const std::string &path, const std::string &value) + { + settings->setValue(path, value); + } + + void HandlerCommon::startScreenLightTimer() + { + screenLightTimer->start(); + } + + auto HandlerCommon::getScreenLightState() const noexcept -> bool + { + return utils::getNumericValue(getValue(settings::Brightness::state)); + } + + auto HandlerCommon::getScreenAutoModeState() const noexcept -> screen_light_control::ScreenLightMode + { + auto mode = utils::getNumericValue(getValue(settings::Brightness::autoMode)); + return static_cast(mode); + } + + auto HandlerCommon::getScreenBrightnessValue() const noexcept -> bsp::eink_frontlight::BrightnessPercentage + { + return utils::getNumericValue(getValue(settings::Brightness::brightnessLevel)); + } + + void HandlerCommon::handleScreenLightRefresh() + { + if (getScreenLightState() && getScreenAutoModeState() == screen_light_control::ScreenLightMode::Automatic) { + if (!screenLightControl->isLightOn()) { + screenLightControl->processRequest(screen_light_control::Action::turnOn); + } + startScreenLightTimer(); + } + } + + void HandlerCommon::handleScreenLightSettings(screen_light_control::Action action, + const screen_light_control::Parameters ¶ms) + { + switch (action) { + case screen_light_control::Action::enableAutomaticMode: + setValue(settings::Brightness::autoMode, + utils::to_string(static_cast(screen_light_control::ScreenLightMode::Automatic))); + break; + case screen_light_control::Action::disableAutomaticMode: + setValue(settings::Brightness::autoMode, + utils::to_string(static_cast(screen_light_control::ScreenLightMode::Manual))); + break; + case screen_light_control::Action::turnOff: + setValue(settings::Brightness::state, utils::to_string(false)); + break; + case screen_light_control::Action::turnOn: + setValue(settings::Brightness::state, utils::to_string(true)); + screenLightTimer->start(); + break; + case screen_light_control::Action::setManualModeBrightness: + if (params.hasManualModeParams()) { + setValue(settings::Brightness::brightnessLevel, + utils::to_string(params.getManualModeParams().manualModeBrightness)); + } + else { + LOG_ERROR("Missing ManualModeBrightness value, change request ignored"); + } + break; + default: + break; + } + } +} // namespace backlight diff --git a/module-services/service-evtmgr/backlight-handler/BacklightHandlerCommon.hpp b/module-services/service-evtmgr/backlight-handler/BacklightHandlerCommon.hpp new file mode 100644 index 0000000000000000000000000000000000000000..9c4472056fd14568dce8261649dd4eef4dae52f5 --- /dev/null +++ b/module-services/service-evtmgr/backlight-handler/BacklightHandlerCommon.hpp @@ -0,0 +1,62 @@ +// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#pragma once + +#include +#include +#include +#include + +namespace settings +{ + class Settings; +} // namespace settings + +namespace backlight +{ + /// @brief Backlight events handler + class HandlerCommon + { + public: + HandlerCommon(std::shared_ptr settings, sys::Service *parent); + + /// initialise in InitHandler when Service is ready + void init(); + + /// Process request of the screen light control + /// @screen_light_control::Action an action to perform + /// @screen_light_control::Parameters parameters being set + void processScreenRequest(screen_light_control::Action action, const screen_light_control::Parameters ¶ms); + + [[nodiscard]] auto getScreenLightState() const noexcept -> bool; + [[nodiscard]] auto getScreenAutoModeState() const noexcept -> screen_light_control::ScreenLightMode; + [[nodiscard]] auto getScreenBrightnessValue() const noexcept -> bsp::eink_frontlight::BrightnessPercentage; + + private: + std::shared_ptr settings; + std::shared_ptr screenLightControl; + + public: + auto getScreenLightTimer() noexcept -> std::shared_ptr + { + return screenLightTimer; + } + auto getScreenLightControl() noexcept -> std::shared_ptr + { + return screenLightControl; + } + void handleScreenLightSettings(screen_light_control::Action action, + const screen_light_control::Parameters ¶ms); + void handleScreenLightRefresh(); + + protected: + [[nodiscard]] auto getValue(const std::string &path) const -> std::string; + void setValue(const std::string &path, const std::string &value); + + /// Timer that keeps screen backlight on for a certain time if there was key pressed + std::shared_ptr screenLightTimer; + + void startScreenLightTimer(); + }; +} // namespace backlight diff --git a/module-services/service-evtmgr/screen-light-control/ControlFunctions.cpp b/module-services/service-evtmgr/screen-light-control/ControlFunctions.cpp index ee9df4359e453efd034be730bf98955a90d6a69c..4c3e404a628d8d850c840c6ca5189bbf33d24fc6 100644 --- a/module-services/service-evtmgr/screen-light-control/ControlFunctions.cpp +++ b/module-services/service-evtmgr/screen-light-control/ControlFunctions.cpp @@ -95,4 +95,9 @@ namespace screen_light_control::functions } } + void setRampTarget(bsp::eink_frontlight::BrightnessPercentage value) + { + rampTarget = value; + } + } // namespace screen_light_control::functions diff --git a/module-services/service-evtmgr/screen-light-control/ControlFunctions.hpp b/module-services/service-evtmgr/screen-light-control/ControlFunctions.hpp index 8dd76fa632c0eda065ca56d3acebdc1b24e350ce..c0a28de04469b77e872ce6e089960c7ceffe05a4 100644 --- a/module-services/service-evtmgr/screen-light-control/ControlFunctions.hpp +++ b/module-services/service-evtmgr/screen-light-control/ControlFunctions.hpp @@ -23,4 +23,6 @@ namespace screen_light_control::functions void setFunctionFromPoints(const BrightnessFunction &points); + void setRampTarget(bsp::eink_frontlight::BrightnessPercentage value); + } // namespace screen_light_control::functions diff --git a/products/BellHybrid/services/evtmgr/CMakeLists.txt b/products/BellHybrid/services/evtmgr/CMakeLists.txt index 6b66cbc59209e41e69e03a7dacfae5f171ff19d0..bb35099367b7487aad5633fed111ae8f0ee1c05a 100644 --- a/products/BellHybrid/services/evtmgr/CMakeLists.txt +++ b/products/BellHybrid/services/evtmgr/CMakeLists.txt @@ -11,6 +11,7 @@ target_sources(evtmgr internal/StaticData.hpp screen-light-control/ScreenLightControl.cpp + backlight-handler/BacklightHandler.cpp PUBLIC include/evtmgr/EventManager.hpp include/evtmgr/api/TemperatureApi.hpp diff --git a/products/BellHybrid/services/evtmgr/EventManager.cpp b/products/BellHybrid/services/evtmgr/EventManager.cpp index 24ae3e0198ac8251cc5324fdfc6eaee869dc14f9..e7bcd4bc36b485a8edc063a3edbf206574a410b7 100644 --- a/products/BellHybrid/services/evtmgr/EventManager.cpp +++ b/products/BellHybrid/services/evtmgr/EventManager.cpp @@ -59,6 +59,10 @@ void EventManager::handleKeyEvent(sys::Message *msg) service::name::system_manager); } } + + if (kbdMessage->key.state == RawKey::State::Pressed) { + backlightHandler.handleKeyPressed(static_cast(key)); + } } auto EventManager::createEventWorker() -> std::unique_ptr @@ -94,6 +98,9 @@ void EventManager::initProductEvents() backlightHandler.getScreenLightState(), backlightHandler.getScreenAutoModeState(), params); return msg; }); + + backlightHandler.processScreenRequest(screen_light_control::Action::enableAutomaticMode, + screen_light_control::Parameters()); } sys::MessagePointer EventManager::DataReceivedHandler(sys::DataMessage *msgl, sys::ResponseMessage *resp) diff --git a/products/BellHybrid/services/evtmgr/backlight-handler/BacklightHandler.cpp b/products/BellHybrid/services/evtmgr/backlight-handler/BacklightHandler.cpp new file mode 100644 index 0000000000000000000000000000000000000000..a272ea02050b784a0fcf6ef87b696d1ccc5580ec --- /dev/null +++ b/products/BellHybrid/services/evtmgr/backlight-handler/BacklightHandler.cpp @@ -0,0 +1,45 @@ +// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#include +#include +#include +#include +#include +#include + +namespace backlight +{ + namespace timers + { + constexpr auto screenLightTimerTimeout = std::chrono::seconds(5); + constexpr auto screenLightTimerHoldTimeout = std::chrono::seconds(10); + } // namespace timers + + Handler::Handler(std::shared_ptr settings, sys::Service *parent) + : HandlerCommon(settings, parent), screenLightControl{getScreenLightControl()}, screenLightTimer{ + getScreenLightTimer()} + {} + + void Handler::handleKeyPressed([[maybe_unused]] const int key) + { + handleScreenLightRefresh(key); + } + + void Handler::handleScreenLightRefresh([[maybe_unused]] const int key) + { + if (getScreenAutoModeState() == screen_light_control::ScreenLightMode::Automatic) { + if (!screenLightControl->isLightOn() && (key == static_cast(KeyMap::Frontlight))) { + screenLightControl->processRequest(screen_light_control::Action::turnOn); + screenLightTimer->restart(timers::screenLightTimerTimeout); + } + else if (screenLightControl->isLightOn() && (key != static_cast(KeyMap::Frontlight))) { + screenLightTimer->restart(timers::screenLightTimerHoldTimeout); + } + else if (key == static_cast(KeyMap::Frontlight)) { + screenLightControl->processRequest(screen_light_control::Action::turnOff); + screenLightTimer->stop(); + } + } + } +} // namespace backlight diff --git a/products/BellHybrid/services/evtmgr/backlight-handler/BacklightHandler.hpp b/products/BellHybrid/services/evtmgr/backlight-handler/BacklightHandler.hpp new file mode 100644 index 0000000000000000000000000000000000000000..c3aef24da2baf57663846a5df0a508f879fb13c0 --- /dev/null +++ b/products/BellHybrid/services/evtmgr/backlight-handler/BacklightHandler.hpp @@ -0,0 +1,37 @@ +// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#pragma once + +#include +#include +#include +#include +#include + +namespace settings +{ + class Settings; +} // namespace settings + +namespace backlight +{ + /// @brief Backlight events handler + class HandlerBell : public Handler + { + public: + HandlerBell(std::shared_ptr settings, sys::Service *parent); + + void handleKeyPressed(const int key = 0); + + private: + std::shared_ptr settings; + std::unique_ptr screenLightControl; + /// Timer that keeps screen backlight on for a certain time if there was key pressed + sys::TimerHandle screenLightTimer; + void startScreenLightTimer(); + void handleScreenLightRefresh(const int key = 0); + void handleScreenLightSettings(screen_light_control::Action action, + const screen_light_control::Parameters ¶ms); + }; +} // namespace backlight diff --git a/products/BellHybrid/services/evtmgr/include/evtmgr/BacklightHandler.hpp b/products/BellHybrid/services/evtmgr/include/evtmgr/BacklightHandler.hpp new file mode 100644 index 0000000000000000000000000000000000000000..03a78d0ad8b74b57437988c3246980baed2f476d --- /dev/null +++ b/products/BellHybrid/services/evtmgr/include/evtmgr/BacklightHandler.hpp @@ -0,0 +1,33 @@ +// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#pragma once + +#include +#include +#include +#include +#include + +namespace settings +{ + class Settings; +} // namespace settings + +namespace backlight +{ + /// @brief Backlight events handler + class Handler : public HandlerCommon + { + public: + Handler(std::shared_ptr settings, sys::Service *parent); + + void handleKeyPressed([[maybe_unused]] const int key = 0); + + private: + std::shared_ptr screenLightControl; + /// Timer that keeps screen backlight on for a certain time if there was key pressed + std::shared_ptr screenLightTimer; + void handleScreenLightRefresh([[maybe_unused]] const int key = 0); + }; +} // namespace backlight diff --git a/products/BellHybrid/services/evtmgr/include/evtmgr/EventManager.hpp b/products/BellHybrid/services/evtmgr/include/evtmgr/EventManager.hpp index 9708c280b57888e886739fe4e9959a3390424a0a..ee07b43de850c97177603f0613a13b31a2171f31 100644 --- a/products/BellHybrid/services/evtmgr/include/evtmgr/EventManager.hpp +++ b/products/BellHybrid/services/evtmgr/include/evtmgr/EventManager.hpp @@ -5,7 +5,7 @@ #include -#include +#include "BacklightHandler.hpp" namespace hal::temperature { diff --git a/products/BellHybrid/services/evtmgr/screen-light-control/ScreenLightControl.cpp b/products/BellHybrid/services/evtmgr/screen-light-control/ScreenLightControl.cpp index 707b4b0b5de94c1561ab0cae6eea0abe3c917787..3ea64e233d0690e4e584980455d1f3646cb2cf23 100644 --- a/products/BellHybrid/services/evtmgr/screen-light-control/ScreenLightControl.cpp +++ b/products/BellHybrid/services/evtmgr/screen-light-control/ScreenLightControl.cpp @@ -66,7 +66,7 @@ namespace screen_light_control void ScreenLightControl::readoutTimerCallback() { - functions::calculateBrightness(brightnessValue); + // functions::calculateBrightness(brightnessValue); } auto ScreenLightControl::getAutoModeState() const noexcept -> ScreenLightMode @@ -114,6 +114,7 @@ namespace screen_light_control void ScreenLightControl::setParameters(ManualModeParameters params) { brightnessValue = params.manualModeBrightness; + functions::setRampTarget(brightnessValue); setManualBrightnessLevel(); } diff --git a/products/PurePhone/services/evtmgr/CMakeLists.txt b/products/PurePhone/services/evtmgr/CMakeLists.txt index 1965d413e6993e4483bdeb5644ce1692d8050a88..2d0a9680e2e2d7b65fd03dceef2f423e22dcfdd5 100644 --- a/products/PurePhone/services/evtmgr/CMakeLists.txt +++ b/products/PurePhone/services/evtmgr/CMakeLists.txt @@ -6,6 +6,7 @@ target_sources(evtmgr WorkerEvent.cpp WorkerEvent.hpp screen-light-control/ScreenLightControl.cpp + backlight-handler/BacklightHandler.cpp PUBLIC include/evtmgr/EVMessages.hpp include/evtmgr/EventManager.hpp diff --git a/products/PurePhone/services/evtmgr/backlight-handler/BacklightHandler.cpp b/products/PurePhone/services/evtmgr/backlight-handler/BacklightHandler.cpp new file mode 100644 index 0000000000000000000000000000000000000000..8aba962e84064a0322352b00d0c249f8ab753029 --- /dev/null +++ b/products/PurePhone/services/evtmgr/backlight-handler/BacklightHandler.cpp @@ -0,0 +1,125 @@ +// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#include +#include +#include +#include +#include + +namespace backlight +{ + namespace timers + { + constexpr auto keypadLightTimerName = "KeypadLightTimer"; + constexpr auto keypadLightTimerTimeout = std::chrono::seconds(5); + } // namespace timers + + Handler::Handler(std::shared_ptr settings, sys::Service *parent) + : HandlerCommon(settings, parent), screenLightControl{getScreenLightControl()}, + screenLightTimer{getScreenLightTimer()}, + + keypadLightTimer{sys::TimerFactory::createSingleShotTimer( + parent, timers::keypadLightTimerName, timers::keypadLightTimerTimeout, [this](sys::Timer &) { + bsp::keypad_backlight::shutdown(); + })} + {} + + void Handler::handleKeyPressed() + { + handleKeypadLightRefresh(); + handleScreenLightRefresh(); + } + + void Handler::stopKeypadTimer() + { + if (keypadLightState == bsp::keypad_backlight::State::activeMode) { + keypadLightTimer.stop(); + } + } + + void Handler::setKeypadLightInCallMode(bool value) noexcept + { + isKeypadLightInCallMode = value; + } + + void Handler::setKeypadLightState(bsp::keypad_backlight::State value) noexcept + { + keypadLightState = value; + } + + auto Handler::processKeypadRequest(bsp::keypad_backlight::Action action) -> bool + { + switch (action) { + case bsp::keypad_backlight::Action::turnOn: { + stopKeypadTimer(); + setKeypadLightState(bsp::keypad_backlight::State::on); + return bsp::keypad_backlight::turnOnAll(); + } + case bsp::keypad_backlight::Action::turnOff: { + stopKeypadTimer(); + setKeypadLightState(bsp::keypad_backlight::State::off); + return bsp::keypad_backlight::shutdown(); + } + case bsp::keypad_backlight::Action::checkState: { + return bsp::keypad_backlight::checkState(); + } + case bsp::keypad_backlight::Action::turnOnActiveMode: { + setKeypadLightState(bsp::keypad_backlight::State::activeMode); + const auto response = bsp::keypad_backlight::turnOnAll(); + startKeypadLightTimer(); + return response; + } + case bsp::keypad_backlight::Action::turnOnCallMode: { + if (keypadLightTimer.isActive()) { + keypadLightTimer.stop(); + } + return bsp::keypad_backlight::turnOnFunctionKeysBacklight(); + } + case bsp::keypad_backlight::Action::turnOffCallMode: { + setKeypadLightInCallMode(false); + restoreKeypadLightState(); + return true; + } + } + return false; + } + + void Handler::restoreKeypadLightState() + { + switch (keypadLightState) { + case bsp::keypad_backlight::State::off: + processKeypadRequest(bsp::keypad_backlight::Action::turnOff); + break; + case bsp::keypad_backlight::State::on: + processKeypadRequest(bsp::keypad_backlight::Action::turnOn); + break; + case bsp::keypad_backlight::State::activeMode: + processKeypadRequest(bsp::keypad_backlight::Action::turnOnActiveMode); + break; + } + } + + void Handler::startKeypadLightTimer() + { + keypadLightTimer.start(); + } + + void Handler::handleKeypadLightRefresh() + { + if (keypadLightState == bsp::keypad_backlight::State::activeMode && !isKeypadLightInCallMode) { + bsp::keypad_backlight::turnOnAll(); + startKeypadLightTimer(); + } + } + + void Handler::handleScreenLightRefresh([[maybe_unused]] const int key) + { + if (getScreenLightState() && getScreenAutoModeState() == screen_light_control::ScreenLightMode::Automatic) { + if (!screenLightControl->isLightOn()) { + screenLightControl->processRequest(screen_light_control::Action::turnOn); + } + startScreenLightTimer(); + } + } +} // namespace backlight diff --git a/module-services/service-evtmgr/backlight-handler/BacklightHandler.hpp b/products/PurePhone/services/evtmgr/backlight-handler/BacklightHandler.hpp similarity index 96% rename from module-services/service-evtmgr/backlight-handler/BacklightHandler.hpp rename to products/PurePhone/services/evtmgr/backlight-handler/BacklightHandler.hpp index 170bee328b848887d18e6d93b22ef11c717e38b9..689726484a4e014e2399c5dffa21ad747af8b6e5 100644 --- a/module-services/service-evtmgr/backlight-handler/BacklightHandler.hpp +++ b/products/PurePhone/services/evtmgr/backlight-handler/BacklightHandler.hpp @@ -29,7 +29,7 @@ namespace backlight /// @screen_light_control::Parameters parameters being set void processScreenRequest(screen_light_control::Action action, const screen_light_control::Parameters ¶ms); - void handleKeyPressed(); + void handleKeyPressed(const int key = 0); /// Process request of the keypad light control /// @keypad_backlight::action an action to perform /// @return True if request was processed successfully, false otherwise @@ -60,7 +60,7 @@ namespace backlight void setKeypadLightState(bsp::keypad_backlight::State value) noexcept; void restoreKeypadLightState(); void handleKeypadLightRefresh(); - void handleScreenLightRefresh(); + void handleScreenLightRefresh(const int key = 0); void handleScreenLightSettings(screen_light_control::Action action, const screen_light_control::Parameters ¶ms); }; diff --git a/products/PurePhone/services/evtmgr/include/evtmgr/BacklightHandler.hpp b/products/PurePhone/services/evtmgr/include/evtmgr/BacklightHandler.hpp new file mode 100644 index 0000000000000000000000000000000000000000..7358bd798c1cfb6952edf1d1e501c0a72fdae015 --- /dev/null +++ b/products/PurePhone/services/evtmgr/include/evtmgr/BacklightHandler.hpp @@ -0,0 +1,51 @@ +// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#pragma once + +#include +#include +#include +#include +#include + +namespace settings +{ + class Settings; +} // namespace settings + +namespace backlight +{ + /// @brief Backlight events handler + class Handler : public HandlerCommon + { + public: + Handler(std::shared_ptr settings, sys::Service *parent); + + void handleKeyPressed(); + /// Process request of the keypad light control + /// @keypad_backlight::action an action to perform + /// @return True if request was processed successfully, false otherwise + auto processKeypadRequest(bsp::keypad_backlight::Action action) -> bool; + + private: + std::shared_ptr screenLightControl; + /// Timer that keeps screen backlight on for a certain time if there was key pressed + std::shared_ptr screenLightTimer; + /// Timer that keeps key backlight on for a certain time if there was key pressed + sys::TimerHandle keypadLightTimer; + + bsp::keypad_backlight::State keypadLightState = bsp::keypad_backlight::State::off; + bool isKeypadLightInCallMode = false; + + void startKeypadLightTimer(); + void stopKeypadTimer(); + void setKeypadLightInCallMode(bool value) noexcept; + void setKeypadLightState(bsp::keypad_backlight::State value) noexcept; + void restoreKeypadLightState(); + void handleKeypadLightRefresh(); + void handleScreenLightRefresh([[maybe_unused]] const int key = 0); + void handleScreenLightSettings(screen_light_control::Action action, + const screen_light_control::Parameters ¶ms); + }; +} // namespace backlight diff --git a/products/PurePhone/services/evtmgr/include/evtmgr/EventManager.hpp b/products/PurePhone/services/evtmgr/include/evtmgr/EventManager.hpp index e4e35508c56343e82a7943d7ae82ddd1ce7646c2..7fc3c31dfb8968b3d3e0aa01908e2a88c4236458 100644 --- a/products/PurePhone/services/evtmgr/include/evtmgr/EventManager.hpp +++ b/products/PurePhone/services/evtmgr/include/evtmgr/EventManager.hpp @@ -5,7 +5,7 @@ #include -#include +#include "BacklightHandler.hpp" #include #include