[WIP] Livemetadata PR

.gitignore

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

build/depends.py

@@ -438,6 +438,7 @@ def configure(self, build, conf):
 class TestHeaders(Dependence):
     def configure(self, build, conf):
         build.env.Append(CPPPATH="#lib/gtest-1.7.0/include")
+        build.env.Append(CPPPATH="#lib/gmock-1.7.0/include")
 
 class FidLib(Dependence):
     def sources(self, build):
@@ -663,6 +664,10 @@ def sources(self, build):
                    "control/controlttrotary.cpp",
                    "control/controlencoder.cpp",
 
+                   "broadcast/metadatabroadcast.cpp",
+                   "broadcast/scrobblingmanager.cpp",
+                   "broadcast/filelistener.cpp",
+
                    "controllers/dlgcontrollerlearning.cpp",
                    "controllers/dlgprefcontroller.cpp",
                    "controllers/dlgprefcontrollers.cpp",
@@ -1093,6 +1098,8 @@ def sources(self, build):
                    "track/trackinfo.cpp",
                    "track/trackrecord.cpp",
                    "track/trackref.cpp",
+                   "track/trackplaytimers.cpp",
+                   "track/tracktiminginfo.cpp",
 
                    "mixer/auxiliary.cpp",
                    "mixer/baseplayer.cpp",

src/broadcast/filelistener.cpp

@@ -0,0 +1,32 @@
+
+#include "broadcast/filelistener.h"
+
+
+FileListener::FileListener(const QString &path) :
+    m_file(path)
+{
+    QFileInfo fileInfo(path);
+    qDebug() << "Absolute path " << fileInfo.absoluteFilePath();
+    qDebug() << "File exists: " << fileInfo.exists();
+    m_file.open(QIODevice::WriteOnly |
+                QIODevice::Text |
+                QIODevice::Unbuffered);
+
+}
+
+FileListener::~FileListener() {
+    m_file.resize(0);
+}
+
+void FileListener::broadcastCurrentTrack(TrackPointer pTrack) {
+    if (!pTrack)
+        return;
+    QTextStream stream(&m_file);
+    m_file.resize(0);
+    stream << "Now listening " << pTrack->getTitle();
+    stream << " by " << pTrack->getArtist();
+}
+
+void FileListener::scrobbleTrack(TrackPointer pTrack) {
+
+}

src/broadcast/filelistener.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <QFile>
+#include "broadcast/scrobblingservice.h"
+
+class FileListener: public ScrobblingService {
+  public:
+    FileListener(const QString &path);
+    ~FileListener();
+    void broadcastCurrentTrack(TrackPointer pTrack) override;
+    void scrobbleTrack(TrackPointer pTrack) override;
+  private:
+    QFile m_file;
+};

src/broadcast/metadatabroadcast.cpp

@@ -0,0 +1,77 @@
+
+#include <QLinkedListIterator>
+
+#include "broadcast/metadatabroadcast.h"
+#include "mixer/playerinfo.h"
+
+MetadataBroadcaster::MetadataBroadcaster()
+{
+
+}
+
+void MetadataBroadcaster::slotAttemptScrobble(TrackPointer pTrack) {
+    for (auto it = m_trackedTracks.begin();
+         it != m_trackedTracks.end();
+         ++it) {
+        if (*it == GracePeriod(0,pTrack)) {
+            GracePeriod &trackPeriod = *it;
+            if (trackPeriod.hasBeenEjected &&
+                trackPeriod.m_msElapsed > 
+                static_cast<double>(m_gracePeriodSeconds)*1000.0) {
+                for (auto &service : m_scrobblingServices) {
+                    service->scrobbleTrack(pTrack);
+                }
+                trackPeriod.hasBeenEjected = false;
+                trackPeriod.m_numberOfScrobbles++;                     
+            }
+            break;
+        }
+    }
+}
+
+void MetadataBroadcaster::slotNowListening(TrackPointer pTrack) {
+    for (auto &service : m_scrobblingServices) {
+        service->broadcastCurrentTrack(pTrack);
+    }
+}
+
+QLinkedList<TrackId> MetadataBroadcaster::getTrackedTracks() {
+    //Stub    
+    return QLinkedList<TrackId>();
+}
+
+MetadataBroadcaster& MetadataBroadcaster::addNewScrobblingService(ScrobblingService *service) {
+    m_scrobblingServices.push_back(
+        std::move(std::unique_ptr<ScrobblingService>(service)));
+    return *this;    
+}
+
+void MetadataBroadcaster::newTrackLoaded(TrackPointer pTrack) {
+    QLinkedListIterator<GracePeriod> it(m_trackedTracks);
+    if (!it.findNext(GracePeriod(0,pTrack))) {
+        GracePeriod newPeriod(0,pTrack);        
+        m_trackedTracks.append(newPeriod);
+    }        
+}
+
+void MetadataBroadcaster::trackUnloaded(TrackPointer pTrack) {
+    for (auto it = m_trackedTracks.begin();
+         it != m_trackedTracks.end();
+         ++it) {
+        if (*it == GracePeriod(0,pTrack)) {
+            it->hasBeenEjected = true;
+            it->m_msElapsed = 0;
+        }
+        break;
+    }   
+}
+
+void MetadataBroadcaster::slotGuiTick(double timeSinceLastTick) {
+    for (auto it = m_trackedTracks.begin();
+         it != m_trackedTracks.end();
+         ++it) {
+        if (it->hasBeenEjected) {
+            it->m_msElapsed += timeSinceLastTick;
+        }
+    } 
+}

src/broadcast/metadatabroadcast.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <QObject>
+#include <QLinkedList>
+#include <list>
+
+#include "broadcast/scrobblingservice.h"
+#include "track/track.h"
+#include "track/trackid.h"
+#include "track/trackplaytimers.h"
+
+class MetadataBroadcaster : public QObject {
+    Q_OBJECT    
+  private:
+    struct GracePeriod {
+        double m_msElapsed;
+        unsigned int m_numberOfScrobbles = 0;
+        TrackId m_trackId;
+        bool hasBeenEjected = false;      
+        GracePeriod(double msElapsed,TrackPointer pTrack) :
+        m_msElapsed(msElapsed),m_trackId(pTrack->getId()) {}
+        bool operator==(const GracePeriod &other) const {
+          return m_trackId == other.m_trackId;
+        }
+    };  
+  public:    
+
+    MetadataBroadcaster();
+    QLinkedList<TrackId> getTrackedTracks();
+    MetadataBroadcaster& addNewScrobblingService(ScrobblingService *service);
+    void newTrackLoaded(TrackPointer pTrack);
+    void trackUnloaded(TrackPointer pTrack);
+    void setGracePeriod(unsigned int seconds);
+
+  public slots:
+    void slotAttemptScrobble(TrackPointer pTrack);
+    void slotNowListening(TrackPointer pTrack);
+    void slotGuiTick(double timeSinceLastTick);
+  private:    
+    unsigned int m_gracePeriodSeconds;
+    QLinkedList<GracePeriod> m_trackedTracks;
+    std::list<std::unique_ptr<ScrobblingService>> m_scrobblingServices;    
+};