[WIP] Livemetadata PR

SConstruct

@@ -58,6 +58,7 @@ available_features = [features.Mad,
                       features.LocaleCompare,
                       features.Lilv,
                       features.Battery,
+                      features.MPRIS,
 
                       # "Features" of dubious quality
                       features.PerfTools,

build/depends.py

@@ -499,6 +499,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):
@@ -699,6 +700,13 @@ def configure(self, build, conf):
             raise Exception(
                 "Could not find qtkeychain.")
 
+class QtDBus(Dependence):
+    def configure(self, build, conf):
+        libs = ['Qt5DBus']
+        if not conf.CheckLib(libs):
+            raise Exception('Couldn\'t find Qt5Dbus5 library.')
+
+
 class MixxxCore(Feature):
 
     def description(self):
@@ -724,6 +732,16 @@ def sources(self, build):
                    "control/controlttrotary.cpp",
                    "control/controlencoder.cpp",
 
+                   "broadcast/metadatabroadcast.cpp",
+                   "broadcast/scrobblingmanager.cpp",
+                   "broadcast/filelistener/filelistener.cpp",
+                   "broadcast/filelistener/metadatafileworker.cpp",
+                   "broadcast/listenbrainzlistener/networkrequest.cpp",
+                   "broadcast/listenbrainzlistener/networkmanager.cpp",
+                   "broadcast/listenbrainzlistener/networkreply.cpp",
+                   "broadcast/listenbrainzlistener/listenbrainzservice.cpp",
+                   "broadcast/listenbrainzlistener/listenbrainzjsonfactory.cpp",
+
                    "controllers/dlgcontrollerlearning.cpp",
                    "controllers/dlgprefcontroller.cpp",
                    "controllers/dlgprefcontrollers.cpp",
@@ -737,6 +755,7 @@ def sources(self, build):
                    "preferences/dialog/dlgprefeffects.cpp",
                    "preferences/dialog/dlgprefeq.cpp",
                    "preferences/dialog/dlgpreferences.cpp",
+                   "preferences/dialog/dlgprefmetadata.cpp",
                    "preferences/dialog/dlgprefinterface.cpp",
                    "preferences/dialog/dlgpreflibrary.cpp",
                    "preferences/dialog/dlgprefnovinyl.cpp",
@@ -752,6 +771,8 @@ def sources(self, build):
                    "preferences/broadcastsettingsmodel.cpp",
                    "preferences/effectsettingsmodel.cpp",
                    "preferences/broadcastprofile.cpp",
+                   "preferences/metadatafilesettings.cpp",
+                   "preferences/listenbrainzsettings.cpp",
                    "preferences/upgrade.cpp",
                    "preferences/dlgpreferencepage.cpp",
 
@@ -1155,6 +1176,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",
@@ -1266,6 +1289,8 @@ def sources(self, build):
             'preferences/dialog/dlgprefautodjdlg.ui',
             'preferences/dialog/dlgprefbeatsdlg.ui',
             'preferences/dialog/dlgprefdeckdlg.ui',
+            'preferences/dialog/dlgprefmetadatadlg.ui',
+            'preferences/dialog/dlgfilelistenerbox.ui',
             'preferences/dialog/dlgprefcrossfaderdlg.ui',
             'preferences/dialog/dlgpreflv2dlg.ui',
             'preferences/dialog/dlgprefeffectsdlg.ui',
@@ -1356,7 +1381,7 @@ def configure(self, build, conf):
                 # http://clang.llvm.org/docs/ThreadSafetyAnalysis.html
                 build.env.Append(CCFLAGS='-Wthread-safety')
             build.env.Append(CCFLAGS='-Wextra')
-
+            build.env.Append(CCFLAGS='-Werror=return-type')
             # Always generate debugging info.
             build.env.Append(CCFLAGS='-g')
         elif build.toolchain_is_msvs:

build/features.py

@@ -1363,3 +1363,37 @@ def sources(self, build):
 
     def depends(self, build):
         return [depends.QtKeychain]
+
+class MPRIS(Feature):
+    def description(self):
+        return "MPRIS implementation using QtDbus"
+
+    def enabled(self,build):
+        if build.platform_is_linux:
+            build.flags['mpris'] = util.get_flags(build.env, 'mpris', 1)
+        else:
+            build.flags['mpris'] = util.get_flags(build.env, 'mpris', 0)
+        if int(build.flags['mpris']):
+            return True
+        return False
+
+    def add_options(self, build, vars):
+        vars.Add('mpris', 'Set to 1 to enable MPRIS implementation to broadcast current track and interact with Mixxx', 0)
+
+    def configure(self,build,conf):
+        if build.platform_is_linux and self.enabled(build):
+            build.env.Append(CPPDEFINES='__MPRIS__')
+
+    def sources(self,build):
+        if build.platform_is_linux:
+            return ["broadcast/mpris/mprisservice.cpp",
+                    "broadcast/mpris/mpris.cpp",
+                    "broadcast/mpris/mediaplayer2.cpp",
+                    "broadcast/mpris/mediaplayer2player.cpp",
+                    "broadcast/mpris/mprisplayer.cpp",
+                    "broadcast/mpris/mediaplayer2playlists.cpp",
+                    "broadcast/mpris/mediaplayer2tracklist.cpp"]
+        return []
+    def depends(self,build):
+        return [depends.QtDBus]
+

