From 842cdbe6ca66a6151f8da4cc82b9aacab20dbd27 Mon Sep 17 00:00:00 2001
From: Maciej Janicki <maciej.janicki@mudita.com>
Date: Fri, 5 Nov 2021 13:10:20 +0100
Subject: [PATCH] [BH-1125] Add file indexer

Add file indexer
---
 .../ApplicationMusicPlayer.cpp                | 14 +++--
 .../application-music-player/CMakeLists.txt   |  5 --
 .../ApplicationMusicPlayer.hpp                |  3 +-
 .../models/SongsModel.cpp                     | 14 ++---
 .../models/SongsModel.hpp                     | 10 +--
 .../presenters/SongsPresenter.cpp             | 31 +++++-----
 .../presenters/SongsPresenter.hpp             | 30 ++++-----
 .../tests/MockSongsRepository.hpp             |  6 +-
 .../tests/MockTagsFetcher.hpp                 |  6 +-
 .../tests/unittest_songsmodel.cpp             |  6 +-
 module-apps/apps-common/CMakeLists.txt        |  6 ++
 .../models/SongContext.cpp                    |  4 +-
 .../models/SongContext.hpp                    |  6 +-
 .../models/SongsModelInterface.hpp            | 35 +++++------
 .../models/SongsRepository.cpp                | 14 +++--
 .../models/SongsRepository.hpp                | 22 ++++---
 module-db/Interface/MultimediaFilesRecord.cpp | 14 ++++-
 module-db/Interface/MultimediaFilesRecord.hpp |  3 +
 module-db/Tables/MultimediaFilesTable.cpp     |  9 +++
 module-db/Tables/MultimediaFilesTable.hpp     |  1 +
 .../QueryMultimediaFilesGetLimited.cpp        |  9 +++
 .../QueryMultimediaFilesGetLimited.hpp        | 11 ++++
 .../tests/MultimediaFilesTable_tests.cpp      | 24 +++++++
 module-services/CMakeLists.txt                |  1 +
 .../service-fileindexer/CMakeLists.txt        |  0
 .../service-fileindexer/Common.hpp            |  0
 .../service-fileindexer/InotifyHandler.cpp    |  0
 .../ServiceFileIndexer.cpp                    |  5 +-
 .../service-fileindexer/StartupIndexer.cpp    |  6 +-
 .../include/service-fileindexer/Constants.hpp |  0
 .../service-fileindexer/InotifyHandler.hpp    |  0
 .../ServiceFileIndexer.hpp                    |  2 +-
 .../service-fileindexer/StartupIndexer.hpp    |  5 +-
 products/BellHybrid/BellHybridMain.cpp        |  7 +++
 products/BellHybrid/CMakeLists.txt            |  1 +
 .../ApplicationBellBackgroundSounds.cpp       | 14 ++++-
 .../CMakeLists.txt                            |  2 -
 .../data/BGSoundsAudioData.hpp                |  9 +--
 .../ApplicationBellBackgroundSounds.hpp       |  1 +
 .../models/BGSoundsRepository.cpp             | 62 +++++++++----------
 .../models/BGSoundsRepository.hpp             | 24 ++++---
 .../presenter/BGSoundsMainWindowPresenter.cpp | 28 ++++++---
 .../presenter/BGSoundsMainWindowPresenter.hpp | 12 ++--
 .../presenter/BGSoundsProgressPresenter.cpp   |  6 +-
 .../presenter/BGSoundsProgressPresenter.hpp   | 19 +++---
 .../windows/BGSoundsMainWindow.cpp            | 16 ++---
 .../windows/BGSoundsMainWindow.hpp            |  4 +-
 .../windows/BGSoundsProgressWindow.cpp        |  4 +-
 products/BellHybrid/services/db/ServiceDB.cpp | 11 +++-
 .../services/db/include/db/ServiceDB.hpp      |  8 +++
 products/PurePhone/PurePhoneMain.cpp          |  4 +-
 products/PurePhone/services/CMakeLists.txt    |  1 -
 52 files changed, 341 insertions(+), 194 deletions(-)
 rename module-apps/{application-music-player => apps-common}/models/SongContext.cpp (92%)
 rename module-apps/{application-music-player => apps-common}/models/SongContext.hpp (83%)
 rename module-apps/{application-music-player => apps-common}/models/SongsModelInterface.hpp (68%)
 rename module-apps/{application-music-player => apps-common}/models/SongsRepository.cpp (96%)
 rename module-apps/{application-music-player => apps-common}/models/SongsRepository.hpp (92%)
 rename {products/PurePhone/services => module-services}/service-fileindexer/CMakeLists.txt (100%)
 rename {products/PurePhone/services => module-services}/service-fileindexer/Common.hpp (100%)
 rename {products/PurePhone/services => module-services}/service-fileindexer/InotifyHandler.cpp (100%)
 rename {products/PurePhone/services => module-services}/service-fileindexer/ServiceFileIndexer.cpp (88%)
 rename {products/PurePhone/services => module-services}/service-fileindexer/StartupIndexer.cpp (97%)
 rename {products/PurePhone/services => module-services}/service-fileindexer/include/service-fileindexer/Constants.hpp (100%)
 rename {products/PurePhone/services => module-services}/service-fileindexer/include/service-fileindexer/InotifyHandler.hpp (100%)
 rename {products/PurePhone/services => module-services}/service-fileindexer/include/service-fileindexer/ServiceFileIndexer.hpp (94%)
 rename {products/PurePhone/services => module-services}/service-fileindexer/include/service-fileindexer/StartupIndexer.hpp (90%)

diff --git a/module-apps/application-music-player/ApplicationMusicPlayer.cpp b/module-apps/application-music-player/ApplicationMusicPlayer.cpp
index a0902b8615aab768b0f9dc54a1af82787d44d754..0b1adfadd1ebff1c86964f3b33c73d6855a9bd48 100644
--- a/module-apps/application-music-player/ApplicationMusicPlayer.cpp
+++ b/module-apps/application-music-player/ApplicationMusicPlayer.cpp
@@ -27,7 +27,7 @@ namespace app
         class MusicPlayerPriv
         {
           public:
-            std::shared_ptr<app::music_player::SongsModelInterface> songsModel;
+            std::shared_ptr<app::music::SongsModelInterface> songsModel;
             std::shared_ptr<app::music_player::SongsContract::Presenter> songsPresenter;
         };
     } // namespace music_player::internal
@@ -46,15 +46,19 @@ namespace app
 
         bus.channels.push_back(sys::BusChannel::ServiceAudioNotifications);
 
-        auto tagsFetcher     = std::make_unique<app::music_player::ServiceAudioTagsFetcher>(this);
-        auto songsRepository = std::make_unique<app::music_player::SongsRepository>(this, std::move(tagsFetcher));
-        priv->songsModel     = std::make_unique<app::music_player::SongsModel>(this, std::move(songsRepository));
+        auto tagsFetcher = std::make_unique<app::music::ServiceAudioTagsFetcher>(this);
+
+        const auto musicPlayerFilesPath = purefs::createPath(purefs::dir::getUserDiskPath(), "music").string();
+        auto songsRepository =
+            std::make_unique<app::music::SongsRepository>(this, std::move(tagsFetcher), musicPlayerFilesPath);
+
+        priv->songsModel     = std::make_unique<app::music::SongsModel>(this, std::move(songsRepository));
         auto audioOperations = std::make_unique<app::AsyncAudioOperations>(this);
         priv->songsPresenter =
             std::make_unique<app::music_player::SongsPresenter>(this, priv->songsModel, std::move(audioOperations));
 
         // callback used when playing state is changed
-        using SongState                                 = app::music_player::SongState;
+        using SongState                                 = app::music::SongState;
         std::function<void(SongState)> autolockCallback = [this](SongState isPlaying) {
             if (isPlaying == SongState::Playing) {
                 LOG_DEBUG("Preventing autolock while playing track.");
diff --git a/module-apps/application-music-player/CMakeLists.txt b/module-apps/application-music-player/CMakeLists.txt
index ed7438f8634d24c408efb71a30a784f7df161741..ddc0e7deca88eeb31989e27a313bb7338707c65b 100644
--- a/module-apps/application-music-player/CMakeLists.txt
+++ b/module-apps/application-music-player/CMakeLists.txt
@@ -14,9 +14,7 @@ target_sources(application-music-player
     PRIVATE
         ApplicationMusicPlayer.cpp
         AudioNotificationsHandler.cpp
-        models/SongContext.cpp
         models/SongsModel.cpp
-        models/SongsRepository.cpp
         presenters/SongsPresenter.cpp
         widgets/SongItem.cpp
         windows/MusicPlayerMainWindow.cpp
@@ -24,10 +22,7 @@ target_sources(application-music-player
     PRIVATE
         AudioNotificationsHandler.hpp
         data/MusicPlayerStyle.hpp
-        models/SongContext.hpp
         models/SongsModel.hpp
-        models/SongsRepository.hpp
-        models/SongsModelInterface.hpp
         presenters/SongsPresenter.hpp
         widgets/SongItem.hpp
         windows/MusicPlayerMainWindow.cpp
diff --git a/module-apps/application-music-player/include/application-music-player/ApplicationMusicPlayer.hpp b/module-apps/application-music-player/include/application-music-player/ApplicationMusicPlayer.hpp
index 64642729473b3fbae0b183f257ae83540e6fde1c..1d97fa710c80ce6572cf9016c0a7b6c5da0495af 100644
--- a/module-apps/application-music-player/include/application-music-player/ApplicationMusicPlayer.hpp
+++ b/module-apps/application-music-player/include/application-music-player/ApplicationMusicPlayer.hpp
@@ -5,6 +5,7 @@
 
 #include <Application.hpp>
 #include <Audio/decoder/Decoder.hpp>
+#include <purefs/filesystem_paths.hpp>
 #include <atomic>
 
 namespace gui
@@ -14,7 +15,7 @@ namespace gui
         namespace window
         {
             inline constexpr auto track_info_window = "Track Info";
-            inline constexpr auto all_songs_window = "All Songs";
+            inline constexpr auto all_songs_window  = "All Songs";
         }; // namespace window
     };     // namespace name
 };         // namespace gui
diff --git a/module-apps/application-music-player/models/SongsModel.cpp b/module-apps/application-music-player/models/SongsModel.cpp
index 93a86865b8172cb7ce5856f3322e1e0fda037170..f9f89b6ec185237aec0b53ecf5906d1e738841e4 100644
--- a/module-apps/application-music-player/models/SongsModel.cpp
+++ b/module-apps/application-music-player/models/SongsModel.cpp
@@ -9,7 +9,7 @@
 #include <service-audio/AudioServiceAPI.hpp>
 #include <time/time_conversion.hpp>
 
-namespace app::music_player
+namespace app::music
 {
 
     SongsListItemProvider::SongsListItemProvider(ApplicationCommon *app) : DatabaseModel(app)
@@ -90,10 +90,10 @@ namespace app::music_player
                                 OnSetNavBarTemporaryCallback navBarTemporaryMode,
                                 OnRestoreNavBarTemporaryCallback navBarRestoreFromTemporaryMode)
     {
-        this->shortReleaseCallback              = shortReleaseCallback;
-        this->longPressCallback                 = longPressCallback;
-        this->navBarTemporaryMode               = navBarTemporaryMode;
-        this->navBarRestoreFromTemporaryMode    = navBarRestoreFromTemporaryMode;
+        this->shortReleaseCallback           = shortReleaseCallback;
+        this->longPressCallback              = longPressCallback;
+        this->navBarTemporaryMode            = navBarTemporaryMode;
+        this->navBarRestoreFromTemporaryMode = navBarRestoreFromTemporaryMode;
 
         songsRepository->initCache();
     }
@@ -135,7 +135,7 @@ namespace app::music_player
 
     void SongsModel::setCurrentSongContext(SongContext context)
     {
-        songContext = context;
+        songContext     = context;
         activatedRecord = songsRepository->getRecord(context.filePath);
     }
 
@@ -175,4 +175,4 @@ namespace app::music_player
         songsRepository->updateRepository(filePath);
     }
 
-} // namespace app::music_player
+} // namespace app::music
diff --git a/module-apps/application-music-player/models/SongsModel.hpp b/module-apps/application-music-player/models/SongsModel.hpp
index d5e2834d017ec71819a2548c8032d3384dc2deb1..5976e41a5cd6e2f38be0b685ccd2f531dcd60d78 100644
--- a/module-apps/application-music-player/models/SongsModel.hpp
+++ b/module-apps/application-music-player/models/SongsModel.hpp
@@ -5,13 +5,13 @@
 
 #include "module-apps/application-music-player/data/MusicPlayerStyle.hpp"
 
