7 files changed, 59 insertions(+), 62 deletions(-)

M products/BellHybrid/apps/application-bell-settings/ApplicationBellSettings.cpp
M products/BellHybrid/apps/application-bell-settings/models/alarm_settings/SnoozeListItemProvider.cpp
M products/BellHybrid/apps/application-bell-settings/models/alarm_settings/SnoozeListItemProvider.hpp
M products/BellHybrid/apps/application-bell-settings/models/alarm_settings/SnoozeSettingsModel.cpp
M products/BellHybrid/apps/application-bell-settings/models/alarm_settings/SnoozeSettingsModel.hpp
M products/BellHybrid/apps/application-bell-settings/presenter/alarm_settings/SnoozePresenter.cpp
M products/BellHybrid/apps/application-bell-settings/presenter/alarm_settings/SnoozePresenter.hpp

@@ 201,13 201,10 @@ namespace app
         windowsFactory.attach(
             gui::BellSettingsAlarmSettingsSnoozeWindow::name,
             [this](ApplicationCommon *app, [[maybe_unused]] const std::string &name) {
-                auto soundsRepository =
-                    std::make_unique<SimpleSoundsRepository>(paths::audio::proprietary() / paths::audio::snooze());
                 auto snoozeOnOffModel         = std::make_unique<bell_settings::SnoozeOnOffModel>(this);
                 auto snoozeLengthModel        = std::make_unique<bell_settings::SnoozeLengthModel>(this);
                 auto snoozeChimeIntervalModel = std::make_unique<bell_settings::SnoozeChimeIntervalModel>(this);
-                auto snoozeChimeToneModel =
-                    std::make_unique<bell_settings::SnoozeChimeToneModel>(this, *soundsRepository);
+                auto snoozeChimeToneModel     = std::make_unique<bell_settings::SnoozeChimeToneModel>(this);
                 auto snoozeChimeVolumeModel   = std::make_unique<bell_settings::SnoozeChimeVolumeModel>(*audioModel);
                 auto snoozeSettingsModel =
                     std::make_unique<bell_settings::SnoozeSettingsModel>(std::move(snoozeOnOffModel),


@@ 216,10 213,16 @@ namespace app
                                                                          std::move(snoozeChimeToneModel),
                                                                          std::move(snoozeChimeVolumeModel));
 
-                auto provider = std::make_shared<bell_settings::SnoozeListItemProvider>(
-                    *snoozeSettingsModel, soundsRepository->getSongTitles());
+                const auto &pathSorting =
+                    SoundsRepository::PathSorting{paths::audio::proprietary() / paths::audio::snooze(),
+                                                  SoundsRepository::SortingBy::TrackIdAscending};
+                auto soundsRepository = std::make_unique<SoundsRepository>(this, pathSorting);
+                auto songsModel       = std::make_unique<SongsModel>(this, std::move(soundsRepository));
+                auto provider         = std::make_unique<bell_settings::SnoozeListItemProvider>(*snoozeSettingsModel,
+                                                                                        std::move(songsModel));
+
                 auto presenter = std::make_unique<bell_settings::SnoozePresenter>(
-                    provider, std::move(snoozeSettingsModel), *audioModel, std::move(soundsRepository));
+                    std::move(provider), std::move(snoozeSettingsModel), *audioModel);
                 return std::make_unique<gui::BellSettingsAlarmSettingsSnoozeWindow>(app, std::move(presenter));
             });
         windowsFactory.attach(


@@ 248,13 251,11 @@ namespace app
                                                                         std::move(alarmLightOnOffModel),
                                                                         std::move(alarmFrontlightModel));
 
-                auto frontlightModel  = std::make_unique<bell_settings::FrontlightModel>(app);
+                auto frontlightModel = std::make_unique<bell_settings::FrontlightModel>(app);
                 auto provider  = std::make_unique<bell_settings::AlarmSettingsListItemProvider>(*alarmSettingsModel,
                                                                                                std::move(songsModel));
