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

220
src/tidal/tidalbaserequest.cpp
View File

@@ -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,11 @@
#include "config.h"
#include <QObject>
#include <QByteArray>
#include <QPair>
#include <QList>
#include <QString>
#include <QUrl>
#include <QUrlQuery>
#include <QNetworkRequest>
#include <QNetworkReply>
#include <QSslError>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonArray>
#include <QJsonValue>
#include <QJsonObject>
#include "includes/shared_ptr.h"
#include "core/logging.h"
@@ -43,150 +34,103 @@
using namespace Qt::Literals::StringLiterals;
TidalBaseRequest::TidalBaseRequest(TidalService *service, const SharedPtr<NetworkAccessManager> network, QObject *parent)
: QObject(parent),
: JsonBaseRequest(network, parent),
service_(service),
network_(network) {}
QString TidalBaseRequest::service_name() const {
return service_->name();
}
bool TidalBaseRequest::authentication_required() const {
return true;
}
bool TidalBaseRequest::authenticated() const {
return service_->authenticated();
}
bool TidalBaseRequest::use_authorization_header() const {
return true;
}
QByteArray TidalBaseRequest::authorization_header() const {
return service_->authorization_header();
}
QNetworkReply *TidalBaseRequest::CreateRequest(const QString &ressource_name, const ParamList &params_provided) {
const ParamList params = ParamList() << params_provided
<< Param(u"countryCode"_s, 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('/') + ressource_name);
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 (!token_type().isEmpty() && !access_token().isEmpty()) {
req.setRawHeader("Authorization", token_type().toUtf8() + " " + access_token().toUtf8());
}
QNetworkReply *reply = network_->get(req);
QObject::connect(reply, &QNetworkReply::sslErrors, this, &TidalBaseRequest::HandleSSLErrors);
//qLog(Debug) << "Tidal: Sending request" << url;
return reply;
<< Param(u"countryCode"_s, service_->country_code());
return CreateGetRequest(QUrl(QLatin1String(TidalService::kApiUrl) + QLatin1Char('/') + ressource_name), params);
}
void TidalBaseRequest::HandleSSLErrors(const QList<QSslError> &ssl_errors) {
JsonBaseRequest::JsonObjectResult TidalBaseRequest::ParseJsonObject(QNetworkReply *reply) {
for (const QSslError &ssl_error : ssl_errors) {
Error(ssl_error.errorString());
if (reply->error() != QNetworkReply::NoError && reply->error() < 200) {
return ReplyDataResult(ErrorCode::NetworkError, QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
}
}
QByteArray TidalBaseRequest::GetReplyData(QNetworkReply *reply) {
QByteArray data;
if (reply->error() == QNetworkReply::NoError && reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt() == 200) {
data = reply->readAll();
JsonObjectResult result(ErrorCode::Success);
result.network_error = reply->error();
if (reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).isValid()) {
result.http_status_code = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
}
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()));
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();
QString error;
QJsonParseError json_error;
QJsonDocument json_doc = QJsonDocument::fromJson(data, &json_error);
int status = 0;
int sub_status = 0;
if (json_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;
}
QJsonObject TidalBaseRequest::ExtractJsonObj(const QByteArray &data) {
QJsonParseError json_error;
QJsonDocument json_doc = QJsonDocument::fromJson(data, &json_error);
if (json_error.error != QJsonParseError::NoError) {
Error(u"Reply from server missing Json data."_s, data);
return QJsonObject();
}
if (json_doc.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);
return QJsonObject();
}
QJsonObject json_obj = json_doc.object();
if (json_obj.isEmpty()) {
Error(u"Received empty Json object."_s, json_doc);
return QJsonObject();
}
return json_obj;
}
QJsonValue TidalBaseRequest::ExtractItems(const QByteArray &data) {
QJsonObject json_obj = ExtractJsonObj(data);
if (json_obj.isEmpty()) return QJsonValue();
return ExtractItems(json_obj);
}
QJsonValue TidalBaseRequest::ExtractItems(const QJsonObject &json_obj) {
if (!json_obj.contains("items"_L1)) {
Error(u"Json reply is missing items."_s, json_obj);
return QJsonArray();
}
QJsonValue json_items = json_obj["items"_L1];
return json_items;
}
QString TidalBaseRequest::ErrorsToHTML(const QStringList &errors) {
QString error_html;
for (const QString &error : errors) {
error_html += error + "<br />"_L1;
}
return error_html;
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;
}