26 files changed, 245 insertions(+), 142 deletions(-)

M CMakeLists.txt
M module-services/service-evtmgr/backlight-handler/BacklightHandlerCommon.cpp
M module-utils/utility/CMakeLists.txt
A module-utils/utility/FrontlightUtils.hpp
M products/BellHybrid/alarms/src/actions/FrontlightAction.cpp
M products/BellHybrid/apps/application-bell-powernap/models/PowerNapFrontlightModel.cpp
M products/BellHybrid/apps/application-bell-powernap/models/PowerNapFrontlightModel.hpp
M products/BellHybrid/apps/application-bell-settings/models/BedsideModel.cpp
M products/BellHybrid/apps/application-bell-settings/models/FrontlightModel.cpp
M products/BellHybrid/apps/application-bell-settings/models/alarm_settings/AbstractAlarmSettingsModel.hpp
M products/BellHybrid/apps/application-bell-settings/models/alarm_settings/AbstractPrewakeUpSettingsModel.hpp
M products/BellHybrid/apps/application-bell-settings/models/alarm_settings/AlarmSettingsModel.cpp
M products/BellHybrid/apps/application-bell-settings/models/alarm_settings/AlarmSettingsModel.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/common/CMakeLists.txt
D products/BellHybrid/apps/common/include/common/data/FrontlightUtils.hpp
M products/BellHybrid/apps/common/include/common/models/BedsideModel.hpp
M products/BellHybrid/apps/common/include/common/models/FrontlightModel.hpp
A products/BellHybrid/services/db/databases/migration/settings_bell/current/287a0959_Change_store_brightness_from_percent_to_level/.meta
A products/BellHybrid/services/db/databases/migration/settings_bell/current/287a0959_Change_store_brightness_from_percent_to_level/devel.sql
A products/BellHybrid/services/db/databases/migration/settings_bell/current/287a0959_Change_store_brightness_from_percent_to_level/down.sql
A products/BellHybrid/services/db/databases/migration/settings_bell/current/287a0959_Change_store_brightness_from_percent_to_level/up.sql
M products/BellHybrid/services/evtmgr/backlight-handler/BacklightHandler.cpp
M products/BellHybrid/services/evtmgr/screen-light-control/ScreenLightControl.hpp

@@ 36,8 36,16 @@ include(AddDatabases)
 include(FetchContent)
 include(AddScripts)
 
+option(ENABLE_VERSION_PRO "Enable configuration for Pro version" OFF)
+if (ENABLE_VERSION_PRO)
+    add_compile_definitions(CONFIG_VERSION_PRO=1)
+endif()
+
 message("Selected product: ${PRODUCT}")
 message("Selected board:   ${BOARD}")
+if (${PRODUCT} STREQUAL "BellHybrid")
+    message("Pro config:       ${ENABLE_VERSION_PRO}")
+endif()
 message("Board revision:   ${BOARD_REVISION}")
 message("PROJECT_TARGET:   ${PROJECT_TARGET}")
 message("Assets version:   ${ASSETS_TYPE}")


