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; }
static PyObject * User_display_name(User * self) { const char *s = sp_user_display_name(self->_user); return PyUnicode_FromString(s); }
const char* SxPlaylist::getOwnerName() { sp_user* user = sp_playlist_owner(m_spPlaylist); if (user != sp_session_user(Session::getInstance()->getSpSession())) { return sp_user_display_name(user); } return NULL; }
static PyObject *Session_display_name(Session *self) { sp_user *user; user = sp_session_user(self->_session); if(user == NULL) return NULL; const char *username = sp_user_display_name(user); return PyString_FromString(username); };
static PyObject * Session_display_name(PyObject *self) { sp_user *user = sp_session_user(Session_SP_SESSION(self)); if (user == NULL) { PyErr_SetString(SpotifyError, "Not logged in"); return NULL; } return PyUnicode_FromString(sp_user_display_name(user)); };
static PyObject * Session_display_name(Session * self) { sp_user *user; user = sp_session_user(self->_session); if (user == NULL) { PyErr_SetString(SpotifyError, "Not logged in"); return NULL; } const char *username = sp_user_display_name(user); return PyUnicode_FromString(username); };
static void sess_cb_logged_in(sp_session *sess, sp_error err) { if (err == SP_ERROR_OK) { g_session.state = SESS_ONLINE; log_append("Logged in as \"%s\"", sp_user_display_name(sp_session_user(sess))); ui_dirty(UI_FOOTER); ui_show(UI_SET_BROWSER); } else { g_session.state = SESS_ERROR; log_append(sp_error_message(err)); ui_dirty(UI_FOOTER); ui_show(UI_SET_LOG); } }
bool QSpotifyUser::updateData() { QString canonicalName = QString::fromUtf8(sp_user_canonical_name(m_sp_user)); QString displayName = QString::fromUtf8(sp_user_display_name(m_sp_user)); bool updated = false; if (m_canonicalName != canonicalName) { m_canonicalName = canonicalName; updated = true; } if (m_displayName != displayName) { m_displayName = displayName; updated = true; } return updated; }
static void spotify_cb_logged_in (sp_session *spotify_session, sp_error error) { if (SP_ERROR_OK != error) { GST_CAT_ERROR_OBJECT (gst_spot_src_debug_cb, ugly_spot, "Failed to log in to Spotify: %s", sp_error_message (error)); return; } sp_user *me = sp_session_user (spotify_session); const char *my_name = (sp_user_is_loaded (me) ? sp_user_display_name (me) : sp_user_canonical_name (me)); GST_CAT_DEBUG_OBJECT (gst_spot_src_debug_cb, ugly_spot, "Logged_in callback, user=%s", my_name); /* set default bitrate to audiofility */ sp_session_preferred_bitrate(spotify_session, SP_BITRATE_320k); GST_SPOT_SRC_LOGGED_IN (ugly_spot) = 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); }
void SpotifyUser::updateData() { bool updated = false; QString canonicalName = QString::fromUtf8(sp_user_canonical_name(m_spUser)); QString displayName = QString::fromUtf8(sp_user_display_name(m_spUser)); bool loaded = sp_user_is_loaded(m_spUser); if(exchange(canonicalName, m_canonicalName)) { updated = true; } if(exchange(displayName, m_displayName)) { updated = true; } if(exchange(m_loaded, loaded)) { updated = 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 void sess_callback_logged_in(sp_session *session, sp_error error) { sp_user *user; if(error != SP_ERROR_OK) { syslog(LOG_ERR, "Session: Login failed with error: %s", sp_error_message(error)); /* The logout callback is called automatically in libspotify 12 */ return; } user = sp_session_user(session); if(user != NULL) { syslog(LOG_INFO, "Session: Successfully logged in as user %s <%s>", sp_user_display_name(user), sp_user_canonical_name(user)); } /* No point in sharing usage from this program */ syslog(LOG_DEBUG, "Session: enabling private listening mode"); sp_session_set_private_session(session, 1); /* Notify app of login to hook up rootlist callbacks */ app_post_event(APP_LOGGED_IN); }
/** * 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)); 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); // Below are parts related to the playlist manager // error == OK is true by now. logged_in_playlist(session); start_prompt(); }
jobject createJPlaylist(JNIEnv *env, sp_playlist *playlist) { jclass jClass; jobject playlistInstance; jmethodID jMethod; jClass = (*env)->FindClass(env, "jahspotify/media/Playlist"); if (jClass == NULL) { fprintf(stderr,"jahspotify::createJPlaylist: could not load jahnotify.media.Playlist\n"); return NULL; } playlistInstance = (*env)->AllocObject(env,jClass); if (!playlistInstance) { fprintf(stderr,"jahspotify::createJPlaylist: could not create instance of jahspotify.media.Playlistt\n"); return NULL; } sp_link *playlistLink = sp_link_create_from_playlist(playlist); if (playlistLink) { jobject playlistJLink = createJLinkInstance(env,playlistLink); setObjectObjectField(env,playlistInstance,"id","Ljahspotify/media/Link;",playlistJLink); sp_link_release(playlistLink); } setObjectStringField(env,playlistInstance,"name",sp_playlist_name(playlist)); sp_user *owner = sp_playlist_owner(playlist); if (owner) { setObjectStringField(env,playlistInstance,"author",sp_user_display_name(owner)); sp_user_release(owner); } // Lookup the method now - saves us looking it up for each iteration of the loop jMethod = (*env)->GetMethodID(env,jClass,"addTrack","(Ljahspotify/media/Link;)V"); if (jMethod == NULL) { fprintf(stderr,"jahspotify::createJPlaylist: could not load method addTrack(track) on class Playlist\n"); return NULL; } int numTracks = sp_playlist_num_tracks(playlist); int trackCounter = 0; for (trackCounter = 0 ; trackCounter < numTracks; trackCounter++) { sp_track *track = sp_playlist_track(playlist,trackCounter); 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); // Add it to the playlist (*env)->CallVoidMethod(env,playlistInstance,jMethod,trackJLink); sp_link_release(trackLink); } sp_track_release(track); } } return playlistInstance; }
JNIEXPORT jobject JNICALL Java_jahspotify_impl_JahSpotifyImpl_retrieveUser (JNIEnv *env, jobject obj) { sp_user *user = sp_session_user(g_sess); const char *value = NULL; int country = 0; while (!sp_user_is_loaded(user)) { fprintf ( stderr, "jahspotify::Java_jahspotify_impl_JahSpotifyImpl_retrieveUser: waiting for user to load\n" ); sleep(1); } jclass jClass = (*env)->FindClass(env, "jahspotify/media/User"); if (jClass == NULL) { fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_retrieveUser: could not load jahnotify.media.User\n"); return NULL; } jobject userInstance = (*env)->AllocObject(env,jClass); if (!userInstance) { fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_retrieveUser: could not create instance of jahspotify.media.User\n"); return NULL; } while (!sp_user_is_loaded(user)) { sleep(1); } if (sp_user_is_loaded(user)) { fprintf ( stderr, "jahspotify::Java_jahspotify_impl_JahSpotifyImpl_retrieveUser: user is loaded\n" ); value = sp_user_full_name(user); if (value) { setObjectStringField(env,userInstance,"fullName",value); } value = sp_user_canonical_name(user); if (value) { setObjectStringField(env,userInstance,"userName",value); } value = sp_user_display_name(user); if (value) { setObjectStringField(env,userInstance,"displayName",value); } value = sp_user_picture(user); if (value) { setObjectStringField(env,userInstance,"imageURL",value); } // Country encoded in an integer 'SE' = 'S' << 8 | 'E' country = sp_session_user_country(g_sess); char countryStr[] = " "; countryStr[0] = (byte)(country >> 8); countryStr[1] = (byte)country; setObjectStringField(env,userInstance,"country",countryStr); return userInstance; } return NULL; }
json_t *playlist_to_json(sp_playlist *playlist, json_t *object) { assert(sp_playlist_is_loaded(playlist)); // Owner sp_user *owner = sp_playlist_owner(playlist); const char *username = sp_user_display_name(owner); sp_user_release(owner); json_object_set_new_nocheck(object, "creator", json_string_nocheck(username)); // URI size_t playlist_uri_len = strlen("spotify:user:"******":playlist:") + strlen("284on3DVWeAxWkgVuzZKGt"); char *playlist_uri = malloc(playlist_uri_len); if (playlist_uri == NULL) { return NULL; } sp_link *playlist_link = sp_link_create_from_playlist(playlist); sp_link_as_string(playlist_link, playlist_uri, playlist_uri_len); sp_link_release(playlist_link); json_object_set_new(object, "uri", json_string_nocheck(playlist_uri)); free(playlist_uri); // Title const char *title = sp_playlist_name(playlist); json_object_set_new(object, "title", json_string_nocheck(title)); // Collaborative playlist_to_json_set_collaborative(playlist, object); // Description const char *description = sp_playlist_get_description(playlist); if (description != NULL) { json_object_set_new(object, "description", json_string_nocheck(description)); } // Number of subscribers int num_subscribers = sp_playlist_num_subscribers(playlist); json_object_set_new(object, "subscriberCount", json_integer(num_subscribers)); // Tracks json_t *tracks = json_array(); json_object_set_new(object, "tracks", tracks); char track_uri[kTrackLinkLength]; for (int i = 0; i < sp_playlist_num_tracks(playlist); i++) { sp_track *track = sp_playlist_track(playlist, i); sp_link *track_link = sp_link_create_from_track(track, 0); sp_link_as_string(track_link, track_uri, kTrackLinkLength); json_array_append(tracks, json_string_nocheck(track_uri)); sp_link_release(track_link); } return object; }