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

Use QStringLiteral

Browse Source
This commit is contained in:
Jonas Kvinge
2024-04-09 23:20:26 +02:00
parent 3cfffa5fbb
commit 58944993b8
233 changed files with 3885 additions and 3885 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
src/covermanager/albumcoverchoicecontroller.cpp
View File

@@ -102,16 +102,16 @@ AlbumCoverChoiceController::AlbumCoverChoiceController(QWidget *parent)
search_cover_auto_(nullptr),
save_embedded_cover_override_(false) {
cover_from_file_ = new QAction(IconLoader::Load("document-open"), tr("Load cover from disk..."), this);
cover_to_file_ = new QAction(IconLoader::Load("document-save"), tr("Save cover to disk..."), this);
cover_from_url_ = new QAction(IconLoader::Load("download"), tr("Load cover from URL..."), this);
search_for_cover_ = new QAction(IconLoader::Load("search"), tr("Search for album covers..."), this);
unset_cover_ = new QAction(IconLoader::Load("list-remove"), tr("Unset cover"), this);
delete_cover_ = new QAction(IconLoader::Load("list-remove"), tr("Delete cover"), this);
clear_cover_ = new QAction(IconLoader::Load("list-remove"), tr("Clear cover"), this);
cover_from_file_ = new QAction(IconLoader::Load(QStringLiteral("document-open")), tr("Load cover from disk..."), this);
cover_to_file_ = new QAction(IconLoader::Load(QStringLiteral("document-save")), tr("Save cover to disk..."), this);
cover_from_url_ = new QAction(IconLoader::Load(QStringLiteral("download")), tr("Load cover from URL..."), this);
search_for_cover_ = new QAction(IconLoader::Load(QStringLiteral("search")), tr("Search for album covers..."), this);
unset_cover_ = new QAction(IconLoader::Load(QStringLiteral("list-remove")), tr("Unset cover"), this);
delete_cover_ = new QAction(IconLoader::Load(QStringLiteral("list-remove")), tr("Delete cover"), this);
clear_cover_ = new QAction(IconLoader::Load(QStringLiteral("list-remove")), tr("Clear cover"), this);
separator1_ = new QAction(this);
separator1_->setSeparator(true);
show_cover_ = new QAction(IconLoader::Load("zoom-in"), tr("Show fullsize..."), this);
show_cover_ = new QAction(IconLoader::Load(QStringLiteral("zoom-in")), tr("Show fullsize..."), this);
search_cover_auto_ = new QAction(tr("Search automatically"), this);
search_cover_auto_->setCheckable(true);
@@ -230,14 +230,14 @@ QUrl AlbumCoverChoiceController::LoadCoverFromFile(Song *song) {
void AlbumCoverChoiceController::SaveCoverToFileManual(const Song &song, const AlbumCoverImageResult &result) {
QString initial_file_name = "/";
QString initial_file_name = QStringLiteral("/");
if (!song.effective_albumartist().isEmpty()) {
initial_file_name = initial_file_name + song.effective_albumartist();
}
initial_file_name = initial_file_name + "-" + (song.effective_album().isEmpty() ? tr("unknown") : song.effective_album()) + ".jpg";
initial_file_name = initial_file_name.toLower();
initial_file_name.replace(QRegularExpression("\\s"), "-");
initial_file_name.replace(QRegularExpression(QStringLiteral("\\s")), QStringLiteral("-"));
initial_file_name.remove(QRegularExpression(QString(kInvalidFatCharactersRegex), QRegularExpression::CaseInsensitiveOption));
QString save_filename = QFileDialog::getSaveFileName(this, tr("Save album cover"), GetInitialPathForFileDialog(song, initial_file_name), tr(kSaveImageFileFilter) + ";;" + tr(kAllFilesFilter));
@@ -255,7 +255,7 @@ void AlbumCoverChoiceController::SaveCoverToFileManual(const Song &song, const A
fileinfo.setFile(save_filename);
}
if (result.is_jpeg() && fileinfo.completeSuffix().compare("jpg", Qt::CaseInsensitive) == 0) {
if (result.is_jpeg() && fileinfo.completeSuffix().compare(QLatin1String("jpg"), 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();
@@ -655,7 +655,7 @@ QUrl AlbumCoverChoiceController::SaveCoverToFileAutomatic(const Song::Source sou
const AlbumCoverImageResult &result,
const bool force_overwrite) {
QString filepath = CoverUtils::CoverFilePath(cover_options_, source, artist, album, album_id, album_dir, result.cover_url, "jpg");
QString filepath = CoverUtils::CoverFilePath(cover_options_, source, artist, album, album_id, album_dir, result.cover_url, QStringLiteral("jpg"));
if (filepath.isEmpty()) return QUrl();
QFile file(filepath);
@@ -744,7 +744,7 @@ bool AlbumCoverChoiceController::IsKnownImageExtension(const QString &suffix) {
if (!sImageExtensions) {
sImageExtensions = new QSet<QString>();
(*sImageExtensions) << "png" << "jpg" << "jpeg" << "bmp" << "gif" << "xpm" << "pbm" << "pgm" << "ppm" << "xbm";
(*sImageExtensions) << QStringLiteral("png") << QStringLiteral("jpg") << QStringLiteral("jpeg") << QStringLiteral("bmp") << QStringLiteral("gif") << QStringLiteral("xpm") << QStringLiteral("pbm") << QStringLiteral("pgm") << QStringLiteral("ppm") << QStringLiteral("xbm");
}
return sImageExtensions->contains(suffix);

2
src/covermanager/albumcoverexport.cpp
View File

@@ -69,7 +69,7 @@ AlbumCoverExport::DialogResult AlbumCoverExport::Exec() {
if (!result.cancelled_) {
QString fileName = ui_->fileName->text();
if (fileName.isEmpty()) {
fileName = "cover";
fileName = QStringLiteral("cover");
}
OverwriteMode overwrite_mode = ui_->doNotOverwrite->isChecked() ? OverwriteMode::None : (ui_->overwriteAll->isChecked() ? OverwriteMode::All : OverwriteMode::Smaller);
bool forceSize = ui_->forceSize->isChecked();

86
src/covermanager/albumcoverfetchersearch.cpp
View File

@@ -83,7 +83,7 @@ void AlbumCoverFetcherSearch::TerminateSearch() {
void AlbumCoverFetcherSearch::Start(SharedPtr<CoverProviders> cover_providers) {
// Ignore Radio Paradise "commercial" break.
if (request_.artist.compare("commercial-free", Qt::CaseInsensitive) == 0 && request_.title.compare("listener-supported", Qt::CaseInsensitive) == 0) {
if (request_.artist.compare(QLatin1String("commercial-free"), Qt::CaseInsensitive) == 0 && request_.title.compare(QLatin1String("listener-supported"), Qt::CaseInsensitive) == 0) {
TerminateSearch();
return;
}
@@ -167,51 +167,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("hits", Qt::CaseInsensitive) ||
result_album.contains("greatest", Qt::CaseInsensitive) ||
result_album.contains("best", Qt::CaseInsensitive) ||
result_album.contains("collection", Qt::CaseInsensitive) ||
result_album.contains("classics", Qt::CaseInsensitive) ||
result_album.contains("singles", Qt::CaseInsensitive) ||
result_album.contains("bootleg", Qt::CaseInsensitive) ||
result_album.contains("live", Qt::CaseInsensitive) ||
result_album.contains("concert", Qt::CaseInsensitive) ||
result_album.contains("essential", Qt::CaseInsensitive) ||
result_album.contains("ultimate", Qt::CaseInsensitive) ||
result_album.contains("karaoke", Qt::CaseInsensitive) ||
result_album.contains("mixtape", Qt::CaseInsensitive) ||
result_album.contains("country rock", Qt::CaseInsensitive) ||
result_album.contains("indie folk", Qt::CaseInsensitive) ||
result_album.contains("soft rock", Qt::CaseInsensitive) ||
result_album.contains("folk music", Qt::CaseInsensitive) ||
result_album.contains("60's rock", Qt::CaseInsensitive) ||
result_album.contains("60's romance", Qt::CaseInsensitive) ||
result_album.contains("60s music", Qt::CaseInsensitive) ||
result_album.contains("late 60s", Qt::CaseInsensitive) ||
result_album.contains("the 60s", Qt::CaseInsensitive) ||
result_album.contains("folk and blues", Qt::CaseInsensitive) ||
result_album.contains("60 from the 60's", Qt::CaseInsensitive) ||
result_album.contains("classic psychedelic", Qt::CaseInsensitive) ||
result_album.contains("playlist: acoustic", Qt::CaseInsensitive) ||
result_album.contains("90's rnb playlist", Qt::CaseInsensitive) ||
result_album.contains("rock 80s", Qt::CaseInsensitive) ||
result_album.contains("classic 80s", Qt::CaseInsensitive) ||
result_album.contains("rock anthems", Qt::CaseInsensitive) ||
result_album.contains("rock songs", Qt::CaseInsensitive) ||
result_album.contains("rock 2019", Qt::CaseInsensitive) ||
result_album.contains("guitar anthems", Qt::CaseInsensitive) ||
result_album.contains("driving anthems", Qt::CaseInsensitive) ||
result_album.contains("traffic jam jams", Qt::CaseInsensitive) ||
result_album.contains("perfect background music", Qt::CaseInsensitive) ||
result_album.contains("70's gold", Qt::CaseInsensitive) ||
result_album.contains("rockfluence", Qt::CaseInsensitive) ||
result_album.contains("acoustic dinner accompaniment", Qt::CaseInsensitive) ||
result_album.contains("complete studio albums", Qt::CaseInsensitive) ||
result_album.contains("mellow rock", Qt::CaseInsensitive)
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)
)) {
results_copy[i].score_match -= 1;
}
else if (request_album.isEmpty() && result_album.contains("soundtrack", Qt::CaseInsensitive)) {
else if (request_album.isEmpty() && result_album.contains(QLatin1String("soundtrack"), Qt::CaseInsensitive)) {
results_copy[i].score_match -= 0.5;
}

2
src/covermanager/albumcoverloaderoptions.cpp
View File

@@ -35,7 +35,7 @@ AlbumCoverLoaderOptions::Types AlbumCoverLoaderOptions::LoadTypes() {
QSettings s;
s.beginGroup(CoversSettingsPage::kSettingsGroup);
const QStringList all_cover_types = QStringList() << "art_unset" << "art_embedded" << "art_manual" << "art_automatic";
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 == "art_unset") {

22
src/covermanager/albumcovermanager.cpp
View File

@@ -112,8 +112,8 @@ AlbumCoverManager::AlbumCoverManager(Application *app, SharedPtr<CollectionBacke
cover_searcher_(nullptr),
cover_export_(nullptr),
cover_exporter_(new AlbumCoverExporter(this)),
artist_icon_(IconLoader::Load("folder-sound")),
all_artists_icon_(IconLoader::Load("library-music")),
artist_icon_(IconLoader::Load(QStringLiteral("folder-sound"))),
all_artists_icon_(IconLoader::Load(QStringLiteral("library-music"))),
image_nocover_thumbnail_(ImageUtils::GenerateNoCoverImage(QSize(120, 120), devicePixelRatio())),
icon_nocover_item_(QPixmap::fromImage(image_nocover_thumbnail_)),
context_menu_(new QMenu(this)),
@@ -126,12 +126,12 @@ AlbumCoverManager::AlbumCoverManager(Application *app, SharedPtr<CollectionBacke
ui_->albums->set_cover_manager(this);
// Icons
ui_->action_fetch->setIcon(IconLoader::Load("download"));
ui_->export_covers->setIcon(IconLoader::Load("document-save"));
ui_->view->setIcon(IconLoader::Load("view-choose"));
ui_->button_fetch->setIcon(IconLoader::Load("download"));
ui_->action_add_to_playlist->setIcon(IconLoader::Load("media-playback-start"));
ui_->action_load->setIcon(IconLoader::Load("media-playback-start"));
ui_->action_fetch->setIcon(IconLoader::Load(QStringLiteral("download")));
ui_->export_covers->setIcon(IconLoader::Load(QStringLiteral("document-save")));
ui_->view->setIcon(IconLoader::Load(QStringLiteral("view-choose")));
ui_->button_fetch->setIcon(IconLoader::Load(QStringLiteral("download")));
ui_->action_add_to_playlist->setIcon(IconLoader::Load(QStringLiteral("media-playback-start")));
ui_->action_load->setIcon(IconLoader::Load(QStringLiteral("media-playback-start")));
album_cover_choice_controller_->Init(app_);
@@ -877,12 +877,12 @@ SongList AlbumCoverManager::GetSongsInAlbum(const QModelIndex &idx) const {
CollectionQuery q(db, collection_backend_->songs_table(), collection_backend_->fts_table());
q.SetColumnSpec("ROWID," + Song::kColumnSpec);
q.AddWhere("album", idx.data(Role_Album).toString());
q.SetOrderBy("disc, track, title");
q.AddWhere(QStringLiteral("album"), idx.data(Role_Album).toString());
q.SetOrderBy(QStringLiteral("disc, track, title"));
QString albumartist = idx.data(Role_AlbumArtist).toString();
if (!albumartist.isEmpty()) {
q.AddWhere("effective_albumartist", albumartist);
q.AddWhere(QStringLiteral("effective_albumartist"), albumartist);
}
q.AddCompilationRequirement(albumartist.isEmpty());

6
src/covermanager/coverexportrunnable.cpp
View File

@@ -76,7 +76,7 @@ void CoverExportRunnable::ProcessAndExportCover() {
if (song_.art_embedded() && dialog_result_.export_embedded_) {
image = TagReaderClient::Instance()->LoadEmbeddedArtAsImageBlocking(song_.url().toLocalFile());
if (!image.isNull()) {
extension = "jpg";
extension = QStringLiteral("jpg");
}
}
break;
@@ -111,7 +111,7 @@ void CoverExportRunnable::ProcessAndExportCover() {
}
QString cover_dir = song_.url().toLocalFile().section('/', 0, -2);
QString new_file = cover_dir + '/' + dialog_result_.filename_ + '.' + (song_.art_embedded() ? "jpg" : extension);
QString new_file = cover_dir + '/' + dialog_result_.filename_ + '.' + (song_.art_embedded() ? QStringLiteral("jpg") : extension);
// If the file exists, do not override!
if (dialog_result_.overwrite_ == AlbumCoverExport::OverwriteMode::None && QFile::exists(new_file)) {
@@ -169,7 +169,7 @@ void CoverExportRunnable::ExportCover() {
image = TagReaderClient::Instance()->LoadEmbeddedArtAsImageBlocking(song_.url().toLocalFile());
if (!image.isNull()) {
embedded_cover = true;
extension = "jpg";
extension = QStringLiteral("jpg");
}
}
break;

2
src/covermanager/coverfromurldialog.cpp
View File

@@ -56,7 +56,7 @@ CoverFromURLDialog::~CoverFromURLDialog() {
AlbumCoverImageResult CoverFromURLDialog::Exec() {
// reset state
ui_->url->setText("");
ui_->url->setText(QLatin1String(""));
last_album_cover_ = AlbumCoverImageResult();
QClipboard *clipboard = QApplication::clipboard();

2
src/covermanager/coversearchstatistics.cpp
View File

@@ -60,7 +60,7 @@ CoverSearchStatistics &CoverSearchStatistics::operator+=(const CoverSearchStatis
QString CoverSearchStatistics::AverageDimensions() const {
if (chosen_images_ == 0) {
return "0x0";
return QStringLiteral("0x0");
}
return QString::number(chosen_width_ / chosen_images_) + "x" + QString::number(chosen_height_ / chosen_images_);

2
src/covermanager/coversearchstatisticsdialog.cpp
View File

@@ -79,7 +79,7 @@ void CoverSearchStatisticsDialog::Show(const CoverSearchStatistics &statistics)
AddLine(tr("Total network requests made"), QString::number(statistics.network_requests_made_));
AddLine(tr("Average image size"), statistics.AverageDimensions());
AddLine(tr("Total bytes transferred"), statistics.bytes_transferred_ > 0 ? Utilities::PrettySize(statistics.bytes_transferred_) : "0 bytes");
AddLine(tr("Total bytes transferred"), statistics.bytes_transferred_ > 0 ? Utilities::PrettySize(statistics.bytes_transferred_) : QStringLiteral("0 bytes"));
details_layout_->addStretch();

2
src/covermanager/currentalbumcoverloader.cpp
View File

@@ -46,7 +46,7 @@ CurrentAlbumCoverLoader::CurrentAlbumCoverLoader(Application *app, QObject *pare
options_.options = AlbumCoverLoaderOptions::Option::RawImageData | AlbumCoverLoaderOptions::Option::OriginalImage | AlbumCoverLoaderOptions::Option::ScaledImage;
options_.desired_scaled_size = QSize(120, 120);
options_.default_cover = ":/pictures/cdcase.png";
options_.default_cover = QStringLiteral(":/pictures/cdcase.png");
QObject::connect(&*app_->playlist_manager(), &PlaylistManager::CurrentSongChanged, this, &CurrentAlbumCoverLoader::LoadAlbumCover);
QObject::connect(&*app_->album_cover_loader(), &AlbumCoverLoader::AlbumCoverLoaded, this, &CurrentAlbumCoverLoader::AlbumCoverReady);

88
src/covermanager/deezercoverprovider.cpp
View File

@@ -51,7 +51,7 @@ const char *DeezerCoverProvider::kApiUrl = "https://api.deezer.com";
const int DeezerCoverProvider::kLimit = 10;
DeezerCoverProvider::DeezerCoverProvider(Application *app, SharedPtr<NetworkAccessManager> network, QObject *parent)
: JsonCoverProvider("Deezer", true, false, 2.0, true, true, app, network, parent) {}
: JsonCoverProvider(QStringLiteral("Deezer"), true, false, 2.0, true, true, app, network, parent) {}
DeezerCoverProvider::~DeezerCoverProvider() {
@@ -71,12 +71,12 @@ bool DeezerCoverProvider::StartSearch(const QString &artist, const QString &albu
QString resource;
QString query = artist;
if (album.isEmpty() && !title.isEmpty()) {
resource = "search/track";
resource = QStringLiteral("search/track");
if (!query.isEmpty()) query.append(" ");
query.append(title);
}
else {
resource = "search/album";
resource = QStringLiteral("search/album");
if (!album.isEmpty()) {
if (!query.isEmpty()) query.append(" ");
query.append(album);
@@ -92,7 +92,7 @@ bool DeezerCoverProvider::StartSearch(const QString &artist, const QString &albu
url_query.addQueryItem(QUrl::toPercentEncoding(param.first), QUrl::toPercentEncoding(param.second));
}
QUrl url(kApiUrl + QString("/") + resource);
QUrl url(kApiUrl + QStringLiteral("/") + resource);
url.setQuery(url_query);
QNetworkRequest req(url);
req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
@@ -116,7 +116,7 @@ QByteArray DeezerCoverProvider::GetReplyData(QNetworkReply *reply) {
else {
if (reply->error() != QNetworkReply::NoError && reply->error() < 200) {
// This is a network error, there is nothing more to do.
QString error = QString("%1 (%2)").arg(reply->errorString()).arg(reply->error());
QString error = QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
Error(error);
}
else {
@@ -127,22 +127,22 @@ 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("error")) {
QJsonValue value_error = json_obj["error"];
if (json_obj.contains(QStringLiteral("error"))) {
QJsonValue value_error = json_obj[QStringLiteral("error")];
if (value_error.isObject()) {
QJsonObject obj_error = value_error.toObject();
int code = obj_error["code"].toInt();
QString message = obj_error["message"].toString();
error = QString("%1 (%2)").arg(message).arg(code);
int code = obj_error[QStringLiteral("code")].toInt();
QString message = obj_error[QStringLiteral("message")].toString();
error = QStringLiteral("%1 (%2)").arg(message).arg(code);
}
}
}
if (error.isEmpty()) {
if (reply->error() != QNetworkReply::NoError) {
error = QString("%1 (%2)").arg(reply->errorString()).arg(reply->error());
error = QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
}
else {
error = QString("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt());
error = QStringLiteral("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt());
}
}
Error(error);
@@ -159,27 +159,27 @@ QJsonValue DeezerCoverProvider::ExtractData(const QByteArray &data) {
QJsonObject json_obj = ExtractJsonObj(data);
if (json_obj.isEmpty()) return QJsonObject();
if (json_obj.contains("error")) {
QJsonValue value_error = json_obj["error"];
if (json_obj.contains(QStringLiteral("error"))) {
QJsonValue value_error = json_obj[QStringLiteral("error")];
if (!value_error.isObject()) {
Error("Error missing object", json_obj);
Error(QStringLiteral("Error missing object"), json_obj);
return QJsonValue();
}
QJsonObject obj_error = value_error.toObject();
const int code = obj_error["code"].toInt();
QString message = obj_error["message"].toString();
Error(QString("%1 (%2)").arg(message).arg(code));
const int code = obj_error[QStringLiteral("code")].toInt();
QString message = obj_error[QStringLiteral("message")].toString();
Error(QStringLiteral("%1 (%2)").arg(message).arg(code));
return QJsonValue();
}
if (!json_obj.contains("data") && !json_obj.contains("DATA")) {
Error("Json reply object is missing data.", json_obj);
if (!json_obj.contains(QStringLiteral("data")) && !json_obj.contains(QStringLiteral("DATA"))) {
Error(QStringLiteral("Json reply object is missing data."), json_obj);
return QJsonValue();
}
QJsonValue value_data;
if (json_obj.contains("data")) value_data = json_obj["data"];
else value_data = json_obj["DATA"];
if (json_obj.contains(QStringLiteral("data"))) value_data = json_obj[QStringLiteral("data")];
else value_data = json_obj[QStringLiteral("DATA")];
return value_data;
@@ -215,63 +215,63 @@ void DeezerCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id)
for (const QJsonValueRef json_value : array_data) {
if (!json_value.isObject()) {
Error("Invalid Json reply, data array value is not a object.");
Error(QStringLiteral("Invalid Json reply, data array value is not a object."));
continue;
}
QJsonObject json_obj = json_value.toObject();
QJsonObject obj_album;
if (json_obj.contains("album") && json_obj["album"].isObject()) { // Song search, so extract the album.
obj_album = json_obj["album"].toObject();
if (json_obj.contains(QStringLiteral("album")) && json_obj[QStringLiteral("album")].isObject()) { // Song search, so extract the album.
obj_album = json_obj[QStringLiteral("album")].toObject();
}
else {
obj_album = json_obj;
}
if (!json_obj.contains("id") || !obj_album.contains("id")) {
Error("Invalid Json reply, data array value object is missing ID.", json_obj);
if (!json_obj.contains(QStringLiteral("id")) || !obj_album.contains(QStringLiteral("id"))) {
Error(QStringLiteral("Invalid Json reply, data array value object is missing ID."), json_obj);
continue;
}
if (!obj_album.contains("type")) {
Error("Invalid Json reply, data array value album object is missing type.", obj_album);
if (!obj_album.contains(QStringLiteral("type"))) {
Error(QStringLiteral("Invalid Json reply, data array value album object is missing type."), obj_album);
continue;
}
QString type = obj_album["type"].toString();
QString type = obj_album[QStringLiteral("type")].toString();
if (type != "album") {
Error("Invalid Json reply, data array value album object has incorrect type returned", obj_album);
Error(QStringLiteral("Invalid Json reply, data array value album object has incorrect type returned"), obj_album);
continue;
}
if (!json_obj.contains("artist")) {
Error("Invalid Json reply, data array value object is missing artist.", json_obj);
if (!json_obj.contains(QStringLiteral("artist"))) {
Error(QStringLiteral("Invalid Json reply, data array value object is missing artist."), json_obj);
continue;
}
QJsonValue value_artist = json_obj["artist"];
QJsonValue value_artist = json_obj[QStringLiteral("artist")];
if (!value_artist.isObject()) {
Error("Invalid Json reply, data array value artist is not a object.", value_artist);
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("name")) {
Error("Invalid Json reply, data array value artist object is missing name.", obj_artist);
if (!obj_artist.contains(QStringLiteral("name"))) {
Error(QStringLiteral("Invalid Json reply, data array value artist object is missing name."), obj_artist);
continue;
}
QString artist = obj_artist["name"].toString();
QString artist = obj_artist[QStringLiteral("name")].toString();
if (!obj_album.contains("title")) {
Error("Invalid Json reply, data array value album object is missing title.", obj_album);
if (!obj_album.contains(QStringLiteral("title"))) {
Error(QStringLiteral("Invalid Json reply, data array value album object is missing title."), obj_album);
continue;
}
QString album = obj_album["title"].toString();
QString album = obj_album[QStringLiteral("title")].toString();
CoverProviderSearchResult cover_result;
cover_result.artist = artist;
cover_result.album = Song::AlbumRemoveDiscMisc(album);
bool have_cover = false;
QList<QPair<QString, QSize>> cover_sizes = QList<QPair<QString, QSize>>() << qMakePair(QString("cover_xl"), QSize(1000, 1000))
<< qMakePair(QString("cover_big"), QSize(500, 500));
QList<QPair<QString, QSize>> cover_sizes = QList<QPair<QString, QSize>>() << qMakePair(QStringLiteral("cover_xl"), QSize(1000, 1000))
<< qMakePair(QStringLiteral("cover_big"), QSize(500, 500));
for (const QPair<QString, QSize> &cover_size : cover_sizes) {
if (!obj_album.contains(cover_size.first)) continue;
QString cover = obj_album[cover_size.first].toString();
@@ -289,7 +289,7 @@ void DeezerCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id)
}
if (!have_cover) {
Error("Invalid Json reply, data array value album object is missing cover.", obj_album);
Error(QStringLiteral("Invalid Json reply, data array value album object is missing cover."), obj_album);
}
}

88
src/covermanager/discogscoverprovider.cpp
View File

@@ -58,7 +58,7 @@ const char *DiscogsCoverProvider::kSecretKeyB64 = "ZkFIcmlaSER4aHhRSlF2U3d0bm5ZV
const int DiscogsCoverProvider::kRequestsDelay = 1000;
DiscogsCoverProvider::DiscogsCoverProvider(Application *app, SharedPtr<NetworkAccessManager> network, QObject *parent)
: JsonCoverProvider("Discogs", false, false, 0.0, false, false, app, network, parent),
: JsonCoverProvider(QStringLiteral("Discogs"), false, false, 0.0, false, false, app, network, parent),
timer_flush_requests_(new QTimer(this)) {
timer_flush_requests_->setInterval(kRequestsDelay);
@@ -163,11 +163,11 @@ QNetworkReply *DiscogsCoverProvider::CreateRequest(QUrl url, const ParamList &pa
url.setQuery(url_query);
// Sign the request
const QByteArray data_to_sign = QString("GET\n%1\n%2\n%3").arg(url.host(), url.path(), query_items.join("&")).toUtf8();
const QByteArray data_to_sign = QStringLiteral("GET\n%1\n%2\n%3").arg(url.host(), url.path(), query_items.join(QStringLiteral("&"))).toUtf8();
const QByteArray signature(Utilities::HmacSha256(QByteArray::fromBase64(kSecretKeyB64), data_to_sign));
// Add the signature to the request
url_query.addQueryItem("Signature", QUrl::toPercentEncoding(signature.toBase64()));
url_query.addQueryItem(QStringLiteral("Signature"), QUrl::toPercentEncoding(signature.toBase64()));
QNetworkRequest req(url);
req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
@@ -190,7 +190,7 @@ QByteArray DiscogsCoverProvider::GetReplyData(QNetworkReply *reply) {
else {
if (reply->error() != QNetworkReply::NoError && reply->error() < 200) {
// This is a network error, there is nothing more to do.
QString error = QString("%1 (%2)").arg(reply->errorString()).arg(reply->error());
QString error = QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
Error(error);
}
else {
@@ -201,16 +201,16 @@ 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("message")) {
error = json_obj["message"].toString();
if (json_obj.contains(QStringLiteral("message"))) {
error = json_obj[QStringLiteral("message")].toString();
}
}
if (error.isEmpty()) {
if (reply->error() != QNetworkReply::NoError) {
error = QString("%1 (%2)").arg(reply->errorString()).arg(reply->error());
error = QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
}
else {
error = QString("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt());
error = QStringLiteral("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt());
}
}
Error(error);
@@ -245,23 +245,23 @@ void DiscogsCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id)
}
QJsonValue value_results;
if (json_obj.contains("results")) {
value_results = json_obj["results"];
if (json_obj.contains(QStringLiteral("results"))) {
value_results = json_obj[QStringLiteral("results")];
}
else if (json_obj.contains("message")) {
QString message = json_obj["message"].toString();
Error(QString("%1").arg(message));
else if (json_obj.contains(QStringLiteral("message"))) {
QString message = json_obj[QStringLiteral("message")].toString();
Error(QStringLiteral("%1").arg(message));
EndSearch(search);
return;
}
else {
Error("Json object is missing results.", json_obj);
Error(QStringLiteral("Json object is missing results."), json_obj);
EndSearch(search);
return;
}
if (!value_results.isArray()) {
Error("Missing results array.", value_results);
Error(QStringLiteral("Missing results array."), value_results);
EndSearch(search);
return;
}
@@ -270,20 +270,20 @@ void DiscogsCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id)
for (QJsonValueRef value_result : array_results) {
if (!value_result.isObject()) {
Error("Invalid Json reply, results value is not a object.");
Error(QStringLiteral("Invalid Json reply, results value is not a object."));
continue;
}
QJsonObject obj_result = value_result.toObject();
if (!obj_result.contains("id") || !obj_result.contains("title") || !obj_result.contains("resource_url")) {
Error("Invalid Json reply, results value object is missing ID, title or resource_url.", obj_result);
if (!obj_result.contains(QStringLiteral("id")) || !obj_result.contains(QStringLiteral("title")) || !obj_result.contains(QStringLiteral("resource_url"))) {
Error(QStringLiteral("Invalid Json reply, results value object is missing ID, title or resource_url."), obj_result);
continue;
}
quint64 release_id = obj_result["id"].toInt();
QUrl resource_url(obj_result["resource_url"].toString());
QString title = obj_result["title"].toString();
quint64 release_id = obj_result[QStringLiteral("id")].toInt();
QUrl resource_url(obj_result[QStringLiteral("resource_url")].toString());
QString title = obj_result[QStringLiteral("title")].toString();
if (title.contains(" - ")) {
QStringList title_splitted = title.split(" - ");
if (title.contains(QLatin1String(" - "))) {
QStringList title_splitted = title.split(QStringLiteral(" - "));
if (title_splitted.count() == 2) {
QString artist = title_splitted.first();
title = title_splitted.last();
@@ -354,20 +354,20 @@ void DiscogsCoverProvider::HandleReleaseReply(QNetworkReply *reply, const int se
return;
}
if (!json_obj.contains("artists") || !json_obj.contains("title")) {
Error("Json reply object is missing artists or title.", json_obj);
if (!json_obj.contains(QStringLiteral("artists")) || !json_obj.contains(QStringLiteral("title"))) {
Error(QStringLiteral("Json reply object is missing artists or title."), json_obj);
EndSearch(search, release.id);
return;
}
if (!json_obj.contains("images")) {
if (!json_obj.contains(QStringLiteral("images"))) {
EndSearch(search, release.id);
return;
}
QJsonValue value_artists = json_obj["artists"];
QJsonValue value_artists = json_obj[QStringLiteral("artists")];
if (!value_artists.isArray()) {
Error("Json reply object artists is not a array.", value_artists);
Error(QStringLiteral("Json reply object artists is not a array."), value_artists);
EndSearch(search, release.id);
return;
}
@@ -376,15 +376,15 @@ void DiscogsCoverProvider::HandleReleaseReply(QNetworkReply *reply, const int se
QString artist;
for (const QJsonValueRef value_artist : array_artists) {
if (!value_artist.isObject()) {
Error("Invalid Json reply, atists array value is not a object.");
Error(QStringLiteral("Invalid Json reply, atists array value is not a object."));
continue;
}
QJsonObject obj_artist = value_artist.toObject();
if (!obj_artist.contains("name")) {
Error("Invalid Json reply, artists array value object is missing name.", obj_artist);
if (!obj_artist.contains(QStringLiteral("name"))) {
Error(QStringLiteral("Invalid Json reply, artists array value object is missing name."), obj_artist);
continue;
}
artist = obj_artist["name"].toString();
artist = obj_artist[QStringLiteral("name")].toString();
++i;
if (artist == search->artist) break;
}
@@ -393,24 +393,24 @@ void DiscogsCoverProvider::HandleReleaseReply(QNetworkReply *reply, const int se
EndSearch(search, release.id);
return;
}
if (i > 1 && artist != search->artist) artist = "Various artists";
if (i > 1 && artist != search->artist) artist = QStringLiteral("Various artists");
QString album = json_obj["title"].toString();
QString album = json_obj[QStringLiteral("title")].toString();
if (artist != search->artist && album != search->album) {
EndSearch(search, release.id);
return;
}
QJsonValue value_images = json_obj["images"];
QJsonValue value_images = json_obj[QStringLiteral("images")];
if (!value_images.isArray()) {
Error("Json images is not an array.");
Error(QStringLiteral("Json images is not an array."));
EndSearch(search, release.id);
return;
}
QJsonArray array_images = value_images.toArray();
if (array_images.isEmpty()) {
Error("Invalid Json reply, images array is empty.");
Error(QStringLiteral("Invalid Json reply, images array is empty."));
EndSearch(search, release.id);
return;
}
@@ -418,27 +418,27 @@ void DiscogsCoverProvider::HandleReleaseReply(QNetworkReply *reply, const int se
for (const QJsonValueRef value_image : array_images) {
if (!value_image.isObject()) {
Error("Invalid Json reply, images array value is not an object.");
Error(QStringLiteral("Invalid Json reply, images array value is not an object."));
continue;
}
QJsonObject obj_image = value_image.toObject();
if (!obj_image.contains("type") || !obj_image.contains("resource_url") || !obj_image.contains("width") || !obj_image.contains("height")) {
Error("Invalid Json reply, images array value object is missing type, resource_url, width or height.", obj_image);
if (!obj_image.contains(QStringLiteral("type")) || !obj_image.contains(QStringLiteral("resource_url")) || !obj_image.contains(QStringLiteral("width")) || !obj_image.contains(QStringLiteral("height"))) {
Error(QStringLiteral("Invalid Json reply, images array value object is missing type, resource_url, width or height."), obj_image);
continue;
}
QString type = obj_image["type"].toString();
QString type = obj_image[QStringLiteral("type")].toString();
if (type != "primary") {
continue;
}
int width = obj_image["width"].toInt();
int height = obj_image["height"].toInt();
int width = obj_image[QStringLiteral("width")].toInt();
int height = obj_image[QStringLiteral("height")].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["resource_url"].toString());
result.image_url = QUrl(obj_image[QStringLiteral("resource_url")].toString());
if (result.image_url.isEmpty()) continue;
search->results.append(result);
}

8
src/covermanager/jsoncoverprovider.cpp
View File

@@ -40,23 +40,23 @@ QJsonObject JsonCoverProvider::ExtractJsonObj(const QByteArray &data) {
QJsonDocument json_doc = QJsonDocument::fromJson(data, &json_error);
if (json_error.error != QJsonParseError::NoError) {
Error(QString("Failed to parse json data: %1").arg(json_error.errorString()));
Error(QStringLiteral("Failed to parse json data: %1").arg(json_error.errorString()));
return QJsonObject();
}
if (json_doc.isEmpty()) {
Error("Received empty Json document.", data);
Error(QStringLiteral("Received empty Json document."), data);
return QJsonObject();
}
if (!json_doc.isObject()) {
Error("Json document is not an object.", json_doc);
Error(QStringLiteral("Json document is not an object."), json_doc);
return QJsonObject();
}
QJsonObject json_obj = json_doc.object();
if (json_obj.isEmpty()) {
Error("Received empty Json object.", json_doc);
Error(QStringLiteral("Received empty Json object."), json_doc);
return QJsonObject();
}

92
src/covermanager/lastfmcoverprovider.cpp
View File

@@ -51,7 +51,7 @@ const char *LastFmCoverProvider::kApiKey = "211990b4c96782c05d1536e7219eb56e";
const char *LastFmCoverProvider::kSecret = "80fd738f49596e9709b1bf9319c444a8";
LastFmCoverProvider::LastFmCoverProvider(Application *app, SharedPtr<NetworkAccessManager> network, QObject *parent)
: JsonCoverProvider("Last.fm", true, false, 1.0, true, false, app, network, parent) {}
: JsonCoverProvider(QStringLiteral("Last.fm"), true, false, 1.0, true, false, app, network, parent) {}
LastFmCoverProvider::~LastFmCoverProvider() {
@@ -72,14 +72,14 @@ bool LastFmCoverProvider::StartSearch(const QString &artist, const QString &albu
QString type;
QString query = artist;
if (album.isEmpty() && !title.isEmpty()) {
method = "track.search";
type = "track";
method = QStringLiteral("track.search");
type = QStringLiteral("track");
if (!query.isEmpty()) query.append(" ");
query.append(title);
}
else {
method = "album.search";
type = "album";
method = QStringLiteral("album.search");
type = QStringLiteral("album");
if (!album.isEmpty()) {
if (!query.isEmpty()) query.append(" ");
query.append(album);
@@ -104,8 +104,8 @@ bool LastFmCoverProvider::StartSearch(const QString &artist, const QString &albu
QByteArray const digest = QCryptographicHash::hash(data_to_sign.toUtf8(), QCryptographicHash::Md5);
QString signature = QString::fromLatin1(digest.toHex()).rightJustified(32, '0').toLower();
url_query.addQueryItem(QUrl::toPercentEncoding("api_sig"), QUrl::toPercentEncoding(signature));
url_query.addQueryItem(QUrl::toPercentEncoding("format"), QUrl::toPercentEncoding("json"));
url_query.addQueryItem(QUrl::toPercentEncoding(QStringLiteral("api_sig")), QUrl::toPercentEncoding(signature));
url_query.addQueryItem(QUrl::toPercentEncoding(QStringLiteral("format")), QUrl::toPercentEncoding(QStringLiteral("json")));
QUrl url(kUrl);
QNetworkRequest req(url);
@@ -141,31 +141,31 @@ void LastFmCoverProvider::QueryFinished(QNetworkReply *reply, const int id, cons
}
QJsonValue value_results;
if (json_obj.contains("results")) {
value_results = json_obj["results"];
if (json_obj.contains(QStringLiteral("results"))) {
value_results = json_obj[QStringLiteral("results")];
}
else if (json_obj.contains("error") && json_obj.contains("message")) {
int error = json_obj["error"].toInt();
QString message = json_obj["message"].toString();
Error(QString("Error: %1: %2").arg(QString::number(error), message));
else if (json_obj.contains(QStringLiteral("error")) && json_obj.contains(QStringLiteral("message"))) {
int error = json_obj[QStringLiteral("error")].toInt();
QString message = json_obj[QStringLiteral("message")].toString();
Error(QStringLiteral("Error: %1: %2").arg(QString::number(error), message));
emit SearchFinished(id, results);
return;
}
else {
Error(QString("Json reply is missing results."), json_obj);
Error(QStringLiteral("Json reply is missing results."), json_obj);
emit SearchFinished(id, results);
return;
}
if (!value_results.isObject()) {
Error("Json results is not a object.", value_results);
Error(QStringLiteral("Json results is not a object."), value_results);
emit SearchFinished(id, results);
return;
}
QJsonObject obj_results = value_results.toObject();
if (obj_results.isEmpty()) {
Error("Json results object is empty.", value_results);
Error(QStringLiteral("Json results object is empty."), value_results);
emit SearchFinished(id, results);
return;
}
@@ -173,49 +173,49 @@ void LastFmCoverProvider::QueryFinished(QNetworkReply *reply, const int id, cons
QJsonValue value_matches;
if (type == "album") {
if (obj_results.contains("albummatches")) {
value_matches = obj_results["albummatches"];
if (obj_results.contains(QStringLiteral("albummatches"))) {
value_matches = obj_results[QStringLiteral("albummatches")];
}
else {
Error("Json results object is missing albummatches.", obj_results);
Error(QStringLiteral("Json results object is missing albummatches."), obj_results);
emit SearchFinished(id, results);
return;
}
}
else if (type == "track") {
if (obj_results.contains("trackmatches")) {
value_matches = obj_results["trackmatches"];
if (obj_results.contains(QStringLiteral("trackmatches"))) {
value_matches = obj_results[QStringLiteral("trackmatches")];
}
else {
Error("Json results object is missing trackmatches.", obj_results);
Error(QStringLiteral("Json results object is missing trackmatches."), obj_results);
emit SearchFinished(id, results);
return;
}
}
if (!value_matches.isObject()) {
Error("Json albummatches or trackmatches is not an object.", value_matches);
Error(QStringLiteral("Json albummatches or trackmatches is not an object."), value_matches);
emit SearchFinished(id, results);
return;
}
QJsonObject obj_matches = value_matches.toObject();
if (obj_matches.isEmpty()) {
Error("Json albummatches or trackmatches object is empty.", value_matches);
Error(QStringLiteral("Json albummatches or trackmatches object is empty."), value_matches);
emit SearchFinished(id, results);
return;
}
QJsonValue value_type;
if (!obj_matches.contains(type)) {
Error(QString("Json object is missing %1.").arg(type), obj_matches);
Error(QStringLiteral("Json object is missing %1.").arg(type), obj_matches);
emit SearchFinished(id, results);
return;
}
value_type = obj_matches[type];
if (!value_type.isArray()) {
Error("Json album value in albummatches object is not an array.", value_type);
Error(QStringLiteral("Json album value in albummatches object is not an array."), value_type);
emit SearchFinished(id, results);
return;
}
@@ -224,23 +224,23 @@ void LastFmCoverProvider::QueryFinished(QNetworkReply *reply, const int id, cons
for (const QJsonValueRef value : array_type) {
if (!value.isObject()) {
Error("Invalid Json reply, value in albummatches/trackmatches array is not a object.");
Error(QStringLiteral("Invalid Json reply, value in albummatches/trackmatches array is not a object."));
continue;
}
QJsonObject obj = value.toObject();
if (!obj.contains("artist") || !obj.contains("image") || !obj.contains("name")) {
Error("Invalid Json reply, album is missing artist, image or name.", obj);
if (!obj.contains(QStringLiteral("artist")) || !obj.contains(QStringLiteral("image")) || !obj.contains(QStringLiteral("name"))) {
Error(QStringLiteral("Invalid Json reply, album is missing artist, image or name."), obj);
continue;
}
QString artist = obj["artist"].toString();
QString artist = obj[QStringLiteral("artist")].toString();
QString album;
if (type == "album") {
album = obj["name"].toString();
album = obj[QStringLiteral("name")].toString();
}
QJsonValue json_image = obj["image"];
QJsonValue json_image = obj[QStringLiteral("image")];
if (!json_image.isArray()) {
Error("Invalid Json reply, album image is not a array.", json_image);
Error(QStringLiteral("Invalid Json reply, album image is not a array."), json_image);
continue;
}
QJsonArray array_image = json_image.toArray();
@@ -248,17 +248,17 @@ void LastFmCoverProvider::QueryFinished(QNetworkReply *reply, const int id, cons
LastFmImageSize image_size_use(LastFmImageSize::Unknown);
for (const QJsonValueRef value_image : array_image) {
if (!value_image.isObject()) {
Error("Invalid Json reply, album image value is not an object.");
Error(QStringLiteral("Invalid Json reply, album image value is not an object."));
continue;
}
QJsonObject obj_image = value_image.toObject();
if (!obj_image.contains("#text") || !obj_image.contains("size")) {
Error("Invalid Json reply, album image value is missing #text or size.", obj_image);
if (!obj_image.contains(QStringLiteral("#text")) || !obj_image.contains(QStringLiteral("size"))) {
Error(QStringLiteral("Invalid Json reply, album image value is missing #text or size."), obj_image);
continue;
}
QString image_url = obj_image["#text"].toString();
QString image_url = obj_image[QStringLiteral("#text")].toString();
if (image_url.isEmpty()) continue;
LastFmImageSize image_size = ImageSizeFromString(obj_image["size"].toString().toLower());
LastFmImageSize image_size = ImageSizeFromString(obj_image[QStringLiteral("size")].toString().toLower());
if (image_url_use.isEmpty() || image_size > image_size_use) {
image_url_use = image_url;
image_size_use = image_size;
@@ -268,8 +268,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("/300x300/")) {
image_url_use = image_url_use.replace("/300x300/", "/740x0/");
if (image_url_use.contains(QLatin1String("/300x300/"))) {
image_url_use = image_url_use.replace(QLatin1String("/300x300/"), QLatin1String("/740x0/"));
}
QUrl url(image_url_use);
if (!url.isValid()) continue;
@@ -295,7 +295,7 @@ QByteArray LastFmCoverProvider::GetReplyData(QNetworkReply *reply) {
else {
if (reply->error() != QNetworkReply::NoError && reply->error() < 200) {
// This is a network error, there is nothing more to do.
Error(QString("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
Error(QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
}
else {
// See if there is Json data containing "error" and "message" - then use that instead.
@@ -305,18 +305,18 @@ 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("error") && json_obj.contains("message")) {
int code = json_obj["error"].toInt();
QString message = json_obj["message"].toString();
if (json_obj.contains(QStringLiteral("error")) && json_obj.contains(QStringLiteral("message"))) {
int code = json_obj[QStringLiteral("error")].toInt();
QString message = json_obj[QStringLiteral("message")].toString();
error = "Error: " + QString::number(code) + ": " + message;
}
}
if (error.isEmpty()) {
if (reply->error() != QNetworkReply::NoError) {
error = QString("%1 (%2)").arg(reply->errorString()).arg(reply->error());
error = QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
}
else {
error = QString("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt());
error = QStringLiteral("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt());
}
}
Error(error);

64
src/covermanager/musicbrainzcoverprovider.cpp
View File

@@ -50,7 +50,7 @@ const int MusicbrainzCoverProvider::kLimit = 8;
const int MusicbrainzCoverProvider::kRequestsDelay = 1000;
MusicbrainzCoverProvider::MusicbrainzCoverProvider(Application *app, SharedPtr<NetworkAccessManager> network, QObject *parent)
: JsonCoverProvider("MusicBrainz", true, false, 1.5, true, false, app, network, parent),
: JsonCoverProvider(QStringLiteral("MusicBrainz"), true, false, 1.5, true, false, app, network, parent),
timer_flush_requests_(new QTimer(this)) {
timer_flush_requests_->setInterval(kRequestsDelay);
@@ -89,12 +89,12 @@ bool MusicbrainzCoverProvider::StartSearch(const QString &artist, const QString
void MusicbrainzCoverProvider::SendSearchRequest(const SearchRequest &request) {
QString query = QString("release:\"%1\" AND artist:\"%2\"").arg(request.album.trimmed().replace('"', "\\\""), request.artist.trimmed().replace('"', "\\\""));
QString query = QStringLiteral("release:\"%1\" AND artist:\"%2\"").arg(request.album.trimmed().replace('"', QLatin1String("\\\"")), request.artist.trimmed().replace('"', QLatin1String("\\\"")));
QUrlQuery url_query;
url_query.addQueryItem("query", query);
url_query.addQueryItem("limit", QString::number(kLimit));
url_query.addQueryItem("fmt", "json");
url_query.addQueryItem(QStringLiteral("query"), query);
url_query.addQueryItem(QStringLiteral("limit"), QString::number(kLimit));
url_query.addQueryItem(QStringLiteral("fmt"), QStringLiteral("json"));
QUrl url(kReleaseSearchUrl);
url.setQuery(url_query);
@@ -138,21 +138,21 @@ void MusicbrainzCoverProvider::HandleSearchReply(QNetworkReply *reply, const int
return;
}
if (!json_obj.contains("releases")) {
if (json_obj.contains("error")) {
QString error = json_obj["error"].toString();
if (!json_obj.contains(QStringLiteral("releases"))) {
if (json_obj.contains(QStringLiteral("error"))) {
QString error = json_obj[QStringLiteral("error")].toString();
Error(error);
}
else {
Error(QString("Json reply is missing releases."), json_obj);
Error(QStringLiteral("Json reply is missing releases."), json_obj);
}
emit SearchFinished(search_id, results);
return;
}
QJsonValue value_releases = json_obj["releases"];
QJsonValue value_releases = json_obj[QStringLiteral("releases")];
if (!value_releases.isArray()) {
Error("Json releases is not an array.", value_releases);
Error(QStringLiteral("Json releases is not an array."), value_releases);
emit SearchFinished(search_id, results);
return;
}
@@ -166,18 +166,18 @@ void MusicbrainzCoverProvider::HandleSearchReply(QNetworkReply *reply, const int
for (const QJsonValueRef value_release : array_releases) {
if (!value_release.isObject()) {
Error("Invalid Json reply, releases array value is not an object.");
Error(QStringLiteral("Invalid Json reply, releases array value is not an object."));
continue;
}
QJsonObject obj_release = value_release.toObject();
if (!obj_release.contains("id") || !obj_release.contains("artist-credit") || !obj_release.contains("title")) {
Error("Invalid Json reply, releases array object is missing id, artist-credit or title.", obj_release);
if (!obj_release.contains(QStringLiteral("id")) || !obj_release.contains(QStringLiteral("artist-credit")) || !obj_release.contains(QStringLiteral("title"))) {
Error(QStringLiteral("Invalid Json reply, releases array object is missing id, artist-credit or title."), obj_release);
continue;
}
QJsonValue json_artists = obj_release["artist-credit"];
QJsonValue json_artists = obj_release[QStringLiteral("artist-credit")];
if (!json_artists.isArray()) {
Error("Invalid Json reply, artist-credit is not a array.", json_artists);
Error(QStringLiteral("Invalid Json reply, artist-credit is not a array."), json_artists);
continue;
}
QJsonArray array_artists = json_artists.toArray();
@@ -185,33 +185,33 @@ void MusicbrainzCoverProvider::HandleSearchReply(QNetworkReply *reply, const int
QString artist;
for (const QJsonValueRef value_artist : array_artists) {
if (!value_artist.isObject()) {
Error("Invalid Json reply, artist is not a object.");
Error(QStringLiteral("Invalid Json reply, artist is not a object."));
continue;
}
QJsonObject obj_artist = value_artist.toObject();
if (!obj_artist.contains("artist")) {
Error("Invalid Json reply, artist is missing.", obj_artist);
if (!obj_artist.contains(QStringLiteral("artist"))) {
Error(QStringLiteral("Invalid Json reply, artist is missing."), obj_artist);
continue;
}
QJsonValue value_artist2 = obj_artist["artist"];
QJsonValue value_artist2 = obj_artist[QStringLiteral("artist")];
if (!value_artist2.isObject()) {
Error("Invalid Json reply, artist is not an object.", value_artist2);
Error(QStringLiteral("Invalid Json reply, artist is not an object."), value_artist2);
continue;
}
QJsonObject obj_artist2 = value_artist2.toObject();
if (!obj_artist2.contains("name")) {
Error("Invalid Json reply, artist is missing name.", value_artist2);
if (!obj_artist2.contains(QStringLiteral("name"))) {
Error(QStringLiteral("Invalid Json reply, artist is missing name."), value_artist2);
continue;
}
artist = obj_artist2["name"].toString();
artist = obj_artist2[QStringLiteral("name")].toString();
++i;
}
if (i > 1) artist = "Various artists";
if (i > 1) artist = QStringLiteral("Various artists");
QString id = obj_release["id"].toString();
QString album = obj_release["title"].toString();
QString id = obj_release[QStringLiteral("id")].toString();
QString album = obj_release[QStringLiteral("title")].toString();
CoverProviderSearchResult cover_result;
QUrl url(QString(kAlbumCoverUrl).arg(id));
@@ -234,7 +234,7 @@ QByteArray MusicbrainzCoverProvider::GetReplyData(QNetworkReply *reply) {
else {
if (reply->error() != QNetworkReply::NoError && reply->error() < 200) {
// This is a network error, there is nothing more to do.
QString failure_reason = QString("%1 (%2)").arg(reply->errorString()).arg(reply->error());
QString failure_reason = QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
Error(failure_reason);
}
else {
@@ -245,16 +245,16 @@ 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("error")) {
error = json_obj["error"].toString();
if (json_obj.contains(QStringLiteral("error"))) {
error = json_obj[QStringLiteral("error")].toString();
}
}
if (error.isEmpty()) {
if (reply->error() != QNetworkReply::NoError) {
error = QString("%1 (%2)").arg(reply->errorString()).arg(reply->error());
error = QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
}
else {
error = QString("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt());
error = QStringLiteral("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt());
}
}
Error(error);

68
src/covermanager/musixmatchcoverprovider.cpp
View File

@@ -41,7 +41,7 @@
#include "musixmatchcoverprovider.h"
MusixmatchCoverProvider::MusixmatchCoverProvider(Application *app, SharedPtr<NetworkAccessManager> network, QObject *parent)
: JsonCoverProvider("Musixmatch", true, false, 1.0, true, false, app, network, parent) {}
: JsonCoverProvider(QStringLiteral("Musixmatch"), true, false, 1.0, true, false, app, network, parent) {}
MusixmatchCoverProvider::~MusixmatchCoverProvider() {
@@ -65,7 +65,7 @@ bool MusixmatchCoverProvider::StartSearch(const QString &artist, const QString &
if (artist_stripped.isEmpty() || album_stripped.isEmpty()) return false;
QUrl url(QString("https://www.musixmatch.com/album/%1/%2").arg(artist_stripped, album_stripped));
QUrl url(QStringLiteral("https://www.musixmatch.com/album/%1/%2").arg(artist_stripped, album_stripped));
QNetworkRequest req(url);
req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
QNetworkReply *reply = network_->get(req);
@@ -90,25 +90,25 @@ void MusixmatchCoverProvider::HandleSearchReply(QNetworkReply *reply, const int
CoverProviderSearchResults results;
if (reply->error() != QNetworkReply::NoError) {
Error(QString("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
Error(QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
emit SearchFinished(id, results);
return;
}
else if (reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt() != 200) {
Error(QString("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt()));
Error(QStringLiteral("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt()));
emit SearchFinished(id, results);
return;
}
QByteArray data = reply->readAll();
if (data.isEmpty()) {
Error("Empty reply received from server.");
Error(QStringLiteral("Empty reply received from server."));
emit SearchFinished(id, results);
return;
}
QString content = data;
const QString data_begin = "<script id=\"__NEXT_DATA__\" type=\"application/json\">";
const QString data_end = "</script>";
const QString data_begin = QStringLiteral("<script id=\"__NEXT_DATA__\" type=\"application/json\">");
const QString data_end = QStringLiteral("</script>");
if (!content.contains(data_begin) || !content.contains(data_end)) {
emit SearchFinished(id, results);
return;
@@ -128,7 +128,7 @@ void MusixmatchCoverProvider::HandleSearchReply(QNetworkReply *reply, const int
return;
}
if (content_json.contains(QRegularExpression("<[^>]*>"))) { // Make sure it's not HTML code.
if (content_json.contains(QRegularExpression(QStringLiteral("<[^>]*>")))) { // Make sure it's not HTML code.
emit SearchFinished(id, results);
return;
}
@@ -137,71 +137,71 @@ void MusixmatchCoverProvider::HandleSearchReply(QNetworkReply *reply, const int
QJsonDocument json_doc = QJsonDocument::fromJson(content_json.toUtf8(), &error);
if (error.error != QJsonParseError::NoError) {
Error(QString("Failed to parse json data: %1").arg(error.errorString()));
Error(QStringLiteral("Failed to parse json data: %1").arg(error.errorString()));
emit SearchFinished(id, results);
return;
}
if (json_doc.isEmpty()) {
Error("Received empty Json document.", data);
Error(QStringLiteral("Received empty Json document."), data);
emit SearchFinished(id, results);
return;
}
if (!json_doc.isObject()) {
Error("Json document is not an object.", json_doc);
Error(QStringLiteral("Json document is not an object."), json_doc);
emit SearchFinished(id, results);
return;
}
QJsonObject obj_data = json_doc.object();
if (obj_data.isEmpty()) {
Error("Received empty Json object.", json_doc);
Error(QStringLiteral("Received empty Json object."), json_doc);
emit SearchFinished(id, results);
return;
}
if (!obj_data.contains("props") || !obj_data["props"].isObject()) {
Error("Json reply is missing props.", obj_data);
if (!obj_data.contains(QStringLiteral("props")) || !obj_data[QStringLiteral("props")].isObject()) {
Error(QStringLiteral("Json reply is missing props."), obj_data);
emit SearchFinished(id, results);
return;
}
obj_data = obj_data["props"].toObject();
obj_data = obj_data[QStringLiteral("props")].toObject();
if (!obj_data.contains("pageProps") || !obj_data["pageProps"].isObject()) {
Error("Json props is missing pageProps.", obj_data);
if (!obj_data.contains(QStringLiteral("pageProps")) || !obj_data[QStringLiteral("pageProps")].isObject()) {
Error(QStringLiteral("Json props is missing pageProps."), obj_data);
emit SearchFinished(id, results);
return;
}
obj_data = obj_data["pageProps"].toObject();
obj_data = obj_data[QStringLiteral("pageProps")].toObject();
if (!obj_data.contains("data") || !obj_data["data"].isObject()) {
Error("Json pageProps is missing data.", obj_data);
if (!obj_data.contains(QStringLiteral("data")) || !obj_data[QStringLiteral("data")].isObject()) {
Error(QStringLiteral("Json pageProps is missing data."), obj_data);
emit SearchFinished(id, results);
return;
}
obj_data = obj_data["data"].toObject();
obj_data = obj_data[QStringLiteral("data")].toObject();
if (!obj_data.contains("albumGet") || !obj_data["albumGet"].isObject()) {
Error("Json data is missing albumGet.", obj_data);
if (!obj_data.contains(QStringLiteral("albumGet")) || !obj_data[QStringLiteral("albumGet")].isObject()) {
Error(QStringLiteral("Json data is missing albumGet."), obj_data);
emit SearchFinished(id, results);
return;
}
obj_data = obj_data["albumGet"].toObject();
obj_data = obj_data[QStringLiteral("albumGet")].toObject();
if (!obj_data.contains("data") || !obj_data["data"].isObject()) {
Error("Json albumGet reply is missing data.", obj_data);
if (!obj_data.contains(QStringLiteral("data")) || !obj_data[QStringLiteral("data")].isObject()) {
Error(QStringLiteral("Json albumGet reply is missing data."), obj_data);
emit SearchFinished(id, results);
return;
}
obj_data = obj_data["data"].toObject();
obj_data = obj_data[QStringLiteral("data")].toObject();
CoverProviderSearchResult result;
if (obj_data.contains("artistName") && obj_data["artistName"].isString()) {
result.artist = obj_data["artistName"].toString();
if (obj_data.contains(QStringLiteral("artistName")) && obj_data[QStringLiteral("artistName")].isString()) {
result.artist = obj_data[QStringLiteral("artistName")].toString();
}
if (obj_data.contains("name") && obj_data["name"].isString()) {
result.album = obj_data["name"].toString();
if (obj_data.contains(QStringLiteral("name")) && obj_data[QStringLiteral("name")].isString()) {
result.album = obj_data[QStringLiteral("name")].toString();
}
if (result.artist.compare(artist, Qt::CaseInsensitive) != 0 && result.album.compare(album, Qt::CaseInsensitive) != 0) {
@@ -209,9 +209,9 @@ void MusixmatchCoverProvider::HandleSearchReply(QNetworkReply *reply, const int
return;
}
QList<QPair<QString, QSize>> cover_sizes = QList<QPair<QString, QSize>>() << qMakePair(QString("coverImage800x800"), QSize(800, 800))
<< qMakePair(QString("coverImage500x500"), QSize(500, 500))
<< qMakePair(QString("coverImage350x350"), QSize(350, 350));
QList<QPair<QString, QSize>> cover_sizes = QList<QPair<QString, QSize>>() << qMakePair(QStringLiteral("coverImage800x800"), QSize(800, 800))
<< qMakePair(QStringLiteral("coverImage500x500"), QSize(500, 500))
<< qMakePair(QStringLiteral("coverImage350x350"), QSize(350, 350));
for (const QPair<QString, QSize> &cover_size : cover_sizes) {
if (!obj_data.contains(cover_size.first)) continue;

76
src/covermanager/opentidalcoverprovider.cpp
View File

@@ -57,7 +57,7 @@ constexpr const int kRequestsDelay = 1000;
using std::make_shared;
OpenTidalCoverProvider::OpenTidalCoverProvider(Application *app, SharedPtr<NetworkAccessManager> network, QObject *parent)
: JsonCoverProvider("OpenTidal", true, false, 2.5, true, false, app, network, parent),
: JsonCoverProvider(QStringLiteral("OpenTidal"), true, false, 2.5, true, false, app, network, parent),
login_timer_(new QTimer(this)),
timer_flush_requests_(new QTimer(this)),
login_in_progress_(false),
@@ -160,7 +160,7 @@ void OpenTidalCoverProvider::Login() {
req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
req.setRawHeader("Authorization", "Basic " + QByteArray(QByteArray::fromBase64(kApiClientIdB64) + ":" + QByteArray::fromBase64(kApiClientSecretB64)).toBase64());
QUrlQuery url_query;
url_query.addQueryItem("grant_type", "client_credentials");
url_query.addQueryItem(QStringLiteral("grant_type"), QStringLiteral("client_credentials"));
QNetworkReply *reply = network_->post(req, url_query.toString(QUrl::FullyEncoded).toUtf8());
replies_ << reply;
QObject::connect(reply, &QNetworkReply::sslErrors, this, &OpenTidalCoverProvider::HandleLoginSSLErrors);
@@ -192,21 +192,21 @@ void OpenTidalCoverProvider::LoginFinished(QNetworkReply *reply) {
return;
}
if (!json_obj.contains("access_token") ||
!json_obj.contains("token_type") ||
!json_obj.contains("expires_in") ||
!json_obj["access_token"].isString() ||
!json_obj["token_type"].isString()) {
if (!json_obj.contains(QStringLiteral("access_token")) ||
!json_obj.contains(QStringLiteral("token_type")) ||
!json_obj.contains(QStringLiteral("expires_in")) ||
!json_obj[QStringLiteral("access_token")].isString() ||
!json_obj[QStringLiteral("token_type")].isString()) {
qLog(Error) << "OpenTidal: Invalid login reply.";
FinishAllSearches();
return;
}
have_login_ = true;
token_type_ = json_obj["token_type"].toString();
access_token_ = json_obj["access_token"].toString();
token_type_ = json_obj[QStringLiteral("token_type")].toString();
access_token_ = json_obj[QStringLiteral("access_token")].toString();
login_time_ = QDateTime::currentDateTime().toSecsSinceEpoch();
expires_in_ = json_obj["expires_in"].toInt();
expires_in_ = json_obj[QStringLiteral("expires_in")].toInt();
QSettings s;
s.beginGroup(kSettingsGroup);
@@ -261,19 +261,19 @@ QJsonObject OpenTidalCoverProvider::GetJsonObject(QNetworkReply *reply) {
return QJsonObject();
}
QJsonObject json_obj = ExtractJsonObj(data);
if (json_obj.contains("errors") && json_obj["errors"].isArray()) {
QJsonArray array = json_obj["errors"].toArray();
if (json_obj.contains(QStringLiteral("errors")) && json_obj[QStringLiteral("errors")].isArray()) {
QJsonArray array = json_obj[QStringLiteral("errors")].toArray();
for (const QJsonValue &value : array) {
if (!value.isObject()) continue;
QJsonObject obj = value.toObject();
if (!obj.contains("category") ||
!obj.contains("code") ||
!obj.contains("detail")) {
if (!obj.contains(QStringLiteral("category")) ||
!obj.contains(QStringLiteral("code")) ||
!obj.contains(QStringLiteral("detail"))) {
continue;
}
QString category = obj["category"].toString();
QString code = obj["code"].toString();
QString detail = obj["detail"].toString();
QString category = obj[QStringLiteral("category")].toString();
QString code = obj[QStringLiteral("code")].toString();
QString detail = obj[QStringLiteral("detail")].toString();
qLog(Error) << "OpenTidal:" << category << code << detail;
}
}
@@ -302,10 +302,10 @@ void OpenTidalCoverProvider::SendSearchRequest(SearchRequestPtr search_request)
}
QUrlQuery url_query;
url_query.addQueryItem("query", QUrl::toPercentEncoding(query));
url_query.addQueryItem("limit", QString::number(kLimit));
url_query.addQueryItem("countryCode", "US");
QUrl url(QString(kApiUrl) + QString("/search"));
url_query.addQueryItem(QStringLiteral("query"), QUrl::toPercentEncoding(query));
url_query.addQueryItem(QStringLiteral("limit"), QString::number(kLimit));
url_query.addQueryItem(QStringLiteral("countryCode"), QStringLiteral("US"));
QUrl url(QString(kApiUrl) + QStringLiteral("/search"));
url.setQuery(url_query);
QNetworkRequest req(url);
req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
@@ -331,13 +331,13 @@ void OpenTidalCoverProvider::HandleSearchReply(QNetworkReply *reply, SearchReque
return;
}
if (!json_obj.contains("albums") || !json_obj["albums"].isArray()) {
if (!json_obj.contains(QStringLiteral("albums")) || !json_obj[QStringLiteral("albums")].isArray()) {
qLog(Debug) << "OpenTidal: Json object is missing albums.";
emit SearchFinished(search_request->id, CoverProviderSearchResults());
return;
}
QJsonArray array_albums = json_obj["albums"].toArray();
QJsonArray array_albums = json_obj[QStringLiteral("albums")].toArray();
if (array_albums.isEmpty()) {
emit SearchFinished(search_request->id, CoverProviderSearchResults());
return;
@@ -353,55 +353,55 @@ void OpenTidalCoverProvider::HandleSearchReply(QNetworkReply *reply, SearchReque
}
QJsonObject obj_album = value_album.toObject();
if (!obj_album.contains("resource") || !obj_album["resource"].isObject()) {
if (!obj_album.contains(QStringLiteral("resource")) || !obj_album[QStringLiteral("resource")].isObject()) {
qLog(Debug) << "OpenTidal: Invalid Json reply: Albums array album is missing resource object.";
continue;
}
QJsonObject obj_resource = obj_album["resource"].toObject();
QJsonObject obj_resource = obj_album[QStringLiteral("resource")].toObject();
if (!obj_resource.contains("artists") || !obj_resource["artists"].isArray()) {
if (!obj_resource.contains(QStringLiteral("artists")) || !obj_resource[QStringLiteral("artists")].isArray()) {
qLog(Debug) << "OpenTidal: Invalid Json reply: Resource is missing artists array.";
continue;
}
if (!obj_resource.contains("title") || !obj_resource["title"].isString()) {
if (!obj_resource.contains(QStringLiteral("title")) || !obj_resource[QStringLiteral("title")].isString()) {
qLog(Debug) << "OpenTidal: Invalid Json reply: Resource is missing title.";
continue;
}
if (!obj_resource.contains("imageCover") || !obj_resource["imageCover"].isArray()) {
if (!obj_resource.contains(QStringLiteral("imageCover")) || !obj_resource[QStringLiteral("imageCover")].isArray()) {
qLog(Debug) << "OpenTidal: Invalid Json reply: Resource is missing imageCover array.";
continue;
}
QString artist;
const QString album = obj_resource["title"].toString();
const QString album = obj_resource[QStringLiteral("title")].toString();
QJsonArray array_artists = obj_resource["artists"].toArray();
QJsonArray array_artists = obj_resource[QStringLiteral("artists")].toArray();
for (const QJsonValueRef value_artist : array_artists) {
if (!value_artist.isObject()) {
continue;
}
QJsonObject obj_artist = value_artist.toObject();
if (!obj_artist.contains("name")) {
if (!obj_artist.contains(QStringLiteral("name"))) {
continue;
}
artist = obj_artist["name"].toString();
artist = obj_artist[QStringLiteral("name")].toString();
break;
}
QJsonArray array_covers = obj_resource["imageCover"].toArray();
QJsonArray array_covers = obj_resource[QStringLiteral("imageCover")].toArray();
for (const QJsonValueRef value_cover : array_covers) {
if (!value_cover.isObject()) {
continue;
}
QJsonObject obj_cover = value_cover.toObject();
if (!obj_cover.contains("url") || !obj_cover.contains("width") || !obj_cover.contains("height")) {
if (!obj_cover.contains(QStringLiteral("url")) || !obj_cover.contains(QStringLiteral("width")) || !obj_cover.contains(QStringLiteral("height"))) {
continue;
}
const QUrl url(obj_cover["url"].toString());
const int width = obj_cover["width"].toInt();
const int height = obj_cover["height"].toInt();
const QUrl url(obj_cover[QStringLiteral("url")].toString());
const int width = obj_cover[QStringLiteral("width")].toInt();
const int height = obj_cover[QStringLiteral("height")].toInt();
if (!url.isValid()) continue;
if (width < 640 || height < 640) continue;
CoverProviderSearchResult cover_result;

78
src/covermanager/qobuzcoverprovider.cpp
View File

@@ -49,7 +49,7 @@
constexpr int QobuzCoverProvider::kLimit = 10;
QobuzCoverProvider::QobuzCoverProvider(Application *app, SharedPtr<NetworkAccessManager> network, QObject *parent)
: JsonCoverProvider("Qobuz", true, true, 2.0, true, true, app, network, parent),
: JsonCoverProvider(QStringLiteral("Qobuz"), true, true, 2.0, true, true, app, network, parent),
service_(app->internet_services()->Service<QobuzService>()) {}
QobuzCoverProvider::~QobuzCoverProvider() {
@@ -70,12 +70,12 @@ bool QobuzCoverProvider::StartSearch(const QString &artist, const QString &album
QString resource;
QString query = artist;
if (album.isEmpty() && !title.isEmpty()) {
resource = "track/search";
resource = QStringLiteral("track/search");
if (!query.isEmpty()) query.append(" ");
query.append(title);
}
else {
resource = "album/search";
resource = QStringLiteral("album/search");
if (!album.isEmpty()) {
if (!query.isEmpty()) query.append(" ");
query.append(album);
@@ -93,7 +93,7 @@ bool QobuzCoverProvider::StartSearch(const QString &artist, const QString &album
url_query.addQueryItem(QUrl::toPercentEncoding(param.first), QUrl::toPercentEncoding(param.second));
}
QUrl url(QString(QobuzService::kApiUrl) + QString("/") + resource);
QUrl url(QString(QobuzService::kApiUrl) + QStringLiteral("/") + resource);
url.setQuery(url_query);
QNetworkRequest req(url);
@@ -121,7 +121,7 @@ QByteArray QobuzCoverProvider::GetReplyData(QNetworkReply *reply) {
else {
if (reply->error() != QNetworkReply::NoError && reply->error() < 200) {
// This is a network error, there is nothing more to do.
Error(QString("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
Error(QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
}
else {
// See if there is Json data containing "status", "code" and "message" - then use that instead.
@@ -131,18 +131,18 @@ 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("status") && json_obj.contains("code") && json_obj.contains("message")) {
int code = json_obj["code"].toInt();
QString message = json_obj["message"].toString();
error = QString("%1 (%2)").arg(message).arg(code);
if (!json_obj.isEmpty() && json_obj.contains(QStringLiteral("status")) && json_obj.contains(QStringLiteral("code")) && json_obj.contains(QStringLiteral("message"))) {
int code = json_obj[QStringLiteral("code")].toInt();
QString message = json_obj[QStringLiteral("message")].toString();
error = QStringLiteral("%1 (%2)").arg(message).arg(code);
}
}
if (error.isEmpty()) {
if (reply->error() != QNetworkReply::NoError) {
error = QString("%1 (%2)").arg(reply->errorString()).arg(reply->error());
error = QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
}
else {
error = QString("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt());
error = QStringLiteral("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt());
}
}
Error(error);
@@ -176,34 +176,34 @@ void QobuzCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id) {
}
QJsonValue value_type;
if (json_obj.contains("albums")) {
value_type = json_obj["albums"];
if (json_obj.contains(QStringLiteral("albums"))) {
value_type = json_obj[QStringLiteral("albums")];
}
else if (json_obj.contains("tracks")) {
value_type = json_obj["tracks"];
else if (json_obj.contains(QStringLiteral("tracks"))) {
value_type = json_obj[QStringLiteral("tracks")];
}
else {
Error("Json reply is missing albums and tracks object.", json_obj);
Error(QStringLiteral("Json reply is missing albums and tracks object."), json_obj);
emit SearchFinished(id, results);
return;
}
if (!value_type.isObject()) {
Error("Json albums or tracks is not a object.", value_type);
Error(QStringLiteral("Json albums or tracks is not a object."), value_type);
emit SearchFinished(id, results);
return;
}
QJsonObject obj_type = value_type.toObject();
if (!obj_type.contains("items")) {
Error("Json albums or tracks object does not contain items.", obj_type);
if (!obj_type.contains(QStringLiteral("items"))) {
Error(QStringLiteral("Json albums or tracks object does not contain items."), obj_type);
emit SearchFinished(id, results);
return;
}
QJsonValue value_items = obj_type["items"];
QJsonValue value_items = obj_type[QStringLiteral("items")];
if (!value_items.isArray()) {
Error("Json albums or track object items is not a array.", value_items);
Error(QStringLiteral("Json albums or track object items is not a array."), value_items);
emit SearchFinished(id, results);
return;
}
@@ -212,55 +212,55 @@ void QobuzCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id) {
for (const QJsonValueRef value : array_items) {
if (!value.isObject()) {
Error("Invalid Json reply, value in items is not a object.");
Error(QStringLiteral("Invalid Json reply, value in items is not a object."));
continue;
}
QJsonObject item_obj = value.toObject();
QJsonObject obj_album;
if (item_obj.contains("album")) {
if (!item_obj["album"].isObject()) {
Error("Invalid Json reply, items album is not a object.", item_obj);
if (item_obj.contains(QStringLiteral("album"))) {
if (!item_obj[QStringLiteral("album")].isObject()) {
Error(QStringLiteral("Invalid Json reply, items album is not a object."), item_obj);
continue;
}
obj_album = item_obj["album"].toObject();
obj_album = item_obj[QStringLiteral("album")].toObject();
}
else {
obj_album = item_obj;
}
if (!obj_album.contains("artist") || !obj_album.contains("image") || !obj_album.contains("title")) {
Error("Invalid Json reply, item is missing artist, title or image.", obj_album);
if (!obj_album.contains(QStringLiteral("artist")) || !obj_album.contains(QStringLiteral("image")) || !obj_album.contains(QStringLiteral("title"))) {
Error(QStringLiteral("Invalid Json reply, item is missing artist, title or image."), obj_album);
continue;
}
QString album = obj_album["title"].toString();
QString album = obj_album[QStringLiteral("title")].toString();
// Artist
QJsonValue value_artist = obj_album["artist"];
QJsonValue value_artist = obj_album[QStringLiteral("artist")];
if (!value_artist.isObject()) {
Error("Invalid Json reply, items (album) artist is not a object.", value_artist);
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("name")) {
Error("Invalid Json reply, items (album) artist is missing name.", obj_artist);
if (!obj_artist.contains(QStringLiteral("name"))) {
Error(QStringLiteral("Invalid Json reply, items (album) artist is missing name."), obj_artist);
continue;
}
QString artist = obj_artist["name"].toString();
QString artist = obj_artist[QStringLiteral("name")].toString();
// Image
QJsonValue value_image = obj_album["image"];
QJsonValue value_image = obj_album[QStringLiteral("image")];
if (!value_image.isObject()) {
Error("Invalid Json reply, items (album) image is not a object.", value_image);
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("large")) {
Error("Invalid Json reply, items (album) image is missing large.", obj_image);
if (!obj_image.contains(QStringLiteral("large"))) {
Error(QStringLiteral("Invalid Json reply, items (album) image is missing large."), obj_image);
continue;
}
QUrl cover_url(obj_image["large"].toString());
QUrl cover_url(obj_image[QStringLiteral("large")].toString());
CoverProviderSearchResult cover_result;
cover_result.artist = artist;

108
src/covermanager/spotifycoverprovider.cpp
View File

@@ -62,7 +62,7 @@ const char *SpotifyCoverProvider::kApiUrl = "https://api.spotify.com/v1";
const int SpotifyCoverProvider::kLimit = 10;
SpotifyCoverProvider::SpotifyCoverProvider(Application *app, SharedPtr<NetworkAccessManager> network, QObject *parent)
: JsonCoverProvider("Spotify", true, true, 2.5, true, true, app, network, parent),
: JsonCoverProvider(QStringLiteral("Spotify"), true, true, 2.5, true, true, app, network, parent),
server_(nullptr),
expires_in_(0),
login_time_(0) {
@@ -146,7 +146,7 @@ void SpotifyCoverProvider::Authenticate() {
const bool result = QDesktopServices::openUrl(url);
if (!result) {
QMessageBox messagebox(QMessageBox::Information, tr("Spotify Authentication"), tr("Please open this URL in your browser") + QString(":<br /><a href=\"%1\">%1</a>").arg(url.toString()), QMessageBox::Ok);
QMessageBox messagebox(QMessageBox::Information, tr("Spotify Authentication"), tr("Please open this URL in your browser") + QStringLiteral(":<br /><a href=\"%1\">%1</a>").arg(url.toString()), QMessageBox::Ok);
messagebox.setTextFormat(Qt::RichText);
messagebox.exec();
}
@@ -180,12 +180,12 @@ void SpotifyCoverProvider::RedirectArrived() {
QUrl url = server_->request_url();
if (url.isValid()) {
QUrlQuery url_query(url);
if (url_query.hasQueryItem("error")) {
AuthError(QUrlQuery(url).queryItemValue("error"));
if (url_query.hasQueryItem(QStringLiteral("error"))) {
AuthError(QUrlQuery(url).queryItemValue(QStringLiteral("error")));
}
else if (url_query.hasQueryItem("code") && url_query.hasQueryItem("state")) {
else if (url_query.hasQueryItem(QStringLiteral("code")) && url_query.hasQueryItem(QStringLiteral("state"))) {
qLog(Debug) << "Spotify: Authorization URL Received" << url;
QString code = url_query.queryItemValue("code");
QString code = url_query.queryItemValue(QStringLiteral("code"));
QUrl redirect_url(kOAuthRedirectUrl);
redirect_url.setPort(server_->url().port());
RequestAccessToken(code, redirect_url);
@@ -237,7 +237,7 @@ void SpotifyCoverProvider::RequestAccessToken(const QString &code, const QUrl &r
QNetworkRequest req(new_url);
req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
req.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
QString auth_header_data = QByteArray::fromBase64(kClientIDB64) + QString(":") + QByteArray::fromBase64(kClientSecretB64);
QString auth_header_data = QByteArray::fromBase64(kClientIDB64) + QStringLiteral(":") + QByteArray::fromBase64(kClientSecretB64);
req.setRawHeader("Authorization", "Basic " + auth_header_data.toUtf8().toBase64());
QByteArray query = url_query.toString(QUrl::FullyEncoded).toUtf8();
@@ -267,7 +267,7 @@ void SpotifyCoverProvider::AccessTokenRequestFinished(QNetworkReply *reply) {
if (reply->error() != QNetworkReply::NoError || reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt() != 200) {
if (reply->error() != QNetworkReply::NoError && reply->error() < 200) {
// This is a network error, there is nothing more to do.
AuthError(QString("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
AuthError(QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
return;
}
else {
@@ -277,18 +277,18 @@ void SpotifyCoverProvider::AccessTokenRequestFinished(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.isEmpty() && json_obj.contains("error") && json_obj.contains("error_description")) {
QString error = json_obj["error"].toString();
QString error_description = json_obj["error_description"].toString();
login_errors_ << QString("Authentication failure: %1 (%2)").arg(error, error_description);
if (!json_obj.isEmpty() && json_obj.contains(QStringLiteral("error")) && json_obj.contains(QStringLiteral("error_description"))) {
QString error = json_obj[QStringLiteral("error")].toString();
QString error_description = json_obj[QStringLiteral("error_description")].toString();
login_errors_ << QStringLiteral("Authentication failure: %1 (%2)").arg(error, error_description);
}
}
if (login_errors_.isEmpty()) {
if (reply->error() != QNetworkReply::NoError) {
login_errors_ << QString("%1 (%2)").arg(reply->errorString()).arg(reply->error());
login_errors_ << QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
}
else {
login_errors_ << QString("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt());
login_errors_ << QStringLiteral("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt());
}
}
AuthError();
@@ -302,36 +302,36 @@ void SpotifyCoverProvider::AccessTokenRequestFinished(QNetworkReply *reply) {
QJsonDocument json_doc = QJsonDocument::fromJson(data, &json_error);
if (json_error.error != QJsonParseError::NoError) {
Error(QString("Failed to parse Json data in authentication reply: %1").arg(json_error.errorString()));
Error(QStringLiteral("Failed to parse Json data in authentication reply: %1").arg(json_error.errorString()));
return;
}
if (json_doc.isEmpty()) {
AuthError("Authentication reply from server has empty Json document.");
AuthError(QStringLiteral("Authentication reply from server has empty Json document."));
return;
}
if (!json_doc.isObject()) {
AuthError("Authentication reply from server has Json document that is not an object.", json_doc);
AuthError(QStringLiteral("Authentication reply from server has Json document that is not an object."), json_doc);
return;
}
QJsonObject json_obj = json_doc.object();
if (json_obj.isEmpty()) {
AuthError("Authentication reply from server has empty Json object.", json_doc);
AuthError(QStringLiteral("Authentication reply from server has empty Json object."), json_doc);
return;
}
if (!json_obj.contains("access_token") || !json_obj.contains("expires_in")) {
AuthError("Authentication reply from server is missing access token or expires in.", json_obj);
if (!json_obj.contains(QStringLiteral("access_token")) || !json_obj.contains(QStringLiteral("expires_in"))) {
AuthError(QStringLiteral("Authentication reply from server is missing access token or expires in."), json_obj);
return;
}
access_token_ = json_obj["access_token"].toString();
if (json_obj.contains("refresh_token")) {
refresh_token_ = json_obj["refresh_token"].toString();
access_token_ = json_obj[QStringLiteral("access_token")].toString();
if (json_obj.contains(QStringLiteral("refresh_token"))) {
refresh_token_ = json_obj[QStringLiteral("refresh_token")].toString();
}
expires_in_ = json_obj["expires_in"].toInt();
expires_in_ = json_obj[QStringLiteral("expires_in")].toInt();
login_time_ = QDateTime::currentDateTime().toSecsSinceEpoch();
QSettings s;
@@ -364,14 +364,14 @@ bool SpotifyCoverProvider::StartSearch(const QString &artist, const QString &alb
QString extract;
QString query = artist;
if (album.isEmpty() && !title.isEmpty()) {
type = "track";
extract = "tracks";
type = QStringLiteral("track");
extract = QStringLiteral("tracks");
if (!query.isEmpty()) query.append(" ");
query.append(title);
}
else {
type = "album";
extract = "albums";
type = QStringLiteral("album");
extract = QStringLiteral("albums");
if (!album.isEmpty()) {
if (!query.isEmpty()) query.append(" ");
query.append(album);
@@ -387,7 +387,7 @@ bool SpotifyCoverProvider::StartSearch(const QString &artist, const QString &alb
url_query.addQueryItem(QUrl::toPercentEncoding(param.first), QUrl::toPercentEncoding(param.second));
}
QUrl url(kApiUrl + QString("/search"));
QUrl url(kApiUrl + QStringLiteral("/search"));
url.setQuery(url_query);
QNetworkRequest req(url);
req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
@@ -414,7 +414,7 @@ QByteArray SpotifyCoverProvider::GetReplyData(QNetworkReply *reply) {
else {
if (reply->error() != QNetworkReply::NoError && reply->error() < 200) {
// This is a network error, there is nothing more to do.
Error(QString("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
Error(QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
}
else {
data = reply->readAll();
@@ -423,12 +423,12 @@ 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("error") && json_obj["error"].isObject()) {
QJsonObject obj_error = json_obj["error"].toObject();
if (obj_error.contains("status") && obj_error.contains("message")) {
int status = obj_error["status"].toInt();
QString message = obj_error["message"].toString();
error = QString("%1 (%2)").arg(message).arg(status);
if (!json_obj.isEmpty() && json_obj.contains(QStringLiteral("error")) && json_obj[QStringLiteral("error")].isObject()) {
QJsonObject obj_error = json_obj[QStringLiteral("error")].toObject();
if (obj_error.contains(QStringLiteral("status")) && obj_error.contains(QStringLiteral("message"))) {
int status = obj_error[QStringLiteral("status")].toInt();
QString message = obj_error[QStringLiteral("message")].toString();
error = QStringLiteral("%1 (%2)").arg(message).arg(status);
if (status == 401) access_token_.clear();
}
}
@@ -436,10 +436,10 @@ QByteArray SpotifyCoverProvider::GetReplyData(QNetworkReply *reply) {
if (error.isEmpty()) {
if (reply->error() != QNetworkReply::NoError) {
if (reply->error() == 204) access_token_.clear();
error = QString("%1 (%2)").arg(reply->errorString()).arg(reply->error());
error = QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
}
else {
error = QString("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt());
error = QStringLiteral("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt());
}
}
Error(error);
@@ -471,19 +471,19 @@ void SpotifyCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id,
}
if (!json_obj.contains(extract) || !json_obj[extract].isObject()) {
Error(QString("Json object is missing %1 object.").arg(extract), json_obj);
Error(QStringLiteral("Json object is missing %1 object.").arg(extract), json_obj);
emit SearchFinished(id, CoverProviderSearchResults());
return;
}
json_obj = json_obj[extract].toObject();
if (!json_obj.contains("items") || !json_obj["items"].isArray()) {
Error(QString("%1 object is missing items array.").arg(extract), json_obj);
if (!json_obj.contains(QStringLiteral("items")) || !json_obj[QStringLiteral("items")].isArray()) {
Error(QStringLiteral("%1 object is missing items array.").arg(extract), json_obj);
emit SearchFinished(id, CoverProviderSearchResults());
return;
}
QJsonArray array_items = json_obj["items"].toArray();
QJsonArray array_items = json_obj[QStringLiteral("items")].toArray();
if (array_items.isEmpty()) {
emit SearchFinished(id, CoverProviderSearchResults());
return;
@@ -498,33 +498,33 @@ void SpotifyCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id,
QJsonObject obj_item = value_item.toObject();
QJsonObject obj_album = obj_item;
if (obj_item.contains("album") && obj_item["album"].isObject()) {
obj_album = obj_item["album"].toObject();
if (obj_item.contains(QStringLiteral("album")) && obj_item[QStringLiteral("album")].isObject()) {
obj_album = obj_item[QStringLiteral("album")].toObject();
}
if (!obj_album.contains("artists") || !obj_album.contains("name") || !obj_album.contains("images") || !obj_album["artists"].isArray() || !obj_album["images"].isArray()) {
if (!obj_album.contains(QStringLiteral("artists")) || !obj_album.contains(QStringLiteral("name")) || !obj_album.contains(QStringLiteral("images")) || !obj_album[QStringLiteral("artists")].isArray() || !obj_album[QStringLiteral("images")].isArray()) {
continue;
}
QJsonArray array_artists = obj_album["artists"].toArray();
QJsonArray array_images = obj_album["images"].toArray();
QString album = obj_album["name"].toString();
QJsonArray array_artists = obj_album[QStringLiteral("artists")].toArray();
QJsonArray array_images = obj_album[QStringLiteral("images")].toArray();
QString album = obj_album[QStringLiteral("name")].toString();
QStringList artists;
for (const QJsonValueRef value_artist : array_artists) {
if (!value_artist.isObject()) continue;
QJsonObject obj_artist = value_artist.toObject();
if (!obj_artist.contains("name")) continue;
artists << obj_artist["name"].toString();
if (!obj_artist.contains(QStringLiteral("name"))) continue;
artists << obj_artist[QStringLiteral("name")].toString();
}
for (const QJsonValueRef value_image : array_images) {
if (!value_image.isObject()) continue;
QJsonObject obj_image = value_image.toObject();
if (!obj_image.contains("url") || !obj_image.contains("width") || !obj_image.contains("height")) continue;
int width = obj_image["width"].toInt();
int height = obj_image["height"].toInt();
if (!obj_image.contains(QStringLiteral("url")) || !obj_image.contains(QStringLiteral("width")) || !obj_image.contains(QStringLiteral("height"))) continue;
int width = obj_image[QStringLiteral("width")].toInt();
int height = obj_image[QStringLiteral("height")].toInt();
if (width < 300 || height < 300) continue;
QUrl url(obj_image["url"].toString());
QUrl url(obj_image[QStringLiteral("url")].toString());
CoverProviderSearchResult result;
result.album = album;
result.image_url = url;

68
src/covermanager/tidalcoverprovider.cpp
View File

@@ -48,7 +48,7 @@
constexpr int TidalCoverProvider::kLimit = 10;
TidalCoverProvider::TidalCoverProvider(Application *app, SharedPtr<NetworkAccessManager> network, QObject *parent)
: JsonCoverProvider("Tidal", true, true, 2.5, true, true, app, network, parent),
: JsonCoverProvider(QStringLiteral("Tidal"), true, true, 2.5, true, true, app, network, parent),
service_(app->internet_services()->Service<TidalService>()) {}
TidalCoverProvider::~TidalCoverProvider() {
@@ -71,12 +71,12 @@ bool TidalCoverProvider::StartSearch(const QString &artist, const QString &album
QString resource;
QString query = artist;
if (album.isEmpty() && !title.isEmpty()) {
resource = "search/tracks";
resource = QStringLiteral("search/tracks");
if (!query.isEmpty()) query.append(" ");
query.append(title);
}
else {
resource = "search/albums";
resource = QStringLiteral("search/albums");
if (!album.isEmpty()) {
if (!query.isEmpty()) query.append(" ");
query.append(album);
@@ -92,7 +92,7 @@ bool TidalCoverProvider::StartSearch(const QString &artist, const QString &album
url_query.addQueryItem(QUrl::toPercentEncoding(param.first), QUrl::toPercentEncoding(param.second));
}
QUrl url(QString(TidalService::kApiUrl) + QString("/") + resource);
QUrl url(QString(TidalService::kApiUrl) + QStringLiteral("/") + resource);
url.setQuery(url_query);
QNetworkRequest req(url);
req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
@@ -120,7 +120,7 @@ QByteArray TidalCoverProvider::GetReplyData(QNetworkReply *reply) {
else {
if (reply->error() != QNetworkReply::NoError && reply->error() < 200) {
// This is a network error, there is nothing more to do.
Error(QString("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
Error(QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
}
else {
// See if there is Json data containing "status" and "userMessage" - then use that instead.
@@ -132,19 +132,19 @@ 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("status") && json_obj.contains("userMessage")) {
status = json_obj["status"].toInt();
sub_status = json_obj["subStatus"].toInt();
QString user_message = json_obj["userMessage"].toString();
error = QString("%1 (%2) (%3)").arg(user_message).arg(status).arg(sub_status);
if (!json_obj.isEmpty() && json_obj.contains(QStringLiteral("status")) && json_obj.contains(QStringLiteral("userMessage"))) {
status = json_obj[QStringLiteral("status")].toInt();
sub_status = json_obj[QStringLiteral("subStatus")].toInt();
QString user_message = json_obj[QStringLiteral("userMessage")].toString();
error = QStringLiteral("%1 (%2) (%3)").arg(user_message).arg(status).arg(sub_status);
}
}
if (error.isEmpty()) {
if (reply->error() != QNetworkReply::NoError) {
error = QString("%1 (%2)").arg(reply->errorString()).arg(reply->error());
error = QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
}
else {
error = QString("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt());
error = QStringLiteral("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt());
}
}
if (status == 401 && sub_status == 6001) { // User does not have a valid session
@@ -178,12 +178,12 @@ void TidalCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id) {
return;
}
if (!json_obj.contains("items")) {
Error("Json object is missing items.", json_obj);
if (!json_obj.contains(QStringLiteral("items"))) {
Error(QStringLiteral("Json object is missing items."), json_obj);
emit SearchFinished(id, CoverProviderSearchResults());
return;
}
QJsonValue value_items = json_obj["items"];
QJsonValue value_items = json_obj[QStringLiteral("items")];
if (!value_items.isArray()) {
emit SearchFinished(id, CoverProviderSearchResults());
@@ -200,35 +200,35 @@ void TidalCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id) {
for (const QJsonValueRef value_item : array_items) {
if (!value_item.isObject()) {
Error("Invalid Json reply, items array item is not a object.");
Error(QStringLiteral("Invalid Json reply, items array item is not a object."));
continue;
}
QJsonObject obj_item = value_item.toObject();
if (!obj_item.contains("artist")) {
Error("Invalid Json reply, items array item is missing artist.", obj_item);
if (!obj_item.contains(QStringLiteral("artist"))) {
Error(QStringLiteral("Invalid Json reply, items array item is missing artist."), obj_item);
continue;
}
QJsonValue value_artist = obj_item["artist"];
QJsonValue value_artist = obj_item[QStringLiteral("artist")];
if (!value_artist.isObject()) {
Error("Invalid Json reply, items array item artist is not a object.", value_artist);
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("name")) {
Error("Invalid Json reply, items array item artist is missing name.", obj_artist);
if (!obj_artist.contains(QStringLiteral("name"))) {
Error(QStringLiteral("Invalid Json reply, items array item artist is missing name."), obj_artist);
continue;
}
QString artist = obj_artist["name"].toString();
QString artist = obj_artist[QStringLiteral("name")].toString();
QJsonObject obj_album;
if (obj_item.contains("album")) {
QJsonValue value_album = obj_item["album"];
if (obj_item.contains(QStringLiteral("album"))) {
QJsonValue value_album = obj_item[QStringLiteral("album")];
if (value_album.isObject()) {
obj_album = value_album.toObject();
}
else {
Error("Invalid Json reply, items array item album is not a object.", value_album);
Error(QStringLiteral("Invalid Json reply, items array item album is not a object."), value_album);
continue;
}
}
@@ -236,23 +236,23 @@ void TidalCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id) {
obj_album = obj_item;
}
if (!obj_album.contains("title") || !obj_album.contains("cover")) {
Error("Invalid Json reply, items array item album is missing title or cover.", obj_album);
if (!obj_album.contains(QStringLiteral("title")) || !obj_album.contains(QStringLiteral("cover"))) {
Error(QStringLiteral("Invalid Json reply, items array item album is missing title or cover."), obj_album);
continue;
}
QString album = obj_album["title"].toString();
QString cover = obj_album["cover"].toString().replace("-", "/");
QString album = obj_album[QStringLiteral("title")].toString();
QString cover = obj_album[QStringLiteral("cover")].toString().replace(QLatin1String("-"), QLatin1String("/"));
CoverProviderSearchResult cover_result;
cover_result.artist = artist;
cover_result.album = Song::AlbumRemoveDiscMisc(album);
cover_result.number = ++i;
QList<QPair<QString, QSize>> cover_sizes = QList<QPair<QString, QSize>>() << qMakePair(QString("1280x1280"), QSize(1280, 1280))
<< qMakePair(QString("750x750"), QSize(750, 750))
<< qMakePair(QString("640x640"), QSize(640, 640));
QList<QPair<QString, QSize>> cover_sizes = QList<QPair<QString, QSize>>() << qMakePair(QStringLiteral("1280x1280"), QSize(1280, 1280))
<< qMakePair(QStringLiteral("750x750"), QSize(750, 750))
<< qMakePair(QStringLiteral("640x640"), QSize(640, 640));
for (const QPair<QString, QSize> &cover_size : cover_sizes) {
QUrl cover_url(QString("%1/images/%2/%3.jpg").arg(TidalService::kResourcesUrl, cover, cover_size.first));
QUrl cover_url(QStringLiteral("%1/images/%2/%3.jpg").arg(TidalService::kResourcesUrl, cover, cover_size.first));
cover_result.image_url = cover_url;
cover_result.image_size = cover_size.second;
results << cover_result;