-#include "SongContext.hpp"
-#include "SongsRepository.hpp"
-#include "SongsModelInterface.hpp"
+#include <apps-common/models/SongsRepository.hpp>
+#include <apps-common/models/SongsModelInterface.hpp>
 
+#include <apps-common/models/SongContext.hpp>
 #include <Audio/decoder/Decoder.hpp>
 
-namespace app::music_player
+namespace app::music
 {
     class SongsModel : public SongsModelInterface
     {
@@ -61,4 +61,4 @@ namespace app::music_player
 
         std::shared_ptr<AbstractSongsRepository> songsRepository;
     };
-} // namespace app::music_player
+} // namespace app::music
diff --git a/module-apps/application-music-player/presenters/SongsPresenter.cpp b/module-apps/application-music-player/presenters/SongsPresenter.cpp
index 95495c02704840d47114ffcc066e95c8f85bc0a7..882319b550610777e7a411f7924d2ffd1b5940f6 100644
--- a/module-apps/application-music-player/presenters/SongsPresenter.cpp
+++ b/module-apps/application-music-player/presenters/SongsPresenter.cpp
@@ -10,7 +10,7 @@
 namespace app::music_player
 {
     SongsPresenter::SongsPresenter(app::ApplicationCommon *app,
-                                   std::shared_ptr<app::music_player::SongsModelInterface> songsModelInterface,
+                                   std::shared_ptr<app::music::SongsModelInterface> songsModelInterface,
                                    std::unique_ptr<AbstractAudioOperations> &&audioOperations)
         : songsModelInterface{std::move(songsModelInterface)}, audioOperations{std::move(audioOperations)}
     {
@@ -19,7 +19,7 @@ namespace app::music_player
             app, "MP Song Progres", tick, [this]([[maybe_unused]] sys::Timer &) { handleTrackProgressTick(); });
     }
 
-    std::shared_ptr<app::music_player::SongsModelInterface> SongsPresenter::getMusicPlayerModelInterface() const
+    std::shared_ptr<app::music::SongsModelInterface> SongsPresenter::getMusicPlayerModelInterface() const
     {
         return songsModelInterface;
     }
@@ -46,11 +46,12 @@ namespace app::music_player
                 return;
             }
 
-            SongContext songContext{SongState::Playing, token, filePath, SongContext::StartPos};
+            app::music::SongContext songContext{
+                app::music::SongState::Playing, token, filePath, app::music::SongContext::StartPos};
             songsModelInterface->setCurrentSongContext(songContext);
 
             if (changePlayingStateCallback != nullptr) {
-                changePlayingStateCallback(SongState::Playing);
+                changePlayingStateCallback(app::music::SongState::Playing);
             }
             updateViewSongState();
             songsModelInterface->updateRepository(filePath);
@@ -76,9 +77,9 @@ namespace app::music_player
                     LOG_ERROR("Pause audio operation failed, wrong token");
                     return;
                 }
-                songsModelInterface->setCurrentSongState(SongState::NotPlaying);
+                songsModelInterface->setCurrentSongState(app::music::SongState::NotPlaying);
                 if (changePlayingStateCallback != nullptr) {
-                    changePlayingStateCallback(SongState::NotPlaying);
+                    changePlayingStateCallback(app::music::SongState::NotPlaying);
                 }
                 updateViewSongState();
                 songProgressTimer.stop();
@@ -106,9 +107,9 @@ namespace app::music_player
                         LOG_ERROR("Resume audio operation failed, wrong token");
                         return;
                     }
-                    songsModelInterface->setCurrentSongState(SongState::Playing);
+                    songsModelInterface->setCurrentSongState(app::music::SongState::Playing);
                     if (changePlayingStateCallback != nullptr) {
-                        changePlayingStateCallback(SongState::Playing);
+                        changePlayingStateCallback(app::music::SongState::Playing);
                     }
                     updateViewSongState();
                     songProgressTimestamp = std::chrono::system_clock::now();
@@ -161,7 +162,7 @@ namespace app::music_player
         updateViewSongState();
     }
 
-    void SongsPresenter::setPlayingStateCallback(std::function<void(SongState)> cb)
+    void SongsPresenter::setPlayingStateCallback(std::function<void(app::music::SongState)> cb)
     {
         changePlayingStateCallback = std::move(cb);
     }
