28 files changed, 380 insertions(+), 135 deletions(-)

M harmony_changelog.md
M image/assets/lang/English.json
M image/user/db/settings_bell_002.sql
M products/BellHybrid/alarms/src/actions/FrontlightAction.cpp
M products/BellHybrid/alarms/src/actions/FrontlightAction.hpp
M products/BellHybrid/apps/application-bell-settings/ApplicationBellSettings.cpp
M products/BellHybrid/apps/application-bell-settings/models/FrontlightModel.cpp
M products/BellHybrid/apps/application-bell-settings/models/alarm_settings/AbstractPrewakeUpSettingsModel.hpp
M products/BellHybrid/apps/application-bell-settings/models/alarm_settings/AlarmSettingsListItemProvider.cpp
M products/BellHybrid/apps/application-bell-settings/models/alarm_settings/AlarmSettingsListItemProvider.hpp
M products/BellHybrid/apps/application-bell-settings/models/alarm_settings/AlarmSettingsModel.cpp
M products/BellHybrid/apps/application-bell-settings/models/alarm_settings/PrewakeUpListItemProvider.cpp
M products/BellHybrid/apps/application-bell-settings/models/alarm_settings/PrewakeUpListItemProvider.hpp
M products/BellHybrid/apps/application-bell-settings/models/alarm_settings/PrewakeUpSettingsModel.cpp
M products/BellHybrid/apps/application-bell-settings/models/alarm_settings/PrewakeUpSettingsModel.hpp
M products/BellHybrid/apps/application-bell-settings/models/alarm_settings/SettingsListItemProvider.hpp
M products/BellHybrid/apps/application-bell-settings/presenter/alarm_settings/AlarmSettingsPresenter.cpp
M products/BellHybrid/apps/application-bell-settings/presenter/alarm_settings/AlarmSettingsPresenter.hpp
M products/BellHybrid/apps/application-bell-settings/presenter/alarm_settings/PrewakeUpPresenter.cpp
M products/BellHybrid/apps/application-bell-settings/presenter/alarm_settings/PrewakeUpPresenter.hpp
M products/BellHybrid/apps/application-bell-settings/windows/alarm_settings/BellSettingsAlarmSettingsWindow.cpp
M products/BellHybrid/apps/application-bell-settings/windows/alarm_settings/BellSettingsAlarmSettingsWindow.hpp
M products/BellHybrid/apps/common/CMakeLists.txt
A products/BellHybrid/apps/common/include/common/data/FrontlightUtils.hpp
M products/BellHybrid/apps/common/include/common/models/AbstractAlarmSettingsModel.hpp
M products/BellHybrid/apps/common/include/common/models/AlarmSettingsModel.hpp
M products/BellHybrid/apps/common/include/common/models/FrontlightModel.hpp
M products/BellHybrid/services/db/include/db/SystemSettings.hpp

@@ 17,6 17,9 @@
 #### Onboarding
 * Shortcuts instruction.
 
+#### Alarm
+* Front light intensity during the main alarm and pre-wake up
+
 ### Changed
 
 #### Home Screen:

@@ 669,11 669,11 @@
   "app_bell_settings_about_info_text": "www.mudita.com",
   "app_bell_settings_alarm_settings": "Alarm",
   "app_bell_settings_alarm_settings_title": "Alarm settings",
-  "app_bell_settings_alarm_settings_tone": "Alarm tone",
-  "app_bell_settings_alarm_settings_volume": "Alarm volume",
-  "app_bell_settings_alarm_settings_light": "Alarm light",
+  "app_bell_settings_alarm_settings_tone": "Main alarm tone",
+  "app_bell_settings_alarm_settings_volume": "Main alarm volume",
+  "app_bell_settings_alarm_settings_light": "Main alarm light",
   "app_bell_settings_alarm_settings_prewake_up": "Pre-wake up",
-  "app_bell_settings_alarm_settings_prewake_up_chime_top_description": "Pre-wake up chime",
+  "app_bell_settings_alarm_settings_prewake_up_chime_top_description": "Pre-wake up",
   "app_bell_settings_alarm_settings_prewake_up_chime_bottom_description": "before the alarm",
   "app_bell_settings_alarm_settings_prewake_up_chime_tone": "Pre-wake up chime tone",
   "app_bell_settings_alarm_settings_prewake_up_chime_volume": "Pre-wake up chime volume",

@@ 38,9 38,11 @@ INSERT OR IGNORE INTO settings_tab (path, value) VALUES
     ('prewake_up_duration', '0'),
     ('prewake_up_tone','Joyful Awakening'),
     ('prewake_up_light_duration','0'),
+    ('prewake_up_brightness','50.0f'),
     ('alarm_tone','Morning Dew'),
     ('alarm_light_active','1'),
     ('alarm_duration','5'),
+    ('alarm_brightness','50.0f'),
     ('bedtime_active','0'),
     ('bedtime_time','22:00'),
     ('bedtime_tone','Evening Horizon'),

@@ 9,6 9,7 @@
 #include <service-db/Settings.hpp>
 #include <db/SystemSettings.hpp>
 #include <module-utils/utility/Utils.hpp>
+#include <common/data/FrontlightUtils.hpp>
 
 namespace alarms
 {


@@ 25,6 26,7 @@ namespace alarms
             screen_light_control::ManualModeParameters prepareParameters();
 
             sys::Service &service;
+            settings::Settings settings;
         };
 
         class LinearProgressFrontlightAction : public AbstractAlarmAction


@@ 84,6 86,7 @@ namespace alarms
         case SettingsDependency::None:
             break;
         }
+
         return pimpl->execute();
     }
 


@@ 103,11 106,25 @@ namespace alarms
         default:
             break;
         }
+
         return pimpl->turnOff();
     }
 
+    screen_light_control::ManualModeParameters ManualFrontlightAction::prepareParameters()
+    {
+        std::string brightnessString =
+            settings.getValue(bell::settings::Alarm::brightness, settings::SettingsScope::Global);
+
+        screen_light_control::ManualModeParameters params{};
+        params.manualModeBrightness = frontlight_utils::fixedValToPercentage(std::stoi(brightnessString));
+
+        return params;
+    }
+
     ManualFrontlightAction::ManualFrontlightAction(sys::Service &service) : service{service}
-    {}
+    {
+        settings.init(service::ServiceProxy{service.weak_from_this()});
+    }
 
     bool ManualFrontlightAction::execute()
     {


@@ 118,11 135,6 @@ namespace alarms
         return true;
     }
 
