From 3043c063eca7e112c71323e03b45dc296ba58230 Mon Sep 17 00:00:00 2001 From: Onufry Pajaczek Date: Thu, 21 Jul 2022 16:29:32 +0200 Subject: [PATCH] [BH-1515] Bedtime reminder notification issue AbstractAlarmAction execute method takes Record as paremeter to pass it to action Bedtime abstraction extended to keep own EvetContainer and hadle needed actions(push,clear ... and so on) Fixed an issue where cpp file was added by #include directive New fuction added to test/CMakeLists.txt to add manually prepared target to test siute googletest-service-time-alarm-operations source moved to library and than linked in to googletest-service-time-bell-alarm-operations --- module-apps/apps-common/ApplicationCommon.cpp | 2 +- .../ApplicationCommonPopupBlueprints.cpp | 14 ++ module-apps/apps-common/CMakeLists.txt | 1 + .../BedtimeReminderPopupRequestParams.hpp | 8 +- .../service-time/AlarmOperations.cpp | 44 +++++-- .../service-time/AlarmOperations.hpp | 20 +-- .../service-time/tests/CMakeLists.txt | 29 +++-- .../tests/tests-AlarmOperations.cpp | 121 ++---------------- .../tests/tests-AlarmOperations.hpp | 110 ++++++++++++++++ .../BellHybrid/alarms/BellAlarmHandler.cpp | 2 +- products/BellHybrid/alarms/CMakeLists.txt | 1 - .../alarms/include/AbstractAlarmAction.hpp | 11 +- .../alarms/src/actions/FrontlightAction.cpp | 16 +-- .../alarms/src/actions/FrontlightAction.hpp | 2 +- .../alarms/src/actions/NotifyGUIAction.cpp | 4 +- .../alarms/src/actions/NotifyGUIAction.hpp | 4 +- .../NotifyGUIBedtimeReminderAction.cpp | 8 +- .../NotifyGUIBedtimeReminderAction.hpp | 4 +- .../alarms/src/actions/PlayAudioActions.cpp | 4 +- .../alarms/src/actions/PlayAudioActions.hpp | 4 +- .../presenter/BellBedtimeWindowPresenter.hpp | 4 +- .../BellHybrid/apps/common/CMakeLists.txt | 1 + .../include/common/data/BatteryUtils.hpp | 1 + .../include/common/models/BedtimeModel.hpp | 2 +- .../popups/BedtimeNotificationWindow.hpp | 5 +- .../src/popups/BedtimeNotificationWindow.cpp | 24 +++- .../include/appmgr/messages/AlarmMessage.hpp | 12 +- .../services/time/AlarmOperations.cpp | 54 +++++++- .../time/include/time/AlarmOperations.hpp | 10 ++ .../services/time/tests/CMakeLists.txt | 1 + .../time/tests/test-BellAlarmOperations.cpp | 41 +++--- test/CMakeLists.txt | 50 +++++++- 32 files changed, 410 insertions(+), 204 deletions(-) rename {products/BellHybrid/alarms/include/popups => module-apps/apps-common/popups/data}/BedtimeReminderPopupRequestParams.hpp (51%) create mode 100644 module-services/service-time/tests/tests-AlarmOperations.hpp diff --git a/module-apps/apps-common/ApplicationCommon.cpp b/module-apps/apps-common/ApplicationCommon.cpp index 4eaea929aea112e9a74ec57007f93f4673fef193..fa635b316ff5f97d1c41d2e20d7f7c01d39a015c 100644 --- a/module-apps/apps-common/ApplicationCommon.cpp +++ b/module-apps/apps-common/ApplicationCommon.cpp @@ -2,7 +2,7 @@ // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md #include "ApplicationCommon.hpp" -#include "GuiTimer.hpp" // for GuiTimer +#include "GuiTimer.hpp" // for GuiTimer #include "Timers/TimerFactory.hpp" // for Timer #include "status-bar/Time.hpp" #include "messages/AppSwitchWindowPopupMessage.hpp" diff --git a/module-apps/apps-common/ApplicationCommonPopupBlueprints.cpp b/module-apps/apps-common/ApplicationCommonPopupBlueprints.cpp index 16508a3776be6b7830c466dab980bf51bf55bf2c..e2face32f6ff58320122d10991d83d277ae6bad9 100644 --- a/module-apps/apps-common/ApplicationCommonPopupBlueprints.cpp +++ b/module-apps/apps-common/ApplicationCommonPopupBlueprints.cpp @@ -7,6 +7,7 @@ #include "service-db/Settings.hpp" #include "service-db/agents/settings/SystemSettings.hpp" #include "popups/data/PopupData.hpp" +#include "popups/data/BedtimeReminderPopupRequestParams.hpp" namespace app { @@ -132,6 +133,19 @@ namespace app std::make_unique(popupParams)); return true; }); + + popupBlueprint.registerBlueprint( + ID::BedtimeNotification, [&](gui::popup::ID id, std::unique_ptr ¶ms) { + auto popupParams = dynamic_cast(params.get()); + if (popupParams == nullptr) { + return false; + } + + switchWindowPopup(gui::popup::resolveWindowName(id), + params->getDisposition(), + std::make_unique(popupParams->eventRecord)); + return true; + }); } std::optional ApplicationCommon::popupBlueprintFallback(gui::popup::ID id) diff --git a/module-apps/apps-common/CMakeLists.txt b/module-apps/apps-common/CMakeLists.txt index ec230872bfe6dd54f7ef5f86b8c1137d5b3b2d67..fd7294c528491cf21d5d7d60d333f4e2ba924d82 100644 --- a/module-apps/apps-common/CMakeLists.txt +++ b/module-apps/apps-common/CMakeLists.txt @@ -75,6 +75,7 @@ target_sources(apps-common widgets/TimeSetFmtSpinner.hpp actions/AlarmRingingData.hpp actions/AlarmTriggeredAction.hpp + popups/data/BedtimeReminderPopupRequestParams.hpp models/SongContext.hpp models/SongsRepository.hpp diff --git a/products/BellHybrid/alarms/include/popups/BedtimeReminderPopupRequestParams.hpp b/module-apps/apps-common/popups/data/BedtimeReminderPopupRequestParams.hpp similarity index 51% rename from products/BellHybrid/alarms/include/popups/BedtimeReminderPopupRequestParams.hpp rename to module-apps/apps-common/popups/data/BedtimeReminderPopupRequestParams.hpp index 22a592e4e13298d7b1ccb6f5a07d61f187efc726..ba0c2bd408b9bb5f0ef542dcc0e3bab9d58e613f 100644 --- a/products/BellHybrid/alarms/include/popups/BedtimeReminderPopupRequestParams.hpp +++ b/module-apps/apps-common/popups/data/BedtimeReminderPopupRequestParams.hpp @@ -1,16 +1,20 @@ -// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// Copyright (c) 2017-2022, Mudita Sp. z.o.o. All rights reserved. // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md #pragma once #include +#include namespace gui { class BedtimeReminderPopupRequestParams : public PopupRequestParams { public: - BedtimeReminderPopupRequestParams() : PopupRequestParams{gui::popup::ID::BedtimeNotification} + BedtimeReminderPopupRequestParams(Record record) + : PopupRequestParams{gui::popup::ID::BedtimeNotification}, eventRecord{record} {} + + Record eventRecord; }; } // namespace gui diff --git a/module-services/service-time/AlarmOperations.cpp b/module-services/service-time/AlarmOperations.cpp index 00a6c4685b446731c1cf66df1c4cf00d61d4cf18..92bdf6aed9aa31853ed90873f70408dd406aab01 100644 --- a/module-services/service-time/AlarmOperations.cpp +++ b/module-services/service-time/AlarmOperations.cpp @@ -1,4 +1,4 @@ -// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// Copyright (c) 2017-2022, Mudita Sp. z.o.o. All rights reserved. // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md #include "AlarmOperations.hpp" @@ -128,18 +128,13 @@ namespace alarms void AlarmOperationsCommon::turnOffRingingAlarm(const std::uint32_t id, OnTurnOffRingingAlarm callback) { - auto found = findSingleEventById(ongoingSingleEvents, id); - if (found == ongoingSingleEvents.end()) { - LOG_ERROR("Trying to turn off nonexisting event"); + bool ongoingEventsResult = turnOffAlarmIfFoundInOngoingEvents(id); + bool bedtimeEventsResult = turnOffAlarmIfFoundInBedtime(id); + if (not ongoingEventsResult and not bedtimeEventsResult) { + LOG_ERROR("Trying to turn off nonexisting event ID %d", static_cast(id)); callback(false); - return; } - switchAlarmExecution(*(*found), false); - ongoingSingleEvents.erase(found); - processOngoingEvents(); - - handleActiveAlarmsCountChange(); callback(true); } @@ -338,6 +333,26 @@ namespace alarms } } + bool AlarmOperationsCommon::turnOffAlarmIfFoundInOngoingEvents(std::uint32_t id) + { + auto found = findSingleEventById(ongoingSingleEvents, id); + if (found == ongoingSingleEvents.end()) { + return false; + } + + switchAlarmExecution(*(*found), false); + ongoingSingleEvents.erase(found); + processOngoingEvents(); + handleActiveAlarmsCountChange(); + + return true; + } + + bool AlarmOperationsCommon::turnOffAlarmIfFoundInBedtime(const std::uint32_t id) + { + return false; + } + void AlarmOperationsCommon::onAlarmTurnedOff(const std::shared_ptr &event, alarms::AlarmType alarmType) {} @@ -433,15 +448,16 @@ namespace alarms callback(std::move(snoozedEvents)); } - auto findSingleEventById(std::vector> &events, const std::uint32_t id) - -> std::vector>::iterator + auto findSingleEventById(EventsContainer &events, const std::uint32_t id) + -> EventsContainer::iterator { return std::find_if(events.begin(), events.end(), [id](const std::unique_ptr &event) { return id == event->parent->ID; }); } - auto findSnoozedEventById(std::vector> &events, const std::uint32_t id) - -> std::vector>::iterator + + auto findSnoozedEventById(EventsContainer &events, const std::uint32_t id) + -> EventsContainer::iterator { return std::find_if(events.begin(), events.end(), [id](const std::unique_ptr &event) { return id == event->parent->ID; diff --git a/module-services/service-time/AlarmOperations.hpp b/module-services/service-time/AlarmOperations.hpp index 506a9e0f5cd17858c3deb08e1c1c8bf00f92f5cc..e9d268d418a365f7c423bec99f9fccf0df5daa17 100644 --- a/module-services/service-time/AlarmOperations.hpp +++ b/module-services/service-time/AlarmOperations.hpp @@ -15,6 +15,8 @@ namespace alarms { + template using EventsContainer = std::vector>; + class IAlarmOperations { public: @@ -114,14 +116,17 @@ namespace alarms AlarmHandlerFactory alarmHandlerFactory; // Events we are waiting for (on one timepoint) - std::vector> nextSingleEvents; - std::vector> ongoingSingleEvents; - std::vector> snoozedSingleEvents; + EventsContainer nextSingleEvents; + EventsContainer ongoingSingleEvents; + EventsContainer snoozedSingleEvents; alarms::AlarmType getAlarmEventType(const SingleEventRecord &event); virtual void handleAlarmEvent(const std::shared_ptr &event, alarms::AlarmType alarmType, bool newStateOn); + virtual bool turnOffAlarmIfFoundInBedtime(std::uint32_t id); + bool turnOffAlarmIfFoundInOngoingEvents(std::uint32_t id); + void switchAlarmExecution(const SingleEventRecord &singleAlarmEvent, bool newStateOn); private: GetCurrentTime getCurrentTimeCallback; @@ -139,7 +144,6 @@ namespace alarms std::vector records, OnGetAlarmsProcessed handledCallback); void checkAndUpdateCache(AlarmEventRecord record); - void switchAlarmExecution(const SingleEventRecord &singleAlarmEvent, bool newStateOn); void processEvents(TimePoint now); void processOngoingEvents(); void processNextEventsQueue(const TimePoint now); @@ -160,8 +164,8 @@ namespace alarms IAlarmOperations::GetCurrentTime getCurrentTimeCallback) const override; }; - auto findSingleEventById(std::vector> &events, const std::uint32_t id) - -> std::vector>::iterator; - auto findSnoozedEventById(std::vector> &events, const std::uint32_t id) - -> std::vector>::iterator; + auto findSingleEventById(EventsContainer &events, const std::uint32_t id) + -> EventsContainer::iterator; + auto findSnoozedEventById(EventsContainer &events, const std::uint32_t id) + -> EventsContainer::iterator; } // namespace alarms diff --git a/module-services/service-time/tests/CMakeLists.txt b/module-services/service-time/tests/CMakeLists.txt index 7a16adcae08c2cd6123f3ed917d4a7c04a9325ed..c69fd0f2bd5c5babc6236ba01dc99a358339edb6 100644 --- a/module-services/service-time/tests/CMakeLists.txt +++ b/module-services/service-time/tests/CMakeLists.txt @@ -19,16 +19,25 @@ add_catch2_executable( module-db ) -add_gtest_executable( - NAME - service-time-alarm-operations - SRCS - tests-AlarmOperations.cpp - LIBS +add_library(service-time-alarm-operations-source OBJECT + tests-AlarmOperations.cpp) + +target_link_libraries(service-time-alarm-operations-source + PUBLIC module-sys service-time - INCLUDE - $ - DEFS - COMMON_ALARM_OPERATIONS_TEST + gtest_main + gmock + log-api) + +target_include_directories(service-time-alarm-operations-source + PUBLIC + $) + +add_executable(googletest-service-time-alarm-operations) +target_link_libraries(googletest-service-time-alarm-operations + PUBLIC + service-time-alarm-operations-source ) + +add_gtest_manually_prepared_target(NAME googletest-service-time-alarm-operations) diff --git a/module-services/service-time/tests/tests-AlarmOperations.cpp b/module-services/service-time/tests/tests-AlarmOperations.cpp index 4c9b46a52a06460049af96e9d83528ee0f1b6a6d..1157376dfbc573e89c2eace9c678929971e02999 100644 --- a/module-services/service-time/tests/tests-AlarmOperations.cpp +++ b/module-services/service-time/tests/tests-AlarmOperations.cpp @@ -1,123 +1,22 @@ -// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// Copyright (c) 2017-2022, Mudita Sp. z.o.o. All rights reserved. // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md -#include -#include -#include - -#include - -#include -#include - -class MockAlarmHandler : public alarms::AlarmHandler -{ - public: - MOCK_METHOD(bool, handle, (const AlarmEventRecord &record), ()); - MOCK_METHOD(bool, handleOff, (const AlarmEventRecord &record), ()); -}; - -class MockAlarmEventsRepository : public alarms::AbstractAlarmEventsRepository -{ - public: - std::vector nextRecords; - - MOCK_METHOD(void, - getAlarmEvent, - (const std::uint32_t alarmId, const alarms::OnGetAlarmEventCallback &callback), - ()); - MOCK_METHOD(void, - getAlarmEvents, - (std::uint32_t offset, std::uint32_t limit, const alarms::OnGetAlarmEventsCallback &callback), - ()); - MOCK_METHOD(void, toggleAll, (const bool toggle, const alarms::OnToggleAll &callback), ()); - - auto addAlarmEvent(const AlarmEventRecord &alarmEvent, const alarms::OnAddAlarmEventCallback &callback) -> void - { - addSingleEvent(alarmEvent); - callback({true}); - } - - auto updateAlarmEvent(const AlarmEventRecord &alarmEvent, const alarms::OnAddAlarmEventCallback &callback) -> void - { - nextRecords.erase(std::remove_if(nextRecords.begin(), - nextRecords.end(), - [&alarmEvent](const AlarmEventRecord &ae) { return ae.ID == alarmEvent.ID; }), - nextRecords.end()); - addSingleEvent(alarmEvent); - callback({true}); - } - auto removeAlarmEvent(const std::uint32_t alarmId, const alarms::OnRemoveAlarmEventCallback &callback) -> void - { - nextRecords.erase(std::remove_if(nextRecords.begin(), - nextRecords.end(), - [&alarmId](const AlarmEventRecord &ae) { return ae.ID == alarmId; }), - nextRecords.end()); - callback({true}); - } - - void getAlarmEventsInRange(std::uint32_t offset, - std::uint32_t limit, - const alarms::OnGetAlarmEventsInRangeCallback &callback) - { - callback({nextRecords, nextRecords.size()}); - } - - void getAlarmEnabledEvents(const alarms::OnGetAlarmEventsCallback &callback) - { - std::vector result; - for (const auto &rec : nextRecords) { - if (rec.enabled) { - result.push_back(rec); - } - } - callback({result}); - } - - void addSingleEvent(const AlarmEventRecord record) - { - nextRecords.push_back(record); - } -}; - -/// Time point from string with current test machine time shift -TimePoint TimePointFromStringWithShift(std::string timeString) -{ - const auto timeToCalc = TimePointFromString("2000-01-01 12:00:00"); - const auto fromTimeT = std::chrono::system_clock::to_time_t(timeToCalc); - const auto fromLocal = std::localtime(&fromTimeT); - fromLocal->tm_hour = 12; - fromLocal->tm_min = 0; - auto time = TimePointFloorMinutes(std::chrono::system_clock::from_time_t(std::mktime(fromLocal))); - auto currentTimeShift = timeToCalc - time; - - return TimePointFromString(timeString.c_str()) - currentTimeShift; -} - -alarms::IAlarmOperations::GetCurrentTime timeInjector = []() { - return TimePointFromStringWithShift("2022-11-11 05:00:00"); -}; -alarms::IAlarmOperations::OnUpdateAlarmProcessed universalBoolCallback = [](bool success) { EXPECT_EQ(success, true); }; - -class AlarmOperationsFixture : public ::testing::Test +#include "tests-AlarmOperations.hpp" +namespace { - protected: - std::unique_ptr getMockedAlarmOperations( - std::unique_ptr &alarmRepo); -}; + alarms::IAlarmOperations::OnUpdateAlarmProcessed universalBoolCallback = [](bool success) { + EXPECT_EQ(success, true); + }; + alarms::IAlarmOperations::GetCurrentTime timeInjector = []() { + return TimePointFromStringWithShift("2022-11-11 05:00:00"); + }; +} // namespace -#if defined COMMON_ALARM_OPERATIONS_TEST std::unique_ptr AlarmOperationsFixture::getMockedAlarmOperations( std::unique_ptr &alarmRepo) { return std::make_unique(std::move(alarmRepo), timeInjector); } -#endif - -constexpr auto defRRule = ""; -constexpr auto defMusic = ""; -constexpr auto defEnabled = true; -constexpr auto defSnooze = 15; TEST_F(AlarmOperationsFixture, getEnabledEvents) { diff --git a/module-services/service-time/tests/tests-AlarmOperations.hpp b/module-services/service-time/tests/tests-AlarmOperations.hpp new file mode 100644 index 0000000000000000000000000000000000000000..f9d9db274a647780a5205300c0d4d4ac130eee92 --- /dev/null +++ b/module-services/service-time/tests/tests-AlarmOperations.hpp @@ -0,0 +1,110 @@ +// Copyright (c) 2017-2022, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md +#pragma once + +#include +#include +#include +#include +#include +#include + +class MockAlarmHandler : public alarms::AlarmHandler +{ + public: + MOCK_METHOD(bool, handle, (const AlarmEventRecord &record), ()); + MOCK_METHOD(bool, handleOff, (const AlarmEventRecord &record), ()); +}; + +class MockAlarmEventsRepository : public alarms::AbstractAlarmEventsRepository +{ + public: + std::vector nextRecords; + + MOCK_METHOD(void, + getAlarmEvent, + (const std::uint32_t alarmId, const alarms::OnGetAlarmEventCallback &callback), + ()); + MOCK_METHOD(void, + getAlarmEvents, + (std::uint32_t offset, std::uint32_t limit, const alarms::OnGetAlarmEventsCallback &callback), + ()); + MOCK_METHOD(void, toggleAll, (const bool toggle, const alarms::OnToggleAll &callback), ()); + + auto addAlarmEvent(const AlarmEventRecord &alarmEvent, const alarms::OnAddAlarmEventCallback &callback) -> void + { + addSingleEvent(alarmEvent); + callback({true}); + } + + auto updateAlarmEvent(const AlarmEventRecord &alarmEvent, const alarms::OnAddAlarmEventCallback &callback) -> void + { + nextRecords.erase(std::remove_if(nextRecords.begin(), + nextRecords.end(), + [&alarmEvent](const AlarmEventRecord &ae) { return ae.ID == alarmEvent.ID; }), + nextRecords.end()); + addSingleEvent(alarmEvent); + callback({true}); + } + auto removeAlarmEvent(const std::uint32_t alarmId, const alarms::OnRemoveAlarmEventCallback &callback) -> void + { + nextRecords.erase(std::remove_if(nextRecords.begin(), + nextRecords.end(), + [&alarmId](const AlarmEventRecord &ae) { return ae.ID == alarmId; }), + nextRecords.end()); + callback({true}); + } + + void getAlarmEventsInRange(std::uint32_t offset, + std::uint32_t limit, + const alarms::OnGetAlarmEventsInRangeCallback &callback) + { + callback({nextRecords, nextRecords.size()}); + } + + void getAlarmEnabledEvents(const alarms::OnGetAlarmEventsCallback &callback) + { + std::vector result; + for (const auto &rec : nextRecords) { + if (rec.enabled) { + result.push_back(rec); + } + } + callback({result}); + } + + void addSingleEvent(const AlarmEventRecord record) + { + nextRecords.push_back(record); + } +}; + +namespace +{ + /// Time point from string with current test machine time shift + TimePoint TimePointFromStringWithShift(std::string timeString) + { + const auto timeToCalc = TimePointFromString("2000-01-01 12:00:00"); + const auto fromTimeT = std::chrono::system_clock::to_time_t(timeToCalc); + const auto fromLocal = std::localtime(&fromTimeT); + fromLocal->tm_hour = 12; + fromLocal->tm_min = 0; + auto time = TimePointFloorMinutes(std::chrono::system_clock::from_time_t(std::mktime(fromLocal))); + auto currentTimeShift = timeToCalc - time; + + return TimePointFromString(timeString.c_str()) - currentTimeShift; + } + +} // namespace + +class AlarmOperationsFixture : public ::testing::Test +{ + protected: + virtual std::unique_ptr getMockedAlarmOperations( + std::unique_ptr &alarmRepo); +}; + +constexpr auto defRRule = ""; +constexpr auto defMusic = ""; +constexpr auto defEnabled = true; +constexpr auto defSnooze = 15; diff --git a/products/BellHybrid/alarms/BellAlarmHandler.cpp b/products/BellHybrid/alarms/BellAlarmHandler.cpp index 1fc9818e45be796637e756bed2cd98edd5986484..76200e586ceb447440eb626c8fb2882865d49077 100644 --- a/products/BellHybrid/alarms/BellAlarmHandler.cpp +++ b/products/BellHybrid/alarms/BellAlarmHandler.cpp @@ -17,7 +17,7 @@ namespace alarms auto result{true}; if (record.enabled) { for (const auto &action : actions) { - result &= action->execute(); + result &= action->execute(record.ID); } } return result; diff --git a/products/BellHybrid/alarms/CMakeLists.txt b/products/BellHybrid/alarms/CMakeLists.txt index 94e41c2573aad065c0cd062012c6b0107462057f..a3c20de642f367b49d08433112eedeb19a8593cf 100644 --- a/products/BellHybrid/alarms/CMakeLists.txt +++ b/products/BellHybrid/alarms/CMakeLists.txt @@ -20,7 +20,6 @@ target_sources(alarms include/AlarmSoundPaths.hpp include/popups/AlarmActivatedPopupRequestParams.hpp include/popups/AlarmDeactivatedPopupRequestParams.hpp - include/popups/BedtimeReminderPopupRequestParams.hpp ) target_include_directories(alarms diff --git a/products/BellHybrid/alarms/include/AbstractAlarmAction.hpp b/products/BellHybrid/alarms/include/AbstractAlarmAction.hpp index 6390ae96969a4b5988425e76586d15cc051978ed..33fa928ab464d5a28345d95336d7b6eedb69f085 100644 --- a/products/BellHybrid/alarms/include/AbstractAlarmAction.hpp +++ b/products/BellHybrid/alarms/include/AbstractAlarmAction.hpp @@ -1,15 +1,18 @@ -// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// Copyright (c) 2017-2022, Mudita Sp. z.o.o. All rights reserved. // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md #pragma once +#include +#include + namespace alarms { class AbstractAlarmAction { public: - virtual ~AbstractAlarmAction() = default; - virtual bool execute() = 0; - virtual bool turnOff() = 0; + virtual ~AbstractAlarmAction() = default; + virtual bool execute(Record record) = 0; + virtual bool turnOff() = 0; }; } // namespace alarms diff --git a/products/BellHybrid/alarms/src/actions/FrontlightAction.cpp b/products/BellHybrid/alarms/src/actions/FrontlightAction.cpp index 5583e661c360204510cdd05d61010ef52e47792f..bf4ac853f8a9ef038887f9aa868e740b7fc7f5b7 100644 --- a/products/BellHybrid/alarms/src/actions/FrontlightAction.cpp +++ b/products/BellHybrid/alarms/src/actions/FrontlightAction.cpp @@ -18,7 +18,7 @@ namespace alarms { public: explicit ManualFrontlightAction(sys::Service &service); - bool execute() override; + bool execute(Record record) override; bool turnOff() override; private: @@ -31,7 +31,7 @@ namespace alarms { public: explicit LinearProgressFrontlightAction(sys::Service &service); - bool execute() override; + bool execute(Record record) override; bool turnOff() override; private: @@ -60,7 +60,7 @@ namespace alarms service::ServiceProxy{service.weak_from_this()}} {} - bool FrontlightAction::execute() + bool FrontlightAction::execute([[maybe_unused]] Record record) { std::string settingString; @@ -84,7 +84,7 @@ namespace alarms case SettingsDependency::None: break; } - return pimpl->execute(); + return pimpl->execute(record); } bool FrontlightAction::turnOff() @@ -109,7 +109,7 @@ namespace alarms ManualFrontlightAction::ManualFrontlightAction(sys::Service &service) : service{service} {} - bool ManualFrontlightAction::execute() + bool ManualFrontlightAction::execute([[maybe_unused]] Record record) { auto params = prepareParameters(); service.bus.sendUnicast(std::make_shared( @@ -136,7 +136,7 @@ namespace alarms settings.init(service::ServiceProxy{service.weak_from_this()}); } - bool LinearProgressFrontlightAction::execute() + bool LinearProgressFrontlightAction::execute([[maybe_unused]] Record record) { const auto params = prepareParameters(); service.bus.sendUnicast(std::make_shared(params), @@ -155,9 +155,9 @@ namespace alarms return screen_light_control::LinearProgressModeParameters{ .startBrightnessValue = 0.0f, .functions = {screen_light_control::functions::LinearProgressFunction{.target = 10.0f, - .duration = firstTargetDuration}, + .duration = firstTargetDuration}, screen_light_control::functions::LinearProgressFunction{.target = 100.0f, - .duration = secondTargetDuration}}, + .duration = secondTargetDuration}}, .brightnessHysteresis = 0.0f}; } diff --git a/products/BellHybrid/alarms/src/actions/FrontlightAction.hpp b/products/BellHybrid/alarms/src/actions/FrontlightAction.hpp index 33f34417f804f55a9599adf9b14e884fc901049e..8dcbc018ddd0a3c0b4b979bd6da36ef012fc1939 100644 --- a/products/BellHybrid/alarms/src/actions/FrontlightAction.hpp +++ b/products/BellHybrid/alarms/src/actions/FrontlightAction.hpp @@ -29,7 +29,7 @@ namespace alarms FrontlightAction(sys::Service &service, Mode mode, SettingsDependency settingsDependency = SettingsDependency::None); - bool execute() override; + bool execute(Record record) override; bool turnOff() override; private: diff --git a/products/BellHybrid/alarms/src/actions/NotifyGUIAction.cpp b/products/BellHybrid/alarms/src/actions/NotifyGUIAction.cpp index 3969f331e1d26ab0b5b0d770d787842b22f846f5..37dbae4ec7fd528fb8801d319c9314429ab4622f 100644 --- a/products/BellHybrid/alarms/src/actions/NotifyGUIAction.cpp +++ b/products/BellHybrid/alarms/src/actions/NotifyGUIAction.cpp @@ -1,4 +1,4 @@ -// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// Copyright (c) 2017-2022, Mudita Sp. z.o.o. All rights reserved. // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md #include "NotifyGUIAction.hpp" @@ -10,7 +10,7 @@ namespace alarms { NotifyGUIAction::NotifyGUIAction(sys::Service &service) : service{service} {} - bool NotifyGUIAction::execute() + bool NotifyGUIAction::execute([[maybe_unused]] Record record) { return service.bus.sendUnicast(std::make_shared(), service::name::appmgr); } diff --git a/products/BellHybrid/alarms/src/actions/NotifyGUIAction.hpp b/products/BellHybrid/alarms/src/actions/NotifyGUIAction.hpp index f4f68eccae642bebafea9e169ac925ae106b386e..69aff8420d5556b046c34fae86e8b7336791dee0 100644 --- a/products/BellHybrid/alarms/src/actions/NotifyGUIAction.hpp +++ b/products/BellHybrid/alarms/src/actions/NotifyGUIAction.hpp @@ -1,4 +1,4 @@ -// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// Copyright (c) 2017-2022, Mudita Sp. z.o.o. All rights reserved. // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md #pragma once @@ -13,7 +13,7 @@ namespace alarms { public: explicit NotifyGUIAction(sys::Service &service); - bool execute() override; + bool execute(Record record) override; bool turnOff() override; private: diff --git a/products/BellHybrid/alarms/src/actions/NotifyGUIBedtimeReminderAction.cpp b/products/BellHybrid/alarms/src/actions/NotifyGUIBedtimeReminderAction.cpp index 6045756c3c4c1e1214ed0fa90660223e237a137c..4b6510eba53640fe0de59289bcc7c4098398b972 100644 --- a/products/BellHybrid/alarms/src/actions/NotifyGUIBedtimeReminderAction.cpp +++ b/products/BellHybrid/alarms/src/actions/NotifyGUIBedtimeReminderAction.cpp @@ -1,4 +1,4 @@ -// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// Copyright (c) 2017-2022, Mudita Sp. z.o.o. All rights reserved. // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md #include "NotifyGUIBedtimeReminderAction.hpp" @@ -10,10 +10,12 @@ namespace alarms { NotifyGUIBedtimeReminderAction::NotifyGUIBedtimeReminderAction(sys::Service &service) : service{service} {} - bool NotifyGUIBedtimeReminderAction::execute() + + bool NotifyGUIBedtimeReminderAction::execute(Record record) { - return service.bus.sendUnicast(std::make_shared(), service::name::appmgr); + return service.bus.sendUnicast(std::make_shared(record), service::name::appmgr); } + bool NotifyGUIBedtimeReminderAction::turnOff() { return true; diff --git a/products/BellHybrid/alarms/src/actions/NotifyGUIBedtimeReminderAction.hpp b/products/BellHybrid/alarms/src/actions/NotifyGUIBedtimeReminderAction.hpp index 0684cfdf76961de5c36385d751d7792531b60c4c..02ac88f658495fa1ff67ea5097cac809c0ac760b 100644 --- a/products/BellHybrid/alarms/src/actions/NotifyGUIBedtimeReminderAction.hpp +++ b/products/BellHybrid/alarms/src/actions/NotifyGUIBedtimeReminderAction.hpp @@ -1,4 +1,4 @@ -// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// Copyright (c) 2017-2022, Mudita Sp. z.o.o. All rights reserved. // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md #pragma once @@ -13,7 +13,7 @@ namespace alarms { public: explicit NotifyGUIBedtimeReminderAction(sys::Service &service); - bool execute() override; + bool execute(Record record) override; bool turnOff() override; private: diff --git a/products/BellHybrid/alarms/src/actions/PlayAudioActions.cpp b/products/BellHybrid/alarms/src/actions/PlayAudioActions.cpp index c393ae9d110015abf513563a82df22cd41ade048..41b9aa911a359da7bfde28e3c9386aa8cceef7f7 100644 --- a/products/BellHybrid/alarms/src/actions/PlayAudioActions.cpp +++ b/products/BellHybrid/alarms/src/actions/PlayAudioActions.cpp @@ -1,4 +1,4 @@ -// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// Copyright (c) 2017-2022, Mudita Sp. z.o.o. All rights reserved. // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md #include "AlarmSoundPaths.hpp" @@ -35,7 +35,7 @@ namespace alarms const auto msg = std::make_shared(stopPlaybackVec); return service.bus.sendUnicast(msg, service::audioServiceName); } - bool PlayAudioAction::execute() + bool PlayAudioAction::execute([[maybe_unused]] Record record) { const auto tone = settings.getValue(toneSetting, settings::SettingsScope::Global); std::optional duration{}; diff --git a/products/BellHybrid/alarms/src/actions/PlayAudioActions.hpp b/products/BellHybrid/alarms/src/actions/PlayAudioActions.hpp index d47b7b2920db3245f04d5d351e8c685a0dd4e436..caa392afa94aefa410a6a6b3e80364a0d1028828 100644 --- a/products/BellHybrid/alarms/src/actions/PlayAudioActions.hpp +++ b/products/BellHybrid/alarms/src/actions/PlayAudioActions.hpp @@ -1,4 +1,4 @@ -// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// Copyright (c) 2017-2022, Mudita Sp. z.o.o. All rights reserved. // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md #pragma once @@ -19,7 +19,7 @@ namespace alarms { public: bool turnOff() override; - bool execute() override; + bool execute(Record record) override; explicit PlayAudioAction(sys::Service &service, const std::filesystem::path &tonesDirPath, std::string_view toneSetting, diff --git a/products/BellHybrid/apps/application-bell-bedtime/presenter/BellBedtimeWindowPresenter.hpp b/products/BellHybrid/apps/application-bell-bedtime/presenter/BellBedtimeWindowPresenter.hpp index caaa1ebf5cc0ee81d49e0a9dbc6e3c4dfdba909f..854299d2fbbc12906f0e361cf8edd947da867b6b 100644 --- a/products/BellHybrid/apps/application-bell-bedtime/presenter/BellBedtimeWindowPresenter.hpp +++ b/products/BellHybrid/apps/application-bell-bedtime/presenter/BellBedtimeWindowPresenter.hpp @@ -30,8 +30,8 @@ namespace app::bell_bedtime class View { public: - virtual ~View() noexcept = default; - virtual void exit() = 0; + virtual ~View() noexcept = default; + virtual void exit() = 0; }; class AbstractBedtimePresenter : public BasePresenter diff --git a/products/BellHybrid/apps/common/CMakeLists.txt b/products/BellHybrid/apps/common/CMakeLists.txt index 625b4bec38c2ab7bff51d8e401f1c27dfa57c47c..76f316a26857329e1b37e64389f41efc34dd361c 100644 --- a/products/BellHybrid/apps/common/CMakeLists.txt +++ b/products/BellHybrid/apps/common/CMakeLists.txt @@ -128,6 +128,7 @@ target_link_libraries(application-bell-common module-gui bell::db Microsoft.GSL::GSL + bell::alarms ) if (${ENABLE_TESTS}) diff --git a/products/BellHybrid/apps/common/include/common/data/BatteryUtils.hpp b/products/BellHybrid/apps/common/include/common/data/BatteryUtils.hpp index 6fc03c43893e4be4e51128856e38260a8228698d..77a840e3c8db2a27e70130f0e26279e72e3883a1 100644 --- a/products/BellHybrid/apps/common/include/common/data/BatteryUtils.hpp +++ b/products/BellHybrid/apps/common/include/common/data/BatteryUtils.hpp @@ -7,6 +7,7 @@ #include #include #include +#include #include diff --git a/products/BellHybrid/apps/common/include/common/models/BedtimeModel.hpp b/products/BellHybrid/apps/common/include/common/models/BedtimeModel.hpp index bc536f2ea3a3aaf09e60cfdd9a3636a350505cb7..886bd243caa0327de23e7a40ba3ed0eaf16d9216 100644 --- a/products/BellHybrid/apps/common/include/common/models/BedtimeModel.hpp +++ b/products/BellHybrid/apps/common/include/common/models/BedtimeModel.hpp @@ -1,4 +1,4 @@ -// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// Copyright (c) 2017-2022, Mudita Sp. z.o.o. All rights reserved. // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md #pragma once diff --git a/products/BellHybrid/apps/common/include/common/popups/BedtimeNotificationWindow.hpp b/products/BellHybrid/apps/common/include/common/popups/BedtimeNotificationWindow.hpp index f3dfafb0d3cbf7cac19eff37d2fb3236c0fe9099..882a597c2a4f742cab85609344d8fc342065fc36 100644 --- a/products/BellHybrid/apps/common/include/common/popups/BedtimeNotificationWindow.hpp +++ b/products/BellHybrid/apps/common/include/common/popups/BedtimeNotificationWindow.hpp @@ -1,4 +1,4 @@ -// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// Copyright (c) 2017-2022, Mudita Sp. z.o.o. All rights reserved. // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md #pragma once @@ -23,11 +23,14 @@ namespace gui app::ApplicationCommon *app; Icon *icon = nullptr; + Record currentEventRecord; bool onInput(const InputEvent &inputEvent) override; void returnToPreviousWindow(); void buildInterface() override; public: + bool handleSwitchData(gui::SwitchData *data) override; + explicit BedtimeNotificationWindow(app::ApplicationCommon *app); void onBeforeShow(ShowMode mode, SwitchData *data) override; }; diff --git a/products/BellHybrid/apps/common/src/popups/BedtimeNotificationWindow.cpp b/products/BellHybrid/apps/common/src/popups/BedtimeNotificationWindow.cpp index ad964ad3e2cc40969578b7fdaa1baaf8cad1ba2c..88117b8d924a10b596fd9f44b8ca0f85b16771ac 100644 --- a/products/BellHybrid/apps/common/src/popups/BedtimeNotificationWindow.cpp +++ b/products/BellHybrid/apps/common/src/popups/BedtimeNotificationWindow.cpp @@ -1,15 +1,17 @@ -// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// Copyright (c) 2017-2022, Mudita Sp. z.o.o. All rights reserved. // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md #include