5 files changed, 42 insertions(+), 8 deletions(-)

M module-apps/application-music-player/ApplicationMusicPlayer.cpp
M module-apps/application-music-player/include/application-music-player/ApplicationMusicPlayer.hpp
M module-apps/application-music-player/presenters/SongsPresenter.cpp
M module-apps/application-music-player/presenters/SongsPresenter.hpp
M module-apps/apps-common/locks/handlers/LockPolicyHandler.hpp

@@ 8,6 8,7 @@
 #include <presenters/SongsPresenter.hpp>
 #include <models/SongsRepository.hpp>
 #include <models/SongsModel.hpp>
+#include <service-appmgr/Controller.hpp>
 
 #include <filesystem>
 #include <log.hpp>


@@ 45,13 46,23 @@ namespace app
         priv->songsPresenter =
             std::make_unique<app::music_player::SongsPresenter>(priv->songsModel, std::move(audioOperations));
 
-        std::function<bool()> stateLockCallback = [this]() -> bool {
-            auto isTrackPlaying = priv->songsModel->isSongPlaying();
-            if (isTrackPlaying) {
+        // callback used when playing state is changed
+        using SongState                                 = music_player::SongsModelInterface::SongState;
+        std::function<void(SongState)> autolockCallback = [this](SongState isPlaying) {
+            if (isPlaying == SongState::Playing) {
                 LOG_DEBUG("Preventing autolock while playing track.");
+                lockPolicyHandler.set(locks::AutoLockPolicy::DetermineByAppState);
+            }
+            else {
+                LOG_DEBUG("Autolock reenabled because track is no longer playing.");
+                lockPolicyHandler.set(locks::AutoLockPolicy::DetermineByWindow);
+                app::manager::Controller::preventBlockingDevice(this);
             }
-            return isTrackPlaying;
         };
+        priv->songsPresenter->setPlayingStateCallback(std::move(autolockCallback));
+
+        // callback used when track is not played and we are in DetermineByAppState
+        std::function<bool()> stateLockCallback = []() -> bool { return true; };
         lockPolicyHandler.setPreventsAutoLockByStateCallback(std::move(stateLockCallback));
     }
 


@@ 91,7 102,8 @@ namespace app
 
     sys::ReturnCodes ApplicationMusicPlayer::DeinitHandler()
     {
-        return sys::ReturnCodes::Success;
+        priv->songsPresenter->stop();
+        return Application::DeinitHandler();
     }
 
     void ApplicationMusicPlayer::createUserInterface()

@@ 65,7 65,7 @@ namespace app
         static auto GetManifest() -> manager::ApplicationManifest
         {
             return {{manager::actions::Launch, manager::actions::PhoneModeChanged},
-                    locks::AutoLockPolicy::DetermineByAppState};
+                    locks::AutoLockPolicy::DetermineByWindow};
         }
     };
 } /* namespace app */

@@ 25,6 25,10 @@ namespace app::music_player
     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); });
     }


@@ 34,6 38,9 @@ namespace app::music_player
         auto currentFileToken = songsModelInterface->getCurrentFileToken();
         if (currentFileToken) {
             songsModelInterface->setCurrentSongState(SongState::NotPlaying);
+            if (changePlayingStateCallback != nullptr) {
+                changePlayingStateCallback(SongState::NotPlaying);
+            }
             return audioOperations->pause(currentFileToken.value());
         }
         return false;


@@ 44,6 51,9 @@ 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 false;


@@ 54,6 64,10 @@ namespace app::music_player
         auto currentFileToken = songsModelInterface->getCurrentFileToken();
         if (currentFileToken) {
             songsModelInterface->setCurrentSongState(SongState::NotPlaying);
+            if (changePlayingStateCallback != nullptr) {
+                changePlayingStateCallback(SongState::NotPlaying);
+            }
+
             return audioOperations->stop(currentFileToken.value(), [this](audio::Token token) {
                 if (token == songsModelInterface->getCurrentFileToken()) {
                     songsModelInterface->setCurrentFileToken(std::nullopt);


@@ 74,4 88,9 @@ namespace app::music_player
         }
     }
 
+    void SongsPresenter::setPlayingStateCallback(std::function<void(SongState)> cb)
+    {
+        changePlayingStateCallback = std::move(cb);
+    }
+
 } // namespace app::music_player

@@ 32,6 32,8 @@ namespace app::music_player
             virtual bool resume()                          = 0;
             virtual bool stop()                            = 0;
             virtual void togglePlaying()                   = 0;
+
+            virtual void setPlayingStateCallback(std::function<void(SongsModelInterface::SongState)> cb) = 0;
         };
     };
 


@@ 50,9 52,11 @@ namespace app::music_player
         bool resume() override;
         bool stop() override;
         void togglePlaying() override;
+        void setPlayingStateCallback(std::function<void(SongsModelInterface::SongState)> cb) override;
 
       private:
         std::shared_ptr<SongsModelInterface> songsModelInterface;
         std::unique_ptr<AbstractAudioOperations> audioOperations;
+        std::function<void(SongsModelInterface::SongState)> changePlayingStateCallback = nullptr;
     };
 } // namespace app::music_player

@@ 23,15 23,14 @@ namespace locks
 
     class LockPolicyAccessInterface
     {
-        friend class app::ApplicationLauncher;
         AutoLockPolicy autoLockingPolicy = AutoLockPolicy::DetermineByWindow;
-        void set(AutoLockPolicy policy) noexcept;
 
       protected:
         [[nodiscard]] AutoLockPolicy get() const noexcept;
 
       public:
         virtual ~LockPolicyAccessInterface() = default;
+        void set(AutoLockPolicy policy) noexcept;
     };
 
     class LockPolicyHandlerInterface : public LockPolicyAccessInterface