[WIP] Livemetadata PR

.gitignore

@@ -57,3 +57,5 @@ lib/*/*.lib
 lib/*/lib/*.lib
 
 lib/qtscript-bytearray/*.cc
+
+*.vscode

build/depends.py

@@ -663,6 +663,8 @@ def sources(self, build):
                    "control/controlttrotary.cpp",
                    "control/controlencoder.cpp",
 
+                   "broadcast/metadatabroadcast.cpp",
+
                    "controllers/dlgcontrollerlearning.cpp",
                    "controllers/dlgprefcontroller.cpp",
                    "controllers/dlgprefcontrollers.cpp",
@@ -1093,6 +1095,7 @@ def sources(self, build):
                    "track/trackinfo.cpp",
                    "track/trackrecord.cpp",
                    "track/trackref.cpp",
+                   "track/trackplaytimers.cpp",
 
                    "mixer/auxiliary.cpp",
                    "mixer/baseplayer.cpp",

src/broadcast/metadatabroadcast.cpp

@@ -0,0 +1,37 @@
+#include "metadatabroadcast.h"
+#include "mixer/playerinfo.h"
+
+MetadataBroadcast::MetadataBroadcast() {
+    /*connect(&PlayerInfo::instance(),SIGNAL(trackLoaded(QString,TrackPointer)),
+            this,SLOT(slotTrackLoaded(QString,TrackPointer)));
+    connect(&PlayerInfo::instance(),SIGNAL(trackUnloaded(QString,TrackPointer)),
+            this,SLOT(slotTrackUnloaded(QString,TrackPointer)));
+    connect(&PlayerInfo::instance(),SIGNAL(trackPaused(QString,TrackPointer)),
+            this,SLOT(slotTrackPaused(QString,TrackPointer)));
+    connect(&PlayerInfo::instance(),SIGNAL(trackResumed(QString,TrackPointer)),
+            this,SLOT(slotTrackResumed(QString,TrackPointer)));*/
+}
+
+void MetadataBroadcast::slotTrackLoaded(QString group, TrackPointer pTrack) {
+    if (!pTrack)
+        return;
+    qDebug() << "Track " << pTrack->getTitle() << "loaded in group " << group << ".";
+}
+
+void MetadataBroadcast::slotTrackUnloaded(QString group, TrackPointer pTrack) {
+    if (!pTrack)
+        return;
+    qDebug() << "Track " << pTrack->getTitle() << "unloaded in group " << group << ".";
+}
+
+void MetadataBroadcast::slotTrackPaused(QString group, TrackPointer pTrack) {
+    if (!pTrack)
+        return;
+    qDebug() << "Track " << pTrack->getTitle() << "paused in group " << group << ".";
+}
+
+void MetadataBroadcast::slotTrackResumed(QString group, TrackPointer pTrack) {
+    if (!pTrack)
+        return;
+    qDebug() << "Track " << pTrack->getTitle() << "resumed in group " << group << ".";
+}

src/broadcast/metadatabroadcast.h

@@ -0,0 +1,13 @@
+#include <QObject>
+#include "track/track.h"
+
+class MetadataBroadcast : public QObject {
+    Q_OBJECT
+public:
+    MetadataBroadcast();
+public slots:
+    void slotTrackLoaded(QString group, TrackPointer pTrack);
+    void slotTrackUnloaded(QString group, TrackPointer pTrack);
+    void slotTrackPaused(QString group, TrackPointer pTrack);
+    void slotTrackResumed(QString group, TrackPointer pTrack);
+};

src/mixer/basetrackplayer.cpp

