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

Use QStringLiteral

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

32
src/tidal/tidalbaserequest.cpp
View File

@@ -55,7 +55,7 @@ QNetworkReply *TidalBaseRequest::CreateRequest(const QString &ressource_name, co
url_query.addQueryItem(QUrl::toPercentEncoding(param.first), QUrl::toPercentEncoding(param.second));
}
QUrl url(QString(TidalService::kApiUrl) + QString("/") + ressource_name);
QUrl url(QString(TidalService::kApiUrl) + QStringLiteral("/") + ressource_name);
url.setQuery(url_query);
QNetworkRequest req(url);
req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
@@ -90,7 +90,7 @@ QByteArray TidalBaseRequest::GetReplyData(QNetworkReply *reply, const bool send_
else {
if (reply->error() != QNetworkReply::NoError && reply->error() < 200) {
// This is a network error, there is nothing more to do.
Error(QString("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
Error(QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
}
else {
// See if there is Json data containing "status" and "userMessage" - then use that instead.
@@ -102,19 +102,19 @@ 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("status") && json_obj.contains("userMessage")) {
status = json_obj["status"].toInt();
sub_status = json_obj["subStatus"].toInt();
QString user_message = json_obj["userMessage"].toString();
error = QString("%1 (%2) (%3)").arg(user_message).arg(status).arg(sub_status);
if (!json_obj.isEmpty() && json_obj.contains(QStringLiteral("status")) && json_obj.contains(QStringLiteral("userMessage"))) {
status = json_obj[QStringLiteral("status")].toInt();
sub_status = json_obj[QStringLiteral("subStatus")].toInt();
QString user_message = json_obj[QStringLiteral("userMessage")].toString();
error = QStringLiteral("%1 (%2) (%3)").arg(user_message).arg(status).arg(sub_status);
}
}
if (error.isEmpty()) {
if (reply->error() != QNetworkReply::NoError) {
error = QString("%1 (%2)").arg(reply->errorString()).arg(reply->error());
error = QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
}
else {
error = QString("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt());
error = QStringLiteral("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt());
}
}
if (status == 401 && sub_status == 6001) { // User does not have a valid session
@@ -151,23 +151,23 @@ QJsonObject TidalBaseRequest::ExtractJsonObj(const QByteArray &data) {
QJsonDocument json_doc = QJsonDocument::fromJson(data, &json_error);
if (json_error.error != QJsonParseError::NoError) {
Error("Reply from server missing Json data.", data);
Error(QStringLiteral("Reply from server missing Json data."), data);
return QJsonObject();
}
if (json_doc.isEmpty()) {
Error("Received empty Json document.", data);
Error(QStringLiteral("Received empty Json document."), data);
return QJsonObject();
}
if (!json_doc.isObject()) {
Error("Json document is not an object.", json_doc);
Error(QStringLiteral("Json document is not an object."), json_doc);
return QJsonObject();
}
QJsonObject json_obj = json_doc.object();
if (json_obj.isEmpty()) {
Error("Received empty Json object.", json_doc);
Error(QStringLiteral("Received empty Json object."), json_doc);
return QJsonObject();
}
@@ -185,11 +185,11 @@ QJsonValue TidalBaseRequest::ExtractItems(const QByteArray &data) {
QJsonValue TidalBaseRequest::ExtractItems(const QJsonObject &json_obj) {
if (!json_obj.contains("items")) {
Error("Json reply is missing items.", json_obj);
if (!json_obj.contains(QStringLiteral("items"))) {
Error(QStringLiteral("Json reply is missing items."), json_obj);
return QJsonArray();
}
QJsonValue json_items = json_obj["items"];
QJsonValue json_items = json_obj[QStringLiteral("items")];
return json_items;
}

16
src/tidal/tidalfavoriterequest.cpp
View File

@@ -60,11 +60,11 @@ QString TidalFavoriteRequest::FavoriteText(const FavoriteType type) {
switch (type) {
case FavoriteType::Artists:
return "artists";
return QStringLiteral("artists");
case FavoriteType::Albums:
return "albums";
return QStringLiteral("albums");
case FavoriteType::Songs:
return "tracks";
return QStringLiteral("tracks");
}
return QString();
@@ -75,11 +75,11 @@ QString TidalFavoriteRequest::FavoriteMethod(const FavoriteType type) {
switch (type) {
case FavoriteType::Artists:
return "artistIds";
return QStringLiteral("artistIds");
case FavoriteType::Albums:
return "albumIds";
return QStringLiteral("albumIds");
case FavoriteType::Songs:
return "trackIds";
return QStringLiteral("trackIds");
}
return QString();
@@ -142,7 +142,7 @@ void TidalFavoriteRequest::AddFavoritesRequest(const FavoriteType type, const QS
url_query.addQueryItem(QUrl::toPercentEncoding(param.first), QUrl::toPercentEncoding(param.second));
}
QUrl url(QString(TidalService::kApiUrl) + QString("/") + "users/" + QString::number(service_->user_id()) + "/favorites/" + FavoriteText(type));
QUrl url(QString(TidalService::kApiUrl) + QStringLiteral("/") + "users/" + QString::number(service_->user_id()) + "/favorites/" + FavoriteText(type));
QNetworkRequest req(url);
req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
req.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
@@ -251,7 +251,7 @@ void TidalFavoriteRequest::RemoveFavoritesRequest(const FavoriteType type, const
url_query.addQueryItem(QUrl::toPercentEncoding(param.first), QUrl::toPercentEncoding(param.second));
}
QUrl url(QString(TidalService::kApiUrl) + QString("/") + "users/" + QString::number(service_->user_id()) + "/favorites/" + FavoriteText(type) + QString("/") + id);
QUrl url(QString(TidalService::kApiUrl) + QStringLiteral("/") + "users/" + QString::number(service_->user_id()) + "/favorites/" + FavoriteText(type) + QStringLiteral("/") + id);
url.setQuery(url_query);
QNetworkRequest req(url);
req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);

272
src/tidal/tidalrequest.cpp
View File

@@ -165,7 +165,7 @@ void TidalRequest::Process() {
SongsSearch();
break;
default:
Error("Invalid query type.");
Error(QStringLiteral("Invalid query type."));
break;
}
@@ -253,10 +253,10 @@ void TidalRequest::FlushArtistsRequests() {
if (request.offset > 0) parameters << Param("offset", QString::number(request.offset));
QNetworkReply *reply = nullptr;
if (query_type_ == QueryType::Artists) {
reply = CreateRequest(QString("users/%1/favorites/artists").arg(service_->user_id()), parameters);
reply = CreateRequest(QStringLiteral("users/%1/favorites/artists").arg(service_->user_id()), parameters);
}
if (query_type_ == QueryType::SearchArtists) {
reply = CreateRequest("search/artists", parameters);
reply = CreateRequest(QStringLiteral("search/artists"), parameters);
}
if (!reply) continue;
replies_ << reply;
@@ -301,10 +301,10 @@ void TidalRequest::FlushAlbumsRequests() {
if (request.offset > 0) parameters << Param("offset", QString::number(request.offset));
QNetworkReply *reply = nullptr;
if (query_type_ == QueryType::Albums) {
reply = CreateRequest(QString("users/%1/favorites/albums").arg(service_->user_id()), parameters);
reply = CreateRequest(QStringLiteral("users/%1/favorites/albums").arg(service_->user_id()), parameters);
}
if (query_type_ == QueryType::SearchAlbums) {
reply = CreateRequest("search/albums", parameters);
reply = CreateRequest(QStringLiteral("search/albums"), parameters);
}
if (!reply) continue;
replies_ << reply;
@@ -349,10 +349,10 @@ void TidalRequest::FlushSongsRequests() {
if (request.offset > 0) parameters << Param("offset", QString::number(request.offset));
QNetworkReply *reply = nullptr;
if (query_type_ == QueryType::Songs) {
reply = CreateRequest(QString("users/%1/favorites/tracks").arg(service_->user_id()), parameters);
reply = CreateRequest(QStringLiteral("users/%1/favorites/tracks").arg(service_->user_id()), parameters);
}
if (query_type_ == QueryType::SearchSongs) {
reply = CreateRequest("search/tracks", parameters);
reply = CreateRequest(QStringLiteral("search/tracks"), parameters);
}
if (!reply) continue;
replies_ << reply;
@@ -431,29 +431,29 @@ void TidalRequest::ArtistsReplyReceived(QNetworkReply *reply, const int limit_re
return;
}
if (!json_obj.contains("limit") ||
!json_obj.contains("offset") ||
!json_obj.contains("totalNumberOfItems") ||
!json_obj.contains("items")) {
Error("Json object missing values.", json_obj);
if (!json_obj.contains(QStringLiteral("limit")) ||
!json_obj.contains(QStringLiteral("offset")) ||
!json_obj.contains(QStringLiteral("totalNumberOfItems")) ||
!json_obj.contains(QStringLiteral("items"))) {
Error(QStringLiteral("Json object missing values."), json_obj);
ArtistsFinishCheck();
return;
}
//int limit = json_obj["limit"].toInt();
int offset = json_obj["offset"].toInt();
int artists_total = json_obj["totalNumberOfItems"].toInt();
int offset = json_obj[QStringLiteral("offset")].toInt();
int artists_total = json_obj[QStringLiteral("totalNumberOfItems")].toInt();
if (offset_requested == 0) {
artists_total_ = artists_total;
}
else if (artists_total != artists_total_) {
Error(QString("totalNumberOfItems returned does not match previous totalNumberOfItems! %1 != %2").arg(artists_total).arg(artists_total_));
Error(QStringLiteral("totalNumberOfItems returned does not match previous totalNumberOfItems! %1 != %2").arg(artists_total).arg(artists_total_));
ArtistsFinishCheck();
return;
}
if (offset != offset_requested) {
Error(QString("Offset returned does not match offset requested! %1 != %2").arg(offset).arg(offset_requested));
Error(QStringLiteral("Offset returned does not match offset requested! %1 != %2").arg(offset).arg(offset_requested));
ArtistsFinishCheck();
return;
}
@@ -480,33 +480,33 @@ void TidalRequest::ArtistsReplyReceived(QNetworkReply *reply, const int limit_re
++artists_received;
if (!value_item.isObject()) {
Error("Invalid Json reply, item in array is not a object.");
Error(QStringLiteral("Invalid Json reply, item in array is not a object."));
continue;
}
QJsonObject obj_item = value_item.toObject();
if (obj_item.contains("item")) {
QJsonValue json_item = obj_item["item"];
if (obj_item.contains(QStringLiteral("item"))) {
QJsonValue json_item = obj_item[QStringLiteral("item")];
if (!json_item.isObject()) {
Error("Invalid Json reply, item in array is not a object.", json_item);
Error(QStringLiteral("Invalid Json reply, item in array is not a object."), json_item);
continue;
}
obj_item = json_item.toObject();
}
if (!obj_item.contains("id") || !obj_item.contains("name")) {
Error("Invalid Json reply, item missing id or album.", obj_item);
if (!obj_item.contains(QStringLiteral("id")) || !obj_item.contains(QStringLiteral("name"))) {
Error(QStringLiteral("Invalid Json reply, item missing id or album."), obj_item);
continue;
}
Artist artist;
if (obj_item["id"].isString()) {
artist.artist_id = obj_item["id"].toString();
if (obj_item[QStringLiteral("id")].isString()) {
artist.artist_id = obj_item[QStringLiteral("id")].toString();
}
else {
artist.artist_id = QString::number(obj_item["id"].toInt());
artist.artist_id = QString::number(obj_item[QStringLiteral("id")].toInt());
}
artist.artist = obj_item["name"].toString();
artist.artist = obj_item[QStringLiteral("name")].toString();
if (artist_albums_requests_pending_.contains(artist.artist_id)) continue;
@@ -585,7 +585,7 @@ void TidalRequest::FlushArtistAlbumsRequests() {
ParamList parameters;
if (request.offset > 0) parameters << Param("offset", QString::number(request.offset));
QNetworkReply *reply = CreateRequest(QString("artists/%1/albums").arg(request.artist.artist_id), parameters);
QNetworkReply *reply = CreateRequest(QStringLiteral("artists/%1/albums").arg(request.artist.artist_id), parameters);
QObject::connect(reply, &QNetworkReply::finished, this, [this, reply, request]() { ArtistAlbumsReplyReceived(reply, request.artist, request.offset); });
replies_ << reply;
@@ -626,21 +626,21 @@ void TidalRequest::AlbumsReceived(QNetworkReply *reply, const Artist &artist_req
return;
}
if (!json_obj.contains("limit") ||
!json_obj.contains("offset") ||
!json_obj.contains("totalNumberOfItems") ||
!json_obj.contains("items")) {
Error("Json object missing values.", json_obj);
if (!json_obj.contains(QStringLiteral("limit")) ||
!json_obj.contains(QStringLiteral("offset")) ||
!json_obj.contains(QStringLiteral("totalNumberOfItems")) ||
!json_obj.contains(QStringLiteral("items"))) {
Error(QStringLiteral("Json object missing values."), json_obj);
AlbumsFinishCheck(artist_requested);
return;
}
//int limit = json_obj["limit"].toInt();
int offset = json_obj["offset"].toInt();
int albums_total = json_obj["totalNumberOfItems"].toInt();
int offset = json_obj[QStringLiteral("offset")].toInt();
int albums_total = json_obj[QStringLiteral("totalNumberOfItems")].toInt();
if (offset != offset_requested) {
Error(QString("Offset returned does not match offset requested! %1 != %2").arg(offset).arg(offset_requested));
Error(QStringLiteral("Offset returned does not match offset requested! %1 != %2").arg(offset).arg(offset_requested));
AlbumsFinishCheck(artist_requested);
return;
}
@@ -662,95 +662,95 @@ void TidalRequest::AlbumsReceived(QNetworkReply *reply, const Artist &artist_req
++albums_received;
if (!value_item.isObject()) {
Error("Invalid Json reply, item in array is not a object.");
Error(QStringLiteral("Invalid Json reply, item in array is not a object."));
continue;
}
QJsonObject obj_item = value_item.toObject();
if (obj_item.contains("item")) {
QJsonValue json_item = obj_item["item"];
if (obj_item.contains(QStringLiteral("item"))) {
QJsonValue json_item = obj_item[QStringLiteral("item")];
if (!json_item.isObject()) {
Error("Invalid Json reply, item in array is not a object.", json_item);
Error(QStringLiteral("Invalid Json reply, item in array is not a object."), json_item);
continue;
}
obj_item = json_item.toObject();
}
Album album;
if (obj_item.contains("type")) { // This was an albums request or search
if (!obj_item.contains("id") || !obj_item.contains("title")) {
Error("Invalid Json reply, item is missing ID or title.", obj_item);
if (obj_item.contains(QStringLiteral("type"))) { // This was an albums request or search
if (!obj_item.contains(QStringLiteral("id")) || !obj_item.contains(QStringLiteral("title"))) {
Error(QStringLiteral("Invalid Json reply, item is missing ID or title."), obj_item);
continue;
}
if (obj_item["id"].isString()) {
album.album_id = obj_item["id"].toString();
if (obj_item[QStringLiteral("id")].isString()) {
album.album_id = obj_item[QStringLiteral("id")].toString();
}
else {
album.album_id = QString::number(obj_item["id"].toInt());
album.album_id = QString::number(obj_item[QStringLiteral("id")].toInt());
}
album.album = obj_item["title"].toString();
if (service_->album_explicit() && obj_item.contains("explicit")) {
album.album_explicit = obj_item["explicit"].toVariant().toBool();
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();
if (album.album_explicit && !album.album.isEmpty()) {
album.album.append(" (Explicit)");
}
}
}
else if (obj_item.contains("album")) { // This was a tracks request or search
QJsonValue value_album = obj_item["album"];
else if (obj_item.contains(QStringLiteral("album"))) { // This was a tracks request or search
QJsonValue value_album = obj_item[QStringLiteral("album")];
if (!value_album.isObject()) {
Error("Invalid Json reply, item album is not a object.", value_album);
Error(QStringLiteral("Invalid Json reply, item album is not a object."), value_album);
continue;
}
QJsonObject obj_album = value_album.toObject();
if (!obj_album.contains("id") || !obj_album.contains("title")) {
Error("Invalid Json reply, item album is missing ID or title.", obj_album);
if (!obj_album.contains(QStringLiteral("id")) || !obj_album.contains(QStringLiteral("title"))) {
Error(QStringLiteral("Invalid Json reply, item album is missing ID or title."), obj_album);
continue;
}
if (obj_album["id"].isString()) {
album.album_id = obj_album["id"].toString();
if (obj_album[QStringLiteral("id")].isString()) {
album.album_id = obj_album[QStringLiteral("id")].toString();
}
else {
album.album_id = QString::number(obj_album["id"].toInt());
album.album_id = QString::number(obj_album[QStringLiteral("id")].toInt());
}
album.album = obj_album["title"].toString();
if (service_->album_explicit() && obj_album.contains("explicit")) {
album.album_explicit = obj_album["explicit"].toVariant().toBool();
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();
if (album.album_explicit && !album.album.isEmpty()) {
album.album.append(" (Explicit)");
}
}
}
else {
Error("Invalid Json reply, item missing type or album.", obj_item);
Error(QStringLiteral("Invalid Json reply, item missing type or album."), obj_item);
continue;
}
if (album_songs_requests_pending_.contains(album.album_id)) continue;
if (!obj_item.contains("artist") || !obj_item.contains("title") || !obj_item.contains("audioQuality")) {
Error("Invalid Json reply, item missing artist, title or audioQuality.", obj_item);
if (!obj_item.contains(QStringLiteral("artist")) || !obj_item.contains(QStringLiteral("title")) || !obj_item.contains(QStringLiteral("audioQuality"))) {
Error(QStringLiteral("Invalid Json reply, item missing artist, title or audioQuality."), obj_item);
continue;
}
QJsonValue value_artist = obj_item["artist"];
QJsonValue value_artist = obj_item[QStringLiteral("artist")];
if (!value_artist.isObject()) {
Error("Invalid Json reply, item artist is not a object.", value_artist);
Error(QStringLiteral("Invalid Json reply, item artist is not a object."), value_artist);
continue;
}
QJsonObject obj_artist = value_artist.toObject();
if (!obj_artist.contains("id") || !obj_artist.contains("name")) {
Error("Invalid Json reply, item artist missing id or name.", obj_artist);
if (!obj_artist.contains(QStringLiteral("id")) || !obj_artist.contains(QStringLiteral("name"))) {
Error(QStringLiteral("Invalid Json reply, item artist missing id or name."), obj_artist);
continue;
}
Artist album_artist;
if (obj_artist["id"].isString()) {
album_artist.artist_id = obj_artist["id"].toString();
if (obj_artist[QStringLiteral("id")].isString()) {
album_artist.artist_id = obj_artist[QStringLiteral("id")].toString();
}
else {
album_artist.artist_id = QString::number(obj_artist["id"].toInt());
album_artist.artist_id = QString::number(obj_artist[QStringLiteral("id")].toInt());
}
album_artist.artist = obj_artist["name"].toString();
album_artist.artist = obj_artist[QStringLiteral("name")].toString();
//QString quality = obj_item["audioQuality"].toString();
//QString copyright = obj_item["copyright"].toString();
@@ -860,7 +860,7 @@ void TidalRequest::FlushAlbumSongsRequests() {
AlbumSongsRequest request = album_songs_requests_queue_.dequeue();
ParamList parameters;
if (request.offset > 0) parameters << Param("offset", QString::number(request.offset));
QNetworkReply *reply = CreateRequest(QString("albums/%1/tracks").arg(request.album.album_id), parameters);
QNetworkReply *reply = CreateRequest(QStringLiteral("albums/%1/tracks").arg(request.album.album_id), parameters);
replies_ << reply;
QObject::connect(reply, &QNetworkReply::finished, this, [this, reply, request]() { AlbumSongsReplyReceived(reply, request.artist, request.album, request.offset); });
@@ -903,21 +903,21 @@ void TidalRequest::SongsReceived(QNetworkReply *reply, const Artist &artist, con
return;
}
if (!json_obj.contains("limit") ||
!json_obj.contains("offset") ||
!json_obj.contains("totalNumberOfItems") ||
!json_obj.contains("items")) {
Error("Json object missing values.", json_obj);
if (!json_obj.contains(QStringLiteral("limit")) ||
!json_obj.contains(QStringLiteral("offset")) ||
!json_obj.contains(QStringLiteral("totalNumberOfItems")) ||
!json_obj.contains(QStringLiteral("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["offset"].toInt();
int songs_total = json_obj["totalNumberOfItems"].toInt();
int offset = json_obj[QStringLiteral("offset")].toInt();
int songs_total = json_obj[QStringLiteral("totalNumberOfItems")].toInt();
if (offset != offset_requested) {
Error(QString("Offset returned does not match offset requested! %1 != %2").arg(offset).arg(offset_requested));
Error(QStringLiteral("Offset returned does not match offset requested! %1 != %2").arg(offset).arg(offset_requested));
SongsFinishCheck(artist, album, limit_requested, offset_requested, songs_total, 0);
return;
}
@@ -941,15 +941,15 @@ void TidalRequest::SongsReceived(QNetworkReply *reply, const Artist &artist, con
for (const QJsonValueRef value_item : array_items) {
if (!value_item.isObject()) {
Error("Invalid Json reply, track is not a object.");
Error(QStringLiteral("Invalid Json reply, track is not a object."));
continue;
}
QJsonObject obj_item = value_item.toObject();
if (obj_item.contains("item")) {
QJsonValue item = obj_item["item"];
if (obj_item.contains(QStringLiteral("item"))) {
QJsonValue item = obj_item[QStringLiteral("item")];
if (!item.isObject()) {
Error("Invalid Json reply, item is not a object.", item);
Error(QStringLiteral("Invalid Json reply, item is not a object."), item);
continue;
}
obj_item = item.toObject();
@@ -1017,93 +1017,93 @@ 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("album") ||
!json_obj.contains("allowStreaming") ||
!json_obj.contains("artist") ||
!json_obj.contains("artists") ||
!json_obj.contains("audioQuality") ||
!json_obj.contains("duration") ||
!json_obj.contains("id") ||
!json_obj.contains("streamReady") ||
!json_obj.contains("title") ||
!json_obj.contains("trackNumber") ||
!json_obj.contains("url") ||
!json_obj.contains("volumeNumber") ||
!json_obj.contains("copyright")
!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"))
) {
Error("Invalid Json reply, track is missing one or more values.", json_obj);
Error(QStringLiteral("Invalid Json reply, track is missing one or more values."), json_obj);
return;
}
QJsonValue value_artist = json_obj["artist"];
QJsonValue value_album = json_obj["album"];
QJsonValue json_duration = json_obj["duration"];
QJsonValue value_artist = json_obj[QStringLiteral("artist")];
QJsonValue value_album = json_obj[QStringLiteral("album")];
QJsonValue json_duration = json_obj[QStringLiteral("duration")];
//QJsonArray array_artists = json_obj["artists"].toArray();
QString song_id;
if (json_obj["id"].isString()) {
song_id = json_obj["id"].toString();
if (json_obj[QStringLiteral("id")].isString()) {
song_id = json_obj[QStringLiteral("id")].toString();
}
else {
song_id = QString::number(json_obj["id"].toInt());
song_id = QString::number(json_obj[QStringLiteral("id")].toInt());
}
QString title = json_obj["title"].toString();
QString title = json_obj[QStringLiteral("title")].toString();
//QString urlstr = json_obj["url"].toString();
int track = json_obj["trackNumber"].toInt();
int disc = json_obj["volumeNumber"].toInt();
bool allow_streaming = json_obj["allowStreaming"].toBool();
bool stream_ready = json_obj["streamReady"].toBool();
QString copyright = json_obj["copyright"].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();
if (!value_artist.isObject()) {
Error("Invalid Json reply, track artist is not a object.", value_artist);
Error(QStringLiteral("Invalid Json reply, track artist is not a object."), value_artist);
return;
}
QJsonObject obj_artist = value_artist.toObject();
if (!obj_artist.contains("id") || !obj_artist.contains("name")) {
Error("Invalid Json reply, track artist is missing id or name.", obj_artist);
if (!obj_artist.contains(QStringLiteral("id")) || !obj_artist.contains(QStringLiteral("name"))) {
Error(QStringLiteral("Invalid Json reply, track artist is missing id or name."), obj_artist);
return;
}
QString artist_id;
if (obj_artist["id"].isString()) {
artist_id = obj_artist["id"].toString();
if (obj_artist[QStringLiteral("id")].isString()) {
artist_id = obj_artist[QStringLiteral("id")].toString();
}
else {
artist_id = QString::number(obj_artist["id"].toInt());
artist_id = QString::number(obj_artist[QStringLiteral("id")].toInt());
}
QString artist = obj_artist["name"].toString();
QString artist = obj_artist[QStringLiteral("name")].toString();
if (!value_album.isObject()) {
Error("Invalid Json reply, track album is not a object.", value_album);
Error(QStringLiteral("Invalid Json reply, track album is not a object."), value_album);
return;
}
QJsonObject obj_album = value_album.toObject();
if (!obj_album.contains("id") || !obj_album.contains("title")) {
Error("Invalid Json reply, track album is missing ID or title.", obj_album);
if (!obj_album.contains(QStringLiteral("id")) || !obj_album.contains(QStringLiteral("title"))) {
Error(QStringLiteral("Invalid Json reply, track album is missing ID or title."), obj_album);
return;
}
QString album_id;
if (obj_album["id"].isString()) {
album_id = obj_album["id"].toString();
if (obj_album[QStringLiteral("id")].isString()) {
album_id = obj_album[QStringLiteral("id")].toString();
}
else {
album_id = QString::number(obj_album["id"].toInt());
album_id = QString::number(obj_album[QStringLiteral("id")].toInt());
}
if (!album.album_id.isEmpty() && album.album_id != album_id) {
Error("Invalid Json reply, track album id is wrong.", obj_album);
Error(QStringLiteral("Invalid Json reply, track album id is wrong."), obj_album);
return;
}
QString album_title = obj_album["title"].toString();
QString album_title = obj_album[QStringLiteral("title")].toString();
if (album.album_explicit) album_title.append(" (Explicit)");
if (!allow_streaming) {
Warn(QString("Song %1 %2 %3 is not allowStreaming").arg(artist, album_title, title));
Warn(QStringLiteral("Song %1 %2 %3 is not allowStreaming").arg(artist, album_title, title));
return;
}
if (!stream_ready) {
Warn(QString("Song %1 %2 %3 is not streamReady").arg(artist, album_title, title));
Warn(QStringLiteral("Song %1 %2 %3 is not streamReady").arg(artist, album_title, title));
return;
}
@@ -1117,15 +1117,15 @@ void TidalRequest::ParseSong(Song &song, const QJsonObject &json_obj, const Arti
duration = q_duration.toLongLong() * kNsecPerSec;
}
else {
Error("Invalid duration for song.", json_duration);
Error(QStringLiteral("Invalid duration for song."), json_duration);
return;
}
QUrl cover_url;
if (obj_album.contains("cover")) {
const QString cover = obj_album["cover"].toString().replace("-", "/");
if (obj_album.contains(QStringLiteral("cover"))) {
const QString cover = obj_album[QStringLiteral("cover")].toString().replace(QLatin1String("-"), QLatin1String("/"));
if (!cover.isEmpty()) {
cover_url.setUrl(QString("%1/images/%2/%3.jpg").arg(kResourcesUrl, cover, coversize_));
cover_url.setUrl(QStringLiteral("%1/images/%2/%3.jpg").arg(kResourcesUrl, cover, coversize_));
}
}
@@ -1263,14 +1263,14 @@ void TidalRequest::AlbumCoverReceived(QNetworkReply *reply, const QString &album
}
if (reply->error() != QNetworkReply::NoError) {
Error(QString("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
Error(QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
album_covers_requests_sent_.remove(album_id);
AlbumCoverFinishCheck();
return;
}
if (reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt() != 200) {
Error(QString("Received HTTP code %1 for %2.").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt()).arg(url.toString()));
Error(QStringLiteral("Received HTTP code %1 for %2.").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt()).arg(url.toString()));
if (album_covers_requests_sent_.contains(album_id)) album_covers_requests_sent_.remove(album_id);
AlbumCoverFinishCheck();
return;
@@ -1281,7 +1281,7 @@ void TidalRequest::AlbumCoverReceived(QNetworkReply *reply, const QString &album
mimetype = mimetype.left(mimetype.indexOf(';'));
}
if (!ImageUtils::SupportedImageMimeTypes().contains(mimetype, Qt::CaseInsensitive) && !ImageUtils::SupportedImageFormats().contains(mimetype, Qt::CaseInsensitive)) {
Error(QString("Unsupported mimetype for image reader %1 for %2").arg(mimetype, url.toString()));
Error(QStringLiteral("Unsupported mimetype for image reader %1 for %2").arg(mimetype, url.toString()));
if (album_covers_requests_sent_.contains(album_id)) album_covers_requests_sent_.remove(album_id);
AlbumCoverFinishCheck();
return;
@@ -1289,7 +1289,7 @@ void TidalRequest::AlbumCoverReceived(QNetworkReply *reply, const QString &album
QByteArray data = reply->readAll();
if (data.isEmpty()) {
Error(QString("Received empty image data for %1").arg(url.toString()));
Error(QStringLiteral("Received empty image data for %1").arg(url.toString()));
if (album_covers_requests_sent_.contains(album_id)) album_covers_requests_sent_.remove(album_id);
AlbumCoverFinishCheck();
return;
@@ -1312,13 +1312,13 @@ void TidalRequest::AlbumCoverReceived(QNetworkReply *reply, const QString &album
}
}
else {
Error(QString("Error saving image data to %1").arg(filename));
Error(QStringLiteral("Error saving image data to %1").arg(filename));
if (album_covers_requests_sent_.contains(album_id)) album_covers_requests_sent_.remove(album_id);
}
}
else {
if (album_covers_requests_sent_.contains(album_id)) album_covers_requests_sent_.remove(album_id);
Error(QString("Error decoding image data from %1").arg(url.toString()));
Error(QStringLiteral("Error decoding image data from %1").arg(url.toString()));
}
AlbumCoverFinishCheck();

96
src/tidal/tidalservice.cpp
View File

@@ -87,7 +87,7 @@ constexpr char TidalService::kAlbumsSongsFtsTable[] = "tidal_albums_songs_fts";
constexpr char TidalService::kSongsFtsTable[] = "tidal_songs_fts";
TidalService::TidalService(Application *app, QObject *parent)
: InternetService(Song::Source::Tidal, "Tidal", "tidal", TidalSettingsPage::kSettingsGroup, SettingsDialog::Page::Tidal, app, parent),
: InternetService(Song::Source::Tidal, QStringLiteral("Tidal"), QStringLiteral("tidal"), TidalSettingsPage::kSettingsGroup, SettingsDialog::Page::Tidal, app, parent),
app_(app),
network_(app->network()),
url_handler_(new TidalUrlHandler(app, this)),
@@ -337,13 +337,13 @@ void TidalService::AuthorizationUrlReceived(const QUrl &url) {
QUrlQuery url_query(url);
if (url_query.hasQueryItem("token_type") && url_query.hasQueryItem("expires_in") && url_query.hasQueryItem("access_token")) {
if (url_query.hasQueryItem(QStringLiteral("token_type")) && url_query.hasQueryItem(QStringLiteral("expires_in")) && url_query.hasQueryItem(QStringLiteral("access_token"))) {
access_token_ = url_query.queryItemValue("access_token").toUtf8();
if (url_query.hasQueryItem("refresh_token")) {
refresh_token_ = url_query.queryItemValue("refresh_token").toUtf8();
access_token_ = url_query.queryItemValue(QStringLiteral("access_token")).toUtf8();
if (url_query.hasQueryItem(QStringLiteral("refresh_token"))) {
refresh_token_ = url_query.queryItemValue(QStringLiteral("refresh_token")).toUtf8();
}
expires_in_ = url_query.queryItemValue("expires_in").toInt();
expires_in_ = url_query.queryItemValue(QStringLiteral("expires_in")).toInt();
login_time_ = QDateTime::currentDateTime().toSecsSinceEpoch();
session_id_.clear();
@@ -360,9 +360,9 @@ void TidalService::AuthorizationUrlReceived(const QUrl &url) {
emit LoginSuccess();
}
else if (url_query.hasQueryItem("code") && url_query.hasQueryItem("state")) {
else if (url_query.hasQueryItem(QStringLiteral("code")) && url_query.hasQueryItem(QStringLiteral("state"))) {
QString code = url_query.queryItemValue("code");
QString code = url_query.queryItemValue(QStringLiteral("code"));
RequestAccessToken(code);
@@ -432,7 +432,7 @@ void TidalService::AccessTokenRequestFinished(QNetworkReply *reply) {
if (reply->error() != QNetworkReply::NoError || reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt() != 200) {
if (reply->error() != QNetworkReply::NoError && reply->error() < 200) {
// This is a network error, there is nothing more to do.
LoginError(QString("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
LoginError(QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
return;
}
else {
@@ -442,19 +442,19 @@ 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("status") && json_obj.contains("userMessage")) {
int status = json_obj["status"].toInt();
int sub_status = json_obj["subStatus"].toInt();
QString user_message = json_obj["userMessage"].toString();
login_errors_ << QString("Authentication failure: %1 (%2) (%3)").arg(user_message).arg(status).arg(sub_status);
if (!json_obj.isEmpty() && json_obj.contains(QStringLiteral("status")) && json_obj.contains(QStringLiteral("userMessage"))) {
int status = json_obj[QStringLiteral("status")].toInt();
int sub_status = json_obj[QStringLiteral("subStatus")].toInt();
QString user_message = json_obj[QStringLiteral("userMessage")].toString();
login_errors_ << QStringLiteral("Authentication failure: %1 (%2) (%3)").arg(user_message).arg(status).arg(sub_status);
}
}
if (login_errors_.isEmpty()) {
if (reply->error() != QNetworkReply::NoError) {
login_errors_ << QString("%1 (%2)").arg(reply->errorString()).arg(reply->error());
login_errors_ << QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
}
else {
login_errors_ << QString("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt());
login_errors_ << QStringLiteral("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt());
}
}
LoginError();
@@ -467,43 +467,43 @@ void TidalService::AccessTokenRequestFinished(QNetworkReply *reply) {
QJsonDocument json_doc = QJsonDocument::fromJson(data, &json_error);
if (json_error.error != QJsonParseError::NoError) {
LoginError("Authentication reply from server missing Json data.");
LoginError(QStringLiteral("Authentication reply from server missing Json data."));
return;
}
if (json_doc.isEmpty()) {
LoginError("Authentication reply from server has empty Json document.");
LoginError(QStringLiteral("Authentication reply from server has empty Json document."));
return;
}
if (!json_doc.isObject()) {
LoginError("Authentication reply from server has Json document that is not an object.", json_doc);
LoginError(QStringLiteral("Authentication reply from server has Json document that is not an object."), json_doc);
return;
}
QJsonObject json_obj = json_doc.object();
if (json_obj.isEmpty()) {
LoginError("Authentication reply from server has empty Json object.", json_doc);
LoginError(QStringLiteral("Authentication reply from server has empty Json object."), json_doc);
return;
}
if (!json_obj.contains("access_token") || !json_obj.contains("expires_in")) {
LoginError("Authentication reply from server is missing access_token or expires_in", json_obj);
if (!json_obj.contains(QStringLiteral("access_token")) || !json_obj.contains(QStringLiteral("expires_in"))) {
LoginError(QStringLiteral("Authentication reply from server is missing access_token or expires_in"), json_obj);
return;
}
access_token_ = json_obj["access_token"].toString();
expires_in_ = json_obj["expires_in"].toInt();
if (json_obj.contains("refresh_token")) {
refresh_token_ = json_obj["refresh_token"].toString();
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();
}
login_time_ = QDateTime::currentDateTime().toSecsSinceEpoch();
if (json_obj.contains("user") && json_obj["user"].isObject()) {
QJsonObject obj_user = json_obj["user"].toObject();
if (obj_user.contains("countryCode") && obj_user.contains("userId")) {
country_code_ = obj_user["countryCode"].toString();
user_id_ = obj_user["userId"].toInt();
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();
}
}
@@ -581,7 +581,7 @@ void TidalService::HandleAuthReply(QNetworkReply *reply) {
if (reply->error() != QNetworkReply::NoError || reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt() != 200) {
if (reply->error() != QNetworkReply::NoError && reply->error() < 200) {
// This is a network error, there is nothing more to do.
LoginError(QString("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
LoginError(QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
login_errors_.clear();
return;
}
@@ -592,19 +592,19 @@ 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("status") && json_obj.contains("userMessage")) {
int status = json_obj["status"].toInt();
int sub_status = json_obj["subStatus"].toInt();
QString user_message = json_obj["userMessage"].toString();
login_errors_ << QString("Authentication failure: %1 (%2) (%3)").arg(user_message).arg(status).arg(sub_status);
if (!json_obj.isEmpty() && json_obj.contains(QStringLiteral("status")) && json_obj.contains(QStringLiteral("userMessage"))) {
int status = json_obj[QStringLiteral("status")].toInt();
int sub_status = json_obj[QStringLiteral("subStatus")].toInt();
QString user_message = json_obj[QStringLiteral("userMessage")].toString();
login_errors_ << QStringLiteral("Authentication failure: %1 (%2) (%3)").arg(user_message).arg(status).arg(sub_status);
}
}
if (login_errors_.isEmpty()) {
if (reply->error() != QNetworkReply::NoError) {
login_errors_ << QString("%1 (%2)").arg(reply->errorString()).arg(reply->error());
login_errors_ << QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
}
else {
login_errors_ << QString("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt());
login_errors_ << QStringLiteral("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt());
}
}
LoginError();
@@ -620,34 +620,34 @@ void TidalService::HandleAuthReply(QNetworkReply *reply) {
QJsonDocument json_doc = QJsonDocument::fromJson(data, &json_error);
if (json_error.error != QJsonParseError::NoError) {
LoginError("Authentication reply from server missing Json data.");
LoginError(QStringLiteral("Authentication reply from server missing Json data."));
return;
}
if (json_doc.isEmpty()) {
LoginError("Authentication reply from server has empty Json document.");
LoginError(QStringLiteral("Authentication reply from server has empty Json document."));
return;
}
if (!json_doc.isObject()) {
LoginError("Authentication reply from server has Json document that is not an object.", json_doc);
LoginError(QStringLiteral("Authentication reply from server has Json document that is not an object."), json_doc);
return;
}
QJsonObject json_obj = json_doc.object();
if (json_obj.isEmpty()) {
LoginError("Authentication reply from server has empty Json object.", json_doc);
LoginError(QStringLiteral("Authentication reply from server has empty Json object."), json_doc);
return;
}
if (!json_obj.contains("userId") || !json_obj.contains("sessionId") || !json_obj.contains("countryCode")) {
LoginError("Authentication reply from server is missing userId, sessionId or countryCode", json_obj);
if (!json_obj.contains(QStringLiteral("userId")) || !json_obj.contains(QStringLiteral("sessionId")) || !json_obj.contains(QStringLiteral("countryCode"))) {
LoginError(QStringLiteral("Authentication reply from server is missing userId, sessionId or countryCode"), json_obj);
return;
}
country_code_ = json_obj["countryCode"].toString();
session_id_ = json_obj["sessionId"].toString();
user_id_ = json_obj["userId"].toInt();
country_code_ = json_obj[QStringLiteral("countryCode")].toString();
session_id_ = json_obj[QStringLiteral("sessionId")].toString();
user_id_ = json_obj[QStringLiteral("userId")].toInt();
access_token_.clear();
refresh_token_.clear();

60
src/tidal/tidalstreamurlrequest.cpp
View File

@@ -122,7 +122,7 @@ void TidalStreamURLRequest::GetStreamURL() {
switch (stream_url_method()) {
case TidalSettingsPage::StreamUrlMethod::StreamUrl:
params << Param("soundQuality", quality());
reply_ = CreateRequest(QString("tracks/%1/streamUrl").arg(song_id_), params);
reply_ = CreateRequest(QStringLiteral("tracks/%1/streamUrl").arg(song_id_), params);
QObject::connect(reply_, &QNetworkReply::finished, this, &TidalStreamURLRequest::StreamURLReceived);
break;
case TidalSettingsPage::StreamUrlMethod::UrlPostPaywall:
@@ -130,14 +130,14 @@ void TidalStreamURLRequest::GetStreamURL() {
params << Param("playbackmode", "STREAM");
params << Param("assetpresentation", "FULL");
params << Param("urlusagemode", "STREAM");
reply_ = CreateRequest(QString("tracks/%1/urlpostpaywall").arg(song_id_), params);
reply_ = CreateRequest(QStringLiteral("tracks/%1/urlpostpaywall").arg(song_id_), params);
QObject::connect(reply_, &QNetworkReply::finished, this, &TidalStreamURLRequest::StreamURLReceived);
break;
case TidalSettingsPage::StreamUrlMethod::PlaybackInfoPostPaywall:
params << Param("audioquality", quality());
params << Param("playbackmode", "STREAM");
params << Param("assetpresentation", "FULL");
reply_ = CreateRequest(QString("tracks/%1/playbackinfopostpaywall").arg(song_id_), params);
reply_ = CreateRequest(QStringLiteral("tracks/%1/playbackinfopostpaywall").arg(song_id_), params);
QObject::connect(reply_, &QNetworkReply::finished, this, &TidalStreamURLRequest::StreamURLReceived);
break;
}
@@ -169,22 +169,22 @@ void TidalStreamURLRequest::StreamURLReceived() {
return;
}
if (!json_obj.contains("trackId")) {
Error("Invalid Json reply, stream missing trackId.", json_obj);
if (!json_obj.contains(QStringLiteral("trackId"))) {
Error(QStringLiteral("Invalid Json reply, stream missing trackId."), json_obj);
emit StreamURLFailure(id_, media_url_, errors_.first());
return;
}
int track_id = json_obj["trackId"].toInt();
int track_id = json_obj[QStringLiteral("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("codec") || json_obj.contains("codecs")) {
if (json_obj.contains(QStringLiteral("codec")) || json_obj.contains(QStringLiteral("codecs"))) {
QString codec;
if (json_obj.contains("codec")) codec = json_obj["codec"].toString().toLower();
if (json_obj.contains("codecs")) codec = json_obj["codecs"].toString().toLower();
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();
filetype = Song::FiletypeByExtension(codec);
if (filetype == Song::FileType::Unknown) {
qLog(Debug) << "Tidal: Unknown codec" << codec;
@@ -194,16 +194,16 @@ void TidalStreamURLRequest::StreamURLReceived() {
QList<QUrl> urls;
if (json_obj.contains("manifest")) {
if (json_obj.contains(QStringLiteral("manifest"))) {
QString manifest(json_obj["manifest"].toString());
QString manifest(json_obj[QStringLiteral("manifest")].toString());
QByteArray data_manifest = QByteArray::fromBase64(manifest.toUtf8());
QXmlStreamReader xml_reader(data_manifest);
if (xml_reader.readNextStartElement()) {
QUrl url;
url.setScheme("data");
url.setPath(QString("application/dash+xml;base64,%1").arg(manifest));
url.setScheme(QStringLiteral("data"));
url.setPath(QStringLiteral("application/dash+xml;base64,%1").arg(manifest));
urls << url;
}
@@ -215,9 +215,9 @@ void TidalStreamURLRequest::StreamURLReceived() {
return;
}
if (json_obj.contains("encryptionType") && json_obj.contains("keyId")) {
QString encryption_type = json_obj["encryptionType"].toString();
QString key_id = json_obj["keyId"].toString();
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 (!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("mimeType")) {
Error("Invalid Json reply, stream url reply manifest is missing mimeType.", json_obj);
if (!json_obj.contains(QStringLiteral("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["mimeType"].toString();
QString mimetype = json_obj[QStringLiteral("mimeType")].toString();
QMimeDatabase mimedb;
QStringList suffixes = mimedb.mimeTypeForName(mimetype.toUtf8()).suffixes();
for (const QString &suffix : suffixes) {
@@ -246,10 +246,10 @@ void TidalStreamURLRequest::StreamURLReceived() {
}
if (json_obj.contains("urls")) {
QJsonValue json_urls = json_obj["urls"];
if (json_obj.contains(QStringLiteral("urls"))) {
QJsonValue json_urls = json_obj[QStringLiteral("urls")];
if (!json_urls.isArray()) {
Error("Invalid Json reply, urls is not an array.", json_urls);
Error(QStringLiteral("Invalid Json reply, urls is not an array."), json_urls);
emit StreamURLFailure(id_, media_url_, errors_.first());
return;
}
@@ -259,8 +259,8 @@ void TidalStreamURLRequest::StreamURLReceived() {
urls << QUrl(value.toString());
}
}
else if (json_obj.contains("url")) {
QUrl new_url(json_obj["url"].toString());
else if (json_obj.contains(QStringLiteral("url"))) {
QUrl new_url(json_obj[QStringLiteral("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("encryptionKey")) {
QString encryption_key = json_obj["encryptionKey"].toString();
if (json_obj.contains(QStringLiteral("encryptionKey"))) {
QString encryption_key = json_obj[QStringLiteral("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("securityType") && json_obj.contains("securityToken")) {
QString security_type = json_obj["securityType"].toString();
QString security_token = json_obj["securityToken"].toString();
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 (!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());
@@ -289,7 +289,7 @@ void TidalStreamURLRequest::StreamURLReceived() {
}
if (urls.isEmpty()) {
Error("Missing stream urls.", json_obj);
Error(QStringLiteral("Missing stream urls."), json_obj);
emit StreamURLFailure(id_, media_url_, errors_.first());
return;
}

2
src/tidal/tidalurlhandler.cpp
View File

@@ -42,7 +42,7 @@ TidalUrlHandler::TidalUrlHandler(Application *app, TidalService *service)
UrlHandler::LoadResult TidalUrlHandler::StartLoading(const QUrl &url) {
Request req;
req.task_id = app_->task_manager()->StartTask(QString("Loading %1 stream...").arg(url.scheme()));
req.task_id = app_->task_manager()->StartTask(QStringLiteral("Loading %1 stream...").arg(url.scheme()));
QString error;
req.id = service_->GetStreamURL(url, error);
if (req.id == 0) {