From cd54ba058903b2c518f246cfdbc46ee33f41c1c3 Mon Sep 17 00:00:00 2001 From: Maciej-Mudita Date: Thu, 9 Feb 2023 12:54:28 +0100 Subject: [PATCH] [MOS-202] Add meditation parameters to non-volatile memory The meditation parameters set by the user will be remembered. style check fix --- .../ApplicationMeditation.cpp | 63 +++++++++++++++++-- .../application-meditation/CMakeLists.txt | 3 +- .../application-meditation/data/Constants.hpp | 27 ++++++++ .../data/MeditationParams.hpp | 20 ++++++ .../data/OptionsData.cpp | 39 ++++++++++++ .../data/OptionsData.hpp | 55 ++++++++++++++++ .../ApplicationMeditation.hpp | 8 ++- .../application-meditation/OptionsData.hpp | 23 ------- .../widgets/IntervalBox.cpp | 40 +++++++++--- .../widgets/IntervalBox.hpp | 6 +- .../widgets/TimerProperty.cpp | 46 +++++++++++--- .../widgets/TimerProperty.hpp | 28 +++++---- .../windows/MeditationOptionsWindows.cpp | 35 +++++------ .../windows/MeditationOptionsWindows.hpp | 6 +- .../windows/MeditationWindow.cpp | 17 +++-- .../windows/MeditationWindow.hpp | 6 +- .../apps-common/widgets/TextSpinnerBox.cpp | 9 ++- .../apps-common/widgets/TextSpinnerBox.hpp | 5 +- .../widgets/TextSpinnerBoxWithLabel.cpp | 9 ++- .../widgets/TextSpinnerBoxWithLabel.hpp | 3 +- .../agents/settings/SystemSettings.hpp | 16 +++-- .../migration/settings_v2/0/devel.sql | 2 +- .../databases/migration/settings_v2/0/up.sql | 2 +- pure_changelog.md | 1 + 24 files changed, 371 insertions(+), 98 deletions(-) create mode 100644 module-apps/application-meditation/data/Constants.hpp create mode 100644 module-apps/application-meditation/data/MeditationParams.hpp create mode 100644 module-apps/application-meditation/data/OptionsData.cpp create mode 100644 module-apps/application-meditation/data/OptionsData.hpp delete mode 100644 module-apps/application-meditation/include/application-meditation/OptionsData.hpp diff --git a/module-apps/application-meditation/ApplicationMeditation.cpp b/module-apps/application-meditation/ApplicationMeditation.cpp index 919a94aa5e660e50c0ca817c69aaf21d1c54b499..9cd578bc5d08ab739c5ed73b2bc037e29d29d98c 100644 --- a/module-apps/application-meditation/ApplicationMeditation.cpp +++ b/module-apps/application-meditation/ApplicationMeditation.cpp @@ -1,4 +1,4 @@ -// Copyright (c) 2017-2022, 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 "ApplicationMeditation.hpp" @@ -6,6 +6,11 @@ #include "MeditationTimerWindow.hpp" #include "MeditationWindow.hpp" #include "Names.hpp" +#include "MeditationParams.hpp" +#include "Constants.hpp" + +#include +#include namespace app { @@ -13,7 +18,7 @@ namespace app std::string parent, StatusIndicators statusIndicators, StartInBackground startInBackground) - : Application{name, parent, statusIndicators, startInBackground}, state{std::make_unique()} + : Application{name, parent, statusIndicators, startInBackground} {} auto ApplicationMeditation::InitHandler() -> sys::ReturnCodes @@ -22,6 +27,26 @@ namespace app if (ret != sys::ReturnCodes::Success) return ret; + auto counterVisible = + getLocalSettingsValue(settings::Meditation::showCounter, Constants::Params::defaultCounterVisible); + auto counterVisibleOnChangeCallback = [this](bool newValue) { + settings->setValue( + settings::Meditation::showCounter, utils::to_string(newValue), settings::SettingsScope::AppLocal); + }; + + auto preparationTime = std::chrono::seconds(getLocalSettingsValue( + settings::Meditation::preparationTime, Constants::Params::defaultPreparationTime.count())); + auto preparationTimeOnChangeCallback = [this](std::chrono::seconds newValue) { + settings->setValue(settings::Meditation::preparationTime, + utils::to_string(newValue.count()), + settings::SettingsScope::AppLocal); + }; + gui::OptionsData::OptionParams params = { + .preparationTime{std::move(preparationTime), std::move(preparationTimeOnChangeCallback)}, + .showCounter{std::move(counterVisible), std::move(counterVisibleOnChangeCallback)}}; + + state = std::make_unique(std::move(params)); + createUserInterface(); return ret; @@ -46,10 +71,29 @@ namespace app void ApplicationMeditation::createUserInterface() { - windowsFactory.attach(app::window::name::meditation_main_window, - [](ApplicationCommon *app, const std::string &name) { - return std::make_unique(app); - }); + windowsFactory.attach( + app::window::name::meditation_main_window, [&](ApplicationCommon *app, const std::string &name) { + auto durationInitValue = + getLocalSettingsValue(settings::Meditation::duration, Constants::Params::defaultMeditationDuration); + auto durationOnChangeCallback = [this](std::int32_t newValue) { + settings->setValue( + settings::Meditation::duration, utils::to_string(newValue), settings::SettingsScope::AppLocal); + }; + auto intervalChimeInitValue = std::chrono::minutes(getLocalSettingsValue( + settings::Meditation::intervalChime, Constants::Params::defaultChimeInterval.count())); + auto intervalChimeOnChangeCallback = [this](std::chrono::minutes newValue) { + settings->setValue(settings::Meditation::intervalChime, + utils::to_string(newValue.count()), + settings::SettingsScope::AppLocal); + }; + MeditationParams params = { + .meditationDuration{.initValue = std::move(durationInitValue), + .onChangeCallback = std::move(durationOnChangeCallback)}, + .intervalChime{.initValue = std::move(intervalChimeInitValue), + .onChangeCallback = std::move(intervalChimeOnChangeCallback)}}; + + return std::make_unique(app, std::move(params)); + }); windowsFactory.attach(app::window::name::meditation_timer, [](ApplicationCommon *app, const std::string &name) { return std::make_unique(app); }); @@ -73,4 +117,11 @@ namespace app void ApplicationMeditation::destroyUserInterface() {} + + template + T ApplicationMeditation::getLocalSettingsValue(const std::string &variableName, T defaultValue) + { + const std::string value = settings->getValue(variableName, settings::SettingsScope::AppLocal); + return value.empty() ? defaultValue : utils::getNumericValue(value); + } } // namespace app diff --git a/module-apps/application-meditation/CMakeLists.txt b/module-apps/application-meditation/CMakeLists.txt index 46274986e320a82d01f8f65cfc190bdee3da1838..bbfbf053d296c82af3887c8e4756197195c5567e 100644 --- a/module-apps/application-meditation/CMakeLists.txt +++ b/module-apps/application-meditation/CMakeLists.txt @@ -20,6 +20,8 @@ target_sources(application-meditation ApplicationMeditation.cpp data/MeditationTimerData.hpp data/Style.hpp + data/OptionsData.hpp + data/OptionsData.cpp widgets/IntervalBox.cpp widgets/IntervalBox.hpp widgets/MeditationTimer.cpp @@ -35,7 +37,6 @@ target_sources(application-meditation windows/Names.hpp PUBLIC include/application-meditation/ApplicationMeditation.hpp - include/application-meditation/OptionsData.hpp ) target_link_libraries(application-meditation diff --git a/module-apps/application-meditation/data/Constants.hpp b/module-apps/application-meditation/data/Constants.hpp new file mode 100644 index 0000000000000000000000000000000000000000..0bfa9dc2f8c0121ad639fb40ba3fe329d5129e20 --- /dev/null +++ b/module-apps/application-meditation/data/Constants.hpp @@ -0,0 +1,27 @@ +// Copyright (c) 2017-2023, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#pragma once + +#include +#include +#include + +namespace Constants +{ + namespace Params + { + using minutes = std::chrono::minutes; + constexpr auto defaultChimeInterval{minutes{2}}; + constexpr std::array chimeIntervals{ + minutes{2}, minutes{5}, minutes{10}, minutes{15}, minutes{30}, minutes{0}}; + + constexpr int defaultMeditationDuration = 15; + constexpr std::array meditationDurations = {15, 30, 60, 90}; + + using namespace std::chrono_literals; + constexpr auto defaultPreparationTime{5s}; + constexpr auto defaultCounterVisible{true}; + constexpr std::array preparationTimes{5s, 10s, 30s, 1min, 2min, 5min, 10min}; + } // namespace Params +} // namespace Constants diff --git a/module-apps/application-meditation/data/MeditationParams.hpp b/module-apps/application-meditation/data/MeditationParams.hpp new file mode 100644 index 0000000000000000000000000000000000000000..638d42145a319e133cdbe59a979278a90200a0a0 --- /dev/null +++ b/module-apps/application-meditation/data/MeditationParams.hpp @@ -0,0 +1,20 @@ +// Copyright (c) 2017-2023, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#pragma once + +#include +#include + +template +struct SettingsParam +{ + T initValue; + std::function onChangeCallback{nullptr}; +}; + +struct MeditationParams +{ + SettingsParam meditationDuration; + SettingsParam intervalChime; +}; diff --git a/module-apps/application-meditation/data/OptionsData.cpp b/module-apps/application-meditation/data/OptionsData.cpp new file mode 100644 index 0000000000000000000000000000000000000000..23c61ceec11d67daa7e8f916ef89199e8ebdc32d --- /dev/null +++ b/module-apps/application-meditation/data/OptionsData.cpp @@ -0,0 +1,39 @@ +// Copyright (c) 2017-2023, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#include "OptionsData.hpp" +#include "Constants.hpp" + +namespace gui +{ + OptionsData::OptionsData(OptionParams params) : params(params) + {} + + [[nodiscard]] std::chrono::seconds OptionsData::getPreparationTime() const noexcept + { + return params.preparationTime.get(); + } + + bool OptionsData::setPreparationTime(std::chrono::seconds value) + { + bool result = true; + const auto it = std::find( + std::begin(Constants::Params::preparationTimes), std::end(Constants::Params::preparationTimes), value); + if (it == std::end(Constants::Params::preparationTimes)) { + value = Constants::Params::defaultPreparationTime; + result = false; + } + params.preparationTime.set(value); + return result; + } + + [[nodiscard]] bool OptionsData::isCounterVisible() const noexcept + { + return params.showCounter.get(); + } + + void OptionsData::setCounterVisible(bool value) + { + params.showCounter.set(value); + } +} // namespace gui diff --git a/module-apps/application-meditation/data/OptionsData.hpp b/module-apps/application-meditation/data/OptionsData.hpp new file mode 100644 index 0000000000000000000000000000000000000000..41f46a1513db0891fc5c1acb73447647bdf41933 --- /dev/null +++ b/module-apps/application-meditation/data/OptionsData.hpp @@ -0,0 +1,55 @@ +// Copyright (c) 2017-2023, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#pragma once + +#include +#include +#include + +namespace gui +{ + template + class OptionParam + { + public: + OptionParam(T value, std::function callback) : value(value), onChangeCallback(callback) + {} + [[nodiscard]] T get() const noexcept + { + return value; + } + void set(T newValue) + { + value = newValue; + if (onChangeCallback != nullptr) { + onChangeCallback(newValue); + } + } + + private: + T value; + std::function onChangeCallback{nullptr}; + }; + + class OptionsData : public gui::SwitchData + { + public: + struct OptionParams + { + OptionParam preparationTime; + OptionParam showCounter; + }; + + OptionsData(OptionParams params); + + [[nodiscard]] std::chrono::seconds getPreparationTime() const noexcept; + bool setPreparationTime(std::chrono::seconds value); + + [[nodiscard]] bool isCounterVisible() const noexcept; + void setCounterVisible(bool value); + + private: + OptionParams params; + }; +} // namespace gui diff --git a/module-apps/application-meditation/include/application-meditation/ApplicationMeditation.hpp b/module-apps/application-meditation/include/application-meditation/ApplicationMeditation.hpp index 683096e6a2aaf8b64a101a35d95ad77d55d9e335..d66a7a663a098f52eb44e1358332d6cd83cdeefa 100644 --- a/module-apps/application-meditation/include/application-meditation/ApplicationMeditation.hpp +++ b/module-apps/application-meditation/include/application-meditation/ApplicationMeditation.hpp @@ -1,9 +1,9 @@ -// Copyright (c) 2017-2022, 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 #pragma once -#include +#include #include @@ -28,6 +28,10 @@ namespace app void createUserInterface() override; void destroyUserInterface() override; std::unique_ptr state; + + private: + template + T getLocalSettingsValue(const std::string &variableName, T defaultValue); }; template <> diff --git a/module-apps/application-meditation/include/application-meditation/OptionsData.hpp b/module-apps/application-meditation/include/application-meditation/OptionsData.hpp deleted file mode 100644 index a7afdd24f8b78afdc6ce736bc4f0fd24d93a850b..0000000000000000000000000000000000000000 --- a/module-apps/application-meditation/include/application-meditation/OptionsData.hpp +++ /dev/null @@ -1,23 +0,0 @@ -// 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 - -#include - -namespace gui -{ - class OptionsData : public gui::SwitchData - { - public: - OptionsData() = default; - OptionsData(std::chrono::seconds preparation, bool showCounter) - : preparationTime(preparation), showCounter(showCounter) - {} - - std::chrono::seconds preparationTime{5}; - bool showCounter = true; - }; -} // namespace gui diff --git a/module-apps/application-meditation/widgets/IntervalBox.cpp b/module-apps/application-meditation/widgets/IntervalBox.cpp index 3862e40cbb794215eb7a36321ba2476e03d1b8e3..df107fd5cab68d031d55a1e7e6aee9fa4e18c270 100644 --- a/module-apps/application-meditation/widgets/IntervalBox.cpp +++ b/module-apps/application-meditation/widgets/IntervalBox.cpp @@ -1,4 +1,4 @@ -// Copyright (c) 2017-2022, 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 "IntervalBox.hpp" @@ -7,18 +7,11 @@ #include #include - +#include #include using namespace gui; -namespace -{ - using minutes = std::chrono::minutes; - const std::vector chimeIntervals{ - minutes{2}, minutes{5}, minutes{10}, minutes{15}, minutes{30}, minutes{0}}; -} // namespace - IntervalBox::IntervalBox(Item *parent, uint32_t x, uint32_t y, uint32_t w, uint32_t h, TimerProperty *timerSetter) : HBox(parent, x, y, w, h), timerSetter(timerSetter) { @@ -49,7 +42,7 @@ void IntervalBox::updateIntervals() auto setTime = timerSetter->getTime(); std::vector chimeOptions; - for (auto chime : chimeIntervals) { + for (auto chime : Constants::Params::chimeIntervals) { if (chime < setTime) { chimeOptions.push_back(intervalToString(chime)); } @@ -73,6 +66,33 @@ std::chrono::seconds IntervalBox::getIntervalValue() noexcept } } +bool IntervalBox::setIntervalValue(std::chrono::minutes newValue) +{ + bool result = true; + const auto it = + std::find(std::begin(Constants::Params::chimeIntervals), std::end(Constants::Params::chimeIntervals), newValue); + if (it == std::end(Constants::Params::chimeIntervals)) { + newValue = Constants::Params::defaultChimeInterval; + result = false; + } + + if (const auto setTime = timerSetter->getTime(); newValue < setTime) { + chimeSpinner->setCurrentValue(intervalToString(newValue)); + } + return result; +} + +void IntervalBox::setOnChangeCallback(OnChangeCallback &callback) +{ + if (chimeSpinner != nullptr) { + chimeSpinner->setOnValueChangeCallback([&](const UTF8 &newValue) { + if (callback != nullptr) { + callback(stringToInterval(newValue)); + } + }); + } +} + std::string IntervalBox::intervalToString(std::chrono::minutes time) { if (time.count() == 0) { diff --git a/module-apps/application-meditation/widgets/IntervalBox.hpp b/module-apps/application-meditation/widgets/IntervalBox.hpp index b8ccffd018ff2c992feb4066bd7fb58c235b0f89..9808b43d7f4e2b41f138d138d221b9076a5320d9 100644 --- a/module-apps/application-meditation/widgets/IntervalBox.hpp +++ b/module-apps/application-meditation/widgets/IntervalBox.hpp @@ -1,4 +1,4 @@ -// Copyright (c) 2017-2022, 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 #pragma once @@ -28,8 +28,12 @@ namespace gui void rescaleIntervals(); public: + using OnChangeCallback = std::function; + IntervalBox(Item *parent, uint32_t x, uint32_t y, uint32_t w, uint32_t h, TimerProperty *timerSetter); [[nodiscard]] std::chrono::seconds getIntervalValue() noexcept; + bool setIntervalValue(std::chrono::minutes newValue); + void setOnChangeCallback(OnChangeCallback &callback); }; } // namespace gui diff --git a/module-apps/application-meditation/widgets/TimerProperty.cpp b/module-apps/application-meditation/widgets/TimerProperty.cpp index 434975f79f5e1aa2c41cc54bbae79bd57b949971..b44c5959906d471b8409195fa4a9889bcd7580b0 100644 --- a/module-apps/application-meditation/widgets/TimerProperty.cpp +++ b/module-apps/application-meditation/widgets/TimerProperty.cpp @@ -1,4 +1,4 @@ -// Copyright (c) 2017-2022, 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 "Style.hpp" @@ -7,10 +7,12 @@ #include #include #include +#include using namespace gui; -TimerProperty::TimerProperty(Item *parent, const uint32_t x, const uint32_t y, const uint32_t w, const uint32_t h) +TimerProperty::TimerProperty( + Item *parent, const std::uint32_t x, const std::uint32_t y, const std::uint32_t w, const std::uint32_t h) : Rect(parent, x, y, w, h) { build(); @@ -110,6 +112,9 @@ void TimerProperty::setMeditationTime() else { timeUnitLabel->setText(utils::translate("app_meditation_minutes")); } + if (onChangeCallback != nullptr) { + onChangeCallback(meditationTime); + } } std::chrono::minutes TimerProperty::getTime() noexcept @@ -118,6 +123,29 @@ std::chrono::minutes TimerProperty::getTime() noexcept return state.getTime(); } +bool TimerProperty::setTime(std::int32_t newValue) +{ + bool result = state.setTime(newValue); + setMeditationTime(); + return result; +} +void TimerProperty::setOnChangeCallback(OnChangeCallback callback) +{ + onChangeCallback = callback; +} + +bool TimerProperty::State::setTime(int value) +{ + const auto it = std::find( + std::begin(Constants::Params::meditationDurations), std::end(Constants::Params::meditationDurations), value); + if (it != std::end(Constants::Params::meditationDurations)) { + timeInMinutes = *it; + return true; + } + timeInMinutes = Constants::Params::defaultMeditationDuration; + return false; +} + void TimerProperty::State::checkBounds() noexcept { timeInMinutes = std::clamp(timeInMinutes, minimalValue, maximalValue); @@ -152,8 +180,10 @@ void TimerProperty::State::delNumericValue() noexcept void TimerProperty::State::increment() noexcept { - auto it = std::upper_bound(std::begin(timeArr), std::end(timeArr), timeInMinutes); - if (it == std::end(timeArr)) { + auto it = std::upper_bound(std::begin(Constants::Params::meditationDurations), + std::end(Constants::Params::meditationDurations), + timeInMinutes); + if (it == std::end(Constants::Params::meditationDurations)) { it--; } timeInMinutes = *it; @@ -162,9 +192,11 @@ void TimerProperty::State::increment() noexcept void TimerProperty::State::decrement() noexcept { - auto it = - std::upper_bound(std::rbegin(timeArr), std::rend(timeArr), timeInMinutes, [](int a, int b) { return a > b; }); - if (it == std::rend(timeArr)) { + auto it = std::upper_bound(std::rbegin(Constants::Params::meditationDurations), + std::rend(Constants::Params::meditationDurations), + timeInMinutes, + [](int a, int b) { return a > b; }); + if (it == std::rend(Constants::Params::meditationDurations)) { it--; } timeInMinutes = *it; diff --git a/module-apps/application-meditation/widgets/TimerProperty.hpp b/module-apps/application-meditation/widgets/TimerProperty.hpp index 3eaeec1db0cc3db86a183cf85cf3b6e01483b950..bdc6704d7e65c1aa2558e9aa7eb07a0b622259a1 100644 --- a/module-apps/application-meditation/widgets/TimerProperty.hpp +++ b/module-apps/application-meditation/widgets/TimerProperty.hpp @@ -1,4 +1,4 @@ -// Copyright (c) 2017-2022, 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 #pragma once @@ -19,17 +19,16 @@ namespace gui static constexpr int counterMaxDigits = 2; static constexpr int minimalValue = 1; static constexpr int maximalValue = 99; - static constexpr int defaultMeditationTime = 15; - static constexpr std::array timeArr = {15, 30, 60, 90}; bool resetValueOnNumeric = true; - int timeInMinutes = defaultMeditationTime; + int timeInMinutes; public: [[nodiscard]] std::chrono::minutes getTime() const noexcept { return std::chrono::minutes{timeInMinutes}; } + bool setTime(int value); void checkBounds() noexcept; void putNumericValue(int digit) noexcept; void delNumericValue() noexcept; @@ -42,21 +41,28 @@ namespace gui } } state; + public: + using OnChangeCallback = std::function; + + TimerProperty( + Item *parent, const std::uint32_t x, const std::uint32_t y, const std::uint32_t w, const std::uint32_t h); + + bool onFocus(bool isFocused) final; + bool onInput(const InputEvent &inputEvent) final; + [[nodiscard]] std::chrono::minutes getTime() noexcept; + bool setTime(std::int32_t newValue); + void setOnChangeCallback(OnChangeCallback callback); + + private: Circle *circle = nullptr; VBox *centerBody = nullptr; Label *timeLabel = nullptr; Rect *divRect = nullptr; Label *timeUnitLabel = nullptr; + OnChangeCallback onChangeCallback; void build(); void setMeditationTime(); - - public: - TimerProperty(Item *parent, const uint32_t x, const uint32_t y, const uint32_t w, const uint32_t h); - - bool onFocus(bool isFocused) final; - bool onInput(const InputEvent &inputEvent) final; - [[nodiscard]] std::chrono::minutes getTime() noexcept; }; } // namespace gui diff --git a/module-apps/application-meditation/windows/MeditationOptionsWindows.cpp b/module-apps/application-meditation/windows/MeditationOptionsWindows.cpp index 0e23b567ac82c6827d601ba25c00c3b532fe4e1c..925c9b578ea5707ede4e9415faa6f8ad96369697 100644 --- a/module-apps/application-meditation/windows/MeditationOptionsWindows.cpp +++ b/module-apps/application-meditation/windows/MeditationOptionsWindows.cpp @@ -1,10 +1,11 @@ -// 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 "ApplicationMeditation.hpp" #include "MeditationOptionsWindows.hpp" #include "Names.hpp" +#include #include #include @@ -12,9 +13,6 @@ using namespace gui; namespace { - using namespace std::chrono_literals; - constexpr std::array preparationTimes{5s, 10s, 30s, 1min, 2min, 5min, 10min}; - std::string toString(std::chrono::seconds duration) { if (duration.count() >= 60) { @@ -45,7 +43,7 @@ void MeditationOptionsWindow::addCounterOption(std::list