15 files changed, 182 insertions(+), 41 deletions(-)

M module-services/service-time/AlarmMessageHandler.cpp
M module-services/service-time/AlarmMessageHandler.hpp
M module-services/service-time/AlarmOperations.cpp
M module-services/service-time/AlarmOperations.hpp
M module-services/service-time/CMakeLists.txt
M module-services/service-time/ServiceTime.cpp
M module-services/service-time/include/service-time/AlarmMessage.hpp
A module-services/service-time/include/service-time/AlarmStatus.hpp
M products/BellHybrid/apps/application-bell-main/presenters/HomeScreenPresenter.cpp
M products/BellHybrid/apps/application-bell-main/presenters/StateController.cpp
M products/BellHybrid/apps/application-bell-main/presenters/StateController.hpp
M products/BellHybrid/apps/common/CMakeLists.txt
M products/BellHybrid/apps/common/include/common/models/AbstractAlarmModel.hpp
M products/BellHybrid/apps/common/include/common/models/AlarmModel.hpp
M products/BellHybrid/apps/common/src/AlarmModel.cpp

@@ 30,6 30,18 @@ namespace alarms
             });
     }
 
+    auto AlarmMessageHandler::handleGetAlarmWithStatus(AlarmGetWithStatusRequestMessage *request)
+        -> std::shared_ptr<AlarmGetWithStatusResponseMessage>
+    {
+        return handleWithCallback<AlarmGetWithStatusRequestMessage,
+                                  AlarmGetWithStatusResponseMessage,
+                                  std::pair<AlarmEventRecord, AlarmStatus>>(
+            request,
+            [&](AlarmGetWithStatusRequestMessage *request, IAlarmOperations::OnGetAlarmWithStatusProcessed callback) {
+                alarmOperations->getAlarmWithStatus(request->id, callback);
+            });
+    }
+
     auto AlarmMessageHandler::handleAddAlarm(AlarmAddRequestMessage *request)
         -> std::shared_ptr<AlarmAddResponseMessage>
     {

@@ 23,6 23,8 @@ namespace alarms
 
         auto handleTimeUpdate(TimePoint time) -> void;
         auto handleGetAlarm(AlarmGetRequestMessage *request) -> std::shared_ptr<AlarmGetResponseMessage>;
+        auto handleGetAlarmWithStatus(AlarmGetWithStatusRequestMessage *request)
+            -> std::shared_ptr<AlarmGetWithStatusResponseMessage>;
         auto handleAddAlarm(AlarmAddRequestMessage *request) -> std::shared_ptr<AlarmAddResponseMessage>;
         auto handleUpdateAlarm(AlarmUpdateRequestMessage *request) -> std::shared_ptr<AlarmUpdateResponseMessage>;
         auto handleRemoveAlarm(AlarmRemoveRequestMessage *request) -> std::shared_ptr<AlarmRemoveResponseMessage>;

@@ 41,6 41,38 @@ namespace alarms
         alarmEventsRepo->getAlarmEvent(alarmId, repoCallback);
     }
 
