void SpotifyClient::LoggedInCallback(sp_session* session, sp_error error) { SpotifyClient* me = reinterpret_cast<SpotifyClient*>(sp_session_userdata(session)); const bool success = error == SP_ERROR_OK; spotify_pb::LoginResponse_Error error_code = spotify_pb::LoginResponse_Error_Other; if (!success) { qLog(Warning) << "Failed to login" << sp_error_message(error); } switch (error) { case SP_ERROR_BAD_USERNAME_OR_PASSWORD: error_code = spotify_pb::LoginResponse_Error_BadUsernameOrPassword; break; case SP_ERROR_USER_BANNED: error_code = spotify_pb::LoginResponse_Error_UserBanned; break; case SP_ERROR_USER_NEEDS_PREMIUM : error_code = spotify_pb::LoginResponse_Error_UserNeedsPremium; break; } me->SendLoginCompleted(success, sp_error_message(error), error_code); if (success) { sp_playlistcontainer_add_callbacks( sp_session_playlistcontainer(session), &me->playlistcontainer_callbacks_, me); } }
static void logged_in(sp_session *session, sp_error error) { pthread_mutex_lock(&g_mutex); if (SP_ERROR_OK != error) { fprintf(stderr, "Could not perform login: %s\n", sp_error_message(error)); exit(1); } pthread_cond_signal(&g_cond); pthread_mutex_unlock(&g_mutex); printf("Logged in!\n"); sp_playlistcontainer* list_container = sp_session_playlistcontainer(session); if (list_container == NULL) { fprintf(stderr, "Cannot get main playlist container, aborting"); exit(1); } sp_playlistcontainer_add_callbacks( list_container, &pc_callbacks, NULL); }
/** * 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); } }
bool PlayListContainer::Load(sp_playlistcontainer *container) { container_ = container; sp_playlistcontainer_callbacks callbacks; GetCallbacks(&callbacks); sp_playlistcontainer_add_callbacks(container_, &callbacks, this); loading_ = true; return true; }
void Spotify::loggedInCb(sp_session *sp, sp_error err) { if (err == SP_ERROR_OK) { sp_playlistcontainer_add_callbacks(sp_session_playlistcontainer(sp), Spotify_Wrapper::playlistcontainerCallbacks(), this); eq.put(EVENT_LOGGED_IN); } else { fprintf(stderr, "Failed to login: %s\n", sp_error_message(err)); eq.put(EVENT_LOGGED_OUT); } }
static struct playlistcontainer_handler *register_playlistcontainer_callbacks( sp_playlistcontainer *pc, struct evhttp_request *request, handle_playlistcontainer_fn callback, sp_playlistcontainer_callbacks *playlistcontainer_callbacks, void *userdata) { struct playlistcontainer_handler *handler = malloc(sizeof (struct playlistcontainer_handler)); handler->request = request; handler->callback = callback; handler->playlistcontainer_callbacks = playlistcontainer_callbacks; handler->userdata = userdata; sp_playlistcontainer_add_callbacks(pc, handler->playlistcontainer_callbacks, handler); return handler; }
SpotifyPlaylistContainer::SpotifyPlaylistContainer(sp_session* session, SpotifySession* spotifySession) { this->session = session; this->spotifySession = spotifySession; playlistContainer = sp_session_playlistcontainer(session); sp_playlistcontainer_callbacks playlistCallbacks; playlistCallbacks.container_loaded = &container_loaded; playlistCallbacks.playlist_added = &playlist_added; playlistCallbacks.playlist_removed = &playlist_removed; playlistCallbacks.playlist_moved = &playlist_moved; sp_playlistcontainer_add_callbacks(playlistContainer, &playlistCallbacks, nullptr); }
/* -- Session callbacks -- */ static void logged_in(sp_session *session, sp_error error) { debug("Callback on_login"); if (error != SP_ERROR_OK) { fprintf(stderr, "Error: unable to log in: %s\n", sp_error_message(error)); exit(1); } pc = sp_session_playlistcontainer(session); sp_playlistcontainer_add_callbacks( pc, &pc_callbacks, NULL); g_logged_in = 1; is_logged_in = TRUE; printf("logged in\n"); }
QSpotifyPlaylistContainer::QSpotifyPlaylistContainer(sp_playlistcontainer *container) : QSpotifyObject(true) , m_updateEventPosted(false) { m_container = container; g_containerObjects.insert(container, this); m_callbacks = new sp_playlistcontainer_callbacks; m_callbacks->container_loaded = callback_container_loaded; m_callbacks->playlist_added = callback_playlist_added; m_callbacks->playlist_moved = callback_playlist_moved; m_callbacks->playlist_removed = callback_playlist_removed; sp_playlistcontainer_add_callbacks(m_container, m_callbacks, 0); connect(QSpotifySession::instance(), SIGNAL(offlineModeChanged()), this, SLOT(updatePlaylists())); metadataUpdated(); }
static void logged_in(sp_session *session, sp_error error) { if (error != SP_ERROR_OK) { fprintf(stderr, "%s\n", sp_error_message(error)); exit_status = EXIT_FAILURE; logged_out(session); return; } struct state *state = sp_session_userdata(session); state->session = session; evsignal_add(state->sigint, NULL); sp_playlistcontainer *pc = sp_session_playlistcontainer(session); sp_playlistcontainer_add_callbacks(pc, &playlistcontainer_callbacks, session); }
PHP_METHOD(Spotify, initPlaylistContainer) { int timeout = 0; spotify_object *p = (spotify_object*)zend_object_store_get_object(getThis() TSRMLS_CC); if (p->playlistcontainer != NULL) { RETURN_TRUE; } sp_playlistcontainer *tempcontainer = sp_session_playlistcontainer(p->session); sp_playlistcontainer_add_callbacks(tempcontainer, &playlistcontainer_callbacks, p); while (p->playlistcontainer == NULL) { sp_session_process_events(p->session, &timeout); } RETURN_TRUE; }
void logged_in(sp_session *session, sp_error error) { struct state *state = sp_session_userdata(session); if (error != SP_ERROR_OK) { syslog(LOG_CRIT, "Error logging in to Spotify: %s", sp_error_message(error)); state->exit_status = EXIT_FAILURE; logged_out(session); return; } state->session = session; evsignal_add(state->sigint, NULL); sp_playlistcontainer *pc = sp_session_playlistcontainer(session); sp_playlistcontainer_add_callbacks(pc, &playlistcontainer_callbacks, session); }
/** loggedin callback from spotify also initilizes the playlistcontainer and callbacks **/ void SpotifySession::loggedIn(sp_session *session, sp_error error) { SpotifySession* _session = reinterpret_cast<SpotifySession*>(sp_session_userdata(session)); if (error == SP_ERROR_OK) { qDebug() << "Logged in successfully!!"; _session->setSession(session); _session->setLoggedIn(true); _session->setPlaylistContainer( sp_session_playlistcontainer(session) ); sp_playlistcontainer_add_ref( _session->PlaylistContainer() ); sp_playlistcontainer_add_callbacks(_session->PlaylistContainer(), &SpotifyCallbacks::containerCallbacks, _session); } qDebug() << Q_FUNC_INFO << "==== " << sp_error_message( error ) << " ===="; const QString msg = QString::fromUtf8( sp_error_message( error ) ); emit _session->loginResponse( error == SP_ERROR_OK, msg ); }
void SpotWorker::emitLoggedInSignal(sp_session *session, sp_error error) { if (SP_ERROR_OK != error) { fprintf(stderr, "SpotWorker: Login failed: %s\n", sp_error_message(error)); } else{ printf("SpotWorker: Successfully logged in\n"); emit loggedIn(session, error); sp_playlistcontainer *playlists = sp_session_playlistcontainer(session); void * userdata = NULL; sp_playlistcontainer_add_callbacks(playlists, &pc_callbacks, userdata); int listCount = sp_playlistcontainer_num_playlists(playlists); printf("%d playlists discovered\n", sp_playlistcontainer_num_playlists(playlists)); if(listCount > 0) emit playlistAdded(playlists); for (int i = 0; i < listCount && i < 10; ++i) { sp_playlist *pl = sp_playlistcontainer_playlist(playlists, i); //TODO: register playback callback //sp_playlist_add_callbacks(pl, &pl_callbacks, NULL); if (sp_playlist_is_loaded(pl)){ DEBUG printf("Playlist found: %s (%i tracks)\n", sp_playlist_name(pl), sp_playlist_num_tracks(pl)); } } DEBUG { if (listCount > 10) printf("...and %d more.\n", listCount-10); } } }
static void SP_CALLCONV logged_in(sp_session *session, sp_error error) { sp_playlistcontainer *pc; static sp_playlistcontainer_callbacks callbacks; DSFYDEBUG("SESSION CALLBACK\n"); if (SP_ERROR_OK != error) { fprintf(stderr, "failed to log in to Spotify: %s\n", sp_error_message(error)); return; } /* Snoop on added playlists */ memset(&callbacks, 0, sizeof(callbacks)); callbacks.playlist_added = pc_playlist_added; callbacks.playlist_moved = NULL; callbacks.playlist_removed = NULL; pc = sp_session_playlistcontainer(session); sp_playlistcontainer_add_callbacks(pc, &callbacks, NULL); }
/** * Added note: The callbacks for the playlist-handling are set * by logged_in_playlist(), for each playlist in the * playlist container. * * The callbacks for the playlist-container-handling are set * by main(). * */ int spshell_init(const char *username, const char *password) { sp_session_config config; sp_error error; sp_session *session; /// The application key is specific to each project, and allows Spotify /// to produce statistics on how our service is used. extern const char g_appkey[]; /// The size of the application key. extern const size_t g_appkey_size; // Always do this. It allows libspotify to check for // header/library inconsistencies. config.api_version = SPOTIFY_API_VERSION; // The path of the directory to store the cache. This must be specified. // Please read the documentation on preferred values. config.cache_location = "tmp"; // The path of the directory to store the settings. // This must be specified. // Please read the documentation on preferred values. config.settings_location = "tmp"; // The key of the application. They are generated by Spotify, // and are specific to each application using libspotify. config.application_key = g_appkey; config.application_key_size = g_appkey_size; // This identifies the application using some // free-text string [1, 255] characters. config.user_agent = "listify"; // Register the callbacks. config.callbacks = &callbacks; error = sp_session_init(&config, &session); if (SP_ERROR_OK != error) { fprintf(stderr, "failed to create session: %s\n", sp_error_message(error)); return 2; } // Added Code: Adding the callbacks for the playlist-container sp_playlistcontainer_add_callbacks( sp_session_playlistcontainer(session), &pc_callbacks, NULL); // Login using the credentials given on the command line. error = sp_session_login(session, username, password); if (SP_ERROR_OK != error) { fprintf(stderr, "failed to login: %s\n", sp_error_message(error)); return 3; } g_session = session; return 0; }
int main(int argc, char **argv) { sp_session *sp; sp_error err; int next_timeout = 0; const char *username = NULL; const char *password = NULL; int opt; while ((opt = getopt(argc, argv, "u:p:l:d")) != EOF) { switch (opt) { case 'u': username = optarg; break; case 'p': password = optarg; break; case 'l': g_listname = optarg; break; case 'd': g_remove_tracks = 1; break; default: exit(1); } } if (!username || !password || !g_listname) { usage(basename(argv[0])); exit(1); } audio_init(&g_audiofifo); /* Create session */ spconfig.application_key_size = g_appkey_size; err = sp_session_create(&spconfig, &sp); if (SP_ERROR_OK != err) { fprintf(stderr, "Unable to create session: %s\n", sp_error_message(err)); exit(1); } g_sess = sp; pthread_mutex_init(&g_notify_mutex, NULL); pthread_cond_init(&g_notify_cond, NULL); sp_playlistcontainer_add_callbacks( sp_session_playlistcontainer(g_sess), &pc_callbacks, NULL); sp_session_login(sp, username, password, 0); pthread_mutex_lock(&g_notify_mutex); for (;;) { if (next_timeout == 0) { while(!g_notify_do && !g_playback_done) pthread_cond_wait(&g_notify_cond, &g_notify_mutex); } else { struct timespec ts; #if _POSIX_TIMERS > 0 clock_gettime(CLOCK_REALTIME, &ts); #else struct timeval tv; gettimeofday(&tv, NULL); TIMEVAL_TO_TIMESPEC(&tv, &ts); #endif ts.tv_sec += next_timeout / 1000; ts.tv_nsec += (next_timeout % 1000) * 1000000; pthread_cond_timedwait(&g_notify_cond, &g_notify_mutex, &ts); } g_notify_do = 0; pthread_mutex_unlock(&g_notify_mutex); if (g_playback_done) { track_ended(); g_playback_done = 0; } do { sp_session_process_events(sp, &next_timeout); } while (next_timeout == 0); pthread_mutex_lock(&g_notify_mutex); } return 0; }
int main(int argc, char **argv) { init_session_config(); init_session_callbacks(); init_playlist_callbacks(); init_playlist_container_callbacks(); sp_session *sp; sp_error err; int next_timeout = 0; const char *username = NULL; const char *password = NULL; int opt; while ((opt = getopt(argc, argv, "u:p:l:d")) != EOF) { switch (opt) { case 'u': username = optarg; break; case 'p': password = optarg; break; case 'l': g_listname = optarg; break; case 'd': g_remove_tracks = 1; break; default: exit(1); } } if (!username || !password || !g_listname) { usage(argv[0]); exit(1); } audio_open(); err = sp_session_create(&spconfig, &sp); if (SP_ERROR_OK != err) { fprintf(stderr, "Unable to create session: %s\n", sp_error_message(err)); exit(1); } g_sess = sp; g_notify_mutex = SDL_CreateMutex(); g_notify_cond = SDL_CreateCond(); sp_playlistcontainer_add_callbacks( sp_session_playlistcontainer(g_sess), &pc_callbacks, NULL); sp_session_login(sp, username, password); SDL_mutexP(g_notify_mutex); for (;;) { if (next_timeout == 0) { while(!g_notify_do && !g_playback_done) SDL_CondWait(g_notify_cond, g_notify_mutex); } else { SDL_CondWaitTimeout(g_notify_cond, g_notify_mutex, next_timeout); } g_notify_do = 0; SDL_mutexV(g_notify_mutex); if (g_playback_done) { track_ended(); g_playback_done = 0; } do { sp_session_process_events(sp, &next_timeout); } while (next_timeout == 0); SDL_mutexP(g_notify_mutex); } return 0; }
JNIEXPORT int JNICALL Java_jahspotify_impl_JahSpotifyImpl_initialize ( JNIEnv *env, jobject obj, jstring username, jstring password ) { sp_session *sp; sp_error err; uint8_t *nativePassword = NULL; uint8_t *nativeUsername = NULL; int next_timeout = 0; if ( !username || !password ) { fprintf ( stderr, "Username or password not specified\n" ); return 1; } /* Create session */ spconfig.application_key_size = g_appkey_size; err = sp_session_create ( &spconfig, &sp ); if ( SP_ERROR_OK != err ) { fprintf ( stderr, "Unable to create session: %s\n",sp_error_message ( err ) ); return 1; } fprintf ( stderr, "Session created %x\n",(int)sp); nativeUsername = ( uint8_t * ) ( *env )->GetStringUTFChars ( env, username, NULL ); nativePassword = ( uint8_t * ) ( *env )->GetStringUTFChars ( env, password, NULL ); g_sess = sp; pthread_mutex_init ( &g_notify_mutex, NULL ); pthread_cond_init ( &g_notify_cond, NULL ); sp_playlistcontainer_add_callbacks ( sp_session_playlistcontainer ( g_sess ),&pc_callbacks,NULL ); fprintf ( stderr, "Initiating login: %s\n",nativeUsername ); sp_session_login ( sp, nativeUsername, nativePassword ); pthread_mutex_lock ( &g_notify_mutex ); for ( ;; ) { if ( next_timeout == 0 ) { while ( !g_notify_do && !g_playback_done ) pthread_cond_wait ( &g_notify_cond, &g_notify_mutex ); } else { struct timespec ts; #if _POSIX_TIMERS > 0 clock_gettime ( CLOCK_REALTIME, &ts ); #else struct timeval tv; gettimeofday ( &tv, NULL ); TIMEVAL_TO_TIMESPEC ( &tv, &ts ); #endif ts.tv_sec += next_timeout / 1000; ts.tv_nsec += ( next_timeout % 1000 ) * 1000000; pthread_cond_timedwait ( &g_notify_cond, &g_notify_mutex, &ts ); } g_notify_do = 0; pthread_mutex_unlock ( &g_notify_mutex ); if ( g_playback_done ) { track_ended(); g_playback_done = 0; } sp_connectionstate conn_state = sp_session_connectionstate(sp); switch (conn_state) { case SP_CONNECTION_STATE_UNDEFINED: case SP_CONNECTION_STATE_LOGGED_OUT: case SP_CONNECTION_STATE_LOGGED_IN: break; case SP_CONNECTION_STATE_DISCONNECTED: fprintf ( stderr, "Disconnected!\n"); break; } do { sp_session_process_events ( sp, &next_timeout ); } while ( next_timeout == 0 ); pthread_mutex_lock ( &g_notify_mutex ); } // FIXME: Release the username/password allocated? return 0; }