29 files changed, 737 insertions(+), 32 deletions(-)

M image/assets/lang/English.json
M module-apps/CMakeLists.txt
M module-apps/application-bell-main/ApplicationBellMain.cpp
M module-apps/application-bell-main/CMakeLists.txt
M module-apps/application-bell-main/include/application-bell-main/ApplicationBellMain.hpp
M module-apps/application-bell-main/windows/BellMainMenuWindow.cpp
A module-apps/application-bell-settings/ApplicationBellSettings.cpp
A module-apps/application-bell-settings/CMakeLists.txt
A module-apps/application-bell-settings/data/BellSettingsStyle.hpp
A module-apps/application-bell-settings/include/application-bell-settings/ApplicationBellSettings.hpp
A module-apps/application-bell-settings/models/TimeUnitsModel.cpp
A module-apps/application-bell-settings/models/TimeUnitsModel.hpp
A module-apps/application-bell-settings/presenter/TimeUnitsPresenter.cpp
A module-apps/application-bell-settings/presenter/TimeUnitsPresenter.hpp
A module-apps/application-bell-settings/widgets/TimeSetSpinnerListItem.cpp
A module-apps/application-bell-settings/widgets/TimeSetSpinnerListItem.hpp
A module-apps/application-bell-settings/windows/BellSettingsAdvancedWindow.cpp
A module-apps/application-bell-settings/windows/BellSettingsAdvancedWindow.hpp
A module-apps/application-bell-settings/windows/BellSettingsTimeUnitsWindow.cpp
A module-apps/application-bell-settings/windows/BellSettingsTimeUnitsWindow.hpp
A module-apps/application-bell-settings/windows/BellSettingsWindow.cpp
A module-apps/application-bell-settings/windows/BellSettingsWindow.hpp
M module-gui/gui/widgets/SideListItem.cpp
M module-gui/gui/widgets/SideListItem.hpp
M module-gui/gui/widgets/SideListView.cpp
M module-gui/gui/widgets/SideListView.hpp
M module-gui/gui/widgets/Spinner.cpp
M products/BellHybrid/BellHybridMain.cpp
M products/BellHybrid/CMakeLists.txt

@@ 537,14 537,19 @@
   "app_desktop_update_ready_for_reset": "Ready for reset...",
   "app_desktop_update_success": "MuditaOS has been updated to ver. $VERSION succesfully.",
   "app_call_private_number": "Private number",
+  "tethering": "Tethering",
+  "tethering_turn_off_question": "Turn tethering off?",
+  "tethering_enable_question": "<text>You're connected to the computer.<br />Turn tethering on?<br /><text color='9'>(some functions may be disabled)</text></text>",
+  "tethering_phone_mode_change_prohibited": "<text>Tethering is on.<br /><br />Other modes (Connected, DND,<br />Offline) are overriden by this mode<br />and are not working.</text>",
+  "tethering_menu_access_decline": "<text>Tethering is on.<br /><br />To access menu,<br />turn tethering off.</text>",
+
+  "app_bell_settings_time_units_time_message": "Time",
   "app_bellmain_next_alarm": "Next alarm",
   "app_bellmain_power_nap": "Power nap",
   "app_bellmain_meditation_timer": "Meditation timer",
   "app_bellmain_media_library": "Media Library",
   "app_bellmain_settings": "Settings",
-  "tethering": "Tethering",
-  "tethering_turn_off_question": "Turn tethering off?",
-  "tethering_enable_question": "<text>You're connected to the computer.<br />Turn tethering on?<br /><text color='9'>(some functions may be disabled)</text></text>",
-  "tethering_phone_mode_change_prohibited": "<text>Tethering is on.<br /><br />Other modes (Connected, DND,<br />Offline) are overriden by this mode<br />and are not working.</text>",
-  "tethering_menu_access_decline": "<text>Tethering is on.<br /><br />To access menu,<br />turn tethering off.</text>"
+  "app_bellmain_main_window_title": "Bell Hybrid+",
+  "app_bell_settings_advanced": "Advanced",
+  "app_bell_settings_advanced_time_units": "Time & units"
 }

@@ 10,6 10,7 @@ add_library(${PROJECT_NAME} STATIC)
 
 add_subdirectory(application-antenna)
 add_subdirectory(application-bell-main)
+add_subdirectory(application-bell-settings)
 add_subdirectory(application-calculator)
 add_subdirectory(application-call)
 add_subdirectory(application-desktop)

