diff --git a/autotests/elisaqmltests.cpp b/autotests/elisaqmltests.cpp
index af15efb9..1346276d 100644
--- a/autotests/elisaqmltests.cpp
+++ b/autotests/elisaqmltests.cpp
@@ -1,20 +1,20 @@
 /*
  * Copyright 2018 Matthieu Gallien <matthieu_gallien@yahoo.fr>
  *
  * This program is free software: you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 3 of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-#include <QtQuickTest/QtQuickTest>
+#include <QtQuickTest>
 
 QUICK_TEST_MAIN(ElisaQmlTests)
diff --git a/src/elisaqmlplugin.cpp b/src/elisaqmlplugin.cpp
index 5a6e9c12..2b65bf88 100644
--- a/src/elisaqmlplugin.cpp
+++ b/src/elisaqmlplugin.cpp
@@ -1,185 +1,184 @@
 /*
  * Copyright 2018 Matthieu Gallien <matthieu_gallien@yahoo.fr>
  *
  * This program is free software: you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 3 of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
 #include "elisaqmlplugin.h"
 
 #if defined UPNPQT_FOUND && UPNPQT_FOUND
 #include "upnp/upnpcontrolconnectionmanager.h"
 #include "upnp/upnpcontrolmediaserver.h"
 #include "upnp/upnpcontrolcontentdirectory.h"
 #include "upnp/upnpcontentdirectorymodel.h"
 #include "upnpdevicedescription.h"
 #include "upnp/didlparser.h"
 #include "upnp/upnpdiscoverallmusic.h"
 
 #include "upnpssdpengine.h"
 #include "upnpabstractservice.h"
 #include "upnpcontrolabstractdevice.h"
 #include "upnpcontrolabstractservice.h"
 #include "upnpbasictypes.h"
 #endif
 
 #include "elisautils.h"
 #include "elisaapplication.h"
 #include "progressindicator.h"
 #include "mediaplaylist.h"
 #include "managemediaplayercontrol.h"
 #include "manageheaderbar.h"
 #include "manageaudioplayer.h"
 #include "musicaudiotrack.h"
 #include "musiclistenersmanager.h"
 #include "trackslistener.h"
 #include "viewmanager.h"
 #include "databaseinterface.h"
 #include "models/datamodel.h"
 #include "models/trackmetadatamodel.h"
 #include "models/trackcontextmetadatamodel.h"
 #include "models/viewsmodel.h"
 #include "models/gridviewproxymodel.h"
 #include "models/alltracksproxymodel.h"
 #include "models/singlealbumproxymodel.h"
 
 #if defined KF5FileMetaData_FOUND && KF5FileMetaData_FOUND
 #include "embeddedcoverageimageprovider.h"
 #endif
 
 #if defined KF5KIO_FOUND && KF5KIO_FOUND
 #include "models/filebrowsermodel.h"
 #include "models/filebrowserproxymodel.h"
 #endif
 
 #include "audiowrapper.h"
 #include "notificationitem.h"
 #include "topnotificationmanager.h"
-#include "elisautils.h"
 
 #if defined Qt5DBus_FOUND && Qt5DBus_FOUND
 #include "mpris2/mpris2.h"
 #include "mpris2/mediaplayer2player.h"
 #endif
 
 #include <QSortFilterProxyModel>
 
 #include <QAction>
 #include <QStandardPaths>
 
 #include <QQmlExtensionPlugin>
 #include <QQmlEngine>
 #include <QQmlContext>
 
 void ElisaQmlTestPlugin::initializeEngine(QQmlEngine *engine, const char *uri)
 {
     QQmlExtensionPlugin::initializeEngine(engine, uri);
 #if defined KF5FileMetaData_FOUND && KF5FileMetaData_FOUND
     engine->addImageProvider(QStringLiteral("cover"), new EmbeddedCoverageImageProvider);
 #endif
 }
 
 void ElisaQmlTestPlugin::registerTypes(const char *uri)
 {
 #if defined UPNPQT_FOUND && UPNPQT_FOUND
     qmlRegisterType<UpnpSsdpEngine>(uri, 1, 0, "UpnpSsdpEngine");
     qmlRegisterType<UpnpDiscoverAllMusic>(uri, 1, 0, "UpnpDiscoverAllMusic");
 
     qmlRegisterType<UpnpAbstractDevice>(uri, 1, 0, "UpnpAbstractDevice");
     qmlRegisterType<UpnpAbstractService>(uri, 1, 0, "UpnpAbstractService");
     qmlRegisterType<UpnpControlAbstractDevice>(uri, 1, 0, "UpnpControlAbstractDevice");
     qmlRegisterType<UpnpControlAbstractService>(uri, 1, 0, "UpnpControlAbstractService");
     qmlRegisterType<UpnpControlConnectionManager>(uri, 1, 0, "UpnpControlConnectionManager");
     qmlRegisterType<UpnpControlMediaServer>(uri, 1, 0, "UpnpControlMediaServer");
     qmlRegisterType<UpnpContentDirectoryModel>(uri, 1, 0, "UpnpContentDirectoryModel");
     qmlRegisterType<DidlParser>(uri, 1, 0, "DidlParser");
     qmlRegisterType<UpnpControlContentDirectory>(uri, 1, 0, "UpnpControlContentDirectory");
     qmlRegisterType<UpnpDeviceDescription>(uri, 1, 0, "UpnpDeviceDescription");
 
     qRegisterMetaType<A_ARG_TYPE_InstanceID>();
     qRegisterMetaType<QPointer<UpnpAbstractDevice> >();
     qRegisterMetaType<UpnpControlConnectionManager*>();
     qRegisterMetaType<UpnpContentDirectoryModel*>();
     qRegisterMetaType<UpnpDeviceDescription*>();
 #endif
 
     qmlRegisterType<MediaPlayList>(uri, 1, 0, "MediaPlayList");
     qmlRegisterType<ManageMediaPlayerControl>(uri, 1, 0, "ManageMediaPlayerControl");
     qmlRegisterType<ManageHeaderBar>(uri, 1, 0, "ManageHeaderBar");
     qmlRegisterType<ManageAudioPlayer>(uri, 1, 0, "ManageAudioPlayer");
     qmlRegisterType<ProgressIndicator>(uri, 1, 0, "ProgressIndicator");
     qmlRegisterType<MusicListenersManager>(uri, 1, 0, "MusicListenersManager");
     qmlRegisterType<ViewManager>(uri, 1, 0, "ViewManager");
     qmlRegisterType<DataModel>(uri, 1, 0, "DataModel");
     qmlRegisterType<TrackMetadataModel>(uri, 1, 0, "TrackMetadataModel");
     qmlRegisterType<TrackContextMetaDataModel>(uri, 1, 0, "TrackContextMetaDataModel");
     qmlRegisterType<ViewsModel>(uri, 1, 0, "ViewsModel");
     qmlRegisterType<GridViewProxyModel>(uri, 1, 0, "GridViewProxyModel");
     qmlRegisterType<AllTracksProxyModel>(uri, 1, 0, "AllTracksProxyModel");
     qmlRegisterType<SingleAlbumProxyModel>(uri, 1, 0, "SingleAlbumProxyModel");
 
 #if defined KF5KIO_FOUND && KF5KIO_FOUND
     qmlRegisterType<FileBrowserModel>(uri, 1, 0, "FileBrowserModel");
     qmlRegisterType<FileBrowserProxyModel>(uri, 1, 0, "FileBrowserProxyModel");
 #endif
 
     qmlRegisterType<AudioWrapper>(uri, 1, 0, "AudioWrapper");
     qmlRegisterType<TopNotificationManager>(uri, 1, 0, "TopNotificationManager");
     qmlRegisterUncreatableType<DatabaseInterface>(uri, 1, 0, "DatabaseInterface", QStringLiteral("Only created in c++"));
 
 #if defined Qt5DBus_FOUND && Qt5DBus_FOUND
     qmlRegisterType<Mpris2>(uri, 1, 0, "Mpris2");
     qRegisterMetaType<MediaPlayer2Player*>();
 #endif
 
     qRegisterMetaType<AbstractMediaProxyModel*>();
     qRegisterMetaType<QHash<QString,QUrl>>("QHash<QString,QUrl>");
     qRegisterMetaType<QHash<QUrl,QDateTime>>("QHash<QUrl,QDateTime>");
     qRegisterMetaType<QList<MusicAudioTrack>>("QList<MusicAudioTrack>");
     qRegisterMetaType<QList<MusicAudioTrack>>("QVector<MusicAudioTrack>");
     qRegisterMetaType<QVector<qulonglong>>("QVector<qulonglong>");
     qRegisterMetaType<QHash<qulonglong,int>>("QHash<qulonglong,int>");
     qRegisterMetaType<DatabaseInterface::ListTrackDataType>("DatabaseInterface::ListTrackDataType");
     qRegisterMetaType<DatabaseInterface::ListAlbumDataType>("DatabaseInterface::ListAlbumDataType");
     qRegisterMetaType<DatabaseInterface::ListArtistDataType>("DatabaseInterface::ListArtistDataType");
     qRegisterMetaType<DatabaseInterface::ListGenreDataType>("DatabaseInterface::ListGenreDataType");
     qRegisterMetaType<ModelDataLoader::ListTrackDataType>("ModelDataLoader::ListTrackDataType");
     qRegisterMetaType<ModelDataLoader::ListAlbumDataType>("ModelDataLoader::ListAlbumDataType");
     qRegisterMetaType<ModelDataLoader::ListArtistDataType>("ModelDataLoader::ListArtistDataType");
     qRegisterMetaType<ModelDataLoader::ListGenreDataType>("ModelDataLoader::ListGenreDataType");
     qRegisterMetaType<ModelDataLoader::AlbumDataType>("ModelDataLoader::AlbumDataType");
     qRegisterMetaType<TracksListener::ListTrackDataType>("TracksListener::ListTrackDataType");
     qRegisterMetaType<QMap<QString, int>>();
     qRegisterMetaType<QAction*>();
     qRegisterMetaType<NotificationItem>("NotificationItem");
     qRegisterMetaType<QMap<QString,int>>("QMap<QString,int>");
     qRegisterMetaType<ElisaUtils::PlayListEnqueueMode>("ElisaUtils::PlayListEnqueueMode");
     qRegisterMetaType<ElisaUtils::PlayListEnqueueTriggerPlay>("ElisaUtils::PlayListEnqueueTriggerPlay");
     qRegisterMetaType<ElisaUtils::PlayListEntryType>("ElisaUtils::PlayListEntryType");
     qRegisterMetaType<ElisaUtils::EntryData>("ElisaUtils::EntryData");
     qRegisterMetaType<ElisaUtils::EntryDataList>("ElisaUtils::EntryDataList");
     qRegisterMetaType<ElisaUtils::FilterType>("ElisaUtils::FilterType");
     qRegisterMetaType<DatabaseInterface::TrackDataType>("DatabaseInterface::TrackDataType");
     qRegisterMetaType<DatabaseInterface::AlbumDataType>("DatabaseInterface::AlbumDataType");
     qRegisterMetaType<DatabaseInterface::ArtistDataType>("DatabaseInterface::ArtistDataType");
     qRegisterMetaType<DatabaseInterface::GenreDataType>("DatabaseInterface::GenreDataType");
     qRegisterMetaType<ModelDataLoader::TrackDataType>("ModelDataLoader::TrackDataType");
     qRegisterMetaType<TracksListener::TrackDataType>("TracksListener::TrackDataType");
     qRegisterMetaType<ViewManager::ViewsType>("ViewManager::ViewsType");
     qRegisterMetaType<ViewManager::SortOrder>("ViewManager::SortOrder");
 
     qRegisterMetaTypeStreamOperators<ManageMediaPlayerControl::PlayerState>("PlayListControler::PlayerState");
 
     qmlRegisterUncreatableType<ElisaApplication>(uri, 1, 0, "ElisaApplication", QStringLiteral("only one and done in c++"));
     qmlRegisterUncreatableMetaObject(ElisaUtils::staticMetaObject, uri, 1, 0, "ElisaUtils", QStringLiteral("Namespace ElisaUtils"));
 }
diff --git a/src/models/trackcontextmetadatamodel.h b/src/models/trackcontextmetadatamodel.h
index 0deac342..2b9c4c05 100644
--- a/src/models/trackcontextmetadatamodel.h
+++ b/src/models/trackcontextmetadatamodel.h
@@ -1,42 +1,42 @@
 /*
  * Copyright 2019 Matthieu Gallien <matthieu_gallien@yahoo.fr>
  *
  * This program is free software: you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 3 of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
 #ifndef TRACKCONTEXTMETADATAMODEL_H
 #define TRACKCONTEXTMETADATAMODEL_H
 
 #include "elisaLib_export.h"
 
 #include "trackmetadatamodel.h"
 
 class ELISALIB_EXPORT TrackContextMetaDataModel : public TrackMetadataModel
 {
 
     Q_OBJECT
 
 public:
 
-    TrackContextMetaDataModel(QObject *parent = nullptr);
+    explicit TrackContextMetaDataModel(QObject *parent = nullptr);
 
 protected:
 
     void filterDataFromTrackData() override;
 
     void fillLyricsDataFromTrack() override;
 
 };
 
 #endif // TRACKCONTEXTMETADATAMODEL_H
diff --git a/src/models/trackmetadatamodel.cpp b/src/models/trackmetadatamodel.cpp
index 6bba7419..4435bd1e 100644
--- a/src/models/trackmetadatamodel.cpp
+++ b/src/models/trackmetadatamodel.cpp
@@ -1,474 +1,474 @@
 /*
  * Copyright 2018 Matthieu Gallien <matthieu_gallien@yahoo.fr>
  *
  * This program is free software: you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 3 of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
 #include "trackmetadatamodel.h"
 
 #include "musiclistenersmanager.h"
 
 #include <KI18n/KLocalizedString>
 
-#include <QtConcurrent/QtConcurrentRun>
+#include <QtConcurrent>
 
 TrackMetadataModel::TrackMetadataModel(QObject *parent)
     : QAbstractListModel(parent)
 {
     connect(&mLyricsValueWatcher, &QFutureWatcher<QString>::finished,
             this, &TrackMetadataModel::lyricsValueIsReady);
 }
 
 TrackMetadataModel::~TrackMetadataModel()
 {
     if (mLyricsValueWatcher.isRunning() && !mLyricsValueWatcher.isFinished()) {
         mLyricsValueWatcher.waitForFinished();
     }
 }
 
 int TrackMetadataModel::rowCount(const QModelIndex &parent) const
 {
     if (parent.isValid()) {
         return 0;
     }
 
     return mTrackData.count();
 }
 
 QVariant TrackMetadataModel::data(const QModelIndex &index, int role) const
 {
     auto result = QVariant{};
 
     const auto currentKey = mTrackKeys[index.row()];
 
     switch (role)
     {
     case Qt::DisplayRole:
         switch (currentKey)
         {
         case DatabaseInterface::TrackNumberRole:
         {
             auto trackNumber = mTrackData.trackNumber();
             if (trackNumber > 0) {
                 result = trackNumber;
             }
             break;
         }
         case DatabaseInterface::DiscNumberRole:
         {
             auto discNumber = mTrackData.discNumber();
             if (discNumber > 0) {
                 result = discNumber;
             }
             break;
         }
         case DatabaseInterface::ChannelsRole:
         {
             auto channels = mTrackData.channels();
             if (channels > 0) {
                 result = channels;
             }
             break;
         }
         case DatabaseInterface::BitRateRole:
         {
             auto bitRate = mTrackData.bitRate();
             if (bitRate > 0) {
                 result = bitRate;
             }
             break;
         }
         case DatabaseInterface::SampleRateRole:
         {
             auto sampleRate = mTrackData.sampleRate();
             if (sampleRate > 0) {
                 result = sampleRate;
             }
             break;
         }
         default:
             result = mTrackData[currentKey];
             break;
         }
         break;
     case ItemNameRole:
         switch (currentKey)
         {
         case DatabaseInterface::TitleRole:
             result = i18nc("Track title for track metadata view", "Title");
             break;
         case DatabaseInterface::DurationRole:
             result = i18nc("Duration label for track metadata view", "Duration");
             break;
         case DatabaseInterface::ArtistRole:
             result = i18nc("Track artist for track metadata view", "Artist");
             break;
         case DatabaseInterface::AlbumRole:
             result = i18nc("Album name for track metadata view", "Album");
             break;
         case DatabaseInterface::AlbumArtistRole:
             result = i18nc("Album artist for track metadata view", "Album Artist");
             break;
         case DatabaseInterface::TrackNumberRole:
             result = i18nc("Track number for track metadata view", "Track Number");
             break;
         case DatabaseInterface::DiscNumberRole:
             result = i18nc("Disc number for track metadata view", "Disc Number");
             break;
         case DatabaseInterface::RatingRole:
             result = i18nc("Rating label for information panel", "Rating");
             break;
         case DatabaseInterface::GenreRole:
             result = i18nc("Genre label for track metadata view", "Genre");
             break;
         case DatabaseInterface::LyricistRole:
             result = i18nc("Lyricist label for track metadata view", "Lyricist");
             break;
         case DatabaseInterface::ComposerRole:
             result = i18nc("Composer name for track metadata view", "Composer");
             break;
         case DatabaseInterface::CommentRole:
             result = i18nc("Comment label for track metadata view", "Comment");
             break;
         case DatabaseInterface::YearRole:
             result = i18nc("Year label for track metadata view", "Year");
             break;
         case DatabaseInterface::ChannelsRole:
             result = i18nc("Channels label for track metadata view", "Channels");
             break;
         case DatabaseInterface::BitRateRole:
             result = i18nc("Bit rate label for track metadata view", "Bit Rate");
             break;
         case DatabaseInterface::SampleRateRole:
             result = i18nc("Sample Rate label for track metadata view", "Sample Rate");
             break;
         case DatabaseInterface::LastPlayDate:
             result = i18nc("Last play date label for track metadata view", "Last played");
             break;
         case DatabaseInterface::PlayCounter:
             result = i18nc("Play counter label for track metadata view", "Play count");
             break;
         case DatabaseInterface::LyricsRole:
             result = i18nc("Lyrics label for track metadata view", "Lyrics");
             break;
         case DatabaseInterface::SecondaryTextRole:
         case DatabaseInterface::ImageUrlRole:
         case DatabaseInterface::ShadowForImageRole:
         case DatabaseInterface::ChildModelRole:
         case DatabaseInterface::StringDurationRole:
         case DatabaseInterface::MilliSecondsDurationRole:
         case DatabaseInterface::AllArtistsRole:
         case DatabaseInterface::HighestTrackRating:
         case DatabaseInterface::ResourceRole:
         case DatabaseInterface::IdRole:
         case DatabaseInterface::DatabaseIdRole:
         case DatabaseInterface::IsSingleDiscAlbumRole:
         case DatabaseInterface::ContainerDataRole:
         case DatabaseInterface::IsPartialDataRole:
         case DatabaseInterface::AlbumIdRole:
         case DatabaseInterface::HasEmbeddedCover:
         case DatabaseInterface::FileModificationTime:
         case DatabaseInterface::FirstPlayDate:
         case DatabaseInterface::PlayFrequency:
         case DatabaseInterface::ElementTypeRole:
             break;
         }
         break;
     case ItemTypeRole:
         switch (currentKey)
         {
         case DatabaseInterface::TitleRole:
             result = TextEntry;
             break;
         case DatabaseInterface::ArtistRole:
             result = TextEntry;
             break;
         case DatabaseInterface::AlbumRole:
             result = TextEntry;
             break;
         case DatabaseInterface::AlbumArtistRole:
             result = TextEntry;
             break;
         case DatabaseInterface::TrackNumberRole:
             result = IntegerEntry;
             break;
         case DatabaseInterface::DiscNumberRole:
             result = IntegerEntry;
             break;
         case DatabaseInterface::RatingRole:
             result = RatingEntry;
             break;
         case DatabaseInterface::GenreRole:
             result = TextEntry;
             break;
         case DatabaseInterface::LyricistRole:
             result = TextEntry;
             break;
         case DatabaseInterface::ComposerRole:
             result = TextEntry;
             break;
         case DatabaseInterface::CommentRole:
             result = TextEntry;
             break;
         case DatabaseInterface::YearRole:
             result = IntegerEntry;
             break;
         case DatabaseInterface::LastPlayDate:
             result = DateEntry;
             break;
         case DatabaseInterface::PlayCounter:
             result = IntegerEntry;
             break;
         case DatabaseInterface::LyricsRole:
             result = LongTextEntry;
             break;
         case DatabaseInterface::DurationRole:
         case DatabaseInterface::SampleRateRole:
         case DatabaseInterface::BitRateRole:
         case DatabaseInterface::ChannelsRole:
         case DatabaseInterface::SecondaryTextRole:
         case DatabaseInterface::ImageUrlRole:
         case DatabaseInterface::ShadowForImageRole:
         case DatabaseInterface::ChildModelRole:
         case DatabaseInterface::StringDurationRole:
         case DatabaseInterface::MilliSecondsDurationRole:
         case DatabaseInterface::AllArtistsRole:
         case DatabaseInterface::HighestTrackRating:
         case DatabaseInterface::ResourceRole:
         case DatabaseInterface::IdRole:
         case DatabaseInterface::DatabaseIdRole:
         case DatabaseInterface::IsSingleDiscAlbumRole:
         case DatabaseInterface::ContainerDataRole:
         case DatabaseInterface::IsPartialDataRole:
         case DatabaseInterface::AlbumIdRole:
         case DatabaseInterface::HasEmbeddedCover:
         case DatabaseInterface::FileModificationTime:
         case DatabaseInterface::FirstPlayDate:
         case DatabaseInterface::PlayFrequency:
         case DatabaseInterface::ElementTypeRole:
             break;
         }
         break;
     }
 
     return result;
 }
 
 bool TrackMetadataModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     if (data(index, role) != value) {
         // FIXME: Implement me!
         emit dataChanged(index, index, QVector<int>() << role);
         return true;
     }
     return false;
 }
 
 QHash<int, QByteArray> TrackMetadataModel::roleNames() const
 {
     auto names = QAbstractListModel::roleNames();
 
     names[ItemNameRole] = "name";
     names[ItemTypeRole] = "type";
 
     return names;
 }
 
 QString TrackMetadataModel::fileUrl() const
 {
     return mFileUrl;
 }
 
 QUrl TrackMetadataModel::coverUrl() const
 {
     if (mCoverImage.isEmpty()) {
         return QUrl(QStringLiteral("image://icon/media-optical-audio"));
     } else {
         return mCoverImage;
     }
 }
 
 MusicListenersManager *TrackMetadataModel::manager() const
 {
     return mManager;
 }
 
 QString TrackMetadataModel::lyrics() const
 {
     return mFullData[TrackDataType::key_type::LyricsRole].toString();
 }
 
 void TrackMetadataModel::trackData(const TrackMetadataModel::TrackDataType &trackData)
 {
     if (!mFullData.isEmpty() && trackData.databaseId() != mFullData.databaseId()) {
         return;
     }
 
     fillDataFromTrackData(trackData);
 }
 
 void TrackMetadataModel::fillDataFromTrackData(const TrackMetadataModel::TrackDataType &trackData)
 {
     beginResetModel();
     mFullData = trackData;
     mTrackData.clear();
     mTrackKeys.clear();
 
     for (auto role : {DatabaseInterface::TitleRole, DatabaseInterface::ArtistRole, DatabaseInterface::AlbumRole,
          DatabaseInterface::AlbumArtistRole, DatabaseInterface::TrackNumberRole, DatabaseInterface::DiscNumberRole,
          DatabaseInterface::RatingRole, DatabaseInterface::GenreRole, DatabaseInterface::LyricistRole,
          DatabaseInterface::ComposerRole, DatabaseInterface::CommentRole, DatabaseInterface::YearRole,
          DatabaseInterface::LastPlayDate, DatabaseInterface::PlayCounter}) {
         if (trackData.constFind(role) != trackData.constEnd()) {
             if (role == DatabaseInterface::RatingRole) {
                 if (trackData[role].toInt() == 0) {
                     continue;
                 }
             }
 
             mTrackKeys.push_back(role);
             mTrackData[role] = trackData[role];
         }
     }
     filterDataFromTrackData();
     endResetModel();
 
     fetchLyrics();
 
     mCoverImage = trackData[DatabaseInterface::ImageUrlRole].toUrl();
     Q_EMIT coverUrlChanged();
 
     auto rawFileUrl = trackData[DatabaseInterface::ResourceRole].toUrl();
 
     if (rawFileUrl.isLocalFile()) {
         mFileUrl = rawFileUrl.toLocalFile();
     } else {
         mFileUrl = rawFileUrl.toString();
     }
     Q_EMIT fileUrlChanged();
 }
 
 void TrackMetadataModel::filterDataFromTrackData()
 {
 }
 
 void TrackMetadataModel::removeMetaData(DatabaseInterface::ColumnsRoles metaData)
 {
     auto itMetaData = std::find(mTrackKeys.begin(), mTrackKeys.end(), metaData);
     if (itMetaData == mTrackKeys.end()) {
         return;
     }
 
     mTrackKeys.erase(itMetaData);
     mTrackData.remove(metaData);
 }
 
 TrackMetadataModel::TrackDataType::mapped_type TrackMetadataModel::dataFromType(TrackDataType::key_type metaData) const
 {
     return mFullData[metaData];
 }
 
 void TrackMetadataModel::fillLyricsDataFromTrack()
 {
     beginInsertRows({}, mTrackData.size(), mTrackData.size());
     mTrackKeys.push_back(DatabaseInterface::LyricsRole);
     mTrackData[DatabaseInterface::LyricsRole] = mLyricsValueWatcher.result();
     endInsertRows();
 }
 
 void TrackMetadataModel::lyricsValueIsReady()
 {
     if (!mLyricsValueWatcher.result().isEmpty()) {
         fillLyricsDataFromTrack();
 
         mFullData[DatabaseInterface::LyricsRole] = mLyricsValueWatcher.result();
 
         Q_EMIT lyricsChanged();
     }
 }
 
 void TrackMetadataModel::initialize(MusicListenersManager *newManager, DatabaseInterface *trackDatabase)
 {
     mManager = newManager;
     Q_EMIT managerChanged();
 
     if (mManager) {
         mDataLoader.setDatabase(mManager->viewDatabase());
     } else if (trackDatabase) {
         mDataLoader.setDatabase(trackDatabase);
     }
 
     if (mManager) {
         mManager->connectModel(&mDataLoader);
     }
 
     connect(this, &TrackMetadataModel::needDataByDatabaseId,
             &mDataLoader, &ModelDataLoader::loadDataByDatabaseId);
     connect(this, &TrackMetadataModel::needDataByFileName,
             &mDataLoader, &ModelDataLoader::loadDataByFileName);
     connect(&mDataLoader, &ModelDataLoader::allTrackData,
             this, &TrackMetadataModel::trackData);
     connect(&mDataLoader, &ModelDataLoader::trackModified,
             this, &TrackMetadataModel::trackData);
 }
 
 void TrackMetadataModel::fetchLyrics()
 {
     auto lyricicsValue = QtConcurrent::run(QThreadPool::globalInstance(), [=]() {
         auto trackData = mFileScanner.scanOneFile(mFullData[DatabaseInterface::ResourceRole].toUrl(), mMimeDatabase);
         if (!trackData.lyrics().isEmpty()) {
             return trackData.lyrics();
         }
         return QString{};
     });
 
     mLyricsValueWatcher.setFuture(lyricicsValue);
 }
 
 void TrackMetadataModel::initializeByTrackId(qulonglong databaseId)
 {
     mFullData.clear();
     mTrackData.clear();
     mCoverImage.clear();
     mFileUrl.clear();
 
     Q_EMIT lyricsChanged();
 
     Q_EMIT needDataByDatabaseId(ElisaUtils::Track, databaseId);
 }
 
 void TrackMetadataModel::initializeByTrackFileName(const QString &fileName)
 {
     mFullData.clear();
     mTrackData.clear();
     mCoverImage.clear();
     mFileUrl.clear();
 
     Q_EMIT lyricsChanged();
 
     Q_EMIT needDataByFileName(ElisaUtils::FileName, QUrl::fromLocalFile(fileName));
 }
 
 void TrackMetadataModel::setManager(MusicListenersManager *newManager)
 {
     initialize(newManager, nullptr);
 }
 
 void TrackMetadataModel::setDatabase(DatabaseInterface *trackDatabase)
 {
     initialize(nullptr, trackDatabase);
 }
 
 
 #include "moc_trackmetadatamodel.cpp"