@@ -171,7 +172,7 @@ namespace app::music_player
         if (token == songsModelInterface->getCurrentFileToken()) {
             songsModelInterface->clearCurrentSongContext();
             if (changePlayingStateCallback != nullptr) {
-                changePlayingStateCallback(SongState::NotPlaying);
+                changePlayingStateCallback(app::music::SongState::NotPlaying);
             }
             if (!waitingToPlay) {
                 updateViewSongState();
@@ -189,7 +190,7 @@ namespace app::music_player
         if (token == currentSongContext.currentFileToken) {
             songsModelInterface->clearCurrentSongContext();
             if (changePlayingStateCallback != nullptr) {
-                changePlayingStateCallback(SongState::NotPlaying);
+                changePlayingStateCallback(app::music::SongState::NotPlaying);
             }
             auto nextSongToPlay = songsModelInterface->getNextFilePath(currentSongContext.filePath);
             if (!nextSongToPlay.empty()) {
@@ -207,9 +208,9 @@ namespace app::music_player
     bool SongsPresenter::handleAudioPausedNotification(audio::Token token)
     {
         if (token == songsModelInterface->getCurrentFileToken()) {
-            songsModelInterface->setCurrentSongState(SongState::NotPlaying);
+            songsModelInterface->setCurrentSongState(app::music::SongState::NotPlaying);
             if (changePlayingStateCallback != nullptr) {
-                changePlayingStateCallback(SongState::NotPlaying);
+                changePlayingStateCallback(app::music::SongState::NotPlaying);
             }
             updateViewSongState();
             return true;
@@ -220,9 +221,9 @@ namespace app::music_player
     bool SongsPresenter::handleAudioResumedNotification(audio::Token token)
     {
         if (token == songsModelInterface->getCurrentFileToken()) {
-            songsModelInterface->setCurrentSongState(SongState::Playing);
+            songsModelInterface->setCurrentSongState(app::music::SongState::Playing);
             if (changePlayingStateCallback != nullptr) {
-                changePlayingStateCallback(SongState::Playing);
+                changePlayingStateCallback(app::music::SongState::Playing);
             }
             updateViewSongState();
             return true;
diff --git a/module-apps/application-music-player/presenters/SongsPresenter.hpp b/module-apps/application-music-player/presenters/SongsPresenter.hpp
index 98b00cb30a28998c15e470224515c6b9e0f8d8b4..e43ad64eabfbabab05f73db4217164dac266ac6d 100644
--- a/module-apps/application-music-player/presenters/SongsPresenter.hpp
+++ b/module-apps/application-music-player/presenters/SongsPresenter.hpp
@@ -6,7 +6,7 @@
 #include <apps-common/AudioOperations.hpp>
 #include <apps-common/BasePresenter.hpp>
 
-#include <module-apps/application-music-player/models/SongsModelInterface.hpp>
+#include <apps-common/models/SongsModelInterface.hpp>
 
 namespace app::music_player
 {
@@ -23,24 +23,24 @@ namespace app::music_player
                 Stopped
             };
 
-            virtual ~View() noexcept                                        = default;
+            virtual ~View() noexcept                                     = default;
             virtual void updateSongsState(std::optional<db::multimedia_files::MultimediaFilesRecord> record,
-                                          RecordState state)                = 0;
-            virtual void updateSongProgress(float progress)                 = 0;
-            virtual void refreshWindow()                                    = 0;
-            virtual void setNavBarTemporaryMode(const std::string &text)    = 0;
-            virtual void restoreFromNavBarTemporaryMode()                   = 0;
+                                          RecordState state)             = 0;
+            virtual void updateSongProgress(float progress)              = 0;
+            virtual void refreshWindow()                                 = 0;
+            virtual void setNavBarTemporaryMode(const std::string &text) = 0;
+            virtual void restoreFromNavBarTemporaryMode()                = 0;
         };
 
         class Presenter : public BasePresenter<SongsContract::View>
         {
           public:
-            using OnPlayingStateChangeCallback = std::function<void(SongState)>;
+            using OnPlayingStateChangeCallback = std::function<void(app::music::SongState)>;
 
             virtual ~Presenter() noexcept = default;
 
-            virtual std::shared_ptr<SongsModelInterface> getMusicPlayerModelInterface() const = 0;
-            virtual void createData()                                                         = 0;
+            virtual std::shared_ptr<app::music::SongsModelInterface> getMusicPlayerModelInterface() const = 0;
+            virtual void createData()                                                                     = 0;
 
             virtual bool play(const std::string &filePath) = 0;
             virtual bool pause()                           = 0;
@@ -63,10 +63,10 @@ namespace app::music_player
     {
       public:
         explicit SongsPresenter(app::ApplicationCommon *app,
-                                std::shared_ptr<SongsModelInterface> songsListItemProvider,
+                                std::shared_ptr<app::music::SongsModelInterface> songsListItemProvider,
                                 std::unique_ptr<AbstractAudioOperations> &&audioOperations);
 
-        std::shared_ptr<SongsModelInterface> getMusicPlayerModelInterface() const override;
+        std::shared_ptr<app::music::SongsModelInterface> getMusicPlayerModelInterface() const override;
 
         void createData() override;
 
@@ -78,7 +78,7 @@ namespace app::music_player
         bool playPrevious() override;
 
         void songsStateRequest() override;
-        void setPlayingStateCallback(std::function<void(SongState)> cb) override;
+        void setPlayingStateCallback(std::function<void(app::music::SongState)> cb) override;
         bool handleAudioStopNotifiaction(audio::Token token) override;
         bool handleAudioEofNotification(audio::Token token) override;
         bool handleAudioPausedNotification(audio::Token token) override;
@@ -100,9 +100,9 @@ namespace app::music_player
         bool requestAudioOperation(const std::string &filePath = "");
         void setViewNavBarTemporaryMode(const std::string &text);
         void restoreViewNavBarFromTemporaryMode();
-        std::shared_ptr<SongsModelInterface> songsModelInterface;
+        std::shared_ptr<app::music::SongsModelInterface> songsModelInterface;
         std::unique_ptr<AbstractAudioOperations> audioOperations;
-        std::function<void(SongState)> changePlayingStateCallback = nullptr;
+        std::function<void(app::music::SongState)> changePlayingStateCallback = nullptr;
 
         sys::TimerHandle songProgressTimer;
         std::chrono::time_point<std::chrono::system_clock> songProgressTimestamp;
diff --git a/module-apps/application-music-player/tests/MockSongsRepository.hpp b/module-apps/application-music-player/tests/MockSongsRepository.hpp
index f47587740bfc38cee7f571c0291ad46245b16871..80b73a01497f0c9cfb72ffbe98f324fbadc44d70 100644
--- a/module-apps/application-music-player/tests/MockSongsRepository.hpp
+++ b/module-apps/application-music-player/tests/MockSongsRepository.hpp
@@ -12,9 +12,9 @@
 #include <string>
 #include <vector>
 
-namespace testing::app::music_player
+namespace testing::app::music
 {
-    class MockSongsRepository : public ::app::music_player::AbstractSongsRepository
+    class MockSongsRepository : public ::app::music::AbstractSongsRepository
     {
       public:
         MOCK_METHOD(void,
@@ -31,4 +31,4 @@ namespace testing::app::music_player
                     (const override));
         MOCK_METHOD(void, updateRepository, (const std::string &filePath), (override));
     };
-}; // namespace testing::app::music_player
+}; // namespace testing::app::music
diff --git a/module-apps/application-music-player/tests/MockTagsFetcher.hpp b/module-apps/application-music-player/tests/MockTagsFetcher.hpp
index 533be2ec5cb1a143d3d288252cc1bac2d44f9718..db9a00c3674c911b355d498ff075a2af0752a172 100644
--- a/module-apps/application-music-player/tests/MockTagsFetcher.hpp
+++ b/module-apps/application-music-player/tests/MockTagsFetcher.hpp
@@ -10,11 +10,11 @@
 
 #include <optional>
 
-namespace testing::app::music_player
+namespace testing::app::music
 {
-    class MockTagsFetcher : public ::app::music_player::AbstractTagsFetcher
+    class MockTagsFetcher : public ::app::music::AbstractTagsFetcher
     {
       public:
         MOCK_METHOD(std::optional<tags::fetcher::Tags>, getFileTags, (const std::string &filePath), (const override));
     };
-}; // namespace testing::app::music_player
+}; // namespace testing::app::music
diff --git a/module-apps/application-music-player/tests/unittest_songsmodel.cpp b/module-apps/application-music-player/tests/unittest_songsmodel.cpp
index 2e8d5545dd5a743489ecb83ba3e5fe9d3f8c2e52..646f883b02130925f58de49e63f4dab86d8db640 100644
--- a/module-apps/application-music-player/tests/unittest_songsmodel.cpp
+++ b/module-apps/application-music-player/tests/unittest_songsmodel.cpp
@@ -10,9 +10,9 @@
 #include <memory>
 #include <optional>
 
-using ::app::music_player::SongsModel;
+using ::app::music::SongsModel;
 using ::testing::Return;
-using ::testing::app::music_player::MockSongsRepository;
+using ::testing::app::music::MockSongsRepository;
 
 TEST(SongsModel, Init)
 {
@@ -31,5 +31,5 @@ TEST(SongsModel, EmptyContext)
 
     EXPECT_EQ(ctx.currentFileToken, std::nullopt);
     EXPECT_TRUE(ctx.filePath.empty());
-    EXPECT_EQ(ctx.currentSongState, app::music_player::SongState::NotPlaying);
+    EXPECT_EQ(ctx.currentSongState, app::music::SongState::NotPlaying);
 }
diff --git a/module-apps/apps-common/CMakeLists.txt b/module-apps/apps-common/CMakeLists.txt
index 2aa8e8e078bdfd9b3fe6be37452ed2177890ade6..4228fcea0c6df77f7608e822c1f8e37f76303dad 100644
--- a/module-apps/apps-common/CMakeLists.txt
+++ b/module-apps/apps-common/CMakeLists.txt
@@ -15,6 +15,8 @@ target_sources(apps-common
         StatusBarManager.cpp
         WindowsFactory.cpp
         audio/SoundsPlayer.cpp
+        models/SongContext.cpp
+        models/SongsRepository.cpp
         notifications/NotificationData.cpp
         notifications/NotificationListItem.cpp
         notifications/NotificationProvider.cpp
@@ -62,6 +64,10 @@ target_sources(apps-common
         actions/AlarmRingingData.hpp
         actions/AlarmTriggeredAction.hpp
 
+        models/SongContext.hpp
+        models/SongsRepository.hpp
+        models/SongsModelInterface.hpp
+
         widgets/spinners/GenericSpinner.hpp
         widgets/spinners/SpinnerPolicies.hpp
         widgets/spinners/Spinners.hpp
diff --git a/module-apps/application-music-player/models/SongContext.cpp b/module-apps/apps-common/models/SongContext.cpp
similarity index 92%
rename from module-apps/application-music-player/models/SongContext.cpp
rename to module-apps/apps-common/models/SongContext.cpp
index 12a917bfb70798b67e1c0953cfe0238712eb4da6..8037c3b285b9bd2e97bda784ab1b7e1fd7ef0520 100644
--- a/module-apps/application-music-player/models/SongContext.cpp
+++ b/module-apps/apps-common/models/SongContext.cpp
@@ -4,7 +4,7 @@
 #include "SongContext.hpp"
 #include <optional>
 
-namespace app::music_player
+namespace app::music
 {
     void SongContext::clear()
     {
@@ -28,4 +28,4 @@ namespace app::music_player
     {
         return isValid() && currentSongState == SongState::NotPlaying;
     }
-} // namespace app::music_player
+} // namespace app::music
diff --git a/module-apps/application-music-player/models/SongContext.hpp b/module-apps/apps-common/models/SongContext.hpp
similarity index 83%
rename from module-apps/application-music-player/models/SongContext.hpp
rename to module-apps/apps-common/models/SongContext.hpp
index 969e278c113ce08fcbeb62859bb499bb398dc5e6..b38232203b4f06b3077ecca62fd9fb0176eee4b5 100644
--- a/module-apps/application-music-player/models/SongContext.hpp
+++ b/module-apps/apps-common/models/SongContext.hpp
@@ -4,7 +4,7 @@
 
 #include <Audio/decoder/Decoder.hpp>
 
-namespace app::music_player
+namespace app::music
 {
 
     enum class SongState
@@ -16,7 +16,7 @@ namespace app::music_player
     struct SongContext
     {
         static constexpr uint32_t StartPos = 0;
-        SongState currentSongState = SongState::NotPlaying;
+        SongState currentSongState         = SongState::NotPlaying;
         std::optional<audio::Token> currentFileToken;
         std::string filePath;
         uint32_t currentPos = StartPos;
@@ -28,4 +28,4 @@ namespace app::music_player
         bool isValid() const;
     };
 
-} // namespace app::music_player
+} // namespace app::music
diff --git a/module-apps/application-music-player/models/SongsModelInterface.hpp b/module-apps/apps-common/models/SongsModelInterface.hpp
similarity index 68%
rename from module-apps/application-music-player/models/SongsModelInterface.hpp
rename to module-apps/apps-common/models/SongsModelInterface.hpp
index 35ead71499a9f72b52ee7926db6ad8d452cd4149..bfdece3800020720eef2956c46d7759cec51a22e 100644
--- a/module-apps/application-music-player/models/SongsModelInterface.hpp
+++ b/module-apps/apps-common/models/SongsModelInterface.hpp
@@ -5,30 +5,29 @@
 
 #include "SongContext.hpp"
 #include <string>
-#include <widgets/SongItem.hpp>
 #include <ListItemProvider.hpp>
 #include <apps-common/ApplicationCommon.hpp>
 #include <apps-common/DatabaseModel.hpp>
 #include <module-db/Interface/MultimediaFilesRecord.hpp>
 
-namespace app::music_player
+namespace app::music
 {
     class SongsListItemProvider : public app::DatabaseModel<db::multimedia_files::MultimediaFilesRecord>,
                                   public gui::ListItemProvider
     {
       public:
-        using OnShortReleaseCallback              = std::function<bool(const std::string &fileName)>;
-        using OnLongPressCallback                 = std::function<void()>;
-        using OnSetNavBarTemporaryCallback        = std::function<void(const UTF8 &)>;
-        using OnRestoreNavBarTemporaryCallback    = std::function<void()>;
+        using OnShortReleaseCallback           = std::function<bool(const std::string &fileName)>;
+        using OnLongPressCallback              = std::function<void()>;
+        using OnSetNavBarTemporaryCallback     = std::function<void(const UTF8 &)>;
+        using OnRestoreNavBarTemporaryCallback = std::function<void()>;
         explicit SongsListItemProvider(app::ApplicationCommon *app);
         virtual ~SongsListItemProvider() noexcept = default;
 
         virtual void createData(OnShortReleaseCallback shortReleaseCallback,
                                 OnLongPressCallback longPressCallback,
                                 OnSetNavBarTemporaryCallback navBarTemporaryMode,
-                                OnRestoreNavBarTemporaryCallback navBarRestoreFromTemporaryMode)       = 0;
-        virtual void clearData()                                                                       = 0;
+                                OnRestoreNavBarTemporaryCallback navBarRestoreFromTemporaryMode) = 0;
+        virtual void clearData()                                                                 = 0;
     };
 
     class SongsModelInterface : public SongsListItemProvider
@@ -37,15 +36,15 @@ namespace app::music_player
         explicit SongsModelInterface(app::ApplicationCommon *app);
         virtual ~SongsModelInterface() noexcept = default;
 
-        virtual bool isSongPlaying() const noexcept                              = 0;
-        virtual void setCurrentSongState(SongState songState) noexcept           = 0;
-        virtual std::optional<audio::Token> getCurrentFileToken() const noexcept = 0;
+        virtual bool isSongPlaying() const noexcept                                                            = 0;
+        virtual void setCurrentSongState(SongState songState) noexcept                                         = 0;
+        virtual std::optional<audio::Token> getCurrentFileToken() const noexcept                               = 0;
         virtual std::optional<db::multimedia_files::MultimediaFilesRecord> getActivatedRecord() const noexcept = 0;
-        virtual SongContext getCurrentSongContext() const noexcept               = 0;
-        virtual void setCurrentSongContext(SongContext context)                  = 0;
-        virtual void clearCurrentSongContext()                                   = 0;
-        virtual std::string getNextFilePath(const std::string &filePath) const     = 0;
-        virtual std::string getPreviousFilePath(const std::string &filePath) const = 0;
-        virtual void updateRepository(const std::string &filePath)                 = 0;
+        virtual SongContext getCurrentSongContext() const noexcept                                             = 0;
+        virtual void setCurrentSongContext(SongContext context)                                                = 0;
+        virtual void clearCurrentSongContext()                                                                 = 0;
+        virtual std::string getNextFilePath(const std::string &filePath) const                                 = 0;
+        virtual std::string getPreviousFilePath(const std::string &filePath) const                             = 0;
+        virtual void updateRepository(const std::string &filePath)                                             = 0;
     };
-} // namespace app::music_player
+} // namespace app::music
diff --git a/module-apps/application-music-player/models/SongsRepository.cpp b/module-apps/apps-common/models/SongsRepository.cpp
similarity index 96%
rename from module-apps/application-music-player/models/SongsRepository.cpp
rename to module-apps/apps-common/models/SongsRepository.cpp
index bba9e822e44d71b58813445139d61e47d8c34c13..3502ae4425decf02c046366f3355b7d6e945246d 100644
--- a/module-apps/application-music-player/models/SongsRepository.cpp
+++ b/module-apps/apps-common/models/SongsRepository.cpp
@@ -10,6 +10,7 @@
 #include <time/ScopedTime.hpp>
 #include <service-audio/AudioMessage.hpp>
 #include <module-db/queries/multimedia_files/QueryMultimediaFilesGetLimited.hpp>
+#include <module-db/queries/multimedia_files/QueryMultimediaFilesGet.hpp>
 
 #include <filesystem>
 
@@ -19,7 +20,7 @@ namespace constants
     inline constexpr auto cacheThreshold{10};
 } // namespace constants
 
-namespace app::music_player
+namespace app::music
 {
     ServiceAudioTagsFetcher::ServiceAudioTagsFetcher(ApplicationCommon *application) : application(application)
     {}
@@ -29,8 +30,11 @@ namespace app::music_player
         return tags::fetcher::fetchTags(filePath);
     }
 
-    SongsRepository::SongsRepository(ApplicationCommon *application, std::unique_ptr<AbstractTagsFetcher> tagsFetcher)
-        : app::AsyncCallbackReceiver{application}, application{application}, tagsFetcher(std::move(tagsFetcher))
+    SongsRepository::SongsRepository(ApplicationCommon *application,
+                                     std::unique_ptr<AbstractTagsFetcher> tagsFetcher,
+                                     std::string pathPrefix)
+        : app::AsyncCallbackReceiver{application}, application{application},
+          tagsFetcher(std::move(tagsFetcher)), pathPrefix{pathPrefix}
     {}
 
     void SongsRepository::initCache()
@@ -55,7 +59,7 @@ namespace app::music_player
                                             std::uint32_t limit,
                                             const OnGetMusicFilesListCallback &callback)
     {
-        auto query = std::make_unique<db::multimedia_files::query::GetLimited>(offset, limit);
+        auto query = std::make_unique<db::multimedia_files::query::GetLimitedByPath>(pathPrefix, offset, limit);
         auto task  = app::AsyncQuery::createFromQuery(std::move(query), db::Interface::Name::MultimediaFiles);
 
         task->setCallback([this, callback, offset](auto response) {
@@ -252,4 +256,4 @@ namespace app::music_player
         return musicFilesModelCache.records[index];
     }
 
-} // namespace app::music_player
+} // namespace app::music
diff --git a/module-apps/application-music-player/models/SongsRepository.hpp b/module-apps/apps-common/models/SongsRepository.hpp
similarity index 92%
rename from module-apps/application-music-player/models/SongsRepository.hpp
rename to module-apps/apps-common/models/SongsRepository.hpp
index 116c3e06df69529171310801e6d93e05644702af..c47334fda67927c33ffc8e899fe47bce7c5877d4 100644
--- a/module-apps/application-music-player/models/SongsRepository.hpp
+++ b/module-apps/apps-common/models/SongsRepository.hpp
@@ -14,7 +14,7 @@
 
 #include <cstddef>
 
-namespace app::music_player
+namespace app::music
 {
     struct FilesCache
     {
@@ -54,22 +54,22 @@ namespace app::music_player
         virtual void getMusicFilesList(std::uint32_t offset,
                                        std::uint32_t limit,
                                        const OnGetMusicFilesListCallback &callback) = 0;
-        virtual std::string getNextFilePath(const std::string &filePath) const     = 0;
-        virtual std::string getPreviousFilePath(const std::string &filePath) const = 0;
+        virtual std::string getNextFilePath(const std::string &filePath) const      = 0;
+        virtual std::string getPreviousFilePath(const std::string &filePath) const  = 0;
         virtual std::optional<db::multimedia_files::MultimediaFilesRecord> getRecord(
-            const std::string &filePath) const                                      = 0;
-        virtual void updateRepository(const std::string &filePath)                  = 0;
+            const std::string &filePath) const                     = 0;
+        virtual void updateRepository(const std::string &filePath) = 0;
     };
 
     class SongsRepository : public AbstractSongsRepository, public app::AsyncCallbackReceiver
     {
       public:
-        explicit SongsRepository(ApplicationCommon *application, std::unique_ptr<AbstractTagsFetcher> tagsFetcher);
+        explicit SongsRepository(ApplicationCommon *application,
+                                 std::unique_ptr<AbstractTagsFetcher> tagsFetcher,
+                                 std::string pathPrefix);
 
         void initCache();
-        void getMusicFilesList(std::uint32_t offset,
-                               std::uint32_t limit,
-                               const OnGetMusicFilesListCallback &callback) override;
+        void getMusicFilesList(std::uint32_t offset, std::uint32_t limit, const OnGetMusicFilesListCallback &callback);
         std::string getNextFilePath(const std::string &filePath) const override;
         std::string getPreviousFilePath(const std::string &filePath) const override;
         std::optional<db::multimedia_files::MultimediaFilesRecord> getRecord(
@@ -88,6 +88,8 @@ namespace app::music_player
 
         std::unique_ptr<AbstractTagsFetcher> tagsFetcher;
 
+        std::string pathPrefix;
+
         /// collection of music files displayed in the list view
         FilesCache musicFilesViewCache;
         /// collection of music files currently playing
@@ -119,4 +121,4 @@ namespace app::music_player
                                   unsigned int repoRecordsCount,
                                   std::uint32_t offset);
     };
-} // namespace app::music_player
+} // namespace app::music
diff --git a/module-db/Interface/MultimediaFilesRecord.cpp b/module-db/Interface/MultimediaFilesRecord.cpp
index d25733f6e01413dfe005c5685286db379607fea0..1264df7832476390ae1a2a576175e786c6ceefcd 100644
--- a/module-db/Interface/MultimediaFilesRecord.cpp
+++ b/module-db/Interface/MultimediaFilesRecord.cpp
@@ -36,6 +36,9 @@ namespace db::multimedia_files
         if (typeid(*query) == typeid(query::GetLimited)) {
             return runQueryImplGetLimited(std::static_pointer_cast<query::GetLimited>(query));
         }