@@ 3,7 3,6 @@
 
 #include "include/application-bell-main/ApplicationBellMain.hpp"
 #include "windows/BellMainMenuWindow.hpp"
-#include "windows/BellMainSetHour.hpp"
 #include "windows/BellMainWindow.hpp"
 #include <windows/Dialog.hpp>
 


@@ 42,10 41,6 @@ namespace app
         windowsFactory.attach(gui::window::name::bell_main_menu_dialog, [](Application *app, const std::string &name) {
             return std::make_unique<gui::Dialog>(app, name);
         });
-
-        windowsFactory.attach(gui::window::name::bell_main_set_hour, [](Application *app, const std::string &name) {
-            return std::make_unique<gui::BellMainSetHour>(app);
-        });
     }
 
     sys::MessagePointer ApplicationBellMain::DataReceivedHandler(sys::DataMessage *msgl, sys::ResponseMessage *resp)

@@ 5,11 5,9 @@ target_sources(application-bell-main
         ApplicationBellMain.cpp
         windows/BellMainWindow.cpp
         windows/BellMainMenuWindow.cpp
-        windows/BellMainSetHour.cpp
  
         windows/BellMainWindow.hpp
         windows/BellMainMenuWindow.hpp
-        windows/BellMainSetHour.hpp
     PUBLIC
         include/application-bell-main/ApplicationBellMain.hpp
 )

@@ 9,7 9,6 @@ namespace gui::window::name
 {
     inline constexpr auto bell_main_menu        = "BellMainMenu";
     inline constexpr auto bell_main_menu_dialog = "BellMainMenuDialog";
-    inline constexpr auto bell_main_set_hour    = "BellMainSetHour";
 
 } // namespace gui::window::name
 

@@ 79,8 79,8 @@ namespace gui
         addWinMenu(utils::translate("app_bellmain_power_nap"), gui::window::name::bell_main_menu_dialog);
         addWinMenu(utils::translate("app_bellmain_meditation_timer"), gui::window::name::bell_main_menu_dialog);
         addWinMenu(utils::translate("app_bellmain_media_library"), gui::window::name::bell_main_menu_dialog);
-        addWinMenu(utils::translate("app_bellmain_settings"), gui::window::name::bell_main_menu_dialog);
-        addWinMenu(utils::translate("Set Hour"), gui::window::name::bell_main_set_hour);
+
+        addAppMenu(utils::translate("app_bellmain_settings"), "ApplicationBellSettings");
 
         return menuOptionList;
     }

@@ 0,0 1,57 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#include "ApplicationBellSettings.hpp"
+#include "TimeUnitsPresenter.hpp"
+#include "windows/BellSettingsAdvancedWindow.hpp"
+#include "windows/BellSettingsTimeUnitsWindow.hpp"
+#include "windows/BellSettingsWindow.hpp"
+
+#include <apps-common/windows/Dialog.hpp>
+
+namespace app
+{
+    ApplicationBellSettings::ApplicationBellSettings(std::string name,
+                                                     std::string parent,
+                                                     sys::phone_modes::PhoneMode mode,
+                                                     StartInBackground startInBackground)
+        : Application(std::move(name), std::move(parent), mode, startInBackground)
+    {}
+
+    sys::ReturnCodes ApplicationBellSettings::InitHandler()
+    {
+        auto ret = Application::InitHandler();
+        if (ret != sys::ReturnCodes::Success) {
+            return ret;
+        }
+        createUserInterface();
+
+        return sys::ReturnCodes::Success;
+    }
+
+    void ApplicationBellSettings::createUserInterface()
+    {
+        windowsFactory.attach(gui::name::window::main_window, [](Application *app, const std::string &name) {
+            return std::make_unique<gui::BellSettingsWindow>(app);
+        });
+
+        windowsFactory.attach(gui::window::name::bellSettingsAdvanced, [](Application *app, const std::string &name) {
+            return std::make_unique<gui::BellSettingsAdvancedWindow>(app);
+        });
+
+        windowsFactory.attach(gui::window::name::bellSettingsTimeUnits, [](Application *app, const std::string &name) {
+            auto timeUnitsProvider = std::make_shared<bell_settings::TimeUnitsModel>(app);
+            auto presenter         = std::make_unique<bell_settings::TimeUnitsWindowPresenter>(timeUnitsProvider);
+            return std::make_unique<gui::BellSettingsTimeUnitsWindow>(app, std::move(presenter));
+        });
+    }
+
+    sys::MessagePointer ApplicationBellSettings::DataReceivedHandler(sys::DataMessage *msgl, sys::ResponseMessage *resp)
+    {
+        auto retMsg = Application::DataReceivedHandler(msgl);
+        if (dynamic_cast<sys::ResponseMessage *>(retMsg.get())->retCode == sys::ReturnCodes::Success) {
+            return retMsg;
+        }
+        return std::make_shared<sys::ResponseMessage>();
+    }
+} // namespace app

