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