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

Change to const references, make search progress and status pass search id

Browse Source
This commit is contained in:
Jonas Kvinge
2019-06-20 16:33:28 +02:00
parent 9d222e2c57
commit bf4001968e
22 changed files with 499 additions and 482 deletions
Download Patch File Download Diff File Expand all files Collapse all files

67
src/internet/internetsearch.cpp
View File

@@ -61,14 +61,13 @@ InternetSearch::InternetSearch(Application *app, Song::Source source, QObject *p
cover_loader_options_.pad_output_image_ = true; cover_loader_options_.pad_output_image_ = true;
cover_loader_options_.scale_output_image_ = true; cover_loader_options_.scale_output_image_ = true;
connect(app_->album_cover_loader(), SIGNAL(ImageLoaded(quint64, QImage)), SLOT(AlbumArtLoaded(quint64, QImage))); connect(app_->album_cover_loader(), SIGNAL(ImageLoaded(quint64, QImage)), SLOT(AlbumArtLoaded(const quint64, const QImage&)));
connect(this, SIGNAL(SearchAsyncSig(int, QString, SearchType)), this, SLOT(DoSearchAsync(int, QString, SearchType))); connect(this, SIGNAL(SearchAsyncSig(const int, const QString&, const SearchType)), this, SLOT(DoSearchAsync(const int, const QString&, const SearchType)));
connect(service_, SIGNAL(SearchUpdateStatus(QString)), SLOT(UpdateStatusSlot(QString))); connect(service_, SIGNAL(SearchUpdateStatus(const int, const QString&)), SLOT(UpdateStatusSlot(const int, const QString&)));
connect(service_, SIGNAL(SearchProgressSetMaximum(int)), SLOT(ProgressSetMaximumSlot(int))); connect(service_, SIGNAL(SearchProgressSetMaximum(const int, const int)), SLOT(ProgressSetMaximumSlot(const int, const int)));
connect(service_, SIGNAL(SearchUpdateProgress(int)), SLOT(UpdateProgressSlot(int))); connect(service_, SIGNAL(SearchUpdateProgress(const int, const int)), SLOT(UpdateProgressSlot(const int, const int)));
connect(service_, SIGNAL(SearchResults(int, SongList)), SLOT(SearchDone(int, SongList))); connect(service_, SIGNAL(SearchResults(const int, const SongList&, const QString&)), SLOT(SearchDone(const int, const SongList&, const QString&)));
connect(service_, SIGNAL(SearchError(int, QString)), SLOT(HandleError(int, QString)));
} }
@@ -105,7 +104,7 @@ bool InternetSearch::Matches(const QStringList &tokens, const QString &string) {
} }
int InternetSearch::SearchAsync(const QString &query, SearchType type) { int InternetSearch::SearchAsync(const QString &query, const SearchType type) {
const int id = searches_next_id_++; const int id = searches_next_id_++;
@@ -115,14 +114,14 @@ int InternetSearch::SearchAsync(const QString &query, SearchType type) {
} }
void InternetSearch::SearchAsync(int id, const QString &query, SearchType type) { void InternetSearch::SearchAsync(const int id, const QString &query, const SearchType type) {
const int service_id = service_->Search(query, type); const int service_id = service_->Search(query, type);
pending_searches_[service_id] = PendingState(id, TokenizeQuery(query)); pending_searches_[service_id] = PendingState(id, TokenizeQuery(query));
} }
void InternetSearch::DoSearchAsync(int id, const QString &query, SearchType type) { void InternetSearch::DoSearchAsync(const int id, const QString &query, const SearchType type) {
int timer_id = startTimer(kDelayedSearchTimeoutMs); int timer_id = startTimer(kDelayedSearchTimeoutMs);
delayed_searches_[timer_id].id_ = id; delayed_searches_[timer_id].id_ = id;
@@ -131,12 +130,19 @@ void InternetSearch::DoSearchAsync(int id, const QString &query, SearchType type
} }
void InternetSearch::SearchDone(int service_id, const SongList &songs) { void InternetSearch::SearchDone(const int service_id, const SongList &songs, const QString &error) {
if (!pending_searches_.contains(service_id)) return;
// Map back to the original id. // Map back to the original id.
const PendingState state = pending_searches_.take(service_id); const PendingState state = pending_searches_.take(service_id);
const int search_id = state.orig_id_; const int search_id = state.orig_id_;
if (songs.isEmpty()) {
emit SearchError(search_id, error);
return;
}
ResultList results; ResultList results;
for (const Song &song : songs) { for (const Song &song : songs) {
Result result; Result result;
@@ -157,13 +163,7 @@ void InternetSearch::SearchDone(int service_id, const SongList &songs) {
} }
void InternetSearch::HandleError(const int id, const QString error) { void InternetSearch::MaybeSearchFinished(const int id) {
emit SearchError(id, error);
}
void InternetSearch::MaybeSearchFinished(int id) {
if (pending_searches_.keys(PendingState(id, QStringList())).isEmpty()) { if (pending_searches_.keys(PendingState(id, QStringList())).isEmpty()) {
emit SearchFinished(id); emit SearchFinished(id);
@@ -171,7 +171,7 @@ void InternetSearch::MaybeSearchFinished(int id) {
} }
void InternetSearch::CancelSearch(int id) { void InternetSearch::CancelSearch(const int id) {
QMap<int, DelayedSearch>::iterator it; QMap<int, DelayedSearch>::iterator it;
for (it = delayed_searches_.begin(); it != delayed_searches_.end(); ++it) { for (it = delayed_searches_.begin(); it != delayed_searches_.end(); ++it) {
@@ -219,7 +219,7 @@ int InternetSearch::LoadArtAsync(const InternetSearch::Result &result) {
} }
void InternetSearch::AlbumArtLoaded(quint64 id, const QImage &image) { void InternetSearch::AlbumArtLoaded(const quint64 id, const QImage &image) {
if (!cover_loader_tasks_.contains(id)) return; if (!cover_loader_tasks_.contains(id)) return;
int orig_id = cover_loader_tasks_.take(id); int orig_id = cover_loader_tasks_.take(id);
@@ -289,14 +289,29 @@ MimeData *InternetSearch::LoadTracks(const ResultList &results) {
} }
void InternetSearch::UpdateStatusSlot(QString text) { void InternetSearch::UpdateStatusSlot(const int service_id, const QString &text) {
emit UpdateStatus(text);
if (!pending_searches_.contains(service_id)) return;
const PendingState state = pending_searches_[service_id];
const int search_id = state.orig_id_;
emit UpdateStatus(search_id, text);
} }
void InternetSearch::ProgressSetMaximumSlot(int max) { void InternetSearch::ProgressSetMaximumSlot(const int service_id, const int max) {
emit ProgressSetMaximum(max);
if (!pending_searches_.contains(service_id)) return;
const PendingState state = pending_searches_[service_id];
const int search_id = state.orig_id_;
emit ProgressSetMaximum(search_id, max);
} }
void InternetSearch::UpdateProgressSlot(int progress) { void InternetSearch::UpdateProgressSlot(const int service_id, const int progress) {
emit UpdateProgress(progress);
if (!pending_searches_.contains(service_id)) return;
const PendingState state = pending_searches_[service_id];
const int search_id = state.orig_id_;
emit UpdateProgress(search_id, progress);
} }

40
src/internet/internetsearch.h
View File

@@ -69,24 +69,24 @@ class InternetSearch : public QObject {
int SearchAsync(const QString &query, SearchType type); int SearchAsync(const QString &query, SearchType type);
int LoadArtAsync(const InternetSearch::Result &result); int LoadArtAsync(const InternetSearch::Result &result);
void CancelSearch(int id); void CancelSearch(const int id);
void CancelArt(int id); void CancelArt(const int id);
// Loads tracks for results that were previously emitted by ResultsAvailable. // Loads tracks for results that were previously emitted by ResultsAvailable.
// The implementation creates a SongMimeData with one Song for each Result. // The implementation creates a SongMimeData with one Song for each Result.
MimeData *LoadTracks(const ResultList &results); MimeData *LoadTracks(const ResultList &results);
signals: signals:
void SearchAsyncSig(int id, const QString &query, SearchType type); void SearchAsyncSig(const int id, const QString &query, const SearchType type);
void ResultsAvailable(int id, const InternetSearch::ResultList &results); void ResultsAvailable(const int id, const InternetSearch::ResultList &results);
void AddResults(int id, const InternetSearch::ResultList &results); void AddResults(const int id, const InternetSearch::ResultList &results);
void SearchError(const int id, const QString error); void SearchError(const int id, const QString &error);
void SearchFinished(int id); void SearchFinished(const int id);
void UpdateStatus(QString text); void UpdateStatus(const int id, const QString &text);
void ProgressSetMaximum(int progress); void ProgressSetMaximum(const int id, const int progress);
void UpdateProgress(int max); void UpdateProgress(const int id, const int max);
void ArtLoaded(int id, const QPixmap &pixmap); void ArtLoaded(const int id, const QPixmap &pixmap);
protected: protected:
@@ -114,22 +114,20 @@ class InternetSearch : public QObject {
static bool Matches(const QStringList &tokens, const QString &string); static bool Matches(const QStringList &tokens, const QString &string);
private slots: private slots:
void DoSearchAsync(int id, const QString &query, SearchType type); void DoSearchAsync(const int id, const QString &query, const SearchType type);
void SearchDone(int id, const SongList &songs); void SearchDone(const int service_id, const SongList &songs, const QString &error);
void HandleError(const int id, const QString error);
void AlbumArtLoaded(quint64 id, const QImage &image); void AlbumArtLoaded(const quint64 id, const QImage &image);
void UpdateStatusSlot(QString text); void UpdateStatusSlot(const int id, const QString &text);
void ProgressSetMaximumSlot(int progress); void ProgressSetMaximumSlot(const int id, const int progress);
void UpdateProgressSlot(int max); void UpdateProgressSlot(const int id, const int max);
private: private:
void SearchAsync(int id, const QString &query, SearchType type); void SearchAsync(const int id, const QString &query, const SearchType type);
void HandleLoadedArt(int id, const QImage &image);
bool FindCachedPixmap(const InternetSearch::Result &result, QPixmap *pixmap) const; bool FindCachedPixmap(const InternetSearch::Result &result, QPixmap *pixmap) const;
QString PixmapCacheKey(const InternetSearch::Result &result) const; QString PixmapCacheKey(const InternetSearch::Result &result) const;
void MaybeSearchFinished(int id); void MaybeSearchFinished(const int id);
void ShowConfig() {} void ShowConfig() {}
static QImage ScaleAndPad(const QImage &image); static QImage ScaleAndPad(const QImage &image);

34
src/internet/internetsearchview.cpp
View File

@@ -110,7 +110,7 @@ InternetSearchView::InternetSearchView(QWidget *parent)
InternetSearchView::~InternetSearchView() { delete ui_; } InternetSearchView::~InternetSearchView() { delete ui_; }
void InternetSearchView::Init(Application *app, InternetSearch *engine, QString settings_group, SettingsDialog::Page settings_page, const bool artists, const bool albums, const bool songs) { void InternetSearchView::Init(Application *app, InternetSearch *engine, const QString &settings_group, const SettingsDialog::Page settings_page, const bool artists, const bool albums, const bool songs) {
app_ = app; app_ = app;
engine_ = engine; engine_ = engine;
@@ -167,13 +167,13 @@ void InternetSearchView::Init(Application *app, InternetSearch *engine, QString
// These have to be queued connections because they may get emitted before our call to Search() (or whatever) returns and we add the ID to the map. // These have to be queued connections because they may get emitted before our call to Search() (or whatever) returns and we add the ID to the map.
connect(engine_, SIGNAL(UpdateStatus(QString)), SLOT(UpdateStatus(QString))); connect(engine_, SIGNAL(UpdateStatus(const int, const QString&)), SLOT(UpdateStatus(const int, const QString&)));
connect(engine_, SIGNAL(ProgressSetMaximum(int)), SLOT(ProgressSetMaximum(int)), Qt::QueuedConnection); connect(engine_, SIGNAL(ProgressSetMaximum(const int, const int)), SLOT(ProgressSetMaximum(const int, const int)), Qt::QueuedConnection);
connect(engine_, SIGNAL(UpdateProgress(int)), SLOT(UpdateProgress(int)), Qt::QueuedConnection); connect(engine_, SIGNAL(UpdateProgress(const int, const int)), SLOT(UpdateProgress(const int, const int)), Qt::QueuedConnection);
connect(engine_, SIGNAL(AddResults(int, InternetSearch::ResultList)), SLOT(AddResults(int, InternetSearch::ResultList)), Qt::QueuedConnection); connect(engine_, SIGNAL(AddResults(const int, InternetSearch::ResultList)), SLOT(AddResults(const int, const InternetSearch::ResultList)), Qt::QueuedConnection);
connect(engine_, SIGNAL(SearchError(int, QString)), SLOT(SearchError(int, QString)), Qt::QueuedConnection); connect(engine_, SIGNAL(SearchError(const int, const QString&)), SLOT(SearchError(const int, const QString&)), Qt::QueuedConnection);
connect(engine_, SIGNAL(ArtLoaded(int, QPixmap)), SLOT(ArtLoaded(int, QPixmap)), Qt::QueuedConnection); connect(engine_, SIGNAL(ArtLoaded(const int, const QPixmap&)), SLOT(ArtLoaded(const int, const QPixmap&)), Qt::QueuedConnection);
ReloadSettings(); ReloadSettings();
@@ -253,7 +253,7 @@ void InternetSearchView::TextEdited(const QString &text) {
} }
void InternetSearchView::AddResults(int id, const InternetSearch::ResultList &results) { void InternetSearchView::AddResults(const int id, const InternetSearch::ResultList &results) {
if (id != last_search_id_) return; if (id != last_search_id_) return;
if (results.isEmpty()) return; if (results.isEmpty()) return;
@@ -264,8 +264,9 @@ void InternetSearchView::AddResults(int id, const InternetSearch::ResultList &re
} }
void InternetSearchView::SearchError(const int id, const QString error) { void InternetSearchView::SearchError(const int id, const QString &error) {
if (id != last_search_id_) return;
error_ = true; error_ = true;
ui_->label_helptext->setText(error); ui_->label_helptext->setText(error);
ui_->label_status->clear(); ui_->label_status->clear();
@@ -594,17 +595,26 @@ void InternetSearchView::SetSearchType(InternetSearch::SearchType type) {
TextEdited(ui_->search->text()); TextEdited(ui_->search->text());
} }
void InternetSearchView::UpdateStatus(QString text) { void InternetSearchView::UpdateStatus(const int id, const QString &text) {
if (id != last_search_id_) return;
ui_->progressbar->show(); ui_->progressbar->show();
ui_->label_status->setText(text); ui_->label_status->setText(text);
} }
void InternetSearchView::ProgressSetMaximum(int max) { void InternetSearchView::ProgressSetMaximum(const int id, const int max) {
if (id != last_search_id_) return;
ui_->progressbar->setMaximum(max); ui_->progressbar->setMaximum(max);
} }
void InternetSearchView::UpdateProgress(int progress) { void InternetSearchView::UpdateProgress(const int id, const int progress) {
if (id != last_search_id_) return;
ui_->progressbar->setValue(progress); ui_->progressbar->setValue(progress);
} }
void InternetSearchView::AddArtists() { void InternetSearchView::AddArtists() {

14
src/internet/internetsearchview.h
View File

@@ -59,7 +59,7 @@ class InternetSearchView : public QWidget {
InternetSearchView(QWidget *parent = nullptr); InternetSearchView(QWidget *parent = nullptr);
~InternetSearchView(); ~InternetSearchView();
void Init(Application *app, InternetSearch *engine, QString settings_group, SettingsDialog::Page settings_page, const bool artists = false, const bool albums = false, const bool songs = false); void Init(Application *app, InternetSearch *engine, const QString &settings_group, const SettingsDialog::Page settings_page, const bool artists = false, const bool albums = false, const bool songs = false);
static const int kSwapModelsTimeoutMsec; static const int kSwapModelsTimeoutMsec;
@@ -84,12 +84,12 @@ class InternetSearchView : public QWidget {
private slots: private slots:
void SwapModels(); void SwapModels();
void TextEdited(const QString &text); void TextEdited(const QString &text);
void UpdateStatus(QString text); void UpdateStatus(const int id, const QString &text);
void ProgressSetMaximum(int progress); void ProgressSetMaximum(const int id, const int progress);
void UpdateProgress(int max); void UpdateProgress(const int id, const int max);
void AddResults(int id, const InternetSearch::ResultList &results); void AddResults(const int id, const InternetSearch::ResultList &results);
void SearchError(const int id, const QString error); void SearchError(const int id, const QString &error);
void ArtLoaded(int id, const QPixmap &pixmap); void ArtLoaded(const int id, const QPixmap &pixmap);
void FocusOnFilter(QKeyEvent *event); void FocusOnFilter(QKeyEvent *event);

46
src/internet/internetservice.h
View File

@@ -87,35 +87,31 @@ class InternetService : public QObject {
void TestFailure(QString failure_reason); void TestFailure(QString failure_reason);
void TestComplete(bool success, QString error = QString()); void TestComplete(bool success, QString error = QString());
void Error(QString message); void Error(const QString &error);
void Results(SongList songs); void Results(const SongList &songs, const QString &error);
void UpdateStatus(QString text); void UpdateStatus(const QString &text);
void ProgressSetMaximum(int max); void ProgressSetMaximum(const int max);
void UpdateProgress(int max); void UpdateProgress(const int max);
void ArtistsError(QString message); void ArtistsResults(const SongList &songs, const QString &error);
void ArtistsResults(SongList songs); void ArtistsUpdateStatus(const QString &text);
void ArtistsUpdateStatus(QString text); void ArtistsProgressSetMaximum(const int max);
void ArtistsProgressSetMaximum(int max); void ArtistsUpdateProgress(const int max);
void ArtistsUpdateProgress(int max);
void AlbumsError(QString message); void AlbumsResults(const SongList &songs, const QString &error);
void AlbumsResults(SongList songs); void AlbumsUpdateStatus(const QString &text);
void AlbumsUpdateStatus(QString text); void AlbumsProgressSetMaximum(const int max);
void AlbumsProgressSetMaximum(int max); void AlbumsUpdateProgress(const int max);
void AlbumsUpdateProgress(int max);
void SongsError(QString message); void SongsResults(const SongList &songs, const QString &error);
void SongsResults(SongList songs); void SongsUpdateStatus(const QString &text);
void SongsUpdateStatus(QString text); void SongsProgressSetMaximum(const int max);
void SongsProgressSetMaximum(int max); void SongsUpdateProgress(const int max);
void SongsUpdateProgress(int max);
void SearchResults(int id, SongList songs); void SearchResults(const int id, const SongList &songs, const QString &error);
void SearchError(int id, QString message); void SearchUpdateStatus(const int id, const QString &text);
void SearchUpdateStatus(QString text); void SearchProgressSetMaximum(const int id, const int max);
void SearchProgressSetMaximum(int max); void SearchUpdateProgress(const int id, const int max);
void SearchUpdateProgress(int max);
void AddArtists(const SongList& songs); void AddArtists(const SongList& songs);
void AddAlbums(const SongList& songs); void AddAlbums(const SongList& songs);

38
src/internet/internetsongsview.cpp
View File

@@ -57,11 +57,10 @@ InternetSongsView::InternetSongsView(Application *app, InternetService *service,
connect(ui_->refresh, SIGNAL(clicked()), SLOT(GetSongs())); connect(ui_->refresh, SIGNAL(clicked()), SLOT(GetSongs()));
connect(ui_->close, SIGNAL(clicked()), SLOT(AbortGetSongs())); connect(ui_->close, SIGNAL(clicked()), SLOT(AbortGetSongs()));
connect(ui_->abort, SIGNAL(clicked()), SLOT(AbortGetSongs())); connect(ui_->abort, SIGNAL(clicked()), SLOT(AbortGetSongs()));
connect(service_, SIGNAL(SongsResults(SongList)), SLOT(SongsFinished(SongList))); connect(service_, SIGNAL(SongsResults(const SongList&, const QString&)), SLOT(SongsFinished(const SongList&, const QString&)));
connect(service_, SIGNAL(SongsError(QString)), SLOT(SongsError(QString))); connect(service_, SIGNAL(SongsUpdateStatus(const QString&)), ui_->status, SLOT(setText(const QString&)));
connect(service_, SIGNAL(SongsUpdateStatus(QString)), ui_->status, SLOT(setText(QString))); connect(service_, SIGNAL(SongsProgressSetMaximum(const int)), ui_->progressbar, SLOT(setMaximum(const int)));
connect(service_, SIGNAL(SongsProgressSetMaximum(int)), ui_->progressbar, SLOT(setMaximum(int))); connect(service_, SIGNAL(SongsUpdateProgress(const int)), ui_->progressbar, SLOT(setValue(const int)));
connect(service_, SIGNAL(SongsUpdateProgress(int)), ui_->progressbar, SLOT(setValue(int)));
connect(service_->songs_collection_model(), SIGNAL(TotalArtistCountUpdated(int)), ui_->view, SLOT(TotalArtistCountUpdated(int))); connect(service_->songs_collection_model(), SIGNAL(TotalArtistCountUpdated(int)), ui_->view, SLOT(TotalArtistCountUpdated(int)));
connect(service_->songs_collection_model(), SIGNAL(TotalAlbumCountUpdated(int)), ui_->view, SLOT(TotalAlbumCountUpdated(int))); connect(service_->songs_collection_model(), SIGNAL(TotalAlbumCountUpdated(int)), ui_->view, SLOT(TotalAlbumCountUpdated(int)));
@@ -104,21 +103,20 @@ void InternetSongsView::AbortGetSongs() {
} }
void InternetSongsView::SongsError(QString error) { void InternetSongsView::SongsFinished(const SongList &songs, const QString &error) {
ui_->status->setText(error); if (songs.isEmpty() && !error.isEmpty()) {
ui_->progressbar->setValue(0); ui_->status->setText(error);
ui_->progressbar->hide(); ui_->progressbar->setValue(0);
ui_->abort->hide(); ui_->progressbar->hide();
ui_->close->show(); ui_->abort->hide();
ui_->close->show();
} }
else {
void InternetSongsView::SongsFinished(SongList songs) { service_->songs_collection_backend()->DeleteAll();
ui_->stacked->setCurrentWidget(ui_->internetcollection_page);
service_->songs_collection_backend()->DeleteAll(); ui_->status->clear();
ui_->stacked->setCurrentWidget(ui_->internetcollection_page); service_->songs_collection_backend()->AddOrUpdateSongs(songs);
ui_->status->clear(); }
service_->songs_collection_backend()->AddOrUpdateSongs(songs);
} }

3
src/internet/internetsongsview.h
View File

@@ -52,8 +52,7 @@ class InternetSongsView : public QWidget {
void contextMenuEvent(QContextMenuEvent *e); void contextMenuEvent(QContextMenuEvent *e);
void GetSongs(); void GetSongs();
void AbortGetSongs();; void AbortGetSongs();;
void SongsError(QString error); void SongsFinished(const SongList &songs, const QString &error);
void SongsFinished(SongList songs);
private: private:
Application *app_; Application *app_;

114
src/internet/internettabsview.cpp
View File

@@ -65,11 +65,10 @@ InternetTabsView::InternetTabsView(Application *app, InternetService *service, I
connect(ui_->artists_collection->button_refresh(), SIGNAL(clicked()), SLOT(GetArtists())); connect(ui_->artists_collection->button_refresh(), SIGNAL(clicked()), SLOT(GetArtists()));
connect(ui_->artists_collection->button_close(), SIGNAL(clicked()), SLOT(AbortGetArtists())); connect(ui_->artists_collection->button_close(), SIGNAL(clicked()), SLOT(AbortGetArtists()));
connect(ui_->artists_collection->button_abort(), SIGNAL(clicked()), SLOT(AbortGetArtists())); connect(ui_->artists_collection->button_abort(), SIGNAL(clicked()), SLOT(AbortGetArtists()));
connect(service_, SIGNAL(ArtistsResults(SongList)), SLOT(ArtistsFinished(SongList))); connect(service_, SIGNAL(ArtistsResults(const SongList&, const QString&)), SLOT(ArtistsFinished(const SongList&, const QString&)));
connect(service_, SIGNAL(ArtistsError(QString)), SLOT(ArtistsError(QString))); connect(service_, SIGNAL(ArtistsUpdateStatus(const QString&)), ui_->artists_collection->status(), SLOT(setText(const QString&)));
connect(service_, SIGNAL(ArtistsUpdateStatus(QString)), ui_->artists_collection->status(), SLOT(setText(QString))); connect(service_, SIGNAL(ArtistsProgressSetMaximum(const int)), ui_->artists_collection->progressbar(), SLOT(setMaximum(const int)));
connect(service_, SIGNAL(ArtistsProgressSetMaximum(int)), ui_->artists_collection->progressbar(), SLOT(setMaximum(int))); connect(service_, SIGNAL(ArtistsUpdateProgress(const int)), ui_->artists_collection->progressbar(), SLOT(setValue(const int)));
connect(service_, SIGNAL(ArtistsUpdateProgress(int)), ui_->artists_collection->progressbar(), SLOT(setValue(int)));
connect(service_->artists_collection_model(), SIGNAL(TotalArtistCountUpdated(int)), ui_->artists_collection->view(), SLOT(TotalArtistCountUpdated(int))); connect(service_->artists_collection_model(), SIGNAL(TotalArtistCountUpdated(int)), ui_->artists_collection->view(), SLOT(TotalArtistCountUpdated(int)));
connect(service_->artists_collection_model(), SIGNAL(TotalAlbumCountUpdated(int)), ui_->artists_collection->view(), SLOT(TotalAlbumCountUpdated(int))); connect(service_->artists_collection_model(), SIGNAL(TotalAlbumCountUpdated(int)), ui_->artists_collection->view(), SLOT(TotalAlbumCountUpdated(int)));
@@ -97,11 +96,10 @@ InternetTabsView::InternetTabsView(Application *app, InternetService *service, I
connect(ui_->albums_collection->button_refresh(), SIGNAL(clicked()), SLOT(GetAlbums())); connect(ui_->albums_collection->button_refresh(), SIGNAL(clicked()), SLOT(GetAlbums()));
connect(ui_->albums_collection->button_close(), SIGNAL(clicked()), SLOT(AbortGetAlbums())); connect(ui_->albums_collection->button_close(), SIGNAL(clicked()), SLOT(AbortGetAlbums()));
connect(ui_->albums_collection->button_abort(), SIGNAL(clicked()), SLOT(AbortGetAlbums())); connect(ui_->albums_collection->button_abort(), SIGNAL(clicked()), SLOT(AbortGetAlbums()));
connect(service_, SIGNAL(AlbumsResults(SongList)), SLOT(AlbumsFinished(SongList))); connect(service_, SIGNAL(AlbumsResults(const SongList&, const QString&)), SLOT(AlbumsFinished(const SongList&, const QString&)));
connect(service_, SIGNAL(AlbumsError(QString)), SLOT(AlbumsError(QString))); connect(service_, SIGNAL(AlbumsUpdateStatus(const QString&)), ui_->albums_collection->status(), SLOT(setText(const QString&)));
connect(service_, SIGNAL(AlbumsUpdateStatus(QString)), ui_->albums_collection->status(), SLOT(setText(QString))); connect(service_, SIGNAL(AlbumsProgressSetMaximum(const int)), ui_->albums_collection->progressbar(), SLOT(setMaximum(const int)));
connect(service_, SIGNAL(AlbumsProgressSetMaximum(int)), ui_->albums_collection->progressbar(), SLOT(setMaximum(int))); connect(service_, SIGNAL(AlbumsUpdateProgress(const int)), ui_->albums_collection->progressbar(), SLOT(setValue(const int)));
connect(service_, SIGNAL(AlbumsUpdateProgress(int)), ui_->albums_collection->progressbar(), SLOT(setValue(int)));
connect(service_->albums_collection_model(), SIGNAL(TotalArtistCountUpdated(int)), ui_->albums_collection->view(), SLOT(TotalArtistCountUpdated(int))); connect(service_->albums_collection_model(), SIGNAL(TotalArtistCountUpdated(int)), ui_->albums_collection->view(), SLOT(TotalArtistCountUpdated(int)));
connect(service_->albums_collection_model(), SIGNAL(TotalAlbumCountUpdated(int)), ui_->albums_collection->view(), SLOT(TotalAlbumCountUpdated(int))); connect(service_->albums_collection_model(), SIGNAL(TotalAlbumCountUpdated(int)), ui_->albums_collection->view(), SLOT(TotalAlbumCountUpdated(int)));
@@ -129,11 +127,10 @@ InternetTabsView::InternetTabsView(Application *app, InternetService *service, I
connect(ui_->songs_collection->button_refresh(), SIGNAL(clicked()), SLOT(GetSongs())); connect(ui_->songs_collection->button_refresh(), SIGNAL(clicked()), SLOT(GetSongs()));
connect(ui_->songs_collection->button_close(), SIGNAL(clicked()), SLOT(AbortGetSongs())); connect(ui_->songs_collection->button_close(), SIGNAL(clicked()), SLOT(AbortGetSongs()));
connect(ui_->songs_collection->button_abort(), SIGNAL(clicked()), SLOT(AbortGetSongs())); connect(ui_->songs_collection->button_abort(), SIGNAL(clicked()), SLOT(AbortGetSongs()));
connect(service_, SIGNAL(SongsResults(SongList)), SLOT(SongsFinished(SongList))); connect(service_, SIGNAL(SongsResults(const SongList&, const QString&)), SLOT(SongsFinished(const SongList&, const QString&)));
connect(service_, SIGNAL(SongsError(QString)), SLOT(SongsError(QString))); connect(service_, SIGNAL(SongsUpdateStatus(const QString&)), ui_->songs_collection->status(), SLOT(setText(const QString&)));
connect(service_, SIGNAL(SongsUpdateStatus(QString)), ui_->songs_collection->status(), SLOT(setText(QString))); connect(service_, SIGNAL(SongsProgressSetMaximum(const int)), ui_->songs_collection->progressbar(), SLOT(setMaximum(const int)));
connect(service_, SIGNAL(SongsProgressSetMaximum(int)), ui_->songs_collection->progressbar(), SLOT(setMaximum(int))); connect(service_, SIGNAL(SongsUpdateProgress(const int)), ui_->songs_collection->progressbar(), SLOT(setValue(const int)));
connect(service_, SIGNAL(SongsUpdateProgress(int)), ui_->songs_collection->progressbar(), SLOT(setValue(int)));
connect(service_->songs_collection_model(), SIGNAL(TotalArtistCountUpdated(int)), ui_->songs_collection->view(), SLOT(TotalArtistCountUpdated(int))); connect(service_->songs_collection_model(), SIGNAL(TotalArtistCountUpdated(int)), ui_->songs_collection->view(), SLOT(TotalArtistCountUpdated(int)));
connect(service_->songs_collection_model(), SIGNAL(TotalAlbumCountUpdated(int)), ui_->songs_collection->view(), SLOT(TotalAlbumCountUpdated(int))); connect(service_->songs_collection_model(), SIGNAL(TotalAlbumCountUpdated(int)), ui_->songs_collection->view(), SLOT(TotalAlbumCountUpdated(int)));
@@ -208,22 +205,21 @@ void InternetTabsView::AbortGetArtists() {
} }
void InternetTabsView::ArtistsError(QString error) { void InternetTabsView::ArtistsFinished(const SongList &songs, const QString &error) {
ui_->artists_collection->status()->setText(error); if (songs.isEmpty() && !error.isEmpty()) {
ui_->artists_collection->progressbar()->setValue(0); ui_->artists_collection->status()->setText(error);
ui_->artists_collection->progressbar()->hide(); ui_->artists_collection->progressbar()->setValue(0);
ui_->artists_collection->button_abort()->hide(); ui_->artists_collection->progressbar()->hide();
ui_->artists_collection->button_close()->show(); ui_->artists_collection->button_abort()->hide();
ui_->artists_collection->button_close()->show();
} }
else {
void InternetTabsView::ArtistsFinished(SongList songs) { service_->artists_collection_backend()->DeleteAll();
ui_->artists_collection->stacked()->setCurrentWidget(ui_->artists_collection->internetcollection_page());
service_->artists_collection_backend()->DeleteAll(); ui_->artists_collection->status()->clear();
ui_->artists_collection->stacked()->setCurrentWidget(ui_->artists_collection->internetcollection_page()); service_->artists_collection_backend()->AddOrUpdateSongs(songs);
ui_->artists_collection->status()->clear(); }
service_->artists_collection_backend()->AddOrUpdateSongs(songs);
} }
@@ -252,22 +248,21 @@ void InternetTabsView::AbortGetAlbums() {
} }
void InternetTabsView::AlbumsError(QString error) { void InternetTabsView::AlbumsFinished(const SongList &songs, const QString &error) {
ui_->albums_collection->status()->setText(error); if (songs.isEmpty() && !error.isEmpty()) {
ui_->albums_collection->progressbar()->setValue(0); ui_->albums_collection->status()->setText(error);
ui_->albums_collection->progressbar()->hide(); ui_->albums_collection->progressbar()->setValue(0);
ui_->albums_collection->button_abort()->hide(); ui_->albums_collection->progressbar()->hide();
ui_->albums_collection->button_close()->show(); ui_->albums_collection->button_abort()->hide();
ui_->albums_collection->button_close()->show();
} }
else {
void InternetTabsView::AlbumsFinished(SongList songs) { service_->albums_collection_backend()->DeleteAll();
ui_->albums_collection->stacked()->setCurrentWidget(ui_->albums_collection->internetcollection_page());
service_->albums_collection_backend()->DeleteAll(); ui_->albums_collection->status()->clear();
ui_->albums_collection->stacked()->setCurrentWidget(ui_->albums_collection->internetcollection_page()); service_->albums_collection_backend()->AddOrUpdateSongs(songs);
ui_->albums_collection->status()->clear(); }
service_->albums_collection_backend()->AddOrUpdateSongs(songs);
} }
@@ -296,21 +291,20 @@ void InternetTabsView::AbortGetSongs() {
} }
void InternetTabsView::SongsError(QString error) { void InternetTabsView::SongsFinished(const SongList &songs, const QString &error) {
ui_->songs_collection->status()->setText(error); if (songs.isEmpty() && !error.isEmpty()) {
ui_->songs_collection->progressbar()->setValue(0); ui_->songs_collection->status()->setText(error);
ui_->songs_collection->progressbar()->hide(); ui_->songs_collection->progressbar()->setValue(0);
ui_->songs_collection->button_abort()->hide(); ui_->songs_collection->progressbar()->hide();
ui_->songs_collection->button_close()->show(); ui_->songs_collection->button_abort()->hide();
ui_->songs_collection->button_close()->show();
} }
else {
void InternetTabsView::SongsFinished(SongList songs) { service_->songs_collection_backend()->DeleteAll();
ui_->songs_collection->stacked()->setCurrentWidget(ui_->songs_collection->internetcollection_page());
service_->songs_collection_backend()->DeleteAll(); ui_->songs_collection->status()->clear();
ui_->songs_collection->stacked()->setCurrentWidget(ui_->songs_collection->internetcollection_page()); service_->songs_collection_backend()->AddOrUpdateSongs(songs);
ui_->songs_collection->status()->clear(); }
service_->songs_collection_backend()->AddOrUpdateSongs(songs);
} }

9
src/internet/internettabsview.h
View File

@@ -62,12 +62,9 @@ class InternetTabsView : public QWidget {
void AbortGetArtists(); void AbortGetArtists();
void AbortGetAlbums(); void AbortGetAlbums();
void AbortGetSongs(); void AbortGetSongs();
void ArtistsError(QString error); void ArtistsFinished(const SongList &songs, const QString &error);
void AlbumsError(QString error); void AlbumsFinished(const SongList &songs, const QString &error);
void SongsError(QString error); void SongsFinished(const SongList &songs, const QString &error);
void ArtistsFinished(SongList songs);
void AlbumsFinished(SongList songs);
void SongsFinished(SongList songs);
private: private:
Application *app_; Application *app_;

200
src/qobuz/qobuzrequest.cpp
View File

@@ -53,7 +53,7 @@ QobuzRequest::QobuzRequest(QobuzService *service, QobuzUrlHandler *url_handler,
url_handler_(url_handler), url_handler_(url_handler),
network_(network), network_(network),
type_(type), type_(type),
search_id_(-1), query_id_(-1),
finished_(false), finished_(false),
artists_requests_active_(0), artists_requests_active_(0),
artists_total_(0), artists_total_(0),
@@ -110,15 +110,15 @@ void QobuzRequest::Process() {
} }
void QobuzRequest::Search(const int search_id, const QString &search_text) { void QobuzRequest::Search(const int query_id, const QString &search_text) {
search_id_ = search_id; query_id_ = query_id;
search_text_ = search_text; search_text_ = search_text;
} }
void QobuzRequest::GetArtists() { void QobuzRequest::GetArtists() {
emit UpdateStatus(tr("Retrieving artists...")); emit UpdateStatus(query_id_, tr("Retrieving artists..."));
emit UpdateProgress(0); emit UpdateProgress(query_id_, 0);
AddArtistsRequest(); AddArtistsRequest();
} }
@@ -156,7 +156,7 @@ void QobuzRequest::FlushArtistsRequests() {
reply = CreateRequest("artist/search", params); reply = CreateRequest("artist/search", params);
} }
if (!reply) continue; if (!reply) continue;
NewClosure(reply, SIGNAL(finished()), this, SLOT(ArtistsReplyReceived(QNetworkReply*, int, int)), reply, request.limit, request.offset); NewClosure(reply, SIGNAL(finished()), this, SLOT(ArtistsReplyReceived(QNetworkReply*, const int, const int)), reply, request.limit, request.offset);
} }
@@ -164,8 +164,8 @@ void QobuzRequest::FlushArtistsRequests() {
void QobuzRequest::GetAlbums() { void QobuzRequest::GetAlbums() {
emit UpdateStatus(tr("Retrieving albums...")); emit UpdateStatus(query_id_, tr("Retrieving albums..."));
emit UpdateProgress(0); emit UpdateProgress(query_id_, 0);
AddAlbumsRequest(); AddAlbumsRequest();
} }
@@ -203,7 +203,7 @@ void QobuzRequest::FlushAlbumsRequests() {
reply = CreateRequest("album/search", params); reply = CreateRequest("album/search", params);
} }
if (!reply) continue; if (!reply) continue;
NewClosure(reply, SIGNAL(finished()), this, SLOT(AlbumsReplyReceived(QNetworkReply*, int, int)), reply, request.limit, request.offset); NewClosure(reply, SIGNAL(finished()), this, SLOT(AlbumsReplyReceived(QNetworkReply*, const int, const int)), reply, request.limit, request.offset);
} }
@@ -211,8 +211,8 @@ void QobuzRequest::FlushAlbumsRequests() {
void QobuzRequest::GetSongs() { void QobuzRequest::GetSongs() {
emit UpdateStatus(tr("Retrieving songs...")); emit UpdateStatus(query_id_, tr("Retrieving songs..."));
emit UpdateProgress(0); emit UpdateProgress(query_id_, 0);
AddSongsRequest(); AddSongsRequest();
} }
@@ -250,7 +250,7 @@ void QobuzRequest::FlushSongsRequests() {
reply = CreateRequest("track/search", params); reply = CreateRequest("track/search", params);
} }
if (!reply) continue; if (!reply) continue;
NewClosure(reply, SIGNAL(finished()), this, SLOT(SongsReplyReceived(QNetworkReply*, int, int)), reply, request.limit, request.offset); NewClosure(reply, SIGNAL(finished()), this, SLOT(SongsReplyReceived(QNetworkReply*, const int, const int)), reply, request.limit, request.offset);
} }
@@ -258,8 +258,8 @@ void QobuzRequest::FlushSongsRequests() {
void QobuzRequest::ArtistsSearch() { void QobuzRequest::ArtistsSearch() {
emit UpdateStatus(tr("Searching...")); emit UpdateStatus(query_id_, tr("Searching..."));
emit UpdateProgress(0); emit UpdateProgress(query_id_, 0);
AddArtistsSearchRequest(); AddArtistsSearchRequest();
} }
@@ -272,8 +272,8 @@ void QobuzRequest::AddArtistsSearchRequest(const int offset) {
void QobuzRequest::AlbumsSearch() { void QobuzRequest::AlbumsSearch() {
emit UpdateStatus(tr("Searching...")); emit UpdateStatus(query_id_, tr("Searching..."));
emit UpdateProgress(0); emit UpdateProgress(query_id_, 0);
AddAlbumsSearchRequest(); AddAlbumsSearchRequest();
} }
@@ -286,8 +286,8 @@ void QobuzRequest::AddAlbumsSearchRequest(const int offset) {
void QobuzRequest::SongsSearch() { void QobuzRequest::SongsSearch() {
emit UpdateStatus(tr("Searching...")); emit UpdateStatus(query_id_, tr("Searching..."));
emit UpdateProgress(0); emit UpdateProgress(query_id_, 0);
AddSongsSearchRequest(); AddSongsSearchRequest();
} }
@@ -317,7 +317,7 @@ void QobuzRequest::ArtistsReplyReceived(QNetworkReply *reply, const int limit_re
ArtistsFinishCheck(); ArtistsFinishCheck();
return; return;
} }
if (!json_obj.contains("artists")) { if (!json_obj.contains("artists")) {
ArtistsFinishCheck(); ArtistsFinishCheck();
Error("Json object is missing artists.", json_obj); Error("Json object is missing artists.", json_obj);
@@ -359,8 +359,8 @@ void QobuzRequest::ArtistsReplyReceived(QNetworkReply *reply, const int limit_re
} }
if (offset_requested == 0) { if (offset_requested == 0) {
emit ProgressSetMaximum(artists_total_); emit ProgressSetMaximum(query_id_, artists_total_);
emit UpdateProgress(artists_received_); emit UpdateProgress(query_id_, artists_received_);
} }
QJsonValue json_value = ExtractItems(json_obj_artists, error); QJsonValue json_value = ExtractItems(json_obj_artists, error);
@@ -371,7 +371,7 @@ void QobuzRequest::ArtistsReplyReceived(QNetworkReply *reply, const int limit_re
QJsonArray json_items = json_value.toArray(); QJsonArray json_items = json_value.toArray();
if (json_items.isEmpty()) { // Empty array means no results if (json_items.isEmpty()) { // Empty array means no results
no_results_ = true; if (offset_requested == 0) no_results_ = true;
ArtistsFinishCheck(); ArtistsFinishCheck();
return; return;
} }
@@ -408,7 +408,7 @@ void QobuzRequest::ArtistsReplyReceived(QNetworkReply *reply, const int limit_re
} }
artists_received_ += artists_received; artists_received_ += artists_received;
if (offset_requested != 0) emit UpdateProgress(artists_received_); if (offset_requested != 0) emit UpdateProgress(query_id_, artists_received_);
ArtistsFinishCheck(limit_requested, offset, artists_received); ArtistsFinishCheck(limit_requested, offset, artists_received);
@@ -438,10 +438,10 @@ void QobuzRequest::ArtistsFinishCheck(const int limit, const int offset, const i
artist_albums_requests_pending_.clear(); artist_albums_requests_pending_.clear();
if (artist_albums_requested_ > 0) { if (artist_albums_requested_ > 0) {
if (artist_albums_requested_ == 1) emit UpdateStatus(tr("Retrieving albums for %1 artist...").arg(artist_albums_requested_)); if (artist_albums_requested_ == 1) emit UpdateStatus(query_id_, tr("Retrieving albums for %1 artist...").arg(artist_albums_requested_));
else emit UpdateStatus(tr("Retrieving albums for %1 artists...").arg(artist_albums_requested_)); else emit UpdateStatus(query_id_, tr("Retrieving albums for %1 artists...").arg(artist_albums_requested_));
emit ProgressSetMaximum(artist_albums_requested_); emit ProgressSetMaximum(query_id_, artist_albums_requested_);
emit UpdateProgress(0); emit UpdateProgress(query_id_, 0);
} }
} }
@@ -478,7 +478,7 @@ void QobuzRequest::FlushArtistAlbumsRequests() {
if (request.offset > 0) params << Param("offset", QString::number(request.offset)); if (request.offset > 0) params << Param("offset", QString::number(request.offset));
QNetworkReply *reply = CreateRequest(QString("artist/get"), params); QNetworkReply *reply = CreateRequest(QString("artist/get"), params);
NewClosure(reply, SIGNAL(finished()), this, SLOT(ArtistAlbumsReplyReceived(QNetworkReply*, const qint64, int)), reply, request.artist_id, request.offset); NewClosure(reply, SIGNAL(finished()), this, SLOT(ArtistAlbumsReplyReceived(QNetworkReply*, const qint64, const int)), reply, request.artist_id, request.offset);
} }
@@ -488,7 +488,7 @@ void QobuzRequest::ArtistAlbumsReplyReceived(QNetworkReply *reply, const qint64
--artist_albums_requests_active_; --artist_albums_requests_active_;
++artist_albums_received_; ++artist_albums_received_;
emit UpdateProgress(artist_albums_received_); emit UpdateProgress(query_id_, artist_albums_received_);
AlbumsReceived(reply, artist_id, 0, offset_requested); AlbumsReceived(reply, artist_id, 0, offset_requested);
if (!artist_albums_requests_queue_.isEmpty() && artist_albums_requests_active_ < kMaxConcurrentArtistAlbumsRequests) FlushArtistAlbumsRequests(); if (!artist_albums_requests_queue_.isEmpty() && artist_albums_requests_active_ < kMaxConcurrentArtistAlbumsRequests) FlushArtistAlbumsRequests();
@@ -512,9 +512,19 @@ void QobuzRequest::AlbumsReceived(QNetworkReply *reply, const qint64 artist_id_r
return; return;
} }
qint64 artist_id = 0; qint64 album_artist_id = artist_id_requested;
if (json_obj.contains("id")) { if (json_obj.contains("id")) {
artist_id = json_obj["id"].toInt(); album_artist_id = json_obj["id"].toInt();
}
QString album_artist;
if (json_obj.contains("name")) {
album_artist = json_obj["name"].toString();
}
if (album_artist_id != artist_id_requested) {
AlbumsFinishCheck(artist_id_requested);
Error("Artist id returned does not match artist id requested.", json_obj);
return;
} }
if (!json_obj.contains("albums")) { if (!json_obj.contains("albums")) {
@@ -556,7 +566,9 @@ void QobuzRequest::AlbumsReceived(QNetworkReply *reply, const qint64 artist_id_r
} }
QJsonArray json_items = json_value.toArray(); QJsonArray json_items = json_value.toArray();
if (json_items.isEmpty()) { if (json_items.isEmpty()) {
no_results_ = true; if ((type_ == QueryType_Albums || type_ == QueryType_SearchAlbums) && offset_requested == 0) {
no_results_ = true;
}
AlbumsFinishCheck(artist_id_requested); AlbumsFinishCheck(artist_id_requested);
return; return;
} }
@@ -593,16 +605,15 @@ void QobuzRequest::AlbumsReceived(QNetworkReply *reply, const qint64 artist_id_r
continue; continue;
} }
artist_id = json_artist["id"].toInt(); qint64 artist_id = json_artist["id"].toInt();
QString artist = json_artist["name"].toString(); QString artist = json_artist["name"].toString();
if (artist_id_requested != 0 && artist_id != artist_id_requested) {
qLog(Debug) << "Skipping artist" << "artist" << artist << artist_id << "does not match album artist" << album_artist_id << album_artist;
continue;
}
Request request; Request request;
if (artist_id_requested == 0) { request.artist_id = artist_id;
request.artist_id = artist_id;
}
else {
request.artist_id = artist_id_requested;
}
request.album_id = album_id; request.album_id = album_id;
request.album_artist = artist; request.album_artist = artist;
request.album = album; request.album = album;
@@ -650,15 +661,15 @@ void QobuzRequest::AlbumsFinishCheck(const qint64 artist_id, const int limit, co
QHash<QString, Request> ::iterator i; QHash<QString, Request> ::iterator i;
for (i = album_songs_requests_pending_.begin() ; i != album_songs_requests_pending_.end() ; ++i) { for (i = album_songs_requests_pending_.begin() ; i != album_songs_requests_pending_.end() ; ++i) {
Request request = i.value(); Request request = i.value();
AddAlbumSongsRequest(request.artist_id, request.album_id, request.album_artist); AddAlbumSongsRequest(request.artist_id, request.album_id, request.album_artist, request.album);
} }
album_songs_requests_pending_.clear(); album_songs_requests_pending_.clear();
if (album_songs_requested_ > 0) { if (album_songs_requested_ > 0) {
if (album_songs_requested_ == 1) emit UpdateStatus(tr("Retrieving songs for %1 album...").arg(album_songs_requested_)); if (album_songs_requested_ == 1) emit UpdateStatus(query_id_, tr("Retrieving songs for %1 album...").arg(album_songs_requested_));
else emit UpdateStatus(tr("Retrieving songs for %1 albums...").arg(album_songs_requested_)); else emit UpdateStatus(query_id_, tr("Retrieving songs for %1 albums...").arg(album_songs_requested_));
emit ProgressSetMaximum(album_songs_requested_); emit ProgressSetMaximum(query_id_, album_songs_requested_);
emit UpdateProgress(0); emit UpdateProgress(query_id_, 0);
} }
} }
@@ -673,12 +684,13 @@ void QobuzRequest::SongsReplyReceived(QNetworkReply *reply, const int limit_requ
} }
void QobuzRequest::AddAlbumSongsRequest(const qint64 artist_id, const QString &album_id, const QString &album_artist, const int offset) { void QobuzRequest::AddAlbumSongsRequest(const qint64 artist_id, const QString &album_id, const QString &album_artist, const QString &album, const int offset) {
Request request; Request request;
request.artist_id = artist_id; request.artist_id = artist_id;
request.album_id = album_id; request.album_id = album_id;
request.album_artist = album_artist; request.album_artist = album_artist;
request.album = album;
request.offset = offset; request.offset = offset;
album_songs_requests_queue_.enqueue(request); album_songs_requests_queue_.enqueue(request);
++album_songs_requested_; ++album_songs_requested_;
@@ -695,24 +707,24 @@ void QobuzRequest::FlushAlbumSongsRequests() {
ParamList params = ParamList() << Param("album_id", request.album_id); ParamList params = ParamList() << Param("album_id", request.album_id);
if (request.offset > 0) params << Param("offset", QString::number(request.offset)); if (request.offset > 0) params << Param("offset", QString::number(request.offset));
QNetworkReply *reply = CreateRequest(QString("album/get"), params); QNetworkReply *reply = CreateRequest(QString("album/get"), params);
NewClosure(reply, SIGNAL(finished()), this, SLOT(AlbumSongsReplyReceived(QNetworkReply*, const qint64, const QString&, int, const QString&)), reply, request.artist_id, request.album_id, request.offset, request.album_artist); NewClosure(reply, SIGNAL(finished()), this, SLOT(AlbumSongsReplyReceived(QNetworkReply*, const qint64, const QString&, const int, const QString&, const QString&)), reply, request.artist_id, request.album_id, request.offset, request.album_artist, request.album);
} }
} }
void QobuzRequest::AlbumSongsReplyReceived(QNetworkReply *reply, const qint64 artist_id, const QString &album_id, const int offset_requested, const QString &album_artist) { void QobuzRequest::AlbumSongsReplyReceived(QNetworkReply *reply, const qint64 artist_id, const QString &album_id, const int offset_requested, const QString &album_artist, const QString &album) {
--album_songs_requests_active_; --album_songs_requests_active_;
++album_songs_received_; ++album_songs_received_;
if (offset_requested == 0) { if (offset_requested == 0) {
emit UpdateProgress(album_songs_received_); emit UpdateProgress(query_id_, album_songs_received_);
} }
SongsReceived(reply, artist_id, album_id, 0, offset_requested, album_artist); SongsReceived(reply, artist_id, album_id, 0, offset_requested, album_artist, album);
} }
void QobuzRequest::SongsReceived(QNetworkReply *reply, const qint64 artist_id_requested, const QString &album_id_requested, const int limit_requested, const int offset_requested, const QString &album_artist_requested) { void QobuzRequest::SongsReceived(QNetworkReply *reply, const qint64 artist_id_requested, const QString &album_id_requested, const int limit_requested, const int offset_requested, const QString &album_artist_requested, const QString &album_requested) {
QString error; QString error;
QByteArray data = GetReplyData(reply, error); QByteArray data = GetReplyData(reply, error);
@@ -720,28 +732,26 @@ void QobuzRequest::SongsReceived(QNetworkReply *reply, const qint64 artist_id_re
if (finished_) return; if (finished_) return;
if (data.isEmpty()) { if (data.isEmpty()) {
SongsFinishCheck(artist_id_requested, album_id_requested, limit_requested, offset_requested, 0, 0, album_artist_requested); SongsFinishCheck(artist_id_requested, album_id_requested, limit_requested, offset_requested, 0, 0, album_artist_requested, album_requested);
return; return;
} }
QJsonObject json_obj = ExtractJsonObj(data, error); QJsonObject json_obj = ExtractJsonObj(data, error);
if (json_obj.isEmpty()) { if (json_obj.isEmpty()) {
SongsFinishCheck(artist_id_requested, album_id_requested, limit_requested, offset_requested, 0, 0, album_artist_requested); SongsFinishCheck(artist_id_requested, album_id_requested, limit_requested, offset_requested, 0, 0, album_artist_requested, album_requested);
return; return;
} }
//qLog(Debug) << json_obj;
if (!json_obj.contains("tracks")) { if (!json_obj.contains("tracks")) {
Error("Json object is missing tracks.", json_obj); Error("Json object is missing tracks.", json_obj);
SongsFinishCheck(artist_id_requested, album_id_requested, limit_requested, offset_requested, 0, 0, album_artist_requested); SongsFinishCheck(artist_id_requested, album_id_requested, limit_requested, offset_requested, 0, 0, album_artist_requested, album_requested);
return; return;
} }
qint64 artist_id = 0; qint64 artist_id = artist_id_requested;
QString album_artist; QString album_artist = album_artist_requested;
QString album_id; QString album_id = album_id_requested;
QString album; QString album = album_requested;
QUrl cover_url; QUrl cover_url;
if (json_obj.contains("id")) { if (json_obj.contains("id")) {
@@ -756,13 +766,13 @@ void QobuzRequest::SongsReceived(QNetworkReply *reply, const qint64 artist_id_re
QJsonValue json_artist = json_obj["artist"]; QJsonValue json_artist = json_obj["artist"];
if (!json_artist.isObject()) { if (!json_artist.isObject()) {
Error("Invalid Json reply, album artist is not a object.", json_artist); Error("Invalid Json reply, album artist is not a object.", json_artist);
SongsFinishCheck(artist_id_requested, album_id_requested, limit_requested, offset_requested, 0, 0, album_artist_requested); SongsFinishCheck(artist_id_requested, album_id_requested, limit_requested, offset_requested, 0, 0, album_artist, album);
return; return;
} }
QJsonObject json_obj_artist = json_artist.toObject(); QJsonObject json_obj_artist = json_artist.toObject();
if (!json_obj_artist.contains("id") || !json_obj_artist.contains("name")) { if (!json_obj_artist.contains("id") || !json_obj_artist.contains("name")) {
Error("Invalid Json reply, album artist is missing id or name.", json_obj_artist); Error("Invalid Json reply, album artist is missing id or name.", json_obj_artist);
SongsFinishCheck(artist_id_requested, album_id_requested, limit_requested, offset_requested, 0, 0, album_artist_requested); SongsFinishCheck(artist_id_requested, album_id_requested, limit_requested, offset_requested, 0, 0, album_artist, album);
return; return;
} }
artist_id = json_obj_artist["id"].toInt(); artist_id = json_obj_artist["id"].toInt();
@@ -773,13 +783,13 @@ void QobuzRequest::SongsReceived(QNetworkReply *reply, const qint64 artist_id_re
QJsonValue json_image = json_obj["image"]; QJsonValue json_image = json_obj["image"];
if (!json_image.isObject()) { if (!json_image.isObject()) {
Error("Invalid Json reply, album image is not a object.", json_image); Error("Invalid Json reply, album image is not a object.", json_image);
SongsFinishCheck(artist_id_requested, album_id_requested, limit_requested, offset_requested, 0, 0, album_artist_requested); SongsFinishCheck(artist_id_requested, album_id_requested, limit_requested, offset_requested, 0, 0, album_artist, album);
return; return;
} }
QJsonObject json_obj_image = json_image.toObject(); QJsonObject json_obj_image = json_image.toObject();
if (!json_obj_image.contains("large")) { if (!json_obj_image.contains("large")) {
Error("Invalid Json reply, album image is missing large.", json_obj_image); Error("Invalid Json reply, album image is missing large.", json_obj_image);
SongsFinishCheck(artist_id_requested, album_id_requested, limit_requested, offset_requested, 0, 0, album_artist_requested); SongsFinishCheck(artist_id_requested, album_id_requested, limit_requested, offset_requested, 0, 0, album_artist, album);
return; return;
} }
QString album_image = json_obj_image["large"].toString(); QString album_image = json_obj_image["large"].toString();
@@ -791,7 +801,7 @@ void QobuzRequest::SongsReceived(QNetworkReply *reply, const qint64 artist_id_re
QJsonValue json_tracks = json_obj["tracks"]; QJsonValue json_tracks = json_obj["tracks"];
if (!json_tracks.isObject()) { if (!json_tracks.isObject()) {
Error("Json tracks is not an object.", json_obj); Error("Json tracks is not an object.", json_obj);
SongsFinishCheck(artist_id_requested, album_id_requested, limit_requested, offset_requested, 0, 0, album_artist_requested); SongsFinishCheck(artist_id_requested, album_id_requested, limit_requested, offset_requested, 0, 0, album_artist, album);
return; return;
} }
QJsonObject json_obj_tracks = json_tracks.toObject(); QJsonObject json_obj_tracks = json_tracks.toObject();
@@ -800,7 +810,7 @@ void QobuzRequest::SongsReceived(QNetworkReply *reply, const qint64 artist_id_re
!json_obj_tracks.contains("offset") || !json_obj_tracks.contains("offset") ||
!json_obj_tracks.contains("total") || !json_obj_tracks.contains("total") ||
!json_obj_tracks.contains("items")) { !json_obj_tracks.contains("items")) {
SongsFinishCheck(artist_id_requested, album_id_requested, limit_requested, offset_requested, 0, 0, album_artist_requested); SongsFinishCheck(artist_id_requested, album_id_requested, limit_requested, offset_requested, 0, 0, album_artist, album);
Error("Json songs object is missing values.", json_obj); Error("Json songs object is missing values.", json_obj);
return; return;
} }
@@ -811,20 +821,22 @@ void QobuzRequest::SongsReceived(QNetworkReply *reply, const qint64 artist_id_re
if (offset != offset_requested) { if (offset != offset_requested) {
Error(QString("Offset returned does not match offset requested! %1 != %2").arg(offset).arg(offset_requested)); Error(QString("Offset returned does not match offset requested! %1 != %2").arg(offset).arg(offset_requested));
SongsFinishCheck(artist_id, album_id, limit_requested, offset_requested, songs_total, 0, album_artist); SongsFinishCheck(artist_id, album_id, limit_requested, offset_requested, songs_total, 0, album_artist, album);
return; return;
} }
QJsonValue json_value = ExtractItems(json_obj_tracks, error); QJsonValue json_value = ExtractItems(json_obj_tracks, error);
if (!json_value.isArray()) { if (!json_value.isArray()) {
SongsFinishCheck(artist_id, album_id, limit_requested, offset_requested, songs_total, 0, album_artist); SongsFinishCheck(artist_id, album_id, limit_requested, offset_requested, songs_total, 0, album_artist, album);
return; return;
} }
QJsonArray json_items = json_value.toArray(); QJsonArray json_items = json_value.toArray();
if (json_items.isEmpty()) { if (json_items.isEmpty()) {
no_results_ = true; if ((type_ == QueryType_Songs || type_ == QueryType_SearchSongs) && offset_requested == 0) {
SongsFinishCheck(artist_id, album_id, limit_requested, offset_requested, songs_total, 0, album_artist); no_results_ = true;
}
SongsFinishCheck(artist_id, album_id, limit_requested, offset_requested, songs_total, 0, album_artist, album);
return; return;
} }
@@ -858,11 +870,11 @@ void QobuzRequest::SongsReceived(QNetworkReply *reply, const qint64 artist_id_re
songs_ << song; songs_ << song;
} }
SongsFinishCheck(artist_id, album_id, limit_requested, offset_requested, songs_total, songs_received, album_artist); SongsFinishCheck(artist_id, album_id, limit_requested, offset_requested, songs_total, songs_received, album_artist, album);
} }
void QobuzRequest::SongsFinishCheck(const qint64 artist_id, const QString &album_id, const int limit, const int offset, const int songs_total, const int songs_received, const QString &album_artist) { void QobuzRequest::SongsFinishCheck(const qint64 artist_id, const QString &album_id, const int limit, const int offset, const int songs_total, const int songs_received, const QString &album_artist, const QString &album) {
if (finished_) return; if (finished_) return;
@@ -874,16 +886,13 @@ void QobuzRequest::SongsFinishCheck(const qint64 artist_id, const QString &album
AddSongsRequest(offset_next); AddSongsRequest(offset_next);
break; break;
case QueryType_SearchSongs: case QueryType_SearchSongs:
// If artist_id and album_id isn't zero it means that it's a songs search where we fetch all albums too. So pass through. AddSongsSearchRequest(offset_next);
if (artist_id == 0 && album_id == 0) { break;
AddSongsSearchRequest(offset_next);
break;
}
case QueryType_Artists: case QueryType_Artists:
case QueryType_SearchArtists: case QueryType_SearchArtists:
case QueryType_Albums: case QueryType_Albums:
case QueryType_SearchAlbums: case QueryType_SearchAlbums:
AddAlbumSongsRequest(artist_id, album_id, album_artist, offset_next); AddAlbumSongsRequest(artist_id, album_id, album_artist, album, offset_next);
break; break;
default: default:
break; break;
@@ -1055,10 +1064,10 @@ void QobuzRequest::GetAlbumCovers() {
} }
FlushAlbumCoverRequests(); FlushAlbumCoverRequests();
if (album_covers_requested_ == 1) emit UpdateStatus(tr("Retrieving album cover for %1 album...").arg(album_covers_requested_)); if (album_covers_requested_ == 1) emit UpdateStatus(query_id_, tr("Retrieving album cover for %1 album...").arg(album_covers_requested_));
else emit UpdateStatus(tr("Retrieving album covers for %1 albums...").arg(album_covers_requested_)); else emit UpdateStatus(query_id_, tr("Retrieving album covers for %1 albums...").arg(album_covers_requested_));
emit ProgressSetMaximum(album_covers_requested_); emit ProgressSetMaximum(query_id_, album_covers_requested_);
emit UpdateProgress(0); emit UpdateProgress(query_id_, 0);
} }
@@ -1115,7 +1124,7 @@ void QobuzRequest::AlbumCoverReceived(QNetworkReply *reply, const QUrl &cover_ur
if (finished_) return; if (finished_) return;
emit UpdateProgress(album_covers_received_); emit UpdateProgress(query_id_, album_covers_received_);
if (!album_covers_requests_sent_.contains(cover_url)) { if (!album_covers_requests_sent_.contains(cover_url)) {
AlbumCoverFinishCheck(); AlbumCoverFinishCheck();
@@ -1225,27 +1234,18 @@ void QobuzRequest::FinishCheck() {
album_covers_received_ >= album_covers_requested_ album_covers_received_ >= album_covers_requested_
) { ) {
finished_ = true; finished_ = true;
if (songs_.isEmpty()) { if (no_results_ && songs_.isEmpty()) {
if (IsSearch()) { if (IsSearch())
if (no_results_) emit ErrorSignal(search_id_, tr("No match")); emit Results(query_id_, SongList(), tr("No match."));
else if (errors_.isEmpty()) emit ErrorSignal(search_id_, tr("Unknown error")); else
else emit ErrorSignal(search_id_, errors_); emit Results(query_id_, SongList(), QString());
}
else {
if (no_results_) emit Results(songs_);
else if (errors_.isEmpty()) emit ErrorSignal(tr("Unknown error"));
else emit ErrorSignal(errors_);
}
} }
else { else {
if (IsSearch()) { if (songs_.isEmpty() && errors_.isEmpty())
emit SearchResults(search_id_, songs_); emit Results(query_id_, songs_, tr("Unknown error"));
} else
else { emit Results(query_id_, songs_, errors_);
emit Results(songs_);
}
} }
} }
} }

22
src/qobuz/qobuzrequest.h
View File

@@ -62,13 +62,10 @@ class QobuzRequest : public QobuzBaseRequest {
void Login(const QString &username, const QString &password, const QString &token); void Login(const QString &username, const QString &password, const QString &token);
void LoginSuccess(); void LoginSuccess();
void LoginFailure(QString failure_reason); void LoginFailure(QString failure_reason);
void Results(SongList songs); void Results(const int id, const SongList &songs, const QString &error);
void SearchResults(int id, SongList songs); void UpdateStatus(const int id, const QString &text);
void ErrorSignal(QString message); void ProgressSetMaximum(const int id, const int max);
void ErrorSignal(int id, QString message); void UpdateProgress(const int id, const int max);
void UpdateStatus(QString text);
void ProgressSetMaximum(int max);
void UpdateProgress(int max);
void StreamURLFinished(const QUrl original_url, const QUrl url, const Song::FileType, QString error = QString()); void StreamURLFinished(const QUrl original_url, const QUrl url, const Song::FileType, QString error = QString());
private slots: private slots:
@@ -79,10 +76,10 @@ class QobuzRequest : public QobuzBaseRequest {
void AlbumsReceived(QNetworkReply *reply, const qint64 artist_id_requested, const int limit_requested, const int offset_requested); void AlbumsReceived(QNetworkReply *reply, const qint64 artist_id_requested, const int limit_requested, const int offset_requested);
void SongsReplyReceived(QNetworkReply *reply, const int limit_requested, const int offset_requested); void SongsReplyReceived(QNetworkReply *reply, const int limit_requested, const int offset_requested);
void SongsReceived(QNetworkReply *reply, const qint64 artist_id_requested, const QString &album_id_requested, const int limit_requested, const int offset_requested, const QString &album_artist_requested = QString()); void SongsReceived(QNetworkReply *reply, const qint64 artist_id_requested, const QString &album_id_requested, const int limit_requested, const int offset_requested, const QString &album_artist_requested = QString(), const QString &album_requested = QString());
void ArtistAlbumsReplyReceived(QNetworkReply *reply, const qint64 artist_id, const int offset_requested); void ArtistAlbumsReplyReceived(QNetworkReply *reply, const qint64 artist_id, const int offset_requested);
void AlbumSongsReplyReceived(QNetworkReply *reply, const qint64 artist_id, const QString &album_id, const int offset_requested, const QString &album_artist); void AlbumSongsReplyReceived(QNetworkReply *reply, const qint64 artist_id, const QString &album_id, const int offset_requested, const QString &album_artist, const QString &album);
void AlbumCoverReceived(QNetworkReply *reply, const QUrl &cover_url, const QString &filename); void AlbumCoverReceived(QNetworkReply *reply, const QUrl &cover_url, const QString &filename);
private: private:
@@ -126,12 +123,12 @@ class QobuzRequest : public QobuzBaseRequest {
void ArtistsFinishCheck(const int limit = 0, const int offset = 0, const int artists_received = 0); void ArtistsFinishCheck(const int limit = 0, const int offset = 0, const int artists_received = 0);
void AlbumsFinishCheck(const qint64 artist_id, const int limit = 0, const int offset = 0, const int albums_total = 0, const int albums_received = 0); void AlbumsFinishCheck(const qint64 artist_id, const int limit = 0, const int offset = 0, const int albums_total = 0, const int albums_received = 0);
void SongsFinishCheck(const qint64 artist_id, const QString &album_id, const int limit, const int offset, const int songs_total, const int songs_received, const QString &album_artist); void SongsFinishCheck(const qint64 artist_id, const QString &album_id, const int limit, const int offset, const int songs_total, const int songs_received, const QString &album_artist, const QString &album);
void AddArtistAlbumsRequest(const qint64 artist_id, const int offset = 0); void AddArtistAlbumsRequest(const qint64 artist_id, const int offset = 0);
void FlushArtistAlbumsRequests(); void FlushArtistAlbumsRequests();
void AddAlbumSongsRequest(const qint64 artist_id, const QString &album_id, const QString &album_artist, const int offset = 0); void AddAlbumSongsRequest(const qint64 artist_id, const QString &album_id, const QString &album_artist, const QString &album, const int offset = 0);
void FlushAlbumSongsRequests(); void FlushAlbumSongsRequests();
int ParseSong(Song &song, const QJsonObject &json_obj, qint64 artist_id, QString album_id, QString album_artist, QString album, QUrl cover_url); int ParseSong(Song &song, const QJsonObject &json_obj, qint64 artist_id, QString album_id, QString album_artist, QString album, QUrl cover_url);
@@ -159,8 +156,7 @@ class QobuzRequest : public QobuzBaseRequest {
NetworkAccessManager *network_; NetworkAccessManager *network_;
QueryType type_; QueryType type_;
int query_id_;
int search_id_;
QString search_text_; QString search_text_;
bool finished_; bool finished_;

90
src/qobuz/qobuzservice.cpp
View File

@@ -398,26 +398,29 @@ void QobuzService::GetArtists() {
artists_request_.reset(new QobuzRequest(this, url_handler_, network_, QobuzBaseRequest::QueryType_Artists, this)); artists_request_.reset(new QobuzRequest(this, url_handler_, network_, QobuzBaseRequest::QueryType_Artists, this));
connect(artists_request_.get(), SIGNAL(ErrorSignal(QString)), SLOT(ArtistsErrorReceived(QString))); connect(artists_request_.get(), SIGNAL(Results(const int, const SongList&, const QString&)), SLOT(ArtistsResultsReceived(const int, const SongList&, const QString&)));
connect(artists_request_.get(), SIGNAL(Results(SongList)), SLOT(ArtistsResultsReceived(SongList))); connect(artists_request_.get(), SIGNAL(UpdateStatus(const int, const QString&)), SLOT(ArtistsUpdateStatusReceived(const int, const QString&)));
connect(artists_request_.get(), SIGNAL(UpdateStatus(QString)), SIGNAL(ArtistsUpdateStatus(QString))); connect(artists_request_.get(), SIGNAL(ProgressSetMaximum(const int, const int)), SLOT(ArtistsProgressSetMaximumReceived(const int, const int)));
connect(artists_request_.get(), SIGNAL(ProgressSetMaximum(int)), SIGNAL(ArtistsProgressSetMaximum(int))); connect(artists_request_.get(), SIGNAL(UpdateProgress(const int, const int)), SLOT(ArtistsUpdateProgressReceived(const int, const int)));
connect(artists_request_.get(), SIGNAL(UpdateProgress(int)), SIGNAL(ArtistsUpdateProgress(int)));
artists_request_->Process(); artists_request_->Process();
} }
void QobuzService::ArtistsResultsReceived(SongList songs) { void QobuzService::ArtistsResultsReceived(const int id, const SongList &songs, const QString &error) {
emit ArtistsResults(songs, error);
emit ArtistsResults(songs);
} }
void QobuzService::ArtistsErrorReceived(QString error) { void QobuzService::ArtistsUpdateStatusReceived(const int id, const QString &text) {
emit ArtistsUpdateStatus(text);
}
emit ArtistsError(error); void QobuzService::ArtistsProgressSetMaximumReceived(const int id, const int max) {
emit ArtistsProgressSetMaximum(max);
}
void QobuzService::ArtistsUpdateProgressReceived(const int id, const int progress) {
emit ArtistsUpdateProgress(progress);
} }
void QobuzService::ResetAlbumsRequest() { void QobuzService::ResetAlbumsRequest() {
@@ -434,26 +437,29 @@ void QobuzService::GetAlbums() {
ResetAlbumsRequest(); ResetAlbumsRequest();
albums_request_.reset(new QobuzRequest(this, url_handler_, network_, QobuzBaseRequest::QueryType_Albums, this)); albums_request_.reset(new QobuzRequest(this, url_handler_, network_, QobuzBaseRequest::QueryType_Albums, this));
connect(albums_request_.get(), SIGNAL(ErrorSignal(QString)), SLOT(AlbumsErrorReceived(QString))); connect(albums_request_.get(), SIGNAL(Results(const int, const SongList&, const QString&)), SLOT(AlbumsResultsReceived(const int, const SongList&, const QString&)));
connect(albums_request_.get(), SIGNAL(Results(SongList)), SLOT(AlbumsResultsReceived(SongList))); connect(albums_request_.get(), SIGNAL(UpdateStatus(const int, const QString&)), SLOT(AlbumsUpdateStatusReceived(const int, const QString&)));
connect(albums_request_.get(), SIGNAL(UpdateStatus(QString)), SIGNAL(AlbumsUpdateStatus(QString))); connect(albums_request_.get(), SIGNAL(ProgressSetMaximum(const int, const int)), SLOT(AlbumsProgressSetMaximumReceived(const int, const int)));
connect(albums_request_.get(), SIGNAL(ProgressSetMaximum(int)), SIGNAL(AlbumsProgressSetMaximum(int))); connect(albums_request_.get(), SIGNAL(UpdateProgress(const int, const int)), SLOT(AlbumsUpdateProgressReceived(const int, const int)));
connect(albums_request_.get(), SIGNAL(UpdateProgress(int)), SIGNAL(AlbumsUpdateProgress(int)));
albums_request_->Process(); albums_request_->Process();
} }
void QobuzService::AlbumsResultsReceived(SongList songs) { void QobuzService::AlbumsResultsReceived(const int id, const SongList &songs, const QString &error) {
emit AlbumsResults(songs, error);
emit AlbumsResults(songs);
} }
void QobuzService::AlbumsErrorReceived(QString error) { void QobuzService::AlbumsUpdateStatusReceived(const int id, const QString &text) {
emit AlbumsUpdateStatus(text);
}
emit AlbumsError(error); void QobuzService::AlbumsProgressSetMaximumReceived(const int id, const int max) {
emit AlbumsProgressSetMaximum(max);
}
void QobuzService::AlbumsUpdateProgressReceived(const int id, const int progress) {
emit AlbumsUpdateProgress(progress);
} }
void QobuzService::ResetSongsRequest() { void QobuzService::ResetSongsRequest() {
@@ -470,26 +476,29 @@ void QobuzService::GetSongs() {
ResetSongsRequest(); ResetSongsRequest();
songs_request_.reset(new QobuzRequest(this, url_handler_, network_, QobuzBaseRequest::QueryType_Songs, this)); songs_request_.reset(new QobuzRequest(this, url_handler_, network_, QobuzBaseRequest::QueryType_Songs, this));
connect(songs_request_.get(), SIGNAL(ErrorSignal(QString)), SLOT(SongsErrorReceived(QString))); connect(songs_request_.get(), SIGNAL(Results(const int, const SongList&, const QString&)), SLOT(SongsResultsReceived(const int, const SongList&, const QString&)));
connect(songs_request_.get(), SIGNAL(Results(SongList)), SLOT(SongsResultsReceived(SongList))); connect(songs_request_.get(), SIGNAL(UpdateStatus(const int, const QString&)), SLOT(SongsUpdateStatusReceived(const int, const QString&)));
connect(songs_request_.get(), SIGNAL(UpdateStatus(QString)), SIGNAL(SongsUpdateStatus(QString))); connect(songs_request_.get(), SIGNAL(ProgressSetMaximum(const int, const int)), SLOT(SongsProgressSetMaximumReceived(const int, const int)));
connect(songs_request_.get(), SIGNAL(ProgressSetMaximum(int)), SIGNAL(SongsProgressSetMaximum(int))); connect(songs_request_.get(), SIGNAL(UpdateProgress(const int, const int)), SLOT(SongsUpdateProgressReceived(const int, const int)));
connect(songs_request_.get(), SIGNAL(UpdateProgress(int)), SIGNAL(SongsUpdateProgress(int)));
songs_request_->Process(); songs_request_->Process();
} }
void QobuzService::SongsResultsReceived(SongList songs) { void QobuzService::SongsResultsReceived(const int id, const SongList &songs, const QString &error) {
emit SongsResults(songs, error);
emit SongsResults(songs);
} }
void QobuzService::SongsErrorReceived(QString error) { void QobuzService::SongsUpdateStatusReceived(const int id, const QString &text) {
emit SongsUpdateStatus(text);
}
emit SongsError(error); void QobuzService::SongsProgressSetMaximumReceived(const int id, const int max) {
emit SongsProgressSetMaximum(max);
}
void QobuzService::SongsUpdateProgressReceived(const int id, const int progress) {
emit SongsUpdateProgress(progress);
} }
int QobuzService::Search(const QString &text, InternetSearch::SearchType type) { int QobuzService::Search(const QString &text, InternetSearch::SearchType type) {
@@ -514,7 +523,7 @@ int QobuzService::Search(const QString &text, InternetSearch::SearchType type) {
void QobuzService::StartSearch() { void QobuzService::StartSearch() {
if (app_id_.isEmpty() || username_.isEmpty() || password_.isEmpty()) { if (app_id_.isEmpty() || username_.isEmpty() || password_.isEmpty()) {
emit SearchError(pending_search_id_, tr("Not authenticated.")); emit SearchResults(pending_search_id_, SongList(), tr("Not authenticated."));
next_pending_search_id_ = 1; next_pending_search_id_ = 1;
ShowConfig(); ShowConfig();
return; return;
@@ -551,17 +560,20 @@ void QobuzService::SendSearch() {
search_request_.reset(new QobuzRequest(this, url_handler_, network_, type, this)); search_request_.reset(new QobuzRequest(this, url_handler_, network_, type, this));
connect(search_request_.get(), SIGNAL(SearchResults(int, SongList)), SIGNAL(SearchResults(int, SongList))); connect(search_request_.get(), SIGNAL(Results(const int, const SongList&, const QString&)), SLOT(SearchResultsReceived(const int, const SongList&, const QString&)));
connect(search_request_.get(), SIGNAL(ErrorSignal(int, QString)), SIGNAL(SearchError(int, QString))); connect(search_request_.get(), SIGNAL(UpdateStatus(const int, const QString&)), SIGNAL(SearchUpdateStatus(const int, const QString&)));
connect(search_request_.get(), SIGNAL(UpdateStatus(QString)), SIGNAL(SearchUpdateStatus(QString))); connect(search_request_.get(), SIGNAL(ProgressSetMaximum(const int, const int)), SIGNAL(SearchProgressSetMaximum(const int, const int)));
connect(search_request_.get(), SIGNAL(ProgressSetMaximum(int)), SIGNAL(SearchProgressSetMaximum(int))); connect(search_request_.get(), SIGNAL(UpdateProgress(const int, const int)), SIGNAL(SearchUpdateProgress(const int, const int)));
connect(search_request_.get(), SIGNAL(UpdateProgress(int)), SIGNAL(SearchUpdateProgress(int)));
search_request_->Search(search_id_, search_text_); search_request_->Search(search_id_, search_text_);
search_request_->Process(); search_request_->Process();
} }
void QobuzService::SearchResultsReceived(const int id, const SongList &songs, const QString &error) {
emit SearchResults(id, songs, error);
}
void QobuzService::GetStreamURL(const QUrl &url) { void QobuzService::GetStreamURL(const QUrl &url) {
QobuzStreamURLRequest *stream_url_req = new QobuzStreamURLRequest(this, network_, url, this); QobuzStreamURLRequest *stream_url_req = new QobuzStreamURLRequest(this, network_, url, this);

19
src/qobuz/qobuzservice.h
View File

@@ -127,12 +127,19 @@ class QobuzService : public InternetService {
void HandleAuthReply(QNetworkReply *reply); void HandleAuthReply(QNetworkReply *reply);
void ResetLoginAttempts(); void ResetLoginAttempts();
void StartSearch(); void StartSearch();
void ArtistsResultsReceived(SongList songs); void ArtistsResultsReceived(const int id, const SongList &songs, const QString &error);
void ArtistsErrorReceived(QString error); void AlbumsResultsReceived(const int id, const SongList &songs, const QString &error);
void AlbumsResultsReceived(SongList songs); void SongsResultsReceived(const int id, const SongList &songs, const QString &error);
void AlbumsErrorReceived(QString error); void SearchResultsReceived(const int id, const SongList &songs, const QString &error);
void SongsResultsReceived(SongList songs); void ArtistsUpdateStatusReceived(const int id, const QString &text);
void SongsErrorReceived(QString error); void AlbumsUpdateStatusReceived(const int id, const QString &text);
void SongsUpdateStatusReceived(const int id, const QString &text);
void ArtistsProgressSetMaximumReceived(const int id, const int max);
void AlbumsProgressSetMaximumReceived(const int id, const int max);
void SongsProgressSetMaximumReceived(const int id, const int max);
void ArtistsUpdateProgressReceived(const int id, const int progress);
void AlbumsUpdateProgressReceived(const int id, const int progress);
void SongsUpdateProgressReceived(const int id, const int progress);
void HandleStreamURLFinished(const QUrl original_url, const QUrl stream_url, const Song::FileType filetype, QString error = QString()); void HandleStreamURLFinished(const QUrl original_url, const QUrl stream_url, const Song::FileType filetype, QString error = QString());
private: private:

11
src/subsonic/subsonicrequest.cpp
View File

@@ -722,15 +722,8 @@ void SubsonicRequest::FinishCheck() {
album_covers_received_ >= album_covers_requested_ album_covers_received_ >= album_covers_requested_
) { ) {
finished_ = true; finished_ = true;
if (songs_.isEmpty()) { if (no_results_) emit Results(SongList(), QString());
if (no_results_) emit Results(songs_); else emit Results(songs_, errors_);
else if (errors_.isEmpty()) emit ErrorSignal(tr("Unknown error"));
else emit ErrorSignal(errors_);
}
else {
emit Results(songs_);
}
} }
} }

10
src/subsonic/subsonicrequest.h
View File

@@ -58,12 +58,10 @@ class SubsonicRequest : public SubsonicBaseRequest {
void Reset(); void Reset();
signals: signals:
void Results(SongList songs); void Results(const SongList &songs, const QString &error);
void ErrorSignal(QString message); void UpdateStatus(const QString &text);
void ErrorSignal(int id, QString message); void ProgressSetMaximum(const int max);
void UpdateStatus(QString text); void UpdateProgress(const int max);
void ProgressSetMaximum(int max);
void UpdateProgress(int max);
private slots: private slots:

19
src/subsonic/subsonicservice.cpp
View File

@@ -321,25 +321,18 @@ void SubsonicService::GetSongs() {
ResetSongsRequest(); ResetSongsRequest();
songs_request_.reset(new SubsonicRequest(this, url_handler_, network_, this)); songs_request_.reset(new SubsonicRequest(this, url_handler_, network_, this));
connect(songs_request_.get(), SIGNAL(ErrorSignal(QString)), SLOT(SongsErrorReceived(QString))); connect(songs_request_.get(), SIGNAL(Results(const SongList&, const QString&)), SLOT(SongsResultsReceived(const SongList&, const QString&)));
connect(songs_request_.get(), SIGNAL(Results(SongList)), SLOT(SongsResultsReceived(SongList))); connect(songs_request_.get(), SIGNAL(UpdateStatus(const QString&)), SIGNAL(SongsUpdateStatus(const QString&)));
connect(songs_request_.get(), SIGNAL(UpdateStatus(QString)), SIGNAL(SongsUpdateStatus(QString))); connect(songs_request_.get(), SIGNAL(ProgressSetMaximum(const int)), SIGNAL(SongsProgressSetMaximum(const int)));
connect(songs_request_.get(), SIGNAL(ProgressSetMaximum(int)), SIGNAL(SongsProgressSetMaximum(int))); connect(songs_request_.get(), SIGNAL(UpdateProgress(const int)), SIGNAL(SongsUpdateProgress(const int)));
connect(songs_request_.get(), SIGNAL(UpdateProgress(int)), SIGNAL(SongsUpdateProgress(int)));
songs_request_->GetAlbums(); songs_request_->GetAlbums();
} }
void SubsonicService::SongsResultsReceived(SongList songs) { void SubsonicService::SongsResultsReceived(const SongList &songs, const QString &error) {
emit SongsResults(songs); emit SongsResults(songs, error);
}
void SubsonicService::SongsErrorReceived(QString error) {
emit SongsError(error);
} }

3
src/subsonic/subsonicservice.h
View File

@@ -90,8 +90,7 @@ class SubsonicService : public InternetService {
private slots: private slots:
void HandlePingReply(QNetworkReply *reply); void HandlePingReply(QNetworkReply *reply);
void SongsResultsReceived(SongList songs); void SongsResultsReceived(const SongList &songs, const QString &error);
void SongsErrorReceived(QString error);
private: private:
typedef QPair<QString, QString> Param; typedef QPair<QString, QString> Param;

2
src/tidal/tidalbaserequest.h
View File

@@ -90,8 +90,6 @@ class TidalBaseRequest : public QObject {
int artistssearchlimit() { return service_->artistssearchlimit(); } int artistssearchlimit() { return service_->artistssearchlimit(); }
int albumssearchlimit() { return service_->albumssearchlimit(); } int albumssearchlimit() { return service_->albumssearchlimit(); }
int songssearchlimit() { return service_->songssearchlimit(); } int songssearchlimit() { return service_->songssearchlimit(); }
bool fetchalbums() { return service_->fetchalbums(); }
QString coversize() { return service_->coversize(); }
QString access_token() { return service_->access_token(); } QString access_token() { return service_->access_token(); }
QString session_id() { return service_->session_id(); } QString session_id() { return service_->session_id(); }

114
src/tidal/tidalrequest.cpp
View File

@@ -53,7 +53,9 @@ TidalRequest::TidalRequest(TidalService *service, TidalUrlHandler *url_handler,
url_handler_(url_handler), url_handler_(url_handler),
network_(network), network_(network),
type_(type), type_(type),
search_id_(-1), fetchalbums_(service->fetchalbums()),
coversize_(service_->coversize()),
query_id_(-1),
finished_(false), finished_(false),
artists_requests_active_(0), artists_requests_active_(0),
artists_total_(0), artists_total_(0),
@@ -100,6 +102,7 @@ void TidalRequest::LoginComplete(bool success, QString error) {
void TidalRequest::Process() { void TidalRequest::Process() {
if (!service_->authenticated()) { if (!service_->authenticated()) {
emit UpdateStatus(query_id_, tr("Authenticating..."));
need_login_ = true; need_login_ = true;
service_->TryLogin(); service_->TryLogin();
return; return;
@@ -131,15 +134,15 @@ void TidalRequest::Process() {
} }
void TidalRequest::Search(const int search_id, const QString &search_text) { void TidalRequest::Search(const int query_id, const QString &search_text) {
search_id_ = search_id; query_id_ = query_id;
search_text_ = search_text; search_text_ = search_text;
} }
void TidalRequest::GetArtists() { void TidalRequest::GetArtists() {
emit UpdateStatus(tr("Retrieving artists...")); emit UpdateStatus(query_id_, tr("Retrieving artists..."));
emit UpdateProgress(0); emit UpdateProgress(query_id_, 0);
AddArtistsRequest(); AddArtistsRequest();
} }
@@ -180,8 +183,8 @@ void TidalRequest::FlushArtistsRequests() {
void TidalRequest::GetAlbums() { void TidalRequest::GetAlbums() {
emit UpdateStatus(tr("Retrieving albums...")); emit UpdateStatus(query_id_, tr("Retrieving albums..."));
emit UpdateProgress(0); emit UpdateProgress(query_id_, 0);
AddAlbumsRequest(); AddAlbumsRequest();
} }
@@ -222,8 +225,8 @@ void TidalRequest::FlushAlbumsRequests() {
void TidalRequest::GetSongs() { void TidalRequest::GetSongs() {
emit UpdateStatus(tr("Retrieving songs...")); emit UpdateStatus(query_id_, tr("Retrieving songs..."));
emit UpdateProgress(0); emit UpdateProgress(query_id_, 0);
AddSongsRequest(); AddSongsRequest();
} }
@@ -264,8 +267,8 @@ void TidalRequest::FlushSongsRequests() {
void TidalRequest::ArtistsSearch() { void TidalRequest::ArtistsSearch() {
emit UpdateStatus(tr("Searching...")); emit UpdateStatus(query_id_, tr("Searching..."));
emit UpdateProgress(0); emit UpdateProgress(query_id_, 0);
AddArtistsSearchRequest(); AddArtistsSearchRequest();
} }
@@ -278,8 +281,8 @@ void TidalRequest::AddArtistsSearchRequest(const int offset) {
void TidalRequest::AlbumsSearch() { void TidalRequest::AlbumsSearch() {
emit UpdateStatus(tr("Searching...")); emit UpdateStatus(query_id_, tr("Searching..."));
emit UpdateProgress(0); emit UpdateProgress(query_id_, 0);
AddAlbumsSearchRequest(); AddAlbumsSearchRequest();
} }
@@ -292,8 +295,8 @@ void TidalRequest::AddAlbumsSearchRequest(const int offset) {
void TidalRequest::SongsSearch() { void TidalRequest::SongsSearch() {
emit UpdateStatus(tr("Searching...")); emit UpdateStatus(query_id_, tr("Searching..."));
emit UpdateProgress(0); emit UpdateProgress(query_id_, 0);
AddSongsSearchRequest(); AddSongsSearchRequest();
} }
@@ -352,11 +355,11 @@ void TidalRequest::ArtistsReplyReceived(QNetworkReply *reply, const int limit_re
} }
if (offset_requested == 0) { if (offset_requested == 0) {
emit ProgressSetMaximum(artists_total_); emit ProgressSetMaximum(query_id_, artists_total_);
emit UpdateProgress(artists_received_); emit UpdateProgress(query_id_, artists_received_);
} }
QJsonValue json_value = ExtractItems(data, error); QJsonValue json_value = ExtractItems(json_obj, error);
if (!json_value.isArray()) { if (!json_value.isArray()) {
ArtistsFinishCheck(); ArtistsFinishCheck();
return; return;
@@ -364,7 +367,7 @@ void TidalRequest::ArtistsReplyReceived(QNetworkReply *reply, const int limit_re
QJsonArray json_items = json_value.toArray(); QJsonArray json_items = json_value.toArray();
if (json_items.isEmpty()) { // Empty array means no results if (json_items.isEmpty()) { // Empty array means no results
no_results_ = true; if (offset_requested == 0) no_results_ = true;
ArtistsFinishCheck(); ArtistsFinishCheck();
return; return;
} }
@@ -401,7 +404,7 @@ void TidalRequest::ArtistsReplyReceived(QNetworkReply *reply, const int limit_re
} }
artists_received_ += artists_received; artists_received_ += artists_received;
if (offset_requested != 0) emit UpdateProgress(artists_received_); if (offset_requested != 0) emit UpdateProgress(query_id_, artists_received_);
ArtistsFinishCheck(limit_requested, offset, artists_received); ArtistsFinishCheck(limit_requested, offset, artists_received);
@@ -431,10 +434,10 @@ void TidalRequest::ArtistsFinishCheck(const int limit, const int offset, const i
artist_albums_requests_pending_.clear(); artist_albums_requests_pending_.clear();
if (artist_albums_requested_ > 0) { if (artist_albums_requested_ > 0) {
if (artist_albums_requested_ == 1) emit UpdateStatus(tr("Retrieving albums for %1 artist...").arg(artist_albums_requested_)); if (artist_albums_requested_ == 1) emit UpdateStatus(query_id_, tr("Retrieving albums for %1 artist...").arg(artist_albums_requested_));
else emit UpdateStatus(tr("Retrieving albums for %1 artists...").arg(artist_albums_requested_)); else emit UpdateStatus(query_id_, tr("Retrieving albums for %1 artists...").arg(artist_albums_requested_));
emit ProgressSetMaximum(artist_albums_requested_); emit ProgressSetMaximum(query_id_, artist_albums_requested_);
emit UpdateProgress(0); emit UpdateProgress(query_id_, 0);
} }
} }
@@ -479,7 +482,7 @@ void TidalRequest::ArtistAlbumsReplyReceived(QNetworkReply *reply, const qint64
--artist_albums_requests_active_; --artist_albums_requests_active_;
++artist_albums_received_; ++artist_albums_received_;
emit UpdateProgress(artist_albums_received_); emit UpdateProgress(query_id_, artist_albums_received_);
AlbumsReceived(reply, artist_id, 0, offset_requested, false); AlbumsReceived(reply, artist_id, 0, offset_requested, false);
if (!artist_albums_requests_queue_.isEmpty() && artist_albums_requests_active_ < kMaxConcurrentArtistAlbumsRequests) FlushArtistAlbumsRequests(); if (!artist_albums_requests_queue_.isEmpty() && artist_albums_requests_active_ < kMaxConcurrentArtistAlbumsRequests) FlushArtistAlbumsRequests();
@@ -529,7 +532,9 @@ void TidalRequest::AlbumsReceived(QNetworkReply *reply, const qint64 artist_id_r
} }
QJsonArray json_items = json_value.toArray(); QJsonArray json_items = json_value.toArray();
if (json_items.isEmpty()) { if (json_items.isEmpty()) {
no_results_ = true; if ((type_ == QueryType_Albums || type_ == QueryType_SearchAlbums || (type_ == QueryType_SearchSongs && fetchalbums_)) && offset_requested == 0) {
no_results_ = true;
}
AlbumsFinishCheck(artist_id_requested); AlbumsFinishCheck(artist_id_requested);
return; return;
} }
@@ -667,10 +672,10 @@ void TidalRequest::AlbumsFinishCheck(const qint64 artist_id, const int limit, co
album_songs_requests_pending_.clear(); album_songs_requests_pending_.clear();
if (album_songs_requested_ > 0) { if (album_songs_requested_ > 0) {
if (album_songs_requested_ == 1) emit UpdateStatus(tr("Retrieving songs for %1 album...").arg(album_songs_requested_)); if (album_songs_requested_ == 1) emit UpdateStatus(query_id_, tr("Retrieving songs for %1 album...").arg(album_songs_requested_));
else emit UpdateStatus(tr("Retrieving songs for %1 albums...").arg(album_songs_requested_)); else emit UpdateStatus(query_id_, tr("Retrieving songs for %1 albums...").arg(album_songs_requested_));
emit ProgressSetMaximum(album_songs_requested_); emit ProgressSetMaximum(query_id_, album_songs_requested_);
emit UpdateProgress(0); emit UpdateProgress(query_id_, 0);
} }
} }
@@ -681,7 +686,7 @@ void TidalRequest::AlbumsFinishCheck(const qint64 artist_id, const int limit, co
void TidalRequest::SongsReplyReceived(QNetworkReply *reply, const int limit_requested, const int offset_requested) { void TidalRequest::SongsReplyReceived(QNetworkReply *reply, const int limit_requested, const int offset_requested) {
--songs_requests_active_; --songs_requests_active_;
if (type_ == QueryType_SearchSongs && service_->fetchalbums()) { if (type_ == QueryType_SearchSongs && fetchalbums_) {
AlbumsReceived(reply, 0, limit_requested, offset_requested, (offset_requested == 0)); AlbumsReceived(reply, 0, limit_requested, offset_requested, (offset_requested == 0));
} }
else { else {
@@ -723,7 +728,7 @@ void TidalRequest::AlbumSongsReplyReceived(QNetworkReply *reply, const qint64 ar
--album_songs_requests_active_; --album_songs_requests_active_;
++album_songs_received_; ++album_songs_received_;
if (offset_requested == 0) { if (offset_requested == 0) {
emit UpdateProgress(album_songs_received_); emit UpdateProgress(query_id_, album_songs_received_);
} }
SongsReceived(reply, artist_id, album_id, 0, offset_requested, false, album_artist); SongsReceived(reply, artist_id, album_id, 0, offset_requested, false, album_artist);
@@ -766,7 +771,7 @@ void TidalRequest::SongsReceived(QNetworkReply *reply, const qint64 artist_id, c
return; return;
} }
QJsonValue json_value = ExtractItems(data, error); QJsonValue json_value = ExtractItems(json_obj, error);
if (!json_value.isArray()) { if (!json_value.isArray()) {
SongsFinishCheck(artist_id, album_id, limit_requested, offset_requested, songs_total, 0, album_artist); SongsFinishCheck(artist_id, album_id, limit_requested, offset_requested, songs_total, 0, album_artist);
return; return;
@@ -774,7 +779,9 @@ void TidalRequest::SongsReceived(QNetworkReply *reply, const qint64 artist_id, c
QJsonArray json_items = json_value.toArray(); QJsonArray json_items = json_value.toArray();
if (json_items.isEmpty()) { if (json_items.isEmpty()) {
no_results_ = true; if ((type_ == QueryType_Songs || type_ == QueryType_SearchSongs) && offset_requested == 0) {
no_results_ = true;
}
SongsFinishCheck(artist_id, album_id, limit_requested, offset_requested, songs_total, 0, album_artist); SongsFinishCheck(artist_id, album_id, limit_requested, offset_requested, songs_total, 0, album_artist);
return; return;
} }
@@ -960,7 +967,7 @@ int TidalRequest::ParseSong(Song &song, const QJsonObject &json_obj, const qint6
} }
cover = cover.replace("-", "/"); cover = cover.replace("-", "/");
QUrl cover_url (QString("%1/images/%2/%3.jpg").arg(kResourcesUrl).arg(cover).arg(service_->coversize())); QUrl cover_url (QString("%1/images/%2/%3.jpg").arg(kResourcesUrl).arg(cover).arg(coversize_));
title.remove(Song::kTitleRemoveMisc); title.remove(Song::kTitleRemoveMisc);
@@ -998,10 +1005,10 @@ void TidalRequest::GetAlbumCovers() {
} }
FlushAlbumCoverRequests(); FlushAlbumCoverRequests();
if (album_covers_requested_ == 1) emit UpdateStatus(tr("Retrieving album cover for %1 album...").arg(album_covers_requested_)); if (album_covers_requested_ == 1) emit UpdateStatus(query_id_, tr("Retrieving album cover for %1 album...").arg(album_covers_requested_));
else emit UpdateStatus(tr("Retrieving album covers for %1 albums...").arg(album_covers_requested_)); else emit UpdateStatus(query_id_, tr("Retrieving album covers for %1 albums...").arg(album_covers_requested_));
emit ProgressSetMaximum(album_covers_requested_); emit ProgressSetMaximum(query_id_, album_covers_requested_);
emit UpdateProgress(0); emit UpdateProgress(query_id_, 0);
} }
@@ -1055,7 +1062,7 @@ void TidalRequest::AlbumCoverReceived(QNetworkReply *reply, const QString &album
if (finished_) return; if (finished_) return;
emit UpdateProgress(album_covers_received_); emit UpdateProgress(query_id_, album_covers_received_);
if (!album_covers_requests_sent_.contains(album_id)) { if (!album_covers_requests_sent_.contains(album_id)) {
AlbumCoverFinishCheck(); AlbumCoverFinishCheck();
@@ -1137,27 +1144,18 @@ void TidalRequest::FinishCheck() {
album_covers_received_ >= album_covers_requested_ album_covers_received_ >= album_covers_requested_
) { ) {
finished_ = true; finished_ = true;
if (songs_.isEmpty()) { if (no_results_ && songs_.isEmpty()) {
if (IsSearch()) { if (IsSearch())
if (no_results_) emit ErrorSignal(search_id_, tr("No match")); emit Results(query_id_, SongList(), tr("No match."));
else if (errors_.isEmpty()) emit ErrorSignal(search_id_, tr("Unknown error")); else
else emit ErrorSignal(search_id_, errors_); emit Results(query_id_, SongList(), QString());
}
else {
if (no_results_) emit Results(songs_);
else if (errors_.isEmpty()) emit ErrorSignal(tr("Unknown error"));
else emit ErrorSignal(errors_);
}
} }
else { else {
if (IsSearch()) { if (songs_.isEmpty() && errors_.isEmpty())
emit SearchResults(search_id_, songs_); emit Results(query_id_, songs_, tr("Unknown error"));
} else
else { emit Results(query_id_, songs_, errors_);
emit Results(songs_);
}
} }
} }
} }

15
src/tidal/tidalrequest.h
View File

@@ -63,13 +63,10 @@ class TidalRequest : public TidalBaseRequest {
void Login(const QString &username, const QString &password, const QString &token); void Login(const QString &username, const QString &password, const QString &token);
void LoginSuccess(); void LoginSuccess();
void LoginFailure(QString failure_reason); void LoginFailure(QString failure_reason);
void Results(SongList songs); void Results(const int id, const SongList &songs, const QString &error);
void SearchResults(int id, SongList songs); void UpdateStatus(const int id, const QString &text);
void ErrorSignal(QString message); void ProgressSetMaximum(const int id, const int max);
void ErrorSignal(int id, QString message); void UpdateProgress(const int id, const int max);
void UpdateStatus(QString text);
void ProgressSetMaximum(int max);
void UpdateProgress(int max);
void StreamURLFinished(const QUrl original_url, const QUrl url, const Song::FileType, QString error = QString()); void StreamURLFinished(const QUrl original_url, const QUrl url, const Song::FileType, QString error = QString());
private slots: private slots:
@@ -160,8 +157,10 @@ class TidalRequest : public TidalBaseRequest {
NetworkAccessManager *network_; NetworkAccessManager *network_;
QueryType type_; QueryType type_;
bool fetchalbums_;
QString coversize_;
int search_id_; int query_id_;
QString search_text_; QString search_text_;
bool finished_; bool finished_;

92
src/tidal/tidalservice.cpp
View File

@@ -452,8 +452,6 @@ void TidalService::SendLogin() {
void TidalService::SendLogin(const QString &username, const QString &password, const QString &token) { void TidalService::SendLogin(const QString &username, const QString &password, const QString &token) {
emit UpdateStatus(tr("Authenticating..."));
login_sent_ = true; login_sent_ = true;
++login_attempts_; ++login_attempts_;
if (timer_login_attempt_->isActive()) timer_login_attempt_->stop(); if (timer_login_attempt_->isActive()) timer_login_attempt_->stop();
@@ -639,27 +637,30 @@ void TidalService::GetArtists() {
artists_request_.reset(new TidalRequest(this, url_handler_, network_, TidalBaseRequest::QueryType_Artists, this)); artists_request_.reset(new TidalRequest(this, url_handler_, network_, TidalBaseRequest::QueryType_Artists, this));
connect(artists_request_.get(), SIGNAL(ErrorSignal(QString)), SLOT(ArtistsErrorReceived(QString))); connect(artists_request_.get(), SIGNAL(Results(const int, const SongList&, const QString&)), SLOT(ArtistsResultsReceived(const int, const SongList&, const QString&)));
connect(artists_request_.get(), SIGNAL(Results(SongList)), SLOT(ArtistsResultsReceived(SongList))); connect(artists_request_.get(), SIGNAL(UpdateStatus(const int, const QString&)), SLOT(ArtistsUpdateStatusReceived(const int, const QString&)));
connect(artists_request_.get(), SIGNAL(UpdateStatus(QString)), SIGNAL(ArtistsUpdateStatus(QString))); connect(artists_request_.get(), SIGNAL(ProgressSetMaximum(const int, const int)), SLOT(ArtistsProgressSetMaximumReceived(const int, const int)));
connect(artists_request_.get(), SIGNAL(ProgressSetMaximum(int)), SIGNAL(ArtistsProgressSetMaximum(int))); connect(artists_request_.get(), SIGNAL(UpdateProgress(const int, const int)), SLOT(ArtistsUpdateProgressReceived(const int, const int)));
connect(artists_request_.get(), SIGNAL(UpdateProgress(int)), SIGNAL(ArtistsUpdateProgress(int)));
connect(this, SIGNAL(LoginComplete(bool, QString)), artists_request_.get(), SLOT(LoginComplete(bool, QString))); connect(this, SIGNAL(LoginComplete(bool, QString)), artists_request_.get(), SLOT(LoginComplete(bool, QString)));
artists_request_->Process(); artists_request_->Process();
} }
void TidalService::ArtistsResultsReceived(SongList songs) { void TidalService::ArtistsResultsReceived(const int id, const SongList &songs, const QString &error) {
emit ArtistsResults(songs, error);
emit ArtistsResults(songs);
} }
void TidalService::ArtistsErrorReceived(QString error) { void TidalService::ArtistsUpdateStatusReceived(const int id, const QString &text) {
emit ArtistsUpdateStatus(text);
}
emit ArtistsError(error); void TidalService::ArtistsProgressSetMaximumReceived(const int id, const int max) {
emit ArtistsProgressSetMaximum(max);
}
void TidalService::ArtistsUpdateProgressReceived(const int id, const int progress) {
emit ArtistsUpdateProgress(progress);
} }
void TidalService::ResetAlbumsRequest() { void TidalService::ResetAlbumsRequest() {
@@ -676,27 +677,30 @@ void TidalService::GetAlbums() {
ResetAlbumsRequest(); ResetAlbumsRequest();
albums_request_.reset(new TidalRequest(this, url_handler_, network_, TidalBaseRequest::QueryType_Albums, this)); albums_request_.reset(new TidalRequest(this, url_handler_, network_, TidalBaseRequest::QueryType_Albums, this));
connect(albums_request_.get(), SIGNAL(ErrorSignal(QString)), SLOT(AlbumsErrorReceived(QString))); connect(albums_request_.get(), SIGNAL(Results(const int, const SongList&, const QString&)), SLOT(AlbumsResultsReceived(const int, const SongList&, const QString&)));
connect(albums_request_.get(), SIGNAL(Results(SongList)), SLOT(AlbumsResultsReceived(SongList))); connect(albums_request_.get(), SIGNAL(UpdateStatus(const int, const QString&)), SLOT(AlbumsUpdateStatusReceived(const int, const QString&)));
connect(albums_request_.get(), SIGNAL(UpdateStatus(QString)), SIGNAL(AlbumsUpdateStatus(QString))); connect(albums_request_.get(), SIGNAL(ProgressSetMaximum(const int, const int)), SLOT(AlbumsProgressSetMaximumReceived(const int, const int)));
connect(albums_request_.get(), SIGNAL(ProgressSetMaximum(int)), SIGNAL(AlbumsProgressSetMaximum(int))); connect(albums_request_.get(), SIGNAL(UpdateProgress(const int, const int)), SLOT(AlbumsUpdateProgressReceived(const int, const int)));
connect(albums_request_.get(), SIGNAL(UpdateProgress(int)), SIGNAL(AlbumsUpdateProgress(int)));
connect(this, SIGNAL(LoginComplete(bool, QString)), albums_request_.get(), SLOT(LoginComplete(bool, QString))); connect(this, SIGNAL(LoginComplete(bool, QString)), albums_request_.get(), SLOT(LoginComplete(bool, QString)));
albums_request_->Process(); albums_request_->Process();
} }
void TidalService::AlbumsResultsReceived(SongList songs) { void TidalService::AlbumsResultsReceived(const int id, const SongList &songs, const QString &error) {
emit AlbumsResults(songs, error);
emit AlbumsResults(songs);
} }
void TidalService::AlbumsErrorReceived(QString error) { void TidalService::AlbumsUpdateStatusReceived(const int id, const QString &text) {
emit AlbumsUpdateStatus(text);
}
emit AlbumsError(error); void TidalService::AlbumsProgressSetMaximumReceived(const int id, const int max) {
emit AlbumsProgressSetMaximum(max);
}
void TidalService::AlbumsUpdateProgressReceived(const int id, const int progress) {
emit AlbumsUpdateProgress(progress);
} }
void TidalService::ResetSongsRequest() { void TidalService::ResetSongsRequest() {
@@ -713,27 +717,30 @@ void TidalService::GetSongs() {
ResetSongsRequest(); ResetSongsRequest();
songs_request_.reset(new TidalRequest(this, url_handler_, network_, TidalBaseRequest::QueryType_Songs, this)); songs_request_.reset(new TidalRequest(this, url_handler_, network_, TidalBaseRequest::QueryType_Songs, this));
connect(songs_request_.get(), SIGNAL(ErrorSignal(QString)), SLOT(SongsErrorReceived(QString))); connect(songs_request_.get(), SIGNAL(Results(const int, const SongList&, const QString&)), SLOT(SongsResultsReceived(const int, const SongList&, const QString&)));
connect(songs_request_.get(), SIGNAL(Results(SongList)), SLOT(SongsResultsReceived(SongList))); connect(songs_request_.get(), SIGNAL(UpdateStatus(const int, const QString&)), SLOT(SongsUpdateStatusReceived(const int, const QString&)));
connect(songs_request_.get(), SIGNAL(UpdateStatus(QString)), SIGNAL(SongsUpdateStatus(QString))); connect(songs_request_.get(), SIGNAL(ProgressSetMaximum(const int, const int)), SLOT(SongsProgressSetMaximumReceived(const int, const int)));
connect(songs_request_.get(), SIGNAL(ProgressSetMaximum(int)), SIGNAL(SongsProgressSetMaximum(int))); connect(songs_request_.get(), SIGNAL(UpdateProgress(const int, const int)), SLOT(SongsUpdateProgressReceived(const int, const int)));
connect(songs_request_.get(), SIGNAL(UpdateProgress(int)), SIGNAL(SongsUpdateProgress(int)));
connect(this, SIGNAL(LoginComplete(bool, QString)), songs_request_.get(), SLOT(LoginComplete(bool, QString))); connect(this, SIGNAL(LoginComplete(bool, QString)), songs_request_.get(), SLOT(LoginComplete(bool, QString)));
songs_request_->Process(); songs_request_->Process();
} }
void TidalService::SongsResultsReceived(SongList songs) { void TidalService::SongsResultsReceived(const int id, const SongList &songs, const QString &error) {
emit SongsResults(songs, error);
emit SongsResults(songs);
} }
void TidalService::SongsErrorReceived(QString error) { void TidalService::SongsUpdateStatusReceived(const int id, const QString &text) {
emit SongsUpdateStatus(text);
}
emit SongsError(error); void TidalService::SongsProgressSetMaximumReceived(const int id, const int max) {
emit SongsProgressSetMaximum(max);
}
void TidalService::SongsUpdateProgressReceived(const int id, const int progress) {
emit SongsUpdateProgress(progress);
} }
int TidalService::Search(const QString &text, InternetSearch::SearchType type) { int TidalService::Search(const QString &text, InternetSearch::SearchType type) {
@@ -758,7 +765,7 @@ int TidalService::Search(const QString &text, InternetSearch::SearchType type) {
void TidalService::StartSearch() { void TidalService::StartSearch() {
if ((oauth_ && !authenticated()) || api_token_.isEmpty() || username_.isEmpty() || password_.isEmpty()) { if ((oauth_ && !authenticated()) || api_token_.isEmpty() || username_.isEmpty() || password_.isEmpty()) {
emit SearchError(pending_search_id_, tr("Not authenticated.")); emit SearchResults(pending_search_id_, SongList(), tr("Not authenticated."));
next_pending_search_id_ = 1; next_pending_search_id_ = 1;
ShowConfig(); ShowConfig();
return; return;
@@ -795,11 +802,10 @@ void TidalService::SendSearch() {
search_request_.reset(new TidalRequest(this, url_handler_, network_, type, this)); search_request_.reset(new TidalRequest(this, url_handler_, network_, type, this));
connect(search_request_.get(), SIGNAL(SearchResults(int, SongList)), SIGNAL(SearchResults(int, SongList))); connect(search_request_.get(), SIGNAL(Results(const int, const SongList&, const QString&)), SLOT(SearchResultsReceived(const int, const SongList&, const QString&)));
connect(search_request_.get(), SIGNAL(ErrorSignal(int, QString)), SIGNAL(SearchError(int, QString))); connect(search_request_.get(), SIGNAL(UpdateStatus(const int, const QString&)), SIGNAL(SearchUpdateStatus(const int, const QString&)));
connect(search_request_.get(), SIGNAL(UpdateStatus(QString)), SIGNAL(SearchUpdateStatus(QString))); connect(search_request_.get(), SIGNAL(ProgressSetMaximum(const int, const int)), SIGNAL(SearchProgressSetMaximum(const int, const int)));
connect(search_request_.get(), SIGNAL(ProgressSetMaximum(int)), SIGNAL(SearchProgressSetMaximum(int))); connect(search_request_.get(), SIGNAL(UpdateProgress(const int, const int)), SIGNAL(SearchUpdateProgress(const int, const int)));
connect(search_request_.get(), SIGNAL(UpdateProgress(int)), SIGNAL(SearchUpdateProgress(int)));
connect(this, SIGNAL(LoginComplete(bool, QString)), search_request_.get(), SLOT(LoginComplete(bool, QString))); connect(this, SIGNAL(LoginComplete(bool, QString)), search_request_.get(), SLOT(LoginComplete(bool, QString)));
search_request_->Search(search_id_, search_text_); search_request_->Search(search_id_, search_text_);
@@ -807,6 +813,10 @@ void TidalService::SendSearch() {
} }
void TidalService::SearchResultsReceived(const int id, const SongList &songs, const QString &error) {
emit SearchResults(id, songs, error);
}
void TidalService::GetStreamURL(const QUrl &url) { void TidalService::GetStreamURL(const QUrl &url) {
TidalStreamURLRequest *stream_url_req = new TidalStreamURLRequest(this, network_, url, this); TidalStreamURLRequest *stream_url_req = new TidalStreamURLRequest(this, network_, url, this);

19
src/tidal/tidalservice.h
View File

@@ -137,12 +137,19 @@ class TidalService : public InternetService {
void HandleAuthReply(QNetworkReply *reply); void HandleAuthReply(QNetworkReply *reply);
void ResetLoginAttempts(); void ResetLoginAttempts();
void StartSearch(); void StartSearch();
void ArtistsResultsReceived(SongList songs); void ArtistsResultsReceived(const int id, const SongList &songs, const QString &error);
void ArtistsErrorReceived(QString error); void AlbumsResultsReceived(const int id, const SongList &songs, const QString &error);
void AlbumsResultsReceived(SongList songs); void SongsResultsReceived(const int id, const SongList &songs, const QString &error);
void AlbumsErrorReceived(QString error); void SearchResultsReceived(const int id, const SongList &songs, const QString &error);
void SongsResultsReceived(SongList songs); void ArtistsUpdateStatusReceived(const int id, const QString &text);
void SongsErrorReceived(QString error); void AlbumsUpdateStatusReceived(const int id, const QString &text);
void SongsUpdateStatusReceived(const int id, const QString &text);
void ArtistsProgressSetMaximumReceived(const int id, const int max);
void AlbumsProgressSetMaximumReceived(const int id, const int max);
void SongsProgressSetMaximumReceived(const int id, const int max);
void ArtistsUpdateProgressReceived(const int id, const int progress);
void AlbumsUpdateProgressReceived(const int id, const int progress);
void SongsUpdateProgressReceived(const int id, const int progress);
void HandleStreamURLFinished(const QUrl original_url, const QUrl stream_url, const Song::FileType filetype, QString error = QString()); void HandleStreamURLFinished(const QUrl original_url, const QUrl stream_url, const Song::FileType filetype, QString error = QString());
private: private: