14 files changed, 186 insertions(+), 17 deletions(-)

M image/assets/lang/English.json
M products/BellHybrid/alarms/AlarmHandlerActions.cpp
M products/BellHybrid/alarms/BellAlarmHandler.cpp
M products/BellHybrid/alarms/CMakeLists.txt
M products/BellHybrid/alarms/include/AlarmHandlerActions.hpp
M products/BellHybrid/alarms/include/BellAlarmHandler.hpp
M products/BellHybrid/apps/application-bell-main/CMakeLists.txt
A products/BellHybrid/apps/application-bell-main/include/application-bell-main/data/AlarmRingingSwitchData.hpp
M products/BellHybrid/apps/application-bell-main/presenters/HomeScreenPresenter.cpp
M products/BellHybrid/apps/application-bell-main/presenters/HomeScreenPresenter.hpp
M products/BellHybrid/apps/application-bell-main/presenters/StateController.cpp
M products/BellHybrid/apps/application-bell-main/presenters/StateController.hpp
M products/BellHybrid/apps/application-bell-main/windows/BellHomeScreenWindow.cpp
M products/BellHybrid/apps/application-bell-main/windows/BellHomeScreenWindow.hpp

@@ 570,5 570,6 @@
   "app_bell_settings_advanced_temp_scale": "Temperature scale",
   "app_bellmain_home_screen_bottom_desc": "Next alarm will ring in",
   "app_bellmain_home_screen_bottom_desc_dp": "Deep press to activate",
-  "app_bell_alarm_deactivated": "Alarm deactivated"
+  "app_bell_alarm_deactivated": "Alarm deactivated",
+  "app_bell_alarm_ringing_deactivated": "Good morning!\nRise and shine"
 }

@@ 3,20 3,29 @@
 
 #include "AlarmHandlerActions.hpp"
 
