diff --git a/src/collection/collectionbackend.cpp b/src/collection/collectionbackend.cpp
index 275df111..e0e0137d 100644
--- a/src/collection/collectionbackend.cpp
+++ b/src/collection/collectionbackend.cpp
@@ -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);
diff --git a/src/collection/collectionfilter.cpp b/src/collection/collectionfilter.cpp
index da1ea12c..a4b43e1f 100644
--- a/src/collection/collectionfilter.cpp
+++ b/src/collection/collectionfilter.cpp
@@ -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;
   }
 
diff --git a/src/collection/collectionfilterwidget.cpp b/src/collection/collectionfilterwidget.cpp
index f9f6e5b2..6b589444 100644
--- a/src/collection/collectionfilterwidget.cpp
+++ b/src/collection/collectionfilterwidget.cpp
@@ -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>") +
diff --git a/src/collection/collectionquery.cpp b/src/collection/collectionquery.cpp
index edae0f9a..44d9dfd7 100644
--- a/src/collection/collectionquery.cpp
+++ b/src/collection/collectionquery.cpp
@@ -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;
 
diff --git a/src/collection/collectionwatcher.cpp b/src/collection/collectionwatcher.cpp
index 7c630205..e7286e1b 100644
--- a/src/collection/collectionwatcher.cpp
+++ b/src/collection/collectionwatcher.cpp
@@ -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.";
     }
 
   }
diff --git a/src/core/mpris2.cpp b/src/core/mpris2.cpp
index c30b8393..2102ee17 100644
--- a/src/core/mpris2.cpp
+++ b/src/core/mpris2.cpp
@@ -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()); }
diff --git a/src/core/song.cpp b/src/core/song.cpp
index ed4f139c..ca2f8d93 100644
--- a/src/core/song.cpp
+++ b/src/core/song.cpp
@@ -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 {
diff --git a/src/core/stylesheetloader.cpp b/src/core/stylesheetloader.cpp
index 0c92d4b4..f5c6f182 100644
--- a/src/core/stylesheetloader.cpp
+++ b/src/core/stylesheetloader.cpp
@@ -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_) {
diff --git a/src/covermanager/deezercoverprovider.cpp b/src/covermanager/deezercoverprovider.cpp
index 3a7ec2ca..2eece7af 100644
--- a/src/covermanager/deezercoverprovider.cpp
+++ b/src/covermanager/deezercoverprovider.cpp
@@ -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;
diff --git a/src/covermanager/discogscoverprovider.cpp b/src/covermanager/discogscoverprovider.cpp
index 70fbcd47..5b2ac8f0 100644
--- a/src/covermanager/discogscoverprovider.cpp
+++ b/src/covermanager/discogscoverprovider.cpp
@@ -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);
   }
diff --git a/src/covermanager/lastfmcoverprovider.cpp b/src/covermanager/lastfmcoverprovider.cpp
index 42701d45..a3fc97b5 100644
--- a/src/covermanager/lastfmcoverprovider.cpp
+++ b/src/covermanager/lastfmcoverprovider.cpp
@@ -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;
 
 }
diff --git a/src/covermanager/musicbrainzcoverprovider.cpp b/src/covermanager/musicbrainzcoverprovider.cpp
index 130e744c..5b174a80 100644
--- a/src/covermanager/musicbrainzcoverprovider.cpp
+++ b/src/covermanager/musicbrainzcoverprovider.cpp
@@ -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()) {
diff --git a/src/covermanager/musixmatchcoverprovider.cpp b/src/covermanager/musixmatchcoverprovider.cpp
index f5247bd3..773018d8 100644
--- a/src/covermanager/musixmatchcoverprovider.cpp
+++ b/src/covermanager/musixmatchcoverprovider.cpp
@@ -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) {
diff --git a/src/covermanager/opentidalcoverprovider.cpp b/src/covermanager/opentidalcoverprovider.cpp
index fd49ba82..b80b04e5 100644
--- a/src/covermanager/opentidalcoverprovider.cpp
+++ b/src/covermanager/opentidalcoverprovider.cpp
@@ -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;
diff --git a/src/covermanager/qobuzcoverprovider.cpp b/src/covermanager/qobuzcoverprovider.cpp
index 64992293..d0a29bdf 100644
--- a/src/covermanager/qobuzcoverprovider.cpp
+++ b/src/covermanager/qobuzcoverprovider.cpp
@@ -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;
diff --git a/src/covermanager/spotifycoverprovider.cpp b/src/covermanager/spotifycoverprovider.cpp
index 64f21dab..95c77396 100644
--- a/src/covermanager/spotifycoverprovider.cpp
+++ b/src/covermanager/spotifycoverprovider.cpp
@@ -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;
diff --git a/src/covermanager/tidalcoverprovider.cpp b/src/covermanager/tidalcoverprovider.cpp
index 3de148ab..f0d9ca41 100644
--- a/src/covermanager/tidalcoverprovider.cpp
+++ b/src/covermanager/tidalcoverprovider.cpp
@@ -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;
diff --git a/src/device/deviceinfo.cpp b/src/device/deviceinfo.cpp
index 97cc287b..b5fc1f5a 100644
--- a/src/device/deviceinfo.cpp
+++ b/src/device/deviceinfo.cpp
@@ -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;
 
diff --git a/src/device/devicemanager.cpp b/src/device/devicemanager.cpp
index da57dd78..afd80278 100644
--- a/src/device/devicemanager.cpp
+++ b/src/device/devicemanager.cpp
@@ -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;
   }
 
