5 files changed, 71 insertions(+), 11 deletions(-)

M harmony_changelog.md
M products/BellHybrid/apps/application-bell-onboarding/include/application-bell-onboarding/ApplicationBellOnBoarding.hpp
M products/BellHybrid/services/time/AlarmOperations.cpp
M products/BellHybrid/services/time/include/time/AlarmOperations.hpp
M products/BellHybrid/services/time/tests/test-BellAlarmOperations.cpp

@@ 6,6 6,7 @@
 * Fixed frequency lock during user activity
 * Fixed boot error screen text alignment
 * Fixed eink errors in logs
+* Fixed alarm when the onboarding is in progress
 
 ### Added
 * Added notification when charger is connected

@@ 44,7 44,7 @@ namespace app
                                            std::string parent                  = "",
                                            StatusIndicators statusIndicators   = StatusIndicators{},
                                            StartInBackground startInBackground = {false},
-                                           std::uint32_t stackDepth            = 1024 * 8);
+                                           std::uint32_t stackDepth            = 1024 * 11);
         ~ApplicationBellOnBoarding();
 
         sys::ReturnCodes InitHandler() override;

@@ 1,13 1,11 @@
 // Copyright (c) 2017-2023, Mudita Sp. z.o.o. All rights reserved.
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
-#include <time/AlarmOperations.hpp>
-
 #include <BellAlarmHandler.hpp>
 
-#include <service-db/Settings.hpp>
-#include <db/SystemSettings.hpp>
+#include <time/AlarmOperations.hpp>
 #include <time/dateCommon.hpp>
+#include <service-db/agents/settings/SystemSettings.hpp>
 
 #include <string>
 


@@ 82,10 80,7 @@ namespace alarms
             std::unique_ptr<app::bell_bedtime::BedtimeTimeModel> bedtimeTimeModel;
             settings::Settings settings;
         };
-    } // namespace
 
-    namespace
-    {
         class SnoozeChimeSettingsProviderImpl : public SnoozeChimeSettingsProvider
         {
           public:


@@ 113,6 108,28 @@ namespace alarms
                 return {true, std::chrono::minutes{interval}};
             }
         }