@@ 112,12 120,12 @@ add_compile_options(
 
 include_directories(${CMAKE_SOURCE_DIR})
 
-option (GENERATE_STACK_USAGE "Generate stack usage report" OFF)
+option(GENERATE_STACK_USAGE "Generate stack usage report" OFF)
 if (GENERATE_STACK_USAGE)
     add_compile_options (-fstack-usage)
 endif ()
 
-option (ENABLE_SECURE_BOOT "Build signed binary for Secure Boot" OFF)
+option(ENABLE_SECURE_BOOT "Build signed binary for Secure Boot" OFF)
 set(SIGN_CLIENT_PATH "${CMAKE_SOURCE_DIR}/../sign_server/key_client" CACHE PATH "signclient.py path")
 set(SERVER "https://10.20.50.10:4430" CACHE STRING "sign server address")
 

@@ 5,6 5,7 @@
 #include <service-db/agents/settings/SystemSettings.hpp>
 #include <service-db/Settings.hpp>
 #include <Timers/TimerFactory.hpp>
+#include <FrontlightUtils.hpp>
 #include <Utils.hpp>
 
 namespace backlight


@@ 55,7 56,8 @@ namespace backlight
 
     auto HandlerCommon::getScreenBrightnessValue() const noexcept -> bsp::eink_frontlight::BrightnessPercentage
     {
-        return utils::getNumericValue<float>(getValue(settings::Brightness::brightnessLevel));
+        const auto brightnessValue = utils::toNumeric(getValue(settings::Brightness::brightnessLevel));
+        return utils::frontlight::fixedValToPercentage(brightnessValue);
     }
 
     void HandlerCommon::handleScreenLightRefresh()


@@ 89,8 91,9 @@ namespace backlight
             break;
         case screen_light_control::Action::setManualModeBrightness:
             if (params.hasManualModeParams()) {
-                setValue(settings::Brightness::brightnessLevel,
-                         utils::to_string(params.getManualModeParams().manualModeBrightness));
+                const auto brightnessValue =
+                    utils::frontlight::percentageToFixedVal(params.getManualModeParams().manualModeBrightness);
+                setValue(settings::Brightness::brightnessLevel, utils::to_string(brightnessValue));
             }
             else {
                 LOG_ERROR("Missing ManualModeBrightness value, change request ignored");

@@ 16,6 16,7 @@ target_sources(utility
         Units.hpp
         Anonymize.hpp
         Version.hpp
+        FrontlightUtils.hpp
 )
 
 target_include_directories(utility

@@ 0,0 1,35 @@
+// Copyright (c) 2017-2024, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/blob/master/LICENSE.md
+
+#pragma once
+
+#include <cmath>
+#include <cstdint>
+#include <algorithm>
+
+namespace utils::frontlight
+{
+#if defined(CONFIG_VERSION_PRO) && (CONFIG_VERSION_PRO == 1)
+    inline constexpr auto minimumLightOnPercentOffsetValue = 8.0f;
+#else
+    inline constexpr auto minimumLightOnPercentOffsetValue = 16.0f;
+#endif
+    inline constexpr auto minPercent    = 0.0f;
+    inline constexpr auto maxPercent    = 100.0f;
+    inline constexpr auto minBrightness = 1U;
+    inline constexpr auto maxBrightness = 10U;
+    inline constexpr float multiplier   = (maxPercent - minimumLightOnPercentOffsetValue) / maxBrightness;
+
+    static inline float fixedValToPercentage(std::uint8_t value)
+    {
+        const float valueScaled =
+            (static_cast<float>(value) - minBrightness) * multiplier + minimumLightOnPercentOffsetValue;
+        return std::clamp(valueScaled, minPercent, maxPercent);
+    }
+
+    static inline std::uint8_t percentageToFixedVal(float percent)
+    {
+        const float value = (percent - minimumLightOnPercentOffsetValue) / multiplier;
+        return static_cast<std::uint8_t>(std::round(value + minBrightness));
+    }
+} // namespace utils::frontlight

@@ 3,30 3,33 @@
 
 #include "FrontlightAction.hpp"
 #include "BellAlarmConstants.hpp"
-
 #include <service-evtmgr/ScreenLightControlMessage.hpp>
 #include <service-evtmgr/ServiceEventManagerName.hpp>
-
 #include <service-db/Settings.hpp>
 #include <db/SystemSettings.hpp>
+#include <module-utils/utility/FrontlightUtils.hpp>
 #include <module-utils/utility/Utils.hpp>
 
 namespace alarms
 {
     namespace
     {
-        constexpr std::string_view alarmFrontlightOff     = "0";
-        constexpr std::string_view prewakeupFrontlightOff = "0";
+        constexpr auto alarmFrontlightOff     = std::string_view{"0"};
+        constexpr auto prewakeupFrontlightOff = std::string_view{"0"};
 
         /* Reach and maintain target brightness 1 minute faster than
          * the duration of the action. */
         constexpr auto frontlightRampDurationOffset = std::chrono::minutes{1};
         constexpr auto initialTargetDuration        = std::chrono::seconds{5};
-        constexpr auto initialZeroBrightnessValue   = 10;
+#if defined(CONFIG_VERSION_PRO) && (CONFIG_VERSION_PRO == 1)
+        constexpr auto initialZeroBrightnessValue = 5.0f;
+#else
+        constexpr auto initialZeroBrightnessValue = 10.0f;
+#endif
 
-        void validateBrightness(std::string &brightness)
+        inline void validateBrightness(std::string &brightness)
         {
-            constexpr auto defaultBrightness = std::string_view{"50.0"};
+            constexpr auto defaultBrightness = std::string_view{"5"};
 
             if (brightness.empty()) {
                 brightness = defaultBrightness;


@@ 163,9 166,9 @@ namespace alarms
 
         auto brightnessString = settings.getValue(bell::settings::Alarm::brightness, settings::SettingsScope::Global);
         validateBrightness(brightnessString);
-        screen_light_control::ManualModeParameters params{};
-        params.manualModeBrightness = static_cast<BrightnessPercentage>(utils::toNumeric(brightnessString));
 
+        screen_light_control::ManualModeParameters params{
+            .manualModeBrightness = utils::frontlight::fixedValToPercentage(utils::toNumeric(brightnessString))};
         return params;
     }
 


@@ 239,17 242,18 @@ namespace alarms
             auto initialBrightnessString =
                 settings.getValue(bell::settings::PrewakeUp::brightness, settings::SettingsScope::Global);
             validateBrightness(initialBrightnessString);
-            initialBrightness = utils::toNumeric(initialBrightnessString);
+            initialBrightness = utils::frontlight::fixedValToPercentage(utils::toNumeric(initialBrightnessString));
         }
 
         auto targetBrightnessString =
             settings.getValue(bell::settings::Alarm::brightness, settings::SettingsScope::Global);
         validateBrightness(targetBrightnessString);
+        const auto targetBrightness = utils::frontlight::fixedValToPercentage(utils::toNumeric(targetBrightnessString));
 
-        const screen_light_control::functions::LinearProgressFunction startFunction{
-            .target = static_cast<float>(initialBrightness), .duration = initialTargetDuration};
-        const screen_light_control::functions::LinearProgressFunction endFunction{
-            .target = static_cast<float>(utils::toNumeric(targetBrightnessString)), .duration = mainTargetDuration};
+        const screen_light_control::functions::LinearProgressFunction startFunction{.target   = initialBrightness,
+                                                                                    .duration = initialTargetDuration};
+        const screen_light_control::functions::LinearProgressFunction endFunction{.target   = targetBrightness,
+                                                                                  .duration = mainTargetDuration};
 
         return screen_light_control::LinearProgressModeParameters{.startBrightnessValue =
                                                                       static_cast<float>(initialBrightness),


@@ 262,14 266,16 @@ namespace alarms
         auto brightnessString =
             settings.getValue(bell::settings::PrewakeUp::brightness, settings::SettingsScope::Global);
         validateBrightness(brightnessString);
-        const auto value = settings.getValue(bell::settings::PrewakeUp::lightDuration, settings::SettingsScope::Global);
-        const auto lightDuration      = std::chrono::minutes{utils::toNumeric(value)};
+        const auto brightnessValue = utils::frontlight::fixedValToPercentage(utils::toNumeric(brightnessString));
+        const auto durationString =
+            settings.getValue(bell::settings::PrewakeUp::lightDuration, settings::SettingsScope::Global);
+        const auto lightDuration      = std::chrono::minutes{utils::toNumeric(durationString)};
         const auto mainTargetDuration = lightDuration - frontlightRampDurationOffset - initialTargetDuration;
 
         const screen_light_control::functions::LinearProgressFunction startFunction{
             .target = initialZeroBrightnessValue, .duration = initialTargetDuration};
-        const screen_light_control::functions::LinearProgressFunction endFunction{
-            .target = static_cast<float>(utils::toNumeric(brightnessString)), .duration = mainTargetDuration};
+        const screen_light_control::functions::LinearProgressFunction endFunction{.target   = brightnessValue,
+                                                                                  .duration = mainTargetDuration};
 
         return screen_light_control::LinearProgressModeParameters{
             .startBrightnessValue = 0.0f, .functions = {startFunction, endFunction}, .brightnessHysteresis = 0.0f};

@@ 7,6 7,8 @@
 #include <apps-common/ApplicationCommon.hpp>
 #include <service-evtmgr/ScreenLightControlMessage.hpp>
 #include <service-evtmgr/ServiceEventManagerName.hpp>
+#include <FrontlightUtils.hpp>
+#include <Utils.hpp>
 
 namespace app::powernap
 {


@@ 59,25 61,30 @@ namespace app::powernap
                              service::name::evt_manager);
     }
 
-    auto PowerNapFrontlightModel::getAlarmBrightness() const -> int
+    auto PowerNapFrontlightModel::getAlarmBrightness() const -> float
     {
-        const auto brightness = settings.getValue(bell::settings::Alarm::brightness, settings::SettingsScope::Global);
-        return utils::toNumeric(brightness);
+        const auto &brightnessString =
+            settings.getValue(bell::settings::Alarm::brightness, settings::SettingsScope::Global);
+        return utils::frontlight::fixedValToPercentage(utils::toNumeric(brightnessString));
     }
 
     auto PowerNapFrontlightModel::prepareFadeInParameters() const -> screen_light_control::LinearProgressModeParameters
     {
         constexpr auto targetReachTimeOffset = std::chrono::minutes{1};
         constexpr auto startFunctionDuration = std::chrono::seconds{5};
-        constexpr auto startFunctionTarget   = 10.0f;
 
+#if defined(CONFIG_VERSION_PRO) && (CONFIG_VERSION_PRO == 1)
+        constexpr auto startFunctionTarget = 5.0f;
+#else
+        constexpr auto startFunctionTarget = 10.0f;
+#endif
         const auto brightness          = getAlarmBrightness();
         const auto endFunctionDuration = alarmDuration - targetReachTimeOffset - startFunctionDuration;
 
         const screen_light_control::functions::LinearProgressFunction startFunction{.target   = startFunctionTarget,
                                                                                     .duration = startFunctionDuration};
-        const screen_light_control::functions::LinearProgressFunction endFunction{
-            .target = static_cast<float>(brightness), .duration = endFunctionDuration};
+        const screen_light_control::functions::LinearProgressFunction endFunction{.target   = brightness,
+                                                                                  .duration = endFunctionDuration};
 
         return screen_light_control::LinearProgressModeParameters{
             .startBrightnessValue = 0.0f, .functions = {startFunction, endFunction}, .brightnessHysteresis = 0.0f};

@@ 30,7 30,7 @@ namespace app::powernap
         const std::chrono::seconds alarmDuration;
         mutable settings::Settings settings;
 
-        auto getAlarmBrightness() const -> int;
+        auto getAlarmBrightness() const -> float;
         auto prepareFadeInParameters() const -> screen_light_control::LinearProgressModeParameters;
     };
 } // namespace app::powernap

@@ 7,17 7,17 @@
 
 namespace app::bell_settings
 {
-    auto BedsideBrightnessModel::setValue(frontlight_utils::Brightness value) -> void
+    auto BedsideBrightnessModel::setValue(std::uint8_t value) -> void
     {
-        const auto str = std::to_string(frontlight_utils::fixedValToPercentage(value));
+        const auto str = std::to_string(value);
         settings.setValue(settings::Brightness::bedsideBrightnessLevel, str, settings::SettingsScope::Global);
     }
 
-    auto BedsideBrightnessModel::getValue() const -> frontlight_utils::Brightness
+    auto BedsideBrightnessModel::getValue() const -> std::uint8_t
     {
         const auto str =
             settings.getValue(settings::Brightness::bedsideBrightnessLevel, settings::SettingsScope::Global);
-        return frontlight_utils::percentageToFixedVal(static_cast<float>(utils::toNumeric(str)));
+        return utils::toNumeric(str);
     }
 
     auto BedsideTimeModel::setValue(std::uint8_t value) -> void

@@ 2,11 2,11 @@
 // For licensing, see https://github.com/mudita/MuditaOS/blob/master/LICENSE.md
 
 #include <common/models/FrontlightModel.hpp>
-
 #include <apps-common/ApplicationCommon.hpp>
 #include <service-evtmgr/screen-light-control/ScreenLightControl.hpp>
 #include <service-evtmgr/ServiceEventManagerName.hpp>
 #include <service-evtmgr/ScreenLightControlMessage.hpp>
+#include <FrontlightUtils.hpp>
 
 namespace app::bell_settings
 {


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


@@ 53,10 53,10 @@ namespace app::bell_settings
             service::name::evt_manager);
     }
 
-    void FrontlightModel::setBrightness(frontlight_utils::Brightness value)
+    void FrontlightModel::setBrightness(std::uint8_t value)
     {
         const screen_light_control::ConstLinearProgressModeParameters parameters{
-            frontlight_utils::fixedValToPercentage(value)};
+            utils::frontlight::fixedValToPercentage(value)};
         app->bus.sendUnicast(std::make_shared<sevm::ScreenLightSetConstLinearModeParams>(parameters),
                              service::name::evt_manager);
     }

@@ 4,22 4,19 @@
 #pragma once
 
 #include <common/models/AbstractSettingsModel.hpp>
-#include <common/data/FrontlightUtils.hpp>
-
-#include <cstdint>
 #include <utf8/UTF8.hpp>
+#include <cstdint>
 
 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>> alarmFadeOnOff,
-            std::unique_ptr<gui::AbstractSettingsModel<bool>> alarmLightOnOff,
-            std::unique_ptr<gui::AbstractSettingsModel<frontlight_utils::Brightness>> alarmFrontlight)
+        AbstractAlarmSettingsModel(std::unique_ptr<gui::AbstractSettingsModel<UTF8>> alarmTone,
+                                   std::unique_ptr<gui::AbstractSettingsModel<std::uint8_t>> alarmVolume,
+                                   std::unique_ptr<gui::AbstractSettingsModel<bool>> alarmFadeOnOff,
+                                   std::unique_ptr<gui::AbstractSettingsModel<bool>> alarmLightOnOff,
+                                   std::unique_ptr<gui::AbstractSettingsModel<std::uint8_t>> alarmFrontlight)
             : alarmTone(std::move(alarmTone)), alarmVolume(std::move(alarmVolume)),
               alarmFadeOnOff(std::move(alarmFadeOnOff)), alarmLightOnOff(std::move(alarmLightOnOff)),
               alarmFrontlight(std::move(alarmFrontlight))


@@ 47,7 44,7 @@ namespace app::bell_settings
             return *alarmLightOnOff;
         }
 
-        gui::AbstractSettingsModel<frontlight_utils::Brightness> &getBrightness()
+        gui::AbstractSettingsModel<std::uint8_t> &getBrightness()
         {
             return *alarmFrontlight;
         }


@@ 57,6 54,6 @@ namespace app::bell_settings
         std::unique_ptr<gui::AbstractSettingsModel<std::uint8_t>> alarmVolume;
         std::unique_ptr<gui::AbstractSettingsModel<bool>> alarmFadeOnOff;
         std::unique_ptr<gui::AbstractSettingsModel<bool>> alarmLightOnOff;
-        std::unique_ptr<gui::AbstractSettingsModel<frontlight_utils::Brightness>> alarmFrontlight;
+        std::unique_ptr<gui::AbstractSettingsModel<std::uint8_t>> alarmFrontlight;
     };
 } // namespace app::bell_settings