@@ 0,0 1,49 @@
+# Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+# For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+add_library(application-bell-settings STATIC)
+
+target_include_directories(application-bell-settings
+    PRIVATE
+        $<BUILD_INTERFACE:
+            ${CMAKE_CURRENT_SOURCE_DIR}
+            data
+            include/application-bell-settings
+            models
+            presenter
+            widgets
+            windows
+        >
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+)
+
+target_sources(application-bell-settings
+    PRIVATE
+        ApplicationBellSettings.cpp
+        models/TimeUnitsModel.cpp
+        presenter/TimeUnitsPresenter.cpp
+        widgets/TimeSetSpinnerListItem.cpp
+        windows/BellSettingsWindow.cpp
+        windows/BellSettingsAdvancedWindow.cpp
+        windows/BellSettingsTimeUnitsWindow.cpp
+
+        models/TimeUnitsModel.hpp
+        presenter/TimeUnitsPresenter.hpp
+        widgets/TimeSetSpinnerListItem.hpp
+        windows/BellSettingsWindow.hpp
+        windows/BellSettingsAdvancedWindow.hpp
+        windows/BellSettingsTimeUnitsWindow.hpp
+
+    PUBLIC
+        include/application-bell-settings/ApplicationBellSettings.hpp
+)
+
+target_link_libraries(application-bell-settings
+    PRIVATE
+        bellgui
+        service-appmgr
+    PUBLIC
+        apps-common
+        module-gui
+)

@@ 0,0 1,26 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#pragma once
+
+#include <gui/Common.hpp>
+#include <Style.hpp>
+
+namespace gui
+{
+    namespace bell_settings_style
+    {
+        namespace settings_window
+        {
+            inline constexpr auto options_list_margin_x = 40;
+            inline constexpr auto options_list_margin_y = 85;
+            inline constexpr auto default_body_width    = 400;
+        } // namespace settings_window
+
+        namespace time_set_spinner_list_item
+        {
+            inline constexpr auto w = 450;
+            inline constexpr auto h = 250;
+        } // namespace time_set_spinner_list_item
+    }     // namespace bell_settings_style
+} // namespace gui

@@ 0,0 1,50 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#pragma once
+
+#include <apps-common/Application.hpp>
+
+namespace gui::window::name
+{
+    inline constexpr auto bellSettings          = "BellSettings";
+    inline constexpr auto bellSettingsAdvanced  = "BellSettingsAdvanced";
+    inline constexpr auto bellSettingsTimeUnits = "BellSettingsTimeUnits";
+    inline constexpr auto bellSettingsDialog    = "BellSettingsDialog";
+
+} // namespace gui::window::name
+
+namespace app
+{
+    inline constexpr auto applicationBellSettingsName = "ApplicationBellSettings";
+
+    class ApplicationBellSettings : public Application
+    {
+      public:
+        ApplicationBellSettings(std::string name                    = applicationBellSettingsName,
+                                std::string parent                  = "",
+                                sys::phone_modes::PhoneMode mode    = sys::phone_modes::PhoneMode::Offline,
+                                StartInBackground startInBackground = {false});
+
+        sys::ReturnCodes InitHandler() override;
+
+        void createUserInterface() override;
+        void destroyUserInterface() override
+        {}
+
+        sys::MessagePointer DataReceivedHandler(sys::DataMessage *msgl, sys::ResponseMessage *resp) override;
+
+        sys::ReturnCodes SwitchPowerModeHandler(const sys::ServicePowerMode mode) override final
+        {
+            return sys::ReturnCodes::Success;
+        }
+    };
+
+    template <> struct ManifestTraits<ApplicationBellSettings>
+    {
+        static auto GetManifest() -> manager::ApplicationManifest
+        {
+            return {{manager::actions::Launch}};
+        }
+    };
+} // namespace app