-                auto presenter = std::make_unique<bell_settings::AlarmSettingsPresenter>(std::move(provider),
-                                                                                         std::move(alarmSettingsModel),
-                                                                                         *audioModel,
-                                                                                         std::move(frontlightModel));
+                auto presenter = std::make_unique<bell_settings::AlarmSettingsPresenter>(
+                    std::move(provider), std::move(alarmSettingsModel), *audioModel, std::move(frontlightModel));
                 return std::make_unique<gui::BellSettingsAlarmSettingsWindow>(app, std::move(presenter));
             });
 

@@ 6,11 6,10 @@
 #include <common/widgets/list_items/NumberWithSuffix.hpp>
 #include <common/widgets/list_items/Numeric.hpp>
 #include <common/widgets/list_items/NumericWithBar.hpp>
-#include <common/widgets/list_items/Text.hpp>
 #include <common/widgets/ListItems.hpp>
 #include <common/LanguageUtils.hpp>
+#include <SongsListViewItem.hpp>
 
-#include <apps-common/ApplicationCommon.hpp>
 #include <utility>
 
 namespace app::bell_settings


@@ 48,20 47,20 @@ namespace app::bell_settings
         return chimeInterval;
     }
 
-    SnoozeListItemProvider::SnoozeListItemProvider(AbstractSnoozeSettingsModel &model,
-                                                   std::vector<UTF8> chimeTonesRange)
-        : model{model}
+    SnoozeListItemProvider::SnoozeListItemProvider(AbstractSnoozeSettingsModel &settingsModel,
+                                                   std::shared_ptr<SongsModel> songsModel)
+        : settingsModel{settingsModel}, songsModel{std::move(songsModel)}
     {
-        buildListItems(std::move(chimeTonesRange));
+        buildListItems();
     }
 
-    void SnoozeListItemProvider::buildListItems(std::vector<UTF8> chimeTonesRange)
+    void SnoozeListItemProvider::buildListItems()
     {
         constexpr auto itemCount = 5U;
         internalData.reserve(itemCount);
 
-        auto onOff =
-            new OnOffListItem(model.getSnoozeOnOff(), utils::translate("app_bell_settings_alarm_settings_snooze"));
+        auto onOff = new OnOffListItem(settingsModel.getSnoozeOnOff(),
+                                       utils::translate("app_bell_settings_alarm_settings_snooze"));
 
         internalData.emplace_back(onOff);
         constexpr auto snoozeLengthStep = 1U;


@@ 69,10 68,10 @@ namespace app::bell_settings
         constexpr auto snoozeLengthMax  = 30U;
 
         auto chimeLengthBottomDescription =
-            utils::language::getCorrectMinutesNumeralForm(model.getSnoozeLength().getValue());
+            utils::language::getCorrectMinutesNumeralForm(settingsModel.getSnoozeLength().getValue());
         auto chimeLength = new list_items::Numeric(
             list_items::Numeric::spinner_type::range{snoozeLengthMin, snoozeLengthMax, snoozeLengthStep},
-            model.getSnoozeLength(),
+            settingsModel.getSnoozeLength(),
             utils::translate("app_bell_settings_alarm_settings_snooze_length"),
             chimeLengthBottomDescription);
 


@@ 90,7 89,7 @@ namespace app::bell_settings
 
         auto chimeInterval = new list_items::NumberWithSuffix(
             getDefaultChimeIntervalRange(),
-            model.getSnoozeChimeInterval(),
+            settingsModel.getSnoozeChimeInterval(),
             utils::translate("app_bell_settings_alarm_settings_snooze_chime_interval"),
             utils::translate("app_bell_settings_alarm_settings_snooze_chime_interval_bot_desc"));
         chimeLength->setValue();


@@ 116,27 115,36 @@ namespace app::bell_settings
             return false;
         };
 
+        chimeInterval->onProceed = [chimeInterval, this]() {
+            if (chimeInterval->value() == 0) {
+                this->onExit();
+                return true;
+            }
+            return false;
+        };
+
         auto snoozeChimeTone =