@@ 4,9 4,7 @@
 #pragma once
 
 #include <common/models/AbstractSettingsModel.hpp>
-#include <common/data/FrontlightUtils.hpp>
 #include <utf8/UTF8.hpp>
-
 #include <cstdint>
 #include <memory>
 #include <string>


@@ 16,12 14,11 @@ 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,
-            std::unique_ptr<gui::AbstractSettingsModel<frontlight_utils::Brightness>> frontlight)
+        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<std::uint8_t>> frontlight)
             : chimeDuration(std::move(chimeDuration)), chimeTone(std::move(chimeTone)),
               chimeVolume(std::move(chimeVolume)), lightDuration(std::move(lightDuration)),
               frontlight(std::move(frontlight))


@@ 49,7 46,7 @@ namespace app::bell_settings
             return *lightDuration;
         }
 
-        gui::AbstractSettingsModel<frontlight_utils::Brightness> &getBrightness()
+        gui::AbstractSettingsModel<std::uint8_t> &getBrightness()
         {
             return *frontlight;
         }


@@ 59,6 56,6 @@ namespace app::bell_settings
         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;
+        std::unique_ptr<gui::AbstractSettingsModel<std::uint8_t>> frontlight;
     };
 } // namespace app::bell_settings

@@ 10,7 10,7 @@ namespace app::bell_settings
     {
         inline void validateBrightness(std::string &brightness)
         {
-            constexpr auto defaultBrightness = std::string_view{"50.0"};
+            constexpr auto defaultBrightness = std::string_view{"5"};
 
             if (brightness.empty()) {
                 brightness = defaultBrightness;


@@ 72,16 72,16 @@ namespace app::bell_settings
         return (utils::toNumeric(str) != 0);
     }
 
-    void AlarmFrontlightModel::setValue(frontlight_utils::Brightness value)
+    void AlarmFrontlightModel::setValue(std::uint8_t value)
     {
-        const auto valStr = std::to_string(frontlight_utils::fixedValToPercentage(value));
+        const auto valStr = std::to_string(value);
         settings.setValue(bell::settings::Alarm::brightness, valStr, settings::SettingsScope::Global);
     }
 
-    frontlight_utils::Brightness AlarmFrontlightModel::getValue() const
+    std::uint8_t AlarmFrontlightModel::getValue() const
     {
         auto str = settings.getValue(bell::settings::Alarm::brightness, settings::SettingsScope::Global);
         validateBrightness(str);
-        return frontlight_utils::percentageToFixedVal(static_cast<float>(utils::toNumeric(str)));
+        return utils::toNumeric(str);
     }
 } // namespace app::bell_settings

@@ 49,13 49,13 @@ namespace app::bell_settings
         bool getValue() const override;
     };
 