@@ 0,0 1,85 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#include "TimeUnitsModel.hpp"
+
+#include <apps-common/widgets/TimeSetSpinner.hpp>
+#include <gui/widgets/ListViewEngine.hpp>
+#include <gui/widgets/Style.hpp>
+#include <gui/widgets/Text.hpp>
+#include <service-time/Constants.hpp>
+#include <service-time/service-time/TimeMessage.hpp>
+
+#include <ctime>
+
+namespace app::bell_settings
+{
+    TimeUnitsModel::TimeUnitsModel(app::Application *app) : application(app)
+    {}
+
+    TimeUnitsModel::~TimeUnitsModel()
+    {
+        clearData();
+    }
+
+    auto TimeUnitsModel::requestRecordsCount() -> unsigned int
+    {
+        return internalData.size();
+    }
+
+    auto TimeUnitsModel::getMinimalItemSpaceRequired() const -> unsigned int
+    {
+        return style::sidelistview::list_item::w;
+    }
+
+    auto TimeUnitsModel::getItem(gui::Order order) -> gui::ListItem *
+    {
+        return getRecord(order);
+    }
+
+    void TimeUnitsModel::createData()
+    {
+        timeSetWidget = new gui::TimeSetSpinnerListItem(
+            0U, 0U, 0, 0, utils::translate("app_bell_settings_time_units_time_message"));
+        internalData.push_back(timeSetWidget);
+
+        for (auto item : internalData) {
+            item->deleteByList = false;
+        }
+    }
+
+    void TimeUnitsModel::clearData()
+    {
+        eraseInternalData();
+    }
+
+    void TimeUnitsModel::saveData()
+    {
+        std::time_t now         = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
+        struct std::tm *newTime = std::localtime(&now);
+        newTime->tm_hour        = timeSetWidget->timeSetSpinner->getHour();
+        newTime->tm_min         = timeSetWidget->timeSetSpinner->getMinute();
+        LOG_INFO("Setting new time: %d:%d", newTime->tm_hour, newTime->tm_min);
+        sendRtcUpdateTimeMessage(std::mktime(newTime));
+    }
+
+    void TimeUnitsModel::loadData()
+    {
+        std::time_t now = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
+        timeSetWidget->timeSetSpinner->setHour(std::localtime(&now)->tm_hour);
+        timeSetWidget->timeSetSpinner->setMinute(std::localtime(&now)->tm_min);
+    }
+
+    auto TimeUnitsModel::requestRecords(uint32_t offset, uint32_t limit) -> void
+    {
+        setupModel(offset, limit);
+        list->onProviderDataUpdate();
+    }
+
+    void TimeUnitsModel::sendRtcUpdateTimeMessage(time_t newTime)
+    {
+        auto msg = std::make_shared<stm::message::TimeChangeRequestMessage>(newTime);
+        application->bus.sendUnicast(std::move(msg), service::name::service_time);
+    }
+
+} // namespace app::bell_settings

@@ 0,0 1,35 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#pragma once
+
+#include "TimeSetSpinnerListItem.hpp"
+
+#include <apps-common/Application.hpp>
+#include <apps-common/InternalModel.hpp>
+
+namespace app::bell_settings
+{
+    class TimeUnitsModel : public app::InternalModel<gui::ListItem *>, public gui::ListItemProvider
+    {
+      public:
+        explicit TimeUnitsModel(app::Application *app);
+        ~TimeUnitsModel();
+
+        auto clearData() -> void;
+        auto saveData() -> void;
+        auto loadData() -> void;
+        auto createData() -> void;
+        auto requestRecords(uint32_t offset, uint32_t limit) -> void;
+
+        [[nodiscard]] auto getItem(gui::Order order) -> gui::ListItem * override;
+        [[nodiscard]] auto requestRecordsCount() -> unsigned int override;
+        [[nodiscard]] auto getMinimalItemSpaceRequired() const -> unsigned int override;
+
+      private:
+        app::Application *application              = nullptr;
+        gui::TimeSetSpinnerListItem *timeSetWidget = nullptr;
+
+        void sendRtcUpdateTimeMessage(time_t newTime);
+    };
+} // namespace app::bell_settings

@@ 0,0 1,36 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#include "TimeUnitsPresenter.hpp"
+
+namespace app::bell_settings
+{
+    TimeUnitsWindowPresenter::TimeUnitsWindowPresenter(std::shared_ptr<TimeUnitsModel> pagesProvider)
+        : pagesProvider(std::move(pagesProvider))
+    {}
+
+    auto TimeUnitsWindowPresenter::getPagesProvider() const -> std::shared_ptr<gui::ListItemProvider>
+    {
+        return pagesProvider;
+    }
+
+    auto TimeUnitsWindowPresenter::clearData() -> void
+    {
+        pagesProvider->clearData();
+    }
+
+    auto TimeUnitsWindowPresenter::saveData() -> void
+    {
+        pagesProvider->saveData();
+    }
+
+    auto TimeUnitsWindowPresenter::loadData() -> void
+    {
+        pagesProvider->loadData();
+    }
+
+    auto TimeUnitsWindowPresenter::createData() -> void
+    {
+        pagesProvider->createData();
+    }
+} // namespace app::bell_settings

