[WIP] Livemetadata PR

build/depends.py

@@ -497,6 +497,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):
@@ -722,6 +723,23 @@ 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",
+                   "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",
+
                    "controllers/dlgcontrollerlearning.cpp",
                    "controllers/dlgprefcontroller.cpp",
                    "controllers/dlgprefcontrollers.cpp",
@@ -735,6 +753,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",
@@ -750,6 +769,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",
 
@@ -1153,6 +1174,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",
@@ -1264,6 +1287,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',
@@ -1354,7 +1379,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:

src/broadcast/filelistener/filelistener.cpp

@@ -0,0 +1,107 @@
+
+#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() {
+    m_workerThread.quit();
+    m_workerThread.wait();
+}
+
+
+void FileListener::slotBroadcastCurrentTrack(TrackPointer pTrack) {
+    if (!pTrack)
+        return;
+    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() {
+    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,30 @@
+
+#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);
+}

src/broadcast/listenbrainzlistener/listenbrainzjsonfactory.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <QByteArray>
+
+#include "track/track.h"
+
+namespace ListenBrainzJSONFactory {
+    enum JsonType {NowListening, Single};
+    QByteArray getJSONFromTrack(TrackPointer pTrack, JsonType type);
+};

src/broadcast/listenbrainzlistener/listenbrainzservice.cpp

@@ -0,0 +1,68 @@
+
+#include <QJsonObject>
+
+#include "preferences/listenbrainzsettings.h"
+#include "broadcast/listenbrainzlistener/listenbrainzservice.h"
+#include "broadcast/listenbrainzlistener/listenbrainzjsonfactory.h"
+#include "broadcast/listenbrainzlistener/networkmanager.h"
+
+ListenBrainzService::ListenBrainzService(UserSettingsPointer pSettings)
+        :  m_request(ListenBrainzAPIURL),
+           m_latestSettings(ListenBrainzSettingsManager::getPersistedSettings(pSettings)),
+           m_COSettingsChanged(kListenBrainzSettingsChanged) {
+    connect(&m_manager,&QNetworkAccessManager::finished,
+            this,&ListenBrainzService::slotAPICallFinished);
+    connect(&m_COSettingsChanged,&ControlPushButton::valueChanged,
+            this,&ListenBrainzService::slotSettingsChanged);
+    m_request.setHeader(QNetworkRequest::ContentTypeHeader,"application/json");
+    if (m_latestSettings.enabled) {
+        m_request.setRawHeader("Authorization","Token " + m_latestSettings.userToken.toUtf8());
+    }
+}
+
+
+void ListenBrainzService::slotBroadcastCurrentTrack(TrackPointer pTrack) {
+    Q_UNUSED(pTrack);
+    /*if (!pTrack || !m_latestSettings.enabled)
+        return;
+    m_currentJSON = new QByteArray(
+            ListenBrainzJSONFactory::getJSONFromTrack(
+                    pTrack,ListenBrainzJSONFactory::NowListening));
+    m_manager.post(m_request,*m_currentJSON);*/
+}
+
+void ListenBrainzService::slotScrobbleTrack(TrackPointer pTrack) {
+    if (!pTrack || !m_latestSettings.enabled)
+        return;
+    m_currentJSON =
+            ListenBrainzJSONFactory::getJSONFromTrack(
+                    pTrack,ListenBrainzJSONFactory::Single);
+    m_manager.post(m_request,m_currentJSON);
+}
+
+void ListenBrainzService::slotAllTracksPaused() {
+
+}
+
+void ListenBrainzService::slotAPICallFinished(QNetworkReply *reply) {
+    if (reply->error() != QNetworkReply::NoError) {
+        qWarning() << "API call to ListenBrainz error: " <<
+                   reply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
+    }
+    m_currentJSON.clear();
+}
+
+void ListenBrainzService::slotSettingsChanged(double value) {
+    if (value) {
+        m_latestSettings = ListenBrainzSettingsManager::getLatestSettings();
+        if (m_latestSettings.enabled) {
+            m_request.setRawHeader("Authorization","Token " + m_latestSettings.userToken.toUtf8());
+        }
+    }
+}
+
+
+
+
+
+