-    class AlarmFrontlightModel : public gui::SettingsModel<frontlight_utils::Brightness>
+    class AlarmFrontlightModel : public gui::SettingsModel<std::uint8_t>
     {
       public:
         using SettingsModel::SettingsModel;
 
-        void setValue(frontlight_utils::Brightness value) override;
-        frontlight_utils::Brightness getValue() const override;
+        void setValue(std::uint8_t value) override;
+        std::uint8_t getValue() const override;
     };
 
     class AlarmSettingsModel : public AbstractAlarmSettingsModel

@@ 8,7 8,14 @@ namespace app::bell_settings
 {
     namespace
     {
-        constexpr std::string_view DefaultBrightness{"50.0"};
+        inline void validateBrightness(std::string &brightness)
+        {
+            constexpr auto defaultBrightness = std::string_view{"5"};
+
+            if (brightness.empty()) {
+                brightness = defaultBrightness;
+            }
+        }
     }
 
     void PrewakeUpChimeDurationModel::setValue(std::uint8_t value)


@@ 65,18 72,16 @@ namespace app::bell_settings
         return utils::toNumeric(str);
     }
 
-    void PrewakeUpFrontlightModel::setValue(frontlight_utils::Brightness value)
+    void PrewakeUpFrontlightModel::setValue(std::uint8_t value)
     {
-        const auto valStr = std::to_string(frontlight_utils::fixedValToPercentage(value));
+        const auto valStr = std::to_string(value);
         settings.setValue(bell::settings::PrewakeUp::brightness, valStr, settings::SettingsScope::Global);
     }
 
-    frontlight_utils::Brightness PrewakeUpFrontlightModel::getValue() const
+    std::uint8_t PrewakeUpFrontlightModel::getValue() const
     {
         auto str = settings.getValue(bell::settings::PrewakeUp::brightness, settings::SettingsScope::Global);
-        if (str.empty()) {
-            str = DefaultBrightness;
-        }
-        return frontlight_utils::percentageToFixedVal(static_cast<float>(utils::toNumeric(str)));
+        validateBrightness(str);
+        return utils::toNumeric(str);
     }
 } // namespace app::bell_settings

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


@@ 51,13 50,13 @@ namespace app::bell_settings
         std::uint8_t getValue() const override;
     };
 
-    class PrewakeUpFrontlightModel : public gui::SettingsModel<frontlight_utils::Brightness>
+    class PrewakeUpFrontlightModel : public gui::SettingsModel<std::uint8_t>
     {
       public:
         using SettingsModel::SettingsModel;
 
-        void setValue(frontlight_utils::Brightness value) override;
-        frontlight_utils::Brightness getValue() const override;
+        void setValue(std::uint8_t value) override;
+        std::uint8_t getValue() const override;
     };
 
     class PrewakeUpSettingsModel : public AbstractPrewakeUpSettingsModel

@@ 4,7 4,6 @@
 #pragma once
 
 #include <common/widgets/BellSideListItemWithCallbacks.hpp>
