Add Qobuz support (#181)

src/qobuz/qobuzbaserequest.cpp

@@ -0,0 +1,194 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2019, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "config.h"
+
+#include <QObject>
+#include <QByteArray>
+#include <QPair>
+#include <QList>
+#include <QString>
+#include <QUrl>
+#include <QUrlQuery>
+#include <QNetworkRequest>
+#include <QNetworkReply>
+#include <QJsonParseError>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QJsonArray>
+#include <QJsonValue>
+
+#include "core/logging.h"
+#include "core/network.h"
+#include "qobuzservice.h"
+#include "qobuzbaserequest.h"
+
+const char *QobuzBaseRequest::kApiUrl = "http://www.qobuz.com/api.json/0.2";
+
+QobuzBaseRequest::QobuzBaseRequest(QobuzService *service, NetworkAccessManager *network, QObject *parent) :
+      QObject(parent),
+      service_(service),
+      network_(network)
+      {}
+
+QobuzBaseRequest::~QobuzBaseRequest() {
+
+  while (!replies_.isEmpty()) {
+    QNetworkReply *reply = replies_.takeFirst();
+    disconnect(reply, 0, nullptr, 0);
+    if (reply->isRunning()) reply->abort();
+    reply->deleteLater();
+  }
+
+}
+
+QNetworkReply *QobuzBaseRequest::CreateRequest(const QString &ressource_name, const QList<Param> &params_provided) {
+
+  ParamList params = ParamList() << params_provided
+                                 << Param("app_id", app_id());
+
+  std::sort(params.begin(), params.end());
+
+  QUrlQuery url_query;
+  for (const Param& param : params) {
+    EncodedParam encoded_param(QUrl::toPercentEncoding(param.first), QUrl::toPercentEncoding(param.second));
+    url_query.addQueryItem(encoded_param.first, encoded_param.second);
+  }
+
+  QUrl url(kApiUrl + QString("/") + ressource_name);
+  url.setQuery(url_query);
+  QNetworkRequest req(url);
+  req.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
+
+  QNetworkReply *reply = network_->get(req);
+  replies_ << reply;
+
+  //qLog(Debug) << "Qobuz: Sending request" << url;
+
+  return reply;
+
+}
+
+QByteArray QobuzBaseRequest::GetReplyData(QNetworkReply *reply, QString &error) {
+
+  if (replies_.contains(reply)) {
+    replies_.removeAll(reply);
+    reply->deleteLater();
+  }
+
+  QByteArray data;
+
+  if (reply->error() == QNetworkReply::NoError) {
+    int http_code = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+    if (http_code == 200) {
+      data = reply->readAll();
+    }
+    else {
+      error = Error(QString("Received HTTP code %1").arg(http_code));
+    }
+  }
+  else {
+    if (reply->error() < 200) {
+      // This is a network error, there is nothing more to do.
+      error = Error(QString("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
+    }
+    else {
+      // See if there is Json data containing "status", "code" and "message" - then use that instead.
+      data = reply->readAll();
+      QJsonParseError parse_error;
+      QJsonDocument json_doc = QJsonDocument::fromJson(data, &parse_error);
+      QString failure_reason;
+      if (parse_error.error == QJsonParseError::NoError && !json_doc.isNull() && !json_doc.isEmpty() && json_doc.isObject()) {
+        QJsonObject json_obj = json_doc.object();
+        if (!json_obj.isEmpty() && json_obj.contains("status") && json_obj.contains("code") && json_obj.contains("message")) {
+          QString status = json_obj["status"].toString();
+          int code = json_obj["code"].toInt();
+          QString message = json_obj["message"].toString();
+          failure_reason = QString("%1 (%2)").arg(message).arg(code);
+        }
+      }
+      if (failure_reason.isEmpty()) {
+        failure_reason = QString("%1 (%2)").arg(reply->errorString()).arg(reply->error());
+      }
+      error = Error(failure_reason);
+    }
+    return QByteArray();
+  }
+
+  return data;
+
+}
+
+QJsonObject QobuzBaseRequest::ExtractJsonObj(QByteArray &data, QString &error) {
+
+  QJsonParseError json_error;
+  QJsonDocument json_doc = QJsonDocument::fromJson(data, &json_error);
+
+  if (json_error.error != QJsonParseError::NoError) {
+    error = Error("Reply from server missing Json data.", data);
+    return QJsonObject();
+  }
+
+  if (json_doc.isNull() || json_doc.isEmpty()) {
+    error = Error("Received empty Json document.", data);
+    return QJsonObject();
+  }
+
+  if (!json_doc.isObject()) {
+    error = Error("Json document is not an object.", json_doc);
+    return QJsonObject();
+  }
+
+  QJsonObject json_obj = json_doc.object();
+  if (json_obj.isEmpty()) {
+    error = Error("Received empty Json object.", json_doc);
+    return QJsonObject();
+  }
+
+  return json_obj;
+
+}
+
+QJsonValue QobuzBaseRequest::ExtractItems(QByteArray &data, QString &error) {
+
+  QJsonObject json_obj = ExtractJsonObj(data, error);
+  if (json_obj.isEmpty()) return QJsonValue();
+  return ExtractItems(json_obj, error);
+
+}
+
+QJsonValue QobuzBaseRequest::ExtractItems(QJsonObject &json_obj, QString &error) {
+
+  if (!json_obj.contains("items")) {
+    error = Error("Json reply is missing items.", json_obj);
+    return QJsonArray();
+  }
+  QJsonValue json_items = json_obj["items"];
+  return json_items;
+
+}
+
+QString QobuzBaseRequest::Error(QString error, QVariant debug) {
+
+  qLog(Error) << "Qobuz:" << error;
+  if (debug.isValid()) qLog(Debug) << debug;
+
+  return error;
+
+}

src/qobuz/qobuzbaserequest.h

@@ -0,0 +1,108 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2019, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef QOBUZBASEREQUEST_H
+#define QOBUZBASEREQUEST_H
+
+#include "config.h"
+
+#include <QtGlobal>
+#include <QObject>
+#include <QList>
+#include <QPair>
+#include <QString>
+#include <QUrl>
+#include <QNetworkReply>
+#include <QJsonObject>
+#include <QJsonArray>
+#include <QJsonValue>
+
+#include "core/song.h"
+#include "internet/internetservices.h"
+#include "internet/internetservice.h"
+#include "internet/internetsearch.h"
+#include "qobuzservice.h"
+
+class Application;
+class NetworkAccessManager;
+class QobuzUrlHandler;
+class CollectionBackend;
+class CollectionModel;
+
+class QobuzBaseRequest : public QObject {
+  Q_OBJECT
+
+ public:
+
+  enum QueryType {
+    QueryType_None,
+    QueryType_Artists,
+    QueryType_Albums,
+    QueryType_Songs,
+    QueryType_SearchArtists,
+    QueryType_SearchAlbums,
+    QueryType_SearchSongs,
+    QueryType_StreamURL,
+  };
+
+  QobuzBaseRequest(QobuzService *service, NetworkAccessManager *network, QObject *parent);
+  ~QobuzBaseRequest();
+
+  typedef QPair<QString, QString> Param;
+  typedef QList<Param> ParamList;
+
+  typedef QPair<QByteArray, QByteArray> EncodedParam;
+  typedef QList<EncodedParam> EncodedParamList;
+
+  QNetworkReply *CreateRequest(const QString &ressource_name, const QList<Param> &params_provided);
+  QByteArray GetReplyData(QNetworkReply *reply, QString &error);
+  QJsonObject ExtractJsonObj(QByteArray &data, QString &error);
+  QJsonValue ExtractItems(QByteArray &data, QString &error);
+  QJsonValue ExtractItems(QJsonObject &json_obj, QString &error);
+
+  virtual QString Error(QString error, QVariant debug = QVariant());
+
+  QString api_url() { return QString(kApiUrl); }
+  QString app_id() { return service_->app_id(); }
+  QString app_secret() { return service_->app_secret(); }
+  QString username() { return service_->username(); }
+  QString password() { return service_->password(); }
+  int format() { return service_->format(); }
+  int artistssearchlimit() { return service_->artistssearchlimit(); }
+  int albumssearchlimit() { return service_->albumssearchlimit(); }
+  int songssearchlimit() { return service_->songssearchlimit(); }
+
+  QString access_token() { return service_->access_token(); }
+
+  bool authenticated() { return service_->authenticated(); }
+  bool login_sent() { return service_->login_sent(); }
+  int max_login_attempts() { return service_->max_login_attempts(); }
+  int login_attempts() { return service_->login_attempts(); }
+
+ private:
+
+  static const char *kApiUrl;
+
+  QobuzService *service_;
+  NetworkAccessManager *network_;
+  QList<QNetworkReply*> replies_;
+
+};
+
+#endif  // QOBUZBASEREQUEST_H

src/qobuz/qobuzfavoriterequest.cpp

@@ -0,0 +1,281 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2019, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "config.h"
+
+#include <QObject>
+#include <QPair>
+#include <QList>
+#include <QMultiMap>
+#include <QByteArray>
+#include <QString>
+#include <QStringList>
+#include <QUrl>
+#include <QUrlQuery>
+#include <QNetworkRequest>
+#include <QNetworkReply>
+#include <QJsonObject>
+
+#include "core/logging.h"
+#include "core/network.h"
+#include "core/closure.h"
+#include "core/song.h"
+#include "qobuzservice.h"
+#include "qobuzbaserequest.h"
+#include "qobuzfavoriterequest.h"
+
+QobuzFavoriteRequest::QobuzFavoriteRequest(QobuzService *service, NetworkAccessManager *network, QObject *parent)
+    : QobuzBaseRequest(service, network, parent),
+    service_(service),
+    network_(network) {}
+
+QobuzFavoriteRequest::~QobuzFavoriteRequest() {
+
+  while (!replies_.isEmpty()) {
+    QNetworkReply *reply = replies_.takeFirst();
+    disconnect(reply, 0, nullptr, 0);
+    reply->abort();
+    reply->deleteLater();
+  }
+
+}
+
+QString QobuzFavoriteRequest::FavoriteText(const FavoriteType type) {
+
+  switch (type) {
+    case FavoriteType_Artists:
+      return "artists";
+    case FavoriteType_Albums:
+      return "albums";
+    case FavoriteType_Songs:
+    default:
+      return "tracks";
+  }
+
+}
+
+void QobuzFavoriteRequest::AddArtists(const SongList &songs) {
+  AddFavorites(FavoriteType_Artists, songs);
+}
+
+void QobuzFavoriteRequest::AddAlbums(const SongList &songs) {
+  AddFavorites(FavoriteType_Albums, songs);
+}
+
+void QobuzFavoriteRequest::AddSongs(const SongList &songs) {
+  AddFavorites(FavoriteType_Songs, songs);
+}
+
+void QobuzFavoriteRequest::AddFavorites(const FavoriteType type, const SongList &songs) {
+
+  if (songs.isEmpty()) return;
+
+  QString text;
+  switch (type) {
+    case FavoriteType_Artists:
+      text = "artist_ids";
+      break;
+  case FavoriteType_Albums:
+      text = "album_ids";
+      break;
+  case FavoriteType_Songs:
+      text = "track_ids";
+      break;
+  }
+
+  QStringList ids_list;
+  for (const Song &song : songs) {
+    QString id;
+    switch (type) {
+      case FavoriteType_Artists:
+        if (song.artist_id() <= 0) continue;
+        id = QString::number(song.artist_id());
+        break;
+    case FavoriteType_Albums:
+        if (song.album_id() <= 0) continue;
+        id = QString::number(song.album_id());
+        break;
+    case FavoriteType_Songs:
+        if (song.song_id() <= 0) continue;
+        id = QString::number(song.song_id());
+        break;
+    }
+    if (id.isEmpty()) continue;
+    if (!ids_list.contains(id)) {
+      ids_list << id;
+    }
+  }
+  if (ids_list.isEmpty()) return;
+
+  QString ids = ids_list.join(',');
+
+  typedef QPair<QByteArray, QByteArray> EncodedParam;
+  typedef QList<EncodedParam> EncodedParamList;
+
+  ParamList params = ParamList() << Param("app_id", app_id())
+                                 << Param("user_auth_token", access_token())
+                                 << Param(text, ids);
+
+  QUrlQuery url_query;
+  for (const Param& param : params) {
+    EncodedParam encoded_param(QUrl::toPercentEncoding(param.first), QUrl::toPercentEncoding(param.second));
+    url_query.addQueryItem(encoded_param.first, encoded_param.second);
+  }
+
+  QNetworkReply *reply = CreateRequest("favorite/create", params);
+  NewClosure(reply, SIGNAL(finished()), this, SLOT(AddFavoritesReply(QNetworkReply*, const FavoriteType, const SongList&)), reply, type, songs);
+  replies_ << reply;
+
+}
+
+void QobuzFavoriteRequest::AddFavoritesReply(QNetworkReply *reply, const FavoriteType type, const SongList &songs) {
+
+  if (replies_.contains(reply)) {
+    replies_.removeAll(reply);
+    reply->deleteLater();
+  }
+  else {
+    return;
+  }
+
+  QString error;
+  QByteArray data = GetReplyData(reply, error);
+
+  if (reply->error() != QNetworkReply::NoError) {
+    return;
+  }
+
+  qLog(Debug) << "Qobuz:" << songs.count() << "songs added to" << FavoriteText(type) << "favorites.";
+
+  switch (type) {
+    case FavoriteType_Artists:
+      emit ArtistsAdded(songs);
+      break;
+  case FavoriteType_Albums:
+      emit AlbumsAdded(songs);
+      break;
+  case FavoriteType_Songs:
+      emit SongsAdded(songs);
+      break;
+  }
+
+}
+
+void QobuzFavoriteRequest::RemoveArtists(const SongList &songs) {
+  RemoveFavorites(FavoriteType_Artists, songs);
+}
+
+void QobuzFavoriteRequest::RemoveAlbums(const SongList &songs) {
+  RemoveFavorites(FavoriteType_Albums, songs);
+}
+
+void QobuzFavoriteRequest::RemoveSongs(const SongList &songs) {
+  RemoveFavorites(FavoriteType_Songs, songs);
+}
+
+void QobuzFavoriteRequest::RemoveFavorites(const FavoriteType type, const SongList &songs) {
+
+  if (songs.isEmpty()) return;
+
+  QString text;
+  switch (type) {
+    case FavoriteType_Artists:
+      text = "artist_ids";
+      break;
+  case FavoriteType_Albums:
+      text = "album_ids";
+      break;
+  case FavoriteType_Songs:
+      text = "track_ids";
+      break;
+  }
+
+  QStringList ids_list;
+  for (const Song &song : songs) {
+    QString id;
+    switch (type) {
+      case FavoriteType_Artists:
+        if (song.artist_id() <= 0) continue;
+        id = QString::number(song.artist_id());
+        break;
+    case FavoriteType_Albums:
+        if (song.album_id() <= 0) continue;
+        id = QString::number(song.album_id());
+        break;
+    case FavoriteType_Songs:
+        if (song.song_id() <= 0) continue;
+        id = QString::number(song.song_id());
+        break;
+    }
+    if (id.isEmpty()) continue;
+    if (!ids_list.contains(id)) {
+      ids_list << id;
+    }
+  }
+  if (ids_list.isEmpty()) return;
+
+  QString ids = ids_list.join(',');
+
+  ParamList params = ParamList() << Param("app_id", app_id())
+                                 << Param("user_auth_token", access_token())
+                                 << Param(text, ids);
+
+  QUrlQuery url_query;
+  for (const Param &param : params) {
+    EncodedParam encoded_param(QUrl::toPercentEncoding(param.first), QUrl::toPercentEncoding(param.second));
+    url_query.addQueryItem(encoded_param.first, encoded_param.second);
+  }
+
+  QNetworkReply *reply = CreateRequest("favorite/delete", params);
+  NewClosure(reply, SIGNAL(finished()), this, SLOT(RemoveFavoritesReply(QNetworkReply*, const FavoriteType, const SongList&)), reply, type, songs);
+  replies_ << reply;
+
+}
+
+void QobuzFavoriteRequest::RemoveFavoritesReply(QNetworkReply *reply, const FavoriteType type, const SongList &songs) {
+
+  if (replies_.contains(reply)) {
+    replies_.removeAll(reply);
+    reply->deleteLater();
+  }
+  else {
+    return;
+  }
+
+  QString error;
+  QByteArray data = GetReplyData(reply, error);
+  if (reply->error() != QNetworkReply::NoError) {
+    return;
+  }
+
+  qLog(Debug) << "Qobuz:" << songs.count() << "songs removed from" << FavoriteText(type) << "favorites.";
+
+  switch (type) {
+    case FavoriteType_Artists:
+      emit ArtistsRemoved(songs);
+      break;
+  case FavoriteType_Albums:
+      emit AlbumsRemoved(songs);
+      break;
+  case FavoriteType_Songs:
+      emit SongsRemoved(songs);
+      break;
+  }
+
+}

src/qobuz/qobuzfavoriterequest.h

@@ -0,0 +1,78 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2019, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef QOBUZFAVORITEREQUEST_H
+#define QOBUZFAVORITEREQUEST_H
+
+#include "config.h"
+
+#include <QList>
+
+#include "qobuzbaserequest.h"
+#include "core/song.h"
+
+class QNetworkReply;
+class QobuzService;
+class NetworkAccessManager;
+
+class QobuzFavoriteRequest : public QobuzBaseRequest {
+  Q_OBJECT
+
+ public:
+  QobuzFavoriteRequest(QobuzService *service, NetworkAccessManager *network, QObject *parent);
+  ~QobuzFavoriteRequest();
+
+  enum FavoriteType {
+    FavoriteType_Artists,
+    FavoriteType_Albums,
+    FavoriteType_Songs
+  };
+
+ signals:
+  void ArtistsAdded(const SongList &songs);
+  void AlbumsAdded(const SongList &songs);
+  void SongsAdded(const SongList &songs);
+  void ArtistsRemoved(const SongList &songs);
+  void AlbumsRemoved(const SongList &songs);
+  void SongsRemoved(const SongList &songs);
+
+ private slots:
+  void AddArtists(const SongList &songs);
+  void AddAlbums(const SongList &songs);
+  void AddSongs(const SongList &songs);
+
+  void RemoveArtists(const SongList &songs);
+  void RemoveAlbums(const SongList &songs);
+  void RemoveSongs(const SongList &songs);
+
+  void AddFavoritesReply(QNetworkReply *reply, const FavoriteType type, const SongList &songs);
+  void RemoveFavoritesReply(QNetworkReply *reply, const FavoriteType type, const SongList &songs);
+
+ private:
+  QString FavoriteText(const FavoriteType type);
+  void AddFavorites(const FavoriteType type, const SongList &songs);
+  void RemoveFavorites(const FavoriteType type, const SongList &songs);
+
+  QobuzService *service_;
+  NetworkAccessManager *network_;
+  QList <QNetworkReply*> replies_;
+
+};
+
+#endif  // QOBUZFAVORITEREQUEST_H

src/qobuz/qobuzrequest.h

@@ -0,0 +1,208 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2019, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef QOBUZREQUEST_H
+#define QOBUZREQUEST_H
+
+#include "config.h"
+
+#include <QtGlobal>
+#include <QObject>
+#include <QPair>
+#include <QList>
+#include <QHash>
+#include <QMap>
+#include <QMultiMap>
+#include <QQueue>
+#include <QString>
+#include <QUrl>
+#include <QNetworkReply>
+#include <QJsonObject>
+#include <QJsonArray>
+#include <QJsonValue>
+
+#include "core/song.h"
+#include "qobuzbaserequest.h"
+
+class NetworkAccessManager;
+class QobuzService;
+class QobuzUrlHandler;
+
+class QobuzRequest : public QobuzBaseRequest {
+  Q_OBJECT
+
+ public:
+
+  QobuzRequest(QobuzService *service, QobuzUrlHandler *url_handler, NetworkAccessManager *network, QueryType type, QObject *parent);
+  ~QobuzRequest();
+
+  void ReloadSettings();
+
+  void Process();
+  void Search(const int search_id, const QString &search_text);
+
+ signals:
+  void Login();
+  void Login(const QString &username, const QString &password, const QString &token);
+  void LoginSuccess();
+  void LoginFailure(QString failure_reason);
+  void Results(SongList songs);
+  void SearchResults(int id, SongList songs);
+  void ErrorSignal(QString message);
+  void ErrorSignal(int id, QString message);
+  void UpdateStatus(QString text);
+  void ProgressSetMaximum(int max);
+  void UpdateProgress(int max);
+  void StreamURLFinished(const QUrl original_url, const QUrl url, const Song::FileType, QString error = QString());
+
+ private slots:
+  //void LoginComplete(bool success, QString error = QString());
+
+  void ArtistsReplyReceived(QNetworkReply *reply, const int limit_requested, const int offset_requested);
+
+  void AlbumsReplyReceived(QNetworkReply *reply, const int limit_requested, const int offset_requested);
+  void AlbumsReceived(QNetworkReply *reply, const int artist_id_requested, const int limit_requested, const int offset_requested);
+
+  void SongsReplyReceived(QNetworkReply *reply, const int limit_requested, const int offset_requested);
+  void SongsReceived(QNetworkReply *reply, const int artist_id_requested, const QString &album_id_requested, const int limit_requested, const int offset_requested, const QString &album_artist_requested = QString());
+
+  void ArtistAlbumsReplyReceived(QNetworkReply *reply, const int artist_id, const int offset_requested);
+  void AlbumSongsReplyReceived(QNetworkReply *reply, const int artist_id, const QString &album_id, const int offset_requested, const QString &album_artist);
+  void AlbumCoverReceived(QNetworkReply *reply, const QUrl &cover_url, const QString &filename);
+
+ private:
+  typedef QPair<QString, QString> Param;
+  typedef QList<Param> ParamList;
+
+  struct Request {
+    int artist_id = 0;
+    QString album_id = 0;
+    int song_id = 0;
+    int offset = 0;
+    int limit = 0;
+    QString album_artist;
+    QString album;
+  };
+  struct AlbumCoverRequest {
+    //int artist_id = 0;
+    QUrl url;
+    QString filename;
+  };
+
+  const bool IsQuery() { return (type_ == QueryType_Artists || type_ == QueryType_Albums || type_ == QueryType_Songs); }
+  const bool IsSearch() { return (type_ == QueryType_SearchArtists || type_ == QueryType_SearchAlbums || type_ == QueryType_SearchSongs); }
+
+  void GetArtists();
+  void GetAlbums();
+  void GetSongs();
+
+  void ArtistsSearch();
+  void AlbumsSearch();
+  void SongsSearch();
+
+  void AddArtistsRequest(const int offset = 0, const int limit = 0);
+  void AddArtistsSearchRequest(const int offset = 0);
+  void FlushArtistsRequests();
+  void AddAlbumsRequest(const int offset = 0, const int limit = 0);
+  void AddAlbumsSearchRequest(const int offset = 0);
+  void FlushAlbumsRequests();
+  void AddSongsRequest(const int offset = 0, const int limit = 0);
+  void AddSongsSearchRequest(const int offset = 0);
+  void FlushSongsRequests();
+
+  void ArtistsFinishCheck(const int limit = 0, const int offset = 0, const int artists_received = 0);
+  void AlbumsFinishCheck(const int artist_id, const int limit = 0, const int offset = 0, const int albums_total = 0, const int albums_received = 0);
+  void SongsFinishCheck(const int artist_id, const QString &album_id, const int limit, const int offset, const int songs_total, const int songs_received, const QString &album_artist);
+
+  void AddArtistAlbumsRequest(const int artist_id, const int offset = 0);
+  void FlushArtistAlbumsRequests();
+
+  void AddAlbumSongsRequest(const int artist_id, const QString &album_id, const QString &album_artist, const int offset = 0);
+  void FlushAlbumSongsRequests();
+
+  int ParseSong(Song &song, const QJsonObject &json_obj, int artist_id, QString album_id, QString album_artist, QString album, QUrl cover_url);
+
+  QString AlbumCoverFileName(const Song &song);
+
+  void GetAlbumCovers();
+  void AddAlbumCoverRequest(Song &song);
+  void FlushAlbumCoverRequests();
+  void AlbumCoverFinishCheck();
+
+  void FinishCheck();
+  void Warn(QString error, QVariant debug = QVariant());
+  QString Error(QString error, QVariant debug = QVariant());
+
+  static const int kMaxConcurrentArtistsRequests;
+  static const int kMaxConcurrentAlbumsRequests;
+  static const int kMaxConcurrentSongsRequests;
+  static const int kMaxConcurrentArtistAlbumsRequests;
+  static const int kMaxConcurrentAlbumSongsRequests;
+  static const int kMaxConcurrentAlbumCoverRequests;
+
+  QobuzService *service_;
+  QobuzUrlHandler *url_handler_;
+  NetworkAccessManager *network_;
+
+  QueryType type_;
+
+  int search_id_;
+  QString search_text_;
+
+  bool finished_;
+
+  QQueue<Request> artists_requests_queue_;
+  QQueue<Request> albums_requests_queue_;
+  QQueue<Request> songs_requests_queue_;
+
+  QQueue<Request> artist_albums_requests_queue_;
+  QQueue<Request> album_songs_requests_queue_;
+  QQueue<AlbumCoverRequest> album_cover_requests_queue_;
+
+  QList<int> artist_albums_requests_pending_;
+  QHash<QString, Request> album_songs_requests_pending_;
+  QMultiMap<QUrl, Song*> album_covers_requests_sent_;
+
+  int artists_requests_active_;
+  int artists_total_;
+  int artists_received_;
+
+  int albums_requests_active_;
+  int songs_requests_active_;
+
+  int artist_albums_requests_active_;
+  int artist_albums_requested_;
+  int artist_albums_received_;
+
+  int album_songs_requests_active_;
+  int album_songs_requested_;
+  int album_songs_received_;
+
+  int album_covers_requests_active_;
+  int album_covers_requested_;
+  int album_covers_received_;
+
+  SongList songs_;
+  QString errors_;
+  bool no_results_;
+  QList<QNetworkReply*> album_cover_replies_;
+
+};
+
+#endif  // QOBUZREQUEST_H

src/qobuz/qobuzservice.cpp

@@ -0,0 +1,603 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2019, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "config.h"
+
+#include <stdbool.h>
+#include <memory>
+
+#include <QObject>
+#include <QStandardPaths>
+#include <QDesktopServices>
+#include <QCryptographicHash>
+#include <QByteArray>
+#include <QPair>
+#include <QList>
+#include <QString>
+#include <QUrl>
+#include <QUrlQuery>
+#include <QNetworkRequest>
+#include <QNetworkReply>
+#include <QTimer>
+#include <QJsonParseError>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QSettings>
+#include <QSortFilterProxyModel>
+
+#include "core/application.h"
+#include "core/player.h"
+#include "core/closure.h"
+#include "core/logging.h"
+#include "core/network.h"
+#include "core/database.h"
+#include "core/song.h"
+#include "core/utilities.h"
+#include "internet/internetsearch.h"
+#include "collection/collectionbackend.h"
+#include "collection/collectionmodel.h"
+#include "qobuzservice.h"
+#include "qobuzurlhandler.h"
+#include "qobuzrequest.h"
+#include "qobuzfavoriterequest.h"
+#include "qobuzstreamurlrequest.h"
+#include "settings/qobuzsettingspage.h"
+
+using std::shared_ptr;
+
+const Song::Source QobuzService::kSource = Song::Source_Qobuz;
+const char *QobuzService::kAuthUrl = "http://www.qobuz.com/api.json/0.2/user/login";
+const int QobuzService::kLoginAttempts = 2;
+const int QobuzService::kTimeResetLoginAttempts = 60000;
+
+const char *QobuzService::kArtistsSongsTable = "qobuz_artists_songs";
+const char *QobuzService::kAlbumsSongsTable = "qobuz_albums_songs";
+const char *QobuzService::kSongsTable = "qobuz_songs";
+
+const char *QobuzService::kArtistsSongsFtsTable = "qobuz_artists_songs_fts";
+const char *QobuzService::kAlbumsSongsFtsTable = "qobuz_albums_songs_fts";
+const char *QobuzService::kSongsFtsTable = "qobuz_songs_fts";
+
+QobuzService::QobuzService(Application *app, QObject *parent)
+    : InternetService(Song::Source_Qobuz, "Qobuz", "qobuz", app, parent),
+      app_(app),
+      network_(new NetworkAccessManager(this)),
+      url_handler_(new QobuzUrlHandler(app, this)),
+      artists_collection_backend_(nullptr),
+      albums_collection_backend_(nullptr),
+      songs_collection_backend_(nullptr),
+      artists_collection_model_(nullptr),
+      albums_collection_model_(nullptr),
+      songs_collection_model_(nullptr),
+      artists_collection_sort_model_(new QSortFilterProxyModel(this)),
+      albums_collection_sort_model_(new QSortFilterProxyModel(this)),
+      songs_collection_sort_model_(new QSortFilterProxyModel(this)),
+      timer_search_delay_(new QTimer(this)),
+      timer_login_attempt_(new QTimer(this)),
+      favorite_request_(new QobuzFavoriteRequest(this, network_, this)),
+      format_(0),
+      search_delay_(1500),
+      artistssearchlimit_(1),
+      albumssearchlimit_(1),
+      songssearchlimit_(1),
+      cache_album_covers_(true),
+      pending_search_id_(0),
+      next_pending_search_id_(1),
+      search_id_(0),
+      login_sent_(false),
+      login_attempts_(0)
+  {
+
+  app->player()->RegisterUrlHandler(url_handler_);
+
+  // Backends
+
+  artists_collection_backend_ = new CollectionBackend();
+  artists_collection_backend_->moveToThread(app_->database()->thread());
+  artists_collection_backend_->Init(app_->database(), kArtistsSongsTable, QString(), QString(), kArtistsSongsFtsTable);
+
+  albums_collection_backend_ = new CollectionBackend();
+  albums_collection_backend_->moveToThread(app_->database()->thread());
+  albums_collection_backend_->Init(app_->database(), kAlbumsSongsTable, QString(), QString(), kAlbumsSongsFtsTable);
+
+  songs_collection_backend_ = new CollectionBackend();
+  songs_collection_backend_->moveToThread(app_->database()->thread());
+  songs_collection_backend_->Init(app_->database(), kSongsTable, QString(), QString(), kSongsFtsTable);
+
+  artists_collection_model_ = new CollectionModel(artists_collection_backend_, app_, this);
+  albums_collection_model_ = new CollectionModel(albums_collection_backend_, app_, this);
+  songs_collection_model_ = new CollectionModel(songs_collection_backend_, app_, this);
+
+  artists_collection_sort_model_->setSourceModel(artists_collection_model_);
+  artists_collection_sort_model_->setSortRole(CollectionModel::Role_SortText);
+  artists_collection_sort_model_->setDynamicSortFilter(true);
+  artists_collection_sort_model_->setSortLocaleAware(true);
+  artists_collection_sort_model_->sort(0);
+
+  albums_collection_sort_model_->setSourceModel(albums_collection_model_);
+  albums_collection_sort_model_->setSortRole(CollectionModel::Role_SortText);
+  albums_collection_sort_model_->setDynamicSortFilter(true);
+  albums_collection_sort_model_->setSortLocaleAware(true);
+  albums_collection_sort_model_->sort(0);
+
+  songs_collection_sort_model_->setSourceModel(songs_collection_model_);
+  songs_collection_sort_model_->setSortRole(CollectionModel::Role_SortText);
+  songs_collection_sort_model_->setDynamicSortFilter(true);
+  songs_collection_sort_model_->setSortLocaleAware(true);
+  songs_collection_sort_model_->sort(0);
+
+  // Search
+
+  timer_search_delay_->setSingleShot(true);
+  connect(timer_search_delay_, SIGNAL(timeout()), SLOT(StartSearch()));
+
+  timer_login_attempt_->setSingleShot(true);
+  connect(timer_login_attempt_, SIGNAL(timeout()), SLOT(ResetLoginAttempts()));
+
+  connect(this, SIGNAL(Login()), SLOT(SendLogin()));
+  connect(this, SIGNAL(Login(QString, QString, QString)), SLOT(SendLogin(QString, QString, QString)));
+
+  connect(this, SIGNAL(AddArtists(const SongList&)), favorite_request_, SLOT(AddArtists(const SongList&)));
+  connect(this, SIGNAL(AddAlbums(const SongList&)), favorite_request_, SLOT(AddAlbums(const SongList&)));
+  connect(this, SIGNAL(AddSongs(const SongList&)), favorite_request_, SLOT(AddSongs(const SongList&)));
+
+  connect(this, SIGNAL(RemoveArtists(const SongList&)), favorite_request_, SLOT(RemoveArtists(const SongList&)));
+  connect(this, SIGNAL(RemoveAlbums(const SongList&)), favorite_request_, SLOT(RemoveAlbums(const SongList&)));
+  connect(this, SIGNAL(RemoveSongs(const SongList&)), favorite_request_, SLOT(RemoveSongs(const SongList&)));
+
+  connect(favorite_request_, SIGNAL(ArtistsAdded(const SongList&)), artists_collection_backend_, SLOT(AddOrUpdateSongs(const SongList&)));
+  connect(favorite_request_, SIGNAL(AlbumsAdded(const SongList&)), albums_collection_backend_, SLOT(AddOrUpdateSongs(const SongList&)));
+  connect(favorite_request_, SIGNAL(SongsAdded(const SongList&)), songs_collection_backend_, SLOT(AddOrUpdateSongs(const SongList&)));
+
+  connect(favorite_request_, SIGNAL(ArtistsRemoved(const SongList&)), artists_collection_backend_, SLOT(DeleteSongs(const SongList&)));
+  connect(favorite_request_, SIGNAL(AlbumsRemoved(const SongList&)), albums_collection_backend_, SLOT(DeleteSongs(const SongList&)));
+  connect(favorite_request_, SIGNAL(SongsRemoved(const SongList&)), songs_collection_backend_, SLOT(DeleteSongs(const SongList&)));
+
+  ReloadSettings();
+
+}
+
+QobuzService::~QobuzService() {
+
+  while (!stream_url_requests_.isEmpty()) {
+    QobuzStreamURLRequest *stream_url_req = stream_url_requests_.takeFirst();
+    disconnect(stream_url_req, 0, nullptr, 0);
+    stream_url_req->deleteLater();
+  }
+
+}
+
+void QobuzService::ShowConfig() {
+  app_->OpenSettingsDialogAtPage(SettingsDialog::Page_Qobuz);
+}
+
+void QobuzService::ReloadSettings() {
+
+  QSettings s;
+  s.beginGroup(QobuzSettingsPage::kSettingsGroup);
+
+  app_id_ = s.value("app_id").toString();
+  app_secret_ = s.value("app_secret").toString();
+
+  username_ = s.value("username").toString();
+  QByteArray password = s.value("password").toByteArray();
+  if (password.isEmpty()) password_.clear();
+  else password_ = QString::fromUtf8(QByteArray::fromBase64(password));
+
+  format_ = s.value("format", 27).toInt();
+  search_delay_ = s.value("searchdelay", 1500).toInt();
+  artistssearchlimit_ = s.value("artistssearchlimit", 5).toInt();
+  albumssearchlimit_ = s.value("albumssearchlimit", 100).toInt();
+  songssearchlimit_ = s.value("songssearchlimit", 100).toInt();
+  cache_album_covers_ = s.value("cachealbumcovers", true).toBool();
+
+  access_token_ = s.value("access_token").toString();
+
+  s.endGroup();
+
+}
+
+QString QobuzService::CoverCacheDir() {
+  return QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation) + "/qobuzalbumcovers";
+}
+
+void QobuzService::SendLogin() {
+  SendLogin(app_id_, username_, password_);
+}
+
+void QobuzService::SendLogin(const QString &app_id, const QString &username, const QString &password) {
+
+  emit UpdateStatus(tr("Authenticating..."));
+
+  login_sent_ = true;
+  ++login_attempts_;
+  if (timer_login_attempt_->isActive()) timer_login_attempt_->stop();
+  timer_login_attempt_->setInterval(kTimeResetLoginAttempts);
+  timer_login_attempt_->start();
+
+  const ParamList params = ParamList() << Param("app_id", app_id)
+                                       << Param("username", username)
+                                       << Param("password", password);
+
+  QUrlQuery url_query;
+  for (const Param &param : params) {
+    EncodedParam encoded_param(QUrl::toPercentEncoding(param.first), QUrl::toPercentEncoding(param.second));
+    url_query.addQueryItem(encoded_param.first, encoded_param.second);
+  }
+
+  QUrl url(kAuthUrl);
+  QNetworkRequest req(url);
+
+  req.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
+
+  QByteArray query = url_query.toString(QUrl::FullyEncoded).toUtf8();
+  QNetworkReply *reply = network_->post(req, query);
+  NewClosure(reply, SIGNAL(finished()), this, SLOT(HandleAuthReply(QNetworkReply*)), reply);
+
+  qLog(Debug) << "Qobuz: Sending request" << url << query;
+
+}
+
+void QobuzService::HandleAuthReply(QNetworkReply *reply) {
+
+  reply->deleteLater();
+
+  login_sent_ = false;
+
+  if (reply->error() != QNetworkReply::NoError) {
+    if (reply->error() < 200) {
+      // This is a network error, there is nothing more to do.
+      LoginError(QString("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
+      return;
+    }
+    else {
+      // See if there is Json data containing "status", "code" and "message" - then use that instead.
+      QByteArray data(reply->readAll());
+      QJsonParseError json_error;
+      QJsonDocument json_doc = QJsonDocument::fromJson(data, &json_error);
+      QString failure_reason;
+      if (json_error.error == QJsonParseError::NoError && !json_doc.isNull() && !json_doc.isEmpty() && json_doc.isObject()) {
+        QJsonObject json_obj = json_doc.object();
+        if (!json_obj.isEmpty() && json_obj.contains("status") && json_obj.contains("code") && json_obj.contains("message")) {
+          QString status = json_obj["status"].toString();
+          int code = json_obj["code"].toInt();
+          QString message = json_obj["message"].toString();
+          failure_reason = QString("%1 (%2)").arg(message).arg(code);
+        }
+      }
+      if (failure_reason.isEmpty()) {
+        failure_reason = QString("%1 (%2)").arg(reply->errorString()).arg(reply->error());
+      }
+      LoginError(failure_reason);
+      return;
+    }
+  }
+
+  int http_code = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+  if (http_code != 200) {
+    LoginError(QString("Received HTTP code %1").arg(http_code));
+    return;
+  }
+
+  QByteArray data(reply->readAll());
+  QJsonParseError json_error;
+  QJsonDocument json_doc = QJsonDocument::fromJson(data, &json_error);
+
+  if (json_error.error != QJsonParseError::NoError) {
+    LoginError("Authentication reply from server missing Json data.");
+    return;
+  }
+
+  if (json_doc.isNull() || json_doc.isEmpty()) {
+    LoginError("Authentication reply from server has empty Json document.");
+    return;
+  }
+
+  if (!json_doc.isObject()) {
+    LoginError("Authentication reply from server has Json document that is not an object.", json_doc);
+    return;
+  }
+
+  QJsonObject json_obj = json_doc.object();
+  if (json_obj.isEmpty()) {
+    LoginError("Authentication reply from server has empty Json object.", json_doc);
+    return;
+  }
+
+  if (!json_obj.contains("user_auth_token")) {
+    LoginError("Authentication reply from server is missing user_auth_token", json_obj);
+    return;
+  }
+
+  access_token_ = json_obj["user_auth_token"].toString();
+
+  QSettings s;
+  s.beginGroup(QobuzSettingsPage::kSettingsGroup);
+  s.setValue("access_token", access_token_);
+  s.endGroup();
+
+  qLog(Debug) << "Qobuz: Login successful" << "access token" << access_token_;
+
+  login_attempts_ = 0;
+  if (timer_login_attempt_->isActive()) timer_login_attempt_->stop();
+
+  emit LoginComplete(true);
+  emit LoginSuccess();
+
+}
+
+void QobuzService::Logout() {
+
+  access_token_.clear();
+
+  QSettings s;
+  s.beginGroup(QobuzSettingsPage::kSettingsGroup);
+  s.remove("user_auth_token");
+  s.endGroup();
+
+}
+
+void QobuzService::ResetLoginAttempts() {
+  login_attempts_ = 0;
+}
+
+void QobuzService::TryLogin() {
+
+  if (authenticated() || login_sent_) return;
+
+  if (login_attempts_ >= kLoginAttempts) {
+    emit LoginComplete(false, "Maximum number of login attempts reached.");
+    return;
+  }
+  if (app_id_.isEmpty()) {
+    emit LoginComplete(false, "Missing Qobuz app ID.");
+    return;
+  }
+  if (username_.isEmpty()) {
+    emit LoginComplete(false, "Missing Qobuz username.");
+    return;
+  }
+  if (password_.isEmpty()) {
+    emit LoginComplete(false, "Missing Qobuz password.");
+    return;
+  }
+
+  emit Login();
+
+}
+
+void QobuzService::ResetArtistsRequest() {
+
+  if (artists_request_.get()) {
+    disconnect(artists_request_.get(), 0, nullptr, 0);
+    disconnect(this, 0, artists_request_.get(), 0);
+    artists_request_.reset();
+  }
+
+}
+
+void QobuzService::GetArtists() {
+
+  ResetArtistsRequest();
+
+  artists_request_.reset(new QobuzRequest(this, url_handler_, network_, QobuzBaseRequest::QueryType_Artists, this));
+
+  connect(artists_request_.get(), SIGNAL(ErrorSignal(QString)), SLOT(ArtistsErrorReceived(QString)));
+  connect(artists_request_.get(), SIGNAL(Results(SongList)), SLOT(ArtistsResultsReceived(SongList)));
+  connect(artists_request_.get(), SIGNAL(UpdateStatus(QString)), SIGNAL(ArtistsUpdateStatus(QString)));
+  connect(artists_request_.get(), SIGNAL(ProgressSetMaximum(int)), SIGNAL(ArtistsProgressSetMaximum(int)));
+  connect(artists_request_.get(), SIGNAL(UpdateProgress(int)), SIGNAL(ArtistsUpdateProgress(int)));
+  connect(this, SIGNAL(LoginComplete(bool, QString)), artists_request_.get(), SLOT(LoginComplete(bool, QString)));
+
+  artists_request_->Process();
+
+}
+
+void QobuzService::ArtistsResultsReceived(SongList songs) {
+
+  emit ArtistsResults(songs);
+
+}
+
+void QobuzService::ArtistsErrorReceived(QString error) {
+
+  emit ArtistsError(error);
+
+}
+
+void QobuzService::ResetAlbumsRequest() {
+
+  if (albums_request_.get()) {
+    disconnect(albums_request_.get(), 0, nullptr, 0);
+    disconnect(this, 0, albums_request_.get(), 0);
+    albums_request_.reset();
+  }
+
+}
+
+void QobuzService::GetAlbums() {
+
+  ResetAlbumsRequest();
+  albums_request_.reset(new QobuzRequest(this, url_handler_, network_, QobuzBaseRequest::QueryType_Albums, this));
+  connect(albums_request_.get(), SIGNAL(ErrorSignal(QString)), SLOT(AlbumsErrorReceived(QString)));
+  connect(albums_request_.get(), SIGNAL(Results(SongList)), SLOT(AlbumsResultsReceived(SongList)));
+  connect(albums_request_.get(), SIGNAL(UpdateStatus(QString)), SIGNAL(AlbumsUpdateStatus(QString)));
+  connect(albums_request_.get(), SIGNAL(ProgressSetMaximum(int)), SIGNAL(AlbumsProgressSetMaximum(int)));
+  connect(albums_request_.get(), SIGNAL(UpdateProgress(int)), SIGNAL(AlbumsUpdateProgress(int)));
+  connect(this, SIGNAL(LoginComplete(bool, QString)), albums_request_.get(), SLOT(LoginComplete(bool, QString)));
+
+  albums_request_->Process();
+
+}
+
+void QobuzService::AlbumsResultsReceived(SongList songs) {
+
+  emit AlbumsResults(songs);
+
+}
+
+void QobuzService::AlbumsErrorReceived(QString error) {
+
+  emit AlbumsError(error);
+
+}
+
+void QobuzService::ResetSongsRequest() {
+
+  if (songs_request_.get()) {
+    disconnect(songs_request_.get(), 0, nullptr, 0);
+    disconnect(this, 0, songs_request_.get(), 0);
+    songs_request_.reset();
+  }
+
+}
+
+void QobuzService::GetSongs() {
+
+  ResetSongsRequest();
+  songs_request_.reset(new QobuzRequest(this, url_handler_, network_, QobuzBaseRequest::QueryType_Songs, this));
+  connect(songs_request_.get(), SIGNAL(ErrorSignal(QString)), SLOT(SongsErrorReceived(QString)));
+  connect(songs_request_.get(), SIGNAL(Results(SongList)), SLOT(SongsResultsReceived(SongList)));
+  connect(songs_request_.get(), SIGNAL(UpdateStatus(QString)), SIGNAL(SongsUpdateStatus(QString)));
+  connect(songs_request_.get(), SIGNAL(ProgressSetMaximum(int)), SIGNAL(SongsProgressSetMaximum(int)));
+  connect(songs_request_.get(), SIGNAL(UpdateProgress(int)), SIGNAL(SongsUpdateProgress(int)));
+  connect(this, SIGNAL(LoginComplete(bool, QString)), songs_request_.get(), SLOT(LoginComplete(bool, QString)));
+
+  songs_request_->Process();
+
+}
+
+void QobuzService::SongsResultsReceived(SongList songs) {
+
+  emit SongsResults(songs);
+
+}
+
+void QobuzService::SongsErrorReceived(QString error) {
+
+  emit SongsError(error);
+
+}
+
+int QobuzService::Search(const QString &text, InternetSearch::SearchType type) {
+
+  pending_search_id_ = next_pending_search_id_;
+  pending_search_text_ = text;
+  pending_search_type_ = type;
+
+  next_pending_search_id_++;
+
+  if (text.isEmpty()) {
+    timer_search_delay_->stop();
+    return pending_search_id_;
+  }
+  timer_search_delay_->setInterval(search_delay_);
+  timer_search_delay_->start();
+
+  return pending_search_id_;
+
+}
+
+void QobuzService::StartSearch() {
+
+  if (app_id_.isEmpty() || username_.isEmpty() || password_.isEmpty()) {
+    emit SearchError(pending_search_id_, tr("Not authenticated."));
+    next_pending_search_id_ = 1;
+    ShowConfig();
+    return;
+  }
+
+  search_id_ = pending_search_id_;
+  search_text_ = pending_search_text_;
+
+  SendSearch();
+
+}
+
+void QobuzService::CancelSearch() {
+}
+
+void QobuzService::SendSearch() {
+
+  QobuzBaseRequest::QueryType type;
+
+  switch (pending_search_type_) {
+    case InternetSearch::SearchType_Artists:
+      type = QobuzBaseRequest::QueryType_SearchArtists;
+      break;
+    case InternetSearch::SearchType_Albums:
+      type = QobuzBaseRequest::QueryType_SearchAlbums;
+      break;
+    case InternetSearch::SearchType_Songs:
+      type = QobuzBaseRequest::QueryType_SearchSongs;
+      break;
+    default:
+      //Error("Invalid search type.");
+      return;
+  }
+
+  search_request_.reset(new QobuzRequest(this, url_handler_, network_, type, this));
+
+  connect(search_request_.get(), SIGNAL(SearchResults(int, SongList)), SIGNAL(SearchResults(int, SongList)));
+  connect(search_request_.get(), SIGNAL(ErrorSignal(int, QString)), SIGNAL(SearchError(int, QString)));
+  connect(search_request_.get(), SIGNAL(UpdateStatus(QString)), SIGNAL(SearchUpdateStatus(QString)));
+  connect(search_request_.get(), SIGNAL(ProgressSetMaximum(int)), SIGNAL(SearchProgressSetMaximum(int)));
+  connect(search_request_.get(), SIGNAL(UpdateProgress(int)), SIGNAL(SearchUpdateProgress(int)));
+  connect(this, SIGNAL(LoginComplete(bool, QString)), search_request_.get(), SLOT(LoginComplete(bool, QString)));
+
+  search_request_->Search(search_id_, search_text_);
+  search_request_->Process();
+
+}
+
+void QobuzService::GetStreamURL(const QUrl &url) {
+
+  QobuzStreamURLRequest *stream_url_req = new QobuzStreamURLRequest(this, network_, url, this);
+  stream_url_requests_ << stream_url_req;
+
+  connect(stream_url_req, SIGNAL(TryLogin()), this, SLOT(TryLogin()));
+  connect(stream_url_req, SIGNAL(StreamURLFinished(QUrl, QUrl, Song::FileType, QString)), this, SLOT(HandleStreamURLFinished(QUrl, QUrl, Song::FileType, QString)));
+  connect(this, SIGNAL(LoginComplete(bool, QString)), stream_url_req, SLOT(LoginComplete(bool, QString)));
+
+  stream_url_req->Process();
+
+}
+
+void QobuzService::HandleStreamURLFinished(const QUrl original_url, const QUrl stream_url, const Song::FileType filetype, QString error) {
+
+  QobuzStreamURLRequest *stream_url_req = qobject_cast<QobuzStreamURLRequest*>(sender());
+  if (!stream_url_req || !stream_url_requests_.contains(stream_url_req)) return;
+  stream_url_req->deleteLater();
+  stream_url_requests_.removeAll(stream_url_req);
+
+  emit StreamURLFinished(original_url, stream_url, filetype, error);
+
+}
+
+QString QobuzService::LoginError(QString error, QVariant debug) {
+
+  qLog(Error) << "Qobuz:" << error;
+  if (debug.isValid()) qLog(Debug) << debug;
+
+  emit LoginFailure(error);
+  emit LoginComplete(false, error);
+
+  return error;
+
+}

src/qobuz/qobuzservice.h

@@ -0,0 +1,212 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2019, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef QOBUZSERVICE_H
+#define QOBUZSERVICE_H
+
+#include "config.h"
+
+#include <memory>
+#include <stdbool.h>
+
+#include <QtGlobal>
+#include <QObject>
+#include <QPair>
+#include <QList>
+#include <QString>
+#include <QUrl>
+#include <QNetworkReply>
+#include <QTimer>
+#include <QSortFilterProxyModel>
+
+#include "core/song.h"
+#include "internet/internetservice.h"
+#include "internet/internetsearch.h"
+#include "settings/qobuzsettingspage.h"
+
+class Application;
+class NetworkAccessManager;
+class QobuzUrlHandler;
+class QobuzRequest;
+class QobuzFavoriteRequest;
+class QobuzStreamURLRequest;
+class CollectionBackend;
+class CollectionModel;
+
+using std::shared_ptr;
+
+class QobuzService : public InternetService {
+  Q_OBJECT
+
+ public:
+  QobuzService(Application *app, QObject *parent);
+  ~QobuzService();
+
+  static const Song::Source kSource;
+
+  void ReloadSettings();
+  QString CoverCacheDir();  
+
+  void Logout();
+  int Search(const QString &query, InternetSearch::SearchType type);
+  void CancelSearch();
+
+  const int max_login_attempts() { return kLoginAttempts; }
+
+  QString app_id() { return app_id_; }
+  QString app_secret() { return app_secret_; }
+  QString username() { return username_; }
+  QString password() { return password_; }
+  int format() { return format_; }
+  int search_delay() { return search_delay_; }
+  int artistssearchlimit() { return artistssearchlimit_; }
+  int albumssearchlimit() { return albumssearchlimit_; }
+  int songssearchlimit() { return songssearchlimit_; }
+  bool cache_album_covers() { return cache_album_covers_; }
+
+  QString access_token() { return access_token_; }
+
+  const bool authenticated() { return (!app_id_.isEmpty() && !app_secret_.isEmpty() && !access_token_.isEmpty()); }
+  const bool login_sent() { return login_sent_; }
+  const bool login_attempts() { return login_attempts_; }
+
+  void GetStreamURL(const QUrl &url);
+
+  CollectionBackend *artists_collection_backend() { return artists_collection_backend_; }
+  CollectionBackend *albums_collection_backend() { return albums_collection_backend_; }
+  CollectionBackend *songs_collection_backend() { return songs_collection_backend_; }
+
+  CollectionModel *artists_collection_model() { return artists_collection_model_; }
+  CollectionModel *albums_collection_model() { return albums_collection_model_; }
+  CollectionModel *songs_collection_model() { return songs_collection_model_; }
+
+  QSortFilterProxyModel *artists_collection_sort_model() { return artists_collection_sort_model_; }
+  QSortFilterProxyModel *albums_collection_sort_model() { return albums_collection_sort_model_; }
+  QSortFilterProxyModel *songs_collection_sort_model() { return songs_collection_sort_model_; }
+
+  enum QueryType {
+    QueryType_Artists,
+    QueryType_Albums,
+    QueryType_Songs,
+    QueryType_SearchArtists,
+    QueryType_SearchAlbums,
+    QueryType_SearchSongs,
+  };
+
+ signals:
+
+ public slots:
+  void ShowConfig();
+  void TryLogin();
+  void SendLogin(const QString &username, const QString &password, const QString &token);
+  void GetArtists();
+  void GetAlbums();
+  void GetSongs();
+  void ResetArtistsRequest();
+  void ResetAlbumsRequest();
+  void ResetSongsRequest();
+
+ private slots:
+  void SendLogin();
+  void HandleAuthReply(QNetworkReply *reply);
+  void ResetLoginAttempts();
+  void StartSearch();
+  void ArtistsResultsReceived(SongList songs);
+  void ArtistsErrorReceived(QString error);
+  void AlbumsResultsReceived(SongList songs);
+  void AlbumsErrorReceived(QString error);
+  void SongsResultsReceived(SongList songs);
+  void SongsErrorReceived(QString error);
+  void HandleStreamURLFinished(const QUrl original_url, const QUrl stream_url, const Song::FileType filetype, QString error = QString());
+
+ private:
+  typedef QPair<QString, QString> Param;
+  typedef QList<Param> ParamList;
+
+  typedef QPair<QByteArray, QByteArray> EncodedParam;
+  typedef QList<EncodedParam> EncodedParamList;
+
+  void SendSearch();
+  QString LoginError(QString error, QVariant debug = QVariant());
+
+  static const char *kAuthUrl;
+  static const int kLoginAttempts;
+  static const int kTimeResetLoginAttempts;
+
+  static const char *kArtistsSongsTable;
+  static const char *kAlbumsSongsTable;
+  static const char *kSongsTable;
+
+  static const char *kArtistsSongsFtsTable;
+  static const char *kAlbumsSongsFtsTable;
+  static const char *kSongsFtsTable;
+
+  Application *app_;
+  NetworkAccessManager *network_;
+  QobuzUrlHandler *url_handler_;
+
+  CollectionBackend *artists_collection_backend_;
+  CollectionBackend *albums_collection_backend_;
+  CollectionBackend *songs_collection_backend_;
+
+  CollectionModel *artists_collection_model_;
+  CollectionModel *albums_collection_model_;
+  CollectionModel *songs_collection_model_;
+
+  QSortFilterProxyModel *artists_collection_sort_model_;
+  QSortFilterProxyModel *albums_collection_sort_model_;
+  QSortFilterProxyModel *songs_collection_sort_model_;
+
+  QTimer *timer_search_delay_;
+  QTimer *timer_login_attempt_;
+
+  std::shared_ptr<QobuzRequest> artists_request_;
+  std::shared_ptr<QobuzRequest> albums_request_;
+  std::shared_ptr<QobuzRequest> songs_request_;
+  std::shared_ptr<QobuzRequest> search_request_;
+  QobuzFavoriteRequest *favorite_request_;
+
+  QString app_id_;
+  QString app_secret_;
+  QString username_;
+  QString password_;
+  int format_;
+  int search_delay_;
+  int artistssearchlimit_;
+  int albumssearchlimit_;
+  int songssearchlimit_;
+  bool cache_album_covers_;
+
+  QString access_token_;
+
+  int pending_search_id_;
+  int next_pending_search_id_;
+  QString pending_search_text_;
+  InternetSearch::SearchType pending_search_type_;
+
+  int search_id_;
+  QString search_text_;
+  bool login_sent_;
+  int login_attempts_;
+
+  QList<QobuzStreamURLRequest*> stream_url_requests_;
+
+};
+
+#endif  // QOBUZSERVICE_H

src/qobuz/qobuzstreamurlrequest.cpp

@@ -0,0 +1,213 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2019, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "config.h"
+
+#include <QObject>
+#include <QStandardPaths>
+#include <QMimeDatabase>
+#include <QFile>
+#include <QDir>
+#include <QList>
+#include <QByteArray>
+#include <QString>
+#include <QUrl>
+#include <QDateTime>
+#include <QJsonValue>
+#include <QJsonObject>
+#include <QXmlStreamReader>
+
+#include "core/logging.h"
+#include "core/network.h"
+#include "core/song.h"
+#include "settings/qobuzsettingspage.h"
+#include "qobuzservice.h"
+#include "qobuzbaserequest.h"
+#include "qobuzstreamurlrequest.h"
+
+QobuzStreamURLRequest::QobuzStreamURLRequest(QobuzService *service, NetworkAccessManager *network, const QUrl &original_url, QObject *parent)
+    : QobuzBaseRequest(service, network, parent),
+    service_(service),
+    reply_(nullptr),
+    original_url_(original_url),
+    song_id_(original_url.path().toInt()),
+    tries_(0),
+    need_login_(false) {}
+
+QobuzStreamURLRequest::~QobuzStreamURLRequest() {
+
+  if (reply_) {
+    disconnect(reply_, 0, nullptr, 0);
+    if (reply_->isRunning()) reply_->abort();
+    reply_->deleteLater();
+  }
+
+}
+
+void QobuzStreamURLRequest::LoginComplete(bool success, QString error) {
+
+  if (!need_login_) return;
+  need_login_ = false;
+
+  if (!success) {
+    emit StreamURLFinished(original_url_, original_url_, Song::FileType_Stream, error);
+    return;
+  }
+
+  Process();
+
+}
+
+void QobuzStreamURLRequest::Process() {
+
+  if (app_id().isEmpty() || app_secret().isEmpty()) {
+    emit StreamURLFinished(original_url_, original_url_, Song::FileType_Stream, tr("Missing app ID or secret."));
+    return;
+  }
+
+  if (!authenticated()) {
+    need_login_ = true;
+    emit TryLogin();
+    return;
+  }
+  GetStreamURL();
+
+}
+
+void QobuzStreamURLRequest::Cancel() {
+
+  if (reply_ && reply_->isRunning()) {
+    reply_->abort();
+  }
+  else {
+    emit StreamURLFinished(original_url_, original_url_, Song::FileType_Stream, tr("Cancelled."));
+  }
+
+}
+
+void QobuzStreamURLRequest::GetStreamURL() {
+
+  ++tries_;
+
+  if (reply_) {
+    disconnect(reply_, 0, nullptr, 0);
+    if (reply_->isRunning()) reply_->abort();
+    reply_->deleteLater();
+  }
+
+  quint64 timestamp = QDateTime::currentDateTime().toTime_t();
+
+  ParamList params_to_sign = ParamList() << Param("format_id", QString::number(format()))
+                                         << Param("track_id", QString::number(song_id_));
+
+  std::sort(params_to_sign.begin(), params_to_sign.end());
+
+  QString data_to_sign;
+  data_to_sign += "trackgetFileUrl";
+  for (const Param &param : params_to_sign) {
+    EncodedParam encoded_param(QUrl::toPercentEncoding(param.first), QUrl::toPercentEncoding(param.second));
+    data_to_sign += param.first;
+    data_to_sign += param.second;
+  }
+  data_to_sign += QString::number(timestamp);
+  data_to_sign += app_secret();
+
+  QByteArray const digest = QCryptographicHash::hash(data_to_sign.toUtf8(), QCryptographicHash::Md5);
+  QString signature = QString::fromLatin1(digest.toHex()).rightJustified(32, '0').toLower();
+
+  ParamList params = params_to_sign;
+  params << Param("request_ts", QString::number(timestamp));
+  params << Param("request_sig", signature);
+  params << Param("user_auth_token", access_token());
+
+  std::sort(params.begin(), params.end());
+
+  reply_ = CreateRequest(QString("track/getFileUrl"), params);
+  connect(reply_, SIGNAL(finished()), this, SLOT(StreamURLReceived()));
+
+}
+
+void QobuzStreamURLRequest::StreamURLReceived() {
+
+  if (!reply_) return;
+  disconnect(reply_, 0, nullptr, 0);
+  reply_->deleteLater();
+
+  QString error;
+
+  QByteArray data = GetReplyData(reply_, error);
+  if (data.isEmpty()) {
+    reply_ = nullptr;
+    if (!authenticated() && login_sent() && tries_ <= 1) {
+      need_login_ = true;
+      return;
+    }
+    emit StreamURLFinished(original_url_, original_url_, Song::FileType_Stream, error);
+    return;
+  }
+  reply_ = nullptr;
+
+  QJsonObject json_obj = ExtractJsonObj(data, error);
+  if (json_obj.isEmpty()) {
+    emit StreamURLFinished(original_url_, original_url_, Song::FileType_Stream, error);
+    return;
+  }
+
+  if (!json_obj.contains("track_id")) {
+    error = Error("Invalid Json reply, stream url is missing track_id.", json_obj);
+    emit StreamURLFinished(original_url_, original_url_, Song::FileType_Stream, error);
+    return;
+  }
+
+  int track_id = json_obj["track_id"].toInt();
+  if (track_id != song_id_) {
+    error = Error("Incorrect track ID returned.", json_obj);
+    emit StreamURLFinished(original_url_, original_url_, Song::FileType_Stream, error);
+    return;
+  }
+
+  if (!json_obj.contains("mime_type") || !json_obj.contains("url")) {
+    error = Error("Invalid Json reply, stream url is missing url or mime_type.", json_obj);
+    emit StreamURLFinished(original_url_, original_url_, Song::FileType_Stream, error);
+    return;
+  }
+
+  QUrl url(json_obj["url"].toString());
+  QString mimetype = json_obj["mime_type"].toString();
+
+  Song::FileType filetype(Song::FileType_Unknown);
+  QMimeDatabase mimedb;
+  for (QString suffix : mimedb.mimeTypeForName(mimetype.toUtf8()).suffixes()) {
+    filetype = Song::FiletypeByExtension(suffix);
+    if (filetype != Song::FileType_Unknown) break;
+  }
+  if (filetype == Song::FileType_Unknown) {
+    qLog(Debug) << "Qobuz: Unknown mimetype" << mimetype;
+    filetype = Song::FileType_Stream;
+  }
+
+  if (!url.isValid()) {
+    error = Error("Returned stream url is invalid.", json_obj);
+    emit StreamURLFinished(original_url_, original_url_, filetype, error);
+    return;
+  }
+
+  emit StreamURLFinished(original_url_, url, filetype);
+
+}

src/qobuz/qobuzstreamurlrequest.h

@@ -0,0 +1,69 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2019, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef QOBUZSTREAMURLREQUEST_H
+#define QOBUZSTREAMURLREQUEST_H
+
+#include "config.h"
+
+#include <QString>
+#include <QUrl>
+
+#include "core/song.h"
+#include "qobuzbaserequest.h"
+
+class QNetworkReply;
+class NetworkAccessManager;
+class QobuzService;
+
+class QobuzStreamURLRequest : public QobuzBaseRequest {
+  Q_OBJECT
+
+ public:
+  QobuzStreamURLRequest(QobuzService *service, NetworkAccessManager *network, const QUrl &original_url, QObject *parent);
+  ~QobuzStreamURLRequest();
+
+  void GetStreamURL();
+  void Process();
+  void NeedLogin() { need_login_ = true; }
+  void Cancel();
+
+  QUrl original_url() { return original_url_; }
+  int song_id() { return song_id_; }
+  bool need_login() { return need_login_; }
+
+ signals:
+  void TryLogin();
+  void StreamURLFinished(const QUrl original_url, const QUrl stream_url, const Song::FileType filetype, QString error = QString());
+
+ private slots:
+  void LoginComplete(bool success, QString error = QString());
+  void StreamURLReceived();
+
+ private:
+  QobuzService *service_;
+  QNetworkReply *reply_;
+  QUrl original_url_;
+  int song_id_;
+  int tries_;
+  bool need_login_;
+
+};
+
+#endif  // QOBUZSTREAMURLREQUEST_H

src/qobuz/qobuzurlhandler.cpp

@@ -0,0 +1,68 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2018, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <QObject>
+#include <QString>
+#include <QUrl>
+
+#include "core/application.h"
+#include "core/taskmanager.h"
+#include "core/iconloader.h"
+#include "core/logging.h"
+#include "core/song.h"
+#include "qobuz/qobuzservice.h"
+#include "qobuzurlhandler.h"
+
+QobuzUrlHandler::QobuzUrlHandler(Application *app, QobuzService *service) :
+  UrlHandler(service),
+  app_(app),
+  service_(service),
+  task_id_(-1)
+  {
+
+  connect(service, SIGNAL(StreamURLFinished(QUrl, QUrl, Song::FileType, QString)), this, SLOT(GetStreamURLFinished(QUrl, QUrl, Song::FileType, QString)));
+
+}
+
+UrlHandler::LoadResult QobuzUrlHandler::StartLoading(const QUrl &url) {
+
+  LoadResult ret(url);
+  if (task_id_ != -1) return ret;
+  task_id_ = app_->task_manager()->StartTask(QString("Loading %1 stream...").arg(url.scheme()));
+  service_->GetStreamURL(url);
+  ret.type_ = LoadResult::WillLoadAsynchronously;
+  return ret;
+
+}
+
+void QobuzUrlHandler::GetStreamURLFinished(QUrl original_url, QUrl url, Song::FileType filetype, QString error) {
+
+  if (task_id_ == -1) return;
+  CancelTask();
+  if (error.isEmpty())
+    emit AsyncLoadComplete(LoadResult(original_url, LoadResult::TrackAvailable, url, filetype));
+  else
+    emit AsyncLoadComplete(LoadResult(original_url, LoadResult::Error, url, filetype, -1, error));
+
+}
+
+void QobuzUrlHandler::CancelTask() {
+  app_->task_manager()->SetTaskFinished(task_id_);
+  task_id_ = -1;
+}

src/qobuz/qobuzurlhandler.h

@@ -0,0 +1,55 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2018, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef QOBUZURLHANDLER_H
+#define QOBUZURLHANDLER_H
+
+#include <QObject>
+#include <QString>
+#include <QUrl>
+
+#include "core/urlhandler.h"
+#include "core/song.h"
+#include "qobuz/qobuzservice.h"
+
+class Application;
+class QobuzService;
+
+class QobuzUrlHandler : public UrlHandler {
+  Q_OBJECT
+
+ public:
+  QobuzUrlHandler(Application *app, QobuzService *service);
+
+  QString scheme() const { return service_->url_scheme(); }
+  LoadResult StartLoading(const QUrl &url);
+
+  void CancelTask();
+
+ private slots:
+  void GetStreamURLFinished(QUrl original_url, QUrl url, Song::FileType filetype, QString error = QString());
+
+ private:
+  Application *app_;
+  QobuzService *service_;
+  int task_id_;
+
+};
+
+#endif