static PyObject * AlbumBrowser_new(PyTypeObject * type, PyObject *args, PyObject *kwds) { PyObject *session, *album, *callback, *userdata = NULL; static char *kwlist[] = { "session", "album", "callback", "userdata", NULL }; if (!PyArg_ParseTupleAndKeywords (args, kwds, "O!O!O|O", kwlist, &SessionType, &session, &AlbumType, &album, &callback, &userdata)) return NULL; AlbumBrowser *self = (AlbumBrowser *) type->tp_alloc(type, 0); self->_callback.callback = callback; self->_callback.userdata = userdata; Py_XINCREF(callback); Py_XINCREF(userdata); Py_BEGIN_ALLOW_THREADS; self->_browser = sp_albumbrowse_create(((Session *) session)->_session, ((Album *) album)->_album, (albumbrowse_complete_cb *) AlbumBrowser_browse_complete, (void *)&self->_callback); Py_END_ALLOW_THREADS; return (PyObject *)self; }
static void get_album_tracks(){ sp_link * new_link; new_link = sp_link_create_from_string(g_guid); sp_album * new_album; new_album = sp_link_as_album(new_link); sp_albumbrowse* albumbrowser; albumbrowser = sp_albumbrowse_create(g_sess,new_album,albumbrowser_callback,NULL); }
int cmd_browse(int argc, char **argv) { sp_link *link; if (argc != 2) { browse_usage(); return -1; } link = sp_link_create_from_string(argv[1]); if (!link) { fprintf(stderr, "Not a spotify link\n"); return -1; } switch(sp_link_type(link)) { default: fprintf(stderr, "Can not handle link"); sp_link_release(link); return -1; case SP_LINKTYPE_ALBUM: sp_albumbrowse_create(g_session, sp_link_as_album(link), browse_album_callback, NULL); break; case SP_LINKTYPE_ARTIST: sp_artistbrowse_create(g_session, sp_link_as_artist(link), browse_artist_callback, NULL); break; case SP_LINKTYPE_TRACK: track_browse = sp_link_as_track(link); metadata_updated_fn = track_browse_try; sp_track_add_ref(track_browse); track_browse_try(); break; case SP_LINKTYPE_PLAYLIST: browse_playlist(sp_playlist_create(g_session, link)); break; } sp_link_release(link); return 0; }
void QSpotifyAlbumBrowse::setAlbum(QSpotifyAlbum *album) { if (m_album == album) return; m_album = album; emit albumChanged(); clearData(); if (!m_album) return; m_busy = true; emit busyChanged(); QMutexLocker lock(&g_mutex); m_sp_albumbrowse = sp_albumbrowse_create(QSpotifySession::instance()->spsession(), m_album->spalbum(), callback_albumbrowse_complete, 0); g_albumBrowseObjects.insert(m_sp_albumbrowse, this); }
void search_for_tracks_at(sp_session *session, char *buf, size_t len, size_t i, bool (*f)(sp_track *)) { if(search == NULL) { return; } buf[0] = '\0'; if(search_is_track(i) && sp_track_is_loaded(sp_search_track(search, i))) { f(sp_search_track(search, i)); if(buf != NULL) { track_to_str(buf, len, sp_search_track(search, i)); } } if(search_is_album(i) && sp_album_is_loaded(sp_search_album(search, i-sp_search_num_tracks(search)))) { sp_albumbrowse_create(session, sp_search_album(search, i-sp_search_num_tracks(search)) ,on_albumbrowse_complete, f); if(buf != NULL) { album_to_str(buf, len, sp_search_album(search, i-sp_search_num_tracks(search))); } } if(search_is_playlist(i)) { sp_playlist *pl = sp_search_playlist(search, i-sp_search_num_tracks(search)-sp_search_num_albums(search)); if(sp_playlist_is_loaded(pl)) { int j; for(j = 0; j < sp_playlist_num_tracks(pl); ++j) { f(sp_playlist_track(pl, j)); } if(buf != NULL) { playlist_to_str(buf, len, pl); } } } }
void SpotifyClient::SearchCompleteCallback(sp_search* result, void* userdata) { SpotifyClient* me = reinterpret_cast<SpotifyClient*>(userdata); if (!me->pending_searches_.contains(result)) { qLog(Warning) << "SearchComplete called with unknown search"; 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); }
/**************** *** Browsing *** ****************/ sp_albumbrowse* albumbrowse_create(sp_album* album, albumbrowse_complete_cb* callback, gpointer userdata) { return sp_albumbrowse_create(g_session, album, callback, userdata); }
AlbumBrowse::AlbumBrowse(boost::shared_ptr<Session> session, boost::shared_ptr<Album> album) : session_(session) , album_(album) , album_browse_(NULL) { album_browse_ = sp_albumbrowse_create(session->session_, album->album_, callback_albumbrowse_complete, this); }
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; }