diff --git a/src/device/udisks2lister.cpp b/src/device/udisks2lister.cpp
index d6ecc5fd..08880170 100644
--- a/src/device/udisks2lister.cpp
+++ b/src/device/udisks2lister.cpp
@@ -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;
 
diff --git a/src/dialogs/about.cpp b/src/dialogs/about.cpp
index 61c6d340..ad3a3cdc 100644
--- a/src/dialogs/about.cpp
+++ b/src/dialogs/about.cpp
@@ -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;
 
 }
diff --git a/src/dialogs/console.cpp b/src/dialogs/console.cpp
index 2510d84b..5c6f4a06 100644
--- a/src/dialogs/console.cpp
+++ b/src/dialogs/console.cpp
@@ -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('|')));
 
   }
 
diff --git a/src/dialogs/edittagdialog.cpp b/src/dialogs/edittagdialog.cpp
index ab9b1bf3..a8bdf3b8 100644
--- a/src/dialogs/edittagdialog.cpp
+++ b/src/dialogs/edittagdialog.cpp
@@ -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>");
diff --git a/src/engine/enginebase.cpp b/src/engine/enginebase.cpp
index 38e44f46..fdf1680d 100644
--- a/src/engine/enginebase.cpp
+++ b/src/engine/enginebase.cpp
@@ -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();
diff --git a/src/engine/gstengine.cpp b/src/engine/gstengine.cpp
index 72297f46..ae8e0104 100644
--- a/src/engine/gstengine.cpp
+++ b/src/engine/gstengine.cpp
@@ -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();
diff --git a/src/lyrics/azlyricscomlyricsprovider.cpp b/src/lyrics/azlyricscomlyricsprovider.cpp
index cf7440f7..9c95ecf9 100644
--- a/src/lyrics/azlyricscomlyricsprovider.cpp
+++ b/src/lyrics/azlyricscomlyricsprovider.cpp
@@ -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"));
 
 }
 
diff --git a/src/lyrics/chartlyricsprovider.cpp b/src/lyrics/chartlyricsprovider.cpp
index c50f50ec..09c31def 100644
--- a/src/lyrics/chartlyricsprovider.cpp
+++ b/src/lyrics/chartlyricsprovider.cpp
@@ -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 ||
diff --git a/src/lyrics/elyricsnetlyricsprovider.cpp b/src/lyrics/elyricsnetlyricsprovider.cpp
index 65c541da..19fa5b8a 100644
--- a/src/lyrics/elyricsnetlyricsprovider.cpp
+++ b/src/lyrics/elyricsnetlyricsprovider.cpp
@@ -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"));
 
 }
 
diff --git a/src/lyrics/geniuslyricsprovider.cpp b/src/lyrics/geniuslyricsprovider.cpp
index 9262a03d..7ea2da02 100644
--- a/src/lyrics/geniuslyricsprovider.cpp
+++ b/src/lyrics/geniuslyricsprovider.cpp
@@ -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;
 
diff --git a/src/lyrics/letraslyricsprovider.cpp b/src/lyrics/letraslyricsprovider.cpp
index 13fe54cc..778654a4 100644
--- a/src/lyrics/letraslyricsprovider.cpp
+++ b/src/lyrics/letraslyricsprovider.cpp
@@ -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));
 
 }
 
