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