2
#include "internetmodel.h"
3
#include "spotifyblobdownloader.h"
4
#include "spotifyserver.h"
5
#include "spotifyservice.h"
6
#include "spotifysearchplaylisttype.h"
7
#include "core/database.h"
8
#include "core/logging.h"
9
#include "core/player.h"
10
#include "core/taskmanager.h"
11
#include "core/timeconstants.h"
12
#include "core/utilities.h"
13
#include "globalsearch/globalsearch.h"
14
#include "globalsearch/spotifysearchprovider.h"
15
#include "playlist/playlist.h"
16
#include "playlist/playlistcontainer.h"
17
#include "playlist/playlistmanager.h"
18
#include "spotifyblob/common/blobversion.h"
19
#include "spotifyblob/common/spotifymessagehandler.h"
20
#include "widgets/didyoumean.h"
21
#include "ui/iconloader.h"
23
#include <QCoreApplication>
27
#include <QMessageBox>
32
Q_DECLARE_METATYPE(QStandardItem*);
34
const char* SpotifyService::kServiceName = "Spotify";
35
const char* SpotifyService::kSettingsGroup = "Spotify";
36
const char* SpotifyService::kBlobDownloadUrl = "http://spotify.clementine-player.org/";
37
const int SpotifyService::kSearchDelayMsec = 400;
39
SpotifyService::SpotifyService(InternetModel* parent)
40
: InternetService(kServiceName, parent, parent),
48
pending_search_playlist_(NULL),
50
search_delay_(new QTimer(this)),
51
login_state_(LoginState_OtherError),
52
bitrate_(spotify_pb::Bitrate320k),
53
volume_normalisation_(false)
55
// Build the search path for the binary blob.
56
// Look for one distributed alongside clementine first, then check in the
57
// user's home directory for any that have been downloaded.
59
system_blob_path_ = QCoreApplication::applicationDirPath() +
60
"/../PlugIns/clementine-spotifyblob";
62
system_blob_path_ = QCoreApplication::applicationDirPath() +
63
"/clementine-spotifyblob" CMAKE_EXECUTABLE_SUFFIX;
66
local_blob_version_ = QString("version%1-%2bit").arg(SPOTIFY_BLOB_VERSION).arg(sizeof(void*) * 8);
67
local_blob_path_ = Utilities::GetConfigPath(Utilities::Path_LocalSpotifyBlob) +
68
"/" + local_blob_version_ + "/blob";
70
qLog(Debug) << "Spotify system blob path:" << system_blob_path_;
71
qLog(Debug) << "Spotify local blob path:" << local_blob_path_;
73
model()->player()->playlists()->RegisterSpecialPlaylistType(
74
new SpotifySearchPlaylistType(this));
76
model()->global_search()->AddProvider(new SpotifySearchProvider(this));
78
search_delay_->setInterval(kSearchDelayMsec);
79
search_delay_->setSingleShot(true);
80
connect(search_delay_, SIGNAL(timeout()), SLOT(DoSearch()));
83
SpotifyService::~SpotifyService() {
84
if (blob_process_ && blob_process_->state() == QProcess::Running) {
85
qLog(Info) << "Terminating blob process...";
86
blob_process_->terminate();
87
blob_process_->waitForFinished(1000);
91
QStandardItem* SpotifyService::CreateRootItem() {
92
root_ = new QStandardItem(QIcon(":icons/22x22/spotify.png"), kServiceName);
93
root_->setData(true, InternetModel::Role_CanLazyLoad);
97
void SpotifyService::LazyPopulate(QStandardItem* item) {
98
switch (item->data(InternetModel::Role_Type).toInt()) {
99
case InternetModel::Type_Service:
100
EnsureServerCreated();
103
case Type_SearchResults:
106
case Type_InboxPlaylist:
107
EnsureServerCreated();
108
server_->LoadInbox();
111
case Type_StarredPlaylist:
112
EnsureServerCreated();
113
server_->LoadStarred();
116
case InternetModel::Type_UserPlaylist:
117
EnsureServerCreated();
118
server_->LoadUserPlaylist(item->data(Role_UserPlaylistIndex).toInt());
128
QModelIndex SpotifyService::GetCurrentIndex() {
129
return QModelIndex();
132
void SpotifyService::Login(const QString& username, const QString& password) {
134
EnsureServerCreated(username, password);
137
void SpotifyService::LoginCompleted(bool success, const QString& error,
138
spotify_pb::LoginResponse_Error error_code) {
139
if (login_task_id_) {
140
model()->task_manager()->SetTaskFinished(login_task_id_);
145
bool show_error_dialog = true;
146
QString error_copy(error);
148
switch (error_code) {
149
case spotify_pb::LoginResponse_Error_BadUsernameOrPassword:
150
login_state_ = LoginState_BadCredentials;
153
case spotify_pb::LoginResponse_Error_UserBanned:
154
login_state_ = LoginState_Banned;
157
case spotify_pb::LoginResponse_Error_UserNeedsPremium:
158
login_state_ = LoginState_NoPremium;
161
case spotify_pb::LoginResponse_Error_ReloginFailed:
162
if (login_state_ == LoginState_LoggedIn) {
163
// This is the first time the relogin has failed - show a message this
165
error_copy = tr("You have been logged out of Spotify, please re-enter your password in the Settings dialog.");
167
show_error_dialog = false;
170
login_state_ = LoginState_ReloginFailed;
174
login_state_ = LoginState_OtherError;
178
if (show_error_dialog) {
179
QMessageBox::warning(NULL, tr("Spotify login error"), error_copy, QMessageBox::Close);
182
login_state_ = LoginState_LoggedIn;
186
s.beginGroup(kSettingsGroup);
187
s.setValue("login_state", login_state_);
189
emit LoginFinished(success);
192
void SpotifyService::BlobProcessError(QProcess::ProcessError error) {
193
qLog(Error) << "Spotify blob process failed:" << error;
194
blob_process_->deleteLater();
195
blob_process_ = NULL;
197
if (login_task_id_) {
198
model()->task_manager()->SetTaskFinished(login_task_id_);
202
void SpotifyService::ReloadSettings() {
204
s.beginGroup(kSettingsGroup);
206
login_state_ = LoginState(s.value("login_state", LoginState_OtherError).toInt());
207
bitrate_ = static_cast<spotify_pb::Bitrate>(
208
s.value("bitrate", spotify_pb::Bitrate320k).toInt());
209
volume_normalisation_ = s.value("volume_normalisation", false).toBool();
211
if (server_ && blob_process_) {
212
server_->SetPlaybackSettings(bitrate_, volume_normalisation_);
216
void SpotifyService::EnsureServerCreated(const QString& username,
217
const QString& password) {
218
if (server_ && blob_process_) {
223
server_ = new SpotifyServer(this);
225
connect(server_, SIGNAL(LoginCompleted(bool,QString,spotify_pb::LoginResponse_Error)),
226
SLOT(LoginCompleted(bool,QString,spotify_pb::LoginResponse_Error)));
227
connect(server_, SIGNAL(PlaylistsUpdated(spotify_pb::Playlists)),
228
SLOT(PlaylistsUpdated(spotify_pb::Playlists)));
229
connect(server_, SIGNAL(InboxLoaded(spotify_pb::LoadPlaylistResponse)),
230
SLOT(InboxLoaded(spotify_pb::LoadPlaylistResponse)));
231
connect(server_, SIGNAL(StarredLoaded(spotify_pb::LoadPlaylistResponse)),
232
SLOT(StarredLoaded(spotify_pb::LoadPlaylistResponse)));
233
connect(server_, SIGNAL(UserPlaylistLoaded(spotify_pb::LoadPlaylistResponse)),
234
SLOT(UserPlaylistLoaded(spotify_pb::LoadPlaylistResponse)));
235
connect(server_, SIGNAL(PlaybackError(QString)),
236
SIGNAL(StreamError(QString)));
237
connect(server_, SIGNAL(SearchResults(spotify_pb::SearchResponse)),
238
SLOT(SearchResults(spotify_pb::SearchResponse)));
239
connect(server_, SIGNAL(ImageLoaded(QString,QImage)),
240
SIGNAL(ImageLoaded(QString,QImage)));
241
connect(server_, SIGNAL(SyncPlaylistProgress(spotify_pb::SyncPlaylistProgress)),
242
SLOT(SyncPlaylistProgress(spotify_pb::SyncPlaylistProgress)));
246
login_task_id_ = model()->task_manager()->StartTask(tr("Connecting to Spotify"));
248
QString login_username = username;
249
QString login_password = password;
251
if (username.isEmpty()) {
253
s.beginGroup(kSettingsGroup);
255
login_username = s.value("username").toString();
256
login_password = QString();
259
server_->Login(login_username, login_password, bitrate_, volume_normalisation_);
264
void SpotifyService::StartBlobProcess() {
265
// Try to find an executable to run
267
QProcessEnvironment env(QProcessEnvironment::systemEnvironment());
269
// Look in the system search path first
270
if (QFile::exists(system_blob_path_)) {
271
blob_path = system_blob_path_;
274
// Next look in the local path
275
if (blob_path.isEmpty()) {
276
if (QFile::exists(local_blob_path_)) {
277
blob_path = local_blob_path_;
278
env.insert("LD_LIBRARY_PATH", QFileInfo(local_blob_path_).path());
282
if (blob_path.isEmpty()) {
283
// If the blob still wasn't found then we'll prompt the user to download one
284
if (login_task_id_) {
285
model()->task_manager()->SetTaskFinished(login_task_id_);
289
if (SpotifyBlobDownloader::Prompt()) {
297
delete blob_process_;
298
blob_process_ = new QProcess(this);
299
blob_process_->setProcessChannelMode(QProcess::ForwardedChannels);
300
blob_process_->setProcessEnvironment(env);
302
connect(blob_process_,
303
SIGNAL(error(QProcess::ProcessError)),
304
SLOT(BlobProcessError(QProcess::ProcessError)));
306
qLog(Info) << "Starting" << blob_path;
307
blob_process_->start(
308
blob_path, QStringList() << QString::number(server_->server_port()));
311
bool SpotifyService::IsBlobInstalled() const {
312
return QFile::exists(system_blob_path_) ||
313
QFile::exists(local_blob_path_);
316
void SpotifyService::InstallBlob() {
317
// The downloader deletes itself when it finishes
318
SpotifyBlobDownloader* downloader = new SpotifyBlobDownloader(
319
local_blob_version_, QFileInfo(local_blob_path_).path(), this);
320
connect(downloader, SIGNAL(Finished()), SLOT(BlobDownloadFinished()));
321
connect(downloader, SIGNAL(Finished()), SIGNAL(BlobStateChanged()));
325
void SpotifyService::BlobDownloadFinished() {
326
EnsureServerCreated();
329
void SpotifyService::PlaylistsUpdated(const spotify_pb::Playlists& response) {
330
if (login_task_id_) {
331
model()->task_manager()->SetTaskFinished(login_task_id_);
335
// Create starred and inbox playlists if they're not here already
337
search_ = new QStandardItem(IconLoader::Load("edit-find"),
338
tr("Search Spotify (opens a new tab)"));
339
search_->setData(Type_SearchResults, InternetModel::Role_Type);
340
search_->setData(InternetModel::PlayBehaviour_DoubleClickAction,
341
InternetModel::Role_PlayBehaviour);
343
starred_ = new QStandardItem(QIcon(":/star-on.png"), tr("Starred"));
344
starred_->setData(Type_StarredPlaylist, InternetModel::Role_Type);
345
starred_->setData(true, InternetModel::Role_CanLazyLoad);
347
inbox_ = new QStandardItem(IconLoader::Load("mail-message"), tr("Inbox"));
348
inbox_->setData(Type_InboxPlaylist, InternetModel::Role_Type);
349
inbox_->setData(true, InternetModel::Role_CanLazyLoad);
351
root_->appendRow(search_);
352
root_->appendRow(starred_);
353
root_->appendRow(inbox_);
356
// Don't do anything if the playlists haven't changed since last time.
357
if (!DoPlaylistsDiffer(response)) {
358
qLog(Debug) << "Playlists haven't changed - not updating";
362
// Remove and recreate the other playlists
363
foreach (QStandardItem* item, playlists_) {
364
item->parent()->removeRow(item->row());
368
for (int i=0 ; i<response.playlist_size() ; ++i) {
369
const spotify_pb::Playlists::Playlist& msg = response.playlist(i);
371
QStandardItem* item = new QStandardItem(QStringFromStdString(msg.name()));
372
item->setData(InternetModel::Type_UserPlaylist, InternetModel::Role_Type);
373
item->setData(true, InternetModel::Role_CanLazyLoad);
374
item->setData(msg.index(), Role_UserPlaylistIndex);
375
item->setData(InternetModel::PlayBehaviour_SingleItem, InternetModel::Role_PlayBehaviour);
377
root_->appendRow(item);
380
// Preload the playlist items so that drag & drop works immediately.
385
bool SpotifyService::DoPlaylistsDiffer(const spotify_pb::Playlists& response) const {
386
if (playlists_.count() != response.playlist_size()) {
390
for (int i=0 ; i<response.playlist_size() ; ++i) {
391
const spotify_pb::Playlists::Playlist& msg = response.playlist(i);
392
const QStandardItem* item = PlaylistBySpotifyIndex(msg.index());
398
if (QStringFromStdString(msg.name()) != item->text()) {
406
void SpotifyService::InboxLoaded(const spotify_pb::LoadPlaylistResponse& response) {
407
FillPlaylist(inbox_, response);
410
void SpotifyService::StarredLoaded(const spotify_pb::LoadPlaylistResponse& response) {
411
FillPlaylist(starred_, response);
414
QStandardItem* SpotifyService::PlaylistBySpotifyIndex(int index) const {
415
foreach (QStandardItem* item, playlists_) {
416
if (item->data(Role_UserPlaylistIndex).toInt() == index) {
423
void SpotifyService::UserPlaylistLoaded(const spotify_pb::LoadPlaylistResponse& response) {
424
// Find a playlist with this index
425
QStandardItem* item = PlaylistBySpotifyIndex(response.request().user_playlist_index());
427
FillPlaylist(item, response);
431
void SpotifyService::FillPlaylist(QStandardItem* item, const spotify_pb::LoadPlaylistResponse& response) {
432
qLog(Debug) << "Filling playlist:" << item->text();
433
if (item->hasChildren())
434
item->removeRows(0, item->rowCount());
436
for (int i=0 ; i<response.track_size() ; ++i) {
438
SongFromProtobuf(response.track(i), &song);
440
QStandardItem* child = new QStandardItem(song.PrettyTitleWithArtist());
441
child->setData(Type_Track, InternetModel::Role_Type);
442
child->setData(QVariant::fromValue(song), InternetModel::Role_SongMetadata);
443
child->setData(InternetModel::PlayBehaviour_SingleItem, InternetModel::Role_PlayBehaviour);
444
child->setData(song.url(), InternetModel::Role_Url);
446
item->appendRow(child);
450
void SpotifyService::SongFromProtobuf(const spotify_pb::Track& track, Song* song) {
451
song->set_rating(track.starred() ? 1.0 : 0.0);
452
song->set_title(QStringFromStdString(track.title()));
453
song->set_album(QStringFromStdString(track.album()));
454
song->set_length_nanosec(track.duration_msec() * kNsecPerMsec);
455
song->set_score(track.popularity());
456
song->set_disc(track.disc());
457
song->set_track(track.track());
458
song->set_year(track.year());
459
song->set_url(QUrl(QStringFromStdString(track.uri())));
460
song->set_art_automatic("spotify://image/" + QStringFromStdString(track.album_art_id()));
463
for (int i=0 ; i<track.artist_size() ; ++i) {
464
artists << QStringFromStdString(track.artist(i));
467
song->set_artist(artists.join(", "));
469
song->set_filetype(Song::Type_Stream);
470
song->set_valid(true);
471
song->set_directory_id(0);
474
song->set_filesize(0);
477
PlaylistItem::Options SpotifyService::playlistitem_options() const {
478
return PlaylistItem::PauseDisabled | PlaylistItem::SeekDisabled;
481
void SpotifyService::EnsureMenuCreated() {
485
context_menu_ = new QMenu;
487
context_menu_->addActions(GetPlaylistActions());
488
context_menu_->addSeparator();
489
context_menu_->addAction(IconLoader::Load("edit-find"), tr("Search Spotify (opens a new tab)..."), this, SLOT(OpenSearchTab()));
490
context_menu_->addSeparator();
491
context_menu_->addAction(IconLoader::Load("configure"), tr("Configure Spotify..."), this, SLOT(ShowConfig()));
493
playlist_context_menu_ = new QMenu;
494
playlist_sync_action_ = playlist_context_menu_->addAction(
495
IconLoader::Load("view-refresh"),
496
tr("Make playlist available offline"),
498
SLOT(SyncPlaylist()));
501
void SpotifyService::SyncPlaylist() {
502
QStandardItem* item = playlist_sync_action_->data().value<QStandardItem*>();
505
switch (item->data(InternetModel::Role_Type).toInt()) {
506
case InternetModel::Type_UserPlaylist: {
507
int index = item->data(Role_UserPlaylistIndex).toInt();
508
server_->SyncUserPlaylist(index);
509
playlist_sync_ids_[index] =
510
model()->task_manager()->StartTask(tr("Syncing Spotify playlist"));
513
case Type_InboxPlaylist:
514
server_->SyncInbox();
515
inbox_sync_id_ = model()->task_manager()->StartTask(tr("Syncing Spotify inbox"));
517
case Type_StarredPlaylist:
518
server_->SyncStarred();
519
starred_sync_id_ = model()->task_manager()->StartTask(tr("Syncing Spotify starred tracks"));
526
void SpotifyService::Search(const QString& text, Playlist* playlist, bool now) {
527
EnsureServerCreated();
529
pending_search_ = text;
530
pending_search_playlist_ = playlist;
533
search_delay_->stop();
536
search_delay_->start();
540
void SpotifyService::DoSearch() {
541
if (!pending_search_.isEmpty()) {
542
server_->Search(pending_search_, 200);
546
void SpotifyService::SearchResults(const spotify_pb::SearchResponse& response) {
547
if (QStringFromStdString(response.request().query()) != pending_search_) {
548
qLog(Debug) << "Old search result for"
549
<< QStringFromStdString(response.request().query())
550
<< "expecting" << pending_search_;
553
pending_search_.clear();
556
for (int i=0 ; i<response.result_size() ; ++i) {
558
SongFromProtobuf(response.result(i), &song);
562
qLog(Debug) << "Got" << songs.count() << "results";
564
pending_search_playlist_->Clear();
565
pending_search_playlist_->InsertSongs(songs);
567
const QString did_you_mean = QStringFromStdString(response.did_you_mean());
568
if (!did_you_mean.isEmpty()) {
569
model()->player()->playlists()->playlist_container()->did_you_mean()->Show(did_you_mean);
573
SpotifyServer* SpotifyService::server() const {
574
SpotifyService* nonconst_this = const_cast<SpotifyService*>(this);
576
if (QThread::currentThread() != thread()) {
577
metaObject()->invokeMethod(nonconst_this, "EnsureServerCreated",
578
Qt::BlockingQueuedConnection);
580
nonconst_this->EnsureServerCreated();
586
void SpotifyService::ShowContextMenu(const QModelIndex& index, const QPoint& global_pos) {
588
QStandardItem* item = model()->itemFromIndex(index);
590
int type = item->data(InternetModel::Role_Type).toInt();
591
if (type == Type_InboxPlaylist ||
592
type == Type_StarredPlaylist ||
593
type == InternetModel::Type_UserPlaylist) {
594
playlist_sync_action_->setData(qVariantFromValue(item));
595
playlist_context_menu_->popup(global_pos);
600
context_menu_->popup(global_pos);
603
void SpotifyService::OpenSearchTab() {
604
model()->player()->playlists()->New(tr("Search Spotify"), SongList(),
605
SpotifySearchPlaylistType::kName);
608
void SpotifyService::ItemDoubleClicked(QStandardItem* item) {
609
if (item == search_) {
614
void SpotifyService::LoadImage(const QString& id) {
615
EnsureServerCreated();
616
server_->LoadImage(id);
619
void SpotifyService::SyncPlaylistProgress(
620
const spotify_pb::SyncPlaylistProgress& progress) {
621
qLog(Debug) << "Sync progress:" << progress.sync_progress();
623
switch (progress.request().type()) {
624
case spotify_pb::Inbox:
625
task_id = inbox_sync_id_;
627
case spotify_pb::Starred:
628
task_id = starred_sync_id_;
630
case spotify_pb::UserPlaylist: {
631
QMap<int, int>::const_iterator it = playlist_sync_ids_.constFind(
632
progress.request().user_playlist_index());
633
if (it != playlist_sync_ids_.constEnd()) {
634
task_id = it.value();
642
qLog(Warning) << "Received sync progress for unknown playlist";
645
model()->task_manager()->SetTaskProgress(task_id, progress.sync_progress(), 100);
646
if (progress.sync_progress() == 100) {
647
model()->task_manager()->SetTaskFinished(task_id);
648
if (progress.request().type() == spotify_pb::UserPlaylist) {
649
playlist_sync_ids_.remove(task_id);
654
void SpotifyService::ShowConfig() {
655
emit OpenSettingsAtPage(SettingsDialog::Page_Spotify);
658
void SpotifyService::Logout() {
660
delete blob_process_;
662
blob_process_ = NULL;
664
login_state_ = LoginState_OtherError;
667
s.beginGroup(kSettingsGroup);
668
s.setValue("login_state", login_state_);
added
removed
src/internet/spotifyservice.cpp