@@ 0,0 1,47 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#pragma once
+
+#include "TimeUnitsModel.hpp"
+
+#include <apps-common/BasePresenter.hpp>
+
+namespace app::bell_settings
+{
+    class TimeUnitsWindowContract
+    {
+      public:
+        class View
+        {
+          public:
+            virtual ~View() noexcept = default;
+        };
+
+        class Presenter : public BasePresenter<TimeUnitsWindowContract::View>
+        {
+          public:
+            virtual ~Presenter() noexcept                                                   = default;
+            virtual auto getPagesProvider() const -> std::shared_ptr<gui::ListItemProvider> = 0;
+            virtual auto clearData() -> void                                                = 0;
+            virtual auto saveData() -> void                                                 = 0;
+            virtual auto loadData() -> void                                                 = 0;
+            virtual auto createData() -> void                                               = 0;
+        };
+    };
+
+    class TimeUnitsWindowPresenter : public TimeUnitsWindowContract::Presenter
+    {
+      public:
+        explicit TimeUnitsWindowPresenter(std::shared_ptr<TimeUnitsModel> pagesProvider);
+
+        auto getPagesProvider() const -> std::shared_ptr<gui::ListItemProvider> override;
+        auto clearData() -> void;
+        auto saveData() -> void;
+        auto loadData() -> void;
+        auto createData() -> void;
+
+      private:
+        std::shared_ptr<TimeUnitsModel> pagesProvider;
+    };
+} // namespace app::bell_settings

@@ 0,0 1,28 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#include "BellSettingsStyle.hpp"
+#include "TimeSetSpinnerListItem.hpp"
+
+#include <widgets/TimeSetSpinner.hpp>
+
+namespace gui
+{
+    TimeSetSpinnerListItem::TimeSetSpinnerListItem(
+        gui::Length x, gui::Length y, gui::Length w, gui::Length h, std::string description)
+        : SideListItem(std::move(description))
+    {
+        setMinimumSize(style::sidelistview::list_item::w, style::sidelistview::list_item::h);
+
+        timeSetSpinner = new TimeSetSpinner(body, 0, 0, 0, 0);
+        timeSetSpinner->setMinimumSize(gui::bell_settings_style::time_set_spinner_list_item::w,
+                                       gui::bell_settings_style::time_set_spinner_list_item::h);
+        body->setFocusItem(timeSetSpinner);
+
+        dimensionChangedCallback = [&](gui::Item &, const BoundingBox &newDim) -> bool {
+            body->setArea({0, 0, newDim.w, newDim.h});
+            return true;
+        };
+        inputCallback = [&](gui::Item &item, const gui::InputEvent &event) { return body->onInput(event); };
+    }
+} /* namespace gui */

@@ 0,0 1,21 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#pragma once
+
+#include <widgets/SideListItem.hpp>
+
+#include <string>
+
+namespace gui
+{
+    class TimeSetSpinner;
+
+    class TimeSetSpinnerListItem : public SideListItem
+    {
+      public:
+        TimeSetSpinner *timeSetSpinner = nullptr;
+
+        TimeSetSpinnerListItem(gui::Length x, gui::Length y, gui::Length w, gui::Length h, std::string description);
+    };
+} /* namespace gui */

