9 files changed, 105 insertions(+), 68 deletions(-)

M harmony_changelog.md
M module-services/service-evtmgr/screen-light-control/ScreenLightControlParameters.hpp
M module-services/service-evtmgr/service-evtmgr/ScreenLightControlMessage.hpp
M products/BellHybrid/alarms/src/actions/FrontlightAction.cpp
M products/BellHybrid/apps/application-bell-settings/models/FrontlightModel.cpp
M products/BellHybrid/apps/application-bell-settings/models/alarm_settings/AlarmSettingsModel.cpp
M products/BellHybrid/services/evtmgr/EventManager.cpp
M products/BellHybrid/services/evtmgr/backlight-handler/BacklightHandler.cpp
M products/BellHybrid/services/evtmgr/include/evtmgr/backlight-handler/BacklightHandler.hpp

@@ 30,6 30,7 @@
 * Add loop mode
 
 ### Fixed
+* Brightness calculation for alarms
 
 #### Home Screen:
 * Centering of battery indicator.

@@ 1,4 1,4 @@
-// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// Copyright (c) 2017-2022, Mudita Sp. z.o.o. All rights reserved.
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
 #pragma once


@@ 8,6 8,14 @@
 
 namespace screen_light_control
 {
+    // Sender which send light request
+    enum class Sender
+    {
+        Other,
+        AlarmPrewakeup,
+        Alarm
+    };
+
     /// Modes in which front light can operate
     enum class ScreenLightMode
     {

@@ 11,15 11,18 @@
 
 namespace sevm
 {
-    class ScreenLightSettingsControlMessage : public sys::DataMessage
+    class ScreenLightControlMessage : public sys::DataMessage
     {
         const screen_light_control::Action action;
         std::optional<screen_light_control::Parameters> params;
+        const screen_light_control::Sender sender;
 
       public:
-        explicit ScreenLightSettingsControlMessage(
-            screen_light_control::Action act, std::optional<screen_light_control::Parameters> params = std::nullopt)
-            : sys::DataMessage(MessageType::ScreenLightControlAction), action(act), params{std::move(params)}
+        explicit ScreenLightControlMessage(screen_light_control::Action act,
+                                           std::optional<screen_light_control::Parameters> params = std::nullopt,
+                                           screen_light_control::Sender sender = screen_light_control::Sender::Other)
+            : sys::DataMessage(MessageType::ScreenLightControlAction),
+              action(act), params{std::move(params)}, sender{sender}
         {}
 
         [[nodiscard]] auto getAction() const noexcept -> screen_light_control::Action


@@ 31,27 34,10 @@ namespace sevm
         {
             return params;
         }
-    };
-
-    class ScreenLightControlMessage : public sys::DataMessage
-    {
-        const screen_light_control::Action action;
-        std::optional<screen_light_control::Parameters> params;
 
-      public:
-        explicit ScreenLightControlMessage(screen_light_control::Action act,
-                                           std::optional<screen_light_control::Parameters> params = std::nullopt)
-            : sys::DataMessage(MessageType::ScreenLightControlAction), action(act), params{std::move(params)}
-        {}
-
-        [[nodiscard]] auto getAction() const noexcept -> screen_light_control::Action
+        [[nodiscard]] auto getSender() const noexcept -> screen_light_control::Sender
         {
-            return action;
-        }
-
-        [[nodiscard]] auto getParams() const noexcept -> const std::optional<screen_light_control::Parameters> &
-        {
-            return params;
+            return sender;
         }
     };
 

@@ 15,10 15,29 @@ namespace alarms
 {
     namespace
     {
+        screen_light_control::Sender translateDependency(FrontlightAction::SettingsDependency dependency)
+        {
+            screen_light_control::Sender sender;
+
+            switch (dependency) {
+            case FrontlightAction::SettingsDependency::AlarmClock:
+                sender = screen_light_control::Sender::Alarm;
+                break;
+            case FrontlightAction::SettingsDependency::Prewakeup:
+                sender = screen_light_control::Sender::AlarmPrewakeup;
+                break;
+            case FrontlightAction::SettingsDependency::None:
+            default:
+                sender = screen_light_control::Sender::Other;
+                break;
+            }
+            return sender;
+        }
+
         class ManualFrontlightAction : public AbstractAlarmAction
         {
           public:
-            explicit ManualFrontlightAction(sys::Service &service);
+            explicit ManualFrontlightAction(sys::Service &service, FrontlightAction::SettingsDependency dependency);
             bool execute() override;
             bool turnOff() override;
 


@@ 27,12 46,14 @@ namespace alarms
 
             sys::Service &service;
             settings::Settings settings;
+            FrontlightAction::SettingsDependency settingsDependency;
         };
 
         class LinearProgressFrontlightAction : public AbstractAlarmAction
         {
           public:
-            explicit LinearProgressFrontlightAction(sys::Service &service);
+            explicit LinearProgressFrontlightAction(sys::Service &service,
+                                                    FrontlightAction::SettingsDependency dependency);
             bool execute() override;
             bool turnOff() override;
 


@@ 41,16 62,17 @@ namespace alarms
 
             sys::Service &service;
             settings::Settings settings;
+            FrontlightAction::SettingsDependency settingsDependency;
         };
 
-        std::unique_ptr<AbstractAlarmAction> createFrontlightImplementation(sys::Service &service,
-                                                                            FrontlightAction::Mode mode)
+        std::unique_ptr<AbstractAlarmAction> createFrontlightImplementation(
+            sys::Service &service, FrontlightAction::Mode mode, FrontlightAction::SettingsDependency settingsDependency)
         {
             switch (mode) {
             case FrontlightAction::Mode::Manual:
-                return std::make_unique<ManualFrontlightAction>(service);
+                return std::make_unique<ManualFrontlightAction>(service, settingsDependency);
             case FrontlightAction::Mode::LinearProgress:
-                return std::make_unique<LinearProgressFrontlightAction>(service);
+                return std::make_unique<LinearProgressFrontlightAction>(service, settingsDependency);
             }
             return nullptr;
         }


@@ 58,8 80,8 @@ namespace alarms
 
     FrontlightAction::FrontlightAction(sys::Service &service, Mode mode, SettingsDependency settingsDependency)
         : service{service}, settingsDependency{settingsDependency},
-          pimpl{createFrontlightImplementation(service, mode)}, settings{
-                                                                    service::ServiceProxy{service.weak_from_this()}}
+          pimpl{createFrontlightImplementation(service, mode, settingsDependency)}, settings{service::ServiceProxy{
+                                                                                        service.weak_from_this()}}
     {}
 
     bool FrontlightAction::execute()


@@ 116,12 138,14 @@ namespace alarms
             settings.getValue(bell::settings::Alarm::brightness, settings::SettingsScope::Global);
 
         screen_light_control::ManualModeParameters params{};
-        params.manualModeBrightness = frontlight_utils::fixedValToPercentage(std::stoi(brightnessString));
+        params.manualModeBrightness = utils::toNumeric(brightnessString);
 
         return params;
     }
 
-    ManualFrontlightAction::ManualFrontlightAction(sys::Service &service) : service{service}
+    ManualFrontlightAction::ManualFrontlightAction(sys::Service &service,
+                                                   FrontlightAction::SettingsDependency dependency)
+        : service{service}, settingsDependency{dependency}
     {
         settings.init(service::ServiceProxy{service.weak_from_this()});
     }


@@ 129,21 153,26 @@ namespace alarms
     bool ManualFrontlightAction::execute()
     {
         auto params = prepareParameters();
-        service.bus.sendUnicast(std::make_shared<sevm::ScreenLightControlMessage>(
-                                    screen_light_control::Action::turnOn, screen_light_control::Parameters{params}),
-                                service::name::evt_manager);
+        auto sender = translateDependency(settingsDependency);
+        service.bus.sendUnicast(
+            std::make_shared<sevm::ScreenLightControlMessage>(
+                screen_light_control::Action::turnOn, screen_light_control::Parameters{params}, sender),
+            service::name::evt_manager);
         return true;
     }
 
     bool ManualFrontlightAction::turnOff()
     {
-        service.bus.sendUnicast(
-            std::make_shared<sevm::ScreenLightControlMessage>(screen_light_control::Action::turnOff),
-            service::name::evt_manager);
+        auto sender = translateDependency(settingsDependency);
+        service.bus.sendUnicast(std::make_shared<sevm::ScreenLightControlMessage>(
+                                    screen_light_control::Action::turnOff, std::nullopt, sender),
+                                service::name::evt_manager);
         return true;
     }
 
-    LinearProgressFrontlightAction::LinearProgressFrontlightAction(sys::Service &service) : service{service}
+    LinearProgressFrontlightAction::LinearProgressFrontlightAction(sys::Service &service,
+                                                                   FrontlightAction::SettingsDependency dependency)
+        : service{service}, settingsDependency{dependency}
     {
         settings.init(service::ServiceProxy{service.weak_from_this()});
     }


@@ 151,9 180,11 @@ namespace alarms
     bool LinearProgressFrontlightAction::execute()
     {
         const auto params = prepareParameters();
+        auto sender       = translateDependency(settingsDependency);
         service.bus.sendUnicast(std::make_shared<sevm::ScreenLightSetAutoProgressiveModeParams>(params),
                                 service::name::evt_manager);
-        service.bus.sendUnicast(std::make_shared<sevm::ScreenLightControlMessage>(screen_light_control::Action::turnOn),
+        service.bus.sendUnicast(std::make_shared<sevm::ScreenLightControlMessage>(
+                                    screen_light_control::Action::turnOn, std::nullopt, sender),
                                 service::name::evt_manager);
         return true;
     }


@@ 175,8 206,7 @@ namespace alarms
         startFunction.target   = 10.0f;
 
         endFunction.duration = secondTargetDuration;
-        endFunction.target   = frontlight_utils::fixedValToPercentage(std::stoi(brightnessString));
-        ;
+        endFunction.target   = utils::toNumeric(brightnessString);
 
         params.startBrightnessValue = 0.0f;
         params.brightnessHysteresis = 0.0f;


@@ 187,9 217,10 @@ namespace alarms
 
     bool LinearProgressFrontlightAction::turnOff()
     {
-        service.bus.sendUnicast(
-            std::make_shared<sevm::ScreenLightControlMessage>(screen_light_control::Action::turnOff),
-            service::name::evt_manager);
+        auto sender = translateDependency(settingsDependency);
+        service.bus.sendUnicast(std::make_shared<sevm::ScreenLightControlMessage>(
+                                    screen_light_control::Action::turnOff, std::nullopt, sender),
+                                service::name::evt_manager);
         return true;
     }
 

@@ 35,17 35,17 @@ namespace app::bell_settings
     }
     void FrontlightModel::setStatus(bool onOff)
     {
-        app->bus.sendUnicast(std::make_shared<sevm::ScreenLightSettingsControlMessage>(
+        app->bus.sendUnicast(std::make_shared<sevm::ScreenLightControlMessage>(
                                  onOff ? screen_light_control::Action::turnOn : screen_light_control::Action::turnOff),
                              service::name::evt_manager);
     }
     void FrontlightModel::setMode(screen_light_control::ScreenLightMode mode)
     {
-        app->bus.sendUnicast(std::make_shared<sevm::ScreenLightSettingsControlMessage>(
-                                 mode == screen_light_control::ScreenLightMode::Automatic
-                                     ? screen_light_control::Action::enableAutomaticMode
-                                     : screen_light_control::Action::disableAutomaticMode),
-                             service::name::evt_manager);
+        app->bus.sendUnicast(
+            std::make_shared<sevm::ScreenLightControlMessage>(mode == screen_light_control::ScreenLightMode::Automatic
+                                                                  ? screen_light_control::Action::enableAutomaticMode
+                                                                  : screen_light_control::Action::disableAutomaticMode),
+            service::name::evt_manager);
     }
     void FrontlightModel::setBrightness(frontlight_utils::Brightness value)
     {

@@ 50,13 50,13 @@ namespace app::bell_settings
 
     void AlarmFrontlightModel::setValue(frontlight_utils::Brightness value)
     {
-        const auto valStr = std::to_string(value);
+        const auto valStr = std::to_string(frontlight_utils::fixedValToPercentage(value));
         settings.setValue(bell::settings::Alarm::brightness, valStr, settings::SettingsScope::Global);
     }
 
     frontlight_utils::Brightness AlarmFrontlightModel::getValue() const
     {
         const auto str = settings.getValue(bell::settings::Alarm::brightness, settings::SettingsScope::Global);
-        return std::stoi(str);
+        return frontlight_utils::percentageToFixedVal(std::stoi(str));
     }
 } // namespace app::bell_settings

@@ 87,17 87,11 @@ void EventManager::initProductEvents()
 {
     backlightHandler.init();
 
-    connect(typeid(sevm::ScreenLightSettingsControlMessage), [&](sys::Message *msgl) {
-        auto *m           = static_cast<sevm::ScreenLightSettingsControlMessage *>(msgl);
-        const auto params = m->getParams();
-        backlightHandler.processScreenRequest(m->getAction(), params.value_or(screen_light_control::Parameters()));
-        return sys::msgHandled();
-    });
-
     connect(typeid(sevm::ScreenLightControlMessage), [&](sys::Message *msgl) {
         auto *m           = static_cast<sevm::ScreenLightControlMessage *>(msgl);
         const auto params = m->getParams();
-        backlightHandler.screenRequest(m->getAction(), params.value_or(screen_light_control::Parameters()));
+        backlightHandler.processRequest(
+            m->getAction(), params.value_or(screen_light_control::Parameters()), m->getSender());
         return sys::msgHandled();
     });
 

@@ 101,10 101,25 @@ namespace backlight
         backlightType = type;
     }
 
-    void Handler::screenRequest(screen_light_control::Action action, const screen_light_control::Parameters &params)
+    void Handler::processRequest(screen_light_control::Action action,
+                                 const screen_light_control::Parameters &params,
+                                 screen_light_control::Sender sender)
     {
-        if (backlightType == Type::Frontlight) {
+        switch (sender) {
+        case screen_light_control::Sender::AlarmPrewakeup:
+        case screen_light_control::Sender::Alarm:
+            switch (action) {
+            case screen_light_control::Action::turnOff:
+                backlightType = Type::Frontlight;
+                break;
+            default:
+                break;
+            }
             processScreenRequest(action, params);
+            break;
+        default:
+            processScreenRequest(action, params);
+            break;
         }
     }
 

@@ 33,13 33,15 @@ namespace backlight
       public:
         Handler(std::shared_ptr<settings::Settings> settings, sys::Service *parent);
 
-        void init() override;
-
         void handleKeyPressed(int key = 0);
 
         void handleScreenLight(Type type);
 
-        void screenRequest(screen_light_control::Action action, const screen_light_control::Parameters &params);
+        void processRequest(screen_light_control::Action action,
+                            const screen_light_control::Parameters &params,
+                            screen_light_control::Sender sender);
+
+        void init() override;
 
         void processScreenRequest(screen_light_control::Action action,
                                   const screen_light_control::Parameters &params) override;