SxPlaylist::SxPlaylist(sp_playlist* spPlaylist, int index, bool isFolder) {
m_spPlaylist = spPlaylist;
m_isValid = true;
m_isFolder = isFolder;
m_index = index;
m_thumb = NULL;
if (!isFolder) {
if (sp_playlist_is_loaded(spPlaylist)) reLoad();
m_plCallbacks.description_changed = 0;
m_plCallbacks.image_changed = 0;
m_plCallbacks.playlist_metadata_updated = &cb_playlist_metadata_updated;
m_plCallbacks.playlist_renamed = &cb_playlist_renamed;
m_plCallbacks.playlist_state_changed = &cb_state_change;
m_plCallbacks.playlist_update_in_progress = 0;
m_plCallbacks.subscribers_changed = 0;
m_plCallbacks.track_created_changed = 0;
m_plCallbacks.track_message_changed = 0;
m_plCallbacks.track_seen_changed = 0;
m_plCallbacks.tracks_added = &cb_tracks_added;
m_plCallbacks.tracks_moved = &cb_tracks_moved;
m_plCallbacks.tracks_removed = &cb_tracks_removed;
sp_playlist_add_callbacks(spPlaylist, &m_plCallbacks, this);
}
}
static void SP_CALLCONV pc_playlist_added(sp_playlistcontainer *pc, sp_playlist *playlist, int position, void *userdata) {
static sp_playlist_callbacks *callbacks;
MLTREEITEM item;
if(callbacks == NULL) {
callbacks = (sp_playlist_callbacks *)malloc(sizeof(sp_playlist_callbacks));
memset(callbacks, 0, sizeof(sp_playlist_callbacks));
callbacks->tracks_added = pl_tracks_added;
callbacks->playlist_renamed = playlist_renamed;
}
/* Snoop on the playlist to know when it's named and tracks are added */
sp_playlist_add_callbacks(playlist, callbacks, NULL);
/* Add playlist to our Media Library tree */
item.size = sizeof(MLTREEITEM);
item.parentId = m_TreeRootId;
item.hasChildren = 0;
item.id = 0;
item.imageIndex = 0;
item.title = "(Loading...)";
/* Create a new entry in under our tree in the Media Library pane */
SendMessage(hwndLibraryParent, WM_ML_IPC, (WPARAM) &item, ML_IPC_TREEITEM_ADD);
DSFYDEBUG("New id of entry '%s' is '%u'\n", item.title, item.id);
/* Add mapping between tree ID and playlist position in playlist container */
tpAdd(item.id, position);
}
/**
* This callback is called when an attempt to login has succeeded or failed.
*
* @sa sp_session_callbacks#logged_in
*/
static void logged_in(sp_session *sess, sp_error error)
{
sp_playlistcontainer *pc = sp_session_playlistcontainer(sess);
int i;
if (SP_ERROR_OK != error) {
fprintf(stderr, "jukebox: Login failed: %s\n",
sp_error_message(error));
exit(2);
}
sp_playlistcontainer_add_callbacks(
pc,
&pc_callbacks,
NULL);
printf("jukebox: Looking at %d playlists\n", sp_playlistcontainer_num_playlists(pc));
for (i = 0; i < sp_playlistcontainer_num_playlists(pc); ++i) {
sp_playlist *pl = sp_playlistcontainer_playlist(pc, i);
sp_playlist_add_callbacks(pl, &pl_callbacks, NULL);
if (!strcasecmp(sp_playlist_name(pl), g_listname)) {
g_jukeboxlist = pl;
try_jukebox_start();
}
}
if (!g_jukeboxlist) {
printf("jukebox: No such playlist. Waiting for one to pop up...\n");
fflush(stdout);
}
}
int cmd_playlist_add_track(int argc, char **argv)
{
sp_link *plink, *tlink;
sp_track *t;
sp_playlist *pl;
int i;
struct pl_update_work *puw;
if(argc < 4) {
printf("add [playlist uri] [position] [track uri] <[track uri]>...\n");
return 1;
}
plink = sp_link_create_from_string(argv[1]);
if (!plink) {
fprintf(stderr, "%s is not a spotify link\n", argv[1]);
return -1;
}
if(sp_link_type(plink) != SP_LINKTYPE_PLAYLIST) {
fprintf(stderr, "%s is not a playlist link\n", argv[1]);
sp_link_release(plink);
return -1;
}
puw = malloc(sizeof(struct pl_update_work));
puw->position = atoi(argv[2]);
puw->tracks = malloc(sizeof(sp_track *) * argc - 3);
puw->num_tracks = 0;
for(i = 0; i < argc - 3; i++) {
tlink = sp_link_create_from_string(argv[i + 3]);
if(tlink == NULL) {
fprintf(stderr, "%s is not a spotify link, skipping\n", argv[i + 3]);
continue;
}
if(sp_link_type(tlink) != SP_LINKTYPE_TRACK) {
fprintf(stderr, "%s is not a track link, skipping\n", argv[i + 3]);
continue;
}
t = sp_link_as_track(tlink);
sp_track_add_ref(t);
puw->tracks[puw->num_tracks++] = t;
sp_link_release(tlink);
}
pl = sp_playlist_create(g_session, plink);
if(!apply_changes(pl, puw)) {
// Changes applied directly, we're done
sp_playlist_release(pl);
sp_link_release(plink);
return 1;
}
fprintf(stderr, "Playlist not yet loaded, waiting...\n");
sp_playlist_add_callbacks(pl, &pl_update_callbacks, puw);
sp_link_release(plink);
return 0;
}
/**
* Callback from libspotify, telling us the rootlist is fully synchronized
*
* @param pc The playlist container handle
* @param userdata The opaque pointer
*/
static void container_loaded ( sp_playlistcontainer *pc, void *userdata )
{
char *folderName = malloc ( sizeof ( char ) * ( MAX_LENGTH_FOLDER_NAME ) );
int i;
if ( folderName == NULL )
{
fprintf ( stderr, "jahspotify: Could not allocate folder name variable)\n" );
return;
}
// fprintf ( stderr, "jahspotify: Rootlist synchronized (%d playlists)\n",sp_playlistcontainer_num_playlists ( pc ) );
signalSynchStarting(sp_playlistcontainer_num_playlists (pc));
for ( i = 0; i < sp_playlistcontainer_num_playlists ( pc ); ++i )
{
sp_playlist *pl = sp_playlistcontainer_playlist ( pc, i );
sp_playlist_add_callbacks ( pl, &pl_callbacks, NULL );
sp_link *link = sp_link_create_from_playlist(pl);
char *linkStr = malloc(sizeof(char) * 100);
if (link)
{
sp_link_add_ref(link);
sp_link_as_string(link,linkStr,100);
}
else
{
strcpy(linkStr,"N/A\0");
}
switch ( sp_playlistcontainer_playlist_type ( pc,i ) )
{
case SP_PLAYLIST_TYPE_PLAYLIST:
signalPlaylistSeen(sp_playlist_name ( pl ),linkStr);
break;
case SP_PLAYLIST_TYPE_START_FOLDER:
sp_playlistcontainer_playlist_folder_name ( pc,i,folderName, MAX_LENGTH_FOLDER_NAME);
signalStartFolderSeen(folderName, sp_playlistcontainer_playlist_folder_id(pc,i));
break;
case SP_PLAYLIST_TYPE_END_FOLDER:
sp_playlistcontainer_playlist_folder_name ( pc,i,folderName,MAX_LENGTH_FOLDER_NAME);
signalEndFolderSeen();
break;
case SP_PLAYLIST_TYPE_PLACEHOLDER:
fprintf ( stderr,"jahspotify: placeholder\n");
}
if (link)
sp_link_release(link);
free(linkStr);
}
signalSynchCompleted();
free ( folderName );
}
///////////////////// playlist container callbacks
void __stdcall SpotifyGuiController::playlist_added(sp_playlistcontainer *pc, sp_playlist *playlist, int position, void *userdata)
{
SpotifyGuiController *instance = (SpotifyGuiController *)userdata;
SpotifyUserData *sp_data = (SpotifyUserData *)instance->spotify_userdata;
if (instance->logWin) instance->logWin->addRow(TEXT("Playlist Received...."));
//aggiungo la callback per la playlist
sp_playlist_add_callbacks(playlist, sp_data->playlist_cb, instance);
}
/**
* Callback from libspotify, telling us a playlist was added to the playlist container.
*
* We add our playlist callbacks to the newly added playlist.
*
* @param pc The playlist container handle
* @param pl The playlist handle
* @param position Index of the added playlist
* @param userdata The opaque pointer
*/
static void playlist_added(sp_playlistcontainer *pc, sp_playlist *pl,
int position, void *userdata)
{
sp_playlist_add_callbacks(pl, &pl_callbacks, NULL);
if (!strcasecmp(sp_playlist_name(pl), g_listname)) {
g_jukeboxlist = pl;
try_jukebox_start();
}
}
void start_playlist(char *uri)
{
printf("Start playlist: %s\n", uri);
sp_link *link = sp_link_create_from_string(uri);
sp_playlist *pl = sp_playlist_create(g_sess, link);
sp_playlist_add_callbacks(pl, &pl_callbacks, NULL);
sprintf(g_last_playlist_name, sp_playlist_name(pl));
// hardware_banner(sp_playlist_name(pl), 200);
g_jukeboxlist = pl;
try_jukebox_start();
}
// Creates a playlist resource object
static php_spotify_playlist * playlist_resource_create(php_spotify_session *session, sp_playlist *playlist) {
php_spotify_playlist * resource = emalloc(sizeof(php_spotify_playlist));
resource->session = session;
resource->playlist = playlist;
sp_playlist_add_callbacks(playlist, &callbacks, resource);
return resource;
}
static struct playlist_handler *register_playlist_callbacks(
sp_playlist *playlist,
struct evhttp_request *request,
handle_playlist_fn callback,
sp_playlist_callbacks *playlist_callbacks,
void *userdata) {
struct playlist_handler *handler = malloc(sizeof (struct playlist_handler));
handler->request = request;
handler->callback = callback;
handler->playlist_callbacks = playlist_callbacks;
handler->userdata = userdata;
sp_playlist_add_callbacks(playlist, handler->playlist_callbacks, handler);
return handler;
}
void Spotify::changeCurrentPlaylist()
{
sp_error err;
sp_playlist * playlist;
if (currentPlaylistIdx < 0) {
return;
}
sp_playlistcontainer * pc = sp_session_playlistcontainer(sp);
if (currentPlaylistIdx >= sp_playlistcontainer_num_playlists(pc)) {
return;
}
switch (sp_playlistcontainer_playlist_type(pc, currentPlaylistIdx)) {
case SP_PLAYLIST_TYPE_PLAYLIST:
playlist = sp_playlistcontainer_playlist(pc, currentPlaylistIdx);
if (!playlist) {
fprintf(stderr, "Spotify: failed to get playlist\n");
break;
}
err = sp_playlist_add_callbacks(playlist, Spotify_Wrapper::playlistCallbacks(), NULL);
if (err != SP_ERROR_OK) {
fprintf(stderr, "Spotify: failed to add callbacks to playlist: %s\n",
sp_error_message(err));
}
if (currentPlaylist) {
sp_playlist_remove_callbacks(currentPlaylist, Spotify_Wrapper::playlistCallbacks(), NULL);
sp_playlist_release(currentPlaylist);
}
currentPlaylist = playlist;
sp_playlist_add_ref(currentPlaylist);
fprintf(stderr, "Spotify: switched to playlist %s\n",
sp_playlist_name(currentPlaylist));
tryLoadPlaylist();
break;
default:
fprintf(stderr, "Spotify: Tried to load a playlist that wasn't a playlist\n");
currentPlaylistIdx = -1;
break;
}
}
bool XplodifyPlaylist::load(sp_playlist * pl) {
if(!pl) {
return false;
}
m_playlist = pl;
sp_playlist_add_callbacks(pl, const_cast<sp_playlist_callbacks *>(&cbs), this);
if(!sp_playlist_is_loaded(pl))
{
m_loading = true;
} else {
m_loading = false; //already loaded.
load_tracks();
}
return true;
}
/**
* This callback is called when an attempt to login has succeeded or failed.
*
* @sa sp_session_callbacks#logged_in
*/
static void logged_in(sp_session *session, sp_error error)
{
sp_user *me;
const char *my_name;
if (SP_ERROR_OK != error) {
fprintf(stderr, "failed to log in to Spotify: %s\n",
sp_error_message(error));
sp_session_release(session);
exit(4);
}
// Let us print the nice message...
me = sp_session_user(session);
my_name = (sp_user_is_loaded(me) ? sp_user_display_name(me) : sp_user_canonical_name(me));
fprintf(stderr, "Logged in to Spotify as user %s\n", my_name);
sp_playlist *pl = sp_playlist_create(session, sp_link_create_from_string("spotify:user:devnevyn:playlist:44ZXlJstDZrwuQvWPOo7KX"));
empty_callbacks.playlist_state_changed = foo;
sp_playlist_add_callbacks(pl, &empty_callbacks, NULL);
}
static PyObject *Playlist__add_callback(Playlist *self, PyObject *args, sp_playlist_callbacks pl_callbacks) {
PyObject *callback;
PyObject *userdata = NULL;
playlist_callback_trampoline *tramp;
if(!PyArg_ParseTuple(args, "O|O", &callback, &userdata))
return NULL;
if (userdata == NULL) {
userdata = (PyObject *)Py_None;
Py_INCREF(Py_None);
}
Py_INCREF(callback);
Py_INCREF(userdata);
tramp = malloc(sizeof(playlist_callback_trampoline));
tramp->userdata = userdata;
tramp->callback = callback;
Py_BEGIN_ALLOW_THREADS
sp_playlist_add_callbacks(self->_playlist, &pl_callbacks, tramp);
Py_END_ALLOW_THREADS
Py_INCREF(Py_None);
return Py_None;
}
/**
* This callback is called when an attempt to login has succeeded or failed.
*
* @sa sp_session_callbacks#logged_in
*/
static void logged_in ( sp_session *sess, sp_error error )
{
sp_playlistcontainer *pc = sp_session_playlistcontainer ( sess );
int i;
if ( SP_ERROR_OK != error )
{
fprintf ( stderr, "jahspotify: Login failed: %s\n", sp_error_message ( error ) );
exit ( 2 );
}
fprintf ( stderr, "jahspotify: Login Success: %d\n", sp_playlistcontainer_num_playlists(pc));
for (i = 0; i < sp_playlistcontainer_num_playlists(pc); ++i) {
sp_playlist *pl = sp_playlistcontainer_playlist(pc, i);
sp_playlist_add_callbacks(pl, &pl_callbacks, NULL);
}
signalLoggedIn();
}
void SpotifyGuiController::RefreshPlaylistTracks ( sp_playlist *plist )
{
if ( plist && plist != selected_playlist )
{
if ( trackTree ) trackTree->removeAllItem();
SpotifyUserData *sp_data = (SpotifyUserData *)spotify_userdata;
//ho la playlist, carico le tracce
sp_playlist_add_callbacks(plist, sp_data->playlist_cb, this);
if ( sp_playlist_is_loaded(plist) )
{
//aggiungo tracce
int n_tracks = sp_playlist_num_tracks(plist);
for ( int nt = 0 ; nt < n_tracks ; nt++ )
{
sp_track *track = sp_playlist_track(plist, nt);
if ( track && sp_track_is_loaded(track) )
{
if ( trackTree )
{
TCHAR trackname[1001] = {0};
memset(trackname, 0, sizeof(TCHAR)*1001);
_sntprintf_s(trackname, 1000, TEXT("%hs"), sp_track_name(track));
trackTree->addItemAsLast(NULL, trackname, track, 0);
}
}
}
}
}
}
void browse_playlist(sp_playlist *pl)
{
playlist_browse = pl;
sp_playlist_add_callbacks(playlist_browse, &pl_callbacks, NULL);
playlist_browse_try();
}
static void playlist_added(sp_playlistcontainer *pc, sp_playlist *pl,
int position, void *userdata)
{
// printf("playlist_added: %s\n", sp_playlist_name(pl));
sp_playlist_add_callbacks(pl, &pl_callbacks, NULL);
}
