Import Fedora patch for compability with media-libs/liblastfm >= 1 wrt #423241 by Ryan Hill

(Portage version: 2.2.0_alpha116/cvs/Linux x86_64)

3 files changed, 619 insertions, 1 deletions

diff --git a/media-sound/clementine/ChangeLog b/media-sound/clementine/ChangeLog
index ba7a1ef494b4..ca762ac2de31 100644
--- a/media-sound/clementine/ChangeLog
+++ b/media-sound/clementine/ChangeLog
@@ -1,6 +1,13 @@
 # ChangeLog for media-sound/clementine
 # Copyright 1999-2012 Gentoo Foundation; Distributed under the GPL v2
-# $Header: /var/cvsroot/gentoo-x86/media-sound/clementine/ChangeLog,v 1.63 2012/07/06 03:29:00 jdhore Exp $
+# $Header: /var/cvsroot/gentoo-x86/media-sound/clementine/ChangeLog,v 1.64 2012/07/07 08:03:03 ssuominen Exp $
+
+*clementine-1.0.1-r2 (07 Jul 2012)
+
+  07 Jul 2012; Samuli Suominen <ssuominen@gentoo.org>
+  +clementine-1.0.1-r2.ebuild, +files/clementine-1.0.1-liblastfm-1.patch:
+  Import Fedora patch for compability with media-libs/liblastfm >= 1 wrt
+  #423241 by Ryan Hill
 
   06 Jul 2012; Jeff Horelick <jdhore@gentoo.org> clementine-1.0.1-r1.ebuild:
   marked x86 per bug 419945