@@ 0,0 1,64 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#include "application-bell-settings/ApplicationBellSettings.hpp"
+#include "BellSettingsAdvancedWindow.hpp"
+#include "BellSettingsStyle.hpp"
+
+#include <apps-common/options/type/OptionBellMenu.hpp>
+#include <apps-common/messages/DialogMetadataMessage.hpp>
+#include <apps-common/windows/Dialog.hpp>
+#include <service-appmgr/Controller.hpp>
+
+namespace gui
+{
+
+    BellSettingsAdvancedWindow::BellSettingsAdvancedWindow(app::Application *app)
+        : OptionWindow(app, gui::window::name::bellSettingsAdvanced)
+    {
+        addOptions(settingsOptionsList());
+        buildInterface();
+    }
+
+    void BellSettingsAdvancedWindow::buildInterface()
+    {
+        statusBar->setVisible(false);
+        header->setTitleVisibility(false);
+        bottomBar->setVisible(false);
+
+        optionsList->setPosition(bell_settings_style::settings_window::options_list_margin_x,
+                                 bell_settings_style::settings_window::options_list_margin_y);
+        optionsList->setMaximumWidth(bell_settings_style::settings_window::default_body_width);
+        optionsList->setBoundaries(gui::Boundaries::Continuous);
+    }
+
+    std::list<Option> BellSettingsAdvancedWindow::settingsOptionsList()
+    {
+        std::list<gui::Option> settingsOptionList;
+        auto addWinSettings = [&](const UTF8 &name, const std::string &window) {
+            settingsOptionList.emplace_back(std::make_unique<gui::option::OptionBellMenu>(
+                name,
+                [=](gui::Item &item) {
+                    if (window.empty()) {
+                        return false;
+                    }
+                    application->switchWindow(
+                        window,
+                        gui::ShowMode::GUI_SHOW_INIT,
+                        std::make_unique<gui::DialogMetadataMessage>(gui::DialogMetadata{name, "search_big", " "}));
+                    return true;
+                },
+                [=](gui::Item &item) {
+                    // put focus change callback here
+                    return true;
+                },
+                this));
+        };
+
+        addWinSettings(utils::translate("app_bell_settings_advanced_time_units"),
+                       gui::window::name::bellSettingsTimeUnits);
+
+        return settingsOptionList;
+    }
+
+} // namespace gui

@@ 0,0 1,21 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#pragma once
+
+#include <apps-common/windows/OptionWindow.hpp>
+
+namespace gui
+{
+
+    class BellSettingsAdvancedWindow : public OptionWindow
+    {
+      public:
+        explicit BellSettingsAdvancedWindow(app::Application *app);
+
+      private:
+        std::list<Option> settingsOptionsList();
+        void buildInterface() override;
+    };
+
+} // namespace gui

@@ 0,0 1,63 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#include "application-bell-settings/ApplicationBellSettings.hpp"
+#include "BellSettingsStyle.hpp"
+#include "BellSettingsTimeUnitsWindow.hpp"
+
+#include <gui/input/InputEvent.hpp>
+#include <apps-common/options/OptionStyle.hpp>
+
+namespace gui
+{
+    BellSettingsTimeUnitsWindow::BellSettingsTimeUnitsWindow(
+        app::Application *app,
+        std::unique_ptr<app::bell_settings::TimeUnitsWindowContract::Presenter> &&windowPresenter,
+        std::string name)
+        : AppWindow(app, name), presenter{std::move(windowPresenter)}
+    {
+        presenter->attach(this);
+        buildInterface();
+    }
+
+    void BellSettingsTimeUnitsWindow::rebuild()
+    {
+        erase();
+        buildInterface();
+    }
+
+    void BellSettingsTimeUnitsWindow::buildInterface()
+    {
+        AppWindow::buildInterface();
+        statusBar->setVisible(false);
+        header->setTitleVisibility(false);
+        bottomBar->setVisible(false);
+
+        presenter->createData();
+
+        sidelistview =
+            new SideListView(this, 0U, 0U, this->getWidth(), this->getHeight(), presenter->getPagesProvider());
+        sidelistview->setEdges(RectangleEdge::None);
+
+        presenter->loadData();
+        sidelistview->rebuildList(listview::RebuildType::Full);
+        setFocusItem(sidelistview);
+    }
+
+    bool BellSettingsTimeUnitsWindow::onInput(const gui::InputEvent &inputEvent)
+    {
+        if (sidelistview->onInput(inputEvent)) {
+            return true;
+        }
+        if (inputEvent.isShortRelease(KeyCode::KEY_ENTER)) {
+            presenter->saveData();
+            application->returnToPreviousWindow();
+            return true;
+        }
+        if (AppWindow::onInput(inputEvent)) {
+            return true;
+        }
+
+        return AppWindow::onInput(inputEvent);
+    }
+} /* namespace gui */

