From cf019e3d9604bb7599f3bfb49d4cda47aff9815d Mon Sep 17 00:00:00 2001
From: Alek Rudnik <aleksander.rudnik@mudita.com>
Date: Tue, 27 Jul 2021 11:56:14 +0200
Subject: [PATCH] [EGD-6776] Music Player All Songs Window

Full MVP design.
Removed redundant Empty Window.
Added play/pause/resume/stop control.
---
 .../now_playing_icon_list.png                 | Bin 0 -> 635 bytes
 .../now_playing_icon_pause_list.png           | Bin 0 -> 541 bytes
 image/assets/images/now_playing_icon_list.vpi | Bin 0 -> 813 bytes
 .../images/now_playing_icon_pause_list.vpi    | Bin 0 -> 1021 bytes
 image/assets/lang/English.json                |   1 +
 .../ApplicationMusicPlayer.cpp                |  24 ++-
 .../AudioNotificationsHandler.cpp             |  26 +++
 .../AudioNotificationsHandler.hpp             |  21 +++
 .../application-music-player/CMakeLists.txt   |  10 +-
 .../data/MusicPlayerStyle.hpp                 |   8 +-
 .../models/SongContext.cpp                    |  30 ++++
 .../models/SongContext.hpp                    |  30 ++++
 .../models/SongsModel.cpp                     |  97 +++++++++--
 .../models/SongsModel.hpp                     |  25 ++-
 .../models/SongsModelInterface.hpp            |  26 +--
 .../models/SongsRepository.cpp                |  44 +++--
 .../models/SongsRepository.hpp                |  46 +++++-
 .../presenters/AudioOperations.cpp            |  43 +++--
 .../presenters/AudioOperations.hpp            |  18 ++-
 .../presenters/SongsPresenter.cpp             | 141 +++++++++++-----
 .../presenters/SongsPresenter.hpp             |  30 +++-
 .../tests/CMakeLists.txt                      |  12 ++
 .../tests/MockSongsRepository.hpp             |  24 +++
 .../tests/MockTagsFetcher.hpp                 |  20 +++
 .../tests/unittest.cpp                        |  10 ++
 .../tests/unittest_songrepository.cpp         | 153 ++++++++++++++++++
 .../tests/unittest_songsmodel.cpp             |  46 ++++++
 .../widgets/SongItem.cpp                      |  65 +++++++-
 .../widgets/SongItem.hpp                      |  35 ++--
 .../windows/MusicPlayerAllSongsWindow.cpp     |  59 ++++++-
 .../windows/MusicPlayerAllSongsWindow.hpp     |   9 +-
 .../windows/MusicPlayerEmptyWindow.cpp        |  80 ---------
 .../windows/MusicPlayerEmptyWindow.hpp        |  35 ----
 .../service-audio/ServiceAudio.cpp            |   2 -
 .../include/service-audio/AudioMessage.hpp    |   7 -
 35 files changed, 905 insertions(+), 272 deletions(-)
 create mode 100644 art/phone/application_musicplayer/now_playing_icon_list.png
 create mode 100644 art/phone/application_musicplayer/now_playing_icon_pause_list.png
 create mode 100644 image/assets/images/now_playing_icon_list.vpi
 create mode 100644 image/assets/images/now_playing_icon_pause_list.vpi
 create mode 100644 module-apps/application-music-player/AudioNotificationsHandler.cpp
 create mode 100644 module-apps/application-music-player/AudioNotificationsHandler.hpp
 create mode 100644 module-apps/application-music-player/models/SongContext.cpp
 create mode 100644 module-apps/application-music-player/models/SongContext.hpp
 create mode 100644 module-apps/application-music-player/tests/CMakeLists.txt
 create mode 100644 module-apps/application-music-player/tests/MockSongsRepository.hpp
 create mode 100644 module-apps/application-music-player/tests/MockTagsFetcher.hpp
 create mode 100644 module-apps/application-music-player/tests/unittest.cpp
 create mode 100644 module-apps/application-music-player/tests/unittest_songrepository.cpp
 create mode 100644 module-apps/application-music-player/tests/unittest_songsmodel.cpp
 delete mode 100644 module-apps/application-music-player/windows/MusicPlayerEmptyWindow.cpp
 delete mode 100644 module-apps/application-music-player/windows/MusicPlayerEmptyWindow.hpp

