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

Disable automatic conversions from 8-bit strings

Browse Source
This commit is contained in:
Jonas Kvinge
2024-04-11 02:56:01 +02:00
parent 58944993b8
commit 0c6872b352
310 changed files with 2501 additions and 2332 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
src/qobuz/qobuzbaserequest.cpp
View File

@@ -52,20 +52,20 @@ QobuzBaseRequest::~QobuzBaseRequest() = default;
QNetworkReply *QobuzBaseRequest::CreateRequest(const QString &ressource_name, const ParamList &params_provided) {
ParamList params = ParamList() << params_provided
<< Param("app_id", app_id());
<< Param(QStringLiteral("app_id"), app_id());
std::sort(params.begin(), params.end());
QUrlQuery url_query;
for (const Param &param : params) {
url_query.addQueryItem(QUrl::toPercentEncoding(param.first), QUrl::toPercentEncoding(param.second));
url_query.addQueryItem(QString::fromLatin1(QUrl::toPercentEncoding(param.first)), QString::fromLatin1(QUrl::toPercentEncoding(param.second)));
}
QUrl url(QString(QobuzService::kApiUrl) + QStringLiteral("/") + ressource_name);
QUrl url(QString::fromLatin1(QobuzService::kApiUrl) + QLatin1Char('/') + ressource_name);
url.setQuery(url_query);
QNetworkRequest req(url);
req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
req.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
req.setHeader(QNetworkRequest::ContentTypeHeader, QStringLiteral("application/x-www-form-urlencoded"));
req.setRawHeader("X-App-Id", app_id().toUtf8());
if (authenticated()) req.setRawHeader("X-User-Auth-Token", user_auth_token().toUtf8());
@@ -182,7 +182,7 @@ QString QobuzBaseRequest::ErrorsToHTML(const QStringList &errors) {
QString error_html;
for (const QString &error : errors) {
error_html += error + "<br />";
error_html += error + QStringLiteral("<br />");
}
return error_html;

16
src/qobuz/qobuzfavoriterequest.cpp
View File

@@ -132,13 +132,13 @@ void QobuzFavoriteRequest::AddFavorites(const FavoriteType type, const SongList
void QobuzFavoriteRequest::AddFavoritesRequest(const FavoriteType type, const QStringList &ids_list, const SongList &songs) {
ParamList params = ParamList() << Param("app_id", app_id())
<< Param("user_auth_token", user_auth_token())
<< Param(FavoriteMethod(type), ids_list.join(','));
ParamList params = ParamList() << Param(QStringLiteral("app_id"), app_id())
<< Param(QStringLiteral("user_auth_token"), user_auth_token())
<< Param(FavoriteMethod(type), ids_list.join(QLatin1Char(',')));
QUrlQuery url_query;
for (const Param &param : params) {
url_query.addQueryItem(QUrl::toPercentEncoding(param.first), QUrl::toPercentEncoding(param.second));
url_query.addQueryItem(QString::fromLatin1(QUrl::toPercentEncoding(param.first)), QString::fromLatin1(QUrl::toPercentEncoding(param.second)));
}
QNetworkReply *reply = CreateRequest(QStringLiteral("favorite/create"), params);
@@ -227,13 +227,13 @@ void QobuzFavoriteRequest::RemoveFavorites(const FavoriteType type, const SongLi
void QobuzFavoriteRequest::RemoveFavoritesRequest(const FavoriteType type, const QStringList &ids_list, const SongList &songs) {
ParamList params = ParamList() << Param("app_id", app_id())
<< Param("user_auth_token", user_auth_token())
<< Param(FavoriteMethod(type), ids_list.join(','));
ParamList params = ParamList() << Param(QStringLiteral("app_id"), app_id())
<< Param(QStringLiteral("user_auth_token"), user_auth_token())
<< Param(FavoriteMethod(type), ids_list.join(QLatin1Char(',')));
QUrlQuery url_query;
for (const Param &param : params) {
url_query.addQueryItem(QUrl::toPercentEncoding(param.first), QUrl::toPercentEncoding(param.second));
url_query.addQueryItem(QString::fromLatin1(QUrl::toPercentEncoding(param.first)), QString::fromLatin1(QUrl::toPercentEncoding(param.second)));
}
QNetworkReply *reply = CreateRequest(QStringLiteral("favorite/delete"), params);

62
src/qobuz/qobuzrequest.cpp
View File

@@ -47,13 +47,15 @@
#include "qobuzbaserequest.h"
#include "qobuzrequest.h"
constexpr int QobuzRequest::kMaxConcurrentArtistsRequests = 3;
constexpr int QobuzRequest::kMaxConcurrentAlbumsRequests = 3;
constexpr int QobuzRequest::kMaxConcurrentSongsRequests = 3;
constexpr int QobuzRequest::kMaxConcurrentArtistAlbumsRequests = 3;
constexpr int QobuzRequest::kMaxConcurrentAlbumSongsRequests = 3;
constexpr int QobuzRequest::kMaxConcurrentAlbumCoverRequests = 1;
constexpr int QobuzRequest::kFlushRequestsDelay = 200;
namespace {
constexpr int kMaxConcurrentArtistsRequests = 3;
constexpr int kMaxConcurrentAlbumsRequests = 3;
constexpr int kMaxConcurrentSongsRequests = 3;
constexpr int kMaxConcurrentArtistAlbumsRequests = 3;
constexpr int kMaxConcurrentAlbumSongsRequests = 3;
constexpr int kMaxConcurrentAlbumCoverRequests = 1;
constexpr int kFlushRequestsDelay = 200;
} // namespace
QobuzRequest::QobuzRequest(QobuzService *service, QobuzUrlHandler *url_handler, Application *app, SharedPtr<NetworkAccessManager> network, const QueryType query_type, QObject *parent)
: QobuzBaseRequest(service, network, parent),
@@ -225,12 +227,12 @@ void QobuzRequest::FlushArtistsRequests() {
ParamList params;
if (query_type_ == QueryType::Artists) {
params << Param("type", "artists");
params << Param("user_auth_token", user_auth_token());
params << Param(QStringLiteral("type"), QStringLiteral("artists"));
params << Param(QStringLiteral("user_auth_token"), user_auth_token());
}
else if (query_type_ == QueryType::SearchArtists) params << Param("query", search_text_);
if (request.limit > 0) params << Param("limit", QString::number(request.limit));
if (request.offset > 0) params << Param("offset", QString::number(request.offset));
else if (query_type_ == QueryType::SearchArtists) params << Param(QStringLiteral("query"), search_text_);
if (request.limit > 0) params << Param(QStringLiteral("limit"), QString::number(request.limit));
if (request.offset > 0) params << Param(QStringLiteral("offset"), QString::number(request.offset));
QNetworkReply *reply = nullptr;
if (query_type_ == QueryType::Artists) {
reply = CreateRequest(QStringLiteral("favorite/getUserFavorites"), params);
@@ -277,12 +279,12 @@ void QobuzRequest::FlushAlbumsRequests() {
ParamList params;
if (query_type_ == QueryType::Albums) {
params << Param("type", "albums");
params << Param("user_auth_token", user_auth_token());
params << Param(QStringLiteral("type"), QStringLiteral("albums"));
params << Param(QStringLiteral("user_auth_token"), user_auth_token());
}
else if (query_type_ == QueryType::SearchAlbums) params << Param("query", search_text_);
if (request.limit > 0) params << Param("limit", QString::number(request.limit));
if (request.offset > 0) params << Param("offset", QString::number(request.offset));
else if (query_type_ == QueryType::SearchAlbums) params << Param(QStringLiteral("query"), search_text_);
if (request.limit > 0) params << Param(QStringLiteral("limit"), QString::number(request.limit));
if (request.offset > 0) params << Param(QStringLiteral("offset"), QString::number(request.offset));
QNetworkReply *reply = nullptr;
if (query_type_ == QueryType::Albums) {
reply = CreateRequest(QStringLiteral("favorite/getUserFavorites"), params);
@@ -329,12 +331,12 @@ void QobuzRequest::FlushSongsRequests() {
ParamList params;
if (query_type_ == QueryType::Songs) {
params << Param("type", "tracks");
params << Param("user_auth_token", user_auth_token());
params << Param(QStringLiteral("type"), QStringLiteral("tracks"));
params << Param(QStringLiteral("user_auth_token"), user_auth_token());
}
else if (query_type_ == QueryType::SearchSongs) params << Param("query", search_text_);
if (request.limit > 0) params << Param("limit", QString::number(request.limit));
if (request.offset > 0) params << Param("offset", QString::number(request.offset));
else if (query_type_ == QueryType::SearchSongs) params << Param(QStringLiteral("query"), search_text_);
if (request.limit > 0) params << Param(QStringLiteral("limit"), QString::number(request.limit));
if (request.offset > 0) params << Param(QStringLiteral("offset"), QString::number(request.offset));
QNetworkReply *reply = nullptr;
if (query_type_ == QueryType::Songs) {
reply = CreateRequest(QStringLiteral("favorite/getUserFavorites"), params);
@@ -585,10 +587,10 @@ void QobuzRequest::FlushArtistAlbumsRequests() {
const ArtistAlbumsRequest request = artist_albums_requests_queue_.dequeue();
ParamList params = ParamList() << Param("artist_id", request.artist.artist_id)
<< Param("extra", "albums");
ParamList params = ParamList() << Param(QStringLiteral("artist_id"), request.artist.artist_id)
<< Param(QStringLiteral("extra"), QStringLiteral("albums"));
if (request.offset > 0) params << Param("offset", QString::number(request.offset));
if (request.offset > 0) params << Param(QStringLiteral("offset"), QString::number(request.offset));
QNetworkReply *reply = CreateRequest(QStringLiteral("artist/get"), params);
QObject::connect(reply, &QNetworkReply::finished, this, [this, reply, request]() { ArtistAlbumsReplyReceived(reply, request.artist, request.offset); });
replies_ << reply;
@@ -842,8 +844,8 @@ void QobuzRequest::FlushAlbumSongsRequests() {
while (!album_songs_requests_queue_.isEmpty() && album_songs_requests_active_ < kMaxConcurrentAlbumSongsRequests) {
AlbumSongsRequest request = album_songs_requests_queue_.dequeue();
ParamList params = ParamList() << Param("album_id", request.album.album_id);
if (request.offset > 0) params << Param("offset", QString::number(request.offset));
ParamList params = ParamList() << Param(QStringLiteral("album_id"), request.album.album_id);
if (request.offset > 0) params << Param(QStringLiteral("offset"), QString::number(request.offset));
QNetworkReply *reply = CreateRequest(QStringLiteral("album/get"), params);
replies_ << reply;
QObject::connect(reply, &QNetworkReply::finished, this, [this, reply, request]() { AlbumSongsReplyReceived(reply, request.artist, request.album, request.offset); });
@@ -1341,8 +1343,8 @@ void QobuzRequest::AlbumCoverReceived(QNetworkReply *reply, const QUrl &cover_ur
}
QString mimetype = reply->header(QNetworkRequest::ContentTypeHeader).toString();
if (mimetype.contains(';')) {
mimetype = mimetype.left(mimetype.indexOf(';'));
if (mimetype.contains(QLatin1Char(';'))) {
mimetype = mimetype.left(mimetype.indexOf(QLatin1Char(';')));
}
if (!ImageUtils::SupportedImageMimeTypes().contains(mimetype, Qt::CaseInsensitive) && !ImageUtils::SupportedImageFormats().contains(mimetype, Qt::CaseInsensitive)) {
Error(QStringLiteral("Unsupported mimetype for image reader %1 for %2").arg(mimetype, cover_url.toString()));
@@ -1351,7 +1353,7 @@ void QobuzRequest::AlbumCoverReceived(QNetworkReply *reply, const QUrl &cover_ur
return;
}
QByteArray data = reply->readAll();
const QByteArray data = reply->readAll();
if (data.isEmpty()) {
Error(QStringLiteral("Received empty image data for %1").arg(cover_url.toString()));
if (album_covers_requests_sent_.contains(cover_url)) album_covers_requests_sent_.remove(cover_url);

8
src/qobuz/qobuzrequest.h
View File

@@ -171,14 +171,6 @@ class QobuzRequest : public QobuzBaseRequest {
static void Warn(const QString &error, const QVariant &debug = QVariant());
void Error(const QString &error, const QVariant &debug = QVariant()) override;
static const int kMaxConcurrentArtistsRequests;
static const int kMaxConcurrentAlbumsRequests;
static const int kMaxConcurrentSongsRequests;
static const int kMaxConcurrentArtistAlbumsRequests;
static const int kMaxConcurrentAlbumSongsRequests;
static const int kMaxConcurrentAlbumCoverRequests;
static const int kFlushRequestsDelay;
QobuzService *service_;
QobuzUrlHandler *url_handler_;
Application *app_;

57
src/qobuz/qobuzservice.cpp
View File

@@ -45,6 +45,7 @@
#include "core/networkaccessmanager.h"
#include "core/database.h"
#include "core/song.h"
#include "core/settings.h"
#include "utilities/macaddrutils.h"
#include "internet/internetsearchview.h"
#include "collection/collectionbackend.h"
@@ -62,22 +63,26 @@ using std::make_shared;
const Song::Source QobuzService::kSource = Song::Source::Qobuz;
const char QobuzService::kApiUrl[] = "https://www.qobuz.com/api.json/0.2";
constexpr char QobuzService::kAuthUrl[] = "https://www.qobuz.com/api.json/0.2/user/login";
const int QobuzService::kLoginAttempts = 2;
constexpr int QobuzService::kTimeResetLoginAttempts = 60000;
constexpr char QobuzService::kArtistsSongsTable[] = "qobuz_artists_songs";
constexpr char QobuzService::kAlbumsSongsTable[] = "qobuz_albums_songs";
constexpr char QobuzService::kSongsTable[] = "qobuz_songs";
namespace {
constexpr char QobuzService::kArtistsSongsFtsTable[] = "qobuz_artists_songs_fts";
constexpr char QobuzService::kAlbumsSongsFtsTable[] = "qobuz_albums_songs_fts";
constexpr char QobuzService::kSongsFtsTable[] = "qobuz_songs_fts";
constexpr char kAuthUrl[] = "https://www.qobuz.com/api.json/0.2/user/login";
constexpr int kTimeResetLoginAttempts = 60000;
constexpr char kArtistsSongsTable[] = "qobuz_artists_songs";
constexpr char kAlbumsSongsTable[] = "qobuz_albums_songs";
constexpr char kSongsTable[] = "qobuz_songs";
constexpr char kArtistsSongsFtsTable[] = "qobuz_artists_songs_fts";
constexpr char kAlbumsSongsFtsTable[] = "qobuz_albums_songs_fts";
constexpr char kSongsFtsTable[] = "qobuz_songs_fts";
} // namespace
QobuzService::QobuzService(Application *app, QObject *parent)
: InternetService(Song::Source::Qobuz, QStringLiteral("Qobuz"), QStringLiteral("qobuz"), QobuzSettingsPage::kSettingsGroup, SettingsDialog::Page::Qobuz, app, parent),
: InternetService(Song::Source::Qobuz, QStringLiteral("Qobuz"), QStringLiteral("qobuz"), QLatin1String(QobuzSettingsPage::kSettingsGroup), SettingsDialog::Page::Qobuz, app, parent),
app_(app),
network_(app->network()),
url_handler_(new QobuzUrlHandler(app, this)),
@@ -115,15 +120,15 @@ QobuzService::QobuzService(Application *app, QObject *parent)
artists_collection_backend_ = make_shared<CollectionBackend>();
artists_collection_backend_->moveToThread(app_->database()->thread());
artists_collection_backend_->Init(app_->database(), app->task_manager(), Song::Source::Qobuz, kArtistsSongsTable, kArtistsSongsFtsTable);
artists_collection_backend_->Init(app_->database(), app->task_manager(), Song::Source::Qobuz, QLatin1String(kArtistsSongsTable), QLatin1String(kArtistsSongsFtsTable));
albums_collection_backend_ = make_shared<CollectionBackend>();
albums_collection_backend_->moveToThread(app_->database()->thread());
albums_collection_backend_->Init(app_->database(), app->task_manager(), Song::Source::Qobuz, kAlbumsSongsTable, kAlbumsSongsFtsTable);
albums_collection_backend_->Init(app_->database(), app->task_manager(), Song::Source::Qobuz, QLatin1String(kAlbumsSongsTable), QLatin1String(kAlbumsSongsFtsTable));
songs_collection_backend_ = make_shared<CollectionBackend>();
songs_collection_backend_->moveToThread(app_->database()->thread());
songs_collection_backend_->Init(app_->database(), app->task_manager(), Song::Source::Qobuz, kSongsTable, kSongsFtsTable);
songs_collection_backend_->Init(app_->database(), app->task_manager(), Song::Source::Qobuz, QLatin1String(kSongsTable), QLatin1String(kSongsFtsTable));
artists_collection_model_ = new CollectionModel(artists_collection_backend_, app_, this);
albums_collection_model_ = new CollectionModel(albums_collection_backend_, app_, this);
@@ -229,7 +234,7 @@ void QobuzService::ShowConfig() {
void QobuzService::ReloadSettings() {
QSettings s;
Settings s;
s.beginGroup(QobuzSettingsPage::kSettingsGroup);
app_id_ = s.value("app_id").toString();
@@ -295,21 +300,21 @@ void QobuzService::SendLoginWithCredentials(const QString &app_id, const QString
timer_login_attempt_->setInterval(kTimeResetLoginAttempts);
timer_login_attempt_->start();
const ParamList params = ParamList() << Param("app_id", app_id)
<< Param("username", username)
<< Param("password", password)
<< Param("device_manufacturer_id", Utilities::MacAddress());
const ParamList params = ParamList() << Param(QStringLiteral("app_id"), app_id)
<< Param(QStringLiteral("username"), username)
<< Param(QStringLiteral("password"), password)
<< Param(QStringLiteral("device_manufacturer_id"), Utilities::MacAddress());
QUrlQuery url_query;
for (const Param &param : params) {
url_query.addQueryItem(QUrl::toPercentEncoding(param.first), QUrl::toPercentEncoding(param.second));
url_query.addQueryItem(QString::fromLatin1(QUrl::toPercentEncoding(param.first)), QString::fromLatin1(QUrl::toPercentEncoding(param.second)));
}
QUrl url(kAuthUrl);
QUrl url(QString::fromLatin1(kAuthUrl));
QNetworkRequest req(url);
req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
req.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
req.setHeader(QNetworkRequest::ContentTypeHeader, QStringLiteral("application/x-www-form-urlencoded"));
QByteArray query = url_query.toString(QUrl::FullyEncoded).toUtf8();
QNetworkReply *reply = network_->post(req, query);
@@ -369,7 +374,7 @@ void QobuzService::HandleAuthReply(QNetworkReply *reply) {
login_errors_.clear();
QByteArray data = reply->readAll();
const QByteArray data = reply->readAll();
QJsonParseError json_error;
QJsonDocument json_doc = QJsonDocument::fromJson(data, &json_error);
@@ -451,7 +456,7 @@ void QobuzService::HandleAuthReply(QNetworkReply *reply) {
}
credential_id_ = obj_credential[QStringLiteral("id")].toInt();
QSettings s;
Settings s;
s.beginGroup(QobuzSettingsPage::kSettingsGroup);
s.setValue("user_auth_token", user_auth_token_);
s.setValue("user_id", user_id_);
@@ -476,7 +481,7 @@ void QobuzService::Logout() {
user_id_ = -1;
credential_id_ = -1;
QSettings s;
Settings s;
s.beginGroup(QobuzSettingsPage::kSettingsGroup);
s.remove("user_id");
s.remove("credential_id");
@@ -784,7 +789,7 @@ void QobuzService::LoginError(const QString &error, const QVariant &debug) {
QString error_html;
for (const QString &e : login_errors_) {
qLog(Error) << "Qobuz:" << e;
error_html += e + "<br />";
error_html += e + QStringLiteral("<br />");
}
if (debug.isValid()) qLog(Debug) << debug;

14
src/qobuz/qobuzservice.h
View File

@@ -63,6 +63,7 @@ class QobuzService : public InternetService {
static const Song::Source kSource;
static const char kApiUrl[];
static const int kLoginAttempts;
void Exit() override;
void ReloadSettings() override;
@@ -147,19 +148,6 @@ class QobuzService : public InternetService {
void SendSearch();
void LoginError(const QString &error = QString(), const QVariant &debug = QVariant());
static const char kAuthUrl[];
static const int kLoginAttempts;
static const int kTimeResetLoginAttempts;
static const char kArtistsSongsTable[];
static const char kAlbumsSongsTable[];
static const char kSongsTable[];
static const char kArtistsSongsFtsTable[];
static const char kAlbumsSongsFtsTable[];
static const char kSongsFtsTable[];
Application *app_;
SharedPtr<NetworkAccessManager> network_;
QobuzUrlHandler *url_handler_;

18
src/qobuz/qobuzstreamurlrequest.cpp
View File

@@ -115,26 +115,26 @@ void QobuzStreamURLRequest::GetStreamURL() {
quint64 timestamp = QDateTime::currentDateTime().toSecsSinceEpoch();
ParamList params_to_sign = ParamList() << Param("format_id", QString::number(format()))
<< Param("track_id", QString::number(song_id_));
ParamList params_to_sign = ParamList() << Param(QStringLiteral("format_id"), QString::number(format()))
<< Param(QStringLiteral("track_id"), QString::number(song_id_));
std::sort(params_to_sign.begin(), params_to_sign.end());
QString data_to_sign;
data_to_sign += QLatin1String("trackgetFileUrl");
data_to_sign += QStringLiteral("trackgetFileUrl");
for (const Param &param : params_to_sign) {
data_to_sign += param.first + param.second;
}
data_to_sign += QString::number(timestamp);
data_to_sign += app_secret().toUtf8();
data_to_sign += app_secret();
QByteArray const digest = QCryptographicHash::hash(data_to_sign.toUtf8(), QCryptographicHash::Md5);
QString signature = QString::fromLatin1(digest.toHex()).rightJustified(32, '0').toLower();
const QString signature = QString::fromLatin1(digest.toHex()).rightJustified(32, QLatin1Char('0')).toLower();
ParamList params = params_to_sign;
params << Param("request_ts", QString::number(timestamp));
params << Param("request_sig", signature);
params << Param("user_auth_token", user_auth_token());
params << Param(QStringLiteral("request_ts"), QString::number(timestamp));
params << Param(QStringLiteral("request_sig"), signature);
params << Param(QStringLiteral("user_auth_token"), user_auth_token());
std::sort(params.begin(), params.end());
@@ -192,7 +192,7 @@ void QobuzStreamURLRequest::StreamURLReceived() {
Song::FileType filetype(Song::FileType::Unknown);
QMimeDatabase mimedb;
QStringList suffixes = mimedb.mimeTypeForName(mimetype.toUtf8()).suffixes();
QStringList suffixes = mimedb.mimeTypeForName(mimetype).suffixes();
for (const QString &suffix : suffixes) {
filetype = Song::FiletypeByExtension(suffix);
if (filetype != Song::FileType::Unknown) break;