@@ 0,0 1,33 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#pragma once
+
+#include "application-bell-settings/ApplicationBellSettings.hpp"
+#include "TimeUnitsPresenter.hpp"
+#include "TimeUnitsModel.hpp"
+
+#include <apps-common/windows/AppWindow.hpp>
+#include <widgets/SideListView.hpp>
+
+namespace gui
+{
+    class SideListView;
+
+    class BellSettingsTimeUnitsWindow : public AppWindow, public app::bell_settings::TimeUnitsWindowContract::View
+    {
+      public:
+        explicit BellSettingsTimeUnitsWindow(
+            app::Application *app,
+            std::unique_ptr<app::bell_settings::TimeUnitsWindowContract::Presenter> &&windowPresenter,
+            std::string name = gui::window::name::bellSettingsTimeUnits);
+
+        void buildInterface() override;
+        bool onInput(const InputEvent &inputEvent) override;
+        void rebuild() override;
+
+      private:
+        SideListView *sidelistview = nullptr;
+        std::unique_ptr<app::bell_settings::TimeUnitsWindowContract::Presenter> presenter;
+    };
+} /* namespace gui */

@@ 0,0 1,60 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#include "BellSettingsWindow.hpp"
+
+#include <application-bell-settings/ApplicationBellSettings.hpp>
+#include <data/BellSettingsStyle.hpp>
+
+#include <apps-common/messages/DialogMetadataMessage.hpp>
+#include <apps-common/options/type/OptionBellMenu.hpp>
+#include <apps-common/windows/Dialog.hpp>
+#include <service-appmgr/Controller.hpp>
+
+namespace gui
+{
+
+    BellSettingsWindow::BellSettingsWindow(app::Application *app) : OptionWindow(app, gui::window::name::bellSettings)
+    {
+        addOptions(settingsOptionsList());
+        buildInterface();
+    }
+
+    void BellSettingsWindow::buildInterface()
+    {
+        statusBar->setVisible(false);
+        header->setTitleVisibility(false);
+        bottomBar->setVisible(false);
+
+        optionsList->setPosition(bell_settings_style::settings_window::options_list_margin_x,
+                                 bell_settings_style::settings_window::options_list_margin_y);
+        optionsList->setMaximumWidth(bell_settings_style::settings_window::default_body_width);
+        optionsList->setBoundaries(gui::Boundaries::Continuous);
+    }
+
+    std::list<Option> BellSettingsWindow::settingsOptionsList()
+    {
+        std::list<gui::Option> settingsOptionList;
+        auto addWinSettings = [&](const UTF8 &name, const std::string &window) {
+            settingsOptionList.emplace_back(std::make_unique<gui::option::OptionBellMenu>(
+                name,
+                [=](gui::Item &item) {
+                    if (window.empty()) {
+                        return false;
+                    }
+                    application->switchWindow(window, gui::ShowMode::GUI_SHOW_INIT);
+                    return true;
+                },
+                [=](gui::Item &item) {
+                    // put focus change callback here
+                    return true;
+                },
+                this));
+        };
+
+        addWinSettings(utils::translate("app_bell_settings_advanced"), gui::window::name::bellSettingsAdvanced);
+
+        return settingsOptionList;
+    }
+
+} // namespace gui

@@ 0,0 1,21 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#pragma once
+
+#include <apps-common/windows/OptionWindow.hpp>
+
+namespace gui
+{
+
+    class BellSettingsWindow : public OptionWindow
+    {
+      public:
+        explicit BellSettingsWindow(app::Application *app);
+
+      private:
+        std::list<Option> settingsOptionsList();
+        void buildInterface() override;
+    };
+
+} // namespace gui

