1
/* This file is part of Clementine.
2
Copyright 2010, David Sansome <me@davidsansome.com>
4
Clementine is free software: you can redistribute it and/or modify
5
it under the terms of the GNU General Public License as published by
6
the Free Software Foundation, either version 3 of the License, or
7
(at your option) any later version.
9
Clementine is distributed in the hope that it will be useful,
10
but WITHOUT ANY WARRANTY; without even the implied warranty of
11
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12
GNU General Public License for more details.
14
You should have received a copy of the GNU General Public License
15
along with Clementine. If not, see <http://www.gnu.org/licenses/>.
18
#include "spotifysearchprovider.h"
19
#include "core/logging.h"
20
#include "internet/internetmodel.h"
21
#include "internet/spotifyserver.h"
22
#include "internet/spotifyservice.h"
23
#include "playlist/songmimedata.h"
24
#include "spotifyblob/common/spotifymessagehandler.h"
26
SpotifySearchProvider::SpotifySearchProvider(QObject* parent)
27
: SearchProvider(parent),
31
Init("Spotify", "spotify", QIcon(":icons/32x32/spotify.png"),
32
WantsDelayedQueries | WantsSerialisedArtQueries | ArtIsProbablyRemote |
36
SpotifyServer* SpotifySearchProvider::server() {
41
service_ = InternetModel::Service<SpotifyService>();
43
if (service_->login_state() != SpotifyService::LoginState_LoggedIn)
46
server_ = service_->server();
47
connect(server_, SIGNAL(SearchResults(spotify_pb::SearchResponse)),
48
SLOT(SearchFinishedSlot(spotify_pb::SearchResponse)));
49
connect(server_, SIGNAL(ImageLoaded(QString,QImage)),
50
SLOT(ArtLoadedSlot(QString,QImage)));
51
connect(server_, SIGNAL(AlbumBrowseResults(spotify_pb::BrowseAlbumResponse)),
52
SLOT(AlbumBrowseResponse(spotify_pb::BrowseAlbumResponse)));
53
connect(server_, SIGNAL(destroyed()), SLOT(ServerDestroyed()));
58
void SpotifySearchProvider::ServerDestroyed() {
62
void SpotifySearchProvider::SearchAsync(int id, const QString& query) {
63
SpotifyServer* s = server();
65
emit SearchFinished(id);
71
state.tokens_ = TokenizeQuery(query);
73
const QString query_string = state.tokens_.join(" ");
74
s->Search(query_string, 5, 5);
75
queries_[query_string] = state;
78
void SpotifySearchProvider::SearchFinishedSlot(const spotify_pb::SearchResponse& response) {
79
QString query_string = QString::fromUtf8(response.request().query().c_str());
80
QMap<QString, PendingState>::iterator it = queries_.find(query_string);
81
if (it == queries_.end())
84
PendingState state = it.value();
88
for (int i=0; i < response.result_size() ; ++i) {
89
const spotify_pb::Track& track = response.result(i);
92
result.type_ = globalsearch::Type_Track;
93
SpotifyService::SongFromProtobuf(track, &result.metadata_);
94
result.match_quality_ = MatchQuality(state.tokens_, result.metadata_.title());
99
for (int i=0 ; i<response.album_size() ; ++i) {
100
const spotify_pb::Album& album = response.album(i);
103
result.type_ = globalsearch::Type_Album;
104
SpotifyService::SongFromProtobuf(album.metadata(), &result.metadata_);
105
result.match_quality_ =
106
qMin(MatchQuality(state.tokens_, result.metadata_.album()),
107
MatchQuality(state.tokens_, result.metadata_.artist()));
108
result.album_size_ = album.metadata().track();
110
for (int j=0; j < album.track_size() ; ++j) {
112
SpotifyService::SongFromProtobuf(album.track(j), &track_song);
113
result.album_songs_ << track_song;
119
emit ResultsAvailable(state.orig_id_, ret);
120
emit SearchFinished(state.orig_id_);
123
void SpotifySearchProvider::LoadArtAsync(int id, const Result& result) {
124
SpotifyServer* s = server();
126
emit ArtLoaded(id, QImage());
130
QString image_id = QUrl(result.metadata_.art_automatic()).path();
131
if (image_id.startsWith('/'))
132
image_id.remove(0, 1);
134
pending_art_[image_id] = id;
135
s->LoadImage(image_id);
138
void SpotifySearchProvider::ArtLoadedSlot(const QString& id, const QImage& image) {
139
QMap<QString, int>::iterator it = pending_art_.find(id);
140
if (it == pending_art_.end())
143
const int orig_id = it.value();
144
pending_art_.erase(it);
146
emit ArtLoaded(orig_id, ScaleAndPad(image));
149
void SpotifySearchProvider::LoadTracksAsync(int id, const Result& result) {
150
switch (result.type_) {
151
case globalsearch::Type_Track: {
152
SongMimeData* mime_data = new SongMimeData;
153
mime_data->songs = SongList() << result.metadata_;
154
emit TracksLoaded(id, mime_data);
158
case globalsearch::Type_Album: {
159
SpotifyServer* s = server();
161
emit TracksLoaded(id, NULL);
165
QString uri = result.metadata_.url().toString();
167
pending_tracks_[uri] = id;
177
void SpotifySearchProvider::AlbumBrowseResponse(const spotify_pb::BrowseAlbumResponse& response) {
178
QString uri = QStringFromStdString(response.uri());
179
QMap<QString, int>::iterator it = pending_tracks_.find(uri);
180
if (it == pending_tracks_.end())
183
const int orig_id = it.value();
184
pending_tracks_.erase(it);
186
SongMimeData* mime_data = new SongMimeData;
188
for (int i=0 ; i<response.track_size() ; ++i) {
190
SpotifyService::SongFromProtobuf(response.track(i), &song);
191
mime_data->songs << song;
194
emit TracksLoaded(orig_id, mime_data);
197
bool SpotifySearchProvider::IsLoggedIn() {
199
return service_->IsLoggedIn();
204
void SpotifySearchProvider::ShowConfig() {
206
return service_->ShowConfig();