diff --git a/media-sound/clementine/clementine-1.0.1-r2.ebuild b/media-sound/clementine/clementine-1.0.1-r2.ebuild
new file mode 100644
index 000000000000..36b544fbaef9
--- /dev/null
+++ b/media-sound/clementine/clementine-1.0.1-r2.ebuild
@@ -0,0 +1,136 @@
+# Copyright 1999-2012 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+# $Header: /var/cvsroot/gentoo-x86/media-sound/clementine/clementine-1.0.1-r2.ebuild,v 1.1 2012/07/07 08:03:03 ssuominen Exp $
+
+EAPI=4
+
+LANGS=" ar be bg bn br bs ca cs cy da de el en_CA en_GB eo es et eu fa fi fr gl he hi hr hu hy ia id is it ja ka kk ko lt lv mr ms nb nl oc pa pl pt_BR pt ro ru sk sl sr@latin sr sv tr uk vi zh_CN zh_TW"
+
+inherit cmake-utils eutils gnome2-utils virtualx
+
+DESCRIPTION="A modern music player and library organizer based on Amarok 1.4 and Qt4"
+HOMEPAGE="http://www.clementine-player.org/ http://code.google.com/p/clementine-player/"
+SRC_URI="http://clementine-player.googlecode.com/files/${P}.tar.gz"
+
+LICENSE="GPL-3"
+SLOT="0"
+KEYWORDS="~amd64 ~x86"
+IUSE="ayatana cdda +dbus ios ipod kde lastfm mms mtp projectm test +udev wiimote"
+IUSE+="${LANGS// / linguas_}"
+
+REQUIRED_USE="
+	ios? ( ipod )
+	udev? ( dbus )
+	wiimote? ( dbus )
+"
+
+COMMON_DEPEND="
+	>=x11-libs/qt-gui-4.5:4[dbus?]
+	>=x11-libs/qt-opengl-4.5:4
+	>=x11-libs/qt-sql-4.5:4[sqlite]
+	dev-db/sqlite[fts3]
+	>=media-libs/taglib-1.7[mp4]
+	>=dev-libs/glib-2.24.1-r1
+	dev-libs/libxml2
+	dev-libs/qjson
+	media-libs/libechonest
+	>=media-libs/chromaprint-0.6
+	media-libs/gstreamer:0.10
+	media-libs/gst-plugins-base:0.10
+	ayatana? ( dev-libs/libindicate-qt )
+	cdda? ( dev-libs/libcdio )
+	ipod? (
+		>=media-libs/libgpod-0.8.0[ios?]
+		ios? (
+			app-pda/libplist
+			>=app-pda/libimobiledevice-1.0
+			app-pda/usbmuxd
+		)
+	)
+	kde? ( >=kde-base/kdelibs-4.4 )
+	lastfm? ( >=media-libs/liblastfm-1 )
+	mtp? ( >=media-libs/libmtp-1.0.0 )
+	projectm? ( media-libs/glew )
+"
+# now only presets are used, libprojectm is internal
+# http://code.google.com/p/clementine-player/source/browse/#svn/trunk/3rdparty/libprojectm/patches
+# r1966 "Compile with a static sqlite by default, since Qt 4.7 doesn't seem to expose the symbols we need to use FTS"
+RDEPEND="${COMMON_DEPEND}
+	dbus? ( udev? ( sys-fs/udisks:0 ) )
+	mms? ( media-plugins/gst-plugins-libmms:0.10 )
+	mtp? ( gnome-base/gvfs )
+	projectm? ( >=media-libs/libprojectm-1.2.0 )
+	media-plugins/gst-plugins-meta:0.10
+	media-plugins/gst-plugins-gio:0.10
+	media-plugins/gst-plugins-soup:0.10
+	media-plugins/gst-plugins-taglib:0.10
+"
+DEPEND="${COMMON_DEPEND}
+	>=dev-libs/boost-1.39
+	virtual/pkgconfig
+	sys-devel/gettext
+	x11-libs/qt-test:4
+	kde? ( dev-util/automoc )
+	dev-cpp/gmock
+	test? ( gnome-base/gsettings-desktop-schemas )
+"
+DOCS="Changelog"
+
+src_prepare() {
+	# some tests fail or hang
+	sed -i \
+		-e '/add_test_file(translations_test.cpp/d' \
+		tests/CMakeLists.txt || die
+
+	# API changed, see http://bugs.gentoo.org/410933
+	has_version '>=app-pda/libimobiledevice-1.1.2' && \
+		sed -i -e 's:event->uuid:event->udid:' src/devices/ilister.cpp
+
+	epatch "${FILESDIR}"/${P}-fresh-start.patch \
+		"${FILESDIR}"/${P}-linguas.patch \
+		"${FILESDIR}"/${P}-liblastfm-1.patch
+}
+
+src_configure() {
+	local langs x
+	for x in ${LANGS}; do
+		use linguas_${x} && langs+=" ${x}"
+	done
+
+	# spotify is not in portage
+	# REMOTE is unstable
+	local mycmakeargs=(
+		-DBUILD_WERROR=OFF
+		-DLINGUAS="${langs}"
+		-DBUNDLE_PROJECTM_PRESETS=OFF
+		$(cmake-utils_use cdda ENABLE_AUDIOCD)
+		$(cmake-utils_use dbus ENABLE_DBUS)
+		$(cmake-utils_use udev ENABLE_DEVICEKIT)
+		$(cmake-utils_use ipod ENABLE_LIBGPOD)
+		$(cmake-utils_use ios ENABLE_IMOBILEDEVICE)
+		$(cmake-utils_use kde ENABLE_PLASMARUNNER)
+		$(cmake-utils_use lastfm ENABLE_LIBLASTFM)
+		$(cmake-utils_use mtp ENABLE_LIBMTP)
+		-DENABLE_GIO=ON
+		$(cmake-utils_use wiimote ENABLE_WIIMOTEDEV)
+		$(cmake-utils_use projectm ENABLE_VISUALISATIONS)
+		$(cmake-utils_use ayatana ENABLE_SOUNDMENU)
+		-DENABLE_SPOTIFY=OFF
+		-DENABLE_SPOTIFY_BLOB=OFF
+		-DENABLE_REMOTE=OFF
+		-DENABLE_BREAKPAD=OFF
+		-DSTATIC_SQLITE=OFF
+		-DUSE_SYSTEM_GMOCK=ON
+		)
+
+	cmake-utils_src_configure
+}
+
+src_test() {
+	cd "${CMAKE_BUILD_DIR}" || die
+	Xemake test
+}
+
+pkg_preinst() { gnome2_icon_savelist; }
+pkg_postinst() { gnome2_icon_cache_update; }
+pkg_postrm() { gnome2_icon_cache_update; }
diff --git a/media-sound/clementine/files/clementine-1.0.1-liblastfm-1.patch b/media-sound/clementine/files/clementine-1.0.1-liblastfm-1.patch
new file mode 100644
index 000000000000..7ab1c29e73e8
--- /dev/null
+++ b/media-sound/clementine/files/clementine-1.0.1-liblastfm-1.patch
@@ -0,0 +1,475 @@
+--- src/core/song.cpp
++++ src/core/song.cpp
+@@ -49,7 +49,7 @@
+ 
+ #ifdef HAVE_LIBLASTFM
+   #include "internet/fixlastfm.h"
+-  #include <lastfm/Track>
++  #include <lastfm/Track.h>
+ #endif
+ 
+ #include <QFile>
+--- src/covers/lastfmcoverprovider.cpp
++++ src/covers/lastfmcoverprovider.cpp
+@@ -19,8 +19,8 @@
+ #include "coverprovider.h"
+ #include "lastfmcoverprovider.h"
+ 
+-#include <lastfm/Artist>
+-#include <lastfm/XmlQuery>
++#include <lastfm/Artist.h>
++#include <lastfm/XmlQuery.h>
+ #include <lastfm/ws.h>
+ 
+ #include <QNetworkReply>
+@@ -52,14 +52,8 @@ void LastFmCoverProvider::QueryFinished(
+ 
+   CoverSearchResults results;
+ 
+-  try {
+-    lastfm::XmlQuery query(lastfm::ws::parse(reply));
+-#ifdef Q_OS_WIN32
+-    if (lastfm::ws::last_parse_error != lastfm::ws::NoError) {
+-      throw std::runtime_error("");
+-    }
+-#endif
+-
++  lastfm::XmlQuery query;
++  if (query.parse(reply->readAll())) {
+     // parse the list of search results
+     QList<lastfm::XmlQuery> elements = query["results"]["albummatches"].children("album");
+ 
+@@ -69,7 +63,7 @@ void LastFmCoverProvider::QueryFinished(
+       result.image_url = element["image size=extralarge"].text();
+       results << result;
+     }
+-  } catch(std::runtime_error&) {
++  } else {
+     // Drop through and emit an empty list of results.
+   }
+ 
+--- src/internet/lastfmservice.cpp
++++ src/internet/lastfmservice.cpp
+@@ -33,20 +33,18 @@
+ 
+ #include <boost/scoped_ptr.hpp>
+ 
+-#include <lastfm/Audioscrobbler>
++#include <lastfm/Audioscrobbler.h>
+ #include <lastfm/misc.h>
+-#include <lastfm/RadioStation>
+-#include <lastfm/Scrobble>
+-#include <lastfm/ScrobbleCache>
+-#include <lastfm/ScrobblePoint>
++#include <lastfm/RadioStation.h>
++#include <lastfm/ScrobbleCache.h>
++#include <lastfm/ScrobblePoint.h>
+ #include <lastfm/ws.h>
+-#include <lastfm/XmlQuery>
++#include <lastfm/XmlQuery.h>
+ 
+ #include <QMenu>
+ #include <QSettings>
+ 
+ using boost::scoped_ptr;
+-using lastfm::Scrobble;
+ using lastfm::XmlQuery;
+ 
+ uint qHash(const lastfm::Track& track) {
+@@ -300,13 +298,8 @@ void LastFMService::AuthenticateReplyFin
+   reply->deleteLater();
+ 
+   // Parse the reply
+-  try {
+-    lastfm::XmlQuery const lfm = lastfm::ws::parse(reply);
+-#ifdef Q_OS_WIN32
+-    if (lastfm::ws::last_parse_error != lastfm::ws::NoError)
+-      throw std::runtime_error("");
+-#endif
+-
++  lastfm::XmlQuery lfm;
++  if (lfm.parse(reply->readAll())) {
+     lastfm::ws::Username = lfm["session"]["name"].text();
+     lastfm::ws::SessionKey = lfm["session"]["key"].text();
+     QString subscribed = lfm["session"]["subscriber"].text();
+@@ -318,8 +311,8 @@ void LastFMService::AuthenticateReplyFin
+     settings.setValue("Username", lastfm::ws::Username);
+     settings.setValue("Session", lastfm::ws::SessionKey);
+     settings.setValue("Subscriber", is_subscriber);
+-  } catch (std::runtime_error& e) {
+-    qLog(Error) << e.what();
++  } else {
++    qLog(Error) << lfm.parseError().message();
+     emit AuthenticationComplete(false);
+     return;
+   }
+@@ -347,13 +340,8 @@ void LastFMService::UpdateSubscriberStat
+ 
+   bool is_subscriber = false;
+ 
+-  try {
+-    const lastfm::XmlQuery lfm = lastfm::ws::parse(reply);
+-#ifdef Q_OS_WIN32
+-    if (lastfm::ws::last_parse_error != lastfm::ws::NoError)
+-      throw std::runtime_error("");
+-#endif
+-
++  lastfm::XmlQuery lfm;
++  if (lfm.parse(reply->readAll())) {
+     connection_problems_ = false;
+     QString subscriber = lfm["user"]["subscriber"].text();
+     is_subscriber = (subscriber.toInt() == 1);
+@@ -362,11 +350,9 @@ void LastFMService::UpdateSubscriberStat
+     settings.beginGroup(kSettingsGroup);
+     settings.setValue("Subscriber", is_subscriber);
+     qLog(Info) << lastfm::ws::Username << "Subscriber status:" << is_subscriber;
+-  } catch (lastfm::ws::ParseError e) {
+-    qLog(Error) << "Last.fm parse error: " << e.enumValue();
+-    connection_problems_ = e.enumValue() == lastfm::ws::MalformedResponse;
+-  } catch (std::runtime_error& e) {
+-    qLog(Error) << e.what();
++  } else {
++    qLog(Error) << "Last.fm parse error: " << lfm.parseError().message();
++    connection_problems_ = lfm.parseError().enumValue() == lastfm::ws::MalformedResponse;
+   }
+ 
+   emit UpdatedSubscriberStatus(is_subscriber);
+@@ -469,7 +455,8 @@ bool LastFMService::InitScrobbler() {
+     scrobbler_ = new lastfm::Audioscrobbler(kAudioscrobblerClientId);
+ 
+   //reemit the signal since the sender is private
+-  connect(scrobbler_, SIGNAL(status(int)), SIGNAL(ScrobblerStatus(int)));
++  connect(scrobbler_, SIGNAL(scrobblesSubmitted(QList<lastfm::Track>)), SIGNAL(ScrobbleSubmitted()));
++  connect(scrobbler_, SIGNAL(nowPlayingError(int,QString)), SIGNAL(ScrobbleError(int)));
+   return true;
+ }
+ 
+@@ -497,7 +484,7 @@ void LastFMService::NowPlaying(const Son
+   if (!last_track_.isNull() &&
+       last_track_.source() == lastfm::Track::NonPersonalisedBroadcast) {
+     const int duration_secs = last_track_.timestamp().secsTo(QDateTime::currentDateTime());
+-    if (duration_secs >= ScrobblePoint::kScrobbleMinLength) {
++    if (duration_secs >= lastfm::ScrobblePoint::scrobbleTimeMin()) {
+       lastfm::MutableTrack mtrack(last_track_);
+       mtrack.setDuration(duration_secs);
+ 
+@@ -514,14 +501,16 @@ void LastFMService::NowPlaying(const Son
+   already_scrobbled_ = false;
+   last_track_ = mtrack;
+ 
+-  //check immediately if the song is valid
+-  Scrobble::Invalidity invalidity;
+-
+-  if (!lastfm::Scrobble(last_track_).isValid( &invalidity )) {
+-    //for now just notify this, we can also see the cause
+-    emit ScrobblerStatus(-1);
+-    return;
+-  }
++// TODO: validity was removed from liblastfm1 but might reappear, it should have
++// no impact as we get a different error when actually trying to scrobble.
++//   //check immediately if the song is valid
++//   Scrobble::Invalidity invalidity;
++//
++//   if (!lastfm::Scrobble(last_track_).isValid( &invalidity )) {
++//     //for now just notify this, we can also see the cause
++//     emit ScrobbleError(-1);
++//     return;
++//   }
+ 
+   scrobbler_->nowPlaying(mtrack);
+ }
+@@ -530,12 +519,12 @@ void LastFMService::Scrobble() {
+   if (!InitScrobbler())
+     return;
+ 
+-  ScrobbleCache cache(lastfm::ws::Username);
++  lastfm::ScrobbleCache cache(lastfm::ws::Username);
+   qLog(Debug) << "There are" << cache.tracks().count() << "tracks in the last.fm cache.";
+   scrobbler_->cache(last_track_);
+ 
+   // Let's mark a track as cached, useful when the connection is down
+-  emit ScrobblerStatus(30);
++  emit ScrobbleError(30);
+   scrobbler_->submit();
+ 
+   already_scrobbled_ = true;
+@@ -640,7 +629,7 @@ void LastFMService::RefreshFriends(bool
+     return;
+   }
+ 
+-  lastfm::AuthenticatedUser user;
++  lastfm::User user;
+   QNetworkReply* reply = user.getFriends();
+   connect(reply, SIGNAL(finished()), SLOT(RefreshFriendsFinished()));
+ }
+@@ -649,7 +638,7 @@ void LastFMService::RefreshNeighbours()
+   if (!neighbours_list_ || !IsAuthenticated())
+     return;
+ 
+-  lastfm::AuthenticatedUser user;
++  lastfm::User user;
+   QNetworkReply* reply = user.getNeighbours();
+   connect(reply, SIGNAL(finished()), SLOT(RefreshNeighboursFinished()));
+ }
+@@ -661,14 +650,11 @@ void LastFMService::RefreshFriendsFinish
+ 
+   QList<lastfm::User> friends;
+ 
+-  try {
+-    friends = lastfm::User::list(reply);
+-#ifdef Q_OS_WIN32
+-    if (lastfm::ws::last_parse_error != lastfm::ws::NoError)
+-      throw std::runtime_error("");
+-#endif
+-  } catch (std::runtime_error& e) {
+-    qLog(Error) << e.what();
++  lastfm::XmlQuery lfm;
++  if (lfm.parse(reply->readAll())) {
++    friends = lastfm::UserList(lfm).users();
++  } else {
++    qLog(Error) << lfm.parseError().message();
+     return;
+   }
+ 
+@@ -708,14 +694,11 @@ void LastFMService::RefreshNeighboursFin
+ 
+   QList<lastfm::User> neighbours;
+ 
+-  try {
+-    neighbours = lastfm::User::list(reply);
+-#ifdef Q_OS_WIN32
+-    if (lastfm::ws::last_parse_error != lastfm::ws::NoError)
+-      throw std::runtime_error("");
+-#endif
+-  } catch (std::runtime_error& e) {
+-    qLog(Error) << e.what();
++  lastfm::XmlQuery lfm;
++  if (lfm.parse(reply->readAll())) {
++    neighbours = lastfm::UserList(lfm).users();
++  } else {
++    qLog(Error) << lfm.parseError().message();
+     return;
+   }
+ 
+@@ -869,13 +852,8 @@ void LastFMService::FetchMoreTracksFinis
+   model()->task_manager()->SetTaskFinished(tune_task_id_);
+   tune_task_id_ = 0;
+ 
+-  try {
+-    const XmlQuery& query = lastfm::ws::parse(reply);
+-#ifdef Q_OS_WIN32
+-    if (lastfm::ws::last_parse_error != lastfm::ws::NoError)
+-      throw std::runtime_error("");
+-#endif
+-
++  XmlQuery query;
++  if (query.parse(reply->readAll())) {
+     const XmlQuery& playlist = query["playlist"];
+     foreach (const XmlQuery& q, playlist["trackList"].children("track")) {
+       lastfm::MutableTrack t;
+@@ -890,17 +868,9 @@ void LastFMService::FetchMoreTracksFinis
+       art_urls_[t] = q["image"].text();
+       playlist_ << t;
+     }
+-  } catch (std::runtime_error& e) {
+-    // For some reason a catch block that takes a lastfm::ws::ParseError&
+-    // doesn't get called, even when a lastfm::ws::ParseError is thrown...
+-    // Hacks like this remind me of Java...
+-    if (QString(typeid(e).name()).contains("ParseError")) {
+-      // dynamic_cast throws a std::bad_cast ... *boggle*
++  } else {
+       emit StreamError(tr("Couldn't load the last.fm radio station")
+-                       .arg(e.what()));
+-    } else {
+-      emit StreamError(tr("An unknown last.fm error occurred: %1").arg(e.what()));
+-    }
++                       .arg(query.parseError().message()));
+     return;
+   }
+ 
+@@ -913,7 +883,7 @@ void LastFMService::Tune(const QUrl& url
+ 
+   last_url_ = url;
+   initial_tune_ = true;
+-  const lastfm::RadioStation station(FixupUrl(url));
++  const lastfm::RadioStation station(FixupUrl(url).toString());
+ 
+   playlist_.clear();
+ 
+--- src/internet/lastfmservice.h
++++ src/internet/lastfmservice.h
+@@ -27,7 +27,8 @@ class Track;
+ uint qHash(const lastfm::Track& track);
+ 
+ #include "fixlastfm.h"
+-#include <lastfm/Track>
++#include <lastfm/Audioscrobbler.h>
++#include <lastfm/Track.h>
+ #include <lastfm/ws.h>
+ 
+ #include "internetmodel.h"
+@@ -132,7 +133,8 @@ class LastFMService : public InternetSer
+   void ScrobblingEnabledChanged(bool value);
+   void ButtonVisibilityChanged(bool value);
+   void ScrobbleButtonVisibilityChanged(bool value);
+-  void ScrobblerStatus(int value);
++  void ScrobbleSubmitted();
++  void ScrobbleError(int value);
+   void UpdatedSubscriberStatus(bool is_subscriber);
+   void ScrobbledRadioStream();
+ 
+--- src/songinfo/lastfmtrackinfoprovider.cpp
++++ src/songinfo/lastfmtrackinfoprovider.cpp
+@@ -22,7 +22,7 @@
+ #include "ui/iconloader.h"
+ 
+ #include <lastfm/ws.h>
+-#include <lastfm/XmlQuery>
++#include <lastfm/XmlQuery.h>
+ 
+ void LastfmTrackInfoProvider::FetchInfo(int id, const Song& metadata) {
+   QMap<QString, QString> params;
+@@ -50,18 +50,12 @@ void LastfmTrackInfoProvider::RequestFin
+     return;
+   }
+ 
+-  try {
+-    lastfm::XmlQuery query = lastfm::ws::parse(reply);
+-#ifdef Q_OS_WIN32
+-    if (lastfm::ws::last_parse_error != lastfm::ws::NoError)
+-      throw std::runtime_error("");
+-#endif
+-
++  lastfm::XmlQuery query;
++  if (query.parse(reply->readAll())) {
+     GetPlayCounts(id, query);
+     GetWiki(id, query);
+     GetTags(id, query);
+ 
+-  } catch (std::runtime_error&) {
+   }
+   emit Finished(id);
+ }
+--- src/suggesters/lastfmsuggester.cpp
++++ src/suggesters/lastfmsuggester.cpp
+@@ -1,6 +1,6 @@
+ #include "lastfmsuggester.h"
+ 
+-#include <lastfm/XmlQuery>
++#include <lastfm/XmlQuery.h>
+ 
+ #include "core/logging.h"
+ #include "core/timeconstants.h"
+@@ -39,13 +39,8 @@ void LastFMSuggester::RequestFinished()
+   int id = it.value();
+   replies_.erase(it);
+ 
+-  try {
+-    lastfm::XmlQuery const lfm = lastfm::ws::parse(reply);
+-#ifdef Q_OS_WIN32
+-    if (lastfm::ws::last_parse_error != lastfm::ws::NoError)
+-      throw std::runtime_error("");
+-#endif
+-
++  lastfm::XmlQuery lfm;
++  if (lfm.parse(reply->readAll())) {
+     const QList<XmlQuery> tracks = lfm["similartracks"].children("track");
+     SongList songs;
+     foreach (const XmlQuery& q, tracks) {
+@@ -59,8 +54,8 @@ void LastFMSuggester::RequestFinished()
+     }
+     qLog(Debug) << songs.length() << "suggested songs from Last.fm";
+     emit SuggestSongsFinished(id, songs);
+-  } catch (std::runtime_error& e) {
+-    qLog(Error) << e.what();
++  } else {
++    qLog(Error) << lfm.parseError().message();
+     emit SuggestSongsFinished(id, SongList());
+   }
+ }
+--- src/ui/mainwindow.cpp
++++ src/ui/mainwindow.cpp
+@@ -700,7 +700,8 @@ MainWindow::MainWindow(
+   connect(player_->playlists()->sequence(), SIGNAL(ShuffleModeChanged(PlaylistSequence::ShuffleMode)), osd_, SLOT(ShuffleModeChanged(PlaylistSequence::ShuffleMode)));
+ 
+ #ifdef HAVE_LIBLASTFM
+-  connect(InternetModel::Service<LastFMService>(), SIGNAL(ScrobblerStatus(int)), SLOT(ScrobblerStatus(int)));
++  connect(InternetModel::Service<LastFMService>(), SIGNAL(ScrobbleSubmitted()), SLOT(ScrobbleSubmitted()));
++  connect(InternetModel::Service<LastFMService>(), SIGNAL(ScrobbleError(int)), SLOT(ScrobbleError(int)));
+ 
+   LastFMButtonVisibilityChanged(internet_model_->InternetModel::Service<LastFMService>()->AreButtonsVisible());
+   ScrobbleButtonVisibilityChanged(internet_model_->InternetModel::Service<LastFMService>()->IsScrobbleButtonVisible());
+@@ -2201,30 +2202,26 @@ void MainWindow::SetToggleScrobblingIcon
+ }
+ 
+ #ifdef HAVE_LIBLASTFM
+-void MainWindow::ScrobblerStatus(int value) {
++void MainWindow::ScrobbleSubmitted() {
+   const LastFMService* lastfm_service = InternetModel::Service<LastFMService>();
+   const bool last_fm_enabled = ui_->action_toggle_scrobbling->isVisible() &&
+                                lastfm_service->IsScrobblingEnabled() &&
+                                lastfm_service->IsAuthenticated();
+ 
++  playlists_->active()->set_lastfm_status(Playlist::LastFM_Scrobbled);
++  // update the button icon
++  if (last_fm_enabled)
++    ui_->action_toggle_scrobbling->setIcon(QIcon(":/last.fm/as.png"));                                                                                                                                     
++}                                                                                                                                                                                                          
++
++void MainWindow::ScrobbleError(int value) {
++
+   switch (value) {
+     case -1:
+       // custom error value got from initial validity check
+       playlists_->active()->set_lastfm_status(Playlist::LastFM_Invalid);
+       break;
+ 
+-    case 2:
+-    case 3:
+-      // we should get 3 for a correct scrobbling, but I just get 2 for
+-      // mysterious reasons
+-      // seems to scrobble fine though, so for now we accept it as correct
+-      playlists_->active()->set_lastfm_status(Playlist::LastFM_Scrobbled);
+-
+-      // update the button icon
+-      if (last_fm_enabled)
+-        ui_->action_toggle_scrobbling->setIcon(QIcon(":/last.fm/as.png"));
+-      break;
+-
+     case 30:
+       // Hack: when offline, liblastfm doesn't inform us, so set the status
+       // as queued; in this way we won't try to scrobble again, it will be done automatically
+--- src/ui/mainwindow.h
++++ src/ui/mainwindow.h
+@@ -224,7 +224,8 @@ class MainWindow : public QMainWindow, p
+ 
+   void ShowCoverManager();
+ #ifdef HAVE_LIBLASTFM
+-  void ScrobblerStatus(int value);
++  void ScrobbleSubmitted();
++  void ScrobbleError(int value);
+ #endif
+   void ShowAboutDialog();
+   void ShowTranscodeDialog();
+--- tests/mpris1_test.cpp
++++ tests/mpris1_test.cpp
+@@ -22,7 +22,7 @@
+ #include "playlist/playlistsequence.h"
+ #ifdef HAVE_LIBLASTFM
+ #include "internet/fixlastfm.h"
+-#include <lastfm/Track>
++#include <lastfm/Track.h>
+ #endif
+ 
+ #include "gmock/gmock.h"
+--- tests/song_test.cpp
++++ tests/song_test.cpp
+@@ -20,7 +20,7 @@
+ #include "core/song.h"
+ #ifdef HAVE_LIBLASTFM
+ #include "internet/fixlastfm.h"
+-#include <lastfm/Track>
++#include <lastfm/Track.h>
+ #endif
+ 
+ #include "gmock/gmock.h"