+        if (typeid(*query) == typeid(query::GetLimitedByPath)) {
+            return runQueryImplGetLimited(std::static_pointer_cast<query::GetLimitedByPath>(query));
+        }
         if (typeid(*query) == typeid(query::Remove)) {
             return runQueryImplRemove(std::static_pointer_cast<query::Remove>(query));
         }
@@ -78,7 +81,6 @@ namespace db::multimedia_files
         if (typeid(*query) == typeid(query::GetByPath)) {
             return runQueryImplGetByPath(std::static_pointer_cast<query::GetByPath>(query));
         }
-
         return nullptr;
     }
 
@@ -249,6 +251,16 @@ namespace db::multimedia_files
         return response;
     }
 
+    std::unique_ptr<db::multimedia_files::query::GetLimitedResult> MultimediaFilesRecordInterface::
+        runQueryImplGetLimited(const std::shared_ptr<db::multimedia_files::query::GetLimitedByPath> &query)
+    {
+        const auto records = database->files.getLimitOffsetByPath(query->path, query->offset, query->limit);
+        auto response      = std::make_unique<query::GetLimitedResult>(records, database->files.count());
+        response->setRequestQuery(query);
+
+        return response;
+    }
+
     std::unique_ptr<db::multimedia_files::query::GetCountResult> MultimediaFilesRecordInterface::runQueryImplGetCount(
         const std::shared_ptr<db::multimedia_files::query::GetCountForAlbum> &query)
     {
diff --git a/module-db/Interface/MultimediaFilesRecord.hpp b/module-db/Interface/MultimediaFilesRecord.hpp
index 2c0d63f6f81fb809c347f48dff1e0ffd03620e31..7000bb7c3a3afe4f280f9bf8ddac2b6910497e00 100644
--- a/module-db/Interface/MultimediaFilesRecord.hpp
+++ b/module-db/Interface/MultimediaFilesRecord.hpp
@@ -34,6 +34,7 @@ namespace db::multimedia_files::query
     class GetCountForArtist;
     class GetCountResult;
     class GetLimited;
+    class GetLimitedByPath;
     class GetLimitedForAlbum;
     class GetLimitedForArtist;
     class GetLimitedResult;
@@ -70,6 +71,8 @@ namespace db::multimedia_files
             const std::shared_ptr<db::multimedia_files::query::Get> &query);
         std::unique_ptr<db::multimedia_files::query::GetLimitedResult> runQueryImplGetLimited(
             const std::shared_ptr<db::multimedia_files::query::GetLimited> &query);
+        std::unique_ptr<db::multimedia_files::query::GetLimitedResult> runQueryImplGetLimited(
+            const std::shared_ptr<db::multimedia_files::query::GetLimitedByPath> &query);
         std::unique_ptr<db::multimedia_files::query::RemoveResult> runQueryImplRemove(
             const std::shared_ptr<db::multimedia_files::query::Remove> &query);
         std::unique_ptr<db::multimedia_files::query::RemoveResult> runQueryImplRemoveAll(
diff --git a/module-db/Tables/MultimediaFilesTable.cpp b/module-db/Tables/MultimediaFilesTable.cpp
index f285059f90955f7179bcd29d8e03269b1cab8263..ab2d89ee841884e8d8639f3eec4ab110c15a0572 100644
--- a/module-db/Tables/MultimediaFilesTable.cpp
+++ b/module-db/Tables/MultimediaFilesTable.cpp
@@ -330,4 +330,13 @@ namespace db::multimedia_files
 
         return (*queryRet)[0].getUInt32();
     }
+
+    auto MultimediaFilesTable::getLimitOffsetByPath(const std::string &path, uint32_t offset, uint32_t limit)
+        -> std::vector<TableRow>
+    {
+        std::string query = "SELECT * FROM files WHERE path LIKE '" + path + "%%' ORDER BY title ASC LIMIT " +
+                            std::to_string(limit) + " OFFSET " + std::to_string(offset) + ";";
+        std::unique_ptr<QueryResult> retQuery = db->query(query.c_str());
+        return retQueryUnpack(std::move(retQuery));
+    }
 } // namespace db::multimedia_files
diff --git a/module-db/Tables/MultimediaFilesTable.hpp b/module-db/Tables/MultimediaFilesTable.hpp
index 964d2985e174047d36e6170d188d7bca76598a0d..3044692380709bf5666bee71dc8ec00208ab3434 100644
--- a/module-db/Tables/MultimediaFilesTable.hpp
+++ b/module-db/Tables/MultimediaFilesTable.hpp
@@ -101,6 +101,7 @@ namespace db::multimedia_files
         auto getLimitOffset(const Album &album, uint32_t offset, uint32_t limit) -> std::vector<TableRow>;
         auto count(const Album &album) -> uint32_t;
 
+        auto getLimitOffsetByPath(const std::string &path, uint32_t offset, uint32_t limit) -> std::vector<TableRow>;
         TableRow getByPath(std::string path);
 
         /// @note entry.ID is skipped
diff --git a/module-db/queries/multimedia_files/QueryMultimediaFilesGetLimited.cpp b/module-db/queries/multimedia_files/QueryMultimediaFilesGetLimited.cpp
index f03c4c8e84b212a266bfd8038b70fdff037c740f..c7885c4fd29e339ded09fd8440620e3a841b9b96 100644
--- a/module-db/queries/multimedia_files/QueryMultimediaFilesGetLimited.cpp
+++ b/module-db/queries/multimedia_files/QueryMultimediaFilesGetLimited.cpp
@@ -105,4 +105,13 @@ namespace db::multimedia_files::query
     {
         return std::string{"GetAlbumsLimitedResult"};
     }