@@ -387,6 +387,10 @@ void BaseTrackPlayerImpl::slotSetReplayGain(mixxx::ReplayGain replayGain) {
 }
 
 void BaseTrackPlayerImpl::slotPlayToggled(double v) {
+    if (v == 0)
+        emit(trackPaused(m_pLoadedTrack));
+    else if (v == 1)
+        emit(trackResumed(m_pLoadedTrack));
     if (!v && m_replaygainPending) {
         setReplayGain(m_pLoadedTrack->getReplayGain().getRatio());
     }
@@ -472,3 +476,7 @@ void BaseTrackPlayerImpl::setReplayGain(double value) {
     m_pReplayGain->set(value);
     m_replaygainPending = false;
 }
+
+bool BaseTrackPlayerImpl::isTrackPaused() const {
+    return m_pPlay->toBool();
+}

src/mixer/basetrackplayer.h

@@ -44,6 +44,8 @@ class BaseTrackPlayer : public BasePlayer {
     void playerEmpty();
     void noPassthroughInputConfigured();
     void noVinylControlInputConfigured();
+    void trackPaused(TrackPointer pPausedTrack);
+    void trackResumed(TrackPointer pResumedTrack);
 };
 
 class BaseTrackPlayerImpl : public BaseTrackPlayer {
@@ -70,6 +72,8 @@ class BaseTrackPlayerImpl : public BaseTrackPlayer {
     // For testing, loads a fake track.
     TrackPointer loadFakeTrack(bool bPlay, double filebpm);
 
+    bool isTrackPaused() const;
+
   public slots:
     void slotLoadTrack(TrackPointer track, bool bPlay) final;
     void slotTrackLoaded(TrackPointer pNewTrack, TrackPointer pOldTrack);

src/mixer/playermanager.cpp

@@ -22,6 +22,7 @@
 #include "util/assert.h"
 #include "util/stat.h"
 #include "util/sleepableqthread.h"
+#include "broadcast/metadatabroadcast.h"
 
 //static
 QAtomicPointer<ControlProxy> PlayerManager::m_pCOPNumDecks;
@@ -51,7 +52,9 @@ PlayerManager::PlayerManager(UserSettingsPointer pConfig,
         m_pCONumMicrophones(new ControlObject(
                 ConfigKey("[Master]", "num_microphones"), true, true)),
         m_pCONumAuxiliaries(new ControlObject(
-                ConfigKey("[Master]", "num_auxiliaries"), true, true)) {
+                ConfigKey("[Master]", "num_auxiliaries"), true, true)),
+        m_pMetadataBroadcast(new MetadataBroadcast())
+        {
     connect(m_pCONumDecks, SIGNAL(valueChanged(double)),
             this, SLOT(slotNumDecksControlChanged(double)),
             Qt::DirectConnection);
@@ -109,6 +112,7 @@ PlayerManager::~PlayerManager() {
     delete m_pCONumPreviewDecks;
     delete m_pCONumMicrophones;
     delete m_pCONumAuxiliaries;
+    delete m_pMetadataBroadcast;
     if (m_pAnalyzerQueue) {
         delete m_pAnalyzerQueue;
     }
@@ -366,6 +370,17 @@ void PlayerManager::addDeckInner() {
     connect(pDeck, SIGNAL(noVinylControlInputConfigured()),
             this, SIGNAL(noVinylControlInputConfigured()));
 
+    connect(pDeck,SIGNAL(trackPaused(TrackPointer)),
+            this, SLOT(slotTrackPaused(TrackPointer)));
+    connect(pDeck,SIGNAL(trackResumed(TrackPointer)),
+            this, SLOT(slotTrackResumed(TrackPointer)));
+    connect(pDeck,SIGNAL(newTrackLoaded(TrackPointer)),
+            this, SLOT(slotNewTrackLoaded(TrackPointer)));
+    connect(pDeck,SIGNAL(loadingTrack(TrackPointer,TrackPointer)),
+            this, SLOT(slotLoadingTrack(TrackPointer,TrackPointer))); 
+    connect(pDeck,SIGNAL(playerEmpty()),
+            this, SLOT(slotPlayerEmpty()));   
+
     if (m_pAnalyzerQueue) {
         connect(pDeck, SIGNAL(newTrackLoaded(TrackPointer)),
                 m_pAnalyzerQueue, SLOT(slotAnalyseTrack(TrackPointer)));
@@ -620,3 +635,60 @@ void PlayerManager::slotLoadTrackIntoNextAvailableSampler(TrackPointer pTrack) {
         ++it;
     }
 }
+
+void PlayerManager::slotTrackPaused(TrackPointer pPausedTrack) {
+    if (!pPausedTrack)
+        return;    
+    QMutexLocker locker(&m_mutex);
+    bool allPaused = true;
+    foreach (Deck *deck,m_decks) {
+        if (deck->getLoadedTrack() == pPausedTrack && !deck->isTrackPaused()) {
+            allPaused = false;
+            break;
+        } 
+    }
+    if (allPaused)
+        pPausedTrack->pausePlayedTime();    
+}
+
+void PlayerManager::slotTrackResumed(TrackPointer pPausedTrack) {
+    if (!pPausedTrack)
+        return;
+    QMutexLocker locker(&m_mutex);
+    pPausedTrack->resumePlayedTime();
+}
+
+void PlayerManager::slotLoadingTrack(TrackPointer pNewTrack, TrackPointer pOldTrack) {
+    QMutexLocker locker(&m_mutex);
+    Deck *loadingDeck = qobject_cast<Deck*>(sender());
+    if (pOldTrack) {
+        bool allUnloaded = true;
+        foreach(Deck *deck,m_decks) {
+            if (deck != loadingDeck && deck->getLoadedTrack() == pOldTrack) {
+                allUnloaded = false;
+                break;
+            }
+        }
+        if (allUnloaded)
+            m_tracksToBeReset.append(trackDeckPair(pOldTrack,loadingDeck));
+    }
+}
+
+void PlayerManager::slotNewTrackLoaded(TrackPointer pNewTrack) {
+    resetTrack(qobject_cast<Deck*>(sender()));
+}
+
+void PlayerManager::slotPlayerEmpty() {
+    resetTrack(qobject_cast<Deck*>(sender()));
+}
+
+void PlayerManager::resetTrack(Deck *deck) {
+    QMutexLocker locker(&m_mutex);
+    Deck *loadingDeck = qobject_cast<Deck*>(sender());
+    foreach (trackDeckPair pair,m_tracksToBeReset) {
+        if (loadingDeck == pair.pDeck) {
+            pair.pTrack->resetPlayedTime();
+            break;
+        }
+    }
+}

src/mixer/playermanager.h

@@ -25,6 +25,7 @@ class PreviewDeck;
 class Sampler;
 class SamplerBank;
 class SoundManager;
+class MetadataBroadcast;
 
 // For mocking PlayerManager.
 class PlayerManagerInterface {
@@ -233,10 +234,21 @@ class PlayerManager : public QObject, public PlayerManagerInterface {
     // Must hold m_mutex before calling this method. Internal method that
     // creates a new auxiliary.
     void addAuxiliaryInner();
+    //Resets the played timer in the track a just switched.
+    void resetTrack(Deck *deck);
 
     // Used to protect access to PlayerManager state across threads.
     mutable QMutex m_mutex;
 
+  private slots:    
+    void slotTrackPaused(TrackPointer pPausedTrack);
+    void slotTrackResumed(TrackPointer pResumedTrack);
+    void slotLoadingTrack(TrackPointer pNewTrack, TrackPointer pOldTrack);
+    void slotNewTrackLoaded(TrackPointer pNewTrack);
+    void slotPlayerEmpty();
+
+  private:
+
     UserSettingsPointer m_pConfig;
     SoundManager* m_pSoundManager;
     EffectsManager* m_pEffectsManager;
@@ -254,7 +266,17 @@ class PlayerManager : public QObject, public PlayerManagerInterface {
     QList<PreviewDeck*> m_preview_decks;
     QList<Microphone*> m_microphones;
     QList<Auxiliary*> m_auxiliaries;
-    QMap<QString, BaseTrackPlayer*> m_players;
+    QMap<QString, BaseTrackPlayer*> m_players; 
+
+    //Live metadata section
+    MetadataBroadcast *m_pMetadataBroadcast;
+    struct trackDeckPair {
+        TrackPointer pTrack;
+        Deck *pDeck;
+        trackDeckPair(TrackPointer pTrack, Deck *pDeck) :
+        pTrack(pTrack),pDeck(pDeck) {}
+    };
+    QList<trackDeckPair> m_tracksToBeReset;
 };
 
 #endif // MIXER_PLAYERMANAGER_H

src/test/trackplayedtimer_test.cpp

@@ -0,0 +1,46 @@
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+#include "track/track.h"
+#include "track/trackplaytimers.h"
+#include "test/trackplayedtimer_test.h"
+
+class ElapsedTimerMock : public TrackTimers::ElapsedTimer {
+  public:
+    ~ElapsedTimerMock() = default;
+    MOCK_METHOD0(invalidate,void());
+    MOCK_METHOD0(start,void());
+    MOCK_METHOD0(isValid,bool());
+    MOCK_METHOD0(elapsed,qint64());
+};
+
+
+class TrackTest : public testing::Test {
+  public:
+    TrackTest() {
+        testTrack = Track::newDummy(QFileInfo(),TrackId());        
+    }
+    ~TrackTest() = default;
+    TrackPointer testTrack;
+  public slots:
+};
+
+TEST_F(TrackTest,SendsSignalWhenScrobbable) {
+    testTrack->setDuration(5);
+    ElapsedTimerMock etmock;
+    TimerMock tmock;
+    EXPECT_CALL(etmock,invalidate());
+    EXPECT_CALL(etmock,isValid())
+        .WillOnce(testing::Return(false))
+        .WillOnce(testing::Return(true));
+    EXPECT_CALL(etmock,start());
+    EXPECT_CALL(tmock,start(1000))
+        .WillOnce(testing::InvokeWithoutArgs(testTrack.get(),
+                  &Track::slotCheckIfScrobbable));
+    EXPECT_CALL(etmock,elapsed())
+        .WillOnce(testing::Return(2500));   
+    testTrack->setTimer(&tmock);
+    testTrack->setElapsedTimer(&etmock);
+    testTrack->resetPlayedTime();
+    testTrack->resumePlayedTime();
+    ASSERT_TRUE(testTrack->isScrobbable());
+}

src/test/trackplayedtimer_test.h

@@ -0,0 +1,12 @@
+#include <QObject>
+#include "track/trackplaytimers.h"
+#include "gmock/gmock.h"
+
+class TimerMock : public TrackTimers::TrackTimer {
+    Q_OBJECT
+  public:
+    ~TimerMock() = default;
+    MOCK_METHOD1(start,void(int msec));
+    MOCK_METHOD0(isActive,bool());
+    MOCK_METHOD0(stop,void());
+};