[Playback] Cache Player instance within Playback

framework/audio/main/internal/playback.cpp

@@ -168,6 +168,11 @@ void Playback::deinit()
     m_saveSoundTrackProgressStreamInited = false;
     m_saveSoundTrackProgressStreamId = 0;
 
+    if (m_player) {
+        m_player->deinit();
+        m_player.reset();
+    }
+
     channel()->send(rpc::make_request(rpc::GLOBAL_CTX_ID, MsgCode::ContextDeinit, RpcPacker::pack(ctxId())));
     m_inited.set(false);
 }
@@ -184,9 +189,17 @@ async::Channel<bool> Playback::initedChanged() const
 
 IPlayerPtr Playback::player() const
 {
-    std::shared_ptr<Player> p = std::make_shared<Player>(iocContext());
-    p->init();
-    return p;
+    //! NOTE The player requests the engine context, so it must exist
+    IF_ASSERT_FAILED(isInited()) {
+        return nullptr;
+    }
+
+    if (!m_player) {
+        m_player = std::make_shared<Player>(iocContext());
+        m_player->init();
+    }
+
+    return m_player;
 }
 
 template<typename T>

framework/audio/main/internal/playback.h

@@ -26,12 +26,14 @@
 #include "global/types/retval.h"
 
 #include "modularity/ioc.h"
-#include "common/rpc/irpcchannel.h"
+#include "audio/common/rpc/irpcchannel.h"
 #include "../istartaudiocontroller.h"
 
 #include "../iplayer.h"
 
 namespace muse::audio {
+class Player;
+
 //! NOTE It may not use contextual services,
 // but the playback itself is contextual,
 // because each context (window) has its own playback.
@@ -138,5 +140,7 @@ class Playback : public IPlayback, public async::Asyncable, public Contextable
     mutable bool m_saveSoundTrackProgressStreamInited = false;
     async::Channel<int64_t, int64_t, SaveSoundTrackStage> m_saveSoundTrackProgressStream;
     mutable rpc::StreamId m_saveSoundTrackProgressStreamId = 0;
+
+    mutable std::shared_ptr<Player> m_player;
 };
 }

framework/audio/main/internal/player.cpp

@@ -48,8 +48,12 @@ void Player::init()
         });
 
         Msg msg = rpc::make_request(ctxId(), MsgCode::GetPlaybackStatus);
-        channel()->send(msg, [this](const Msg& res) {
+        channel()->send(msg, [this, alive = std::weak_ptr<bool>(m_alive)](const Msg& res) {
             ONLY_AUDIO_MAIN_THREAD;
+            if (alive.expired()) {
+                return;
+            }
+
             Ret ret;
             PlaybackStatus status = PlaybackStatus::Stopped;
             StreamId streamId = 0;
@@ -58,6 +62,7 @@ void Player::init()
             }
 
             if (ret) {
+                m_playbackStatusStreamId = streamId;
                 channel()->addReceiveStream(StreamName::PlaybackStatusStream, streamId, m_playbackStatusChanged);
                 //! NOTE Send initial state
                 m_playbackStatusChanged.send(status);
@@ -73,8 +78,12 @@ void Player::init()
         });
 
         Msg msg = rpc::make_request(ctxId(), MsgCode::GetPlaybackPosition);
-        channel()->send(msg, [this](const Msg& res) {
+        channel()->send(msg, [this, alive = std::weak_ptr<bool>(m_alive)](const Msg& res) {
             ONLY_AUDIO_MAIN_THREAD;
+            if (alive.expired()) {
+                return;
+            }
+
             Ret ret;
             secs_t pos = 0.0;
             StreamId streamId = 0;
@@ -83,6 +92,7 @@ void Player::init()
             }
 
             if (ret) {
+                m_playbackPositionStreamId = streamId;
                 channel()->addReceiveStream(StreamName::PlaybackPositionStream, streamId, m_playbackPositionChanged);
                 //! NOTE Send initial state
                 m_playbackPositionChanged.send(pos);
@@ -93,6 +103,26 @@ void Player::init()
     }
 }
 
+void Player::deinit()
+{
+    ONLY_AUDIO_MAIN_THREAD;
+
+    m_alive.reset();
+
+    if (m_playbackStatusStreamId != 0) {
+        channel()->removeStream(m_playbackStatusStreamId);
+        m_playbackStatusStreamId = 0;
+    }
+
+    if (m_playbackPositionStreamId != 0) {
+        channel()->removeStream(m_playbackPositionStreamId);
+        m_playbackPositionStreamId = 0;
+    }
+
+    m_playbackStatusChanged.disconnect(this);
+    m_playbackPositionChanged.disconnect(this);
+}
+
 async::Promise<Ret> Player::prepareToPlay()
 {
     ONLY_AUDIO_MAIN_THREAD;

framework/audio/main/internal/player.h

@@ -40,6 +40,7 @@ class Player : public IPlayer, public Contextable, public async::Asyncable
         : Contextable(ctx) {}
 
     void init();
+    void deinit();
 
     async::Promise<Ret> prepareToPlay() override;
 
@@ -68,6 +69,12 @@ class Player : public IPlayer, public Contextable, public async::Asyncable
 
     secs_t m_playbackPosition = 0.0;
     async::Channel<secs_t> m_playbackPositionChanged;
+
+    rpc::StreamId m_playbackStatusStreamId = 0;
+    rpc::StreamId m_playbackPositionStreamId = 0;
+
+    //! NOTE Responses may come after deinit, they must not be handled
+    std::shared_ptr<bool> m_alive = std::make_shared<bool>(true);
 };
 }
 

framework/audio/tests/CMakeLists.txt

@@ -25,10 +25,12 @@ set(MODULE_TEST_SRC
     ${CMAKE_CURRENT_LIST_DIR}/mocks/audiodriverfactorymock.h
     ${CMAKE_CURRENT_LIST_DIR}/mocks/audiodrivermock.h
     ${CMAKE_CURRENT_LIST_DIR}/mocks/rpcchannelmock.h
+    ${CMAKE_CURRENT_LIST_DIR}/mocks/startaudiocontrollermock.h
 
     ${CMAKE_CURRENT_LIST_DIR}/alignbuffer_tests.cpp
     ${CMAKE_CURRENT_LIST_DIR}/audioresourcetypes_tests.cpp
     ${CMAKE_CURRENT_LIST_DIR}/audiodrivercontroller_tests.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/playback_tests.cpp
 )
 
 set(MODULE_TEST_LINK

framework/audio/tests/mocks/startaudiocontrollermock.h

@@ -0,0 +1,38 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0-only
+ * MuseScore-CLA-applies
+ *
+ * MuseScore
+ * Music Composition & Notation
+ *
+ * Copyright (C) 2026 MuseScore Limited and others
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+#pragma once
+
+#include <gmock/gmock.h>
+
+#include "audio/main/istartaudiocontroller.h"
+
+namespace muse::audio {
+class StartAudioControllerMock : public IStartAudioController
+{
+public:
+    MOCK_METHOD(void, startAudioProcessing, (const IApplication::RunMode&), (override));
+    MOCK_METHOD(void, stopAudioProcessing, (), (override));
+
+    MOCK_METHOD(bool, isAudioStarted, (), (const, override));
+    MOCK_METHOD(async::Channel<bool>, isAudioStartedChanged, (), (const, override));
+};
+}