void SpotifyService::EnsureServerCreated(const QString& username,
const QString& password) {
if (server_ && blob_process_) {
return;
}
delete server_;
server_ = new SpotifyServer(this);
connect(
server_,
SIGNAL(LoginCompleted(bool, QString, pb::spotify::LoginResponse_Error)),
SLOT(LoginCompleted(bool, QString, pb::spotify::LoginResponse_Error)));
connect(server_, SIGNAL(PlaylistsUpdated(pb::spotify::Playlists)),
SLOT(PlaylistsUpdated(pb::spotify::Playlists)));
connect(server_, SIGNAL(InboxLoaded(pb::spotify::LoadPlaylistResponse)),
SLOT(InboxLoaded(pb::spotify::LoadPlaylistResponse)));
connect(server_, SIGNAL(StarredLoaded(pb::spotify::LoadPlaylistResponse)),
SLOT(StarredLoaded(pb::spotify::LoadPlaylistResponse)));
connect(server_,
SIGNAL(UserPlaylistLoaded(pb::spotify::LoadPlaylistResponse)),
SLOT(UserPlaylistLoaded(pb::spotify::LoadPlaylistResponse)));
connect(server_, SIGNAL(PlaybackError(QString)),
SIGNAL(StreamError(QString)));
connect(server_, SIGNAL(SearchResults(pb::spotify::SearchResponse)),
SLOT(SearchResults(pb::spotify::SearchResponse)));
connect(server_, SIGNAL(ImageLoaded(QString, QImage)),
SIGNAL(ImageLoaded(QString, QImage)));
connect(server_,
SIGNAL(SyncPlaylistProgress(pb::spotify::SyncPlaylistProgress)),
SLOT(SyncPlaylistProgress(pb::spotify::SyncPlaylistProgress)));
connect(server_,
SIGNAL(ToplistBrowseResults(pb::spotify::BrowseToplistResponse)),
SLOT(ToplistLoaded(pb::spotify::BrowseToplistResponse)));
server_->Init();
login_task_id_ = app_->task_manager()->StartTask(tr("Connecting to Spotify"));
QString login_username = username;
QString login_password = password;
if (username.isEmpty()) {
QSettings s;
s.beginGroup(kSettingsGroup);
login_username = s.value("username").toString();
login_password = QString();
}
server_->Login(login_username, login_password, bitrate_,
volume_normalisation_);
StartBlobProcess();
}
void SpotifyServer::MessageArrived(const pb::spotify::Message& message) {
if (message.has_login_response()) {
const pb::spotify::LoginResponse& response = message.login_response();
logged_in_ = response.success();
if (response.success()) {
// Send any messages that were queued before the client logged in
for (const pb::spotify::Message& message : queued_messages_) {
SendOrQueueMessage(message);
}
queued_messages_.clear();
}
emit LoginCompleted(response.success(),
QStringFromStdString(response.error()),
response.error_code());
} else if (message.has_playlists_updated()) {
emit PlaylistsUpdated(message.playlists_updated());
} else if (message.has_load_playlist_response()) {
const pb::spotify::LoadPlaylistResponse& response =
message.load_playlist_response();
switch (response.request().type()) {
case pb::spotify::Inbox:
emit InboxLoaded(response);
break;
case pb::spotify::Starred:
emit StarredLoaded(response);
break;
case pb::spotify::UserPlaylist:
emit UserPlaylistLoaded(response);
break;
}
} else if (message.has_playback_error()) {
emit PlaybackError(QStringFromStdString(message.playback_error().error()));
} else if (message.has_search_response()) {
emit SearchResults(message.search_response());
} else if (message.has_image_response()) {
const pb::spotify::ImageResponse& response = message.image_response();
const QString id = QStringFromStdString(response.id());
if (response.has_data()) {
emit ImageLoaded(
id, QImage::fromData(
QByteArray(response.data().data(), response.data().size())));
} else {
emit ImageLoaded(id, QImage());
}
} else if (message.has_sync_playlist_progress()) {
emit SyncPlaylistProgress(message.sync_playlist_progress());
} else if (message.has_browse_album_response()) {
emit AlbumBrowseResults(message.browse_album_response());
} else if (message.has_browse_toplist_response()) {
emit ToplistBrowseResults(message.browse_toplist_response());
}
}
void SpotifyService::EnsureServerCreated(const QString& username,
const QString& password) {
if (server_ && blob_process_) {
return;
}
delete server_;
server_ = new SpotifyServer(this);
connect(server_, SIGNAL(LoginCompleted(bool,QString,spotify_pb::LoginResponse_Error)),
SLOT(LoginCompleted(bool,QString,spotify_pb::LoginResponse_Error)));
connect(server_, SIGNAL(PlaylistsUpdated(spotify_pb::Playlists)),
SLOT(PlaylistsUpdated(spotify_pb::Playlists)));
connect(server_, SIGNAL(InboxLoaded(spotify_pb::LoadPlaylistResponse)),
SLOT(InboxLoaded(spotify_pb::LoadPlaylistResponse)));
connect(server_, SIGNAL(StarredLoaded(spotify_pb::LoadPlaylistResponse)),
SLOT(StarredLoaded(spotify_pb::LoadPlaylistResponse)));
connect(server_, SIGNAL(UserPlaylistLoaded(spotify_pb::LoadPlaylistResponse)),
SLOT(UserPlaylistLoaded(spotify_pb::LoadPlaylistResponse)));
connect(server_, SIGNAL(PlaybackError(QString)),
SIGNAL(StreamError(QString)));
connect(server_, SIGNAL(SearchResults(spotify_pb::SearchResponse)),
SLOT(SearchResults(spotify_pb::SearchResponse)));
connect(server_, SIGNAL(ImageLoaded(QString,QImage)),
SLOT(ImageLoaded(QString,QImage)));
connect(server_, SIGNAL(SyncPlaylistProgress(spotify_pb::SyncPlaylistProgress)),
SLOT(SyncPlaylistProgress(spotify_pb::SyncPlaylistProgress)));
server_->Init();
login_task_id_ = model()->task_manager()->StartTask(tr("Connecting to Spotify"));
if (username.isEmpty()) {
QSettings s;
s.beginGroup(kSettingsGroup);
server_->Login(s.value("username").toString(), s.value("password").toString());
} else {
server_->Login(username, password);
}
StartBlobProcess();
}