void QSpotifyAlbumBrowse::processData() { if (m_sp_albumbrowse) { if (sp_albumbrowse_error(m_sp_albumbrowse) != SP_ERROR_OK) return; m_albumTracks = new QSpotifyTrackList; int c = sp_albumbrowse_num_tracks(m_sp_albumbrowse); for (int i = 0; i < c; ++i) { sp_track *track = sp_albumbrowse_track(m_sp_albumbrowse, i); QSpotifyTrack *qtrack = new QSpotifyTrack(track, m_albumTracks); m_albumTracks->m_tracks.append(qtrack); connect(qtrack, SIGNAL(isStarredChanged()), this, SIGNAL(isStarredChanged())); connect(QSpotifySession::instance()->user()->starredList(), SIGNAL(tracksAdded(QVector<sp_track*>)), qtrack, SLOT(onStarredListTracksAdded(QVector<sp_track*>))); connect(QSpotifySession::instance()->user()->starredList(), SIGNAL(tracksRemoved(QVector<sp_track*>)), qtrack, SLOT(onStarredListTracksRemoved(QVector<sp_track*>))); if (qtrack->artists() != m_album->artist()) m_hasMultipleArtists = true; } m_review = QString::fromUtf8(sp_albumbrowse_review(m_sp_albumbrowse)).split(QLatin1Char('\n'), QString::SkipEmptyParts); if (m_review.isEmpty()) m_review << QLatin1String("No review available"); m_busy = false; emit busyChanged(); emit tracksChanged(); } }
/** * Print the given album browse result and as much information as possible * * @param browse The browse result */ static void print_albumbrowse(sp_albumbrowse *browse) { int i; printf("Album browse of \"%s\" (%d)\n", sp_album_name(sp_albumbrowse_album(browse)), sp_album_year(sp_albumbrowse_album(browse))); for (i = 0; i < sp_albumbrowse_num_copyrights(browse); ++i) printf(" Copyright: %s\n", sp_albumbrowse_copyright(browse, i)); printf(" Tracks: %d\n", sp_albumbrowse_num_tracks(browse)); printf(" Review: %.60s...\n", sp_albumbrowse_review(browse)); puts(""); for (i = 0; i < sp_albumbrowse_num_tracks(browse); ++i) print_track(sp_albumbrowse_track(browse, i)); puts(""); }
PyObject * AlbumBrowser_sq_item(AlbumBrowser * self, Py_ssize_t index) { if (index >= sp_albumbrowse_num_tracks(self->_browser)) { PyErr_SetString(PyExc_IndexError, ""); return NULL; } sp_track *track = sp_albumbrowse_track(self->_browser, (int)index); PyObject *wrapper = Track_FromSpotify(track); return wrapper; }
void SpotifyClient::SendSearchResponse(sp_search* result) { // Take the request out of the queue spotify_pb::SearchRequest req = pending_searches_.take(result); // Prepare the response spotify_pb::SpotifyMessage message; spotify_pb::SearchResponse* response = message.mutable_search_response(); *response->mutable_request() = req; // Check for errors sp_error error = sp_search_error(result); if (error != SP_ERROR_OK) { response->set_error(sp_error_message(error)); handler_->SendMessage(message); sp_search_release(result); return; } // Get the list of tracks from the search int count = sp_search_num_tracks(result); for (int i=0 ; i<count ; ++i) { sp_track* track = sp_search_track(result, i); ConvertTrack(track, response->add_result()); } // Get the albums from the search. All these should be resolved by now. QList<sp_albumbrowse*> browses = pending_search_album_browses_.take(result); foreach (sp_albumbrowse* browse, browses) { sp_album* album = sp_albumbrowse_album(browse); spotify_pb::Album* msg = response->add_album(); ConvertAlbum(album, msg->mutable_metadata()); ConvertAlbumBrowse(browse, msg->mutable_metadata()); // Add all tracks const int tracks = sp_albumbrowse_num_tracks(browse); for (int i=0 ; i<tracks ; ++i) { ConvertTrack(sp_albumbrowse_track(browse, i), msg->add_track()); } sp_albumbrowse_release(browse); }
static void albumbrowser_callback(sp_albumbrowse *result, void *userdata) { int i; for (i = 0; i < sp_albumbrowse_num_tracks(result); ++i) { sp_track *track; track = sp_albumbrowse_track(result,i); //printf("%s\n",sp_track_name(track)); sp_track * tracks[1]; tracks[0] = track; inboxpost_complete_cb *ipc; ipc = inbox_post_callback; sp_inbox_post_tracks(g_sess, g_user,tracks, 1, "Update from Subscribify.se", ipc, NULL); //I have to to do this because the callback doesnt work sleep(5); exit(0); } }
int AlbumBrowse::GetNumTracks() { return sp_albumbrowse_num_tracks(album_browse_); }
jobject createJAlbumInstance(JNIEnv *env, sp_album *album) { jclass albumJClass; jobject albumInstance; albumJClass = (*env)->FindClass(env, "jahspotify/media/Album"); if (albumJClass == NULL) { fprintf(stderr,"jahspotify::createJAlbumInstance: could not load jahnotify.media.Album\n"); return NULL; } albumInstance = (*env)->AllocObject(env,albumJClass); if (!albumInstance) { fprintf(stderr,"jahspotify::createJAlbumInstance: could not create instance of jahspotify.media.Album\n"); return NULL; } sp_albumbrowse *albumBrowse = sp_albumbrowse_create(g_sess,album,albumBrowseCompleteCallback,NULL); if (albumBrowse) { sp_albumbrowse_add_ref(albumBrowse); int count = 0; while (!sp_albumbrowse_is_loaded(albumBrowse) && count < 5) { fprintf(stderr,"jahspotify::createJAlbumInstance: waiting for album browse load to complete\n"); sleep(1); count++; } if (count == 5) { sp_albumbrowse_release(albumBrowse); return NULL; } // By now it looks like the album will also be loaded sp_link *albumLink = sp_link_create_from_album(album); if (albumLink) { sp_link_add_ref(albumLink); jobject albumJLink = createJLinkInstance(env, albumLink); setObjectObjectField(env,albumInstance,"id","Ljahspotify/media/Link;",albumJLink); setObjectStringField(env,albumInstance,"name",sp_album_name(album)); setObjectIntField(env,albumInstance,"year",sp_album_year(album)); sp_albumtype albumType = sp_album_type(album); jclass albumTypeJClass = (*env)->FindClass(env, "jahspotify/media/AlbumType"); jmethodID jMethod = (*env)->GetStaticMethodID(env,albumTypeJClass,"fromOrdinal","(I)Ljahspotify/media/AlbumType;"); jobject albumTypeEnum = (jobjectArray)(*env)->CallStaticObjectMethod(env, albumTypeJClass, jMethod,(int)albumType); setObjectObjectField(env,albumInstance,"type","Ljahspotify/media/AlbumType;",albumTypeEnum); sp_link *albumCoverLink = sp_link_create_from_album_cover(album); if (albumCoverLink) { sp_link_add_ref(albumCoverLink); jobject albumCoverJLink = createJLinkInstance(env, albumCoverLink); setObjectObjectField(env,albumInstance,"cover","Ljahspotify/media/Link;",albumCoverJLink); sp_image *albumCoverImage = sp_image_create_from_link(g_sess,albumCoverLink); if (albumCoverImage) { sp_image_add_ref(albumCoverImage); sp_image_add_load_callback(albumCoverImage,imageLoadedCallback,NULL); } sp_link_release(albumCoverLink); } sp_artist *artist = sp_album_artist(album); if (artist) { sp_artist_add_ref(artist); sp_link *artistLink = sp_link_create_from_artist(artist); if (artistLink) { sp_link_add_ref(artistLink); jobject artistJLink = createJLinkInstance(env,artistLink); setObjectObjectField(env,albumInstance,"artist","Ljahspotify/media/Link;",artistJLink); sp_link_release(artistLink); } sp_artist_release(artist); } sp_link_release(albumLink); } int numTracks = sp_albumbrowse_num_tracks(albumBrowse); if (numTracks > 0) { // Add each track to the album - also pass in the disk as need be jmethodID addTrackJMethodID = (*env)->GetMethodID(env,albumJClass,"addTrack","(ILjahspotify/media/Link;)V"); int i = 0; for (i = 0; i < numTracks; i++) { sp_track *track = sp_albumbrowse_track(albumBrowse,i); if (track) { sp_track_add_ref(track); sp_link *trackLink = sp_link_create_from_track(track,0); if (trackLink) { sp_link_add_ref(trackLink); jobject trackJLink = createJLinkInstance(env,trackLink); (*env)->CallVoidMethod(env, albumInstance, addTrackJMethodID,sp_track_disc(track),trackJLink); sp_link_release(trackLink); } } } } int numCopyrights = sp_albumbrowse_num_copyrights(albumBrowse); if (numCopyrights > 0) { // Add copyrights to album jmethodID addCopyrightMethodID = (*env)->GetMethodID(env,albumJClass,"addCopyright","(Ljava/lang/String;)V"); int i = 0; for (i = 0; i < numCopyrights; i++) { const char *copyright = sp_albumbrowse_copyright(albumBrowse,i); if (copyright) { jstring str = (*env)->NewStringUTF(env, copyright); (*env)->CallVoidMethod(env, albumInstance, addCopyrightMethodID,str); } } } const char *review = sp_albumbrowse_review(albumBrowse); if (review) { setObjectStringField(env,albumInstance,"review",review); } sp_albumbrowse_release(albumBrowse); } return albumInstance; }
Py_ssize_t AlbumBrowser_sq_length(AlbumBrowser * self) { return sp_albumbrowse_num_tracks(self->_browser); }