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;
}