-            new list_items::Text(std::move(chimeTonesRange),
-                                 model.getSnoozeChimeTone(),
-                                 utils::translate("app_bell_settings_alarm_settings_snooze_chime_tone"));
-        snoozeChimeTone->set_on_value_change_cb([this](const auto &val) {
+            new SongsListViewItem(utils::translate("app_bell_settings_alarm_settings_snooze_chime_tone"),
+                                  settingsModel.getSnoozeChimeTone(),
+                                  songsModel);
+        snoozeChimeTone->set_on_value_change_cb([chimeInterval, this](const auto &val) {
+            currentSoundPath = val;
             if (onToneChange) {
                 onToneChange(val);
             }
         });
-        snoozeChimeTone->onEnter = [this, snoozeChimeTone, chimeInterval]() {
+        snoozeChimeTone->onEnter = [this, chimeInterval]() {
             if (chimeInterval->value() == 0) {
                 this->onExit();
                 return;
             }
             if (onToneEnter) {
-                onToneEnter(snoozeChimeTone->value());
+                onToneEnter(currentSoundPath);
             }
         };
-        snoozeChimeTone->onExit = [this, snoozeChimeTone]() {
+        snoozeChimeTone->onExit = [this]() {
             if (onToneExit) {
-                onToneExit(snoozeChimeTone->value());
+                onToneExit(currentSoundPath);
             }
         };
         internalData.emplace_back(snoozeChimeTone);


@@ 146,7 154,7 @@ namespace app::bell_settings
         constexpr auto volumeMax  = AbstractAudioModel::maxVolume;
         snoozeChimeVolume         = new list_items::NumericWithBar(
             list_items::NumericWithBar::spinner_type::range{volumeMin, volumeMax, volumeStep},
-            model.getSnoozeChimeVolume(),
+            settingsModel.getSnoozeChimeVolume(),
             volumeMax,
             utils::translate("app_bell_settings_alarm_settings_snooze_chime_volume"));
         snoozeChimeVolume->set_on_value_change_cb([this](const auto &val) {

@@ 5,6 5,7 @@
 
 #include "SettingsListItemProvider.hpp"
 #include "AbstractSnoozeSettingsModel.hpp"
+#include <common/models/SongsModel.hpp>
 
 namespace app::list_items
 {


@@ 16,14 17,16 @@ namespace app::bell_settings
     class SnoozeListItemProvider : public SettingsListItemProvider
     {
       public:
-        SnoozeListItemProvider(AbstractSnoozeSettingsModel &model, std::vector<UTF8> chimeTonesRange);
+        SnoozeListItemProvider(AbstractSnoozeSettingsModel &settingsModel, std::shared_ptr<SongsModel> songsModel);
 
         auto getCurrentVolume() -> std::uint8_t;
 
       private:
-        void buildListItems(std::vector<UTF8> chimeTonesRange);
+        void buildListItems();
 
-        AbstractSnoozeSettingsModel &model;
+        AbstractSnoozeSettingsModel &settingsModel;
         app::list_items::NumericWithBar *snoozeChimeVolume{nullptr};
+        std::shared_ptr<SongsModel> songsModel;
+        UTF8 currentSoundPath;
     };
 } // namespace app::bell_settings

@@ 42,20 42,14 @@ namespace app::bell_settings
             settings.getValue(bell::settings::Snooze::interval, settings::SettingsScope::Global));
     }
 
-    SnoozeChimeToneModel::SnoozeChimeToneModel(sys::Service *app, SimpleSoundsRepository &soundsRepository)
-        : gui::SettingsModel<UTF8>{app}, soundsRepository{soundsRepository}
-    {}
-
     auto SnoozeChimeToneModel::setValue(UTF8 value) -> void
     {
-        const auto &path = soundsRepository.titleToPath(value).value_or("");
-        settings.setValue(bell::settings::Snooze::tonePath, path, settings::SettingsScope::Global);
+        settings.setValue(bell::settings::Snooze::tonePath, value, settings::SettingsScope::Global);
     }
 
     auto SnoozeChimeToneModel::getValue() const -> UTF8
     {
-        const auto &path = settings.getValue(bell::settings::Snooze::tonePath, settings::SettingsScope::Global);
-        return soundsRepository.pathToTitle(path).value_or("");
+        return settings.getValue(bell::settings::Snooze::tonePath, settings::SettingsScope::Global);
     }
 
     auto SnoozeChimeVolumeModel::setValue(std::uint8_t value) -> void

@@ 40,13 40,10 @@ namespace app::bell_settings
     class SnoozeChimeToneModel : public gui::SettingsModel<UTF8>
     {
       public:
-        SnoozeChimeToneModel(sys::Service *app, SimpleSoundsRepository &soundsRepository);
+        using SettingsModel::SettingsModel;
 
         auto setValue(UTF8 value) -> void override;
         auto getValue() const -> UTF8 override;
-
-      private:
-        SimpleSoundsRepository &soundsRepository;
     };
 
     class SnoozeChimeVolumeModel : public gui::AbstractSettingsModel<std::uint8_t>

@@ 6,19 6,15 @@
 
 namespace app::bell_settings
 {
-    SnoozePresenter::SnoozePresenter(std::shared_ptr<SnoozeListItemProvider> provider,
-                                     std::unique_ptr<AbstractSnoozeSettingsModel> snoozeSettingsModel,
-                                     AbstractAudioModel &audioModel,
-                                     std::unique_ptr<AbstractSimpleSoundsRepository> soundsRepository)
-        : provider{provider}, snoozeSettingsModel{std::move(snoozeSettingsModel)}, audioModel{audioModel},
-          soundsRepository{std::move(soundsRepository)}
+    SnoozePresenter::SnoozePresenter(std::unique_ptr<SnoozeListItemProvider> &&provider,
+                                     std::unique_ptr<AbstractSnoozeSettingsModel> &&snoozeSettingsModel,
+                                     AbstractAudioModel &audioModel)
+        : provider{std::move(provider)}, snoozeSettingsModel{std::move(snoozeSettingsModel)}, audioModel{audioModel}
     {
         auto playSound = [this](const UTF8 &val) {
             currentSoundPath = val;
             this->audioModel.setVolume(this->provider->getCurrentVolume(), AbstractAudioModel::PlaybackType::Snooze);
-            this->audioModel.play(this->soundsRepository->titleToPath(currentSoundPath).value_or(""),
-                                  AbstractAudioModel::PlaybackType::Snooze,
-                                  {});
+            this->audioModel.play(currentSoundPath, AbstractAudioModel::PlaybackType::Snooze, {});
         };
 
         this->provider->onExit = [this]() { getView()->exit(); };

@@ 39,10 39,9 @@ namespace app::bell_settings
     class SnoozePresenter : public AbstractSnoozePresenter
     {
       public:
-        SnoozePresenter(std::shared_ptr<SnoozeListItemProvider> provider,
-                        std::unique_ptr<AbstractSnoozeSettingsModel> snoozeSettingsModel,
-                        AbstractAudioModel &audioModel,
-                        std::unique_ptr<AbstractSimpleSoundsRepository> soundsRepository);
+        SnoozePresenter(std::unique_ptr<SnoozeListItemProvider> &&provider,
+                        std::unique_ptr<AbstractSnoozeSettingsModel> &&snoozeSettingsModel,
+                        AbstractAudioModel &audioModel);
         auto getPagesProvider() const -> std::shared_ptr<gui::ListItemProvider> override;
         void saveData() override;
         void loadData() override;


@@ 55,7 54,6 @@ namespace app::bell_settings
         std::shared_ptr<SnoozeListItemProvider> provider;
         std::unique_ptr<AbstractSnoozeSettingsModel> snoozeSettingsModel;
         AbstractAudioModel &audioModel;
-        std::unique_ptr<AbstractSimpleSoundsRepository> soundsRepository;
         UTF8 currentSoundPath;
     };
 } // namespace app::bell_settings