-#include <common/data/FrontlightUtils.hpp>
 #include <apps-common/InternalModel.hpp>
 
 namespace app::bell_settings


@@ 19,7 18,7 @@ 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 FrontlightCallback      = std::function<void(const std::uint8_t &val)>;
         using FrontlightEnterCallback = FrontlightCallback;
         using FrontlightExitCallback  = std::function<void()>;
 

@@ 112,7 112,6 @@ target_sources(application-bell-common
         include/common/TimeUtils.hpp
 
         include/common/data/BatteryUtils.hpp
-        include/common/data/FrontlightUtils.hpp
         include/common/data/BatteryStatusSwitchData.hpp
 
         include/common/models/AbstractAlarmModel.hpp

@@ 1,36 0,0 @@
-// Copyright (c) 2017-2024, Mudita Sp. z.o.o. All rights reserved.
-// For licensing, see https://github.com/mudita/MuditaOS/blob/master/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

@@ 3,7 3,6 @@
 
 #pragma once
 
-#include <common/data/FrontlightUtils.hpp>
 #include <common/models/SettingsModel.hpp>
 #include <chrono>
 


@@ 12,15 11,14 @@ namespace app::bell_settings
     class AbstractBedsideModel
     {
       public:
-        AbstractBedsideModel(
-            std::unique_ptr<gui::AbstractSettingsModel<frontlight_utils::Brightness>> &&brightnessModel,
-            std::unique_ptr<gui::AbstractSettingsModel<std::uint8_t>> &&timeModel)
+        AbstractBedsideModel(std::unique_ptr<gui::AbstractSettingsModel<std::uint8_t>> &&brightnessModel,
+                             std::unique_ptr<gui::AbstractSettingsModel<std::uint8_t>> &&timeModel)
             : brightnessModel{std::move(brightnessModel)}, timeModel{std::move(timeModel)}
         {}
 
         virtual ~AbstractBedsideModel() = default;
 
-        auto getBrightnessModel() -> gui::AbstractSettingsModel<frontlight_utils::Brightness> &
+        auto getBrightnessModel() -> gui::AbstractSettingsModel<std::uint8_t> &
         {
             return *brightnessModel;
         }


@@ 31,17 29,17 @@ namespace app::bell_settings
         }
 
       private:
-        std::unique_ptr<gui::AbstractSettingsModel<frontlight_utils::Brightness>> brightnessModel;
+        std::unique_ptr<gui::AbstractSettingsModel<std::uint8_t>> brightnessModel;
         std::unique_ptr<gui::AbstractSettingsModel<std::uint8_t>> timeModel;
     };
 