-    screen_light_control::ManualModeParameters ManualFrontlightAction::prepareParameters()
-    {
-        return screen_light_control::ManualModeParameters{.manualModeBrightness = 100.0f};
-    }
-
     bool ManualFrontlightAction::turnOff()
     {
         service.bus.sendUnicast(


@@ 149,16 161,28 @@ namespace alarms
     screen_light_control::LinearProgressModeParameters LinearProgressFrontlightAction::prepareParameters()
     {
         constexpr auto firstTargetDuration = std::chrono::seconds{5};
+
+        std::string brightnessString =
+            settings.getValue(bell::settings::PrewakeUp::brightness, settings::SettingsScope::Global);
         const auto value = settings.getValue(bell::settings::PrewakeUp::lightDuration, settings::SettingsScope::Global);
         const auto lightDuration        = std::chrono::minutes{utils::toNumeric(value)};
         const auto secondTargetDuration = lightDuration - std::chrono::minutes{1} - firstTargetDuration;
-        return screen_light_control::LinearProgressModeParameters{
-            .startBrightnessValue = 0.0f,
-            .functions            = {screen_light_control::functions::LinearProgressFunction{.target   = 10.0f,
-                                                                                  .duration = firstTargetDuration},
-                          screen_light_control::functions::LinearProgressFunction{.target   = 100.0f,
-                                                                                  .duration = secondTargetDuration}},
-            .brightnessHysteresis = 0.0f};
+
+        screen_light_control::LinearProgressModeParameters params{};
+        screen_light_control::functions::LinearProgressFunction startFunction{}, endFunction{};
+
+        startFunction.duration = firstTargetDuration;
+        startFunction.target   = 10.0f;
+
+        endFunction.duration = secondTargetDuration;
+        endFunction.target   = frontlight_utils::fixedValToPercentage(std::stoi(brightnessString));
+        ;
+
+        params.startBrightnessValue = 0.0f;
+        params.brightnessHysteresis = 0.0f;
+        params.functions            = {startFunction, endFunction};
+
+        return params;
     }
 
     bool LinearProgressFrontlightAction::turnOff()


@@ 168,4 192,5 @@ namespace alarms
             service::name::evt_manager);
         return true;
     }
+
 } // namespace alarms

@@ 5,6 5,7 @@
 
 #include "AbstractAlarmAction.hpp"
 #include <service-db/Settings.hpp>
+#include <service-evtmgr/ScreenLightControlMessage.hpp>
 
 #include <Service/Service.hpp>
 

@@ 154,20 154,28 @@ namespace app
 
         windowsFactory.attach(
             gui::BellSettingsPrewakeUpWindow::name, [this](ApplicationCommon *app, const std::string &name) {
-                auto chimeDurationModel = std::make_unique<bell_settings::PrewakeUpChimeDurationModel>(this);
-                auto chimeToneModel     = std::make_unique<bell_settings::PrewakeUpChimeToneModel>(this);
-                auto chimeVolumeModel   = std::make_unique<bell_settings::PrewakeUpChimeVolumeModel>(*audioModel);
-                auto lightDurationModel = std::make_unique<bell_settings::PrewakeUpLightDurationModel>(this);
+                auto prewakeUpChimeDurationModel = std::make_unique<bell_settings::PrewakeUpChimeDurationModel>(this);
+                auto prewakeUpChimeToneModel     = std::make_unique<bell_settings::PrewakeUpChimeToneModel>(this);
+                auto prewakeUpChimeVolumeModel =
+                    std::make_unique<bell_settings::PrewakeUpChimeVolumeModel>(*audioModel);
+                auto prewakeUpLightDurationModel = std::make_unique<bell_settings::PrewakeUpLightDurationModel>(this);
+                auto prewakeUpFrontlightModel    = std::make_unique<bell_settings::PrewakeUpFrontlightModel>(this);
                 auto prewakeUpSettingsModel =
-                    std::make_unique<bell_settings::PrewakeUpSettingsModel>(std::move(chimeDurationModel),
-                                                                            std::move(chimeToneModel),
-                                                                            std::move(chimeVolumeModel),
-                                                                            std::move(lightDurationModel));
+                    std::make_unique<bell_settings::PrewakeUpSettingsModel>(std::move(prewakeUpChimeDurationModel),
+                                                                            std::move(prewakeUpChimeToneModel),
+                                                                            std::move(prewakeUpChimeVolumeModel),
+                                                                            std::move(prewakeUpLightDurationModel),
+                                                                            std::move(prewakeUpFrontlightModel));
                 auto soundsRepository = std::make_unique<SoundsRepository>(alarms::paths::getPreWakeUpChimesDir());
-                auto provider         = std::make_shared<bell_settings::PrewakeUpListItemProvider>(
+                auto provider         = std::make_unique<bell_settings::PrewakeUpListItemProvider>(
                     *prewakeUpSettingsModel, soundsRepository->getSongTitles());
-                auto presenter = std::make_unique<bell_settings::PrewakeUpWindowPresenter>(
-                    provider, std::move(prewakeUpSettingsModel), *audioModel, std::move(soundsRepository));
+                auto frontlightModel = std::make_unique<bell_settings::FrontlightModel>(app);
+                auto presenter =
+                    std::make_unique<bell_settings::PrewakeUpWindowPresenter>(std::move(provider),
+                                                                              std::move(prewakeUpSettingsModel),
+                                                                              *audioModel,
+                                                                              std::move(soundsRepository),
+                                                                              std::move(frontlightModel));
                 return std::make_unique<gui::BellSettingsPrewakeUpWindow>(app, std::move(presenter));
             });
 


@@ 201,13 209,21 @@ namespace app
                 auto alarmToneModel       = std::make_unique<bell_settings::AlarmToneModel>(this);
                 auto alarmVolumeModel     = std::make_unique<bell_settings::AlarmVolumeModel>(*audioModel);
                 auto alarmLightOnOffModel = std::make_unique<bell_settings::AlarmLightOnOffModel>(this);
-                auto alarmSettingsModel   = std::make_unique<bell_settings::AlarmSettingsModel>(
-                    std::move(alarmToneModel), std::move(alarmVolumeModel), std::move(alarmLightOnOffModel));
+                auto alarmFrontlightModel = std::make_unique<bell_settings::AlarmFrontlightModel>(this);
+                auto alarmSettingsModel =
+                    std::make_unique<bell_settings::AlarmSettingsModel>(std::move(alarmToneModel),
+                                                                        std::move(alarmVolumeModel),
+                                                                        std::move(alarmLightOnOffModel),
+                                                                        std::move(alarmFrontlightModel));
                 auto soundsRepository = std::make_unique<SoundsRepository>(alarms::paths::getAlarmDir());
-                auto provider         = std::make_shared<bell_settings::AlarmSettingsListItemProvider>(
+                auto frontlightModel  = std::make_unique<bell_settings::FrontlightModel>(app);
+                auto provider         = std::make_unique<bell_settings::AlarmSettingsListItemProvider>(
                     *alarmSettingsModel, soundsRepository->getSongTitles());
-                auto presenter = std::make_unique<bell_settings::AlarmSettingsPresenter>(
-                    provider, std::move(alarmSettingsModel), *audioModel, std::move(soundsRepository));
+                auto presenter = std::make_unique<bell_settings::AlarmSettingsPresenter>(std::move(provider),
+                                                                                         std::move(alarmSettingsModel),
+                                                                                         *audioModel,
+                                                                                         std::move(soundsRepository),
+                                                                                         std::move(frontlightModel));
                 return std::make_unique<gui::BellSettingsAlarmSettingsWindow>(app, std::move(presenter));
             });
 