diff --git a/src/lyrics/lololyricsprovider.cpp b/src/lyrics/lololyricsprovider.cpp
index d00d8869..522815b0 100644
--- a/src/lyrics/lololyricsprovider.cpp
+++ b/src/lyrics/lololyricsprovider.cpp
@@ -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;
diff --git a/src/lyrics/musixmatchlyricsprovider.cpp b/src/lyrics/musixmatchlyricsprovider.cpp
index 13d18393..8782b01d 100644
--- a/src/lyrics/musixmatchlyricsprovider.cpp
+++ b/src/lyrics/musixmatchlyricsprovider.cpp
@@ -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);
diff --git a/src/lyrics/ovhlyricsprovider.cpp b/src/lyrics/ovhlyricsprovider.cpp
index cc2de7ae..ac90d6ce 100644
--- a/src/lyrics/ovhlyricsprovider.cpp
+++ b/src/lyrics/ovhlyricsprovider.cpp
@@ -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;
diff --git a/src/lyrics/songlyricscomlyricsprovider.cpp b/src/lyrics/songlyricscomlyricsprovider.cpp
index ef606aba..1de143d4 100644
--- a/src/lyrics/songlyricscomlyricsprovider.cpp
+++ b/src/lyrics/songlyricscomlyricsprovider.cpp
@@ -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/"));
 
 }
 
diff --git a/src/musicbrainz/acoustidclient.cpp b/src/musicbrainz/acoustidclient.cpp
index 8d10d082..1d126905 100644
--- a/src/musicbrainz/acoustidclient.cpp
+++ b/src/musicbrainz/acoustidclient.cpp
@@ -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());
         }
       }
     }
diff --git a/src/musicbrainz/musicbrainzclient.cpp b/src/musicbrainz/musicbrainzclient.cpp
index fb63eb9a..fbc83a4d 100644
--- a/src/musicbrainz/musicbrainzclient.cpp
+++ b/src/musicbrainz/musicbrainzclient.cpp
@@ -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;
     }
   }
diff --git a/src/organize/organizeformat.cpp b/src/organize/organizeformat.cpp
index 46882437..1e02b5d7 100644
--- a/src/organize/organizeformat.cpp
+++ b/src/organize/organizeformat.cpp
@@ -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));
diff --git a/src/osd/osdbase.cpp b/src/osd/osdbase.cpp
index f910fdd5..d79892ed 100644
--- a/src/osd/osdbase.cpp
+++ b/src/osd/osdbase.cpp
@@ -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;
   }
 
diff --git a/src/playlist/playlistbackend.cpp b/src/playlist/playlistbackend.cpp
index beacdb58..4bf5825b 100644
--- a/src/playlist/playlistbackend.cpp
+++ b/src/playlist/playlistbackend.cpp
@@ -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);
diff --git a/src/playlist/playlistcontainer.cpp b/src/playlist/playlistcontainer.cpp
index 10a1b36c..7a7c05ec 100644
--- a/src/playlist/playlistcontainer.cpp
+++ b/src/playlist/playlistcontainer.cpp
@@ -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") +
diff --git a/src/playlist/playlistlistmodel.cpp b/src/playlist/playlistlistmodel.cpp
index 8dfd339e..90f45540 100644
--- a/src/playlist/playlistlistmodel.cpp
+++ b/src/playlist/playlistlistmodel.cpp
@@ -68,7 +68,7 @@ QString PlaylistListModel::ItemPath(const QStandardItem *item) {
     current = current->parent();
   }
 
-  return components.join(QStringLiteral("/"));
+  return components.join(QLatin1Char('/'));
 
 }
 
diff --git a/src/playlist/playlisttabbar.cpp b/src/playlist/playlisttabbar.cpp
index 35157a1b..e9f6a4c2 100644
--- a/src/playlist/playlisttabbar.cpp
+++ b/src/playlist/playlisttabbar.cpp
@@ -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);
 
diff --git a/src/playlist/playlistview.cpp b/src/playlist/playlistview.cpp
index efba44cc..f44108be 100644
--- a/src/playlist/playlistview.cpp
+++ b/src/playlist/playlistview.cpp
@@ -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);
 