src/broadcast/broadcastmanager.cpp

@@ -27,7 +27,7 @@ BroadcastManager::BroadcastManager(SettingsManager* pSettingsManager,
           m_pNetworkStream(pSoundManager->getNetworkStream()) {
     const bool persist = true;
     m_pBroadcastEnabled = new ControlPushButton(
-            ConfigKey(BROADCAST_PREF_KEY,"enabled"), persist);
+            ConfigKey(BROADCAST_PREF_KEY, "enabled"), persist);
     m_pBroadcastEnabled->setButtonMode(ControlPushButton::TOGGLE);
     connect(m_pBroadcastEnabled, SIGNAL(valueChanged(double)),
             this, SLOT(slotControlEnabled(double)));

src/broadcast/filelistener/filelistener.cpp

@@ -0,0 +1,117 @@
+
+#include <QTextCodec>
+#include <QtConcurrentRun>
+
+#include "broadcast/filelistener/filelistener.h"
+#include "broadcast/filelistener/metadatafileworker.h"
+#include "preferences/metadatafilesettings.h"
+
+
+FileListener::FileListener(UserSettingsPointer pConfig)
+        : m_COsettingsChanged(kFileSettingsChanged),
+          m_pConfig(pConfig),
+          m_latestSettings(MetadataFileSettings::getPersistedSettings(pConfig)),
+          m_filePathChanged(false),
+          m_tracksPaused(false) {
+
+    MetadataFileWorker *newWorker = new MetadataFileWorker(m_latestSettings.filePath);
+    newWorker->moveToThread(&m_workerThread);
+
+    connect(&m_workerThread, SIGNAL(finished()),
+            newWorker, SLOT(deleteLater()));
+
+    connect(this, SIGNAL(deleteFile()),
+            newWorker, SLOT(slotDeleteFile()));
+
+    connect(this, SIGNAL(moveFile(QString)),
+            newWorker, SLOT(slotMoveFile(QString)));
+
+    connect(this, SIGNAL(writeMetadataToFile(QByteArray)),
+            newWorker, SLOT(slotWriteMetadataToFile(QByteArray)));
+
+    connect(this, SIGNAL(clearFile()),
+            newWorker, SLOT(slotClearFile()));
+
+    connect(&m_COsettingsChanged, SIGNAL(valueChanged(double)),
+            this, SLOT(slotFileSettingsChanged(double)));
+
+    m_workerThread.start();
+}
+
+FileListener::~FileListener() {
+    emit clearFile();
+    m_workerThread.quit();
+    m_workerThread.wait();
+}
+
+
+void FileListener::slotBroadcastCurrentTrack(TrackPointer pTrack) {
+    if (!m_latestSettings.enabled) {
+        return;
+    }
+    if (!pTrack) {
+        emit clearFile();
+    }
+    else {
+        m_fileContents.title = pTrack->getTitle();
+        m_fileContents.artist = pTrack->getArtist();
+        QString writtenString(m_latestSettings.fileFormatString);
+        writtenString.replace("$author", pTrack->getArtist()).
+                replace("$title", pTrack->getTitle()) += '\n';
+        QTextCodec *codec = QTextCodec::codecForName(m_latestSettings.fileEncoding);
+        DEBUG_ASSERT(codec);
+        QByteArray fileContents = codec->fromUnicode(writtenString);
+        m_tracksPaused = false;
+        emit writeMetadataToFile(fileContents);
+    }
+}
+
+void FileListener::slotScrobbleTrack(TrackPointer pTrack) {
+    Q_UNUSED(pTrack);
+}
+
+void FileListener::slotAllTracksPaused() {
+    if (!m_latestSettings.enabled) {
+        return;
+    }
+    m_tracksPaused = true;
+    emit clearFile();
+}
+
+void FileListener::slotFileSettingsChanged(double value) {
+    if (value) {
+        FileSettings latestSettings = MetadataFileSettings::getLatestSettings();
+        m_filePathChanged = latestSettings.filePath != m_latestSettings.filePath;
+        m_latestSettings = latestSettings;
+        updateStateFromSettings();
+    }
+}
+
+void FileListener::updateStateFromSettings() {
+    if (m_latestSettings.enabled) {
+        updateFile();
+    }
+    else  {
+        emit deleteFile();
+    }
+}
+
+void FileListener::updateFile() {
+    if (m_filePathChanged) {
+        emit moveFile(m_latestSettings.filePath);
+        m_filePathChanged = false;
+    }
+    if (!m_tracksPaused && !m_fileContents.isEmpty()) {
+        QTextCodec *codec = QTextCodec::codecForName(m_latestSettings.fileEncoding);
+        if (!codec) {
+            qWarning() << "Text codec selected from metadata broadcast settings doesn't exist";
+            codec = QTextCodec::codecForName("UTF-8");
+        }
+        QString newContents(m_latestSettings.fileFormatString);
+        newContents.replace("$author", m_fileContents.artist)
+                   .replace("$title", m_fileContents.title) += '\n';
+        QByteArray contentsBinary = codec->fromUnicode(newContents);
+        emit writeMetadataToFile(contentsBinary);
+    }
+}
+

src/broadcast/filelistener/filelistener.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <QFile>
+#include <QThread>
+#include "preferences/dialog/dlgprefmetadata.h"
+#include "control/controlpushbutton.h"
+#include "broadcast/scrobblingservice.h"
+
+class FileListener: public ScrobblingService {
+    Q_OBJECT
+  public:
+    explicit FileListener(UserSettingsPointer pSettings);
+    ~FileListener() override;
+    void slotBroadcastCurrentTrack(TrackPointer pTrack) override;
+    void slotScrobbleTrack(TrackPointer pTrack) override;
+    void slotAllTracksPaused() override;
+  signals:
+    void deleteFile();
+    void moveFile(QString destination);
+    void writeMetadataToFile(QByteArray contents);
+    void clearFile();
+  private slots:
+    void slotFileSettingsChanged(double value);
+  private:
+
+    struct WrittenMetadata {
+        QString title, artist;
+        bool isEmpty() {
+            return title.isEmpty() && artist.isEmpty();
+        }
+    };
+
+    void updateStateFromSettings();
+    void updateFile();
+
+    ControlPushButton m_COsettingsChanged;
+    UserSettingsPointer m_pConfig;
+    FileSettings m_latestSettings;
+    QThread m_workerThread;
+    WrittenMetadata m_fileContents;
+    bool m_filePathChanged;
+    bool m_tracksPaused;
+};

src/broadcast/filelistener/metadatafileworker.cpp

@@ -0,0 +1,29 @@
+
+#include "broadcast/filelistener/metadatafileworker.h"
+
+MetadataFileWorker::MetadataFileWorker(const QString& filePath)
+        :  m_file(filePath) {
+}
+
+void MetadataFileWorker::slotDeleteFile() {
+    m_file.remove();
+}
+
+void MetadataFileWorker::slotMoveFile(QString destination) {
+    m_file.remove();
+    m_file.setFileName(destination);
+}
+
+void MetadataFileWorker::slotWriteMetadataToFile(QByteArray fileContents) {
+    m_file.open(QIODevice::WriteOnly |
+                QIODevice::Text |
+                QIODevice::Unbuffered);
+    m_file.write(fileContents);
+    m_file.close();
+}
+
+void MetadataFileWorker::slotClearFile() {
+    m_file.resize(0);
+}
+
+

src/broadcast/filelistener/metadatafileworker.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <QObject>
+#include <QFile>
+
+class MetadataFileWorker : public QObject {
+    Q_OBJECT
+  public:
+    explicit MetadataFileWorker(const QString& filePath);
+  public slots:
+    void slotDeleteFile();
+    void slotMoveFile(QString destination);
+    void slotWriteMetadataToFile(QByteArray fileContents);
+    void slotClearFile();
+  private:
+    QFile m_file;
+};
+

src/broadcast/listenbrainzlistener/listenbrainzjsonfactory.cpp

@@ -0,0 +1,38 @@
+
+#include <QDateTime>
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QJsonObject>
+
+#include "broadcast/listenbrainzlistener/listenbrainzjsonfactory.h"
+
+
+QByteArray ListenBrainzJSONFactory::getJSONFromTrack(TrackPointer pTrack, JsonType type) {
+    QJsonObject jsonObject;
+    QString stringType;
+    if (type == NowListening) {
+        stringType = "playing_now";
+    }
+    else {
+        stringType = "single";
+    }
+
+    QJsonArray payloadArray;
+    QJsonObject payloadObject;
+    QJsonObject metadataObject;
+    QString title = pTrack->getTitle();
+    QString artist = pTrack->getArtist();
+    metadataObject.insert("artist_name", artist);
+    metadataObject.insert("track_name", title);
+    payloadObject.insert("track_metadata", metadataObject);
+    qint64 timeStamp = QDateTime::currentMSecsSinceEpoch() / 1000;
+
+    if (type == Single) {
+        payloadObject.insert("listened_at", timeStamp);
+    }
+    payloadArray.append(payloadObject);
+    jsonObject.insert("listen_type", stringType);
+    jsonObject.insert("payload", payloadArray);
+    QJsonDocument doc(jsonObject);
+    return doc.toJson(QJsonDocument::Compact);
+}