dryark/strawberry
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor Tidal, Spotify, Qobuz, Subsonic and cover providers

Browse Source 
Use common HTTP, Json and OAuthenticator class
This commit is contained in:
Jonas Kvinge
2025-03-08 23:11:07 +01:00
parent 7de8a44709
commit cd516c37b9
81 changed files with 2429 additions and 3968 deletions
Download Patch File Download Diff File Expand all files Collapse all files

222
src/covermanager/spotifycoverprovider.cpp
View File

@@ -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);
}