diff --git a/art/phone/application_musicplayer/now_playing_icon_list.png b/art/phone/application_musicplayer/now_playing_icon_list.png
new file mode 100644
index 0000000000000000000000000000000000000000..25d33b37d55fdd7621f4623cf9a1d267cc2d5dd0
GIT binary patch
literal 635
zcmeAS@N?(olHy`uVBq!ia0vp^3LwnE1|*BCs=fdzmUKs7M+SzC{oH>NS%G|u)CkWs
zUtb0-Ae)1Mu|1Q41;}CqVksbIU|?Fn1Q$_Qz>HvnB>VjwP68Fb^K@|xiQs%2W_#+8
zgTUM){w&$jYjeH`%sZ?X7M1x_RObx~w|4(S#hg7&PFn&Tt2Y+y+jHR1uH7f!v8nd*
ztE3r!ex_<|FI~W-C79T`@$v<G#(LLn59;<`eps;J^wUYZwnyo{DzUnfVe;qYgciLD
zyZL*f*6z6ex=^Cc<IZ;ZYae*bHk7jNl*lua&f9)FpD~p2lWoq!$4sjmZsr_w6tG|y
zcY44aFI~ji;2<Ej_m)cv*8z2%PtR5b6g<go4`i5hBK`c;1+Q#(Y!bSx!7y{pq>kS|
zYt99V6fO-qxkYf>C($`-608g6q@@4+pSRt+^4o7){&weeVXJ3u+azz{dx7Ono_X?I
zZX-p939|j}a{b3+R$nb@UEtpk-Kv(b`|dNLl}s!Tf7U#ES#s)YmF;EuJ6c;3OZLW1
zp8l2n*2kiqODy_U-hVI6>2qfm!{X(~lY+|RuDRSY$TFK9$8t!bIdfygg{r;Fjz3nM
zc7NRuFR3fGAAJv9etBf_$s?MalQmbhCF^n~K8$KxeDTHSR1U^%ZYB~u`)+r5<sbdQ
zwUkepgTYJoxWI?1y+MMm$Bb%n(ix8!gfYsUI8gSZC;i5=xr`}!>Wl>rNsFuk7R|Sr
z!lrP2*W^^j<DXJwCck+5V&2`n?H4xgnZVF(xBj@iyj$Ew;m7kE>gVS2r#n<x-36rp
MPgg&ebxsLQ03+B1%>V!Z

literal 0
HcmV?d00001

diff --git a/art/phone/application_musicplayer/now_playing_icon_pause_list.png b/art/phone/application_musicplayer/now_playing_icon_pause_list.png
new file mode 100644
index 0000000000000000000000000000000000000000..23194909a4f7825d9418e39b1681b046d9936b17
GIT binary patch
literal 541
zcmeAS@N?(olHy`uVBq!ia0vp^3LwnE1|*BCs=fdz#^NA%Cx&(BWL^R}E~ycoX}-P;
zT0k}j17mw80}DtA5K93u0|WB{Mh0de%?J`(zyz07Sip>6gA}f5OZp5{*6!)z7!twx
zHq5cl)j>da^2QCnJ6l_WEf~}%6bOeW=eBb1XpuD+u${L=-L3q!oblXyf2MmZUL9vU
zW!0w}d_^7n?Hl_q<TK7+HlJao5f8JeuXFAF%O<{Cbhuj+Jql%lr=^C7urAH?n)iI>
zB_T!5(u~{FR6UzguF7p_-m96%y5{w%RjV$sP33Hs|5F;k)lfX|d4E%}<A>{=0bCWo
zp4eE#A1r2H$x!3$R}j~%kWjs8qefTVo5xb$H`Z@^{=D2$k>kcT-<bu!<qK@i*qlG}
z{jah_SPb)x=Z@#Kg@pGQaWL&#H+fP+fz0vzzU!|`ZzMiF@XzwYPZ^-h)D7!i-+lkT
z@t0z=0>jZ`Yyo>x1Xvavy4lbbF3|8Pi&-nqks)h0?}`dm#ta>^1&>5o7OaLyPRnBU
zx|dy85XY%_B2)iC{*g@c7LMni8N@$+@jc*g-lNcVfw%B8*OQjDGcPzBOuo;TmJ#w|
zTEzNb!(|UQ>D1ebN^=_s{ygHQ;o|S{@6l(m2Y+~L7*ozBa%w$XvJVtBp00i_>zopr
E0BgL=YybcN

literal 0
HcmV?d00001

diff --git a/image/assets/images/now_playing_icon_list.vpi b/image/assets/images/now_playing_icon_list.vpi
new file mode 100644
index 0000000000000000000000000000000000000000..fb956b98bb5edbafaf041ce9b07ee04fa5148673
GIT binary patch
literal 813
zcmbVL?Gl1849oZ!AmTWmfcJk&ld!2AqMScUuSwQ+U0JYT4gi+4|8~Tu1cV#y3RIWX
zE1r_rQS3mgfyh{1@o07sJJKqEN9`34sb$oQ?ExmU?~QgDoio}QjXBd@C^N(t%G^fj
zV`4hA(y|BlLm;pin>W@b^<hQnm{ib-iN+)DliaFo#IQl#RTHRlEG0{rYn;<cDvHuI
zG&ceTdsDJZL49K>*{9|b$o-`}U;WgL&Q0m}#C0dX-{z&BC|`5?s-HJtzb%^I@rH^0
NzMaRLz5f$d<N;o|3-<s3

literal 0
HcmV?d00001

diff --git a/image/assets/images/now_playing_icon_pause_list.vpi b/image/assets/images/now_playing_icon_pause_list.vpi
new file mode 100644
index 0000000000000000000000000000000000000000..8ce231066d5e86c2d3ffe301118b2f9aaef4b80f
GIT binary patch
literal 1021
zcmbW0YZ8Jm41|MH9)ebH!2M6@ehY)lfC~I5A)8I}XfnhQ&mtm*y#98=yBtyUI<?MK
zM>Lq0=-{&VSwGRjmK)3#77XdPoTN2atB5-m$<}BMT1H4%Hb$$7`<l3QCYuDRA34w2
zD8!tNaqO8GX3I=$XNC78!XA>vberu0N3Rl875Oe*b3tEJZC$wS;w8tjms+sPOT2{_
zk;(91EGqfLQbxPH#7piS8S+NI;$S};gO0lk=ju7vyTk8vd?t>~9kaBaUC`}0U+)BO
R@O_WSX8%sIsau;p;%{pQ44MD{

literal 0
HcmV?d00001

diff --git a/image/assets/lang/English.json b/image/assets/lang/English.json
index f782d9c6914df1bb223e3ff7a23498ddd7b71081..14bfac10e8190b307b8edeac4de48bf965c517ae 100644
--- a/image/assets/lang/English.json
+++ b/image/assets/lang/English.json
@@ -513,6 +513,7 @@
   "app_meditation_minutes": "MINUTES",
   "app_music_player_all_songs": "All songs",
   "app_music_player_play": "PLAY",
+  "app_music_player_music_library_window_name": "Music Library",
   "app_music_player_music_library": "MUSIC LIBRARY",
   "app_music_player_quit": "QUIT",
   "app_music_player_music_empty_window_notification": "Press Music Library to choose\n a song from the library",
diff --git a/module-apps/application-music-player/ApplicationMusicPlayer.cpp b/module-apps/application-music-player/ApplicationMusicPlayer.cpp
index d2c1bb9955cfedbf20375f1b3fdb1a6394aec331..27763a1dc286285e7eaaebed62a09ea539db69e6 100644
--- a/module-apps/application-music-player/ApplicationMusicPlayer.cpp
+++ b/module-apps/application-music-player/ApplicationMusicPlayer.cpp
@@ -2,8 +2,10 @@
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
 #include <application-music-player/ApplicationMusicPlayer.hpp>
+
+#include "AudioNotificationsHandler.hpp"
+
 #include <windows/MusicPlayerAllSongsWindow.hpp>
-#include <windows/MusicPlayerEmptyWindow.hpp>
 #include <presenters/AudioOperations.hpp>
 #include <presenters/SongsPresenter.hpp>
 #include <models/SongsRepository.hpp>
@@ -40,14 +42,17 @@ namespace app
     {
         LOG_INFO("ApplicationMusicPlayer::create");
 
-        auto songsRepository = std::make_unique<app::music_player::SongsRepository>(this);
+        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>(std::move(tagsFetcher));
         priv->songsModel     = std::make_unique<app::music_player::SongsModel>(std::move(songsRepository));
         auto audioOperations = std::make_unique<app::music_player::AudioOperations>(this);
         priv->songsPresenter =
             std::make_unique<app::music_player::SongsPresenter>(priv->songsModel, std::move(audioOperations));
 
         // callback used when playing state is changed
-        using SongState                                 = music_player::SongsModelInterface::SongState;
+        using SongState                                 = app::music_player::SongState;
         std::function<void(SongState)> autolockCallback = [this](SongState isPlaying) {
             if (isPlaying == SongState::Playing) {
                 LOG_DEBUG("Preventing autolock while playing track.");
@@ -64,6 +69,12 @@ namespace app
         // callback used when track is not played and we are in DetermineByAppState
         std::function<bool()> stateLockCallback = []() -> bool { return true; };
         lockPolicyHandler.setPreventsAutoLockByStateCallback(std::move(stateLockCallback));
+
+        connect(typeid(AudioStopNotification), [&](sys::Message *msg) -> sys::MessagePointer {
+            auto notification = static_cast<AudioStopNotification *>(msg);
+            music_player::AudioNotificationsHandler audioNotificationHandler{priv->songsPresenter};
+            return audioNotificationHandler.handleAudioStopNotification(notification);
+        });
     }
 
     ApplicationMusicPlayer::~ApplicationMusicPlayer() = default;
@@ -96,24 +107,21 @@ namespace app
         }
 
         createUserInterface();
-
         return ret;
     }
 
     sys::ReturnCodes ApplicationMusicPlayer::DeinitHandler()
     {
+        priv->songsPresenter->getMusicPlayerItemProvider()->clearData();
         priv->songsPresenter->stop();
         return Application::DeinitHandler();
     }
 
     void ApplicationMusicPlayer::createUserInterface()
     {
-        windowsFactory.attach(gui::name::window::all_songs_window, [&](Application *app, const std::string &name) {
+        windowsFactory.attach(gui::name::window::main_window, [&](Application *app, const std::string &name) {
             return std::make_unique<gui::MusicPlayerAllSongsWindow>(app, priv->songsPresenter);
         });
-        windowsFactory.attach(gui::name::window::main_window, [](Application *app, const std::string &name) {
-            return std::make_unique<gui::MusicPlayerEmptyWindow>(app);
-        });
 
         attachPopups(
             {gui::popup::ID::Volume, gui::popup::ID::Tethering, gui::popup::ID::PhoneModes, gui::popup::ID::PhoneLock});
diff --git a/module-apps/application-music-player/AudioNotificationsHandler.cpp b/module-apps/application-music-player/AudioNotificationsHandler.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..56a7ddf8bd4c2be58cb4d41172c9aeb14028cc79
--- /dev/null
+++ b/module-apps/application-music-player/AudioNotificationsHandler.cpp
@@ -0,0 +1,26 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#include "AudioNotificationsHandler.hpp"
+
+#include <service-audio/AudioMessage.hpp>
+
+namespace app::music_player
+{
+
+    AudioNotificationsHandler::AudioNotificationsHandler(
+        std::shared_ptr<app::music_player::SongsContract::Presenter> presenter)
+        : presenter(presenter)
+    {}
+
+    sys::MessagePointer AudioNotificationsHandler::handleAudioStopNotification(
+        const AudioStopNotification *notification)
+    {
+        if (notification == nullptr) {
+            return sys::msgNotHandled();
+        }
+
+        return presenter->handleAudioStopNotifiaction(notification->token) ? sys::msgNotHandled() : sys::msgHandled();
+    }
+
+} // namespace app::music_player
diff --git a/module-apps/application-music-player/AudioNotificationsHandler.hpp b/module-apps/application-music-player/AudioNotificationsHandler.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..517c7d6f3ed4f1fbdbb7bf4518c3afc09b900ccb
--- /dev/null
+++ b/module-apps/application-music-player/AudioNotificationsHandler.hpp
@@ -0,0 +1,21 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#pragma once
+
+#include <presenters/SongsPresenter.hpp>
+
+class AudioStopNotification;
+namespace app::music_player
+{
+    class AudioNotificationsHandler
+    {
+      public:
+        explicit AudioNotificationsHandler(std::shared_ptr<app::music_player::SongsContract::Presenter> presenter);
+
+        sys::MessagePointer handleAudioStopNotification(const AudioStopNotification *notification);
+
+      private:
+        std::shared_ptr<app::music_player::SongsContract::Presenter> presenter;
+    };
+} // namespace app::music_player
diff --git a/module-apps/application-music-player/CMakeLists.txt b/module-apps/application-music-player/CMakeLists.txt
index 12978a398a8c0d1664c17fef6a17db0ac7828165..94caca52fedfa62435d1fdddf17593b4d4dffa1c 100644
--- a/module-apps/application-music-player/CMakeLists.txt
+++ b/module-apps/application-music-player/CMakeLists.txt
@@ -13,6 +13,8 @@ target_include_directories(application-music-player
 target_sources(application-music-player
     PRIVATE
         ApplicationMusicPlayer.cpp
+        AudioNotificationsHandler.cpp
+        models/SongContext.cpp
         models/SongsModel.cpp
         models/SongsRepository.cpp
         presenters/AudioOperations.cpp
@@ -20,9 +22,10 @@ target_sources(application-music-player
         widgets/Action.cpp
         widgets/SongItem.cpp
         windows/MusicPlayerAllSongsWindow.cpp
-        windows/MusicPlayerEmptyWindow.cpp
     PRIVATE
+        AudioNotificationsHandler.hpp
         data/MusicPlayerStyle.hpp
+        models/SongContext.hpp
         models/SongsModel.hpp
         models/SongsRepository.hpp
         models/SongsModelInterface.hpp
@@ -31,7 +34,6 @@ target_sources(application-music-player
         widgets/Action.hpp
         widgets/SongItem.hpp
         windows/MusicPlayerAllSongsWindow.hpp
-        windows/MusicPlayerEmptyWindow.hpp
     PUBLIC
         include/application-music-player/ApplicationMusicPlayer.hpp
 )
@@ -54,3 +56,7 @@ target_link_libraries(application-music-player
         apps-common
         module-audio
 )
+
+if (${ENABLE_TESTS})
+    add_subdirectory(tests)
+endif()
diff --git a/module-apps/application-music-player/data/MusicPlayerStyle.hpp b/module-apps/application-music-player/data/MusicPlayerStyle.hpp
index d7369f6d5f8d7f8ffa4bde33fdec9a180a6ad71e..394cd41540568a21ce760b374d1750d252a804a6 100644
--- a/module-apps/application-music-player/data/MusicPlayerStyle.hpp
+++ b/module-apps/application-music-player/data/MusicPlayerStyle.hpp
@@ -101,13 +101,13 @@ namespace musicPlayerStyle
         constexpr uint32_t w = style::window::default_body_width;
         constexpr uint32_t h = 100;
 
-        constexpr uint32_t bold_text_h = 24;
-        constexpr uint32_t text_h      = 22;
+        constexpr uint32_t bold_text_h = 33;
+        constexpr uint32_t text_h      = 33;
         constexpr uint32_t duration_w  = 50;
 
-        constexpr int32_t topMargin   = 18;
+        constexpr int32_t topMargin   = 16;
         constexpr int32_t leftMargin  = 10;
-        constexpr int32_t rightMargin = 10;
+        constexpr int32_t rightMargin = 4;
 
     } // namespace songItem
 
diff --git a/module-apps/application-music-player/models/SongContext.cpp b/module-apps/application-music-player/models/SongContext.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0e4f26f6570a2baa0a8ee9f5b3d2dffd2da6b8fc
--- /dev/null
+++ b/module-apps/application-music-player/models/SongContext.cpp
@@ -0,0 +1,30 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#include "SongContext.hpp"
+#include <optional>
+
+namespace app::music_player
+{
+    void SongContext::clear()
+    {
+        currentSongState = SongState::NotPlaying;
+        currentFileToken = std::nullopt;
+        filePath         = "";
+    }
+
+    bool SongContext::isValid() const
+    {
+        return (currentFileToken && currentFileToken->IsValid() && !filePath.empty());
+    }
+
+    bool SongContext::isPlaying() const
+    {
+        return isValid() && currentSongState == SongState::Playing;
+    }
+
+    bool SongContext::isPaused() const
+    {
+        return isValid() && currentSongState == SongState::NotPlaying;
+    }
+} // namespace app::music_player
diff --git a/module-apps/application-music-player/models/SongContext.hpp b/module-apps/application-music-player/models/SongContext.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..f6e8d6fefdbf404a046df74ab3f631f2d5cfcb9d
--- /dev/null
+++ b/module-apps/application-music-player/models/SongContext.hpp
@@ -0,0 +1,30 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+#pragma once
+
+#include <Audio/decoder/Decoder.hpp>
+
+namespace app::music_player
+{
+
+    enum class SongState
+    {
+        Playing,
+        NotPlaying
+    };
+
+    struct SongContext
+    {
+      public:
+        SongState currentSongState = SongState::NotPlaying;
+        std::optional<audio::Token> currentFileToken;
+        std::string filePath;
+
+        void clear();
+
+        bool isPlaying() const;
+        bool isPaused() const;
+        bool isValid() const;
+    };
+
+} // namespace app::music_player
diff --git a/module-apps/application-music-player/models/SongsModel.cpp b/module-apps/application-music-player/models/SongsModel.cpp
index 5e36225afeeffe14078900c0a0ef7f8f6d5e5c92..afc0f6605b5e27c3a380d8630a6f1f342df9f2d0 100644
--- a/module-apps/application-music-player/models/SongsModel.cpp
+++ b/module-apps/application-music-player/models/SongsModel.cpp
@@ -2,6 +2,7 @@
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
 #include "SongsModel.hpp"
+#include "Style.hpp"
 #include "application-music-player/widgets/SongItem.hpp"
 
 #include <ListView.hpp>
@@ -22,7 +23,7 @@ namespace app::music_player
 
     auto SongsModel::getMinimalItemSpaceRequired() const -> unsigned int
     {
-        return musicPlayerStyle::songItem::h;
+        return musicPlayerStyle::songItem::h + style::margins::small * 2;
     }
 
     void SongsModel::requestRecords(const uint32_t offset, const uint32_t limit)
@@ -36,51 +37,115 @@ namespace app::music_player
         return getRecord(order);
     }
 
-    void SongsModel::createData(std::function<bool(const std::string &fileName)> func)
+    void SongsModel::createData(OnShortReleaseCallback shortReleaseCallback,
+                                OnLongPressCallback longPressCallback,
+                                OnSetBottomBarTemporaryCallback bottomBarTemporaryMode,
+                                OnRestoreBottomBarTemporaryCallback bottomBarRestoreFromTemporaryMode)
     {
+        songsRepository->scanMusicFilesList();
         auto songsList = songsRepository->getMusicFilesList();
         for (const auto &song : songsList) {
-            auto item = new gui::SongItem(song.artist, song.title, utils::time::Duration(song.total_duration_s).str());
+            auto item = new gui::SongItem(song.artist,
+                                          song.title,
+                                          utils::time::Duration(song.total_duration_s).str(),
+                                          bottomBarTemporaryMode,
+                                          bottomBarRestoreFromTemporaryMode);
 
             item->activatedCallback = [=](gui::Item &) {
-                func(song.filePath);
+                shortReleaseCallback(song.filePath);
                 return true;
             };
 
+            item->inputCallback = [longPressCallback](gui::Item &, const gui::InputEvent &event) {
+                if (event.isLongRelease(gui::KeyCode::KEY_ENTER)) {
+                    longPressCallback();
+                    return true;
+                }
+                return false;
+            };
+
             internalData.push_back(item);
         }
 
         for (auto &item : internalData) {
             item->deleteByList = false;
         }
+    }
 
-        list->rebuildList();
+    bool SongsModel::isSongPlaying() const noexcept
+    {
+        return songContext.currentSongState == SongState::Playing;
     }
 
-    void SongsModel::clearData()
+    void SongsModel::setCurrentSongState(SongState songState) noexcept
     {
-        list->reset();
+        songContext.currentSongState = songState;
+        updateCurrentItemState();
+    }
 
-        list->rebuildList();
+    std::optional<audio::Token> SongsModel::getCurrentFileToken() const noexcept
+    {
+        return songContext.currentFileToken;
     }
 
-    bool SongsModel::isSongPlaying() const noexcept
+    size_t SongsModel::getCurrentIndex() const
     {
-        return currentSongState == SongState::Playing;
+        auto index = songsRepository->getFileIndex(songContext.filePath);
+        return index == std::numeric_limits<size_t>::max() ? 0 : index;
     }
 
-    void SongsModel::setCurrentSongState(SongState songState) noexcept
+    SongContext SongsModel::getCurrentSongContext() const noexcept
     {
-        currentSongState = songState;
+        return songContext;
     }
 
-    std::optional<audio::Token> SongsModel::getCurrentFileToken() const noexcept
+    void SongsModel::setCurrentSongContext(SongContext context)
     {
-        return currentFileToken;
+        using namespace gui;
+        clearCurrentItemState();
+
+        songContext = context;
+
+        updateCurrentItemState();
     }
 
-    void SongsModel::setCurrentFileToken(std::optional<audio::Token> token) noexcept
+    void SongsModel::clearCurrentSongContext()
     {
-        currentFileToken = token;
+        clearCurrentItemState();
+        songContext.clear();
+    }
+
+    void SongsModel::clearCurrentItemState()
+    {
+        using namespace gui;
+        const auto songIndex = getCurrentIndex();
+        if (songIndex < internalData.size()) {
+            internalData[songIndex]->setState(SongItem::ItemState::None);
+        }
+    }
+
+    void SongsModel::updateCurrentItemState()
+    {
+        using namespace gui;
+        const auto songIndex = getCurrentIndex();
+        if (songIndex >= internalData.size()) {
+            return;
+        }
+
+        if (songContext.isPlaying()) {
+            internalData[songIndex]->setState(SongItem::ItemState::Playing);
+        }
+        else if (songContext.isPaused()) {
+            internalData[songIndex]->setState(SongItem::ItemState::Paused);
+        }
+        else {
+            internalData[songIndex]->setState(SongItem::ItemState::None);
+        }
+    }
+
+    void SongsModel::clearData()
+    {
+        list->reset();
+        eraseInternalData();
     }
 } // namespace app::music_player
diff --git a/module-apps/application-music-player/models/SongsModel.hpp b/module-apps/application-music-player/models/SongsModel.hpp
index 688699fc0e1471c8e0fd9698d8208e39a85a4fb8..af0cb321e9f10d43b5b1cae1bcda2556d0db98aa 100644
--- a/module-apps/application-music-player/models/SongsModel.hpp
+++ b/module-apps/application-music-player/models/SongsModel.hpp
@@ -5,6 +5,7 @@
 
 #include "module-apps/application-music-player/data/MusicPlayerStyle.hpp"
 
+#include "SongContext.hpp"
 #include "SongsRepository.hpp"
 #include "SongsModelInterface.hpp"
 
@@ -17,8 +18,10 @@ namespace app::music_player
       public:
         explicit SongsModel(std::shared_ptr<AbstractSongsRepository> songsRepository);
 
-        void clearData();
-        void createData(std::function<bool(const std::string &fileName)>) override;
+        void createData(OnShortReleaseCallback shortReleaseCallback,
+                        OnLongPressCallback longPressCallback,
+                        OnSetBottomBarTemporaryCallback bottomBarTemporaryMode,
+                        OnRestoreBottomBarTemporaryCallback bottomBarRestoreFromTemporaryMode) override;
 
         [[nodiscard]] auto requestRecordsCount() -> unsigned int override;
 
@@ -26,17 +29,25 @@ namespace app::music_player
 
         auto getItem(gui::Order order) -> gui::ListItem * override;
 
-        void requestRecords(const uint32_t offset, const uint32_t limit) override;
+        void requestRecords(uint32_t offset, uint32_t limit) override;
+
+        size_t getCurrentIndex() const override;
 
         bool isSongPlaying() const noexcept override;
         void setCurrentSongState(SongState songState) noexcept override;
         std::optional<audio::Token> getCurrentFileToken() const noexcept override;
-        void setCurrentFileToken(std::optional<audio::Token> token) noexcept override;
 
-      protected:
-        SongState currentSongState = SongState::NotPlaying;
+        SongContext getCurrentSongContext() const noexcept override;
+        void setCurrentSongContext(SongContext context) override;
+        void clearCurrentSongContext() override;
+
+        void clearData() override;
+
+      private:
+        void clearCurrentItemState();
+        void updateCurrentItemState();
+        SongContext songContext;
 
-        std::optional<audio::Token> currentFileToken;
         std::shared_ptr<AbstractSongsRepository> songsRepository;
     };
 } // namespace app::music_player
diff --git a/module-apps/application-music-player/models/SongsModelInterface.hpp b/module-apps/application-music-player/models/SongsModelInterface.hpp
index c3e8384a260dedcb5432c0d8b177a16f5bdf442c..184b21063c506588e6913e1f872004b3b8f61bf4 100644
--- a/module-apps/application-music-player/models/SongsModelInterface.hpp
+++ b/module-apps/application-music-player/models/SongsModelInterface.hpp
@@ -3,18 +3,30 @@
 
 #pragma once
 
+#include "SongContext.hpp"
+#include <widgets/SongItem.hpp>
 #include <InternalModel.hpp>
 #include <ListItemProvider.hpp>
 #include <apps-common/Application.hpp>
 
 namespace app::music_player
 {
-    class SongsListItemProvider : public app::InternalModel<gui::ListItem *>, public gui::ListItemProvider
+    class SongsListItemProvider : public app::InternalModel<gui::SongItem *>, public gui::ListItemProvider
     {
       public:
+        using OnShortReleaseCallback              = std::function<bool(const std::string &fileName)>;
+        using OnLongPressCallback                 = std::function<void()>;
+        using OnSetBottomBarTemporaryCallback     = std::function<void(const UTF8 &)>;
+        using OnRestoreBottomBarTemporaryCallback = std::function<void()>;
+
         virtual ~SongsListItemProvider() noexcept = default;
 
-        virtual void createData(std::function<bool(const std::string &fileName)>) = 0;
+        virtual void createData(OnShortReleaseCallback shortReleaseCallback,
+                                OnLongPressCallback longPressCallback,
+                                OnSetBottomBarTemporaryCallback bottomBarTemporaryMode,
+                                OnRestoreBottomBarTemporaryCallback bottomBarRestoreFromTemporaryMode) = 0;
+        virtual size_t getCurrentIndex() const                                                         = 0;
+        virtual void clearData()                                                                       = 0;
     };
 
     class SongsModelInterface : public SongsListItemProvider
@@ -22,15 +34,11 @@ namespace app::music_player
       public:
         virtual ~SongsModelInterface() noexcept = default;
 
-        enum class SongState
-        {
-            Playing,
-            NotPlaying
-        };
-
         virtual bool isSongPlaying() const noexcept                              = 0;
         virtual void setCurrentSongState(SongState songState) noexcept           = 0;
         virtual std::optional<audio::Token> getCurrentFileToken() const noexcept = 0;
-        virtual void setCurrentFileToken(std::optional<audio::Token>) noexcept   = 0;
+        virtual SongContext getCurrentSongContext() const noexcept               = 0;
+        virtual void setCurrentSongContext(SongContext context)                  = 0;
+        virtual void clearCurrentSongContext()                                   = 0;
     };
 } // namespace app::music_player
diff --git a/module-apps/application-music-player/models/SongsRepository.cpp b/module-apps/application-music-player/models/SongsRepository.cpp
index 7f8ea2c2ac37909db37d0ae8458ed7af8724cef0..86270929834ed91f53f29b02d447abb8d5fbcefe 100644
--- a/module-apps/application-music-player/models/SongsRepository.cpp
+++ b/module-apps/application-music-player/models/SongsRepository.cpp
@@ -3,47 +3,67 @@
 
 #include "SongsRepository.hpp"
 
+#include <algorithm>
 #include <log.hpp>
 #include <service-audio/AudioServiceAPI.hpp>
 #include <service-audio/AudioServiceName.hpp>
 #include <time/ScopedTime.hpp>
-#include <purefs/filesystem_paths.hpp>
 #include <service-audio/AudioMessage.hpp>
 
 #include <filesystem>
 
 namespace app::music_player
 {
-    SongsRepository::SongsRepository(Application *application) : application(application)
+    ServiceAudioTagsFetcher::ServiceAudioTagsFetcher(Application *application) : application(application)
     {}
 
-    std::vector<audio::Tags> SongsRepository::getMusicFilesList()
+    std::optional<audio::Tags> ServiceAudioTagsFetcher::getFileTags(const std::string &filePath) const
     {
-        const auto musicFolder = purefs::dir::getUserDiskPath() / "music";
-        std::vector<audio::Tags> musicFiles;
-        LOG_INFO("Scanning music folder: %s", musicFolder.c_str());
+        return AudioServiceAPI::GetFileTags(application, filePath);
+    }
+
+    SongsRepository::SongsRepository(std::unique_ptr<AbstractTagsFetcher> tagsFetcher, std::string musicFolderName)
+        : tagsFetcher(std::move(tagsFetcher)), musicFolderName(std::move(musicFolderName))
+    {}
+
+    void SongsRepository::scanMusicFilesList()
+    {
+        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(musicFolder)) {
+            for (const auto &entry : std::filesystem::directory_iterator(musicFolderName)) {
                 if (!std::filesystem::is_directory(entry)) {
                     const auto &filePath = entry.path();
-                    const auto fileTags  = getFileTags(filePath);
+                    const auto fileTags  = tagsFetcher->getFileTags(filePath);
                     if (fileTags) {
                         musicFiles.push_back(*fileTags);
-                        LOG_DEBUG(" - file %s found", entry.path().c_str());
                     }
                     else {
-                        LOG_ERROR("Not an audio file %s", entry.path().c_str());
+                        LOG_ERROR("Scanned not an audio file, skipped");
                     }
                 }
             }
         }
         LOG_INFO("Total number of music files found: %u", static_cast<unsigned int>(musicFiles.size()));
+    }
+
+    std::vector<audio::Tags> SongsRepository::getMusicFilesList() const
+    {
         return musicFiles;
     }
 
-    std::optional<audio::Tags> SongsRepository::getFileTags(const std::string &filePath)
+    std::size_t SongsRepository::getFileIndex(const std::string &filePath) const
     {
-        return AudioServiceAPI::GetFileTags(application, filePath);
+        auto it = std::find_if(musicFiles.begin(), musicFiles.end(), [filePath](const auto &musicFile) {
+            return musicFile.filePath == filePath;
+        });
+
+        if (it != musicFiles.end()) {
+            return std::distance(musicFiles.begin(), it);
+        }
+
+        return std::numeric_limits<size_t>::max();
     }
 } // namespace app::music_player
diff --git a/module-apps/application-music-player/models/SongsRepository.hpp b/module-apps/application-music-player/models/SongsRepository.hpp
index 170e41d6621357ab982c8fefb372a5bab586ca02..49a23a5caee0824b421ef461388be6181887e940 100644
--- a/module-apps/application-music-player/models/SongsRepository.hpp
+++ b/module-apps/application-music-player/models/SongsRepository.hpp
@@ -5,27 +5,61 @@
 
 #include <apps-common/Application.hpp>
 #include <Audio/decoder/Decoder.hpp>
+#include <purefs/filesystem_paths.hpp>
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include <cstddef>
 
 namespace app::music_player
 {
+    class AbstractTagsFetcher
+    {
+      public:
+        virtual ~AbstractTagsFetcher() noexcept = default;
+
+        virtual std::optional<audio::Tags> getFileTags(const std::string &filePath) const = 0;
+    };
+
+    class ServiceAudioTagsFetcher : public AbstractTagsFetcher
+    {
+      public:
+        explicit ServiceAudioTagsFetcher(Application *application);
+
+        std::optional<audio::Tags> getFileTags(const std::string &filePath) const final;
+
+      private:
+        Application *application = nullptr;
+    };
+
     class AbstractSongsRepository
     {
       public:
         virtual ~AbstractSongsRepository() noexcept = default;
 
-        virtual std::vector<audio::Tags> getMusicFilesList()                        = 0;
-        virtual std::optional<audio::Tags> getFileTags(const std::string &filePath) = 0;
+        virtual void scanMusicFilesList()                                   = 0;
+        virtual std::vector<audio::Tags> getMusicFilesList() const          = 0;
+        virtual std::size_t getFileIndex(const std::string &filePath) const = 0;
     };
 
     class SongsRepository : public AbstractSongsRepository
     {
+        static constexpr auto musicSubfolderName = "music";
+
       public:
-        explicit SongsRepository(Application *application);
+        explicit SongsRepository(std::unique_ptr<AbstractTagsFetcher> tagsFetcher,
+                                 std::string musicFolderName = purefs::dir::getUserDiskPath() / musicSubfolderName);
 
-        std::vector<audio::Tags> getMusicFilesList() override;
-        std::optional<audio::Tags> getFileTags(const std::string &filePath) override;
+        void scanMusicFilesList() override;
+        std::vector<audio::Tags> getMusicFilesList() const override;
+        std::size_t getFileIndex(const std::string &filePath) const override;
 
       private:
-        Application *application = nullptr;
+        std::unique_ptr<AbstractTagsFetcher> tagsFetcher;
+        std::string musicFolderName;
+        std::vector<audio::Tags> musicFiles;
     };
 } // namespace app::music_player
diff --git a/module-apps/application-music-player/presenters/AudioOperations.cpp b/module-apps/application-music-player/presenters/AudioOperations.cpp
index 91fab7bea389b836d62040618444452761bf1ce6..dbdf377857be3cdbc0cb5fd1a86cca6e1cabca20 100644
--- a/module-apps/application-music-player/presenters/AudioOperations.cpp
+++ b/module-apps/application-music-player/presenters/AudioOperations.cpp
@@ -28,7 +28,7 @@ namespace app::music_player
                 return false;
             }
             if (callback) {
-                callback(result->token);
+                callback(result->retCode, result->token);
             }
             return true;
         };
@@ -36,26 +36,49 @@ namespace app::music_player
         return true;
     }
 
-    bool AudioOperations::pause(const audio::Token &token)
+    bool AudioOperations::pause(const audio::Token &token, const OnPauseCallback &callback)
     {
-        return AudioServiceAPI::Pause(application, token);
+        auto msg  = std::make_unique<AudioPauseRequest>(token);
+        auto task = app::AsyncRequest::createFromMessage(std::move(msg), service::name::audio);
+        auto cb   = [callback](auto response) {
+            auto result = dynamic_cast<AudioPauseResponse *>(response);
+            if (result == nullptr) {
+                return false;
+            }
+            if (callback) {
+                callback(result->retCode, result->token);
+            }
+            return true;
+        };
+        task->execute(application, this, cb);
+        return true;
     }
-    bool AudioOperations::resume(const audio::Token &token)
+    bool AudioOperations::resume(const audio::Token &token, const OnResumeCallback &callback)
     {
-        return AudioServiceAPI::Resume(application, token);
+        auto msg  = std::make_unique<AudioResumeRequest>(token);
+        auto task = app::AsyncRequest::createFromMessage(std::move(msg), service::name::audio);
+        auto cb   = [callback](auto response) {
+            auto result = dynamic_cast<AudioResumeResponse *>(response);
+            if (result == nullptr) {
+                return false;
+            }
+            if (callback) {
+                callback(result->retCode, result->token);
+            }
+            return true;
+        };
+        task->execute(application, this, cb);
+        return true;
     }
-    bool AudioOperations::stop(const audio::Token &token, const OnStopCallback &callback)
+    bool AudioOperations::stop(const audio::Token &token, [[maybe_unused]] const OnStopCallback &callback)
     {
         auto msg  = std::make_unique<AudioStopRequest>(token);
         auto task = app::AsyncRequest::createFromMessage(std::move(msg), service::name::audio);
-        auto cb   = [callback](auto response) {
+        auto cb   = [](auto response) {
             auto result = dynamic_cast<AudioStopResponse *>(response);
             if (result == nullptr) {
                 return false;
             }
-            if (callback) {
-                callback(result->token);
-            }
             return true;
         };
         task->execute(application, this, cb);
diff --git a/module-apps/application-music-player/presenters/AudioOperations.hpp b/module-apps/application-music-player/presenters/AudioOperations.hpp
index d914be41e2a4a191a93dd3e0c1de3ef4a1cf84e2..75d904f0198dbdadf62593db3e8023417092b604 100644
--- a/module-apps/application-music-player/presenters/AudioOperations.hpp
+++ b/module-apps/application-music-player/presenters/AudioOperations.hpp
@@ -13,15 +13,17 @@ namespace app::music_player
     class AbstractAudioOperations
     {
       public:
-        using OnPlayCallback = std::function<void(audio::Token token)>;
-        using OnStopCallback = OnPlayCallback;
+        using OnPlayCallback   = std::function<void(audio::RetCode retCode, audio::Token token)>;
+        using OnStopCallback   = OnPlayCallback;
+        using OnPauseCallback  = OnPlayCallback;
+        using OnResumeCallback = OnPlayCallback;
 
         virtual ~AbstractAudioOperations() noexcept = default;
 
-        virtual bool play(const std::string &filePath, const OnPlayCallback &callback) = 0;
-        virtual bool pause(const audio::Token &token)                                  = 0;
-        virtual bool resume(const audio::Token &token)                                 = 0;
-        virtual bool stop(const audio::Token &token, const OnStopCallback &callback)   = 0;
+        virtual bool play(const std::string &filePath, const OnPlayCallback &callback)   = 0;
+        virtual bool pause(const audio::Token &token, const OnPauseCallback &callback)   = 0;
+        virtual bool resume(const audio::Token &token, const OnResumeCallback &callback) = 0;
+        virtual bool stop(const audio::Token &token, const OnStopCallback &callback)     = 0;
     };
 
     class AudioOperations : public AbstractAudioOperations, public app::AsyncCallbackReceiver
@@ -30,8 +32,8 @@ namespace app::music_player
         explicit AudioOperations(Application *application);
 
         bool play(const std::string &filePath, const OnPlayCallback &callback) override;
-        bool pause(const audio::Token &token) override;
-        bool resume(const audio::Token &token) override;
+        bool pause(const audio::Token &token, const OnPauseCallback &callback) override;
+        bool resume(const audio::Token &token, const OnResumeCallback &callback) override;
         bool stop(const audio::Token &token, const OnStopCallback &callback) override;
 
       private:
diff --git a/module-apps/application-music-player/presenters/SongsPresenter.cpp b/module-apps/application-music-player/presenters/SongsPresenter.cpp
index 5983983b3f705ada83a5d1a0b404804d10e088a5..65c28884b6ddbadd3c805b7b7d0b808583c2f273 100644
--- a/module-apps/application-music-player/presenters/SongsPresenter.cpp
+++ b/module-apps/application-music-player/presenters/SongsPresenter.cpp
@@ -3,10 +3,10 @@
 
 #include "SongsPresenter.hpp"
 
+#include <service-audio/AudioMessage.hpp>
+
 namespace app::music_player
 {
-    using SongState = SongsModelInterface::SongState;
-
     SongsPresenter::SongsPresenter(std::shared_ptr<app::music_player::SongsModelInterface> songsModelInterface,
                                    std::unique_ptr<AbstractAudioOperations> &&audioOperations)
         : songsModelInterface{std::move(songsModelInterface)}, audioOperations{std::move(audioOperations)}
@@ -17,31 +17,54 @@ namespace app::music_player
         return songsModelInterface;
     }
 
-    void SongsPresenter::createData(std::function<bool(const std::string &fileName)> fn)
+    void SongsPresenter::createData()
     {
-        songsModelInterface->createData(fn);
+        songsModelInterface->createData([this](const std::string &fileName) { return requestAudioOperation(fileName); },
+                                        [this]() { stop(); },
+                                        [this](const UTF8 &text) { setViewBottomBarTemporaryMode(text); },
+                                        [this]() { restoreViewBottomBarFromTemporaryMode(); });
+        updateViewSongState();
     }
 
     bool SongsPresenter::play(const std::string &filePath)
     {
-        songsModelInterface->setCurrentSongState(SongState::Playing);
-        if (changePlayingStateCallback != nullptr) {
-            changePlayingStateCallback(SongState::Playing);
-        }
-
-        return audioOperations->play(filePath,
-                                     [this](audio::Token token) { songsModelInterface->setCurrentFileToken(token); });
+        return audioOperations->play(filePath, [this, filePath](audio::RetCode retCode, audio::Token token) {
+            if (retCode != audio::RetCode::Success || !token.IsValid()) {
+                LOG_ERROR("Playback audio operation failed, retcode = %s, token validity = %d",
+                          str(retCode).c_str(),
+                          token.IsValid());
+                return;
+            }
+            SongContext songToken{SongState::Playing, token, filePath};
+            songsModelInterface->setCurrentSongContext(songToken);
+            if (changePlayingStateCallback != nullptr) {
+                changePlayingStateCallback(SongState::Playing);
+            }
+            updateViewSongState();
+        });
     }
 
     bool SongsPresenter::pause()
     {
         auto currentFileToken = songsModelInterface->getCurrentFileToken();
         if (currentFileToken) {
-            songsModelInterface->setCurrentSongState(SongState::NotPlaying);
-            if (changePlayingStateCallback != nullptr) {
-                changePlayingStateCallback(SongState::NotPlaying);
-            }
-            return audioOperations->pause(currentFileToken.value());
+            return audioOperations->pause(currentFileToken.value(), [this](audio::RetCode retCode, audio::Token token) {
+                if (retCode != audio::RetCode::Success || !token.IsValid()) {
+                    LOG_ERROR("Pause audio operation failed, retcode = %s, token validity = %d",
+                              str(retCode).c_str(),
+                              token.IsValid());
+                    return;
+                }
+                if (token != songsModelInterface->getCurrentFileToken()) {
+                    LOG_ERROR("Pause audio operation failed, wrong token");
+                    return;
+                }
+                songsModelInterface->setCurrentSongState(SongState::NotPlaying);
+                if (changePlayingStateCallback != nullptr) {
+                    changePlayingStateCallback(SongState::NotPlaying);
+                }
+                updateViewSongState();
+            });
         }
         return false;
     }
@@ -50,11 +73,24 @@ namespace app::music_player
     {
         auto currentFileToken = songsModelInterface->getCurrentFileToken();
         if (currentFileToken) {
-            songsModelInterface->setCurrentSongState(SongState::Playing);
-            if (changePlayingStateCallback != nullptr) {
-                changePlayingStateCallback(SongState::Playing);
-            }
-            return audioOperations->resume(currentFileToken.value());
+            return audioOperations->resume(
+                currentFileToken.value(), [this](audio::RetCode retCode, audio::Token token) {
+                    if (retCode != audio::RetCode::Success || !token.IsValid()) {
+                        LOG_ERROR("Resume audio operation failed, retcode = %s, token validity = %d",
+                                  str(retCode).c_str(),
+                                  token.IsValid());
+                        return;
+                    }
+                    if (token != songsModelInterface->getCurrentFileToken()) {
+                        LOG_ERROR("Resume audio operation failed, wrong token");
+                        return;
+                    }
+                    songsModelInterface->setCurrentSongState(SongState::Playing);
+                    if (changePlayingStateCallback != nullptr) {
+                        changePlayingStateCallback(SongState::Playing);
+                    }
+                    updateViewSongState();
+                });
         }
         return false;
     }
@@ -63,34 +99,67 @@ namespace app::music_player
     {
         auto currentFileToken = songsModelInterface->getCurrentFileToken();
         if (currentFileToken) {
-            songsModelInterface->setCurrentSongState(SongState::NotPlaying);
+            return audioOperations->stop(currentFileToken.value(), [](audio::RetCode, audio::Token) {
+                // The answer will come via multicast and will be handled in the application
+            });
+        }
+        return false;
+    }
+
+    void SongsPresenter::setPlayingStateCallback(std::function<void(SongState)> cb)
+    {
+        changePlayingStateCallback = std::move(cb);
+    }
+
+    bool SongsPresenter::handleAudioStopNotifiaction(audio::Token token)
+    {
+        if (token == songsModelInterface->getCurrentFileToken()) {
+            songsModelInterface->clearCurrentSongContext();
             if (changePlayingStateCallback != nullptr) {
                 changePlayingStateCallback(SongState::NotPlaying);
             }
-
-            return audioOperations->stop(currentFileToken.value(), [this](audio::Token token) {
-                if (token == songsModelInterface->getCurrentFileToken()) {
-                    songsModelInterface->setCurrentFileToken(std::nullopt);
-                    songsModelInterface->setCurrentSongState(SongState::NotPlaying);
-                }
-            });
+            updateViewSongState();
+            refreshView();
+            return true;
         }
         return false;
     }
 
-    void SongsPresenter::togglePlaying()
+    bool SongsPresenter::requestAudioOperation(const std::string &filePath)
     {
-        if (songsModelInterface->isSongPlaying()) {
-            pause();
+        auto currentSongContext = songsModelInterface->getCurrentSongContext();
+
+        if (currentSongContext.isValid() && (filePath.empty() || currentSongContext.filePath == filePath)) {
+            return currentSongContext.isPlaying() ? pause() : resume();
         }
-        else {
-            resume();
+        return play(filePath);
+    }
+
+    void SongsPresenter::setViewBottomBarTemporaryMode(const std::string &text)
+    {
+        if (auto view = getView(); view != nullptr) {
+            view->setBottomBarTemporaryMode(text);
         }
     }
 
-    void SongsPresenter::setPlayingStateCallback(std::function<void(SongState)> cb)
+    void SongsPresenter::restoreViewBottomBarFromTemporaryMode()
     {
-        changePlayingStateCallback = std::move(cb);
+        if (auto view = getView(); view != nullptr) {
+            view->restoreFromBottomBarTemporaryMode();
+        }
     }
 
+    void SongsPresenter::updateViewSongState()
+    {
+        if (auto view = getView(); view != nullptr) {
+            view->updateSongsState();
+        }
+    }
+
+    void SongsPresenter::refreshView()
+    {
+        if (auto view = getView(); view != nullptr) {
+            view->refreshWindow();
+        }
+    }
 } // namespace app::music_player
diff --git a/module-apps/application-music-player/presenters/SongsPresenter.hpp b/module-apps/application-music-player/presenters/SongsPresenter.hpp
index b5ac9f3b2fd27763eb38b83ceb5cb1208c3587f5..d8bfa4c68a9f31d744d371daf855f28b94576144 100644
--- a/module-apps/application-music-player/presenters/SongsPresenter.hpp
+++ b/module-apps/application-music-player/presenters/SongsPresenter.hpp
@@ -17,23 +17,29 @@ namespace app::music_player
         class View
         {
           public:
-            virtual ~View() noexcept = default;
+            virtual ~View() noexcept                                        = default;
+            virtual void updateSongsState()                                 = 0;
+            virtual void refreshWindow()                                    = 0;
+            virtual void setBottomBarTemporaryMode(const std::string &text) = 0;
+            virtual void restoreFromBottomBarTemporaryMode()                = 0;
         };
         class Presenter : public BasePresenter<SongsContract::View>
         {
           public:
+            using OnPlayingStateChangeCallback = std::function<void(SongState)>;
+
             virtual ~Presenter() noexcept = default;
 
             virtual std::shared_ptr<SongsListItemProvider> getMusicPlayerItemProvider() const = 0;
-            virtual void createData(std::function<bool(const std::string &fileName)>)         = 0;
+            virtual void createData()                                                         = 0;
 
             virtual bool play(const std::string &filePath) = 0;
             virtual bool pause()                           = 0;
             virtual bool resume()                          = 0;
             virtual bool stop()                            = 0;
-            virtual void togglePlaying()                   = 0;
 
-            virtual void setPlayingStateCallback(std::function<void(SongsModelInterface::SongState)> cb) = 0;
+            virtual void setPlayingStateCallback(OnPlayingStateChangeCallback cb) = 0;
+            virtual bool handleAudioStopNotifiaction(audio::Token token)          = 0;
         };
     };
 
@@ -45,18 +51,26 @@ namespace app::music_player
 
         std::shared_ptr<SongsListItemProvider> getMusicPlayerItemProvider() const override;
 
-        void createData(std::function<bool(const std::string &fileName)>) override;
+        void createData() override;
 
         bool play(const std::string &filePath) override;
         bool pause() override;
         bool resume() override;
         bool stop() override;
-        void togglePlaying() override;
-        void setPlayingStateCallback(std::function<void(SongsModelInterface::SongState)> cb) override;
+
+        void setPlayingStateCallback(std::function<void(SongState)> cb) override;
+        bool handleAudioStopNotifiaction(audio::Token token) override;
 
       private:
+        void updateViewSongState();
+        void refreshView();
+
+        /// Request state dependant audio operation
+        bool requestAudioOperation(const std::string &filePath = "");
+        void setViewBottomBarTemporaryMode(const std::string &text);
+        void restoreViewBottomBarFromTemporaryMode();
         std::shared_ptr<SongsModelInterface> songsModelInterface;
         std::unique_ptr<AbstractAudioOperations> audioOperations;
-        std::function<void(SongsModelInterface::SongState)> changePlayingStateCallback = nullptr;
+        std::function<void(SongState)> changePlayingStateCallback = nullptr;
     };
 } // namespace app::music_player
diff --git a/module-apps/application-music-player/tests/CMakeLists.txt b/module-apps/application-music-player/tests/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f918d305bd4d1cb5f56fefe40175ee9901eb90c7
--- /dev/null
+++ b/module-apps/application-music-player/tests/CMakeLists.txt
@@ -0,0 +1,12 @@
+add_gtest_executable(
+    NAME 
+        app-music-player
+    SRCS
+        unittest.cpp
+        unittest_songrepository.cpp
+        unittest_songsmodel.cpp
+    LIBS
+        application-music-player
+    INCLUDE
+        ${CMAKE_CURRENT_LIST_DIR}/..
+)
diff --git a/module-apps/application-music-player/tests/MockSongsRepository.hpp b/module-apps/application-music-player/tests/MockSongsRepository.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..4d27a9170c75096328ee433c61aae193bf32501e
--- /dev/null
+++ b/module-apps/application-music-player/tests/MockSongsRepository.hpp
@@ -0,0 +1,24 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#pragma once
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include <models/SongsRepository.hpp>
+
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace testing::app::music_player
+{
+    class MockSongsRepository : public ::app::music_player::AbstractSongsRepository
+    {
+      public:
+        MOCK_METHOD(void, scanMusicFilesList, (), (override));
+        MOCK_METHOD(std::vector<audio::Tags>, getMusicFilesList, (), (const override));
+        MOCK_METHOD(std::size_t, getFileIndex, (const std::string &filePath), (const override));
+    };
+}; // namespace testing::app::music_player
diff --git a/module-apps/application-music-player/tests/MockTagsFetcher.hpp b/module-apps/application-music-player/tests/MockTagsFetcher.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..c7755083936c49b1812fc765f41939db06ce0612
--- /dev/null
+++ b/module-apps/application-music-player/tests/MockTagsFetcher.hpp
@@ -0,0 +1,20 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#pragma once
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include <models/SongsRepository.hpp>
+
+#include <optional>
+
+namespace testing::app::music_player
+{
+    class MockTagsFetcher : public ::app::music_player::AbstractTagsFetcher
+    {
+      public:
+        MOCK_METHOD(std::optional<audio::Tags>, getFileTags, (const std::string &filePath), (const override));
+    };
+}; // namespace testing::app::music_player
diff --git a/module-apps/application-music-player/tests/unittest.cpp b/module-apps/application-music-player/tests/unittest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1fefb41ac879053e6d19595207385f2352085010
--- /dev/null
+++ b/module-apps/application-music-player/tests/unittest.cpp
@@ -0,0 +1,10 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#include <gtest/gtest.h>
+
+int main(int argc, char **argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}
diff --git a/module-apps/application-music-player/tests/unittest_songrepository.cpp b/module-apps/application-music-player/tests/unittest_songrepository.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cf998dc97ff34aca24ede55859f08853a481ce1d
--- /dev/null
+++ b/module-apps/application-music-player/tests/unittest_songrepository.cpp
@@ -0,0 +1,153 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include "MockTagsFetcher.hpp"
+
+#include <models/SongsRepository.hpp>
+
+#include <filesystem>
+#include <fstream>
+#include <stdexcept>
+
+using ::testing::Return;
+using ::testing::app::music_player::MockTagsFetcher;
+namespace fs = std::filesystem;
+
+constexpr auto testDir  = "appmusic-test";
+constexpr auto emptyDir = "empty";
+constexpr auto musicDir = "music";
+constexpr auto bazDir   = "bazdir";
+auto testDirPath        = fs::path(testDir);
+auto emptyDirPath       = testDirPath / emptyDir;
+auto musicDirPath       = testDirPath / musicDir;
+auto bazDirPath         = musicDirPath / bazDir;
+
+class SongsRepositoryFixture : public ::testing::Test
+{
+  protected:
+    static void SetUpTestSuite()
+    {
+        if (fs::exists(testDirPath)) {
+            TearDownTestSuite();
+        }
+
+        fs::create_directory(testDirPath);
+        fs::create_directory(emptyDirPath);
+        fs::create_directory(musicDirPath);
+
+        createFile(musicDirPath / "foo");
+        createFile(musicDirPath / "bar");
+
+        fs::create_directory(bazDirPath);
+
+        createFile(bazDirPath / "baz");
+
+        fs::create_directory(musicDirPath / "bazzinga");
+    }
+
+    static void createFile(const std::string &path)
+    {
+        std::ofstream file(path);
+        file << "app music test file";
+    }
+
+    static void TearDownTestSuite()
+    {
+        fs::remove_all(testDir);
+    }
+
+    auto getMockedRepository(const std::string &directoryToScan)
+    {
+        return std::make_unique<app::music_player::SongsRepository>(std::make_unique<MockTagsFetcher>(),
+                                                                    directoryToScan);
+    }
+};
+
+TEST_F(SongsRepositoryFixture, LazyInit)
+{
+    auto repo       = getMockedRepository(testDir);
+    auto musicFiles = repo->getMusicFilesList();
+    EXPECT_EQ(musicFiles.size(), 0);
+}
+
+TEST_F(SongsRepositoryFixture, Empty)
+{
+    auto repo = getMockedRepository(testDirPath / emptyDir);
+    repo->scanMusicFilesList();
+
+    auto musicFiles = repo->getMusicFilesList();
+    EXPECT_EQ(musicFiles.size(), 0);
+}
+
+TEST_F(SongsRepositoryFixture, ScanEmptyFiles)
+{
+    auto tagsFetcherMock = std::make_unique<MockTagsFetcher>();
+    auto rawMock         = tagsFetcherMock.get();
+    auto repo = std::make_unique<app::music_player::SongsRepository>(std::move(tagsFetcherMock), musicDirPath);
+
+    EXPECT_CALL(*rawMock, getFileTags).Times(2);
+    repo->scanMusicFilesList();
+
+    auto musicFiles = repo->getMusicFilesList();
+    EXPECT_EQ(musicFiles.size(), 0);
+}
+
+TEST_F(SongsRepositoryFixture, ScanWithTagsReturn)
+{
+    auto tagsFetcherMock = std::make_unique<MockTagsFetcher>();
+    auto rawMock         = tagsFetcherMock.get();
+    auto repo = std::make_unique<app::music_player::SongsRepository>(std::move(tagsFetcherMock), musicDirPath);
+
+    auto fooTags = ::audio::Tags();
+    auto barTags = ::audio::Tags();
+
+    fooTags.title = "foo";
+    barTags.title = "bar";
+
+    ON_CALL(*rawMock, getFileTags(fs::path(musicDirPath / "foo").c_str())).WillByDefault(Return(fooTags));
+    ON_CALL(*rawMock, getFileTags(fs::path(musicDirPath / "bar").c_str())).WillByDefault(Return(barTags));
+    EXPECT_CALL(*rawMock, getFileTags).Times(2);
+    repo->scanMusicFilesList();
+
+    auto musicFiles = repo->getMusicFilesList();
+    EXPECT_EQ(musicFiles.size(), 2);
+}
+
+TEST_F(SongsRepositoryFixture, FileIndex)
+{
+    auto tagsFetcherMock = std::make_unique<MockTagsFetcher>();
+    auto rawMock         = tagsFetcherMock.get();
+    auto repo = std::make_unique<app::music_player::SongsRepository>(std::move(tagsFetcherMock), musicDirPath);
+
+    auto fooPath = musicDirPath / "foo";
+    auto barPath = musicDirPath / "bar";
+
+    auto fooTags = ::audio::Tags();
+    auto barTags = ::audio::Tags();
+
+    fooTags.title    = "foo";
+    fooTags.filePath = fooPath.c_str();
+
+    barTags.title    = "bar";
+    barTags.filePath = barPath.c_str();
+
+    ON_CALL(*rawMock, getFileTags(fs::path(musicDirPath / "foo").c_str())).WillByDefault(Return(fooTags));
+    ON_CALL(*rawMock, getFileTags(fs::path(musicDirPath / "bar").c_str())).WillByDefault(Return(barTags));
+    EXPECT_CALL(*rawMock, getFileTags).Times(2);
+    repo->scanMusicFilesList();
+
+    auto fooIndex = repo->getFileIndex(fooPath);
+    auto barIndex = repo->getFileIndex(barPath);
+
+    EXPECT_NE(fooIndex, static_cast<std::size_t>(-1));
+    EXPECT_LT(fooIndex, 2);
+
+    EXPECT_NE(barIndex, static_cast<std::size_t>(-1));
+    EXPECT_LT(barIndex, 2);
+
+    auto bazIndex = repo->getFileIndex("baz");
+    EXPECT_EQ(bazIndex, static_cast<std::size_t>(-1));
+}
diff --git a/module-apps/application-music-player/tests/unittest_songsmodel.cpp b/module-apps/application-music-player/tests/unittest_songsmodel.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..edf0287659127b3d00630e5ed4c66638efe79b8d
--- /dev/null
+++ b/module-apps/application-music-player/tests/unittest_songsmodel.cpp
@@ -0,0 +1,46 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#include <gtest/gtest.h>
+
+#include "MockSongsRepository.hpp"
+
+#include <models/SongsModel.hpp>
+
+#include <memory>
+#include <optional>
+
+using ::app::music_player::SongsModel;
+using ::testing::Return;
+using ::testing::app::music_player::MockSongsRepository;
+
+TEST(SongsModel, Init)
+{
+    auto mockRepo = std::make_shared<MockSongsRepository>();
+    auto model    = SongsModel(mockRepo);
+
+    EXPECT_EQ(model.requestRecordsCount(), 0);
+    EXPECT_FALSE(model.isSongPlaying());
+}
+
+TEST(SongsModel, EmptyContext)
+{
+    auto mockRepo = std::make_shared<MockSongsRepository>();
+    auto model    = SongsModel(mockRepo);
+
+    auto ctx = model.getCurrentSongContext();
+
+    EXPECT_EQ(ctx.currentFileToken, std::nullopt);
+    EXPECT_TRUE(ctx.filePath.empty());
+    EXPECT_EQ(ctx.currentSongState, app::music_player::SongState::NotPlaying);
+}
+
+TEST(SongsModel, createDataNoSongs)
+{
+    auto mockRepo = std::make_shared<MockSongsRepository>();
+    auto model    = SongsModel(mockRepo);
+
+    EXPECT_CALL(*mockRepo, scanMusicFilesList);
+    EXPECT_CALL(*mockRepo, getMusicFilesList).WillRepeatedly(Return(std::vector<audio::Tags>()));
+    model.createData([](const std::string &) { return true; }, []() {}, [](const UTF8 &) {}, []() {});
+}
diff --git a/module-apps/application-music-player/widgets/SongItem.cpp b/module-apps/application-music-player/widgets/SongItem.cpp
index 9226c66f5e4b95eaa3bc9b5e8f23517cd75e856f..49f2313024373a3ddfba56edeae07c6840323616 100644
--- a/module-apps/application-music-player/widgets/SongItem.cpp
+++ b/module-apps/application-music-player/widgets/SongItem.cpp
@@ -2,13 +2,19 @@
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
 #include "module-apps/application-music-player/widgets/SongItem.hpp"
+#include <i18n/i18n.hpp>
 
 namespace gui
 {
 
     using namespace musicPlayerStyle;
 
-    SongItem::SongItem(const std::string &authorName, const std::string &songName, const std::string &duration)
+    SongItem::SongItem(const std::string &authorName,
+                       const std::string &songName,
+                       const std::string &duration,
+                       std::function<void(const UTF8 &)> setBtBarCallback,
+                       std::function<void()> restoreBtBarCallback)
+        : bottomBarTemporaryMode(setBtBarCallback), bottomBarRestoreFromTemporaryMode(restoreBtBarCallback)
     {
         setMinimumSize(songItem::w, songItem::h);
         setMargins(Margins(0, style::margins::small, 0, style::margins::small));
@@ -44,15 +50,14 @@ namespace gui
         songText->setMargins(Margins(songItem::leftMargin, 0, 0, 0));
         songText->setEdges(RectangleEdge::None);
         songText->setUnderline(false);
-        songText->setFont(style::window::font::verysmallbold);
+        songText->setFont(style::window::font::bigbold);
         songText->setAlignment(Alignment(gui::Alignment::Horizontal::Left, gui::Alignment::Vertical::Center));
         songText->setEditMode(EditMode::Browse);
         songText->setText(songName);
 
-        playedSong = new ImageBox(secondHBox, 0, 0, 0, 0, new Image("messages_error_W_M"));
-        playedSong->setMinimumSize(songItem::duration_w, songItem::text_h);
+        playedSong = new Image(secondHBox, 0, 0, "");
+        playedSong->setAlignment(Alignment(gui::Alignment::Horizontal::Right, gui::Alignment::Vertical::Center));
         playedSong->setVisible(false);
-        playedSong->setEdges(RectangleEdge::None);
 
         authorText = new TextFixedSize(secondHBox, 0, 0, 0, 0);
         authorText->setMinimumHeight(songItem::text_h);
@@ -60,7 +65,7 @@ namespace gui
         authorText->setMargins(Margins(songItem::leftMargin, 0, 0, 0));
         authorText->setEdges(RectangleEdge::None);
         authorText->setUnderline(false);
-        authorText->setFont(style::window::font::verysmall);
+        authorText->setFont(style::window::font::medium);
         authorText->setAlignment(Alignment(gui::Alignment::Horizontal::Left, gui::Alignment::Vertical::Center));
         authorText->setEditMode(EditMode::Browse);
         authorText->setText(authorName);
@@ -69,5 +74,53 @@ namespace gui
             vBox->setArea({0, 0, newDim.w, newDim.h});
             return true;
         };
+
+        focusChangedCallback = [&](gui::Item &item) {
+            if (item.focus) {
+                std::string bottorBarText;
+                switch (itemState) {
+                case ItemState::Playing:
+                    bottorBarText = utils::translate("common_pause");
+                    break;
+                case ItemState::Paused:
+                    bottorBarText = utils::translate("common_resume");
+                    break;
+                case ItemState::None:
+                    bottorBarText = utils::translate("app_music_player_play");
+                    ;
+                    break;
+                }
+                if (bottomBarTemporaryMode != nullptr) {
+                    bottomBarTemporaryMode(bottorBarText);
+                }
+            }
+            else {
+                setFocusItem(nullptr);
+                if (bottomBarRestoreFromTemporaryMode != nullptr) {
+                    bottomBarRestoreFromTemporaryMode();
+                }
+            }
+            return true;
+        };
+    }
+
+    void SongItem::setState(ItemState state)
+    {
+        itemState = state;
+        switch (state) {
+        case ItemState::Paused:
+            playedSong->set("now_playing_icon_pause_list");
+            playedSong->setVisible(true);
+            break;
+        case ItemState::Playing:
+            playedSong->set("now_playing_icon_list");
+            playedSong->setVisible(true);
+            break;
+        case ItemState::None:
+            playedSong->set("");
+            playedSong->setVisible(false);
+            break;
+        }
+        secondHBox->resizeItems();
     }
 } /* namespace gui */
diff --git a/module-apps/application-music-player/widgets/SongItem.hpp b/module-apps/application-music-player/widgets/SongItem.hpp
index 923ef8b21942f564c411dc2f76188a41379ab2c0..c7b4b16241a0a7afaa85287cc9b8d9d7a3e8cd43 100644
--- a/module-apps/application-music-player/widgets/SongItem.hpp
+++ b/module-apps/application-music-player/widgets/SongItem.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved.
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
 #pragma once
@@ -8,7 +8,7 @@
 #include <ListItem.hpp>
 #include <Text.hpp>
 #include <TextFixedSize.hpp>
-#include <ImageBox.hpp>
+#include <Image.hpp>
 
 namespace gui
 {
@@ -16,16 +16,31 @@ namespace gui
     {
 
       public:
-        SongItem(const std::string &authorName, const std::string &songName, const std::string &duration);
+        SongItem(const std::string &authorName,
+                 const std::string &songName,
+                 const std::string &duration,
+                 std::function<void(const UTF8 &)> bottomBarTemporaryMode,
+                 std::function<void()> bottomBarRestoreFromTemporaryMode);
+
+        enum class ItemState
+        {
+            None,
+            Playing,
+            Paused
+        };
+        void setState(ItemState state);
 
       private:
-        VBox *vBox                  = nullptr;
-        HBox *firstHBox             = nullptr;
-        HBox *secondHBox            = nullptr;
-        TextFixedSize *authorText   = nullptr;
-        TextFixedSize *songText     = nullptr;
-        TextFixedSize *durationText = nullptr;
-        ImageBox *playedSong        = nullptr;
+        VBox *vBox                                                   = nullptr;
+        HBox *firstHBox                                              = nullptr;
+        HBox *secondHBox                                             = nullptr;
+        TextFixedSize *authorText                                    = nullptr;
+        TextFixedSize *songText                                      = nullptr;
+        TextFixedSize *durationText                                  = nullptr;
+        Image *playedSong                                            = nullptr;
+        ItemState itemState                                          = ItemState::None;
+        std::function<void(const UTF8 &text)> bottomBarTemporaryMode = nullptr;
+        std::function<void()> bottomBarRestoreFromTemporaryMode      = nullptr;
     };
 
 } /* namespace gui */
diff --git a/module-apps/application-music-player/windows/MusicPlayerAllSongsWindow.cpp b/module-apps/application-music-player/windows/MusicPlayerAllSongsWindow.cpp
index ce2f5059e64199e2fbaa9b4e5cf9ad65faded427..d6b47ab160df8cb9c8f0d7facc9c88428507dd10 100644
--- a/module-apps/application-music-player/windows/MusicPlayerAllSongsWindow.cpp
+++ b/module-apps/application-music-player/windows/MusicPlayerAllSongsWindow.cpp
@@ -10,6 +10,7 @@
 #include <i18n/i18n.hpp>
 #include <service-audio/AudioServiceAPI.hpp>
 #include <gui/widgets/ListView.hpp>
+#include <gui/widgets/Icon.hpp>
 
 namespace gui
 {
@@ -32,10 +33,8 @@ namespace gui
     {
         AppWindow::buildInterface();
 
-        setTitle(utils::translate("app_music_player_all_songs"));
-
-        bottomBar->setText(BottomBar::Side::CENTER, utils::translate("app_music_player_play"));
-        bottomBar->setText(BottomBar::Side::RIGHT, utils::translate(style::strings::common::back));
+        bottomBar->setText(BottomBar::Side::CENTER, utils::translate("app_music_player_music_library"));
+        bottomBar->setText(BottomBar::Side::RIGHT, utils::translate("app_music_player_quit"));
 
         songsList = new gui::ListView(this,
                                       musicPlayerStyle::allSongsWindow::x,
@@ -45,6 +44,20 @@ namespace gui
                                       presenter->getMusicPlayerItemProvider(),
                                       listview::ScrollBarType::Fixed);
 
+        emptyListIcon = new gui::Icon(this,
+                                      ::style::window::default_left_margin,
+                                      ::style::window::default_vertical_pos,
+                                      ::style::window::default_body_width,
+                                      ::style::window::default_body_height,
+                                      "note",
+                                      utils::translate("app_music_player_music_empty_window_notification"));
+
+        emptyListIcon->setAlignment(Alignment::Horizontal::Center);
+        songsList->emptyListCallback    = [this]() { emptyListIcon->setVisible(true); };
+        songsList->notEmptyListCallback = [this]() {
+            emptyListIcon->setVisible(false);
+            setTitle(utils::translate("app_music_player_music_library_window_name"));
+        };
         setFocusItem(songsList);
     }
 
@@ -55,7 +68,43 @@ namespace gui
 
     void MusicPlayerAllSongsWindow::onBeforeShow([[maybe_unused]] ShowMode mode, [[maybe_unused]] SwitchData *data)
     {
-        presenter->createData([this](const std::string &fileName) { return presenter->play(fileName); });
+        presenter->attach(this);
+        auto index = presenter->getMusicPlayerItemProvider()->getCurrentIndex();
+
+        songsList->rebuildList(listview::RebuildType::OnPageElement, index);
+    }
+
+    void MusicPlayerAllSongsWindow::updateSongsState()
+    {
+        songsList->rebuildList(gui::listview::RebuildType::InPlace);
+    }
+
+    void MusicPlayerAllSongsWindow::refreshWindow()
+    {
+        application->refreshWindow(gui::RefreshModes::GUI_REFRESH_FAST);
     }
 
+    void MusicPlayerAllSongsWindow::setBottomBarTemporaryMode(const std::string &text)
+    {
+        bottomBarTemporaryMode(text, BottomBar::Side::CENTER, false);
+    }
+
+    void MusicPlayerAllSongsWindow::restoreFromBottomBarTemporaryMode()
+    {
+        bottomBarRestoreFromTemporaryMode();
+    }
+
+    bool MusicPlayerAllSongsWindow::onInput(const InputEvent &inputEvent)
+    {
+        if (AppWindow::onInput(inputEvent)) {
+            return true;
+        }
+
+        if (inputEvent.isShortRelease(gui::KeyCode::KEY_ENTER)) {
+            presenter->createData();
+            return true;
+        }
+
+        return false;
+    }
 } /* namespace gui */
diff --git a/module-apps/application-music-player/windows/MusicPlayerAllSongsWindow.hpp b/module-apps/application-music-player/windows/MusicPlayerAllSongsWindow.hpp
index 5ea9a87d3c00975b2d740b28f71498da7a4000c5..3fd6f8867027f6a7a311b5091c3753ca327fa997 100644
--- a/module-apps/application-music-player/windows/MusicPlayerAllSongsWindow.hpp
+++ b/module-apps/application-music-player/windows/MusicPlayerAllSongsWindow.hpp
@@ -10,21 +10,28 @@
 namespace gui
 {
     class ListView;
+    class Icon;
     class MusicPlayerAllSongsWindow : public AppWindow, public app::music_player::SongsContract::View
     {
         std::shared_ptr<app::music_player::SongsContract::Presenter> presenter;
         ListView *songsList = nullptr;
+        Icon *emptyListIcon = nullptr;
 
       public:
         explicit MusicPlayerAllSongsWindow(app::Application *app,
                                            std::shared_ptr<app::music_player::SongsContract::Presenter> presenter);
 
-        // virtual methods
         void onBeforeShow([[maybe_unused]] ShowMode mode, [[maybe_unused]] SwitchData *data) override;
 
         void rebuild() override;
         void buildInterface() override;
         void destroyInterface() override;
+        bool onInput(const InputEvent &inputEvent) override;
+
+        void updateSongsState() override;
+        void refreshWindow() override;
+        void setBottomBarTemporaryMode(const std::string &text) override;
+        void restoreFromBottomBarTemporaryMode() override;
     };
 
 } /* namespace gui */
diff --git a/module-apps/application-music-player/windows/MusicPlayerEmptyWindow.cpp b/module-apps/application-music-player/windows/MusicPlayerEmptyWindow.cpp
deleted file mode 100644
index aa9664b5edea229d1a45603aded4eaac974984b1..0000000000000000000000000000000000000000
--- a/module-apps/application-music-player/windows/MusicPlayerEmptyWindow.cpp
+++ /dev/null
@@ -1,80 +0,0 @@
-// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
-// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
-
-#include "MusicPlayerEmptyWindow.hpp"
-#include "application-music-player/ApplicationMusicPlayer.hpp"
-#include "application-music-player/data/MusicPlayerStyle.hpp"
-
-#include <Style.hpp>
-#include <i18n/i18n.hpp>
-#include <log.hpp>
-#include <service-audio/AudioServiceAPI.hpp>
-
-namespace gui
-{
-    using namespace musicPlayerStyle::emptyWindow;
-
-    MusicPlayerEmptyWindow::MusicPlayerEmptyWindow(app::Application *app)
-        : AppWindow(app, gui::name::window::main_window)
-    {
-        buildInterface();
-    }
-
-    void MusicPlayerEmptyWindow::rebuild()
-    {
-        destroyInterface();
-        buildInterface();
-    }
-
-    void MusicPlayerEmptyWindow::buildInterface()
-    {
-        AppWindow::buildInterface();
-
-        bottomBar->setText(BottomBar::Side::LEFT, utils::translate("app_music_player_music_library"));
-        bottomBar->setText(BottomBar::Side::CENTER, utils::translate("app_music_player_play"));
-        bottomBar->setText(BottomBar::Side::RIGHT, utils::translate("app_music_player_quit"));
-
-        img = new gui::Image(this, noteImg::x, noteImg::y, "note");
-
-        text = new Text(this, infoText::x, infoText::y, infoText::w, infoText::h);
-        text->setText(utils::translate("app_music_player_music_empty_window_notification"));
-        text->setTextType(TextType::MultiLine);
-        text->setEditMode(EditMode::Browse);
-        text->setEdges(RectangleEdge::None);
-        text->setFont(style::window::font::medium);
-        text->setAlignment(gui::Alignment(gui::Alignment::Horizontal::Center, gui::Alignment::Vertical::Center));
-
-        placeHolder = new gui::Image(this, placeHolderImg::x, placeHolderImg::y, "placeholder_player");
-    }
-
-    void MusicPlayerEmptyWindow::destroyInterface()
-    {
-        erase();
-    }
-
-    void MusicPlayerEmptyWindow::onBeforeShow(ShowMode mode, SwitchData *data)
-    {}
-
-    bool MusicPlayerEmptyWindow::onDatabaseMessage(sys::Message *msgl)
-    {
-        return false;
-    }
-
-    bool MusicPlayerEmptyWindow::onInput(const InputEvent &inputEvent)
-    {
-        if (AppWindow::onInput(inputEvent)) {
-            return true;
-        }
-
-        if (inputEvent.isShortRelease(gui::KeyCode::KEY_LF)) {
-            application->switchWindow(gui::name::window::all_songs_window);
-            return true;
-        }
-
-        if (inputEvent.is(gui::KeyCode::KEY_ENTER) || inputEvent.is(gui::KeyCode::HEADSET_OK)) {
-        }
-
-        return false;
-    }
-
-} /* namespace gui */
diff --git a/module-apps/application-music-player/windows/MusicPlayerEmptyWindow.hpp b/module-apps/application-music-player/windows/MusicPlayerEmptyWindow.hpp
deleted file mode 100644
index 5e213d8d80c8d2407358256adf427c4a5232c7b9..0000000000000000000000000000000000000000
--- a/module-apps/application-music-player/windows/MusicPlayerEmptyWindow.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved.
-// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
-
-#pragma once
-
-#include "AppWindow.hpp"
-#include <Text.hpp>
-#include <Image.hpp>
-
-#include <vector>
-#include <string>
-
-namespace gui
-{
-
-    class MusicPlayerEmptyWindow : public AppWindow
-    {
-        Image *img         = nullptr;
-        Text *text         = nullptr;
-        Image *placeHolder = nullptr;
-
-      public:
-        MusicPlayerEmptyWindow(app::Application *app);
-
-        // virtual methods
-        void onBeforeShow(ShowMode mode, SwitchData *data) override;
-
-        void rebuild() override;
-        void buildInterface() override;
-        void destroyInterface() override;
-        bool onDatabaseMessage(sys::Message *msg) override;
-        bool onInput(const InputEvent &inputEvent) final;
-    };
-
-} /* namespace gui */
diff --git a/module-services/service-audio/ServiceAudio.cpp b/module-services/service-audio/ServiceAudio.cpp
index 1bbf97432242ab5b8b6c59aefafb6a633f715f2a..fc86c7aa89ec769fd76df28b28b670db013ff653 100644
--- a/module-services/service-audio/ServiceAudio.cpp
+++ b/module-services/service-audio/ServiceAudio.cpp
@@ -288,8 +288,6 @@ std::unique_ptr<AudioResponseMessage> ServiceAudio::HandlePause(std::optional<Au
         retCode  = audioInput->audio->Pause();
         retToken = audioInput->token;
         audioInput->DisableVibration();
-        bus.sendMulticast(std::make_shared<AudioPausedNotification>(audioInput->token),
-                          sys::BusChannel::ServiceAudioNotifications);
     }
     else {
         retCode = StopInput(audioInput);
diff --git a/module-services/service-audio/include/service-audio/AudioMessage.hpp b/module-services/service-audio/include/service-audio/AudioMessage.hpp
index 8de56c255718ca14048cfcbbd3b6d4c9753116a8..2364a00926da72937b8902293f0ec23fd02a3130 100644
--- a/module-services/service-audio/include/service-audio/AudioMessage.hpp
+++ b/module-services/service-audio/include/service-audio/AudioMessage.hpp
@@ -56,13 +56,6 @@ class AudioNotificationMessage : public AudioMessage
     const audio::Token token;
 };
 
-class AudioPausedNotification : public AudioNotificationMessage
-{
-  public:
-    explicit AudioPausedNotification(audio::Token token) : AudioNotificationMessage{token}
-    {}
-};
-
 class AudioStopNotification : public AudioNotificationMessage
 {
   public: