Get track counts for Spotify albums

spotifyblob/blob/spotifyclient.cpp

@@ -169,8 +169,42 @@ void SpotifyClient::SearchCompleteCallback(sp_search* result, void* userdata) {
     return;
   }
 
+  // If there were any album results then we need to resolve those before
+  // we can send our response.
+  const int count = sp_search_num_albums(result);
+  if (count != 0) {
+    for (int i=0 ; i<count ; ++i) {
+      sp_album* album = sp_search_album(result, i);
+      sp_albumbrowse* browse =
+          sp_albumbrowse_create(me->session_, album, &SearchAlbumBrowseComplete, me);
+
+      me->pending_search_album_browse_responses_[browse] = result;
+    }
+    return;
+  }
+
+  me->SendSearchResponse(result);
+}
+
+void SpotifyClient::SearchAlbumBrowseComplete(sp_albumbrowse* result, void* userdata) {
+  SpotifyClient* me = reinterpret_cast<SpotifyClient*>(userdata);
+
+  if (!me->pending_search_album_browse_responses_.contains(result)) {
+    qLog(Warning) << "SearchAlbumBrowseComplete called with unknown result";
+    return;
+  }
+
+  sp_search* search = me->pending_search_album_browse_responses_.take(result);
+  me->pending_search_album_browses_[search].append(result);
+
+  if (me->pending_search_album_browses_[search].count() >= sp_search_num_albums(search)) {
+    me->SendSearchResponse(search);
+  }
+}
+
+void SpotifyClient::SendSearchResponse(sp_search* result) {
   // Take the request out of the queue
-  spotify_pb::SearchRequest req = me->pending_searches_.take(result);
+  spotify_pb::SearchRequest req = pending_searches_.take(result);
 
   // Prepare the response
   spotify_pb::SpotifyMessage message;
@@ -183,7 +217,7 @@ void SpotifyClient::SearchCompleteCallback(sp_search* result, void* userdata) {
   if (error != SP_ERROR_OK) {
     response->set_error(sp_error_message(error));
 
-    me->handler_->SendMessage(message);
+    handler_->SendMessage(message);
     sp_search_release(result);
     return;
   }
@@ -192,21 +226,24 @@ void SpotifyClient::SearchCompleteCallback(sp_search* result, void* userdata) {
   int count = sp_search_num_tracks(result);
   for (int i=0 ; i<count ; ++i) {
     sp_track* track = sp_search_track(result, i);
-    me->ConvertTrack(track, response->add_result());
+    ConvertTrack(track, response->add_result());
   }
 
-  // Get the albums from the search
+  // Get the albums from the search.  All these should be resolved by now.
-  count = sp_search_num_albums(result);
+  QList<sp_albumbrowse*> browses = pending_search_album_browses_.take(result);
-  for (int i=0 ; i<count ; ++i) {
+  foreach (sp_albumbrowse* browse, browses) {
-    sp_album* album = sp_search_album(result, i);
+    sp_album* album = sp_albumbrowse_album(browse);
-    me->ConvertAlbum(album, response->add_album());
+    spotify_pb::Track* track = response->add_album();
+    ConvertAlbum(album, track);
+    ConvertAlbumBrowse(browse, track);
+    sp_albumbrowse_release(browse);
   }
 
   // Add other data to the response
   response->set_total_tracks(sp_search_total_tracks(result));
   response->set_did_you_mean(sp_search_did_you_mean(result));
 
-  me->handler_->SendMessage(message);
+  handler_->SendMessage(message);
   sp_search_release(result);
 }
 
@@ -534,6 +571,10 @@ void SpotifyClient::ConvertAlbum(sp_album* album, spotify_pb::Track* pb) {
   pb->set_uri(uri);
 }
 
+void SpotifyClient::ConvertAlbumBrowse(sp_albumbrowse* browse, spotify_pb::Track* pb) {
+  pb->set_track(sp_albumbrowse_num_tracks(browse));
+}
+
 void SpotifyClient::MetadataUpdatedCallback(sp_session* session) {
   SpotifyClient* me = reinterpret_cast<SpotifyClient*>(sp_session_userdata(session));
 
@@ -872,7 +913,7 @@ void SpotifyClient::BrowseAlbum(const QString& uri) {
     return;
   }
 
-  // Get the track from the link
+  // Get the album from the link
   sp_album* album = sp_link_as_album(link);
   if (!album) {
     SendPlaybackError("Spotify URI was not an album");
@@ -904,4 +945,5 @@ void SpotifyClient::AlbumBrowseComplete(sp_albumbrowse* result, void* userdata)
   }
 
   me->handler_->SendMessage(message);
+  sp_albumbrowse_release(result);
 }

spotifyblob/blob/spotifyclient.h

@@ -55,6 +55,7 @@ private:
   void SendLoginCompleted(bool success, const QString& error,
                           spotify_pb::LoginResponse_Error error_code);
   void SendPlaybackError(const QString& error);
+  void SendSearchResponse(sp_search* result);
 
   // Spotify session callbacks.
   static void SP_CALLCONV LoggedInCallback(sp_session* session, sp_error error);
@@ -93,6 +94,7 @@ private:
   static void SP_CALLCONV ImageLoaded(sp_image* image, void* userdata);
 
   // Spotify album browse callbacks.
+  static void SP_CALLCONV SearchAlbumBrowseComplete(sp_albumbrowse* result, void* userdata);
   static void SP_CALLCONV AlbumBrowseComplete(sp_albumbrowse* result, void* userdata);
 
   // Request handlers.
@@ -108,6 +110,7 @@ private:
 
   void ConvertTrack(sp_track* track, spotify_pb::Track* pb);
   void ConvertAlbum(sp_album* album, spotify_pb::Track* pb);
+  void ConvertAlbumBrowse(sp_albumbrowse* browse, spotify_pb::Track* pb);
 
   // Gets the appropriate sp_playlist* but does not load it.
   sp_playlist* GetPlaylist(spotify_pb::PlaylistType type, int user_index);
@@ -164,6 +167,9 @@ private:
   QMap<sp_search*, spotify_pb::SearchRequest> pending_searches_;
   QMap<sp_albumbrowse*, QString> pending_album_browses_;
 
+  QMap<sp_search*, QList<sp_albumbrowse*> > pending_search_album_browses_;
+  QMap<sp_albumbrowse*, sp_search*> pending_search_album_browse_responses_;
+
   int media_length_msec_;
 };
 

src/globalsearch/spotifysearchprovider.cpp

@@ -103,7 +103,7 @@ void SpotifySearchProvider::SearchFinishedSlot(const spotify_pb::SearchResponse&
     result.match_quality_ =
         qMin(MatchQuality(state.tokens_, result.metadata_.album()),
              MatchQuality(state.tokens_, result.metadata_.artist()));
-    result.album_size_ = 0;
+    result.album_size_ = track.track();
     ret << result;
   }