Differential D21525 Diff 60539 src/models/radiometadatamodel.cpp

Changeset View

Standalone View

View Options

src/models/radiometadatamodel.cpp

  • This file was copied from src/models/trackmetadatamodel.cpp.
1/* 1​/*
2 * Copyright 2018 Matthieu Gallien <matthieu_gallien@yahoo.fr> 2​ * Copyright 2018 Matthieu Gallien <matthieu_gallien@yahoo.fr>
3​ * Copyright 2019 Jérôme Guidon <guidon@live.fr>
3 * 4​ *
4 * This program is free software: you can redistribute it and/or 5​ * This program is free software: you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public 6​ * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either 7​ * License as published by the Free Software Foundation; either
7 * version 3 of the License, or (at your option) any later version. 8​ * version 3 of the License, or (at your option) any later version.
8 * 9​ *
9 * This program is distributed in the hope that it will be useful, 10​ * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11​ * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12​ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details. 13​ * Lesser General Public License for more details.
13 * 14​ *
14 * You should have received a copy of the GNU Lesser General Public License 15​ * You should have received a copy of the GNU Lesser General Public License
15 * along with this program. If not, see <https://www.gnu.org/licenses/>. 16​ * along with this program. If not, see <https://www.gnu.org/licenses/>.
16 */ 17​ */
17 18​
18#include "trackmetadatamodel.h" 19​#include "radiometadatamodel.h"
19 20​
20#include "musiclistenersmanager.h" 21​#include "musiclistenersmanager.h"
21 22​
22#include <KI18n/KLocalizedString> 23​#include <KI18n/KLocalizedString>
23 24​
24#include <QtConcurrent/QtConcurrentRun> 25​#include <QtConcurrent/QtConcurrentRun>
25 26​
26TrackMetadataModel::TrackMetadataModel(QObject *parent) 27​RadioMetadataModel::RadioMetadataModel(QObject *parent)
27 : QAbstractListModel(parent) 28​ : QAbstractListModel(parent)
28{ 29​{
29 connect(&mLyricsValueWatcher, &QFutureWatcher<QString>::finished, 30​ connect(&mLyricsValueWatcher, &QFutureWatcher<QString>::finished,
30 this, &TrackMetadataModel::lyricsValueIsReady); 31​ this, &RadioMetadataModel::lyricsValueIsReady);
31} 32​}
32 33​
33TrackMetadataModel::~TrackMetadataModel() 34​RadioMetadataModel::~RadioMetadataModel()
34{ 35​{
35 if (mLyricsValueWatcher.isRunning() && !mLyricsValueWatcher.isFinished()) { 36​ if (mLyricsValueWatcher.isRunning() && !mLyricsValueWatcher.isFinished()) {
36 mLyricsValueWatcher.waitForFinished(); 37​ mLyricsValueWatcher.waitForFinished();
37 } 38​ }
38} 39​}
39 40​
40int TrackMetadataModel::rowCount(const QModelIndex &parent) const 41​int RadioMetadataModel::rowCount(const QModelIndex &parent) const
41{ 42​{
42 if (parent.isValid()) { 43​ if (parent.isValid()) {
43 return 0; 44​ return 0;
44 } 45​ }
45 46​
46 return mTrackData.count(); 47​ return mTrackData.count();
47} 48​}
48 49​
49QVariant TrackMetadataModel::data(const QModelIndex &index, int role) const 50​QVariant RadioMetadataModel::data(const QModelIndex &index, int role) const
50{ 51​{
51 auto result = QVariant{}; 52​ auto result = QVariant{};
52 53​
53 const auto currentKey = mTrackKeys[index.row()]; 54​ const auto currentKey = mTrackKeys[index.row()];
54 55​
55 switch (role) 56​ switch (role)
56 { 57​ {
57 case Qt::DisplayRole: 58​ case Qt::DisplayRole:
58 result = mTrackData[currentKey]; 59​ result = mTrackData[currentKey];
59 break; 60​ break;
60 case ItemNameRole: 61​ case ItemNameRole:
61 switch (currentKey) 62​ switch (currentKey)
62 { 63​ {
63 case DatabaseInterface::TitleRole: 64​ case DatabaseInterface::TitleRole:
64 result = i18nc("Track title for track metadata view", "Title"); 65​ result = i18nc("Track title for track metadata view", "Title");
65 break; 66​ break;
67​ case DatabaseInterface::HttpAddressRole:
68​ result = i18nc("Http Address for radio metadata view", "Http Address");
69​ break;
66 case DatabaseInterface::DurationRole: 70​ case DatabaseInterface::DurationRole:
67 result = i18nc("Duration label for track metadata view", "Duration"); 71​ result = i18nc("Duration label for track metadata view", "Duration");
68 break; 72​ break;
69 case DatabaseInterface::ArtistRole: 73​ case DatabaseInterface::ArtistRole:
70 result = i18nc("Track artist for track metadata view", "Artist"); 74​ result = i18nc("Track artist for track metadata view", "Artist");
71 break; 75​ break;
72 case DatabaseInterface::AlbumRole: 76​ case DatabaseInterface::AlbumRole:
73 result = i18nc("Album name for track metadata view", "Album"); 77​ result = i18nc("Album name for track metadata view", "Album");
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Line(s)
141 } 145​ }
142 break; 146​ break;
143 case ItemTypeRole: 147​ case ItemTypeRole:
144 switch (currentKey) 148​ switch (currentKey)
145 { 149​ {
146 case DatabaseInterface::TitleRole: 150​ case DatabaseInterface::TitleRole:
147 result = TextEntry; 151​ result = TextEntry;
148 break; 152​ break;
153​ case DatabaseInterface::HttpAddressRole:
154​ result = TextEntry;
155​ break;
149 case DatabaseInterface::ArtistRole: 156​ case DatabaseInterface::ArtistRole:
150 result = TextEntry; 157​ result = TextEntry;
151 break; 158​ break;
152 case DatabaseInterface::AlbumRole: 159​ case DatabaseInterface::AlbumRole:
153 result = TextEntry; 160​ result = TextEntry;
154 break; 161​ break;
155 case DatabaseInterface::AlbumArtistRole: 162​ case DatabaseInterface::AlbumArtistRole:
156 result = TextEntry; 163​ result = TextEntry;
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Line(s)221 case DatabaseInterface::ElementTypeRole:
215 break; 222​ break;
216 } 223​ }
217 break; 224​ break;
218 } 225​ }
219 226​
220 return result; 227​ return result;
221} 228​}
222 229​
223bool TrackMetadataModel::setData(const QModelIndex &index, const QVariant &value, int role) 230​bool RadioMetadataModel::setData(const QModelIndex &index, const QVariant &value, int role)
224{ 231​{
225 if (data(index, role) != value) { 232​ if (data(index, role) != value) {
226 // FIXME: Implement me! 233​ const auto currentKey = mTrackKeys[index.row()];
234​ auto result = mTrackData[currentKey];
235​
236​ mTrackData[currentKey] = value;
237​
227 emit dataChanged(index, index, QVector<int>() << role); 238​ emit dataChanged(index, index, QVector<int>() << role);
228 return true; 239​ return true;
229 } 240​ }
230 return false; 241​ return false;
231} 242​}
232 243​
233QHash<int, QByteArray> TrackMetadataModel::roleNames() const 244​QHash<int, QByteArray> RadioMetadataModel::roleNames() const
234{ 245​{
235 auto names = QAbstractListModel::roleNames(); 246​ auto names = QAbstractListModel::roleNames();
236 247​
237 names[ItemNameRole] = "name"; 248​ names[ItemNameRole] = "name";
238 names[ItemTypeRole] = "type"; 249​ names[ItemTypeRole] = "type";
239 250​
240 return names; 251​ return names;
241} 252​}
242 253​
243QString TrackMetadataModel::fileUrl() const 254​MusicListenersManager *RadioMetadataModel::manager() const
244{ ​
245 return mFileUrl; ​
246} ​
247 ​
248const QUrl &TrackMetadataModel::coverUrl() const ​
249{ ​
250 return mCoverImage; ​
251} ​
252 ​
253MusicListenersManager *TrackMetadataModel::manager() const ​
254{ 255​{
255 return mManager; 256​ return mManager;
256} 257​}
257 258​
258QString TrackMetadataModel::lyrics() const 259​QString RadioMetadataModel::lyrics() const
259{ 260​{
260 return mFullData[TrackDataType::key_type::LyricsRole].toString(); 261​ return mFullData[TrackDataType::key_type::LyricsRole].toString();
261} 262​}
262 263​
263void TrackMetadataModel::trackData(const TrackMetadataModel::TrackDataType &trackData) 264​void RadioMetadataModel::trackData(const RadioMetadataModel::TrackDataType &trackData)
264{ 265​{
265 if (!mFullData.isEmpty() && trackData.databaseId() != mFullData.databaseId()) { 266​ if (!mFullData.isEmpty() && trackData.databaseId() != mFullData.databaseId()) {
266 return; 267​ return;
267 } 268​ }
268 269​
269 fillDataFromTrackData(trackData); 270​ fillDataFromTrackData(trackData);
270} 271​}
271 272​
272void TrackMetadataModel::fillDataFromTrackData(const TrackMetadataModel::TrackDataType &trackData) 273​void RadioMetadataModel::fillDataFromTrackData(const RadioMetadataModel::TrackDataType &trackData)
273{ 274​{
274 beginResetModel(); 275​ beginResetModel();
275 mFullData = trackData; 276​ mFullData = trackData;
276 mTrackData.clear(); 277​ mTrackData.clear();
277 mTrackKeys.clear(); 278​ mTrackKeys.clear();
278 279​
279 for (auto role : {DatabaseInterface::TitleRole, DatabaseInterface::ArtistRole, DatabaseInterface::AlbumRole, 280​ for (auto role : {
280 DatabaseInterface::AlbumArtistRole, DatabaseInterface::TrackNumberRole, DatabaseInterface::DiscNumberRole, 281​ DatabaseInterface::TitleRole,
281 DatabaseInterface::RatingRole, DatabaseInterface::GenreRole, DatabaseInterface::LyricistRole, 282​ DatabaseInterface::HttpAddressRole,
282 DatabaseInterface::ComposerRole, DatabaseInterface::CommentRole, DatabaseInterface::YearRole, 283​ DatabaseInterface::CommentRole,
283 DatabaseInterface::LastPlayDate, DatabaseInterface::PlayCounter}) { 284​ DatabaseInterface::DatabaseIdRole
285​ }) {
284 if (trackData.constFind(role) != trackData.constEnd()) { 286​ if (trackData.constFind(role) != trackData.constEnd()) {
285 if (role == DatabaseInterface::RatingRole) { 287​ if (role == DatabaseInterface::RatingRole) {
286 if (trackData[role].toInt() == 0) { 288​ if (trackData[role].toInt() == 0) {
287 continue; 289​ continue;
288 } 290​ }
289 } 291​ }
290 292​
291 mTrackKeys.push_back(role); 293​ mTrackKeys.push_back(role);
292 mTrackData[role] = trackData[role]; 294​ mTrackData[role] = trackData[role];
293 } 295​ }
294 } 296​ }
295 filterDataFromTrackData(); 297​ filterDataFromTrackData();
296 endResetModel(); 298​ endResetModel();
297 ​
298 fetchLyrics(); ​
299 ​
300 mCoverImage = trackData[DatabaseInterface::ImageUrlRole].toUrl(); ​
301 Q_EMIT coverUrlChanged(); ​
302 ​
303 auto rawFileUrl = trackData[DatabaseInterface::ResourceRole].toUrl(); ​
304 ​
305 if (rawFileUrl.isLocalFile()) { ​
306 mFileUrl = rawFileUrl.toLocalFile(); ​
307 } else { ​
308 mFileUrl = rawFileUrl.toString(); ​
309 } ​
310 Q_EMIT fileUrlChanged(); ​
311} 299​}
312 300​
313void TrackMetadataModel::filterDataFromTrackData() 301​void RadioMetadataModel::filterDataFromTrackData()
314{ 302​{
315} 303​}
316 304​
317void TrackMetadataModel::removeMetaData(DatabaseInterface::ColumnsRoles metaData) 305​void RadioMetadataModel::removeMetaData(DatabaseInterface::ColumnsRoles metaData)
318{ 306​{
319 auto itMetaData = std::find(mTrackKeys.begin(), mTrackKeys.end(), metaData); 307​ auto itMetaData = std::find(mTrackKeys.begin(), mTrackKeys.end(), metaData);
320 if (itMetaData == mTrackKeys.end()) { 308​ if (itMetaData == mTrackKeys.end()) {
321 return; 309​ return;
322 } 310​ }
323 311​
324 mTrackKeys.erase(itMetaData); 312​ mTrackKeys.erase(itMetaData);
325 mTrackData.remove(metaData); 313​ mTrackData.remove(metaData);
326} 314​}
327 315​
328TrackMetadataModel::TrackDataType::mapped_type TrackMetadataModel::dataFromType(TrackDataType::key_type metaData) const 316​RadioMetadataModel::TrackDataType::mapped_type RadioMetadataModel::dataFromType(TrackDataType::key_type metaData) const
329{ 317​{
330 return mFullData[metaData]; 318​ return mFullData[metaData];
331} 319​}
332 320​
333void TrackMetadataModel::fillLyricsDataFromTrack() 321​void RadioMetadataModel::fillLyricsDataFromTrack()
334{ 322​{
335 beginInsertRows({}, mTrackData.size(), mTrackData.size()); 323​ beginInsertRows({}, mTrackData.size(), mTrackData.size());
336 mTrackKeys.push_back(DatabaseInterface::LyricsRole); 324​ mTrackKeys.push_back(DatabaseInterface::LyricsRole);
337 mTrackData[DatabaseInterface::LyricsRole] = mLyricsValueWatcher.result(); 325​ mTrackData[DatabaseInterface::LyricsRole] = mLyricsValueWatcher.result();
338 endInsertRows(); 326​ endInsertRows();
339} 327​}
340 328​
341void TrackMetadataModel::lyricsValueIsReady() 329​void RadioMetadataModel::lyricsValueIsReady()
342{ 330​{
343 if (!mLyricsValueWatcher.result().isEmpty()) { 331​ if (!mLyricsValueWatcher.result().isEmpty()) {
344 fillLyricsDataFromTrack(); 332​ fillLyricsDataFromTrack();
345 333​
346 mFullData[DatabaseInterface::LyricsRole] = mLyricsValueWatcher.result(); 334​ mFullData[DatabaseInterface::LyricsRole] = mLyricsValueWatcher.result();
347 335​
348 Q_EMIT lyricsChanged(); 336​ Q_EMIT lyricsChanged();
349 } 337​ }
350} 338​}
351 339​
352void TrackMetadataModel::initialize(MusicListenersManager *newManager, DatabaseInterface *trackDatabase) 340​void RadioMetadataModel::initialize(MusicListenersManager *newManager, DatabaseInterface *trackDatabase)
353{ 341​{
354 mManager = newManager; 342​ mManager = newManager;
355 Q_EMIT managerChanged(); 343​ Q_EMIT managerChanged();
356 344​
357 if (mManager) { 345​ if (mManager) {
358 mDataLoader.setDatabase(mManager->viewDatabase()); 346​ mDataLoader.setDatabase(mManager->viewDatabase());
359 } else if (trackDatabase) { 347​ } else if (trackDatabase) {
360 mDataLoader.setDatabase(trackDatabase); 348​ mDataLoader.setDatabase(trackDatabase);
361 } 349​ }
362 350​
363 if (mManager) { 351​ if (mManager) {
364 mManager->connectModel(&mDataLoader); 352​ mManager->connectModel(&mDataLoader);
365 } 353​ }
366 354​
367 connect(this, &TrackMetadataModel::needDataByDatabaseId, 355​ connect(this, &RadioMetadataModel::needDataByDatabaseId,
368 &mDataLoader, &ModelDataLoader::loadDataByDatabaseId); 356​ &mDataLoader, &ModelDataLoader::loadDataByDatabaseId);
369 connect(this, &TrackMetadataModel::needDataByFileName, 357​ connect(this, &RadioMetadataModel::needDataByFileName,
370 &mDataLoader, &ModelDataLoader::loadDataByFileName); 358​ &mDataLoader, &ModelDataLoader::loadDataByFileName);
371 connect(&mDataLoader, &ModelDataLoader::allTrackData, 359​ connect(&mDataLoader, &ModelDataLoader::allRadioData,
372 this, &TrackMetadataModel::trackData); 360​ this, &RadioMetadataModel::trackData);
373 connect(&mDataLoader, &ModelDataLoader::trackModified, 361​ connect(&mDataLoader, &ModelDataLoader::trackModified,
374 this, &TrackMetadataModel::trackData); 362​ this, &RadioMetadataModel::trackData);
363​ connect(this, &RadioMetadataModel::saveRadioData,
364​ &mDataLoader, &ModelDataLoader::updateRadioData);
365​ connect(&mDataLoader, &ModelDataLoader::allRadiosDataUIUpdate,
366​ this, &RadioMetadataModel::updateUI);
375} 367​}
376 368​
377void TrackMetadataModel::fetchLyrics() 369​void RadioMetadataModel::fetchLyrics()
378{ 370​{
379 auto lyricicsValue = QtConcurrent::run(QThreadPool::globalInstance(), [=]() { 371​ auto lyricicsValue = QtConcurrent::run(QThreadPool::globalInstance(), [=]() {
380 auto trackData = mFileScanner.scanOneFile(mFullData[DatabaseInterface::ResourceRole].toUrl(), mMimeDatabase); 372​ auto trackData = mFileScanner.scanOneFile(mFullData[DatabaseInterface::ResourceRole].toUrl(), mMimeDatabase);
381 if (!trackData.lyrics().isEmpty()) { 373​ if (!trackData.lyrics().isEmpty()) {
382 return trackData.lyrics(); 374​ return trackData.lyrics();
383 } 375​ }
384 return QString{}; 376​ return QString{};
385 }); 377​ });
386 378​
387 mLyricsValueWatcher.setFuture(lyricicsValue); 379​ mLyricsValueWatcher.setFuture(lyricicsValue);
388} 380​}
389 381​
390void TrackMetadataModel::initializeByTrackId(qulonglong databaseId) 382​void RadioMetadataModel::initializeByTrackId(qulonglong databaseId)
391{ 383​{
392 mFullData.clear(); 384​ mFullData.clear();
393 mTrackData.clear(); 385​ mTrackData.clear();
394 mCoverImage.clear(); ​
395 mFileUrl.clear(); ​
396 386​
397 Q_EMIT lyricsChanged(); 387​ Q_EMIT lyricsChanged();
398 388​
399 Q_EMIT needDataByDatabaseId(ElisaUtils::Track, databaseId); 389​ Q_EMIT needDataByDatabaseId(ElisaUtils::Radio, databaseId);
400} 390​}
401 391​
402void TrackMetadataModel::initializeByTrackFileName(const QUrl &fileName) 392​void RadioMetadataModel::initializeForNewRadio()
393​{
394​ mFullData.clear();
395​ mTrackData.clear();
396​
397​ fillDataForNewRadio();
398​}
399​
400​void RadioMetadataModel::fillDataForNewRadio()
401​{
402​ beginResetModel();
403​ mTrackData.clear();
404​ mTrackKeys.clear();
405​
406​ for (auto role : {
407​ DatabaseInterface::TitleRole,
408​ DatabaseInterface::HttpAddressRole,
409​ DatabaseInterface::CommentRole,
410​ DatabaseInterface::DatabaseIdRole
411​
412​ }) {
413​ mTrackKeys.push_back(role);
414​ if(role == DatabaseInterface::DatabaseIdRole){
415​ mTrackData[role] = -1;
416​ }else{
417​ mTrackData[role] = QStringLiteral("");
418​ }
419​
420​ }
421​ filterDataFromTrackData();
422​ endResetModel();
423​}
424​
425​void RadioMetadataModel::initializeByTrackFileName(const QUrl &fileName)
403{ 426​{
404 mFullData.clear(); 427​ mFullData.clear();
405 mTrackData.clear(); 428​ mTrackData.clear();
406 mCoverImage.clear(); ​
407 mFileUrl.clear(); ​
408 429​
409 Q_EMIT lyricsChanged(); 430​ Q_EMIT lyricsChanged();
410 431​
411 Q_EMIT needDataByFileName(ElisaUtils::FileName, fileName); 432​ Q_EMIT needDataByFileName(ElisaUtils::FileName, fileName);
412} 433​}
413 434​
414void TrackMetadataModel::setManager(MusicListenersManager *newManager) 435​void RadioMetadataModel::setManager(MusicListenersManager *newManager)
415{ 436​{
416 initialize(newManager, nullptr); 437​ initialize(newManager, nullptr);
417} 438​}
418 439​
419void TrackMetadataModel::setDatabase(DatabaseInterface *trackDatabase) 440​void RadioMetadataModel::setDatabase(DatabaseInterface *trackDatabase)
420{ 441​{
421 initialize(nullptr, trackDatabase); 442​ initialize(nullptr, trackDatabase);
422} 443​}
423 444​
445​void RadioMetadataModel::saveData()
446​{
447​ Q_EMIT saveRadioData(mTrackData);
448​}
449​
450​void RadioMetadataModel::updateUI(TrackDataType radiosData, bool isInsertion){
451​ if(isInsertion){
452​ mTrackData[DatabaseInterface::DatabaseIdRole] = radiosData[DatabaseInterface::DatabaseIdRole];
453​ }
454​ Q_EMIT disableApplyButton();
455​}
456​
424 457​
425#include "moc_trackmetadatamodel.cpp" 458​//#include "moc_radiometadatamodel.cpp"