/** * Print the given track title together with some trivial metadata * * @param track The track object */ void print_track(sp_track *track) { int duration = sp_track_duration(track); char url[256]; sp_link *l; #if WIN32 printf(" %s ", sp_track_is_starred(track) ? "*" : " "); #else printf(" %s ", sp_track_is_starred(track) ? "★" : "☆"); #endif printf("Track %s [%d:%02d] has %d artist(s), %d%% popularity", sp_track_name(track), duration / 60000, (duration / 1000) / 60, sp_track_num_artists(track), sp_track_popularity(track)); if(sp_track_disc(track)) printf(", %d on disc %d", sp_track_index(track), sp_track_disc(track)); printf("\n"); l = sp_link_create_from_track(track, 0); sp_link_as_string(l, url, sizeof(url)); printf("\t\t%s\n", url); sp_link_release(l); }
// ---------------------------------------------------------------------------- // AudioStatus DMX_PLAYER_API GetTrackAudioInfo( LPCSTR track_link, AudioInfo* audio_info, DWORD wait_ms ) { CString spotify_link; memset( audio_info, 0, sizeof(AudioInfo) ); sp_track* track = theApp.m_spotify.linkToTrack( track_link ); if ( track == NULL ) return FAILED; sp_linktype link_type = theApp.m_spotify.getTrackLink( track, spotify_link ); if ( link_type == SP_LINKTYPE_TRACK ) return theApp.m_echonest.getTrackAudioInfo( spotify_link, audio_info, wait_ms ); if ( link_type == SP_LINKTYPE_LOCALTRACK ) { LPCSTR track_name = sp_track_name( track ); if ( track_name == NULL ) return FAILED; sp_artist *artist = sp_track_artist( track, 0 ); if ( artist == NULL ) return FAILED; LPCSTR artist_name = sp_artist_name( artist ); if ( artist_name == NULL ) return FAILED; return theApp.m_echonest.lookupTrackAudioInfo( track_name, artist_name, audio_info, wait_ms ); } return FAILED; }
/** * 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_link *link; if (SP_ERROR_OK != error) { fprintf(stderr, "Login failed: %s\n", sp_error_message(error)); exit(2); } printf("Loading track\n"); link = sp_link_create_from_string("spotify:track:5W3cjX2J3tjhG8zb6u0qHn"); sp_track_add_ref(g_currenttrack = sp_link_as_track(link)); sp_link_release(link); if (sp_track_error(g_currenttrack) == SP_ERROR_OK) { printf("Now playing \"%s\"...\n", sp_track_name(g_currenttrack)); fflush(stdout); sp_session_player_load(g_sess, g_currenttrack); sp_session_player_play(g_sess, 1); } /* Track not loaded? Then we need to wait for the metadata to load before we can start playback (see below) */ }
int cmd_playlist(int argc, char **argv) { int index, i; sp_track *track; sp_playlist *playlist; sp_playlistcontainer *pc = sp_session_playlistcontainer(g_session); if (argc < 1) { printf("playlist [playlist index]\n"); return 0; } index = atoi(argv[1]); if (index < 0 || index > sp_playlistcontainer_num_playlists(pc)) { printf("invalid index\n"); return 0; } playlist = sp_playlistcontainer_playlist(pc, index); printf("Playlist %s by %s%s%s\n", sp_playlist_name(playlist), sp_user_display_name(sp_playlist_owner(playlist)), sp_playlist_is_collaborative(playlist) ? " (collaborative)" : "", sp_playlist_has_pending_changes(playlist) ? " with pending changes" : "" ); for (i = 0; i < sp_playlist_num_tracks(playlist); ++i) { track = sp_playlist_track(playlist, i); printf("%d. %c %s%s %s\n", i, sp_track_is_starred(g_session, track) ? '*' : ' ', sp_track_is_local(g_session, track) ? "local" : " ", sp_track_is_autolinked(g_session, track) ? "autolinked" : " ", sp_track_name(track)); } return 1; }
bool SpotifySong::updateMetadata() { if(sp_track_is_loaded(this->track)) { this->duration = sp_track_duration(this->track); this->title = sp_track_name(this->track); if(this->artist == nullptr) { this->artist = sp_track_artist(this->track,0); sp_artist_add_ref(this->artist); } if(this->album == nullptr) { this->album = sp_track_album(this->track); sp_album_add_ref(this->album); } } else return false; if(this->artist != nullptr && sp_artist_is_loaded(this->artist)) this->artistName = sp_artist_name(this->artist); else return false; if(this->album != nullptr && sp_album_is_loaded(this->album)) this->albumName = sp_album_name(this->album); else return false; return true; }
static PyObject * Track_name(Track * self) { const char *s = sp_track_name(self->_track); return PyUnicode_FromString(s); }
//---------------------------------------------- // get track info from URI //---------------------------------------------- TRef TLSpotify::TSession::FindTrack(const TString& URI) { THeapArray<char> UriString; URI.GetAnsi( UriString ); // find link sp_link *link = sp_link_create_from_string( UriString.GetData() ); if (!link) return TRef(); // get track from the link sp_track* pTrack = sp_link_as_track( link ); if ( !pTrack ) { TDebugString Debug_String; Debug_String << "URI " << URI << " is not a track"; TLDebug_Print( Debug_String ); return TRef(); } // create new track info TRef TrackRef = AddTrack( *pTrack ); const char* TrackName = sp_track_name( pTrack ); // The create function will have increased the reference count for us so release sp_link_release(link); return TrackRef; }
ListResponse<TrackInfo*>* SpotifyPlaylistContainer::listTracks( PlaylistTask* task) { ListResponse<TrackInfo*>* response = new ListResponse<TrackInfo*>(); response->setListType(ListTypeSong); ListPlaylistTrackInfo info = task->getCommandInfo().listPlaylistTrackInfo; int playlistId = info.playlist; if (playlistId > -1 && playlistId < sp_playlistcontainer_num_playlists(playlistContainer)) { bool sendName = ((info.trackInfoFlags & TrackInfoName) == TrackInfoName); bool sendArtist = ((info.trackInfoFlags & TrackInfoArtists) == TrackInfoArtists); bool sendAlbum = ((info.trackInfoFlags & TrackInfoAlbum) == TrackInfoAlbum); bool sendDuration = ((info.trackInfoFlags & TrackInfoDuration) == TrackInfoDuration); bool sendArtwork = ((info.trackInfoFlags & TrackInfoArtwork) == TrackInfoArtwork); sp_playlist* playlist = sp_playlistcontainer_playlist(playlistContainer, playlistId); int numTracks = sp_playlist_num_tracks(playlist); for (int i = 0; i < numTracks; i++) { TrackInfo* trackInfo = new TrackInfo(); trackInfo->id = i; sp_track* track = sp_playlist_track(playlist, i); if (sendName) { trackInfo->name = sp_track_name(track); } if (sendArtist) { trackInfo->numArtists = sp_track_num_artists(track); trackInfo->artists = new const char*[trackInfo->numArtists]; for (int j = 0; j < trackInfo->numArtists; j++) { trackInfo->artists[j] = sp_artist_name( sp_track_artist(track, j)); } } if (sendAlbum) { trackInfo->album = sp_album_name(sp_track_album(track)); } if (sendDuration) { trackInfo->duration = sp_track_duration(track); } if (sendArtwork) { trackInfo->artwork = sp_image_create(session, sp_album_cover(sp_track_album(track), SP_IMAGE_SIZE_NORMAL)); } response->addMember(trackInfo); } return response; } delete response; return nullptr; }
static PyObject * Track_str(PyObject *oself) { Track *self = (Track *) oself; const char *s = sp_track_name(self->_track); return PyUnicode_FromString(s); }
void SpotifyGuiController::StartPlaying() { if ( logButton ) logButton->setEnableState(FALSE); if ( playlistTree ) playlistTree->setEnableState(FALSE); if ( trackTree ) trackTree->setEnableState(FALSE); if ( logWin ) { if ( selected_track ) logWin->addRow(TEXT("Playing %hs..."), sp_track_name(selected_track)); else logWin->addRow(TEXT("Playing, no track selected...")); } }
// ---------------------------------------------------------------------------- // bool DMX_PLAYER_API GetTrackInfo( LPCSTR track_link, LPSTR track_name, size_t track_name_size, LPSTR artist_name, size_t artist_name_size, LPSTR album_name, size_t album_name_size, DWORD* track_duration_ms, bool* starred ) { AFX_MANAGE_STATE(AfxGetStaticModuleState()); sp_track* track = theApp.m_spotify.linkToTrack( track_link ); if ( !track ) return false; if ( track_name ) { LPCSTR title = sp_track_name( track ); if ( title == NULL ) return false; errno_t err = strncpy_s( track_name, track_name_size, title, strlen(title) ); if ( err != 0 ) return false; } if ( artist_name ) { if ( sp_track_num_artists( track ) == 0 ) *artist_name = '\0'; else { sp_artist *artist = sp_track_artist( track, 0 ); if ( artist == NULL ) return false; LPCSTR title = sp_artist_name( artist ); errno_t err = strncpy_s( artist_name, artist_name_size, title, strlen(title) ); if ( err != 0 ) return false; } } if ( album_name ) { sp_album *album = sp_track_album( track ); if ( album == NULL ) return false; LPCSTR title = sp_album_name( album ); errno_t err = strncpy_s( album_name, album_name_size, title, strlen(title) ); if ( err != 0 ) return false; } if ( track_duration_ms ) *track_duration_ms = theApp.m_spotify.getTrackLength( track ); if ( starred ) *starred = theApp.m_spotify.isTrackStarred( track ); return true; }
/** * Callback called when libspotify has new metadata available * * @sa sp_session_callbacks#metadata_updated */ static void metadata_updated(sp_session *sess) { puts("Metadata updated, trying to start playback"); if (sp_track_error(g_currenttrack) != SP_ERROR_OK) return; printf("Now playing \"%s\"...\n", sp_track_name(g_currenttrack)); fflush(stdout); sp_session_player_load(g_sess, g_currenttrack); sp_session_player_play(g_sess, 1); }
/* * Print the full queue */ void queue_print(struct play_queue *node) { printf("printing queue\n"); printf("queue size: %d\n", queue_entry->size); struct play_queue *current = queue_entry->head; int i; while(current != NULL) { printf("%d: %s\n", i++, sp_track_name(current->track)); current = current->next; } printf("done!\n"); }
void TLSpotify::TTrack::UpdateInfo() { if ( m_pTrack ) m_Title = sp_track_name( m_pTrack ); // just verify the loaded state if ( IsReady() && !sp_track_is_loaded( m_pTrack ) ) { TLDebug_Break("track not loaded"); m_Loaded = SyncFalse; } // unknown data if ( !IsReady() ) { m_Title = "???"; return; } // get info m_Title = sp_track_name( m_pTrack ); /* sp_album* pAlbum = sp_track_album( m_pTrack ); m_Album = pAlbum ? pAlbum-> // enum artists int ArtistCount = sp_track_num_artists( m_pTrack ); if ( ArtistCount == 0 ) m_Artist = "???"; for ( u32 a=0; a<ArtistCount; a++ ) { sp_artist* pArtist = sp_track_artist( m_pTrack, a ); if ( !pArtist ) m_Artist << "???"; else m_Artist << pArtist-> */ }
char *getTrackInfos( void ) { TRACE_2( PLAYERMANAGER , "getTrackInfo()."); char *buff = ( char * )zmalloc( 512 * sizeof( char ) ); LOCK_MUTEX( PLAYERMANAGER , &mutexSession ); //If the return of sp_track_name is a empty string, then an error occured if( strcmp( sp_track_name( currentTrack ) , "" ) == 0 ) { snprintf( buff , 512 , "Cannot get metadata from track."); } else { sprintf( buff , "%s , %s , %s" , sp_track_name( currentTrack ) , sp_artist_name( sp_track_artist( currentTrack , 0 ) ) , sp_album_name( sp_track_album( currentTrack ) ) ); } UNLOCK_MUTEX( PLAYERMANAGER , &mutexSession ); return buff; }
SxTrack::SxTrack(sp_track *spTrack) { // Logger::printOut("creating track"); // Logger::printOut(sp_track_name(spSxTrack)); while (!sp_track_is_loaded(spTrack)) ; //Logger::printOut("creating track loaded"); m_references = 1; m_spTrack = spTrack; m_name = sp_track_name(spTrack); m_rating = ceil((float)sp_track_popularity(spTrack) / 10); m_duration = 0.001 * sp_track_duration(spTrack); m_trackNumber = sp_track_index(spTrack); m_albumName = ""; m_albumArtistName = ""; m_year = 0; m_thumb = NULL; m_hasTHumb = false; //load the album and release it when we have harvested all data we need sp_album * album = sp_track_album(spTrack); if (sp_album_is_loaded(album)) { SxAlbum* sAlbum = AlbumStore::getInstance()->getAlbum(sp_track_album(spTrack), false); m_thumb = sAlbum->getThumb(); m_albumName = sAlbum->getAlbumName(); m_albumArtistName = sAlbum->getAlbumArtistName(); m_year = sAlbum->getAlbumYear(); //release it again AlbumStore::getInstance()->removeAlbum(sAlbum); if (m_thumb != NULL) { m_thumb->addRef(); m_hasTHumb = true; } } else Logger::printOut("no album loaded for track"); m_artistName = sp_artist_name(sp_track_artist(spTrack, 0)); sp_link *link = sp_link_create_from_track(spTrack, 0); m_uri = new char[256]; sp_link_as_string(link, m_uri, 256); sp_link_release(link); }
void SpotifySearch::addSearchedTrack( sp_search *result, void *userdata) { qDebug() << Q_FUNC_INFO; sp_playlist *playlist = reinterpret_cast<sp_playlist*>(userdata); if(!sp_playlist_is_loaded( playlist ) ) { qDebug() << "Search Playlist is not loaded"; return; } // Need to pass a ** to add_tracks sp_track **tracks = static_cast<sp_track **>(malloc(sizeof(sp_track*))); if( sp_search_num_tracks( result ) > 0 ) { int num = qMin( sp_search_num_tracks( result ), 1 ); for( int i = 0; i < num; i++ ) { sp_track *const tr = sp_search_track( result, i ); if( !tr || !sp_track_is_loaded( tr ) ) { qDebug() << "Got still loading track, skipping"; continue; } qDebug() << "Adding track to playlist" << sp_track_name( tr ); *(tracks++) = tr; sp_error err = sp_playlist_add_tracks(playlist, tracks, 1, sp_playlist_num_tracks( playlist ), SpotifySession::getInstance()->Session()); switch(err) { case SP_ERROR_OK: qDebug() << "Added tracks to pos" << sp_playlist_num_tracks( playlist )-1; break; case SP_ERROR_INVALID_INDATA: qDebug() << "Invalid position"; break; case SP_ERROR_PERMISSION_DENIED: qDebug() << "Access denied"; break; default: qDebug() << "Other error (should not happen)"; break; } } } delete []tracks; }
json_t *track_to_json(sp_track *track, json_t *object) { char uri[kTrackLinkLength]; sp_link *link = sp_link_create_from_track(track, 0); sp_link_as_string(link, uri, kTrackLinkLength); sp_link_release(link); json_object_set_new(object, "uri", json_string_nocheck(uri)); if (!sp_track_is_loaded(track)) return object; const char *name = sp_track_name(track); json_object_set_new(object, "title", json_string_nocheck(name)); return object; }
static void image_loaded(sp_image *img, void *user) { gazify_t *g = (gazify_t*)user; size_t img_size; const void *data = sp_image_data(img,&img_size); sp_artist *a = sp_track_artist(g->current_t,0); sp_album *alb = sp_track_album(g->current_t); g->g->postTrackInfo(sp_artist_name(a),sp_album_name(alb),sp_track_name(g->current_t),data,img_size); //sp_image_remove_load_callback(img,&image_loaded,user); // sp_image_release(img); //fiuckit, let's leak! }
/** * Called on various events to start playback if it hasn't been started already. * * The function simply starts playing the first track of the playlist. */ static void try_jukebox_start(void) { sp_track *t; if (!g_jukeboxlist) return; if (!sp_playlist_num_tracks(g_jukeboxlist)) { fprintf(stderr, "jukebox: No tracks in playlist. Waiting\n"); return; } if (sp_playlist_num_tracks(g_jukeboxlist) < g_track_index) { fprintf(stderr, "jukebox: No more tracks in playlist. Waiting\n"); return; } t = sp_playlist_track(g_jukeboxlist, g_track_index); if (g_currenttrack && t != g_currenttrack) { /* Someone changed the current track */ audio_fifo_flush(&g_audiofifo); sp_session_player_unload(g_sess); g_currenttrack = NULL; } if (!t) return; if (sp_track_error(t) != SP_ERROR_OK) return; if (g_currenttrack == t) return; g_currenttrack = t; printf("jukebox: Now playing \"%s\"...\n", sp_track_name(t)); fflush(stdout); sp_session_player_load(g_sess, t); sp_session_player_play(g_sess, 1); }
static void try_playback_start(void) { sp_track *t; if(amtSongs() == 0) { fprintf(stderr, "Playlist: No tracks in playlist. Waiting\n"); return; } t = sp_link_as_track(firstSong->song); if(g_currenttrack && t != g_currenttrack) { audio_fifo_flush(&g_audiofifo); sp_session_player_unload(g_sess); g_currenttrack = NULL; } if(!t) { printf("Null Song\n"); fflush(stdout); return; } int next_timeout = 0; sp_session_process_events(g_sess, &next_timeout); while(sp_track_error(t) != SP_ERROR_OK) { sp_session_process_events(g_sess, &next_timeout); printf("Loading Track...\n"); usleep(100000); } if(sp_track_error(t) != SP_ERROR_OK) { printf("SP_ERRoR\n"); printf("%i\n", sp_track_error(t)); fflush(stdout); return; } if(g_currenttrack == t) { printf("Coninuting same track\n"); fflush(stdout); return; } g_currenttrack = t; printf("Partyfy: Now playing \"%s\"...\n", sp_track_name(t)); fflush(stdout); sp_session_player_load(g_sess, t); sp_session_player_play(g_sess, 1); }
static int spfs_open(const char *path, struct fuse_file_info *fi) { file_t *file = find_file(path + 1); if(!file) return -ENOENT; if(!track_ended) sp_session_player_unload(session); printf("Spotify: Loading %s by %s\n", sp_track_name(file->track), sp_artist_name(sp_track_artist(file->track, 0))); sp_session_player_load(session, file->track); sp_session_player_play(session, 1); write_wav_header(frame_buf); frame_buf_size = 44; track_ended = 0; return 0; }
void Spotify::tryLoadPlaylist() { if ((currentPlaylistIdx < 0) || (currentPlaylist == 0)) { return; } if (sp_playlist_is_loaded(currentPlaylist)) { QList<SpotifyTrackInfo> tracks; int numTracks = sp_playlist_num_tracks(currentPlaylist); for (int idx = 0; idx < numTracks; ++idx) { sp_track * track = sp_playlist_track(currentPlaylist, idx); if (!track) { fprintf(stderr, "Spotify: failed to get track #%d\n", idx + 1); continue; } QString name(sp_track_name(track)); if (name.isEmpty()) { fprintf(stderr, "Spotify: got empty track name\n"); continue; } SpotifyTrackInfo info; info.name = name; info.URI = uriFromTrack(track); if (info.URI.isEmpty()) { continue; } tracks.append(info); } emit currentPlaylistUpdated(tracks); fprintf(stderr, "Spotify: loaded playlist %s (%d tracks)\n", sp_playlist_name(currentPlaylist), tracks.size()); } }
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); } } } } } }
static void search_complete(sp_search *result, void *userdata) { sp_track *track; sp_artist *artist; int i; (void)userdata; if (sp_search_error(result) == SP_ERROR_OK) { for (i = 0; i < sp_search_num_tracks(result); ++i) { track = sp_search_track(result, i); artist = sp_track_artist(track, 0); printf("%d. %s - %s\n", i, sp_track_name(track), sp_artist_name(artist)); } fflush(stdout); } else { fprintf(stderr, "failed to search: %s", sp_error_message(sp_search_error(result))); } sp_search_release(result); }
void SpotWorker::saveFile(sp_track *track, SoundSaver::FileType nextFile) { /* Close previous file * This should be done by both the soundsaver and the spotworker * so this code is probably triple redundant. Wear seatbelts! */ if(soundSaver_){ DEBUG printf("Closing open file...\n"); soundSaver_->close(); DEBUG printf("Closed!\n"); } //start a new file DEBUG printf("Extracting filename from track...\n"); sp_artist *tartist = sp_track_artist(track, 0); const char *artistName = sp_artist_name(tartist); const char *trackName = sp_track_name(track); QString fileName("./"); fileName += QString(QString().fromUtf8(artistName)) + " - " + QString(QString().fromUtf8(trackName)); DEBUG printf("Making new soundsaver...\n"); soundSaver_->open(fileName.toUtf8().data(), nextFile); DEBUG printf("Soundsaver made. returning...\n"); }
void track_get_data(sp_track* track, gchar** name, gchar** artist, gchar** album, gchar** link, guint* duration, int* popularity) { sp_artist** art = NULL; sp_album* alb = NULL; sp_link* lnk; int i; int nb_art = 0; const char* s; sp_track_add_ref(track); if (!sp_track_is_loaded(track)) { sp_track_release(track); return; } /* Begin loading everything */ if (name) { *name = g_strdup(sp_track_name(track)); } if (artist) { nb_art = sp_track_num_artists(track); art = (sp_artist**) malloc(nb_art * sizeof(sp_artist*)); if (!art) g_error("Can't allocate memory."); for (i=0; i < nb_art; i++) { art[i] = sp_track_artist(track, i); sp_artist_add_ref(art[i]); } } if (album) { alb = sp_track_album(track); sp_album_add_ref(alb); } if (link) { GString* tmp; lnk = sp_link_create_from_track(track, 0); if (!lnk) g_error("Can't get URI from track."); tmp = g_string_sized_new(1024); if (sp_link_as_string(lnk, tmp->str, 1024) < 0) g_error("Can't render URI from link."); *link = tmp->str; g_string_free(tmp, FALSE); sp_link_release(lnk); } if (duration) { *duration = sp_track_duration(track); } if (popularity) { *popularity = sp_track_popularity(track); } /* Now create destination strings */ if (artist) { GString* tmp = g_string_new(""); for (i=0; i < nb_art; i++) { if (sp_artist_is_loaded(art[i])) s = sp_artist_name(art[i]); else s = "[artist not loaded]"; if (i != 0) g_string_append(tmp, ", "); g_string_append(tmp, s); sp_artist_release(art[i]); } *artist = tmp->str; g_string_free(tmp, FALSE); } if (album) { if (sp_album_is_loaded(alb)) *album = g_strdup(sp_album_name(alb)); else *album = g_strdup("[album not loaded]"); sp_album_release(alb); } sp_track_release(track); }
/** * Append the JSON representing the track to param json. * * Returns TRUE if success - FALSE otherwise */ int track_to_json(sp_track* track, char** json, int* json_size, int count) { int track_info_size = 256; char* append = malloc(track_info_size * sizeof(char)); memset(append, '\0', track_info_size * sizeof(char)); if (append == NULL) { fprintf(stderr, "Failed to allocate memory for track info.\n"); return FALSE; } // Print track here (watch for quotes!) strcat(append, "{\"track_name\":\""); append_string_cleanse(&append, &track_info_size, sp_track_name(track)); int j; int nArtists = sp_track_num_artists(track); // Print artists here (watch for quotes!) strcat_resize(&append, &track_info_size, "\",\"artists\":[\""); for (j=0; j<nArtists; j++) { sp_artist *artist = sp_track_artist(track, j); if (artist == NULL) { fprintf(stderr, "track artist retrieved was null.\n"); if (append) free(append); return FALSE; } append_string_cleanse(&append, &track_info_size, sp_artist_name(artist)); if (j < nArtists - 1) strcat_resize(&append, &track_info_size, "\",\""); // sp_artist_release(artist); } // Print album here (watch for quotes!) strcat_resize(&append, &track_info_size, "\"],\"album\":\""); sp_album *album = sp_track_album(track); append_string_cleanse(&append, &track_info_size, sp_album_name(album)); // sp_album_release(album); // Print track url here (probably safe to assume there are no quotes here...) strcat_resize(&append, &track_info_size, "\",\"track_url\":\""); sp_link *l; char url[256]; l = sp_link_create_from_track(track, 0); sp_link_as_string(l, url, sizeof(url)); strcat_resize(&append, &track_info_size, url); // sp_link_release(l); char votes[5]; sprintf(votes, "%d", count); strcat_resize(&append, &track_info_size, "\",\"votes\":\""); strcat_resize(&append, &track_info_size, votes); strcat_resize(&append, &track_info_size, "\"}"); // close track_url quotes strcat_resize(json, json_size, append); if (append) free(append); return TRUE; }
LRESULT SpotifyGuiController::executeMessage(UINT idcontrol, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) { SpotifyUserData *data = (SpotifyUserData *)spotify_userdata; switch ( idcontrol ) { case LOGBUTTON_ID: { if ( data && data->spotify_logged_in ) { //logout int ret = SpotifyLogOut(data); if ( ret ) { //comando inviato, attendo logButton->setEnableState(FALSE); } } else { char username[10001]; char password[10001]; memset(username, 0, 10001); memset(password, 0, 10001); if (!usernameEdit->GetText(username, 10000)) { logWin->addRow(TEXT("Errore username")); return 0; } if (!passwordEdit->GetText(password, 10000)) { logWin->addRow(TEXT("Errore password")); return 0; } int ret = SpotifyLogIn((SpotifyUserData *)data, username, password); if ( ret ) { //comando inviato attendo logButton->setEnableState(FALSE); } } } break; case DOWNLOADBUTTON_ID: { if (selected_track) { //SpotifyDownloadTrack(data, selected_track); //if (logWin) logWin->addRow(TEXT("Inizio download %s"), sp_track_name(selected_track)); //avvio il download della prima traccia della treeview //creo una lista di tracce data->num_tracks = downloadListTree->getItemCount(); if (data->num_tracks <= 0) return 0; if (data->tracks) free(data->tracks); data->tracks = NULL; data->tracks = (sp_track **)malloc(sizeof(sp_track *) * data->num_tracks); HTREEITEM item = downloadListTree->getRootItem(); for (int k = 0; k < data->num_tracks; k++) { data->tracks[k] = (sp_track *)downloadListTree->getExtraData(item); item = downloadListTree->getNextHItem(item); } //avvio download SpotifyDownloadTracks(data); } } break; case PLAYLIST_ID: { if ( WM_NOTIFY == msg && TVN_SELCHANGED == ((LPNMHDR)lParam)->code ) { if ( playlistTree ) { HTREEITEM item = playlistTree->getSelected(); if ( item ) { sp_playlist *plist = (sp_playlist *)playlistTree->getExtraData(item); if ( plist ) { RefreshPlaylistTracks(plist); selected_playlist = plist; } } } } } break; case TRACK_ID: { if ( WM_NOTIFY == msg && TVN_SELCHANGED == ((LPNMHDR)lParam)->code ) { if ( trackTree ) { HTREEITEM item = trackTree->getSelected(); if ( item ) { sp_track *track = (sp_track *)trackTree->getExtraData(item); selected_track = track; } } } else if (WM_NOTIFY == msg && NM_DBLCLK == ((LPNMHDR)lParam)->code) { if (downloadListTree) { HTREEITEM item = trackTree->getSelected(); if (item) { sp_track *track = (sp_track *)playlistTree->getExtraData(item); TCHAR mess[1001]; memset(mess, 0, 1001); _sntprintf_s(mess, 1000, TEXT("%hs"), sp_track_name(track)); downloadListTree->addItemAsLast(NULL, mess, track, NULL); } } } } break; case DOWNLOADLIST_ID: { } break; } return 0; }
std::string Track::GetName() { const char* name = sp_track_name( m_pTrack ); return name; }