1041 lines
37 KiB
C++
1041 lines
37 KiB
C++
/*
|
|
* Strawberry Music Player
|
|
* Copyright 2018-2021, Jonas Kvinge <jonas@jkvinge.net>
|
|
*
|
|
* Strawberry is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* Strawberry is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with Strawberry. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <memory>
|
|
#include <chrono>
|
|
|
|
#include <QObject>
|
|
#include <QDesktopServices>
|
|
#include <QCryptographicHash>
|
|
#include <QByteArray>
|
|
#include <QList>
|
|
#include <QString>
|
|
#include <QChar>
|
|
#include <QUrl>
|
|
#include <QUrlQuery>
|
|
#include <QNetworkRequest>
|
|
#include <QNetworkReply>
|
|
#include <QSslError>
|
|
#include <QTimer>
|
|
#include <QJsonValue>
|
|
#include <QJsonDocument>
|
|
#include <QJsonObject>
|
|
#include <QSettings>
|
|
#include <QSortFilterProxyModel>
|
|
|
|
#include "core/application.h"
|
|
#include "core/player.h"
|
|
#include "core/logging.h"
|
|
#include "core/networkaccessmanager.h"
|
|
#include "core/database.h"
|
|
#include "core/song.h"
|
|
#include "utilities/randutils.h"
|
|
#include "utilities/timeconstants.h"
|
|
#include "internet/internetsearchview.h"
|
|
#include "collection/collectionbackend.h"
|
|
#include "collection/collectionmodel.h"
|
|
#include "tidalservice.h"
|
|
#include "tidalurlhandler.h"
|
|
#include "tidalbaserequest.h"
|
|
#include "tidalrequest.h"
|
|
#include "tidalfavoriterequest.h"
|
|
#include "tidalstreamurlrequest.h"
|
|
#include "settings/settingsdialog.h"
|
|
#include "settings/tidalsettingspage.h"
|
|
|
|
const Song::Source TidalService::kSource = Song::Source::Tidal;
|
|
|
|
const char TidalService::kApiUrl[] = "https://api.tidalhifi.com/v1";
|
|
const char TidalService::kResourcesUrl[] = "https://resources.tidal.com";
|
|
|
|
constexpr char TidalService::kOAuthUrl[] = "https://login.tidal.com/authorize";
|
|
constexpr char TidalService::kOAuthAccessTokenUrl[] = "https://login.tidal.com/oauth2/token";
|
|
constexpr char TidalService::kOAuthRedirectUrl[] = "tidal://login/auth";
|
|
constexpr char TidalService::kAuthUrl[] = "https://api.tidalhifi.com/v1/login/username";
|
|
|
|
const int TidalService::kLoginAttempts = 2;
|
|
constexpr int TidalService::kTimeResetLoginAttempts = 60000;
|
|
|
|
constexpr char TidalService::kArtistsSongsTable[] = "tidal_artists_songs";
|
|
constexpr char TidalService::kAlbumsSongsTable[] = "tidal_albums_songs";
|
|
constexpr char TidalService::kSongsTable[] = "tidal_songs";
|
|
|
|
constexpr char TidalService::kArtistsSongsFtsTable[] = "tidal_artists_songs_fts";
|
|
constexpr char TidalService::kAlbumsSongsFtsTable[] = "tidal_albums_songs_fts";
|
|
constexpr char TidalService::kSongsFtsTable[] = "tidal_songs_fts";
|
|
|
|
using namespace std::chrono_literals;
|
|
|
|
TidalService::TidalService(Application *app, QObject *parent)
|
|
: InternetService(Song::Source::Tidal, "Tidal", "tidal", TidalSettingsPage::kSettingsGroup, SettingsDialog::Page::Tidal, app, parent),
|
|
app_(app),
|
|
network_(new NetworkAccessManager(this)),
|
|
url_handler_(new TidalUrlHandler(app, this)),
|
|
artists_collection_backend_(nullptr),
|
|
albums_collection_backend_(nullptr),
|
|
songs_collection_backend_(nullptr),
|
|
artists_collection_model_(nullptr),
|
|
albums_collection_model_(nullptr),
|
|
songs_collection_model_(nullptr),
|
|
artists_collection_sort_model_(new QSortFilterProxyModel(this)),
|
|
albums_collection_sort_model_(new QSortFilterProxyModel(this)),
|
|
songs_collection_sort_model_(new QSortFilterProxyModel(this)),
|
|
timer_search_delay_(new QTimer(this)),
|
|
timer_login_attempt_(new QTimer(this)),
|
|
timer_refresh_login_(new QTimer(this)),
|
|
favorite_request_(new TidalFavoriteRequest(this, network_, this)),
|
|
enabled_(false),
|
|
oauth_(false),
|
|
user_id_(0),
|
|
artistssearchlimit_(1),
|
|
albumssearchlimit_(1),
|
|
songssearchlimit_(1),
|
|
fetchalbums_(true),
|
|
download_album_covers_(true),
|
|
stream_url_method_(TidalSettingsPage::StreamUrlMethod::StreamUrl),
|
|
album_explicit_(false),
|
|
expires_in_(0),
|
|
login_time_(0),
|
|
pending_search_id_(0),
|
|
next_pending_search_id_(1),
|
|
pending_search_type_(InternetSearchView::SearchType::Artists),
|
|
search_id_(0),
|
|
login_sent_(false),
|
|
login_attempts_(0),
|
|
next_stream_url_request_id_(0) {
|
|
|
|
app->player()->RegisterUrlHandler(url_handler_);
|
|
|
|
// Backends
|
|
|
|
artists_collection_backend_ = new CollectionBackend();
|
|
artists_collection_backend_->moveToThread(app_->database()->thread());
|
|
artists_collection_backend_->Init(app_->database(), app->task_manager(), Song::Source::Tidal, kArtistsSongsTable, kArtistsSongsFtsTable);
|
|
|
|
albums_collection_backend_ = new CollectionBackend();
|
|
albums_collection_backend_->moveToThread(app_->database()->thread());
|
|
albums_collection_backend_->Init(app_->database(), app->task_manager(), Song::Source::Tidal, kAlbumsSongsTable, kAlbumsSongsFtsTable);
|
|
|
|
songs_collection_backend_ = new CollectionBackend();
|
|
songs_collection_backend_->moveToThread(app_->database()->thread());
|
|
songs_collection_backend_->Init(app_->database(), app->task_manager(), Song::Source::Tidal, kSongsTable, kSongsFtsTable);
|
|
|
|
artists_collection_model_ = new CollectionModel(artists_collection_backend_, app_, this);
|
|
albums_collection_model_ = new CollectionModel(albums_collection_backend_, app_, this);
|
|
songs_collection_model_ = new CollectionModel(songs_collection_backend_, app_, this);
|
|
|
|
artists_collection_sort_model_->setSourceModel(artists_collection_model_);
|
|
artists_collection_sort_model_->setSortRole(CollectionModel::Role_SortText);
|
|
artists_collection_sort_model_->setDynamicSortFilter(true);
|
|
artists_collection_sort_model_->setSortLocaleAware(true);
|
|
artists_collection_sort_model_->sort(0);
|
|
|
|
albums_collection_sort_model_->setSourceModel(albums_collection_model_);
|
|
albums_collection_sort_model_->setSortRole(CollectionModel::Role_SortText);
|
|
albums_collection_sort_model_->setDynamicSortFilter(true);
|
|
albums_collection_sort_model_->setSortLocaleAware(true);
|
|
albums_collection_sort_model_->sort(0);
|
|
|
|
songs_collection_sort_model_->setSourceModel(songs_collection_model_);
|
|
songs_collection_sort_model_->setSortRole(CollectionModel::Role_SortText);
|
|
songs_collection_sort_model_->setDynamicSortFilter(true);
|
|
songs_collection_sort_model_->setSortLocaleAware(true);
|
|
songs_collection_sort_model_->sort(0);
|
|
|
|
// Search
|
|
|
|
timer_search_delay_->setSingleShot(true);
|
|
QObject::connect(timer_search_delay_, &QTimer::timeout, this, &TidalService::StartSearch);
|
|
|
|
timer_login_attempt_->setSingleShot(true);
|
|
timer_login_attempt_->setInterval(kTimeResetLoginAttempts);
|
|
QObject::connect(timer_login_attempt_, &QTimer::timeout, this, &TidalService::ResetLoginAttempts);
|
|
|
|
timer_refresh_login_->setSingleShot(true);
|
|
QObject::connect(timer_refresh_login_, &QTimer::timeout, this, &TidalService::RequestNewAccessToken);
|
|
|
|
QObject::connect(this, &TidalService::RequestLogin, this, &TidalService::SendLogin);
|
|
QObject::connect(this, &TidalService::LoginWithCredentials, this, &TidalService::SendLoginWithCredentials);
|
|
|
|
QObject::connect(this, &TidalService::AddArtists, favorite_request_, &TidalFavoriteRequest::AddArtists);
|
|
QObject::connect(this, &TidalService::AddAlbums, favorite_request_, &TidalFavoriteRequest::AddAlbums);
|
|
QObject::connect(this, &TidalService::AddSongs, favorite_request_, QOverload<const SongList&>::of(&TidalFavoriteRequest::AddSongs));
|
|
|
|
QObject::connect(this, &TidalService::RemoveArtists, favorite_request_, &TidalFavoriteRequest::RemoveArtists);
|
|
QObject::connect(this, &TidalService::RemoveAlbums, favorite_request_, &TidalFavoriteRequest::RemoveAlbums);
|
|
QObject::connect(this, &TidalService::RemoveSongsByList, favorite_request_, QOverload<const SongList&>::of(&TidalFavoriteRequest::RemoveSongs));
|
|
QObject::connect(this, &TidalService::RemoveSongsByMap, favorite_request_, QOverload<const SongMap&>::of(&TidalFavoriteRequest::RemoveSongs));
|
|
|
|
QObject::connect(favorite_request_, &TidalFavoriteRequest::RequestLogin, this, &TidalService::SendLogin);
|
|
|
|
QObject::connect(favorite_request_, &TidalFavoriteRequest::ArtistsAdded, artists_collection_backend_, &CollectionBackend::AddOrUpdateSongs);
|
|
QObject::connect(favorite_request_, &TidalFavoriteRequest::AlbumsAdded, albums_collection_backend_, &CollectionBackend::AddOrUpdateSongs);
|
|
QObject::connect(favorite_request_, &TidalFavoriteRequest::SongsAdded, songs_collection_backend_, &CollectionBackend::AddOrUpdateSongs);
|
|
|
|
QObject::connect(favorite_request_, &TidalFavoriteRequest::ArtistsRemoved, artists_collection_backend_, &CollectionBackend::DeleteSongs);
|
|
QObject::connect(favorite_request_, &TidalFavoriteRequest::AlbumsRemoved, albums_collection_backend_, &CollectionBackend::DeleteSongs);
|
|
QObject::connect(favorite_request_, &TidalFavoriteRequest::SongsRemoved, songs_collection_backend_, &CollectionBackend::DeleteSongs);
|
|
|
|
TidalService::ReloadSettings();
|
|
LoadSession();
|
|
|
|
}
|
|
|
|
TidalService::~TidalService() {
|
|
|
|
while (!replies_.isEmpty()) {
|
|
QNetworkReply *reply = replies_.takeFirst();
|
|
QObject::disconnect(reply, nullptr, this, nullptr);
|
|
reply->abort();
|
|
reply->deleteLater();
|
|
}
|
|
|
|
while (!stream_url_requests_.isEmpty()) {
|
|
std::shared_ptr<TidalStreamURLRequest> stream_url_req = stream_url_requests_.take(stream_url_requests_.firstKey());
|
|
QObject::disconnect(stream_url_req.get(), nullptr, this, nullptr);
|
|
}
|
|
|
|
artists_collection_backend_->deleteLater();
|
|
albums_collection_backend_->deleteLater();
|
|
songs_collection_backend_->deleteLater();
|
|
|
|
}
|
|
|
|
void TidalService::Exit() {
|
|
|
|
wait_for_exit_ << artists_collection_backend_ << albums_collection_backend_ << songs_collection_backend_;
|
|
|
|
QObject::connect(artists_collection_backend_, &CollectionBackend::ExitFinished, this, &TidalService::ExitReceived);
|
|
QObject::connect(albums_collection_backend_, &CollectionBackend::ExitFinished, this, &TidalService::ExitReceived);
|
|
QObject::connect(songs_collection_backend_, &CollectionBackend::ExitFinished, this, &TidalService::ExitReceived);
|
|
|
|
artists_collection_backend_->ExitAsync();
|
|
albums_collection_backend_->ExitAsync();
|
|
songs_collection_backend_->ExitAsync();
|
|
|
|
}
|
|
|
|
void TidalService::ExitReceived() {
|
|
|
|
QObject *obj = sender();
|
|
QObject::disconnect(obj, nullptr, this, nullptr);
|
|
qLog(Debug) << obj << "successfully exited.";
|
|
wait_for_exit_.removeAll(obj);
|
|
if (wait_for_exit_.isEmpty()) emit ExitFinished();
|
|
|
|
}
|
|
|
|
void TidalService::ShowConfig() {
|
|
app_->OpenSettingsDialogAtPage(SettingsDialog::Page::Tidal);
|
|
}
|
|
|
|
void TidalService::LoadSession() {
|
|
|
|
QSettings s;
|
|
s.beginGroup(TidalSettingsPage::kSettingsGroup);
|
|
user_id_ = s.value("user_id").toInt();
|
|
country_code_ = s.value("country_code", "US").toString();
|
|
access_token_ = s.value("access_token").toString();
|
|
refresh_token_ = s.value("refresh_token").toString();
|
|
session_id_ = s.value("session_id").toString();
|
|
expires_in_ = s.value("expires_in").toLongLong();
|
|
login_time_ = s.value("login_time").toLongLong();
|
|
s.endGroup();
|
|
|
|
if (!refresh_token_.isEmpty()) {
|
|
qint64 time = static_cast<qint64>(expires_in_) - (QDateTime::currentDateTime().toSecsSinceEpoch() - static_cast<qint64>(login_time_));
|
|
if (time <= 0) {
|
|
timer_refresh_login_->setInterval(200ms);
|
|
}
|
|
else {
|
|
timer_refresh_login_->setInterval(static_cast<int>(time * kMsecPerSec));
|
|
}
|
|
timer_refresh_login_->start();
|
|
}
|
|
|
|
}
|
|
|
|
void TidalService::ReloadSettings() {
|
|
|
|
QSettings s;
|
|
s.beginGroup(TidalSettingsPage::kSettingsGroup);
|
|
|
|
enabled_ = s.value("enabled", false).toBool();
|
|
oauth_ = s.value("oauth", true).toBool();
|
|
client_id_ = s.value("client_id").toString();
|
|
api_token_ = s.value("api_token").toString();
|
|
|
|
username_ = s.value("username").toString();
|
|
QByteArray password = s.value("password").toByteArray();
|
|
if (password.isEmpty()) password_.clear();
|
|
else password_ = QString::fromUtf8(QByteArray::fromBase64(password));
|
|
|
|
quality_ = s.value("quality", "LOSSLESS").toString();
|
|
quint64 search_delay = s.value("searchdelay", 1500).toInt();
|
|
artistssearchlimit_ = s.value("artistssearchlimit", 4).toInt();
|
|
albumssearchlimit_ = s.value("albumssearchlimit", 10).toInt();
|
|
songssearchlimit_ = s.value("songssearchlimit", 10).toInt();
|
|
fetchalbums_ = s.value("fetchalbums", false).toBool();
|
|
coversize_ = s.value("coversize", "640x640").toString();
|
|
download_album_covers_ = s.value("downloadalbumcovers", true).toBool();
|
|
stream_url_method_ = static_cast<TidalSettingsPage::StreamUrlMethod>(s.value("streamurl", static_cast<int>(TidalSettingsPage::StreamUrlMethod::StreamUrl)).toInt());
|
|
album_explicit_ = s.value("album_explicit").toBool();
|
|
|
|
s.endGroup();
|
|
|
|
timer_search_delay_->setInterval(static_cast<int>(search_delay));
|
|
|
|
}
|
|
|
|
void TidalService::StartAuthorization(const QString &client_id) {
|
|
|
|
client_id_ = client_id;
|
|
code_verifier_ = Utilities::CryptographicRandomString(44);
|
|
code_challenge_ = QString(QCryptographicHash::hash(code_verifier_.toUtf8(), QCryptographicHash::Sha256).toBase64(QByteArray::Base64UrlEncoding));
|
|
|
|
if (code_challenge_.lastIndexOf(QChar('=')) == code_challenge_.length() - 1) {
|
|
code_challenge_.chop(1);
|
|
}
|
|
|
|
const ParamList params = ParamList() << Param("response_type", "code")
|
|
<< Param("code_challenge", code_challenge_)
|
|
<< Param("code_challenge_method", "S256")
|
|
<< Param("redirect_uri", kOAuthRedirectUrl)
|
|
<< Param("client_id", client_id_)
|
|
<< Param("scope", "r_usr w_usr");
|
|
|
|
QUrlQuery url_query;
|
|
for (const Param ¶m : params) {
|
|
url_query.addQueryItem(QUrl::toPercentEncoding(param.first), QUrl::toPercentEncoding(param.second));
|
|
}
|
|
|
|
QUrl url = QUrl(kOAuthUrl);
|
|
url.setQuery(url_query);
|
|
QDesktopServices::openUrl(url);
|
|
|
|
}
|
|
|
|
void TidalService::AuthorizationUrlReceived(const QUrl &url) {
|
|
|
|
qLog(Debug) << "Tidal: Authorization URL Received" << url;
|
|
|
|
QUrlQuery url_query(url);
|
|
|
|
if (url_query.hasQueryItem("token_type") && url_query.hasQueryItem("expires_in") && url_query.hasQueryItem("access_token")) {
|
|
|
|
access_token_ = url_query.queryItemValue("access_token").toUtf8();
|
|
if (url_query.hasQueryItem("refresh_token")) {
|
|
refresh_token_ = url_query.queryItemValue("refresh_token").toUtf8();
|
|
}
|
|
expires_in_ = url_query.queryItemValue("expires_in").toInt();
|
|
login_time_ = QDateTime::currentDateTime().toSecsSinceEpoch();
|
|
session_id_.clear();
|
|
|
|
QSettings s;
|
|
s.beginGroup(TidalSettingsPage::kSettingsGroup);
|
|
s.setValue("access_token", access_token_);
|
|
s.setValue("refresh_token", refresh_token_);
|
|
s.setValue("expires_in", expires_in_);
|
|
s.setValue("login_time", login_time_);
|
|
s.remove("session_id");
|
|
s.endGroup();
|
|
|
|
emit LoginComplete(true);
|
|
emit LoginSuccess();
|
|
}
|
|
|
|
else if (url_query.hasQueryItem("code") && url_query.hasQueryItem("state")) {
|
|
|
|
QString code = url_query.queryItemValue("code");
|
|
|
|
RequestAccessToken(code);
|
|
|
|
}
|
|
|
|
else {
|
|
LoginError(tr("Reply from Tidal is missing query items."));
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
void TidalService::RequestAccessToken(const QString &code) {
|
|
|
|
timer_refresh_login_->stop();
|
|
|
|
ParamList params = ParamList() << Param("client_id", client_id_);
|
|
|
|
if (!code.isEmpty()) {
|
|
params << Param("grant_type", "authorization_code");
|
|
params << Param("code", code);
|
|
params << Param("code_verifier", code_verifier_);
|
|
params << Param("redirect_uri", kOAuthRedirectUrl);
|
|
params << Param("scope", "r_usr w_usr");
|
|
}
|
|
else if (!refresh_token_.isEmpty() && enabled_ && oauth_) {
|
|
params << Param("grant_type", "refresh_token");
|
|
params << Param("refresh_token", refresh_token_);
|
|
}
|
|
else {
|
|
return;
|
|
}
|
|
|
|
QUrlQuery url_query;
|
|
for (const Param ¶m : params) {
|
|
url_query.addQueryItem(QUrl::toPercentEncoding(param.first), QUrl::toPercentEncoding(param.second));
|
|
}
|
|
|
|
QUrl url(kOAuthAccessTokenUrl);
|
|
QNetworkRequest req(url);
|
|
req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
|
|
QByteArray query = url_query.toString(QUrl::FullyEncoded).toUtf8();
|
|
|
|
login_errors_.clear();
|
|
QNetworkReply *reply = network_->post(req, query);
|
|
replies_ << reply;
|
|
QObject::connect(reply, &QNetworkReply::sslErrors, this, &TidalService::HandleLoginSSLErrors);
|
|
QObject::connect(reply, &QNetworkReply::finished, this, [this, reply]() { AccessTokenRequestFinished(reply); });
|
|
|
|
}
|
|
|
|
void TidalService::HandleLoginSSLErrors(const QList<QSslError> &ssl_errors) {
|
|
|
|
for (const QSslError &ssl_error : ssl_errors) {
|
|
login_errors_ += ssl_error.errorString();
|
|
}
|
|
|
|
}
|
|
|
|
void TidalService::AccessTokenRequestFinished(QNetworkReply *reply) {
|
|
|
|
if (!replies_.contains(reply)) return;
|
|
replies_.removeAll(reply);
|
|
QObject::disconnect(reply, nullptr, this, nullptr);
|
|
reply->deleteLater();
|
|
|
|
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()));
|
|
return;
|
|
}
|
|
else {
|
|
// See if there is Json data containing "status" and "userMessage" then use that instead.
|
|
QByteArray data(reply->readAll());
|
|
QJsonParseError json_error;
|
|
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 (login_errors_.isEmpty()) {
|
|
if (reply->error() != QNetworkReply::NoError) {
|
|
login_errors_ << QString("%1 (%2)").arg(reply->errorString()).arg(reply->error());
|
|
}
|
|
else {
|
|
login_errors_ << QString("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt());
|
|
}
|
|
}
|
|
LoginError();
|
|
return;
|
|
}
|
|
}
|
|
|
|
QByteArray data(reply->readAll());
|
|
QJsonParseError json_error;
|
|
QJsonDocument json_doc = QJsonDocument::fromJson(data, &json_error);
|
|
|
|
if (json_error.error != QJsonParseError::NoError) {
|
|
LoginError("Authentication reply from server missing Json data.");
|
|
return;
|
|
}
|
|
|
|
if (json_doc.isEmpty()) {
|
|
LoginError("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);
|
|
return;
|
|
}
|
|
|
|
QJsonObject json_obj = json_doc.object();
|
|
if (json_obj.isEmpty()) {
|
|
LoginError("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);
|
|
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();
|
|
}
|
|
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();
|
|
}
|
|
}
|
|
|
|
session_id_.clear();
|
|
|
|
QSettings s;
|
|
s.beginGroup(TidalSettingsPage::kSettingsGroup);
|
|
s.setValue("access_token", access_token_);
|
|
s.setValue("refresh_token", refresh_token_);
|
|
s.setValue("expires_in", expires_in_);
|
|
s.setValue("login_time", login_time_);
|
|
s.setValue("country_code", country_code_);
|
|
s.setValue("user_id", user_id_);
|
|
s.remove("session_id");
|
|
s.endGroup();
|
|
|
|
if (expires_in_ > 0) {
|
|
timer_refresh_login_->setInterval(static_cast<int>(expires_in_ * kMsecPerSec));
|
|
timer_refresh_login_->start();
|
|
}
|
|
|
|
qLog(Debug) << "Tidal: Login successful" << "user id" << user_id_;
|
|
|
|
emit LoginComplete(true);
|
|
emit LoginSuccess();
|
|
|
|
}
|
|
|
|
void TidalService::SendLogin() {
|
|
SendLoginWithCredentials(api_token_, username_, password_);
|
|
}
|
|
|
|
void TidalService::SendLoginWithCredentials(const QString &api_token, const QString &username, const QString &password) {
|
|
|
|
login_sent_ = true;
|
|
++login_attempts_;
|
|
timer_login_attempt_->start();
|
|
timer_refresh_login_->stop();
|
|
|
|
const ParamList params = ParamList() << Param("token", (api_token.isEmpty() ? api_token_ : api_token))
|
|
<< Param("username", username)
|
|
<< Param("password", password)
|
|
<< Param("clientVersion", "2.2.1--7");
|
|
|
|
QUrlQuery url_query;
|
|
for (const Param ¶m : params) {
|
|
url_query.addQueryItem(QUrl::toPercentEncoding(param.first), QUrl::toPercentEncoding(param.second));
|
|
}
|
|
|
|
QUrl url(kAuthUrl);
|
|
QNetworkRequest req(url);
|
|
|
|
req.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
|
|
req.setRawHeader("X-Tidal-Token", (api_token.isEmpty() ? api_token_.toUtf8() : api_token.toUtf8()));
|
|
|
|
QByteArray query = url_query.toString(QUrl::FullyEncoded).toUtf8();
|
|
QNetworkReply *reply = network_->post(req, query);
|
|
QObject::connect(reply, &QNetworkReply::sslErrors, this, &TidalService::HandleLoginSSLErrors);
|
|
QObject::connect(reply, &QNetworkReply::finished, this, [this, reply]() { HandleAuthReply(reply); });
|
|
replies_ << reply;
|
|
|
|
//qLog(Debug) << "Tidal: Sending request" << url << query;
|
|
|
|
}
|
|
|
|
void TidalService::HandleAuthReply(QNetworkReply *reply) {
|
|
|
|
if (!replies_.contains(reply)) return;
|
|
replies_.removeAll(reply);
|
|
QObject::disconnect(reply, nullptr, this, nullptr);
|
|
reply->deleteLater();
|
|
|
|
login_sent_ = false;
|
|
|
|
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()));
|
|
login_errors_.clear();
|
|
return;
|
|
}
|
|
else {
|
|
// See if there is Json data containing "status" and "userMessage" - then use that instead.
|
|
QByteArray data(reply->readAll());
|
|
QJsonParseError json_error;
|
|
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 (login_errors_.isEmpty()) {
|
|
if (reply->error() != QNetworkReply::NoError) {
|
|
login_errors_ << QString("%1 (%2)").arg(reply->errorString()).arg(reply->error());
|
|
}
|
|
else {
|
|
login_errors_ << QString("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt());
|
|
}
|
|
}
|
|
LoginError();
|
|
login_errors_.clear();
|
|
return;
|
|
}
|
|
}
|
|
|
|
login_errors_.clear();
|
|
|
|
QByteArray data(reply->readAll());
|
|
QJsonParseError json_error;
|
|
QJsonDocument json_doc = QJsonDocument::fromJson(data, &json_error);
|
|
|
|
if (json_error.error != QJsonParseError::NoError) {
|
|
LoginError("Authentication reply from server missing Json data.");
|
|
return;
|
|
}
|
|
|
|
if (json_doc.isEmpty()) {
|
|
LoginError("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);
|
|
return;
|
|
}
|
|
|
|
QJsonObject json_obj = json_doc.object();
|
|
if (json_obj.isEmpty()) {
|
|
LoginError("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);
|
|
return;
|
|
}
|
|
|
|
country_code_ = json_obj["countryCode"].toString();
|
|
session_id_ = json_obj["sessionId"].toString();
|
|
user_id_ = json_obj["userId"].toInt();
|
|
access_token_.clear();
|
|
refresh_token_.clear();
|
|
|
|
QSettings s;
|
|
s.beginGroup(TidalSettingsPage::kSettingsGroup);
|
|
s.remove("access_token");
|
|
s.remove("refresh_token");
|
|
s.remove("expires_in");
|
|
s.remove("login_time");
|
|
s.setValue("user_id", user_id_);
|
|
s.setValue("session_id", session_id_);
|
|
s.setValue("country_code", country_code_);
|
|
s.endGroup();
|
|
|
|
qLog(Debug) << "Tidal: Login successful" << "user id" << user_id_ << "session id" << session_id_ << "country code" << country_code_;
|
|
|
|
login_attempts_ = 0;
|
|
timer_login_attempt_->stop();
|
|
|
|
emit LoginComplete(true);
|
|
emit LoginSuccess();
|
|
|
|
}
|
|
|
|
void TidalService::Logout() {
|
|
|
|
user_id_ = 0;
|
|
country_code_.clear();
|
|
access_token_.clear();
|
|
session_id_.clear();
|
|
expires_in_ = 0;
|
|
login_time_ = 0;
|
|
|
|
QSettings s;
|
|
s.beginGroup(TidalSettingsPage::kSettingsGroup);
|
|
s.remove("user_id");
|
|
s.remove("country_code");
|
|
s.remove("access_token");
|
|
s.remove("session_id");
|
|
s.remove("expires_in");
|
|
s.remove("login_time");
|
|
s.endGroup();
|
|
|
|
timer_refresh_login_->stop();
|
|
|
|
}
|
|
|
|
void TidalService::ResetLoginAttempts() {
|
|
login_attempts_ = 0;
|
|
}
|
|
|
|
void TidalService::TryLogin() {
|
|
|
|
if (authenticated() || login_sent_) return;
|
|
|
|
if (api_token_.isEmpty()) {
|
|
emit LoginComplete(false, tr("Missing Tidal API token."));
|
|
return;
|
|
}
|
|
if (username_.isEmpty()) {
|
|
emit LoginComplete(false, tr("Missing Tidal username."));
|
|
return;
|
|
}
|
|
if (password_.isEmpty()) {
|
|
emit LoginComplete(false, tr("Missing Tidal password."));
|
|
return;
|
|
}
|
|
if (login_attempts_ >= kLoginAttempts) {
|
|
emit LoginComplete(false, tr("Not authenticated with Tidal and reached maximum number of login attempts."));
|
|
return;
|
|
}
|
|
|
|
emit RequestLogin();
|
|
|
|
}
|
|
|
|
void TidalService::ResetArtistsRequest() {
|
|
|
|
if (artists_request_) {
|
|
QObject::disconnect(artists_request_.get(), nullptr, this, nullptr);
|
|
QObject::disconnect(this, nullptr, artists_request_.get(), nullptr);
|
|
artists_request_.reset();
|
|
}
|
|
|
|
}
|
|
|
|
void TidalService::GetArtists() {
|
|
|
|
if (!authenticated()) {
|
|
if (oauth_) {
|
|
emit ArtistsResults(SongMap(), tr("Not authenticated with Tidal."));
|
|
ShowConfig();
|
|
return;
|
|
}
|
|
else if (api_token_.isEmpty() || username_.isEmpty() || password_.isEmpty()) {
|
|
emit ArtistsResults(SongMap(), tr("Missing Tidal API token, username or password."));
|
|
ShowConfig();
|
|
return;
|
|
}
|
|
}
|
|
|
|
ResetArtistsRequest();
|
|
artists_request_.reset(new TidalRequest(this, url_handler_, app_, network_, TidalBaseRequest::QueryType::Artists, this), [](TidalRequest *request) { request->deleteLater(); });
|
|
QObject::connect(artists_request_.get(), &TidalRequest::RequestLogin, this, &TidalService::SendLogin);
|
|
QObject::connect(artists_request_.get(), &TidalRequest::Results, this, &TidalService::ArtistsResultsReceived);
|
|
QObject::connect(artists_request_.get(), &TidalRequest::UpdateStatus, this, &TidalService::ArtistsUpdateStatusReceived);
|
|
QObject::connect(artists_request_.get(), &TidalRequest::UpdateProgress, this, &TidalService::ArtistsUpdateProgressReceived);
|
|
QObject::connect(this, &TidalService::LoginComplete, artists_request_.get(), &TidalRequest::LoginComplete);
|
|
|
|
artists_request_->Process();
|
|
|
|
}
|
|
|
|
void TidalService::ArtistsResultsReceived(const int id, const SongMap &songs, const QString &error) {
|
|
|
|
Q_UNUSED(id);
|
|
emit ArtistsResults(songs, error);
|
|
ResetArtistsRequest();
|
|
|
|
}
|
|
|
|
void TidalService::ArtistsUpdateStatusReceived(const int id, const QString &text) {
|
|
Q_UNUSED(id);
|
|
emit ArtistsUpdateStatus(text);
|
|
}
|
|
|
|
void TidalService::ArtistsUpdateProgressReceived(const int id, const int progress) {
|
|
Q_UNUSED(id);
|
|
emit ArtistsUpdateProgress(progress);
|
|
}
|
|
|
|
void TidalService::ResetAlbumsRequest() {
|
|
|
|
if (albums_request_) {
|
|
QObject::disconnect(albums_request_.get(), nullptr, this, nullptr);
|
|
QObject::disconnect(this, nullptr, albums_request_.get(), nullptr);
|
|
albums_request_.reset();
|
|
}
|
|
|
|
}
|
|
|
|
void TidalService::GetAlbums() {
|
|
|
|
if (!authenticated()) {
|
|
if (oauth_) {
|
|
emit AlbumsResults(SongMap(), tr("Not authenticated with Tidal."));
|
|
ShowConfig();
|
|
return;
|
|
}
|
|
else if (api_token_.isEmpty() || username_.isEmpty() || password_.isEmpty()) {
|
|
emit AlbumsResults(SongMap(), tr("Missing Tidal API token, username or password."));
|
|
ShowConfig();
|
|
return;
|
|
}
|
|
}
|
|
|
|
ResetAlbumsRequest();
|
|
albums_request_.reset(new TidalRequest(this, url_handler_, app_, network_, TidalBaseRequest::QueryType::Albums, this), [](TidalRequest *request) { request->deleteLater(); });
|
|
QObject::connect(albums_request_.get(), &TidalRequest::RequestLogin, this, &TidalService::SendLogin);
|
|
QObject::connect(albums_request_.get(), &TidalRequest::Results, this, &TidalService::AlbumsResultsReceived);
|
|
QObject::connect(albums_request_.get(), &TidalRequest::UpdateStatus, this, &TidalService::AlbumsUpdateStatusReceived);
|
|
QObject::connect(albums_request_.get(), &TidalRequest::UpdateProgress, this, &TidalService::AlbumsUpdateProgressReceived);
|
|
QObject::connect(this, &TidalService::LoginComplete, albums_request_.get(), &TidalRequest::LoginComplete);
|
|
|
|
albums_request_->Process();
|
|
|
|
}
|
|
|
|
void TidalService::AlbumsResultsReceived(const int id, const SongMap &songs, const QString &error) {
|
|
|
|
Q_UNUSED(id);
|
|
emit AlbumsResults(songs, error);
|
|
ResetAlbumsRequest();
|
|
|
|
}
|
|
|
|
void TidalService::AlbumsUpdateStatusReceived(const int id, const QString &text) {
|
|
Q_UNUSED(id);
|
|
emit AlbumsUpdateStatus(text);
|
|
}
|
|
|
|
void TidalService::AlbumsUpdateProgressReceived(const int id, const int progress) {
|
|
Q_UNUSED(id);
|
|
emit AlbumsUpdateProgress(progress);
|
|
}
|
|
|
|
void TidalService::ResetSongsRequest() {
|
|
|
|
if (songs_request_) {
|
|
QObject::disconnect(songs_request_.get(), nullptr, this, nullptr);
|
|
QObject::disconnect(this, nullptr, songs_request_.get(), nullptr);
|
|
songs_request_.reset();
|
|
}
|
|
|
|
}
|
|
|
|
void TidalService::GetSongs() {
|
|
|
|
if (!authenticated()) {
|
|
if (oauth_) {
|
|
emit SongsResults(SongMap(), tr("Not authenticated with Tidal."));
|
|
ShowConfig();
|
|
return;
|
|
}
|
|
else if (api_token_.isEmpty() || username_.isEmpty() || password_.isEmpty()) {
|
|
emit SongsResults(SongMap(), tr("Missing Tidal API token, username or password."));
|
|
ShowConfig();
|
|
return;
|
|
}
|
|
}
|
|
|
|
ResetSongsRequest();
|
|
songs_request_.reset(new TidalRequest(this, url_handler_, app_, network_, TidalBaseRequest::QueryType::Songs, this), [](TidalRequest *request) { request->deleteLater(); });
|
|
QObject::connect(songs_request_.get(), &TidalRequest::RequestLogin, this, &TidalService::SendLogin);
|
|
QObject::connect(songs_request_.get(), &TidalRequest::Results, this, &TidalService::SongsResultsReceived);
|
|
QObject::connect(songs_request_.get(), &TidalRequest::UpdateStatus, this, &TidalService::SongsUpdateStatusReceived);
|
|
QObject::connect(songs_request_.get(), &TidalRequest::UpdateProgress, this, &TidalService::SongsUpdateProgressReceived);
|
|
QObject::connect(this, &TidalService::LoginComplete, songs_request_.get(), &TidalRequest::LoginComplete);
|
|
|
|
songs_request_->Process();
|
|
|
|
}
|
|
|
|
void TidalService::SongsResultsReceived(const int id, const SongMap &songs, const QString &error) {
|
|
|
|
Q_UNUSED(id);
|
|
emit SongsResults(songs, error);
|
|
ResetSongsRequest();
|
|
|
|
}
|
|
|
|
void TidalService::SongsUpdateStatusReceived(const int id, const QString &text) {
|
|
Q_UNUSED(id);
|
|
emit SongsUpdateStatus(text);
|
|
}
|
|
|
|
void TidalService::SongsUpdateProgressReceived(const int id, const int progress) {
|
|
Q_UNUSED(id);
|
|
emit SongsUpdateProgress(progress);
|
|
}
|
|
|
|
int TidalService::Search(const QString &text, InternetSearchView::SearchType type) {
|
|
|
|
pending_search_id_ = next_pending_search_id_;
|
|
pending_search_text_ = text;
|
|
pending_search_type_ = type;
|
|
|
|
next_pending_search_id_++;
|
|
|
|
if (text.isEmpty()) {
|
|
timer_search_delay_->stop();
|
|
return pending_search_id_;
|
|
}
|
|
timer_search_delay_->start();
|
|
|
|
return pending_search_id_;
|
|
|
|
}
|
|
|
|
void TidalService::StartSearch() {
|
|
|
|
if (!authenticated()) {
|
|
if (oauth_) {
|
|
emit SearchResults(pending_search_id_, SongMap(), tr("Not authenticated with Tidal."));
|
|
ShowConfig();
|
|
return;
|
|
}
|
|
else if (api_token_.isEmpty() || username_.isEmpty() || password_.isEmpty()) {
|
|
emit SearchResults(pending_search_id_, SongMap(), tr("Missing Tidal API token, username or password."));
|
|
ShowConfig();
|
|
return;
|
|
}
|
|
}
|
|
|
|
search_id_ = pending_search_id_;
|
|
search_text_ = pending_search_text_;
|
|
|
|
SendSearch();
|
|
|
|
}
|
|
|
|
void TidalService::CancelSearch() {
|
|
}
|
|
|
|
void TidalService::SendSearch() {
|
|
|
|
TidalBaseRequest::QueryType query_type = TidalBaseRequest::QueryType::None;
|
|
|
|
switch (pending_search_type_) {
|
|
case InternetSearchView::SearchType::Artists:
|
|
query_type = TidalBaseRequest::QueryType::SearchArtists;
|
|
break;
|
|
case InternetSearchView::SearchType::Albums:
|
|
query_type = TidalBaseRequest::QueryType::SearchAlbums;
|
|
break;
|
|
case InternetSearchView::SearchType::Songs:
|
|
query_type = TidalBaseRequest::QueryType::SearchSongs;
|
|
break;
|
|
default:
|
|
//Error("Invalid search type.");
|
|
return;
|
|
}
|
|
|
|
search_request_.reset(new TidalRequest(this, url_handler_, app_, network_, query_type, this), [](TidalRequest *request) { request->deleteLater(); });
|
|
|
|
QObject::connect(search_request_.get(), &TidalRequest::RequestLogin, this, &TidalService::SendLogin);
|
|
QObject::connect(search_request_.get(), &TidalRequest::Results, this, &TidalService::SearchResultsReceived);
|
|
QObject::connect(search_request_.get(), &TidalRequest::UpdateStatus, this, &TidalService::SearchUpdateStatus);
|
|
QObject::connect(search_request_.get(), &TidalRequest::UpdateProgress, this, &TidalService::SearchUpdateProgress);
|
|
QObject::connect(this, &TidalService::LoginComplete, search_request_.get(), &TidalRequest::LoginComplete);
|
|
|
|
search_request_->Search(search_id_, search_text_);
|
|
search_request_->Process();
|
|
|
|
}
|
|
|
|
void TidalService::SearchResultsReceived(const int id, const SongMap &songs, const QString &error) {
|
|
|
|
emit SearchResults(id, songs, error);
|
|
search_request_.reset();
|
|
|
|
}
|
|
|
|
uint TidalService::GetStreamURL(const QUrl &url, QString &error) {
|
|
|
|
if (!authenticated()) {
|
|
if (oauth_) {
|
|
error = tr("Not authenticated with Tidal.");
|
|
return 0;
|
|
}
|
|
else if (api_token_.isEmpty() || username_.isEmpty() || password_.isEmpty()) {
|
|
error = tr("Missing Tidal API token, username or password.");
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
uint id = 0;
|
|
while (id == 0) id = ++next_stream_url_request_id_;
|
|
std::shared_ptr<TidalStreamURLRequest> stream_url_req;
|
|
stream_url_req.reset(new TidalStreamURLRequest(this, network_, url, id), [](TidalStreamURLRequest *request) { request->deleteLater(); });
|
|
stream_url_requests_.insert(id, stream_url_req);
|
|
|
|
QObject::connect(stream_url_req.get(), &TidalStreamURLRequest::TryLogin, this, &TidalService::TryLogin);
|
|
QObject::connect(stream_url_req.get(), &TidalStreamURLRequest::StreamURLFailure, this, &TidalService::HandleStreamURLFailure);
|
|
QObject::connect(stream_url_req.get(), &TidalStreamURLRequest::StreamURLSuccess, this, &TidalService::HandleStreamURLSuccess);
|
|
QObject::connect(this, &TidalService::LoginComplete, stream_url_req.get(), &TidalStreamURLRequest::LoginComplete);
|
|
|
|
stream_url_req->Process();
|
|
|
|
return id;
|
|
|
|
}
|
|
|
|
void TidalService::HandleStreamURLFailure(const uint id, const QUrl &original_url, const QString &error) {
|
|
|
|
if (!stream_url_requests_.contains(id)) return;
|
|
stream_url_requests_.remove(id);
|
|
|
|
emit StreamURLFailure(id, original_url, error);
|
|
|
|
}
|
|
|
|
void TidalService::HandleStreamURLSuccess(const uint id, const QUrl &original_url, const QUrl &stream_url, const Song::FileType filetype, const int samplerate, const int bit_depth, const qint64 duration) {
|
|
|
|
if (!stream_url_requests_.contains(id)) return;
|
|
stream_url_requests_.remove(id);
|
|
|
|
emit StreamURLSuccess(id, original_url, stream_url, filetype, samplerate, bit_depth, duration);
|
|
|
|
}
|
|
|
|
void TidalService::LoginError(const QString &error, const QVariant &debug) {
|
|
|
|
if (!error.isEmpty()) login_errors_ << error;
|
|
|
|
QString error_html;
|
|
for (const QString &e : login_errors_) {
|
|
qLog(Error) << "Tidal:" << e;
|
|
error_html += e + "<br />";
|
|
}
|
|
if (debug.isValid()) qLog(Debug) << debug;
|
|
|
|
emit LoginFailure(error_html);
|
|
emit LoginComplete(false, error_html);
|
|
|
|
login_errors_.clear();
|
|
|
|
}
|