+
+    GetLimitedByPath::GetLimitedByPath(std::string path, uint32_t offset, uint32_t limit)
+        : Query(Query::Type::Read), path{path}, offset(offset), limit(limit)
+    {}
+
+    auto GetLimitedByPath::debugInfo() const -> std::string
+    {
+        return std::string{"GetLimitedByPath"};
+    }
 } // namespace db::multimedia_files::query
diff --git a/module-db/queries/multimedia_files/QueryMultimediaFilesGetLimited.hpp b/module-db/queries/multimedia_files/QueryMultimediaFilesGetLimited.hpp
index 8fc5712bfeb21a6e899b1a2965d6fd273184906c..f496a8989af1492991b7f03ad6db0b53864191ec 100644
--- a/module-db/queries/multimedia_files/QueryMultimediaFilesGetLimited.hpp
+++ b/module-db/queries/multimedia_files/QueryMultimediaFilesGetLimited.hpp
@@ -100,4 +100,15 @@ namespace db::multimedia_files::query
         [[nodiscard]] auto getCount() const noexcept -> unsigned int;
         [[nodiscard]] auto debugInfo() const -> std::string override;
     };
+
+    class GetLimitedByPath : public Query
+    {
+      public:
+        GetLimitedByPath(std::string path, uint32_t offset, uint32_t limit);
+        [[nodiscard]] auto debugInfo() const -> std::string override;
+
+        const std::string path;
+        const uint32_t offset = 0;
+        const uint32_t limit  = 0;
+    };
 } // namespace db::multimedia_files::query
diff --git a/module-db/tests/MultimediaFilesTable_tests.cpp b/module-db/tests/MultimediaFilesTable_tests.cpp
index 071a98cfe32213b6c5d2b265acdc3133e314bbd6..ba6f8fe12b2872c81ee8b48f18c5f999ca1c7ad6 100644
--- a/module-db/tests/MultimediaFilesTable_tests.cpp
+++ b/module-db/tests/MultimediaFilesTable_tests.cpp
@@ -345,6 +345,15 @@ TEST_CASE("Multimedia DB tests", "[!mayfail]")
             return record;
         };
 
+        auto getLimitedByPathQuery = [&](const std::string &pathPrefix, const uint32_t offset, const uint32_t limit) {
+            auto query  = std::make_shared<db::multimedia_files::query::GetLimitedByPath>(pathPrefix, offset, limit);
+            auto ret    = multimediaFilesRecordInterface.runQuery(query);
+            auto result = dynamic_cast<db::multimedia_files::query::GetLimitedResult *>(ret.get());
+            REQUIRE(result != nullptr);
+            auto record = result->getResult();
+            return record;
+        };
+
         auto updateQuery = [&](const MultimediaFilesRecord &record) {
             const auto query  = std::make_shared<db::multimedia_files::query::Edit>(record);
             const auto ret    = multimediaFilesRecordInterface.runQuery(query);
@@ -564,6 +573,21 @@ TEST_CASE("Multimedia DB tests", "[!mayfail]")
             REQUIRE(getLimitedQuery(size - 3, size).size() == 3);
         }
 
