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();
}
}
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);
}
/**
* 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("");
}
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);
}
}
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;
}
