Funkwhale
/
strawberry-audio-player-windows-mac-linux
mirror of https://github.com/strawberrymusicplayer/strawberry
1
0
Fork 0
Code Issues Releases Wiki Activity

Replace QStringLiteral with QLatin1String

This commit is contained in:
Jonas Kvinge 2024-06-12 02:13:27 +02:00
parent 597a8cd6c8
commit b89c200076
73 changed files with 1215 additions and 1215 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/collection/collectionbackend.cpp
View File

@ -1103,7 +1103,7 @@ SongList CollectionBackend::GetSongsByForeignId(const QStringList &ids, const QS
QMutexLocker l(db_->Mutex());
QSqlDatabase db(db_->Connect());
QString in = ids.join(QStringLiteral(","));
QString in = ids.join(QLatin1Char(','));
SqlQuery q(db);
q.prepare(QStringLiteral("SELECT %3.ROWID, %2, %3.%4 FROM %3, %1 WHERE %3.%4 IN (in) AND %1.ROWID = %3.ROWID AND unavailable = 0").arg(songs_table_, Song::kColumnSpec, table, column, in));
@ -1134,7 +1134,7 @@ Song CollectionBackend::GetSongById(const int id, QSqlDatabase &db) {
SongList CollectionBackend::GetSongsById(const QStringList &ids, QSqlDatabase &db) {
QString in = ids.join(QStringLiteral(","));
QString in = ids.join(QLatin1Char(','));
SqlQuery q(db);
q.prepare(QStringLiteral("SELECT %1 FROM %2 WHERE ROWID IN (%3)").arg(Song::kRowIdColumnSpec, songs_table_, in));
@ -1885,7 +1885,7 @@ bool CollectionBackend::ResetPlayStatistics(const QStringList &id_str_list) {
SqlQuery q(db);
q.prepare(QStringLiteral("UPDATE %1 SET playcount = 0, skipcount = 0, lastplayed = -1 WHERE ROWID IN (:ids)").arg(songs_table_));
q.BindValue(QStringLiteral(":ids"), id_str_list.join(QStringLiteral(",")));
q.BindValue(QStringLiteral(":ids"), id_str_list.join(QLatin1Char(',')));
if (!q.Exec()) {
db_->ReportErrors(q);
return false;
@ -2063,7 +2063,7 @@ void CollectionBackend::UpdateSongsRating(const QList<int> &id_list, const float
for (int i : id_list) {
id_str_list << QString::number(i);
}
QString ids = id_str_list.join(QStringLiteral(","));
QString ids = id_str_list.join(QLatin1Char(','));
SqlQuery q(db);
q.prepare(QStringLiteral("UPDATE %1 SET rating = :rating WHERE ROWID IN (%2)").arg(songs_table_, ids));
q.BindValue(QStringLiteral(":rating"), rating);

52
src/collection/collectionfilter.cpp
View File

@ -140,11 +140,11 @@ bool CollectionFilter::filterAcceptsRow(const int source_row, const QModelIndex
continue;
}
}
else if (field.compare(QStringLiteral("length"), Qt::CaseInsensitive) == 0) {
else if (field.compare(QLatin1String("length"), Qt::CaseInsensitive) == 0) {
filters.insert(field, Filter(field, static_cast<qint64>(Utilities::ParseSearchTime(value)) * kNsecPerSec, foperator));
continue;
}
else if (field.compare(QStringLiteral("rating"), Qt::CaseInsensitive) == 0) {
else if (field.compare(QLatin1String("rating"), Qt::CaseInsensitive) == 0) {
filters.insert(field, Filter(field, Utilities::ParseSearchRating(value), foperator));
}
}
@ -218,24 +218,24 @@ bool CollectionFilter::ItemMetadataMatchesFilterText(const Song &metadata, const
QVariant CollectionFilter::DataFromField(const QString &field, const Song &metadata) {
if (field == QStringLiteral("albumartist")) return metadata.effective_albumartist();
if (field == QStringLiteral("artist")) return metadata.artist();
if (field == QStringLiteral("album")) return metadata.album();
if (field == QStringLiteral("title")) return metadata.title();
if (field == QStringLiteral("composer")) return metadata.composer();
if (field == QStringLiteral("performer")) return metadata.performer();
if (field == QStringLiteral("grouping")) return metadata.grouping();
if (field == QStringLiteral("genre")) return metadata.genre();
if (field == QStringLiteral("comment")) return metadata.comment();
if (field == QStringLiteral("track")) return metadata.track();
if (field == QStringLiteral("year")) return metadata.year();
if (field == QStringLiteral("length")) return metadata.length_nanosec();
if (field == QStringLiteral("samplerate")) return metadata.samplerate();
if (field == QStringLiteral("bitdepth")) return metadata.bitdepth();
if (field == QStringLiteral("bitrate")) return metadata.bitrate();
if (field == QStringLiteral("rating")) return metadata.rating();
if (field == QStringLiteral("playcount")) return metadata.playcount();
if (field == QStringLiteral("skipcount")) return metadata.skipcount();
if (field == QLatin1String("albumartist")) return metadata.effective_albumartist();
if (field == QLatin1String("artist")) return metadata.artist();
if (field == QLatin1String("album")) return metadata.album();
if (field == QLatin1String("title")) return metadata.title();
if (field == QLatin1String("composer")) return metadata.composer();
if (field == QLatin1String("performer")) return metadata.performer();
if (field == QLatin1String("grouping")) return metadata.grouping();
if (field == QLatin1String("genre")) return metadata.genre();
if (field == QLatin1String("comment")) return metadata.comment();
if (field == QLatin1String("track")) return metadata.track();
if (field == QLatin1String("year")) return metadata.year();
if (field == QLatin1String("length")) return metadata.length_nanosec();
if (field == QLatin1String("samplerate")) return metadata.samplerate();
if (field == QLatin1String("bitdepth")) return metadata.bitdepth();
if (field == QLatin1String("bitrate")) return metadata.bitrate();
if (field == QLatin1String("rating")) return metadata.rating();
if (field == QLatin1String("playcount")) return metadata.playcount();
if (field == QLatin1String("skipcount")) return metadata.skipcount();
return QVariant();
@ -277,22 +277,22 @@ bool CollectionFilter::FieldValueMatchesData(const QVariant &value, const QVaria
template<typename T>
bool CollectionFilter::FieldNumericalValueMatchesData(const T value, const QString &foperator, const T data) {
if (foperator == QStringLiteral("=") || foperator == QStringLiteral("==")) {
if (foperator == QLatin1Char('=') || foperator == QLatin1String("==")) {
return data == value;
}
else if (foperator == QStringLiteral("!=") || foperator == QStringLiteral("<>")) {
else if (foperator == QLatin1String("!=") || foperator == QLatin1String("<>")) {
return data != value;
}
else if (foperator == QStringLiteral("<")) {
else if (foperator == QLatin1Char('<')) {
return data < value;
}
else if (foperator == QStringLiteral(">")) {
else if (foperator == QLatin1Char('>')) {
return data > value;
}
else if (foperator == QStringLiteral(">=")) {
else if (foperator == QLatin1String(">=")) {
return data >= value;
}
else if (foperator == QStringLiteral("<=")) {
else if (foperator == QLatin1String("<=")) {
return data <= value;
}

4
src/collection/collectionfilterwidget.cpp
View File

@ -77,8 +77,8 @@ CollectionFilterWidget::CollectionFilterWidget(QWidget *parent)
ui_->setupUi(this);
QString available_fields = Song::kTextSearchColumns.join(QStringLiteral(", "));
available_fields += QStringLiteral(", ") + Song::kNumericalSearchColumns.join(QStringLiteral(", "));
QString available_fields = Song::kTextSearchColumns.join(QLatin1String(", "));
available_fields += QLatin1String(", ") + Song::kNumericalSearchColumns.join(QLatin1String(", "));
ui_->search_field->setToolTip(
QStringLiteral("<html><head/><body><p>") +

12
src/collection/collectionquery.cpp
View File

@ -62,12 +62,12 @@ CollectionQuery::CollectionQuery(const QSqlDatabase &db, const QString &songs_ta
void CollectionQuery::AddWhere(const QString &column, const QVariant &value, const QString &op) {
// Ignore 'literal' for IN
if (op.compare(QStringLiteral("IN"), Qt::CaseInsensitive) == 0) {
if (op.compare(QLatin1String("IN"), Qt::CaseInsensitive) == 0) {
QStringList values = value.toStringList();
QStringList final_values;
final_values.reserve(values.count());
for (const QString &single_value : values) {
final_values.append(QStringLiteral("?"));
final_values.append(QLatin1String("?"));
bound_values_ << single_value;
}
@ -124,13 +124,13 @@ bool CollectionQuery::Exec() {
where_clauses << QStringLiteral("unavailable = 0");
}
if (!where_clauses.isEmpty()) sql += QStringLiteral(" WHERE ") + where_clauses.join(QStringLiteral(" AND "));
if (!where_clauses.isEmpty()) sql += QLatin1String(" WHERE ") + where_clauses.join(QLatin1String(" AND "));
if (!order_by_.isEmpty()) sql += QStringLiteral(" ORDER BY ") + order_by_;
if (!order_by_.isEmpty()) sql += QLatin1String(" ORDER BY ") + order_by_;
if (limit_ != -1) sql += QStringLiteral(" LIMIT ") + QString::number(limit_);
if (limit_ != -1) sql += QLatin1String(" LIMIT ") + QString::number(limit_);
sql.replace(QStringLiteral("%songs_table"), songs_table_);
sql.replace(QLatin1String("%songs_table"), songs_table_);
if (!QSqlQuery::prepare(sql)) return false;

10
src/collection/collectionwatcher.cpp
View File

@ -511,7 +511,7 @@ void CollectionWatcher::ScanSubdirectory(const QString &path, const CollectionSu
else {
QString ext_part(ExtensionPart(child));
QString dir_part(DirectoryPart(child));
if (kIgnoredExtensions.contains(child_info.suffix(), Qt::CaseInsensitive) || child_info.baseName() == QStringLiteral("qt_temp")) {
if (kIgnoredExtensions.contains(child_info.suffix(), Qt::CaseInsensitive) || child_info.baseName() == QLatin1String("qt_temp")) {
t->AddToProgress(1);
}
else if (sValidImages.contains(ext_part)) {
@ -613,7 +613,7 @@ void CollectionWatcher::ScanSubdirectory(const QString &path, const CollectionSu
Chromaprinter chromaprinter(file);
fingerprint = chromaprinter.CreateFingerprint();
if (fingerprint.isEmpty()) {
fingerprint = QStringLiteral("NONE");
fingerprint = QLatin1String("NONE");
}
}
#endif
@ -640,11 +640,11 @@ void CollectionWatcher::ScanSubdirectory(const QString &path, const CollectionSu
Chromaprinter chromaprinter(file);
fingerprint = chromaprinter.CreateFingerprint();
if (fingerprint.isEmpty()) {
fingerprint = QStringLiteral("NONE");
fingerprint = QLatin1String("NONE");
}
}
#endif
if (song_tracking_ && !fingerprint.isEmpty() && fingerprint != QStringLiteral("NONE") && FindSongsByFingerprint(file, fingerprint, &matching_songs)) {
if (song_tracking_ && !fingerprint.isEmpty() && fingerprint != QLatin1String("NONE") && FindSongsByFingerprint(file, fingerprint, &matching_songs)) {
// The song is in the database and still on disk.
// Check the mtime to see if it's been changed since it was added.
@ -936,7 +936,7 @@ void CollectionWatcher::AddChangedSong(const QString &file, const Song &matching
qLog(Debug) << "Song" << file << "unchanged.";
}
else {
qLog(Debug) << "Song" << file << changes.join(QStringLiteral(", ")) << "changed.";
qLog(Debug) << "Song" << file << changes.join(QLatin1String(", ")) << "changed.";
}
}

32
src/core/mpris2.cpp
View File

@ -133,11 +133,11 @@ Mpris2::Mpris2(Application *app, QObject *parent)
QStringList data_dirs = QString::fromUtf8(qgetenv("XDG_DATA_DIRS")).split(QLatin1Char(':'));
if (!data_dirs.contains(QStringLiteral("/usr/local/share"))) {
if (!data_dirs.contains(QLatin1String("/usr/local/share"))) {
data_dirs.append(QStringLiteral("/usr/local/share"));
}
if (!data_dirs.contains(QStringLiteral("/usr/share"))) {
if (!data_dirs.contains(QLatin1String("/usr/share"))) {
data_dirs.append(QStringLiteral("/usr/share"));
}
@ -207,18 +207,18 @@ void Mpris2::EmitNotification(const QString &name, const QVariant &value, const
void Mpris2::EmitNotification(const QString &name) {
QVariant value;
if (name == QStringLiteral("PlaybackStatus")) value = PlaybackStatus();
else if (name == QStringLiteral("LoopStatus")) value = LoopStatus();
else if (name == QStringLiteral("Shuffle")) value = Shuffle();
else if (name == QStringLiteral("Metadata")) value = Metadata();
else if (name == QStringLiteral("Rating")) value = Rating();
else if (name == QStringLiteral("Volume")) value = Volume();
else if (name == QStringLiteral("Position")) value = Position();
else if (name == QStringLiteral("CanPlay")) value = CanPlay();
else if (name == QStringLiteral("CanPause")) value = CanPause();
else if (name == QStringLiteral("CanSeek")) value = CanSeek();
else if (name == QStringLiteral("CanGoNext")) value = CanGoNext();
else if (name == QStringLiteral("CanGoPrevious")) value = CanGoPrevious();
if (name == QLatin1String("PlaybackStatus")) value = PlaybackStatus();
else if (name == QLatin1String("LoopStatus")) value = LoopStatus();
else if (name == QLatin1String("Shuffle")) value = Shuffle();
else if (name == QLatin1String("Metadata")) value = Metadata();
else if (name == QLatin1String("Rating")) value = Rating();
else if (name == QLatin1String("Volume")) value = Volume();
else if (name == QLatin1String("Position")) value = Position();
else if (name == QLatin1String("CanPlay")) value = CanPlay();
else if (name == QLatin1String("CanPause")) value = CanPause();
else if (name == QLatin1String("CanSeek")) value = CanSeek();
else if (name == QLatin1String("CanGoNext")) value = CanGoNext();
else if (name == QLatin1String("CanGoPrevious")) value = CanGoPrevious();
if (value.isValid()) EmitNotification(name, value);
@ -240,7 +240,7 @@ QString Mpris2::DesktopEntryAbsolutePath() const {
}
QString Mpris2::DesktopEntry() const { return QGuiApplication::desktopFileName() + QStringLiteral(".desktop"); }
QString Mpris2::DesktopEntry() const { return QGuiApplication::desktopFileName() + QLatin1String(".desktop"); }
QStringList Mpris2::SupportedUriSchemes() const {
@ -460,7 +460,7 @@ bool Mpris2::CanPlay() const {
// This one's a bit different than MPRIS 1 - we want this to be true even when the song is already paused or stopped.
bool Mpris2::CanPause() const {
return (app_->player()->GetCurrentItem() && app_->player()->GetState() == EngineBase::State::Playing && !(app_->player()->GetCurrentItem()->options() & PlaylistItem::Option::PauseDisabled)) || PlaybackStatus() == QStringLiteral("Paused") || PlaybackStatus() == QStringLiteral("Stopped");
return (app_->player()->GetCurrentItem() && app_->player()->GetState() == EngineBase::State::Playing && !(app_->player()->GetCurrentItem()->options() & PlaylistItem::Option::PauseDisabled)) || PlaybackStatus() == QLatin1String("Paused") || PlaybackStatus() == QLatin1String("Stopped");
}
bool Mpris2::CanSeek() const { return CanSeek(app_->player()->GetState()); }

10
src/core/song.cpp
View File

@ -144,10 +144,10 @@ const QStringList Song::kColumns = QStringList() << QStringLiteral("title")
const QStringList Song::kRowIdColumns = QStringList() << QStringLiteral("ROWID") << kColumns;
const QString Song::kColumnSpec = kColumns.join(QStringLiteral(", "));
const QString Song::kRowIdColumnSpec = kRowIdColumns.join(QStringLiteral(", "));
const QString Song::kBindSpec = Utilities::Prepend(QStringLiteral(":"), kColumns).join(QStringLiteral(", "));
const QString Song::kUpdateSpec = Utilities::Updateify(kColumns).join(QStringLiteral(", "));
const QString Song::kColumnSpec = kColumns.join(QLatin1String(", "));
const QString Song::kRowIdColumnSpec = kRowIdColumns.join(QLatin1String(", "));
const QString Song::kBindSpec = Utilities::Prepend(QStringLiteral(":"), kColumns).join(QLatin1String(", "));
const QString Song::kUpdateSpec = Utilities::Updateify(kColumns).join(QLatin1String(", "));
const QStringList Song::kTextSearchColumns = QStringList() << QStringLiteral("title")
<< QStringLiteral("album")
@ -711,7 +711,7 @@ int Song::ColumnIndex(const QString &field) {
}
QString Song::JoinSpec(const QString &table) {
return Utilities::Prepend(table + QLatin1Char('.'), kRowIdColumns).join(QStringLiteral(", "));
return Utilities::Prepend(table + QLatin1Char('.'), kRowIdColumns).join(QLatin1String(", "));
}
QString Song::PrettyTitle() const {

42
src/core/stylesheetloader.cpp
View File

@ -93,29 +93,29 @@ void StyleSheetLoader::UpdateStyleSheet(QWidget *widget, SharedPtr<StyleSheetDat
stylesheet.replace(QLatin1String("%palette-alternate-base"), QStringLiteral("rgba(%1,%2,%3,%4)").arg(alt.red()).arg(alt.green()).arg(alt.blue()).arg(alt.alpha()));
}
ReplaceColor(&stylesheet, QStringLiteral("Window"), p, QPalette::Window);
ReplaceColor(&stylesheet, QStringLiteral("Background"), p, QPalette::Window);
ReplaceColor(&stylesheet, QStringLiteral("WindowText"), p, QPalette::WindowText);
ReplaceColor(&stylesheet, QStringLiteral("Base"), p, QPalette::Base);
ReplaceColor(&stylesheet, QStringLiteral("AlternateBase"), p, QPalette::AlternateBase);
ReplaceColor(&stylesheet, QStringLiteral("ToolTipBase"), p, QPalette::ToolTipBase);
ReplaceColor(&stylesheet, QStringLiteral("ToolTipText"), p, QPalette::ToolTipText);
ReplaceColor(&stylesheet, QStringLiteral("Text"), p, QPalette::Text);
ReplaceColor(&stylesheet, QStringLiteral("Button"), p, QPalette::Button);
ReplaceColor(&stylesheet, QStringLiteral("ButtonText"), p, QPalette::ButtonText);
ReplaceColor(&stylesheet, QStringLiteral("BrightText"), p, QPalette::BrightText);
ReplaceColor(&stylesheet, QStringLiteral("Light"), p, QPalette::Light);
ReplaceColor(&stylesheet, QStringLiteral("Midlight"), p, QPalette::Midlight);
ReplaceColor(&stylesheet, QStringLiteral("Dark"), p, QPalette::Dark);
ReplaceColor(&stylesheet, QStringLiteral("Mid"), p, QPalette::Mid);
ReplaceColor(&stylesheet, QStringLiteral("Shadow"), p, QPalette::Shadow);
ReplaceColor(&stylesheet, QStringLiteral("Highlight"), p, QPalette::Highlight);
ReplaceColor(&stylesheet, QStringLiteral("HighlightedText"), p, QPalette::HighlightedText);
ReplaceColor(&stylesheet, QStringLiteral("Link"), p, QPalette::Link);
ReplaceColor(&stylesheet, QStringLiteral("LinkVisited"), p, QPalette::LinkVisited);
ReplaceColor(&stylesheet, QLatin1String("Window"), p, QPalette::Window);
ReplaceColor(&stylesheet, QLatin1String("Background"), p, QPalette::Window);
ReplaceColor(&stylesheet, QLatin1String("WindowText"), p, QPalette::WindowText);
ReplaceColor(&stylesheet, QLatin1String("Base"), p, QPalette::Base);
ReplaceColor(&stylesheet, QLatin1String("AlternateBase"), p, QPalette::AlternateBase);
ReplaceColor(&stylesheet, QLatin1String("ToolTipBase"), p, QPalette::ToolTipBase);
ReplaceColor(&stylesheet, QLatin1String("ToolTipText"), p, QPalette::ToolTipText);
ReplaceColor(&stylesheet, QLatin1String("Text"), p, QPalette::Text);
ReplaceColor(&stylesheet, QLatin1String("Button"), p, QPalette::Button);
ReplaceColor(&stylesheet, QLatin1String("ButtonText"), p, QPalette::ButtonText);
ReplaceColor(&stylesheet, QLatin1String("BrightText"), p, QPalette::BrightText);
ReplaceColor(&stylesheet, QLatin1String("Light"), p, QPalette::Light);
ReplaceColor(&stylesheet, QLatin1String("Midlight"), p, QPalette::Midlight);
ReplaceColor(&stylesheet, QLatin1String("Dark"), p, QPalette::Dark);
ReplaceColor(&stylesheet, QLatin1String("Mid"), p, QPalette::Mid);
ReplaceColor(&stylesheet, QLatin1String("Shadow"), p, QPalette::Shadow);
ReplaceColor(&stylesheet, QLatin1String("Highlight"), p, QPalette::Highlight);
ReplaceColor(&stylesheet, QLatin1String("HighlightedText"), p, QPalette::HighlightedText);
ReplaceColor(&stylesheet, QLatin1String("Link"), p, QPalette::Link);
ReplaceColor(&stylesheet, QLatin1String("LinkVisited"), p, QPalette::LinkVisited);
#ifdef Q_OS_MACOS
stylesheet.replace(QStringLiteral("macos"), QStringLiteral("*"));
stylesheet.replace(QLatin1String("macos"), QLatin1String("*"));
#endif
if (stylesheet != styledata->stylesheet_current_) {

50
src/covermanager/deezercoverprovider.cpp
View File

@ -73,12 +73,12 @@ bool DeezerCoverProvider::StartSearch(const QString &artist, const QString &albu
QString resource;
QString query = artist;
if (album.isEmpty() && !title.isEmpty()) {
resource = QStringLiteral("search/track");
resource = QLatin1String("search/track");
if (!query.isEmpty()) query.append(QLatin1Char(' '));
query.append(title);
}
else {
resource = QStringLiteral("search/album");
resource = QLatin1String("search/album");
if (!album.isEmpty()) {
if (!query.isEmpty()) query.append(QLatin1Char(' '));
query.append(album);
@ -129,12 +129,12 @@ QByteArray DeezerCoverProvider::GetReplyData(QNetworkReply *reply) {
QString error;
if (json_error.error == QJsonParseError::NoError && !json_doc.isEmpty() && json_doc.isObject()) {
QJsonObject json_obj = json_doc.object();
if (json_obj.contains(QStringLiteral("error"))) {
QJsonValue value_error = json_obj[QStringLiteral("error")];
if (json_obj.contains(QLatin1String("error"))) {
QJsonValue value_error = json_obj[QLatin1String("error")];
if (value_error.isObject()) {
QJsonObject obj_error = value_error.toObject();
int code = obj_error[QStringLiteral("code")].toInt();
QString message = obj_error[QStringLiteral("message")].toString();
int code = obj_error[QLatin1String("code")].toInt();
QString message = obj_error[QLatin1String("message")].toString();
error = QStringLiteral("%1 (%2)").arg(message).arg(code);
}
}
@ -161,27 +161,27 @@ QJsonValue DeezerCoverProvider::ExtractData(const QByteArray &data) {
QJsonObject json_obj = ExtractJsonObj(data);
if (json_obj.isEmpty()) return QJsonObject();
if (json_obj.contains(QStringLiteral("error"))) {
QJsonValue value_error = json_obj[QStringLiteral("error")];
if (json_obj.contains(QLatin1String("error"))) {
QJsonValue value_error = json_obj[QLatin1String("error")];
if (!value_error.isObject()) {
Error(QStringLiteral("Error missing object"), json_obj);
return QJsonValue();
}
QJsonObject obj_error = value_error.toObject();
const int code = obj_error[QStringLiteral("code")].toInt();
QString message = obj_error[QStringLiteral("message")].toString();
const int code = obj_error[QLatin1String("code")].toInt();
QString message = obj_error[QLatin1String("message")].toString();
Error(QStringLiteral("%1 (%2)").arg(message).arg(code));
return QJsonValue();
}
if (!json_obj.contains(QStringLiteral("data")) && !json_obj.contains(QStringLiteral("DATA"))) {
if (!json_obj.contains(QLatin1String("data")) && !json_obj.contains(QLatin1String("DATA"))) {
Error(QStringLiteral("Json reply object is missing data."), json_obj);
return QJsonValue();
}
QJsonValue value_data;
if (json_obj.contains(QStringLiteral("data"))) value_data = json_obj[QStringLiteral("data")];
else value_data = json_obj[QStringLiteral("DATA")];
if (json_obj.contains(QLatin1String("data"))) value_data = json_obj[QLatin1String("data")];
else value_data = json_obj[QLatin1String("DATA")];
return value_data;
@ -222,50 +222,50 @@ void DeezerCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id)
}
QJsonObject json_obj = json_value.toObject();
QJsonObject obj_album;
if (json_obj.contains(QStringLiteral("album")) && json_obj[QStringLiteral("album")].isObject()) { // Song search, so extract the album.
obj_album = json_obj[QStringLiteral("album")].toObject();
if (json_obj.contains(QLatin1String("album")) && json_obj[QLatin1String("album")].isObject()) { // Song search, so extract the album.
obj_album = json_obj[QLatin1String("album")].toObject();
}
else {
obj_album = json_obj;
}
if (!json_obj.contains(QStringLiteral("id")) || !obj_album.contains(QStringLiteral("id"))) {
if (!json_obj.contains(QLatin1String("id")) || !obj_album.contains(QLatin1String("id"))) {
Error(QStringLiteral("Invalid Json reply, data array value object is missing ID."), json_obj);
continue;
}
if (!obj_album.contains(QStringLiteral("type"))) {
if (!obj_album.contains(QLatin1String("type"))) {
Error(QStringLiteral("Invalid Json reply, data array value album object is missing type."), obj_album);
continue;
}
QString type = obj_album[QStringLiteral("type")].toString();
if (type != QStringLiteral("album")) {
QString type = obj_album[QLatin1String("type")].toString();
if (type != QLatin1String("album")) {
Error(QStringLiteral("Invalid Json reply, data array value album object has incorrect type returned"), obj_album);
continue;
}
if (!json_obj.contains(QStringLiteral("artist"))) {
if (!json_obj.contains(QLatin1String("artist"))) {
Error(QStringLiteral("Invalid Json reply, data array value object is missing artist."), json_obj);
continue;
}
QJsonValue value_artist = json_obj[QStringLiteral("artist")];
QJsonValue value_artist = json_obj[QLatin1String("artist")];
if (!value_artist.isObject()) {
Error(QStringLiteral("Invalid Json reply, data array value artist is not a object."), value_artist);
continue;
}
QJsonObject obj_artist = value_artist.toObject();
if (!obj_artist.contains(QStringLiteral("name"))) {
if (!obj_artist.contains(QLatin1String("name"))) {
Error(QStringLiteral("Invalid Json reply, data array value artist object is missing name."), obj_artist);
continue;
}
QString artist = obj_artist[QStringLiteral("name")].toString();
QString artist = obj_artist[QLatin1String("name")].toString();
if (!obj_album.contains(QStringLiteral("title"))) {
if (!obj_album.contains(QLatin1String("title"))) {
Error(QStringLiteral("Invalid Json reply, data array value album object is missing title."), obj_album);
continue;
}
QString album = obj_album[QStringLiteral("title")].toString();
QString album = obj_album[QLatin1String("title")].toString();
CoverProviderSearchResult cover_result;
cover_result.artist = artist;

52
src/covermanager/discogscoverprovider.cpp
View File

@ -163,7 +163,7 @@ QNetworkReply *DiscogsCoverProvider::CreateRequest(QUrl url, const ParamList &pa
url.setQuery(url_query);
// Sign the request
const QByteArray data_to_sign = QStringLiteral("GET\n%1\n%2\n%3").arg(url.host(), url.path(), query_items.join(QStringLiteral("&"))).toUtf8();
const QByteArray data_to_sign = QStringLiteral("GET\n%1\n%2\n%3").arg(url.host(), url.path(), query_items.join(QLatin1Char('&'))).toUtf8();
const QByteArray signature(Utilities::HmacSha256(QByteArray::fromBase64(kSecretKeyB64), data_to_sign));
// Add the signature to the request
@ -201,8 +201,8 @@ QByteArray DiscogsCoverProvider::GetReplyData(QNetworkReply *reply) {
QJsonDocument json_doc = QJsonDocument::fromJson(data, &json_error);
if (json_error.error == QJsonParseError::NoError && !json_doc.isEmpty() && json_doc.isObject()) {
QJsonObject json_obj = json_doc.object();
if (json_obj.contains(QStringLiteral("message"))) {
error = json_obj[QStringLiteral("message")].toString();
if (json_obj.contains(QLatin1String("message"))) {
error = json_obj[QLatin1String("message")].toString();
}
}
if (error.isEmpty()) {
@ -245,11 +245,11 @@ void DiscogsCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id)
}
QJsonValue value_results;
if (json_obj.contains(QStringLiteral("results"))) {
value_results = json_obj[QStringLiteral("results")];
if (json_obj.contains(QLatin1String("results"))) {
value_results = json_obj[QLatin1String("results")];
}
else if (json_obj.contains(QStringLiteral("message"))) {
QString message = json_obj[QStringLiteral("message")].toString();
else if (json_obj.contains(QLatin1String("message"))) {
QString message = json_obj[QLatin1String("message")].toString();
Error(QStringLiteral("%1").arg(message));
EndSearch(search);
return;
@ -274,16 +274,16 @@ void DiscogsCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id)
continue;
}
QJsonObject obj_result = value_result.toObject();
if (!obj_result.contains(QStringLiteral("id")) || !obj_result.contains(QStringLiteral("title")) || !obj_result.contains(QStringLiteral("resource_url"))) {
if (!obj_result.contains(QLatin1String("id")) || !obj_result.contains(QLatin1String("title")) || !obj_result.contains(QLatin1String("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[QStringLiteral("id")].toInt();
QUrl resource_url(obj_result[QStringLiteral("resource_url")].toString());
QString title = obj_result[QStringLiteral("title")].toString();
quint64 release_id = obj_result[QLatin1String("id")].toInt();
QUrl resource_url(obj_result[QLatin1String("resource_url")].toString());
QString title = obj_result[QLatin1String("title")].toString();
if (title.contains(QLatin1String(" - "))) {
QStringList title_splitted = title.split(QStringLiteral(" - "));
QStringList title_splitted = title.split(QLatin1String(" - "));
if (title_splitted.count() == 2) {
QString artist = title_splitted.first();
title = title_splitted.last();
@ -354,18 +354,18 @@ void DiscogsCoverProvider::HandleReleaseReply(QNetworkReply *reply, const int se
return;
}
if (!json_obj.contains(QStringLiteral("artists")) || !json_obj.contains(QStringLiteral("title"))) {
if (!json_obj.contains(QLatin1String("artists")) || !json_obj.contains(QLatin1String("title"))) {
Error(QStringLiteral("Json reply object is missing artists or title."), json_obj);
EndSearch(search, release.id);
return;
}
if (!json_obj.contains(QStringLiteral("images"))) {
if (!json_obj.contains(QLatin1String("images"))) {
EndSearch(search, release.id);
return;
}
QJsonValue value_artists = json_obj[QStringLiteral("artists")];
QJsonValue value_artists = json_obj[QLatin1String("artists")];
if (!value_artists.isArray()) {
Error(QStringLiteral("Json reply object artists is not a array."), value_artists);
EndSearch(search, release.id);
@ -380,11 +380,11 @@ void DiscogsCoverProvider::HandleReleaseReply(QNetworkReply *reply, const int se
continue;
}
QJsonObject obj_artist = value_artist.toObject();
if (!obj_artist.contains(QStringLiteral("name"))) {
if (!obj_artist.contains(QLatin1String("name"))) {
Error(QStringLiteral("Invalid Json reply, artists array value object is missing name."), obj_artist);
continue;
}
artist = obj_artist[QStringLiteral("name")].toString();
artist = obj_artist[QLatin1String("name")].toString();
++i;
if (artist == search->artist) break;
}
@ -393,15 +393,15 @@ void DiscogsCoverProvider::HandleReleaseReply(QNetworkReply *reply, const int se
EndSearch(search, release.id);
return;
}
if (i > 1 && artist != search->artist) artist = QStringLiteral("Various artists");
if (i > 1 && artist != search->artist) artist = QLatin1String("Various artists");
QString album = json_obj[QStringLiteral("title")].toString();
QString album = json_obj[QLatin1String("title")].toString();
if (artist != search->artist && album != search->album) {
EndSearch(search, release.id);
return;
}
QJsonValue value_images = json_obj[QStringLiteral("images")];
QJsonValue value_images = json_obj[QLatin1String("images")];
if (!value_images.isArray()) {
Error(QStringLiteral("Json images is not an array."));
EndSearch(search, release.id);
@ -422,23 +422,23 @@ void DiscogsCoverProvider::HandleReleaseReply(QNetworkReply *reply, const int se
continue;
}
QJsonObject obj_image = value_image.toObject();
if (!obj_image.contains(QStringLiteral("type")) || !obj_image.contains(QStringLiteral("resource_url")) || !obj_image.contains(QStringLiteral("width")) || !obj_image.contains(QStringLiteral("height"))) {
if (!obj_image.contains(QLatin1String("type")) || !obj_image.contains(QLatin1String("resource_url")) || !obj_image.contains(QLatin1String("width")) || !obj_image.contains(QLatin1String("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[QStringLiteral("type")].toString();
if (type != QStringLiteral("primary")) {
QString type = obj_image[QLatin1String("type")].toString();
if (type != QLatin1String("primary")) {
continue;
}
int width = obj_image[QStringLiteral("width")].toInt();
int height = obj_image[QStringLiteral("height")].toInt();
int width = obj_image[QLatin1String("width")].toInt();
int height = obj_image[QLatin1String("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[QStringLiteral("resource_url")].toString());
result.image_url = QUrl(obj_image[QLatin1String("resource_url")].toString());
if (result.image_url.isEmpty()) continue;
search->results.append(result);
}

62
src/covermanager/lastfmcoverprovider.cpp
View File

@ -74,14 +74,14 @@ bool LastFmCoverProvider::StartSearch(const QString &artist, const QString &albu
QString type;
QString query = artist;
if (album.isEmpty() && !title.isEmpty()) {
method = QStringLiteral("track.search");
type = QStringLiteral("track");
method = QLatin1String("track.search");
type = QLatin1String("track");
if (!query.isEmpty()) query.append(QLatin1Char(' '));
query.append(title);
}
else {
method = QStringLiteral("album.search");
type = QStringLiteral("album");
method = QLatin1String("album.search");
type = QLatin1String("album");
if (!album.isEmpty()) {
if (!query.isEmpty()) query.append(QLatin1Char(' '));
query.append(album);
@ -143,12 +143,12 @@ void LastFmCoverProvider::QueryFinished(QNetworkReply *reply, const int id, cons
}
QJsonValue value_results;
if (json_obj.contains(QStringLiteral("results"))) {
value_results = json_obj[QStringLiteral("results")];
if (json_obj.contains(QLatin1String("results"))) {
value_results = json_obj[QLatin1String("results")];
}
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();
else if (json_obj.contains(QLatin1String("error")) && json_obj.contains(QLatin1String("message"))) {
int error = json_obj[QLatin1String("error")].toInt();
QString message = json_obj[QLatin1String("message")].toString();
Error(QStringLiteral("Error: %1: %2").arg(QString::number(error), message));
emit SearchFinished(id, results);
return;
@ -174,9 +174,9 @@ void LastFmCoverProvider::QueryFinished(QNetworkReply *reply, const int id, cons
QJsonValue value_matches;
if (type == QStringLiteral("album")) {
if (obj_results.contains(QStringLiteral("albummatches"))) {
value_matches = obj_results[QStringLiteral("albummatches")];
if (type == QLatin1String("album")) {
if (obj_results.contains(QLatin1String("albummatches"))) {
value_matches = obj_results[QLatin1String("albummatches")];
}
else {
Error(QStringLiteral("Json results object is missing albummatches."), obj_results);
@ -184,9 +184,9 @@ void LastFmCoverProvider::QueryFinished(QNetworkReply *reply, const int id, cons
return;
}
}
else if (type == QStringLiteral("track")) {
if (obj_results.contains(QStringLiteral("trackmatches"))) {
value_matches = obj_results[QStringLiteral("trackmatches")];
else if (type == QLatin1String("track")) {
if (obj_results.contains(QLatin1String("trackmatches"))) {
value_matches = obj_results[QLatin1String("trackmatches")];
}
else {
Error(QStringLiteral("Json results object is missing trackmatches."), obj_results);
@ -230,17 +230,17 @@ void LastFmCoverProvider::QueryFinished(QNetworkReply *reply, const int id, cons
continue;
}
QJsonObject obj = value.toObject();
if (!obj.contains(QStringLiteral("artist")) || !obj.contains(QStringLiteral("image")) || !obj.contains(QStringLiteral("name"))) {
if (!obj.contains(QLatin1String("artist")) || !obj.contains(QLatin1String("image")) || !obj.contains(QLatin1String("name"))) {
Error(QStringLiteral("Invalid Json reply, album is missing artist, image or name."), obj);
continue;
}
QString artist = obj[QStringLiteral("artist")].toString();
QString artist = obj[QLatin1String("artist")].toString();
QString album;
if (type == QStringLiteral("album")) {
album = obj[QStringLiteral("name")].toString();
if (type == QLatin1String("album")) {
album = obj[QLatin1String("name")].toString();
}
QJsonValue json_image = obj[QStringLiteral("image")];
QJsonValue json_image = obj[QLatin1String("image")];
if (!json_image.isArray()) {
Error(QStringLiteral("Invalid Json reply, album image is not a array."), json_image);
continue;
@ -254,13 +254,13 @@ void LastFmCoverProvider::QueryFinished(QNetworkReply *reply, const int id, cons
continue;
}
QJsonObject obj_image = value_image.toObject();
if (!obj_image.contains(QStringLiteral("#text")) || !obj_image.contains(QStringLiteral("size"))) {
if (!obj_image.contains(QLatin1String("#text")) || !obj_image.contains(QLatin1String("size"))) {
Error(QStringLiteral("Invalid Json reply, album image value is missing #text or size."), obj_image);
continue;
}
QString image_url = obj_image[QStringLiteral("#text")].toString();
QString image_url = obj_image[QLatin1String("#text")].toString();
if (image_url.isEmpty()) continue;
LastFmImageSize image_size = ImageSizeFromString(obj_image[QStringLiteral("size")].toString().toLower());
LastFmImageSize image_size = ImageSizeFromString(obj_image[QLatin1String("size")].toString().toLower());
if (image_url_use.isEmpty() || image_size > image_size_use) {
image_url_use = image_url;
image_size_use = image_size;
@ -307,10 +307,10 @@ QByteArray LastFmCoverProvider::GetReplyData(QNetworkReply *reply) {
QJsonDocument json_doc = QJsonDocument::fromJson(data, &json_error);
if (json_error.error == QJsonParseError::NoError && !json_doc.isEmpty() && json_doc.isObject()) {
QJsonObject json_obj = json_doc.object();
if (json_obj.contains(QStringLiteral("error")) && json_obj.contains(QStringLiteral("message"))) {
int code = json_obj[QStringLiteral("error")].toInt();
QString message = json_obj[QStringLiteral("message")].toString();
error = QStringLiteral("Error: ") + QString::number(code) + QStringLiteral(": ") + message;
if (json_obj.contains(QLatin1String("error")) && json_obj.contains(QLatin1String("message"))) {
int code = json_obj[QLatin1String("error")].toInt();
QString message = json_obj[QLatin1String("message")].toString();
error = QLatin1String("Error: ") + QString::number(code) + QLatin1String(": ") + message;
}
}
if (error.isEmpty()) {
@ -339,10 +339,10 @@ void LastFmCoverProvider::Error(const QString &error, const QVariant &debug) {
LastFmCoverProvider::LastFmImageSize LastFmCoverProvider::ImageSizeFromString(const QString &size) {
if (size == QStringLiteral("small")) return LastFmImageSize::Small;
else if (size == QStringLiteral("medium")) return LastFmImageSize::Medium;
else if (size == QStringLiteral("large")) return LastFmImageSize::Large;
else if (size == QStringLiteral("extralarge")) return LastFmImageSize::ExtraLarge;
if (size == QLatin1String("small")) return LastFmImageSize::Small;
else if (size == QLatin1String("medium")) return LastFmImageSize::Medium;
else if (size == QLatin1String("large")) return LastFmImageSize::Large;
else if (size == QLatin1String("extralarge")) return LastFmImageSize::ExtraLarge;
else return LastFmImageSize::Unknown;
}

30
src/covermanager/musicbrainzcoverprovider.cpp
View File

@ -140,9 +140,9 @@ void MusicbrainzCoverProvider::HandleSearchReply(QNetworkReply *reply, const int
return;
}
if (!json_obj.contains(QStringLiteral("releases"))) {
if (json_obj.contains(QStringLiteral("error"))) {
QString error = json_obj[QStringLiteral("error")].toString();
if (!json_obj.contains(QLatin1String("releases"))) {
if (json_obj.contains(QLatin1String("error"))) {
QString error = json_obj[QLatin1String("error")].toString();
Error(error);
}
else {
@ -151,7 +151,7 @@ void MusicbrainzCoverProvider::HandleSearchReply(QNetworkReply *reply, const int
emit SearchFinished(search_id, results);
return;
}
QJsonValue value_releases = json_obj[QStringLiteral("releases")];
QJsonValue value_releases = json_obj[QLatin1String("releases")];
if (!value_releases.isArray()) {
Error(QStringLiteral("Json releases is not an array."), value_releases);
@ -172,12 +172,12 @@ void MusicbrainzCoverProvider::HandleSearchReply(QNetworkReply *reply, const int
continue;
}
QJsonObject obj_release = value_release.toObject();
if (!obj_release.contains(QStringLiteral("id")) || !obj_release.contains(QStringLiteral("artist-credit")) || !obj_release.contains(QStringLiteral("title"))) {
if (!obj_release.contains(QLatin1String("id")) || !obj_release.contains(QLatin1String("artist-credit")) || !obj_release.contains(QLatin1String("title"))) {
Error(QStringLiteral("Invalid Json reply, releases array object is missing id, artist-credit or title."), obj_release);
continue;
}
QJsonValue json_artists = obj_release[QStringLiteral("artist-credit")];
QJsonValue json_artists = obj_release[QLatin1String("artist-credit")];
if (!json_artists.isArray()) {
Error(QStringLiteral("Invalid Json reply, artist-credit is not a array."), json_artists);
continue;
@ -192,28 +192,28 @@ void MusicbrainzCoverProvider::HandleSearchReply(QNetworkReply *reply, const int
}
QJsonObject obj_artist = value_artist.toObject();
if (!obj_artist.contains(QStringLiteral("artist"))) {
if (!obj_artist.contains(QLatin1String("artist"))) {
Error(QStringLiteral("Invalid Json reply, artist is missing."), obj_artist);
continue;
}
QJsonValue value_artist2 = obj_artist[QStringLiteral("artist")];
QJsonValue value_artist2 = obj_artist[QLatin1String("artist")];
if (!value_artist2.isObject()) {
Error(QStringLiteral("Invalid Json reply, artist is not an object."), value_artist2);
continue;
}
QJsonObject obj_artist2 = value_artist2.toObject();
if (!obj_artist2.contains(QStringLiteral("name"))) {
if (!obj_artist2.contains(QLatin1String("name"))) {
Error(QStringLiteral("Invalid Json reply, artist is missing name."), value_artist2);
continue;
}
artist = obj_artist2[QStringLiteral("name")].toString();
artist = obj_artist2[QLatin1String("name")].toString();
++i;
}
if (i > 1) artist = QStringLiteral("Various artists");
if (i > 1) artist = QLatin1String("Various artists");
QString id = obj_release[QStringLiteral("id")].toString();
QString album = obj_release[QStringLiteral("title")].toString();
QString id = obj_release[QLatin1String("id")].toString();
QString album = obj_release[QLatin1String("title")].toString();
CoverProviderSearchResult cover_result;
QUrl url(QString::fromLatin1(kAlbumCoverUrl).arg(id));
@ -247,8 +247,8 @@ QByteArray MusicbrainzCoverProvider::GetReplyData(QNetworkReply *reply) {
QJsonDocument json_doc = QJsonDocument::fromJson(data, &json_error);
if (json_error.error == QJsonParseError::NoError && !json_doc.isEmpty() && json_doc.isObject()) {
QJsonObject json_obj = json_doc.object();
if (json_obj.contains(QStringLiteral("error"))) {
error = json_obj[QStringLiteral("error")].toString();
if (json_obj.contains(QLatin1String("error"))) {
error = json_obj[QLatin1String("error")].toString();
}
}
if (error.isEmpty()) {

32
src/covermanager/musixmatchcoverprovider.cpp
View File

@ -107,8 +107,8 @@ void MusixmatchCoverProvider::HandleSearchReply(QNetworkReply *reply, const int
return;
}
const QString content = QString::fromUtf8(data);
const QString data_begin = QStringLiteral("<script id=\"__NEXT_DATA__\" type=\"application/json\">");
const QString data_end = QStringLiteral("</script>");
const QString data_begin = QLatin1String("<script id=\"__NEXT_DATA__\" type=\"application/json\">");
const QString data_end = QLatin1String("</script>");
if (!content.contains(data_begin) || !content.contains(data_end)) {
emit SearchFinished(id, results);
return;
@ -161,47 +161,47 @@ void MusixmatchCoverProvider::HandleSearchReply(QNetworkReply *reply, const int
return;
}
if (!obj_data.contains(QStringLiteral("props")) || !obj_data[QStringLiteral("props")].isObject()) {
if (!obj_data.contains(QLatin1String("props")) || !obj_data[QLatin1String("props")].isObject()) {
Error(QStringLiteral("Json reply is missing props."), obj_data);
emit SearchFinished(id, results);
return;
}
obj_data = obj_data[QStringLiteral("props")].toObject();
obj_data = obj_data[QLatin1String("props")].toObject();
if (!obj_data.contains(QStringLiteral("pageProps")) || !obj_data[QStringLiteral("pageProps")].isObject()) {
if (!obj_data.contains(QLatin1String("pageProps")) || !obj_data[QLatin1String("pageProps")].isObject()) {
Error(QStringLiteral("Json props is missing pageProps."), obj_data);
emit SearchFinished(id, results);
return;
}
obj_data = obj_data[QStringLiteral("pageProps")].toObject();
obj_data = obj_data[QLatin1String("pageProps")].toObject();
if (!obj_data.contains(QStringLiteral("data")) || !obj_data[QStringLiteral("data")].isObject()) {
if (!obj_data.contains(QLatin1String("data")) || !obj_data[QLatin1String("data")].isObject()) {
Error(QStringLiteral("Json pageProps is missing data."), obj_data);
emit SearchFinished(id, results);
return;
}
obj_data = obj_data[QStringLiteral("data")].toObject();
obj_data = obj_data[QLatin1String("data")].toObject();
if (!obj_data.contains(QStringLiteral("albumGet")) || !obj_data[QStringLiteral("albumGet")].isObject()) {
if (!obj_data.contains(QLatin1String("albumGet")) || !obj_data[QLatin1String("albumGet")].isObject()) {
Error(QStringLiteral("Json data is missing albumGet."), obj_data);
emit SearchFinished(id, results);
return;
}
obj_data = obj_data[QStringLiteral("albumGet")].toObject();
obj_data = obj_data[QLatin1String("albumGet")].toObject();
if (!obj_data.contains(QStringLiteral("data")) || !obj_data[QStringLiteral("data")].isObject()) {
if (!obj_data.contains(QLatin1String("data")) || !obj_data[QLatin1String("data")].isObject()) {
Error(QStringLiteral("Json albumGet reply is missing data."), obj_data);
emit SearchFinished(id, results);
return;
}
obj_data = obj_data[QStringLiteral("data")].toObject();
obj_data = obj_data[QLatin1String("data")].toObject();
CoverProviderSearchResult result;
if (obj_data.contains(QStringLiteral("artistName")) && obj_data[QStringLiteral("artistName")].isString()) {
result.artist = obj_data[QStringLiteral("artistName")].toString();
if (obj_data.contains(QLatin1String("artistName")) && obj_data[QLatin1String("artistName")].isString()) {
result.artist = obj_data[QLatin1String("artistName")].toString();
}
if (obj_data.contains(QStringLiteral("name")) && obj_data[QStringLiteral("name")].isString()) {
result.album = obj_data[QStringLiteral("name")].toString();
if (obj_data.contains(QLatin1String("name")) && obj_data[QLatin1String("name")].isString()) {
result.album = obj_data[QLatin1String("name")].toString();
}
if (result.artist.compare(artist, Qt::CaseInsensitive) != 0 && result.album.compare(album, Qt::CaseInsensitive) != 0) {

66
src/covermanager/opentidalcoverprovider.cpp
View File

@ -193,21 +193,21 @@ void OpenTidalCoverProvider::LoginFinished(QNetworkReply *reply) {
return;
}
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()) {
if (!json_obj.contains(QLatin1String("access_token")) ||
!json_obj.contains(QLatin1String("token_type")) ||
!json_obj.contains(QLatin1String("expires_in")) ||
!json_obj[QLatin1String("access_token")].isString() ||
!json_obj[QLatin1String("token_type")].isString()) {
qLog(Error) << "OpenTidal: Invalid login reply.";
FinishAllSearches();
return;
}
have_login_ = true;
token_type_ = json_obj[QStringLiteral("token_type")].toString();
access_token_ = json_obj[QStringLiteral("access_token")].toString();
token_type_ = json_obj[QLatin1String("token_type")].toString();
access_token_ = json_obj[QLatin1String("access_token")].toString();
login_time_ = QDateTime::currentDateTime().toSecsSinceEpoch();
expires_in_ = json_obj[QStringLiteral("expires_in")].toInt();
expires_in_ = json_obj[QLatin1String("expires_in")].toInt();
Settings s;
s.beginGroup(kSettingsGroup);
@ -262,19 +262,19 @@ QJsonObject OpenTidalCoverProvider::GetJsonObject(QNetworkReply *reply) {
return QJsonObject();
}
QJsonObject json_obj = ExtractJsonObj(data);
if (json_obj.contains(QStringLiteral("errors")) && json_obj[QStringLiteral("errors")].isArray()) {
QJsonArray array = json_obj[QStringLiteral("errors")].toArray();
if (json_obj.contains(QLatin1String("errors")) && json_obj[QLatin1String("errors")].isArray()) {
QJsonArray array = json_obj[QLatin1String("errors")].toArray();
for (const QJsonValue &value : array) {
if (!value.isObject()) continue;
QJsonObject obj = value.toObject();
if (!obj.contains(QStringLiteral("category")) ||
!obj.contains(QStringLiteral("code")) ||
!obj.contains(QStringLiteral("detail"))) {
if (!obj.contains(QLatin1String("category")) ||
!obj.contains(QLatin1String("code")) ||
!obj.contains(QLatin1String("detail"))) {
continue;
}
QString category = obj[QStringLiteral("category")].toString();
QString code = obj[QStringLiteral("code")].toString();
QString detail = obj[QStringLiteral("detail")].toString();
QString category = obj[QLatin1String("category")].toString();
QString code = obj[QLatin1String("code")].toString();
QString detail = obj[QLatin1String("detail")].toString();
qLog(Error) << "OpenTidal:" << category << code << detail;
}
}
@ -306,7 +306,7 @@ void OpenTidalCoverProvider::SendSearchRequest(SearchRequestPtr search_request)
url_query.addQueryItem(QStringLiteral("query"), QString::fromUtf8(QUrl::toPercentEncoding(query)));
url_query.addQueryItem(QStringLiteral("limit"), QString::number(kLimit));
url_query.addQueryItem(QStringLiteral("countryCode"), QStringLiteral("US"));
QUrl url(QLatin1String(kApiUrl) + QStringLiteral("/search"));
QUrl url(QLatin1String(kApiUrl) + QLatin1String("/search"));
url.setQuery(url_query);
QNetworkRequest req(url);
req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
@ -332,13 +332,13 @@ void OpenTidalCoverProvider::HandleSearchReply(QNetworkReply *reply, SearchReque
return;
}
if (!json_obj.contains(QStringLiteral("albums")) || !json_obj[QStringLiteral("albums")].isArray()) {
if (!json_obj.contains(QLatin1String("albums")) || !json_obj[QLatin1String("albums")].isArray()) {
qLog(Debug) << "OpenTidal: Json object is missing albums.";
emit SearchFinished(search_request->id, CoverProviderSearchResults());
return;
}
QJsonArray array_albums = json_obj[QStringLiteral("albums")].toArray();
QJsonArray array_albums = json_obj[QLatin1String("albums")].toArray();
if (array_albums.isEmpty()) {
emit SearchFinished(search_request->id, CoverProviderSearchResults());
return;
@ -354,55 +354,55 @@ void OpenTidalCoverProvider::HandleSearchReply(QNetworkReply *reply, SearchReque
}
QJsonObject obj_album = value_album.toObject();
if (!obj_album.contains(QStringLiteral("resource")) || !obj_album[QStringLiteral("resource")].isObject()) {
if (!obj_album.contains(QLatin1String("resource")) || !obj_album[QLatin1String("resource")].isObject()) {
qLog(Debug) << "OpenTidal: Invalid Json reply: Albums array album is missing resource object.";
continue;
}
QJsonObject obj_resource = obj_album[QStringLiteral("resource")].toObject();
QJsonObject obj_resource = obj_album[QLatin1String("resource")].toObject();
if (!obj_resource.contains(QStringLiteral("artists")) || !obj_resource[QStringLiteral("artists")].isArray()) {
if (!obj_resource.contains(QLatin1String("artists")) || !obj_resource[QLatin1String("artists")].isArray()) {
qLog(Debug) << "OpenTidal: Invalid Json reply: Resource is missing artists array.";
continue;
}
if (!obj_resource.contains(QStringLiteral("title")) || !obj_resource[QStringLiteral("title")].isString()) {
if (!obj_resource.contains(QLatin1String("title")) || !obj_resource[QLatin1String("title")].isString()) {
qLog(Debug) << "OpenTidal: Invalid Json reply: Resource is missing title.";
continue;
}
if (!obj_resource.contains(QStringLiteral("imageCover")) || !obj_resource[QStringLiteral("imageCover")].isArray()) {
if (!obj_resource.contains(QLatin1String("imageCover")) || !obj_resource[QLatin1String("imageCover")].isArray()) {
qLog(Debug) << "OpenTidal: Invalid Json reply: Resource is missing imageCover array.";
continue;
}
QString artist;
const QString album = obj_resource[QStringLiteral("title")].toString();
const QString album = obj_resource[QLatin1String("title")].toString();
QJsonArray array_artists = obj_resource[QStringLiteral("artists")].toArray();
QJsonArray array_artists = obj_resource[QLatin1String("artists")].toArray();
for (const QJsonValueRef value_artist : array_artists) {
if (!value_artist.isObject()) {
continue;
}
QJsonObject obj_artist = value_artist.toObject();
if (!obj_artist.contains(QStringLiteral("name"))) {
if (!obj_artist.contains(QLatin1String("name"))) {
continue;
}
artist = obj_artist[QStringLiteral("name")].toString();
artist = obj_artist[QLatin1String("name")].toString();
break;
}
QJsonArray array_covers = obj_resource[QStringLiteral("imageCover")].toArray();
QJsonArray array_covers = obj_resource[QLatin1String("imageCover")].toArray();
for (const QJsonValueRef value_cover : array_covers) {
if (!value_cover.isObject()) {
continue;
}
QJsonObject obj_cover = value_cover.toObject();
if (!obj_cover.contains(QStringLiteral("url")) || !obj_cover.contains(QStringLiteral("width")) || !obj_cover.contains(QStringLiteral("height"))) {
if (!obj_cover.contains(QLatin1String("url")) || !obj_cover.contains(QLatin1String("width")) || !obj_cover.contains(QLatin1String("height"))) {
continue;
}
const QUrl url(obj_cover[QStringLiteral("url")].toString());
const int width = obj_cover[QStringLiteral("width")].toInt();
const int height = obj_cover[QStringLiteral("height")].toInt();
const QUrl url(obj_cover[QLatin1String("url")].toString());
const int width = obj_cover[QLatin1String("width")].toInt();
const int height = obj_cover[QLatin1String("height")].toInt();
if (!url.isValid()) continue;
if (width < 640 || height < 640) continue;
CoverProviderSearchResult cover_result;

44
src/covermanager/qobuzcoverprovider.cpp
View File

@ -72,12 +72,12 @@ bool QobuzCoverProvider::StartSearch(const QString &artist, const QString &album
QString resource;
QString query = artist;
if (album.isEmpty() && !title.isEmpty()) {
resource = QStringLiteral("track/search");
resource = QLatin1String("track/search");
if (!query.isEmpty()) query.append(QLatin1Char(' '));
query.append(title);
}
else {
resource = QStringLiteral("album/search");
resource = QLatin1String("album/search");
if (!album.isEmpty()) {
if (!query.isEmpty()) query.append(QLatin1Char(' '));
query.append(album);
@ -133,9 +133,9 @@ QByteArray QobuzCoverProvider::GetReplyData(QNetworkReply *reply) {
QJsonDocument json_doc = QJsonDocument::fromJson(data, &parse_error);
if (parse_error.error == QJsonParseError::NoError && !json_doc.isEmpty() && json_doc.isObject()) {
QJsonObject json_obj = json_doc.object();
if (!json_obj.isEmpty() && json_obj.contains(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();
if (!json_obj.isEmpty() && json_obj.contains(QLatin1String("status")) && json_obj.contains(QLatin1String("code")) && json_obj.contains(QLatin1String("message"))) {
int code = json_obj[QLatin1String("code")].toInt();
QString message = json_obj[QLatin1String("message")].toString();
error = QStringLiteral("%1 (%2)").arg(message).arg(code);
}
}
@ -178,11 +178,11 @@ void QobuzCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id) {
}
QJsonValue value_type;
if (json_obj.contains(QStringLiteral("albums"))) {
value_type = json_obj[QStringLiteral("albums")];
if (json_obj.contains(QLatin1String("albums"))) {
value_type = json_obj[QLatin1String("albums")];
}
else if (json_obj.contains(QStringLiteral("tracks"))) {
value_type = json_obj[QStringLiteral("tracks")];
else if (json_obj.contains(QLatin1String("tracks"))) {
value_type = json_obj[QLatin1String("tracks")];
}
else {
Error(QStringLiteral("Json reply is missing albums and tracks object."), json_obj);
@ -197,12 +197,12 @@ void QobuzCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id) {
}
QJsonObject obj_type = value_type.toObject();
if (!obj_type.contains(QStringLiteral("items"))) {
if (!obj_type.contains(QLatin1String("items"))) {
Error(QStringLiteral("Json albums or tracks object does not contain items."), obj_type);
emit SearchFinished(id, results);
return;
}
QJsonValue value_items = obj_type[QStringLiteral("items")];
QJsonValue value_items = obj_type[QLatin1String("items")];
if (!value_items.isArray()) {
Error(QStringLiteral("Json albums or track object items is not a array."), value_items);
@ -220,49 +220,49 @@ void QobuzCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id) {
QJsonObject item_obj = value.toObject();
QJsonObject obj_album;
if (item_obj.contains(QStringLiteral("album"))) {
if (!item_obj[QStringLiteral("album")].isObject()) {
if (item_obj.contains(QLatin1String("album"))) {
if (!item_obj[QLatin1String("album")].isObject()) {
Error(QStringLiteral("Invalid Json reply, items album is not a object."), item_obj);
continue;
}
obj_album = item_obj[QStringLiteral("album")].toObject();
obj_album = item_obj[QLatin1String("album")].toObject();
}
else {
obj_album = item_obj;
}
if (!obj_album.contains(QStringLiteral("artist")) || !obj_album.contains(QStringLiteral("image")) || !obj_album.contains(QStringLiteral("title"))) {
if (!obj_album.contains(QLatin1String("artist")) || !obj_album.contains(QLatin1String("image")) || !obj_album.contains(QLatin1String("title"))) {
Error(QStringLiteral("Invalid Json reply, item is missing artist, title or image."), obj_album);
continue;
}
QString album = obj_album[QStringLiteral("title")].toString();
QString album = obj_album[QLatin1String("title")].toString();
// Artist
QJsonValue value_artist = obj_album[QStringLiteral("artist")];
QJsonValue value_artist = obj_album[QLatin1String("artist")];
if (!value_artist.isObject()) {
Error(QStringLiteral("Invalid Json reply, items (album) artist is not a object."), value_artist);
continue;
}
QJsonObject obj_artist = value_artist.toObject();
if (!obj_artist.contains(QStringLiteral("name"))) {
if (!obj_artist.contains(QLatin1String("name"))) {
Error(QStringLiteral("Invalid Json reply, items (album) artist is missing name."), obj_artist);
continue;
}
QString artist = obj_artist[QStringLiteral("name")].toString();
QString artist = obj_artist[QLatin1String("name")].toString();
// Image
QJsonValue value_image = obj_album[QStringLiteral("image")];
QJsonValue value_image = obj_album[QLatin1String("image")];
if (!value_image.isObject()) {
Error(QStringLiteral("Invalid Json reply, items (album) image is not a object."), value_image);
continue;
}
QJsonObject obj_image = value_image.toObject();
if (!obj_image.contains(QStringLiteral("large"))) {
if (!obj_image.contains(QLatin1String("large"))) {
Error(QStringLiteral("Invalid Json reply, items (album) image is missing large."), obj_image);
continue;
}
QUrl cover_url(obj_image[QStringLiteral("large")].toString());
QUrl cover_url(obj_image[QLatin1String("large")].toString());
CoverProviderSearchResult cover_result;
cover_result.artist = artist;

62
src/covermanager/spotifycoverprovider.cpp
View File

@ -280,9 +280,9 @@ 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(QStringLiteral("error")) && json_obj.contains(QStringLiteral("error_description"))) {
QString error = json_obj[QStringLiteral("error")].toString();
QString error_description = json_obj[QStringLiteral("error_description")].toString();
if (!json_obj.isEmpty() && json_obj.contains(QLatin1String("error")) && json_obj.contains(QLatin1String("error_description"))) {
QString error = json_obj[QLatin1String("error")].toString();
QString error_description = json_obj[QLatin1String("error_description")].toString();
login_errors_ << QStringLiteral("Authentication failure: %1 (%2)").arg(error, error_description);
}
}
@ -325,16 +325,16 @@ void SpotifyCoverProvider::AccessTokenRequestFinished(QNetworkReply *reply) {
return;
}
if (!json_obj.contains(QStringLiteral("access_token")) || !json_obj.contains(QStringLiteral("expires_in"))) {
if (!json_obj.contains(QLatin1String("access_token")) || !json_obj.contains(QLatin1String("expires_in"))) {
AuthError(QStringLiteral("Authentication reply from server is missing access token or expires in."), json_obj);
return;
}
access_token_ = json_obj[QStringLiteral("access_token")].toString();
if (json_obj.contains(QStringLiteral("refresh_token"))) {
refresh_token_ = json_obj[QStringLiteral("refresh_token")].toString();
access_token_ = json_obj[QLatin1String("access_token")].toString();
if (json_obj.contains(QLatin1String("refresh_token"))) {
refresh_token_ = json_obj[QLatin1String("refresh_token")].toString();
}
expires_in_ = json_obj[QStringLiteral("expires_in")].toInt();
expires_in_ = json_obj[QLatin1String("expires_in")].toInt();
login_time_ = QDateTime::currentDateTime().toSecsSinceEpoch();
Settings s;
@ -367,14 +367,14 @@ bool SpotifyCoverProvider::StartSearch(const QString &artist, const QString &alb
QString extract;
QString query = artist;
if (album.isEmpty() && !title.isEmpty()) {
type = QStringLiteral("track");
extract = QStringLiteral("tracks");
type = QLatin1String("track");
extract = QLatin1String("tracks");
if (!query.isEmpty()) query.append(QLatin1Char(' '));
query.append(title);
}
else {
type = QStringLiteral("album");
extract = QStringLiteral("albums");
type = QLatin1String("album");
extract = QLatin1String("albums");
if (!album.isEmpty()) {
if (!query.isEmpty()) query.append(QLatin1Char(' '));
query.append(album);
@ -426,11 +426,11 @@ QByteArray SpotifyCoverProvider::GetReplyData(QNetworkReply *reply) {
QString error;
if (parse_error.error == QJsonParseError::NoError && !json_doc.isEmpty() && json_doc.isObject()) {
QJsonObject json_obj = json_doc.object();
if (!json_obj.isEmpty() && json_obj.contains(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();
if (!json_obj.isEmpty() && json_obj.contains(QLatin1String("error")) && json_obj[QLatin1String("error")].isObject()) {
QJsonObject obj_error = json_obj[QLatin1String("error")].toObject();
if (obj_error.contains(QLatin1String("status")) && obj_error.contains(QLatin1String("message"))) {
int status = obj_error[QLatin1String("status")].toInt();
QString message = obj_error[QLatin1String("message")].toString();
error = QStringLiteral("%1 (%2)").arg(message).arg(status);
if (status == 401) access_token_.clear();
}
@ -480,13 +480,13 @@ void SpotifyCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id,
}
json_obj = json_obj[extract].toObject();
if (!json_obj.contains(QStringLiteral("items")) || !json_obj[QStringLiteral("items")].isArray()) {
if (!json_obj.contains(QLatin1String("items")) || !json_obj[QLatin1String("items")].isArray()) {
Error(QStringLiteral("%1 object is missing items array.").arg(extract), json_obj);
emit SearchFinished(id, CoverProviderSearchResults());
return;
}
QJsonArray array_items = json_obj[QStringLiteral("items")].toArray();
QJsonArray array_items = json_obj[QLatin1String("items")].toArray();
if (array_items.isEmpty()) {
emit SearchFinished(id, CoverProviderSearchResults());
return;
@ -501,33 +501,33 @@ void SpotifyCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id,
QJsonObject obj_item = value_item.toObject();
QJsonObject obj_album = obj_item;
if (obj_item.contains(QStringLiteral("album")) && obj_item[QStringLiteral("album")].isObject()) {
obj_album = obj_item[QStringLiteral("album")].toObject();
if (obj_item.contains(QLatin1String("album")) && obj_item[QLatin1String("album")].isObject()) {
obj_album = obj_item[QLatin1String("album")].toObject();
}
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()) {
if (!obj_album.contains(QLatin1String("artists")) || !obj_album.contains(QLatin1String("name")) || !obj_album.contains(QLatin1String("images")) || !obj_album[QLatin1String("artists")].isArray() || !obj_album[QLatin1String("images")].isArray()) {
continue;
}
QJsonArray array_artists = obj_album[QStringLiteral("artists")].toArray();
QJsonArray array_images = obj_album[QStringLiteral("images")].toArray();
QString album = obj_album[QStringLiteral("name")].toString();
QJsonArray array_artists = obj_album[QLatin1String("artists")].toArray();
QJsonArray array_images = obj_album[QLatin1String("images")].toArray();
QString album = obj_album[QLatin1String("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(QStringLiteral("name"))) continue;
artists << obj_artist[QStringLiteral("name")].toString();
if (!obj_artist.contains(QLatin1String("name"))) continue;
artists << obj_artist[QLatin1String("name")].toString();
}
for (const QJsonValueRef value_image : array_images) {
if (!value_image.isObject()) continue;
QJsonObject obj_image = value_image.toObject();
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 (!obj_image.contains(QLatin1String("url")) || !obj_image.contains(QLatin1String("width")) || !obj_image.contains(QLatin1String("height"))) continue;
int width = obj_image[QLatin1String("width")].toInt();
int height = obj_image[QLatin1String("height")].toInt();
if (width < 300 || height < 300) continue;
QUrl url(obj_image[QStringLiteral("url")].toString());
QUrl url(obj_image[QLatin1String("url")].toString());
CoverProviderSearchResult result;
result.album = album;
result.image_url = url;

34
src/covermanager/tidalcoverprovider.cpp
View File

@ -73,12 +73,12 @@ bool TidalCoverProvider::StartSearch(const QString &artist, const QString &album
QString resource;
QString query = artist;
if (album.isEmpty() && !title.isEmpty()) {
resource = QStringLiteral("search/tracks");
resource = QLatin1String("search/tracks");
if (!query.isEmpty()) query.append(QLatin1Char(' '));
query.append(title);
}
else {
resource = QStringLiteral("search/albums");
resource = QLatin1String("search/albums");
if (!album.isEmpty()) {
if (!query.isEmpty()) query.append(QLatin1Char(' '));
query.append(album);
@ -134,10 +134,10 @@ QByteArray TidalCoverProvider::GetReplyData(QNetworkReply *reply) {
QString error;
if (parse_error.error == QJsonParseError::NoError && !json_doc.isEmpty() && json_doc.isObject()) {
QJsonObject json_obj = json_doc.object();
if (!json_obj.isEmpty() && json_obj.contains(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();
if (!json_obj.isEmpty() && json_obj.contains(QLatin1String("status")) && json_obj.contains(QLatin1String("userMessage"))) {
status = json_obj[QLatin1String("status")].toInt();
sub_status = json_obj[QLatin1String("subStatus")].toInt();
QString user_message = json_obj[QLatin1String("userMessage")].toString();
error = QStringLiteral("%1 (%2) (%3)").arg(user_message).arg(status).arg(sub_status);
}
}
@ -180,12 +180,12 @@ void TidalCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id) {
return;
}
if (!json_obj.contains(QStringLiteral("items"))) {
if (!json_obj.contains(QLatin1String("items"))) {
Error(QStringLiteral("Json object is missing items."), json_obj);
emit SearchFinished(id, CoverProviderSearchResults());
return;
}
QJsonValue value_items = json_obj[QStringLiteral("items")];
QJsonValue value_items = json_obj[QLatin1String("items")];
if (!value_items.isArray()) {
emit SearchFinished(id, CoverProviderSearchResults());
@ -207,25 +207,25 @@ void TidalCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id) {
}
QJsonObject obj_item = value_item.toObject();
if (!obj_item.contains(QStringLiteral("artist"))) {
if (!obj_item.contains(QLatin1String("artist"))) {
Error(QStringLiteral("Invalid Json reply, items array item is missing artist."), obj_item);
continue;
}
QJsonValue value_artist = obj_item[QStringLiteral("artist")];
QJsonValue value_artist = obj_item[QLatin1String("artist")];
if (!value_artist.isObject()) {
Error(QStringLiteral("Invalid Json reply, items array item artist is not a object."), value_artist);
continue;
}
QJsonObject obj_artist = value_artist.toObject();
if (!obj_artist.contains(QStringLiteral("name"))) {
if (!obj_artist.contains(QLatin1String("name"))) {
Error(QStringLiteral("Invalid Json reply, items array item artist is missing name."), obj_artist);
continue;
}
QString artist = obj_artist[QStringLiteral("name")].toString();
QString artist = obj_artist[QLatin1String("name")].toString();
QJsonObject obj_album;
if (obj_item.contains(QStringLiteral("album"))) {
QJsonValue value_album = obj_item[QStringLiteral("album")];
if (obj_item.contains(QLatin1String("album"))) {
QJsonValue value_album = obj_item[QLatin1String("album")];
if (value_album.isObject()) {
obj_album = value_album.toObject();
}
@ -238,12 +238,12 @@ void TidalCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id) {
obj_album = obj_item;
}
if (!obj_album.contains(QStringLiteral("title")) || !obj_album.contains(QStringLiteral("cover"))) {
if (!obj_album.contains(QLatin1String("title")) || !obj_album.contains(QLatin1String("cover"))) {
Error(QStringLiteral("Invalid Json reply, items array item album is missing title or cover."), obj_album);
continue;
}
QString album = obj_album[QStringLiteral("title")].toString();
QString cover = obj_album[QStringLiteral("cover")].toString().replace(QLatin1String("-"), QLatin1String("/"));
QString album = obj_album[QLatin1String("title")].toString();
QString cover = obj_album[QLatin1String("cover")].toString().replace(QLatin1String("-"), QLatin1String("/"));
CoverProviderSearchResult cover_result;
cover_result.artist = artist;

2
src/device/deviceinfo.cpp
View File

@ -49,7 +49,7 @@ DeviceDatabaseBackend::Device DeviceInfo::SaveToDb() const {
for (const Backend &backend : backends_) {
unique_ids << backend.unique_id_;
}
ret.unique_id_ = unique_ids.join(QStringLiteral(","));
ret.unique_id_ = unique_ids.join(QLatin1Char(','));
return ret;

2
src/device/devicemanager.cpp
View File

@ -629,7 +629,7 @@ SharedPtr<ConnectedDevice> DeviceManager::Connect(DeviceInfo *info) {
url_strings << url.toString();
}
app_->AddError(tr("This type of device is not supported: %1").arg(url_strings.join(QStringLiteral(", "))));
app_->AddError(tr("This type of device is not supported: %1").arg(url_strings.join(QLatin1String(", "))));
return ret;
}

2
src/device/udisks2lister.cpp
View File

@ -122,7 +122,7 @@ QVariantMap Udisks2Lister::DeviceHardwareInfo(const QString &id) {
const PartitionData &data = device_data_[id];
result[QStringLiteral(QT_TR_NOOP("D-Bus path"))] = data.dbus_path;
result[QStringLiteral(QT_TR_NOOP("Serial number"))] = data.serial;
result[QStringLiteral(QT_TR_NOOP("Mount points"))] = data.mount_paths.join(QStringLiteral(", "));
result[QStringLiteral(QT_TR_NOOP("Mount points"))] = data.mount_paths.join(QLatin1String(", "));
result[QStringLiteral(QT_TR_NOOP("Partition label"))] = data.label;
result[QStringLiteral(QT_TR_NOOP("UUID"))] = data.uuid;

64
src/dialogs/about.cpp
View File

@ -103,31 +103,31 @@ QString About::MainHtml() const {
QString ret;
ret += QStringLiteral("<p>");
ret += QLatin1String("<p>");
ret += tr("Version %1").arg(QCoreApplication::applicationVersion());
ret += QStringLiteral("</p>");
ret += QLatin1String("</p>");
ret += QStringLiteral("<p>");
ret += QLatin1String("<p>");
ret += tr("Strawberry is a music player and music collection organizer.");
ret += QStringLiteral("<br />");
ret += QLatin1String("<br />");
ret += tr("It is a fork of Clementine released in 2018 aimed at music collectors and audiophiles.");
ret += QStringLiteral("</p>");
ret += QLatin1String("</p>");
ret += QStringLiteral("<p>");
ret += tr("Strawberry is free software released under GPL. The source code is available on %1").arg(QStringLiteral("<a style=\"color:%1;\" href=\"https://github.com/strawberrymusicplayer/strawberry\">GitHub</a>.").arg(palette().text().color().name()));
ret += QStringLiteral("<br />");
ret += tr("You should have received a copy of the GNU General Public License along with this program. If not, see %1").arg(QStringLiteral("<a style=\"color:%1;\" href=\"http://www.gnu.org/licenses/\">http://www.gnu.org/licenses/</a>").arg(palette().text().color().name()));
ret += QStringLiteral("</p>");
ret += QLatin1String("<p>");
ret += tr("Strawberry is free software released under GPL. The source code is available on %1").arg(QLatin1String("<a style=\"color:%1;\" href=\"https://github.com/strawberrymusicplayer/strawberry\">GitHub</a>.").arg(palette().text().color().name()));
ret += QLatin1String("<br />");
ret += tr("You should have received a copy of the GNU General Public License along with this program. If not, see %1").arg(QLatin1String("<a style=\"color:%1;\" href=\"http://www.gnu.org/licenses/\">http://www.gnu.org/licenses/</a>").arg(palette().text().color().name()));
ret += QLatin1String("</p>");
ret += QStringLiteral("<p>");
ret += QLatin1String("<p>");
ret += tr("If you like Strawberry and can make use of it, consider sponsoring or donating.");
ret += QStringLiteral("<br />");
ret += QLatin1String("<br />");
ret += tr("You can sponsor the author on %1. You can also make a one-time payment through %2.").arg(
QStringLiteral("<a style=\"color:%1;\" href=\"https://github.com/sponsors/jonaski\">GitHub sponsors</a>").arg(palette().text().color().name()),
QStringLiteral("<a style=\"color:%1;\" href=\"https://paypal.me/jonaskvinge\">paypal.me/jonaskvinge</a>").arg(palette().text().color().name())
QLatin1String("<a style=\"color:%1;\" href=\"https://github.com/sponsors/jonaski\">GitHub sponsors</a>").arg(palette().text().color().name()),
QLatin1String("<a style=\"color:%1;\" href=\"https://paypal.me/jonaskvinge\">paypal.me/jonaskvinge</a>").arg(palette().text().color().name())
);
ret += QStringLiteral("</p>");
ret += QLatin1String("</p>");
return ret;
@ -137,54 +137,54 @@ QString About::ContributorsHtml() const {
QString ret;
ret += QStringLiteral("<p>");
ret += QLatin1String("<p>");
ret += QLatin1String("<b>");
ret += tr("Author and maintainer");
ret += QLatin1String("</b>");
for (const Person &person : strawberry_authors_) {
ret += QStringLiteral("<br />") + PersonToHtml(person);
ret += QLatin1String("<br />") + PersonToHtml(person);
}
ret += QStringLiteral("</p>");
ret += QLatin1String("</p>");
ret += QStringLiteral("<p>");
ret += QLatin1String("<p>");
ret += QLatin1String("<b>");
ret += tr("Contributors");
ret += QLatin1String("</b>");
for (const Person &person : strawberry_contributors_) {
ret += QStringLiteral("<br />") + PersonToHtml(person);
ret += QLatin1String("<br />") + PersonToHtml(person);
}
ret += QStringLiteral("</p>");
ret += QLatin1String("</p>");
ret += QStringLiteral("<p>");
ret += QLatin1String("<p>");
ret += QLatin1String("<b>");
ret += tr("Clementine authors");
ret += QLatin1String("</b>");
for (const Person &person : clementine_authors_) {
ret += QStringLiteral("<br />") + PersonToHtml(person);
ret += QLatin1String("<br />") + PersonToHtml(person);
}
ret += QStringLiteral("</p>");
ret += QLatin1String("</p>");
ret += QStringLiteral("<p>");
ret += QLatin1String("<p>");
ret += QLatin1String("<b>");
ret += tr("Clementine contributors");
ret += QLatin1String("</b>");
for (const Person &person : clementine_contributors_) {
ret += QStringLiteral("<br />") + PersonToHtml(person);
ret += QLatin1String("<br />") + PersonToHtml(person);
}
ret += QStringLiteral("</p>");
ret += QLatin1String("</p>");
ret += QStringLiteral("<p>");
ret += QLatin1String("<p>");
ret += QLatin1String("<b>");
ret += tr("Thanks to");
ret += QLatin1String("</b>");
for (const Person &person : strawberry_thanks_) {
ret += QStringLiteral("<br />") + PersonToHtml(person);
ret += QLatin1String("<br />") + PersonToHtml(person);
}
ret += QStringLiteral("</p>");
ret += QLatin1String("</p>");
ret += QStringLiteral("<p>");
ret += QLatin1String("<p>");
ret += tr("Thanks to all the other Amarok and Clementine contributors.");
ret += QStringLiteral("</p>");
ret += QLatin1String("</p>");
return ret;
}

2
src/dialogs/console.cpp
View File

@ -79,7 +79,7 @@ void Console::RunQuery() {
values.append(record.value(i).toString());
}
ui_.output->append(values.join(QStringLiteral("|")));
ui_.output->append(values.join(QLatin1Char('|')));
}

62
src/dialogs/edittagdialog.cpp
View File

@ -478,21 +478,21 @@ void EditTagDialog::SetSongListVisibility(bool visible) {
QVariant EditTagDialog::Data::value(const Song &song, const QString &id) {
if (id == QStringLiteral("title")) return song.title();
if (id == QStringLiteral("artist")) return song.artist();
if (id == QStringLiteral("album")) return song.album();
if (id == QStringLiteral("albumartist")) return song.albumartist();
if (id == QStringLiteral("composer")) return song.composer();
if (id == QStringLiteral("performer")) return song.performer();
if (id == QStringLiteral("grouping")) return song.grouping();
if (id == QStringLiteral("genre")) return song.genre();
if (id == QStringLiteral("comment")) return song.comment();
if (id == QStringLiteral("lyrics")) return song.lyrics();
if (id == QStringLiteral("track")) return song.track();
if (id == QStringLiteral("disc")) return song.disc();
if (id == QStringLiteral("year")) return song.year();
if (id == QStringLiteral("compilation")) return song.compilation();
if (id == QStringLiteral("rating")) { return song.rating(); }
if (id == QLatin1String("title")) return song.title();
if (id == QLatin1String("artist")) return song.artist();
if (id == QLatin1String("album")) return song.album();
if (id == QLatin1String("albumartist")) return song.albumartist();
if (id == QLatin1String("composer")) return song.composer();
if (id == QLatin1String("performer")) return song.performer();
if (id == QLatin1String("grouping")) return song.grouping();
if (id == QLatin1String("genre")) return song.genre();
if (id == QLatin1String("comment")) return song.comment();
if (id == QLatin1String("lyrics")) return song.lyrics();
if (id == QLatin1String("track")) return song.track();
if (id == QLatin1String("disc")) return song.disc();
if (id == QLatin1String("year")) return song.year();
if (id == QLatin1String("compilation")) return song.compilation();
if (id == QLatin1String("rating")) { return song.rating(); }
qLog(Warning) << "Unknown ID" << id;
return QVariant();
@ -500,21 +500,21 @@ QVariant EditTagDialog::Data::value(const Song &song, const QString &id) {
void EditTagDialog::Data::set_value(const QString &id, const QVariant &value) {
if (id == QStringLiteral("title")) current_.set_title(value.toString());
else if (id == QStringLiteral("artist")) current_.set_artist(value.toString());
else if (id == QStringLiteral("album")) current_.set_album(value.toString());
else if (id == QStringLiteral("albumartist")) current_.set_albumartist(value.toString());
else if (id == QStringLiteral("composer")) current_.set_composer(value.toString());
else if (id == QStringLiteral("performer")) current_.set_performer(value.toString());
else if (id == QStringLiteral("grouping")) current_.set_grouping(value.toString());
else if (id == QStringLiteral("genre")) current_.set_genre(value.toString());
else if (id == QStringLiteral("comment")) current_.set_comment(value.toString());
else if (id == QStringLiteral("lyrics")) current_.set_lyrics(value.toString());
else if (id == QStringLiteral("track")) current_.set_track(value.toInt());
else if (id == QStringLiteral("disc")) current_.set_disc(value.toInt());
else if (id == QStringLiteral("year")) current_.set_year(value.toInt());
else if (id == QStringLiteral("compilation")) current_.set_compilation(value.toBool());
else if (id == QStringLiteral("rating")) { current_.set_rating(value.toFloat()); }
if (id == QLatin1String("title")) current_.set_title(value.toString());
else if (id == QLatin1String("artist")) current_.set_artist(value.toString());
else if (id == QLatin1String("album")) current_.set_album(value.toString());
else if (id == QLatin1String("albumartist")) current_.set_albumartist(value.toString());
else if (id == QLatin1String("composer")) current_.set_composer(value.toString());
else if (id == QLatin1String("performer")) current_.set_performer(value.toString());
else if (id == QLatin1String("grouping")) current_.set_grouping(value.toString());
else if (id == QLatin1String("genre")) current_.set_genre(value.toString());
else if (id == QLatin1String("comment")) current_.set_comment(value.toString());
else if (id == QLatin1String("lyrics")) current_.set_lyrics(value.toString());
else if (id == QLatin1String("track")) current_.set_track(value.toInt());
else if (id == QLatin1String("disc")) current_.set_disc(value.toInt());
else if (id == QLatin1String("year")) current_.set_year(value.toInt());
else if (id == QLatin1String("compilation")) current_.set_compilation(value.toBool());
else if (id == QLatin1String("rating")) { current_.set_rating(value.toFloat()); }
else qLog(Warning) << "Unknown ID" << id;
}
@ -693,7 +693,7 @@ void EditTagDialog::SelectionChanged() {
QString summary;
if (indexes.count() == 1) {
summary += QStringLiteral("<p><b>") + first_song.PrettyTitleWithArtist().toHtmlEscaped() + QStringLiteral("</b></p>");
summary += QLatin1String("<p><b>") + first_song.PrettyTitleWithArtist().toHtmlEscaped() + QLatin1String("</b></p>");
}
else {
summary += QLatin1String("<p><b>");

2
src/engine/enginebase.cpp
View File

@ -205,7 +205,7 @@ void EngineBase::ReloadSettings() {
if (http2_enabled != http2_enabled_) {
http2_enabled_ = http2_enabled;
Utilities::SetEnv("SOUP_FORCE_HTTP1", http2_enabled_ ? QLatin1String("") : QStringLiteral("1"));
qLog(Debug) << "SOUP_FORCE_HTTP1:" << (http2_enabled_ ? QLatin1String("OFF") : QLatin1String("ON"));
qLog(Debug) << "SOUP_FORCE_HTTP1:" << (http2_enabled_ ? "OFF" : "ON");
}
strict_ssl_enabled_ = s.value("strict_ssl", false).toBool();

2
src/engine/gstengine.cpp
View File

@ -739,7 +739,7 @@ QByteArray GstEngine::FixupUrl(const QUrl &url) {
// We keep the device in mind, and we will set it later using SourceSetupCallback
QStringList path = url.path().split(QLatin1Char('/'));
str = QStringLiteral("cdda://%1").arg(path.takeLast());
QString device = path.join(QStringLiteral("/"));
QString device = path.join(QLatin1Char('/'));
if (current_pipeline_) current_pipeline_->SetSourceDevice(device);
}
uri = str.toUtf8();

2
src/lyrics/azlyricscomlyricsprovider.cpp
View File

@ -40,7 +40,7 @@ AzLyricsComLyricsProvider::AzLyricsComLyricsProvider(SharedPtr<NetworkAccessMana
QUrl AzLyricsComLyricsProvider::Url(const LyricsSearchRequest &request) {
return QUrl(QLatin1String(kUrl) + StringFixup(request.artist) + QStringLiteral("/") + StringFixup(request.title) + QStringLiteral(".html"));
return QUrl(QLatin1String(kUrl) + StringFixup(request.artist) + QLatin1Char('/') + StringFixup(request.title) + QStringLiteral(".html"));
}

10
src/lyrics/chartlyricsprovider.cpp
View File

@ -101,21 +101,21 @@ void ChartLyricsProvider::HandleSearchReply(QNetworkReply *reply, const int id,
QXmlStreamReader::TokenType type = reader.readNext();
QString name = reader.name().toString();
if (type == QXmlStreamReader::StartElement) {
if (name == QStringLiteral("GetLyricResult")) {
if (name == QLatin1String("GetLyricResult")) {
result = LyricsSearchResult();
}
if (name == QStringLiteral("LyricArtist")) {
if (name == QLatin1String("LyricArtist")) {
result.artist = reader.readElementText();
}
else if (name == QStringLiteral("LyricSong")) {
else if (name == QLatin1String("LyricSong")) {
result.title = reader.readElementText();
}
else if (name == QStringLiteral("Lyric")) {
else if (name == QLatin1String("Lyric")) {
result.lyrics = reader.readElementText();
}
}
else if (type == QXmlStreamReader::EndElement) {
if (name == QStringLiteral("GetLyricResult")) {
if (name == QLatin1String("GetLyricResult")) {
if (!result.artist.isEmpty() && !result.title.isEmpty() && !result.lyrics.isEmpty() &&
(result.artist.compare(request.albumartist, Qt::CaseInsensitive) == 0 ||
result.artist.compare(request.artist, Qt::CaseInsensitive) == 0 ||

2
src/lyrics/elyricsnetlyricsprovider.cpp
View File

@ -40,7 +40,7 @@ ElyricsNetLyricsProvider::ElyricsNetLyricsProvider(SharedPtr<NetworkAccessManage
QUrl ElyricsNetLyricsProvider::Url(const LyricsSearchRequest &request) {
return QUrl(QLatin1String(kUrl) + request.artist[0].toLower() + QLatin1Char('/') + StringFixup(request.artist) + QStringLiteral("-lyrics/") + StringFixup(request.title) + QStringLiteral("-lyrics.html"));
return QUrl(QLatin1String(kUrl) + request.artist[0].toLower() + QLatin1Char('/') + StringFixup(request.artist) + QLatin1String("-lyrics/") + StringFixup(request.title) + QLatin1String("-lyrics.html"));
}

54
src/lyrics/geniuslyricsprovider.cpp
View File

@ -226,9 +226,9 @@ void GeniusLyricsProvider::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(QStringLiteral("error")) && json_obj.contains(QStringLiteral("error_description"))) {
QString error = json_obj[QStringLiteral("error")].toString();
QString error_description = json_obj[QStringLiteral("error_description")].toString();
if (!json_obj.isEmpty() && json_obj.contains(QLatin1String("error")) && json_obj.contains(QLatin1String("error_description"))) {
QString error = json_obj[QLatin1String("error")].toString();
QString error_description = json_obj[QLatin1String("error_description")].toString();
login_errors_ << QStringLiteral("Authentication failure: %1 (%2)").arg(error, error_description);
}
}
@ -271,12 +271,12 @@ void GeniusLyricsProvider::AccessTokenRequestFinished(QNetworkReply *reply) {
return;
}
if (!json_obj.contains(QStringLiteral("access_token"))) {
if (!json_obj.contains(QLatin1String("access_token"))) {
AuthError(QStringLiteral("Authentication reply from server is missing access token."), json_obj);
return;
}
access_token_ = json_obj[QStringLiteral("access_token")].toString();
access_token_ = json_obj[QLatin1String("access_token")].toString();
Settings s;
s.beginGroup(kSettingsGroup);
@ -333,26 +333,26 @@ void GeniusLyricsProvider::HandleSearchReply(QNetworkReply *reply, const int id)
return;
}
if (!json_obj.contains(QStringLiteral("meta"))) {
if (!json_obj.contains(QLatin1String("meta"))) {
Error(QStringLiteral("Json reply is missing meta object."), json_obj);
EndSearch(search);
return;
}
if (!json_obj[QStringLiteral("meta")].isObject()) {
if (!json_obj[QLatin1String("meta")].isObject()) {
Error(QStringLiteral("Json reply meta is not an object."), json_obj);
EndSearch(search);
return;
}
QJsonObject obj_meta = json_obj[QStringLiteral("meta")].toObject();
if (!obj_meta.contains(QStringLiteral("status"))) {
QJsonObject obj_meta = json_obj[QLatin1String("meta")].toObject();
if (!obj_meta.contains(QLatin1String("status"))) {
Error(QStringLiteral("Json reply meta object is missing status."), obj_meta);
EndSearch(search);
return;
}
int status = obj_meta[QStringLiteral("status")].toInt();
int status = obj_meta[QLatin1String("status")].toInt();
if (status != 200) {
if (obj_meta.contains(QStringLiteral("message"))) {
Error(QStringLiteral("Received error %1: %2.").arg(status).arg(obj_meta[QStringLiteral("message")].toString()));
if (obj_meta.contains(QLatin1String("message"))) {
Error(QStringLiteral("Received error %1: %2.").arg(status).arg(obj_meta[QLatin1String("message")].toString()));
}
else {
Error(QStringLiteral("Received error %1.").arg(status));
@ -361,50 +361,50 @@ void GeniusLyricsProvider::HandleSearchReply(QNetworkReply *reply, const int id)
return;
}
if (!json_obj.contains(QStringLiteral("response"))) {
if (!json_obj.contains(QLatin1String("response"))) {
Error(QStringLiteral("Json reply is missing response."), json_obj);
EndSearch(search);
return;
}
if (!json_obj[QStringLiteral("response")].isObject()) {
if (!json_obj[QLatin1String("response")].isObject()) {
Error(QStringLiteral("Json response is not an object."), json_obj);
EndSearch(search);
return;
}
QJsonObject obj_response = json_obj[QStringLiteral("response")].toObject();
if (!obj_response.contains(QStringLiteral("hits"))) {
QJsonObject obj_response = json_obj[QLatin1String("response")].toObject();
if (!obj_response.contains(QLatin1String("hits"))) {
Error(QStringLiteral("Json response is missing hits."), obj_response);
EndSearch(search);
return;
}
if (!obj_response[QStringLiteral("hits")].isArray()) {
if (!obj_response[QLatin1String("hits")].isArray()) {
Error(QStringLiteral("Json hits is not an array."), obj_response);
EndSearch(search);
return;
}
QJsonArray array_hits = obj_response[QStringLiteral("hits")].toArray();
QJsonArray array_hits = obj_response[QLatin1String("hits")].toArray();
for (const QJsonValueRef value_hit : array_hits) {
if (!value_hit.isObject()) {
continue;
}
QJsonObject obj_hit = value_hit.toObject();
if (!obj_hit.contains(QStringLiteral("result"))) {
if (!obj_hit.contains(QLatin1String("result"))) {
continue;
}
if (!obj_hit[QStringLiteral("result")].isObject()) {
if (!obj_hit[QLatin1String("result")].isObject()) {
continue;
}
QJsonObject obj_result = obj_hit[QStringLiteral("result")].toObject();
if (!obj_result.contains(QStringLiteral("title")) || !obj_result.contains(QStringLiteral("primary_artist")) || !obj_result.contains(QStringLiteral("url")) || !obj_result[QStringLiteral("primary_artist")].isObject()) {
QJsonObject obj_result = obj_hit[QLatin1String("result")].toObject();
if (!obj_result.contains(QLatin1String("title")) || !obj_result.contains(QLatin1String("primary_artist")) || !obj_result.contains(QLatin1String("url")) || !obj_result[QLatin1String("primary_artist")].isObject()) {
Error(QStringLiteral("Missing one or more values in result object"), obj_result);
continue;
}
QJsonObject primary_artist = obj_result[QStringLiteral("primary_artist")].toObject();
if (!primary_artist.contains(QStringLiteral("name"))) continue;
QJsonObject primary_artist = obj_result[QLatin1String("primary_artist")].toObject();
if (!primary_artist.contains(QLatin1String("name"))) continue;
QString artist = primary_artist[QStringLiteral("name")].toString();
QString title = obj_result[QStringLiteral("title")].toString();
QString artist = primary_artist[QLatin1String("name")].toString();
QString title = obj_result[QLatin1String("title")].toString();
// Ignore results where both the artist and title don't match.
if (!artist.startsWith(search->request.albumartist, Qt::CaseInsensitive) &&
@ -413,7 +413,7 @@ void GeniusLyricsProvider::HandleSearchReply(QNetworkReply *reply, const int id)
continue;
}
QUrl url(obj_result[QStringLiteral("url")].toString());
QUrl url(obj_result[QLatin1String("url")].toString());
if (!url.isValid()) continue;
if (search->requests_lyric_.contains(url)) continue;

2
src/lyrics/letraslyricsprovider.cpp
View File

@ -41,7 +41,7 @@ LetrasLyricsProvider::LetrasLyricsProvider(SharedPtr<NetworkAccessManager> netwo
QUrl LetrasLyricsProvider::Url(const LyricsSearchRequest &request) {
return QUrl(QLatin1String(kUrl) + QStringLiteral("?musica=") + StringFixup(request.artist) + QStringLiteral("&artista=") + StringFixup(request.title));
return QUrl(QLatin1String(kUrl) + QLatin1String("?musica=") + StringFixup(request.artist) + QLatin1String("&artista=") + StringFixup(request.title));
}

10
src/lyrics/lololyricsprovider.cpp
View File

@ -105,15 +105,15 @@ void LoloLyricsProvider::HandleSearchReply(QNetworkReply *reply, const int id, c
QXmlStreamReader::TokenType type = reader.readNext();
QString name = reader.name().toString();
if (type == QXmlStreamReader::StartElement) {
if (name == QStringLiteral("result")) {
if (name == QLatin1String("result")) {
status.clear();
result = LyricsSearchResult();
}
else if (name == QStringLiteral("status")) {
else if (name == QLatin1String("status")) {
status = reader.readElementText();
}
else if (name == QStringLiteral("response")) {
if (status == QStringLiteral("OK")) {
else if (name == QLatin1String("response")) {
if (status == QLatin1String("OK")) {
result.lyrics = reader.readElementText();
}
else {
@ -123,7 +123,7 @@ void LoloLyricsProvider::HandleSearchReply(QNetworkReply *reply, const int id, c
}
}
else if (type == QXmlStreamReader::EndElement) {
if (name == QStringLiteral("result")) {
if (name == QLatin1String("result")) {
if (!result.lyrics.isEmpty()) {
result.lyrics = Utilities::DecodeHtmlEntities(result.lyrics);
results << result;

98
src/lyrics/musixmatchlyricsprovider.cpp
View File

@ -136,31 +136,31 @@ void MusixmatchLyricsProvider::HandleSearchReply(QNetworkReply *reply, LyricsSea
return;
}
if (!json_obj.contains(QStringLiteral("message"))) {
if (!json_obj.contains(QLatin1String("message"))) {
Error(QStringLiteral("Json reply is missing message object."), json_obj);
EndSearch(search);
return;
}
if (!json_obj[QStringLiteral("message")].isObject()) {
if (!json_obj[QLatin1String("message")].isObject()) {
Error(QStringLiteral("Json reply message is not an object."), json_obj);
EndSearch(search);
return;
}
QJsonObject obj_message = json_obj[QStringLiteral("message")].toObject();
QJsonObject obj_message = json_obj[QLatin1String("message")].toObject();
if (!obj_message.contains(QStringLiteral("header"))) {
if (!obj_message.contains(QLatin1String("header"))) {
Error(QStringLiteral("Json reply message object is missing header."), obj_message);
EndSearch(search);
return;
}
if (!obj_message[QStringLiteral("header")].isObject()) {
if (!obj_message[QLatin1String("header")].isObject()) {
Error(QStringLiteral("Json reply message header is not an object."), obj_message);
EndSearch(search);
return;
}
QJsonObject obj_header = obj_message[QStringLiteral("header")].toObject();
QJsonObject obj_header = obj_message[QLatin1String("header")].toObject();
int status_code = obj_header[QStringLiteral("status_code")].toInt();
int status_code = obj_header[QLatin1String("status_code")].toInt();
if (status_code != 200) {
Error(QStringLiteral("Received status code %1, switching to URL based lookup.").arg(status_code));
use_api_ = false;
@ -168,29 +168,29 @@ void MusixmatchLyricsProvider::HandleSearchReply(QNetworkReply *reply, LyricsSea
return;
}
if (!obj_message.contains(QStringLiteral("body"))) {
if (!obj_message.contains(QLatin1String("body"))) {
Error(QStringLiteral("Json reply is missing body."), json_obj);
EndSearch(search);
return;
}
if (!obj_message[QStringLiteral("body")].isObject()) {
if (!obj_message[QLatin1String("body")].isObject()) {
Error(QStringLiteral("Json body is not an object."), json_obj);
EndSearch(search);
return;
}
QJsonObject obj_body = obj_message[QStringLiteral("body")].toObject();
QJsonObject obj_body = obj_message[QLatin1String("body")].toObject();
if (!obj_body.contains(QStringLiteral("track_list"))) {
if (!obj_body.contains(QLatin1String("track_list"))) {
Error(QStringLiteral("Json response is missing body."), obj_body);
EndSearch(search);
return;
}
if (!obj_body[QStringLiteral("track_list")].isArray()) {
if (!obj_body[QLatin1String("track_list")].isArray()) {
Error(QStringLiteral("Json hits is not an array."), obj_body);
EndSearch(search);
return;
}
QJsonArray array_tracklist = obj_body[QStringLiteral("track_list")].toArray();
QJsonArray array_tracklist = obj_body[QLatin1String("track_list")].toArray();
for (const QJsonValueRef value_track : array_tracklist) {
if (!value_track.isObject()) {
@ -198,23 +198,23 @@ void MusixmatchLyricsProvider::HandleSearchReply(QNetworkReply *reply, LyricsSea
}
QJsonObject obj_track = value_track.toObject();
if (!obj_track.contains(QStringLiteral("track")) || !obj_track[QStringLiteral("track")].isObject()) {
if (!obj_track.contains(QLatin1String("track")) || !obj_track[QLatin1String("track")].isObject()) {
continue;
}
obj_track = obj_track[QStringLiteral("track")].toObject();
if (!obj_track.contains(QStringLiteral("artist_name")) ||
!obj_track.contains(QStringLiteral("album_name")) ||
!obj_track.contains(QStringLiteral("track_name")) ||
!obj_track.contains(QStringLiteral("track_share_url"))) {
obj_track = obj_track[QLatin1String("track")].toObject();
if (!obj_track.contains(QLatin1String("artist_name")) ||
!obj_track.contains(QLatin1String("album_name")) ||
!obj_track.contains(QLatin1String("track_name")) ||
!obj_track.contains(QLatin1String("track_share_url"))) {
Error(QStringLiteral("Missing one or more values in result object"), obj_track);
continue;
}
QString artist_name = obj_track[QStringLiteral("artist_name")].toString();
QString album_name = obj_track[QStringLiteral("album_name")].toString();
QString track_name = obj_track[QStringLiteral("track_name")].toString();
QUrl track_share_url(obj_track[QStringLiteral("track_share_url")].toString());
QString artist_name = obj_track[QLatin1String("artist_name")].toString();
QString album_name = obj_track[QLatin1String("album_name")].toString();
QString track_name = obj_track[QLatin1String("track_name")].toString();
QUrl track_share_url(obj_track[QLatin1String("track_share_url")].toString());
// Ignore results where both the artist, album and title don't match.
if (use_api_ &&
@ -298,8 +298,8 @@ void MusixmatchLyricsProvider::HandleLyricsReply(QNetworkReply *reply, LyricsSea
}
const QString content = QString::fromUtf8(data);
const QString data_begin = QStringLiteral("<script id=\"__NEXT_DATA__\" type=\"application/json\">");
const QString data_end = QStringLiteral("</script>");
const QString data_begin = QLatin1String("<script id=\"__NEXT_DATA__\" type=\"application/json\">");
const QString data_end = QLatin1String("</script>");
qint64 begin_idx = content.indexOf(data_begin);
QString content_json;
if (begin_idx > 0) {
@ -326,86 +326,86 @@ void MusixmatchLyricsProvider::HandleLyricsReply(QNetworkReply *reply, LyricsSea
return;
}
if (!obj_data.contains(QStringLiteral("props")) || !obj_data[QStringLiteral("props")].isObject()) {
if (!obj_data.contains(QLatin1String("props")) || !obj_data[QLatin1String("props")].isObject()) {
Error(QStringLiteral("Json reply is missing props."), obj_data);
EndSearch(search, url);
return;
}
obj_data = obj_data[QStringLiteral("props")].toObject();
obj_data = obj_data[QLatin1String("props")].toObject();
if (!obj_data.contains(QStringLiteral("pageProps")) || !obj_data[QStringLiteral("pageProps")].isObject()) {
if (!obj_data.contains(QLatin1String("pageProps")) || !obj_data[QLatin1String("pageProps")].isObject()) {
Error(QStringLiteral("Json props is missing pageProps."), obj_data);
EndSearch(search, url);
return;
}
obj_data = obj_data[QStringLiteral("pageProps")].toObject();
obj_data = obj_data[QLatin1String("pageProps")].toObject();
if (!obj_data.contains(QStringLiteral("data")) || !obj_data[QStringLiteral("data")].isObject()) {
if (!obj_data.contains(QLatin1String("data")) || !obj_data[QLatin1String("data")].isObject()) {
Error(QStringLiteral("Json pageProps is missing data."), obj_data);
EndSearch(search, url);
return;
}
obj_data = obj_data[QStringLiteral("data")].toObject();
obj_data = obj_data[QLatin1String("data")].toObject();
if (!obj_data.contains(QStringLiteral("trackInfo")) || !obj_data[QStringLiteral("trackInfo")].isObject()) {
if (!obj_data.contains(QLatin1String("trackInfo")) || !obj_data[QLatin1String("trackInfo")].isObject()) {
Error(QStringLiteral("Json data is missing trackInfo."), obj_data);
EndSearch(search, url);
return;
}
obj_data = obj_data[QStringLiteral("trackInfo")].toObject();
obj_data = obj_data[QLatin1String("trackInfo")].toObject();
if (!obj_data.contains(QStringLiteral("data")) || !obj_data[QStringLiteral("data")].isObject()) {
if (!obj_data.contains(QLatin1String("data")) || !obj_data[QLatin1String("data")].isObject()) {
Error(QStringLiteral("Json trackInfo reply is missing data."), obj_data);
EndSearch(search, url);
return;
}
obj_data = obj_data[QStringLiteral("data")].toObject();
obj_data = obj_data[QLatin1String("data")].toObject();
if (!obj_data.contains(QStringLiteral("track")) || !obj_data[QStringLiteral("track")].isObject()) {
if (!obj_data.contains(QLatin1String("track")) || !obj_data[QLatin1String("track")].isObject()) {
Error(QStringLiteral("Json data is missing track."), obj_data);
EndSearch(search, url);
return;
}
const QJsonObject obj_track = obj_data[QStringLiteral("track")].toObject();
const QJsonObject obj_track = obj_data[QLatin1String("track")].toObject();
if (!obj_track.contains(QStringLiteral("hasLyrics")) || !obj_track[QStringLiteral("hasLyrics")].isBool()) {
if (!obj_track.contains(QLatin1String("hasLyrics")) || !obj_track[QLatin1String("hasLyrics")].isBool()) {
Error(QStringLiteral("Json track is missing hasLyrics."), obj_track);
EndSearch(search, url);
return;
}
const bool has_lyrics = obj_track[QStringLiteral("hasLyrics")].toBool();
const bool has_lyrics = obj_track[QLatin1String("hasLyrics")].toBool();
if (!has_lyrics) {
EndSearch(search, url);
return;
}
LyricsSearchResult result;
if (obj_track.contains(QStringLiteral("artistName")) && obj_track[QStringLiteral("artistName")].isString()) {
result.artist = obj_track[QStringLiteral("artistName")].toString();
if (obj_track.contains(QLatin1String("artistName")) && obj_track[QLatin1String("artistName")].isString()) {
result.artist = obj_track[QLatin1String("artistName")].toString();
}
if (obj_track.contains(QStringLiteral("albumName")) && obj_track[QStringLiteral("albumName")].isString()) {
result.album = obj_track[QStringLiteral("albumName")].toString();
if (obj_track.contains(QLatin1String("albumName")) && obj_track[QLatin1String("albumName")].isString()) {
result.album = obj_track[QLatin1String("albumName")].toString();
}
if (obj_track.contains(QStringLiteral("name")) && obj_track[QStringLiteral("name")].isString()) {
result.title = obj_track[QStringLiteral("name")].toString();
if (obj_track.contains(QLatin1String("name")) && obj_track[QLatin1String("name")].isString()) {
result.title = obj_track[QLatin1String("name")].toString();
}
if (!obj_data.contains(QStringLiteral("lyrics")) || !obj_data[QStringLiteral("lyrics")].isObject()) {
if (!obj_data.contains(QLatin1String("lyrics")) || !obj_data[QLatin1String("lyrics")].isObject()) {
Error(QStringLiteral("Json data is missing lyrics."), obj_data);
EndSearch(search, url);
return;
}
QJsonObject obj_lyrics = obj_data[QStringLiteral("lyrics")].toObject();
QJsonObject obj_lyrics = obj_data[QLatin1String("lyrics")].toObject();
if (!obj_lyrics.contains(QStringLiteral("body")) || !obj_lyrics[QStringLiteral("body")].isString()) {
if (!obj_lyrics.contains(QLatin1String("body")) || !obj_lyrics[QLatin1String("body")].isString()) {
Error(QStringLiteral("Json lyrics reply is missing body."), obj_lyrics);
EndSearch(search, url);
return;
}
result.lyrics = obj_lyrics[QStringLiteral("body")].toString();
result.lyrics = obj_lyrics[QLatin1String("body")].toString();
if (!result.lyrics.isEmpty()) {
result.lyrics = Utilities::DecodeHtmlEntities(result.lyrics);

8
src/lyrics/ovhlyricsprovider.cpp
View File

@ -81,20 +81,20 @@ void OVHLyricsProvider::HandleSearchReply(QNetworkReply *reply, const int id, co
return;
}
if (json_obj.contains(QStringLiteral("error"))) {
Error(json_obj[QStringLiteral("error")].toString());
if (json_obj.contains(QLatin1String("error"))) {
Error(json_obj[QLatin1String("error")].toString());
qLog(Debug) << "OVHLyrics: No lyrics for" << request.artist << request.title;
emit SearchFinished(id);
return;
}
if (!json_obj.contains(QStringLiteral("lyrics"))) {
if (!json_obj.contains(QLatin1String("lyrics"))) {
emit SearchFinished(id);
return;
}
LyricsSearchResult result;
result.lyrics = json_obj[QStringLiteral("lyrics")].toString();
result.lyrics = json_obj[QLatin1String("lyrics")].toString();
if (result.lyrics.isEmpty()) {
qLog(Debug) << "OVHLyrics: No lyrics for" << request.artist << request.title;

2
src/lyrics/songlyricscomlyricsprovider.cpp
View File

@ -39,7 +39,7 @@ SongLyricsComLyricsProvider::SongLyricsComLyricsProvider(SharedPtr<NetworkAccess
QUrl SongLyricsComLyricsProvider::Url(const LyricsSearchRequest &request) {
return QUrl(QLatin1String(kUrl) + StringFixup(request.artist) + QLatin1Char('/') + StringFixup(request.title) + QStringLiteral("-lyrics/"));
return QUrl(QLatin1String(kUrl) + StringFixup(request.artist) + QLatin1Char('/') + StringFixup(request.title) + QLatin1String("-lyrics/"));
}

14
src/musicbrainz/acoustidclient.cpp
View File

@ -150,8 +150,8 @@ void AcoustidClient::RequestFinished(QNetworkReply *reply, const int request_id)
QJsonObject json_object = json_document.object();
QString status = json_object[QStringLiteral("status")].toString();
if (status != QStringLiteral("ok")) {
QString status = json_object[QLatin1String("status")].toString();
if (status != QLatin1String("ok")) {
emit Finished(request_id, QStringList(), status);
return;
}
@ -161,19 +161,19 @@ void AcoustidClient::RequestFinished(QNetworkReply *reply, const int request_id)
// -then sort results by number of sources (the results are originally
// unsorted but results with more sources are likely to be more accurate)
// -keep only the ids, as sources where useful only to sort the results
QJsonArray json_results = json_object[QStringLiteral("results")].toArray();
QJsonArray json_results = json_object[QLatin1String("results")].toArray();
// List of <id, nb of sources> pairs
QList<IdSource> id_source_list;
for (const QJsonValueRef v : json_results) {
QJsonObject r = v.toObject();
if (!r[QStringLiteral("recordings")].isUndefined()) {
QJsonArray json_recordings = r[QStringLiteral("recordings")].toArray();
if (!r[QLatin1String("recordings")].isUndefined()) {
QJsonArray json_recordings = r[QLatin1String("recordings")].toArray();
for (const QJsonValueRef recording : json_recordings) {
QJsonObject o = recording.toObject();
if (!o[QStringLiteral("id")].isUndefined()) {
id_source_list << IdSource(o[QStringLiteral("id")].toString(), o[QStringLiteral("sources")].toInt());
if (!o[QLatin1String("id")].isUndefined()) {
id_source_list << IdSource(o[QLatin1String("id")].toString(), o[QLatin1String("sources")].toInt());
}
}
}

60
src/musicbrainz/musicbrainzclient.cpp
View File

@ -95,8 +95,8 @@ QByteArray MusicBrainzClient::GetReplyData(QNetworkReply *reply, QString &error)
QJsonDocument json_doc = QJsonDocument::fromJson(data, &json_error);
if (json_error.error == QJsonParseError::NoError && json_doc.isObject()) {
QJsonObject json_obj = json_doc.object();
if (!json_obj.isEmpty() && json_obj.contains(QStringLiteral("error"))) {
error = json_obj[QStringLiteral("error")].toString();
if (!json_obj.isEmpty() && json_obj.contains(QLatin1String("error"))) {
error = json_obj[QLatin1String("error")].toString();
}
}
if (error.isEmpty()) {
@ -212,7 +212,7 @@ void MusicBrainzClient::RequestFinished(QNetworkReply *reply, const int id, cons
QXmlStreamReader reader(data);
ResultList res;
while (!reader.atEnd()) {
if (reader.readNext() == QXmlStreamReader::StartElement && reader.name().toString() == QStringLiteral("recording")) {
if (reader.readNext() == QXmlStreamReader::StartElement && reader.name().toString() == QLatin1String("recording")) {
ResultList tracks = ParseTrack(&reader);
for (const Result &track : tracks) {
if (!track.title_.isEmpty()) {
@ -267,20 +267,20 @@ void MusicBrainzClient::DiscIdRequestFinished(const QString &discid, QNetworkRep
QXmlStreamReader::TokenType type = reader.readNext();
if (type == QXmlStreamReader::StartElement) {
QString name = reader.name().toString();
if (name == QStringLiteral("title")) {
if (name == QLatin1String("title")) {
album = reader.readElementText();
}
else if (name == QStringLiteral("date")) {
else if (name == QLatin1String("date")) {
QRegularExpression regex(QString::fromLatin1(kDateRegex));
QRegularExpressionMatch re_match = regex.match(reader.readElementText());
if (re_match.capturedStart() == 0) {
year = re_match.captured(0).toInt();
}
}
else if (name == QStringLiteral("artist-credit")) {
else if (name == QLatin1String("artist-credit")) {
ParseArtist(&reader, &artist);
}
else if (name == QStringLiteral("medium-list")) {
else if (name == QLatin1String("medium-list")) {
break;
}
}
@ -289,7 +289,7 @@ void MusicBrainzClient::DiscIdRequestFinished(const QString &discid, QNetworkRep
while (!reader.atEnd()) {
QXmlStreamReader::TokenType token = reader.readNext();
QString name = reader.name().toString();
if (token == QXmlStreamReader::StartElement && name == QStringLiteral("medium")) {
if (token == QXmlStreamReader::StartElement && name == QLatin1String("medium")) {
// Get the medium with a matching discid.
if (MediumHasDiscid(discid, &reader)) {
ResultList tracks = ParseMedium(&reader);
@ -303,7 +303,7 @@ void MusicBrainzClient::DiscIdRequestFinished(const QString &discid, QNetworkRep
Utilities::ConsumeCurrentElement(&reader);
}
}
else if (token == QXmlStreamReader::EndElement && name == QStringLiteral("medium-list")) {
else if (token == QXmlStreamReader::EndElement && name == QLatin1String("medium-list")) {
break;
}
}
@ -325,10 +325,10 @@ bool MusicBrainzClient::MediumHasDiscid(const QString &discid, QXmlStreamReader
QXmlStreamReader::TokenType type = reader->readNext();
QString name = reader->name().toString();
if (type == QXmlStreamReader::StartElement && name == QStringLiteral("disc") && reader->attributes().value(QStringLiteral("id")).toString() == discid) {
if (type == QXmlStreamReader::StartElement && name == QLatin1String("disc") && reader->attributes().value(QStringLiteral("id")).toString() == discid) {
return true;
}
else if (type == QXmlStreamReader::EndElement && name == QStringLiteral("disc-list")) {
else if (type == QXmlStreamReader::EndElement && name == QLatin1String("disc-list")) {
return false;
}
}
@ -345,14 +345,14 @@ MusicBrainzClient::ResultList MusicBrainzClient::ParseMedium(QXmlStreamReader *r
QString name = reader->name().toString();
if (type == QXmlStreamReader::StartElement) {
if (name == QStringLiteral("track")) {
if (name == QLatin1String("track")) {
Result result;
result = ParseTrackFromDisc(reader);
ret << result;
}
}
if (type == QXmlStreamReader::EndElement && name == QStringLiteral("track-list")) {
if (type == QXmlStreamReader::EndElement && name == QLatin1String("track-list")) {
break;
}
}
@ -370,18 +370,18 @@ MusicBrainzClient::Result MusicBrainzClient::ParseTrackFromDisc(QXmlStreamReader
QString name = reader->name().toString();
if (type == QXmlStreamReader::StartElement) {
if (name == QStringLiteral("position")) {
if (name == QLatin1String("position")) {
result.track_ = reader->readElementText().toInt();
}
else if (name == QStringLiteral("length")) {
else if (name == QLatin1String("length")) {
result.duration_msec_ = reader->readElementText().toInt();
}
else if (name == QStringLiteral("title")) {
else if (name == QLatin1String("title")) {
result.title_ = reader->readElementText();
}
}
if (type == QXmlStreamReader::EndElement && name == QStringLiteral("track")) {
if (type == QXmlStreamReader::EndElement && name == QLatin1String("track")) {
break;
}
}
@ -400,21 +400,21 @@ MusicBrainzClient::ResultList MusicBrainzClient::ParseTrack(QXmlStreamReader *re
if (type == QXmlStreamReader::StartElement) {
if (name == QStringLiteral("title")) {
if (name == QLatin1String("title")) {
result.title_ = reader->readElementText();
}
else if (name == QStringLiteral("length")) {
else if (name == QLatin1String("length")) {
result.duration_msec_ = reader->readElementText().toInt();
}
else if (name == QStringLiteral("artist-credit")) {
else if (name == QLatin1String("artist-credit")) {
ParseArtist(reader, &result.artist_);
}
else if (name == QStringLiteral("release")) {
else if (name == QLatin1String("release")) {
releases << ParseRelease(reader);
}
}
if (type == QXmlStreamReader::EndElement && name == QStringLiteral("recording")) {
if (type == QXmlStreamReader::EndElement && name == QLatin1String("recording")) {
break;
}
}
@ -441,15 +441,15 @@ void MusicBrainzClient::ParseArtist(QXmlStreamReader *reader, QString *artist) {
while (!reader->atEnd()) {
QXmlStreamReader::TokenType type = reader->readNext();
QString name = reader->name().toString();
if (type == QXmlStreamReader::StartElement && name == QStringLiteral("name-credit")) {
if (type == QXmlStreamReader::StartElement && name == QLatin1String("name-credit")) {
join_phrase = reader->attributes().value(QStringLiteral("joinphrase")).toString();
}
if (type == QXmlStreamReader::StartElement && name == QStringLiteral("name")) {
if (type == QXmlStreamReader::StartElement && name == QLatin1String("name")) {
*artist += reader->readElementText() + join_phrase;
}
if (type == QXmlStreamReader::EndElement && name == QStringLiteral("artist-credit")) {
if (type == QXmlStreamReader::EndElement && name == QLatin1String("artist-credit")) {
return;
}
}
@ -464,26 +464,26 @@ MusicBrainzClient::Release MusicBrainzClient::ParseRelease(QXmlStreamReader *rea
QString name = reader->name().toString();
if (type == QXmlStreamReader::StartElement) {
if (name == QStringLiteral("title")) {
if (name == QLatin1String("title")) {
ret.album_ = reader->readElementText();
}
else if (name == QStringLiteral("status")) {
else if (name == QLatin1String("status")) {
ret.SetStatusFromString(reader->readElementText());
}
else if (name == QStringLiteral("date")) {
else if (name == QLatin1String("date")) {
QRegularExpression regex(QString::fromLatin1(kDateRegex));
QRegularExpressionMatch re_match = regex.match(reader->readElementText());
if (re_match.capturedStart() == 0) {
ret.year_ = re_match.captured(0).toInt();
}
}
else if (name == QStringLiteral("track-list")) {
else if (name == QLatin1String("track-list")) {
ret.track_ = reader->attributes().value(QStringLiteral("offset")).toString().toInt() + 1;
Utilities::ConsumeCurrentElement(reader);
}
}
if (type == QXmlStreamReader::EndElement && name == QStringLiteral("release")) {
if (type == QXmlStreamReader::EndElement && name == QLatin1String("release")) {
break;
}
}

52
src/organize/organizeformat.cpp
View File

@ -170,14 +170,14 @@ OrganizeFormat::GetFilenameForSongResult OrganizeFormat::GetFilenameForSong(cons
extension = info.suffix();
}
}
if (!info.path().isEmpty() && info.path() != QStringLiteral(".")) {
if (!info.path().isEmpty() && info.path() != QLatin1Char('.')) {
filepath.append(info.path());
filepath.append(QLatin1Char('/'));
}
filepath.append(info.completeBaseName());
// Fix any parts of the path that start with dots.
QStringList parts_old = filepath.split(QStringLiteral("/"));
QStringList parts_old = filepath.split(QLatin1Char('/'));
QStringList parts_new;
for (int i = 0; i < parts_old.count(); ++i) {
QString part = parts_old[i];
@ -190,12 +190,12 @@ OrganizeFormat::GetFilenameForSongResult OrganizeFormat::GetFilenameForSong(cons
part = part.trimmed();
parts_new.append(part);
}
filepath = parts_new.join(QStringLiteral("/"));
filepath = parts_new.join(QLatin1Char('/'));
if (replace_spaces_) filepath.replace(QRegularExpression(QStringLiteral("\\s")), QStringLiteral("_"));
if (!extension.isEmpty()) {
filepath.append(QStringLiteral(".%1").arg(extension));
filepath.append(QLatin1String(".%1").arg(extension));
}
return GetFilenameForSongResult(filepath, unique_filename);
@ -251,75 +251,75 @@ QString OrganizeFormat::TagValue(const QString &tag, const Song &song) const {
QString value;
if (tag == QStringLiteral("title")) {
if (tag == QLatin1String("title")) {
value = song.title();
}
else if (tag == QStringLiteral("album")) {
else if (tag == QLatin1String("album")) {
value = song.album();
}
else if (tag == QStringLiteral("artist")) {
else if (tag == QLatin1String("artist")) {
value = song.artist();
}
else if (tag == QStringLiteral("composer")) {
else if (tag == QLatin1String("composer")) {
value = song.composer();
}
else if (tag == QStringLiteral("performer")) {
else if (tag == QLatin1String("performer")) {
value = song.performer();
}
else if (tag == QStringLiteral("grouping")) {
else if (tag == QLatin1String("grouping")) {
value = song.grouping();
}
else if (tag == QStringLiteral("lyrics")) {
else if (tag == QLatin1String("lyrics")) {
value = song.lyrics();
}
else if (tag == QStringLiteral("genre")) {
else if (tag == QLatin1String("genre")) {
value = song.genre();
}
else if (tag == QStringLiteral("comment")) {
else if (tag == QLatin1String("comment")) {
value = song.comment();
}
else if (tag == QStringLiteral("year")) {
else if (tag == QLatin1String("year")) {
value = QString::number(song.year());
}
else if (tag == QStringLiteral("originalyear")) {
else if (tag == QLatin1String("originalyear")) {
value = QString::number(song.effective_originalyear());
}
else if (tag == QStringLiteral("track")) {
else if (tag == QLatin1String("track")) {
value = QString::number(song.track());
}
else if (tag == QStringLiteral("disc")) {
else if (tag == QLatin1String("disc")) {
value = QString::number(song.disc());
}
else if (tag == QStringLiteral("length")) {
else if (tag == QLatin1String("length")) {
value = QString::number(song.length_nanosec() / kNsecPerSec);
}
else if (tag == QStringLiteral("bitrate")) {
else if (tag == QLatin1String("bitrate")) {
value = QString::number(song.bitrate());
}
else if (tag == QStringLiteral("samplerate")) {
else if (tag == QLatin1String("samplerate")) {
value = QString::number(song.samplerate());
}
else if (tag == QStringLiteral("bitdepth")) {
else if (tag == QLatin1String("bitdepth")) {
value = QString::number(song.bitdepth());
}
else if (tag == QStringLiteral("extension")) {
else if (tag == QLatin1String("extension")) {
value = QFileInfo(song.url().toLocalFile()).suffix();
}
else if (tag == QStringLiteral("artistinitial")) {
else if (tag == QLatin1String("artistinitial")) {
value = song.effective_albumartist().trimmed();
if (!value.isEmpty()) {
value.replace(QRegularExpression(QStringLiteral("^the\\s+"), QRegularExpression::CaseInsensitiveOption), QLatin1String(""));
value = value[0].toUpper();
}
}
else if (tag == QStringLiteral("albumartist")) {
else if (tag == QLatin1String("albumartist")) {
value = song.is_compilation() ? QStringLiteral("Various Artists") : song.effective_albumartist();
}
if (value == QStringLiteral("0") || value == QStringLiteral("-1")) value = QLatin1String("");
if (value == QLatin1Char('0') || value == QLatin1String("-1")) value = QLatin1String("");
// Prepend a 0 to single-digit track numbers
if (tag == QStringLiteral("track") && value.length() == 1) value.prepend(QLatin1Char('0'));
if (tag == QLatin1String("track") && value.length() == 1) value.prepend(QLatin1Char('0'));
// Replace characters that really shouldn't be in paths
value = value.remove(QRegularExpression(QString::fromLatin1(kInvalidDirCharactersRegex), QRegularExpression::PatternOption::CaseInsensitiveOption));

12
src/osd/osdbase.cpp
View File

@ -169,7 +169,7 @@ void OSDBase::ShowPlaying(const Song &song, const QUrl &cover_url, const QImage
#endif
}
QString message = message_parts.join(QStringLiteral(", "));
QString message = message_parts.join(QLatin1String(", "));
if (html_escaped) message = message.toHtmlEscaped();
if (show_art_) {
@ -201,7 +201,7 @@ void OSDBase::Paused() {
else {
summary = last_song_.PrettyTitle();
if (!last_song_.artist().isEmpty()) {
summary.prepend(QStringLiteral(" - "));
summary.prepend(QLatin1String(" - "));
summary.prepend(last_song_.artist());
}
if (behaviour_ == Behaviour::Pretty) {
@ -246,7 +246,7 @@ void OSDBase::Stopped() {
else {
summary = last_song_.PrettyTitle();
if (!last_song_.artist().isEmpty()) {
summary.prepend(QStringLiteral(" - "));
summary.prepend(QLatin1String(" - "));
summary.prepend(last_song_.artist());
}
if (behaviour_ == Behaviour::Pretty) {
@ -386,7 +386,7 @@ QString OSDBase::ReplaceMessage(const MessageType type, const QString &message,
case Behaviour::Native:
#if defined(Q_OS_MACOS)
html_escaped = false;
newline = QStringLiteral("\n");
newline = QLatin1String("\n");
break;
#elif defined(HAVE_DBUS)
switch (type) {
@ -397,7 +397,7 @@ QString OSDBase::ReplaceMessage(const MessageType type, const QString &message,
}
case MessageType::Message:{
html_escaped = true;
newline = QStringLiteral("<br />");
newline = QLatin1String("<br />");
break;
}
}
@ -417,7 +417,7 @@ QString OSDBase::ReplaceMessage(const MessageType type, const QString &message,
case Behaviour::Disabled: // When notifications are disabled, we force the PrettyOSD
case Behaviour::Pretty:
html_escaped = true;
newline = QStringLiteral("<br />");
newline = QLatin1String("<br />");
break;
}

2
src/playlist/playlistbackend.cpp
View File

@ -117,7 +117,7 @@ PlaylistBackend::PlaylistList PlaylistBackend::GetPlaylists(const GetPlaylistsFl
}
QString condition;
if (!condition_list.isEmpty()) {
condition = QStringLiteral(" WHERE ") + condition_list.join(QStringLiteral(" OR "));
condition = QLatin1String(" WHERE ") + condition_list.join(QLatin1String(" OR "));
}
SqlQuery q(db);

6
src/playlist/playlistcontainer.cpp
View File

@ -124,7 +124,7 @@ PlaylistContainer::PlaylistContainer(QWidget *parent)
QObject::connect(ui_->playlist, &PlaylistView::FocusOnFilterSignal, this, &PlaylistContainer::FocusOnFilter);
ui_->search_field->installEventFilter(this);
QString available_fields = PlaylistFilter().column_names().keys().join(QStringLiteral(", "));
QString available_fields = PlaylistFilter().column_names().keys().join(QLatin1String(", "));
ui_->search_field->setToolTip(
QStringLiteral("<html><head/><body><p>") +
tr("Prefix a search term with a field name to limit the search to that field, e.g.:") +
@ -136,7 +136,7 @@ PlaylistContainer::PlaylistContainer(QWidget *parent)
QStringLiteral("</p><p>") +
tr("Search terms for numerical fields can be prefixed with %1 or %2 to refine the search, e.g.: ")
.arg(QStringLiteral(" =, !=, &lt;, &gt;, &lt;="), QStringLiteral("&gt;=")) +
.arg(QLatin1String(" =, !=, &lt;, &gt;, &lt;="), QStringLiteral("&gt;=")) +
QStringLiteral("<span style=\"font-weight:600;\">") +
tr("rating") +
QStringLiteral("</span>") +
@ -145,7 +145,7 @@ PlaylistContainer::PlaylistContainer(QWidget *parent)
QStringLiteral("</p><p>") +
tr("Multiple search terms can also be combined with \"%1\" (default) and \"%2\", as well as grouped with parentheses. ")
.arg(QStringLiteral("AND"), QStringLiteral("OR")) +
.arg(QLatin1String("AND"), QLatin1String("OR")) +
QStringLiteral("</p><p><span style=\"font-weight:600;\">") +
tr("Available fields") +

2
src/playlist/playlistlistmodel.cpp
View File

@ -68,7 +68,7 @@ QString PlaylistListModel::ItemPath(const QStandardItem *item) {
current = current->parent();
}
return components.join(QStringLiteral("/"));
return components.join(QLatin1Char('/'));
}

2
src/playlist/playlisttabbar.cpp
View File

@ -333,7 +333,7 @@ void PlaylistTabBar::RemoveTab(const int id) {
void PlaylistTabBar::set_text_by_id(const int id, const QString &text) {
QString new_text = text;
new_text = new_text.replace(QLatin1String("&"), QLatin1String("&&"));
new_text = new_text.replace(QLatin1Char('&'), QLatin1String("&&"));
setTabText(index_of(id), new_text);
setTabToolTip(index_of(id), text);

2
src/playlist/playlistview.cpp
View File

@ -1399,7 +1399,7 @@ void PlaylistView::CopyCurrentSongToClipboard() const {
QMimeData *mime_data = new QMimeData;
mime_data->setUrls(QList<QUrl>() << url);
mime_data->setText(columns.join(QStringLiteral(" - ")));
mime_data->setText(columns.join(QLatin1String(" - ")));
QApplication::clipboard()->setMimeData(mime_data);

2
src/playlistparsers/m3uparser.cpp
View File

@ -112,7 +112,7 @@ bool M3UParser::ParseMetadata(const QString &line, M3UParser::Metadata *metadata
metadata->length = length * kNsecPerSec;
QString track_info = info.section(QLatin1Char(','), 1);
QStringList list = track_info.split(QStringLiteral(" - "));
QStringList list = track_info.split(QLatin1String(" - "));
if (list.size() <= 1) {
metadata->title = track_info;
return true;

6
src/playlistparsers/playlistparser.cpp
View File

@ -100,10 +100,10 @@ QString PlaylistParser::filters(const Type type) const {
}
if (type == Type::Load) {
filters.prepend(tr("All playlists (%1)").arg(all_extensions.join(QStringLiteral(" "))));
filters.prepend(tr("All playlists (%1)").arg(all_extensions.join(QLatin1Char(' '))));
}
return filters.join(QStringLiteral(";;"));
return filters.join(QLatin1String(";;"));
}
@ -118,7 +118,7 @@ QString PlaylistParser::FilterForParser(const ParserBase *parser, QStringList *a
if (all_extensions) *all_extensions << extensions;
return tr("%1 playlists (%2)").arg(parser->name(), extensions.join(QStringLiteral(" ")));
return tr("%1 playlists (%2)").arg(parser->name(), extensions.join(QLatin1Char(' ')));
}

10
src/qobuz/qobuzbaserequest.cpp
View File

@ -106,9 +106,9 @@ QByteArray QobuzBaseRequest::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(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();
if (!json_obj.isEmpty() && json_obj.contains(QLatin1String("status")) && json_obj.contains(QLatin1String("code")) && json_obj.contains(QLatin1String("message"))) {
int code = json_obj[QLatin1String("code")].toInt();
QString message = json_obj[QLatin1String("message")].toString();
error = QStringLiteral("%1 (%2)").arg(message).arg(code);
}
}
@ -169,11 +169,11 @@ QJsonValue QobuzBaseRequest::ExtractItems(QByteArray &data) {
QJsonValue QobuzBaseRequest::ExtractItems(QJsonObject &json_obj) {
if (!json_obj.contains(QStringLiteral("items"))) {
if (!json_obj.contains(QLatin1String("items"))) {
Error(QStringLiteral("Json reply is missing items."), json_obj);
return QJsonArray();
}
QJsonValue json_items = json_obj[QStringLiteral("items")];
QJsonValue json_items = json_obj[QLatin1String("items")];
return json_items;
}

210
src/qobuz/qobuzrequest.cpp
View File

@ -421,12 +421,12 @@ void QobuzRequest::ArtistsReplyReceived(QNetworkReply *reply, const int limit_re
return;
}
if (!json_obj.contains(QStringLiteral("artists"))) {
if (!json_obj.contains(QLatin1String("artists"))) {
ArtistsFinishCheck();
Error(QStringLiteral("Json object is missing artists."), json_obj);
return;
}
QJsonValue value_artists = json_obj[QStringLiteral("artists")];
QJsonValue value_artists = json_obj[QLatin1String("artists")];
if (!value_artists.isObject()) {
Error(QStringLiteral("Json artists is not an object."), json_obj);
ArtistsFinishCheck();
@ -434,17 +434,17 @@ void QobuzRequest::ArtistsReplyReceived(QNetworkReply *reply, const int limit_re
}
QJsonObject obj_artists = value_artists.toObject();
if (!obj_artists.contains(QStringLiteral("limit")) ||
!obj_artists.contains(QStringLiteral("offset")) ||
!obj_artists.contains(QStringLiteral("total")) ||
!obj_artists.contains(QStringLiteral("items"))) {
if (!obj_artists.contains(QLatin1String("limit")) ||
!obj_artists.contains(QLatin1String("offset")) ||
!obj_artists.contains(QLatin1String("total")) ||
!obj_artists.contains(QLatin1String("items"))) {
ArtistsFinishCheck();
Error(QStringLiteral("Json artists object is missing values."), json_obj);
return;
}
//int limit = obj_artists["limit"].toInt();
int offset = obj_artists[QStringLiteral("offset")].toInt();
int artists_total = obj_artists[QStringLiteral("total")].toInt();
int offset = obj_artists[QLatin1String("offset")].toInt();
int artists_total = obj_artists[QLatin1String("total")].toInt();
if (offset_requested == 0) {
artists_total_ = artists_total;
@ -489,8 +489,8 @@ void QobuzRequest::ArtistsReplyReceived(QNetworkReply *reply, const int limit_re
}
QJsonObject obj_item = value_item.toObject();
if (obj_item.contains(QStringLiteral("item"))) {
QJsonValue json_item = obj_item[QStringLiteral("item")];
if (obj_item.contains(QLatin1String("item"))) {
QJsonValue json_item = obj_item[QLatin1String("item")];
if (!json_item.isObject()) {
Error(QStringLiteral("Invalid Json reply, item not a object."), json_item);
continue;
@ -498,19 +498,19 @@ void QobuzRequest::ArtistsReplyReceived(QNetworkReply *reply, const int limit_re
obj_item = json_item.toObject();
}
if (!obj_item.contains(QStringLiteral("id")) || !obj_item.contains(QStringLiteral("name"))) {
if (!obj_item.contains(QLatin1String("id")) || !obj_item.contains(QLatin1String("name"))) {
Error(QStringLiteral("Invalid Json reply, item missing id or album."), obj_item);
continue;
}
Artist artist;
if (obj_item[QStringLiteral("id")].isString()) {
artist.artist_id = obj_item[QStringLiteral("id")].toString();
if (obj_item[QLatin1String("id")].isString()) {
artist.artist_id = obj_item[QLatin1String("id")].toString();
}
else {
artist.artist_id = QString::number(obj_item[QStringLiteral("id")].toInt());
artist.artist_id = QString::number(obj_item[QLatin1String("id")].toInt());
}
artist.artist = obj_item[QStringLiteral("name")].toString();
artist.artist = obj_item[QLatin1String("name")].toString();
if (artist_albums_requests_pending_.contains(artist.artist_id)) continue;
@ -634,14 +634,14 @@ void QobuzRequest::AlbumsReceived(QNetworkReply *reply, const Artist &artist_req
Artist artist = artist_requested;
if (json_obj.contains(QStringLiteral("id")) && json_obj.contains(QStringLiteral("name"))) {
if (json_obj[QStringLiteral("id")].isString()) {
artist.artist_id = json_obj[QStringLiteral("id")].toString();
if (json_obj.contains(QLatin1String("id")) && json_obj.contains(QLatin1String("name"))) {
if (json_obj[QLatin1String("id")].isString()) {
artist.artist_id = json_obj[QLatin1String("id")].toString();
}
else {
artist.artist_id = QString::number(json_obj[QStringLiteral("id")].toInt());
artist.artist_id = QString::number(json_obj[QLatin1String("id")].toInt());
}
artist.artist = json_obj[QStringLiteral("name")].toString();
artist.artist = json_obj[QLatin1String("name")].toString();
}
if (artist.artist_id != artist_requested.artist_id) {
@ -650,12 +650,12 @@ void QobuzRequest::AlbumsReceived(QNetworkReply *reply, const Artist &artist_req
return;
}
if (!json_obj.contains(QStringLiteral("albums"))) {
if (!json_obj.contains(QLatin1String("albums"))) {
AlbumsFinishCheck(artist_requested);
Error(QStringLiteral("Json object is missing albums."), json_obj);
return;
}
QJsonValue value_albums = json_obj[QStringLiteral("albums")];
QJsonValue value_albums = json_obj[QLatin1String("albums")];
if (!value_albums.isObject()) {
Error(QStringLiteral("Json albums is not an object."), json_obj);
AlbumsFinishCheck(artist_requested);
@ -663,18 +663,18 @@ void QobuzRequest::AlbumsReceived(QNetworkReply *reply, const Artist &artist_req
}
QJsonObject obj_albums = value_albums.toObject();
if (!obj_albums.contains(QStringLiteral("limit")) ||
!obj_albums.contains(QStringLiteral("offset")) ||
!obj_albums.contains(QStringLiteral("total")) ||
!obj_albums.contains(QStringLiteral("items"))) {
if (!obj_albums.contains(QLatin1String("limit")) ||
!obj_albums.contains(QLatin1String("offset")) ||
!obj_albums.contains(QLatin1String("total")) ||
!obj_albums.contains(QLatin1String("items"))) {
AlbumsFinishCheck(artist_requested);
Error(QStringLiteral("Json albums object is missing values."), json_obj);
return;
}
//int limit = obj_albums["limit"].toInt();
int offset = obj_albums[QStringLiteral("offset")].toInt();
int albums_total = obj_albums[QStringLiteral("total")].toInt();
int offset = obj_albums[QLatin1String("offset")].toInt();
int albums_total = obj_albums[QLatin1String("total")].toInt();
if (offset != offset_requested) {
Error(QStringLiteral("Offset returned does not match offset requested! %1 != %2").arg(offset).arg(offset_requested));
@ -707,41 +707,41 @@ void QobuzRequest::AlbumsReceived(QNetworkReply *reply, const Artist &artist_req
}
QJsonObject obj_item = value_item.toObject();
if (!obj_item.contains(QStringLiteral("artist")) || !obj_item.contains(QStringLiteral("title")) || !obj_item.contains(QStringLiteral("id"))) {
if (!obj_item.contains(QLatin1String("artist")) || !obj_item.contains(QLatin1String("title")) || !obj_item.contains(QLatin1String("id"))) {
Error(QStringLiteral("Invalid Json reply, item missing artist, title or id."), obj_item);
continue;
}
Album album;
if (obj_item[QStringLiteral("id")].isString()) {
album.album_id = obj_item[QStringLiteral("id")].toString();
if (obj_item[QLatin1String("id")].isString()) {
album.album_id = obj_item[QLatin1String("id")].toString();
}
else {
album.album_id = QString::number(obj_item[QStringLiteral("id")].toInt());
album.album_id = QString::number(obj_item[QLatin1String("id")].toInt());
}
album.album = obj_item[QStringLiteral("title")].toString();
album.album = obj_item[QLatin1String("title")].toString();
if (album_songs_requests_pending_.contains(album.album_id)) continue;
QJsonValue value_artist = obj_item[QStringLiteral("artist")];
QJsonValue value_artist = obj_item[QLatin1String("artist")];
if (!value_artist.isObject()) {
Error(QStringLiteral("Invalid Json reply, item artist is not a object."), value_artist);
continue;
}
QJsonObject obj_artist = value_artist.toObject();
if (!obj_artist.contains(QStringLiteral("id")) || !obj_artist.contains(QStringLiteral("name"))) {
if (!obj_artist.contains(QLatin1String("id")) || !obj_artist.contains(QLatin1String("name"))) {
Error(QStringLiteral("Invalid Json reply, item artist missing id or name."), obj_artist);
continue;
}
Artist album_artist;
if (obj_artist[QStringLiteral("id")].isString()) {
album_artist.artist_id = obj_artist[QStringLiteral("id")].toString();
if (obj_artist[QLatin1String("id")].isString()) {
album_artist.artist_id = obj_artist[QLatin1String("id")].toString();
}
else {
album_artist.artist_id = QString::number(obj_artist[QStringLiteral("id")].toInt());
album_artist.artist_id = QString::number(obj_artist[QLatin1String("id")].toInt());
}
album_artist.artist = obj_artist[QStringLiteral("name")].toString();
album_artist.artist = obj_artist[QLatin1String("name")].toString();
if (!artist_requested.artist_id.isEmpty() && album_artist.artist_id != artist_requested.artist_id) {
qLog(Debug) << "Skipping artist" << album_artist.artist << album_artist.artist_id << "does not match album artist" << artist_requested.artist_id << artist_requested.artist;
@ -889,7 +889,7 @@ void QobuzRequest::SongsReceived(QNetworkReply *reply, const Artist &artist_requ
return;
}
if (!json_obj.contains(QStringLiteral("tracks"))) {
if (!json_obj.contains(QLatin1String("tracks"))) {
Error(QStringLiteral("Json object is missing tracks."), json_obj);
SongsFinishCheck(artist_requested, album_requested, limit_requested, offset_requested);
return;
@ -898,58 +898,58 @@ void QobuzRequest::SongsReceived(QNetworkReply *reply, const Artist &artist_requ
Artist album_artist = artist_requested;
Album album = album_requested;
if (json_obj.contains(QStringLiteral("id")) && json_obj.contains(QStringLiteral("title"))) {
if (json_obj[QStringLiteral("id")].isString()) {
album.album_id = json_obj[QStringLiteral("id")].toString();
if (json_obj.contains(QLatin1String("id")) && json_obj.contains(QLatin1String("title"))) {
if (json_obj[QLatin1String("id")].isString()) {
album.album_id = json_obj[QLatin1String("id")].toString();
}
else {
album.album_id = QString::number(json_obj[QStringLiteral("id")].toInt());
album.album_id = QString::number(json_obj[QLatin1String("id")].toInt());
}
album.album = json_obj[QStringLiteral("title")].toString();
album.album = json_obj[QLatin1String("title")].toString();
}
if (json_obj.contains(QStringLiteral("artist"))) {
QJsonValue value_artist = json_obj[QStringLiteral("artist")];
if (json_obj.contains(QLatin1String("artist"))) {
QJsonValue value_artist = json_obj[QLatin1String("artist")];
if (!value_artist.isObject()) {
Error(QStringLiteral("Invalid Json reply, album artist is not a object."), value_artist);
SongsFinishCheck(artist_requested, album_requested, limit_requested, offset_requested);
return;
}
QJsonObject obj_artist = value_artist.toObject();
if (!obj_artist.contains(QStringLiteral("id")) || !obj_artist.contains(QStringLiteral("name"))) {
if (!obj_artist.contains(QLatin1String("id")) || !obj_artist.contains(QLatin1String("name"))) {
Error(QStringLiteral("Invalid Json reply, album artist is missing id or name."), obj_artist);
SongsFinishCheck(artist_requested, album_requested, limit_requested, offset_requested);
return;
}
if (obj_artist[QStringLiteral("id")].isString()) {
album_artist.artist_id = obj_artist[QStringLiteral("id")].toString();
if (obj_artist[QLatin1String("id")].isString()) {
album_artist.artist_id = obj_artist[QLatin1String("id")].toString();
}
else {
album_artist.artist_id = QString::number(obj_artist[QStringLiteral("id")].toInt());
album_artist.artist_id = QString::number(obj_artist[QLatin1String("id")].toInt());
}
album_artist.artist = obj_artist[QStringLiteral("name")].toString();
album_artist.artist = obj_artist[QLatin1String("name")].toString();
}
if (json_obj.contains(QStringLiteral("image"))) {
QJsonValue value_image = json_obj[QStringLiteral("image")];
if (json_obj.contains(QLatin1String("image"))) {
QJsonValue value_image = json_obj[QLatin1String("image")];
if (!value_image.isObject()) {
Error(QStringLiteral("Invalid Json reply, album image is not a object."), value_image);
SongsFinishCheck(artist_requested, album_requested, limit_requested, offset_requested);
return;
}
QJsonObject obj_image = value_image.toObject();
if (!obj_image.contains(QStringLiteral("large"))) {
if (!obj_image.contains(QLatin1String("large"))) {
Error(QStringLiteral("Invalid Json reply, album image is missing large."), obj_image);
SongsFinishCheck(artist_requested, album_requested, limit_requested, offset_requested);
return;
}
QString album_image = obj_image[QStringLiteral("large")].toString();
QString album_image = obj_image[QLatin1String("large")].toString();
if (!album_image.isEmpty()) {
album.cover_url = QUrl(album_image);
}
}
QJsonValue value_tracks = json_obj[QStringLiteral("tracks")];
QJsonValue value_tracks = json_obj[QLatin1String("tracks")];
if (!value_tracks.isObject()) {
Error(QStringLiteral("Json tracks is not an object."), json_obj);
SongsFinishCheck(artist_requested, album_requested, limit_requested, offset_requested);
@ -957,18 +957,18 @@ void QobuzRequest::SongsReceived(QNetworkReply *reply, const Artist &artist_requ
}
QJsonObject obj_tracks = value_tracks.toObject();
if (!obj_tracks.contains(QStringLiteral("limit")) ||
!obj_tracks.contains(QStringLiteral("offset")) ||
!obj_tracks.contains(QStringLiteral("total")) ||
!obj_tracks.contains(QStringLiteral("items"))) {
if (!obj_tracks.contains(QLatin1String("limit")) ||
!obj_tracks.contains(QLatin1String("offset")) ||
!obj_tracks.contains(QLatin1String("total")) ||
!obj_tracks.contains(QLatin1String("items"))) {
SongsFinishCheck(artist_requested, album_requested, limit_requested, offset_requested);
Error(QStringLiteral("Json songs object is missing values."), json_obj);
return;
}
//int limit = obj_tracks["limit"].toInt();
int offset = obj_tracks[QStringLiteral("offset")].toInt();
int songs_total = obj_tracks[QStringLiteral("total")].toInt();
int offset = obj_tracks[QLatin1String("offset")].toInt();
int songs_total = obj_tracks[QLatin1String("total")].toInt();
if (offset != offset_requested) {
Error(QStringLiteral("Offset returned does not match offset requested! %1 != %2").arg(offset).arg(offset_requested));
@ -1061,126 +1061,126 @@ void QobuzRequest::SongsFinishCheck(const Artist &artist, const Album &album, co
void QobuzRequest::ParseSong(Song &song, const QJsonObject &json_obj, const Artist &album_artist, const Album &album) {
if (
!json_obj.contains(QStringLiteral("id")) ||
!json_obj.contains(QStringLiteral("title")) ||
!json_obj.contains(QStringLiteral("track_number")) ||
!json_obj.contains(QStringLiteral("duration")) ||
!json_obj.contains(QStringLiteral("copyright")) ||
!json_obj.contains(QStringLiteral("streamable"))
!json_obj.contains(QLatin1String("id")) ||
!json_obj.contains(QLatin1String("title")) ||
!json_obj.contains(QLatin1String("track_number")) ||
!json_obj.contains(QLatin1String("duration")) ||
!json_obj.contains(QLatin1String("copyright")) ||
!json_obj.contains(QLatin1String("streamable"))
) {
Error(QStringLiteral("Invalid Json reply, track is missing one or more values."), json_obj);
return;
}
QString song_id;
if (json_obj[QStringLiteral("id")].isString()) {
song_id = json_obj[QStringLiteral("id")].toString();
if (json_obj[QLatin1String("id")].isString()) {
song_id = json_obj[QLatin1String("id")].toString();
}
else {
song_id = QString::number(json_obj[QStringLiteral("id")].toInt());
song_id = QString::number(json_obj[QLatin1String("id")].toInt());
}
QString title = json_obj[QStringLiteral("title")].toString();
int track = json_obj[QStringLiteral("track_number")].toInt();
QString title = json_obj[QLatin1String("title")].toString();
int track = json_obj[QLatin1String("track_number")].toInt();
int disc = 0;
QString copyright = json_obj[QStringLiteral("copyright")].toString();
qint64 duration = json_obj[QStringLiteral("duration")].toInt() * kNsecPerSec;
QString copyright = json_obj[QLatin1String("copyright")].toString();
qint64 duration = json_obj[QLatin1String("duration")].toInt() * kNsecPerSec;
//bool streamable = json_obj["streamable"].toBool();
QString composer;
QString performer;
if (json_obj.contains(QStringLiteral("media_number"))) {
disc = json_obj[QStringLiteral("media_number")].toInt();
if (json_obj.contains(QLatin1String("media_number"))) {
disc = json_obj[QLatin1String("media_number")].toInt();
}
Artist song_artist = album_artist;
Album song_album = album;
if (json_obj.contains(QStringLiteral("album"))) {
if (json_obj.contains(QLatin1String("album"))) {
QJsonValue value_album = json_obj[QStringLiteral("album")];
QJsonValue value_album = json_obj[QLatin1String("album")];
if (!value_album.isObject()) {
Error(QStringLiteral("Invalid Json reply, album is not an object."), value_album);
return;
}
QJsonObject obj_album = value_album.toObject();
if (obj_album.contains(QStringLiteral("id"))) {
if (obj_album[QStringLiteral("id")].isString()) {
song_album.album_id = obj_album[QStringLiteral("id")].toString();
if (obj_album.contains(QLatin1String("id"))) {
if (obj_album[QLatin1String("id")].isString()) {
song_album.album_id = obj_album[QLatin1String("id")].toString();
}
else {
song_album.album_id = QString::number(obj_album[QStringLiteral("id")].toInt());
song_album.album_id = QString::number(obj_album[QLatin1String("id")].toInt());
}
}
if (obj_album.contains(QStringLiteral("title"))) {
song_album.album = obj_album[QStringLiteral("title")].toString();
if (obj_album.contains(QLatin1String("title"))) {
song_album.album = obj_album[QLatin1String("title")].toString();
}
if (obj_album.contains(QStringLiteral("artist"))) {
QJsonValue value_artist = obj_album[QStringLiteral("artist")];
if (obj_album.contains(QLatin1String("artist"))) {
QJsonValue value_artist = obj_album[QLatin1String("artist")];
if (!value_artist.isObject()) {
Error(QStringLiteral("Invalid Json reply, album artist is not a object."), value_artist);
return;
}
QJsonObject obj_artist = value_artist.toObject();
if (!obj_artist.contains(QStringLiteral("id")) || !obj_artist.contains(QStringLiteral("name"))) {
if (!obj_artist.contains(QLatin1String("id")) || !obj_artist.contains(QLatin1String("name"))) {
Error(QStringLiteral("Invalid Json reply, album artist is missing id or name."), obj_artist);
return;
}
if (obj_artist[QStringLiteral("id")].isString()) {
song_artist.artist_id = obj_artist[QStringLiteral("id")].toString();
if (obj_artist[QLatin1String("id")].isString()) {
song_artist.artist_id = obj_artist[QLatin1String("id")].toString();
}
else {
song_artist.artist_id = QString::number(obj_artist[QStringLiteral("id")].toInt());
song_artist.artist_id = QString::number(obj_artist[QLatin1String("id")].toInt());
}
song_artist.artist = obj_artist[QStringLiteral("name")].toString();
song_artist.artist = obj_artist[QLatin1String("name")].toString();
}
if (obj_album.contains(QStringLiteral("image"))) {
QJsonValue value_image = obj_album[QStringLiteral("image")];
if (obj_album.contains(QLatin1String("image"))) {
QJsonValue value_image = obj_album[QLatin1String("image")];
if (!value_image.isObject()) {
Error(QStringLiteral("Invalid Json reply, album image is not a object."), value_image);
return;
}
QJsonObject obj_image = value_image.toObject();
if (!obj_image.contains(QStringLiteral("large"))) {
if (!obj_image.contains(QLatin1String("large"))) {
Error(QStringLiteral("Invalid Json reply, album image is missing large."), obj_image);
return;
}
QString album_image = obj_image[QStringLiteral("large")].toString();
QString album_image = obj_image[QLatin1String("large")].toString();
if (!album_image.isEmpty()) {
song_album.cover_url.setUrl(album_image);
}
}
}
if (json_obj.contains(QStringLiteral("composer"))) {
QJsonValue value_composer = json_obj[QStringLiteral("composer")];
if (json_obj.contains(QLatin1String("composer"))) {
QJsonValue value_composer = json_obj[QLatin1String("composer")];
if (!value_composer.isObject()) {
Error(QStringLiteral("Invalid Json reply, track composer is not a object."), value_composer);
return;
}
QJsonObject obj_composer = value_composer.toObject();
if (!obj_composer.contains(QStringLiteral("id")) || !obj_composer.contains(QStringLiteral("name"))) {
if (!obj_composer.contains(QLatin1String("id")) || !obj_composer.contains(QLatin1String("name"))) {
Error(QStringLiteral("Invalid Json reply, track composer is missing id or name."), obj_composer);
return;
}
composer = obj_composer[QStringLiteral("name")].toString();
composer = obj_composer[QLatin1String("name")].toString();
}
if (json_obj.contains(QStringLiteral("performer"))) {
QJsonValue value_performer = json_obj[QStringLiteral("performer")];
if (json_obj.contains(QLatin1String("performer"))) {
QJsonValue value_performer = json_obj[QLatin1String("performer")];
if (!value_performer.isObject()) {
Error(QStringLiteral("Invalid Json reply, track performer is not a object."), value_performer);
return;
}
QJsonObject obj_performer = value_performer.toObject();
if (!obj_performer.contains(QStringLiteral("id")) || !obj_performer.contains(QStringLiteral("name"))) {
if (!obj_performer.contains(QLatin1String("id")) || !obj_performer.contains(QLatin1String("name"))) {
Error(QStringLiteral("Invalid Json reply, track performer is missing id or name."), obj_performer);
return;
}
performer = obj_performer[QStringLiteral("name")].toString();
performer = obj_performer[QLatin1String("name")].toString();
}
//if (!streamable) {

34
src/qobuz/qobuzservice.cpp
View File

@ -329,9 +329,9 @@ void QobuzService::HandleAuthReply(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(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();
if (!json_obj.isEmpty() && json_obj.contains(QLatin1String("status")) && json_obj.contains(QLatin1String("code")) && json_obj.contains(QLatin1String("message"))) {
int code = json_obj[QLatin1String("code")].toInt();
QString message = json_obj[QLatin1String("message")].toString();
login_errors_ << QStringLiteral("%1 (%2)").arg(message).arg(code);
}
}
@ -375,62 +375,62 @@ void QobuzService::HandleAuthReply(QNetworkReply *reply) {
return;
}
if (!json_obj.contains(QStringLiteral("user_auth_token"))) {
if (!json_obj.contains(QLatin1String("user_auth_token"))) {
LoginError(QStringLiteral("Authentication reply from server is missing user_auth_token"), json_obj);
return;
}
user_auth_token_ = json_obj[QStringLiteral("user_auth_token")].toString();
user_auth_token_ = json_obj[QLatin1String("user_auth_token")].toString();
if (!json_obj.contains(QStringLiteral("user"))) {
if (!json_obj.contains(QLatin1String("user"))) {
LoginError(QStringLiteral("Authentication reply from server is missing user"), json_obj);
return;
}
QJsonValue value_user = json_obj[QStringLiteral("user")];
QJsonValue value_user = json_obj[QLatin1String("user")];
if (!value_user.isObject()) {
LoginError(QStringLiteral("Authentication reply user is not a object"), json_obj);
return;
}
QJsonObject obj_user = value_user.toObject();
if (!obj_user.contains(QStringLiteral("id"))) {
if (!obj_user.contains(QLatin1String("id"))) {
LoginError(QStringLiteral("Authentication reply from server is missing user id"), obj_user);
return;
}
user_id_ = obj_user[QStringLiteral("id")].toInt();
user_id_ = obj_user[QLatin1String("id")].toInt();
if (!obj_user.contains(QStringLiteral("device"))) {
if (!obj_user.contains(QLatin1String("device"))) {
LoginError(QStringLiteral("Authentication reply from server is missing user device"), obj_user);
return;
}
QJsonValue value_device = obj_user[QStringLiteral("device")];
QJsonValue value_device = obj_user[QLatin1String("device")];
if (!value_device.isObject()) {
LoginError(QStringLiteral("Authentication reply from server user device is not a object"), value_device);
return;
}
QJsonObject obj_device = value_device.toObject();
if (!obj_device.contains(QStringLiteral("device_manufacturer_id"))) {
if (!obj_device.contains(QLatin1String("device_manufacturer_id"))) {
LoginError(QStringLiteral("Authentication reply from server device is missing device_manufacturer_id"), obj_device);
return;
}
device_id_ = obj_device[QStringLiteral("device_manufacturer_id")].toString();
device_id_ = obj_device[QLatin1String("device_manufacturer_id")].toString();
if (!obj_user.contains(QStringLiteral("credential"))) {
if (!obj_user.contains(QLatin1String("credential"))) {
LoginError(QStringLiteral("Authentication reply from server is missing user credential"), obj_user);
return;
}
QJsonValue value_credential = obj_user[QStringLiteral("credential")];
QJsonValue value_credential = obj_user[QLatin1String("credential")];
if (!value_credential.isObject()) {
LoginError(QStringLiteral("Authentication reply from serve userr credential is not a object"), value_device);
return;
}
QJsonObject obj_credential = value_credential.toObject();
if (!obj_credential.contains(QStringLiteral("id"))) {
if (!obj_credential.contains(QLatin1String("id"))) {
LoginError(QStringLiteral("Authentication reply user credential from server is missing user credential id"), obj_credential);
return;
}
credential_id_ = obj_credential[QStringLiteral("id")].toInt();
credential_id_ = obj_credential[QLatin1String("id")].toInt();
Settings s;
s.beginGroup(QobuzSettingsPage::kSettingsGroup);

22
src/qobuz/qobuzstreamurlrequest.cpp
View File

@ -168,27 +168,27 @@ void QobuzStreamURLRequest::StreamURLReceived() {
return;
}
if (!json_obj.contains(QStringLiteral("track_id"))) {
if (!json_obj.contains(QLatin1String("track_id"))) {
Error(QStringLiteral("Invalid Json reply, stream url is missing track_id."), json_obj);
emit StreamURLFailure(id_, media_url_, errors_.first());
return;
}
int track_id = json_obj[QStringLiteral("track_id")].toInt();
int track_id = json_obj[QLatin1String("track_id")].toInt();
if (track_id != song_id_) {
Error(QStringLiteral("Incorrect track ID returned."), json_obj);
emit StreamURLFailure(id_, media_url_, errors_.first());
return;
}
if (!json_obj.contains(QStringLiteral("mime_type")) || !json_obj.contains(QStringLiteral("url"))) {
if (!json_obj.contains(QLatin1String("mime_type")) || !json_obj.contains(QLatin1String("url"))) {
Error(QStringLiteral("Invalid Json reply, stream url is missing url or mime_type."), json_obj);
emit StreamURLFailure(id_, media_url_, errors_.first());
return;
}
QUrl url(json_obj[QStringLiteral("url")].toString());
QString mimetype = json_obj[QStringLiteral("mime_type")].toString();
QUrl url(json_obj[QLatin1String("url")].toString());
QString mimetype = json_obj[QLatin1String("mime_type")].toString();
Song::FileType filetype(Song::FileType::Unknown);
QMimeDatabase mimedb;
@ -209,16 +209,16 @@ void QobuzStreamURLRequest::StreamURLReceived() {
}
qint64 duration = -1;
if (json_obj.contains(QStringLiteral("duration"))) {
duration = json_obj[QStringLiteral("duration")].toInt() * kNsecPerSec;
if (json_obj.contains(QLatin1String("duration"))) {
duration = json_obj[QLatin1String("duration")].toInt() * kNsecPerSec;
}
int samplerate = -1;
if (json_obj.contains(QStringLiteral("sampling_rate"))) {
samplerate = static_cast<int>(json_obj[QStringLiteral("sampling_rate")].toDouble()) * 1000;
if (json_obj.contains(QLatin1String("sampling_rate"))) {
samplerate = static_cast<int>(json_obj[QLatin1String("sampling_rate")].toDouble()) * 1000;
}
int bit_depth = -1;
if (json_obj.contains(QStringLiteral("bit_depth"))) {
bit_depth = static_cast<int>(json_obj[QStringLiteral("bit_depth")].toDouble());
if (json_obj.contains(QLatin1String("bit_depth"))) {
bit_depth = static_cast<int>(json_obj[QLatin1String("bit_depth")].toDouble());
}
emit StreamURLSuccess(id_, media_url_, url, filetype, samplerate, bit_depth, duration);

18
src/radios/radioparadiseservice.cpp
View File

@ -80,35 +80,35 @@ void RadioParadiseService::GetChannelsReply(QNetworkReply *reply, const int task
return;
}
if (!object.contains(QStringLiteral("channels")) || !object[QStringLiteral("channels")].isArray()) {
if (!object.contains(QLatin1String("channels")) || !object[QLatin1String("channels")].isArray()) {
Error(QStringLiteral("Missing JSON channels array."), object);
app_->task_manager()->SetTaskFinished(task_id);
emit NewChannels();
return;
}
QJsonArray array_channels = object[QStringLiteral("channels")].toArray();
QJsonArray array_channels = object[QLatin1String("channels")].toArray();
RadioChannelList channels;
for (const QJsonValueRef value_channel : array_channels) {
if (!value_channel.isObject()) continue;
QJsonObject obj_channel = value_channel.toObject();
if (!obj_channel.contains(QStringLiteral("chan_name")) || !obj_channel.contains(QStringLiteral("streams"))) {
if (!obj_channel.contains(QLatin1String("chan_name")) || !obj_channel.contains(QLatin1String("streams"))) {
continue;
}
QString name = obj_channel[QStringLiteral("chan_name")].toString();
QJsonValue value_streams = obj_channel[QStringLiteral("streams")];
QString name = obj_channel[QLatin1String("chan_name")].toString();
QJsonValue value_streams = obj_channel[QLatin1String("streams")];
if (!value_streams.isArray()) {
continue;
}
QJsonArray array_streams = obj_channel[QStringLiteral("streams")].toArray();
QJsonArray array_streams = obj_channel[QLatin1String("streams")].toArray();
for (const QJsonValueRef value_stream : array_streams) {
if (!value_stream.isObject()) continue;
QJsonObject obj_stream = value_stream.toObject();
if (!obj_stream.contains(QStringLiteral("label")) || !obj_stream.contains(QStringLiteral("url"))) {
if (!obj_stream.contains(QLatin1String("label")) || !obj_stream.contains(QLatin1String("url"))) {
continue;
}
QString label = obj_stream[QStringLiteral("label")].toString();
QString url = obj_stream[QStringLiteral("url")].toString();
QString label = obj_stream[QLatin1String("label")].toString();
QString url = obj_stream[QLatin1String("url")].toString();
if (!url.contains(QRegularExpression(QStringLiteral("^[0-9a-zA-Z]*:\\/\\/"), QRegularExpression::CaseInsensitiveOption))) {
url.prepend(QStringLiteral("https://"));
}

22
src/radios/somafmservice.cpp
View File

@ -86,39 +86,39 @@ void SomaFMService::GetChannelsReply(QNetworkReply *reply, const int task_id) {
return;
}
if (!object.contains(QStringLiteral("channels")) || !object[QStringLiteral("channels")].isArray()) {
if (!object.contains(QLatin1String("channels")) || !object[QLatin1String("channels")].isArray()) {
Error(QStringLiteral("Missing JSON channels array."), object);
app_->task_manager()->SetTaskFinished(task_id);
emit NewChannels();
return;
}
QJsonArray array_channels = object[QStringLiteral("channels")].toArray();
QJsonArray array_channels = object[QLatin1String("channels")].toArray();
RadioChannelList channels;
for (const QJsonValueRef value_channel : array_channels) {
if (!value_channel.isObject()) continue;
QJsonObject obj_channel = value_channel.toObject();
if (!obj_channel.contains(QStringLiteral("title")) || !obj_channel.contains(QStringLiteral("image"))) {
if (!obj_channel.contains(QLatin1String("title")) || !obj_channel.contains(QLatin1String("image"))) {
continue;
}
QString name = obj_channel[QStringLiteral("title")].toString();
QString image = obj_channel[QStringLiteral("image")].toString();
QJsonArray playlists = obj_channel[QStringLiteral("playlists")].toArray();
QString name = obj_channel[QLatin1String("title")].toString();
QString image = obj_channel[QLatin1String("image")].toString();
QJsonArray playlists = obj_channel[QLatin1String("playlists")].toArray();
for (const QJsonValueRef playlist : playlists) {
if (!playlist.isObject()) continue;
QJsonObject obj_playlist = playlist.toObject();
if (!obj_playlist.contains(QStringLiteral("url")) || !obj_playlist.contains(QStringLiteral("quality"))) {
if (!obj_playlist.contains(QLatin1String("url")) || !obj_playlist.contains(QLatin1String("quality"))) {
continue;
}
RadioChannel channel;
QString quality = obj_playlist[QStringLiteral("quality")].toString();
QString quality = obj_playlist[QLatin1String("quality")].toString();
if (quality != QStringLiteral("highest")) continue;
channel.source = source_;
channel.name = name;
channel.url.setUrl(obj_playlist[QStringLiteral("url")].toString());
channel.url.setUrl(obj_playlist[QLatin1String("url")].toString());
channel.thumbnail_url.setUrl(image);
if (obj_playlist.contains(QStringLiteral("format"))) {
channel.name.append(QLatin1Char(' ') + obj_playlist[QStringLiteral("format")].toString().toUpper());
if (obj_playlist.contains(QLatin1String("format"))) {
channel.name.append(QLatin1Char(' ') + obj_playlist[QLatin1String("format")].toString().toUpper());
}
channels << channel;
}

122
src/scrobbler/lastfmimport.cpp
View File

@ -155,9 +155,9 @@ QByteArray LastFMImport::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(QStringLiteral("error")) && json_obj.contains(QStringLiteral("message"))) {
int error_code = json_obj[QStringLiteral("error")].toInt();
QString error_message = json_obj[QStringLiteral("message")].toString();
if (json_obj.contains(QLatin1String("error")) && json_obj.contains(QLatin1String("message"))) {
int error_code = json_obj[QLatin1String("error")].toInt();
QString error_message = json_obj[QLatin1String("message")].toString();
error = QStringLiteral("%1 (%2)").arg(error_message).arg(error_code);
}
}
@ -287,62 +287,62 @@ void LastFMImport::GetRecentTracksRequestFinished(QNetworkReply *reply, const in
return;
}
if (json_obj.contains(QStringLiteral("error")) && json_obj.contains(QStringLiteral("message"))) {
int error_code = json_obj[QStringLiteral("error")].toInt();
QString error_message = json_obj[QStringLiteral("message")].toString();
if (json_obj.contains(QLatin1String("error")) && json_obj.contains(QLatin1String("message"))) {
int error_code = json_obj[QLatin1String("error")].toInt();
QString error_message = json_obj[QLatin1String("message")].toString();
QString error_reason = QStringLiteral("%1 (%2)").arg(error_message).arg(error_code);
Error(error_reason);
return;
}
if (!json_obj.contains(QStringLiteral("recenttracks"))) {
if (!json_obj.contains(QLatin1String("recenttracks"))) {
Error(QStringLiteral("JSON reply from server is missing recenttracks."), json_obj);
return;
}
if (!json_obj[QStringLiteral("recenttracks")].isObject()) {
if (!json_obj[QLatin1String("recenttracks")].isObject()) {
Error(QStringLiteral("Failed to parse JSON: recenttracks is not an object!"), json_obj);
return;
}
json_obj = json_obj[QStringLiteral("recenttracks")].toObject();
json_obj = json_obj[QLatin1String("recenttracks")].toObject();
if (!json_obj.contains(QStringLiteral("@attr"))) {
if (!json_obj.contains(QLatin1String("@attr"))) {
Error(QStringLiteral("JSON reply from server is missing @attr."), json_obj);
return;
}
if (!json_obj.contains(QStringLiteral("track"))) {
if (!json_obj.contains(QLatin1String("track"))) {
Error(QStringLiteral("JSON reply from server is missing track."), json_obj);
return;
}
if (!json_obj[QStringLiteral("@attr")].isObject()) {
if (!json_obj[QLatin1String("@attr")].isObject()) {
Error(QStringLiteral("Failed to parse JSON: @attr is not an object."), json_obj);
return;
}
if (!json_obj[QStringLiteral("track")].isArray()) {
if (!json_obj[QLatin1String("track")].isArray()) {
Error(QStringLiteral("Failed to parse JSON: track is not an object."), json_obj);
return;
}
QJsonObject obj_attr = json_obj[QStringLiteral("@attr")].toObject();
QJsonObject obj_attr = json_obj[QLatin1String("@attr")].toObject();
if (!obj_attr.contains(QStringLiteral("page"))) {
if (!obj_attr.contains(QLatin1String("page"))) {
Error(QStringLiteral("Failed to parse JSON: attr object is missing page."), json_obj);
return;
}
if (!obj_attr.contains(QStringLiteral("totalPages"))) {
if (!obj_attr.contains(QLatin1String("totalPages"))) {
Error(QStringLiteral("Failed to parse JSON: attr object is missing totalPages."), json_obj);
return;
}
if (!obj_attr.contains(QStringLiteral("total"))) {
if (!obj_attr.contains(QLatin1String("total"))) {
Error(QStringLiteral("Failed to parse JSON: attr object is missing total."), json_obj);
return;
}
int total = obj_attr[QStringLiteral("total")].toString().toInt();
int pages = obj_attr[QStringLiteral("totalPages")].toString().toInt();
int total = obj_attr[QLatin1String("total")].toString().toInt();
int pages = obj_attr[QLatin1String("totalPages")].toString().toInt();
if (page == 0) {
lastplayed_total_ = total;
@ -351,7 +351,7 @@ void LastFMImport::GetRecentTracksRequestFinished(QNetworkReply *reply, const in
}
else {
QJsonArray array_track = json_obj[QStringLiteral("track")].toArray();
QJsonArray array_track = json_obj[QLatin1String("track")].toArray();
for (const QJsonValueRef value_track : array_track) {
@ -361,29 +361,29 @@ void LastFMImport::GetRecentTracksRequestFinished(QNetworkReply *reply, const in
continue;
}
QJsonObject obj_track = value_track.toObject();
if (!obj_track.contains(QStringLiteral("artist")) ||
!obj_track.contains(QStringLiteral("album")) ||
!obj_track.contains(QStringLiteral("name")) ||
!obj_track.contains(QStringLiteral("date")) ||
!obj_track[QStringLiteral("artist")].isObject() ||
!obj_track[QStringLiteral("album")].isObject() ||
!obj_track[QStringLiteral("date")].isObject()
if (!obj_track.contains(QLatin1String("artist")) ||
!obj_track.contains(QLatin1String("album")) ||
!obj_track.contains(QLatin1String("name")) ||
!obj_track.contains(QLatin1String("date")) ||
!obj_track[QLatin1String("artist")].isObject() ||
!obj_track[QLatin1String("album")].isObject() ||
!obj_track[QLatin1String("date")].isObject()
) {
continue;
}
QJsonObject obj_artist = obj_track[QStringLiteral("artist")].toObject();
QJsonObject obj_album = obj_track[QStringLiteral("album")].toObject();
QJsonObject obj_date = obj_track[QStringLiteral("date")].toObject();
QJsonObject obj_artist = obj_track[QLatin1String("artist")].toObject();
QJsonObject obj_album = obj_track[QLatin1String("album")].toObject();
QJsonObject obj_date = obj_track[QLatin1String("date")].toObject();
if (!obj_artist.contains(QStringLiteral("#text")) || !obj_album.contains(QStringLiteral("#text")) || !obj_date.contains(QStringLiteral("#text"))) {
if (!obj_artist.contains(QLatin1String("#text")) || !obj_album.contains(QLatin1String("#text")) || !obj_date.contains(QLatin1String("#text"))) {
continue;
}
QString artist = obj_artist[QStringLiteral("#text")].toString();
QString album = obj_album[QStringLiteral("#text")].toString();
QString date = obj_date[QStringLiteral("#text")].toString();
QString title = obj_track[QStringLiteral("name")].toString();
QString artist = obj_artist[QLatin1String("#text")].toString();
QString album = obj_album[QLatin1String("#text")].toString();
QString date = obj_date[QLatin1String("#text")].toString();
QString title = obj_track[QLatin1String("name")].toString();
QDateTime datetime = QDateTime::fromString(date, QStringLiteral("dd MMM yyyy, hh:mm"));
if (datetime.isValid()) {
emit UpdateLastPlayed(artist, album, title, datetime.toSecsSinceEpoch());
@ -450,62 +450,62 @@ void LastFMImport::GetTopTracksRequestFinished(QNetworkReply *reply, const int p
return;
}
if (json_obj.contains(QStringLiteral("error")) && json_obj.contains(QStringLiteral("message"))) {
int error_code = json_obj[QStringLiteral("error")].toInt();
QString error_message = json_obj[QStringLiteral("message")].toString();
if (json_obj.contains(QLatin1String("error")) && json_obj.contains(QLatin1String("message"))) {
int error_code = json_obj[QLatin1String("error")].toInt();
QString error_message = json_obj[QLatin1String("message")].toString();
QString error_reason = QStringLiteral("%1 (%2)").arg(error_message).arg(error_code);
Error(error_reason);
return;
}
if (!json_obj.contains(QStringLiteral("toptracks"))) {
if (!json_obj.contains(QLatin1String("toptracks"))) {
Error(QStringLiteral("JSON reply from server is missing toptracks."), json_obj);
return;
}
if (!json_obj[QStringLiteral("toptracks")].isObject()) {
if (!json_obj[QLatin1String("toptracks")].isObject()) {
Error(QStringLiteral("Failed to parse JSON: toptracks is not an object!"), json_obj);
return;
}
json_obj = json_obj[QStringLiteral("toptracks")].toObject();
json_obj = json_obj[QLatin1String("toptracks")].toObject();
if (!json_obj.contains(QStringLiteral("@attr"))) {
if (!json_obj.contains(QLatin1String("@attr"))) {
Error(QStringLiteral("JSON reply from server is missing @attr."), json_obj);
return;
}
if (!json_obj.contains(QStringLiteral("track"))) {
if (!json_obj.contains(QLatin1String("track"))) {
Error(QStringLiteral("JSON reply from server is missing track."), json_obj);
return;
}
if (!json_obj[QStringLiteral("@attr")].isObject()) {
if (!json_obj[QLatin1String("@attr")].isObject()) {
Error(QStringLiteral("Failed to parse JSON: @attr is not an object."), json_obj);
return;
}
if (!json_obj[QStringLiteral("track")].isArray()) {
if (!json_obj[QLatin1String("track")].isArray()) {
Error(QStringLiteral("Failed to parse JSON: track is not an object."), json_obj);
return;
}
QJsonObject obj_attr = json_obj[QStringLiteral("@attr")].toObject();
QJsonObject obj_attr = json_obj[QLatin1String("@attr")].toObject();
if (!obj_attr.contains(QStringLiteral("page"))) {
if (!obj_attr.contains(QLatin1String("page"))) {
Error(QStringLiteral("Failed to parse JSON: attr object is missing page."), json_obj);
return;
}
if (!obj_attr.contains(QStringLiteral("totalPages"))) {
if (!obj_attr.contains(QLatin1String("totalPages"))) {
Error(QStringLiteral("Failed to parse JSON: attr object is missing page."), json_obj);
return;
}
if (!obj_attr.contains(QStringLiteral("total"))) {
if (!obj_attr.contains(QLatin1String("total"))) {
Error(QStringLiteral("Failed to parse JSON: attr object is missing total."), json_obj);
return;
}
int pages = obj_attr[QStringLiteral("totalPages")].toString().toInt();
int total = obj_attr[QStringLiteral("total")].toString().toInt();
int pages = obj_attr[QLatin1String("totalPages")].toString().toInt();
int total = obj_attr[QLatin1String("total")].toString().toInt();
if (page == 0) {
playcount_total_ = total;
@ -514,7 +514,7 @@ void LastFMImport::GetTopTracksRequestFinished(QNetworkReply *reply, const int p
}
else {
QJsonArray array_track = json_obj[QStringLiteral("track")].toArray();
QJsonArray array_track = json_obj[QLatin1String("track")].toArray();
for (QJsonArray::iterator it = array_track.begin(); it != array_track.end(); ++it) {
const QJsonValue &value_track = *it;
@ -526,22 +526,22 @@ void LastFMImport::GetTopTracksRequestFinished(QNetworkReply *reply, const int p
}
QJsonObject obj_track = value_track.toObject();
if (!obj_track.contains(QStringLiteral("artist")) ||
!obj_track.contains(QStringLiteral("name")) ||
!obj_track.contains(QStringLiteral("playcount")) ||
!obj_track[QStringLiteral("artist")].isObject()
if (!obj_track.contains(QLatin1String("artist")) ||
!obj_track.contains(QLatin1String("name")) ||
!obj_track.contains(QLatin1String("playcount")) ||
!obj_track[QLatin1String("artist")].isObject()
) {
continue;
}
QJsonObject obj_artist = obj_track[QStringLiteral("artist")].toObject();
if (!obj_artist.contains(QStringLiteral("name"))) {
QJsonObject obj_artist = obj_track[QLatin1String("artist")].toObject();
if (!obj_artist.contains(QLatin1String("name"))) {
continue;
}
QString artist = obj_artist[QStringLiteral("name")].toString();
QString title = obj_track[QStringLiteral("name")].toString();
int playcount = obj_track[QStringLiteral("playcount")].toString().toInt();
QString artist = obj_artist[QLatin1String("name")].toString();
QString title = obj_track[QLatin1String("name")].toString();
int playcount = obj_track[QLatin1String("playcount")].toString().toInt();
if (playcount <= 0) continue;

86
src/scrobbler/listenbrainzscrobbler.cpp
View File

@ -249,12 +249,12 @@ ListenBrainzScrobbler::ReplyResult ListenBrainzScrobbler::GetJsonObject(QNetwork
if (reply->error() == QNetworkReply::NoError || reply->error() >= 200) {
const QByteArray data = reply->readAll();
if (!data.isEmpty() && ExtractJsonObj(data, json_obj, error_description)) {
if (json_obj.contains(QStringLiteral("error")) && json_obj.contains(QStringLiteral("error_description"))) {
error_description = json_obj[QStringLiteral("error_description")].toString();
if (json_obj.contains(QLatin1String("error")) && json_obj.contains(QLatin1String("error_description"))) {
error_description = json_obj[QLatin1String("error_description")].toString();
reply_error_type = ReplyResult::APIError;
}
else if (json_obj.contains(QStringLiteral("code")) && json_obj.contains(QStringLiteral("error"))) {
error_description = QStringLiteral("%1 (%2)").arg(json_obj[QStringLiteral("error")].toString()).arg(json_obj[QStringLiteral("code")].toInt());
else if (json_obj.contains(QLatin1String("code")) && json_obj.contains(QLatin1String("error"))) {
error_description = QStringLiteral("%1 (%2)").arg(json_obj[QLatin1String("error")].toString()).arg(json_obj[QLatin1String("code")].toInt());
reply_error_type = ReplyResult::APIError;
}
}
@ -319,16 +319,16 @@ void ListenBrainzScrobbler::AuthenticateReplyFinished(QNetworkReply *reply) {
return;
}
if (!json_obj.contains(QStringLiteral("access_token")) || !json_obj.contains(QStringLiteral("expires_in")) || !json_obj.contains(QStringLiteral("token_type"))) {
if (!json_obj.contains(QLatin1String("access_token")) || !json_obj.contains(QLatin1String("expires_in")) || !json_obj.contains(QLatin1String("token_type"))) {
AuthError(QStringLiteral("Json access_token, expires_in or token_type is missing."));
return;
}
access_token_ = json_obj[QStringLiteral("access_token")].toString();
expires_in_ = json_obj[QStringLiteral("expires_in")].toInt();
token_type_ = json_obj[QStringLiteral("token_type")].toString();
if (json_obj.contains(QStringLiteral("refresh_token"))) {
refresh_token_ = json_obj[QStringLiteral("refresh_token")].toString();
access_token_ = json_obj[QLatin1String("access_token")].toString();
expires_in_ = json_obj[QLatin1String("expires_in")].toInt();
token_type_ = json_obj[QLatin1String("token_type")].toString();
if (json_obj.contains(QLatin1String("refresh_token"))) {
refresh_token_ = json_obj[QLatin1String("refresh_token")].toString();
}
login_time_ = QDateTime::currentDateTime().toSecsSinceEpoch();
@ -373,32 +373,32 @@ QJsonObject ListenBrainzScrobbler::JsonTrackMetadata(const ScrobbleMetadata &met
QJsonObject object_track_metadata;
if (prefer_albumartist_) {
object_track_metadata.insert(QStringLiteral("artist_name"), QJsonValue::fromVariant(metadata.effective_albumartist()));
object_track_metadata.insert(QLatin1String("artist_name"), QJsonValue::fromVariant(metadata.effective_albumartist()));
}
else {
object_track_metadata.insert(QStringLiteral("artist_name"), QJsonValue::fromVariant(metadata.artist));
object_track_metadata.insert(QLatin1String("artist_name"), QJsonValue::fromVariant(metadata.artist));
}
if (!metadata.album.isEmpty()) {
object_track_metadata.insert(QStringLiteral("release_name"), QJsonValue::fromVariant(StripAlbum(metadata.album)));
object_track_metadata.insert(QLatin1String("release_name"), QJsonValue::fromVariant(StripAlbum(metadata.album)));
}
object_track_metadata.insert(QStringLiteral("track_name"), QJsonValue::fromVariant(StripTitle(metadata.title)));
object_track_metadata.insert(QLatin1String("track_name"), QJsonValue::fromVariant(StripTitle(metadata.title)));
QJsonObject object_additional_info;
if (metadata.length_nanosec > 0) {
object_additional_info.insert(QStringLiteral("duration_ms"), metadata.length_nanosec / kNsecPerMsec);
object_additional_info.insert(QLatin1String("duration_ms"), metadata.length_nanosec / kNsecPerMsec);
}
if (metadata.track > 0) {
object_additional_info.insert(QStringLiteral("tracknumber"), metadata.track);
object_additional_info.insert(QLatin1String("tracknumber"), metadata.track);
}
object_additional_info.insert(QStringLiteral("media_player"), QCoreApplication::applicationName());
object_additional_info.insert(QStringLiteral("media_player_version"), QCoreApplication::applicationVersion());
object_additional_info.insert(QStringLiteral("submission_client"), QCoreApplication::applicationName());
object_additional_info.insert(QStringLiteral("submission_client_version"), QCoreApplication::applicationVersion());
object_additional_info.insert(QLatin1String("media_player"), QCoreApplication::applicationName());
object_additional_info.insert(QLatin1String("media_player_version"), QCoreApplication::applicationVersion());
object_additional_info.insert(QLatin1String("submission_client"), QCoreApplication::applicationName());
object_additional_info.insert(QLatin1String("submission_client_version"), QCoreApplication::applicationVersion());
QStringList artist_mbids_list;
if (!metadata.musicbrainz_album_artist_id.isEmpty()) {
@ -418,28 +418,28 @@ QJsonObject ListenBrainzScrobbler::JsonTrackMetadata(const ScrobbleMetadata &met
}
}
if (!artist_mbids_array.isEmpty()) {
object_additional_info.insert(QStringLiteral("artist_mbids"), artist_mbids_array);
object_additional_info.insert(QLatin1String("artist_mbids"), artist_mbids_array);
}
}
if (!metadata.musicbrainz_album_id.isEmpty()) {
object_additional_info.insert(QStringLiteral("release_mbid"), metadata.musicbrainz_album_id);
object_additional_info.insert(QLatin1String("release_mbid"), metadata.musicbrainz_album_id);
}
else if (!metadata.musicbrainz_original_album_id.isEmpty()) {
object_additional_info.insert(QStringLiteral("release_mbid"), metadata.musicbrainz_original_album_id);
object_additional_info.insert(QLatin1String("release_mbid"), metadata.musicbrainz_original_album_id);
}
if (!metadata.musicbrainz_recording_id.isEmpty()) {
object_additional_info.insert(QStringLiteral("recording_mbid"), metadata.musicbrainz_recording_id);
object_additional_info.insert(QLatin1String("recording_mbid"), metadata.musicbrainz_recording_id);
}
if (!metadata.musicbrainz_track_id.isEmpty()) {
object_additional_info.insert(QStringLiteral("track_mbid"), metadata.musicbrainz_track_id);
object_additional_info.insert(QLatin1String("track_mbid"), metadata.musicbrainz_track_id);
}
if (!metadata.musicbrainz_work_id.isEmpty()) {
object_additional_info.insert(QStringLiteral("work_mbids"), QJsonArray() << metadata.musicbrainz_work_id);
object_additional_info.insert(QLatin1String("work_mbids"), QJsonArray() << metadata.musicbrainz_work_id);
}
object_track_metadata.insert(QStringLiteral("additional_info"), object_additional_info);
object_track_metadata.insert(QLatin1String("additional_info"), object_additional_info);
return object_track_metadata;
@ -456,15 +456,15 @@ void ListenBrainzScrobbler::UpdateNowPlaying(const Song &song) {
if (!song.is_metadata_good() || !authenticated() || settings_->offline()) return;
QJsonObject object_listen;
object_listen.insert(QStringLiteral("track_metadata"), JsonTrackMetadata(ScrobbleMetadata(song)));
object_listen.insert(QLatin1String("track_metadata"), JsonTrackMetadata(ScrobbleMetadata(song)));
QJsonArray array_payload;
array_payload.append(object_listen);
QJsonObject object;
object.insert(QStringLiteral("listen_type"), QStringLiteral("playing_now"));
object.insert(QStringLiteral("payload"), array_payload);
object.insert(QLatin1String("listen_type"), QLatin1String("playing_now"));
object.insert(QLatin1String("payload"), array_payload);
QJsonDocument doc(object);
QUrl url(QStringLiteral("%1/1/submit-listens").arg(QLatin1String(kApiUrl)));
QUrl url(QLatin1String("%1/1/submit-listens").arg(QLatin1String(kApiUrl)));
QNetworkReply *reply = CreateRequest(url, doc);
QObject::connect(reply, &QNetworkReply::finished, this, [this, reply]() { UpdateNowPlayingRequestFinished(reply); });
@ -484,12 +484,12 @@ void ListenBrainzScrobbler::UpdateNowPlayingRequestFinished(QNetworkReply *reply
return;
}
if (!json_obj.contains(QStringLiteral("status"))) {
if (!json_obj.contains(QLatin1String("status"))) {
Error(QStringLiteral("Now playing request is missing status from server."));
return;
}
QString status = json_obj[QStringLiteral("status")].toString();
QString status = json_obj[QLatin1String("status")].toString();
if (status.compare(QLatin1String("ok"), Qt::CaseInsensitive) != 0) {
Error(QStringLiteral("Received %1 status for now playing.").arg(status));
}
@ -552,8 +552,8 @@ void ListenBrainzScrobbler::Submit() {
cache_item->sent = true;
cache_items_sent << cache_item;
QJsonObject object_listen;
object_listen.insert(QStringLiteral("listened_at"), QJsonValue::fromVariant(cache_item->timestamp));
object_listen.insert(QStringLiteral("track_metadata"), JsonTrackMetadata(cache_item->metadata));
object_listen.insert(QLatin1String("listened_at"), QJsonValue::fromVariant(cache_item->timestamp));
object_listen.insert(QLatin1String("track_metadata"), JsonTrackMetadata(cache_item->metadata));
array.append(QJsonValue::fromVariant(object_listen));
if (cache_items_sent.count() >= kScrobblesPerRequest || cache_item->error) break;
}
@ -563,8 +563,8 @@ void ListenBrainzScrobbler::Submit() {
submitted_ = true;
QJsonObject object;
object.insert(QStringLiteral("listen_type"), QStringLiteral("import"));
object.insert(QStringLiteral("payload"), array);
object.insert(QLatin1String("listen_type"), QLatin1String("import"));
object.insert(QLatin1String("payload"), array);
QJsonDocument doc(object);
QUrl url(QStringLiteral("%1/1/submit-listens").arg(QLatin1String(kApiUrl)));
@ -586,8 +586,8 @@ void ListenBrainzScrobbler::ScrobbleRequestFinished(QNetworkReply *reply, Scrobb
QString error_message;
const ReplyResult reply_result = GetJsonObject(reply, json_obj, error_message);
if (reply_result == ReplyResult::Success) {
if (json_obj.contains(QStringLiteral("status"))) {
QString status = json_obj[QStringLiteral("status")].toString();
if (json_obj.contains(QLatin1String("status"))) {
QString status = json_obj[QLatin1String("status")].toString();
qLog(Debug) << "ListenBrainz: Received scrobble status:" << status;
}
else {
@ -634,8 +634,8 @@ void ListenBrainzScrobbler::Love() {
qLog(Debug) << "ListenBrainz: Sending love for song" << song_playing_.artist() << song_playing_.album() << song_playing_.title();
QJsonObject object;
object.insert(QStringLiteral("recording_mbid"), song_playing_.musicbrainz_recording_id());
object.insert(QStringLiteral("score"), 1);
object.insert(QLatin1String("recording_mbid"), song_playing_.musicbrainz_recording_id());
object.insert(QLatin1String("score"), 1);
QUrl url(QStringLiteral("%1/1/feedback/recording-feedback").arg(QLatin1String(kApiUrl)));
QNetworkReply *reply = CreateRequest(url, QJsonDocument(object));
@ -657,8 +657,8 @@ void ListenBrainzScrobbler::LoveRequestFinished(QNetworkReply *reply) {
return;
}
if (json_obj.contains(QStringLiteral("status"))) {
qLog(Debug) << "ListenBrainz: Received recording-feedback status:" << json_obj[QStringLiteral("status")].toString();
if (json_obj.contains(QLatin1String("status"))) {
qLog(Debug) << "ListenBrainz: Received recording-feedback status:" << json_obj[QLatin1String("status")].toString();
}
}

114
src/scrobbler/scrobblercache.cpp
View File

@ -99,11 +99,11 @@ void ScrobblerCache::ReadCache() {
qLog(Error) << "Scrobbler cache has empty JSON object.";
return;
}
if (!json_obj.contains(QStringLiteral("tracks"))) {
if (!json_obj.contains(QLatin1String("tracks"))) {
qLog(Error) << "Scrobbler cache is missing JSON tracks.";
return;
}
QJsonValue json_tracks = json_obj[QStringLiteral("tracks")];
QJsonValue json_tracks = json_obj[QLatin1String("tracks")];
if (!json_tracks.isArray()) {
qLog(Error) << "Scrobbler cache JSON tracks is not an array.";
return;
@ -121,13 +121,13 @@ void ScrobblerCache::ReadCache() {
}
QJsonObject json_obj_track = value.toObject();
if (
!json_obj_track.contains(QStringLiteral("timestamp")) ||
!json_obj_track.contains(QStringLiteral("artist")) ||
!json_obj_track.contains(QStringLiteral("album")) ||
!json_obj_track.contains(QStringLiteral("title")) ||
!json_obj_track.contains(QStringLiteral("track")) ||
!json_obj_track.contains(QStringLiteral("albumartist")) ||
!json_obj_track.contains(QStringLiteral("length_nanosec"))
!json_obj_track.contains(QLatin1String("timestamp")) ||
!json_obj_track.contains(QLatin1String("artist")) ||
!json_obj_track.contains(QLatin1String("album")) ||
!json_obj_track.contains(QLatin1String("title")) ||
!json_obj_track.contains(QLatin1String("track")) ||
!json_obj_track.contains(QLatin1String("albumartist")) ||
!json_obj_track.contains(QLatin1String("length_nanosec"))
) {
qLog(Error) << "Scrobbler cache JSON tracks array value is missing data.";
qLog(Debug) << value;
@ -135,52 +135,52 @@ void ScrobblerCache::ReadCache() {
}
ScrobbleMetadata metadata;
quint64 timestamp = json_obj_track[QStringLiteral("timestamp")].toVariant().toULongLong();
metadata.artist = json_obj_track[QStringLiteral("artist")].toString();
metadata.album = json_obj_track[QStringLiteral("album")].toString();
metadata.title = json_obj_track[QStringLiteral("title")].toString();
metadata.track = json_obj_track[QStringLiteral("track")].toInt();
metadata.albumartist = json_obj_track[QStringLiteral("albumartist")].toString();
metadata.length_nanosec = json_obj_track[QStringLiteral("length_nanosec")].toVariant().toLongLong();
quint64 timestamp = json_obj_track[QLatin1String("timestamp")].toVariant().toULongLong();
metadata.artist = json_obj_track[QLatin1String("artist")].toString();
metadata.album = json_obj_track[QLatin1String("album")].toString();
metadata.title = json_obj_track[QLatin1String("title")].toString();
metadata.track = json_obj_track[QLatin1String("track")].toInt();
metadata.albumartist = json_obj_track[QLatin1String("albumartist")].toString();
metadata.length_nanosec = json_obj_track[QLatin1String("length_nanosec")].toVariant().toLongLong();
if (timestamp == 0 || metadata.artist.isEmpty() || metadata.title.isEmpty() || metadata.length_nanosec <= 0) {
qLog(Error) << "Invalid cache data" << "for song" << metadata.title;
continue;
}
if (json_obj_track.contains(QStringLiteral("grouping"))) {
metadata.grouping = json_obj_track[QStringLiteral("grouping")].toString();
if (json_obj_track.contains(QLatin1String("grouping"))) {
metadata.grouping = json_obj_track[QLatin1String("grouping")].toString();
}
if (json_obj_track.contains(QStringLiteral("musicbrainz_album_artist_id"))) {
metadata.musicbrainz_album_artist_id = json_obj_track[QStringLiteral("musicbrainz_album_artist_id")].toString();
if (json_obj_track.contains(QLatin1String("musicbrainz_album_artist_id"))) {
metadata.musicbrainz_album_artist_id = json_obj_track[QLatin1String("musicbrainz_album_artist_id")].toString();
}
if (json_obj_track.contains(QStringLiteral("musicbrainz_artist_id"))) {
metadata.musicbrainz_artist_id = json_obj_track[QStringLiteral("musicbrainz_artist_id")].toString();
if (json_obj_track.contains(QLatin1String("musicbrainz_artist_id"))) {
metadata.musicbrainz_artist_id = json_obj_track[QLatin1String("musicbrainz_artist_id")].toString();
}
if (json_obj_track.contains(QStringLiteral("musicbrainz_original_artist_id"))) {
metadata.musicbrainz_original_artist_id = json_obj_track[QStringLiteral("musicbrainz_original_artist_id")].toString();
if (json_obj_track.contains(QLatin1String("musicbrainz_original_artist_id"))) {
metadata.musicbrainz_original_artist_id = json_obj_track[QLatin1String("musicbrainz_original_artist_id")].toString();
}
if (json_obj_track.contains(QStringLiteral("musicbrainz_album_id"))) {
metadata.musicbrainz_album_id = json_obj_track[QStringLiteral("musicbrainz_album_id")].toString();
if (json_obj_track.contains(QLatin1String("musicbrainz_album_id"))) {
metadata.musicbrainz_album_id = json_obj_track[QLatin1String("musicbrainz_album_id")].toString();
}
if (json_obj_track.contains(QStringLiteral("musicbrainz_original_album_id"))) {
metadata.musicbrainz_original_album_id = json_obj_track[QStringLiteral("musicbrainz_original_album_id")].toString();
if (json_obj_track.contains(QLatin1String("musicbrainz_original_album_id"))) {
metadata.musicbrainz_original_album_id = json_obj_track[QLatin1String("musicbrainz_original_album_id")].toString();
}
if (json_obj_track.contains(QStringLiteral("musicbrainz_recording_id"))) {
metadata.musicbrainz_recording_id = json_obj_track[QStringLiteral("musicbrainz_recording_id")].toString();
if (json_obj_track.contains(QLatin1String("musicbrainz_recording_id"))) {
metadata.musicbrainz_recording_id = json_obj_track[QLatin1String("musicbrainz_recording_id")].toString();
}
if (json_obj_track.contains(QStringLiteral("musicbrainz_track_id"))) {
metadata.musicbrainz_track_id = json_obj_track[QStringLiteral("musicbrainz_track_id")].toString();
if (json_obj_track.contains(QLatin1String("musicbrainz_track_id"))) {
metadata.musicbrainz_track_id = json_obj_track[QLatin1String("musicbrainz_track_id")].toString();
}
if (json_obj_track.contains(QStringLiteral("musicbrainz_disc_id"))) {
metadata.musicbrainz_disc_id = json_obj_track[QStringLiteral("musicbrainz_disc_id")].toString();
if (json_obj_track.contains(QLatin1String("musicbrainz_disc_id"))) {
metadata.musicbrainz_disc_id = json_obj_track[QLatin1String("musicbrainz_disc_id")].toString();
}
if (json_obj_track.contains(QStringLiteral("musicbrainz_release_group_id"))) {
metadata.musicbrainz_release_group_id = json_obj_track[QStringLiteral("musicbrainz_release_group_id")].toString();
if (json_obj_track.contains(QLatin1String("musicbrainz_release_group_id"))) {
metadata.musicbrainz_release_group_id = json_obj_track[QLatin1String("musicbrainz_release_group_id")].toString();
}
if (json_obj_track.contains(QStringLiteral("musicbrainz_work_id"))) {
metadata.musicbrainz_work_id = json_obj_track[QStringLiteral("musicbrainz_work_id")].toString();
if (json_obj_track.contains(QLatin1String("musicbrainz_work_id"))) {
metadata.musicbrainz_work_id = json_obj_track[QLatin1String("musicbrainz_work_id")].toString();
}
ScrobblerCacheItemPtr cache_item = make_shared<ScrobblerCacheItem>(metadata, timestamp);
@ -205,29 +205,29 @@ void ScrobblerCache::WriteCache() {
QJsonArray array;
for (ScrobblerCacheItemPtr cache_item : scrobbler_cache_) {
QJsonObject object;
object.insert(QStringLiteral("timestamp"), QJsonValue::fromVariant(cache_item->timestamp));
object.insert(QStringLiteral("artist"), QJsonValue::fromVariant(cache_item->metadata.artist));
object.insert(QStringLiteral("album"), QJsonValue::fromVariant(cache_item->metadata.album));
object.insert(QStringLiteral("title"), QJsonValue::fromVariant(cache_item->metadata.title));
object.insert(QStringLiteral("track"), QJsonValue::fromVariant(cache_item->metadata.track));
object.insert(QStringLiteral("albumartist"), QJsonValue::fromVariant(cache_item->metadata.albumartist));
object.insert(QStringLiteral("grouping"), QJsonValue::fromVariant(cache_item->metadata.grouping));
object.insert(QStringLiteral("musicbrainz_album_artist_id"), QJsonValue::fromVariant(cache_item->metadata.musicbrainz_album_artist_id));
object.insert(QStringLiteral("musicbrainz_artist_id"), QJsonValue::fromVariant(cache_item->metadata.musicbrainz_artist_id));
object.insert(QStringLiteral("musicbrainz_original_artist_id"), QJsonValue::fromVariant(cache_item->metadata.musicbrainz_original_artist_id));
object.insert(QStringLiteral("musicbrainz_album_id"), QJsonValue::fromVariant(cache_item->metadata.musicbrainz_album_id));
object.insert(QStringLiteral("musicbrainz_original_album_id"), QJsonValue::fromVariant(cache_item->metadata.musicbrainz_original_album_id));
object.insert(QStringLiteral("musicbrainz_recording_id"), QJsonValue::fromVariant(cache_item->metadata.musicbrainz_recording_id));
object.insert(QStringLiteral("musicbrainz_track_id"), QJsonValue::fromVariant(cache_item->metadata.musicbrainz_track_id));
object.insert(QStringLiteral("musicbrainz_disc_id"), QJsonValue::fromVariant(cache_item->metadata.musicbrainz_disc_id));
object.insert(QStringLiteral("musicbrainz_release_group_id"), QJsonValue::fromVariant(cache_item->metadata.musicbrainz_release_group_id));
object.insert(QStringLiteral("musicbrainz_work_id"), QJsonValue::fromVariant(cache_item->metadata.musicbrainz_work_id));
object.insert(QStringLiteral("length_nanosec"), QJsonValue::fromVariant(cache_item->metadata.length_nanosec));
object.insert(QLatin1String("timestamp"), QJsonValue::fromVariant(cache_item->timestamp));
object.insert(QLatin1String("artist"), QJsonValue::fromVariant(cache_item->metadata.artist));
object.insert(QLatin1String("album"), QJsonValue::fromVariant(cache_item->metadata.album));
object.insert(QLatin1String("title"), QJsonValue::fromVariant(cache_item->metadata.title));
object.insert(QLatin1String("track"), QJsonValue::fromVariant(cache_item->metadata.track));
object.insert(QLatin1String("albumartist"), QJsonValue::fromVariant(cache_item->metadata.albumartist));
object.insert(QLatin1String("grouping"), QJsonValue::fromVariant(cache_item->metadata.grouping));
object.insert(QLatin1String("musicbrainz_album_artist_id"), QJsonValue::fromVariant(cache_item->metadata.musicbrainz_album_artist_id));
object.insert(QLatin1String("musicbrainz_artist_id"), QJsonValue::fromVariant(cache_item->metadata.musicbrainz_artist_id));
object.insert(QLatin1String("musicbrainz_original_artist_id"), QJsonValue::fromVariant(cache_item->metadata.musicbrainz_original_artist_id));
object.insert(QLatin1String("musicbrainz_album_id"), QJsonValue::fromVariant(cache_item->metadata.musicbrainz_album_id));
object.insert(QLatin1String("musicbrainz_original_album_id"), QJsonValue::fromVariant(cache_item->metadata.musicbrainz_original_album_id));
object.insert(QLatin1String("musicbrainz_recording_id"), QJsonValue::fromVariant(cache_item->metadata.musicbrainz_recording_id));
object.insert(QLatin1String("musicbrainz_track_id"), QJsonValue::fromVariant(cache_item->metadata.musicbrainz_track_id));
object.insert(QLatin1String("musicbrainz_disc_id"), QJsonValue::fromVariant(cache_item->metadata.musicbrainz_disc_id));
object.insert(QLatin1String("musicbrainz_release_group_id"), QJsonValue::fromVariant(cache_item->metadata.musicbrainz_release_group_id));
object.insert(QLatin1String("musicbrainz_work_id"), QJsonValue::fromVariant(cache_item->metadata.musicbrainz_work_id));
object.insert(QLatin1String("length_nanosec"), QJsonValue::fromVariant(cache_item->metadata.length_nanosec));
array.append(QJsonValue::fromVariant(object));
}
QJsonObject object;
object.insert(QStringLiteral("tracks"), array);
object.insert(QLatin1String("tracks"), array);
QJsonDocument doc(object);
QFile file(filename_);

118
src/scrobbler/scrobblingapi20.cpp
View File

@ -170,9 +170,9 @@ ScrobblingAPI20::ReplyResult ScrobblingAPI20::GetJsonObject(QNetworkReply *reply
if (reply->error() == QNetworkReply::NoError || reply->error() >= 200) {
const QByteArray data = reply->readAll();
int error_code = 0;
if (!data.isEmpty() && ExtractJsonObj(data, json_obj, error_description) && json_obj.contains(QStringLiteral("error")) && json_obj.contains(QStringLiteral("message"))) {
error_code = json_obj[QStringLiteral("error")].toInt();
QString error_message = json_obj[QStringLiteral("message")].toString();
if (!data.isEmpty() && ExtractJsonObj(data, json_obj, error_description) && json_obj.contains(QLatin1String("error")) && json_obj.contains(QLatin1String("message"))) {
error_code = json_obj[QLatin1String("error")].toInt();
QString error_message = json_obj[QLatin1String("message")].toString();
error_description = QStringLiteral("%1 (%2)").arg(error_message).arg(error_code);
reply_error_type = ReplyResult::APIError;
}
@ -220,7 +220,7 @@ void ScrobblingAPI20::Authenticate() {
if (openurl_result) {
break;
}
QMessageBox messagebox_error(QMessageBox::Warning, tr("%1 Scrobbler Authentication").arg(name_), tr("Could not open URL. Please open this URL in your browser") + QStringLiteral(":<br /><a href=\"%1\">%1</a>").arg(url.toString()), QMessageBox::Ok);
QMessageBox messagebox_error(QMessageBox::Warning, tr("%1 Scrobbler Authentication").arg(name_), tr("Could not open URL. Please open this URL in your browser") + QLatin1String(":<br /><a href=\"%1\">%1</a>").arg(url.toString()), QMessageBox::Ok);
messagebox_error.setTextFormat(Qt::RichText);
messagebox_error.exec();
}
@ -311,12 +311,12 @@ void ScrobblingAPI20::AuthenticateReplyFinished(QNetworkReply *reply) {
return;
}
if (!json_obj.contains(QStringLiteral("session"))) {
if (!json_obj.contains(QLatin1String("session"))) {
AuthError(QStringLiteral("Json reply from server is missing session."));
return;
}
QJsonValue json_session = json_obj[QStringLiteral("session")];
QJsonValue json_session = json_obj[QLatin1String("session")];
if (!json_session.isObject()) {
AuthError(QStringLiteral("Json session is not an object."));
return;
@ -326,14 +326,14 @@ void ScrobblingAPI20::AuthenticateReplyFinished(QNetworkReply *reply) {
AuthError(QStringLiteral("Json session object is empty."));
return;
}
if (!json_obj.contains(QStringLiteral("subscriber")) || !json_obj.contains(QStringLiteral("name")) || !json_obj.contains(QStringLiteral("key"))) {
if (!json_obj.contains(QLatin1String("subscriber")) || !json_obj.contains(QLatin1String("name")) || !json_obj.contains(QLatin1String("key"))) {
AuthError(QStringLiteral("Json session object is missing values."));
return;
}
subscriber_ = json_obj[QStringLiteral("subscriber")].toBool();
username_ = json_obj[QStringLiteral("name")].toString();
session_key_ = json_obj[QStringLiteral("key")].toString();
subscriber_ = json_obj[QLatin1String("subscriber")].toBool();
username_ = json_obj[QLatin1String("name")].toString();
session_key_ = json_obj[QLatin1String("key")].toString();
Settings s;
s.beginGroup(settings_group_);
@ -429,7 +429,7 @@ void ScrobblingAPI20::UpdateNowPlayingRequestFinished(QNetworkReply *reply) {
return;
}
if (!json_obj.contains(QStringLiteral("nowplaying"))) {
if (!json_obj.contains(QLatin1String("nowplaying"))) {
Error(QStringLiteral("Json reply from server is missing nowplaying."), json_obj);
return;
}
@ -508,13 +508,13 @@ void ScrobblingAPI20::Submit() {
params << Param(QStringLiteral("%1[%2]").arg(QStringLiteral("timestamp")).arg(i), QString::number(cache_item->timestamp));
params << Param(QStringLiteral("%1[%2]").arg(QStringLiteral("duration")).arg(i), QString::number(cache_item->metadata.length_nanosec / kNsecPerSec));
if (!cache_item->metadata.album.isEmpty()) {
params << Param(QStringLiteral("%1[%2]").arg(QStringLiteral("album")).arg(i), StripAlbum(cache_item->metadata.album));
params << Param(QStringLiteral("%1[%2]").arg(QLatin1String("album")).arg(i), StripAlbum(cache_item->metadata.album));
}
if (!prefer_albumartist_ && !cache_item->metadata.albumartist.isEmpty()) {
params << Param(QStringLiteral("%1[%2]").arg(QStringLiteral("albumArtist")).arg(i), cache_item->metadata.albumartist);
params << Param(QStringLiteral("%1[%2]").arg(QLatin1String("albumArtist")).arg(i), cache_item->metadata.albumartist);
}
if (cache_item->metadata.track > 0) {
params << Param(QStringLiteral("%1[%2]").arg(QStringLiteral("trackNumber")).arg(i), QString::number(cache_item->metadata.track));
params << Param(QStringLiteral("%1[%2]").arg(QLatin1String("trackNumber")).arg(i), QString::number(cache_item->metadata.track));
}
++i;
if (cache_items_sent.count() >= kScrobblesPerRequest) break;
@ -551,13 +551,13 @@ void ScrobblingAPI20::ScrobbleRequestFinished(QNetworkReply *reply, ScrobblerCac
cache_->Flush(cache_items);
submit_error_ = false;
if (!json_obj.contains(QStringLiteral("scrobbles"))) {
if (!json_obj.contains(QLatin1String("scrobbles"))) {
Error(QStringLiteral("Json reply from server is missing scrobbles."), json_obj);
StartSubmit();
return;
}
QJsonValue value_scrobbles = json_obj[QStringLiteral("scrobbles")];
QJsonValue value_scrobbles = json_obj[QLatin1String("scrobbles")];
if (!value_scrobbles.isObject()) {
Error(QStringLiteral("Json scrobbles is not an object."), json_obj);
StartSubmit();
@ -569,13 +569,13 @@ void ScrobblingAPI20::ScrobbleRequestFinished(QNetworkReply *reply, ScrobblerCac
StartSubmit();
return;
}
if (!json_obj.contains(QStringLiteral("@attr")) || !json_obj.contains(QStringLiteral("scrobble"))) {
if (!json_obj.contains(QLatin1String("@attr")) || !json_obj.contains(QLatin1String("scrobble"))) {
Error(QStringLiteral("Json scrobbles object is missing values."), json_obj);
StartSubmit();
return;
}
QJsonValue value_attr = json_obj[QStringLiteral("@attr")];
QJsonValue value_attr = json_obj[QLatin1String("@attr")];
if (!value_attr.isObject()) {
Error(QStringLiteral("Json scrobbles attr is not an object."), value_attr);
StartSubmit();
@ -587,19 +587,19 @@ void ScrobblingAPI20::ScrobbleRequestFinished(QNetworkReply *reply, ScrobblerCac
StartSubmit();
return;
}
if (!obj_attr.contains(QStringLiteral("accepted")) || !obj_attr.contains(QStringLiteral("ignored"))) {
if (!obj_attr.contains(QLatin1String("accepted")) || !obj_attr.contains(QLatin1String("ignored"))) {
Error(QStringLiteral("Json scrobbles attr is missing values."), obj_attr);
StartSubmit();
return;
}
int accepted = obj_attr[QStringLiteral("accepted")].toInt();
int ignored = obj_attr[QStringLiteral("ignored")].toInt();
int accepted = obj_attr[QLatin1String("accepted")].toInt();
int ignored = obj_attr[QLatin1String("ignored")].toInt();
qLog(Debug) << name_ << "Scrobbles accepted:" << accepted << "ignored:" << ignored;
QJsonArray array_scrobble;
QJsonValue value_scrobble = json_obj[QStringLiteral("scrobble")];
QJsonValue value_scrobble = json_obj[QLatin1String("scrobble")];
if (value_scrobble.isObject()) {
QJsonObject obj_scrobble = value_scrobble.toObject();
if (obj_scrobble.isEmpty()) {
@ -634,22 +634,22 @@ void ScrobblingAPI20::ScrobbleRequestFinished(QNetworkReply *reply, ScrobblerCac
continue;
}
if (!json_track.contains(QStringLiteral("artist")) ||
!json_track.contains(QStringLiteral("album")) ||
!json_track.contains(QStringLiteral("albumArtist")) ||
!json_track.contains(QStringLiteral("track")) ||
!json_track.contains(QStringLiteral("timestamp")) ||
!json_track.contains(QStringLiteral("ignoredMessage"))
if (!json_track.contains(QLatin1String("artist")) ||
!json_track.contains(QLatin1String("album")) ||
!json_track.contains(QLatin1String("albumArtist")) ||
!json_track.contains(QLatin1String("track")) ||
!json_track.contains(QLatin1String("timestamp")) ||
!json_track.contains(QLatin1String("ignoredMessage"))
) {
Error(QStringLiteral("Json scrobbles scrobble is missing values."), json_track);
continue;
}
QJsonValue value_artist = json_track[QStringLiteral("artist")];
QJsonValue value_album = json_track[QStringLiteral("album")];
QJsonValue value_song = json_track[QStringLiteral("track")];
QJsonValue value_ignoredmessage = json_track[QStringLiteral("ignoredMessage")];
//quint64 timestamp = json_track["timestamp"].toVariant().toULongLong();
QJsonValue value_artist = json_track[QLatin1String("artist")];
QJsonValue value_album = json_track[QLatin1String("album")];
QJsonValue value_song = json_track[QLatin1String("track")];
QJsonValue value_ignoredmessage = json_track[QLatin1String("ignoredMessage")];
//quint64 timestamp = json_track[QLatin1String("timestamp")].toVariant().toULongLong();
if (!value_artist.isObject() || !value_album.isObject() || !value_song.isObject() || !value_ignoredmessage.isObject()) {
Error(QStringLiteral("Json scrobbles scrobble values are not objects."), json_track);
@ -666,15 +666,15 @@ void ScrobblingAPI20::ScrobbleRequestFinished(QNetworkReply *reply, ScrobblerCac
continue;
}
if (!obj_artist.contains(QStringLiteral("#text")) || !obj_album.contains(QStringLiteral("#text")) || !obj_song.contains(QStringLiteral("#text"))) {
if (!obj_artist.contains(QLatin1String("#text")) || !obj_album.contains(QLatin1String("#text")) || !obj_song.contains(QLatin1String("#text"))) {
continue;
}
//QString artist = obj_artist["#text"].toString();
//QString album = obj_album["#text"].toString();
QString song = obj_song[QStringLiteral("#text")].toString();
bool ignoredmessage = obj_ignoredmessage[QStringLiteral("code")].toVariant().toBool();
QString ignoredmessage_text = obj_ignoredmessage[QStringLiteral("#text")].toString();
QString song = obj_song[QLatin1String("#text")].toString();
bool ignoredmessage = obj_ignoredmessage[QLatin1String("code")].toVariant().toBool();
QString ignoredmessage_text = obj_ignoredmessage[QLatin1String("#text")].toString();
if (ignoredmessage) {
Error(QStringLiteral("Scrobble for \"%1\" ignored: %2").arg(song, ignoredmessage_text));
@ -728,7 +728,7 @@ void ScrobblingAPI20::SingleScrobbleRequestFinished(QNetworkReply *reply, Scrobb
return;
}
if (!json_obj.contains(QStringLiteral("scrobbles"))) {
if (!json_obj.contains(QLatin1String("scrobbles"))) {
Error(QStringLiteral("Json reply from server is missing scrobbles."), json_obj);
cache_item->sent = false;
return;
@ -736,7 +736,7 @@ void ScrobblingAPI20::SingleScrobbleRequestFinished(QNetworkReply *reply, Scrobb
cache_->Remove(cache_item);
QJsonValue value_scrobbles = json_obj[QStringLiteral("scrobbles")];
QJsonValue value_scrobbles = json_obj[QLatin1String("scrobbles")];
if (!value_scrobbles.isObject()) {
Error(QStringLiteral("Json scrobbles is not an object."), json_obj);
return;
@ -746,12 +746,12 @@ void ScrobblingAPI20::SingleScrobbleRequestFinished(QNetworkReply *reply, Scrobb
Error(QStringLiteral("Json scrobbles object is empty."), value_scrobbles);
return;
}
if (!json_obj.contains(QStringLiteral("@attr")) || !json_obj.contains(QStringLiteral("scrobble"))) {
if (!json_obj.contains(QLatin1String("@attr")) || !json_obj.contains(QLatin1String("scrobble"))) {
Error(QStringLiteral("Json scrobbles object is missing values."), json_obj);
return;
}
QJsonValue value_attr = json_obj[QStringLiteral("@attr")];
QJsonValue value_attr = json_obj[QLatin1String("@attr")];
if (!value_attr.isObject()) {
Error(QStringLiteral("Json scrobbles attr is not an object."), value_attr);
return;
@ -762,7 +762,7 @@ void ScrobblingAPI20::SingleScrobbleRequestFinished(QNetworkReply *reply, Scrobb
return;
}
QJsonValue value_scrobble = json_obj[QStringLiteral("scrobble")];
QJsonValue value_scrobble = json_obj[QLatin1String("scrobble")];
if (!value_scrobble.isObject()) {
Error(QStringLiteral("Json scrobbles scrobble is not an object."), value_scrobble);
return;
@ -773,19 +773,19 @@ void ScrobblingAPI20::SingleScrobbleRequestFinished(QNetworkReply *reply, Scrobb
return;
}
if (!obj_attr.contains(QStringLiteral("accepted")) || !obj_attr.contains(QStringLiteral("ignored"))) {
if (!obj_attr.contains(QLatin1String("accepted")) || !obj_attr.contains(QLatin1String("ignored"))) {
Error(QStringLiteral("Json scrobbles attr is missing values."), obj_attr);
return;
}
if (!json_obj_scrobble.contains(QStringLiteral("artist")) || !json_obj_scrobble.contains(QStringLiteral("album")) || !json_obj_scrobble.contains(QStringLiteral("albumArtist")) || !json_obj_scrobble.contains(QStringLiteral("track")) || !json_obj_scrobble.contains(QStringLiteral("timestamp"))) {
if (!json_obj_scrobble.contains(QLatin1String("artist")) || !json_obj_scrobble.contains(QLatin1String("album")) || !json_obj_scrobble.contains(QLatin1String("albumArtist")) || !json_obj_scrobble.contains(QLatin1String("track")) || !json_obj_scrobble.contains(QLatin1String("timestamp"))) {
Error(QStringLiteral("Json scrobbles scrobble is missing values."), json_obj_scrobble);
return;
}
QJsonValue json_value_artist = json_obj_scrobble[QStringLiteral("artist")];
QJsonValue json_value_album = json_obj_scrobble[QStringLiteral("album")];
QJsonValue json_value_song = json_obj_scrobble[QStringLiteral("track")];
QJsonValue json_value_artist = json_obj_scrobble[QLatin1String("artist")];
QJsonValue json_value_album = json_obj_scrobble[QLatin1String("album")];
QJsonValue json_value_song = json_obj_scrobble[QLatin1String("track")];
if (!json_value_artist.isObject() || !json_value_album.isObject() || !json_value_song.isObject()) {
Error(QStringLiteral("Json scrobbles scrobble values are not objects."), json_obj_scrobble);
@ -801,16 +801,16 @@ void ScrobblingAPI20::SingleScrobbleRequestFinished(QNetworkReply *reply, Scrobb
return;
}
if (!json_obj_artist.contains(QStringLiteral("#text")) || !json_obj_album.contains(QStringLiteral("#text")) || !json_obj_song.contains(QStringLiteral("#text"))) {
if (!json_obj_artist.contains(QLatin1String("#text")) || !json_obj_album.contains(QLatin1String("#text")) || !json_obj_song.contains(QLatin1String("#text"))) {
Error(QStringLiteral("Json scrobbles scrobble values objects are missing #text."), json_obj_artist);
return;
}
//QString artist = json_obj_artist["#text"].toString();
//QString album = json_obj_album["#text"].toString();
QString song = json_obj_song[QStringLiteral("#text")].toString();
QString song = json_obj_song[QLatin1String("#text")].toString();
int accepted = obj_attr[QStringLiteral("accepted")].toVariant().toInt();
int accepted = obj_attr[QLatin1String("accepted")].toVariant().toInt();
if (accepted == 1) {
qLog(Debug) << name_ << "Scrobble for" << song << "accepted";
}
@ -860,8 +860,8 @@ void ScrobblingAPI20::LoveRequestFinished(QNetworkReply *reply) {
return;
}
if (json_obj.contains(QStringLiteral("error"))) {
QJsonValue json_value = json_obj[QStringLiteral("error")];
if (json_obj.contains(QLatin1String("error"))) {
QJsonValue json_value = json_obj[QLatin1String("error")];
if (!json_value.isObject()) {
Error(QStringLiteral("Error is not on object."));
return;
@ -871,21 +871,21 @@ void ScrobblingAPI20::LoveRequestFinished(QNetworkReply *reply) {
Error(QStringLiteral("Received empty json error object."), json_obj);
return;
}
if (json_obj_error.contains(QStringLiteral("code")) && json_obj_error.contains(QStringLiteral("#text"))) {
int code = json_obj_error[QStringLiteral("code")].toInt();
QString text = json_obj_error[QStringLiteral("#text")].toString();
if (json_obj_error.contains(QLatin1String("code")) && json_obj_error.contains(QLatin1String("#text"))) {
int code = json_obj_error[QLatin1String("code")].toInt();
QString text = json_obj_error[QLatin1String("#text")].toString();
QString error_reason = QStringLiteral("%1 (%2)").arg(text).arg(code);
Error(error_reason);
return;
}
}
if (json_obj.contains(QStringLiteral("lfm"))) {
QJsonValue json_value = json_obj[QStringLiteral("lfm")];
if (json_obj.contains(QLatin1String("lfm"))) {
QJsonValue json_value = json_obj[QLatin1String("lfm")];
if (json_value.isObject()) {
QJsonObject json_obj_lfm = json_value.toObject();
if (json_obj_lfm.contains(QStringLiteral("status"))) {
QString status = json_obj_lfm[QStringLiteral("status")].toString();
if (json_obj_lfm.contains(QLatin1String("status"))) {
QString status = json_obj_lfm[QLatin1String("status")].toString();
qLog(Debug) << name_ << "Received love status:" << status;
return;
}

6
src/settings/behavioursettingspage.cpp
View File

@ -94,9 +94,9 @@ BehaviourSettingsPage::BehaviourSettingsPage(SettingsDialog *dialog, QWidget *pa
QString code = re_match.captured(1);
QString lookup_code = QString(code)
.replace(QStringLiteral("@latin"), QStringLiteral("_Latn"))
.replace(QStringLiteral("_CN"), QStringLiteral("_Hans_CN"))
.replace(QStringLiteral("_TW"), QStringLiteral("_Hant_TW"));
.replace(QLatin1String("@latin"), QLatin1String("_Latn"))
.replace(QLatin1String("_CN"), QLatin1String("_Hans_CN"))
.replace(QLatin1String("_TW"), QLatin1String("_Hant_TW"));
QString language_name = QLocale::languageToString(QLocale(lookup_code).language());
QString native_name = QLocale(lookup_code).nativeLanguageName();

2
src/settings/collectionsettingspage.cpp
View File

@ -156,7 +156,7 @@ void CollectionSettingsPage::Load() {
ui_->expire_unavailable_songs_days->setValue(s.value("expire_unavailable_songs", 60).toInt());
QStringList filters = s.value("cover_art_patterns", QStringList() << QStringLiteral("front") << QStringLiteral("cover")).toStringList();
ui_->cover_art_patterns->setText(filters.join(QStringLiteral(",")));
ui_->cover_art_patterns->setText(filters.join(QLatin1Char(',')));
ui_->spinbox_cache_size->setValue(s.value(kSettingsCacheSize, kSettingsCacheSizeDefault).toInt());
ui_->combobox_cache_size->setCurrentIndex(ui_->combobox_cache_size->findData(s.value(kSettingsCacheSizeUnit, static_cast<int>(CacheSizeUnit::MB)).toInt()));

18
src/settings/coverssettingspage.cpp
View File

@ -222,11 +222,11 @@ void CoversSettingsPage::ProvidersCurrentItemChanged(QListWidgetItem *item_curre
CoverProvider *provider = dialog()->app()->cover_providers()->ProviderByName(item_current->text());
if (provider) {
if (provider->AuthenticationRequired()) {
if (provider->name() == QStringLiteral("Tidal") && !provider->IsAuthenticated()) {
if (provider->name() == QLatin1String("Tidal") && !provider->IsAuthenticated()) {
DisableAuthentication();
ui_->label_auth_info->setText(tr("Use Tidal settings to authenticate."));
}
else if (provider->name() == QStringLiteral("Qobuz") && !provider->IsAuthenticated()) {
else if (provider->name() == QLatin1String("Qobuz") && !provider->IsAuthenticated()) {
DisableAuthentication();
ui_->label_auth_info->setText(tr("Use Qobuz settings to authenticate."));
}
@ -335,11 +335,11 @@ void CoversSettingsPage::LogoutClicked() {
if (!provider) return;
provider->Deauthenticate();
if (provider->name() == QStringLiteral("Tidal")) {
if (provider->name() == QLatin1String("Tidal")) {
DisableAuthentication();
ui_->label_auth_info->setText(tr("Use Tidal settings to authenticate."));
}
else if (provider->name() == QStringLiteral("Qobuz")) {
else if (provider->name() == QLatin1String("Qobuz")) {
DisableAuthentication();
ui_->label_auth_info->setText(tr("Use Qobuz settings to authenticate."));
}
@ -371,7 +371,7 @@ void CoversSettingsPage::AuthenticationFailure(const QStringList &errors) {
if (!isVisible() || !ui_->providers->currentItem() || ui_->providers->currentItem()->text() != provider->name()) return;
QMessageBox::warning(this, tr("Authentication failed"), errors.join(QStringLiteral("\n")));
QMessageBox::warning(this, tr("Authentication failed"), errors.join(QLatin1Char('\n')));
ui_->login_state->SetLoggedIn(LoginStateWidget::State::LoggedOut);
ui_->button_authenticate->setEnabled(true);
@ -421,16 +421,16 @@ void CoversSettingsPage::AddAlbumCoverArtType(const QString &name, const QString
QString CoversSettingsPage::AlbumCoverArtTypeDescription(const QString &type) const {
if (type == QStringLiteral("art_unset")) {
if (type == QLatin1String("art_unset")) {
return tr("Manually unset (%1)").arg(type);
}
if (type == QStringLiteral("art_manual")) {
if (type == QLatin1String("art_manual")) {
return tr("Set through album cover search (%1)").arg(type);
}
if (type == QStringLiteral("art_automatic")) {
if (type == QLatin1String("art_automatic")) {
return tr("Automatically picked up from album directory (%1)").arg(type);
}
if (type == QStringLiteral("art_embedded")) {
if (type == QLatin1String("art_embedded")) {
return tr("Embedded album cover art (%1)").arg(type);
}

2
src/settings/lyricssettingspage.cpp
View File

@ -253,7 +253,7 @@ void LyricsSettingsPage::AuthenticationFailure(const QStringList &errors) {
if (!isVisible() || !ui_->providers->currentItem() || ui_->providers->currentItem()->text() != provider->name()) return;
QMessageBox::warning(this, tr("Authentication failed"), errors.join(QStringLiteral("\n")));
QMessageBox::warning(this, tr("Authentication failed"), errors.join(QLatin1Char('\n')));
ui_->login_state->SetLoggedIn(LoginStateWidget::State::LoggedOut);
ui_->button_authenticate->setEnabled(true);

4
src/smartplaylists/smartplaylistsearch.cpp
View File

@ -70,7 +70,7 @@ QString SmartPlaylistSearch::ToSql(const QString &songs_table) const {
if (!id_not_in_.isEmpty()) {
QString numbers;
for (int id : id_not_in_) {
numbers += (numbers.isEmpty() ? QLatin1String("") : QStringLiteral(",")) + QString::number(id);
numbers += (numbers.isEmpty() ? QLatin1String("") : QLatin1String(",")) + QString::number(id);
}
where_clauses << QStringLiteral("(ROWID NOT IN (") + numbers + QStringLiteral("))");
}
@ -80,7 +80,7 @@ QString SmartPlaylistSearch::ToSql(const QString &songs_table) const {
where_clauses << QStringLiteral("unavailable = 0");
if (!where_clauses.isEmpty()) {
sql += QStringLiteral(" WHERE ") + where_clauses.join(QStringLiteral(" AND "));
sql += QStringLiteral(" WHERE ") + where_clauses.join(QLatin1String(" AND "));
}
// Add sort by

24
src/subsonic/subsonicbaserequest.cpp
View File

@ -79,11 +79,11 @@ QUrl SubsonicBaseRequest::CreateUrl(const QUrl &server_url, const SubsonicSettin
QUrl url(server_url);
if (!url.path().isEmpty() && url.path().right(1) == QStringLiteral("/")) {
url.setPath(url.path() + QStringLiteral("rest/") + ressource_name + QStringLiteral(".view"));
if (!url.path().isEmpty() && url.path().right(1) == QLatin1Char('/')) {
url.setPath(url.path() + QLatin1String("rest/") + ressource_name + QLatin1String(".view"));
}
else {
url.setPath(url.path() + QStringLiteral("/rest/") + ressource_name + QStringLiteral(".view"));
url.setPath(url.path() + QLatin1String("/rest/") + ressource_name + QLatin1String(".view"));
}
url.setQuery(url_query);
@ -97,7 +97,7 @@ QNetworkReply *SubsonicBaseRequest::CreateGetRequest(const QString &ressource_na
QUrl url = CreateUrl(server_url(), auth_method(), username(), password(), ressource_name, params_provided);
QNetworkRequest req(url);
if (url.scheme() == QStringLiteral("https") && !verify_certificate()) {
if (url.scheme() == QLatin1String("https") && !verify_certificate()) {
QSslConfiguration sslconfig = QSslConfiguration::defaultConfiguration();
sslconfig.setPeerVerifyMode(QSslSocket::VerifyNone);
req.setSslConfiguration(sslconfig);
@ -148,13 +148,13 @@ QByteArray SubsonicBaseRequest::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(QStringLiteral("error"))) {
QJsonValue json_error = json_obj[QStringLiteral("error")];
if (!json_obj.isEmpty() && json_obj.contains(QLatin1String("error"))) {
QJsonValue json_error = json_obj[QLatin1String("error")];
if (json_error.isObject()) {
json_obj = json_error.toObject();
if (!json_obj.isEmpty() && json_obj.contains(QStringLiteral("code")) && json_obj.contains(QStringLiteral("message"))) {
int code = json_obj[QStringLiteral("code")].toInt();
QString message = json_obj[QStringLiteral("message")].toString();
if (!json_obj.isEmpty() && json_obj.contains(QLatin1String("code")) && json_obj.contains(QLatin1String("message"))) {
int code = json_obj[QLatin1String("code")].toInt();
QString message = json_obj[QLatin1String("message")].toString();
error = QStringLiteral("%1 (%2)").arg(message).arg(code);
}
}
@ -202,12 +202,12 @@ QJsonObject SubsonicBaseRequest::ExtractJsonObj(QByteArray &data) {
return QJsonObject();
}
if (!json_obj.contains(QStringLiteral("subsonic-response"))) {
if (!json_obj.contains(QLatin1String("subsonic-response"))) {
Error(QStringLiteral("Json reply is missing subsonic-response."), json_obj);
return QJsonObject();
}
QJsonValue json_response = json_obj[QStringLiteral("subsonic-response")];
QJsonValue json_response = json_obj[QLatin1String("subsonic-response")];
if (!json_response.isObject()) {
Error(QStringLiteral("Json response is not an object."), json_response);
return QJsonObject();
@ -222,7 +222,7 @@ QString SubsonicBaseRequest::ErrorsToHTML(const QStringList &errors) {
QString error_html;
for (const QString &error : errors) {
error_html += error + QStringLiteral("<br />");
error_html += error + QLatin1String("<br />");
}
return error_html;

164
src/subsonic/subsonicrequest.cpp
View File

@ -184,17 +184,17 @@ void SubsonicRequest::AlbumsReplyReceived(QNetworkReply *reply, const int offset
return;
}
if (json_obj.contains(QStringLiteral("error"))) {
QJsonValue json_error = json_obj[QStringLiteral("error")];
if (json_obj.contains(QLatin1String("error"))) {
QJsonValue json_error = json_obj[QLatin1String("error")];
if (!json_error.isObject()) {
Error(QStringLiteral("Json error is not an object."), json_obj);
AlbumsFinishCheck(offset_requested, size_requested);
return;
}
json_obj = json_error.toObject();
if (!json_obj.isEmpty() && json_obj.contains(QStringLiteral("code")) && json_obj.contains(QStringLiteral("message"))) {
int code = json_obj[QStringLiteral("code")].toInt();
QString message = json_obj[QStringLiteral("message")].toString();
if (!json_obj.isEmpty() && json_obj.contains(QLatin1String("code")) && json_obj.contains(QLatin1String("message"))) {
int code = json_obj[QLatin1String("code")].toInt();
QString message = json_obj[QLatin1String("message")].toString();
Error(QStringLiteral("%1 (%2)").arg(message).arg(code));
AlbumsFinishCheck(offset_requested, size_requested);
}
@ -205,14 +205,14 @@ void SubsonicRequest::AlbumsReplyReceived(QNetworkReply *reply, const int offset
return;
}
if (!json_obj.contains(QStringLiteral("albumList")) && !json_obj.contains(QStringLiteral("albumList2"))) {
if (!json_obj.contains(QLatin1String("albumList")) && !json_obj.contains(QLatin1String("albumList2"))) {
Error(QStringLiteral("Json reply is missing albumList."), json_obj);
AlbumsFinishCheck(offset_requested, size_requested);
return;
}
QJsonValue value_albumlist;
if (json_obj.contains(QStringLiteral("albumList"))) value_albumlist = json_obj[QStringLiteral("albumList")];
else if (json_obj.contains(QStringLiteral("albumList2"))) value_albumlist = json_obj[QStringLiteral("albumList2")];
if (json_obj.contains(QLatin1String("albumList"))) value_albumlist = json_obj[QLatin1String("albumList")];
else if (json_obj.contains(QLatin1String("albumList2"))) value_albumlist = json_obj[QLatin1String("albumList2")];
if (!value_albumlist.isObject()) {
Error(QStringLiteral("Json album list is not an object."), value_albumlist);
@ -225,11 +225,11 @@ void SubsonicRequest::AlbumsReplyReceived(QNetworkReply *reply, const int offset
return;
}
if (!json_obj.contains(QStringLiteral("album"))) {
if (!json_obj.contains(QLatin1String("album"))) {
Error(QStringLiteral("Json album list does not contain album array."), json_obj);
AlbumsFinishCheck(offset_requested, size_requested);
}
QJsonValue json_album = json_obj[QStringLiteral("album")];
QJsonValue json_album = json_obj[QLatin1String("album")];
if (json_album.isNull()) {
if (offset_requested == 0) no_results_ = true;
AlbumsFinishCheck(offset_requested, size_requested);
@ -258,25 +258,25 @@ void SubsonicRequest::AlbumsReplyReceived(QNetworkReply *reply, const int offset
}
QJsonObject obj_album = value_album.toObject();
if (!obj_album.contains(QStringLiteral("id")) || !obj_album.contains(QStringLiteral("artist"))) {
if (!obj_album.contains(QLatin1String("id")) || !obj_album.contains(QLatin1String("artist"))) {
Error(QStringLiteral("Invalid Json reply, album object in array is missing ID or artist."), obj_album);
continue;
}
if (!obj_album.contains(QStringLiteral("album")) && !obj_album.contains(QStringLiteral("name"))) {
if (!obj_album.contains(QLatin1String("album")) && !obj_album.contains(QLatin1String("name"))) {
Error(QStringLiteral("Invalid Json reply, album object in array is missing album or name."), obj_album);
continue;
}
QString album_id = obj_album[QStringLiteral("id")].toString();
QString album_id = obj_album[QLatin1String("id")].toString();
if (album_id.isEmpty()) {
album_id = QString::number(obj_album[QStringLiteral("id")].toInt());
album_id = QString::number(obj_album[QLatin1String("id")].toInt());
}
QString artist = obj_album[QStringLiteral("artist")].toString();
QString artist = obj_album[QLatin1String("artist")].toString();
QString album;
if (obj_album.contains(QStringLiteral("album"))) album = obj_album[QStringLiteral("album")].toString();
else if (obj_album.contains(QStringLiteral("name"))) album = obj_album[QStringLiteral("name")].toString();
if (obj_album.contains(QLatin1String("album"))) album = obj_album[QLatin1String("album")].toString();
else if (obj_album.contains(QLatin1String("name"))) album = obj_album[QLatin1String("name")].toString();
if (album_songs_requests_pending_.contains(album_id)) continue;
@ -379,17 +379,17 @@ void SubsonicRequest::AlbumSongsReplyReceived(QNetworkReply *reply, const QStrin
return;
}
if (json_obj.contains(QStringLiteral("error"))) {
QJsonValue json_error = json_obj[QStringLiteral("error")];
if (json_obj.contains(QLatin1String("error"))) {
QJsonValue json_error = json_obj[QLatin1String("error")];
if (!json_error.isObject()) {
Error(QStringLiteral("Json error is not an object."), json_obj);
SongsFinishCheck();
return;
}
json_obj = json_error.toObject();
if (!json_obj.isEmpty() && json_obj.contains(QStringLiteral("code")) && json_obj.contains(QStringLiteral("message"))) {
int code = json_obj[QStringLiteral("code")].toInt();
QString message = json_obj[QStringLiteral("message")].toString();
if (!json_obj.isEmpty() && json_obj.contains(QLatin1String("code")) && json_obj.contains(QLatin1String("message"))) {
int code = json_obj[QLatin1String("code")].toInt();
QString message = json_obj[QLatin1String("message")].toString();
Error(QStringLiteral("%1 (%2)").arg(message).arg(code));
SongsFinishCheck();
}
@ -400,12 +400,12 @@ void SubsonicRequest::AlbumSongsReplyReceived(QNetworkReply *reply, const QStrin
return;
}
if (!json_obj.contains(QStringLiteral("album"))) {
if (!json_obj.contains(QLatin1String("album"))) {
Error(QStringLiteral("Json reply is missing albumList."), json_obj);
SongsFinishCheck();
return;
}
QJsonValue value_album = json_obj[QStringLiteral("album")];
QJsonValue value_album = json_obj[QLatin1String("album")];
if (!value_album.isObject()) {
Error(QStringLiteral("Json album is not an object."), value_album);
@ -414,12 +414,12 @@ void SubsonicRequest::AlbumSongsReplyReceived(QNetworkReply *reply, const QStrin
}
QJsonObject obj_album = value_album.toObject();
if (!obj_album.contains(QStringLiteral("song"))) {
if (!obj_album.contains(QLatin1String("song"))) {
Error(QStringLiteral("Json album object does not contain song array."), json_obj);
SongsFinishCheck();
return;
}
QJsonValue json_song = obj_album[QStringLiteral("song")];
QJsonValue json_song = obj_album[QLatin1String("song")];
if (!json_song.isArray()) {
Error(QStringLiteral("Json song is not an array."), obj_album);
SongsFinishCheck();
@ -428,8 +428,8 @@ void SubsonicRequest::AlbumSongsReplyReceived(QNetworkReply *reply, const QStrin
QJsonArray array_songs = json_song.toArray();
qint64 created = 0;
if (obj_album.contains(QStringLiteral("created"))) {
created = QDateTime::fromString(obj_album[QStringLiteral("created")].toString(), Qt::ISODate).toSecsSinceEpoch();
if (obj_album.contains(QLatin1String("created"))) {
created = QDateTime::fromString(obj_album[QLatin1String("created")].toString(), Qt::ISODate).toSecsSinceEpoch();
}
bool compilation = false;
@ -491,133 +491,133 @@ QString SubsonicRequest::ParseSong(Song &song, const QJsonObject &json_obj, cons
Q_UNUSED(album_id_requested);
if (
!json_obj.contains(QStringLiteral("id")) ||
!json_obj.contains(QStringLiteral("title")) ||
!json_obj.contains(QStringLiteral("size")) ||
!json_obj.contains(QStringLiteral("suffix")) ||
!json_obj.contains(QStringLiteral("duration")) ||
!json_obj.contains(QStringLiteral("type"))
!json_obj.contains(QLatin1String("id")) ||
!json_obj.contains(QLatin1String("title")) ||
!json_obj.contains(QLatin1String("size")) ||
!json_obj.contains(QLatin1String("suffix")) ||
!json_obj.contains(QLatin1String("duration")) ||
!json_obj.contains(QLatin1String("type"))
) {
Error(QStringLiteral("Invalid Json reply, song is missing one or more values."), json_obj);
return QString();
}
QString song_id;
if (json_obj[QStringLiteral("id")].type() == QJsonValue::String) {
song_id = json_obj[QStringLiteral("id")].toString();
if (json_obj[QLatin1String("id")].type() == QJsonValue::String) {
song_id = json_obj[QLatin1String("id")].toString();
}
else {
song_id = QString::number(json_obj[QStringLiteral("id")].toInt());
song_id = QString::number(json_obj[QLatin1String("id")].toInt());
}
QString album_id;
if (json_obj.contains(QStringLiteral("albumId"))) {
if (json_obj[QStringLiteral("albumId")].type() == QJsonValue::String) {
album_id = json_obj[QStringLiteral("albumId")].toString();
if (json_obj.contains(QLatin1String("albumId"))) {
if (json_obj[QLatin1String("albumId")].type() == QJsonValue::String) {
album_id = json_obj[QLatin1String("albumId")].toString();
}
else {
album_id = QString::number(json_obj[QStringLiteral("albumId")].toInt());
album_id = QString::number(json_obj[QLatin1String("albumId")].toInt());
}
}
QString artist_id;
if (json_obj.contains(QStringLiteral("artistId"))) {
if (json_obj[QStringLiteral("artistId")].type() == QJsonValue::String) {
artist_id = json_obj[QStringLiteral("artistId")].toString();
if (json_obj.contains(QLatin1String("artistId"))) {
if (json_obj[QLatin1String("artistId")].type() == QJsonValue::String) {
artist_id = json_obj[QLatin1String("artistId")].toString();
}
else {
artist_id = QString::number(json_obj[QStringLiteral("artistId")].toInt());
artist_id = QString::number(json_obj[QLatin1String("artistId")].toInt());
}
}
QString title = json_obj[QStringLiteral("title")].toString();
QString title = json_obj[QLatin1String("title")].toString();
QString album;
if (json_obj.contains(QStringLiteral("album"))) {
album = json_obj[QStringLiteral("album")].toString();
if (json_obj.contains(QLatin1String("album"))) {
album = json_obj[QLatin1String("album")].toString();
}
QString artist;
if (json_obj.contains(QStringLiteral("artist"))) {
artist = json_obj[QStringLiteral("artist")].toString();
if (json_obj.contains(QLatin1String("artist"))) {
artist = json_obj[QLatin1String("artist")].toString();
}
int size = 0;
if (json_obj[QStringLiteral("size")].type() == QJsonValue::String) {
size = json_obj[QStringLiteral("size")].toString().toInt();
if (json_obj[QLatin1String("size")].type() == QJsonValue::String) {
size = json_obj[QLatin1String("size")].toString().toInt();
}
else {
size = json_obj[QStringLiteral("size")].toInt();
size = json_obj[QLatin1String("size")].toInt();
}
qint64 duration = 0;
if (json_obj[QStringLiteral("duration")].type() == QJsonValue::String) {
duration = json_obj[QStringLiteral("duration")].toString().toInt() * kNsecPerSec;
if (json_obj[QLatin1String("duration")].type() == QJsonValue::String) {
duration = json_obj[QLatin1String("duration")].toString().toInt() * kNsecPerSec;
}
else {
duration = json_obj[QStringLiteral("duration")].toInt() * kNsecPerSec;
duration = json_obj[QLatin1String("duration")].toInt() * kNsecPerSec;
}
int bitrate = 0;
if (json_obj.contains(QStringLiteral("bitRate"))) {
if (json_obj[QStringLiteral("bitRate")].type() == QJsonValue::String) {
bitrate = json_obj[QStringLiteral("bitRate")].toString().toInt();
if (json_obj.contains(QLatin1String("bitRate"))) {
if (json_obj[QLatin1String("bitRate")].type() == QJsonValue::String) {
bitrate = json_obj[QLatin1String("bitRate")].toString().toInt();
}
else {
bitrate = json_obj[QStringLiteral("bitRate")].toInt();
bitrate = json_obj[QLatin1String("bitRate")].toInt();
}
}
QString mimetype;
if (json_obj.contains(QStringLiteral("contentType"))) {
mimetype = json_obj[QStringLiteral("contentType")].toString();
if (json_obj.contains(QLatin1String("contentType"))) {
mimetype = json_obj[QLatin1String("contentType")].toString();
}
int year = 0;
if (json_obj.contains(QStringLiteral("year"))) {
if (json_obj[QStringLiteral("year")].type() == QJsonValue::String) {
year = json_obj[QStringLiteral("year")].toString().toInt();
if (json_obj.contains(QLatin1String("year"))) {
if (json_obj[QLatin1String("year")].type() == QJsonValue::String) {
year = json_obj[QLatin1String("year")].toString().toInt();
}
else {
year = json_obj[QStringLiteral("year")].toInt();
year = json_obj[QLatin1String("year")].toInt();
}
}
int disc = 0;
if (json_obj.contains(QStringLiteral("discNumber"))) {
if (json_obj[QStringLiteral("discNumber")].type() == QJsonValue::String) {
disc = json_obj[QStringLiteral("discNumber")].toString().toInt();
if (json_obj.contains(QLatin1String("discNumber"))) {
if (json_obj[QLatin1String("discNumber")].type() == QJsonValue::String) {
disc = json_obj[QLatin1String("discNumber")].toString().toInt();
}
else {
disc = json_obj[QStringLiteral("discNumber")].toInt();
disc = json_obj[QLatin1String("discNumber")].toInt();
}
}
int track = 0;
if (json_obj.contains(QStringLiteral("track"))) {
if (json_obj[QStringLiteral("track")].type() == QJsonValue::String) {
track = json_obj[QStringLiteral("track")].toString().toInt();
if (json_obj.contains(QLatin1String("track"))) {
if (json_obj[QLatin1String("track")].type() == QJsonValue::String) {
track = json_obj[QLatin1String("track")].toString().toInt();
}
else {
track = json_obj[QStringLiteral("track")].toInt();
track = json_obj[QLatin1String("track")].toInt();
}
}
QString genre;
if (json_obj.contains(QStringLiteral("genre"))) genre = json_obj[QStringLiteral("genre")].toString();
if (json_obj.contains(QLatin1String("genre"))) genre = json_obj[QLatin1String("genre")].toString();
QString cover_id;
if (json_obj.contains(QStringLiteral("coverArt"))) {
if (json_obj[QStringLiteral("coverArt")].type() == QJsonValue::String) {
cover_id = json_obj[QStringLiteral("coverArt")].toString();
if (json_obj.contains(QLatin1String("coverArt"))) {
if (json_obj[QLatin1String("coverArt")].type() == QJsonValue::String) {
cover_id = json_obj[QLatin1String("coverArt")].toString();
}
else {
cover_id = QString::number(json_obj[QStringLiteral("coverArt")].toInt());
cover_id = QString::number(json_obj[QLatin1String("coverArt")].toInt());
}
}
qint64 created = 0;
if (json_obj.contains(QStringLiteral("created"))) {
created = QDateTime::fromString(json_obj[QStringLiteral("created")].toString(), Qt::ISODate).toSecsSinceEpoch();
if (json_obj.contains(QLatin1String("created"))) {
created = QDateTime::fromString(json_obj[QLatin1String("created")].toString(), Qt::ISODate).toSecsSinceEpoch();
}
else {
created = album_created;
@ -723,7 +723,7 @@ void SubsonicRequest::AddAlbumCoverRequest(const Song &song) {
request.album_id = song.album_id();
request.cover_id = cover_id;
request.url = cover_url;
request.filename = cover_path + QLatin1Char('/') + cover_id + QStringLiteral(".jpg");
request.filename = cover_path + QLatin1Char('/') + cover_id + QLatin1String(".jpg");
if (request.filename.isEmpty()) return;
album_covers_requests_sent_.insert(cover_id, song.song_id());

10
src/subsonic/subsonicscrobblerequest.cpp
View File

@ -111,17 +111,17 @@ void SubsonicScrobbleRequest::ScrobbleReplyReceived(QNetworkReply *reply) {
return;
}
if (json_obj.contains(QStringLiteral("error"))) {
QJsonValue json_error = json_obj[QStringLiteral("error")];
if (json_obj.contains(QLatin1String("error"))) {
QJsonValue json_error = json_obj[QLatin1String("error")];
if (!json_error.isObject()) {
Error(QStringLiteral("Json error is not an object."), json_obj);
FinishCheck();
return;
}
json_obj = json_error.toObject();
if (!json_obj.isEmpty() && json_obj.contains(QStringLiteral("code")) && json_obj.contains(QStringLiteral("message"))) {
int code = json_obj[QStringLiteral("code")].toInt();
QString message = json_obj[QStringLiteral("message")].toString();
if (!json_obj.isEmpty() && json_obj.contains(QLatin1String("code")) && json_obj.contains(QLatin1String("message"))) {
int code = json_obj[QLatin1String("code")].toInt();
QString message = json_obj[QLatin1String("message")].toString();
Error(QStringLiteral("%1 (%2)").arg(message).arg(code));
FinishCheck();
}

42
src/subsonic/subsonicservice.cpp
View File

@ -174,11 +174,11 @@ void SubsonicService::SendPingWithCredentials(QUrl url, const QString &username,
}
if (!redirect) {
if (!url.path().isEmpty() && url.path().right(1) == QStringLiteral("/")) {
url.setPath(url.path() + QStringLiteral("rest/ping.view"));
if (!url.path().isEmpty() && url.path().right(1) == QLatin1Char('/')) {
url.setPath(url.path() + QLatin1String("rest/ping.view"));
}
else {
url.setPath(url.path() + QStringLiteral("/rest/ping.view"));
url.setPath(url.path() + QLatin1String("/rest/ping.view"));
}
}
@ -186,7 +186,7 @@ void SubsonicService::SendPingWithCredentials(QUrl url, const QString &username,
QNetworkRequest req(url);
if (url.scheme() == QStringLiteral("https") && !verify_certificate_) {
if (url.scheme() == QLatin1String("https") && !verify_certificate_) {
QSslConfiguration sslconfig = QSslConfiguration::defaultConfiguration();
sslconfig.setPeerVerifyMode(QSslSocket::VerifyNone);
req.setSslConfiguration(sslconfig);
@ -260,13 +260,13 @@ void SubsonicService::HandlePingReply(QNetworkReply *reply, const QUrl &url, con
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(QStringLiteral("error"))) {
QJsonValue json_error = json_obj[QStringLiteral("error")];
if (!json_obj.isEmpty() && json_obj.contains(QLatin1String("error"))) {
QJsonValue json_error = json_obj[QLatin1String("error")];
if (json_error.isObject()) {
json_obj = json_error.toObject();
if (!json_obj.isEmpty() && json_obj.contains(QStringLiteral("code")) && json_obj.contains(QStringLiteral("message"))) {
int code = json_obj[QStringLiteral("code")].toInt();
QString message = json_obj[QStringLiteral("message")].toString();
if (!json_obj.isEmpty() && json_obj.contains(QLatin1String("code")) && json_obj.contains(QLatin1String("message"))) {
int code = json_obj[QLatin1String("code")].toInt();
QString message = json_obj[QLatin1String("message")].toString();
errors_ << QStringLiteral("%1 (%2)").arg(message).arg(code);
}
}
@ -313,49 +313,49 @@ void SubsonicService::HandlePingReply(QNetworkReply *reply, const QUrl &url, con
return;
}
if (!json_obj.contains(QStringLiteral("subsonic-response"))) {
if (!json_obj.contains(QLatin1String("subsonic-response"))) {
PingError(QStringLiteral("Ping reply from server is missing subsonic-response"), json_obj);
return;
}
QJsonValue value_response = json_obj[QStringLiteral("subsonic-response")];
QJsonValue value_response = json_obj[QLatin1String("subsonic-response")];
if (!value_response.isObject()) {
PingError(QStringLiteral("Ping reply from server subsonic-response is not an object"), value_response);
return;
}
QJsonObject obj_response = value_response.toObject();
if (obj_response.contains(QStringLiteral("error"))) {
QJsonValue value_error = obj_response[QStringLiteral("error")];
if (obj_response.contains(QLatin1String("error"))) {
QJsonValue value_error = obj_response[QLatin1String("error")];
if (!value_error.isObject()) {
PingError(QStringLiteral("Authentication error reply from server is not an object"), value_error);
return;
}
QJsonObject obj_error = value_error.toObject();
if (!obj_error.contains(QStringLiteral("code")) || !obj_error.contains(QStringLiteral("message"))) {
if (!obj_error.contains(QLatin1String("code")) || !obj_error.contains(QLatin1String("message"))) {
PingError(QStringLiteral("Authentication error reply from server is missing status or message"), json_obj);
return;
}
//int status = obj_error["code"].toInt();
QString message = obj_error[QStringLiteral("message")].toString();
QString message = obj_error[QLatin1String("message")].toString();
emit TestComplete(false, message);
emit TestFailure(message);
return;
}
if (!obj_response.contains(QStringLiteral("status"))) {
if (!obj_response.contains(QLatin1String("status"))) {
PingError(QStringLiteral("Ping reply from server is missing status"), obj_response);
return;
}
QString status = obj_response[QStringLiteral("status")].toString().toLower();
QString message = obj_response[QStringLiteral("message")].toString();
QString status = obj_response[QLatin1String("status")].toString().toLower();
QString message = obj_response[QLatin1String("message")].toString();
if (status == QStringLiteral("failed")) {
if (status == QLatin1String("failed")) {
emit TestComplete(false, message);
emit TestFailure(message);
return;
}
else if (status == QStringLiteral("ok")) {
else if (status == QLatin1String("ok")) {
emit TestComplete(true);
emit TestSuccess();
return;
@ -453,7 +453,7 @@ void SubsonicService::PingError(const QString &error, const QVariant &debug) {
QString error_html;
for (const QString &e : errors_) {
qLog(Error) << "Subsonic:" << e;
error_html += e + QStringLiteral("<br />");
error_html += e + QLatin1String("<br />");
}
if (debug.isValid()) qLog(Debug) << debug;

14
src/tidal/tidalbaserequest.cpp
View File

@ -102,10 +102,10 @@ QByteArray TidalBaseRequest::GetReplyData(QNetworkReply *reply, const bool send_
int sub_status = 0;
if (json_error.error == QJsonParseError::NoError && !json_doc.isEmpty() && json_doc.isObject()) {
QJsonObject json_obj = json_doc.object();
if (!json_obj.isEmpty() && json_obj.contains(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();
if (!json_obj.isEmpty() && json_obj.contains(QLatin1String("status")) && json_obj.contains(QLatin1String("userMessage"))) {
status = json_obj[QLatin1String("status")].toInt();
sub_status = json_obj[QLatin1String("subStatus")].toInt();
QString user_message = json_obj[QLatin1String("userMessage")].toString();
error = QStringLiteral("%1 (%2) (%3)").arg(user_message).arg(status).arg(sub_status);
}
}
@ -185,11 +185,11 @@ QJsonValue TidalBaseRequest::ExtractItems(const QByteArray &data) {
QJsonValue TidalBaseRequest::ExtractItems(const QJsonObject &json_obj) {
if (!json_obj.contains(QStringLiteral("items"))) {
if (!json_obj.contains(QLatin1String("items"))) {
Error(QStringLiteral("Json reply is missing items."), json_obj);
return QJsonArray();
}
QJsonValue json_items = json_obj[QStringLiteral("items")];
QJsonValue json_items = json_obj[QLatin1String("items")];
return json_items;
}
@ -198,7 +198,7 @@ QString TidalBaseRequest::ErrorsToHTML(const QStringList &errors) {
QString error_html;
for (const QString &error : errors) {
error_html += error + QStringLiteral("<br />");
error_html += error + QLatin1String("<br />");
}
return error_html;

4
src/tidal/tidalfavoriterequest.cpp
View File

@ -142,7 +142,7 @@ void TidalFavoriteRequest::AddFavoritesRequest(const FavoriteType type, const QS
url_query.addQueryItem(QString::fromLatin1(QUrl::toPercentEncoding(param.first)), QString::fromLatin1(QUrl::toPercentEncoding(param.second)));
}
QUrl url(QLatin1String(TidalService::kApiUrl) + QLatin1Char('/') + QStringLiteral("users/") + QString::number(service_->user_id()) + QStringLiteral("/favorites/") + FavoriteText(type));
QUrl url(QLatin1String(TidalService::kApiUrl) + QLatin1Char('/') + QLatin1String("users/") + QString::number(service_->user_id()) + QLatin1String("/favorites/") + FavoriteText(type));
QNetworkRequest req(url);
req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
req.setHeader(QNetworkRequest::ContentTypeHeader, QStringLiteral("application/x-www-form-urlencoded"));
@ -251,7 +251,7 @@ void TidalFavoriteRequest::RemoveFavoritesRequest(const FavoriteType type, const
url_query.addQueryItem(QString::fromLatin1(QUrl::toPercentEncoding(param.first)), QString::fromLatin1(QUrl::toPercentEncoding(param.second)));
}
QUrl url(QLatin1String(TidalService::kApiUrl) + QStringLiteral("/users/") + QString::number(service_->user_id()) + QStringLiteral("/favorites/") + FavoriteText(type) + QStringLiteral("/") + id);
QUrl url(QLatin1String(TidalService::kApiUrl) + QLatin1String("/users/") + QString::number(service_->user_id()) + QLatin1String("/favorites/") + FavoriteText(type) + QLatin1String("/") + id);
url.setQuery(url_query);
QNetworkRequest req(url);
req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);

186
src/tidal/tidalrequest.cpp
View File

@ -433,17 +433,17 @@ void TidalRequest::ArtistsReplyReceived(QNetworkReply *reply, const int limit_re
return;
}
if (!json_obj.contains(QStringLiteral("limit")) ||
!json_obj.contains(QStringLiteral("offset")) ||
!json_obj.contains(QStringLiteral("totalNumberOfItems")) ||
!json_obj.contains(QStringLiteral("items"))) {
if (!json_obj.contains(QLatin1String("limit")) ||
!json_obj.contains(QLatin1String("offset")) ||
!json_obj.contains(QLatin1String("totalNumberOfItems")) ||
!json_obj.contains(QLatin1String("items"))) {
Error(QStringLiteral("Json object missing values."), json_obj);
ArtistsFinishCheck();
return;
}
//int limit = json_obj["limit"].toInt();
int offset = json_obj[QStringLiteral("offset")].toInt();
int artists_total = json_obj[QStringLiteral("totalNumberOfItems")].toInt();
int offset = json_obj[QLatin1String("offset")].toInt();
int artists_total = json_obj[QLatin1String("totalNumberOfItems")].toInt();
if (offset_requested == 0) {
artists_total_ = artists_total;
@ -487,8 +487,8 @@ void TidalRequest::ArtistsReplyReceived(QNetworkReply *reply, const int limit_re
}
QJsonObject obj_item = value_item.toObject();
if (obj_item.contains(QStringLiteral("item"))) {
QJsonValue json_item = obj_item[QStringLiteral("item")];
if (obj_item.contains(QLatin1String("item"))) {
QJsonValue json_item = obj_item[QLatin1String("item")];
if (!json_item.isObject()) {
Error(QStringLiteral("Invalid Json reply, item in array is not a object."), json_item);
continue;
@ -496,19 +496,19 @@ void TidalRequest::ArtistsReplyReceived(QNetworkReply *reply, const int limit_re
obj_item = json_item.toObject();
}
if (!obj_item.contains(QStringLiteral("id")) || !obj_item.contains(QStringLiteral("name"))) {
if (!obj_item.contains(QLatin1String("id")) || !obj_item.contains(QLatin1String("name"))) {
Error(QStringLiteral("Invalid Json reply, item missing id or album."), obj_item);
continue;
}
Artist artist;
if (obj_item[QStringLiteral("id")].isString()) {
artist.artist_id = obj_item[QStringLiteral("id")].toString();
if (obj_item[QLatin1String("id")].isString()) {
artist.artist_id = obj_item[QLatin1String("id")].toString();
}
else {
artist.artist_id = QString::number(obj_item[QStringLiteral("id")].toInt());
artist.artist_id = QString::number(obj_item[QLatin1String("id")].toInt());
}
artist.artist = obj_item[QStringLiteral("name")].toString();
artist.artist = obj_item[QLatin1String("name")].toString();
if (artist_albums_requests_pending_.contains(artist.artist_id)) continue;
@ -628,18 +628,18 @@ void TidalRequest::AlbumsReceived(QNetworkReply *reply, const Artist &artist_req
return;
}
if (!json_obj.contains(QStringLiteral("limit")) ||
!json_obj.contains(QStringLiteral("offset")) ||
!json_obj.contains(QStringLiteral("totalNumberOfItems")) ||
!json_obj.contains(QStringLiteral("items"))) {
if (!json_obj.contains(QLatin1String("limit")) ||
!json_obj.contains(QLatin1String("offset")) ||
!json_obj.contains(QLatin1String("totalNumberOfItems")) ||
!json_obj.contains(QLatin1String("items"))) {
Error(QStringLiteral("Json object missing values."), json_obj);
AlbumsFinishCheck(artist_requested);
return;
}
//int limit = json_obj["limit"].toInt();
int offset = json_obj[QStringLiteral("offset")].toInt();
int albums_total = json_obj[QStringLiteral("totalNumberOfItems")].toInt();
int offset = json_obj[QLatin1String("offset")].toInt();
int albums_total = json_obj[QLatin1String("totalNumberOfItems")].toInt();
if (offset != offset_requested) {
Error(QStringLiteral("Offset returned does not match offset requested! %1 != %2").arg(offset).arg(offset_requested));
@ -669,8 +669,8 @@ void TidalRequest::AlbumsReceived(QNetworkReply *reply, const Artist &artist_req
}
QJsonObject obj_item = value_item.toObject();
if (obj_item.contains(QStringLiteral("item"))) {
QJsonValue json_item = obj_item[QStringLiteral("item")];
if (obj_item.contains(QLatin1String("item"))) {
QJsonValue json_item = obj_item[QLatin1String("item")];
if (!json_item.isObject()) {
Error(QStringLiteral("Invalid Json reply, item in array is not a object."), json_item);
continue;
@ -679,47 +679,47 @@ void TidalRequest::AlbumsReceived(QNetworkReply *reply, const Artist &artist_req
}
Album album;
if (obj_item.contains(QStringLiteral("type"))) { // This was an albums request or search
if (!obj_item.contains(QStringLiteral("id")) || !obj_item.contains(QStringLiteral("title"))) {
if (obj_item.contains(QLatin1String("type"))) { // This was an albums request or search
if (!obj_item.contains(QLatin1String("id")) || !obj_item.contains(QLatin1String("title"))) {
Error(QStringLiteral("Invalid Json reply, item is missing ID or title."), obj_item);
continue;
}
if (obj_item[QStringLiteral("id")].isString()) {
album.album_id = obj_item[QStringLiteral("id")].toString();
if (obj_item[QLatin1String("id")].isString()) {
album.album_id = obj_item[QLatin1String("id")].toString();
}
else {
album.album_id = QString::number(obj_item[QStringLiteral("id")].toInt());
album.album_id = QString::number(obj_item[QLatin1String("id")].toInt());
}
album.album = obj_item[QStringLiteral("title")].toString();
if (service_->album_explicit() && obj_item.contains(QStringLiteral("explicit"))) {
album.album_explicit = obj_item[QStringLiteral("explicit")].toVariant().toBool();
album.album = obj_item[QLatin1String("title")].toString();
if (service_->album_explicit() && obj_item.contains(QLatin1String("explicit"))) {
album.album_explicit = obj_item[QLatin1String("explicit")].toVariant().toBool();
if (album.album_explicit && !album.album.isEmpty()) {
album.album.append(QStringLiteral(" (Explicit)"));
album.album.append(QLatin1String(" (Explicit)"));
}
}
}
else if (obj_item.contains(QStringLiteral("album"))) { // This was a tracks request or search
QJsonValue value_album = obj_item[QStringLiteral("album")];
else if (obj_item.contains(QLatin1String("album"))) { // This was a tracks request or search
QJsonValue value_album = obj_item[QLatin1String("album")];
if (!value_album.isObject()) {
Error(QStringLiteral("Invalid Json reply, item album is not a object."), value_album);
continue;
}
QJsonObject obj_album = value_album.toObject();
if (!obj_album.contains(QStringLiteral("id")) || !obj_album.contains(QStringLiteral("title"))) {
if (!obj_album.contains(QLatin1String("id")) || !obj_album.contains(QLatin1String("title"))) {
Error(QStringLiteral("Invalid Json reply, item album is missing ID or title."), obj_album);
continue;
}
if (obj_album[QStringLiteral("id")].isString()) {
album.album_id = obj_album[QStringLiteral("id")].toString();
if (obj_album[QLatin1String("id")].isString()) {
album.album_id = obj_album[QLatin1String("id")].toString();
}
else {
album.album_id = QString::number(obj_album[QStringLiteral("id")].toInt());
album.album_id = QString::number(obj_album[QLatin1String("id")].toInt());
}
album.album = obj_album[QStringLiteral("title")].toString();
if (service_->album_explicit() && obj_album.contains(QStringLiteral("explicit"))) {
album.album_explicit = obj_album[QStringLiteral("explicit")].toVariant().toBool();
album.album = obj_album[QLatin1String("title")].toString();
if (service_->album_explicit() && obj_album.contains(QLatin1String("explicit"))) {
album.album_explicit = obj_album[QLatin1String("explicit")].toVariant().toBool();
if (album.album_explicit && !album.album.isEmpty()) {
album.album.append(QStringLiteral(" (Explicit)"));
album.album.append(QLatin1String(" (Explicit)"));
}
}
}
@ -730,29 +730,29 @@ void TidalRequest::AlbumsReceived(QNetworkReply *reply, const Artist &artist_req
if (album_songs_requests_pending_.contains(album.album_id)) continue;
if (!obj_item.contains(QStringLiteral("artist")) || !obj_item.contains(QStringLiteral("title")) || !obj_item.contains(QStringLiteral("audioQuality"))) {
if (!obj_item.contains(QLatin1String("artist")) || !obj_item.contains(QLatin1String("title")) || !obj_item.contains(QLatin1String("audioQuality"))) {
Error(QStringLiteral("Invalid Json reply, item missing artist, title or audioQuality."), obj_item);
continue;
}
QJsonValue value_artist = obj_item[QStringLiteral("artist")];
QJsonValue value_artist = obj_item[QLatin1String("artist")];
if (!value_artist.isObject()) {
Error(QStringLiteral("Invalid Json reply, item artist is not a object."), value_artist);
continue;
}
QJsonObject obj_artist = value_artist.toObject();
if (!obj_artist.contains(QStringLiteral("id")) || !obj_artist.contains(QStringLiteral("name"))) {
if (!obj_artist.contains(QLatin1String("id")) || !obj_artist.contains(QLatin1String("name"))) {
Error(QStringLiteral("Invalid Json reply, item artist missing id or name."), obj_artist);
continue;
}
Artist album_artist;
if (obj_artist[QStringLiteral("id")].isString()) {
album_artist.artist_id = obj_artist[QStringLiteral("id")].toString();
if (obj_artist[QLatin1String("id")].isString()) {
album_artist.artist_id = obj_artist[QLatin1String("id")].toString();
}
else {
album_artist.artist_id = QString::number(obj_artist[QStringLiteral("id")].toInt());
album_artist.artist_id = QString::number(obj_artist[QLatin1String("id")].toInt());
}
album_artist.artist = obj_artist[QStringLiteral("name")].toString();
album_artist.artist = obj_artist[QLatin1String("name")].toString();
//QString quality = obj_item["audioQuality"].toString();
//QString copyright = obj_item["copyright"].toString();
@ -905,18 +905,18 @@ void TidalRequest::SongsReceived(QNetworkReply *reply, const Artist &artist, con
return;
}
if (!json_obj.contains(QStringLiteral("limit")) ||
!json_obj.contains(QStringLiteral("offset")) ||
!json_obj.contains(QStringLiteral("totalNumberOfItems")) ||
!json_obj.contains(QStringLiteral("items"))) {
if (!json_obj.contains(QLatin1String("limit")) ||
!json_obj.contains(QLatin1String("offset")) ||
!json_obj.contains(QLatin1String("totalNumberOfItems")) ||
!json_obj.contains(QLatin1String("items"))) {
Error(QStringLiteral("Json object missing values."), json_obj);
SongsFinishCheck(artist, album, limit_requested, offset_requested);
return;
}
//int limit = json_obj["limit"].toInt();
int offset = json_obj[QStringLiteral("offset")].toInt();
int songs_total = json_obj[QStringLiteral("totalNumberOfItems")].toInt();
int offset = json_obj[QLatin1String("offset")].toInt();
int songs_total = json_obj[QLatin1String("totalNumberOfItems")].toInt();
if (offset != offset_requested) {
Error(QStringLiteral("Offset returned does not match offset requested! %1 != %2").arg(offset).arg(offset_requested));
@ -948,8 +948,8 @@ void TidalRequest::SongsReceived(QNetworkReply *reply, const Artist &artist, con
}
QJsonObject obj_item = value_item.toObject();
if (obj_item.contains(QStringLiteral("item"))) {
QJsonValue item = obj_item[QStringLiteral("item")];
if (obj_item.contains(QLatin1String("item"))) {
QJsonValue item = obj_item[QLatin1String("item")];
if (!item.isObject()) {
Error(QStringLiteral("Invalid Json reply, item is not a object."), item);
continue;
@ -1019,85 +1019,85 @@ void TidalRequest::SongsFinishCheck(const Artist &artist, const Album &album, co
void TidalRequest::ParseSong(Song &song, const QJsonObject &json_obj, const Artist &album_artist, const Album &album) {
if (
!json_obj.contains(QStringLiteral("album")) ||
!json_obj.contains(QStringLiteral("allowStreaming")) ||
!json_obj.contains(QStringLiteral("artist")) ||
!json_obj.contains(QStringLiteral("artists")) ||
!json_obj.contains(QStringLiteral("audioQuality")) ||
!json_obj.contains(QStringLiteral("duration")) ||
!json_obj.contains(QStringLiteral("id")) ||
!json_obj.contains(QStringLiteral("streamReady")) ||
!json_obj.contains(QStringLiteral("title")) ||
!json_obj.contains(QStringLiteral("trackNumber")) ||
!json_obj.contains(QStringLiteral("url")) ||
!json_obj.contains(QStringLiteral("volumeNumber")) ||
!json_obj.contains(QStringLiteral("copyright"))
!json_obj.contains(QLatin1String("album")) ||
!json_obj.contains(QLatin1String("allowStreaming")) ||
!json_obj.contains(QLatin1String("artist")) ||
!json_obj.contains(QLatin1String("artists")) ||
!json_obj.contains(QLatin1String("audioQuality")) ||
!json_obj.contains(QLatin1String("duration")) ||
!json_obj.contains(QLatin1String("id")) ||
!json_obj.contains(QLatin1String("streamReady")) ||
!json_obj.contains(QLatin1String("title")) ||
!json_obj.contains(QLatin1String("trackNumber")) ||
!json_obj.contains(QLatin1String("url")) ||
!json_obj.contains(QLatin1String("volumeNumber")) ||
!json_obj.contains(QLatin1String("copyright"))
) {
Error(QStringLiteral("Invalid Json reply, track is missing one or more values."), json_obj);
return;
}
QJsonValue value_artist = json_obj[QStringLiteral("artist")];
QJsonValue value_album = json_obj[QStringLiteral("album")];
QJsonValue json_duration = json_obj[QStringLiteral("duration")];
QJsonValue value_artist = json_obj[QLatin1String("artist")];
QJsonValue value_album = json_obj[QLatin1String("album")];
QJsonValue json_duration = json_obj[QLatin1String("duration")];
//QJsonArray array_artists = json_obj["artists"].toArray();
QString song_id;
if (json_obj[QStringLiteral("id")].isString()) {
song_id = json_obj[QStringLiteral("id")].toString();
if (json_obj[QLatin1String("id")].isString()) {
song_id = json_obj[QLatin1String("id")].toString();
}
else {
song_id = QString::number(json_obj[QStringLiteral("id")].toInt());
song_id = QString::number(json_obj[QLatin1String("id")].toInt());
}
QString title = json_obj[QStringLiteral("title")].toString();
QString title = json_obj[QLatin1String("title")].toString();
//QString urlstr = json_obj["url"].toString();
int track = json_obj[QStringLiteral("trackNumber")].toInt();
int disc = json_obj[QStringLiteral("volumeNumber")].toInt();
bool allow_streaming = json_obj[QStringLiteral("allowStreaming")].toBool();
bool stream_ready = json_obj[QStringLiteral("streamReady")].toBool();
QString copyright = json_obj[QStringLiteral("copyright")].toString();
int track = json_obj[QLatin1String("trackNumber")].toInt();
int disc = json_obj[QLatin1String("volumeNumber")].toInt();
bool allow_streaming = json_obj[QLatin1String("allowStreaming")].toBool();
bool stream_ready = json_obj[QLatin1String("streamReady")].toBool();
QString copyright = json_obj[QLatin1String("copyright")].toString();
if (!value_artist.isObject()) {
Error(QStringLiteral("Invalid Json reply, track artist is not a object."), value_artist);
return;
}
QJsonObject obj_artist = value_artist.toObject();
if (!obj_artist.contains(QStringLiteral("id")) || !obj_artist.contains(QStringLiteral("name"))) {
if (!obj_artist.contains(QLatin1String("id")) || !obj_artist.contains(QLatin1String("name"))) {
Error(QStringLiteral("Invalid Json reply, track artist is missing id or name."), obj_artist);
return;
}
QString artist_id;
if (obj_artist[QStringLiteral("id")].isString()) {
artist_id = obj_artist[QStringLiteral("id")].toString();
if (obj_artist[QLatin1String("id")].isString()) {
artist_id = obj_artist[QLatin1String("id")].toString();
}
else {
artist_id = QString::number(obj_artist[QStringLiteral("id")].toInt());
artist_id = QString::number(obj_artist[QLatin1String("id")].toInt());
}
QString artist = obj_artist[QStringLiteral("name")].toString();
QString artist = obj_artist[QLatin1String("name")].toString();
if (!value_album.isObject()) {
Error(QStringLiteral("Invalid Json reply, track album is not a object."), value_album);
return;
}
QJsonObject obj_album = value_album.toObject();
if (!obj_album.contains(QStringLiteral("id")) || !obj_album.contains(QStringLiteral("title"))) {
if (!obj_album.contains(QLatin1String("id")) || !obj_album.contains(QLatin1String("title"))) {
Error(QStringLiteral("Invalid Json reply, track album is missing ID or title."), obj_album);
return;
}
QString album_id;
if (obj_album[QStringLiteral("id")].isString()) {
album_id = obj_album[QStringLiteral("id")].toString();
if (obj_album[QLatin1String("id")].isString()) {
album_id = obj_album[QLatin1String("id")].toString();
}
else {
album_id = QString::number(obj_album[QStringLiteral("id")].toInt());
album_id = QString::number(obj_album[QLatin1String("id")].toInt());
}
if (!album.album_id.isEmpty() && album.album_id != album_id) {
Error(QStringLiteral("Invalid Json reply, track album id is wrong."), obj_album);
return;
}
QString album_title = obj_album[QStringLiteral("title")].toString();
if (album.album_explicit) album_title.append(QStringLiteral(" (Explicit)"));
QString album_title = obj_album[QLatin1String("title")].toString();
if (album.album_explicit) album_title.append(QLatin1String(" (Explicit)"));
if (!allow_streaming) {
Warn(QStringLiteral("Song %1 %2 %3 is not allowStreaming").arg(artist, album_title, title));
@ -1124,8 +1124,8 @@ void TidalRequest::ParseSong(Song &song, const QJsonObject &json_obj, const Arti
}
QUrl cover_url;
if (obj_album.contains(QStringLiteral("cover"))) {
const QString cover = obj_album[QStringLiteral("cover")].toString().replace(QLatin1String("-"), QLatin1String("/"));
if (obj_album.contains(QLatin1String("cover"))) {
const QString cover = obj_album[QLatin1String("cover")].toString().replace(QLatin1Char('-'), QLatin1Char('/'));
if (!cover.isEmpty()) {
cover_url.setUrl(QStringLiteral("%1/images/%2/%3.jpg").arg(QLatin1String(kResourcesUrl), cover, coversize_));
}

46
src/tidal/tidalservice.cpp
View File

@ -424,10 +424,10 @@ void TidalService::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(QStringLiteral("status")) && json_obj.contains(QStringLiteral("userMessage"))) {
int status = json_obj[QStringLiteral("status")].toInt();
int sub_status = json_obj[QStringLiteral("subStatus")].toInt();
QString user_message = json_obj[QStringLiteral("userMessage")].toString();
if (!json_obj.isEmpty() && json_obj.contains(QLatin1String("status")) && json_obj.contains(QLatin1String("userMessage"))) {
int status = json_obj[QLatin1String("status")].toInt();
int sub_status = json_obj[QLatin1String("subStatus")].toInt();
QString user_message = json_obj[QLatin1String("userMessage")].toString();
login_errors_ << QStringLiteral("Authentication failure: %1 (%2) (%3)").arg(user_message).arg(status).arg(sub_status);
}
}
@ -469,23 +469,23 @@ void TidalService::AccessTokenRequestFinished(QNetworkReply *reply) {
return;
}
if (!json_obj.contains(QStringLiteral("access_token")) || !json_obj.contains(QStringLiteral("expires_in"))) {
if (!json_obj.contains(QLatin1String("access_token")) || !json_obj.contains(QLatin1String("expires_in"))) {
LoginError(QStringLiteral("Authentication reply from server is missing access_token or expires_in"), json_obj);
return;
}
access_token_ = json_obj[QStringLiteral("access_token")].toString();
expires_in_ = json_obj[QStringLiteral("expires_in")].toInt();
if (json_obj.contains(QStringLiteral("refresh_token"))) {
refresh_token_ = json_obj[QStringLiteral("refresh_token")].toString();
access_token_ = json_obj[QLatin1String("access_token")].toString();
expires_in_ = json_obj[QLatin1String("expires_in")].toInt();
if (json_obj.contains(QLatin1String("refresh_token"))) {
refresh_token_ = json_obj[QLatin1String("refresh_token")].toString();
}
login_time_ = QDateTime::currentDateTime().toSecsSinceEpoch();
if (json_obj.contains(QStringLiteral("user")) && json_obj[QStringLiteral("user")].isObject()) {
QJsonObject obj_user = json_obj[QStringLiteral("user")].toObject();
if (obj_user.contains(QStringLiteral("countryCode")) && obj_user.contains(QStringLiteral("userId"))) {
country_code_ = obj_user[QStringLiteral("countryCode")].toString();
user_id_ = obj_user[QStringLiteral("userId")].toInt();
if (json_obj.contains(QLatin1String("user")) && json_obj[QLatin1String("user")].isObject()) {
QJsonObject obj_user = json_obj[QLatin1String("user")].toObject();
if (obj_user.contains(QLatin1String("countryCode")) && obj_user.contains(QLatin1String("userId"))) {
country_code_ = obj_user[QLatin1String("countryCode")].toString();
user_id_ = obj_user[QLatin1String("userId")].toInt();
}
}
@ -574,10 +574,10 @@ void TidalService::HandleAuthReply(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(QStringLiteral("status")) && json_obj.contains(QStringLiteral("userMessage"))) {
int status = json_obj[QStringLiteral("status")].toInt();
int sub_status = json_obj[QStringLiteral("subStatus")].toInt();
QString user_message = json_obj[QStringLiteral("userMessage")].toString();
if (!json_obj.isEmpty() && json_obj.contains(QLatin1String("status")) && json_obj.contains(QLatin1String("userMessage"))) {
int status = json_obj[QLatin1String("status")].toInt();
int sub_status = json_obj[QLatin1String("subStatus")].toInt();
QString user_message = json_obj[QLatin1String("userMessage")].toString();
login_errors_ << QStringLiteral("Authentication failure: %1 (%2) (%3)").arg(user_message).arg(status).arg(sub_status);
}
}
@ -622,14 +622,14 @@ void TidalService::HandleAuthReply(QNetworkReply *reply) {
return;
}
if (!json_obj.contains(QStringLiteral("userId")) || !json_obj.contains(QStringLiteral("sessionId")) || !json_obj.contains(QStringLiteral("countryCode"))) {
if (!json_obj.contains(QLatin1String("userId")) || !json_obj.contains(QLatin1String("sessionId")) || !json_obj.contains(QLatin1String("countryCode"))) {
LoginError(QStringLiteral("Authentication reply from server is missing userId, sessionId or countryCode"), json_obj);
return;
}
country_code_ = json_obj[QStringLiteral("countryCode")].toString();
session_id_ = json_obj[QStringLiteral("sessionId")].toString();
user_id_ = json_obj[QStringLiteral("userId")].toInt();
country_code_ = json_obj[QLatin1String("countryCode")].toString();
session_id_ = json_obj[QLatin1String("sessionId")].toString();
user_id_ = json_obj[QLatin1String("userId")].toInt();
access_token_.clear();
refresh_token_.clear();
@ -1008,7 +1008,7 @@ void TidalService::LoginError(const QString &error, const QVariant &debug) {
QString error_html;
for (const QString &e : login_errors_) {
qLog(Error) << "Tidal:" << e;
error_html += e + QStringLiteral("<br />");
error_html += e + QLatin1String("<br />");
}
if (debug.isValid()) qLog(Debug) << debug;

42
src/tidal/tidalstreamurlrequest.cpp
View File

@ -169,22 +169,22 @@ void TidalStreamURLRequest::StreamURLReceived() {
return;
}
if (!json_obj.contains(QStringLiteral("trackId"))) {
if (!json_obj.contains(QLatin1String("trackId"))) {
Error(QStringLiteral("Invalid Json reply, stream missing trackId."), json_obj);
emit StreamURLFailure(id_, media_url_, errors_.first());
return;
}
int track_id = json_obj[QStringLiteral("trackId")].toInt();
int track_id = json_obj[QLatin1String("trackId")].toInt();
if (track_id != song_id_) {
qLog(Debug) << "Tidal returned track ID" << track_id << "for" << media_url_;
}
Song::FileType filetype(Song::FileType::Stream);
if (json_obj.contains(QStringLiteral("codec")) || json_obj.contains(QStringLiteral("codecs"))) {
if (json_obj.contains(QLatin1String("codec")) || json_obj.contains(QLatin1String("codecs"))) {
QString codec;
if (json_obj.contains(QStringLiteral("codec"))) codec = json_obj[QStringLiteral("codec")].toString().toLower();
if (json_obj.contains(QStringLiteral("codecs"))) codec = json_obj[QStringLiteral("codecs")].toString().toLower();
if (json_obj.contains(QLatin1String("codec"))) codec = json_obj[QLatin1String("codec")].toString().toLower();
if (json_obj.contains(QLatin1String("codecs"))) codec = json_obj[QLatin1String("codecs")].toString().toLower();
filetype = Song::FiletypeByExtension(codec);
if (filetype == Song::FileType::Unknown) {
qLog(Debug) << "Tidal: Unknown codec" << codec;
@ -194,9 +194,9 @@ void TidalStreamURLRequest::StreamURLReceived() {
QList<QUrl> urls;
if (json_obj.contains(QStringLiteral("manifest"))) {
if (json_obj.contains(QLatin1String("manifest"))) {
QString manifest(json_obj[QStringLiteral("manifest")].toString());
QString manifest(json_obj[QLatin1String("manifest")].toString());
QByteArray data_manifest = QByteArray::fromBase64(manifest.toUtf8());
QXmlStreamReader xml_reader(data_manifest);
@ -215,9 +215,9 @@ void TidalStreamURLRequest::StreamURLReceived() {
return;
}
if (json_obj.contains(QStringLiteral("encryptionType")) && json_obj.contains(QStringLiteral("keyId"))) {
QString encryption_type = json_obj[QStringLiteral("encryptionType")].toString();
QString key_id = json_obj[QStringLiteral("keyId")].toString();
if (json_obj.contains(QLatin1String("encryptionType")) && json_obj.contains(QLatin1String("keyId"))) {
QString encryption_type = json_obj[QLatin1String("encryptionType")].toString();
QString key_id = json_obj[QLatin1String("keyId")].toString();
if (!encryption_type.isEmpty() && !key_id.isEmpty()) {
Error(tr("Received URL with %1 encrypted stream from Tidal. Strawberry does not currently support encrypted streams.").arg(encryption_type));
emit StreamURLFailure(id_, media_url_, errors_.first());
@ -225,13 +225,13 @@ void TidalStreamURLRequest::StreamURLReceived() {
}
}
if (!json_obj.contains(QStringLiteral("mimeType"))) {
if (!json_obj.contains(QLatin1String("mimeType"))) {
Error(QStringLiteral("Invalid Json reply, stream url reply manifest is missing mimeType."), json_obj);
emit StreamURLFailure(id_, media_url_, errors_.first());
return;
}
QString mimetype = json_obj[QStringLiteral("mimeType")].toString();
QString mimetype = json_obj[QLatin1String("mimeType")].toString();
QMimeDatabase mimedb;
QStringList suffixes = mimedb.mimeTypeForName(mimetype).suffixes();
for (const QString &suffix : suffixes) {
@ -246,8 +246,8 @@ void TidalStreamURLRequest::StreamURLReceived() {
}
if (json_obj.contains(QStringLiteral("urls"))) {
QJsonValue json_urls = json_obj[QStringLiteral("urls")];
if (json_obj.contains(QLatin1String("urls"))) {
QJsonValue json_urls = json_obj[QLatin1String("urls")];
if (!json_urls.isArray()) {
Error(QStringLiteral("Invalid Json reply, urls is not an array."), json_urls);
emit StreamURLFailure(id_, media_url_, errors_.first());
@ -259,8 +259,8 @@ void TidalStreamURLRequest::StreamURLReceived() {
urls << QUrl(value.toString());
}
}
else if (json_obj.contains(QStringLiteral("url"))) {
QUrl new_url(json_obj[QStringLiteral("url")].toString());
else if (json_obj.contains(QLatin1String("url"))) {
QUrl new_url(json_obj[QLatin1String("url")].toString());
urls << new_url;
if (filetype == Song::FileType::Stream) {
// Guess filetype by filename extension in URL.
@ -269,8 +269,8 @@ void TidalStreamURLRequest::StreamURLReceived() {
}
}
if (json_obj.contains(QStringLiteral("encryptionKey"))) {
QString encryption_key = json_obj[QStringLiteral("encryptionKey")].toString();
if (json_obj.contains(QLatin1String("encryptionKey"))) {
QString encryption_key = json_obj[QLatin1String("encryptionKey")].toString();
if (!encryption_key.isEmpty()) {
Error(tr("Received URL with encrypted stream from Tidal. Strawberry does not currently support encrypted streams."));
emit StreamURLFailure(id_, media_url_, errors_.first());
@ -278,9 +278,9 @@ void TidalStreamURLRequest::StreamURLReceived() {
}
}
if (json_obj.contains(QStringLiteral("securityType")) && json_obj.contains(QStringLiteral("securityToken"))) {
QString security_type = json_obj[QStringLiteral("securityType")].toString();
QString security_token = json_obj[QStringLiteral("securityToken")].toString();
if (json_obj.contains(QLatin1String("securityType")) && json_obj.contains(QLatin1String("securityToken"))) {
QString security_type = json_obj[QLatin1String("securityType")].toString();
QString security_token = json_obj[QLatin1String("securityToken")].toString();
if (!security_type.isEmpty() && !security_token.isEmpty()) {
Error(tr("Received URL with encrypted stream from Tidal. Strawberry does not currently support encrypted streams."));
emit StreamURLFailure(id_, media_url_, errors_.first());

2
src/transcoder/transcodedialog.cpp
View File

@ -315,7 +315,7 @@ void TranscodeDialog::UpdateStatusText() {
sections << QStringLiteral("<font color=\"#b60000\">") + tr("%n failed", "", finished_failed_) + QStringLiteral("</font>");
}
ui_->progress_text->setText(sections.join(QStringLiteral(", ")));
ui_->progress_text->setText(sections.join(QLatin1String(", ")));
}

8
src/utilities/coverutils.cpp
View File

@ -46,7 +46,7 @@ QString CoverUtils::AlbumCoverFilename(QString artist, QString album, const QStr
artist.remove(QLatin1Char('/')).remove(QLatin1Char('\\'));
album.remove(QLatin1Char('/')).remove(QLatin1Char('\\'));
QString filename = artist + QStringLiteral("-") + album;
QString filename = artist + QLatin1Char('-') + album;
filename = Utilities::Transliterate(filename.toLower());
filename = filename.replace(QLatin1Char(' '), QLatin1Char('-'))
.replace(QLatin1String("--"), QLatin1String("-"))
@ -76,7 +76,7 @@ QString CoverUtils::CoverFilePath(const CoverOptions &options, const Song::Sourc
path = Song::ImageCacheDir(source);
}
if (path.right(1) == QDir::separator() || path.right(1) == QLatin1String("/")) {
if (path.right(1) == QDir::separator() || path.right(1) == QLatin1Char('/')) {
path.chop(1);
}
@ -105,7 +105,7 @@ QString CoverUtils::CoverFilePath(const CoverOptions &options, const Song::Sourc
filename = CoverFilenameFromSource(source, cover_url, artist, album, album_id, extension);
}
QString filepath(path + QStringLiteral("/") + filename);
QString filepath(path + QLatin1Char('/') + filename);
return filepath;
@ -118,7 +118,7 @@ QString CoverUtils::CoverFilenameFromSource(const Song::Source source, const QUr
switch (source) {
case Song::Source::Tidal:
if (!album_id.isEmpty()) {
filename = album_id + QStringLiteral("-") + cover_url.fileName();
filename = album_id + QLatin1Char('-') + cover_url.fileName();
break;
}
[[fallthrough]];

10
src/utilities/filemanagerutils.cpp
View File

@ -52,9 +52,9 @@ void OpenInFileManager(const QString &path, const QUrl &url) {
QString desktop_file = QString::fromUtf8(proc.readLine()).simplified();
QString xdg_data_dirs = QString::fromUtf8(qgetenv("XDG_DATA_DIRS"));
if (xdg_data_dirs.isEmpty()) {
xdg_data_dirs = QStringLiteral("/usr/local/share/:/usr/share/");
xdg_data_dirs = QLatin1String("/usr/local/share/:/usr/share/");
}
const QStringList data_dirs = xdg_data_dirs.split(QStringLiteral(":"));
const QStringList data_dirs = xdg_data_dirs.split(QLatin1Char(':'));
QString command;
QStringList command_params;
@ -63,7 +63,7 @@ void OpenInFileManager(const QString &path, const QUrl &url) {
if (!QFile::exists(desktop_file_path)) continue;
QSettings setting(desktop_file_path, QSettings::IniFormat);
setting.beginGroup(QStringLiteral("Desktop Entry"));
if (setting.contains(QStringLiteral("Exec"))) {
if (setting.contains(QLatin1String("Exec"))) {
QString cmd = setting.value(QStringLiteral("Exec")).toString();
if (cmd.isEmpty()) break;
cmd = cmd.remove(QRegularExpression(QStringLiteral("[%][a-zA-Z]*( |$)"), QRegularExpression::CaseInsensitiveOption));
@ -80,10 +80,10 @@ void OpenInFileManager(const QString &path, const QUrl &url) {
}
if (command.startsWith(QLatin1String("/usr/bin/"))) {
command = command.split(QStringLiteral("/")).last();
command = command.split(QLatin1Char('/')).last();
}
if (command.isEmpty() || command == QStringLiteral("exo-open")) {
if (command.isEmpty() || command == QLatin1String("exo-open")) {
QDesktopServices::openUrl(QUrl::fromLocalFile(path));
}
else if (command.startsWith(QLatin1String("nautilus"))) {

2
src/widgets/multiloadingindicator.cpp
View File

@ -82,7 +82,7 @@ void MultiLoadingIndicator::UpdateText() {
strings << task_text;
}
text_ = strings.join(QStringLiteral(", "));
text_ = strings.join(QLatin1String(", "));
if (!text_.isEmpty()) {
text_[0] = text_[0].toUpper();
text_ += QLatin1String("...");