+        SECTION("getLimitOffsetByPath")
+        {
+            auto rootPrefix   = "user/";
+            auto musicPrefix  = "user/music/";
+            auto falsePrefix1 = "user/music1/";
+            auto flasePrefix2 = "user/music2";
+            auto falsePrefix3 = "abc/";
+            auto size         = records.size();
+            REQUIRE(getLimitedByPathQuery(rootPrefix, 0, size).size() == size);
+            REQUIRE(getLimitedByPathQuery(musicPrefix, 0, size).size() == (size - 3));
+            REQUIRE(getLimitedByPathQuery(falsePrefix1, 0, size).size() == 0);
+            REQUIRE(getLimitedByPathQuery(flasePrefix2, 0, size).size() == 0);
+            REQUIRE(getLimitedByPathQuery(falsePrefix3, 0, size).size() == 0);
+        }
+
         SECTION("Artists")
         {
             REQUIRE(getCountArtistsQuery() == artists.size());
diff --git a/module-services/CMakeLists.txt b/module-services/CMakeLists.txt
index 98f436cffccab895639b245de13907aba6f643a8..ba77276d6ede580a964e4aaba7ea20c506586690 100644
--- a/module-services/CMakeLists.txt
+++ b/module-services/CMakeLists.txt
@@ -14,6 +14,7 @@ add_subdirectory( service-db )
 add_subdirectory( service-desktop )
 add_subdirectory( service-eink )
 add_subdirectory( service-evtmgr )
+add_subdirectory( service-fileindexer )
 add_subdirectory( service-gui )
 add_subdirectory( service-time )
 
diff --git a/products/PurePhone/services/service-fileindexer/CMakeLists.txt b/module-services/service-fileindexer/CMakeLists.txt
similarity index 100%
rename from products/PurePhone/services/service-fileindexer/CMakeLists.txt
rename to module-services/service-fileindexer/CMakeLists.txt
diff --git a/products/PurePhone/services/service-fileindexer/Common.hpp b/module-services/service-fileindexer/Common.hpp
similarity index 100%
rename from products/PurePhone/services/service-fileindexer/Common.hpp
rename to module-services/service-fileindexer/Common.hpp
diff --git a/products/PurePhone/services/service-fileindexer/InotifyHandler.cpp b/module-services/service-fileindexer/InotifyHandler.cpp
similarity index 100%
rename from products/PurePhone/services/service-fileindexer/InotifyHandler.cpp
rename to module-services/service-fileindexer/InotifyHandler.cpp
diff --git a/products/PurePhone/services/service-fileindexer/ServiceFileIndexer.cpp b/module-services/service-fileindexer/ServiceFileIndexer.cpp
similarity index 88%
rename from products/PurePhone/services/service-fileindexer/ServiceFileIndexer.cpp
rename to module-services/service-fileindexer/ServiceFileIndexer.cpp
index 2a195af578fc23fc50bcfd4e0042c15c87bbf417..05dbbdc18df95f78373c80ec609fc9ecca026202 100644
--- a/products/PurePhone/services/service-fileindexer/ServiceFileIndexer.cpp
+++ b/module-services/service-fileindexer/ServiceFileIndexer.cpp
@@ -19,9 +19,10 @@ namespace
 namespace service
 {
 
-    ServiceFileIndexer::ServiceFileIndexer(const std::string_view name) : sys::Service(std::string(name))
+    ServiceFileIndexer::ServiceFileIndexer(const std::vector<std::string> &paths)
+        : sys::Service{service::name::file_indexer}, mStartupIndexer{paths}
     {
-        LOG_DEBUG("[%s] Initializing", std::string(name).c_str());
+        LOG_DEBUG("[%s] Initializing", service::name::file_indexer);
     }
 
     sys::MessagePointer ServiceFileIndexer::DataReceivedHandler(sys::DataMessage *msgl, sys::ResponseMessage *resp)
diff --git a/products/PurePhone/services/service-fileindexer/StartupIndexer.cpp b/module-services/service-fileindexer/StartupIndexer.cpp
similarity index 97%
rename from products/PurePhone/services/service-fileindexer/StartupIndexer.cpp
rename to module-services/service-fileindexer/StartupIndexer.cpp
index 1fd5677970f43a7b0d92454615bb70a76115fbaf..56f9bf5a13d0f127c3a81109065b65370a02522e 100644
--- a/products/PurePhone/services/service-fileindexer/StartupIndexer.cpp
+++ b/module-services/service-fileindexer/StartupIndexer.cpp
@@ -18,9 +18,6 @@ namespace service::detail
     namespace
     {
         using namespace std::string_literals;
-
-        // List of initial dirs for scan
-        const std::vector<std::string> start_dirs{purefs::dir::getUserDiskPath() / "music"};
         // Lock file name
         const auto lock_file_name = purefs::dir::getUserDiskPath() / ".directory_is_indexed";
         // Time for indexing first unit
@@ -29,6 +26,9 @@ namespace service::detail
         constexpr auto timer_run_delay = 10000;
     } // namespace
 
+    StartupIndexer::StartupIndexer(const std::vector<std::string> &paths) : start_dirs{paths}
+    {}
+
     // Process single entry
     auto StartupIndexer::processEntry(std::shared_ptr<sys::Service> svc,
                                       const std::filesystem::recursive_directory_iterator::value_type &entry) -> void
diff --git a/products/PurePhone/services/service-fileindexer/include/service-fileindexer/Constants.hpp b/module-services/service-fileindexer/include/service-fileindexer/Constants.hpp
similarity index 100%
rename from products/PurePhone/services/service-fileindexer/include/service-fileindexer/Constants.hpp
rename to module-services/service-fileindexer/include/service-fileindexer/Constants.hpp
diff --git a/products/PurePhone/services/service-fileindexer/include/service-fileindexer/InotifyHandler.hpp b/module-services/service-fileindexer/include/service-fileindexer/InotifyHandler.hpp
similarity index 100%
rename from products/PurePhone/services/service-fileindexer/include/service-fileindexer/InotifyHandler.hpp
rename to module-services/service-fileindexer/include/service-fileindexer/InotifyHandler.hpp
diff --git a/products/PurePhone/services/service-fileindexer/include/service-fileindexer/ServiceFileIndexer.hpp b/module-services/service-fileindexer/include/service-fileindexer/ServiceFileIndexer.hpp
similarity index 94%
rename from products/PurePhone/services/service-fileindexer/include/service-fileindexer/ServiceFileIndexer.hpp
rename to module-services/service-fileindexer/include/service-fileindexer/ServiceFileIndexer.hpp
index bdde92b611b40d1d9c1b504241bb30ee5b4957b5..977f2c8f232fbf979b9f662eaf21bfed31c834c2 100644
--- a/products/PurePhone/services/service-fileindexer/include/service-fileindexer/ServiceFileIndexer.hpp
+++ b/module-services/service-fileindexer/include/service-fileindexer/ServiceFileIndexer.hpp
@@ -15,7 +15,7 @@ namespace service
     class ServiceFileIndexer final : public sys::Service
     {
       public:
-        ServiceFileIndexer(const std::string_view name = service::name::file_indexer);
+        ServiceFileIndexer(const std::vector<std::string> &paths);
         virtual ~ServiceFileIndexer()                  = default;
         ServiceFileIndexer(const ServiceFileIndexer &) = delete;
         ServiceFileIndexer &operator=(const ServiceFileIndexer &) = delete;
diff --git a/products/PurePhone/services/service-fileindexer/include/service-fileindexer/StartupIndexer.hpp b/module-services/service-fileindexer/include/service-fileindexer/StartupIndexer.hpp
similarity index 90%
rename from products/PurePhone/services/service-fileindexer/include/service-fileindexer/StartupIndexer.hpp
rename to module-services/service-fileindexer/include/service-fileindexer/StartupIndexer.hpp
index 79d9e74bb62ea2156a3b8ef5cbfa3deeb27ebe18..ea4064c5bdee8e3f35b02667503c2df92dddd217 100644
--- a/products/PurePhone/services/service-fileindexer/include/service-fileindexer/StartupIndexer.hpp
+++ b/module-services/service-fileindexer/include/service-fileindexer/StartupIndexer.hpp
@@ -13,7 +13,7 @@ namespace service::detail
     {
 
       public:
-        StartupIndexer()                       = default;
+        explicit StartupIndexer(const std::vector<std::string> &paths);
         ~StartupIndexer()                      = default;
         StartupIndexer(const StartupIndexer &) = delete;
         StartupIndexer &operator=(StartupIndexer) = delete;
@@ -41,5 +41,8 @@ namespace service::detail
         sys::TimerHandle mIdxTimer;
         bool mStarted{};
         bool mForceStop{};
+
+        // List of initial dirs for scan
+        const std::vector<std::string> start_dirs;
     };
 } // namespace service::detail
diff --git a/products/BellHybrid/BellHybridMain.cpp b/products/BellHybrid/BellHybridMain.cpp
index 115c5f4d23d1294b98877cc77509af442600aea2..6f6c4888f574e46e4f2c50841521fb76e206e118 100644
--- a/products/BellHybrid/BellHybridMain.cpp
+++ b/products/BellHybrid/BellHybridMain.cpp
@@ -15,7 +15,9 @@
 
 // modules
 #include <module-db/Databases/EventsDB.hpp>
+#include <module-db/Databases/MultimediaFilesDB.hpp>
 #include <module-db/Interface/AlarmEventRecord.hpp>
+#include <module-db/Interface/MultimediaFilesRecord.hpp>
 
 // services
 #include <appmgr/ApplicationManager.hpp>
@@ -28,6 +30,7 @@
 #include <service-eink/ServiceEink.hpp>
 #include <service-gui/ServiceGUI.hpp>
 #include <service-time/ServiceTime.hpp>
+#include <service-fileindexer/ServiceFileIndexer.hpp>
 
 #include <Application.hpp>
 #include <ApplicationLauncher.hpp>
@@ -47,6 +50,9 @@ int main()
 {
     constexpr auto ApplicationName = "BellHybrid";
 
+    const std::vector<std::string> fileIndexerAudioPaths = {
+        {purefs::dir::getCurrentOSPath() / "assets/audio/bell/bg_sounds"}};
+
 #if SYSTEM_VIEW_ENABLED
     SEGGER_SYSVIEW_Conf();
     SEGGER_SYSVIEW_DisableEvents(SYSVIEW_EVTMASK_ISR_ENTER);
@@ -68,6 +74,7 @@ int main()
 
     std::vector<std::unique_ptr<sys::BaseServiceCreator>> systemServices;
     systemServices.emplace_back(sys::CreatorFor<EventManager>([]() { return dumpLogs(); }));
+    systemServices.emplace_back(sys::CreatorFor<service::ServiceFileIndexer>(std::move(fileIndexerAudioPaths)));
     systemServices.emplace_back(sys::CreatorFor<ServiceDB>());
     systemServices.emplace_back(sys::CreatorFor<service::Audio>());
     systemServices.emplace_back(sys::CreatorFor<ServiceDesktop>());
diff --git a/products/BellHybrid/CMakeLists.txt b/products/BellHybrid/CMakeLists.txt
index 619315d737a9072fd390061011abd3081414774c..88dcede7d84fd27d14d189c42d2fe6d1c48bed7a 100644
--- a/products/BellHybrid/CMakeLists.txt
+++ b/products/BellHybrid/CMakeLists.txt
@@ -58,6 +58,7 @@ target_link_libraries(BellHybrid
         module-vfs
         service-desktop
         service-time
+        service-fileindexer
         sys
         bell::time
         platform
diff --git a/products/BellHybrid/apps/application-bell-background-sounds/ApplicationBellBackgroundSounds.cpp b/products/BellHybrid/apps/application-bell-background-sounds/ApplicationBellBackgroundSounds.cpp
index 2bfe1f1a94aee0624ace8643f80fd7763c183390..8e5b6cf5ce4e7a38495643ea00e751749ac9f56c 100644
--- a/products/BellHybrid/apps/application-bell-background-sounds/ApplicationBellBackgroundSounds.cpp
+++ b/products/BellHybrid/apps/application-bell-background-sounds/ApplicationBellBackgroundSounds.cpp
@@ -2,7 +2,6 @@
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
 #include "ApplicationBellBackgroundSounds.hpp"
-#include "models/BGSoundsRepository.hpp"
 #include "presenter/BGSoundsMainWindowPresenter.hpp"
 #include "presenter/BGSoundsTimerSelectPresenter.hpp"
 #include "presenter/BGSoundsProgressPresenter.hpp"
@@ -14,11 +13,19 @@
 #include "windows/BGSoundsVolumeWindow.hpp"
 #include "widgets/BGSoundsPlayer.hpp"
 #include <apps-common/messages/AppMessage.hpp>
+#include <apps-common/models/SongsRepository.hpp>
 #include <common/models/TimeModel.hpp>
 #include <common/models/AudioModel.hpp>
 #include <audio/AudioMessage.hpp>
 
 #include <log/log.hpp>
+
+namespace
+{
+    const auto backgroundSoundsFilesPath =
+        purefs::createPath(purefs::dir::getCurrentOSPath(), "assets/audio/bell/bg_sounds").string();
+}
+
 namespace app
 {
     ApplicationBellBackgroundSounds::ApplicationBellBackgroundSounds(std::string name,
@@ -48,8 +55,9 @@ namespace app
     void ApplicationBellBackgroundSounds::createUserInterface()
     {
         windowsFactory.attach(gui::name::window::main_window, [this](ApplicationCommon *app, const std::string &name) {
-            auto tagsFetcher      = std::make_unique<bgSounds::BGSoundsTagsFetcher>(app);
-            auto soundsRepository = std::make_shared<bgSounds::BGSoundsRepository>(std::move(tagsFetcher));
+            auto tagsFetcher = std::make_unique<app::music::ServiceAudioTagsFetcher>(app);
+            auto soundsRepository =
+                std::make_unique<app::music::SongsRepository>(app, std::move(tagsFetcher), backgroundSoundsFilesPath);
             auto presenter = std::make_unique<bgSounds::BGSoundsMainWindowPresenter>(std::move(soundsRepository));
             return std::make_unique<gui::BGSoundsMainWindow>(app, std::move(presenter));
         });
diff --git a/products/BellHybrid/apps/application-bell-background-sounds/CMakeLists.txt b/products/BellHybrid/apps/application-bell-background-sounds/CMakeLists.txt
index ece94e16e98c705ce95593158f2dfb4711519b68..af80ae4ba04a2556f1ea06bb510e34f3d5de5380 100644
--- a/products/BellHybrid/apps/application-bell-background-sounds/CMakeLists.txt
+++ b/products/BellHybrid/apps/application-bell-background-sounds/CMakeLists.txt
@@ -13,7 +13,6 @@ target_include_directories(application-bell-background-sounds
 target_sources(application-bell-background-sounds
     PRIVATE
         ApplicationBellBackgroundSounds.cpp
-        models/BGSoundsRepository.cpp
         presenter/BGSoundsMainWindowPresenter.cpp
         presenter/BGSoundsProgressPresenter.cpp
         presenter/BGSoundsTimerSelectPresenter.cpp
@@ -28,7 +27,6 @@ target_sources(application-bell-background-sounds
         data/BGSoundsCommon.hpp
         data/BGSoundsStyle.hpp
         data/BGSoundsAudioData.hpp
-        models/BGSoundsRepository.hpp
         widgets/BGSoundsPlayer.hpp
         windows/BGSoundsMainWindow.hpp
         presenter/BGSoundsMainWindowPresenter.hpp
diff --git a/products/BellHybrid/apps/application-bell-background-sounds/data/BGSoundsAudioData.hpp b/products/BellHybrid/apps/application-bell-background-sounds/data/BGSoundsAudioData.hpp
index b4fffd3b95eea86aa0b911fbe378869b81f73fa5..38e6624baf5a0b0e2514c89bc73aa0f369e1dabc 100644
--- a/products/BellHybrid/apps/application-bell-background-sounds/data/BGSoundsAudioData.hpp
+++ b/products/BellHybrid/apps/application-bell-background-sounds/data/BGSoundsAudioData.hpp
@@ -3,6 +3,7 @@
 
 #pragma once
 #include <SwitchData.hpp>
+#include <module-db/Interface/MultimediaFilesRecord.hpp>
 #include <tags_fetcher/TagsFetcher.hpp>
 
 #include <chrono>
@@ -13,14 +14,14 @@ namespace gui
 {
     class BGSoundsAudioContext
     {
-        tags::fetcher::Tags tags;
+        db::multimedia_files::MultimediaFilesRecord sound;
 
       public:
-        explicit BGSoundsAudioContext(const tags::fetcher::Tags &tags) : tags{tags}
+        explicit BGSoundsAudioContext(const db::multimedia_files::MultimediaFilesRecord &sound) : sound{sound}
         {}
-        [[nodiscard]] const tags::fetcher::Tags &getTags() const noexcept
+        [[nodiscard]] const db::multimedia_files::MultimediaFilesRecord &getSound() const noexcept
         {
-            return tags;
+            return sound;
         }
     };
 
diff --git a/products/BellHybrid/apps/application-bell-background-sounds/include/application-bell-background-sounds/ApplicationBellBackgroundSounds.hpp b/products/BellHybrid/apps/application-bell-background-sounds/include/application-bell-background-sounds/ApplicationBellBackgroundSounds.hpp
index f043c02b91c1ab5fe54c6fce94e2114e2dea8b67..54b46ebaebe609341de389e13f739cdf768dedb4 100644
--- a/products/BellHybrid/apps/application-bell-background-sounds/include/application-bell-background-sounds/ApplicationBellBackgroundSounds.hpp
+++ b/products/BellHybrid/apps/application-bell-background-sounds/include/application-bell-background-sounds/ApplicationBellBackgroundSounds.hpp
@@ -5,6 +5,7 @@
 
 #include <Application.hpp>
 #include <common/models/AbstractAudioModel.hpp>
+#include <purefs/filesystem_paths.hpp>
 
 namespace gui::window::name
 {
diff --git a/products/BellHybrid/apps/application-bell-background-sounds/models/BGSoundsRepository.cpp b/products/BellHybrid/apps/application-bell-background-sounds/models/BGSoundsRepository.cpp
index 8985ea56db39ef004b6b9061af15bbe7046318de..87ff9d147ac5783717ff53a897f083ad0d11672f 100644
--- a/products/BellHybrid/apps/application-bell-background-sounds/models/BGSoundsRepository.cpp
+++ b/products/BellHybrid/apps/application-bell-background-sounds/models/BGSoundsRepository.cpp
@@ -1,12 +1,12 @@
 // Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
-#include "BGSoundsRepository.hpp"
-
 #include <algorithm>
 #include <log/log.hpp>
 #include <time/ScopedTime.hpp>
 #include <tags_fetcher/TagsFetcher.hpp>
+#include <apps-common/models/SongsRepository.hpp>
+#include <module-db/queries/multimedia_files/QueryMultimediaFilesGetLimited.hpp>
 
 #include <filesystem>
 
@@ -20,41 +20,39 @@ namespace app::bgSounds
         return tags::fetcher::fetchTags(filePath);
     }
 
-    BGSoundsRepository::BGSoundsRepository(std::unique_ptr<AbstractTagsFetcher> tagsFetcher,
+    BGSoundsRepository::BGSoundsRepository(ApplicationCommon *application,
+                                           std::unique_ptr<AbstractTagsFetcher> tagsFetcher,
                                            std::string musicFolderName)
-        : tagsFetcher(std::move(tagsFetcher)), musicFolderName(std::move(musicFolderName))
+        : app::AsyncCallbackReceiver{application}, application{application}, tagsFetcher(std::move(tagsFetcher)),
+          musicFolderName(std::move(musicFolderName))
     {}
 
-    void BGSoundsRepository::scanMusicFilesList()
+    void BGSoundsRepository::getMusicFilesList(std::uint32_t offset,
+                                               std::uint32_t limit,
+                                               const OnGetMusicFilesListCallback &callback)
     {
-        musicFiles.clear();
-
-        LOG_INFO("Scanning music folder: %s", musicFolderName.c_str());
-        {
-            auto time = utils::time::Scoped("fetch tags time");
-            for (const auto &entry : std::filesystem::directory_iterator(musicFolderName)) {
-                if (!std::filesystem::is_directory(entry)) {
-                    const auto &filePath = entry.path();
-                    const auto fileTags  = tagsFetcher->getFileTags(filePath);
-                    if (fileTags) {
-                        musicFiles.push_back(*fileTags);
-                    }
-                    else {
-                        LOG_ERROR("Scanned not an audio file, skipped");
-                    }
-                }
+        auto query = std::make_unique<db::multimedia_files::query::GetLimited>(offset, limit);
+        auto task  = app::AsyncQuery::createFromQuery(std::move(query), db::Interface::Name::MultimediaFiles);
+
+        task->setCallback([this, callback, offset](auto response) {
+            auto result = dynamic_cast<db::multimedia_files::query::GetLimitedResult *>(response);
+            musicFilesViewCache.records.clear();
+
+            if (result == nullptr) {
+                return false;
             }
-            std::sort(
-                musicFiles.begin(), musicFiles.end(), [](const tags::fetcher::Tags &t1, const tags::fetcher::Tags &t2) {
-                    return t1.filePath < t2.filePath;
-                });
-        }
-        LOG_INFO("Total number of music files found: %u", static_cast<unsigned int>(musicFiles.size()));
-    }
 
-    std::vector<tags::fetcher::Tags> BGSoundsRepository::getMusicFilesList() const
-    {
-        return musicFiles;
-    }
+            for (auto &record : result->getResult()) {
+                musicFilesViewCache.records.push_back(record);
+            }
+            musicFilesViewCache.recordsOffset = offset;
+            musicFilesViewCache.recordsCount  = result->getCount();
 
+            if (callback) {
+                callback(musicFilesViewCache.records, musicFilesViewCache.recordsCount);
+            }
+            return true;
+        });
+        task->execute(application, this);
+    }
 } // namespace app::bgSounds
diff --git a/products/BellHybrid/apps/application-bell-background-sounds/models/BGSoundsRepository.hpp b/products/BellHybrid/apps/application-bell-background-sounds/models/BGSoundsRepository.hpp
index 418007834075ea7729dca0d96eee537f3aa9fe31..a54a5cd795a14f8a4726a24a5c7e696c13af2781 100644
--- a/products/BellHybrid/apps/application-bell-background-sounds/models/BGSoundsRepository.hpp
+++ b/products/BellHybrid/apps/application-bell-background-sounds/models/BGSoundsRepository.hpp
@@ -16,6 +16,13 @@
 
 namespace app::bgSounds
 {
+    struct FilesCache
+    {
+        std::vector<db::multimedia_files::MultimediaFilesRecord> records{};
+        std::uint32_t recordsOffset{0};
+        std::uint32_t recordsCount{0};
+    };
+
     class AbstractTagsFetcher
     {
       public:
@@ -40,25 +47,28 @@ namespace app::bgSounds
       public:
         virtual ~AbstractSoundsRepository() noexcept = default;
 
-        virtual void scanMusicFilesList()                                  = 0;
         virtual std::vector<tags::fetcher::Tags> getMusicFilesList() const = 0;
     };
 
-    class BGSoundsRepository : public AbstractSoundsRepository
+    class BGSoundsRepository : public AbstractSoundsRepository, public app::AsyncCallbackReceiver
     {
         static constexpr auto bgsoundsSubfolderPath = "assets/audio/bell/bg_sounds";
 
       public:
-        explicit BGSoundsRepository(std::unique_ptr<AbstractTagsFetcher> tagsFetcher,
-                                    std::string musicFolderName = purefs::dir::getCurrentOSPath() /
-                                                                  bgsoundsSubfolderPath);
+        using OnGetMusicFilesListCallback =
+            std::function<bool(const std::vector<db::multimedia_files::MultimediaFilesRecord> &, unsigned int)>;
 
-        void scanMusicFilesList() override;
-        std::vector<tags::fetcher::Tags> getMusicFilesList() const override;
+        BGSoundsRepository(ApplicationCommon *application,
+                           std::unique_ptr<AbstractTagsFetcher> tagsFetcher,
+                           std::string musicFolderName = purefs::dir::getCurrentOSPath() / bgsoundsSubfolderPath);
+
+        void getMusicFilesList(std::uint32_t offset, std::uint32_t limit, const OnGetMusicFilesListCallback &callback);
 
       private:
+        ApplicationCommon *application = nullptr;
         std::unique_ptr<AbstractTagsFetcher> tagsFetcher;
         std::string musicFolderName;
+        FilesCache musicFilesViewCache;
         std::vector<tags::fetcher::Tags> musicFiles;
     };
 } // namespace app::bgSounds
diff --git a/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsMainWindowPresenter.cpp b/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsMainWindowPresenter.cpp
index 4f9bbb94130db0b31895c511282dae8cb196adda..7f15ec95cd7f18a5391f9ba3444bbf9567bd221b 100644
--- a/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsMainWindowPresenter.cpp
+++ b/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsMainWindowPresenter.cpp
@@ -2,18 +2,32 @@
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
 #include "BGSoundsMainWindowPresenter.hpp"
-#include "models/BGSoundsRepository.hpp"
-#include <application-music-player/models/SongsRepository.hpp>
+#include <apps-common/models/SongsRepository.hpp>
+#include <purefs/filesystem_paths.hpp>
+
+namespace
+{
+    constexpr auto soundsRepoOffset = 0;
+    constexpr auto soundsRepoLimit  = 100;
+} // namespace
 
 namespace app::bgSounds
 {
-    BGSoundsMainWindowPresenter::BGSoundsMainWindowPresenter(std::shared_ptr<AbstractSoundsRepository> soundsRepository)
+    auto bgSoundsPath = purefs::dir::getCurrentOSPath() / "assets" / "audio" / "bell" / "bg_sounds";
+
+    BGSoundsMainWindowPresenter::BGSoundsMainWindowPresenter(
+        std::unique_ptr<app::music::AbstractSongsRepository> soundsRepository)
         : soundsRepository{std::move(soundsRepository)}
-    {
-        this->soundsRepository->scanMusicFilesList();
-    }
+    {}
     void BGSoundsMainWindowPresenter::loadAudioRecords()
     {
-        getView()->setSoundsList(soundsRepository->getMusicFilesList());
+        soundsRepository->getMusicFilesList(
+            soundsRepoOffset,
+            soundsRepoLimit,
+            [this](const std::vector<db::multimedia_files::MultimediaFilesRecord> &records,
+                   unsigned int repoRecordsCount) {
+                getView()->setSoundsList(records);
+                return true;
+            });
     }
 } // namespace app::bgSounds
diff --git a/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsMainWindowPresenter.hpp b/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsMainWindowPresenter.hpp
index cc787b1fe373577b9747806141c20f5a81c74401..a4c987d722a72be895f2eb588dfc819fdb82a970 100644
--- a/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsMainWindowPresenter.hpp
+++ b/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsMainWindowPresenter.hpp
@@ -4,11 +4,16 @@
 #pragma once
 
 #include <apps-common/BasePresenter.hpp>
+#include <module-db/Interface/MultimediaFilesRecord.hpp>
 #include <tags_fetcher/TagsFetcher.hpp>
 #include <memory>
 #include <string>
 #include <vector>
 
+namespace app::music
+{
+    class AbstractSongsRepository;
+}
 namespace app::bgSounds
 {
     class BGSoundsMainWindowContract
@@ -19,7 +24,7 @@ namespace app::bgSounds
           public:
             virtual ~View() = default;
 
-            virtual void setSoundsList(std::vector<tags::fetcher::Tags> soundsTags) = 0;
+            virtual void setSoundsList(std::vector<db::multimedia_files::MultimediaFilesRecord> songs) = 0;
         };
 
         class Presenter : public BasePresenter<BGSoundsMainWindowContract::View>
@@ -29,14 +34,13 @@ namespace app::bgSounds
         };
     };
 
-    class AbstractSoundsRepository;
     class BGSoundsMainWindowPresenter : public BGSoundsMainWindowContract::Presenter
     {
-        std::shared_ptr<AbstractSoundsRepository> soundsRepository;
+        std::unique_ptr<app::music::AbstractSongsRepository> soundsRepository;
         void loadAudioRecords() override;
 
       public:
-        explicit BGSoundsMainWindowPresenter(std::shared_ptr<AbstractSoundsRepository> soundsRepository);
+        explicit BGSoundsMainWindowPresenter(std::unique_ptr<app::music::AbstractSongsRepository> soundsRepository);
     };
 
 } // namespace app::bgSounds
diff --git a/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsProgressPresenter.cpp b/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsProgressPresenter.cpp
index 91bf8e10132b8db3f66aa49300a212f0be4dbabe..feb05eceaef567d6de63037640702d549fdd8665 100644
--- a/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsProgressPresenter.cpp
+++ b/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsProgressPresenter.cpp
@@ -27,7 +27,7 @@ namespace app::bgSounds
         timer->registerOnFinishedCallback([this]() { onFinished(); });
     }
 
-    void BGSoundsProgressPresenter::activate(const tags::fetcher::Tags &tags)
+    void BGSoundsProgressPresenter::activate(const db::multimedia_files::MultimediaFilesRecord &song)
     {
         Expects(timer != nullptr);
         AbstractBGSoundsPlayer::PlaybackMode mode;
@@ -37,7 +37,7 @@ namespace app::bgSounds
             mode = AbstractBGSoundsPlayer::PlaybackMode::Looped;
         }
         else {
-            timer->reset(std::chrono::seconds{tags.total_duration_s});
+            timer->reset(std::chrono::seconds{song.audioProperties.songLength});
             mode = AbstractBGSoundsPlayer::PlaybackMode::SingleShot;
         }
         auto onStartCallback = [this](audio::RetCode retCode) {
@@ -45,7 +45,7 @@ namespace app::bgSounds
                 timer->start();
             }
         };
-        player.start(tags.filePath, mode, std::move(onStartCallback));
+        player.start(song.fileInfo.path, mode, std::move(onStartCallback));
     }
     void BGSoundsProgressPresenter::stop()
     {
diff --git a/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsProgressPresenter.hpp b/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsProgressPresenter.hpp
index a04c3de21b7d102ac997e5d9bee3b29b390bcff4..7785027437419d42a8e4db238bf0e9d3d933c2c0 100644
--- a/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsProgressPresenter.hpp
+++ b/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsProgressPresenter.hpp
@@ -5,6 +5,7 @@
 
 #include <apps-common/BasePresenter.hpp>
 #include <apps-common/widgets/TimerWithCallbacks.hpp>
+#include <module-db/Interface/MultimediaFilesRecord.hpp>
 #include <tags_fetcher/TagsFetcher.hpp>
 #include <time/time_locale.hpp>
 #include <memory>
@@ -40,14 +41,14 @@ namespace app::bgSounds
         class Presenter : public BasePresenter<BGSoundsProgressContract::View>
         {
           public:
-            virtual void activate(const tags::fetcher::Tags &tags)                  = 0;
-            virtual void stop()                                                     = 0;
-            virtual void pause()                                                    = 0;
-            virtual void resume()                                                   = 0;
-            virtual void setTimer(std::unique_ptr<app::TimerWithCallbacks> &&timer) = 0;
-            virtual void handleUpdateTimeEvent()                                    = 0;
-            virtual bool isPaused()                                                 = 0;
-            virtual void onBeforeShow()                                             = 0;
+            virtual void activate(const db::multimedia_files::MultimediaFilesRecord &tags) = 0;
+            virtual void stop()                                                            = 0;
+            virtual void pause()                                                           = 0;
+            virtual void resume()                                                          = 0;
+            virtual void setTimer(std::unique_ptr<app::TimerWithCallbacks> &&timer)        = 0;
+            virtual void handleUpdateTimeEvent()                                           = 0;
+            virtual bool isPaused()                                                        = 0;
+            virtual void onBeforeShow()                                                    = 0;
         };
     };
 
@@ -60,7 +61,7 @@ namespace app::bgSounds
         std::unique_ptr<app::TimerWithCallbacks> timer;
         std::unique_ptr<AbstractTimeModel> timeModel;
 
-        void activate(const tags::fetcher::Tags &tags) override;
+        void activate(const db::multimedia_files::MultimediaFilesRecord &tags) override;
         void stop() override;
         void pause() override;
         void resume() override;
diff --git a/products/BellHybrid/apps/application-bell-background-sounds/windows/BGSoundsMainWindow.cpp b/products/BellHybrid/apps/application-bell-background-sounds/windows/BGSoundsMainWindow.cpp
index f2fee6b95d686b59f247e7043be55a77e4cfad08..527436f414d18324e22aa641129e94a2b00f2d9a 100644
--- a/products/BellHybrid/apps/application-bell-background-sounds/windows/BGSoundsMainWindow.cpp
+++ b/products/BellHybrid/apps/application-bell-background-sounds/windows/BGSoundsMainWindow.cpp
@@ -19,21 +19,21 @@ namespace gui
         buildInterface();
         setListTitle(utils::translate("app_bellmain_background_sounds"));
     }
-    void BGSoundsMainWindow::setSoundsList(std::vector<tags::fetcher::Tags> soundsTags)
+    void BGSoundsMainWindow::setSoundsList(std::vector<db::multimedia_files::MultimediaFilesRecord> sounds)
     {
         std::list<gui::Option> menuOptionList;
-        auto addRecord = [&](const tags::fetcher::Tags &soundTags) {
+        auto addRecord = [&](const db::multimedia_files::MultimediaFilesRecord &sound) {
             menuOptionList.emplace_back(std::make_unique<gui::option::OptionBellMenu>(
-                soundTags.title,
+                sound.tags.title,
                 [=](gui::Item &item) {
-                    onActivated(soundTags);
+                    onActivated(sound);
                     return true;
                 },
                 [=](gui::Item &item) { return true; },
                 this));
         };
-        for (const auto &tag : soundsTags) {
-            addRecord(tag);
+        for (const auto &sound : sounds) {
+            addRecord(sound);
         }
 
         addOptions(std::move(menuOptionList));
@@ -44,9 +44,9 @@ namespace gui
         presenter->loadAudioRecords();
     }
 
-    void BGSoundsMainWindow::onActivated(const tags::fetcher::Tags &selectedSoundTags)
+    void BGSoundsMainWindow::onActivated(const db::multimedia_files::MultimediaFilesRecord &selectedSound)
     {
-        auto audioContext = std::make_unique<BGSoundsAudioContext>(selectedSoundTags);
+        auto audioContext = std::make_unique<BGSoundsAudioContext>(selectedSound);
         auto switchData   = std::make_unique<BGSoundsSwitchData>(std::move(audioContext));
         application->switchWindow(gui::window::name::bgSoundsTimerSelect, std::move(switchData));
     }
diff --git a/products/BellHybrid/apps/application-bell-background-sounds/windows/BGSoundsMainWindow.hpp b/products/BellHybrid/apps/application-bell-background-sounds/windows/BGSoundsMainWindow.hpp
index 50b4bbbeae2365f405c13168acdda796c9a3efa0..16f60a883ca4a32a1d60eca4bc67dd06250da0af 100644
--- a/products/BellHybrid/apps/application-bell-background-sounds/windows/BGSoundsMainWindow.hpp
+++ b/products/BellHybrid/apps/application-bell-background-sounds/windows/BGSoundsMainWindow.hpp
@@ -11,10 +11,10 @@ namespace gui
     {
         std::unique_ptr<app::bgSounds::BGSoundsMainWindowContract::Presenter> presenter;
 
-        void setSoundsList(std::vector<tags::fetcher::Tags> soundsTags);
+        void setSoundsList(std::vector<db::multimedia_files::MultimediaFilesRecord> soundsTags);
         void buildInterface() override;
 
-        void onActivated(const tags::fetcher::Tags &selectedSoundTags);
+        void onActivated(const db::multimedia_files::MultimediaFilesRecord &selectedSound);
 
       public:
         BGSoundsMainWindow(app::ApplicationCommon *app,
diff --git a/products/BellHybrid/apps/application-bell-background-sounds/windows/BGSoundsProgressWindow.cpp b/products/BellHybrid/apps/application-bell-background-sounds/windows/BGSoundsProgressWindow.cpp
index e2ae98b27d2e9b8c2d5cae36eb1db9fa8eacf157..8e8f89fd0e327875aa8e6ec8e148ee14dd0f12f5 100644
--- a/products/BellHybrid/apps/application-bell-background-sounds/windows/BGSoundsProgressWindow.cpp
+++ b/products/BellHybrid/apps/application-bell-background-sounds/windows/BGSoundsProgressWindow.cpp
@@ -86,8 +86,8 @@ namespace gui
         if (data && typeid(*data) == typeid(BGSoundsSwitchData)) {
             auto *audioSwitchData = static_cast<BGSoundsSwitchData *>(data);
             audioContext          = audioSwitchData->getAudioContext();
-            title->setText(audioContext->getTags().title);
-            presenter->activate(audioContext->getTags());
+            title->setText(audioContext->getSound().tags.title);
+            presenter->activate(audioContext->getSound());
         }
     }
 
diff --git a/products/BellHybrid/services/db/ServiceDB.cpp b/products/BellHybrid/services/db/ServiceDB.cpp
index 88f0e2852e1e99aa4ccef5d91d3d09cf8a1d4ab2..5c2d11598fa3e2df60622eea55e2a1f7a1df161a 100644
--- a/products/BellHybrid/services/db/ServiceDB.cpp
+++ b/products/BellHybrid/services/db/ServiceDB.cpp
@@ -4,7 +4,10 @@
 #include <db/ServiceDB.hpp>
 
 #include <module-db/Databases/EventsDB.hpp>
+#include <module-db/Databases/MultimediaFilesDB.hpp>
+
 #include <module-db/Interface/AlarmEventRecord.hpp>
+#include <module-db/Interface/MultimediaFilesRecord.hpp>
 
 #include <service-db/DBServiceMessage.hpp>
 #include <service-db/agents/settings/SettingsAgent.hpp>
@@ -25,6 +28,8 @@ db::Interface *ServiceDB::getInterface(db::Interface::Name interface)
     switch (interface) {
     case db::Interface::Name::AlarmEvents:
         return alarmEventRecordInterface.get();
+    case db::Interface::Name::MultimediaFiles:
+        return multimediaFilesRecordInterface.get();
     default:
         LOG_INFO("Not supported interface");
     }
@@ -67,10 +72,14 @@ sys::ReturnCodes ServiceDB::InitHandler()
     }
 
     // Create databases
-    eventsDB = std::make_unique<EventsDB>((purefs::dir::getUserDiskPath() / "events.db").c_str());
+    eventsDB          = std::make_unique<EventsDB>((purefs::dir::getUserDiskPath() / "events.db").c_str());
+    multimediaFilesDB = std::make_unique<db::multimedia_files::MultimediaFilesDB>(
+        (purefs::dir::getUserDiskPath() / "multimedia.db").c_str());
 
     // Create record interfaces
     alarmEventRecordInterface = std::make_unique<AlarmEventRecordInterface>(eventsDB.get());
+    multimediaFilesRecordInterface =
+        std::make_unique<db::multimedia_files::MultimediaFilesRecordInterface>(multimediaFilesDB.get());
 
     databaseAgents.emplace(std::make_unique<SettingsAgent>(this, "settings_bell.db"));
 
diff --git a/products/BellHybrid/services/db/include/db/ServiceDB.hpp b/products/BellHybrid/services/db/include/db/ServiceDB.hpp
index 4b75f96532a85aac59ec3785ac562c92ff573c22..1da6834c0b1bdb2d81535b6c1f9a2e6a2b3dd66f 100644
--- a/products/BellHybrid/services/db/include/db/ServiceDB.hpp
+++ b/products/BellHybrid/services/db/include/db/ServiceDB.hpp
@@ -10,6 +10,11 @@ class AlarmEventRecordInterface;
 class EventsDB;
 
 class ThreadRecordInterface;
+namespace db::multimedia_files
+{
+    class MultimediaFilesDB;
+    class MultimediaFilesRecordInterface;
+} // namespace db::multimedia_files
 
 class ServiceDB : public ServiceDBCommon
 {
@@ -20,7 +25,10 @@ class ServiceDB : public ServiceDBCommon
 
   private:
     std::unique_ptr<EventsDB> eventsDB;
+    std::unique_ptr<db::multimedia_files::MultimediaFilesDB> multimediaFilesDB;
+
     std::unique_ptr<AlarmEventRecordInterface> alarmEventRecordInterface;
+    std::unique_ptr<db::multimedia_files::MultimediaFilesRecordInterface> multimediaFilesRecordInterface;
 
     db::Interface *getInterface(db::Interface::Name interface) override;
     sys::MessagePointer DataReceivedHandler(sys::DataMessage *msgl, sys::ResponseMessage *resp) override;
diff --git a/products/PurePhone/PurePhoneMain.cpp b/products/PurePhone/PurePhoneMain.cpp
index f501bc29cece7756b1190d07eac3ba38a3801e65..724c0580138108990e14a19102cbc42b205bc70b 100644
--- a/products/PurePhone/PurePhoneMain.cpp
+++ b/products/PurePhone/PurePhoneMain.cpp
@@ -75,6 +75,8 @@ int main()
 {
     constexpr auto ApplicationName = "PurePhone";
 
+    const std::vector<std::string> fileIndexerAudioPaths = {{purefs::dir::getUserDiskPath() / "music"}};
+
 #if SYSTEM_VIEW_ENABLED
     SEGGER_SYSVIEW_Conf();
     SEGGER_SYSVIEW_DisableEvents(SYSVIEW_EVTMASK_ISR_ENTER);
@@ -96,7 +98,7 @@ int main()
 
     std::vector<std::unique_ptr<sys::BaseServiceCreator>> systemServices;
     systemServices.emplace_back(sys::CreatorFor<EventManager>([]() { return dumpLogs(); }));
-    systemServices.emplace_back(sys::CreatorFor<service::ServiceFileIndexer>());
+    systemServices.emplace_back(sys::CreatorFor<service::ServiceFileIndexer>(std::move(fileIndexerAudioPaths)));
     systemServices.emplace_back(sys::CreatorFor<ServiceDB>());
 #if ENABLE_GSM == 0
     // For now disable permanently Service cellular when there is no GSM configured
diff --git a/products/PurePhone/services/CMakeLists.txt b/products/PurePhone/services/CMakeLists.txt
index 08a3f4e2bfe5192311e261de5baf6e306711a6a4..992fc2a71f167e85ca33fdefe66ebbfda52bd492 100644
--- a/products/PurePhone/services/CMakeLists.txt
+++ b/products/PurePhone/services/CMakeLists.txt
@@ -2,5 +2,4 @@ add_subdirectory(appmgr)
 add_subdirectory(evtmgr)
 add_subdirectory(db)
 add_subdirectory(desktop)
-add_subdirectory(service-fileindexer)
 add_subdirectory(time)