@@ 8,28 8,6 @@
 #include <service-evtmgr/Constants.hpp>
 #include <service-evtmgr/ScreenLightControlMessage.hpp>
 
-namespace
-{
-    constexpr auto minPercent                       = 0.0f;
-    constexpr auto maxPercent                       = 100.0f;
-    constexpr auto minimumLightOnPercentOffsetValue = 16.0f;
-    constexpr auto minBrightness                    = 1U;
-    constexpr auto maxBrightness                    = 10U;
-    constexpr float multiplier                      = (maxPercent - minimumLightOnPercentOffsetValue) / maxBrightness;
-
-    float fixedValToPercentage(app::bell_settings::AbstractFrontlightModel::Brightness value)
-    {
-        float scaled = minimumLightOnPercentOffsetValue + (value - minBrightness) * multiplier;
-        return std::min(maxPercent, std::max(minPercent, scaled));
-    }
-
-    app::bell_settings::AbstractFrontlightModel::Brightness percentageToFixedVal(float percent)
-    {
-        auto value = (percent - minimumLightOnPercentOffsetValue) / multiplier;
-        return std::round(value + minBrightness);
-    }
-} // namespace
-
 namespace app::bell_settings
 {
     FrontlightModel::FrontlightModel(ApplicationCommon *app)


@@ 41,7 19,8 @@ namespace app::bell_settings
         const auto responseCallback = [this](const auto response) -> bool {
             const auto resp = dynamic_cast<sevm::ScreenLightControlParametersResponse *>(response);
             if (resp) {
-                this->brightnessAdapter->update(percentageToFixedVal(resp->getParams().manualModeBrightness));
+                this->brightnessAdapter->update(
+                    frontlight_utils::percentageToFixedVal(resp->getParams().manualModeBrightness));
                 this->modeAdapter->update(
                     resp->getMode() == screen_light_control::ScreenLightMode::Automatic ? autoStr : onDemandStr);
                 if (this->onReady) {


@@ 68,10 47,11 @@ namespace app::bell_settings
                                      : screen_light_control::Action::disableAutomaticMode),
                              service::name::evt_manager);
     }
-    void FrontlightModel::setBrightness(Brightness value)
+    void FrontlightModel::setBrightness(frontlight_utils::Brightness value)
     {
         hasUnsavedChanges = true;
-        screen_light_control::ConstLinearProgressModeParameters parameters{fixedValToPercentage(value)};
+        screen_light_control::ConstLinearProgressModeParameters parameters{
+            frontlight_utils::fixedValToPercentage(value)};
         app->bus.sendUnicast(std::make_shared<sevm::ScreenLightSetConstLinearModeParams>(parameters),
                              service::name::evt_manager);
     }


@@ 89,10 69,10 @@ namespace app::bell_settings
         if (!hasUnsavedChanges) {
             return;
         }
-        setStatus(false);
         setMode(modeAdapter->getValue() == autoStr ? screen_light_control::ScreenLightMode::Automatic
                                                    : screen_light_control::ScreenLightMode::Manual);
         setBrightness(brightnessAdapter->getValue());
+        setStatus(true);
     }
 
     void FrontlightModel::setChangesSaved()

@@ 1,9 1,10 @@
-// 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
 
 #include <common/models/AbstractSettingsModel.hpp>
+#include <common/data/FrontlightUtils.hpp>
 #include <utf8/UTF8.hpp>
 
 #include <cstdint>


@@ 15,12 16,15 @@ namespace app::bell_settings
     class AbstractPrewakeUpSettingsModel
     {
       public:
-        AbstractPrewakeUpSettingsModel(std::unique_ptr<gui::AbstractSettingsModel<std::uint8_t>> chimeDuration,
-                                       std::unique_ptr<gui::AbstractSettingsModel<UTF8>> chimeTone,
-                                       std::unique_ptr<gui::AbstractSettingsModel<std::uint8_t>> chimeVolume,
-                                       std::unique_ptr<gui::AbstractSettingsModel<std::uint8_t>> lightDuration)
+        AbstractPrewakeUpSettingsModel(
+            std::unique_ptr<gui::AbstractSettingsModel<std::uint8_t>> chimeDuration,
+            std::unique_ptr<gui::AbstractSettingsModel<UTF8>> chimeTone,
+            std::unique_ptr<gui::AbstractSettingsModel<std::uint8_t>> chimeVolume,
+            std::unique_ptr<gui::AbstractSettingsModel<std::uint8_t>> lightDuration,
+            std::unique_ptr<gui::AbstractSettingsModel<frontlight_utils::Brightness>> frontlight)
             : chimeDuration(std::move(chimeDuration)), chimeTone(std::move(chimeTone)),
-              chimeVolume(std::move(chimeVolume)), lightDuration(std::move(lightDuration))
+              chimeVolume(std::move(chimeVolume)), lightDuration(std::move(lightDuration)),
+              frontlight(std::move(frontlight))
         {}
 
         virtual ~AbstractPrewakeUpSettingsModel() = default;


@@ 45,10 49,16 @@ namespace app::bell_settings
             return *lightDuration;
         }
 
+        gui::AbstractSettingsModel<frontlight_utils::Brightness> &getBrightness()
+        {
+            return *frontlight;
+        }
+
       private:
         std::unique_ptr<gui::AbstractSettingsModel<std::uint8_t>> chimeDuration;
         std::unique_ptr<gui::AbstractSettingsModel<UTF8>> chimeTone;
         std::unique_ptr<gui::AbstractSettingsModel<std::uint8_t>> chimeVolume;
         std::unique_ptr<gui::AbstractSettingsModel<std::uint8_t>> lightDuration;
