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 "magnatunedownloaddialog.h"
19
#include "magnatuneplaylistitem.h"
20
#include "magnatuneservice.h"
21
#include "radiomodel.h"
22
#include "core/mergedproxymodel.h"
23
#include "core/network.h"
24
#include "core/song.h"
25
#include "core/taskmanager.h"
26
#include "library/librarymodel.h"
27
#include "library/librarybackend.h"
28
#include "library/libraryfilterwidget.h"
29
#include "ui/iconloader.h"
30
#include "ui/settingsdialog.h"
32
#include "qtiocompressor.h"
34
#include <QNetworkAccessManager>
35
#include <QNetworkRequest>
36
#include <QNetworkReply>
37
#include <QXmlStreamReader>
38
#include <QSortFilterProxyModel>
40
#include <QDesktopServices>
41
#include <QCoreApplication>
46
using boost::shared_ptr;
48
const char* MagnatuneService::kServiceName = "Magnatune";
49
const char* MagnatuneService::kSettingsGroup = "Magnatune";
50
const char* MagnatuneService::kSongsTable = "magnatune_songs";
51
const char* MagnatuneService::kFtsTable = "magnatune_songs_fts";
53
const char* MagnatuneService::kHomepage = "http://magnatune.com";
54
const char* MagnatuneService::kDatabaseUrl = "http://magnatune.com/info/song_info_xml.gz";
55
const char* MagnatuneService::kStreamingHostname = "streaming.magnatune.com";
56
const char* MagnatuneService::kDownloadHostname = "download.magnatune.com";
58
const char* MagnatuneService::kPartnerId = "clementine";
59
const char* MagnatuneService::kDownloadUrl = "http://download.magnatune.com/buy/membership_free_dl_xml";
61
MagnatuneService::MagnatuneService(RadioModel* parent)
62
: RadioService(kServiceName, parent),
65
library_backend_(NULL),
67
library_filter_(NULL),
68
library_sort_model_(new QSortFilterProxyModel(this)),
69
load_database_task_id_(0),
70
membership_(Membership_None),
73
network_(new NetworkAccessManager(this))
77
// Create the library backend in the database thread
78
library_backend_ = new LibraryBackend;
79
library_backend_->moveToThread(parent->db_thread());
80
library_backend_->Init(parent->db_thread()->Worker(), kSongsTable,
81
QString::null, QString::null, kFtsTable);
82
library_model_ = new LibraryModel(library_backend_, parent->task_manager(), this);
84
connect(library_backend_, SIGNAL(TotalSongCountUpdated(int)),
85
SLOT(UpdateTotalSongCount(int)));
87
library_sort_model_->setSourceModel(library_model_);
88
library_sort_model_->setSortRole(LibraryModel::Role_SortText);
89
library_sort_model_->setDynamicSortFilter(true);
90
library_sort_model_->sort(0);
93
MagnatuneService::~MagnatuneService() {
97
void MagnatuneService::ReloadSettings() {
99
s.beginGroup(kSettingsGroup);
101
membership_ = MembershipType(s.value("membership", Membership_None).toInt());
102
username_ = s.value("username").toString();
103
password_ = s.value("password").toString();
104
format_ = PreferredFormat(s.value("format", Format_Ogg).toInt());
107
QStandardItem* MagnatuneService::CreateRootItem() {
108
root_ = new QStandardItem(QIcon(":/providers/magnatune.png"), kServiceName);
109
root_->setData(true, RadioModel::Role_CanLazyLoad);
113
void MagnatuneService::LazyPopulate(QStandardItem* item) {
114
switch (item->data(RadioModel::Role_Type).toInt()) {
115
case RadioModel::Type_Service:
116
library_model_->Init();
117
model()->merged_model()->AddSubModel(item->index(), library_sort_model_);
125
void MagnatuneService::UpdateTotalSongCount(int count) {
126
total_song_count_ = count;
127
if (total_song_count_ == 0 && !load_database_task_id_) {
132
void MagnatuneService::ReloadDatabase() {
133
QNetworkRequest request = QNetworkRequest(QUrl(kDatabaseUrl));
134
request.setAttribute(QNetworkRequest::CacheLoadControlAttribute,
135
QNetworkRequest::AlwaysNetwork);
137
QNetworkReply* reply = network_->get(request);
138
connect(reply, SIGNAL(finished()), SLOT(ReloadDatabaseFinished()));
140
if (!load_database_task_id_)
141
load_database_task_id_ = model()->task_manager()->StartTask(
142
tr("Downloading Magnatune catalogue"));
145
void MagnatuneService::ReloadDatabaseFinished() {
146
QNetworkReply* reply = qobject_cast<QNetworkReply*>(sender());
148
model()->task_manager()->SetTaskFinished(load_database_task_id_);
149
load_database_task_id_ = 0;
151
if (reply->error() != QNetworkReply::NoError) {
152
// TODO: Error handling
153
qDebug() << reply->errorString();
157
if (root_->hasChildren())
158
root_->removeRows(0, root_->rowCount());
160
// The XML file is compressed
161
QtIOCompressor gzip(reply);
162
gzip.setStreamFormat(QtIOCompressor::GzipFormat);
163
if (!gzip.open(QIODevice::ReadOnly)) {
164
qWarning() << "Error opening gzip stream";
168
// Remove all existing songs in the database
169
library_backend_->DeleteAll();
171
// Parse the XML we got from Magnatune
172
QXmlStreamReader reader(&gzip);
174
while (!reader.atEnd()) {
177
if (reader.tokenType() == QXmlStreamReader::StartElement &&
178
reader.name() == "Track") {
179
songs << ReadTrack(reader);
183
// Add the songs to the database
184
library_backend_->AddOrUpdateSongs(songs);
187
Song MagnatuneService::ReadTrack(QXmlStreamReader& reader) {
190
while (!reader.atEnd()) {
193
if (reader.tokenType() == QXmlStreamReader::EndElement)
196
if (reader.tokenType() == QXmlStreamReader::StartElement) {
197
QStringRef name = reader.name();
198
QString value = ReadElementText(reader);
200
if (name == "artist") song.set_artist(value);
201
if (name == "albumname") song.set_album(value);
202
if (name == "trackname") song.set_title(value);
203
if (name == "tracknum") song.set_track(value.toInt());
204
if (name == "year") song.set_year(value.toInt());
205
if (name == "magnatunegenres") song.set_genre(value.section(',', 0, 0));
206
if (name == "seconds") song.set_length_nanosec(value.toInt() * kNsecPerSec);
207
if (name == "url") song.set_filename(value);
208
if (name == "cover_small") song.set_art_automatic(value);
209
if (name == "albumsku") song.set_comment(value);
213
song.set_valid(true);
214
song.set_filetype(Song::Type_Stream);
216
// We need to set these to satisfy the database constraints
217
song.set_directory_id(0);
220
song.set_filesize(0);
225
// TODO: Replace with readElementText(SkipChildElements) in Qt 4.6
226
QString MagnatuneService::ReadElementText(QXmlStreamReader& reader) {
229
while (!reader.atEnd()) {
230
switch (reader.readNext()) {
231
case QXmlStreamReader::StartElement: level++; break;
232
case QXmlStreamReader::EndElement: level--; break;
233
case QXmlStreamReader::Characters:
234
ret += reader.text().toString().trimmed();
245
void MagnatuneService::EnsureMenuCreated() {
249
context_menu_ = new QMenu;
251
context_menu_->addActions(GetPlaylistActions());
252
download_ = context_menu_->addAction(
253
IconLoader::Load("download"), tr("Download this album"), this, SLOT(Download()));
254
context_menu_->addSeparator();
255
context_menu_->addAction(IconLoader::Load("download"), tr("Open magnatune.com in browser"), this, SLOT(Homepage()));
256
context_menu_->addAction(IconLoader::Load("view-refresh"), tr("Refresh catalogue"), this, SLOT(ReloadDatabase()));
257
QAction* config_action = context_menu_->addAction(IconLoader::Load("configure"), tr("Configure Magnatune..."), this, SLOT(ShowConfig()));
259
library_filter_ = new LibraryFilterWidget(0);
260
library_filter_->SetSettingsGroup(kSettingsGroup);
261
library_filter_->SetLibraryModel(library_model_);
262
library_filter_->SetFilterHint(tr("Search Magnatune"));
263
library_filter_->SetAgeFilterEnabled(false);
264
library_filter_->AddMenuAction(config_action);
267
void MagnatuneService::ShowContextMenu(const QModelIndex& index, const QPoint& global_pos) {
270
if (index.model() == library_sort_model_)
271
context_item_ = index;
273
context_item_ = QModelIndex();
275
GetAppendToPlaylistAction()->setEnabled(context_item_.isValid());
276
GetReplacePlaylistAction()->setEnabled(context_item_.isValid());
277
GetOpenInNewPlaylistAction()->setEnabled(context_item_.isValid());
278
download_->setEnabled(context_item_.isValid() && membership_ == Membership_Download);
279
context_menu_->popup(global_pos);
282
QModelIndex MagnatuneService::GetCurrentIndex() {
283
return context_item_;
286
void MagnatuneService::Homepage() {
287
QDesktopServices::openUrl(QUrl(kHomepage));
290
QUrl MagnatuneService::ModifyUrl(const QUrl& url) const {
293
switch(membership_) {
294
case Membership_None:
295
return ret; // Use the URL as-is
297
// Otherwise add the hostname
298
case Membership_Streaming:
299
ret.setHost(kStreamingHostname);
301
case Membership_Download:
302
ret.setHost(kDownloadHostname);
306
// Add the credentials
307
ret.setUserName(username_);
308
ret.setPassword(password_);
310
// And remove the commercial
311
QString path = ret.path();
312
path.insert(path.lastIndexOf('.'), "_nospeech");
318
void MagnatuneService::ShowConfig() {
319
emit OpenSettingsAtPage(SettingsDialog::Page_Magnatune);
322
void MagnatuneService::Download() {
323
QModelIndex index = library_sort_model_->mapToSource(context_item_);
324
SongList songs = library_model_->GetChildSongs(index);
326
MagnatuneDownloadDialog* dialog = new MagnatuneDownloadDialog(this, 0);
327
dialog->setAttribute(Qt::WA_DeleteOnClose);
330
connect(dialog, SIGNAL(Finished(QStringList)), SIGNAL(DownloadFinished(QStringList)));
333
QWidget* MagnatuneService::HeaderWidget() const {
334
const_cast<MagnatuneService*>(this)->EnsureMenuCreated();
335
return library_filter_;
added
removed
src/radio/magnatuneservice.cpp
