15 files changed, 271 insertions(+), 6 deletions(-)

A module-services/service-alarm/AlarmHandlerFactory.cpp
M module-services/service-alarm/CMakeLists.txt
A module-services/service-alarm/include/service-alarm/AlarmHandler.hpp
A module-services/service-alarm/include/service-alarm/AlarmHandlerFactory.hpp
M module-services/service-alarm/include/service-alarm/AlarmServiceAPI.hpp
A module-services/service-alarm/tests/CMakeLists.txt
A module-services/service-alarm/tests/MockAlarmHandler.hpp
A module-services/service-alarm/tests/tests-AlarmHandlerFactory.cpp
A module-services/service-alarm/tests/tests-main.cpp
M products/BellHybrid/CMakeLists.txt
A products/BellHybrid/alarms/AlarmHandlerActions.cpp
A products/BellHybrid/alarms/BellAlarmHandler.cpp
A products/BellHybrid/alarms/CMakeLists.txt
A products/BellHybrid/alarms/include/AlarmHandlerActions.hpp
A products/BellHybrid/alarms/include/BellAlarmHandler.hpp

@@ 0,0 1,25 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#include <map>
+#include <memory>
+
+#include "include/service-alarm/AlarmHandler.hpp"
+#include "include/service-alarm/AlarmHandlerFactory.hpp"
+
+namespace alarms
+{
+    [[nodiscard]] auto AlarmHandlerFactory::getHandler(const AlarmType type) -> const std::shared_ptr<AlarmHandler>
+    {
+        if (handlers.count(type) != 0u) {
+            return handlers.at(type);
+        }
+        LOG_ERROR("no such alarm type handler defined: %d", static_cast<int>(type));
+        return nullptr;
+    }
+
+    auto AlarmHandlerFactory::addHandler(const AlarmType type, const std::shared_ptr<AlarmHandler> handler) -> void
+    {
+        handlers.insert({type, handler});
+    }
+} // namespace alarms