@@ 10,11 10,13 @@ namespace gui
 {
     SideListItem::SideListItem(std::string description) : ListItemWithDescription(description)
     {
-        body = new HBox(this, 0U, 0U, style::sidelistview::list_item::w, style::sidelistview::list_item::h);
+        setEdges(RectangleEdge::None);
+        body = new VBox(this);
+        body->setMinimumSize(style::sidelistview::list_item::w, style::sidelistview::list_item::h);
         body->setEdges(RectangleEdge::None);
 
-        auto topMessage =
-            new Label(body, 0U, 0U, style::sidelistview::top_message::w, style::sidelistview::top_message::h);
+        auto topMessage = new Label(body);
+        topMessage->setMinimumSize(style::sidelistview::top_message::w, style::sidelistview::top_message::h);
         topMessage->setFont(style::sidelistview::top_message::font);
         topMessage->setEdges(gui::RectangleEdge::None);
         topMessage->activeItem = false;

@@ 11,7 11,7 @@ namespace gui
     class SideListItem : public ListItemWithDescription
     {
       public:
-        HBox *body = nullptr;
+        VBox *body = nullptr;
 
         SideListItem(std::string description);
     };

@@ 1,10 1,10 @@
 // Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
+#include "Image.hpp"
+#include "InputEvent.hpp"
 #include "SideListView.hpp"
 #include "Style.hpp"
-#include "Image.hpp"
-#include <InputEvent.hpp>
 
 namespace gui
 {


@@ 30,17 30,17 @@ namespace gui
         body = new HBox{bodyOverlay, 0, 0, 0, 0};
         body->setMinimumSize(w, bodyHeight);
         body->setAlignment(Alignment::Horizontal::Center);
-        body->setEdges(RectangleEdge::All);
+        body->setEdges(RectangleEdge::None);
         bodyOverlay->resizeItems();
 
         body->borderCallback = [this](const InputEvent &inputEvent) -> bool {
             if (!inputEvent.isShortRelease()) {
                 return false;
             }
-            if (inputEvent.is(KeyCode::KEY_LEFT) && pageLoaded) {
+            if (inputEvent.is(KeyCode::KEY_RF) && pageLoaded) {
                 return this->requestPreviousPage();
             }
-            else if (inputEvent.is(KeyCode::KEY_RIGHT) && pageLoaded) {
+            else if (inputEvent.is(KeyCode::KEY_ENTER) && pageLoaded) {
                 return this->requestNextPage();
             }
             else {


@@ 101,8 101,8 @@ namespace gui
         arrowLeft->setEdges(RectangleEdge::None);
         arrowsOverlay->addWidget(arrowLeft);
 
-        auto arrowRight = new gui::Image(style::sidelistview::arrow_right_image);
-        arrowRight->setAlignment(Alignment(gui::Alignment::Horizontal::Right, gui::Alignment::Vertical::Center));
+        auto arrowRight = new Image(style::sidelistview::arrow_right_image);
+        arrowRight->setAlignment(Alignment(Alignment::Horizontal::Right, Alignment::Vertical::Center));
         arrowRight->activeItem = false;
         arrowRight->setEdges(RectangleEdge::None);
 


@@ 130,6 130,12 @@ namespace gui
 
     auto SideListView::onInput(const InputEvent &inputEvent) -> bool
     {
-        return body->onInput(inputEvent);
+        if (body->onInput(inputEvent)) {
+            return true;
+        }
+        if (body->borderCallback && body->borderCallback(inputEvent)) {
+            return true;
+        }
+        return false;
     }
 } /* namespace gui */

@@ 6,7 6,7 @@
 #include "ListViewEngine.hpp"
 #include "ListItemProvider.hpp"
 #include "BoxLayout.hpp"
-#include <widgets/BarGraph.hpp>
+#include <apps-common/widgets/BarGraph.hpp>
 
 namespace gui
 {

@@ 75,15 75,15 @@ namespace gui
             switch (inputEvent.getKeyCode()) {
             case KeyCode::KEY_UP:
                 stepUp();
-                break;
+                return true;
             case KeyCode::KEY_DOWN:
                 stepDown();
-                break;
+                return true;
             default:
                 break;
             }
         }
-        return true;
+        return false;
     }
 
     bool Spinner::onFocus(bool state)

@@ 11,6 11,7 @@
 #include <application-alarm-clock/ApplicationAlarmClock.hpp>
 #include <application-onboarding/ApplicationOnBoarding.hpp>
 #include <application-bell-main/ApplicationBellMain.hpp>
+#include <application-bell-settings/ApplicationBellSettings.hpp>
 
 // services
 #include <service-appmgr/model/ApplicationManager.hpp>


@@ 100,6 101,7 @@ int main()
             std::vector<std::unique_ptr<app::ApplicationLauncher>> applications;
             applications.push_back(
                 app::CreateLauncher<app::ApplicationBellMain>(app::applicationBellName, app::Closeable::False));
+            applications.push_back(app::CreateLauncher<app::ApplicationBellSettings>(app::applicationBellSettingsName));
             // start application manager
             return sysmgr->RunSystemService(
                 std::make_shared<app::manager::ApplicationManager>(

@@ 1,7 1,7 @@
 add_executable(BellHybrid)
 
 add_custom_target(Bell ALL
-    DEPENDS BellHybrid BellHybrid.img
+    DEPENDS BellHybrid PurePhone-disk-img
     )
 
 target_link_directories(BellHybrid PRIVATE ${PROJECT_LIB_DIRECTORY})


@@ 48,6 48,7 @@ set_target_properties(BellHybrid
 target_link_libraries(BellHybrid
     PRIVATE
         application-bell-main
+        application-bell-settings
         application-music-player
         messagetype
         module-apps