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

Replace QLatin1String with operator _L1

Browse Source
This commit is contained in:
Jonas Kvinge
2024-09-07 04:24:14 +02:00
parent e3e6a22172
commit 4270b12cd1
185 changed files with 2429 additions and 2139 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
src/covermanager/albumcoverchoicecontroller.cpp
View File

@@ -79,6 +79,8 @@
#include "coverfromurldialog.h"
#include "currentalbumcoverloader.h"
using namespace Qt::StringLiterals;
const char *AlbumCoverChoiceController::kLoadImageFileFilter = QT_TR_NOOP("Images (*.png *.jpg *.jpeg *.bmp *.gif *.xpm *.pbm *.pgm *.ppm *.xbm)");
const char *AlbumCoverChoiceController::kSaveImageFileFilter = QT_TR_NOOP("Images (*.png *.jpg *.jpeg *.bmp *.xpm *.pbm *.ppm *.xbm)");
const char *AlbumCoverChoiceController::kAllFilesFilter = QT_TR_NOOP("All files (*)");
@@ -233,12 +235,12 @@ QUrl AlbumCoverChoiceController::LoadCoverFromFile(Song *song) {
void AlbumCoverChoiceController::SaveCoverToFileManual(const Song &song, const AlbumCoverImageResult &result) {
QString initial_file_name = QLatin1String("/");
QString initial_file_name = "/"_L1;
if (!song.effective_albumartist().isEmpty()) {
initial_file_name = initial_file_name + song.effective_albumartist();
}
initial_file_name = initial_file_name + QLatin1Char('-') + (song.effective_album().isEmpty() ? tr("unknown") : song.effective_album()) + QLatin1String(".jpg");
initial_file_name = initial_file_name + QLatin1Char('-') + (song.effective_album().isEmpty() ? tr("unknown") : song.effective_album()) + ".jpg"_L1;
initial_file_name = initial_file_name.toLower();
static const QRegularExpression regex_whitespaces(QStringLiteral("\\s"));
initial_file_name.replace(regex_whitespaces, QStringLiteral("-"));
@@ -251,16 +253,16 @@ void AlbumCoverChoiceController::SaveCoverToFileManual(const Song &song, const A
QFileInfo fileinfo(save_filename);
if (fileinfo.suffix().isEmpty()) {
save_filename.append(QLatin1String(".jpg"));
save_filename.append(".jpg"_L1);
fileinfo.setFile(save_filename);
}
if (!QImageWriter::supportedImageFormats().contains(fileinfo.completeSuffix().toUtf8().toLower())) {
save_filename = Utilities::PathWithoutFilenameExtension(save_filename) + QLatin1String(".jpg");
save_filename = Utilities::PathWithoutFilenameExtension(save_filename) + ".jpg"_L1;
fileinfo.setFile(save_filename);
}
if (result.is_jpeg() && fileinfo.completeSuffix().compare(QLatin1String("jpg"), Qt::CaseInsensitive) == 0) {
if (result.is_jpeg() && fileinfo.completeSuffix().compare("jpg"_L1, Qt::CaseInsensitive) == 0) {
QFile file(save_filename);
if (!file.open(QIODevice::WriteOnly)) {
qLog(Error) << "Failed to open cover file" << save_filename << "for writing:" << file.errorString();
@@ -294,8 +296,8 @@ QString AlbumCoverChoiceController::GetInitialPathForFileDialog(const Song &song
}
// If no automatic art, start in the song's folder
if (!song.url().isEmpty() && song.url().isValid() && song.url().isLocalFile() && song.url().toLocalFile().contains(QLatin1Char('/'))) {
return song.url().toLocalFile().section(QLatin1Char('/'), 0, -2) + filename;
if (!song.url().isEmpty() && song.url().isValid() && song.url().isLocalFile() && song.url().toLocalFile().contains(u'/')) {
return song.url().toLocalFile().section(u'/', 0, -2) + filename;
}
return QDir::home().absolutePath() + filename;
@@ -478,13 +480,13 @@ void AlbumCoverChoiceController::ShowCover(const Song &song, const QPixmap &pixm
// Use Artist - Album as the window title
QString title_text(song.effective_albumartist());
if (!song.effective_album().isEmpty()) title_text += QLatin1String(" - ") + song.effective_album();
if (!song.effective_album().isEmpty()) title_text += " - "_L1 + song.effective_album();
QLabel *label = new QLabel(dialog);
label->setPixmap(pixmap);
// Add (WxHpx) to the title before possibly resizing
title_text += QLatin1String(" (") + QString::number(pixmap.width()) + QLatin1Char('x') + QString::number(pixmap.height()) + QLatin1String("px)");
title_text += QLatin1String(" (") + QString::number(pixmap.width()) + QLatin1Char('x') + QString::number(pixmap.height()) + "px)"_L1;
// If the cover is larger than the screen, resize the window 85% seems to be enough to account for title bar and taskbar etc.
QScreen *screen = Utilities::GetScreen(this);
@@ -666,7 +668,7 @@ QUrl AlbumCoverChoiceController::SaveCoverToFileAutomatic(const Song::Source sou
if (source == Song::Source::Collection && !cover_options_.cover_overwrite && !force_overwrite && get_save_album_cover_type() == CoverOptions::CoverType::Album && cover_options_.cover_filename == CoverOptions::CoverFilename::Pattern && file.exists()) {
while (file.exists()) {
QFileInfo fileinfo(file.fileName());
file.setFileName(fileinfo.path() + QLatin1String("/0") + fileinfo.fileName());
file.setFileName(fileinfo.path() + "/0"_L1 + fileinfo.fileName());
}
filepath = file.fileName();
}

6
src/covermanager/albumcoverexport.cpp
View File

@@ -35,6 +35,8 @@
#include "core/settings.h"
using namespace Qt::StringLiterals;
const char *AlbumCoverExport::kSettingsGroup = "AlbumCoverExport";
AlbumCoverExport::AlbumCoverExport(QWidget *parent) : QDialog(parent), ui_(new Ui_AlbumCoverExport) {
@@ -62,8 +64,8 @@ AlbumCoverExport::DialogResult AlbumCoverExport::Exec() {
ui_->overwriteAll->setChecked(static_cast<OverwriteMode>(s.value("overwrite", static_cast<int>(OverwriteMode::All)).toInt()) == OverwriteMode::All);
ui_->overwriteSmaller->setChecked(static_cast<OverwriteMode>(s.value("overwrite", static_cast<int>(OverwriteMode::Smaller)).toInt()) == OverwriteMode::Smaller);
ui_->forceSize->setChecked(s.value("forceSize", false).toBool());
ui_->width->setText(s.value("width", QLatin1String("")).toString());
ui_->height->setText(s.value("height", QLatin1String("")).toString());
ui_->width->setText(s.value("width", ""_L1).toString());
ui_->height->setText(s.value("height", ""_L1).toString());
ui_->export_downloaded->setChecked(s.value("export_downloaded", true).toBool());
ui_->export_embedded->setChecked(s.value("export_embedded", false).toBool());

92
src/covermanager/albumcoverfetchersearch.cpp
View File

@@ -48,6 +48,8 @@
#include "coverproviders.h"
#include "albumcoverimageresult.h"
using namespace Qt::StringLiterals;
namespace {
constexpr int kSearchTimeoutMs = 20000;
constexpr int kImageLoadTimeoutMs = 6000;
@@ -86,7 +88,7 @@ void AlbumCoverFetcherSearch::TerminateSearch() {
void AlbumCoverFetcherSearch::Start(SharedPtr<CoverProviders> cover_providers) {
// Ignore Radio Paradise "commercial" break.
if (request_.artist.compare(QLatin1String("commercial-free"), Qt::CaseInsensitive) == 0 && request_.title.compare(QLatin1String("listener-supported"), Qt::CaseInsensitive) == 0) {
if (request_.artist.compare("commercial-free"_L1, Qt::CaseInsensitive) == 0 && request_.title.compare("listener-supported"_L1, Qt::CaseInsensitive) == 0) {
TerminateSearch();
return;
}
@@ -170,51 +172,51 @@ void AlbumCoverFetcherSearch::ProviderSearchResults(CoverProvider *provider, con
// This is done since we can't match the album titles, and we want to prevent compilation or live albums from being picked before studio albums for streams.
// TODO: Make these regular expressions.
if (request_album.isEmpty() && (
result_album.contains(QLatin1String("hits"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("greatest"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("best"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("collection"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("classics"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("singles"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("bootleg"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("live"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("concert"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("essential"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("ultimate"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("karaoke"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("mixtape"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("country rock"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("indie folk"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("soft rock"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("folk music"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("60's rock"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("60's romance"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("60s music"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("late 60s"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("the 60s"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("folk and blues"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("60 from the 60's"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("classic psychedelic"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("playlist: acoustic"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("90's rnb playlist"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("rock 80s"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("classic 80s"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("rock anthems"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("rock songs"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("rock 2019"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("guitar anthems"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("driving anthems"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("traffic jam jams"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("perfect background music"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("70's gold"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("rockfluence"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("acoustic dinner accompaniment"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("complete studio albums"), Qt::CaseInsensitive) ||
result_album.contains(QLatin1String("mellow rock"), Qt::CaseInsensitive)
result_album.contains("hits"_L1, Qt::CaseInsensitive) ||
result_album.contains("greatest"_L1, Qt::CaseInsensitive) ||
result_album.contains("best"_L1, Qt::CaseInsensitive) ||
result_album.contains("collection"_L1, Qt::CaseInsensitive) ||
result_album.contains("classics"_L1, Qt::CaseInsensitive) ||
result_album.contains("singles"_L1, Qt::CaseInsensitive) ||
result_album.contains("bootleg"_L1, Qt::CaseInsensitive) ||
result_album.contains("live"_L1, Qt::CaseInsensitive) ||
result_album.contains("concert"_L1, Qt::CaseInsensitive) ||
result_album.contains("essential"_L1, Qt::CaseInsensitive) ||
result_album.contains("ultimate"_L1, Qt::CaseInsensitive) ||
result_album.contains("karaoke"_L1, Qt::CaseInsensitive) ||
result_album.contains("mixtape"_L1, Qt::CaseInsensitive) ||
result_album.contains("country rock"_L1, Qt::CaseInsensitive) ||
result_album.contains("indie folk"_L1, Qt::CaseInsensitive) ||
result_album.contains("soft rock"_L1, Qt::CaseInsensitive) ||
result_album.contains("folk music"_L1, Qt::CaseInsensitive) ||
result_album.contains("60's rock"_L1, Qt::CaseInsensitive) ||
result_album.contains("60's romance"_L1, Qt::CaseInsensitive) ||
result_album.contains("60s music"_L1, Qt::CaseInsensitive) ||
result_album.contains("late 60s"_L1, Qt::CaseInsensitive) ||
result_album.contains("the 60s"_L1, Qt::CaseInsensitive) ||
result_album.contains("folk and blues"_L1, Qt::CaseInsensitive) ||
result_album.contains("60 from the 60's"_L1, Qt::CaseInsensitive) ||
result_album.contains("classic psychedelic"_L1, Qt::CaseInsensitive) ||
result_album.contains("playlist: acoustic"_L1, Qt::CaseInsensitive) ||
result_album.contains("90's rnb playlist"_L1, Qt::CaseInsensitive) ||
result_album.contains("rock 80s"_L1, Qt::CaseInsensitive) ||
result_album.contains("classic 80s"_L1, Qt::CaseInsensitive) ||
result_album.contains("rock anthems"_L1, Qt::CaseInsensitive) ||
result_album.contains("rock songs"_L1, Qt::CaseInsensitive) ||
result_album.contains("rock 2019"_L1, Qt::CaseInsensitive) ||
result_album.contains("guitar anthems"_L1, Qt::CaseInsensitive) ||
result_album.contains("driving anthems"_L1, Qt::CaseInsensitive) ||
result_album.contains("traffic jam jams"_L1, Qt::CaseInsensitive) ||
result_album.contains("perfect background music"_L1, Qt::CaseInsensitive) ||
result_album.contains("70's gold"_L1, Qt::CaseInsensitive) ||
result_album.contains("rockfluence"_L1, Qt::CaseInsensitive) ||
result_album.contains("acoustic dinner accompaniment"_L1, Qt::CaseInsensitive) ||
result_album.contains("complete studio albums"_L1, Qt::CaseInsensitive) ||
result_album.contains("mellow rock"_L1, Qt::CaseInsensitive)
)) {
results_copy[i].score_match -= 1;
}
else if (request_album.isEmpty() && result_album.contains(QLatin1String("soundtrack"), Qt::CaseInsensitive)) {
else if (request_album.isEmpty() && result_album.contains("soundtrack"_L1, Qt::CaseInsensitive)) {
results_copy[i].score_match -= 0.5;
}
@@ -323,8 +325,8 @@ void AlbumCoverFetcherSearch::ProviderCoverFetchFinished(QNetworkReply *reply) {
}
else {
QString mimetype = reply->header(QNetworkRequest::ContentTypeHeader).toString();
if (mimetype.contains(QLatin1Char(';'))) {
mimetype = mimetype.left(mimetype.indexOf(QLatin1Char(';')));
if (mimetype.contains(u';')) {
mimetype = mimetype.left(mimetype.indexOf(u';'));
}
if (ImageUtils::SupportedImageMimeTypes().contains(mimetype, Qt::CaseInsensitive) || ImageUtils::SupportedImageFormats().contains(mimetype, Qt::CaseInsensitive)) {
QByteArray image_data = reply->readAll();

10
src/covermanager/albumcoverloaderoptions.cpp
View File

@@ -24,6 +24,8 @@
#include "core/settings.h"
#include "settings/coverssettingspage.h"
using namespace Qt::StringLiterals;
AlbumCoverLoaderOptions::AlbumCoverLoaderOptions(const Options _options, const QSize _desired_scaled_size, const qreal _device_pixel_ratio, const Types &_types)
: options(_options),
desired_scaled_size(_desired_scaled_size),
@@ -39,16 +41,16 @@ AlbumCoverLoaderOptions::Types AlbumCoverLoaderOptions::LoadTypes() {
const QStringList all_cover_types = QStringList() << QStringLiteral("art_unset") << QStringLiteral("art_embedded") << QStringLiteral("art_manual") << QStringLiteral("art_automatic");
const QStringList cover_types_strlist = s.value(CoversSettingsPage::kTypes, all_cover_types).toStringList();
for (const QString &cover_type_str : cover_types_strlist) {
if (cover_type_str == QLatin1String("art_unset")) {
if (cover_type_str == "art_unset"_L1) {
cover_types << AlbumCoverLoaderOptions::Type::Unset;
}
else if (cover_type_str == QLatin1String("art_embedded")) {
else if (cover_type_str == "art_embedded"_L1) {
cover_types << AlbumCoverLoaderOptions::Type::Embedded;
}
else if (cover_type_str == QLatin1String("art_manual")) {
else if (cover_type_str == "art_manual"_L1) {
cover_types << AlbumCoverLoaderOptions::Type::Manual;
}
else if (cover_type_str == QLatin1String("art_automatic")) {
else if (cover_type_str == "art_automatic"_L1) {
cover_types << AlbumCoverLoaderOptions::Type::Automatic;
}
}

15
src/covermanager/albumcovermanager.cpp
View File

@@ -95,6 +95,7 @@
#include "ui_albumcovermanager.h"
using namespace std::literals::chrono_literals;
using namespace Qt::StringLiterals;
namespace {
constexpr char kSettingsGroup[] = "CoverManager";
@@ -289,10 +290,10 @@ void AlbumCoverManager::LoadGeometry() {
Settings s;
s.beginGroup(kSettingsGroup);
if (s.contains(QLatin1String("geometry"))) {
if (s.contains("geometry"_L1)) {
restoreGeometry(s.value("geometry").toByteArray());
}
if (s.contains(QLatin1String("splitter_state"))) {
if (s.contains("splitter_state"_L1)) {
ui_->splitter->restoreState(s.value("splitter_state").toByteArray());
}
else {
@@ -402,7 +403,7 @@ void AlbumCoverManager::ArtistChanged(QListWidgetItem *current) {
display_text = album_info.album;
}
else {
display_text = album_info.album_artist + QLatin1String(" - ") + album_info.album;
display_text = album_info.album_artist + " - "_L1 + album_info.album;
}
AlbumItem *album_item = new AlbumItem(icon_nocover_item_, display_text, ui_->albums);
@@ -418,7 +419,7 @@ void AlbumCoverManager::ArtistChanged(QListWidgetItem *current) {
album_item->setToolTip(album_info.album);
}
else {
album_item->setToolTip(album_info.album_artist + QLatin1String(" - ") + album_info.album);
album_item->setToolTip(album_info.album_artist + " - "_L1 + album_info.album);
}
album_item->setData(Role_ArtEmbedded, album_info.art_embedded);
@@ -536,7 +537,7 @@ bool AlbumCoverManager::ShouldHide(const AlbumItem &album_item, const QString &f
return false;
}
const QStringList query = filter.split(QLatin1Char(' '));
const QStringList query = filter.split(u' ');
for (const QString &s : query) {
bool in_text = album_item.text().contains(s, Qt::CaseInsensitive);
bool in_albumartist = album_item.data(Role_AlbumArtist).toString().contains(s, Qt::CaseInsensitive);
@@ -597,7 +598,7 @@ void AlbumCoverManager::UpdateStatusText() {
.arg(fetch_statistics_.missing_images_);
if (fetch_statistics_.bytes_transferred_ > 0) {
message += QLatin1String(", ") + tr("%1 transferred").arg(Utilities::PrettySize(fetch_statistics_.bytes_transferred_));
message += ", "_L1 + tr("%1 transferred").arg(Utilities::PrettySize(fetch_statistics_.bytes_transferred_));
}
statusBar()->showMessage(message);
@@ -671,7 +672,7 @@ Song AlbumCoverManager::AlbumItemAsSong(AlbumItem *album_item) {
QString title = album_item->data(Role_Album).toString();
QString artist_name = album_item->data(Role_AlbumArtist).toString();
if (!artist_name.isEmpty()) {
result.set_title(artist_name + QLatin1String(" - ") + title);
result.set_title(artist_name + " - "_L1 + title);
}
else {
result.set_title(title);

20
src/covermanager/coverexportrunnable.cpp
View File

@@ -34,6 +34,8 @@
#include "albumcoverexport.h"
#include "coverexportrunnable.h"
using namespace Qt::StringLiterals;
CoverExportRunnable::CoverExportRunnable(const AlbumCoverExport::DialogResult &dialog_result, const AlbumCoverLoaderOptions::Types &cover_types, const Song &song, QObject *parent)
: QObject(parent),
dialog_result_(dialog_result),
@@ -78,7 +80,7 @@ void CoverExportRunnable::ProcessAndExportCover() {
if (song_.art_embedded() && dialog_result_.export_embedded_) {
const TagReaderClient::Result result = TagReaderClient::Instance()->LoadEmbeddedArtAsImageBlocking(song_.url().toLocalFile(), image);
if (result.success() && !image.isNull()) {
extension = QLatin1String("jpg");
extension = "jpg"_L1;
}
}
break;
@@ -86,7 +88,7 @@ void CoverExportRunnable::ProcessAndExportCover() {
if (dialog_result_.export_downloaded_ && song_.art_manual_is_valid()) {
const QString cover_path = song_.art_manual().toLocalFile();
if (image.load(cover_path)) {
extension = cover_path.section(QLatin1Char('.'), -1);
extension = cover_path.section(u'.', -1);
}
}
break;
@@ -94,7 +96,7 @@ void CoverExportRunnable::ProcessAndExportCover() {
if (dialog_result_.export_downloaded_ && song_.art_automatic_is_valid()) {
const QString cover_path = song_.art_automatic().toLocalFile();
if (image.load(cover_path)) {
extension = cover_path.section(QLatin1Char('.'), -1);
extension = cover_path.section(u'.', -1);
}
}
break;
@@ -112,8 +114,8 @@ void CoverExportRunnable::ProcessAndExportCover() {
image = image.scaled(QSize(dialog_result_.width_, dialog_result_.height_), Qt::IgnoreAspectRatio);
}
QString cover_dir = song_.url().toLocalFile().section(QLatin1Char('/'), 0, -2);
QString new_file = cover_dir + QLatin1Char('/') + dialog_result_.filename_ + QLatin1Char('.') + (song_.art_embedded() ? QLatin1String("jpg") : extension);
QString cover_dir = song_.url().toLocalFile().section(u'/', 0, -2);
QString new_file = cover_dir + QLatin1Char('/') + dialog_result_.filename_ + QLatin1Char('.') + (song_.art_embedded() ? "jpg"_L1 : extension);
// If the file exists, do not override!
if (dialog_result_.overwrite_ == AlbumCoverExport::OverwriteMode::None && QFile::exists(new_file)) {
@@ -171,7 +173,7 @@ void CoverExportRunnable::ExportCover() {
const TagReaderClient::Result result = TagReaderClient::Instance()->LoadEmbeddedArtAsImageBlocking(song_.url().toLocalFile(), image);
if (result.success() && !image.isNull()) {
embedded_cover = true;
extension = QLatin1String("jpg");
extension = "jpg"_L1;
}
}
break;
@@ -179,7 +181,7 @@ void CoverExportRunnable::ExportCover() {
if (dialog_result_.export_downloaded_ && song_.art_manual_is_valid()) {
cover_path = song_.art_manual().toLocalFile();
if (image.load(cover_path)) {
extension = cover_path.section(QLatin1Char('.'), -1);
extension = cover_path.section(u'.', -1);
}
}
break;
@@ -187,7 +189,7 @@ void CoverExportRunnable::ExportCover() {
if (dialog_result_.export_downloaded_ && song_.art_automatic_is_valid()) {
cover_path = song_.art_automatic().toLocalFile();
if (image.load(cover_path)) {
extension = cover_path.section(QLatin1Char('.'), -1);
extension = cover_path.section(u'.', -1);
}
}
break;
@@ -200,7 +202,7 @@ void CoverExportRunnable::ExportCover() {
return;
}
QString cover_dir = song_.url().toLocalFile().section(QLatin1Char('/'), 0, -2);
QString cover_dir = song_.url().toLocalFile().section(u'/', 0, -2);
QString new_file = cover_dir + QLatin1Char('/') + dialog_result_.filename_ + QLatin1Char('.') + extension;
// If the file exists, do not override!

4
src/covermanager/coverfromurldialog.cpp
View File

@@ -39,6 +39,8 @@
#include "coverfromurldialog.h"
#include "ui_coverfromurldialog.h"
using namespace Qt::StringLiterals;
CoverFromURLDialog::CoverFromURLDialog(SharedPtr<NetworkAccessManager> network, QWidget *parent)
: QDialog(parent),
network_(network),
@@ -56,7 +58,7 @@ CoverFromURLDialog::~CoverFromURLDialog() {
AlbumCoverImageResult CoverFromURLDialog::Exec() {
// reset state
ui_->url->setText(QLatin1String(""));
ui_->url->setText(""_L1);
last_album_cover_ = AlbumCoverImageResult();
QClipboard *clipboard = QApplication::clipboard();

56
src/covermanager/deezercoverprovider.cpp
View File

@@ -48,6 +48,8 @@
#include "jsoncoverprovider.h"
#include "deezercoverprovider.h"
using namespace Qt::StringLiterals;
namespace {
constexpr char kApiUrl[] = "https://api.deezer.com";
constexpr int kLimit = 10;
@@ -74,14 +76,14 @@ bool DeezerCoverProvider::StartSearch(const QString &artist, const QString &albu
QString resource;
QString query = artist;
if (album.isEmpty() && !title.isEmpty()) {
resource = QLatin1String("search/track");
if (!query.isEmpty()) query.append(QLatin1Char(' '));
resource = "search/track"_L1;
if (!query.isEmpty()) query.append(u' ');
query.append(title);
}
else {
resource = QLatin1String("search/album");
resource = "search/album"_L1;
if (!album.isEmpty()) {
if (!query.isEmpty()) query.append(QLatin1Char(' '));
if (!query.isEmpty()) query.append(u' ');
query.append(album);
}
}
@@ -130,12 +132,12 @@ QByteArray DeezerCoverProvider::GetReplyData(QNetworkReply *reply) {
QString error;
if (json_error.error == QJsonParseError::NoError && !json_doc.isEmpty() && json_doc.isObject()) {
QJsonObject json_obj = json_doc.object();
if (json_obj.contains(QLatin1String("error"))) {
QJsonValue value_error = json_obj[QLatin1String("error")];
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[QLatin1String("code")].toInt();
QString message = obj_error[QLatin1String("message")].toString();
int code = obj_error["code"_L1].toInt();
QString message = obj_error["message"_L1].toString();
error = QStringLiteral("%1 (%2)").arg(message).arg(code);
}
}
@@ -162,27 +164,27 @@ QJsonValue DeezerCoverProvider::ExtractData(const QByteArray &data) {
QJsonObject json_obj = ExtractJsonObj(data);
if (json_obj.isEmpty()) return QJsonObject();
if (json_obj.contains(QLatin1String("error"))) {
QJsonValue value_error = json_obj[QLatin1String("error")];
if (json_obj.contains("error"_L1)) {
QJsonValue value_error = json_obj["error"_L1];
if (!value_error.isObject()) {
Error(QStringLiteral("Error missing object"), json_obj);
return QJsonValue();
}
QJsonObject obj_error = value_error.toObject();
const int code = obj_error[QLatin1String("code")].toInt();
QString message = obj_error[QLatin1String("message")].toString();
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(QLatin1String("data")) && !json_obj.contains(QLatin1String("DATA"))) {
if (!json_obj.contains("data"_L1) && !json_obj.contains("DATA"_L1)) {
Error(QStringLiteral("Json reply object is missing data."), json_obj);
return QJsonValue();
}
QJsonValue value_data;
if (json_obj.contains(QLatin1String("data"))) value_data = json_obj[QLatin1String("data")];
else value_data = json_obj[QLatin1String("DATA")];
if (json_obj.contains("data"_L1)) value_data = json_obj["data"_L1];
else value_data = json_obj["DATA"_L1];
return value_data;
@@ -223,50 +225,50 @@ void DeezerCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id)
}
QJsonObject json_obj = json_value.toObject();
QJsonObject obj_album;
if (json_obj.contains(QLatin1String("album")) && json_obj[QLatin1String("album")].isObject()) { // Song search, so extract the album.
obj_album = json_obj[QLatin1String("album")].toObject();
if (json_obj.contains("album"_L1) && json_obj["album"_L1].isObject()) { // Song search, so extract the album.
obj_album = json_obj["album"_L1].toObject();
}
else {
obj_album = json_obj;
}
if (!json_obj.contains(QLatin1String("id")) || !obj_album.contains(QLatin1String("id"))) {
if (!json_obj.contains("id"_L1) || !obj_album.contains("id"_L1)) {
Error(QStringLiteral("Invalid Json reply, data array value object is missing ID."), json_obj);
continue;
}
if (!obj_album.contains(QLatin1String("type"))) {
if (!obj_album.contains("type"_L1)) {
Error(QStringLiteral("Invalid Json reply, data array value album object is missing type."), obj_album);
continue;
}
QString type = obj_album[QLatin1String("type")].toString();
if (type != QLatin1String("album")) {
QString type = obj_album["type"_L1].toString();
if (type != "album"_L1) {
Error(QStringLiteral("Invalid Json reply, data array value album object has incorrect type returned"), obj_album);
continue;
}
if (!json_obj.contains(QLatin1String("artist"))) {
if (!json_obj.contains("artist"_L1)) {
Error(QStringLiteral("Invalid Json reply, data array value object is missing artist."), json_obj);
continue;
}
QJsonValue value_artist = json_obj[QLatin1String("artist")];
QJsonValue value_artist = json_obj["artist"_L1];
if (!value_artist.isObject()) {
Error(QStringLiteral("Invalid Json reply, data array value artist is not a object."), value_artist);
continue;
}
QJsonObject obj_artist = value_artist.toObject();
if (!obj_artist.contains(QLatin1String("name"))) {
if (!obj_artist.contains("name"_L1)) {
Error(QStringLiteral("Invalid Json reply, data array value artist object is missing name."), obj_artist);
continue;
}
QString artist = obj_artist[QLatin1String("name")].toString();
QString artist = obj_artist["name"_L1].toString();
if (!obj_album.contains(QLatin1String("title"))) {
if (!obj_album.contains("title"_L1)) {
Error(QStringLiteral("Invalid Json reply, data array value album object is missing title."), obj_album);
continue;
}
QString album = obj_album[QLatin1String("title")].toString();
QString album = obj_album["title"_L1].toString();
CoverProviderSearchResult cover_result;
cover_result.artist = artist;

53
src/covermanager/discogscoverprovider.cpp
View File

@@ -50,6 +50,7 @@
#include "jsoncoverprovider.h"
#include "discogscoverprovider.h"
using namespace Qt::StringLiterals;
using std::make_shared;
const char *DiscogsCoverProvider::kUrlSearch = "https://api.discogs.com/database/search";
@@ -163,7 +164,7 @@ QNetworkReply *DiscogsCoverProvider::CreateRequest(QUrl url, const ParamList &pa
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(QLatin1Char('&'))).toUtf8();
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 signature(Utilities::HmacSha256(QByteArray::fromBase64(kSecretKeyB64), data_to_sign));
// Add the signature to the request
@@ -201,8 +202,8 @@ QByteArray DiscogsCoverProvider::GetReplyData(QNetworkReply *reply) {
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(QLatin1String("message"))) {
error = json_obj[QLatin1String("message")].toString();
if (json_obj.contains("message"_L1)) {
error = json_obj["message"_L1].toString();
}
}
if (error.isEmpty()) {
@@ -245,11 +246,11 @@ void DiscogsCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id)
}
QJsonValue value_results;
if (json_obj.contains(QLatin1String("results"))) {
value_results = json_obj[QLatin1String("results")];
if (json_obj.contains("results"_L1)) {
value_results = json_obj["results"_L1];
}
else if (json_obj.contains(QLatin1String("message"))) {
QString message = json_obj[QLatin1String("message")].toString();
else if (json_obj.contains("message"_L1)) {
QString message = json_obj["message"_L1].toString();
Error(QStringLiteral("%1").arg(message));
EndSearch(search);
return;
@@ -274,15 +275,15 @@ void DiscogsCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id)
continue;
}
QJsonObject obj_result = value_result.toObject();
if (!obj_result.contains(QLatin1String("id")) || !obj_result.contains(QLatin1String("title")) || !obj_result.contains(QLatin1String("resource_url"))) {
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);
continue;
}
quint64 release_id = obj_result[QLatin1String("id")].toInt();
QUrl resource_url(obj_result[QLatin1String("resource_url")].toString());
QString title = obj_result[QLatin1String("title")].toString();
quint64 release_id = obj_result["id"_L1].toInt();
QUrl resource_url(obj_result["resource_url"_L1].toString());
QString title = obj_result["title"_L1].toString();
if (title.contains(QLatin1String(" - "))) {
if (title.contains(" - "_L1)) {
QStringList title_splitted = title.split(QStringLiteral(" - "));
if (title_splitted.count() == 2) {
QString artist = title_splitted.first();
@@ -354,18 +355,18 @@ void DiscogsCoverProvider::HandleReleaseReply(QNetworkReply *reply, const int se
return;
}
if (!json_obj.contains(QLatin1String("artists")) || !json_obj.contains(QLatin1String("title"))) {
if (!json_obj.contains("artists"_L1) || !json_obj.contains("title"_L1)) {
Error(QStringLiteral("Json reply object is missing artists or title."), json_obj);
EndSearch(search, release.id);
return;
}
if (!json_obj.contains(QLatin1String("images"))) {
if (!json_obj.contains("images"_L1)) {
EndSearch(search, release.id);
return;
}
QJsonValue value_artists = json_obj[QLatin1String("artists")];
QJsonValue value_artists = json_obj["artists"_L1];
if (!value_artists.isArray()) {
Error(QStringLiteral("Json reply object artists is not a array."), value_artists);
EndSearch(search, release.id);
@@ -380,11 +381,11 @@ void DiscogsCoverProvider::HandleReleaseReply(QNetworkReply *reply, const int se
continue;
}
QJsonObject obj_artist = value_artist.toObject();
if (!obj_artist.contains(QLatin1String("name"))) {
if (!obj_artist.contains("name"_L1)) {
Error(QStringLiteral("Invalid Json reply, artists array value object is missing name."), obj_artist);
continue;
}
artist = obj_artist[QLatin1String("name")].toString();
artist = obj_artist["name"_L1].toString();
++i;
if (artist == search->artist) break;
}
@@ -393,15 +394,15 @@ void DiscogsCoverProvider::HandleReleaseReply(QNetworkReply *reply, const int se
EndSearch(search, release.id);
return;
}
if (i > 1 && artist != search->artist) artist = QLatin1String("Various artists");
if (i > 1 && artist != search->artist) artist = "Various artists"_L1;
QString album = json_obj[QLatin1String("title")].toString();
QString album = json_obj["title"_L1].toString();
if (artist != search->artist && album != search->album) {
EndSearch(search, release.id);
return;
}
QJsonValue value_images = json_obj[QLatin1String("images")];
QJsonValue value_images = json_obj["images"_L1];
if (!value_images.isArray()) {
Error(QStringLiteral("Json images is not an array."));
EndSearch(search, release.id);
@@ -422,23 +423,23 @@ void DiscogsCoverProvider::HandleReleaseReply(QNetworkReply *reply, const int se
continue;
}
QJsonObject obj_image = value_image.toObject();
if (!obj_image.contains(QLatin1String("type")) || !obj_image.contains(QLatin1String("resource_url")) || !obj_image.contains(QLatin1String("width")) || !obj_image.contains(QLatin1String("height"))) {
if (!obj_image.contains("type"_L1) || !obj_image.contains("resource_url"_L1) || !obj_image.contains("width"_L1) || !obj_image.contains("height"_L1)) {
Error(QStringLiteral("Invalid Json reply, images array value object is missing type, resource_url, width or height."), obj_image);
continue;
}
QString type = obj_image[QLatin1String("type")].toString();
if (type != QLatin1String("primary")) {
QString type = obj_image["type"_L1].toString();
if (type != "primary"_L1) {
continue;
}
int width = obj_image[QLatin1String("width")].toInt();
int height = obj_image[QLatin1String("height")].toInt();
int width = obj_image["width"_L1].toInt();
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;
CoverProviderSearchResult result;
result.artist = artist;
result.album = album;
result.image_url = QUrl(obj_image[QLatin1String("resource_url")].toString());
result.image_url = QUrl(obj_image["resource_url"_L1].toString());
if (result.image_url.isEmpty()) continue;
search->results.append(result);
}

74
src/covermanager/lastfmcoverprovider.cpp
View File

@@ -47,6 +47,8 @@
#include "albumcoverfetcher.h"
#include "lastfmcoverprovider.h"
using namespace Qt::StringLiterals;
namespace {
constexpr char kUrl[] = "https://ws.audioscrobbler.com/2.0/";
constexpr char kApiKey[] = "211990b4c96782c05d1536e7219eb56e";
@@ -75,16 +77,16 @@ bool LastFmCoverProvider::StartSearch(const QString &artist, const QString &albu
QString type;
QString query = artist;
if (album.isEmpty() && !title.isEmpty()) {
method = QLatin1String("track.search");
type = QLatin1String("track");
if (!query.isEmpty()) query.append(QLatin1Char(' '));
method = "track.search"_L1;
type = "track"_L1;
if (!query.isEmpty()) query.append(u' ');
query.append(title);
}
else {
method = QLatin1String("album.search");
type = QLatin1String("album");
method = "album.search"_L1;
type = "album"_L1;
if (!album.isEmpty()) {
if (!query.isEmpty()) query.append(QLatin1Char(' '));
if (!query.isEmpty()) query.append(u' ');
query.append(album);
}
}
@@ -105,7 +107,7 @@ bool LastFmCoverProvider::StartSearch(const QString &artist, const QString &albu
data_to_sign += QLatin1String(kSecret);
QByteArray const digest = QCryptographicHash::hash(data_to_sign.toUtf8(), QCryptographicHash::Md5);
QString signature = QString::fromLatin1(digest.toHex()).rightJustified(32, QLatin1Char('0')).toLower();
QString signature = QString::fromLatin1(digest.toHex()).rightJustified(32, u'0').toLower();
url_query.addQueryItem(QString::fromLatin1(QUrl::toPercentEncoding(QStringLiteral("api_sig"))), QString::fromLatin1(QUrl::toPercentEncoding(signature)));
url_query.addQueryItem(QString::fromLatin1(QUrl::toPercentEncoding(QStringLiteral("format"))), QString::fromLatin1(QUrl::toPercentEncoding(QStringLiteral("json"))));
@@ -144,12 +146,12 @@ void LastFmCoverProvider::QueryFinished(QNetworkReply *reply, const int id, cons
}
QJsonValue value_results;
if (json_obj.contains(QLatin1String("results"))) {
value_results = json_obj[QLatin1String("results")];
if (json_obj.contains("results"_L1)) {
value_results = json_obj["results"_L1];
}
else if (json_obj.contains(QLatin1String("error")) && json_obj.contains(QLatin1String("message"))) {
int error = json_obj[QLatin1String("error")].toInt();
QString message = json_obj[QLatin1String("message")].toString();
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();
Error(QStringLiteral("Error: %1: %2").arg(QString::number(error), message));
Q_EMIT SearchFinished(id, results);
return;
@@ -175,9 +177,9 @@ void LastFmCoverProvider::QueryFinished(QNetworkReply *reply, const int id, cons
QJsonValue value_matches;
if (type == QLatin1String("album")) {
if (obj_results.contains(QLatin1String("albummatches"))) {
value_matches = obj_results[QLatin1String("albummatches")];
if (type == "album"_L1) {
if (obj_results.contains("albummatches"_L1)) {
value_matches = obj_results["albummatches"_L1];
}
else {
Error(QStringLiteral("Json results object is missing albummatches."), obj_results);
@@ -185,9 +187,9 @@ void LastFmCoverProvider::QueryFinished(QNetworkReply *reply, const int id, cons
return;
}
}
else if (type == QLatin1String("track")) {
if (obj_results.contains(QLatin1String("trackmatches"))) {
value_matches = obj_results[QLatin1String("trackmatches")];
else if (type == "track"_L1) {
if (obj_results.contains("trackmatches"_L1)) {
value_matches = obj_results["trackmatches"_L1];
}
else {
Error(QStringLiteral("Json results object is missing trackmatches."), obj_results);
@@ -231,17 +233,17 @@ void LastFmCoverProvider::QueryFinished(QNetworkReply *reply, const int id, cons
continue;
}
QJsonObject obj = value.toObject();
if (!obj.contains(QLatin1String("artist")) || !obj.contains(QLatin1String("image")) || !obj.contains(QLatin1String("name"))) {
if (!obj.contains("artist"_L1) || !obj.contains("image"_L1) || !obj.contains("name"_L1)) {
Error(QStringLiteral("Invalid Json reply, album is missing artist, image or name."), obj);
continue;
}
QString artist = obj[QLatin1String("artist")].toString();
QString artist = obj["artist"_L1].toString();
QString album;
if (type == QLatin1String("album")) {
album = obj[QLatin1String("name")].toString();
if (type == "album"_L1) {
album = obj["name"_L1].toString();
}
QJsonValue json_image = obj[QLatin1String("image")];
QJsonValue json_image = obj["image"_L1];
if (!json_image.isArray()) {
Error(QStringLiteral("Invalid Json reply, album image is not a array."), json_image);
continue;
@@ -255,13 +257,13 @@ void LastFmCoverProvider::QueryFinished(QNetworkReply *reply, const int id, cons
continue;
}
QJsonObject obj_image = value_image.toObject();
if (!obj_image.contains(QLatin1String("#text")) || !obj_image.contains(QLatin1String("size"))) {
if (!obj_image.contains("#text"_L1) || !obj_image.contains("size"_L1)) {
Error(QStringLiteral("Invalid Json reply, album image value is missing #text or size."), obj_image);
continue;
}
QString image_url = obj_image[QLatin1String("#text")].toString();
QString image_url = obj_image["#text"_L1].toString();
if (image_url.isEmpty()) continue;
LastFmImageSize image_size = ImageSizeFromString(obj_image[QLatin1String("size")].toString().toLower());
LastFmImageSize image_size = ImageSizeFromString(obj_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;
@@ -271,8 +273,8 @@ void LastFmCoverProvider::QueryFinished(QNetworkReply *reply, const int id, cons
if (image_url_use.isEmpty()) continue;
// Workaround for API limiting to 300x300 images.
if (image_url_use.contains(QLatin1String("/300x300/"))) {
image_url_use = image_url_use.replace(QLatin1String("/300x300/"), QLatin1String("/740x0/"));
if (image_url_use.contains("/300x300/"_L1)) {
image_url_use = image_url_use.replace("/300x300/"_L1, "/740x0/"_L1);
}
QUrl url(image_url_use);
if (!url.isValid()) continue;
@@ -308,10 +310,10 @@ QByteArray LastFmCoverProvider::GetReplyData(QNetworkReply *reply) {
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(QLatin1String("error")) && json_obj.contains(QLatin1String("message"))) {
int code = json_obj[QLatin1String("error")].toInt();
QString message = json_obj[QLatin1String("message")].toString();
error = QLatin1String("Error: ") + QString::number(code) + QLatin1String(": ") + message;
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()) {
@@ -340,10 +342,10 @@ void LastFmCoverProvider::Error(const QString &error, const QVariant &debug) {
LastFmCoverProvider::LastFmImageSize LastFmCoverProvider::ImageSizeFromString(const QString &size) {
if (size == QLatin1String("small")) return LastFmImageSize::Small;
if (size == QLatin1String("medium")) return LastFmImageSize::Medium;
if (size == QLatin1String("large")) return LastFmImageSize::Large;
if (size == QLatin1String("extralarge")) return LastFmImageSize::ExtraLarge;
if (size == "small"_L1) return LastFmImageSize::Small;
if (size == "medium"_L1) return LastFmImageSize::Medium;
if (size == "large"_L1) return LastFmImageSize::Large;
if (size == "extralarge"_L1) return LastFmImageSize::ExtraLarge;
return LastFmImageSize::Unknown;

34
src/covermanager/musicbrainzcoverprovider.cpp
View File

@@ -44,6 +44,8 @@
#include "jsoncoverprovider.h"
#include "musicbrainzcoverprovider.h"
using namespace Qt::StringLiterals;
namespace {
constexpr char kReleaseSearchUrl[] = "https://musicbrainz.org/ws/2/release/";
constexpr char kAlbumCoverUrl[] = "https://coverartarchive.org/release/%1/front";
@@ -91,7 +93,7 @@ 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(QLatin1Char('"'), QLatin1String("\\\"")), request.artist.trimmed().replace(QLatin1Char('"'), QLatin1String("\\\"")));
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(QStringLiteral("query"), query);
@@ -140,9 +142,9 @@ void MusicbrainzCoverProvider::HandleSearchReply(QNetworkReply *reply, const int
return;
}
if (!json_obj.contains(QLatin1String("releases"))) {
if (json_obj.contains(QLatin1String("error"))) {
QString error = json_obj[QLatin1String("error")].toString();
if (!json_obj.contains("releases"_L1)) {
if (json_obj.contains("error"_L1)) {
QString error = json_obj["error"_L1].toString();
Error(error);
}
else {
@@ -151,7 +153,7 @@ void MusicbrainzCoverProvider::HandleSearchReply(QNetworkReply *reply, const int
Q_EMIT SearchFinished(search_id, results);
return;
}
QJsonValue value_releases = json_obj[QLatin1String("releases")];
QJsonValue value_releases = json_obj["releases"_L1];
if (!value_releases.isArray()) {
Error(QStringLiteral("Json releases is not an array."), value_releases);
@@ -172,12 +174,12 @@ void MusicbrainzCoverProvider::HandleSearchReply(QNetworkReply *reply, const int
continue;
}
QJsonObject obj_release = value_release.toObject();
if (!obj_release.contains(QLatin1String("id")) || !obj_release.contains(QLatin1String("artist-credit")) || !obj_release.contains(QLatin1String("title"))) {
if (!obj_release.contains("id"_L1) || !obj_release.contains("artist-credit"_L1) || !obj_release.contains("title"_L1)) {
Error(QStringLiteral("Invalid Json reply, releases array object is missing id, artist-credit or title."), obj_release);
continue;
}
QJsonValue json_artists = obj_release[QLatin1String("artist-credit")];
QJsonValue json_artists = obj_release["artist-credit"_L1];
if (!json_artists.isArray()) {
Error(QStringLiteral("Invalid Json reply, artist-credit is not a array."), json_artists);
continue;
@@ -192,28 +194,28 @@ void MusicbrainzCoverProvider::HandleSearchReply(QNetworkReply *reply, const int
}
QJsonObject obj_artist = value_artist.toObject();
if (!obj_artist.contains(QLatin1String("artist"))) {
if (!obj_artist.contains("artist"_L1)) {
Error(QStringLiteral("Invalid Json reply, artist is missing."), obj_artist);
continue;
}
QJsonValue value_artist2 = obj_artist[QLatin1String("artist")];
QJsonValue value_artist2 = obj_artist["artist"_L1];
if (!value_artist2.isObject()) {
Error(QStringLiteral("Invalid Json reply, artist is not an object."), value_artist2);
continue;
}
QJsonObject obj_artist2 = value_artist2.toObject();
if (!obj_artist2.contains(QLatin1String("name"))) {
if (!obj_artist2.contains("name"_L1)) {
Error(QStringLiteral("Invalid Json reply, artist is missing name."), value_artist2);
continue;
}
artist = obj_artist2[QLatin1String("name")].toString();
artist = obj_artist2["name"_L1].toString();
++i;
}
if (i > 1) artist = QLatin1String("Various artists");
if (i > 1) artist = "Various artists"_L1;
QString id = obj_release[QLatin1String("id")].toString();
QString album = obj_release[QLatin1String("title")].toString();
QString id = obj_release["id"_L1].toString();
QString album = obj_release["title"_L1].toString();
CoverProviderSearchResult cover_result;
QUrl url(QString::fromLatin1(kAlbumCoverUrl).arg(id));
@@ -247,8 +249,8 @@ QByteArray MusicbrainzCoverProvider::GetReplyData(QNetworkReply *reply) {
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(QLatin1String("error"))) {
error = json_obj[QLatin1String("error")].toString();
if (json_obj.contains("error"_L1)) {
error = json_obj["error"_L1].toString();
}
}
if (error.isEmpty()) {

34
src/covermanager/musixmatchcoverprovider.cpp
View File

@@ -40,6 +40,8 @@
#include "jsoncoverprovider.h"
#include "musixmatchcoverprovider.h"
using namespace Qt::StringLiterals;
MusixmatchCoverProvider::MusixmatchCoverProvider(Application *app, SharedPtr<NetworkAccessManager> network, QObject *parent)
: JsonCoverProvider(QStringLiteral("Musixmatch"), true, false, 1.0, true, false, app, network, parent) {}
@@ -107,8 +109,8 @@ void MusixmatchCoverProvider::HandleSearchReply(QNetworkReply *reply, const int
return;
}
const QString content = QString::fromUtf8(data);
const QString data_begin = QLatin1String("<script id=\"__NEXT_DATA__\" type=\"application/json\">");
const QString data_end = QLatin1String("</script>");
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;
@@ -162,47 +164,47 @@ void MusixmatchCoverProvider::HandleSearchReply(QNetworkReply *reply, const int
return;
}
if (!obj_data.contains(QLatin1String("props")) || !obj_data[QLatin1String("props")].isObject()) {
if (!obj_data.contains("props"_L1) || !obj_data["props"_L1].isObject()) {
Error(QStringLiteral("Json reply is missing props."), obj_data);
Q_EMIT SearchFinished(id, results);
return;
}
obj_data = obj_data[QLatin1String("props")].toObject();
obj_data = obj_data["props"_L1].toObject();
if (!obj_data.contains(QLatin1String("pageProps")) || !obj_data[QLatin1String("pageProps")].isObject()) {
if (!obj_data.contains("pageProps"_L1) || !obj_data["pageProps"_L1].isObject()) {
Error(QStringLiteral("Json props is missing pageProps."), obj_data);
Q_EMIT SearchFinished(id, results);
return;
}
obj_data = obj_data[QLatin1String("pageProps")].toObject();
obj_data = obj_data["pageProps"_L1].toObject();
if (!obj_data.contains(QLatin1String("data")) || !obj_data[QLatin1String("data")].isObject()) {
if (!obj_data.contains("data"_L1) || !obj_data["data"_L1].isObject()) {
Error(QStringLiteral("Json pageProps is missing data."), obj_data);
Q_EMIT SearchFinished(id, results);
return;
}
obj_data = obj_data[QLatin1String("data")].toObject();
obj_data = obj_data["data"_L1].toObject();
if (!obj_data.contains(QLatin1String("albumGet")) || !obj_data[QLatin1String("albumGet")].isObject()) {
if (!obj_data.contains("albumGet"_L1) || !obj_data["albumGet"_L1].isObject()) {
Error(QStringLiteral("Json data is missing albumGet."), obj_data);
Q_EMIT SearchFinished(id, results);
return;
}
obj_data = obj_data[QLatin1String("albumGet")].toObject();
obj_data = obj_data["albumGet"_L1].toObject();
if (!obj_data.contains(QLatin1String("data")) || !obj_data[QLatin1String("data")].isObject()) {
if (!obj_data.contains("data"_L1) || !obj_data["data"_L1].isObject()) {
Error(QStringLiteral("Json albumGet reply is missing data."), obj_data);
Q_EMIT SearchFinished(id, results);
return;
}
obj_data = obj_data[QLatin1String("data")].toObject();
obj_data = obj_data["data"_L1].toObject();
CoverProviderSearchResult result;
if (obj_data.contains(QLatin1String("artistName")) && obj_data[QLatin1String("artistName")].isString()) {
result.artist = obj_data[QLatin1String("artistName")].toString();
if (obj_data.contains("artistName"_L1) && obj_data["artistName"_L1].isString()) {
result.artist = obj_data["artistName"_L1].toString();
}
if (obj_data.contains(QLatin1String("name")) && obj_data[QLatin1String("name")].isString()) {
result.album = obj_data[QLatin1String("name")].toString();
if (obj_data.contains("name"_L1) && obj_data["name"_L1].isString()) {
result.album = obj_data["name"_L1].toString();
}
if (result.artist.compare(artist, Qt::CaseInsensitive) != 0 && result.album.compare(album, Qt::CaseInsensitive) != 0) {

74
src/covermanager/opentidalcoverprovider.cpp
View File

@@ -47,6 +47,8 @@
#include "jsoncoverprovider.h"
#include "opentidalcoverprovider.h"
using namespace Qt::StringLiterals;
namespace {
constexpr char kSettingsGroup[] = "OpenTidal";
constexpr char kAuthUrl[] = "https://auth.tidal.com/v1/oauth2/token";
@@ -208,21 +210,21 @@ void OpenTidalCoverProvider::LoginFinished(QNetworkReply *reply) {
return;
}
if (!json_obj.contains(QLatin1String("access_token")) ||
!json_obj.contains(QLatin1String("token_type")) ||
!json_obj.contains(QLatin1String("expires_in")) ||
!json_obj[QLatin1String("access_token")].isString() ||
!json_obj[QLatin1String("token_type")].isString()) {
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;
}
have_login_ = true;
token_type_ = json_obj[QLatin1String("token_type")].toString();
access_token_ = json_obj[QLatin1String("access_token")].toString();
token_type_ = json_obj["token_type"_L1].toString();
access_token_ = json_obj["access_token"_L1].toString();
login_time_ = QDateTime::currentSecsSinceEpoch();
expires_in_ = json_obj[QLatin1String("expires_in")].toInt();
expires_in_ = json_obj["expires_in"_L1].toInt();
Settings s;
s.beginGroup(kSettingsGroup);
@@ -285,21 +287,21 @@ QJsonObject OpenTidalCoverProvider::GetJsonObject(QNetworkReply *reply) {
return QJsonObject();
}
QJsonObject json_obj = ExtractJsonObj(data);
if (json_obj.contains(QLatin1String("errors")) && json_obj[QLatin1String("errors")].isArray()) {
const QJsonArray array = json_obj[QLatin1String("errors")].toArray();
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(QLatin1String("category")) ||
!obj.contains(QLatin1String("code")) ||
!obj.contains(QLatin1String("detail"))) {
if (!obj.contains("category"_L1) ||
!obj.contains("code"_L1) ||
!obj.contains("detail"_L1)) {
continue;
}
QString category = obj[QLatin1String("category")].toString();
QString code = obj[QLatin1String("code")].toString();
QString detail = obj[QLatin1String("detail")].toString();
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 == QLatin1String("AUTHENTICATION_ERROR")) {
if (category == "AUTHENTICATION_ERROR"_L1) {
LoginCheck();
}
}
@@ -320,11 +322,11 @@ void OpenTidalCoverProvider::SendSearchRequest(SearchRequestPtr search_request)
QString query = search_request->artist;
if (!search_request->album.isEmpty()) {
if (!query.isEmpty()) query.append(QLatin1Char(' '));
if (!query.isEmpty()) query.append(u' ');
query.append(search_request->album);
}
else if (!search_request->title.isEmpty()) {
if (!query.isEmpty()) query.append(QLatin1Char(' '));
if (!query.isEmpty()) query.append(u' ');
query.append(search_request->title);
}
@@ -332,7 +334,7 @@ void OpenTidalCoverProvider::SendSearchRequest(SearchRequestPtr search_request)
url_query.addQueryItem(QStringLiteral("query"), QString::fromUtf8(QUrl::toPercentEncoding(query)));
url_query.addQueryItem(QStringLiteral("limit"), QString::number(kLimit));
url_query.addQueryItem(QStringLiteral("countryCode"), QStringLiteral("US"));
QUrl url(QLatin1String(kApiUrl) + QLatin1String("/search"));
QUrl url(QLatin1String(kApiUrl) + "/search"_L1);
url.setQuery(url_query);
QNetworkRequest req(url);
req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
@@ -363,13 +365,13 @@ void OpenTidalCoverProvider::HandleSearchReply(QNetworkReply *reply, SearchReque
return;
}
if (!json_obj.contains(QLatin1String("albums")) || !json_obj[QLatin1String("albums")].isArray()) {
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());
return;
}
const QJsonArray array_albums = json_obj[QLatin1String("albums")].toArray();
const QJsonArray array_albums = json_obj["albums"_L1].toArray();
if (array_albums.isEmpty()) {
Q_EMIT SearchFinished(search_request->id, CoverProviderSearchResults());
return;
@@ -385,55 +387,55 @@ void OpenTidalCoverProvider::HandleSearchReply(QNetworkReply *reply, SearchReque
}
QJsonObject obj_album = value_album.toObject();
if (!obj_album.contains(QLatin1String("resource")) || !obj_album[QLatin1String("resource")].isObject()) {
if (!obj_album.contains("resource"_L1) || !obj_album["resource"_L1].isObject()) {
qLog(Debug) << "OpenTidal: Invalid Json reply: Albums array album is missing resource object.";
continue;
}
QJsonObject obj_resource = obj_album[QLatin1String("resource")].toObject();
QJsonObject obj_resource = obj_album["resource"_L1].toObject();
if (!obj_resource.contains(QLatin1String("artists")) || !obj_resource[QLatin1String("artists")].isArray()) {
if (!obj_resource.contains("artists"_L1) || !obj_resource["artists"_L1].isArray()) {
qLog(Debug) << "OpenTidal: Invalid Json reply: Resource is missing artists array.";
continue;
}
if (!obj_resource.contains(QLatin1String("title")) || !obj_resource[QLatin1String("title")].isString()) {
if (!obj_resource.contains("title"_L1) || !obj_resource["title"_L1].isString()) {
qLog(Debug) << "OpenTidal: Invalid Json reply: Resource is missing title.";
continue;
}
if (!obj_resource.contains(QLatin1String("imageCover")) || !obj_resource[QLatin1String("imageCover")].isArray()) {
if (!obj_resource.contains("imageCover"_L1) || !obj_resource["imageCover"_L1].isArray()) {
qLog(Debug) << "OpenTidal: Invalid Json reply: Resource is missing imageCover array.";
continue;
}
QString artist;
const QString album = obj_resource[QLatin1String("title")].toString();
const QString album = obj_resource["title"_L1].toString();
const QJsonArray array_artists = obj_resource[QLatin1String("artists")].toArray();
const QJsonArray array_artists = obj_resource["artists"_L1].toArray();
for (const QJsonValue &value_artist : array_artists) {
if (!value_artist.isObject()) {
continue;
}
QJsonObject obj_artist = value_artist.toObject();
if (!obj_artist.contains(QLatin1String("name"))) {
if (!obj_artist.contains("name"_L1)) {
continue;
}
artist = obj_artist[QLatin1String("name")].toString();
artist = obj_artist["name"_L1].toString();
break;
}
const QJsonArray array_covers = obj_resource[QLatin1String("imageCover")].toArray();
const QJsonArray array_covers = obj_resource["imageCover"_L1].toArray();
for (const QJsonValue &value_cover : array_covers) {
if (!value_cover.isObject()) {
continue;
}
QJsonObject obj_cover = value_cover.toObject();
if (!obj_cover.contains(QLatin1String("url")) || !obj_cover.contains(QLatin1String("width")) || !obj_cover.contains(QLatin1String("height"))) {
if (!obj_cover.contains("url"_L1) || !obj_cover.contains("width"_L1) || !obj_cover.contains("height"_L1)) {
continue;
}
const QUrl url(obj_cover[QLatin1String("url")].toString());
const int width = obj_cover[QLatin1String("width")].toInt();
const int height = obj_cover[QLatin1String("height")].toInt();
const QUrl url(obj_cover["url"_L1].toString());
const int width = obj_cover["width"_L1].toInt();
const int height = obj_cover["height"_L1].toInt();
if (!url.isValid()) continue;
if (width < 640 || height < 640) continue;
CoverProviderSearchResult cover_result;

50
src/covermanager/qobuzcoverprovider.cpp
View File

@@ -47,6 +47,8 @@
#include "jsoncoverprovider.h"
#include "qobuzcoverprovider.h"
using namespace Qt::StringLiterals;
namespace {
constexpr int kLimit = 10;
}
@@ -73,14 +75,14 @@ bool QobuzCoverProvider::StartSearch(const QString &artist, const QString &album
QString resource;
QString query = artist;
if (album.isEmpty() && !title.isEmpty()) {
resource = QLatin1String("track/search");
if (!query.isEmpty()) query.append(QLatin1Char(' '));
resource = "track/search"_L1;
if (!query.isEmpty()) query.append(u' ');
query.append(title);
}
else {
resource = QLatin1String("album/search");
resource = "album/search"_L1;
if (!album.isEmpty()) {
if (!query.isEmpty()) query.append(QLatin1Char(' '));
if (!query.isEmpty()) query.append(u' ');
query.append(album);
}
}
@@ -134,9 +136,9 @@ QByteArray QobuzCoverProvider::GetReplyData(QNetworkReply *reply) {
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(QLatin1String("status")) && json_obj.contains(QLatin1String("code")) && json_obj.contains(QLatin1String("message"))) {
int code = json_obj[QLatin1String("code")].toInt();
QString message = json_obj[QLatin1String("message")].toString();
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);
}
}
@@ -179,11 +181,11 @@ void QobuzCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id) {
}
QJsonValue value_type;
if (json_obj.contains(QLatin1String("albums"))) {
value_type = json_obj[QLatin1String("albums")];
if (json_obj.contains("albums"_L1)) {
value_type = json_obj["albums"_L1];
}
else if (json_obj.contains(QLatin1String("tracks"))) {
value_type = json_obj[QLatin1String("tracks")];
else if (json_obj.contains("tracks"_L1)) {
value_type = json_obj["tracks"_L1];
}
else {
Error(QStringLiteral("Json reply is missing albums and tracks object."), json_obj);
@@ -198,12 +200,12 @@ void QobuzCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id) {
}
QJsonObject obj_type = value_type.toObject();
if (!obj_type.contains(QLatin1String("items"))) {
if (!obj_type.contains("items"_L1)) {
Error(QStringLiteral("Json albums or tracks object does not contain items."), obj_type);
Q_EMIT SearchFinished(id, results);
return;
}
QJsonValue value_items = obj_type[QLatin1String("items")];
QJsonValue value_items = obj_type["items"_L1];
if (!value_items.isArray()) {
Error(QStringLiteral("Json albums or track object items is not a array."), value_items);
@@ -221,49 +223,49 @@ void QobuzCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id) {
QJsonObject item_obj = value.toObject();
QJsonObject obj_album;
if (item_obj.contains(QLatin1String("album"))) {
if (!item_obj[QLatin1String("album")].isObject()) {
if (item_obj.contains("album"_L1)) {
if (!item_obj["album"_L1].isObject()) {
Error(QStringLiteral("Invalid Json reply, items album is not a object."), item_obj);
continue;
}
obj_album = item_obj[QLatin1String("album")].toObject();
obj_album = item_obj["album"_L1].toObject();
}
else {
obj_album = item_obj;
}
if (!obj_album.contains(QLatin1String("artist")) || !obj_album.contains(QLatin1String("image")) || !obj_album.contains(QLatin1String("title"))) {
if (!obj_album.contains("artist"_L1) || !obj_album.contains("image"_L1) || !obj_album.contains("title"_L1)) {
Error(QStringLiteral("Invalid Json reply, item is missing artist, title or image."), obj_album);
continue;
}
QString album = obj_album[QLatin1String("title")].toString();
QString album = obj_album["title"_L1].toString();
// Artist
QJsonValue value_artist = obj_album[QLatin1String("artist")];
QJsonValue value_artist = obj_album["artist"_L1];
if (!value_artist.isObject()) {
Error(QStringLiteral("Invalid Json reply, items (album) artist is not a object."), value_artist);
continue;
}
QJsonObject obj_artist = value_artist.toObject();
if (!obj_artist.contains(QLatin1String("name"))) {
if (!obj_artist.contains("name"_L1)) {
Error(QStringLiteral("Invalid Json reply, items (album) artist is missing name."), obj_artist);
continue;
}
QString artist = obj_artist[QLatin1String("name")].toString();
QString artist = obj_artist["name"_L1].toString();
// Image
QJsonValue value_image = obj_album[QLatin1String("image")];
QJsonValue value_image = obj_album["image"_L1];
if (!value_image.isObject()) {
Error(QStringLiteral("Invalid Json reply, items (album) image is not a object."), value_image);
continue;
}
QJsonObject obj_image = value_image.toObject();
if (!obj_image.contains(QLatin1String("large"))) {
if (!obj_image.contains("large"_L1)) {
Error(QStringLiteral("Invalid Json reply, items (album) image is missing large."), obj_image);
continue;
}
QUrl cover_url(obj_image[QLatin1String("large")].toString());
QUrl cover_url(obj_image["large"_L1].toString());
CoverProviderSearchResult cover_result;
cover_result.artist = artist;

52
src/covermanager/spotifycoverprovider.cpp
View File

@@ -52,6 +52,8 @@
#include "jsoncoverprovider.h"
#include "spotifycoverprovider.h"
using namespace Qt::StringLiterals;
namespace {
constexpr char kApiUrl[] = "https://api.spotify.com/v1";
constexpr int kLimit = 10;
@@ -82,16 +84,16 @@ bool SpotifyCoverProvider::StartSearch(const QString &artist, const QString &alb
QString extract;
QString query = artist;
if (album.isEmpty() && !title.isEmpty()) {
type = QLatin1String("track");
extract = QLatin1String("tracks");
if (!query.isEmpty()) query.append(QLatin1Char(' '));
type = "track"_L1;
extract = "tracks"_L1;
if (!query.isEmpty()) query.append(u' ');
query.append(title);
}
else {
type = QLatin1String("album");
extract = QLatin1String("albums");
type = "album"_L1;
extract = "albums"_L1;
if (!album.isEmpty()) {
if (!query.isEmpty()) query.append(QLatin1Char(' '));
if (!query.isEmpty()) query.append(u' ');
query.append(album);
}
}
@@ -141,11 +143,11 @@ QByteArray SpotifyCoverProvider::GetReplyData(QNetworkReply *reply) {
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(QLatin1String("error")) && json_obj[QLatin1String("error")].isObject()) {
QJsonObject obj_error = json_obj[QLatin1String("error")].toObject();
if (obj_error.contains(QLatin1String("status")) && obj_error.contains(QLatin1String("message"))) {
int status = obj_error[QLatin1String("status")].toInt();
QString message = obj_error[QLatin1String("message")].toString();
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();
}
@@ -195,13 +197,13 @@ void SpotifyCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id,
}
json_obj = json_obj[extract].toObject();
if (!json_obj.contains(QLatin1String("items")) || !json_obj[QLatin1String("items")].isArray()) {
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[QLatin1String("items")].toArray();
const QJsonArray array_items = json_obj["items"_L1].toArray();
if (array_items.isEmpty()) {
Q_EMIT SearchFinished(id, CoverProviderSearchResults());
return;
@@ -216,33 +218,33 @@ void SpotifyCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id,
QJsonObject obj_item = value_item.toObject();
QJsonObject obj_album = obj_item;
if (obj_item.contains(QLatin1String("album")) && obj_item[QLatin1String("album")].isObject()) {
obj_album = obj_item[QLatin1String("album")].toObject();
if (obj_item.contains("album"_L1) && obj_item["album"_L1].isObject()) {
obj_album = obj_item["album"_L1].toObject();
}
if (!obj_album.contains(QLatin1String("artists")) || !obj_album.contains(QLatin1String("name")) || !obj_album.contains(QLatin1String("images")) || !obj_album[QLatin1String("artists")].isArray() || !obj_album[QLatin1String("images")].isArray()) {
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()) {
continue;
}
const QJsonArray array_artists = obj_album[QLatin1String("artists")].toArray();
const QJsonArray array_images = obj_album[QLatin1String("images")].toArray();
QString album = obj_album[QLatin1String("name")].toString();
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();
QStringList artists;
for (const QJsonValue &value_artist : array_artists) {
if (!value_artist.isObject()) continue;
QJsonObject obj_artist = value_artist.toObject();
if (!obj_artist.contains(QLatin1String("name"))) continue;
artists << obj_artist[QLatin1String("name")].toString();
if (!obj_artist.contains("name"_L1)) continue;
artists << obj_artist["name"_L1].toString();
}
for (const QJsonValue &value_image : array_images) {
if (!value_image.isObject()) continue;
QJsonObject obj_image = value_image.toObject();
if (!obj_image.contains(QLatin1String("url")) || !obj_image.contains(QLatin1String("width")) || !obj_image.contains(QLatin1String("height"))) continue;
int width = obj_image[QLatin1String("width")].toInt();
int height = obj_image[QLatin1String("height")].toInt();
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();
if (width < 300 || height < 300) continue;
QUrl url(obj_image[QLatin1String("url")].toString());
QUrl url(obj_image["url"_L1].toString());
CoverProviderSearchResult result;
result.album = album;
result.image_url = url;

40
src/covermanager/tidalcoverprovider.cpp
View File

@@ -45,6 +45,8 @@
#include "jsoncoverprovider.h"
#include "tidalcoverprovider.h"
using namespace Qt::StringLiterals;
namespace {
constexpr int kLimit = 10;
}
@@ -73,14 +75,14 @@ bool TidalCoverProvider::StartSearch(const QString &artist, const QString &album
QString resource;
QString query = artist;
if (album.isEmpty() && !title.isEmpty()) {
resource = QLatin1String("search/tracks");
if (!query.isEmpty()) query.append(QLatin1Char(' '));
resource = "search/tracks"_L1;
if (!query.isEmpty()) query.append(u' ');
query.append(title);
}
else {
resource = QLatin1String("search/albums");
resource = "search/albums"_L1;
if (!album.isEmpty()) {
if (!query.isEmpty()) query.append(QLatin1Char(' '));
if (!query.isEmpty()) query.append(u' ');
query.append(album);
}
}
@@ -134,10 +136,10 @@ QByteArray TidalCoverProvider::GetReplyData(QNetworkReply *reply) {
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(QLatin1String("status")) && json_obj.contains(QLatin1String("userMessage"))) {
status = json_obj[QLatin1String("status")].toInt();
sub_status = json_obj[QLatin1String("subStatus")].toInt();
QString user_message = json_obj[QLatin1String("userMessage")].toString();
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);
}
}
@@ -180,12 +182,12 @@ void TidalCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id) {
return;
}
if (!json_obj.contains(QLatin1String("items"))) {
if (!json_obj.contains("items"_L1)) {
Error(QStringLiteral("Json object is missing items."), json_obj);
Q_EMIT SearchFinished(id, CoverProviderSearchResults());
return;
}
QJsonValue value_items = json_obj[QLatin1String("items")];
QJsonValue value_items = json_obj["items"_L1];
if (!value_items.isArray()) {
Q_EMIT SearchFinished(id, CoverProviderSearchResults());
@@ -207,25 +209,25 @@ void TidalCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id) {
}
QJsonObject obj_item = value_item.toObject();
if (!obj_item.contains(QLatin1String("artist"))) {
if (!obj_item.contains("artist"_L1)) {
Error(QStringLiteral("Invalid Json reply, items array item is missing artist."), obj_item);
continue;
}
QJsonValue value_artist = obj_item[QLatin1String("artist")];
QJsonValue value_artist = obj_item["artist"_L1];
if (!value_artist.isObject()) {
Error(QStringLiteral("Invalid Json reply, items array item artist is not a object."), value_artist);
continue;
}
QJsonObject obj_artist = value_artist.toObject();
if (!obj_artist.contains(QLatin1String("name"))) {
if (!obj_artist.contains("name"_L1)) {
Error(QStringLiteral("Invalid Json reply, items array item artist is missing name."), obj_artist);
continue;
}
QString artist = obj_artist[QLatin1String("name")].toString();
QString artist = obj_artist["name"_L1].toString();
QJsonObject obj_album;
if (obj_item.contains(QLatin1String("album"))) {
QJsonValue value_album = obj_item[QLatin1String("album")];
if (obj_item.contains("album"_L1)) {
QJsonValue value_album = obj_item["album"_L1];
if (value_album.isObject()) {
obj_album = value_album.toObject();
}
@@ -238,12 +240,12 @@ void TidalCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id) {
obj_album = obj_item;
}
if (!obj_album.contains(QLatin1String("title")) || !obj_album.contains(QLatin1String("cover"))) {
if (!obj_album.contains("title"_L1) || !obj_album.contains("cover"_L1)) {
Error(QStringLiteral("Invalid Json reply, items array item album is missing title or cover."), obj_album);
continue;
}
QString album = obj_album[QLatin1String("title")].toString();
QString cover = obj_album[QLatin1String("cover")].toString().replace(QLatin1String("-"), QLatin1String("/"));
QString album = obj_album["title"_L1].toString();
QString cover = obj_album["cover"_L1].toString().replace("-"_L1, "/"_L1);
CoverProviderSearchResult cover_result;
cover_result.artist = artist;