@@ 8,18 8,18 @@ target_sources(service-alarm
     PUBLIC
         include/service-alarm/AlarmMessage.hpp
         include/service-alarm/AlarmServiceAPI.hpp
+        include/service-alarm/AlarmHandler.hpp
+        include/service-alarm/AlarmHandlerFactory.hpp
     PRIVATE
         AlarmRepository.hpp
+        AlarmHandlerFactory.cpp
 )
 
 target_include_directories(service-alarm
     PUBLIC
         $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
     PRIVATE
-        $<BUILD_INTERFACE:
-            ${CMAKE_CURRENT_SOURCE_DIR}
-            include
-        >
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
 )
 
 target_link_libraries(service-alarm


@@ 30,3 30,7 @@ target_link_libraries(service-alarm
         messagetype
         module-sys
 )
+
+if (${ENABLE_TESTS})
+    add_subdirectory(tests)
+endif ()

@@ 0,0 1,25 @@
+// 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 <module-db/Interface/AlarmEventRecord.hpp>
+
+namespace alarms
+{
+    enum class AlarmType
+    {
+        Clock,
+        Calendar,
+        EveningReminder,
+        None
+    };
+
+    class AlarmHandler
+    {
+      public:
+        virtual ~AlarmHandler() = default;
+
+        virtual auto handle(const AlarmEventRecord &record) -> bool = 0;
+    };
+} // namespace alarms

@@ 0,0 1,27 @@
+// 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 "AlarmHandler.hpp"
+
+#include <module-db/Interface/AlarmEventRecord.hpp>
+
+#include <map>
+
+namespace alarms
+{
+    class AlarmHandlerFactory
+    {
+      private:
+        std::map<const AlarmType, const std::shared_ptr<AlarmHandler>> handlers;
+
+      public:
+        AlarmHandlerFactory() = default;
+        explicit AlarmHandlerFactory(const std::map<const AlarmType, const std::shared_ptr<AlarmHandler>> handlers)
+            : handlers{handlers} {};
+
+        [[nodiscard]] auto getHandler(const AlarmType type) -> const std::shared_ptr<AlarmHandler>;
+        auto addHandler(const AlarmType type, const std::shared_ptr<AlarmHandler>) -> void;
+    };
+} // namespace alarms

@@ 1,5 1,3 @@
-#pragma once
-
 // Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 

@@ 0,0 1,11 @@
+add_catch2_executable(
+    NAME
+        service-alarm-tests
+    SRCS
+        tests-main.cpp
+        tests-AlarmHandlerFactory.cpp
+        MockAlarmHandler.hpp
+    LIBS
+        service-alarm
+        module-db
+)

@@ 0,0 1,20 @@
+// 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 <service-alarm/AlarmHandler.hpp>
+
+namespace alarms
+{
+
+    class MockAlarmHandler : public AlarmHandler
+    {
+      public:
+        auto handle(const AlarmEventRecord &record) -> bool
+        {
+            LOG_DEBUG("MockAlarmHandler");
+            return true;
+        }
+    };
+} // namespace alarms

@@ 0,0 1,30 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#include "MockAlarmHandler.hpp"
+
+#include <service-alarm/AlarmHandlerFactory.hpp>
+
+#include <catch2/catch.hpp>
+
+TEST_CASE("AlarmHandlerFactory Tests")
+{
+    using namespace alarms;
+
+    SECTION("Create AlarmHandlerFactory")
+    {
+        AlarmHandlerFactory alarmHandlerFactory;
+        REQUIRE(alarmHandlerFactory.getHandler(AlarmType::Clock) == nullptr);
+    }
+
+    SECTION("Add/get handler")
+    {
+        AlarmHandlerFactory alarmHandlerFactory;
+        auto handler = std::make_shared<MockAlarmHandler>();
+        alarmHandlerFactory.addHandler(AlarmType::Clock, handler);
+
+        REQUIRE(alarmHandlerFactory.getHandler(AlarmType::Clock) != nullptr);
+        REQUIRE(alarmHandlerFactory.getHandler(AlarmType::Clock) == handler);
+        REQUIRE(alarmHandlerFactory.getHandler(AlarmType::Calendar) == nullptr);
+    }
+}

@@ 0,0 1,5 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#define CATCH_CONFIG_MAIN // This tells Catch to provide a main() - only do this in one cpp file
+#include <catch2/catch.hpp>

@@ 84,3 84,4 @@ add_standalone_image(BellHybrid)
 add_update_package(BellHybrid)
 
 add_subdirectory(services)
+add_subdirectory(alarms)

@@ 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 "AlarmHandlerActions.hpp"
+
+#include <service-audio/AudioServiceAPI.hpp>
+
+namespace alarms
+{
+
+    auto playAlarmSound(const std::string &soundPath) -> bool
+    {
+        // playAlarmSound after it will be implemented [BH-660]
+        return true;
+    }
+
+    auto displayAlarmPopup() -> bool
+    {
+        // displayAlarmPopup after it will be implemented [BH-566]
+        return true;
+    }
+
+    auto turnOnFrontlight() -> bool
+    {
+        // turnOnFrontlight after it will be implemented [BH-756]
+        return true;
+    }
+} // namespace alarms

@@ 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
+
+#include <BellAlarmHandler.hpp>
+#include <AlarmHandlerActions.hpp>
+
+namespace alarms
+{
+
+    auto BellAlarmClockHandler::handle(const AlarmEventRecord &record) -> bool
+    {
+        LOG_DEBUG("BellAlarmClockHandler");
+
+        auto result = false;
+
+        if (record.enabled) {
+            result = playAlarmSound(record.musicTone);
+            result = turnOnFrontlight();
+            result = displayAlarmPopup();
+            return result;
+        }
+
+        return result;
+    }
+
+    auto EveningReminderHandler::handle(const AlarmEventRecord &record) -> bool
+    {
+        LOG_DEBUG("EveningReminderHandler");
+        // implement this alarm type handling here
+        return true;
+    }
+
+} // namespace alarms

@@ 0,0 1,21 @@
+add_library(alarms STATIC)
+
+target_sources(alarms
+    PRIVATE
+        BellAlarmHandler.cpp
+        AlarmHandlerActions.cpp
+)
+
+target_include_directories(alarms
+    PRIVATE
+        include
+        
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+)
+
+target_link_libraries(alarms
+   PUBLIC
+        module-db
+        service-alarm
+)

@@ 0,0 1,15 @@
+// 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 <module-db/Interface/AlarmEventRecord.hpp>
+
+namespace alarms
+{
+
+    auto playAlarmSound(const std::string &soundPath) -> bool;
+    auto displayAlarmPopup() -> bool;
+    auto turnOnFrontlight() -> bool;
+
+} // namespace alarms

@@ 0,0 1,22 @@
+// 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 <service-alarm/AlarmHandler.hpp>
+
+namespace alarms
+{
+
+    class BellAlarmClockHandler : public AlarmHandler
+    {
+      public:
+        auto handle(const AlarmEventRecord &record) -> bool;
+    };
+
+    class EveningReminderHandler : public AlarmHandler
+    {
+      public:
+        auto handle(const AlarmEventRecord &record) -> bool;
+    };
+} // namespace alarms