+        std::unique_ptr<gui::AbstractSettingsModel<frontlight_utils::Brightness>> frontlight;
     };
 } // namespace app::bell_settings

@@ 1,8 1,9 @@
-// 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
 
 #include "BellSettingsStyle.hpp"
 #include "AlarmSettingsListItemProvider.hpp"
+#include <common/models/FrontlightModel.hpp>
 #include <common/widgets/ListItems.hpp>
 #include <common/widgets/list_items/Text.hpp>
 #include <common/widgets/list_items/Numeric.hpp>


@@ 12,20 13,23 @@ namespace app::bell_settings
 {
     using namespace gui;
 
-    AlarmSettingsListItemProvider::AlarmSettingsListItemProvider(AbstractAlarmSettingsModel &model,
+    AlarmSettingsListItemProvider::AlarmSettingsListItemProvider(AbstractAlarmSettingsModel &settingsModel,
                                                                  std::vector<UTF8> alarmToneRange)
-        : model{model}
+        : settingsModel{settingsModel}
     {
         buildListItems(std::move(alarmToneRange));
     }
 
     void AlarmSettingsListItemProvider::buildListItems(std::vector<UTF8> alarmTonesRange)
     {
-        constexpr auto itemCount = 4U;
+        constexpr auto brightnessMin  = 1U;
+        constexpr auto brightnessMax  = 10U;
+        constexpr auto brightnessStep = 1U;
+        constexpr auto itemCount      = 5U;
         internalData.reserve(itemCount);
 
         auto alarmTone = new list_items::Text(std::move(alarmTonesRange),
-                                              model.getAlarmTone(),
+                                              settingsModel.getAlarmTone(),
                                               utils::translate("app_bell_settings_alarm_settings_tone"));
         alarmTone->set_on_value_change_cb([this](const auto &val) {
             if (onToneChange) {


@@ 49,7 53,7 @@ namespace app::bell_settings
         constexpr auto volumeMax  = 10U;
         auto alarmVolume =
             new list_items::Numeric(list_items::Numeric::spinner_type::range{volumeMin, volumeMax, volumeStep},
-                                    model.getAlarmVolume(),
+                                    settingsModel.getAlarmVolume(),
                                     utils::translate("app_bell_settings_alarm_settings_volume"));
         alarmVolume->set_on_value_change_cb([this](const auto &val) {
             if (onVolumeChange) {


@@ 69,8 73,44 @@ namespace app::bell_settings
 
         internalData.emplace_back(alarmVolume);
 
-        internalData.emplace_back(
-            new OnOffListItem(model.getAlarmLightOnOff(), utils::translate("app_bell_settings_alarm_settings_light")));
+        auto onOffLight = new OnOffListItem(settingsModel.getAlarmLightOnOff(),
+                                            utils::translate("app_bell_settings_alarm_settings_light"));
+
+        internalData.emplace_back(onOffLight);
+
+        onOffLight->onProceed = [onOffLight, this]() {
+            if (!onOffLight->isActive()) {
+                this->onExit();
+                return true;
+            }
+            return false;
+        };
+
+        auto brightness = new list_items::Numeric(
+            list_items::Numeric::spinner_type::range{brightnessMin, brightnessMax, brightnessStep},
+            settingsModel.getBrightness(),
+            utils::translate("app_bell_settings_frontlight_top_message"));
+
+        brightness->set_on_value_change_cb([this](const auto &val) {
+            if (onFrontlightChange) {
+                onFrontlightChange(val);
+            }
+        });
+
+        brightness->onEnter = [this]() {
+            auto brightness = settingsModel.getBrightness().getValue();
+            if (onFrontlightEnter) {
+                onFrontlightEnter(brightness);
+            }
+        };
+
+        brightness->onExit = [this]() {
+            if (onFrontlightExit) {
+                onFrontlightExit();
+            }
+        };
+
+        internalData.emplace_back(brightness);
 
         for (auto item : internalData) {
             item->deleteByList = false;

@@ 5,18 5,20 @@
 
 #include "SettingsListItemProvider.hpp"
 #include <common/models/AbstractAlarmSettingsModel.hpp>
+#include <common/models/AbstractSettingsModel.hpp>
 
 namespace app::bell_settings
 {
+    class AbstractFrontlightModel;
     class AlarmSettingsListItemProvider : public SettingsListItemProvider
     {
       public:
-        AlarmSettingsListItemProvider(AbstractAlarmSettingsModel &model, std::vector<UTF8> alarmToneRange);
+        AlarmSettingsListItemProvider(AbstractAlarmSettingsModel &settingsModel, std::vector<UTF8> alarmToneRange);
 
       private:
         void buildListItems(std::vector<UTF8> alarmTonesRange);
 
-        AbstractAlarmSettingsModel &model;
+        AbstractAlarmSettingsModel &settingsModel;
     };
 
 } // namespace app::bell_settings

@@ 47,4 47,16 @@ namespace app::bell_settings
         const auto str = settings.getValue(bell::settings::Alarm::lightActive, settings::SettingsScope::Global);
         return std::stoi(str);
     }
+
+    void AlarmFrontlightModel::setValue(frontlight_utils::Brightness value)
+    {
+        const auto valStr = std::to_string(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);
+    }
 } // namespace app::bell_settings

@@ 1,7 1,8 @@
-// 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
 
 #include "PrewakeUpListItemProvider.hpp"
+#include <common/models/FrontlightModel.hpp>
 #include <common/widgets/list_items/NumberWithSuffix.hpp>
 #include <common/widgets/list_items/Numeric.hpp>
 #include <common/widgets/ListItems.hpp>


@@ 14,29 15,31 @@ namespace app::bell_settings
 {
     using namespace gui;
 
-    PrewakeUpListItemProvider::PrewakeUpListItemProvider(AbstractPrewakeUpSettingsModel &model,
+    PrewakeUpListItemProvider::PrewakeUpListItemProvider(AbstractPrewakeUpSettingsModel &settingsModel,
                                                          std::vector<UTF8> chimeToneRange)
-        : model{model}
+        : settingsModel{settingsModel}
     {
         buildListItems(std::move(chimeToneRange));
     }
 
     void PrewakeUpListItemProvider::buildListItems(std::vector<UTF8> chimeToneRange)
     {
-        constexpr auto itemCount = 4U;
+        constexpr auto brightnessMin  = 1U;
+        constexpr auto brightnessMax  = 10U;
+        constexpr auto brightnessStep = 1U;
+        constexpr auto itemCount      = 5U;
         internalData.reserve(itemCount);
 
         const std::string minStr = utils::translate("common_minute_short");
         auto chimeDuration       = new list_items::NumberWithSuffix(
             list_items::NumberWithSuffix::spinner_type::range{0, 5, 10, 15},
-            model.getChimeDuration(),
+            settingsModel.getChimeDuration(),
             utils::translate("app_bell_settings_alarm_settings_prewake_up_chime_top_description"),
             utils::translate("app_bell_settings_alarm_settings_prewake_up_chime_bottom_description"));
 
         chimeDuration->onProceed = [chimeDuration, this]() {
             if (chimeDuration->value() == 0) {
-                constexpr auto lightDurationListIndex = 3U;
-                list->rebuildList(gui::listview::RebuildType::OnOffset, lightDurationListIndex);
+                this->onExit();
                 return true;
             }
             return false;


@@ 46,7 49,7 @@ namespace app::bell_settings
 
         auto chimeTone =
             new list_items::Text(std::move(chimeToneRange),
-                                 model.getChimeTone(),
+                                 settingsModel.getChimeTone(),
                                  utils::translate("app_bell_settings_alarm_settings_prewake_up_chime_tone"));
         chimeTone->set_on_value_change_cb([this](const auto &val) {
             if (onToneChange) {


@@ 70,7 73,7 @@ namespace app::bell_settings
         constexpr auto volumeMax  = 10U;
         auto volume =
             new list_items::Numeric(list_items::Numeric::spinner_type::range{volumeMin, volumeMax, volumeStep},
-                                    model.getChimeVolume(),
+                                    settingsModel.getChimeVolume(),
                                     utils::translate("app_bell_settings_alarm_settings_prewake_up_chime_volume"));
         volume->set_on_value_change_cb([this](const auto &val) {
             if (onVolumeChange) {


@@ 93,7 96,7 @@ namespace app::bell_settings
 
         auto lightDuration = new list_items::NumberWithSuffix(
             list_items::NumberWithSuffix::spinner_type::range{0, 5, 10, 15},
-            model.getLightDuration(),
+            settingsModel.getLightDuration(),
             utils::translate("app_bell_settings_alarm_settings_prewake_up_light_top_description"),
             utils::translate("app_bell_settings_alarm_settings_prewake_up_light_bottom_description"));
 


@@ 105,8 108,42 @@ namespace app::bell_settings
             return false;
         };
 
+        lightDuration->onProceed = [lightDuration, this]() {
+            if (lightDuration->value() == 0) {
+                this->onExit();
+                return true;
+            }
+            return false;
+        };
+
         internalData.emplace_back(lightDuration);
 
+        auto brightness = new list_items::Numeric(
+            list_items::Numeric::spinner_type::range{brightnessMin, brightnessMax, brightnessStep},
+            settingsModel.getBrightness(),
+            utils::translate("app_bell_settings_frontlight_top_message"));
+
+        brightness->set_on_value_change_cb([this](const auto &val) {
+            if (onFrontlightChange) {
+                onFrontlightChange(val);
+            }
+        });
+
+        brightness->onEnter = [this]() {
+            auto brightness = settingsModel.getBrightness().getValue();
+            if (onFrontlightEnter) {
+                onFrontlightEnter(brightness);
+            }
+        };
+
+        brightness->onExit = [this]() {
+            if (onFrontlightExit) {
+                onFrontlightExit();
+            }
+        };
+
+        internalData.emplace_back(brightness);
+
         for (auto item : internalData) {
             item->deleteByList = false;
         }

@@ 1,22 1,24 @@
-// 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
 
 #include "SettingsListItemProvider.hpp"
 #include "AbstractPrewakeUpSettingsModel.hpp"
+#include <common/models/AbstractSettingsModel.hpp>
 
 namespace app::bell_settings
 {
+    class AbstractFrontlightModel;
     class PrewakeUpListItemProvider : public SettingsListItemProvider
     {
       public:
-        PrewakeUpListItemProvider(AbstractPrewakeUpSettingsModel &model, std::vector<UTF8> chimeToneRange);
+        PrewakeUpListItemProvider(AbstractPrewakeUpSettingsModel &settingsModel, std::vector<UTF8> chimeToneRange);
 
       private:
         void buildListItems(std::vector<UTF8> preWakeupToneRange);
 
-        AbstractPrewakeUpSettingsModel &model;
+        AbstractPrewakeUpSettingsModel &settingsModel;
     };
 
 } // namespace app::bell_settings

@@ 59,4 59,16 @@ namespace app::bell_settings
         const auto str = settings.getValue(bell::settings::PrewakeUp::lightDuration, settings::SettingsScope::Global);
         return std::stoi(str);
     }
+
+    void PrewakeUpFrontlightModel::setValue(frontlight_utils::Brightness value)
+    {
+        const auto valStr = std::to_string(frontlight_utils::fixedValToPercentage(value));
+        settings.setValue(bell::settings::PrewakeUp::brightness, valStr, settings::SettingsScope::Global);
+    }
+
+    frontlight_utils::Brightness PrewakeUpFrontlightModel::getValue() const
+    {
+        const auto str = settings.getValue(bell::settings::PrewakeUp::brightness, settings::SettingsScope::Global);
+        return frontlight_utils::percentageToFixedVal(std::stoi(str));
+    }
 } // namespace app::bell_settings

@@ 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


@@ 6,6 6,7 @@
 #include "AbstractPrewakeUpSettingsModel.hpp"
 #include <common/models/SettingsModel.hpp>
 #include <common/models/AudioModel.hpp>
+#include <common/data/FrontlightUtils.hpp>
 
 namespace app::bell_settings
 {


@@ 49,17 50,28 @@ namespace app::bell_settings
         std::uint8_t getValue() const override;
     };
 
+    class PrewakeUpFrontlightModel : public gui::SettingsModel<frontlight_utils::Brightness>
+    {
+      public:
+        using SettingsModel::SettingsModel;
+
+        void setValue(frontlight_utils::Brightness value) override;
+        frontlight_utils::Brightness getValue() const override;
+    };
+
     class PrewakeUpSettingsModel : public AbstractPrewakeUpSettingsModel
     {
       public:
         PrewakeUpSettingsModel(std::unique_ptr<PrewakeUpChimeDurationModel> chimeDurationModel,
                                std::unique_ptr<PrewakeUpChimeToneModel> chimeToneModel,
                                std::unique_ptr<PrewakeUpChimeVolumeModel> chimeVolumeModel,
-                               std::unique_ptr<PrewakeUpLightDurationModel> lightDurationModel)
+                               std::unique_ptr<PrewakeUpLightDurationModel> lightDurationModel,
+                               std::unique_ptr<PrewakeUpFrontlightModel> frontlightModel)
             : AbstractPrewakeUpSettingsModel(std::move(chimeDurationModel),
                                              std::move(chimeToneModel),
                                              std::move(chimeVolumeModel),
-                                             std::move(lightDurationModel))
+                                             std::move(lightDurationModel),
+                                             std::move(frontlightModel))
         {}
     };
 } // namespace app::bell_settings

@@ 1,9 1,10 @@
-// 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
 
 #include <common/widgets/BellSideListItemWithCallbacks.hpp>
+#include <common/data/FrontlightUtils.hpp>
 #include <apps-common/InternalModel.hpp>
 
 namespace app::bell_settings


@@ 18,6 19,9 @@ namespace app::bell_settings
         /// Val contains currently chosen volume(1-10 range)
         using VolumeCallback      = std::function<void(const uint32_t &val)>;
         using VolumeEnterCallback = ToneCallback;
+        using FrontlightCallback      = std::function<void(const frontlight_utils::Brightness &val)>;
+        using FrontlightEnterCallback = FrontlightCallback;
+        using FrontlightExitCallback  = std::function<void()>;
 
         std::vector<gui::BellSideListItemWithCallbacks *> getListItems();
 


@@ 40,6 44,10 @@ namespace app::bell_settings
         VolumeEnterCallback onVolumeEnter;
         VolumeCallback onVolumeExit;
         VolumeCallback onVolumeChange;
+
+        FrontlightEnterCallback onFrontlightEnter;
+        FrontlightExitCallback onFrontlightExit;
+        FrontlightCallback onFrontlightChange;
     };
 
 } // namespace app::bell_settings

@@ 6,12 6,13 @@
 
 namespace app::bell_settings
 {
-    AlarmSettingsPresenter::AlarmSettingsPresenter(std::shared_ptr<AlarmSettingsListItemProvider> provider,
-                                                   std::unique_ptr<AbstractAlarmSettingsModel> model,
+    AlarmSettingsPresenter::AlarmSettingsPresenter(std::unique_ptr<AlarmSettingsListItemProvider> &&provider,
+                                                   std::unique_ptr<AbstractAlarmSettingsModel> &&settingsModel,
                                                    AbstractAudioModel &audioModel,
-                                                   std::unique_ptr<AbstractSoundsRepository> soundsRepository)
-        : provider(provider),
-          model(std::move(model)), audioModel{audioModel}, soundsRepository{std::move(soundsRepository)}
+                                                   std::unique_ptr<AbstractSoundsRepository> &&soundsRepository,
+                                                   std::unique_ptr<AbstractFrontlightModel> &&frontlight)
+        : provider{std::move(provider)}, settingsModel{std::move(settingsModel)}, audioModel{audioModel},
+          soundsRepository{std::move(soundsRepository)}, frontlight{std::move(frontlight)}
     {
 
         auto playSound = [this](const UTF8 &val) {


@@ 29,6 30,15 @@ namespace app::bell_settings
         this->provider->onVolumeChange = [this](const auto &val) {
             this->audioModel.setVolume(val, AbstractAudioModel::PlaybackType::Alarm, {});
         };
+
+        auto setBrightness = [this](const auto &brightness) {
+            this->frontlight->setStatus(true);
+            this->frontlight->setBrightness(brightness);
+        };
+
+        this->provider->onFrontlightEnter  = setBrightness;
+        this->provider->onFrontlightChange = setBrightness;
+        this->provider->onFrontlightExit   = [this]() { this->frontlight->revertUnsavedChanges(); };
     }
 
     auto AlarmSettingsPresenter::saveData() -> void


@@ 54,10 64,12 @@ namespace app::bell_settings
     {
         provider->clearData();
     }
+
     void AlarmSettingsPresenter::stopSound()
     {
         this->audioModel.stopPlayedByThis({});
     }
+
     void AlarmSettingsPresenter::exitWithSave()
     {
         saveData();


@@ 67,7 79,7 @@ namespace app::bell_settings
     void AlarmSettingsPresenter::exitWithRollback()
     {
         this->stopSound();
-        model->getAlarmVolume().restoreDefault();
+        settingsModel->getAlarmVolume().restoreDefault();
         eraseProviderData();
     }
 } // namespace app::bell_settings

@@ 6,6 6,7 @@
 #include <apps-common/BasePresenter.hpp>
 #include <apps-common/AudioOperations.hpp>
 #include <common/models/AbstractAudioModel.hpp>
+#include <common/models/FrontlightModel.hpp>
 #include <common/SoundsRepository.hpp>
 #include <memory>
 


@@ 35,6 36,7 @@ namespace app::bell_settings
             virtual ~Presenter() noexcept                                                   = default;
             virtual auto getPagesProvider() const -> std::shared_ptr<gui::ListItemProvider> = 0;
             virtual auto loadData() -> void                                                 = 0;
+            virtual auto saveData() -> void                                                 = 0;
             virtual auto eraseProviderData() -> void                                        = 0;
             virtual auto exitWithSave() -> void                                             = 0;
             virtual auto exitWithRollback() -> void                                         = 0;


@@ 44,24 46,26 @@ namespace app::bell_settings
     class AlarmSettingsPresenter : public AlarmSettingsWindowContract::Presenter
     {
       public:
-        AlarmSettingsPresenter(std::shared_ptr<AlarmSettingsListItemProvider> provider,
-                               std::unique_ptr<AbstractAlarmSettingsModel> model,
+        AlarmSettingsPresenter(std::unique_ptr<AlarmSettingsListItemProvider> &&provider,
+                               std::unique_ptr<AbstractAlarmSettingsModel> &&settingsModel,
                                AbstractAudioModel &audioModel,
-                               std::unique_ptr<AbstractSoundsRepository> soundsRepository);
+                               std::unique_ptr<AbstractSoundsRepository> &&soundsRepository,
+                               std::unique_ptr<AbstractFrontlightModel> &&frontlight);
 
         auto getPagesProvider() const -> std::shared_ptr<gui::ListItemProvider> override;
         auto loadData() -> void override;
+        auto saveData() -> void;
         auto eraseProviderData() -> void override;
         auto exitWithSave() -> void override;
         auto exitWithRollback() -> void override;
 
       private:
         auto stopSound() -> void;
-        auto saveData() -> void;
 
         std::shared_ptr<AlarmSettingsListItemProvider> provider;
-        std::unique_ptr<AbstractAlarmSettingsModel> model;
+        std::unique_ptr<AbstractAlarmSettingsModel> settingsModel;
         AbstractAudioModel &audioModel;
         std::unique_ptr<AbstractSoundsRepository> soundsRepository;
+        std::unique_ptr<AbstractFrontlightModel> frontlight;
     };
 } // namespace app::bell_settings

@@ 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
 
 #include "PrewakeUpPresenter.hpp"


@@ 6,12 6,13 @@
 
 namespace app::bell_settings
 {
-    PrewakeUpWindowPresenter::PrewakeUpWindowPresenter(std::shared_ptr<PrewakeUpListItemProvider> provider,
-                                                       std::unique_ptr<AbstractPrewakeUpSettingsModel> model,
+    PrewakeUpWindowPresenter::PrewakeUpWindowPresenter(std::unique_ptr<PrewakeUpListItemProvider> &&provider,
+                                                       std::unique_ptr<AbstractPrewakeUpSettingsModel> &&model,
                                                        AbstractAudioModel &audioModel,
-                                                       std::unique_ptr<AbstractSoundsRepository> soundsRepository)
-        : provider(std::move(provider)),
-          model(std::move(model)), audioModel{audioModel}, soundsRepository{std::move(soundsRepository)}
+                                                       std::unique_ptr<AbstractSoundsRepository> &&soundsRepository,
+                                                       std::unique_ptr<AbstractFrontlightModel> &&frontlight)
+        : provider{std::move(provider)}, model{std::move(model)}, audioModel{audioModel},
+          soundsRepository{std::move(soundsRepository)}, frontlight{std::move(frontlight)}
     {
         auto playSound = [this](const UTF8 &val) {
             currentSoundPath = val;


@@ 34,11 35,21 @@ namespace app::bell_settings
                 playSound(currentSoundPath);
             }
         };
+
+        auto setBrightness = [this](const auto &brightness) {
+            this->frontlight->setStatus(true);
+            this->frontlight->setBrightness(brightness);
+        };
+
+        this->provider->onFrontlightEnter  = setBrightness;
+        this->provider->onFrontlightChange = setBrightness;
+        this->provider->onFrontlightExit   = [this]() { this->frontlight->revertUnsavedChanges(); };
     }
 
     auto PrewakeUpWindowPresenter::saveData() -> void
     {
         for (const auto &item : provider->getListItems()) {
+
             item->getValue();
         }
     }

@@ 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


@@ 7,6 7,7 @@
 #include <apps-common/AudioOperations.hpp>
 #include <models/alarm_settings/AbstractPrewakeUpSettingsModel.hpp>
 #include <common/models/AbstractAudioModel.hpp>
+#include <common/models/FrontlightModel.hpp>
 #include <common/SoundsRepository.hpp>
 #include <memory>
 


@@ 44,10 45,11 @@ namespace app::bell_settings
     class PrewakeUpWindowPresenter : public PrewakeUpWindowContract::Presenter
     {
       public:
-        PrewakeUpWindowPresenter(std::shared_ptr<PrewakeUpListItemProvider> provider,
-                                 std::unique_ptr<AbstractPrewakeUpSettingsModel> model,
+        PrewakeUpWindowPresenter(std::unique_ptr<PrewakeUpListItemProvider> &&provider,
+                                 std::unique_ptr<AbstractPrewakeUpSettingsModel> &&model,
                                  AbstractAudioModel &audioModel,
-                                 std::unique_ptr<AbstractSoundsRepository> soundsRepository);
+                                 std::unique_ptr<AbstractSoundsRepository> &&soundsRepository,
+                                 std::unique_ptr<AbstractFrontlightModel> &&frontlight);
 
         auto getPagesProvider() const -> std::shared_ptr<gui::ListItemProvider> override;
         auto saveData() -> void override;


@@ 62,6 64,7 @@ namespace app::bell_settings
         std::unique_ptr<AbstractPrewakeUpSettingsModel> model;
         AbstractAudioModel &audioModel;
         std::unique_ptr<AbstractSoundsRepository> soundsRepository;
+        std::unique_ptr<AbstractFrontlightModel> frontlight;
         UTF8 currentSoundPath;
     };
 } // namespace app::bell_settings

@@ 26,7 26,6 @@ namespace gui
     {
         erase();
         buildInterface();
-        isSaveNeeded = false;
     }
 
     void BellSettingsAlarmSettingsWindow::buildInterface()


@@ 51,7 50,6 @@ namespace gui
             return true;
         }
         if (inputEvent.isShortRelease(KeyCode::KEY_ENTER)) {
-            isSaveNeeded = true;
             exit();
             return true;
         }


@@ 64,6 62,7 @@ namespace gui
 
     void BellSettingsAlarmSettingsWindow::exit()
     {
+        presenter->saveData();
         application->switchWindow(
             window::bell_finished::defaultName,
             BellFinishedWindowData::Factory::create("circle_success_big", BellSettingsAlarmSettingsMenuWindow::name));


@@ 72,12 71,7 @@ namespace gui
     void BellSettingsAlarmSettingsWindow::onClose(CloseReason reason)
     {
         if (reason != CloseReason::Popup) {
-            if (isSaveNeeded) {
-                presenter->exitWithSave();
-            }
-            else {
-                presenter->exitWithRollback();
-            }
+            presenter->eraseProviderData();
         }
     }
 

@@ 31,6 31,5 @@ namespace gui
       private:
         SideListView *sidelistview{};
         std::unique_ptr<app::bell_settings::AlarmSettingsWindowContract::Presenter> presenter;
-        bool isSaveNeeded{false};
     };
 } /* namespace gui */

@@ 75,6 75,7 @@ target_sources(application-bell-common
         include/common/windows/SessionPausedWindow.hpp
         include/common/TimeUtils.hpp
         include/common/data/BatteryUtils.hpp
+        include/common/data/FrontlightUtils.hpp
         include/common/models/AbstractAlarmModel.hpp
         include/common/models/AbstractBedtimeModel.hpp
         include/common/models/AbstractSettingsModel.hpp

@@ 0,0 1,36 @@
+// Copyright (c) 2017-2022, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#pragma once
+
+#include <cmath>
+#include <cstdint>
+
+namespace frontlight_utils
+{
+    namespace
+    {
+        static constexpr auto minPercent                       = 0.0f;
+        static constexpr auto maxPercent                       = 100.0f;
+        static constexpr auto minimumLightOnPercentOffsetValue = 16.0f;
+        static constexpr auto minBrightness                    = 1U;
+        static constexpr auto maxBrightness                    = 10U;
+        static constexpr float multiplier = (maxPercent - minimumLightOnPercentOffsetValue) / maxBrightness;
+    } // namespace
+
+    /// 1-10 range
+    using Brightness = std::uint8_t;
+
+    static inline float fixedValToPercentage(Brightness value)
+    {
+        float scaled = minimumLightOnPercentOffsetValue + (value - minBrightness) * multiplier;
+        return std::min(maxPercent, std::max(minPercent, scaled));
+    }
+
+    static inline Brightness percentageToFixedVal(float percent)
+    {
+        auto value = (percent - minimumLightOnPercentOffsetValue) / multiplier;
+        return std::round(value + minBrightness);
+    }
+
+} // namespace frontlight_utils

@@ 1,9 1,10 @@
-// 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
 
 #include <common/models/AbstractSettingsModel.hpp>
+#include <common/data/FrontlightUtils.hpp>
 
 #include <cstdint>
 #include <utf8/UTF8.hpp>


@@ 13,11 14,13 @@ namespace app::bell_settings
     class AbstractAlarmSettingsModel
     {
       public:
-        AbstractAlarmSettingsModel(std::unique_ptr<gui::AbstractSettingsModel<UTF8>> alarmTone,
-                                   std::unique_ptr<gui::AbstractSettingsModel<std::uint8_t>> alarmVolume,
-                                   std::unique_ptr<gui::AbstractSettingsModel<bool>> alarmLightOnOff)
+        AbstractAlarmSettingsModel(
+            std::unique_ptr<gui::AbstractSettingsModel<UTF8>> alarmTone,
+            std::unique_ptr<gui::AbstractSettingsModel<std::uint8_t>> alarmVolume,
+            std::unique_ptr<gui::AbstractSettingsModel<bool>> alarmLightOnOff,
+            std::unique_ptr<gui::AbstractSettingsModel<frontlight_utils::Brightness>> alarmFrontlight)
             : alarmTone(std::move(alarmTone)), alarmVolume(std::move(alarmVolume)),
-              alarmLightOnOff(std::move(alarmLightOnOff))
+              alarmLightOnOff(std::move(alarmLightOnOff)), alarmFrontlight(std::move(alarmFrontlight))
         {}
 
         virtual ~AbstractAlarmSettingsModel() = default;


@@ 37,9 40,15 @@ namespace app::bell_settings
             return *alarmLightOnOff;
         }
 
+        gui::AbstractSettingsModel<frontlight_utils::Brightness> &getBrightness()
+        {
+            return *alarmFrontlight;
+        }
+
       private:
         std::unique_ptr<gui::AbstractSettingsModel<UTF8>> alarmTone;
         std::unique_ptr<gui::AbstractSettingsModel<std::uint8_t>> alarmVolume;
         std::unique_ptr<gui::AbstractSettingsModel<bool>> alarmLightOnOff;
+        std::unique_ptr<gui::AbstractSettingsModel<frontlight_utils::Brightness>> alarmFrontlight;
     };
 } // namespace app::bell_settings

@@ 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


@@ 6,6 6,7 @@
 #include "AbstractAlarmSettingsModel.hpp"
 #include <common/models/SettingsModel.hpp>
 #include <common/models/AudioModel.hpp>
+#include <common/data/FrontlightUtils.hpp>
 
 namespace app::bell_settings
 {


@@ 40,14 41,26 @@ namespace app::bell_settings
         bool getValue() const override;
     };
 
+    class AlarmFrontlightModel : public gui::SettingsModel<frontlight_utils::Brightness>
+    {
+      public:
+        using SettingsModel::SettingsModel;
+
+        void setValue(frontlight_utils::Brightness value) override;
+        frontlight_utils::Brightness getValue() const override;
+    };
+
     class AlarmSettingsModel : public AbstractAlarmSettingsModel
     {
       public:
         AlarmSettingsModel(std::unique_ptr<AlarmToneModel> alarmToneModel,
                            std::unique_ptr<AlarmVolumeModel> alarmVolumeModel,
-                           std::unique_ptr<AlarmLightOnOffModel> alarmLightOnOffModel)
-            : AbstractAlarmSettingsModel(
-                  std::move(alarmToneModel), std::move(alarmVolumeModel), std::move(alarmLightOnOffModel))
+                           std::unique_ptr<AlarmLightOnOffModel> alarmLightOnOffModel,
+                           std::unique_ptr<AlarmFrontlightModel> alarmFrontlightModel)
+            : AbstractAlarmSettingsModel(std::move(alarmToneModel),
+                                         std::move(alarmVolumeModel),
+                                         std::move(alarmLightOnOffModel),
+                                         std::move(alarmFrontlightModel))
         {}
     };
 } // namespace app::bell_settings

@@ 5,6 5,7 @@
 
 #include <apps-common/AsyncTask.hpp>
 #include <common/models/SettingsModel.hpp>
+#include <common/data/FrontlightUtils.hpp>
 #include <screen-light-control/ScreenLightControlParameters.hpp>
 
 namespace app


@@ 17,10 18,8 @@ namespace app::bell_settings
     class AbstractFrontlightModel
     {
       public:
-        /// 1-10 range
-        using Brightness                                                 = std::uint8_t;
         virtual ~AbstractFrontlightModel()                               = default;
-        virtual void setBrightness(Brightness value)                     = 0;
+        virtual void setBrightness(frontlight_utils::Brightness value)   = 0;
         virtual void setMode(screen_light_control::ScreenLightMode mode) = 0;
         virtual void setStatus(bool onOff)                               = 0;
         virtual void revertUnsavedChanges()                              = 0;


@@ 40,7 39,7 @@ namespace app::bell_settings
         gui::AbstractSettingsModel<std::uint8_t> &getBrightnessModel() override;
         gui::AbstractSettingsModel<UTF8> &getModeModel() override;
 
-        void setBrightness(Brightness value) override;
+        void setBrightness(frontlight_utils::Brightness value) override;
         void setMode(screen_light_control::ScreenLightMode mode) override;
         void setStatus(bool onOff) override;
         void revertUnsavedChanges() override;

@@ 21,12 21,14 @@ namespace bell::settings
         constexpr inline auto duration      = "prewake_up_duration";
         constexpr inline auto tone          = "prewake_up_tone";
         constexpr inline auto lightDuration = "prewake_up_light_duration";
+        constexpr inline auto brightness    = "prewake_up_brightness";
     } // namespace PrewakeUp
     namespace Alarm
     {
         constexpr inline auto tone        = "alarm_tone";
         constexpr inline auto lightActive = "alarm_light_active";
         constexpr inline auto duration    = "alarm_duration";
+        constexpr inline auto brightness  = "alarm_brightness";
     } // namespace Alarm
     namespace Bedtime
     {