+    void AlarmOperationsCommon::getAlarmWithStatus(const std::uint32_t alarmId, OnGetAlarmWithStatusProcessed callback)
+    {
+        OnGetAlarmEventCallback repoCallback = [this, callback](AlarmEventRecord record) {
+            // Check if snoozed
+            auto foundSnoozed = findSnoozedEventById(snoozedSingleEvents, record.ID);
+            if (foundSnoozed != snoozedSingleEvents.end()) {
+                callback(std::pair<AlarmEventRecord, AlarmStatus>(record, AlarmStatus::Snoozed));
+                return;
+            }
+
+            // Check if ringing or queued
+            auto foundOngoing = findSingleEventById(ongoingSingleEvents, record.ID);
+            if (foundOngoing != ongoingSingleEvents.end()) {
+                if (foundOngoing == ongoingSingleEvents.begin()) {
+                    callback(std::pair<AlarmEventRecord, AlarmStatus>(record, AlarmStatus::Ringing));
+                }
+                else {
+                    callback(std::pair<AlarmEventRecord, AlarmStatus>(record, AlarmStatus::Queued));
+                }
+                return;
+            }
+
+            if (record.enabled) {
+                callback(std::pair<AlarmEventRecord, AlarmStatus>(record, AlarmStatus::Activated));
+            }
+            else {
+                callback(std::pair<AlarmEventRecord, AlarmStatus>(record, AlarmStatus::Deactivated));
+            }
+        };
+        alarmEventsRepo->getAlarmEvent(alarmId, repoCallback);
+    }
+
     void AlarmOperationsCommon::addAlarm(AlarmEventRecord record, OnAddAlarmProcessed callback)
     {
         OnAddAlarmEventCallback repoCallback = [&, callback, record](bool success) mutable {


@@ 53,12 85,7 @@ namespace alarms
     void AlarmOperationsCommon::updateAlarm(AlarmEventRecord record, OnUpdateAlarmProcessed callback)
     {
         OnUpdateAlarmEventCallback repoCallback = [&, callback, record](bool success) mutable {
-            auto found = std::find_if(nextSingleEvents.begin(),
-                                      nextSingleEvents.end(),
-                                      [recordId = record.ID](const std::unique_ptr<SingleEventRecord> &e) {
-                                          return e->parent->ID == recordId;
-                                      });
-
+            auto found = findSingleEventById(nextSingleEvents, record.ID);
             if (found != std::end(nextSingleEvents)) {
                 updateEventsCache(getCurrentTime());
             }


@@ 73,11 100,7 @@ namespace alarms
     void AlarmOperationsCommon::removeAlarm(const std::uint32_t alarmId, OnRemoveAlarmProcessed callback)
     {
         OnRemoveAlarmEventCallback repoCallback = [&, callback, alarmId](bool success) {
-            auto found = std::find_if(
-                nextSingleEvents.begin(),
-                nextSingleEvents.end(),
-                [alarmId](const std::unique_ptr<SingleEventRecord> &e) { return e->parent->ID == alarmId; });
-
+            auto found = findSingleEventById(nextSingleEvents, alarmId);
             if (found != std::end(nextSingleEvents) && nextSingleEvents.size() == 1) {
                 updateEventsCache(getCurrentTime());
             }


@@ 105,10 128,7 @@ namespace alarms
 
     void AlarmOperationsCommon::turnOffRingingAlarm(const std::uint32_t id, OnTurnOffRingingAlarm callback)
     {
-        auto found =
-            std::find_if(ongoingSingleEvents.begin(),
-                         ongoingSingleEvents.end(),
-                         [id](const std::unique_ptr<SingleEventRecord> &event) { return id == event->parent->ID; });
+        auto found = findSingleEventById(ongoingSingleEvents, id);
         if (found == ongoingSingleEvents.end()) {
             LOG_ERROR("Trying to turn off nonexisting event");
             callback(false);


@@ 122,10 142,7 @@ namespace alarms
 
     void AlarmOperationsCommon::turnOffSnoozedAlarm(const std::uint32_t id, OnTurnOffRingingAlarm callback)
     {
-        auto found = std::find_if(
-            snoozedSingleEvents.begin(),
-            snoozedSingleEvents.end(),
-            [id](const std::unique_ptr<SnoozedAlarmEventRecord> &event) { return id == event->parent->ID; });
+        auto found = findSnoozedEventById(snoozedSingleEvents, id);
         if (found == snoozedSingleEvents.end()) {
             LOG_ERROR("Trying to turn off nonexisting event");
             callback(false);


@@ 141,10 158,7 @@ namespace alarms
                                                    const TimePoint nextAlarmTime,
                                                    OnSnoozeRingingAlarm callback)
     {
-        auto found =
-            std::find_if(ongoingSingleEvents.begin(),
-                         ongoingSingleEvents.end(),
-                         [id](const std::unique_ptr<SingleEventRecord> &event) { return id == event->parent->ID; });
+        auto found = findSingleEventById(ongoingSingleEvents, id);
         if (found == ongoingSingleEvents.end()) {
             LOG_ERROR("Trying to snooze nonexisting event");
             callback(false);


@@ 189,10 203,7 @@ namespace alarms
                                                const TimePoint nextAlarmTime,
                                                OnSnoozeRingingAlarm callback)
     {
-        auto found = std::find_if(
-            snoozedSingleEvents.begin(),
-            snoozedSingleEvents.end(),
-            [id](const std::unique_ptr<SnoozedAlarmEventRecord> &event) { return id == event->parent->ID; });
+        auto found = findSnoozedEventById(snoozedSingleEvents, id);
         if (found == snoozedSingleEvents.end()) {
             LOG_ERROR("Trying to postpone nonexisting snooze");
             callback(false);


@@ 409,4 420,19 @@ namespace alarms
         }
         callback(std::move(snoozedEvents));
     }
+
+    auto findSingleEventById(std::vector<std::unique_ptr<SingleEventRecord>> &events, const std::uint32_t id)
+        -> std::vector<std::unique_ptr<SingleEventRecord>>::iterator
+    {
+        return std::find_if(events.begin(), events.end(), [id](const std::unique_ptr<SingleEventRecord> &event) {
+            return id == event->parent->ID;
+        });
+    }
+    auto findSnoozedEventById(std::vector<std::unique_ptr<SnoozedAlarmEventRecord>> &events, const std::uint32_t id)
+        -> std::vector<std::unique_ptr<SnoozedAlarmEventRecord>>::iterator
+    {
+        return std::find_if(events.begin(), events.end(), [id](const std::unique_ptr<SnoozedAlarmEventRecord> &event) {
+            return id == event->parent->ID;
+        });
+    }
 } // namespace alarms

@@ 7,6 7,7 @@
 #include "SnoozedAlarmEventRecord.hpp"
 
 #include <service-time/AlarmHandlerFactory.hpp>
+#include <service-time/AlarmStatus.hpp>
 
 #include <module-db/Interface/AlarmEventRecord.hpp>
 


@@ 18,6 19,7 @@ namespace alarms
     {
       public:
         using OnGetAlarmProcessed           = std::function<void(AlarmEventRecord)>;
+        using OnGetAlarmWithStatusProcessed = std::function<void(std::pair<AlarmEventRecord, AlarmStatus>)>;
         using OnGetAlarmsInRangeProcessed   = std::function<void(std::pair<std::vector<AlarmEventRecord>, uint32_t>)>;
         using OnAddAlarmProcessed           = std::function<void(bool)>;
         using OnUpdateAlarmProcessed        = std::function<void(bool)>;


@@ 38,6 40,7 @@ namespace alarms
         virtual void updateEventsCache(TimePoint now) = 0;
 
         virtual void getAlarm(const std::uint32_t alarmId, OnGetAlarmProcessed callback)              = 0;
+        virtual void getAlarmWithStatus(const std::uint32_t alarmId, OnGetAlarmWithStatusProcessed callback) = 0;
         virtual void addAlarm(AlarmEventRecord record, OnAddAlarmProcessed callback)                  = 0;
         virtual void updateAlarm(AlarmEventRecord record, OnUpdateAlarmProcessed callback)            = 0;
         virtual void removeAlarm(const std::uint32_t alarmId, OnRemoveAlarmProcessed callback)        = 0;


@@ 83,6 86,7 @@ namespace alarms
         void updateEventsCache(TimePoint now) override;
 
         void getAlarm(const std::uint32_t alarmId, OnGetAlarmProcessed callback) override;
+        void getAlarmWithStatus(const std::uint32_t alarmId, OnGetAlarmWithStatusProcessed callback) override;
         void addAlarm(AlarmEventRecord record, OnAddAlarmProcessed callback) override;
         void updateAlarm(AlarmEventRecord record, OnUpdateAlarmProcessed callback) override;
         void removeAlarm(const std::uint32_t alarmId, OnRemoveAlarmProcessed callback) override;


@@ 154,4 158,9 @@ namespace alarms
             std::unique_ptr<AbstractAlarmEventsRepository> &&alarmEventsRepo,
             IAlarmOperations::GetCurrentTime getCurrentTimeCallback) const override;
     };
+
+    auto findSingleEventById(std::vector<std::unique_ptr<SingleEventRecord>> &events, const std::uint32_t id)
+        -> std::vector<std::unique_ptr<SingleEventRecord>>::iterator;
+    auto findSnoozedEventById(std::vector<std::unique_ptr<SnoozedAlarmEventRecord>> &events, const std::uint32_t id)
+        -> std::vector<std::unique_ptr<SnoozedAlarmEventRecord>>::iterator;
 } // namespace alarms

@@ 17,6 17,7 @@ set(SOURCES
     include/service-time/AlarmHandlerFactory.hpp
     include/service-time/AlarmMessage.hpp
     include/service-time/AlarmServiceAPI.hpp
+    include/service-time/AlarmStatus.hpp
 )
 
 add_library(${PROJECT_NAME} STATIC ${SOURCES})

@@ 138,6 138,10 @@ namespace stm
         connect(typeid(alarms::AlarmGetRequestMessage), [&](sys::Message *request) -> sys::MessagePointer {
             return alarmMessageHandler->handleGetAlarm(static_cast<alarms::AlarmGetRequestMessage *>(request));
         });
+        connect(typeid(alarms::AlarmGetWithStatusRequestMessage), [&](sys::Message *request) -> sys::MessagePointer {
+            return alarmMessageHandler->handleGetAlarmWithStatus(
+                static_cast<alarms::AlarmGetWithStatusRequestMessage *>(request));
+        });
         connect(typeid(alarms::AlarmAddRequestMessage), [&](sys::Message *request) -> sys::MessagePointer {
             return alarmMessageHandler->handleAddAlarm(static_cast<alarms::AlarmAddRequestMessage *>(request));
         });

@@ 3,6 3,8 @@
 
 #pragma once
 
+#include "AlarmStatus.hpp"
+
 #include <module-db/Interface/AlarmEventRecord.hpp>
 #include <module-db/Interface/EventRecord.hpp>
 #include <MessageType.hpp>


@@ 38,6 40,21 @@ namespace alarms
         const AlarmEventRecord alarm;
     };
 
+    class AlarmGetWithStatusRequestMessage : public AlarmMessage
+    {
+      public:
+        explicit AlarmGetWithStatusRequestMessage(const unsigned int id = 1) : id(id){};
+        const unsigned int id;
+    };
+
+    class AlarmGetWithStatusResponseMessage : public AlarmResponse
+    {
+      public:
+        AlarmGetWithStatusResponseMessage(const std::pair<AlarmEventRecord, AlarmStatus> p)
+            : alarm(std::move(p.first)), status(p.second){};
+        const AlarmEventRecord alarm;
+        const AlarmStatus status;
+    };
     class AlarmAddRequestMessage : public AlarmMessage
     {
       public:

@@ 0,0 1,17 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#pragma once
+
+namespace alarms
+{
+    enum class AlarmStatus
+    {
+        Invalid,
+        Deactivated,
+        Activated,
+        Snoozed,
+        Ringing,
+        Queued
+    };
+}

@@ 65,7 65,7 @@ namespace app::home_screen
 
     void HomeScreenPresenter::onBeforeShow()
     {
-        alarmModel->update([&]() { handleAlarmModelReady(); });
+        stateController->resetStateMachine();
         getView()->setTimeFormat(timeModel->getTimeFormat());
         getView()->setTime(timeModel->getCurrentTime());
         getView()->setAlarmTimeFormat(timeModel->getTimeFormat());

@@ 32,10 32,23 @@ namespace app::home_screen
     {
         namespace Helpers
         {
-            auto switchToMenu          = [](AbstractView &view) { view.switchToMenu(); };
+            auto isDeactivated = [](AbstractAlarmModel &alarmModel) {
+                return alarmModel.getAlarmStatus() == alarms::AlarmStatus::Deactivated;
+            };
+            auto isActivated = [](AbstractAlarmModel &alarmModel) {
+                return alarmModel.getAlarmStatus() == alarms::AlarmStatus::Activated;
+            };
+            auto isSnoozed = [](AbstractAlarmModel &alarmModel) {
+                return alarmModel.getAlarmStatus() == alarms::AlarmStatus::Snoozed;
+            };
+            auto isRinging = [](AbstractAlarmModel &alarmModel) {
+                return alarmModel.getAlarmStatus() == alarms::AlarmStatus::Ringing;
+            };
+
+            auto switchToMenu         = [](AbstractView &view) { view.switchToMenu(); };
+            auto makeAlarmEditable    = [](AbstractView &view) { view.setAlarmEdit(true); };
+            auto makeAlarmNonEditable = [](AbstractView &view) { view.setAlarmEdit(false); };
             auto switchToBatteryStatus = [](AbstractView &view) { view.switchToBatteryStatus(); };
-            auto makeAlarmEditable     = [](AbstractView &view) { view.setAlarmEdit(true); };
-            auto makeAlarmNonEditable  = [](AbstractView &view) { view.setAlarmEdit(false); };
             auto updateBottomStats =
                 [](AbstractView &view, AbstractBatteryModel &batteryModel, AbstractTemperatureModel &temperatureModel) {
                     view.setTemperature(temperatureModel.getTemperature());


@@ 96,6 109,8 @@ namespace app::home_screen
             {};
             struct ModelReady
             {};
+            struct Reset
+            {};
         } // namespace Events
 
         namespace Init


@@ 266,10 281,13 @@ namespace app::home_screen
                 using namespace sml;
                 // clang-format off
                 return make_transition_table(*"Init"_s + sml::on_entry<_> / Init::entry,
-                                             "Init"_s + event<Events::ModelReady> = "Deactivated"_s,
+                                             "Init"_s + event<Events::ModelReady> [Helpers::isDeactivated] = "Deactivated"_s,
+                                             "Init"_s + event<Events::ModelReady> [Helpers::isActivated] = "Activated"_s,
+                                             "Init"_s + event<Events::ModelReady> [Helpers::isSnoozed] = "AlarmSnoozed"_s,
+                                             "Init"_s + event<Events::ModelReady> [Helpers::isRinging] = "AlarmRinging"_s,
 
                                              "Deactivated"_s + sml::on_entry<_> / Deactivated::entry,
-                                             "Deactivated"_s [Helpers::isAlarmActive] = "Activated"_s,
+                                             "Deactivated"_s + event<Events::Reset> = "Init"_s,
                                              "Deactivated"_s + event<Events::LightPress>/ Helpers::switchToMenu,
                                              "Deactivated"_s + event<Events::RotateLeftPress> / Helpers::makeAlarmEditable = "DeactivatedEdit"_s,
                                              "Deactivated"_s + event<Events::RotateRightPress> / Helpers::makeAlarmEditable = "DeactivatedEdit"_s,


@@ 279,6 297,7 @@ namespace app::home_screen
 
                                              "DeactivatedWait"_s + sml::on_entry<_> / DeactivatedWait::entry,
                                              "DeactivatedWait"_s + sml::on_exit<_> / DeactivatedWait::exit,
+                                             "DeactivatedWait"_s + event<Events::Reset> = "Init"_s,
                                              "DeactivatedWait"_s + event<Events::Timer> = "Deactivated"_s,
                                              "DeactivatedWait"_s + event<Events::LightPress>/ Helpers::switchToMenu = "Deactivated"_s,
                                              "DeactivatedWait"_s + event<Events::DeepUpPress> = "ActivatedWait"_s,


@@ 288,6 307,7 @@ namespace app::home_screen
 
                                              "DeactivatedEdit"_s + sml::on_entry<_> / AlarmEdit::entry,
                                              "DeactivatedEdit"_s + sml::on_exit<_> / AlarmEdit::exit,
+                                             "DeactivatedEdit"_s + event<Events::Reset> = "Init"_s,
                                              "DeactivatedEdit"_s + event<Events::TimeUpdate> / Helpers::updateBottomStats,
                                              "DeactivatedEdit"_s + event<Events::RotateLeftPress> / AlarmEdit::processRotateLeft,
                                              "DeactivatedEdit"_s + event<Events::RotateRightPress> / AlarmEdit::processRotateRight,


@@ 297,6 317,7 @@ namespace app::home_screen
 
                                              "WaitForConfirmation"_s + sml::on_entry<_> / WaitForConfirmation::entry,
                                              "WaitForConfirmation"_s + sml::on_exit<_> / WaitForConfirmation::exit,
+                                             "WaitForConfirmation"_s + event<Events::Reset> = "Init"_s,
                                              "WaitForConfirmation"_s + event<Events::Timer> / Helpers::makeAlarmNonEditable = "Deactivated"_s,
                                              "WaitForConfirmation"_s + event<Events::DeepUpPress> / WaitForConfirmation::action = "ActivatedWait"_s,
                                              "WaitForConfirmation"_s + event<Events::LightPress>/ Helpers::switchToMenu = "Deactivated"_s,


@@ 306,6 327,7 @@ namespace app::home_screen
 
                                              "ActivatedWait"_s + sml::on_entry<_> / ActivatedWait::entry,
                                              "ActivatedWait"_s + sml::on_exit<_> / ActivatedWait::exit,
+                                             "ActivatedWait"_s + event<Events::Reset> = "Init"_s,
                                              "ActivatedWait"_s + event<Events::Timer> / Helpers::makeAlarmNonEditable = "Activated"_s,
                                              "ActivatedWait"_s + event<Events::LightPress>/ Helpers::switchToMenu = "Activated"_s,
                                              "ActivatedWait"_s + event<Events::DeepDownPress> = "DeactivatedWait"_s,


@@ 315,6 337,7 @@ namespace app::home_screen
                                              "ActivatedWait"_s + event<Events::AlarmRinging>  = "AlarmRinging"_s,
 
                                              "Activated"_s + sml::on_entry<_> / Activated::entry,
+                                             "Activated"_s + event<Events::Reset> = "Init"_s,
                                              "Activated"_s [not Helpers::isAlarmActive] = "Deactivated"_s,
                                              "Activated"_s + event<Events::LightPress>/ Helpers::switchToMenu = "Activated"_s,
                                              "Activated"_s + event<Events::RotateLeftPress> / Helpers::makeAlarmEditable = "ActivatedEdit"_s,


@@ 326,6 349,7 @@ namespace app::home_screen
 
                                              "ActivatedEdit"_s + sml::on_entry<_> / AlarmEdit::entry,
                                              "ActivatedEdit"_s + sml::on_exit<_> / AlarmEdit::exit,
+                                             "ActivatedEdit"_s + event<Events::Reset> = "Init"_s,
                                              "ActivatedEdit"_s + event<Events::TimeUpdate> / Helpers::updateBottomStats,
                                              "ActivatedEdit"_s + event<Events::RotateLeftPress> / AlarmEdit::processRotateLeft,
                                              "ActivatedEdit"_s + event<Events::RotateRightPress> / AlarmEdit::processRotateRight,


@@ 335,6 359,7 @@ namespace app::home_screen
 
                                              "AlarmRinging"_s + sml::on_entry<_> / AlarmRinging::entry,
                                              "AlarmRinging"_s + sml::on_exit<_> / AlarmRinging::exit,
+                                             "AlarmRinging"_s + event<Events::Reset> = "Init"_s,
                                              "AlarmRinging"_s + event<Events::Timer> [Helpers::isSnoozeAllowed] / Helpers::snooze = "AlarmSnoozedWait"_s,
                                              "AlarmRinging"_s + event<Events::Timer> [!Helpers::isSnoozeAllowed] / Helpers::setDefaultAlarmTime  = "ActivatedWait"_s,
                                              "AlarmRinging"_s + event<Events::LightPress> = "AlarmSnoozedWait"_s,


@@ 344,6 369,7 @@ namespace app::home_screen
 
                                              "AlarmRingingDeactivatedWait"_s + sml::on_entry<_> / AlarmRingingDeactivatedWait::entry,
                                              "AlarmRingingDeactivatedWait"_s + sml::on_exit<_> / AlarmRingingDeactivatedWait::exit,
+                                             "AlarmRingingDeactivatedWait"_s + event<Events::Reset> = "Init"_s,
                                              "AlarmRingingDeactivatedWait"_s + event<Events::Timer> = "Deactivated"_s,
                                              "AlarmRingingDeactivatedWait"_s + event<Events::DeepDownPress> = "DeactivatedWait"_s,
                                              "AlarmRingingDeactivatedWait"_s + event<Events::BackPress> = "Deactivated"_s,


@@ 353,6 379,7 @@ namespace app::home_screen
 
                                              "AlarmSnoozedWait"_s + sml::on_entry<_> / AlarmSnoozedWait::entry,
                                              "AlarmSnoozedWait"_s + sml::on_exit<_> / AlarmSnoozedWait::exit,
+                                             "AlarmSnoozedWait"_s + event<Events::Reset> = "Init"_s,
                                              "AlarmSnoozedWait"_s + event<Events::Timer> = "AlarmSnoozed"_s,
                                              "AlarmSnoozedWait"_s + event<Events::DeepDownPress> = "DeactivatedWait"_s,
                                              "AlarmSnoozedWait"_s + event<Events::LightPress>/ Helpers::switchToMenu = "AlarmSnoozed"_s,


@@ 360,6 387,7 @@ namespace app::home_screen
 
                                              "AlarmSnoozed"_s + sml::on_entry<_> / AlarmSnoozed::entry,
                                              "AlarmSnoozed"_s + sml::on_entry<_> / AlarmSnoozed::exit,
+                                             "AlarmSnoozed"_s + event<Events::Reset> = "Init"_s,
                                              "AlarmSnoozed"_s + event<Events::ModelReady> [not Helpers::isSnoozeActive] = "Activated"_s,
                                              "AlarmSnoozed"_s + event<Events::AlarmRinging>  = "AlarmRinging"_s,
                                              "AlarmSnoozed"_s + event<Events::DeepDownPress> = "DeactivatedWait"_s,


@@ 485,4 513,9 @@ namespace app::home_screen
         }
     }
 
+    void StateController::resetStateMachine()
+    {
+        pimpl->sm.process_event(Events::Reset{});
+    }
+
 } // namespace app::home_screen

@@ 28,6 28,7 @@ namespace app::home_screen
       public:
         virtual ~AbstractController() noexcept = default;
 
+        virtual void resetStateMachine()                                 = 0;
         virtual bool handleInputEvent(const gui::InputEvent &inputEvent) = 0;
         virtual bool handleTimerEvent()                                  = 0;
         virtual bool handleTimeUpdateEvent()                             = 0;


@@ 47,6 48,8 @@ namespace app::home_screen
                         AbstractAlarmModel &alarmModel,
                         AbstractTimeModel &timeModel);
         ~StateController();
+
+        void resetStateMachine() override;
         bool handleInputEvent(const gui::InputEvent &inputEvent) override;
         bool handleTimerEvent() override;
         bool handleTimeUpdateEvent() override;

@@ 77,11 77,11 @@ target_link_libraries(application-bell-common
     PUBLIC
         apps-common
         service-db
+        service-time
 
     PRIVATE
         bell::app-main
         bell::app-alarm
         module-gui
-        service-time
         bell::db
         )

@@ 3,6 3,8 @@
 
 #pragma once
 
+#include <service-time/AlarmStatus.hpp>
+
 #include <chrono>
 #include <ctime>
 #include <cstdint>


@@ 28,6 30,7 @@ namespace app
         virtual void turnOff()                    = 0;
         virtual void snooze()                     = 0;
         virtual std::chrono::seconds getTimeToNextSnooze() = 0;
+        virtual alarms::AlarmStatus getAlarmStatus()       = 0;
         /// Command model to update its internal data
         virtual void update(AlarmModelReadyHandler callback = AlarmModelReadyHandler()) = 0;
     };

@@ 4,6 4,7 @@
 #pragma once
 
 #include "AbstractAlarmModel.hpp"
+#include <service-time/AlarmStatus.hpp>
 
 #include <apps-common/AsyncTask.hpp>
 #include <module-db/Interface/AlarmEventRecord.hpp>


@@ 37,6 38,7 @@ namespace app
         void turnOff() override;
         void snooze() override;
         std::chrono::seconds getTimeToNextSnooze() override;
+        alarms::AlarmStatus getAlarmStatus() override;
 
       private:
         enum class State


@@ 50,10 52,11 @@ namespace app
         AlarmEventRecord generateDefaultAlarm() const;
         std::shared_ptr<AlarmEventRecord> getAlarmPtr() const;
         void disableSnooze(AlarmEventRecord &alarm);
-        void updateCache(const SingleEventRecord &record);
+        void updateCache(const SingleEventRecord &record, alarms::AlarmStatus status);
 
         ApplicationCommon *app{};
         State state{State::Invalid};
+        alarms::AlarmStatus alarmStatus{alarms::AlarmStatus::Invalid};
         SingleEventRecord cachedRecord;
         std::uint32_t snoozeCount = 0;
         TimePoint nextSnoozeTime  = TIME_POINT_INVALID;

@@ 22,11 22,11 @@ namespace app
     void AlarmModel::update(AlarmModelReadyHandler callback)
     {
         responseCallback = [this, callback](const auto response) -> bool {
-            const auto resp = dynamic_cast<alarms::AlarmGetResponseMessage *>(response);
+            const auto resp = dynamic_cast<alarms::AlarmGetWithStatusResponseMessage *>(response);
             if (resp) {
                 if (resp->alarm.isValid()) {
                     auto alarm = resp->alarm;
-                    updateCache(alarm.getNextSingleEvent(TimePointNow()));
+                    updateCache(alarm.getNextSingleEvent(TimePointNow()), resp->status);
                     if (callback) {
                         callback();
                     }


@@ 46,7 46,7 @@ namespace app
             return true;
         };
 
-        auto request = AsyncRequest::createFromMessage(std::make_unique<alarms::AlarmGetRequestMessage>(),
+        auto request = AsyncRequest::createFromMessage(std::make_unique<alarms::AlarmGetWithStatusRequestMessage>(),
                                                        service::name::service_time);
         request->execute(app, this, responseCallback);
     }


@@ 75,7 75,11 @@ namespace app
         }
         alarmEventPtr->enabled = value;
         updateAlarm(*alarmEventPtr);
-        if (!value) {
+        if (value) {
+            alarmStatus = alarms::AlarmStatus::Activated;
+        }
+        else {
+            alarmStatus = alarms::AlarmStatus::Deactivated;
             disableSnooze(*alarmEventPtr);
         }
     }


@@ 137,6 141,7 @@ namespace app
         nextSnoozeTime =
             std::chrono::floor<std::chrono::minutes>(TimePointNow()) + std::chrono::minutes(snoozeDuration);
         alarms::AlarmServiceAPI::requestSnoozeRingingAlarm(app, cachedRecord.parent->ID, nextSnoozeTime);
+        alarmStatus = alarms::AlarmStatus::Snoozed;
     }
 
     std::chrono::seconds AlarmModel::getTimeToNextSnooze()


@@ 170,12 175,13 @@ namespace app
     {
         return snoozeCount > 0;
     }
-    void AlarmModel::updateCache(const SingleEventRecord &record)
+    void AlarmModel::updateCache(const SingleEventRecord &record, alarms::AlarmStatus status)
     {
         if (record.startDate != cachedRecord.startDate) {
             snoozeCount  = 0;
-            cachedRecord = record;
         }
+        cachedRecord = record;
+        alarmStatus  = status;
         state = State::Valid;
     }
     void AlarmModel::setDefaultAlarmTime()


@@ 188,4 194,9 @@ namespace app
 
         updateAlarm(*alarmEventPtr);
     }
+
+    alarms::AlarmStatus AlarmModel::getAlarmStatus()
+    {
+        return alarmStatus;
+    }
 } // namespace app