+
+        class OnboardingSettingsProviderImpl : public OnboardingSettingsProvider
+        {
+          public:
+            explicit OnboardingSettingsProviderImpl(sys::Service *service);
+            auto isDone() -> bool override;
+
+          private:
+            settings::Settings settings;
+        };
+
+        OnboardingSettingsProviderImpl::OnboardingSettingsProviderImpl(sys::Service *service)
+        {
+            settings.init(service::ServiceProxy{service->weak_from_this()});
+        }
+
+        auto OnboardingSettingsProviderImpl::isDone() -> bool
+        {
+            return utils::getNumericValue<bool>(
+                settings.getValue(settings::SystemProperties::onboardingDone, settings::SettingsScope::Global));
+        }
+
     } // namespace
 
     std::unique_ptr<IAlarmOperations> AlarmOperationsFactory::create(


@@ 122,11 139,13 @@ namespace alarms
     {
         auto preWakeUpSettingsProvider   = std::make_unique<PreWakeUpSettingsProviderImpl>(service);
         auto snoozeChimeSettingsProvider = std::make_unique<SnoozeChimeSettingsProviderImpl>(service);
+        auto onboardingSettingsProvider  = std::make_unique<OnboardingSettingsProviderImpl>(service);
         auto bedtimeSettingsProvider     = std::make_unique<BedtimeSettingsProviderImpl>(service);
         auto alarmOperations             = std::make_unique<AlarmOperations>(std::move(alarmEventsRepo),
                                                                  getCurrentTimeCallback,
                                                                  std::move(preWakeUpSettingsProvider),
                                                                  std::move(snoozeChimeSettingsProvider),
+                                                                 std::move(onboardingSettingsProvider),
                                                                  std::move(bedtimeSettingsProvider));
         alarmOperations->addAlarmExecutionHandler(alarms::AlarmType::Clock,
                                                   std::make_shared<alarms::BellAlarmClockHandler>(service));


@@ 146,14 165,19 @@ namespace alarms
                                      GetCurrentTime getCurrentTimeCallback,
                                      std::unique_ptr<PreWakeUpSettingsProvider> &&preWakeUpSettingsProvider,
                                      std::unique_ptr<SnoozeChimeSettingsProvider> &&snoozeChimeSettings,
+                                     std::unique_ptr<OnboardingSettingsProvider> &&onboardingSettings,
                                      std::unique_ptr<AbstractBedtimeSettingsProvider> &&bedtimeSettingsProvider)
         : AlarmOperationsCommon{std::move(alarmEventsRepo), std::move(getCurrentTimeCallback)},
           preWakeUp(std::move(preWakeUpSettingsProvider)), snoozeChimeSettings(std::move(snoozeChimeSettings)),
-          bedtime(std::move(bedtimeSettingsProvider))
+          onboardingSettings(std::move(onboardingSettings)), bedtime(std::move(bedtimeSettingsProvider))
     {}
 
     void AlarmOperations::minuteUpdated(TimePoint now)
     {
+        // Prevent activating alarms when the onboard is not done yet
+        if (!isOnboardingDone()) {
+            return;
+        }
         /**
          * A very simple alarm priority:
          * 1. Main alarm


@@ 306,6 330,10 @@ namespace alarms
     {
         return ongoingSingleEvents.empty() && snoozedSingleEvents.empty() && not preWakeUp.isActive();
     }
+    bool AlarmOperations::isOnboardingDone()
+    {
+        return onboardingSettings->isDone();
+    }
 
     void AlarmOperations::handleAlarmEvent(const std::shared_ptr<AlarmEventRecord> &event,
                                            alarms::AlarmType alarmType,

@@ 6,7 6,7 @@
 #include <AlarmOperations.hpp>
 #include <db/SystemSettings.hpp>
 #include <common/models/BedtimeModel.hpp>
-
+#include <service-db/Settings.hpp>
 namespace alarms
 {
     class AlarmOperationsFactory : public IAlarmOperationsFactory


@@ 45,6 45,13 @@ namespace alarms
         virtual auto getSettings() -> Settings          = 0;
     };
 
+    class OnboardingSettingsProvider
+    {
+      public:
+        virtual ~OnboardingSettingsProvider() noexcept = default;
+        virtual auto isDone() -> bool                  = 0;
+    };
+
     class AbstractBedtimeSettingsProvider
     {
       public:


@@ 95,6 102,7 @@ namespace alarms
                         GetCurrentTime getCurrentTimeCallback,
                         std::unique_ptr<PreWakeUpSettingsProvider> &&preWakeUpSettingsProvider,
                         std::unique_ptr<SnoozeChimeSettingsProvider> &&snoozeChimeSettingsProvider,
+                        std::unique_ptr<OnboardingSettingsProvider> &&onboardingSettingsProvider,
                         std::unique_ptr<AbstractBedtimeSettingsProvider> &&BedtimeModel);
 
       private:


@@ 117,9 125,11 @@ namespace alarms
                               bool newStateOn) override;
 
         bool isBedtimeAllowed() const;
+        bool isOnboardingDone();
 
         PreWakeUp preWakeUp;
         std::unique_ptr<SnoozeChimeSettingsProvider> snoozeChimeSettings;
+        std::unique_ptr<OnboardingSettingsProvider> onboardingSettings;
         Bedtime bedtime;
     };
 } // namespace alarms

@@ 1,4 1,4 @@
-// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// Copyright (c) 2017-2023, Mudita Sp. z.o.o. All rights reserved.
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
 #include <AlarmOperations.hpp>


@@ 62,6 62,23 @@ namespace
         Settings settings{true, std::chrono::minutes{1}};
     };
 
+    class MockedOnboardingSettingsProvider : public alarms::OnboardingSettingsProvider
+    {
+      public:
+        void setSettings(bool doneOnboarding)
+        {
+            done = doneOnboarding;
+        }
+
+        auto isDone() -> bool override
+        {
+            return done;
+        }
+
+      private:
+        bool done{true};
+    };
+
     class MockedBedtimeModel : public alarms::AbstractBedtimeSettingsProvider
     {
       public:


@@ 87,12 104,14 @@ namespace
         std::unique_ptr<MockAlarmEventsRepository> &alarmRepo,
         std::unique_ptr<alarms::PreWakeUpSettingsProvider> &&preWakeUpSettingsProvider,
         std::unique_ptr<alarms::SnoozeChimeSettingsProvider> &&snoozeChimeSettingsProvider,
+        std::unique_ptr<alarms::OnboardingSettingsProvider> &&onboardingSettingsProvider,
         std::unique_ptr<alarms::AbstractBedtimeSettingsProvider> &&bedtimeSettingsProvider)
     {
         return std::make_unique<alarms::AlarmOperations>(std::move(alarmRepo),
                                                          timeInjector,
                                                          std::move(preWakeUpSettingsProvider),
                                                          std::move(snoozeChimeSettingsProvider),
+                                                         std::move(onboardingSettingsProvider),
                                                          std::move(bedtimeSettingsProvider));
     }
 } // namespace


@@ 104,6 123,7 @@ std::unique_ptr<alarms::IAlarmOperations> AlarmOperationsFixture::getMockedAlarm
     return ::getMockedAlarmOperations(alarmRepo,
                                       std::make_unique<MockedPreWakeUpSettingsProvider>(),
                                       std::make_unique<MockedSnoozeChimeSettingsProvider>(),
+                                      std::make_unique<MockedOnboardingSettingsProvider>(),
                                       std::make_unique<MockedBedtimeModel>());
 }
 


@@ 219,6 239,7 @@ class BellAlarmOperationsFixture : public ::testing::Test
         alarmOperations = ::getMockedAlarmOperations(alarmRepoMock,
                                                      std::make_unique<MockedPreWakeUpSettingsProvider>(),
                                                      std::make_unique<MockedSnoozeChimeSettingsProvider>(),
+                                                     std::make_unique<MockedOnboardingSettingsProvider>(),
                                                      std::make_unique<MockedBedtimeModel>());
         alarmOperations->addAlarmExecutionHandler(alarms::AlarmType::PreWakeUpChime, chimeHandler);
         alarmOperations->addAlarmExecutionHandler(alarms::AlarmType::PreWakeUpFrontlight, frontlightHandler);