-    class BedsideBrightnessModel : public gui::SettingsModel<frontlight_utils::Brightness>
+    class BedsideBrightnessModel : public gui::SettingsModel<std::uint8_t>
     {
       public:
         using SettingsModel::SettingsModel;
 
-        auto setValue(frontlight_utils::Brightness value) -> void override;
-        auto getValue() const -> frontlight_utils::Brightness override;
+        auto setValue(std::uint8_t value) -> void override;
+        auto getValue() const -> std::uint8_t override;
     };
 
     class BedsideTimeModel : public gui::SettingsModel<std::uint8_t>

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


@@ 25,7 24,7 @@ namespace app::bell_settings
     {
       public:
         virtual ~AbstractFrontlightModel()                               = default;
-        virtual void setBrightness(frontlight_utils::Brightness value)   = 0;
+        virtual void setBrightness(std::uint8_t value)                   = 0;
         virtual void setMode(screen_light_control::ScreenLightMode mode) = 0;
         virtual void setBacklight(BacklightState state)                  = 0;
         virtual void revertConfig()                                      = 0;


@@ 46,7 45,7 @@ namespace app::bell_settings
         gui::AbstractSettingsModel<std::uint8_t> &getBrightnessModel() override;
         gui::AbstractSettingsModel<UTF8> &getModeModel() override;
 
-        void setBrightness(frontlight_utils::Brightness value) override;
+        void setBrightness(std::uint8_t value) override;
         void setMode(screen_light_control::ScreenLightMode mode) override;
         void setBacklight(BacklightState state) override;
         void revertConfig() override;

@@ 0,0 1,6 @@
+{
+ "id": "287a0959-d838-49a9-bc3c-a25b5969d8a1",
+ "date": "2024-11-06 11:20:45",
+ "message": "Change store brightness from percent to level",
+ "parent": 0
+}<
\ No newline at end of file

@@ 0,0 1,8 @@
+-- Copyright (c) 2017-2024, Mudita Sp. z.o.o. All rights reserved.
+-- For licensing, see https://github.com/mudita/MuditaOS/blob/master/LICENSE.md
+
+-- Message: Change store brightness from percent to level
+-- Revision: 287a0959-d838-49a9-bc3c-a25b5969d8a1
+-- Create Date: 2024-11-06 11:20:45
+
+-- Insert SQL here

@@ 0,0 1,32 @@
+-- Copyright (c) 2017-2024, Mudita Sp. z.o.o. All rights reserved.
+-- For licensing, see https://github.com/mudita/MuditaOS/blob/master/LICENSE.md
+
+-- Message: Change store brightness from percent to level
+-- Revision: 287a0959-d838-49a9-bc3c-a25b5969d8a1
+-- Create Date: 2024-11-06 11:20:45
+
+-- The transformation equation has been derived from FrontlightUtils.hpp helpers
+
+UPDATE OR IGNORE settings_tab
+SET value = (SELECT ((value - 1.0) * ((100.0 - 16.0) / 10.0) + 16.0)
+    FROM settings_tab
+    WHERE path = 'br_level')
+WHERE path = 'br_level';
+
+UPDATE OR IGNORE settings_tab
+SET value = (SELECT ((value - 1.0) * ((100.0 - 16.0) / 10.0) + 16.0)
+    FROM settings_tab
+    WHERE path = 'br_bedside_level')
+WHERE path = 'br_bedside_level';
+
+UPDATE OR IGNORE settings_tab
+SET value = (SELECT ((value - 1.0) * ((100.0 - 16.0) / 10.0) + 16.0)
+    FROM settings_tab
+    WHERE path = 'alarm_brightness')
+WHERE path = 'alarm_brightness';
+
+UPDATE OR IGNORE settings_tab
+SET value = (SELECT ((value - 1.0) * ((100.0 - 16.0) / 10.0) + 16.0)
+    FROM settings_tab
+    WHERE path = 'prewake_up_brightness')
+WHERE path = 'prewake_up_brightness';

@@ 0,0 1,32 @@
+-- Copyright (c) 2017-2024, Mudita Sp. z.o.o. All rights reserved.
+-- For licensing, see https://github.com/mudita/MuditaOS/blob/master/LICENSE.md
+
+-- Message: Change store brightness from percent to level
+-- Revision: 287a0959-d838-49a9-bc3c-a25b5969d8a1
+-- Create Date: 2024-11-06 11:20:45
+
+-- The transformation equation has been derived from FrontlightUtils.hpp helpers
+
+UPDATE OR IGNORE settings_tab
+SET value = (SELECT CAST(ROUND((value - 16.0) / ((100.0 - 16.0) / 10.0) + 1.0) AS INT)
+    FROM settings_tab
+    WHERE path = 'br_level')
+WHERE path = 'br_level';
+
+UPDATE OR IGNORE settings_tab
+SET value = (SELECT CAST(ROUND((value - 16.0) / ((100.0 - 16.0) / 10.0) + 1.0) AS INT)
+    FROM settings_tab
+    WHERE path = 'br_bedside_level')
+WHERE path = 'br_bedside_level';
+
+UPDATE OR IGNORE settings_tab
+SET value = (SELECT CAST(ROUND((value - 16.0) / ((100.0 - 16.0) / 10.0) + 1.0) AS INT)
+    FROM settings_tab
+    WHERE path = 'alarm_brightness')
+WHERE path = 'alarm_brightness';
+
+UPDATE OR IGNORE settings_tab
+SET value = (SELECT CAST(ROUND((value - 16.0) / ((100.0 - 16.0) / 10.0) + 1.0) AS INT)
+    FROM settings_tab
+    WHERE path = 'prewake_up_brightness')
+WHERE path = 'prewake_up_brightness';

@@ 2,13 2,12 @@
 // For licensing, see https://github.com/mudita/MuditaOS/blob/master/LICENSE.md
 
 #include <evtmgr/backlight-handler/BacklightHandler.hpp>
-
 #include <screen-light-control/ScreenLightControl.hpp>
 #include <service-db/agents/settings/SystemSettings.hpp>
 #include <service-db/Settings.hpp>
-
 #include <Timers/TimerFactory.hpp>
 #include <keymap/KeyMap.hpp>
+#include <FrontlightUtils.hpp>
 #include <Utils.hpp>
 
 namespace backlight


@@ 36,7 35,11 @@ namespace backlight
         using namespace screen_light_control;
 
         settings->registerValueChange(settings::Brightness::brightnessLevel, [&](const std::string &value) {
-            const ConstLinearProgressModeParameters params{utils::getNumericValue<float>(value)};
+            float percentValue = 0.0f;
+            if (!value.empty()) {
+                percentValue = utils::frontlight::fixedValToPercentage(utils::toNumeric(value));
+            }
+            const ConstLinearProgressModeParameters params{percentValue};
             screenLightController->processRequest(Action::setAutomaticModeParameters, Parameters(params));
         });
 


@@ 149,8 152,9 @@ namespace backlight
         case screen_light_control::Action::setAutomaticModeParameters:
             if (params.hasConstLinearProgressModeParams()) {
                 backlightMode = BacklightMode::WithTimer;
-                setValue(settings::Brightness::brightnessLevel,
-                         utils::to_string(params.getConstLinearProgressModeParams().targetBrightness));
+                const auto brightnessValue =
+                    utils::frontlight::percentageToFixedVal(params.getConstLinearProgressModeParams().targetBrightness);
+                setValue(settings::Brightness::brightnessLevel, utils::to_string(brightnessValue));
             }
             else if (params.hasLinearProgressModeParams()) {
                 backlightMode = BacklightMode::WithoutTimer;


@@ 186,8 190,9 @@ namespace backlight
     {
         using namespace screen_light_control;
 
-        const auto brightnessLevel = utils::getNumericValue<float>(getValue(settings::Brightness::brightnessLevel));
-        const ConstLinearProgressModeParameters params{brightnessLevel};
+        const auto &brightnessString = getValue(settings::Brightness::brightnessLevel);
+        const auto percentValue     = utils::frontlight::fixedValToPercentage(utils::toNumeric(brightnessString));
+        const ConstLinearProgressModeParameters params{percentValue};
         screenLightController->processRequest(Action::setAutomaticModeParameters, Parameters(params));
     }
 


@@ 209,9 214,8 @@ namespace backlight
     {
         using namespace screen_light_control;
 
-        const auto bedsideBrightness =
-            utils::getNumericValue<float>(getValue(settings::Brightness::bedsideBrightnessLevel));
-        const auto manualParams = ManualModeParameters{bedsideBrightness};
-        return Parameters{manualParams};
+        const auto &brightnessString = getValue(settings::Brightness::bedsideBrightnessLevel);
+        const auto brightnessLevel   = utils::frontlight::fixedValToPercentage(utils::toNumeric(brightnessString));
+        return Parameters{ManualModeParameters{brightnessLevel}};
     }
 } // namespace backlight

@@ 70,7 70,11 @@ namespace bell::screen_light_control
 
         static constexpr auto controlTimerIntervalMs  = 25;
         static constexpr auto rampStepPerMs           = 0.1f;
+#if defined(CONFIG_VERSION_PRO) && (CONFIG_VERSION_PRO == 1)
+        static constexpr auto minimalTargetBrightness = 7;
+#else
         static constexpr auto minimalTargetBrightness = 15;
+#endif
 
         sys::TimerHandle controlTimer;
         std::shared_ptr<sys::CpuSentinel> cpuSentinel;