1 /****************************************************************************************
2 * Copyright (c) 2012 Matěj Laitl <matej@laitl.cz> *
3 * *
4 * This program is free software; you can redistribute it and/or modify it under *
5 * the terms of the GNU General Public License as published by the Free Software *
6 * Foundation; either version 2 of the License, or (at your option) any later *
7 * version. *
8 * *
9 * This program is distributed in the hope that it will be useful, but WITHOUT ANY *
10 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A *
11 * PARTICULAR PURPOSE. See the GNU General Public License for more details. *
12 * *
13 * You should have received a copy of the GNU General Public License along with *
14 * this program. If not, see <http://www.gnu.org/licenses/>. *
15 ****************************************************************************************/
16
17 #include "SynchronizeTracksJob.h"
18
19 #include "core/meta/Meta.h"
20 #include "core/meta/Statistics.h"
21 #include "core/support/Components.h"
22 #include "core/support/Debug.h"
23 #include "statsyncing/Controller.h"
24 #include "statsyncing/TrackTuple.h"
25
26 #include <ThreadWeaver/Thread>
27
28 using namespace StatSyncing;
29
30 static const int denom = 20; // Q_EMIT incementProgress() signal each N tracks
31 static const int fuzz = denom / 2;
32
SynchronizeTracksJob(const QList<TrackTuple> & tuples,const TrackList & tracksToScrobble,const Options & options,QObject * parent)33 SynchronizeTracksJob::SynchronizeTracksJob( const QList<TrackTuple> &tuples,
34 const TrackList &tracksToScrobble,
35 const Options &options, QObject *parent )
36 : QObject( parent )
37 , ThreadWeaver::Job()
38 , m_abort( false )
39 , m_tuples( tuples )
40 , m_tracksToScrobble( tracksToScrobble )
41 , m_updatedTracksCount( 0 )
42 , m_options( options )
43 {
44 }
45
46 void
abort()47 SynchronizeTracksJob::abort()
48 {
49 m_abort = true;
50 }
51
52 void
run(ThreadWeaver::JobPointer self,ThreadWeaver::Thread * thread)53 SynchronizeTracksJob::run(ThreadWeaver::JobPointer self, ThreadWeaver::Thread *thread)
54 {
55 Q_UNUSED(self);
56 Q_UNUSED(thread);
57 Q_EMIT totalSteps( ( m_tuples.size() + fuzz ) / denom );
58
59 Controller *controller = Amarok::Components::statSyncingController();
60 if( controller )
61 {
62 connect( this, &SynchronizeTracksJob::scrobble,
63 controller, &StatSyncing::Controller::scrobble );
64 // we don't run an event loop, we must use direct connection for controller to talk to us
65 connect( controller, &StatSyncing::Controller::trackScrobbled,
66 this, &SynchronizeTracksJob::slotTrackScrobbled, Qt::DirectConnection );
67 connect( controller, &StatSyncing::Controller::scrobbleFailed,
68 this, &SynchronizeTracksJob::slotScrobbleFailed, Qt::DirectConnection );
69 }
70 else
71 warning() << __PRETTY_FUNCTION__ << "StatSyncing::Controller not available!";
72
73 // first, queue tracks for scrobbling, because after syncing their recent playcount is
74 // reset
75 foreach( const TrackPtr &track, m_tracksToScrobble )
76 {
77 Meta::TrackPtr metaTrack = track->metaTrack();
78 int playcount = track->recentPlayCount();
79 if( metaTrack && playcount > 0 )
80 {
81 m_scrobbledTracks << metaTrack;
82 Q_EMIT scrobble( metaTrack, playcount, track->lastPlayed() );
83 }
84 }
85
86 ProviderPtrSet updatedProviders;
87 int i = 0;
88 foreach( const TrackTuple &tuple, m_tuples )
89 {
90 if( m_abort )
91 break;
92
93 // no point in checking for hasUpdate() here, synchronize() is witty enough
94 const ProviderPtrSet tupleUpdatedProviders = tuple.synchronize( m_options );
95 updatedProviders |= tupleUpdatedProviders;
96 m_updatedTracksCount += tupleUpdatedProviders.count();
97 if( ( i + fuzz ) % denom == 0 )
98 Q_EMIT incrementProgress();
99 i++;
100 }
101
102 foreach( ProviderPtr provider, updatedProviders )
103 provider->commitTracks();
104
105
106 // we need to reset playCount of scrobbled tracks to reset their recent play count
107 foreach( Meta::TrackPtr track, m_scrobbledTracks )
108 {
109 Meta::StatisticsPtr statistics = track->statistics();
110 statistics->setPlayCount( statistics->playCount() );
111 }
112
113 if( !m_tracksToScrobble.isEmpty() )
114 // wait 3 seconds so that we have chance to catch slotTrackScrobbled()..
115 QObject::thread()->msleep( 3000 );
116 if( controller )
117 disconnect( controller, &StatSyncing::Controller::trackScrobbled, this, 0 );
118 disconnect( controller, &StatSyncing::Controller::scrobbleFailed, this, 0 );
119
120 Q_EMIT endProgressOperation( this );
121 }
122
defaultBegin(const ThreadWeaver::JobPointer & self,ThreadWeaver::Thread * thread)123 void SynchronizeTracksJob::defaultBegin(const ThreadWeaver::JobPointer& self, ThreadWeaver::Thread *thread)
124 {
125 Q_EMIT started(self);
126 ThreadWeaver::Job::defaultBegin(self, thread);
127 }
128
defaultEnd(const ThreadWeaver::JobPointer & self,ThreadWeaver::Thread * thread)129 void SynchronizeTracksJob::defaultEnd(const ThreadWeaver::JobPointer& self, ThreadWeaver::Thread *thread)
130 {
131 ThreadWeaver::Job::defaultEnd(self, thread);
132 if (!self->success()) {
133 Q_EMIT failed(self);
134 }
135 Q_EMIT done(self);
136 }
137
138 void
slotTrackScrobbled(const ScrobblingServicePtr & service,const Meta::TrackPtr & track)139 SynchronizeTracksJob::slotTrackScrobbled( const ScrobblingServicePtr &service,
140 const Meta::TrackPtr &track )
141 {
142 slotScrobbleFailed( service, track, ScrobblingService::NoError );
143 }
144
145 void
slotScrobbleFailed(const ScrobblingServicePtr & service,const Meta::TrackPtr & track,int error)146 SynchronizeTracksJob::slotScrobbleFailed( const ScrobblingServicePtr &service,
147 const Meta::TrackPtr &track, int error )
148 {
149 // only count tracks scrobbled by us. Still chance for false-positives, though
150 if( m_scrobbledTracks.contains( track ) )
151 {
152 ScrobblingService::ScrobbleError errorEnum = ScrobblingService::ScrobbleError( error );
153 m_scrobbles[ service ][ errorEnum ]++;
154 }
155 }
156
157 int
updatedTracksCount() const158 SynchronizeTracksJob::updatedTracksCount() const
159 {
160 return m_updatedTracksCount;
161 }
162
163 QMap<ScrobblingServicePtr, QMap<ScrobblingService::ScrobbleError, int> >
scrobbles()164 SynchronizeTracksJob::scrobbles()
165 {
166 return m_scrobbles;
167 }
168