diff --git a/src/playlistparsers/m3uparser.cpp b/src/playlistparsers/m3uparser.cpp
index 7240b9fa..14b841d9 100644
--- a/src/playlistparsers/m3uparser.cpp
+++ b/src/playlistparsers/m3uparser.cpp
@@ -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;
diff --git a/src/playlistparsers/playlistparser.cpp b/src/playlistparsers/playlistparser.cpp
index 597e9d07..e97ed9e1 100644
--- a/src/playlistparsers/playlistparser.cpp
+++ b/src/playlistparsers/playlistparser.cpp
@@ -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(' ')));
 
 }
 
diff --git a/src/qobuz/qobuzbaserequest.cpp b/src/qobuz/qobuzbaserequest.cpp
index 8eea67aa..5c6d3452 100644
--- a/src/qobuz/qobuzbaserequest.cpp
+++ b/src/qobuz/qobuzbaserequest.cpp
@@ -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;
 
 }
diff --git a/src/qobuz/qobuzrequest.cpp b/src/qobuz/qobuzrequest.cpp
index 262c9389..a7a39ed9 100644
--- a/src/qobuz/qobuzrequest.cpp
+++ b/src/qobuz/qobuzrequest.cpp
@@ -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) {
diff --git a/src/qobuz/qobuzservice.cpp b/src/qobuz/qobuzservice.cpp
index 1fc06780..570f0a4b 100644
--- a/src/qobuz/qobuzservice.cpp
+++ b/src/qobuz/qobuzservice.cpp
@@ -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);
diff --git a/src/qobuz/qobuzstreamurlrequest.cpp b/src/qobuz/qobuzstreamurlrequest.cpp
index 8a628490..539553ed 100644
--- a/src/qobuz/qobuzstreamurlrequest.cpp
+++ b/src/qobuz/qobuzstreamurlrequest.cpp
@@ -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);
diff --git a/src/radios/radioparadiseservice.cpp b/src/radios/radioparadiseservice.cpp
index 71c9c880..0c099a31 100644
--- a/src/radios/radioparadiseservice.cpp
+++ b/src/radios/radioparadiseservice.cpp
@@ -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://"));
       }
diff --git a/src/radios/somafmservice.cpp b/src/radios/somafmservice.cpp
index b1a7a9be..4d808899 100644
--- a/src/radios/somafmservice.cpp
+++ b/src/radios/somafmservice.cpp
@@ -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;
     }
diff --git a/src/scrobbler/lastfmimport.cpp b/src/scrobbler/lastfmimport.cpp
index e58b5115..906d3ec0 100644
--- a/src/scrobbler/lastfmimport.cpp
+++ b/src/scrobbler/lastfmimport.cpp
@@ -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;
 
diff --git a/src/scrobbler/listenbrainzscrobbler.cpp b/src/scrobbler/listenbrainzscrobbler.cpp
index 8dbc7a34..4d182ba2 100644
--- a/src/scrobbler/listenbrainzscrobbler.cpp
+++ b/src/scrobbler/listenbrainzscrobbler.cpp
@@ -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();
   }
 
 }
diff --git a/src/scrobbler/scrobblercache.cpp b/src/scrobbler/scrobblercache.cpp
index 8096f016..bd853847 100644
--- a/src/scrobbler/scrobblercache.cpp
+++ b/src/scrobbler/scrobblercache.cpp
@@ -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_);
diff --git a/src/scrobbler/scrobblingapi20.cpp b/src/scrobbler/scrobblingapi20.cpp
index 0926ea11..909bd6b0 100644
--- a/src/scrobbler/scrobblingapi20.cpp
+++ b/src/scrobbler/scrobblingapi20.cpp
@@ -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;
       }
diff --git a/src/settings/behavioursettingspage.cpp b/src/settings/behavioursettingspage.cpp
index 5865b5a3..f12602c2 100644
--- a/src/settings/behavioursettingspage.cpp
+++ b/src/settings/behavioursettingspage.cpp
@@ -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();
diff --git a/src/settings/collectionsettingspage.cpp b/src/settings/collectionsettingspage.cpp
index 5665104b..2c6edc9f 100644
--- a/src/settings/collectionsettingspage.cpp
+++ b/src/settings/collectionsettingspage.cpp
@@ -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()));
diff --git a/src/settings/coverssettingspage.cpp b/src/settings/coverssettingspage.cpp
index cce42f72..3b837618 100644
--- a/src/settings/coverssettingspage.cpp
+++ b/src/settings/coverssettingspage.cpp
@@ -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);
   }
 
