Refactor Tidal, Spotify, Qobuz, Subsonic and cover providers

Use common HTTP, Json and OAuthenticator class
2025-03-08 23:11:07 +01:00
parent 7de8a44709
commit cd516c37b9
81 changed files with 2429 additions and 3968 deletions
--- a/src/covermanager/albumcoverfetchersearch.cpp
+++ b/src/covermanager/albumcoverfetchersearch.cpp
@@ -101,7 +101,7 @@ void AlbumCoverFetcherSearch::Start(SharedPtr<CoverProviders> cover_providers) {
    if (!provider->is_enabled()) continue;

    // Skip any provider that requires authentication but is not authenticated.
-    if (provider->AuthenticationRequired() && !provider->IsAuthenticated()) {
+    if (provider->authentication_required() && !provider->authenticated()) {
      continue;
    }

--- a/src/covermanager/coverprovider.cpp
+++ b/src/covermanager/coverprovider.cpp
@@ -2,7 +2,7 @@
 * Strawberry Music Player
 * This file was part of Clementine.
 * Copyright 2010, David Sansome <me@davidsansome.com>
- * Copyright 2018-2021, Jonas Kvinge <jonas@jkvinge.net>
+ * Copyright 2018-2025, 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
@@ -21,10 +21,9 @@

 #include "config.h"

-#include <QObject>
 #include <QString>

 #include "includes/shared_ptr.h"
 #include "coverprovider.h"

-CoverProvider::CoverProvider(const QString &name, const bool enabled, const bool authentication_required, const float quality, const bool batch, const bool allow_missing_album, const SharedPtr<NetworkAccessManager> network, QObject *parent) : QObject(parent), network_(network), name_(name), enabled_(enabled), order_(0), authentication_required_(authentication_required), quality_(quality), batch_(batch), allow_missing_album_(allow_missing_album) {}
+CoverProvider::CoverProvider(const QString &name, const bool enabled, const bool authentication_required, const float quality, const bool batch, const bool allow_missing_album, const SharedPtr<NetworkAccessManager> network, QObject *parent) : JsonBaseRequest(network, parent), network_(network), name_(name), enabled_(enabled), order_(0), authentication_required_(authentication_required), quality_(quality), batch_(batch), allow_missing_album_(allow_missing_album) {}
--- a/src/covermanager/coverprovider.h
+++ b/src/covermanager/coverprovider.h
@@ -2,7 +2,7 @@
 * Strawberry Music Player
 * This file was part of Clementine.
 * Copyright 2010, David Sansome <me@davidsansome.com>
- * Copyright 2018-2021, Jonas Kvinge <jonas@jkvinge.net>
+ * Copyright 2018-2025, 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
@@ -24,26 +24,22 @@

 #include "config.h"

-#include <QtGlobal>
-#include <QObject>
 #include <QVariant>
 #include <QString>
 #include <QStringList>

 #include "includes/shared_ptr.h"
+#include "core/jsonbaserequest.h"
 #include "albumcoverfetcher.h"

 class NetworkAccessManager;

-// Each implementation of this interface downloads covers from one online service.
-// There are no limitations on what this service might be - last.fm, Amazon, Google Images - you name it.
-class CoverProvider : public QObject {
+class CoverProvider : public JsonBaseRequest {
  Q_OBJECT

 public:
  explicit CoverProvider(const QString &name, const bool enabled, const bool authentication_required, const float quality, const bool batch, const bool allow_missing_album, const SharedPtr<NetworkAccessManager> network, QObject *parent);

-  // A name (very short description) of this provider, like "last.fm".
  QString name() const { return name_; }
  bool is_enabled() const { return enabled_; }
  int order() const { return order_; }
@@ -54,10 +50,14 @@ class CoverProvider : public QObject {
  void set_enabled(const bool enabled) { enabled_ = enabled; }
  void set_order(const int order) { order_ = order; }

-  bool AuthenticationRequired() const { return authentication_required_; }
-  virtual bool IsAuthenticated() const { return true; }
+  virtual QString service_name() const override { return name_; }
+  virtual bool authentication_required() const override { return authentication_required_; }
+  virtual bool authenticated() const override { return true; }
+  virtual bool use_authorization_header() const override { return false; }
+  virtual QByteArray authorization_header() const override { return QByteArray(); }
+
  virtual void Authenticate() {}
-  virtual void Deauthenticate() {}
+  virtual void ClearSession() {}

  // Starts searching for covers matching the given query text.
  // Returns true if the query has been started, or false if an error occurred.
@@ -65,12 +65,10 @@ class CoverProvider : public QObject {
  virtual bool StartSearch(const QString &artist, const QString &album, const QString &title, const int id) = 0;
  virtual void CancelSearch(const int id) { Q_UNUSED(id); }

-  virtual void Error(const QString &error, const QVariant &debug = QVariant()) = 0;
-
 Q_SIGNALS:
-  void AuthenticationComplete(const bool success, const QStringList &errors = QStringList());
+  void AuthenticationFinished(const bool success, const QString &error = QString());
  void AuthenticationSuccess();
-  void AuthenticationFailure(const QStringList &errors);
+  void AuthenticationFailure(const QString &error);
  void SearchResults(const int id, const CoverProviderSearchResults &results);
  void SearchFinished(const int id, const CoverProviderSearchResults &results);

--- a/src/covermanager/deezercoverprovider.cpp
+++ b/src/covermanager/deezercoverprovider.cpp
@@ -1,6 +1,6 @@
 /*
 * Strawberry Music Player
- * Copyright 2018-2021, Jonas Kvinge <jonas@jkvinge.net>
+ * Copyright 2018-2025, 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
@@ -22,8 +22,6 @@
 #include <algorithm>
 #include <utility>

-#include <QtGlobal>
-#include <QObject>
 #include <QPair>
 #include <QList>
 #include <QMap>
@@ -38,6 +36,7 @@
 #include <QJsonValue>
 #include <QJsonObject>
 #include <QJsonArray>
+#include <QScopeGuard>

 #include "core/networkaccessmanager.h"
 #include "core/logging.h"
@@ -52,22 +51,11 @@ using namespace Qt::Literals::StringLiterals;
 namespace {
 constexpr char kApiUrl[] = "https://api.deezer.com";
 constexpr int kLimit = 10;
-}
+}  // namespace

 DeezerCoverProvider::DeezerCoverProvider(const SharedPtr<NetworkAccessManager> network, QObject *parent)
    : JsonCoverProvider(u"Deezer"_s, true, false, 2.0, true, true, network, parent) {}

-DeezerCoverProvider::~DeezerCoverProvider() {
-
-  while (!replies_.isEmpty()) {
-    QNetworkReply *reply = replies_.takeFirst();
-    QObject::disconnect(reply, nullptr, this, nullptr);
-    reply->abort();
-    reply->deleteLater();
-  }
-
-}
-
 bool DeezerCoverProvider::StartSearch(const QString &artist, const QString &album, const QString &title, const int id) {

  if (artist.isEmpty() && album.isEmpty() && title.isEmpty()) return false;
@@ -91,17 +79,7 @@ bool DeezerCoverProvider::StartSearch(const QString &artist, const QString &albu
                                       << Param(u"q"_s, query)
                                       << Param(u"limit"_s, QString::number(kLimit));

-  QUrlQuery url_query;
-  for (const Param &param : params) {
-    url_query.addQueryItem(QString::fromLatin1(QUrl::toPercentEncoding(param.first)), QString::fromLatin1(QUrl::toPercentEncoding(param.second)));
-  }
-
-  QUrl url(QLatin1String(kApiUrl) + QLatin1Char('/') + resource);
-  url.setQuery(url_query);
-  QNetworkRequest req(url);
-  req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
-  QNetworkReply *reply = network_->get(req);
-  replies_ << reply;
+  QNetworkReply *reply = CreateGetRequest(QUrl(QLatin1String(kApiUrl) + QLatin1Char('/') + resource), params);
  QObject::connect(reply, &QNetworkReply::finished, this, [this, reply, id]() { HandleSearchReply(reply, id); });

  return true;
@@ -110,82 +88,56 @@ bool DeezerCoverProvider::StartSearch(const QString &artist, const QString &albu

 void DeezerCoverProvider::CancelSearch(const int id) { Q_UNUSED(id); }

-QByteArray DeezerCoverProvider::GetReplyData(QNetworkReply *reply) {
+JsonBaseRequest::JsonObjectResult DeezerCoverProvider::ParseJsonObject(QNetworkReply *reply) {

-  QByteArray data;
-
-  if (reply->error() == QNetworkReply::NoError && reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt() == 200) {
-    data = reply->readAll();
+  if (reply->error() != QNetworkReply::NoError && reply->error() < 200) {
+    return ReplyDataResult(ErrorCode::NetworkError, QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
  }
-  else {
-    if (reply->error() != QNetworkReply::NoError && reply->error() < 200) {
-      // This is a network error, there is nothing more to do.
-      QString error = QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
-      Error(error);
+
+  JsonObjectResult result(ErrorCode::Success);
+  result.network_error = reply->error();
+  if (reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).isValid()) {
+    result.http_status_code = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+  }
+
+  const QByteArray data = reply->readAll();
+  if (!data.isEmpty()) {
+    QJsonParseError json_parse_error;
+    const QJsonDocument json_document = QJsonDocument::fromJson(data, &json_parse_error);
+    if (json_parse_error.error == QJsonParseError::NoError) {
+      const QJsonObject json_object = json_document.object();
+      if (json_object.contains("error"_L1) && json_object["error"_L1].isObject()) {
+        const QJsonObject object_error = json_object["error"_L1].toObject();
+        if (object_error.contains("code"_L1) && object_error.contains("type"_L1) && object_error.contains("message"_L1)) {
+          const int code = object_error["code"_L1].toInt();
+          const QString type = object_error["type"_L1].toString();
+          const QString message = object_error["message"_L1].toString();
+          result.error_code = ErrorCode::APIError;
+          result.error_message = QStringLiteral("%1: %2 (%3)").arg(type, message).arg(code);
+        }
+      }
+      else {
+        result.json_object = json_document.object();
+      }
    }
    else {
-      // See if there is Json data containing "error" object - then use that instead.
-      data = reply->readAll();
-      QJsonParseError json_error;
-      QJsonDocument json_doc = QJsonDocument::fromJson(data, &json_error);
-      QString error;
-      if (json_error.error == QJsonParseError::NoError && !json_doc.isEmpty() && json_doc.isObject()) {
-        QJsonObject json_obj = json_doc.object();
-        if (json_obj.contains("error"_L1)) {
-          QJsonValue value_error = json_obj["error"_L1];
-          if (value_error.isObject()) {
-            QJsonObject obj_error = value_error.toObject();
-            int code = obj_error["code"_L1].toInt();
-            QString message = obj_error["message"_L1].toString();
-            error = QStringLiteral("%1 (%2)").arg(message).arg(code);
-          }
-        }
-      }
-      if (error.isEmpty()) {
-        if (reply->error() != QNetworkReply::NoError) {
-          error = QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
-        }
-        else {
-          error = QStringLiteral("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt());
-        }
-      }
-      Error(error);
+      result.error_code = ErrorCode::ParseError;
+      result.error_message = json_parse_error.errorString();
    }
-    return QByteArray();
  }

-  return data;
-
-}
-
-QJsonValue DeezerCoverProvider::ExtractData(const QByteArray &data) {
-
-  QJsonObject json_obj = ExtractJsonObj(data);
-  if (json_obj.isEmpty()) return QJsonObject();
-
-  if (json_obj.contains("error"_L1)) {
-    QJsonValue value_error = json_obj["error"_L1];
-    if (!value_error.isObject()) {
-      Error(u"Error missing object"_s, json_obj);
-      return QJsonValue();
+  if (result.error_code != ErrorCode::APIError) {
+    if (reply->error() != QNetworkReply::NoError) {
+      result.error_code = ErrorCode::NetworkError;
+      result.error_message = QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
+    }
+    else if (result.http_status_code != 200) {
+      result.error_code = ErrorCode::HttpError;
+      result.error_message = QStringLiteral("Received HTTP code %1").arg(result.http_status_code);
    }
-    QJsonObject obj_error = value_error.toObject();
-    const int code = obj_error["code"_L1].toInt();
-    QString message = obj_error["message"_L1].toString();
-    Error(QStringLiteral("%1 (%2)").arg(message).arg(code));
-    return QJsonValue();
  }

-  if (!json_obj.contains("data"_L1) && !json_obj.contains("DATA"_L1)) {
-    Error(u"Json reply object is missing data."_s, json_obj);
-    return QJsonValue();
-  }
-
-  QJsonValue value_data;
-  if (json_obj.contains("data"_L1)) value_data = json_obj["data"_L1];
-  else value_data = json_obj["DATA"_L1];
-
-  return value_data;
+  return result;

 }

@@ -196,25 +148,37 @@ void DeezerCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id)
  QObject::disconnect(reply, nullptr, this, nullptr);
  reply->deleteLater();

-  QByteArray data = GetReplyData(reply);
-  if (data.isEmpty()) {
-    Q_EMIT SearchFinished(id, CoverProviderSearchResults());
+  CoverProviderSearchResults results;
+  const QScopeGuard search_finished = qScopeGuard([this, id, &results]() { Q_EMIT SearchFinished(id, results); });
+
+  const JsonObjectResult json_object_result = ParseJsonObject(reply);
+  if (!json_object_result.success()) {
+    Error(json_object_result.error_message);
    return;
  }

-  QJsonValue value_data = ExtractData(data);
-  if (!value_data.isArray()) {
-    Q_EMIT SearchFinished(id, CoverProviderSearchResults());
+  const QJsonObject &json_object = json_object_result.json_object;
+  if (!json_object.isEmpty()) {
+    return;
+  }
+
+  QJsonArray array_data;
+  if (json_object.contains("data"_L1) && json_object["DATA"_L1].isArray()) {
+    array_data = json_object["data"_L1].toArray();
+  }
+  else if (json_object.contains("DATA"_L1) && json_object["DATA"_L1].isArray()) {
+    array_data = json_object["data"_L1].toArray();
+  }
+  else {
+    Error(u"Json reply object is missing data."_s, json_object);
    return;
  }

-  QJsonArray array_data = value_data.toArray();
  if (array_data.isEmpty()) {
-    Q_EMIT SearchFinished(id, CoverProviderSearchResults());
    return;
  }

-  QMap<QUrl, CoverProviderSearchResult> results;
+  QMap<QUrl, CoverProviderSearchResult> cover_results;
  int i = 0;
  for (const QJsonValue &json_value : std::as_const(array_data)) {

@@ -222,52 +186,52 @@ void DeezerCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id)
      Error(u"Invalid Json reply, data array value is not a object."_s);
      continue;
    }
-    QJsonObject json_obj = json_value.toObject();
-    QJsonObject obj_album;
-    if (json_obj.contains("album"_L1) && json_obj["album"_L1].isObject()) {  // Song search, so extract the album.
-      obj_album = json_obj["album"_L1].toObject();
+    const QJsonObject value_object = json_value.toObject();
+    QJsonObject object_album;
+    if (value_object.contains("album"_L1) && value_object["album"_L1].isObject()) {  // Song search, so extract the album.
+      object_album = value_object["album"_L1].toObject();
    }
    else {
-      obj_album = json_obj;
+      object_album = value_object;
    }

-    if (!json_obj.contains("id"_L1) || !obj_album.contains("id"_L1)) {
-      Error(u"Invalid Json reply, data array value object is missing ID."_s, json_obj);
+    if (!value_object.contains("id"_L1) || !object_album.contains("id"_L1)) {
+      Error(u"Invalid Json reply, data array value object is missing ID."_s, value_object);
      continue;
    }

-    if (!obj_album.contains("type"_L1)) {
-      Error(u"Invalid Json reply, data array value album object is missing type."_s, obj_album);
+    if (!object_album.contains("type"_L1)) {
+      Error(u"Invalid Json reply, data array value album object is missing type."_s, object_album);
      continue;
    }
-    QString type = obj_album["type"_L1].toString();
+    const QString type = object_album["type"_L1].toString();
    if (type != "album"_L1) {
-      Error(u"Invalid Json reply, data array value album object has incorrect type returned"_s, obj_album);
+      Error(u"Invalid Json reply, data array value album object has incorrect type returned"_s, object_album);
      continue;
    }

-    if (!json_obj.contains("artist"_L1)) {
-      Error(u"Invalid Json reply, data array value object is missing artist."_s, json_obj);
+    if (!json_object.contains("artist"_L1)) {
+      Error(u"Invalid Json reply, data array value object is missing artist."_s, json_object);
      continue;
    }
-    QJsonValue value_artist = json_obj["artist"_L1];
+    const QJsonValue value_artist = json_object["artist"_L1];
    if (!value_artist.isObject()) {
      Error(u"Invalid Json reply, data array value artist is not a object."_s, value_artist);
      continue;
    }
-    QJsonObject obj_artist = value_artist.toObject();
+    const QJsonObject object_artist = value_artist.toObject();

-    if (!obj_artist.contains("name"_L1)) {
-      Error(u"Invalid Json reply, data array value artist object is missing name."_s, obj_artist);
+    if (!object_artist.contains("name"_L1)) {
+      Error(u"Invalid Json reply, data array value artist object is missing name."_s, object_artist);
      continue;
    }
-    QString artist = obj_artist["name"_L1].toString();
+    const QString artist = object_artist["name"_L1].toString();

-    if (!obj_album.contains("title"_L1)) {
-      Error(u"Invalid Json reply, data array value album object is missing title."_s, obj_album);
+    if (!object_album.contains("title"_L1)) {
+      Error(u"Invalid Json reply, data array value album object is missing title."_s, object_album);
      continue;
    }
-    QString album = obj_album["title"_L1].toString();
+    const QString album = object_album["title"_L1].toString();

    CoverProviderSearchResult cover_result;
    cover_result.artist = artist;
@@ -277,35 +241,29 @@ void DeezerCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id)
    const QList<QPair<QString, QSize>> cover_sizes = QList<QPair<QString, QSize>>() << qMakePair(u"cover_xl"_s, QSize(1000, 1000))
                                                                                    << qMakePair(u"cover_big"_s, QSize(500, 500));
    for (const QPair<QString, QSize> &cover_size : cover_sizes) {
-      if (!obj_album.contains(cover_size.first)) continue;
-      QString cover = obj_album[cover_size.first].toString();
+      if (!object_album.contains(cover_size.first)) continue;
+      QString cover = object_album[cover_size.first].toString();
      if (!have_cover) {
        have_cover = true;
        ++i;
      }
      QUrl url(cover);
-      if (!results.contains(url)) {
+      if (!cover_results.contains(url)) {
        cover_result.image_url = url;
        cover_result.image_size = cover_size.second;
        cover_result.number = i;
-        results.insert(url, cover_result);
+        cover_results.insert(url, cover_result);
      }
    }

    if (!have_cover) {
-      Error(u"Invalid Json reply, data array value album object is missing cover."_s, obj_album);
+      Error(u"Invalid Json reply, data array value album object is missing cover."_s, object_album);
    }

  }

-  if (results.isEmpty()) {
-    Q_EMIT SearchFinished(id, CoverProviderSearchResults());
-  }
-  else {
-    CoverProviderSearchResults cover_results = results.values();
-    std::stable_sort(cover_results.begin(), cover_results.end(), AlbumCoverFetcherSearch::CoverProviderSearchResultCompareNumber);
-    Q_EMIT SearchFinished(id, cover_results);
-  }
+  results = cover_results.values();
+  std::stable_sort(results.begin(), results.end(), AlbumCoverFetcherSearch::CoverProviderSearchResultCompareNumber);

 }

--- a/src/covermanager/deezercoverprovider.h
+++ b/src/covermanager/deezercoverprovider.h
@@ -1,6 +1,6 @@
 /*
 * Strawberry Music Player
- * Copyright 2018-2021, Jonas Kvinge <jonas@jkvinge.net>
+ * Copyright 2018-2025, 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
@@ -22,13 +22,8 @@

 #include "config.h"

-#include <QObject>
-#include <QList>
 #include <QVariant>
-#include <QByteArray>
 #include <QString>
-#include <QJsonValue>
-#include <QJsonObject>

 #include "jsoncoverprovider.h"

@@ -40,7 +35,6 @@ class DeezerCoverProvider : public JsonCoverProvider {

 public:
  explicit DeezerCoverProvider(const SharedPtr<NetworkAccessManager> network, QObject *parent = nullptr);
-  ~DeezerCoverProvider() override;

  bool StartSearch(const QString &artist, const QString &album, const QString &title, const int id) override;
  void CancelSearch(const int id) override;
@@ -48,13 +42,11 @@ class DeezerCoverProvider : public JsonCoverProvider {
 private Q_SLOTS:
  void HandleSearchReply(QNetworkReply *reply, const int id);

- private:
-  QByteArray GetReplyData(QNetworkReply *reply);
-  QJsonValue ExtractData(const QByteArray &data);
-  void Error(const QString &error, const QVariant &debug = QVariant()) override;
+ protected:
+  JsonObjectResult ParseJsonObject(QNetworkReply *reply);

 private:
-  QList<QNetworkReply*> replies_;
+  void Error(const QString &error, const QVariant &debug = QVariant()) override;
 };

 #endif  // DEEZERCOVERPROVIDER_H
--- a/src/covermanager/discogscoverprovider.cpp
+++ b/src/covermanager/discogscoverprovider.cpp
@@ -2,7 +2,7 @@
 * Strawberry Music Player
 * This file was part of Clementine.
 * Copyright 2012, Martin Björklund <mbj4668@gmail.com>
- * Copyright 2016-2021, Jonas Kvinge <jonas@jkvinge.net>
+ * Copyright 2016-2025, 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
@@ -24,8 +24,6 @@
 #include <memory>
 #include <algorithm>

-#include <QtGlobal>
-#include <QObject>
 #include <QByteArray>
 #include <QPair>
 #include <QVariant>
@@ -40,6 +38,7 @@
 #include <QJsonObject>
 #include <QJsonValue>
 #include <QJsonArray>
+#include <QScopeGuard>

 #include "includes/shared_ptr.h"
 #include "core/logging.h"
@@ -146,81 +145,88 @@ void DiscogsCoverProvider::SendSearchRequest(SharedPtr<DiscogsCoverSearchContext

 }

-QNetworkReply *DiscogsCoverProvider::CreateRequest(QUrl url, const ParamList &params_provided) {
+QNetworkReply *DiscogsCoverProvider::CreateRequest(const QUrl &url, const ParamList &params) {

-  const ParamList params = ParamList() << Param(u"key"_s, QString::fromLatin1(QByteArray::fromBase64(kAccessKeyB64)))
-                                       << Param(u"secret"_s, QString::fromLatin1(QByteArray::fromBase64(kSecretKeyB64)))
-                                       << params_provided;
+  const ParamList request_params = ParamList() << Param(u"key"_s, QString::fromLatin1(QByteArray::fromBase64(kAccessKeyB64)))
+                                               << Param(u"secret"_s, QString::fromLatin1(QByteArray::fromBase64(kSecretKeyB64)))
+                                               << params;

  QUrlQuery url_query;
  QStringList query_items;

  // Encode the arguments
  using EncodedParam = QPair<QByteArray, QByteArray>;
-  for (const Param &param : params) {
-    EncodedParam encoded_param(QUrl::toPercentEncoding(param.first), QUrl::toPercentEncoding(param.second));
+  for (const Param &param : request_params) {
+    const EncodedParam encoded_param(QUrl::toPercentEncoding(param.first), QUrl::toPercentEncoding(param.second));
    query_items << QString::fromLatin1(encoded_param.first) + QLatin1Char('=') + QString::fromLatin1(encoded_param.second);
    url_query.addQueryItem(QString::fromLatin1(encoded_param.first), QString::fromLatin1(encoded_param.second));
  }
-  url.setQuery(url_query);
+
+  QUrl request_url(url);
+  request_url.setQuery(url_query);

  // Sign the request
-  const QByteArray data_to_sign = QStringLiteral("GET\n%1\n%2\n%3").arg(url.host(), url.path(), query_items.join(u'&')).toUtf8();
+  const QByteArray data_to_sign = QStringLiteral("GET\n%1\n%2\n%3").arg(request_url.host(), request_url.path(), query_items.join(u'&')).toUtf8();
  const QByteArray signature(Utilities::HmacSha256(QByteArray::fromBase64(kSecretKeyB64), data_to_sign));

  // Add the signature to the request
  url_query.addQueryItem(u"Signature"_s, QString::fromLatin1(QUrl::toPercentEncoding(QString::fromLatin1(signature.toBase64()))));

-  QNetworkRequest req(url);
-  req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
-  QNetworkReply *reply = network_->get(req);
+  QNetworkRequest network_request(request_url);
+  network_request.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
+  QNetworkReply *reply = network_->get(network_request);
  replies_ << reply;

-  qLog(Debug) << "Discogs: Sending request" << url;
+  qLog(Debug) << "Discogs: Sending request" << request_url;

  return reply;

 }

-QByteArray DiscogsCoverProvider::GetReplyData(QNetworkReply *reply) {
+JsonBaseRequest::JsonObjectResult DiscogsCoverProvider::ParseJsonObject(QNetworkReply *reply) {

-  QByteArray data;
-
-  if (reply->error() == QNetworkReply::NoError && reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt() == 200) {
-    data = reply->readAll();
+  if (reply->error() != QNetworkReply::NoError && reply->error() < 200) {
+    return ReplyDataResult(ErrorCode::NetworkError, QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
  }
-  else {
-    if (reply->error() != QNetworkReply::NoError && reply->error() < 200) {
-      // This is a network error, there is nothing more to do.
-      QString error = QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
-      Error(error);
+
+  JsonObjectResult result(ErrorCode::Success);
+  result.network_error = reply->error();
+  if (reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).isValid()) {
+    result.http_status_code = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+  }
+
+  const QByteArray data = reply->readAll();
+  if (!data.isEmpty()) {
+    QJsonParseError json_parse_error;
+    const QJsonDocument json_document = QJsonDocument::fromJson(data, &json_parse_error);
+    if (json_parse_error.error == QJsonParseError::NoError) {
+      const QJsonObject json_object = json_document.object();
+      if (json_object.contains("message"_L1)) {
+        result.error_code = ErrorCode::APIError;
+        result.error_message = json_object["message"_L1].toString();
+      }
+      else {
+        result.json_object = json_document.object();
+      }
    }
    else {
-      // See if there is Json data containing "message" - then use that instead.
-      data = reply->readAll();
-      QString error;
-      QJsonParseError json_error;
-      QJsonDocument json_doc = QJsonDocument::fromJson(data, &json_error);
-      if (json_error.error == QJsonParseError::NoError && !json_doc.isEmpty() && json_doc.isObject()) {
-        QJsonObject json_obj = json_doc.object();
-        if (json_obj.contains("message"_L1)) {
-          error = json_obj["message"_L1].toString();
-        }
-      }
-      if (error.isEmpty()) {
-        if (reply->error() != QNetworkReply::NoError) {
-          error = QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
-        }
-        else {
-          error = QStringLiteral("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt());
-        }
-      }
-      Error(error);
+      result.error_code = ErrorCode::ParseError;
+      result.error_message = json_parse_error.errorString();
    }
-    return QByteArray();
  }

-  return data;
+  if (result.error_code != ErrorCode::APIError) {
+    if (reply->error() != QNetworkReply::NoError) {
+      result.error_code = ErrorCode::NetworkError;
+      result.error_message = QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
+    }
+    else if (result.http_status_code != 200) {
+      result.error_code = ErrorCode::HttpError;
+      result.error_message = QStringLiteral("Received HTTP code %1").arg(result.http_status_code);
+    }
+  }
+
+  return result;

 }

@@ -234,37 +240,34 @@ void DiscogsCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id)
  if (!requests_search_.contains(id)) return;
  SharedPtr<DiscogsCoverSearchContext> search = requests_search_.value(id);

-  QByteArray data = GetReplyData(reply);
-  if (data.isEmpty()) {
-    EndSearch(search);
+  const QScopeGuard end_search = qScopeGuard([this, search]() { EndSearch(search); });
+
+  const JsonObjectResult json_object_result = ParseJsonObject(reply);
+  if (!json_object_result.success()) {
+    Error(json_object_result.error_message);
    return;
  }

-  QJsonObject json_obj = ExtractJsonObj(data);
-  if (json_obj.isEmpty()) {
-    EndSearch(search);
+  const QJsonObject &json_object = json_object_result.json_object;
+  if (json_object.isEmpty()) {
    return;
  }

  QJsonValue value_results;
-  if (json_obj.contains("results"_L1)) {
-    value_results = json_obj["results"_L1];
+  if (json_object.contains("results"_L1)) {
+    value_results = json_object["results"_L1];
  }
-  else if (json_obj.contains("message"_L1)) {
-    QString message = json_obj["message"_L1].toString();
-    Error(QStringLiteral("%1").arg(message));
-    EndSearch(search);
+  else if (json_object.contains("message"_L1)) {
+    Error(json_object["message"_L1].toString());
    return;
  }
  else {
-    Error(u"Json object is missing results."_s, json_obj);
-    EndSearch(search);
+    Error(u"Json object is missing results."_s, json_object);
    return;
  }

  if (!value_results.isArray()) {
    Error(u"Missing results array."_s, value_results);
-    EndSearch(search);
    return;
  }

@@ -275,19 +278,19 @@ void DiscogsCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id)
      Error(u"Invalid Json reply, results value is not a object."_s);
      continue;
    }
-    QJsonObject obj_result = value_result.toObject();
-    if (!obj_result.contains("id"_L1) || !obj_result.contains("title"_L1) || !obj_result.contains("resource_url"_L1)) {
-      Error(QStringLiteral("Invalid Json reply, results value object is missing ID, title or resource_url."), obj_result);
+    const QJsonObject object_result = value_result.toObject();
+    if (!object_result.contains("id"_L1) || !object_result.contains("title"_L1) || !object_result.contains("resource_url"_L1)) {
+      Error(QStringLiteral("Invalid Json reply, results value object is missing ID, title or resource_url."), object_result);
      continue;
    }
-    quint64 release_id = obj_result["id"_L1].toInt();
-    QUrl resource_url(obj_result["resource_url"_L1].toString());
-    QString title = obj_result["title"_L1].toString();
+    const quint64 release_id = object_result["id"_L1].toInt();
+    const QUrl resource_url(object_result["resource_url"_L1].toString());
+    QString title = object_result["title"_L1].toString();

    if (title.contains(" - "_L1)) {
      QStringList title_splitted = title.split(u" - "_s);
      if (title_splitted.count() == 2) {
-        QString artist = title_splitted.first();
+        const QString artist = title_splitted.first();
        title = title_splitted.last();
        if (artist.compare(search->artist, Qt::CaseInsensitive) != 0 && title.compare(search->album, Qt::CaseInsensitive) != 0) continue;
      }
@@ -300,14 +303,9 @@ void DiscogsCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id)
    StartReleaseRequest(search, release_id, resource_url);
  }

-  if (search->requests_release_.count() == 0) {
-    if (search->type == DiscogsCoverType::Master) {
-      search->type = DiscogsCoverType::Release;
-      queue_search_requests_.enqueue(search);
-    }
-    else {
-      EndSearch(search);
-    }
+  if (search->requests_release_.count() == 0 && search->type == DiscogsCoverType::Master) {
+    search->type = DiscogsCoverType::Release;
+    queue_search_requests_.enqueue(search);
  }

 }
@@ -344,33 +342,31 @@ void DiscogsCoverProvider::HandleReleaseReply(QNetworkReply *reply, const int se
  if (!search->requests_release_.contains(release_id)) return;
  const DiscogsCoverReleaseContext &release = search->requests_release_.value(release_id);

-  QByteArray data = GetReplyData(reply);
-  if (data.isEmpty()) {
-    EndSearch(search, release.id);
+  const QScopeGuard end_search = qScopeGuard([this, search, release]() { EndSearch(search, release.id); });
+
+  const JsonObjectResult json_object_result = ParseJsonObject(reply);
+  if (!json_object_result.success()) {
+    Error(json_object_result.error_message);
    return;
  }

-  QJsonObject json_obj = ExtractJsonObj(data);
-  if (json_obj.isEmpty()) {
-    EndSearch(search, release.id);
+  const QJsonObject &json_object = json_object_result.json_object;
+  if (json_object.isEmpty()) {
    return;
  }

-  if (!json_obj.contains("artists"_L1) || !json_obj.contains("title"_L1)) {
-    Error(u"Json reply object is missing artists or title."_s, json_obj);
-    EndSearch(search, release.id);
+  if (!json_object.contains("artists"_L1) || !json_object.contains("title"_L1)) {
+    Error(u"Json reply object is missing artists or title."_s, json_object);
    return;
  }

-  if (!json_obj.contains("images"_L1)) {
-    EndSearch(search, release.id);
+  if (!json_object.contains("images"_L1)) {
    return;
  }

-  QJsonValue value_artists = json_obj["artists"_L1];
+  const QJsonValue value_artists = json_object["artists"_L1];
  if (!value_artists.isArray()) {
    Error(u"Json reply object artists is not a array."_s, value_artists);
-    EndSearch(search, release.id);
    return;
  }
  const QJsonArray array_artists = value_artists.toArray();
@@ -381,39 +377,35 @@ void DiscogsCoverProvider::HandleReleaseReply(QNetworkReply *reply, const int se
      Error(u"Invalid Json reply, atists array value is not a object."_s);
      continue;
    }
-    QJsonObject obj_artist = value_artist.toObject();
-    if (!obj_artist.contains("name"_L1)) {
-      Error(u"Invalid Json reply, artists array value object is missing name."_s, obj_artist);
+    const QJsonObject object_artist = value_artist.toObject();
+    if (!object_artist.contains("name"_L1)) {
+      Error(u"Invalid Json reply, artists array value object is missing name."_s, object_artist);
      continue;
    }
-    artist = obj_artist["name"_L1].toString();
+    artist = object_artist["name"_L1].toString();
    ++i;
    if (artist == search->artist) break;
  }

  if (artist.isEmpty()) {
-    EndSearch(search, release.id);
    return;
  }
  if (i > 1 && artist != search->artist) artist = "Various artists"_L1;

-  QString album = json_obj["title"_L1].toString();
+  const QString album = json_object["title"_L1].toString();
  if (artist != search->artist && album != search->album) {
-    EndSearch(search, release.id);
    return;
  }

-  QJsonValue value_images = json_obj["images"_L1];
+  const QJsonValue value_images = json_object["images"_L1];
  if (!value_images.isArray()) {
    Error(u"Json images is not an array."_s);
-    EndSearch(search, release.id);
    return;
  }
  const QJsonArray array_images = value_images.toArray();

  if (array_images.isEmpty()) {
    Error(u"Invalid Json reply, images array is empty."_s);
-    EndSearch(search, release.id);
    return;
  }

@@ -423,17 +415,17 @@ void DiscogsCoverProvider::HandleReleaseReply(QNetworkReply *reply, const int se
      Error(u"Invalid Json reply, images array value is not an object."_s);
      continue;
    }
-    QJsonObject obj_image = value_image.toObject();
+    const QJsonObject obj_image = value_image.toObject();
    if (!obj_image.contains("type"_L1) || !obj_image.contains("resource_url"_L1) || !obj_image.contains("width"_L1) || !obj_image.contains("height"_L1)) {
      Error(u"Invalid Json reply, images array value object is missing type, resource_url, width or height."_s, obj_image);
      continue;
    }
-    QString type = obj_image["type"_L1].toString();
+    const QString type = obj_image["type"_L1].toString();
    if (type != "primary"_L1) {
      continue;
    }
-    int width = obj_image["width"_L1].toInt();
-    int height = obj_image["height"_L1].toInt();
+    const int width = obj_image["width"_L1].toInt();
+    const int height = obj_image["height"_L1].toInt();
    if (width < 300 || height < 300) continue;
    const float aspect_score = static_cast<float>(1.0) - static_cast<float>(std::max(width, height) - std::min(width, height)) / static_cast<float>(std::max(height, width));
    if (aspect_score < 0.85) continue;
@@ -448,8 +440,6 @@ void DiscogsCoverProvider::HandleReleaseReply(QNetworkReply *reply, const int se
  Q_EMIT SearchResults(search->id, search->results);
  search->results.clear();

-  EndSearch(search, release.id);
-
 }

 void DiscogsCoverProvider::EndSearch(SharedPtr<DiscogsCoverSearchContext> search, const quint64 release_id) {
--- a/src/covermanager/discogscoverprovider.h
+++ b/src/covermanager/discogscoverprovider.h
@@ -2,7 +2,7 @@
 * Strawberry Music Player
 * This file was part of Clementine.
 * Copyright 2012, Martin Björklund <mbj4668@gmail.com>
- * Copyright 2016-2021, Jonas Kvinge <jonas@jkvinge.net>
+ * Copyright 2016-2025, 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
@@ -24,16 +24,11 @@

 #include "config.h"

-#include <QObject>
-#include <QMetaType>
-#include <QPair>
-#include <QList>
 #include <QQueue>
 #include <QMap>
 #include <QVariant>
 #include <QByteArray>
 #include <QString>
-#include <QJsonObject>

 #include "includes/shared_ptr.h"
 #include "jsoncoverprovider.h"
@@ -77,9 +72,9 @@ class DiscogsCoverProvider : public JsonCoverProvider {
 private:
  void SendSearchRequest(SharedPtr<DiscogsCoverSearchContext> search);
  void SendReleaseRequest(const DiscogsCoverReleaseContext &release);
-  QNetworkReply *CreateRequest(QUrl url, const ParamList &params_provided = ParamList());
-  QByteArray GetReplyData(QNetworkReply *reply);
+  QNetworkReply *CreateRequest(const QUrl &url, const ParamList &params = ParamList());
  void StartReleaseRequest(SharedPtr<DiscogsCoverSearchContext> search, const quint64 release_id, const QUrl &url);
+  JsonObjectResult ParseJsonObject(QNetworkReply *reply);
  void EndSearch(SharedPtr<DiscogsCoverSearchContext> search, const quint64 release_id = 0);
  void Error(const QString &error, const QVariant &debug = QVariant()) override;

@@ -93,7 +88,6 @@ class DiscogsCoverProvider : public JsonCoverProvider {
  QQueue<SharedPtr<DiscogsCoverSearchContext>> queue_search_requests_;
  QQueue<DiscogsCoverReleaseContext> queue_release_requests_;
  QMap<int, SharedPtr<DiscogsCoverSearchContext>> requests_search_;
-  QList<QNetworkReply*> replies_;
 };

 Q_DECLARE_METATYPE(DiscogsCoverProvider::DiscogsCoverSearchContext)
--- a/src/covermanager/jsoncoverprovider.cpp
+++ b/src/covermanager/jsoncoverprovider.cpp
@@ -1,6 +1,6 @@
 /*
 * Strawberry Music Player
- * Copyright 2018-2021, Jonas Kvinge <jonas@jkvinge.net>
+ * Copyright 2018-2025, 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
@@ -19,10 +19,10 @@

 #include "config.h"

-#include <QObject>
 #include <QByteArray>
 #include <QString>
 #include <QJsonDocument>
+#include <QJsonParseError>
 #include <QJsonObject>

 #include "includes/shared_ptr.h"
@@ -35,32 +35,31 @@ using namespace Qt::Literals::StringLiterals;
 JsonCoverProvider::JsonCoverProvider(const QString &name, const bool enabled, const bool authentication_required, const float quality, const bool batch, const bool allow_missing_album, const SharedPtr<NetworkAccessManager> network, QObject *parent)
    : CoverProvider(name, enabled, authentication_required, quality, batch, allow_missing_album, network, parent) {}

-QJsonObject JsonCoverProvider::ExtractJsonObj(const QByteArray &data) {
+QJsonObject JsonCoverProvider::ExtractJsonObject(const QByteArray &data) {

  QJsonParseError json_error;
-  QJsonDocument json_doc = QJsonDocument::fromJson(data, &json_error);
-
+  const QJsonDocument json_document = QJsonDocument::fromJson(data, &json_error);
  if (json_error.error != QJsonParseError::NoError) {
-    Error(QStringLiteral("Failed to parse json data: %1").arg(json_error.errorString()));
+    Error(QStringLiteral("Failed to parse Json data: %1").arg(json_error.errorString()));
    return QJsonObject();
  }

-  if (json_doc.isEmpty()) {
+  if (json_document.isEmpty()) {
    Error(u"Received empty Json document."_s, data);
    return QJsonObject();
  }

-  if (!json_doc.isObject()) {
-    Error(u"Json document is not an object."_s, json_doc);
+  if (!json_document.isObject()) {
+    Error(u"Json document is not an object."_s, json_document);
    return QJsonObject();
  }

-  QJsonObject json_obj = json_doc.object();
-  if (json_obj.isEmpty()) {
-    Error(u"Received empty Json object."_s, json_doc);
+  const QJsonObject json_object = json_document.object();
+  if (json_object.isEmpty()) {
+    Error(u"Received empty Json object."_s, json_document);
    return QJsonObject();
  }

-  return json_obj;
+  return json_object;

 }
--- a/src/covermanager/jsoncoverprovider.h
+++ b/src/covermanager/jsoncoverprovider.h
@@ -1,6 +1,6 @@
 /*
 * Strawberry Music Player
- * Copyright 2018-2021, Jonas Kvinge <jonas@jkvinge.net>
+ * Copyright 2018-2025, 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
@@ -22,7 +22,6 @@

 #include "config.h"

-#include <QObject>
 #include <QByteArray>
 #include <QString>
 #include <QJsonObject>
@@ -39,7 +38,7 @@ class JsonCoverProvider : public CoverProvider {
  explicit JsonCoverProvider(const QString &name, const bool enabled, const bool authentication_required, const float quality, const bool batch, const bool allow_missing_album, const SharedPtr<NetworkAccessManager> network, QObject *parent);

 protected:
-  QJsonObject ExtractJsonObj(const QByteArray &data);
+  QJsonObject ExtractJsonObject(const QByteArray &data);
 };

 #endif  // JSONCOVERPROVIDER_H
--- a/src/covermanager/lastfmcoverprovider.cpp
+++ b/src/covermanager/lastfmcoverprovider.cpp
@@ -1,6 +1,6 @@
 /*
 * Strawberry Music Player
- * Copyright 2018-2021, Jonas Kvinge <jonas@jkvinge.net>
+ * Copyright 2018-2025, 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
@@ -22,10 +22,7 @@
 #include <algorithm>
 #include <utility>

-#include <QObject>
 #include <QLocale>
-#include <QList>
-#include <QPair>
 #include <QByteArray>
 #include <QString>
 #include <QUrl>
@@ -37,6 +34,7 @@
 #include <QJsonValue>
 #include <QJsonObject>
 #include <QJsonArray>
+#include <QScopeGuard>

 #include "includes/shared_ptr.h"
 #include "core/networkaccessmanager.h"
@@ -57,17 +55,6 @@ constexpr char kSecret[] = "80fd738f49596e9709b1bf9319c444a8";
 LastFmCoverProvider::LastFmCoverProvider(const SharedPtr<NetworkAccessManager> network, QObject *parent)
    : JsonCoverProvider(u"Last.fm"_s, true, false, 1.0, true, false, network, parent) {}

-LastFmCoverProvider::~LastFmCoverProvider() {
-
-  while (!replies_.isEmpty()) {
-    QNetworkReply *reply = replies_.takeFirst();
-    QObject::disconnect(reply, nullptr, this, nullptr);
-    reply->abort();
-    reply->deleteLater();
-  }
-
-}
-
 bool LastFmCoverProvider::StartSearch(const QString &artist, const QString &album, const QString &title, const int id) {

  if (artist.isEmpty() && album.isEmpty() && title.isEmpty()) return false;
@@ -111,18 +98,62 @@ bool LastFmCoverProvider::StartSearch(const QString &artist, const QString &albu
  url_query.addQueryItem(QString::fromLatin1(QUrl::toPercentEncoding(u"api_sig"_s)), QString::fromLatin1(QUrl::toPercentEncoding(signature)));
  url_query.addQueryItem(QString::fromLatin1(QUrl::toPercentEncoding(u"format"_s)), QString::fromLatin1(QUrl::toPercentEncoding(u"json"_s)));

-  QUrl url(QString::fromLatin1(kUrl));
-  QNetworkRequest req(url);
-  req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
-  req.setHeader(QNetworkRequest::ContentTypeHeader, u"application/x-www-form-urlencoded"_s);
-  QNetworkReply *reply = network_->post(req, url_query.toString(QUrl::FullyEncoded).toUtf8());
-  replies_ << reply;
+  QNetworkReply *reply = CreatePostRequest(QUrl(QLatin1String(kUrl)), url_query);
  QObject::connect(reply, &QNetworkReply::finished, this, [this, reply, id, type]() { QueryFinished(reply, id, type); });

  return true;

 }

+JsonBaseRequest::JsonObjectResult LastFmCoverProvider::ParseJsonObject(QNetworkReply *reply) {
+
+  if (reply->error() != QNetworkReply::NoError && reply->error() < 200) {
+    return ReplyDataResult(ErrorCode::NetworkError, QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
+  }
+
+  JsonObjectResult result(ErrorCode::Success);
+  result.network_error = reply->error();
+  if (reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).isValid()) {
+    result.http_status_code = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+  }
+
+  const QByteArray data = reply->readAll();
+  if (!data.isEmpty()) {
+    QJsonParseError json_parse_error;
+    const QJsonDocument json_document = QJsonDocument::fromJson(data, &json_parse_error);
+    if (json_parse_error.error == QJsonParseError::NoError) {
+      const QJsonObject json_object = json_document.object();
+      if (json_object.contains("error"_L1) && json_object.contains("message"_L1)) {
+        const int error = json_object["error"_L1].toInt();
+        const QString message = json_object["message"_L1].toString();
+        result.error_code = ErrorCode::APIError;
+        result.error_message = QStringLiteral("%1 (%2)").arg(message).arg(error);
+      }
+      else {
+        result.json_object = json_document.object();
+      }
+    }
+    else {
+      result.error_code = ErrorCode::ParseError;
+      result.error_message = json_parse_error.errorString();
+    }
+  }
+
+  if (result.error_code != ErrorCode::APIError) {
+    if (reply->error() != QNetworkReply::NoError) {
+      result.error_code = ErrorCode::NetworkError;
+      result.error_message = QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
+    }
+    else if (result.http_status_code != 200) {
+      result.error_code = ErrorCode::HttpError;
+      result.error_message = QStringLiteral("Received HTTP code %1").arg(result.http_status_code);
+    }
+  }
+
+  return result;
+
+}
+
 void LastFmCoverProvider::QueryFinished(QNetworkReply *reply, const int id, const QString &type) {

  if (!replies_.contains(reply)) return;
@@ -131,96 +162,85 @@ void LastFmCoverProvider::QueryFinished(QNetworkReply *reply, const int id, cons
  reply->deleteLater();

  CoverProviderSearchResults results;
+  const QScopeGuard end_search = qScopeGuard([this, id, &results]() { Q_EMIT SearchFinished(id, results); });

-  QByteArray data = GetReplyData(reply);
-  if (data.isEmpty()) {
-    Q_EMIT SearchFinished(id, results);
+  const JsonObjectResult json_object_result = ParseJsonObject(reply);
+  if (!json_object_result.success()) {
+    Error(json_object_result.error_message);
    return;
  }

-  QJsonObject json_obj = ExtractJsonObj(data);
-  if (json_obj.isEmpty()) {
-    Q_EMIT SearchFinished(id, results);
+  const QJsonObject &json_object = json_object_result.json_object;
+  if (json_object.isEmpty()) {
    return;
  }

  QJsonValue value_results;
-  if (json_obj.contains("results"_L1)) {
-    value_results = json_obj["results"_L1];
+  if (json_object.contains("results"_L1)) {
+    value_results = json_object["results"_L1];
  }
-  else if (json_obj.contains("error"_L1) && json_obj.contains("message"_L1)) {
-    int error = json_obj["error"_L1].toInt();
-    QString message = json_obj["message"_L1].toString();
+  else if (json_object.contains("error"_L1) && json_object.contains("message"_L1)) {
+    const int error = json_object["error"_L1].toInt();
+    const QString message = json_object["message"_L1].toString();
    Error(QStringLiteral("Error: %1: %2").arg(QString::number(error), message));
-    Q_EMIT SearchFinished(id, results);
    return;
  }
  else {
-    Error(u"Json reply is missing results."_s, json_obj);
-    Q_EMIT SearchFinished(id, results);
+    Error(u"Json reply is missing results."_s, json_object);
    return;
  }

  if (!value_results.isObject()) {
    Error(u"Json results is not a object."_s, value_results);
-    Q_EMIT SearchFinished(id, results);
    return;
  }

-  QJsonObject obj_results = value_results.toObject();
-  if (obj_results.isEmpty()) {
+  const QJsonObject object_results = value_results.toObject();
+  if (object_results.isEmpty()) {
    Error(u"Json results object is empty."_s, value_results);
-    Q_EMIT SearchFinished(id, results);
    return;
  }

  QJsonValue value_matches;

  if (type == "album"_L1) {
-    if (obj_results.contains("albummatches"_L1)) {
-      value_matches = obj_results["albummatches"_L1];
+    if (object_results.contains("albummatches"_L1)) {
+      value_matches = object_results["albummatches"_L1];
    }
    else {
-      Error(u"Json results object is missing albummatches."_s, obj_results);
-      Q_EMIT SearchFinished(id, results);
+      Error(u"Json results object is missing albummatches."_s, object_results);
      return;
    }
  }
  else if (type == "track"_L1) {
-    if (obj_results.contains("trackmatches"_L1)) {
-      value_matches = obj_results["trackmatches"_L1];
+    if (object_results.contains("trackmatches"_L1)) {
+      value_matches = object_results["trackmatches"_L1];
    }
    else {
-      Error(u"Json results object is missing trackmatches."_s, obj_results);
-      Q_EMIT SearchFinished(id, results);
+      Error(u"Json results object is missing trackmatches."_s, object_results);
      return;
    }
  }

  if (!value_matches.isObject()) {
    Error(u"Json albummatches or trackmatches is not an object."_s, value_matches);
-    Q_EMIT SearchFinished(id, results);
    return;
  }

-  QJsonObject obj_matches = value_matches.toObject();
-  if (obj_matches.isEmpty()) {
+  const QJsonObject object_matches = value_matches.toObject();
+  if (object_matches.isEmpty()) {
    Error(u"Json albummatches or trackmatches object is empty."_s, value_matches);
-    Q_EMIT SearchFinished(id, results);
    return;
  }

-  QJsonValue value_type;
-  if (!obj_matches.contains(type)) {
-    Error(QStringLiteral("Json object is missing %1.").arg(type), obj_matches);
-    Q_EMIT SearchFinished(id, results);
+  if (!object_matches.contains(type)) {
+    Error(QStringLiteral("Json object is missing %1.").arg(type), object_matches);
    return;
  }
-  value_type = obj_matches[type];
+  const QJsonValue value_type = object_matches[type];

  if (!value_type.isArray()) {
    Error(u"Json album value in albummatches object is not an array."_s, value_type);
-    Q_EMIT SearchFinished(id, results);
    return;
  }
  const QJsonArray array_type = value_type.toArray();
@@ -231,23 +251,22 @@ void LastFmCoverProvider::QueryFinished(QNetworkReply *reply, const int id, cons
      Error(u"Invalid Json reply, value in albummatches/trackmatches array is not a object."_s);
      continue;
    }
-    QJsonObject obj = value.toObject();
-    if (!obj.contains("artist"_L1) || !obj.contains("image"_L1) || !obj.contains("name"_L1)) {
-      Error(u"Invalid Json reply, album is missing artist, image or name."_s, obj);
+    const QJsonObject object = value.toObject();
+    if (!object.contains("artist"_L1) || !object.contains("image"_L1) || !object.contains("name"_L1)) {
+      Error(u"Invalid Json reply, album is missing artist, image or name."_s, object);
      continue;
    }
-    QString artist = obj["artist"_L1].toString();
+    const QString artist = object["artist"_L1].toString();
    QString album;
    if (type == "album"_L1) {
-      album = obj["name"_L1].toString();
+      album = object["name"_L1].toString();
    }

-    QJsonValue json_image = obj["image"_L1];
-    if (!json_image.isArray()) {
-      Error(u"Invalid Json reply, album image is not a array."_s, json_image);
+    if (!object.contains("image"_L1) || !object["image"_L1].isArray()) {
+      Error(u"Invalid Json reply, album image is not a array."_s, object);
      continue;
    }
-    const QJsonArray array_image = json_image.toArray();
+    const QJsonArray array_image = object["image"_L1].toArray();
    QString image_url_use;
    LastFmImageSize image_size_use = LastFmImageSize::Unknown;
    for (const QJsonValue &value_image : array_image) {
@@ -255,14 +274,14 @@ void LastFmCoverProvider::QueryFinished(QNetworkReply *reply, const int id, cons
        Error(u"Invalid Json reply, album image value is not an object."_s);
        continue;
      }
-      QJsonObject obj_image = value_image.toObject();
-      if (!obj_image.contains("#text"_L1) || !obj_image.contains("size"_L1)) {
-        Error(u"Invalid Json reply, album image value is missing #text or size."_s, obj_image);
+      const QJsonObject object_image = value_image.toObject();
+      if (!object_image.contains("#text"_L1) || !object_image.contains("size"_L1)) {
+        Error(u"Invalid Json reply, album image value is missing #text or size."_s, object_image);
        continue;
      }
-      QString image_url = obj_image["#text"_L1].toString();
+      const QString image_url = object_image["#text"_L1].toString();
      if (image_url.isEmpty()) continue;
-      LastFmImageSize image_size = ImageSizeFromString(obj_image["size"_L1].toString().toLower());
+      const LastFmImageSize image_size = ImageSizeFromString(object_image["size"_L1].toString().toLower());
      if (image_url_use.isEmpty() || image_size > image_size_use) {
        image_url_use = image_url;
        image_size_use = image_size;
@@ -275,7 +294,7 @@ void LastFmCoverProvider::QueryFinished(QNetworkReply *reply, const int id, cons
    if (image_url_use.contains("/300x300/"_L1)) {
      image_url_use = image_url_use.replace("/300x300/"_L1, "/740x0/"_L1);
    }
-    QUrl url(image_url_use);
+    const QUrl url(image_url_use);
    if (!url.isValid()) continue;

    CoverProviderSearchResult cover_result;
@@ -285,50 +304,6 @@ void LastFmCoverProvider::QueryFinished(QNetworkReply *reply, const int id, cons
    cover_result.image_size = QSize(300, 300);
    results << cover_result;
  }
-  Q_EMIT SearchFinished(id, results);
-
-}
-
-QByteArray LastFmCoverProvider::GetReplyData(QNetworkReply *reply) {
-
-  QByteArray data;
-
-  if (reply->error() == QNetworkReply::NoError && reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt() == 200) {
-    data = reply->readAll();
-  }
-  else {
-    if (reply->error() != QNetworkReply::NoError && reply->error() < 200) {
-      // This is a network error, there is nothing more to do.
-      Error(QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
-    }
-    else {
-      // See if there is Json data containing "error" and "message" - then use that instead.
-      data = reply->readAll();
-      QString error;
-      QJsonParseError json_error;
-      QJsonDocument json_doc = QJsonDocument::fromJson(data, &json_error);
-      if (json_error.error == QJsonParseError::NoError && !json_doc.isEmpty() && json_doc.isObject()) {
-        QJsonObject json_obj = json_doc.object();
-        if (json_obj.contains("error"_L1) && json_obj.contains("message"_L1)) {
-          int code = json_obj["error"_L1].toInt();
-          QString message = json_obj["message"_L1].toString();
-          error = "Error: "_L1 + QString::number(code) + ": "_L1 + message;
-        }
-      }
-      if (error.isEmpty()) {
-        if (reply->error() != QNetworkReply::NoError) {
-          error = QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
-        }
-        else {
-          error = QStringLiteral("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt());
-        }
-      }
-      Error(error);
-    }
-    return QByteArray();
-  }
-
-  return data;

 }

--- a/src/covermanager/lastfmcoverprovider.h
+++ b/src/covermanager/lastfmcoverprovider.h
@@ -1,6 +1,6 @@
 /*
 * Strawberry Music Player
- * Copyright 2018-2021, Jonas Kvinge <jonas@jkvinge.net>
+ * Copyright 2018-2025, 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
@@ -22,12 +22,8 @@

 #include "config.h"

-#include <QObject>
-#include <QList>
 #include <QVariant>
-#include <QByteArray>
 #include <QString>
-#include <QJsonObject>

 #include "includes/shared_ptr.h"
 #include "jsoncoverprovider.h"
@@ -40,13 +36,17 @@ class LastFmCoverProvider : public JsonCoverProvider {

 public:
  explicit LastFmCoverProvider(const SharedPtr<NetworkAccessManager> network, QObject *parent = nullptr);
-  ~LastFmCoverProvider() override;
+
+  bool authentication_required() const override { return true; }

  bool StartSearch(const QString &artist, const QString &album, const QString &title, const int id) override;

 private Q_SLOTS:
  void QueryFinished(QNetworkReply *reply, const int id, const QString &type);

+ protected:
+  JsonObjectResult ParseJsonObject(QNetworkReply *reply);
+
 private:
  enum class LastFmImageSize {
    Unknown,
@@ -56,12 +56,8 @@ class LastFmCoverProvider : public JsonCoverProvider {
    ExtraLarge = 300
  };

-  QByteArray GetReplyData(QNetworkReply *reply);
  static LastFmImageSize ImageSizeFromString(const QString &size);
  void Error(const QString &error, const QVariant &debug = QVariant()) override;
-
- private:
-  QList<QNetworkReply*> replies_;
 };

 #endif  // LASTFMCOVERPROVIDER_H
--- a/src/covermanager/musicbrainzcoverprovider.cpp
+++ b/src/covermanager/musicbrainzcoverprovider.cpp
@@ -1,6 +1,6 @@
 /*
 * Strawberry Music Player
- * Copyright 2018-2021, Jonas Kvinge <jonas@jkvinge.net>
+ * Copyright 2018-2025, 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
@@ -19,22 +19,18 @@

 #include "config.h"

-#include <algorithm>
-
-#include <QtGlobal>
-#include <QObject>
 #include <QVariant>
 #include <QByteArray>
 #include <QString>
 #include <QUrl>
 #include <QUrlQuery>
 #include <QTimer>
-#include <QNetworkRequest>
 #include <QNetworkReply>
 #include <QJsonDocument>
 #include <QJsonValue>
 #include <QJsonObject>
 #include <QJsonArray>
+#include <QScopeGuard>

 #include "includes/shared_ptr.h"
 #include "core/networkaccessmanager.h"
@@ -62,17 +58,6 @@ MusicbrainzCoverProvider::MusicbrainzCoverProvider(const SharedPtr<NetworkAccess

 }

-MusicbrainzCoverProvider::~MusicbrainzCoverProvider() {
-
-  while (!replies_.isEmpty()) {
-    QNetworkReply *reply = replies_.takeFirst();
-    QObject::disconnect(reply, nullptr, this, nullptr);
-    reply->abort();
-    reply->deleteLater();
-  }
-
-}
-
 bool MusicbrainzCoverProvider::StartSearch(const QString &artist, const QString &album, const QString &title, const int id) {

  Q_UNUSED(title);
@@ -92,19 +77,12 @@ bool MusicbrainzCoverProvider::StartSearch(const QString &artist, const QString

 void MusicbrainzCoverProvider::SendSearchRequest(const SearchRequest &request) {

-  QString query = QStringLiteral("release:\"%1\" AND artist:\"%2\"").arg(request.album.trimmed().replace(u'"', "\""_L1), request.artist.trimmed().replace(u'"', "\""_L1));
-
+  const QString query = QStringLiteral("release:\"%1\" AND artist:\"%2\"").arg(request.album.trimmed().replace(u'"', "\""_L1), request.artist.trimmed().replace(u'"', "\""_L1));
  QUrlQuery url_query;
  url_query.addQueryItem(u"query"_s, query);
  url_query.addQueryItem(u"limit"_s, QString::number(kLimit));
  url_query.addQueryItem(u"fmt"_s, u"json"_s);
-
-  QUrl url(QString::fromLatin1(kReleaseSearchUrl));
-  url.setQuery(url_query);
-  QNetworkRequest req(url);
-  req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
-  QNetworkReply *reply = network_->get(req);
-  replies_ << reply;
+  QNetworkReply *reply = CreateGetRequest(QUrl(QLatin1String(kReleaseSearchUrl)), url_query);
  QObject::connect(reply, &QNetworkReply::finished, this, [this, reply, request]() { HandleSearchReply(reply, request.id); });

 }
@@ -120,6 +98,55 @@ void MusicbrainzCoverProvider::FlushRequests() {

 }

+JsonBaseRequest::JsonObjectResult MusicbrainzCoverProvider::ParseJsonObject(QNetworkReply *reply) {
+
+  if (reply->error() != QNetworkReply::NoError && reply->error() < 200) {
+    return ReplyDataResult(ErrorCode::NetworkError, QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
+  }
+
+  JsonObjectResult result(ErrorCode::Success);
+  result.network_error = reply->error();
+  if (reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).isValid()) {
+    result.http_status_code = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+  }
+
+  const QByteArray data = reply->readAll();
+  if (!data.isEmpty()) {
+    QJsonParseError json_parse_error;
+    const QJsonDocument json_document = QJsonDocument::fromJson(data, &json_parse_error);
+    if (json_parse_error.error == QJsonParseError::NoError) {
+      const QJsonObject json_object = json_document.object();
+      if (json_object.contains("error"_L1) && json_object.contains("help"_L1)) {
+        const QString error = json_object["error"_L1].toString();
+        const QString help = json_object["help"_L1].toString();
+        result.error_code = ErrorCode::APIError;
+        result.error_message = QStringLiteral("%1 (%2)").arg(error, help);
+      }
+      else {
+        result.json_object = json_document.object();
+      }
+    }
+    else {
+      result.error_code = ErrorCode::ParseError;
+      result.error_message = json_parse_error.errorString();
+    }
+  }
+
+  if (result.error_code != ErrorCode::APIError) {
+    if (reply->error() != QNetworkReply::NoError) {
+      result.error_code = ErrorCode::NetworkError;
+      result.error_message = QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
+    }
+    else if (result.http_status_code != 200) {
+      result.error_code = ErrorCode::HttpError;
+      result.error_message = QStringLiteral("Received HTTP code %1").arg(result.http_status_code);
+    }
+  }
+
+  return result;
+
+}
+
 void MusicbrainzCoverProvider::HandleSearchReply(QNetworkReply *reply, const int search_id) {

  if (!replies_.contains(reply)) return;
@@ -128,41 +155,33 @@ void MusicbrainzCoverProvider::HandleSearchReply(QNetworkReply *reply, const int
  reply->deleteLater();

  CoverProviderSearchResults results;
+  const QScopeGuard search_finished = qScopeGuard([this, search_id, &results]() { Q_EMIT SearchFinished(search_id, results); });

-  QByteArray data = GetReplyData(reply);
-  if (data.isEmpty()) {
-    Q_EMIT SearchFinished(search_id, results);
+  const JsonObjectResult json_object_result = ParseJsonObject(reply);
+  if (!json_object_result.success()) {
+    Error(json_object_result.error_message);
    return;
  }

-  QJsonObject json_obj = ExtractJsonObj(data);
-  if (json_obj.isEmpty()) {
-    Q_EMIT SearchFinished(search_id, results);
+  const QJsonObject &json_object = json_object_result.json_object;
+  if (json_object.isEmpty()) {
    return;
  }

-  if (!json_obj.contains("releases"_L1)) {
-    if (json_obj.contains("error"_L1)) {
-      QString error = json_obj["error"_L1].toString();
-      Error(error);
-    }
-    else {
-      Error(u"Json reply is missing releases."_s, json_obj);
-    }
-    Q_EMIT SearchFinished(search_id, results);
+  if (!json_object.contains("releases"_L1)) {
+    Error(u"Json reply is missing releases."_s, json_object);
    return;
  }
-  QJsonValue value_releases = json_obj["releases"_L1];
+
+  const QJsonValue value_releases = json_object["releases"_L1];

  if (!value_releases.isArray()) {
    Error(u"Json releases is not an array."_s, value_releases);
-    Q_EMIT SearchFinished(search_id, results);
    return;
  }
  const QJsonArray array_releases = value_releases.toArray();

  if (array_releases.isEmpty()) {
-    Q_EMIT SearchFinished(search_id, results);
    return;
  }

@@ -172,18 +191,18 @@ void MusicbrainzCoverProvider::HandleSearchReply(QNetworkReply *reply, const int
      Error(u"Invalid Json reply, releases array value is not an object."_s);
      continue;
    }
-    QJsonObject obj_release = value_release.toObject();
-    if (!obj_release.contains("id"_L1) || !obj_release.contains("artist-credit"_L1) || !obj_release.contains("title"_L1)) {
-      Error(u"Invalid Json reply, releases array object is missing id, artist-credit or title."_s, obj_release);
+    const QJsonObject object_release = value_release.toObject();
+    if (!object_release.contains("id"_L1) || !object_release.contains("artist-credit"_L1) || !object_release.contains("title"_L1)) {
+      Error(u"Invalid Json reply, releases array object is missing id, artist-credit or title."_s, object_release);
      continue;
    }

-    QJsonValue json_artists = obj_release["artist-credit"_L1];
-    if (!json_artists.isArray()) {
-      Error(u"Invalid Json reply, artist-credit is not a array."_s, json_artists);
+    const QJsonValue value_artists = object_release["artist-credit"_L1];
+    if (!value_artists.isArray()) {
+      Error(u"Invalid Json reply, artist-credit is not a array."_s, value_artists);
      continue;
    }
-    const QJsonArray array_artists = json_artists.toArray();
+    const QJsonArray array_artists = value_artists.toArray();
    int i = 0;
    QString artist;
    for (const QJsonValue &value_artist : array_artists) {
@@ -191,18 +210,18 @@ void MusicbrainzCoverProvider::HandleSearchReply(QNetworkReply *reply, const int
        Error(u"Invalid Json reply, artist is not a object."_s);
        continue;
      }
-      QJsonObject obj_artist = value_artist.toObject();
+      const QJsonObject object_artist = value_artist.toObject();

-      if (!obj_artist.contains("artist"_L1)) {
-        Error(u"Invalid Json reply, artist is missing."_s, obj_artist);
+      if (!object_artist.contains("artist"_L1)) {
+        Error(u"Invalid Json reply, artist is missing."_s, object_artist);
        continue;
      }
-      QJsonValue value_artist2 = obj_artist["artist"_L1];
+      const QJsonValue value_artist2 = object_artist["artist"_L1];
      if (!value_artist2.isObject()) {
        Error(u"Invalid Json reply, artist is not an object."_s, value_artist2);
        continue;
      }
-      QJsonObject obj_artist2 = value_artist2.toObject();
+      const QJsonObject obj_artist2 = value_artist2.toObject();

      if (!obj_artist2.contains("name"_L1)) {
        Error(u"Invalid Json reply, artist is missing name."_s, value_artist2);
@@ -213,59 +232,16 @@ void MusicbrainzCoverProvider::HandleSearchReply(QNetworkReply *reply, const int
    }
    if (i > 1) artist = "Various artists"_L1;

-    QString id = obj_release["id"_L1].toString();
-    QString album = obj_release["title"_L1].toString();
+    const QString id = object_release["id"_L1].toString();
+    const QString album = object_release["title"_L1].toString();

    CoverProviderSearchResult cover_result;
-    QUrl url(QString::fromLatin1(kAlbumCoverUrl).arg(id));
+    const QUrl url(QString::fromLatin1(kAlbumCoverUrl).arg(id));
    cover_result.artist = artist;
    cover_result.album = album;
    cover_result.image_url = url;
    results.append(cover_result);
  }
-  Q_EMIT SearchFinished(search_id, results);
-
-}
-
-QByteArray MusicbrainzCoverProvider::GetReplyData(QNetworkReply *reply) {
-
-  QByteArray data;
-
-  if (reply->error() == QNetworkReply::NoError && reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt() == 200) {
-    data = reply->readAll();
-  }
-  else {
-    if (reply->error() != QNetworkReply::NoError && reply->error() < 200) {
-      // This is a network error, there is nothing more to do.
-      QString failure_reason = QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
-      Error(failure_reason);
-    }
-    else {
-      // See if there is Json data containing "error" - then use that instead.
-      data = reply->readAll();
-      QString error;
-      QJsonParseError json_error;
-      QJsonDocument json_doc = QJsonDocument::fromJson(data, &json_error);
-      if (json_error.error == QJsonParseError::NoError && !json_doc.isEmpty() && json_doc.isObject()) {
-        QJsonObject json_obj = json_doc.object();
-        if (json_obj.contains("error"_L1)) {
-          error = json_obj["error"_L1].toString();
-        }
-      }
-      if (error.isEmpty()) {
-        if (reply->error() != QNetworkReply::NoError) {
-          error = QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
-        }
-        else {
-          error = QStringLiteral("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt());
-        }
-      }
-      Error(error);
-    }
-    return QByteArray();
-  }
-
-  return data;

 }

--- a/src/covermanager/musicbrainzcoverprovider.h
+++ b/src/covermanager/musicbrainzcoverprovider.h
@@ -1,6 +1,6 @@
 /*
 * Strawberry Music Player
- * Copyright 2018-2021, Jonas Kvinge <jonas@jkvinge.net>
+ * Copyright 2018-2025, 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
@@ -22,13 +22,9 @@

 #include "config.h"

-#include <QObject>
-#include <QList>
 #include <QQueue>
-#include <QByteArray>
 #include <QVariant>
 #include <QString>
-#include <QJsonObject>

 #include "includes/shared_ptr.h"
 #include "jsoncoverprovider.h"
@@ -42,7 +38,6 @@ class MusicbrainzCoverProvider : public JsonCoverProvider {

 public:
  explicit MusicbrainzCoverProvider(const SharedPtr<NetworkAccessManager> network, QObject *parent = nullptr);
-  ~MusicbrainzCoverProvider() override;

  bool StartSearch(const QString &artist, const QString &album, const QString &title, const int id) override;

@@ -59,13 +54,12 @@ class MusicbrainzCoverProvider : public JsonCoverProvider {
  };

  void SendSearchRequest(const SearchRequest &request);
-  QByteArray GetReplyData(QNetworkReply *reply);
+  JsonObjectResult ParseJsonObject(QNetworkReply *reply);
  void Error(const QString &error, const QVariant &debug = QVariant()) override;

 private:
  QTimer *timer_flush_requests_;
  QQueue<SearchRequest> queue_search_requests_;
-  QList<QNetworkReply*> replies_;
 };

 #endif  // MUSICBRAINZCOVERPROVIDER_H
--- a/src/covermanager/musixmatchcoverprovider.cpp
+++ b/src/covermanager/musixmatchcoverprovider.cpp
@@ -1,6 +1,6 @@
 /*
 * Strawberry Music Player
- * Copyright 2020-2021, Jonas Kvinge <jonas@jkvinge.net>
+ * Copyright 2020-2025, 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
@@ -19,20 +19,20 @@

 #include "config.h"

-#include <QObject>
 #include <QByteArray>
 #include <QVariant>
 #include <QString>
 #include <QUrl>
 #include <QUrlQuery>
 #include <QRegularExpression>
-#include <QNetworkRequest>
 #include <QNetworkReply>
 #include <QJsonDocument>
 #include <QJsonParseError>
 #include <QJsonObject>
+#include <QScopeGuard>

 #include "includes/shared_ptr.h"
+#include "utilities/musixmatchprovider.h"
 #include "core/logging.h"
 #include "core/networkaccessmanager.h"
 #include "albumcoverfetcher.h"
@@ -40,37 +40,23 @@
 #include "musixmatchcoverprovider.h"

 using namespace Qt::Literals::StringLiterals;
+using namespace MusixmatchProvider;

 MusixmatchCoverProvider::MusixmatchCoverProvider(const SharedPtr<NetworkAccessManager> network, QObject *parent)
    : JsonCoverProvider(u"Musixmatch"_s, true, false, 1.0, true, false, network, parent) {}

-MusixmatchCoverProvider::~MusixmatchCoverProvider() {
-
-  while (!replies_.isEmpty()) {
-    QNetworkReply *reply = replies_.takeFirst();
-    QObject::disconnect(reply, nullptr, this, nullptr);
-    reply->abort();
-    reply->deleteLater();
-  }
-
-}
-
 bool MusixmatchCoverProvider::StartSearch(const QString &artist, const QString &album, const QString &title, const int id) {

  Q_UNUSED(title);

  if (artist.isEmpty() || album.isEmpty()) return false;

-  QString artist_stripped = StringFixup(artist);
-  QString album_stripped = StringFixup(album);
+  const QString artist_stripped = StringFixup(artist);
+  const QString album_stripped = StringFixup(album);

  if (artist_stripped.isEmpty() || album_stripped.isEmpty()) return false;

-  QUrl url(QStringLiteral("https://www.musixmatch.com/album/%1/%2").arg(artist_stripped, album_stripped));
-  QNetworkRequest req(url);
-  req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
-  QNetworkReply *reply = network_->get(req);
-  replies_ << reply;
+  QNetworkReply *reply = CreateGetRequest(QUrl(QStringLiteral("https://www.musixmatch.com/album/%1/%2").arg(artist_stripped, album_stripped)));
  QObject::connect(reply, &QNetworkReply::finished, this, [this, reply, id, artist, album]() { HandleSearchReply(reply, id, artist, album); });

  //qLog(Debug) << "Musixmatch: Sending request for" << artist_stripped << album_stripped << url;
@@ -89,29 +75,19 @@ void MusixmatchCoverProvider::HandleSearchReply(QNetworkReply *reply, const int
  reply->deleteLater();

  CoverProviderSearchResults results;
+  const QScopeGuard search_finished = qScopeGuard([this, id, &results]() { Q_EMIT SearchFinished(id, results);; });

-  if (reply->error() != QNetworkReply::NoError) {
-    Error(QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
-    Q_EMIT SearchFinished(id, results);
-    return;
-  }
-  if (reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt() != 200) {
-    Error(QStringLiteral("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt()));
-    Q_EMIT SearchFinished(id, results);
+  const ReplyDataResult reply_data_result = GetReplyData(reply);
+  if (!reply_data_result.success()) {
+    Error(reply_data_result.error_message);
    return;
  }

-  const QByteArray data = reply->readAll();
-  if (data.isEmpty()) {
-    Error(u"Empty reply received from server."_s);
-    Q_EMIT SearchFinished(id, results);
-    return;
-  }
+  const QByteArray &data = reply_data_result.data;
  const QString content = QString::fromUtf8(data);
  const QString data_begin = "<script id=\"__NEXT_DATA__\" type=\"application/json\">"_L1;
  const QString data_end = "</script>"_L1;
  if (!content.contains(data_begin) || !content.contains(data_end)) {
-    Q_EMIT SearchFinished(id, results);
    return;
  }
  qint64 begin_idx = content.indexOf(data_begin);
@@ -125,89 +101,61 @@ void MusixmatchCoverProvider::HandleSearchReply(QNetworkReply *reply, const int
  }

  if (content_json.isEmpty()) {
-    Q_EMIT SearchFinished(id, results);
    return;
  }

  static const QRegularExpression regex_html_tag(u"<[^>]*>"_s);
  if (content_json.contains(regex_html_tag)) {  // Make sure it's not HTML code.
-    Q_EMIT SearchFinished(id, results);
    return;
  }

-  QJsonParseError error;
-  QJsonDocument json_doc = QJsonDocument::fromJson(content_json.toUtf8(), &error);
-
-  if (error.error != QJsonParseError::NoError) {
-    Error(QStringLiteral("Failed to parse json data: %1").arg(error.errorString()));
-    Q_EMIT SearchFinished(id, results);
+  const JsonObjectResult json_object_result = GetJsonObject(content_json.toUtf8());
+  if (!json_object_result.success()) {
+    Error(json_object_result.error_message);
    return;
  }

-  if (json_doc.isEmpty()) {
-    Error(u"Received empty Json document."_s, data);
-    Q_EMIT SearchFinished(id, results);
+  QJsonObject json_object = json_object_result.json_object;
+  if (!json_object.contains("props"_L1) || !json_object["props"_L1].isObject()) {
+    Error(u"Json reply is missing props."_s, json_object);
    return;
  }
+  json_object = json_object["props"_L1].toObject();

-  if (!json_doc.isObject()) {
-    Error(u"Json document is not an object."_s, json_doc);
+  if (!json_object.contains("pageProps"_L1) || !json_object["pageProps"_L1].isObject()) {
+    Error(u"Json props is missing pageProps."_s, json_object);
    Q_EMIT SearchFinished(id, results);
    return;
  }
+  json_object = json_object["pageProps"_L1].toObject();

-  QJsonObject obj_data = json_doc.object();
-  if (obj_data.isEmpty()) {
-    Error(u"Received empty Json object."_s, json_doc);
-    Q_EMIT SearchFinished(id, results);
+  if (!json_object.contains("data"_L1) || !json_object["data"_L1].isObject()) {
+    Error(u"Json pageProps is missing data."_s, json_object);
    return;
  }
+  json_object = json_object["data"_L1].toObject();

-  if (!obj_data.contains("props"_L1) || !obj_data["props"_L1].isObject()) {
-    Error(u"Json reply is missing props."_s, obj_data);
-    Q_EMIT SearchFinished(id, results);
+  if (!json_object.contains("albumGet"_L1) || !json_object["albumGet"_L1].isObject()) {
+    Error(u"Json data is missing albumGet."_s, json_object);
    return;
  }
-  obj_data = obj_data["props"_L1].toObject();
+  json_object = json_object["albumGet"_L1].toObject();

-  if (!obj_data.contains("pageProps"_L1) || !obj_data["pageProps"_L1].isObject()) {
-    Error(u"Json props is missing pageProps."_s, obj_data);
-    Q_EMIT SearchFinished(id, results);
+  if (!json_object.contains("data"_L1) || !json_object["data"_L1].isObject()) {
+    Error(u"Json albumGet reply is missing data."_s, json_object);
    return;
  }
-  obj_data = obj_data["pageProps"_L1].toObject();
-
-  if (!obj_data.contains("data"_L1) || !obj_data["data"_L1].isObject()) {
-    Error(u"Json pageProps is missing data."_s, obj_data);
-    Q_EMIT SearchFinished(id, results);
-    return;
-  }
-  obj_data = obj_data["data"_L1].toObject();
-
-  if (!obj_data.contains("albumGet"_L1) || !obj_data["albumGet"_L1].isObject()) {
-    Error(u"Json data is missing albumGet."_s, obj_data);
-    Q_EMIT SearchFinished(id, results);
-    return;
-  }
-  obj_data = obj_data["albumGet"_L1].toObject();
-
-  if (!obj_data.contains("data"_L1) || !obj_data["data"_L1].isObject()) {
-    Error(u"Json albumGet reply is missing data."_s, obj_data);
-    Q_EMIT SearchFinished(id, results);
-    return;
-  }
-  obj_data = obj_data["data"_L1].toObject();
+  json_object = json_object["data"_L1].toObject();

  CoverProviderSearchResult result;
-  if (obj_data.contains("artistName"_L1) && obj_data["artistName"_L1].isString()) {
-    result.artist = obj_data["artistName"_L1].toString();
+  if (json_object.contains("artistName"_L1) && json_object["artistName"_L1].isString()) {
+    result.artist = json_object["artistName"_L1].toString();
  }
-  if (obj_data.contains("name"_L1) && obj_data["name"_L1].isString()) {
-    result.album = obj_data["name"_L1].toString();
+  if (json_object.contains("name"_L1) && json_object["name"_L1].isString()) {
+    result.album = json_object["name"_L1].toString();
  }

  if (result.artist.compare(artist, Qt::CaseInsensitive) != 0 && result.album.compare(album, Qt::CaseInsensitive) != 0) {
-    Q_EMIT SearchFinished(id, results);
    return;
  }

@@ -216,8 +164,8 @@ void MusixmatchCoverProvider::HandleSearchReply(QNetworkReply *reply, const int
                                                                                  << qMakePair(u"coverImage350x350"_s, QSize(350, 350));

  for (const QPair<QString, QSize> &cover_size : cover_sizes) {
-    if (!obj_data.contains(cover_size.first)) continue;
-    QUrl cover_url(obj_data[cover_size.first].toString());
+    if (!json_object.contains(cover_size.first)) continue;
+    const QUrl cover_url(json_object[cover_size.first].toString());
    if (cover_url.isValid()) {
      result.image_url = cover_url;
      result.image_size = cover_size.second;
@@ -225,8 +173,6 @@ void MusixmatchCoverProvider::HandleSearchReply(QNetworkReply *reply, const int
    }
  }

-  Q_EMIT SearchFinished(id, results);
-
 }

 void MusixmatchCoverProvider::Error(const QString &error, const QVariant &debug) {
--- a/src/covermanager/musixmatchcoverprovider.h
+++ b/src/covermanager/musixmatchcoverprovider.h
@@ -1,6 +1,6 @@
 /*
 * Strawberry Music Player
- * Copyright 2020-2021, Jonas Kvinge <jonas@jkvinge.net>
+ * Copyright 2020-2025, 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
@@ -22,25 +22,20 @@

 #include "config.h"

-#include <QtGlobal>
-#include <QObject>
-#include <QList>
 #include <QVariant>
 #include <QString>

 #include "includes/shared_ptr.h"
 #include "jsoncoverprovider.h"
-#include "providers/musixmatchprovider.h"

 class QNetworkReply;
 class NetworkAccessManager;

-class MusixmatchCoverProvider : public JsonCoverProvider, MusixmatchProvider {
+class MusixmatchCoverProvider : public JsonCoverProvider {
  Q_OBJECT

 public:
  explicit MusixmatchCoverProvider(const SharedPtr<NetworkAccessManager> network, QObject *parent = nullptr);
-  ~MusixmatchCoverProvider() override;

  bool StartSearch(const QString &artist, const QString &album, const QString &title, const int id) override;
  void CancelSearch(const int id) override;
@@ -50,9 +45,6 @@ class MusixmatchCoverProvider : public JsonCoverProvider, MusixmatchProvider {

 private Q_SLOTS:
  void HandleSearchReply(QNetworkReply *reply, const int id, const QString &artist, const QString &album);
-
- private:
-  QList<QNetworkReply*> replies_;
 };

 #endif  // MUSIXMATCHCOVERPROVIDER_H
--- a/src/covermanager/opentidalcoverprovider.cpp
+++ b/src/covermanager/opentidalcoverprovider.cpp
@@ -1,6 +1,6 @@
 /*
 * Strawberry Music Player
- * Copyright 2024, Jonas Kvinge <jonas@jkvinge.net>
+ * Copyright 2024-2025, 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
@@ -19,11 +19,6 @@

 #include "config.h"

-#include <utility>
-
-#include <QtGlobal>
-#include <QObject>
-#include <QList>
 #include <QVariant>
 #include <QByteArray>
 #include <QString>
@@ -36,13 +31,13 @@
 #include <QJsonObject>
 #include <QJsonArray>
 #include <QTimer>
+#include <QScopeGuard>

 #include "includes/shared_ptr.h"
 #include "core/networkaccessmanager.h"
 #include "core/logging.h"
-#include "core/settings.h"
 #include "core/song.h"
-#include "constants/timeconstants.h"
+#include "core/oauthenticator.h"
 #include "albumcoverfetcher.h"
 #include "jsoncoverprovider.h"
 #include "opentidalcoverprovider.h"
@@ -51,8 +46,8 @@ using namespace Qt::Literals::StringLiterals;

 namespace {
 constexpr char kSettingsGroup[] = "OpenTidal";
-constexpr char kAuthUrl[] = "https://auth.tidal.com/v1/oauth2/token";
-constexpr char kApiUrl[] = "https://openapi.tidal.com";
+constexpr char kOAuthAccessTokenUrl[] = "https://auth.tidal.com/v1/oauth2/token";
+constexpr char kApiUrl[] = "https://openapi.tidal.com/v2";
 constexpr char kApiClientIdB64[] = "RHBwV3FpTEM4ZFJSV1RJaQ==";
 constexpr char kApiClientSecretB64[] = "cGk0QmxpclZXQWlteWpBc0RnWmZ5RmVlRzA2b3E1blVBVTljUW1IdFhDST0=";
 constexpr int kLimit = 10;
@@ -63,32 +58,24 @@ using std::make_shared;

 OpenTidalCoverProvider::OpenTidalCoverProvider(const SharedPtr<NetworkAccessManager> network, QObject *parent)
    : JsonCoverProvider(u"OpenTidal"_s, true, false, 2.5, true, false, network, parent),
-      login_timer_(new QTimer(this)),
+      oauth_(new OAuthenticator(network, this)),
      timer_flush_requests_(new QTimer(this)),
-      login_in_progress_(false),
-      have_login_(false),
-      login_time_(0),
-      expires_in_(0) {
+      login_in_progress_(false) {

-  login_timer_->setSingleShot(true);
-  QObject::connect(login_timer_, &QTimer::timeout, this, &OpenTidalCoverProvider::Login);
+  oauth_->set_settings_group(QLatin1String(kSettingsGroup));
+  oauth_->set_type(OAuthenticator::Type::Client_Credentials);
+  oauth_->set_access_token_url(QUrl(QLatin1String(kOAuthAccessTokenUrl)));
+  oauth_->set_client_id(QString::fromLatin1(QByteArray::fromBase64(kApiClientIdB64)));
+  oauth_->set_client_secret(QString::fromLatin1(QByteArray::fromBase64(kApiClientSecretB64)));
+  oauth_->set_use_local_redirect_server(false);
+  oauth_->set_random_port(false);
+  QObject::connect(oauth_, &OAuthenticator::AuthenticationFinished, this, &OpenTidalCoverProvider::OAuthFinished);

  timer_flush_requests_->setInterval(kRequestsDelay);
  timer_flush_requests_->setSingleShot(false);
  QObject::connect(timer_flush_requests_, &QTimer::timeout, this, &OpenTidalCoverProvider::FlushRequests);

-  LoadSession();
-
-}
-
-OpenTidalCoverProvider::~OpenTidalCoverProvider() {
-
-  while (!replies_.isEmpty()) {
-    QNetworkReply *reply = replies_.takeFirst();
-    QObject::disconnect(reply, nullptr, this, nullptr);
-    reply->abort();
-    reply->deleteLater();
-  }
+  oauth_->LoadSession();

 }

@@ -96,7 +83,7 @@ bool OpenTidalCoverProvider::StartSearch(const QString &artist, const QString &a

  if (artist.isEmpty() || album.isEmpty()) return false;

-  if (!have_login_ && !login_in_progress_ && QDateTime::currentSecsSinceEpoch() - last_login_attempt_.toSecsSinceEpoch() < 120) {
+  if (!oauth_->authenticated() && !login_in_progress_ && (last_login_attempt_.isValid() && (QDateTime::currentSecsSinceEpoch() - last_login_attempt_.toSecsSinceEpoch()) < 120)) {
    return false;
  }

@@ -115,32 +102,10 @@ void OpenTidalCoverProvider::CancelSearch(const int id) {
  Q_UNUSED(id);
 }

-void OpenTidalCoverProvider::LoadSession() {
-
-  Settings s;
-  s.beginGroup(kSettingsGroup);
-  token_type_ = s.value("token_type").toString();
-  access_token_ = s.value("access_token").toString();
-  expires_in_ = s.value("expires_in", 0).toLongLong();
-  login_time_ = s.value("login_time", 0).toLongLong();
-  s.endGroup();
-
-  if (!token_type_.isEmpty() && !access_token_.isEmpty() && (login_time_ + expires_in_) > (QDateTime::currentSecsSinceEpoch() + 30)) {
-    have_login_ = true;
-  }
-
-}
-
 void OpenTidalCoverProvider::FlushRequests() {

-  if (have_login_ && (login_time_ + expires_in_) < QDateTime::currentSecsSinceEpoch()) {
-    have_login_ = false;
-  }
-
-  if (!have_login_) {
-    if (!login_in_progress_) {
-      Login();
-    }
+  if (!oauth_->authenticated()) {
+    LoginCheck();
    return;
  }

@@ -155,7 +120,7 @@ void OpenTidalCoverProvider::FlushRequests() {

 void OpenTidalCoverProvider::LoginCheck() {

-  if (!login_in_progress_ && (!last_login_attempt_.isValid() || QDateTime::currentSecsSinceEpoch() - last_login_attempt_.toSecsSinceEpoch() > 120)) {
+  if (!oauth_->authenticated() && !login_in_progress_ && (!last_login_attempt_.isValid() || QDateTime::currentSecsSinceEpoch() - last_login_attempt_.toSecsSinceEpoch() > 120)) {
    Login();
  }

@@ -165,156 +130,93 @@ void OpenTidalCoverProvider::Login() {

  qLog(Debug) << "Authenticating...";

-  if (login_timer_->isActive()) {
-    login_timer_->stop();
-  }
-
-  have_login_ = false;
  login_in_progress_ = true;
-  last_login_attempt_ = QDateTime::currentDateTime();

-  QUrl url(QString::fromLatin1(kAuthUrl));
-  QNetworkRequest req(url);
-  req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
-  req.setRawHeader("Authorization", "Basic " + QByteArray(QByteArray::fromBase64(kApiClientIdB64) + ":" + QByteArray::fromBase64(kApiClientSecretB64)).toBase64());
-  QUrlQuery url_query;
-  url_query.addQueryItem(u"grant_type"_s, u"client_credentials"_s);
-  QNetworkReply *reply = network_->post(req, url_query.toString(QUrl::FullyEncoded).toUtf8());
-  replies_ << reply;
-  QObject::connect(reply, &QNetworkReply::sslErrors, this, &OpenTidalCoverProvider::HandleLoginSSLErrors);
-  QObject::connect(reply, &QNetworkReply::finished, this, [this, reply]() { LoginFinished(reply); });
+  oauth_->Authenticate();

 }

-void OpenTidalCoverProvider::HandleLoginSSLErrors(const QList<QSslError> &ssl_errors) {
-
-  for (const QSslError &ssl_error : ssl_errors) {
-    qLog(Error) << "OpenTidal:" << ssl_error.errorString();
-  }
-
-}
-
-void OpenTidalCoverProvider::LoginFinished(QNetworkReply *reply) {
-
-  if (!replies_.contains(reply)) return;
-  replies_.removeAll(reply);
-  QObject::disconnect(reply, nullptr, this, nullptr);
-  reply->deleteLater();
+void OpenTidalCoverProvider::OAuthFinished(const bool success, const QString &error) {

  login_in_progress_ = false;
-  last_login_attempt_ = QDateTime();

-  QJsonObject json_obj = GetJsonObject(reply);
-  if (json_obj.isEmpty()) {
-    FinishAllSearches();
-    return;
+  if (success) {
+    qLog(Debug) << "OpenTidal: Authentication successful";
+    last_login_attempt_ = QDateTime();
+    if (!timer_flush_requests_->isActive()) {
+      timer_flush_requests_->start();
+    }
  }
-
-  if (!json_obj.contains("access_token"_L1) ||
-      !json_obj.contains("token_type"_L1) ||
-      !json_obj.contains("expires_in"_L1) ||
-      !json_obj["access_token"_L1].isString() ||
-      !json_obj["token_type"_L1].isString()) {
-    qLog(Error) << "OpenTidal: Invalid login reply.";
-    FinishAllSearches();
-    return;
+  else {
+    qLog(Debug) << "OpenTidal: Authentication failed" << error;
+    last_login_attempt_ = QDateTime::currentDateTime();
  }

-  have_login_ = true;
-  token_type_ = json_obj["token_type"_L1].toString();
-  access_token_ = json_obj["access_token"_L1].toString();
-  login_time_ = QDateTime::currentSecsSinceEpoch();
-  expires_in_ = json_obj["expires_in"_L1].toInt();
-
-  Settings s;
-  s.beginGroup(kSettingsGroup);
-  s.setValue("token_type", token_type_);
-  s.setValue("access_token", access_token_);
-  s.setValue("expires_in", expires_in_);
-  s.setValue("login_time", login_time_);
-  s.endGroup();
-
-  if (expires_in_ <= 300) {
-    expires_in_ = 300;
-  }
-
-  expires_in_ -= 30;
-
-  login_timer_->setInterval(static_cast<int>(expires_in_ * kMsecPerSec));
-  login_timer_->start();
-
-  if (!timer_flush_requests_->isActive()) {
-    timer_flush_requests_->start();
-  }
-
-  qLog(Debug) << "Authentication successful";
-
 }

-QJsonObject OpenTidalCoverProvider::ExtractJsonObj(const QByteArray &data) {
+JsonBaseRequest::JsonObjectResult OpenTidalCoverProvider::ParseJsonObject(QNetworkReply *reply) {

-  QJsonParseError json_parse_error;
-  const QJsonDocument json_doc = QJsonDocument::fromJson(data, &json_parse_error);
-  if (json_parse_error.error != QJsonParseError::NoError) {
-    qLog(Error) << "OpenTidal:" << json_parse_error.errorString();
-    return QJsonObject();
+  if (reply->error() != QNetworkReply::NoError && reply->error() < 200) {
+    return ReplyDataResult(ErrorCode::NetworkError, QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
  }
-  if (!json_doc.isObject()) {
-    return QJsonObject();
-  }
-  return json_doc.object();

-}
-
-QJsonObject OpenTidalCoverProvider::GetJsonObject(QNetworkReply *reply) {
-
-  const int http_code = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
-  if (reply->error() != QNetworkReply::NoError || (http_code != 200 && http_code != 207)) {
-    if (reply->error() != QNetworkReply::NoError) {
-      qLog(Error) << "OpenTidal:" << reply->errorString();
-      if (reply->error() < 200) {
-        return QJsonObject();
-      }
-      if (reply->error() == QNetworkReply::AuthenticationRequiredError) {
-        LoginCheck();
-      }
-    }
-    else if (http_code != 200 && http_code != 207) {
-      qLog(Error) << "OpenTidal: Received HTTP code" << http_code;
-    }
-    const QByteArray data = reply->readAll();
-    if (data.isEmpty()) {
-      return QJsonObject();
-    }
-    QJsonObject json_obj = ExtractJsonObj(data);
-    if (json_obj.contains("errors"_L1) && json_obj["errors"_L1].isArray()) {
-      const QJsonArray array = json_obj["errors"_L1].toArray();
-      for (const QJsonValue &value : array) {
-        if (!value.isObject()) continue;
-        QJsonObject obj = value.toObject();
-        if (!obj.contains("category"_L1) ||
-            !obj.contains("code"_L1) ||
-            !obj.contains("detail"_L1)) {
-          continue;
-        }
-        QString category = obj["category"_L1].toString();
-        QString code = obj["code"_L1].toString();
-        QString detail = obj["detail"_L1].toString();
-        qLog(Error) << "OpenTidal:" << category << code << detail;
-        if (category == "AUTHENTICATION_ERROR"_L1) {
-          LoginCheck();
-        }
-      }
-    }
-    return QJsonObject();
+  JsonObjectResult result(ErrorCode::Success);
+  result.network_error = reply->error();
+  if (reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).isValid()) {
+    result.http_status_code = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
  }

  const QByteArray data = reply->readAll();
-  if (data.isEmpty()) {
-    return QJsonObject();
+  bool clear_session = false;
+  if (!data.isEmpty()) {
+    QJsonParseError json_parse_error;
+    const QJsonDocument json_document = QJsonDocument::fromJson(data, &json_parse_error);
+    if (json_parse_error.error == QJsonParseError::NoError) {
+      const QJsonObject json_object = json_document.object();
+      if (json_object.contains("errors"_L1) && json_object["errors"_L1].isArray()) {
+        const QJsonArray array_errors = json_object["errors"_L1].toArray();
+        for (const auto &value : array_errors) {
+          if (!value.isObject()) continue;
+          const QJsonObject object_error = value.toObject();
+          if (!object_error.contains("category"_L1) || !object_error.contains("code"_L1) || !object_error.contains("detail"_L1)) {
+            continue;
+          }
+          const QString category = object_error["category"_L1].toString();
+          const QString code = object_error["code"_L1].toString();
+          const QString detail = object_error["detail"_L1].toString();
+          result.error_code = ErrorCode::APIError;
+          result.error_message = QStringLiteral("%1 (%2) (%3)").arg(category, code, detail);
+          if (category == "AUTHENTICATION_ERROR"_L1) {
+            clear_session = true;
+          }
+        }
+      }
+      else {
+        result.json_object = json_document.object();
+      }
+    }
+    else {
+      result.error_code = ErrorCode::ParseError;
+      result.error_message = json_parse_error.errorString();
+    }
  }

-  return ExtractJsonObj(data);
+  if (result.error_code != ErrorCode::APIError) {
+    if (reply->error() != QNetworkReply::NoError) {
+      result.error_code = ErrorCode::NetworkError;
+      result.error_message = QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
+    }
+    else if (result.http_status_code != 200) {
+      result.error_code = ErrorCode::HttpError;
+      result.error_message = QStringLiteral("Received HTTP code %1").arg(result.http_status_code);
+    }
+  }
+
+  if (reply->error() == QNetworkReply::AuthenticationRequiredError || clear_session) {
+    oauth_->ClearSession();
+  }
+
+  return result;

 }

@@ -331,17 +233,19 @@ void OpenTidalCoverProvider::SendSearchRequest(SearchRequestPtr search_request)
  }

  QUrlQuery url_query;
-  url_query.addQueryItem(u"query"_s, QString::fromUtf8(QUrl::toPercentEncoding(query)));
+  url_query.addQueryItem(u"include"_s, u"albums"_s);
  url_query.addQueryItem(u"limit"_s, QString::number(kLimit));
  url_query.addQueryItem(u"countryCode"_s, u"US"_s);
-  QUrl url(QLatin1String(kApiUrl) + "/search"_L1);
+  QUrl url(QLatin1String(kApiUrl) + "/searchresults/"_L1 + QString::fromUtf8(QUrl::toPercentEncoding(query)));
  url.setQuery(url_query);
-  QNetworkRequest req(url);
-  req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
-  req.setHeader(QNetworkRequest::ContentTypeHeader, u"application/vnd.tidal.v1+json"_s);
-  req.setRawHeader("Authorization", token_type_.toUtf8() + " " + access_token_.toUtf8());
+  QNetworkRequest network_request(url);
+  network_request.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
+  network_request.setHeader(QNetworkRequest::ContentTypeHeader, u"application/vnd.tidal.v1+json"_s);
+  if (oauth_->authenticated()) {
+    network_request.setRawHeader("Authorization", oauth_->authorization_header());
+  }

-  QNetworkReply *reply = network_->get(req);
+  QNetworkReply *reply = network_->get(network_request);
  replies_ << reply;
  QObject::connect(reply, &QNetworkReply::finished, this, [this, reply, search_request]() { HandleSearchReply(reply, search_request); });

@@ -354,92 +258,76 @@ void OpenTidalCoverProvider::HandleSearchReply(QNetworkReply *reply, SearchReque
  QObject::disconnect(reply, nullptr, this, nullptr);
  reply->deleteLater();

-  QJsonObject json_obj = GetJsonObject(reply);
-  if (json_obj.isEmpty()) {
+  CoverProviderSearchResults results;
+  const QScopeGuard search_finished = qScopeGuard([this, search_request, &results]() { Q_EMIT SearchFinished(search_request->id, results); });
+
+  const JsonObjectResult json_object_result = ParseJsonObject(reply);
+  if (!json_object_result.success()) {
+    Error(json_object_result.error_message);
    if (login_in_progress_) {
      search_requests_queue_.prepend(search_request);
    }
-    else {
-      Q_EMIT SearchFinished(search_request->id, CoverProviderSearchResults());
-    }
+    return;
+  }
+  const QJsonObject &json_object = json_object_result.json_object;
+
+  if (!json_object.contains("included"_L1) || !json_object["included"_L1].isArray()) {
+    qLog(Error) << "OpenTidal: Json object is missing included.";
    return;
  }

-  if (!json_obj.contains("albums"_L1) || !json_obj["albums"_L1].isArray()) {
-    qLog(Debug) << "OpenTidal: Json object is missing albums.";
-    Q_EMIT SearchFinished(search_request->id, CoverProviderSearchResults());
+  const QJsonArray array_included = json_object["included"_L1].toArray();
+  if (array_included.isEmpty()) {
    return;
  }

-  const QJsonArray array_albums = json_obj["albums"_L1].toArray();
-  if (array_albums.isEmpty()) {
-    Q_EMIT SearchFinished(search_request->id, CoverProviderSearchResults());
-    return;
-  }
-
-  CoverProviderSearchResults results;
  int i = 0;
-  for (const QJsonValue &value_album : array_albums) {
+  for (const auto &value_included : array_included) {

-    if (!value_album.isObject()) {
-      qLog(Debug) << "OpenTidal: Invalid Json reply: Albums array value is not a object.";
+    if (!value_included.isObject()) {
+      qLog(Error) << "OpenTidal: Invalid Json reply: Albums array value is not a object.";
      continue;
    }
-    QJsonObject obj_album = value_album.toObject();
+    const QJsonObject object_included = value_included.toObject();

-    if (!obj_album.contains("resource"_L1) || !obj_album["resource"_L1].isObject()) {
-      qLog(Debug) << "OpenTidal: Invalid Json reply: Albums array album is missing resource object.";
+    if (!object_included.contains("attributes"_L1) || !object_included["attributes"_L1].isObject()) {
+      qLog(Error) << "OpenTidal: Invalid Json reply: Included array item is missing attributes object." << object_included;
      continue;
    }
-    QJsonObject obj_resource = obj_album["resource"_L1].toObject();
+    const QJsonObject object_attributes = object_included["attributes"_L1].toObject();

-    if (!obj_resource.contains("artists"_L1) || !obj_resource["artists"_L1].isArray()) {
-      qLog(Debug) << "OpenTidal: Invalid Json reply: Resource is missing artists array.";
+    if (!object_attributes.contains("title"_L1) || !object_attributes["title"_L1].isString()) {
+      qLog(Error) << "OpenTidal: Invalid Json reply: Attributes is missing title string." << object_attributes;
      continue;
    }

-    if (!obj_resource.contains("title"_L1) || !obj_resource["title"_L1].isString()) {
-      qLog(Debug) << "OpenTidal: Invalid Json reply: Resource is missing title.";
+    if (!object_attributes.contains("imageLinks"_L1) || !object_attributes["imageLinks"_L1].isArray()) {
+      qLog(Error) << "OpenTidal: Invalid Json reply: Attributes is missing imageLinks object." << object_attributes;
      continue;
    }

-    if (!obj_resource.contains("imageCover"_L1) || !obj_resource["imageCover"_L1].isArray()) {
-      qLog(Debug) << "OpenTidal: Invalid Json reply: Resource is missing imageCover array.";
-      continue;
-    }
+    const QString album = object_attributes["title"_L1].toString();
+    const QJsonArray array_imagelinks = object_attributes["imageLinks"_L1].toArray();

-    QString artist;
-    const QString album = obj_resource["title"_L1].toString();
-
-    const QJsonArray array_artists = obj_resource["artists"_L1].toArray();
-    for (const QJsonValue &value_artist : array_artists) {
-      if (!value_artist.isObject()) {
+    for (const auto &value_imagelink : array_imagelinks) {
+      if (!value_imagelink.isObject()) {
        continue;
      }
-      QJsonObject obj_artist = value_artist.toObject();
-      if (!obj_artist.contains("name"_L1)) {
+      const QJsonObject object_imagelink = value_imagelink.toObject();
+      if (!object_imagelink.contains("href"_L1) || !object_imagelink.contains("meta"_L1) || !object_imagelink["meta"_L1].isObject()) {
        continue;
      }
-      artist = obj_artist["name"_L1].toString();
-      break;
-    }
-
-    const QJsonArray array_covers = obj_resource["imageCover"_L1].toArray();
-    for (const QJsonValue &value_cover : array_covers) {
-      if (!value_cover.isObject()) {
+      QJsonObject object_meta = object_imagelink["meta"_L1].toObject();
+      if (!object_meta.contains("width"_L1) || !object_meta.contains("height"_L1)) {
        continue;
      }
-      QJsonObject obj_cover = value_cover.toObject();
-      if (!obj_cover.contains("url"_L1) || !obj_cover.contains("width"_L1) || !obj_cover.contains("height"_L1)) {
-        continue;
-      }
-      const QUrl url(obj_cover["url"_L1].toString());
-      const int width = obj_cover["width"_L1].toInt();
-      const int height = obj_cover["height"_L1].toInt();
+      const QUrl url(object_imagelink["href"_L1].toString());
+      const int width = object_meta["width"_L1].toInt();
+      const int height = object_meta["height"_L1].toInt();
      if (!url.isValid()) continue;
      if (width < 640 || height < 640) continue;
      CoverProviderSearchResult cover_result;
-      cover_result.artist = artist;
+      cover_result.artist = search_request->artist;
      cover_result.album = Song::AlbumRemoveDiscMisc(album);
      cover_result.image_url = url;
      cover_result.image_size = QSize(width, height);
@@ -448,8 +336,6 @@ void OpenTidalCoverProvider::HandleSearchReply(QNetworkReply *reply, SearchReque
    }
  }

-  Q_EMIT SearchFinished(search_request->id, results);
-
 }

 void OpenTidalCoverProvider::FinishAllSearches() {
@@ -465,7 +351,7 @@ void OpenTidalCoverProvider::FinishAllSearches() {

 void OpenTidalCoverProvider::Error(const QString &error, const QVariant &debug) {

-  qLog(Error) << "Tidal:" << error;
+  qLog(Error) << "OpenTidal:" << error;
  if (debug.isValid()) qLog(Debug) << debug;

 }
--- a/src/covermanager/opentidalcoverprovider.h
+++ b/src/covermanager/opentidalcoverprovider.h
@@ -1,6 +1,6 @@
 /*
 * Strawberry Music Player
- * Copyright 2024, Jonas Kvinge <jonas@jkvinge.net>
+ * Copyright 2024-2025, 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
@@ -22,15 +22,10 @@

 #include "config.h"

-#include <QObject>
-#include <QList>
 #include <QQueue>
 #include <QVariant>
-#include <QByteArray>
 #include <QString>
 #include <QDateTime>
-#include <QSslError>
-#include <QJsonObject>

 #include "includes/shared_ptr.h"
 #include "jsoncoverprovider.h"
@@ -38,13 +33,13 @@
 class QNetworkReply;
 class NetworkAccessManager;
 class QTimer;
+class OAuthenticator;

 class OpenTidalCoverProvider : public JsonCoverProvider {
  Q_OBJECT

 public:
  explicit OpenTidalCoverProvider(const SharedPtr<NetworkAccessManager> network, QObject *parent = nullptr);
-  ~OpenTidalCoverProvider() override;

  bool StartSearch(const QString &artist, const QString &album, const QString &title, const int id) override;
  void CancelSearch(const int id) override;
@@ -60,33 +55,24 @@ class OpenTidalCoverProvider : public JsonCoverProvider {
  using SearchRequestPtr = SharedPtr<SearchRequest>;

 private:
-  void LoadSession();
  void LoginCheck();
  void Login();
-  QJsonObject GetJsonObject(QNetworkReply *reply);
-  QJsonObject ExtractJsonObj(const QByteArray &data);
  void SendSearchRequest(SearchRequestPtr request);
+  JsonObjectResult ParseJsonObject(QNetworkReply *reply);
  void FinishAllSearches();
  void Error(const QString &error, const QVariant &debug = QVariant()) override;

 private Q_SLOTS:
+  void OAuthFinished(const bool success, const QString &error = QString());
  void FlushRequests();
-  void LoginFinished(QNetworkReply *reply);
-  void HandleLoginSSLErrors(const QList<QSslError> &ssl_errors);
  void HandleSearchReply(QNetworkReply *reply, OpenTidalCoverProvider::SearchRequestPtr search_request);

 private:
-  QTimer *login_timer_;
+  OAuthenticator *oauth_;
  QTimer *timer_flush_requests_;
  bool login_in_progress_;
  QDateTime last_login_attempt_;
-  bool have_login_;
-  QString token_type_;
-  QString access_token_;
-  qint64 login_time_;
-  qint64 expires_in_;
  QQueue<SearchRequestPtr> search_requests_queue_;
-  QList<QNetworkReply*> replies_;
 };

 #endif  // OPENTIDALCOVERPROVIDER_H
--- a/src/covermanager/qobuzcoverprovider.cpp
+++ b/src/covermanager/qobuzcoverprovider.cpp
@@ -1,6 +1,6 @@
 /*
 * Strawberry Music Player
- * Copyright 2020-2021, Jonas Kvinge <jonas@jkvinge.net>
+ * Copyright 2020-2025, 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
@@ -22,8 +22,6 @@
 #include <algorithm>
 #include <utility>

-#include <QtGlobal>
-#include <QObject>
 #include <QVariant>
 #include <QByteArray>
 #include <QString>
@@ -35,6 +33,7 @@
 #include <QJsonValue>
 #include <QJsonObject>
 #include <QJsonArray>
+#include <QScopeGuard>

 #include "includes/shared_ptr.h"
 #include "core/networkaccessmanager.h"
@@ -49,26 +48,27 @@ using namespace Qt::Literals::StringLiterals;

 namespace {
 constexpr int kLimit = 10;
-}
+}  // namespace

 QobuzCoverProvider::QobuzCoverProvider(const QobuzServicePtr service, SharedPtr<NetworkAccessManager> network, QObject *parent)
    : JsonCoverProvider(u"Qobuz"_s, true, true, 2.0, true, true, network, parent),
      service_(service) {}

-QobuzCoverProvider::~QobuzCoverProvider() {
+bool QobuzCoverProvider::authenticated() const {

-  while (!replies_.isEmpty()) {
-    QNetworkReply *reply = replies_.takeFirst();
-    QObject::disconnect(reply, nullptr, this, nullptr);
-    reply->abort();
-    reply->deleteLater();
-  }
+  return service_->authenticated();
+
+}
+
+void QobuzCoverProvider::ClearSession() {
+
+  service_->ClearSession();

 }

 bool QobuzCoverProvider::StartSearch(const QString &artist, const QString &album, const QString &title, const int id) {

-  if (artist.isEmpty() && album.isEmpty() && title.isEmpty()) return false;
+  if (!service_->authenticated() || (artist.isEmpty() && album.isEmpty() && title.isEmpty())) return false;

  QString resource;
  QString query = artist;
@@ -99,12 +99,12 @@ bool QobuzCoverProvider::StartSearch(const QString &artist, const QString &album
  QUrl url(QLatin1String(QobuzService::kApiUrl) + QLatin1Char('/') + resource);
  url.setQuery(url_query);

-  QNetworkRequest req(url);
-  req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
-  req.setHeader(QNetworkRequest::ContentTypeHeader, u"application/x-www-form-urlencoded"_s);
-  req.setRawHeader("X-App-Id", service_->app_id().toUtf8());
-  req.setRawHeader("X-User-Auth-Token", service_->user_auth_token().toUtf8());
-  QNetworkReply *reply = network_->get(req);
+  QNetworkRequest network_request(url);
+  network_request.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
+  network_request.setHeader(QNetworkRequest::ContentTypeHeader, u"application/x-www-form-urlencoded"_s);
+  network_request.setRawHeader("X-App-Id", service_->app_id().toUtf8());
+  network_request.setRawHeader("X-User-Auth-Token", service_->user_auth_token().toUtf8());
+  QNetworkReply *reply = network_->get(network_request);
  replies_ << reply;
  QObject::connect(reply, &QNetworkReply::finished, this, [this, reply, id]() { HandleSearchReply(reply, id); });

@@ -114,46 +114,56 @@ bool QobuzCoverProvider::StartSearch(const QString &artist, const QString &album

 void QobuzCoverProvider::CancelSearch(const int id) { Q_UNUSED(id); }

-QByteArray QobuzCoverProvider::GetReplyData(QNetworkReply *reply) {
+JsonBaseRequest::JsonObjectResult QobuzCoverProvider::ParseJsonObject(QNetworkReply *reply) {

-  QByteArray data;
-
-  if (reply->error() == QNetworkReply::NoError && reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt() == 200) {
-    data = reply->readAll();
+  if (reply->error() != QNetworkReply::NoError && reply->error() < 200) {
+    return ReplyDataResult(ErrorCode::NetworkError, QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
  }
-  else {
-    if (reply->error() != QNetworkReply::NoError && reply->error() < 200) {
-      // This is a network error, there is nothing more to do.
-      Error(QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
+
+  JsonObjectResult result(ErrorCode::Success);
+  result.network_error = reply->error();
+  if (reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).isValid()) {
+    result.http_status_code = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+  }
+
+  const QByteArray data = reply->readAll();
+  if (!data.isEmpty()) {
+    QJsonParseError json_parse_error;
+    const QJsonDocument json_document = QJsonDocument::fromJson(data, &json_parse_error);
+    if (json_parse_error.error == QJsonParseError::NoError) {
+      const QJsonObject json_object = json_document.object();
+      if (json_object.contains("code"_L1) && json_object.contains("status"_L1) && json_object.contains("message"_L1)) {
+        const int code = json_object["code"_L1].toInt();
+        const QString message = json_object["message"_L1].toString();
+        result.error_code = ErrorCode::APIError;
+        result.error_message = QStringLiteral("%1 (%2)").arg(message).arg(code);
+      }
+      else {
+        result.json_object = json_document.object();
+      }
    }
    else {
-      // See if there is Json data containing "status", "code" and "message" - then use that instead.
-      data = reply->readAll();
-      QString error;
-      QJsonParseError parse_error;
-      QJsonDocument json_doc = QJsonDocument::fromJson(data, &parse_error);
-      if (parse_error.error == QJsonParseError::NoError && !json_doc.isEmpty() && json_doc.isObject()) {
-        QJsonObject json_obj = json_doc.object();
-        if (!json_obj.isEmpty() && json_obj.contains("status"_L1) && json_obj.contains("code"_L1) && json_obj.contains("message"_L1)) {
-          int code = json_obj["code"_L1].toInt();
-          QString message = json_obj["message"_L1].toString();
-          error = QStringLiteral("%1 (%2)").arg(message).arg(code);
-        }
-      }
-      if (error.isEmpty()) {
-        if (reply->error() != QNetworkReply::NoError) {
-          error = QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
-        }
-        else {
-          error = QStringLiteral("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt());
-        }
-      }
-      Error(error);
+      result.error_code = ErrorCode::ParseError;
+      result.error_message = json_parse_error.errorString();
    }
-    return QByteArray();
  }

-  return data;
+  if (result.error_code != ErrorCode::APIError) {
+    if (reply->error() != QNetworkReply::NoError) {
+      result.error_code = ErrorCode::NetworkError;
+      result.error_message = QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
+    }
+    else if (result.http_status_code != 200) {
+      result.error_code = ErrorCode::HttpError;
+      result.error_message = QStringLiteral("Received HTTP code %1").arg(result.http_status_code);
+    }
+  }
+
+  if (reply->error() == QNetworkReply::AuthenticationRequiredError) {
+    service_->ClearSession();
+  }
+
+  return result;

 }

@@ -165,49 +175,45 @@ void QobuzCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id) {
  reply->deleteLater();

  CoverProviderSearchResults results;
+  const QScopeGuard search_finished = qScopeGuard([this, id, &results]() { Q_EMIT SearchFinished(id, results); });

-  QByteArray data = GetReplyData(reply);
-  if (data.isEmpty()) {
-    Q_EMIT SearchFinished(id, results);
+  const JsonObjectResult json_object_result = ParseJsonObject(reply);
+  if (!json_object_result.success()) {
+    Error(json_object_result.error_message);
    return;
  }

-  QJsonObject json_obj = ExtractJsonObj(data);
-  if (json_obj.isEmpty()) {
-    Q_EMIT SearchFinished(id, results);
+  const QJsonObject &json_object = json_object_result.json_object;
+  if (json_object.isEmpty()) {
    return;
  }

  QJsonValue value_type;
-  if (json_obj.contains("albums"_L1)) {
-    value_type = json_obj["albums"_L1];
+  if (json_object.contains("albums"_L1)) {
+    value_type = json_object["albums"_L1];
  }
-  else if (json_obj.contains("tracks"_L1)) {
-    value_type = json_obj["tracks"_L1];
+  else if (json_object.contains("tracks"_L1)) {
+    value_type = json_object["tracks"_L1];
  }
  else {
-    Error(u"Json reply is missing albums and tracks object."_s, json_obj);
-    Q_EMIT SearchFinished(id, results);
+    Error(u"Json reply is missing albums and tracks object."_s, json_object);
    return;
  }

  if (!value_type.isObject()) {
    Error(u"Json albums or tracks is not a object."_s, value_type);
-    Q_EMIT SearchFinished(id, results);
    return;
  }
-  QJsonObject obj_type = value_type.toObject();
+  const QJsonObject object_type = value_type.toObject();

-  if (!obj_type.contains("items"_L1)) {
-    Error(u"Json albums or tracks object does not contain items."_s, obj_type);
-    Q_EMIT SearchFinished(id, results);
+  if (!object_type.contains("items"_L1)) {
+    Error(u"Json albums or tracks object does not contain items."_s, object_type);
    return;
  }
-  QJsonValue value_items = obj_type["items"_L1];
+  const QJsonValue value_items = object_type["items"_L1];

  if (!value_items.isArray()) {
    Error(u"Json albums or track object items is not a array."_s, value_items);
-    Q_EMIT SearchFinished(id, results);
    return;
  }
  const QJsonArray array_items = value_items.toArray();
@@ -218,52 +224,52 @@ void QobuzCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id) {
      Error(u"Invalid Json reply, value in items is not a object."_s);
      continue;
    }
-    QJsonObject item_obj = value.toObject();
+    const QJsonObject item_object = value.toObject();

-    QJsonObject obj_album;
-    if (item_obj.contains("album"_L1)) {
-      if (!item_obj["album"_L1].isObject()) {
-        Error(u"Invalid Json reply, items album is not a object."_s, item_obj);
+    QJsonObject object_album;
+    if (item_object.contains("album"_L1)) {
+      if (!item_object["album"_L1].isObject()) {
+        Error(u"Invalid Json reply, items album is not a object."_s, item_object);
        continue;
      }
-      obj_album = item_obj["album"_L1].toObject();
+      object_album = item_object["album"_L1].toObject();
    }
    else {
-      obj_album = item_obj;
+      object_album = item_object;
    }

-    if (!obj_album.contains("artist"_L1) || !obj_album.contains("image"_L1) || !obj_album.contains("title"_L1)) {
-      Error(u"Invalid Json reply, item is missing artist, title or image."_s, obj_album);
+    if (!object_album.contains("artist"_L1) || !object_album.contains("image"_L1) || !object_album.contains("title"_L1)) {
+      Error(u"Invalid Json reply, item is missing artist, title or image."_s, object_album);
      continue;
    }

-    QString album = obj_album["title"_L1].toString();
+    const QString album = object_album["title"_L1].toString();

    // Artist
-    QJsonValue value_artist = obj_album["artist"_L1];
+    const QJsonValue value_artist = object_album["artist"_L1];
    if (!value_artist.isObject()) {
      Error(u"Invalid Json reply, items (album) artist is not a object."_s, value_artist);
      continue;
    }
-    QJsonObject obj_artist = value_artist.toObject();
-    if (!obj_artist.contains("name"_L1)) {
-      Error(u"Invalid Json reply, items (album) artist is missing name."_s, obj_artist);
+    const QJsonObject object_artist = value_artist.toObject();
+    if (!object_artist.contains("name"_L1)) {
+      Error(u"Invalid Json reply, items (album) artist is missing name."_s, object_artist);
      continue;
    }
-    QString artist = obj_artist["name"_L1].toString();
+    const QString artist = object_artist["name"_L1].toString();

    // Image
-    QJsonValue value_image = obj_album["image"_L1];
-    if (!value_image.isObject()) {
-      Error(u"Invalid Json reply, items (album) image is not a object."_s, value_image);
+    const QJsonValue _timer_ = object_album["image"_L1];
+    if (!_timer_.isObject()) {
+      Error(u"Invalid Json reply, items (album) image is not a object."_s, _timer_);
      continue;
    }
-    QJsonObject obj_image = value_image.toObject();
-    if (!obj_image.contains("large"_L1)) {
-      Error(u"Invalid Json reply, items (album) image is missing large."_s, obj_image);
+    const QJsonObject object_image = _timer_.toObject();
+    if (!object_image.contains("large"_L1)) {
+      Error(u"Invalid Json reply, items (album) image is missing large."_s, object_image);
      continue;
    }
-    QUrl cover_url(obj_image["large"_L1].toString());
+    const QUrl cover_url(object_image["large"_L1].toString());

    CoverProviderSearchResult cover_result;
    cover_result.artist = artist;
@@ -273,7 +279,6 @@ void QobuzCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id) {
    results << cover_result;

  }
-  Q_EMIT SearchFinished(id, results);

 }

--- a/src/covermanager/qobuzcoverprovider.h
+++ b/src/covermanager/qobuzcoverprovider.h
@@ -1,6 +1,6 @@
 /*
 * Strawberry Music Player
- * Copyright 2020-2021, Jonas Kvinge <jonas@jkvinge.net>
+ * Copyright 2020-2025, 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
@@ -22,44 +22,37 @@

 #include "config.h"

-#include <QObject>
-#include <QList>
 #include <QVariant>
-#include <QByteArray>
 #include <QString>
-#include <QJsonObject>
-#include <QSslError>

 #include "includes/shared_ptr.h"
 #include "jsoncoverprovider.h"
-#include "qobuz/qobuzservice.h"

 class QNetworkReply;
 class NetworkAccessManager;
+class QobuzService;

 class QobuzCoverProvider : public JsonCoverProvider {
  Q_OBJECT

 public:
-  explicit QobuzCoverProvider(const QobuzServicePtr service, SharedPtr<NetworkAccessManager> network, QObject *parent = nullptr);
-  ~QobuzCoverProvider() override;
+  explicit QobuzCoverProvider(const SharedPtr<QobuzService> service, SharedPtr<NetworkAccessManager> network, QObject *parent = nullptr);
+
+  virtual bool authenticated() const override;

  bool StartSearch(const QString &artist, const QString &album, const QString &title, const int id) override;
  void CancelSearch(const int id) override;
-
-  bool IsAuthenticated() const override { return service_ && service_->authenticated(); }
-  void Deauthenticate() override { if (service_) service_->Logout(); }
+  void ClearSession() override;

 private Q_SLOTS:
  void HandleSearchReply(QNetworkReply *reply, const int id);

 private:
-  QByteArray GetReplyData(QNetworkReply *reply);
+  JsonObjectResult ParseJsonObject(QNetworkReply *reply);
  void Error(const QString &error, const QVariant &debug = QVariant()) override;

 private:
-  QobuzServicePtr service_;
-  QList<QNetworkReply*> replies_;
+  SharedPtr<QobuzService> service_;
 };

 #endif  // QOBUZCOVERPROVIDER_H
--- a/src/covermanager/spotifycoverprovider.cpp
+++ b/src/covermanager/spotifycoverprovider.cpp
@@ -1,6 +1,6 @@
 /*
 * Strawberry Music Player
- * Copyright 2020-2024, Jonas Kvinge <jonas@jkvinge.net>
+ * Copyright 2020-2025, 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
@@ -19,24 +19,14 @@

 #include "config.h"

-#include <algorithm>
-
-#include <QtGlobal>
-#include <QObject>
-#include <QList>
-#include <QVariant>
 #include <QByteArray>
 #include <QString>
 #include <QUrl>
-#include <QUrlQuery>
-#include <QNetworkRequest>
 #include <QNetworkReply>
-#include <QJsonDocument>
 #include <QJsonValue>
 #include <QJsonObject>
 #include <QJsonArray>
-#include <QDesktopServices>
-#include <QMessageBox>
+#include <QScopeGuard>

 #include "includes/shared_ptr.h"
 #include "core/networkaccessmanager.h"
@@ -57,20 +47,33 @@ SpotifyCoverProvider::SpotifyCoverProvider(const SpotifyServicePtr service, Shar
    : JsonCoverProvider(u"Spotify"_s, true, true, 2.5, true, true, network, parent),
      service_(service) {}

-SpotifyCoverProvider::~SpotifyCoverProvider() {
+bool SpotifyCoverProvider::authenticated() const {

-  while (!replies_.isEmpty()) {
-    QNetworkReply *reply = replies_.takeFirst();
-    QObject::disconnect(reply, nullptr, this, nullptr);
-    reply->abort();
-    reply->deleteLater();
-  }
+  return service_->authenticated();
+
+}
+
+bool SpotifyCoverProvider::use_authorization_header() const {
+
+  return true;
+
+}
+
+QByteArray SpotifyCoverProvider::authorization_header() const {
+
+  return service_->authorization_header();
+
+}
+
+void SpotifyCoverProvider::ClearSession() {
+
+  service_->ClearSession();

 }

 bool SpotifyCoverProvider::StartSearch(const QString &artist, const QString &album, const QString &title, const int id) {

-  if (!IsAuthenticated()) return false;
+  if (!service_->authenticated()) return false;

  if (artist.isEmpty() && album.isEmpty() && title.isEmpty()) return false;

@@ -96,20 +99,7 @@ bool SpotifyCoverProvider::StartSearch(const QString &artist, const QString &alb
                                       << Param(u"type"_s, type)
                                       << Param(u"limit"_s, QString::number(kLimit));

-  QUrlQuery url_query;
-  for (const Param &param : params) {
-    url_query.addQueryItem(QString::fromLatin1(QUrl::toPercentEncoding(param.first)), QString::fromLatin1(QUrl::toPercentEncoding(param.second)));
-  }
-
-  QUrl url(QLatin1String(kApiUrl) + u"/search"_s);
-  url.setQuery(url_query);
-  QNetworkRequest req(url);
-  req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
-  req.setHeader(QNetworkRequest::ContentTypeHeader, u"application/x-www-form-urlencoded"_s);
-  req.setRawHeader("Authorization", "Bearer " + service_->access_token().toUtf8());
-
-  QNetworkReply *reply = network_->get(req);
-  replies_ << reply;
+  QNetworkReply *reply = CreateGetRequest(QUrl(QLatin1String(kApiUrl) + u"/search"_s), params);
  QObject::connect(reply, &QNetworkReply::finished, this, [this, reply, id, extract]() { HandleSearchReply(reply, id, extract); });

  return true;
@@ -118,50 +108,59 @@ bool SpotifyCoverProvider::StartSearch(const QString &artist, const QString &alb

 void SpotifyCoverProvider::CancelSearch(const int id) { Q_UNUSED(id); }

-QByteArray SpotifyCoverProvider::GetReplyData(QNetworkReply *reply) {
+JsonBaseRequest::JsonObjectResult SpotifyCoverProvider::ParseJsonObject(QNetworkReply *reply) {

-  QByteArray data;
-
-  if (reply->error() == QNetworkReply::NoError && reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt() == 200) {
-    data = reply->readAll();
+  if (reply->error() != QNetworkReply::NoError && reply->error() < 200) {
+    return ReplyDataResult(ErrorCode::NetworkError, QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
  }
-  else {
-    if (reply->error() != QNetworkReply::NoError && reply->error() < 200) {
-      // This is a network error, there is nothing more to do.
-      Error(QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
+
+  JsonObjectResult result(ErrorCode::Success);
+  result.network_error = reply->error();
+  if (reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).isValid()) {
+    result.http_status_code = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+  }
+
+  const QByteArray data = reply->readAll();
+  if (!data.isEmpty()) {
+    QJsonParseError json_parse_error;
+    const QJsonDocument json_document = QJsonDocument::fromJson(data, &json_parse_error);
+    if (json_parse_error.error == QJsonParseError::NoError) {
+      const QJsonObject json_object = json_document.object();
+      if (json_object.contains("error"_L1) && json_object["error"_L1].isObject()) {
+        const QJsonObject object_error = json_object["error"_L1].toObject();
+        if (object_error.contains("status"_L1) && object_error.contains("message"_L1)) {
+          const int status = object_error["status"_L1].toInt();
+          const QString message = object_error["message"_L1].toString();
+          result.error_code = ErrorCode::APIError;
+          result.error_message = QStringLiteral("%1 (%2)").arg(message).arg(status);
+        }
+      }
+      else {
+        result.json_object = json_document.object();
+      }
    }
    else {
-      data = reply->readAll();
-      QJsonParseError parse_error;
-      QJsonDocument json_doc = QJsonDocument::fromJson(data, &parse_error);
-      QString error;
-      if (parse_error.error == QJsonParseError::NoError && !json_doc.isEmpty() && json_doc.isObject()) {
-        QJsonObject json_obj = json_doc.object();
-        if (!json_obj.isEmpty() && json_obj.contains("error"_L1) && json_obj["error"_L1].isObject()) {
-          QJsonObject obj_error = json_obj["error"_L1].toObject();
-          if (obj_error.contains("status"_L1) && obj_error.contains("message"_L1)) {
-            int status = obj_error["status"_L1].toInt();
-            QString message = obj_error["message"_L1].toString();
-            error = QStringLiteral("%1 (%2)").arg(message).arg(status);
-            if (status == 401) Deauthenticate();
-          }
-        }
-      }
-      if (error.isEmpty()) {
-        if (reply->error() != QNetworkReply::NoError) {
-          if (reply->error() == 204) Deauthenticate();
-          error = QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
-        }
-        else {
-          error = QStringLiteral("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt());
-        }
-      }
-      Error(error);
+      result.error_code = ErrorCode::ParseError;
+      result.error_message = json_parse_error.errorString();
    }
-    return QByteArray();
  }

-  return data;
+  if (result.error_code != ErrorCode::APIError) {
+    if (reply->error() != QNetworkReply::NoError) {
+      result.error_code = ErrorCode::NetworkError;
+      result.error_message = QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
+    }
+    else if (result.http_status_code != 200) {
+      result.error_code = ErrorCode::HttpError;
+      result.error_message = QStringLiteral("Received HTTP code %1").arg(result.http_status_code);
+    }
+  }
+
+  if (reply->error() == QNetworkReply::AuthenticationRequiredError) {
+    service_->ClearSession();
+  }
+
+  return result;

 }

@@ -172,48 +171,46 @@ void SpotifyCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id,
  QObject::disconnect(reply, nullptr, this, nullptr);
  reply->deleteLater();

-  QByteArray data = GetReplyData(reply);
-  if (data.isEmpty()) {
-    Q_EMIT SearchFinished(id, CoverProviderSearchResults());
-    return;
-  }
-
-  QJsonObject json_obj = ExtractJsonObj(data);
-  if (json_obj.isEmpty()) {
-    Q_EMIT SearchFinished(id, CoverProviderSearchResults());
-    return;
-  }
-
-  if (!json_obj.contains(extract) || !json_obj[extract].isObject()) {
-    Error(QStringLiteral("Json object is missing %1 object.").arg(extract), json_obj);
-    Q_EMIT SearchFinished(id, CoverProviderSearchResults());
-    return;
-  }
-  json_obj = json_obj[extract].toObject();
-
-  if (!json_obj.contains("items"_L1) || !json_obj["items"_L1].isArray()) {
-    Error(QStringLiteral("%1 object is missing items array.").arg(extract), json_obj);
-    Q_EMIT SearchFinished(id, CoverProviderSearchResults());
-    return;
-  }
-
-  const QJsonArray array_items = json_obj["items"_L1].toArray();
-  if (array_items.isEmpty()) {
-    Q_EMIT SearchFinished(id, CoverProviderSearchResults());
-    return;
-  }
-
  CoverProviderSearchResults results;
+  const QScopeGuard search_finished = qScopeGuard([this, id, &results]() { Q_EMIT SearchFinished(id, results); });
+
+  const JsonObjectResult json_object_result = ParseJsonObject(reply);
+  if (!json_object_result.success()) {
+    Error(json_object_result.error_message);
+    return;
+  }
+
+  QJsonObject json_object = json_object_result.json_object;
+  if (json_object.isEmpty()) {
+    return;
+  }
+
+  if (!json_object.contains(extract) || !json_object[extract].isObject()) {
+    Error(QStringLiteral("Json object is missing %1 object.").arg(extract), json_object);
+    return;
+  }
+  json_object = json_object[extract].toObject();
+
+  if (!json_object.contains("items"_L1) || !json_object["items"_L1].isArray()) {
+    Error(QStringLiteral("%1 object is missing items array.").arg(extract), json_object);
+    return;
+  }
+
+  const QJsonArray array_items = json_object["items"_L1].toArray();
+  if (array_items.isEmpty()) {
+    return;
+  }
+
  for (const QJsonValue &value_item : array_items) {

    if (!value_item.isObject()) {
      continue;
    }
-    QJsonObject obj_item = value_item.toObject();
+    const QJsonObject object_item = value_item.toObject();

-    QJsonObject obj_album = obj_item;
-    if (obj_item.contains("album"_L1) && obj_item["album"_L1].isObject()) {
-      obj_album = obj_item["album"_L1].toObject();
+    QJsonObject obj_album = object_item;
+    if (object_item.contains("album"_L1) && object_item["album"_L1].isObject()) {
+      obj_album = object_item["album"_L1].toObject();
    }

    if (!obj_album.contains("artists"_L1) || !obj_album.contains("name"_L1) || !obj_album.contains("images"_L1) || !obj_album["artists"_L1].isArray() || !obj_album["images"_L1].isArray()) {
@@ -221,7 +218,7 @@ void SpotifyCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id,
    }
    const QJsonArray array_artists = obj_album["artists"_L1].toArray();
    const QJsonArray array_images = obj_album["images"_L1].toArray();
-    QString album = obj_album["name"_L1].toString();
+    const QString album = obj_album["name"_L1].toString();

    QStringList artists;
    for (const QJsonValue &value_artist : array_artists) {
@@ -233,12 +230,12 @@ void SpotifyCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id,

    for (const QJsonValue &value_image : array_images) {
      if (!value_image.isObject()) continue;
-      QJsonObject obj_image = value_image.toObject();
-      if (!obj_image.contains("url"_L1) || !obj_image.contains("width"_L1) || !obj_image.contains("height"_L1)) continue;
-      int width = obj_image["width"_L1].toInt();
-      int height = obj_image["height"_L1].toInt();
+      const QJsonObject object_image = value_image.toObject();
+      if (!object_image.contains("url"_L1) || !object_image.contains("width"_L1) || !object_image.contains("height"_L1)) continue;
+      const int width = object_image["width"_L1].toInt();
+      const int height = object_image["height"_L1].toInt();
      if (width < 300 || height < 300) continue;
-      QUrl url(obj_image["url"_L1].toString());
+      const QUrl url(object_image["url"_L1].toString());
      CoverProviderSearchResult result;
      result.album = album;
      result.image_url = url;
@@ -248,7 +245,6 @@ void SpotifyCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id,
    }

  }
-  Q_EMIT SearchFinished(id, results);

 }

--- a/src/covermanager/spotifycoverprovider.h
+++ b/src/covermanager/spotifycoverprovider.h
@@ -1,6 +1,6 @@
 /*
 * Strawberry Music Player
- * Copyright 2018-2024, Jonas Kvinge <jonas@jkvinge.net>
+ * Copyright 2018-2025, 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
@@ -22,50 +22,41 @@

 #include "config.h"

-#include <QObject>
-#include <QPair>
-#include <QSet>
-#include <QList>
 #include <QVariant>
-#include <QByteArray>
 #include <QString>
-#include <QSslError>
-#include <QJsonValue>
-#include <QJsonObject>
-#include <QTimer>

 #include "includes/shared_ptr.h"
 #include "jsoncoverprovider.h"
-#include "spotify/spotifyservice.h"

 class QNetworkReply;
 class NetworkAccessManager;
+class SpotifyService;
+
+using SpotifyServicePtr = SharedPtr<SpotifyService>;

 class SpotifyCoverProvider : public JsonCoverProvider {
  Q_OBJECT

 public:
  explicit SpotifyCoverProvider(const SpotifyServicePtr service, const SharedPtr<NetworkAccessManager> network, QObject *parent = nullptr);
-  ~SpotifyCoverProvider() override;
+
+  virtual bool authenticated() const override;
+  virtual bool use_authorization_header() const override;
+  virtual QByteArray authorization_header() const override;

  bool StartSearch(const QString &artist, const QString &album, const QString &title, const int id) override;
  void CancelSearch(const int id) override;
-
-  bool IsAuthenticated() const override { return service_ && service_->authenticated(); }
-  void Deauthenticate() override {
-    if (service_) service_->Deauthenticate();
-  }
+  void ClearSession() override;

 private Q_SLOTS:
  void HandleSearchReply(QNetworkReply *reply, const int id, const QString &extract);

 private:
-  QByteArray GetReplyData(QNetworkReply *reply);
+  JsonObjectResult ParseJsonObject(QNetworkReply *reply);
  void Error(const QString &error, const QVariant &debug = QVariant()) override;

 private:
-  const SharedPtr<SpotifyService> service_;
-  QList<QNetworkReply*> replies_;
+  const SpotifyServicePtr service_;
 };

 #endif  // SPOTIFYCOVERPROVIDER_H
--- a/src/covermanager/tidalcoverprovider.cpp
+++ b/src/covermanager/tidalcoverprovider.cpp
@@ -1,6 +1,6 @@
 /*
 * Strawberry Music Player
- * Copyright 2018-2021, Jonas Kvinge <jonas@jkvinge.net>
+ * Copyright 2018-2025, 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
@@ -19,20 +19,17 @@

 #include "config.h"

-#include <QtGlobal>
-#include <QObject>
 #include <QList>
 #include <QVariant>
 #include <QByteArray>
 #include <QString>
 #include <QUrl>
-#include <QUrlQuery>
-#include <QNetworkRequest>
 #include <QNetworkReply>
 #include <QJsonDocument>
 #include <QJsonValue>
 #include <QJsonObject>
 #include <QJsonArray>
+#include <QScopeGuard>

 #include "includes/shared_ptr.h"
 #include "core/networkaccessmanager.h"
@@ -47,20 +44,33 @@ using namespace Qt::Literals::StringLiterals;

 namespace {
 constexpr int kLimit = 10;
-}
+}  // namespace

 TidalCoverProvider::TidalCoverProvider(const TidalServicePtr service, const SharedPtr<NetworkAccessManager> network, QObject *parent)
    : JsonCoverProvider(u"Tidal"_s, true, true, 2.5, true, true, network, parent),
      service_(service) {}

-TidalCoverProvider::~TidalCoverProvider() {
+bool TidalCoverProvider::authenticated() const {

-  while (!replies_.isEmpty()) {
-    QNetworkReply *reply = replies_.takeFirst();
-    QObject::disconnect(reply, nullptr, this, nullptr);
-    reply->abort();
-    reply->deleteLater();
-  }
+  return service_->authenticated();
+
+}
+
+bool TidalCoverProvider::use_authorization_header() const {
+
+  return true;
+
+}
+
+QByteArray TidalCoverProvider::authorization_header() const {
+
+  return service_->authorization_header();
+
+}
+
+void TidalCoverProvider::ClearSession() {
+
+  service_->ClearSession();

 }

@@ -89,20 +99,7 @@ bool TidalCoverProvider::StartSearch(const QString &artist, const QString &album
                                       << Param(u"limit"_s, QString::number(kLimit))
                                       << Param(u"countryCode"_s, service_->country_code());

-  QUrlQuery url_query;
-  for (const Param &param : params) {
-    url_query.addQueryItem(QString::fromLatin1(QUrl::toPercentEncoding(param.first)), QString::fromLatin1(QUrl::toPercentEncoding(param.second)));
-  }
-
-  QUrl url(QLatin1String(TidalService::kApiUrl) + QLatin1Char('/') + resource);
-  url.setQuery(url_query);
-  QNetworkRequest req(url);
-  req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
-  req.setHeader(QNetworkRequest::ContentTypeHeader, u"application/x-www-form-urlencoded"_s);
-  if (!service_->access_token().isEmpty()) req.setRawHeader("authorization", "Bearer " + service_->access_token().toUtf8());
-
-  QNetworkReply *reply = network_->get(req);
-  replies_ << reply;
+  QNetworkReply *reply = CreateGetRequest(QUrl(QLatin1String(TidalService::kApiUrl) + QLatin1Char('/') + resource), params);
  QObject::connect(reply, &QNetworkReply::finished, this, [this, reply, id]() { HandleSearchReply(reply, id); });

  return true;
@@ -111,52 +108,62 @@ bool TidalCoverProvider::StartSearch(const QString &artist, const QString &album

 void TidalCoverProvider::CancelSearch(const int id) { Q_UNUSED(id); }

-QByteArray TidalCoverProvider::GetReplyData(QNetworkReply *reply) {
+JsonBaseRequest::JsonObjectResult TidalCoverProvider::ParseJsonObject(QNetworkReply *reply) {

-  QByteArray data;
-
-  if (reply->error() == QNetworkReply::NoError && reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt() == 200) {
-    data = reply->readAll();
+  if (reply->error() != QNetworkReply::NoError && reply->error() < 200) {
+    return ReplyDataResult(ErrorCode::NetworkError, QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
  }
-  else {
-    if (reply->error() != QNetworkReply::NoError && reply->error() < 200) {
-      // This is a network error, there is nothing more to do.
-      Error(QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
+
+  JsonObjectResult result(ErrorCode::Success);
+  result.network_error = reply->error();
+  if (reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).isValid()) {
+    result.http_status_code = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+  }
+
+  const QByteArray data = reply->readAll();
+  bool clear_session = false;
+  if (!data.isEmpty()) {
+    QJsonParseError json_parse_error;
+    const QJsonDocument json_document = QJsonDocument::fromJson(data, &json_parse_error);
+    if (json_parse_error.error == QJsonParseError::NoError) {
+      const QJsonObject json_object = json_document.object();
+      if (json_object.contains("status"_L1) && json_object.contains("subStatus"_L1) && json_object.contains("userMessage"_L1)) {
+        const int status = json_object["status"_L1].toInt();
+        const int sub_status = json_object["subStatus"_L1].toInt();
+        const QString user_message = json_object["userMessage"_L1].toString();
+        result.error_code = ErrorCode::APIError;
+        result.api_error = status;
+        result.error_message = QStringLiteral("%1 (%2) (%3)").arg(user_message).arg(status).arg(sub_status);
+        if (status == 401 && sub_status == 6001) {
+          clear_session = true;
+        }
+      }
+      else {
+        result.json_object = json_document.object();
+      }
    }
    else {
-      // See if there is Json data containing "status" and "userMessage" - then use that instead.
-      data = reply->readAll();
-      QJsonParseError parse_error;
-      QJsonDocument json_doc = QJsonDocument::fromJson(data, &parse_error);
-      int status = 0;
-      int sub_status = 0;
-      QString error;
-      if (parse_error.error == QJsonParseError::NoError && !json_doc.isEmpty() && json_doc.isObject()) {
-        QJsonObject json_obj = json_doc.object();
-        if (!json_obj.isEmpty() && json_obj.contains("status"_L1) && json_obj.contains("userMessage"_L1)) {
-          status = json_obj["status"_L1].toInt();
-          sub_status = json_obj["subStatus"_L1].toInt();
-          QString user_message = json_obj["userMessage"_L1].toString();
-          error = QStringLiteral("%1 (%2) (%3)").arg(user_message).arg(status).arg(sub_status);
-        }
-      }
-      if (error.isEmpty()) {
-        if (reply->error() != QNetworkReply::NoError) {
-          error = QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
-        }
-        else {
-          error = QStringLiteral("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt());
-        }
-      }
-      if (status == 401 && sub_status == 6001) {  // User does not have a valid session
-        service_->Logout();
-      }
-      Error(error);
+      result.error_code = ErrorCode::ParseError;
+      result.error_message = json_parse_error.errorString();
    }
-    return QByteArray();
  }

-  return data;
+  if (result.error_code != ErrorCode::APIError) {
+    if (reply->error() != QNetworkReply::NoError) {
+      result.error_code = ErrorCode::NetworkError;
+      result.error_message = QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
+    }
+    else if (result.http_status_code != 200) {
+      result.error_code = ErrorCode::HttpError;
+      result.error_message = QStringLiteral("Received HTTP code %1").arg(result.http_status_code);
+    }
+  }
+
+  if (reply->error() == QNetworkReply::AuthenticationRequiredError || clear_session) {
+    service_->ClearSession();
+  }
+
+  return result;

 }

@@ -167,36 +174,34 @@ void TidalCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id) {
  QObject::disconnect(reply, nullptr, this, nullptr);
  reply->deleteLater();

-  QByteArray data = GetReplyData(reply);
-  if (data.isEmpty()) {
-    Q_EMIT SearchFinished(id, CoverProviderSearchResults());
+  CoverProviderSearchResults results;
+  const QScopeGuard search_finished = qScopeGuard([this, id, &results]() { Q_EMIT SearchFinished(id, results); });
+
+  const JsonObjectResult json_object_result = ParseJsonObject(reply);
+  if (!json_object_result.success()) {
+    Error(json_object_result.error_message);
    return;
  }

-  QJsonObject json_obj = ExtractJsonObj(data);
-  if (json_obj.isEmpty()) {
-    Q_EMIT SearchFinished(id, CoverProviderSearchResults());
+  const QJsonObject json_object = json_object_result.json_object;
+  if (json_object.isEmpty()) {
    return;
  }

-  if (!json_obj.contains("items"_L1)) {
-    Error(u"Json object is missing items."_s, json_obj);
-    Q_EMIT SearchFinished(id, CoverProviderSearchResults());
+  if (!json_object.contains("items"_L1)) {
+    Error(u"Json object is missing items."_s, json_object);
    return;
  }
-  QJsonValue value_items = json_obj["items"_L1];
+  const QJsonValue value_items = json_object["items"_L1];

  if (!value_items.isArray()) {
-    Q_EMIT SearchFinished(id, CoverProviderSearchResults());
    return;
  }
  const QJsonArray array_items = value_items.toArray();
  if (array_items.isEmpty()) {
-    Q_EMIT SearchFinished(id, CoverProviderSearchResults());
    return;
  }

-  CoverProviderSearchResults results;
  int i = 0;
  for (const QJsonValue &value_item : array_items) {

@@ -204,29 +209,29 @@ void TidalCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id) {
      Error(u"Invalid Json reply, items array item is not a object."_s);
      continue;
    }
-    QJsonObject obj_item = value_item.toObject();
+    const QJsonObject object_item = value_item.toObject();

-    if (!obj_item.contains("artist"_L1)) {
-      Error(u"Invalid Json reply, items array item is missing artist."_s, obj_item);
+    if (!object_item.contains("artist"_L1)) {
+      Error(u"Invalid Json reply, items array item is missing artist."_s, object_item);
      continue;
    }
-    QJsonValue value_artist = obj_item["artist"_L1];
+    const QJsonValue value_artist = object_item["artist"_L1];
    if (!value_artist.isObject()) {
      Error(u"Invalid Json reply, items array item artist is not a object."_s, value_artist);
      continue;
    }
-    QJsonObject obj_artist = value_artist.toObject();
-    if (!obj_artist.contains("name"_L1)) {
-      Error(u"Invalid Json reply, items array item artist is missing name."_s, obj_artist);
+    const QJsonObject object_artist = value_artist.toObject();
+    if (!object_artist.contains("name"_L1)) {
+      Error(u"Invalid Json reply, items array item artist is missing name."_s, object_artist);
      continue;
    }
-    QString artist = obj_artist["name"_L1].toString();
+    const QString artist = object_artist["name"_L1].toString();

-    QJsonObject obj_album;
-    if (obj_item.contains("album"_L1)) {
-      QJsonValue value_album = obj_item["album"_L1];
+    QJsonObject object_album;
+    if (object_item.contains("album"_L1)) {
+      QJsonValue value_album = object_item["album"_L1];
      if (value_album.isObject()) {
-        obj_album = value_album.toObject();
+        object_album = value_album.toObject();
      }
      else {
        Error(u"Invalid Json reply, items array item album is not a object."_s, value_album);
@@ -234,15 +239,15 @@ void TidalCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id) {
      }
    }
    else {
-      obj_album = obj_item;
+      object_album = object_item;
    }

-    if (!obj_album.contains("title"_L1) || !obj_album.contains("cover"_L1)) {
-      Error(u"Invalid Json reply, items array item album is missing title or cover."_s, obj_album);
+    if (!object_album.contains("title"_L1) || !object_album.contains("cover"_L1)) {
+      Error(u"Invalid Json reply, items array item album is missing title or cover."_s, object_album);
      continue;
    }
-    QString album = obj_album["title"_L1].toString();
-    QString cover = obj_album["cover"_L1].toString().replace("-"_L1, "/"_L1);
+    const QString album = object_album["title"_L1].toString();
+    const QString cover = object_album["cover"_L1].toString().replace("-"_L1, "/"_L1);

    CoverProviderSearchResult cover_result;
    cover_result.artist = artist;
@@ -260,7 +265,6 @@ void TidalCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id) {
    }

  }
-  Q_EMIT SearchFinished(id, results);

 }

--- a/src/covermanager/tidalcoverprovider.h
+++ b/src/covermanager/tidalcoverprovider.h
@@ -1,6 +1,6 @@
 /*
 * Strawberry Music Player
- * Copyright 2018-2021, Jonas Kvinge <jonas@jkvinge.net>
+ * Copyright 2018-2025, 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
@@ -22,48 +22,41 @@

 #include "config.h"

-#include <QObject>
-#include <QPair>
-#include <QSet>
-#include <QList>
 #include <QVariant>
-#include <QByteArray>
 #include <QString>
-#include <QJsonValue>
-#include <QJsonObject>

 #include "includes/shared_ptr.h"
 #include "jsoncoverprovider.h"
-#include "tidal/tidalservice.h"

 class QNetworkReply;
 class NetworkAccessManager;
+class TidalService;
+
+using TidalServicePtr = SharedPtr<TidalService>;

 class TidalCoverProvider : public JsonCoverProvider {
  Q_OBJECT

 public:
  explicit TidalCoverProvider(const TidalServicePtr service, const SharedPtr<NetworkAccessManager> network, QObject *parent = nullptr);
-  ~TidalCoverProvider() override;
+
+  virtual bool authenticated() const override;
+  virtual bool use_authorization_header() const override;
+  virtual QByteArray authorization_header() const override;

  bool StartSearch(const QString &artist, const QString &album, const QString &title, const int id) override;
  void CancelSearch(const int id) override;
-
-  bool IsAuthenticated() const override { return service_ && service_->authenticated(); }
-  void Deauthenticate() override {
-    if (service_) service_->Logout();
-  }
+  void ClearSession() override;

 private Q_SLOTS:
  void HandleSearchReply(QNetworkReply *reply, const int id);

 private:
-  QByteArray GetReplyData(QNetworkReply *reply);
+  JsonObjectResult ParseJsonObject(QNetworkReply *reply);
  void Error(const QString &error, const QVariant &debug = QVariant()) override;

 private:
  const TidalServicePtr service_;
-  QList<QNetworkReply*> replies_;
 };

 #endif  // TIDALCOVERPROVIDER_H