void QSpotifyPlaylistContainer::addPlaylist(sp_playlist *playlist, int pos) { if (playlist != sp_playlistcontainer_playlist(m_container, pos)) { int count = sp_playlistcontainer_num_playlists(m_container); for (int i = 0; i < count; ++i) { if (playlist == sp_playlistcontainer_playlist(m_container, i)) { pos = i; break; } } } sp_playlist_type type = sp_playlistcontainer_playlist_type(m_container, pos); QSpotifyPlaylist *pl = new QSpotifyPlaylist(QSpotifyPlaylist::Type(type), playlist); if (pos == -1) m_playlists.append(pl); else m_playlists.insert(pos, pl); if (type == SP_PLAYLIST_TYPE_START_FOLDER) { char buffer[200]; sp_playlistcontainer_playlist_folder_name(m_container, pos, buffer, 200); pl->m_name = QString::fromUtf8(buffer); } connect(pl, SIGNAL(nameChanged()), this, SIGNAL(playlistsNameChanged())); }
/** * 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 ); }
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 QSpotifyPlaylistContainer::updateData() { bool updated = false; if (m_playlists.isEmpty()) { int count = sp_playlistcontainer_num_playlists(m_container); for (int i = 0; i < count; ++i) { addPlaylist(sp_playlistcontainer_playlist(m_container, i), i); if(sp_playlistcontainer_playlist_type(m_container, i) == SP_PLAYLIST_TYPE_PLACEHOLDER) sp_playlistcontainer_remove_playlist(m_container, i); } updated = true; updatePlaylists(); } return updated; }
int cmd_update_subscriptions(int argc, char **argv) { int i; sp_playlistcontainer *pc = sp_session_playlistcontainer(g_session); sp_playlist *pl; subscriptions_updated = 1; for (i = 0; i < sp_playlistcontainer_num_playlists(pc); ++i) { switch (sp_playlistcontainer_playlist_type(pc, i)) { case SP_PLAYLIST_TYPE_PLAYLIST: pl = sp_playlistcontainer_playlist(pc, i); sp_playlist_update_subscribers(g_session, pl); break; default: break; } } return 1; }
static bool validate_complete_load() { if (g_list_container == NULL) { return false; } sp_playlistcontainer *list_container = g_list_container; int pl_count = sp_playlistcontainer_num_playlists(list_container); int i=0; for(; i < pl_count; i++) { sp_playlist *l = sp_playlistcontainer_playlist(list_container, i); sp_playlist_type type = sp_playlistcontainer_playlist_type(list_container, i); if (type == SP_PLAYLIST_TYPE_PLAYLIST && !sp_playlist_is_loaded(l)) { return false; } } sp_playlist *source_list = NULL; i=0; for(; i < pl_count; i++) { sp_playlist *l = sp_playlistcontainer_playlist(list_container, i); const char* pname = sp_playlist_name(l); if (strcmp(pname, playlist_name) == 0) { source_list = l; break; } } if (source_list == NULL) { fprintf(stderr, "Cannot find source list: %s\n", playlist_name); exit(1); } int nt = sp_playlist_num_tracks(source_list); i=0; for(; i < nt; i++) { sp_track *t = sp_playlist_track(source_list, i); sp_artist *a = sp_track_artist(t,0); // get first artist on track because I am lazy sp_album *al = sp_track_album(t); if (al == NULL || a == NULL) { return false; } } return true; }
static sp_playlist *find_album_playlist(sp_playlistcontainer *list_container, int *spiffify_start_index, int spiffify_end_index, sp_album *al) { if (al == NULL) { return NULL; } int j=*spiffify_start_index; sp_artist *a = sp_album_artist(al); const char *artist = sp_artist_name(a); int artist_end = 0; sp_uint64 artist_folder_id = 0; for(; j < spiffify_end_index; j++) { sp_playlist *p = sp_playlistcontainer_playlist(list_container, j); if (p == NULL) { continue; } sp_playlist_type type = sp_playlistcontainer_playlist_type(list_container,j); if (type == SP_PLAYLIST_TYPE_START_FOLDER) { char folder_name[256]; sp_error error = sp_playlistcontainer_playlist_folder_name(list_container, j, folder_name, 255); if (strcmp(folder_name, artist) == 0) { artist_folder_id = sp_playlistcontainer_playlist_folder_id(list_container, j); } } else if (type == SP_PLAYLIST_TYPE_END_FOLDER) { if (artist_folder_id == sp_playlistcontainer_playlist_folder_id(list_container, j)) { artist_end = j; } } const char *plname = sp_playlist_name(p); if (plname != NULL) { const char *alname = sp_album_name(al); if (strcmp(plname, alname) == 0) { return p; } } } // in the case where we don't yet have the playlist for this album and we are about to create it, send back the end of this artist folder if (artist_end != 0) { *spiffify_start_index = artist_end-1; } return NULL; }
int cmd_playlists(int argc, char **argv) { sp_playlistcontainer *pc = sp_session_playlistcontainer(g_session); int i, j, level = 0; sp_playlist *pl; char name[200]; printf("%d entries in the container\n", sp_playlistcontainer_num_playlists(pc)); for (i = 0; i < sp_playlistcontainer_num_playlists(pc); ++i) { switch (sp_playlistcontainer_playlist_type(pc, i)) { case SP_PLAYLIST_TYPE_PLAYLIST: printf("%d. ", i); for (j = level; j; --j) printf("\t"); pl = sp_playlistcontainer_playlist(pc, i); printf("%s", sp_playlist_name(pl)); if(subscriptions_updated) printf(" (%d subscribers)", sp_playlist_num_subscribers(pl)); printf("\n"); break; case SP_PLAYLIST_TYPE_START_FOLDER: printf("%d. ", i); for (j = level; j; --j) printf("\t"); sp_playlistcontainer_playlist_folder_name(pc, i, name, sizeof(name)); printf("Folder: %s with id %llu\n", name, sp_playlistcontainer_playlist_folder_id(pc, i)); level++; break; case SP_PLAYLIST_TYPE_END_FOLDER: level--; printf("%d. ", i); for (j = level; j; --j) printf("\t"); printf("End folder with id %llu\n", sp_playlistcontainer_playlist_folder_id(pc, i)); break; case SP_PLAYLIST_TYPE_PLACEHOLDER: printf("%d. Placeholder", i); break; } } return 1; }
void PlayListContainer::OnContainerLoaded() { LOG4CPLUS_DEBUG(logger, "OnContainerLoaded"); int num_playlists = sp_playlistcontainer_num_playlists(container_); boost::shared_ptr<PlayListElement> it_container = shared_from_this(); for (int i = 0; i < num_playlists; i++) { sp_playlist_type type = sp_playlistcontainer_playlist_type(container_, i); switch (type) { case SP_PLAYLIST_TYPE_PLAYLIST: { sp_playlist *p = sp_playlistcontainer_playlist(container_, i); boost::shared_ptr<PlayList> playlist = session_->CreatePlayList(); playlist->Load(p); it_container->AddPlayList(playlist); } break; case SP_PLAYLIST_TYPE_START_FOLDER: { boost::shared_ptr<PlayListFolder> folder = session_->CreatePlayListFolder(); folder->Load(container_, i); it_container->AddPlayList(folder); it_container = folder; } break; case SP_PLAYLIST_TYPE_END_FOLDER: it_container = it_container->GetParent(); break; case SP_PLAYLIST_TYPE_PLACEHOLDER: default: LOG4CPLUS_WARN(logger, "Unrecognized playlist type"); break; } } BOOST_ASSERT(it_container == shared_from_this()); }
ListResponse<PlaylistInfo*>* SpotifyPlaylistContainer::listPlaylists( PlaylistTask* task) { ListResponse<PlaylistInfo*>* response = new ListResponse<PlaylistInfo*>(); response->setListType(ListTypePlaylist); CommandInfo info = task->getCommandInfo(); bool sendName = ((info.ListFlags & Name) == Name); bool sendNumTracks = ((info.ListFlags & NumTracks) == NumTracks); bool sendDescription = ((info.ListFlags & Description) == Description); int numPlaylists = sp_playlistcontainer_num_playlists(playlistContainer); for (int i = 0; i < numPlaylists; i++) { if (sp_playlistcontainer_playlist_type(playlistContainer, i) == SP_PLAYLIST_TYPE_PLAYLIST) { sp_playlist* playlist = sp_playlistcontainer_playlist( playlistContainer, i); const char* name = sp_playlist_name(playlist); if (!(name[0] == '_' && name[1] == '_')) { PlaylistInfo* playlistInfo = new PlaylistInfo(); playlistInfo->id = i; if (sendName) { playlistInfo->name = name; } if (sendNumTracks) { playlistInfo->numTracks = sp_playlist_num_tracks(playlist); } if (sendDescription) { playlistInfo->description = sp_playlist_get_description( playlist); } response->addMember(playlistInfo); } } } return response; }
/** * Move playlists */ int sort_playlists(sp_session *session) { sp_playlistcontainer *pc = sp_session_playlistcontainer(session); sp_playlist_type playlist_type; int i, not_loaded = 0, num_playlists = 0; int *reorder; sp_playlist *pl; node *items, *parent, *previous; #ifdef TESTING playlist_item *faux_playlist; #endif num_playlists = sp_playlistcontainer_num_playlists(pc); items = previous = parent = NULL; #ifdef TESTING faux_playlist = (playlist_item*) malloc(sizeof(playlist_item) * num_playlists); #endif printf("Reordering %d playlists and playlist folders\n", num_playlists); for (i = 0; i < num_playlists; ++i) { playlist_type = sp_playlistcontainer_playlist_type(pc, i); switch (playlist_type) { case SP_PLAYLIST_TYPE_PLAYLIST: pl = sp_playlistcontainer_playlist(pc, i); if (!sp_playlist_is_loaded(pl)) { not_loaded++; } else { previous = create_node(previous, parent, create_playlist_item(i, sp_playlist_name(pl))); if (items == NULL) { items = previous; } } #ifdef TESTING faux_playlist[i].index = -1; faux_playlist[i].name = strdup(sp_playlist_name(pl)); #endif break; case SP_PLAYLIST_TYPE_START_FOLDER: parent = create_node(previous, parent, create_playlist_item(i, sp_playlistcontainer_playlist_folder_name(pc, i))); previous = NULL; if (items == NULL) { items = parent; } #ifdef TESTING faux_playlist[i].index = sp_playlistcontainer_playlist_folder_id(pc, i); faux_playlist[i].name = strdup(sp_playlistcontainer_playlist_folder_name(pc, i)); #endif break; case SP_PLAYLIST_TYPE_END_FOLDER: previous = parent; previous->item->end_index = i; parent = parent->parent; #ifdef TESTING faux_playlist[i].index = sp_playlistcontainer_playlist_folder_id(pc, i); faux_playlist[i].name = NULL; #endif break; case SP_PLAYLIST_TYPE_PLACEHOLDER: #ifdef TESTING printf("%d. Placeholder", i); faux_playlist[i].index = -1; faux_playlist[i].name = NULL; #endif break; } } if(not_loaded > 0) { printf("ERROR: %d playlists could not be loaded\n", not_loaded); return 1; } if(items != NULL) { items = sort_list(items); #ifdef TESTING print_list(items); #endif reorder = (int *) malloc(sizeof(int) * num_playlists); flatten_list(items, reorder); for(i = 0; i < num_playlists; ++i) { printf("."); if(i != reorder[i]) { #ifdef TESTING printf("Moving item at %d -> %d\n", reorder[i], i); move_playlist(faux_playlist, num_playlists, reorder[i], i); #else sp_playlistcontainer_move_playlist(pc, reorder[i], i); #endif recalculate_indexes(reorder, num_playlists, i); } } printf("\ndone\n"); free(reorder); free_list(items); } #ifdef TESTING for(i = 0; i < num_playlists; ++i) { if(faux_playlist[i].name != NULL) { printf(" -- %s (%d)\n", faux_playlist[i].name, faux_playlist[i].index); free((void*)faux_playlist[i].name); } else { printf(" -- %d\n", faux_playlist[i].index); } } free(faux_playlist); #endif return 1; }
sp_playlist_type playlist_type(int nb) { if (nb == 0) return SP_PLAYLIST_TYPE_PLAYLIST; else return sp_playlistcontainer_playlist_type(g_container, nb-1); }
static bool spiffify() { if (!validate_complete_load()) { return false; } sp_playlistcontainer *list_container = g_list_container; // check to see if all playlists have been loaded int pl_count = sp_playlistcontainer_num_playlists(list_container); int i=0; sp_playlist *source_list = NULL; sp_playlist *spiffify_list = NULL; char folder_name[256]; int spiffify_start_index = -1; int spiffify_end_index = -1; sp_uint64 spiffify_folder_id = -1; i=0; for(; i < pl_count; i++) { sp_playlist *l = sp_playlistcontainer_playlist(list_container, i); const char* pname = sp_playlist_name(l); if (strcmp(pname, playlist_name) == 0) { source_list = l; } sp_playlist_type type = sp_playlistcontainer_playlist_type(list_container, i); if (type == SP_PLAYLIST_TYPE_START_FOLDER) { sp_error error = sp_playlistcontainer_playlist_folder_name(list_container, i, folder_name, 256); if (error == SP_ERROR_OK) { if (strcmp(folder_name, SPIFFIFY_PLAYLIST_NAME) == 0) { spiffify_list = l; spiffify_start_index = i; spiffify_folder_id = sp_playlistcontainer_playlist_folder_id(list_container, i); } } } else if (type == SP_PLAYLIST_TYPE_END_FOLDER) { sp_uint64 id = sp_playlistcontainer_playlist_folder_id(list_container, i); if (id == spiffify_folder_id) { spiffify_end_index = i; } } } if (source_list == NULL) { fprintf(stderr, "Cannot find source list: %s\n", playlist_name); exit(1); } if (spiffify_list != NULL && spiffify_start_index != -1) { // smoke the list and start over every time.. it's just not worth the effort of inserting changes. int x=spiffify_end_index; for(; x >= spiffify_start_index; x--) { sp_playlistcontainer_remove_playlist(list_container, x); } spiffify_list = NULL; spiffify_start_index = -1; spiffify_end_index = -1; } pl_count = sp_playlistcontainer_num_playlists(list_container); // reset count. if (spiffify_list == NULL) { // make the Spiffify list for this user; sp_error error = sp_playlistcontainer_add_folder(list_container, pl_count, SPIFFIFY_PLAYLIST_NAME); if (error == SP_ERROR_OK) { spiffify_list = sp_playlistcontainer_playlist(list_container, pl_count); spiffify_start_index = pl_count; spiffify_end_index = spiffify_start_index+1; } if (spiffify_list == NULL) { fprintf(stderr, "Cannot create '%s' playlist\n", SPIFFIFY_PLAYLIST_NAME); exit(1); } } // iterate the source playlist int nt = sp_playlist_num_tracks(source_list); // allocate storage for tracks sp_track **tracks = (sp_track **) malloc(nt * sizeof(sp_track *)); i=0; for(; i < nt; i++) { sp_track *t = sp_playlist_track(source_list, i); tracks[i] = t; // store in the array } // :) mergesort(tracks, nt, sizeof(sp_track *), &compare_tracks); i=0; for(; i < nt; i++) { sp_track *t = tracks[i]; //sp_playlist_track(source_list, i); sp_artist *a = sp_track_artist(t,0); // get first artist on track because I am lazy // find artist folder inside our spiffify list bool haveartist = false; int j=spiffify_start_index; char artist[256]; if (a != NULL) { strcpy(artist, sp_artist_name(a)); } else { strcpy(artist, "Unknown Artist"); } for(; j < spiffify_end_index; j++) { sp_error error = sp_playlistcontainer_playlist_folder_name(list_container, j, folder_name, 256); if (strcmp(artist, folder_name) == 0) { haveartist = true; break; } } sp_album *al = sp_track_album(t); while (al == NULL) { printf("Cannot find album or it's not loaded.. forcing an event loop\n"); return false; } if (!haveartist) { int artist_pos = spiffify_end_index; sp_playlistcontainer_add_folder(list_container, artist_pos, artist); spiffify_end_index+=2; // a folder adds 2 indexes. pl_count = sp_playlistcontainer_num_playlists(list_container); sp_playlist* album = sp_playlistcontainer_add_new_playlist(list_container, sp_album_name(al)); sp_playlist_add_tracks(album, &t, 1, 0, session); sp_playlistcontainer_move_playlist(list_container, pl_count, artist_pos+1, false); spiffify_end_index++; // one more for the album. } else { int artist_pos = j; sp_playlist *albumpl = find_album_playlist(list_container, &artist_pos, spiffify_end_index, al); if (albumpl == NULL) { pl_count = sp_playlistcontainer_num_playlists(list_container); albumpl = sp_playlistcontainer_add_new_playlist(list_container, sp_album_name(al)); sp_playlistcontainer_move_playlist(list_container, pl_count, artist_pos+1, false); spiffify_end_index++; // one more for the album. } sp_playlist_add_tracks(albumpl, &t, 1, 0, session); } } free(tracks); return true; }