diff --git a/src/settings/lyricssettingspage.cpp b/src/settings/lyricssettingspage.cpp
index 0d8a6c80..4dbbe342 100644
--- a/src/settings/lyricssettingspage.cpp
+++ b/src/settings/lyricssettingspage.cpp
@@ -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);
diff --git a/src/smartplaylists/smartplaylistsearch.cpp b/src/smartplaylists/smartplaylistsearch.cpp
index 9291ceab..45460a96 100644
--- a/src/smartplaylists/smartplaylistsearch.cpp
+++ b/src/smartplaylists/smartplaylistsearch.cpp
@@ -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
diff --git a/src/subsonic/subsonicbaserequest.cpp b/src/subsonic/subsonicbaserequest.cpp
index c9e0d992..4be08ff7 100644
--- a/src/subsonic/subsonicbaserequest.cpp
+++ b/src/subsonic/subsonicbaserequest.cpp
@@ -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;
 
diff --git a/src/subsonic/subsonicrequest.cpp b/src/subsonic/subsonicrequest.cpp
index 92318075..37fb0043 100644
--- a/src/subsonic/subsonicrequest.cpp
+++ b/src/subsonic/subsonicrequest.cpp
@@ -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());
diff --git a/src/subsonic/subsonicscrobblerequest.cpp b/src/subsonic/subsonicscrobblerequest.cpp
index bb7e1e0a..a24651c7 100644
--- a/src/subsonic/subsonicscrobblerequest.cpp
+++ b/src/subsonic/subsonicscrobblerequest.cpp
@@ -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();
     }
diff --git a/src/subsonic/subsonicservice.cpp b/src/subsonic/subsonicservice.cpp
index 53b71008..92b8a8f2 100644
--- a/src/subsonic/subsonicservice.cpp
+++ b/src/subsonic/subsonicservice.cpp
@@ -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;
 
diff --git a/src/tidal/tidalbaserequest.cpp b/src/tidal/tidalbaserequest.cpp
index c9f73f61..2ca60b3e 100644
--- a/src/tidal/tidalbaserequest.cpp
+++ b/src/tidal/tidalbaserequest.cpp
@@ -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;
 
diff --git a/src/tidal/tidalfavoriterequest.cpp b/src/tidal/tidalfavoriterequest.cpp
index 1f94271c..0d315ff3 100644
--- a/src/tidal/tidalfavoriterequest.cpp
+++ b/src/tidal/tidalfavoriterequest.cpp
@@ -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);
diff --git a/src/tidal/tidalrequest.cpp b/src/tidal/tidalrequest.cpp
index 2c0918d0..de36cba3 100644
--- a/src/tidal/tidalrequest.cpp
+++ b/src/tidal/tidalrequest.cpp
@@ -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_));
     }
diff --git a/src/tidal/tidalservice.cpp b/src/tidal/tidalservice.cpp
index 9d3b30cd..3da71929 100644
--- a/src/tidal/tidalservice.cpp
+++ b/src/tidal/tidalservice.cpp
@@ -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;
 
diff --git a/src/tidal/tidalstreamurlrequest.cpp b/src/tidal/tidalstreamurlrequest.cpp
index e2c1bc3b..39bb3441 100644
--- a/src/tidal/tidalstreamurlrequest.cpp
+++ b/src/tidal/tidalstreamurlrequest.cpp
@@ -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());
diff --git a/src/transcoder/transcodedialog.cpp b/src/transcoder/transcodedialog.cpp
index c3a40e9d..f2cccfea 100644
--- a/src/transcoder/transcodedialog.cpp
+++ b/src/transcoder/transcodedialog.cpp
@@ -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(", ")));
 
 }
 
diff --git a/src/utilities/coverutils.cpp b/src/utilities/coverutils.cpp
index 55c2a67f..b9e7bba5 100644
--- a/src/utilities/coverutils.cpp
+++ b/src/utilities/coverutils.cpp
@@ -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]];
diff --git a/src/utilities/filemanagerutils.cpp b/src/utilities/filemanagerutils.cpp
index 3c1b21e8..6ea102e8 100644
--- a/src/utilities/filemanagerutils.cpp
+++ b/src/utilities/filemanagerutils.cpp
@@ -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"))) {
diff --git a/src/widgets/multiloadingindicator.cpp b/src/widgets/multiloadingindicator.cpp
index a5112e88..6986714c 100644
--- a/src/widgets/multiloadingindicator.cpp
+++ b/src/widgets/multiloadingindicator.cpp
@@ -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("...");