1 /* This file is part of Clementine.
2    Copyright 2010, David Sansome <me@davidsansome.com>
3 
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.
8 
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.
13 
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/>.
16 */
17 
18 #include "library.h"
19 
20 #include "librarymodel.h"
21 #include "librarybackend.h"
22 #include "core/application.h"
23 #include "core/database.h"
24 #include "core/player.h"
25 #include "core/tagreaderclient.h"
26 #include "core/taskmanager.h"
27 #include "core/thread.h"
28 #include "smartplaylists/generator.h"
29 #include "smartplaylists/querygenerator.h"
30 #include "smartplaylists/search.h"
31 
32 const char* Library::kSongsTable = "songs";
33 const char* Library::kDirsTable = "directories";
34 const char* Library::kSubdirsTable = "subdirectories";
35 const char* Library::kFtsTable = "songs_fts";
36 
Library(Application * app,QObject * parent)37 Library::Library(Application* app, QObject* parent)
38     : QObject(parent),
39       app_(app),
40       backend_(nullptr),
41       model_(nullptr),
42       watcher_(nullptr),
43       watcher_thread_(nullptr),
44       save_statistics_in_files_(false),
45       save_ratings_in_files_(false) {
46   backend_ = new LibraryBackend;
47   backend()->moveToThread(app->database()->thread());
48 
49   backend_->Init(app->database(), kSongsTable, kDirsTable, kSubdirsTable,
50                  kFtsTable);
51 
52   using smart_playlists::Generator;
53   using smart_playlists::GeneratorPtr;
54   using smart_playlists::QueryGenerator;
55   using smart_playlists::Search;
56   using smart_playlists::SearchTerm;
57 
58   model_ = new LibraryModel(backend_, app_, this);
59   model_->set_show_smart_playlists(true);
60   model_->set_default_smart_playlists(
61       LibraryModel::DefaultGenerators()
62       << (LibraryModel::GeneratorList()
63           << GeneratorPtr(new QueryGenerator(
64                  QT_TRANSLATE_NOOP("Library", "50 random tracks"),
65                  Search(Search::Type_All, Search::TermList(),
66                         Search::Sort_Random, SearchTerm::Field_Title, 50)))
67           << GeneratorPtr(new QueryGenerator(
68                  QT_TRANSLATE_NOOP("Library", "Ever played"),
69                  Search(Search::Type_And, Search::TermList() << SearchTerm(
70                                               SearchTerm::Field_PlayCount,
71                                               SearchTerm::Op_GreaterThan, 0),
72                         Search::Sort_Random, SearchTerm::Field_Title)))
73           << GeneratorPtr(new QueryGenerator(
74                  QT_TRANSLATE_NOOP("Library", "Never played"),
75                  Search(Search::Type_And, Search::TermList() << SearchTerm(
76                                               SearchTerm::Field_PlayCount,
77                                               SearchTerm::Op_Equals, 0),
78                         Search::Sort_Random, SearchTerm::Field_Title)))
79           << GeneratorPtr(new QueryGenerator(
80                  QT_TRANSLATE_NOOP("Library", "Last played"),
81                  Search(Search::Type_All, Search::TermList(),
82                         Search::Sort_FieldDesc, SearchTerm::Field_LastPlayed)))
83           << GeneratorPtr(new QueryGenerator(
84                  QT_TRANSLATE_NOOP("Library", "Most played"),
85                  Search(Search::Type_All, Search::TermList(),
86                         Search::Sort_FieldDesc, SearchTerm::Field_PlayCount)))
87           << GeneratorPtr(new QueryGenerator(
88                  QT_TRANSLATE_NOOP("Library", "Favourite tracks"),
89                  Search(Search::Type_All, Search::TermList(),
90                         Search::Sort_FieldDesc, SearchTerm::Field_Score)))
91           << GeneratorPtr(new QueryGenerator(
92                  QT_TRANSLATE_NOOP("Library", "Newest tracks"),
93                  Search(Search::Type_All, Search::TermList(),
94                         Search::Sort_FieldDesc,
95                         SearchTerm::Field_DateCreated))))
96       << (LibraryModel::GeneratorList()
97           << GeneratorPtr(new QueryGenerator(
98                  QT_TRANSLATE_NOOP("Library", "All tracks"),
99                  Search(Search::Type_All, Search::TermList(),
100                         Search::Sort_FieldAsc, SearchTerm::Field_Artist, -1)))
101           << GeneratorPtr(new QueryGenerator(
102                  QT_TRANSLATE_NOOP("Library", "Least favourite tracks"),
103                  Search(Search::Type_Or,
104                         Search::TermList()
105                             << SearchTerm(SearchTerm::Field_Rating,
106                                           SearchTerm::Op_LessThan, 0.6)
107                             << SearchTerm(SearchTerm::Field_SkipCount,
108                                           SearchTerm::Op_GreaterThan, 4),
109                         Search::Sort_FieldDesc, SearchTerm::Field_SkipCount))))
110       << (LibraryModel::GeneratorList() << GeneratorPtr(new QueryGenerator(
111               QT_TRANSLATE_NOOP("Library", "Dynamic random mix"),
112               Search(Search::Type_All, Search::TermList(), Search::Sort_Random,
113                      SearchTerm::Field_Title),
114               true))));
115 
116   // full rescan revisions
117   full_rescan_revisions_[26] = tr("CUE sheet support");
118   full_rescan_revisions_[50] = tr("Original year tag support");
119 
120   ReloadSettings();
121 }
122 
~Library()123 Library::~Library() {
124   watcher_->Stop();
125   watcher_->deleteLater();
126   watcher_thread_->exit();
127   watcher_thread_->wait(5000 /* five seconds */);
128 }
129 
Init()130 void Library::Init() {
131   watcher_ = new LibraryWatcher;
132   watcher_thread_ = new Thread(this);
133   watcher_thread_->SetIoPriority(Utilities::IOPRIO_CLASS_IDLE);
134 
135   watcher_->moveToThread(watcher_thread_);
136   watcher_thread_->start(QThread::IdlePriority);
137 
138   watcher_->set_backend(backend_);
139   watcher_->set_task_manager(app_->task_manager());
140 
141   connect(backend_, SIGNAL(DirectoryDiscovered(Directory, SubdirectoryList)),
142           watcher_, SLOT(AddDirectory(Directory, SubdirectoryList)));
143   connect(backend_, SIGNAL(DirectoryDeleted(Directory)), watcher_,
144           SLOT(RemoveDirectory(Directory)));
145   connect(backend_, SIGNAL(SongsRatingChanged(SongList)),
146           SLOT(SongsRatingChanged(SongList)));
147   connect(backend_, SIGNAL(SongsStatisticsChanged(SongList)),
148           SLOT(SongsStatisticsChanged(SongList)));
149   connect(watcher_, SIGNAL(NewOrUpdatedSongs(SongList)), backend_,
150           SLOT(AddOrUpdateSongs(SongList)));
151   connect(watcher_, SIGNAL(SongsMTimeUpdated(SongList)), backend_,
152           SLOT(UpdateMTimesOnly(SongList)));
153   connect(watcher_, SIGNAL(SongsDeleted(SongList)), backend_,
154           SLOT(MarkSongsUnavailable(SongList)));
155   connect(watcher_, SIGNAL(SongsReadded(SongList, bool)), backend_,
156           SLOT(MarkSongsUnavailable(SongList, bool)));
157   connect(watcher_, SIGNAL(SubdirsDiscovered(SubdirectoryList)), backend_,
158           SLOT(AddOrUpdateSubdirs(SubdirectoryList)));
159   connect(watcher_, SIGNAL(SubdirsMTimeUpdated(SubdirectoryList)), backend_,
160           SLOT(AddOrUpdateSubdirs(SubdirectoryList)));
161   connect(watcher_, SIGNAL(CompilationsNeedUpdating()), backend_,
162           SLOT(UpdateCompilations()));
163   connect(app_->playlist_manager(), SIGNAL(CurrentSongChanged(Song)),
164           SLOT(CurrentSongChanged(Song)));
165   connect(app_->player(), SIGNAL(Stopped()), SLOT(Stopped()));
166 
167   // This will start the watcher checking for updates
168   backend_->LoadDirectoriesAsync();
169 }
170 
IncrementalScan()171 void Library::IncrementalScan() { watcher_->IncrementalScanAsync(); }
172 
FullScan()173 void Library::FullScan() { watcher_->FullScanAsync(); }
174 
PauseWatcher()175 void Library::PauseWatcher() { watcher_->SetRescanPausedAsync(true); }
176 
ResumeWatcher()177 void Library::ResumeWatcher() { watcher_->SetRescanPausedAsync(false); }
178 
ReloadSettings()179 void Library::ReloadSettings() {
180   watcher_->ReloadSettingsAsync();
181 
182   // These don't belong in LibraryBackend's group but it's too late to change
183   // now.
184   QSettings s;
185   s.beginGroup(LibraryBackend::kSettingsGroup);
186   save_statistics_in_files_ =
187       s.value("save_statistics_in_file", false).toBool();
188   save_ratings_in_files_ = s.value("save_ratings_in_file", false).toBool();
189 }
190 
WriteAllSongsStatisticsToFiles()191 void Library::WriteAllSongsStatisticsToFiles() {
192   const SongList all_songs = backend_->GetAllSongs();
193 
194   const int task_id = app_->task_manager()->StartTask(
195       tr("Saving songs statistics into songs files"));
196   app_->task_manager()->SetTaskBlocksLibraryScans(task_id);
197 
198   const int nb_songs = all_songs.size();
199   int i = 0;
200   for (const Song& song : all_songs) {
201     TagReaderClient::Instance()->UpdateSongStatisticsBlocking(song);
202     TagReaderClient::Instance()->UpdateSongRatingBlocking(song);
203     app_->task_manager()->SetTaskProgress(task_id, ++i, nb_songs);
204   }
205   app_->task_manager()->SetTaskFinished(task_id);
206 }
207 
Stopped()208 void Library::Stopped() { CurrentSongChanged(Song()); }
209 
CurrentSongChanged(const Song & song)210 void Library::CurrentSongChanged(const Song& song) {
211   TagReaderReply* reply = nullptr;
212   if (queued_rating_.is_valid()) {
213     reply = app_->tag_reader_client()->UpdateSongRating(queued_rating_);
214     queued_rating_ = Song();
215   } else if (queued_statistics_.is_valid()) {
216     reply = app_->tag_reader_client()->UpdateSongStatistics(queued_statistics_);
217     queued_statistics_ = Song();
218   }
219 
220   if (reply) {
221     connect(reply, SIGNAL(Finished(bool)), reply, SLOT(deleteLater()));
222   }
223 
224   if (song.filetype() == Song::Type_Asf) {
225     current_wma_song_url_ = song.url();
226   }
227 }
228 
SongsRatingChanged(const SongList & songs)229 void Library::SongsRatingChanged(const SongList& songs) {
230   if (save_ratings_in_files_) {
231     app_->tag_reader_client()->UpdateSongsRating(
232         FilterCurrentWMASong(songs, &queued_rating_));
233   }
234 }
235 
SongsStatisticsChanged(const SongList & songs)236 void Library::SongsStatisticsChanged(const SongList& songs) {
237   if (save_statistics_in_files_) {
238     app_->tag_reader_client()->UpdateSongsStatistics(
239         FilterCurrentWMASong(songs, &queued_statistics_));
240   }
241 }
242 
FilterCurrentWMASong(SongList songs,Song * queued)243 SongList Library::FilterCurrentWMASong(SongList songs, Song* queued) {
244   for (SongList::iterator it = songs.begin(); it != songs.end();) {
245     if (it->url() == current_wma_song_url_) {
246       *queued = *it;
247       it = songs.erase(it);
248     } else {
249       ++it;
250     }
251   }
252   return songs;
253 }
254