-#include <service-audio/AudioServiceAPI.hpp>
+#include <BellAlarmHandler.hpp>
+#include <application-bell-main/ApplicationBellMain.hpp>
+#include <application-bell-main/data/AlarmRingingSwitchData.hpp>
+#include <apps-common/windows/AppWindow.hpp>
+#include <service-appmgr/include/service-appmgr/Constants.hpp>
+#include <service-appmgr/messages/SwitchRequest.hpp>
+#include <service-time/ServiceTime.hpp>
 
 namespace alarms
 {
-
     auto playAlarmSound(const std::string &soundPath) -> bool
     {
         // playAlarmSound after it will be implemented [BH-660]
         return true;
     }
 
-    auto displayAlarmPopup() -> bool
+    auto displayAlarmPopup(stm::ServiceTime *serviceTime) -> bool
     {
-        // displayAlarmPopup after it will be implemented [BH-566]
+        auto msg = std::make_shared<app::manager::SwitchRequest>(BellAlarmClockHandler::name,
+                                                                 app::applicationBellName,
+                                                                 gui::name::window::main_window,
+                                                                 std::make_unique<AlarmRingingSwitchData>());
+        serviceTime->bus.sendUnicast(std::move(msg), service::name::appmgr);
         return true;
     }
 

@@ 3,9 3,12 @@
 
 #include <BellAlarmHandler.hpp>
 #include <AlarmHandlerActions.hpp>
+#include <service-time/ServiceTime.hpp>
 
 namespace alarms
 {
+    BellAlarmClockHandler::BellAlarmClockHandler(stm::ServiceTime *serviceTime) : serviceTime(serviceTime)
+    {}
 
     auto BellAlarmClockHandler::handle(const AlarmEventRecord &record) -> bool
     {


@@ 16,7 19,7 @@ namespace alarms
         if (record.enabled) {
             result = playAlarmSound(record.musicTone);
             result = turnOnFrontlight();
-            result = displayAlarmPopup();
+            result = displayAlarmPopup(serviceTime);
             return result;
         }
 

@@ 19,6 19,8 @@ target_include_directories(alarms
 )
 
 target_link_libraries(alarms
+   PRIVATE
+        application-bell-main
    PUBLIC
         module-db
         service-time

@@ 5,11 5,16 @@
 
 #include <module-db/Interface/AlarmEventRecord.hpp>
 
+namespace stm
+{
+    class ServiceTime;
+}
+
 namespace alarms
 {
 
     auto playAlarmSound(const std::string &soundPath) -> bool;
-    auto displayAlarmPopup() -> bool;
+    auto displayAlarmPopup(stm::ServiceTime *serviceTime) -> bool;
     auto turnOnFrontlight() -> bool;
 
 } // namespace alarms

@@ 5,13 5,24 @@
 
 #include <service-time/AlarmHandler.hpp>
 
+namespace stm
+{
+    class ServiceTime;
+}
+
 namespace alarms
 {
 
     class BellAlarmClockHandler : public AlarmHandler
     {
       public:
+        explicit BellAlarmClockHandler(stm::ServiceTime *serviceTime);
         auto handle(const AlarmEventRecord &record) -> bool;
+
+        static constexpr auto name = "BellAlarmClockHandler";
+
+      private:
+        stm::ServiceTime *serviceTime;
     };
 
     class EveningReminderHandler : public AlarmHandler

@@ 25,6 25,7 @@ target_sources(application-bell-main
 
     PUBLIC
         include/application-bell-main/ApplicationBellMain.hpp
+        include/application-bell-main/data/AlarmRingingSwitchData.hpp
 )
 
 target_include_directories(application-bell-main

@@ 0,0 1,16 @@
+// 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 <SwitchData.hpp>
+
+namespace alarms
+{
+    class AlarmRingingSwitchData : public gui::SwitchData
+    {
+      public:
+        AlarmRingingSwitchData() : SwitchData()
+        {}
+    };
+} // namespace alarms

@@ 28,15 28,23 @@ namespace app::home_screen
         : app{app}, alarmModel{std::move(alarmModel)},
           temperatureModel{std::move(temperatureModel)}, timeModel{std::move(timeModel)}
     {}
+
     void HomeScreenPresenter::handleUpdateTimeEvent()
     {
         getView()->setTime(timeModel->getCurrentTime());
         stateController->handleTimeUpdateEvent();
     }
+
+    void HomeScreenPresenter::handleAlarmRingingEvent()
+    {
+        stateController->handleAlarmRingingEvent();
+    }
+
     bool HomeScreenPresenter::handleInputEvent(const gui::InputEvent &inputEvent)
     {
         return stateController->handleInputEvent(inputEvent);
     }
+
     void HomeScreenPresenter::spawnTimer(std::chrono::milliseconds timeout)
     {
         if (not timer.isValid()) {


@@ 46,6 54,7 @@ namespace app::home_screen
         timer.stop();
         timer.start();
     }
+
     void HomeScreenPresenter::detachTimer()
     {
         if (timer.isValid()) {


@@ 53,10 62,12 @@ namespace app::home_screen
             timer.reset();
         }
     }
+
     HomeScreenPresenter::~HomeScreenPresenter()
     {
         detachTimer();
     }
+
     void HomeScreenPresenter::onBeforeShow()
     {
         getView()->setTimeFormat(timeModel->getTimeFormat());


@@ 64,6 75,7 @@ namespace app::home_screen
         getView()->setAlarmTimeFormat(timeModel->getTimeFormat());
         getView()->setTemperature(temperatureModel->getTemperature());
     }
+
     void HomeScreenPresenter::setDefaultAlarmTime()
     {
         const auto now     = timeModel->getCurrentTime();


@@ 77,12 89,14 @@ namespace app::home_screen
         }
         getView()->setAlarmTime(alarmTime);
     }
+
     void HomeScreenPresenter::createData()
     {
         setDefaultAlarmTime();
         stateController =
             std::make_unique<StateController>(*getView(), *this, *temperatureModel, *alarmModel, *timeModel);
     }
+
     void HomeScreenPresenter::refreshWindow()
     {
         app->refreshWindow(gui::RefreshModes::GUI_REFRESH_FAST);

@@ 37,6 37,7 @@ namespace app::home_screen
 
         /// Alarm widget related API
         virtual void setAlarmTriggered()                                     = 0;
+        virtual void setAlarmSnoozed()                                       = 0;
         virtual void setAlarmActive(bool)                                    = 0;
         virtual void setAlarmEdit(bool)                                      = 0;
         virtual void setAlarmVisible(bool)                                   = 0;


@@ 70,6 71,7 @@ namespace app::home_screen
         virtual void refreshWindow()                                                = 0;
         virtual void spawnTimer(std::chrono::milliseconds timeout = defaultTimeout) = 0;
         virtual void detachTimer()                                                  = 0;
+        virtual void handleAlarmRingingEvent()                                      = 0;
 
         static constexpr auto defaultTimeout = std::chrono::milliseconds{5000};
     };


@@ 96,6 98,7 @@ namespace app::home_screen
 
         void spawnTimer(std::chrono::milliseconds timeout) override;
         void detachTimer() override;
+        void handleAlarmRingingEvent() override;
 
       private:
         void setDefaultAlarmTime();

@@ 19,7 19,6 @@ namespace app::home_screen
     {
         namespace Helpers
         {
-            auto spawnTimer           = [](AbstractPresenter &presenter) { presenter.spawnTimer(); };
             auto detachTimer          = [](AbstractPresenter &presenter) { presenter.detachTimer(); };
             auto switchToMenu         = [](AbstractView &view) { view.switchToMenu(); };
             auto makeAlarmEditable    = [](AbstractView &view) { view.setAlarmEdit(true); };


@@ 63,6 62,8 @@ namespace app::home_screen
             {};
             struct TimeUpdate
             {};
+            struct AlarmRinging
+            {};
         } // namespace Events
 
         namespace Deactivated


@@ 77,10 78,7 @@ namespace app::home_screen
 
         namespace DeactivatedWait
         {
-            auto entry = [](AbstractView &view,
-                            AbstractPresenter &presenter,
-                            AbstractAlarmModel &alarmModel,
-                            AbstractTimeModel &timeModel) {
+            auto entry = [](AbstractView &view, AbstractPresenter &presenter) {
                 presenter.spawnTimer();
                 view.setBottomDescription(utils::translate("app_bell_alarm_deactivated"));
                 view.setAlarmActive(false);


@@ 96,7 94,7 @@ namespace app::home_screen
                 view.setAlarmTimeVisible(true);
                 view.setAlarmVisible(true);
             };
-            auto exit = [](AbstractView &view, AbstractPresenter &presenter) { view.setAlarmEdit(false); };
+            auto exit = [](AbstractView &view) { view.setAlarmEdit(false); };
 
             auto processRotateLeft = [](AbstractView &view, AbstractPresenter &presenter) {
                 presenter.spawnTimer();


@@ 107,7 105,7 @@ namespace app::home_screen
                 presenter.spawnTimer();
                 view.incAlarmMinute();
             };
-        }; // namespace AlarmEdit
+        } // namespace AlarmEdit
 
         namespace WaitForConfirmation
         {


@@ 127,7 125,6 @@ namespace app::home_screen
         {
             auto entry = [](AbstractView &view,
                             AbstractPresenter &presenter,
-                            AbstractAlarmModel &alarmModel,
                             AbstractTimeModel &timeModel) {
                 presenter.spawnTimer();
                 view.setBottomDescription(


@@ 147,6 144,51 @@ namespace app::home_screen
             };
         } // namespace Activated
 
+        namespace AlarmRinging
+        {
+            auto entry = [](AbstractView &view, AbstractPresenter &presenter) {
+                presenter.spawnTimer();
+                view.setAlarmTimeVisible(false);
+                view.setAlarmTriggered();
+            };
+            auto exit = [](AbstractPresenter &presenter) { presenter.detachTimer(); };
+        } // namespace AlarmRinging
+
+        namespace AlarmRingingDeactivatedWait
+        {
+            auto entry = [](AbstractView &view, AbstractPresenter &presenter) {
+                presenter.spawnTimer();
+                view.setBottomDescription(utils::translate("app_bell_alarm_ringing_deactivated"));
+                view.setAlarmActive(false);
+            };
+            auto exit = [](AbstractPresenter &presenter) { presenter.detachTimer(); };
+        } // namespace AlarmRingingDeactivatedWait
+
+        namespace AlarmSnoozedWait
+        {
+            auto entry = [](AbstractView &view, AbstractPresenter &presenter) {
+                presenter.spawnTimer();
+                view.setAlarmTimeVisible(false);
+                view.setAlarmSnoozed();
+                const auto bottomDescription = utils::translate("app_bellmain_home_screen_bottom_desc") +
+                                               " 10 min"; // TODO: Get duration from settings
+                view.setBottomDescription(bottomDescription);
+            };
+            auto exit = [](AbstractPresenter &presenter) { presenter.detachTimer(); };
+        } // namespace AlarmSnoozedWait
+
+        namespace AlarmSnoozed
+        {
+            auto entry =
+                [](AbstractView &view, AbstractPresenter &presenter, AbstractTemperatureModel &temperatureModel) {
+                    presenter.spawnTimer();
+                    view.setAlarmTimeVisible(false);
+                    view.setAlarmSnoozed();
+                    view.setTemperature(temperatureModel.getTemperature());
+                };
+            auto exit = [](AbstractPresenter &presenter) { presenter.detachTimer(); };
+        } // namespace AlarmSnoozed
+
         class StateMachine
         {
           public:


@@ 189,6 231,7 @@ namespace app::home_screen
                                              "Activated"_s + event<Events::RotateRightPress> / Helpers::makeAlarmEditable = "ActivatedEdit"_s,
                                              "Activated"_s + event<Events::TimeUpdate> / Helpers::updateTemperature,
                                              "Activated"_s + event<Events::DeepDownPress> / Helpers::hideAlarmTime  = "DeactivatedWait"_s,
+                                             "Activated"_s + event<Events::AlarmRinging>  = "AlarmRinging"_s,
 
                                              "ActivatedEdit"_s + sml::on_entry<_> / AlarmEdit::entry,
                                              "ActivatedEdit"_s + sml::on_exit<_> / AlarmEdit::exit,


@@ 196,7 239,30 @@ namespace app::home_screen
                                              "ActivatedEdit"_s + event<Events::RotateLeftPress> / AlarmEdit::processRotateLeft,
                                              "ActivatedEdit"_s + event<Events::RotateRightPress> / AlarmEdit::processRotateRight,
                                              "ActivatedEdit"_s + event<Events::Timer>  = "ActivatedWait"_s,
-                                             "ActivatedEdit"_s + event<Events::LightPress> / Helpers::detachTimer = "ActivatedWait"_s
+                                             "ActivatedEdit"_s + event<Events::LightPress> / Helpers::detachTimer = "ActivatedWait"_s,
+
+                                             "AlarmRinging"_s + sml::on_entry<_> / AlarmRinging::entry,
+                                             "AlarmRinging"_s + sml::on_exit<_> / AlarmRinging::exit,
+                                             "AlarmRinging"_s + event<Events::Timer> = "AlarmSnoozedWait"_s,
+                                             "AlarmRinging"_s + event<Events::LightPress> = "AlarmSnoozedWait"_s,
+                                             "AlarmRinging"_s + event<Events::RotateLeftPress> = "AlarmSnoozedWait"_s,
+                                             "AlarmRinging"_s + event<Events::RotateRightPress> = "AlarmSnoozedWait"_s,
+                                             "AlarmRinging"_s + event<Events::DeepDownPress> = "AlarmRingingDeactivatedWait"_s,
+
+                                             "AlarmRingingDeactivatedWait"_s + sml::on_entry<_> / AlarmRingingDeactivatedWait::entry,
+                                             "AlarmRingingDeactivatedWait"_s + sml::on_exit<_> / AlarmRingingDeactivatedWait::exit,
+                                             "AlarmRingingDeactivatedWait"_s + event<Events::Timer> = "Deactivated"_s,
+                                             "AlarmRingingDeactivatedWait"_s + event<Events::DeepDownPress> = "DeactivatedWait"_s,
+
+                                             "AlarmSnoozedWait"_s + sml::on_entry<_> / AlarmSnoozedWait::entry,
+                                             "AlarmSnoozedWait"_s + sml::on_exit<_> / AlarmSnoozedWait::exit,
+                                             "AlarmSnoozedWait"_s + event<Events::Timer> = "AlarmSnoozed"_s,
+                                             "AlarmSnoozedWait"_s + event<Events::DeepDownPress> = "DeactivatedWait"_s,
+
+                                             "AlarmSnoozed"_s + sml::on_entry<_> / AlarmSnoozed::entry,
+                                             "AlarmSnoozed"_s + sml::on_entry<_> / AlarmSnoozed::exit,
+                                             "AlarmSnoozed"_s + event<Events::Timer> = "AlarmRinging"_s,
+                                             "AlarmSnoozed"_s + event<Events::DeepDownPress> = "DeactivatedWait"_s
                     );
                 // clang-format on
             }


@@ 255,15 321,23 @@ namespace app::home_screen
 
         return true;
     }
+
     bool StateController::handleTimerEvent()
     {
         pimpl->sm.process_event(Events::Timer{});
         presenter.refreshWindow();
         return true;
     }
+
     bool StateController::handleTimeUpdateEvent()
     {
         pimpl->sm.process_event(Events::TimeUpdate{});
         return true;
     }
+
+    bool StateController::handleAlarmRingingEvent()
+    {
+        pimpl->sm.process_event(Events::AlarmRinging{});
+        return true;
+    }
 } // namespace app::home_screen

@@ 21,6 21,7 @@ namespace app::home_screen
         virtual bool handleInputEvent(const gui::InputEvent &inputEvent) = 0;
         virtual bool handleTimerEvent()                                  = 0;
         virtual bool handleTimeUpdateEvent()                             = 0;
+        virtual bool handleAlarmRingingEvent()                           = 0;
     };
 
     class StateController : public AbstractController


@@ 35,6 36,7 @@ namespace app::home_screen
         bool handleInputEvent(const gui::InputEvent &inputEvent) override;
         bool handleTimerEvent() override;
         bool handleTimeUpdateEvent() override;
+        bool handleAlarmRingingEvent() override;
 
       private:
         class Impl;

@@ 5,6 5,7 @@
 #include "data/BellMainStyle.hpp"
 
 #include <application-bell-main/ApplicationBellMain.hpp>
+#include <application-bell-main/data/AlarmRingingSwitchData.hpp>
 #include <apps-common/widgets/BellBaseLayout.hpp>
 #include <gui/input/InputEvent.hpp>
 #include <gui/widgets/TextFixedSize.hpp>


@@ 32,6 33,7 @@ namespace
             tm.tm_min = 0;
         }
     }
+
     void decreaseHour(struct tm &tm)
     {
         if (tm.tm_hour <= Locale::min_hour_24H_mode) {


@@ 43,6 45,7 @@ namespace
             tm.tm_min = utils::time::Locale::max_minutes;
         }
     }
+
     void handleMinuteIncrease(struct tm &tm)
     {
         if (tm.tm_min >= Locale::max_minutes) {


@@ 52,6 55,7 @@ namespace
             tm.tm_min++;
         }
     }
+
     void handleMinuteDecrease(struct tm &tm)
     {
         if (tm.tm_min <= 0) {


@@ 115,11 119,17 @@ namespace gui
         body->centerBox->resizeItems();
         body->lastBox->resizeItems();
     }
+
     void BellHomeScreenWindow::setAlarmTriggered()
     {
         alarm->setAlarmStatus(AlarmSetSpinner::Status::RINGING);
     }
 
+    void BellHomeScreenWindow::setAlarmSnoozed()
+    {
+        alarm->setAlarmStatus(AlarmSetSpinner::Status::SNOOZE);
+    }
+
     void BellHomeScreenWindow::setAlarmActive(bool val)
     {
         if (val) {


@@ 144,22 154,27 @@ namespace gui
     {
         bottomText->setText(utils::temperature::tempToStrDec(newTemp));
     }
+
     void BellHomeScreenWindow::setBottomDescription(const UTF8 &desc)
     {
         bottomText->setText(desc);
     }
+
     void BellHomeScreenWindow::setTime(std::time_t newTime)
     {
         time->setTime(newTime);
     }
+
     void BellHomeScreenWindow::setTimeFormat(utils::time::Locale::TimeFormat fmt)
     {
         time->setTimeFormat(fmt);
     }
+
     void BellHomeScreenWindow::setAlarmTimeFormat(utils::time::Locale::TimeFormat fmt)
     {
         alarm->setTimeFormat(fmt);
     }
+
     void BellHomeScreenWindow::setAlarmEdit(bool val)
     {
         if (not val) {


@@ 169,10 184,12 @@ namespace gui
             alarm->setEditMode(EditMode::Edit);
         };
     }
+
     void BellHomeScreenWindow::switchToMenu()
     {
         application->switchWindow(window::name::bell_main_menu, nullptr);
     }
+
     bool BellHomeScreenWindow::onInput(const InputEvent &inputEvent)
     {
         if (inputEvent.isShortRelease()) {


@@ 180,10 197,16 @@ namespace gui
         }
         return false;
     }
-    void BellHomeScreenWindow::onBeforeShow(ShowMode, SwitchData *)
+
+    void BellHomeScreenWindow::onBeforeShow(ShowMode, SwitchData *data)
     {
         presenter->onBeforeShow();
+        const auto alarmRingingSwitchData = dynamic_cast<alarms::AlarmRingingSwitchData *>(data);
+        if (alarmRingingSwitchData != nullptr) {
+            presenter->handleAlarmRingingEvent();
+        }
     }
+
     std::time_t BellHomeScreenWindow::getAlarmTime() const
     {
         const auto now = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());


@@ 193,10 216,12 @@ namespace gui
         }
         return alarmTime;
     }
+
     void BellHomeScreenWindow::setAlarmTime(std::time_t newTime)
     {
         alarm->setTime(newTime);
     }
+
     bool BellHomeScreenWindow::updateTime()
     {
         if (presenter) {


@@ 204,6 229,7 @@ namespace gui
         }
         return true;
     }
+
     void BellHomeScreenWindow::incAlarmMinute()
     {
         const auto alarmTime = alarm->getTime();


@@ 211,6 237,7 @@ namespace gui
         handleMinuteIncrease(*newTime);
         alarm->setTime(std::mktime(newTime));
     }
+
     void BellHomeScreenWindow::decAlarmMinute()
     {
         const auto alarmTime = alarm->getTime();

@@ 28,6 28,7 @@ namespace gui
         void onBeforeShow(ShowMode mode, SwitchData *data) override;
 
         void setAlarmTriggered() override;
+        void setAlarmSnoozed() override;
         void setAlarmActive(bool val) override;
         void setAlarmEdit(bool val) override;
         void setAlarmVisible(bool val) override;