diff --git a/src/abstractfile/abstractfilelistener.cpp b/src/abstractfile/abstractfilelistener.cpp
index d3365277..b42988c8 100644
--- a/src/abstractfile/abstractfilelistener.cpp
+++ b/src/abstractfile/abstractfilelistener.cpp
@@ -1,129 +1,125 @@
 /*
  * Copyright 2016-2017 Matthieu Gallien <matthieu_gallien@yahoo.fr>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 3 of the License, or (at your option) any later version.
  *
  * This library 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "abstractfilelistener.h"
 
 #include "abstractfilelisting.h"
 #include "databaseinterface.h"
 #include "notificationitem.h"
 
 #include <QThread>
 
 class AbstractFileListenerPrivate
 {
 public:
 
-    explicit AbstractFileListenerPrivate()
-    {
-    }
-
     QThread mFileQueryThread;
 
     AbstractFileListing *mFileListing = nullptr;
 
 };
 
 AbstractFileListener::AbstractFileListener(QObject *parent)
     : QObject(parent), d(std::make_unique<AbstractFileListenerPrivate>())
 {
 }
 
 AbstractFileListener::~AbstractFileListener()
 {
     d->mFileQueryThread.quit();
     d->mFileQueryThread.wait();
 }
 
 DatabaseInterface *AbstractFileListener::databaseInterface() const
 {
     return nullptr;
 }
 
 void AbstractFileListener::setDatabaseInterface(DatabaseInterface *model)
 {
     if (model) {
         connect(this, &AbstractFileListener::newTrackFile, d->mFileListing, &AbstractFileListing::newTrackFile);
         connect(d->mFileListing, &AbstractFileListing::tracksList, model, &DatabaseInterface::insertTracksList);
         connect(d->mFileListing, &AbstractFileListing::removedTracksList, model, &DatabaseInterface::removeTracksList);
         connect(d->mFileListing, &AbstractFileListing::modifyTracksList, model, &DatabaseInterface::modifyTracksList);
 
         QMetaObject::invokeMethod(d->mFileListing, "init", Qt::QueuedConnection);
     }
 
     Q_EMIT databaseInterfaceChanged();
 }
 
 void AbstractFileListener::applicationAboutToQuit()
 {
     d->mFileListing->applicationAboutToQuit();
 
     d->mFileQueryThread.exit();
     d->mFileQueryThread.wait();
 }
 
 void AbstractFileListener::quitListener()
 {
     applicationAboutToQuit();
 
     Q_EMIT clearDatabase(d->mFileListing->sourceName());
 }
 
 void AbstractFileListener::resetImportedTracksCounter()
 {
     d->mFileListing->resetImportedTracksCounter();
 }
 
 void AbstractFileListener::setFileListing(AbstractFileListing *fileIndexer)
 {
     d->mFileListing = fileIndexer;
     d->mFileQueryThread.start();
     d->mFileListing->moveToThread(&d->mFileQueryThread);
     connect(fileIndexer, &AbstractFileListing::indexingStarted,
             this, &AbstractFileListener::indexingStarted);
     connect(fileIndexer, &AbstractFileListing::indexingFinished,
             this, &AbstractFileListener::indexingFinished);
     connect(fileIndexer, &AbstractFileListing::newNotification,
             this, &AbstractFileListener::newNotification);
     connect(fileIndexer, &AbstractFileListing::closeNotification,
             this, &AbstractFileListener::closeNotification);
     connect(fileIndexer, &AbstractFileListing::importedTracksCountChanged,
             this, &AbstractFileListener::importedTracksCountChanged);
 }
 
 AbstractFileListing *AbstractFileListener::fileListing() const
 {
     return d->mFileListing;
 }
 
 int AbstractFileListener::importedTracksCount() const
 {
     if (!d->mFileListing) {
         return 0;
     }
 
     return d->mFileListing->importedTracksCount();
 }
 
 void AbstractFileListener::performInitialScan()
 {
     d->mFileListing->refreshContent();
 }
 
 
 #include "moc_abstractfilelistener.cpp"
diff --git a/src/abstractfile/abstractfilelisting.cpp b/src/abstractfile/abstractfilelisting.cpp
index 78868ecc..ded3ff07 100644
--- a/src/abstractfile/abstractfilelisting.cpp
+++ b/src/abstractfile/abstractfilelisting.cpp
@@ -1,404 +1,404 @@
 /*
  * Copyright 2016-2017 Matthieu Gallien <matthieu_gallien@yahoo.fr>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 3 of the License, or (at your option) any later version.
  *
  * This library 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "abstractfilelisting.h"
 
 #include "musicaudiotrack.h"
 #include "notificationitem.h"
 #include "elisautils.h"
 
 #include <KFileMetaData/Properties>
 #include <KFileMetaData/ExtractorCollection>
 #include <KFileMetaData/Extractor>
 #include <KFileMetaData/SimpleExtractionResult>
 #include <KFileMetaData/UserMetaData>
 
 #include <QThread>
 #include <QHash>
 #include <QFileInfo>
 #include <QDir>
 #include <QFileSystemWatcher>
 #include <QMimeDatabase>
 #include <QSet>
 #include <QPair>
 #include <QAtomicInt>
 
 #include <QtGlobal>
 
 #include <algorithm>
 #include <utility>
 
 class AbstractFileListingPrivate
 {
 public:
 
     explicit AbstractFileListingPrivate(QString sourceName) : mSourceName(std::move(sourceName))
     {
     }
 
     QFileSystemWatcher mFileSystemWatcher;
 
     QHash<QString, QUrl> mAllAlbumCover;
 
     QHash<QUrl, QSet<QPair<QUrl, bool>>> mDiscoveredFiles;
 
     QString mSourceName;
 
-    bool mHandleNewFiles = true;
-
     KFileMetaData::ExtractorCollection mExtractors;
 
-    QAtomicInt mStopRequest = 0;
-
     QMimeDatabase mMimeDb;
 
+    QAtomicInt mStopRequest = 0;
+
     int mImportedTracksCount = 0;
 
     int mNotificationUpdateInterval = 1;
 
     int mNewFilesEmitInterval = 1;
 
+    bool mHandleNewFiles = true;
+
 };
 
 AbstractFileListing::AbstractFileListing(const QString &sourceName, QObject *parent) : QObject(parent), d(std::make_unique<AbstractFileListingPrivate>(sourceName))
 {
     connect(&d->mFileSystemWatcher, &QFileSystemWatcher::directoryChanged,
             this, &AbstractFileListing::directoryChanged);
     connect(&d->mFileSystemWatcher, &QFileSystemWatcher::fileChanged,
             this, &AbstractFileListing::fileChanged);
 }
 
 AbstractFileListing::~AbstractFileListing()
 = default;
 
 void AbstractFileListing::init()
 {
     executeInit();
 }
 
 void AbstractFileListing::newTrackFile(const MusicAudioTrack &partialTrack)
 {
     const auto &newTrack = scanOneFile(partialTrack.resourceURI());
 
     if (newTrack.isValid() && newTrack != partialTrack) {
         Q_EMIT modifyTracksList({newTrack}, d->mAllAlbumCover, d->mSourceName);
     }
 }
 
 void AbstractFileListing::resetImportedTracksCounter()
 {
     d->mImportedTracksCount = 0;
 }
 
 void AbstractFileListing::applicationAboutToQuit()
 {
     d->mStopRequest = 1;
 }
 
 void AbstractFileListing::scanDirectory(QList<MusicAudioTrack> &newFiles, const QUrl &path)
 {
     if (d->mStopRequest == 1) {
         return;
     }
 
     QDir rootDirectory(path.toLocalFile());
     rootDirectory.refresh();
 
     if (rootDirectory.exists()) {
         watchPath(path.toLocalFile());
     }
 
     auto &currentDirectoryListingFiles = d->mDiscoveredFiles[path];
 
     auto currentFilesList = QSet<QUrl>();
 
     rootDirectory.refresh();
     const auto entryList = rootDirectory.entryInfoList(QDir::NoDotAndDotDot | QDir::Files | QDir::Dirs);
     for (const auto &oneEntry : entryList) {
         auto newFilePath = QUrl::fromLocalFile(oneEntry.canonicalFilePath());
 
         if (oneEntry.isDir() || oneEntry.isFile()) {
             currentFilesList.insert(newFilePath);
         }
     }
 
     auto removedTracks = QVector<QPair<QUrl, bool>>();
     for (const auto &removedFilePath : currentDirectoryListingFiles) {
         auto itFilePath = std::find(currentFilesList.begin(), currentFilesList.end(), removedFilePath.first);
 
         if (itFilePath != currentFilesList.end()) {
             continue;
         }
 
         removedTracks.push_back(removedFilePath);
     }
 
     auto allRemovedTracks = QList<QUrl>();
     for (const auto &oneRemovedTrack : removedTracks) {
         if (oneRemovedTrack.second) {
             allRemovedTracks.push_back(oneRemovedTrack.first);
         } else {
             removeFile(oneRemovedTrack.first, allRemovedTracks);
         }
     }
     for (const auto &oneRemovedTrack : removedTracks) {
         currentDirectoryListingFiles.remove(oneRemovedTrack);
         currentDirectoryListingFiles.remove(oneRemovedTrack);
     }
 
     if (!allRemovedTracks.isEmpty()) {
         Q_EMIT removedTracksList(allRemovedTracks);
     }
 
     if (!d->mHandleNewFiles) {
         return;
     }
 
     for (const auto &newFilePath : currentFilesList) {
         QFileInfo oneEntry(newFilePath.toLocalFile());
 
         auto itFilePath = std::find(currentDirectoryListingFiles.begin(), currentDirectoryListingFiles.end(), QPair<QUrl, bool>{newFilePath, oneEntry.isFile()});
 
         if (itFilePath != currentDirectoryListingFiles.end()) {
             continue;
         }
 
         if (oneEntry.isDir()) {
             addFileInDirectory(newFilePath, path);
             scanDirectory(newFiles, newFilePath);
 
             if (d->mStopRequest == 1) {
                 break;
             }
 
             continue;
         }
         if (!oneEntry.isFile()) {
             continue;
         }
 
         auto newTrack = scanOneFile(newFilePath);
 
         if (newTrack.isValid() && d->mStopRequest == 0) {
             addCover(newTrack);
 
             addFileInDirectory(newTrack.resourceURI(), path);
             newFiles.push_back(newTrack);
 
             ++d->mImportedTracksCount;
             if (d->mImportedTracksCount % d->mNotificationUpdateInterval == 0) {
                 d->mNotificationUpdateInterval = std::min(50, 1 + d->mNotificationUpdateInterval * 2);
                 Q_EMIT importedTracksCountChanged();
             }
 
             if (newFiles.size() > d->mNewFilesEmitInterval && d->mStopRequest == 0) {
                 d->mNewFilesEmitInterval = std::min(50, 1 + d->mNewFilesEmitInterval * d->mNewFilesEmitInterval);
                 Q_EMIT importedTracksCountChanged();
                 emitNewFiles(newFiles);
                 newFiles.clear();
             }
         }
 
         if (d->mStopRequest == 1) {
             Q_EMIT importedTracksCountChanged();
             break;
         }
     }
 }
 
 const QString &AbstractFileListing::sourceName() const
 {
     return d->mSourceName;
 }
 
 int AbstractFileListing::importedTracksCount() const
 {
     return d->mImportedTracksCount;
 }
 
 void AbstractFileListing::directoryChanged(const QString &path)
 {
     const auto directoryEntry = d->mDiscoveredFiles.find(QUrl::fromLocalFile(path));
     if (directoryEntry == d->mDiscoveredFiles.end()) {
         return;
     }
 
     Q_EMIT indexingStarted();
 
     scanDirectoryTree(path);
 
     Q_EMIT indexingFinished(d->mImportedTracksCount);
 }
 
 void AbstractFileListing::fileChanged(const QString &modifiedFileName)
 {
     auto modifiedFile = QUrl::fromLocalFile(modifiedFileName);
 
     auto modifiedTrack = scanOneFile(modifiedFile);
 
     if (modifiedTrack.isValid()) {
         Q_EMIT modifyTracksList({modifiedTrack}, d->mAllAlbumCover, d->mSourceName);
     }
 }
 
 void AbstractFileListing::executeInit()
 {
 }
 
 void AbstractFileListing::triggerRefreshOfContent()
 {
     d->mImportedTracksCount = 0;
 }
 
 void AbstractFileListing::refreshContent()
 {
     triggerRefreshOfContent();
 }
 
 MusicAudioTrack AbstractFileListing::scanOneFile(const QUrl &scanFile)
 {
     MusicAudioTrack newTrack;
 
     newTrack = ElisaUtils::scanOneFile(scanFile, d->mMimeDb, d->mExtractors);
 
     if (newTrack.isValid()) {
         QFileInfo scanFileInfo(scanFile.toLocalFile());
         if (scanFileInfo.exists()) {
             watchPath(scanFile.toLocalFile());
         }
     }
 
     return newTrack;
 }
 
 void AbstractFileListing::watchPath(const QString &pathName)
 {
     d->mFileSystemWatcher.addPath(pathName);
 }
 
 void AbstractFileListing::addFileInDirectory(const QUrl &newFile, const QUrl &directoryName)
 {
     const auto directoryEntry = d->mDiscoveredFiles.find(directoryName);
     if (directoryEntry == d->mDiscoveredFiles.end()) {
         watchPath(directoryName.toLocalFile());
 
         QDir currentDirectory(directoryName.toLocalFile());
         if (currentDirectory.cdUp()) {
             const auto parentDirectoryName = currentDirectory.absolutePath();
             const auto parentDirectory = QUrl::fromLocalFile(parentDirectoryName);
             const auto parentDirectoryEntry = d->mDiscoveredFiles.find(parentDirectory);
             if (parentDirectoryEntry == d->mDiscoveredFiles.end()) {
                 watchPath(parentDirectoryName);
             }
 
             auto &parentCurrentDirectoryListingFiles = d->mDiscoveredFiles[parentDirectory];
 
             parentCurrentDirectoryListingFiles.insert({directoryName, false});
         }
     }
     auto &currentDirectoryListingFiles = d->mDiscoveredFiles[directoryName];
 
     QFileInfo isAFile(newFile.toLocalFile());
     currentDirectoryListingFiles.insert({newFile, isAFile.isFile()});
 }
 
 void AbstractFileListing::scanDirectoryTree(const QString &path)
 {
     auto newFiles = QList<MusicAudioTrack>();
 
     scanDirectory(newFiles, QUrl::fromLocalFile(path));
 
     if (!newFiles.isEmpty() && d->mStopRequest == 0) {
         Q_EMIT importedTracksCountChanged();
         emitNewFiles(newFiles);
     }
 }
 
 void AbstractFileListing::setHandleNewFiles(bool handleThem)
 {
     d->mHandleNewFiles = handleThem;
 }
 
 void AbstractFileListing::emitNewFiles(const QList<MusicAudioTrack> &tracks)
 {
     Q_EMIT tracksList(tracks, d->mAllAlbumCover, d->mSourceName);
 }
 
 void AbstractFileListing::addCover(const MusicAudioTrack &newTrack)
 {
     auto itCover = d->mAllAlbumCover.find(newTrack.albumName());
     if (itCover != d->mAllAlbumCover.end()) {
         return;
     }
 
     QFileInfo trackFilePath(newTrack.resourceURI().toLocalFile());
     QDir trackFileDir = trackFilePath.absoluteDir();
     QStringList filters;
     filters << QStringLiteral("cover.jpg") << QStringLiteral("cover.png")
             << QStringLiteral("folder.jpg") << QStringLiteral("folder.png");
     trackFileDir.setNameFilters(filters);
     QFileInfoList coverFiles = trackFileDir.entryInfoList();
     if (coverFiles.isEmpty()) {
         return;
     } else {
         d->mAllAlbumCover[newTrack.resourceURI().toString()] = QUrl::fromLocalFile(coverFiles.at(0).absoluteFilePath());
     }
 }
 
 void AbstractFileListing::removeDirectory(const QUrl &removedDirectory, QList<QUrl> &allRemovedFiles)
 {
     const auto itRemovedDirectory = d->mDiscoveredFiles.find(removedDirectory);
 
     if (itRemovedDirectory == d->mDiscoveredFiles.end()) {
         return;
     }
 
     const auto &currentRemovedDirectory = *itRemovedDirectory;
     for (const auto &itFile : currentRemovedDirectory) {
         if (itFile.first.isValid() && !itFile.first.isEmpty()) {
             removeFile(itFile.first, allRemovedFiles);
             if (itFile.second) {
                 allRemovedFiles.push_back(itFile.first);
             }
         }
     }
 
     d->mDiscoveredFiles.erase(itRemovedDirectory);
 }
 
 void AbstractFileListing::removeFile(const QUrl &oneRemovedTrack, QList<QUrl> &allRemovedFiles)
 {
     auto itRemovedDirectory = d->mDiscoveredFiles.find(oneRemovedTrack);
     if (itRemovedDirectory != d->mDiscoveredFiles.end()) {
         removeDirectory(oneRemovedTrack, allRemovedFiles);
     }
 }
 
 void AbstractFileListing::setSourceName(const QString &name)
 {
     d->mSourceName = name;
 }
 
 void AbstractFileListing::increaseImportedTracksCount()
 {
     ++d->mImportedTracksCount;
 }
 
 
 #include "moc_abstractfilelisting.cpp"
diff --git a/src/baloo/localbaloofilelisting.cpp b/src/baloo/localbaloofilelisting.cpp
index 28315c44..662c345c 100644
--- a/src/baloo/localbaloofilelisting.cpp
+++ b/src/baloo/localbaloofilelisting.cpp
@@ -1,490 +1,490 @@
 /*
  * Copyright 2016-2017 Matthieu Gallien <matthieu_gallien@yahoo.fr>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 3 of the License, or (at your option) any later version.
  *
  * This library 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "localbaloofilelisting.h"
 
 #include "musicaudiotrack.h"
 #include "notificationitem.h"
 #include "elisa_settings.h"
 
 #include "baloo/scheduler.h"
 #include "baloo/fileindexer.h"
 
 #include <Baloo/Query>
 #include <Baloo/File>
 #include <Baloo/IndexerConfig>
 
 #include <KFileMetaData/Properties>
 #include <KFileMetaData/UserMetaData>
 
 #include <KLocalizedString>
 
 #include <QDBusConnection>
 #include <QDBusConnectionInterface>
 #include <QDBusMessage>
 #include <QDBusServiceWatcher>
 
 #include <QThread>
 #include <QHash>
 #include <QFileInfo>
 #include <QDir>
 #include <QAtomicInt>
 #include <QScopedPointer>
 #include <QDebug>
 #include <QGuiApplication>
 
 #include <algorithm>
 #include <memory>
 
 class LocalBalooFileListingPrivate
 {
 public:
 
     Baloo::Query mQuery;
 
     QHash<QString, QVector<MusicAudioTrack>> mAllAlbums;
 
     QHash<QString, QVector<MusicAudioTrack>> mNewAlbums;
 
     QList<MusicAudioTrack> mNewTracks;
 
-    QAtomicInt mStopRequest = 0;
-
     QDBusServiceWatcher mServiceWatcher;
 
-    bool mIsRegistered = false;
-
-    bool mIsRegistering = false;
-
     QScopedPointer<org::kde::baloo::fileindexer> mBalooIndexer;
 
     QScopedPointer<org::kde::baloo::scheduler> mBalooScheduler;
 
+    QAtomicInt mStopRequest = 0;
+
+    bool mIsRegistered = false;
+
+    bool mIsRegistering = false;
+
 };
 
 LocalBalooFileListing::LocalBalooFileListing(QObject *parent)
     : AbstractFileListing(QStringLiteral("baloo"), parent), d(std::make_unique<LocalBalooFileListingPrivate>())
 {
     d->mQuery.addType(QStringLiteral("Audio"));
     setHandleNewFiles(false);
 
     auto sessionBus = QDBusConnection::sessionBus();
 
     connect(&d->mServiceWatcher, &QDBusServiceWatcher::serviceRegistered,
             this, &LocalBalooFileListing::serviceRegistered);
     connect(&d->mServiceWatcher, &QDBusServiceWatcher::serviceOwnerChanged,
             this, &LocalBalooFileListing::serviceOwnerChanged);
     connect(&d->mServiceWatcher, &QDBusServiceWatcher::serviceUnregistered,
             this, &LocalBalooFileListing::serviceUnregistered);
 
     d->mServiceWatcher.setConnection(sessionBus);
     d->mServiceWatcher.addWatchedService(QStringLiteral("org.kde.baloo"));
 
     if (sessionBus.interface()->isServiceRegistered(QStringLiteral("org.kde.baloo"))) {
         registerToBaloo();
     }
 }
 
 LocalBalooFileListing::~LocalBalooFileListing()
 {
     Q_EMIT closeNotification(QStringLiteral("balooInvalidConfiguration"));
 }
 
 void LocalBalooFileListing::applicationAboutToQuit()
 {
     AbstractFileListing::applicationAboutToQuit();
     d->mStopRequest = 1;
 }
 
 void LocalBalooFileListing::newBalooFile(const QString &fileName)
 {
     auto newFile = QUrl::fromLocalFile(fileName);
 
     auto newTrack = scanOneFile(newFile);
 
     if (newTrack.isValid()) {
         QFileInfo newFileInfo(fileName);
 
         addFileInDirectory(newFile, QUrl::fromLocalFile(newFileInfo.absoluteDir().absolutePath()));
 
         emitNewFiles({newTrack});
     }
 }
 
 void LocalBalooFileListing::registeredToBaloo(QDBusPendingCallWatcher *watcher)
 {
     qDebug() << "LocalBalooFileListing::registeredToBaloo";
 
     if (!watcher) {
         return;
     }
 
     QDBusPendingReply<> reply = *watcher;
     if (reply.isError()) {
         qDebug() << "LocalBalooFileListing::executeInit" << reply.error().name() << reply.error().message();
         d->mIsRegistered = false;
     } else {
         d->mIsRegistered = true;
     }
 
     d->mIsRegistering = false;
 
     watcher->deleteLater();
 }
 
 void LocalBalooFileListing::registerToBaloo()
 {
     if (d->mIsRegistering) {
         qDebug() << "LocalBalooFileListing::registerToBaloo" << "already registering";
         return;
     }
 
     qDebug() << "LocalBalooFileListing::registerToBaloo";
 
     d->mIsRegistering = true;
 
     auto sessionBus = QDBusConnection::sessionBus();
 
     d->mBalooIndexer.reset(new org::kde::baloo::fileindexer(QStringLiteral("org.kde.baloo"), QStringLiteral("/fileindexer"),
                                                             sessionBus, this));
 
     if (!d->mBalooIndexer->isValid()) {
         qDebug() << "LocalBalooFileListing::registerToBaloo" << "invalid org.kde.baloo/fileindexer interface";
         return;
     }
 
     connect(d->mBalooIndexer.data(), &org::kde::baloo::fileindexer::finishedIndexingFile,
             this, &LocalBalooFileListing::newBalooFile);
 
     d->mBalooScheduler.reset(new org::kde::baloo::scheduler(QStringLiteral("org.kde.baloo"), QStringLiteral("/scheduler"),
                                                             sessionBus, this));
 
     if (!d->mBalooScheduler->isValid()) {
         qDebug() << "LocalBalooFileListing::registerToBaloo" << "invalid org.kde.baloo/scheduler interface";
         return;
     }
 
     qDebug() << "LocalBalooFileListing::registerToBaloo" << "call registerMonitor";
     auto answer = d->mBalooIndexer->registerMonitor();
 
     if (answer.isError()) {
         qDebug() << "LocalBalooFileListing::executeInit" << answer.error().name() << answer.error().message();
     }
 
     auto pendingCallWatcher = new QDBusPendingCallWatcher(answer);
 
     connect(pendingCallWatcher, &QDBusPendingCallWatcher::finished, this, &LocalBalooFileListing::registeredToBaloo);
     if (pendingCallWatcher->isFinished()) {
         registeredToBaloo(pendingCallWatcher);
     }
 }
 
 void LocalBalooFileListing::renamedFiles(const QString &from, const QString &to, const QStringList &listFiles)
 {
     qDebug() << "LocalBalooFileListing::renamedFiles" << from << to << listFiles;
 }
 
 void LocalBalooFileListing::serviceOwnerChanged(const QString &serviceName, const QString &oldOwner, const QString &newOwner)
 {
     Q_UNUSED(oldOwner);
     Q_UNUSED(newOwner);
 
     qDebug() << "LocalBalooFileListing::serviceOwnerChanged" << serviceName << oldOwner << newOwner;
 
     if (serviceName == QStringLiteral("org.kde.baloo") && !newOwner.isEmpty()) {
         d->mIsRegistered = false;
         registerToBaloo();
     }
 }
 
 void LocalBalooFileListing::serviceRegistered(const QString &serviceName)
 {
     qDebug() << "LocalBalooFileListing::serviceRegistered" << serviceName;
 
     if (serviceName == QStringLiteral("org.kde.baloo")) {
         registerToBaloo();
     }
 }
 
 void LocalBalooFileListing::serviceUnregistered(const QString &serviceName)
 {
     qDebug() << "LocalBalooFileListing::serviceUnregistered" << serviceName;
 
     if (serviceName == QStringLiteral("org.kde.baloo")) {
         d->mIsRegistered = false;
     }
 }
 
 void LocalBalooFileListing::executeInit()
 {
 }
 
 void LocalBalooFileListing::triggerRefreshOfContent()
 {
     if (!checkBalooConfiguration()) {
         return;
     }
 
     Q_EMIT indexingStarted();
 
     AbstractFileListing::triggerRefreshOfContent();
 
     auto resultIterator = d->mQuery.exec();
     auto newFiles = QList<MusicAudioTrack>();
 
     while(resultIterator.next() && d->mStopRequest == 0) {
         const auto &newFileUrl = QUrl::fromLocalFile(resultIterator.filePath());
         auto scanFileInfo = QFileInfo(resultIterator.filePath());
         const auto currentDirectory = QUrl::fromLocalFile(scanFileInfo.absoluteDir().absolutePath());
 
         addFileInDirectory(newFileUrl, currentDirectory);
 
         const auto &newTrack = scanOneFile(newFileUrl);
 
         if (newTrack.isValid()) {
             newFiles.push_back(newTrack);
             increaseImportedTracksCount();
             if (newFiles.size() % 50 == 0) {
                 Q_EMIT importedTracksCountChanged();
             }
             if (newFiles.size() > 500 && d->mStopRequest == 0) {
                 Q_EMIT importedTracksCountChanged();
                 emitNewFiles(newFiles);
                 newFiles.clear();
             }
         }
     }
 
     if (!newFiles.isEmpty() && d->mStopRequest == 0) {
         Q_EMIT importedTracksCountChanged();
         emitNewFiles(newFiles);
     }
 
     Q_EMIT indexingFinished(importedTracksCount());
 }
 
 MusicAudioTrack LocalBalooFileListing::scanOneFile(const QUrl &scanFile)
 {
     auto newTrack = MusicAudioTrack();
 
     auto fileName = scanFile.toLocalFile();
     auto scanFileInfo = QFileInfo(fileName);
 
     if (scanFileInfo.exists()) {
         watchPath(fileName);
     }
 
     Baloo::File match(fileName);
     match.load();
 
     const auto &allProperties = match.properties();
 
     auto titleProperty = allProperties.find(KFileMetaData::Property::Title);
     auto durationProperty = allProperties.find(KFileMetaData::Property::Duration);
     auto artistProperty = allProperties.find(KFileMetaData::Property::Artist);
     auto albumProperty = allProperties.find(KFileMetaData::Property::Album);
     auto albumArtistProperty = allProperties.find(KFileMetaData::Property::AlbumArtist);
     auto trackNumberProperty = allProperties.find(KFileMetaData::Property::TrackNumber);
     auto discNumberProperty = allProperties.find(KFileMetaData::Property::DiscNumber);
     auto genreProperty = allProperties.find(KFileMetaData::Property::Genre);
     auto yearProperty = allProperties.find(KFileMetaData::Property::ReleaseYear);
     auto composerProperty = allProperties.find(KFileMetaData::Property::Composer);
     auto lyricistProperty = allProperties.find(KFileMetaData::Property::Lyricist);
     auto channelsProperty = allProperties.find(KFileMetaData::Property::Channels);
     auto bitRateProperty = allProperties.find(KFileMetaData::Property::BitRate);
     auto sampleRateProperty = allProperties.find(KFileMetaData::Property::SampleRate);
     auto commentProperty = allProperties.find(KFileMetaData::Property::Comment);
     auto fileData = KFileMetaData::UserMetaData(fileName);
 
     if (albumProperty != allProperties.end()) {
         auto albumValue = albumProperty->toString();
         auto &allTracks = d->mAllAlbums[albumValue];
 
         newTrack.setAlbumName(albumValue);
 
         if (artistProperty != allProperties.end()) {
             newTrack.setArtist(artistProperty->toStringList().join(QStringLiteral(", ")));
         }
 
         if (durationProperty != allProperties.end()) {
             newTrack.setDuration(QTime::fromMSecsSinceStartOfDay(1000 * durationProperty->toDouble()));
         }
 
         if (titleProperty != allProperties.end()) {
             newTrack.setTitle(titleProperty->toString());
         }
 
         if (trackNumberProperty != allProperties.end()) {
             newTrack.setTrackNumber(trackNumberProperty->toInt());
         }
 
         if (discNumberProperty != allProperties.end()) {
             newTrack.setDiscNumber(discNumberProperty->toInt());
         } else {
             newTrack.setDiscNumber(1);
         }
 
         if (albumArtistProperty != allProperties.end()) {
             newTrack.setAlbumArtist(albumArtistProperty->toStringList().join(QStringLiteral(", ")));
         }
 
         if (newTrack.artist().isEmpty()) {
             newTrack.setArtist(newTrack.albumArtist());
         }
 
         if (yearProperty != allProperties.end()) {
             newTrack.setYear(yearProperty->toInt());
         }
 
         if (channelsProperty != allProperties.end()) {
             newTrack.setChannels(channelsProperty->toInt());
         }
 
         if (bitRateProperty != allProperties.end()) {
             newTrack.setBitRate(bitRateProperty->toInt());
         }
 
         if (sampleRateProperty != allProperties.end()) {
             newTrack.setSampleRate(sampleRateProperty->toInt());
         }
 
         if (genreProperty != allProperties.end()) {
             newTrack.setGenre(genreProperty->toStringList().join(QStringLiteral(", ")));
         }
 
         if (composerProperty != allProperties.end()) {
             newTrack.setComposer(composerProperty->toStringList().join(QStringLiteral(", ")));
         }
 
         if (lyricistProperty != allProperties.end()) {
             newTrack.setLyricist(lyricistProperty->toStringList().join(QStringLiteral(", ")));
         }
 
         if (commentProperty != allProperties.end()) {
             newTrack.setComment(commentProperty->toString());
         }
 
         newTrack.setRating(fileData.rating());
 
         newTrack.setResourceURI(scanFile);
 
         auto itTrack = std::find(allTracks.begin(), allTracks.end(), newTrack);
         if (itTrack == allTracks.end()) {
             allTracks.push_back(newTrack);
             d->mNewTracks.push_back(newTrack);
             d->mNewAlbums[newTrack.albumName()].push_back(newTrack);
 
             auto &newTracks = d->mAllAlbums[newTrack.albumName()];
 
             std::sort(allTracks.begin(), allTracks.end());
             std::sort(newTracks.begin(), newTracks.end());
         }
 
         if (newTrack.title().isEmpty()) {
             return newTrack;
         }
 
         if (newTrack.artist().isEmpty()) {
             return newTrack;
         }
 
         if (newTrack.albumName().isEmpty()) {
             return newTrack;
         }
 
         if (!newTrack.duration().isValid()) {
             return newTrack;
         }
 
         newTrack.setValid(true);
     }
 
     if (!newTrack.isValid()) {
         newTrack = AbstractFileListing::scanOneFile(scanFile);
     }
 
     if (newTrack.isValid()) {
         AbstractFileListing::addCover(newTrack);
     }
 
     return newTrack;
 }
 
 bool LocalBalooFileListing::checkBalooConfiguration()
 {
     bool problemDetected = false;
     Baloo::IndexerConfig balooConfiguration;
 
     problemDetected = problemDetected || !balooConfiguration.fileIndexingEnabled();
     problemDetected = problemDetected || balooConfiguration.onlyBasicIndexing();
 
     if (problemDetected) {
         NotificationItem balooInvalidConfiguration;
 
         balooInvalidConfiguration.setNotificationId(QStringLiteral("balooInvalidConfiguration"));
 
         balooInvalidConfiguration.setTargetObject(this);
 
         balooInvalidConfiguration.setMessage(i18nc("Notification about unusable Baloo Configuration", "Baloo configuration does not allow to discover your music"));
 
         balooInvalidConfiguration.setMainButtonText(i18nc("Text of button to modify Baloo Configuration", "Modify it"));
         balooInvalidConfiguration.setMainButtonIconName(QStringLiteral("configure"));
         balooInvalidConfiguration.setMainButtonMethodName(QStringLiteral("fixBalooConfiguration"));
 
         balooInvalidConfiguration.setSecondaryButtonText(i18nc("Text of button to disable Baloo indexer", "Disable Baloo support"));
         balooInvalidConfiguration.setSecondaryButtonIconName(QStringLiteral("configure"));
         balooInvalidConfiguration.setSecondaryButtonMethodName(QStringLiteral("disableBalooIndexer"));
 
         Q_EMIT newNotification(balooInvalidConfiguration);
     } else {
         Q_EMIT closeNotification(QStringLiteral("balooInvalidConfiguration"));
     }
 
     return !problemDetected;
 }
 
 void LocalBalooFileListing::fixBalooConfiguration()
 {
     qDebug() << "LocalBalooFileListing::fixBalooConfiguration";
 
     Baloo::IndexerConfig balooConfiguration;
 
     if (!balooConfiguration.fileIndexingEnabled()) {
         balooConfiguration.setFileIndexingEnabled(true);
     }
 
     if (balooConfiguration.onlyBasicIndexing()) {
         balooConfiguration.setOnlyBasicIndexing(false);
     }
 
     balooConfiguration.refresh();
 
     if (checkBalooConfiguration()) {
         triggerRefreshOfContent();
     }
 }
 
 void LocalBalooFileListing::disableBalooIndexer()
 {
     Elisa::ElisaConfiguration::self()->setBalooIndexer(false);
     Elisa::ElisaConfiguration::self()->save();
 }
 
 
 #include "moc_localbaloofilelisting.cpp"
diff --git a/src/databaseinterface.cpp b/src/databaseinterface.cpp
index c9cde650..01f32d97 100644
--- a/src/databaseinterface.cpp
+++ b/src/databaseinterface.cpp
@@ -1,3666 +1,3666 @@
 /*
  * Copyright 2016-2017 Matthieu Gallien <matthieu_gallien@yahoo.fr>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 3 of the License, or (at your option) any later version.
  *
  * This library 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "databaseinterface.h"
 
 #include <KI18n/KLocalizedString>
 
 #include <QSqlDatabase>
 #include <QSqlDriver>
 #include <QSqlQuery>
 #include <QSqlRecord>
 #include <QSqlError>
 
 #include <QMutex>
 #include <QVariant>
 #include <QAtomicInt>
 #include <QDebug>
 
 #include <algorithm>
 
 class DatabaseInterfacePrivate
 {
 public:
 
     DatabaseInterfacePrivate(const QSqlDatabase &tracksDatabase)
         : mTracksDatabase(tracksDatabase), mSelectAlbumQuery(mTracksDatabase),
           mSelectTrackQuery(mTracksDatabase), mSelectAlbumIdFromTitleQuery(mTracksDatabase),
           mInsertAlbumQuery(mTracksDatabase), mSelectTrackIdFromTitleAlbumIdArtistQuery(mTracksDatabase),
           mInsertTrackQuery(mTracksDatabase), mSelectAlbumTrackCountQuery(mTracksDatabase),
           mUpdateAlbumQuery(mTracksDatabase), mSelectTracksFromArtist(mTracksDatabase),
           mSelectTrackFromIdQuery(mTracksDatabase), mSelectCountAlbumsForArtistQuery(mTracksDatabase),
           mSelectTrackIdFromTitleArtistAlbumTrackDiscNumberQuery(mTracksDatabase), mSelectAllAlbumsQuery(mTracksDatabase),
           mSelectAllAlbumsFromArtistQuery(mTracksDatabase), mSelectAllArtistsQuery(mTracksDatabase),
           mInsertArtistsQuery(mTracksDatabase), mSelectArtistByNameQuery(mTracksDatabase),
           mSelectArtistQuery(mTracksDatabase), mSelectTrackFromFilePathQuery(mTracksDatabase),
           mRemoveTrackQuery(mTracksDatabase), mRemoveAlbumQuery(mTracksDatabase),
           mRemoveArtistQuery(mTracksDatabase), mSelectAllTracksQuery(mTracksDatabase),
           mInsertTrackMapping(mTracksDatabase), mSelectAllTracksFromSourceQuery(mTracksDatabase),
           mInsertMusicSource(mTracksDatabase), mSelectMusicSource(mTracksDatabase),
           mUpdateIsSingleDiscAlbumFromIdQuery(mTracksDatabase), mSelectAllInvalidTracksFromSourceQuery(mTracksDatabase),
           mInitialUpdateTracksValidity(mTracksDatabase), mUpdateTrackMapping(mTracksDatabase),
           mSelectTracksMapping(mTracksDatabase), mSelectTracksMappingPriority(mTracksDatabase),
           mUpdateAlbumArtUriFromAlbumIdQuery(mTracksDatabase), mSelectTracksMappingPriorityByTrackId(mTracksDatabase),
           mSelectAllTrackFilesFromSourceQuery(mTracksDatabase), mFindInvalidTrackFilesQuery(mTracksDatabase),
           mSelectAlbumIdsFromArtist(mTracksDatabase), mRemoveTracksMappingFromSource(mTracksDatabase),
           mRemoveTracksMapping(mTracksDatabase), mSelectTracksWithoutMappingQuery(mTracksDatabase),
           mSelectAlbumIdFromTitleAndArtistQuery(mTracksDatabase), mSelectAlbumIdFromTitleWithoutArtistQuery(mTracksDatabase),
           mInsertAlbumArtistQuery(mTracksDatabase), mInsertTrackArtistQuery(mTracksDatabase),
           mRemoveTrackArtistQuery(mTracksDatabase), mRemoveAlbumArtistQuery(mTracksDatabase),
           mSelectTrackIdFromTitleAlbumTrackDiscNumberQuery(mTracksDatabase), mSelectAlbumArtUriFromAlbumIdQuery(mTracksDatabase)
     {
     }
 
     QSqlDatabase mTracksDatabase;
 
     QSqlQuery mSelectAlbumQuery;
 
     QSqlQuery mSelectTrackQuery;
 
     QSqlQuery mSelectAlbumIdFromTitleQuery;
 
     QSqlQuery mInsertAlbumQuery;
 
     QSqlQuery mSelectTrackIdFromTitleAlbumIdArtistQuery;
 
     QSqlQuery mInsertTrackQuery;
 
     QSqlQuery mSelectAlbumTrackCountQuery;
 
     QSqlQuery mUpdateAlbumQuery;
 
     QSqlQuery mSelectTracksFromArtist;
 
     QSqlQuery mSelectTrackFromIdQuery;
 
     QSqlQuery mSelectCountAlbumsForArtistQuery;
 
     QSqlQuery mSelectTrackIdFromTitleArtistAlbumTrackDiscNumberQuery;
 
     QSqlQuery mSelectAllAlbumsQuery;
 
     QSqlQuery mSelectAllAlbumsFromArtistQuery;
 
     QSqlQuery mSelectAllArtistsQuery;
 
     QSqlQuery mInsertArtistsQuery;
 
     QSqlQuery mSelectArtistByNameQuery;
 
     QSqlQuery mSelectArtistQuery;
 
     QSqlQuery mSelectTrackFromFilePathQuery;
 
     QSqlQuery mRemoveTrackQuery;
 
     QSqlQuery mRemoveAlbumQuery;
 
     QSqlQuery mRemoveArtistQuery;
 
     QSqlQuery mSelectAllTracksQuery;
 
     QSqlQuery mInsertTrackMapping;
 
     QSqlQuery mSelectAllTracksFromSourceQuery;
 
     QSqlQuery mInsertMusicSource;
 
     QSqlQuery mSelectMusicSource;
 
     QSqlQuery mUpdateIsSingleDiscAlbumFromIdQuery;
 
     QSqlQuery mSelectAllInvalidTracksFromSourceQuery;
 
     QSqlQuery mInitialUpdateTracksValidity;
 
     QSqlQuery mUpdateTrackMapping;
 
     QSqlQuery mSelectTracksMapping;
 
     QSqlQuery mSelectTracksMappingPriority;
 
     QSqlQuery mUpdateAlbumArtUriFromAlbumIdQuery;
 
     QSqlQuery mSelectTracksMappingPriorityByTrackId;
 
     QSqlQuery mSelectAllTrackFilesFromSourceQuery;
 
     QSqlQuery mFindInvalidTrackFilesQuery;
 
     QSqlQuery mSelectAlbumIdsFromArtist;
 
     QSqlQuery mRemoveTracksMappingFromSource;
 
     QSqlQuery mRemoveTracksMapping;
 
     QSqlQuery mSelectTracksWithoutMappingQuery;
 
     QSqlQuery mSelectAlbumIdFromTitleAndArtistQuery;
 
     QSqlQuery mSelectAlbumIdFromTitleWithoutArtistQuery;
 
     QSqlQuery mInsertAlbumArtistQuery;
 
     QSqlQuery mInsertTrackArtistQuery;
 
     QSqlQuery mRemoveTrackArtistQuery;
 
     QSqlQuery mRemoveAlbumArtistQuery;
 
     QSqlQuery mSelectTrackIdFromTitleAlbumTrackDiscNumberQuery;
 
     QSqlQuery mSelectAlbumArtUriFromAlbumIdQuery;
 
     qulonglong mAlbumId = 1;
 
     qulonglong mArtistId = 1;
 
     qulonglong mTrackId = 1;
 
     qulonglong mDiscoverId = 1;
 
-    bool mInitFinished = false;
-
     QAtomicInt mStopRequest = 0;
 
+    bool mInitFinished = false;
+
 };
 
 DatabaseInterface::DatabaseInterface(QObject *parent) : QObject(parent), d(nullptr)
 {
 }
 
 DatabaseInterface::~DatabaseInterface()
 {
     if (d) {
         d->mTracksDatabase.close();
     }
 }
 
 void DatabaseInterface::init(const QString &dbName, const QString &databaseFileName)
 {
     QSqlDatabase tracksDatabase = QSqlDatabase::addDatabase(QStringLiteral("QSQLITE"), dbName);
 
     if (!databaseFileName.isEmpty()) {
         tracksDatabase.setDatabaseName(QStringLiteral("file:") + databaseFileName);
     } else {
         tracksDatabase.setDatabaseName(QStringLiteral("file:memdb1?mode=memory"));
     }
     tracksDatabase.setConnectOptions(QStringLiteral("foreign_keys = ON;locking_mode = EXCLUSIVE;QSQLITE_OPEN_URI;QSQLITE_BUSY_TIMEOUT=500000"));
 
     auto result = tracksDatabase.open();
     if (result) {
         qDebug() << "database open";
     } else {
         qDebug() << "database not open";
     }
     qDebug() << "DatabaseInterface::init" << (tracksDatabase.driver()->hasFeature(QSqlDriver::Transactions) ? "yes" : "no");
 
     d = std::make_unique<DatabaseInterfacePrivate>(tracksDatabase);
 
     initDatabase();
     initRequest();
 
     if (!databaseFileName.isEmpty()) {
         reloadExistingDatabase();
     }
 }
 
 MusicAlbum DatabaseInterface::albumFromTitleAndArtist(const QString &title, const QString &artist)
 {
     auto result = MusicAlbum();
 
     auto transactionResult = startTransaction();
     if (!transactionResult) {
         return result;
     }
 
     result = internalAlbumFromTitleAndArtist(title, artist);
 
     transactionResult = finishTransaction();
     if (!transactionResult) {
         return result;
     }
 
     return result;
 }
 
 
 QList<MusicAudioTrack> DatabaseInterface::allTracks()
 {
     auto result = QList<MusicAudioTrack>();
 
     if (!d) {
         return result;
     }
 
     auto transactionResult = startTransaction();
     if (!transactionResult) {
         return result;
     }
 
     auto queryResult = d->mSelectAllTracksQuery.exec();
 
     if (!queryResult || !d->mSelectAllTracksQuery.isSelect() || !d->mSelectAllTracksQuery.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::allAlbums" << d->mSelectAllTracksQuery.lastQuery();
         qDebug() << "DatabaseInterface::allAlbums" << d->mSelectAllTracksQuery.boundValues();
         qDebug() << "DatabaseInterface::allAlbums" << d->mSelectAllTracksQuery.lastError();
 
         return result;
     }
 
     while(d->mSelectAllTracksQuery.next()) {
         const auto &currentRecord = d->mSelectAllTracksQuery.record();
 
         result.push_back(buildTrackFromDatabaseRecord(currentRecord));
     }
 
     d->mSelectAllTracksQuery.finish();
 
     transactionResult = finishTransaction();
     if (!transactionResult) {
         return result;
     }
 
     return result;
 }
 
 QList<MusicAudioTrack> DatabaseInterface::allTracksFromSource(const QString &musicSource)
 {
     auto result = QList<MusicAudioTrack>();
 
     if (!d) {
         return result;
     }
 
     auto transactionResult = startTransaction();
     if (!transactionResult) {
         return result;
     }
 
     d->mSelectAllTracksFromSourceQuery.bindValue(QStringLiteral(":source"), musicSource);
 
     auto queryResult = d->mSelectAllTracksFromSourceQuery.exec();
 
     if (!queryResult || !d->mSelectAllTracksFromSourceQuery.isSelect() || !d->mSelectAllTracksFromSourceQuery.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::allAlbums" << d->mSelectAllTracksFromSourceQuery.lastQuery();
         qDebug() << "DatabaseInterface::allAlbums" << d->mSelectAllTracksFromSourceQuery.boundValues();
         qDebug() << "DatabaseInterface::allAlbums" << d->mSelectAllTracksFromSourceQuery.lastError();
 
         d->mSelectAllTracksFromSourceQuery.finish();
 
         transactionResult = finishTransaction();
         if (!transactionResult) {
             return result;
         }
 
         return result;
     }
 
     while(d->mSelectAllTracksFromSourceQuery.next()) {
         const auto &currentRecord = d->mSelectAllTracksFromSourceQuery.record();
 
         result.push_back(buildTrackFromDatabaseRecord(currentRecord));
     }
 
     d->mSelectAllTracksFromSourceQuery.finish();
 
     transactionResult = finishTransaction();
     if (!transactionResult) {
         return result;
     }
 
     return result;
 }
 
 QList<MusicAudioTrack> DatabaseInterface::allInvalidTracksFromSource(const QString &musicSource)
 {
     auto result = QList<MusicAudioTrack>();
 
     if (!d) {
         return result;
     }
 
     auto transactionResult = startTransaction();
     if (!transactionResult) {
         return result;
     }
 
     d->mSelectAllInvalidTracksFromSourceQuery.bindValue(QStringLiteral(":source"), musicSource);
 
     auto queryResult = d->mSelectAllInvalidTracksFromSourceQuery.exec();
 
     if (!queryResult || !d->mSelectAllInvalidTracksFromSourceQuery.isSelect() || !d->mSelectAllInvalidTracksFromSourceQuery.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::allAlbums" << d->mSelectAllInvalidTracksFromSourceQuery.lastQuery();
         qDebug() << "DatabaseInterface::allAlbums" << d->mSelectAllInvalidTracksFromSourceQuery.boundValues();
         qDebug() << "DatabaseInterface::allAlbums" << d->mSelectAllInvalidTracksFromSourceQuery.lastError();
 
         return result;
     }
 
     while(d->mSelectAllInvalidTracksFromSourceQuery.next()) {
         const auto &currentRecord = d->mSelectAllInvalidTracksFromSourceQuery.record();
 
         result.push_back(buildTrackFromDatabaseRecord(currentRecord));
     }
 
     d->mSelectAllInvalidTracksFromSourceQuery.finish();
 
     transactionResult = finishTransaction();
     if (!transactionResult) {
         return result;
     }
 
     return result;
 }
 
 QList<MusicAlbum> DatabaseInterface::allAlbums()
 {
     auto result = QList<MusicAlbum>();
 
     if (!d) {
         return result;
     }
 
     auto transactionResult = startTransaction();
     if (!transactionResult) {
         return result;
     }
 
     auto queryResult = d->mSelectAllAlbumsQuery.exec();
 
     if (!queryResult || !d->mSelectAllAlbumsQuery.isSelect() || !d->mSelectAllAlbumsQuery.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::allAlbums" << d->mSelectAllAlbumsQuery.lastQuery();
         qDebug() << "DatabaseInterface::allAlbums" << d->mSelectAllAlbumsQuery.boundValues();
         qDebug() << "DatabaseInterface::allAlbums" << d->mSelectAllAlbumsQuery.lastError();
 
         return result;
     }
 
     while(d->mSelectAllAlbumsQuery.next()) {
         auto newAlbum = MusicAlbum();
 
         const auto &currentRecord = d->mSelectAllAlbumsQuery.record();
 
         newAlbum.setDatabaseId(currentRecord.value(0).toULongLong());
         newAlbum.setTitle(currentRecord.value(1).toString());
         newAlbum.setId(currentRecord.value(2).toString());
         newAlbum.setArtist(currentRecord.value(3).toString());
         newAlbum.setAlbumArtURI(currentRecord.value(4).toUrl());
         newAlbum.setTracksCount(currentRecord.value(5).toInt());
         newAlbum.setIsSingleDiscAlbum(currentRecord.value(6).toBool());
         newAlbum.setTracks(fetchTracks(newAlbum.databaseId()));
         newAlbum.setValid(true);
 
         result.push_back(newAlbum);
     }
 
     d->mSelectAllAlbumsQuery.finish();
 
     transactionResult = finishTransaction();
     if (!transactionResult) {
         return result;
     }
 
     return result;
 }
 
 QList<MusicArtist> DatabaseInterface::allArtists()
 {
     auto result = QList<MusicArtist>();
 
     if (!d) {
         return result;
     }
 
     auto transactionResult = startTransaction();
     if (!transactionResult) {
         return result;
     }
 
     auto queryResult = d->mSelectAllArtistsQuery.exec();
 
     if (!queryResult || !d->mSelectAllArtistsQuery.isSelect() || !d->mSelectAllArtistsQuery.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::allArtists" << d->mSelectAllArtistsQuery.lastQuery();
         qDebug() << "DatabaseInterface::allArtists" << d->mSelectAllArtistsQuery.boundValues();
         qDebug() << "DatabaseInterface::allArtists" << d->mSelectAllArtistsQuery.lastError();
 
         d->mSelectAllArtistsQuery.finish();
 
         transactionResult = finishTransaction();
         if (!transactionResult) {
             return result;
         }
 
         return result;
     }
 
     while(d->mSelectAllArtistsQuery.next()) {
         auto newArtist = MusicArtist();
 
         const auto &currentRecord = d->mSelectAllArtistsQuery.record();
 
         newArtist.setDatabaseId(currentRecord.value(0).toULongLong());
         newArtist.setName(currentRecord.value(1).toString());
         newArtist.setValid(true);
 
         d->mSelectCountAlbumsForArtistQuery.bindValue(QStringLiteral(":artistName"), newArtist.name());
 
         auto queryResult = d->mSelectCountAlbumsForArtistQuery.exec();
 
         if (!queryResult || !d->mSelectCountAlbumsForArtistQuery.isSelect() || !d->mSelectCountAlbumsForArtistQuery.isActive() || !d->mSelectCountAlbumsForArtistQuery.next()) {
             Q_EMIT databaseError();
 
             qDebug() << "DatabaseInterface::allArtists" << d->mSelectCountAlbumsForArtistQuery.lastQuery();
             qDebug() << "DatabaseInterface::allArtists" << d->mSelectCountAlbumsForArtistQuery.boundValues();
             qDebug() << "DatabaseInterface::allArtists" << d->mSelectCountAlbumsForArtistQuery.lastError();
 
             d->mSelectCountAlbumsForArtistQuery.finish();
 
             transactionResult = finishTransaction();
             if (!transactionResult) {
                 return result;
             }
 
             return result;
         }
 
         newArtist.setAlbumsCount(d->mSelectCountAlbumsForArtistQuery.record().value(0).toInt());
 
         d->mSelectCountAlbumsForArtistQuery.finish();
 
         result.push_back(newArtist);
     }
 
     d->mSelectAllArtistsQuery.finish();
 
     transactionResult = finishTransaction();
     if (!transactionResult) {
         return result;
     }
 
     return result;
 }
 
 QList<MusicAudioTrack> DatabaseInterface::tracksFromAuthor(const QString &artistName)
 {
     auto allTracks = QList<MusicAudioTrack>();
 
     auto transactionResult = startTransaction();
     if (!transactionResult) {
         return allTracks;
     }
 
     allTracks = internalTracksFromAuthor(artistName);
 
     transactionResult = finishTransaction();
     if (!transactionResult) {
         return allTracks;
     }
 
     return allTracks;
 }
 
 MusicArtist DatabaseInterface::internalArtistFromId(qulonglong artistId)
 {
     auto result = MusicArtist();
 
     if (!d || !d->mTracksDatabase.isValid() || !d->mInitFinished) {
         return result;
     }
 
     d->mSelectArtistQuery.bindValue(QStringLiteral(":artistId"), artistId);
 
     auto queryResult = d->mSelectArtistQuery.exec();
 
     if (!queryResult || !d->mSelectArtistQuery.isSelect() || !d->mSelectArtistQuery.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::internalArtistFromId" << d->mSelectArtistQuery.lastQuery();
         qDebug() << "DatabaseInterface::internalArtistFromId" << d->mSelectArtistQuery.boundValues();
         qDebug() << "DatabaseInterface::internalArtistFromId" << d->mSelectArtistQuery.lastError();
 
         d->mSelectArtistQuery.finish();
 
         return result;
     }
 
     if (!d->mSelectArtistQuery.next()) {
         d->mSelectArtistQuery.finish();
 
         return result;
     }
 
     const auto &currentRecord = d->mSelectArtistQuery.record();
 
     result.setDatabaseId(currentRecord.value(0).toULongLong());
     result.setName(currentRecord.value(1).toString());
     result.setValid(true);
 
     d->mSelectArtistQuery.finish();
 
     d->mSelectCountAlbumsForArtistQuery.bindValue(QStringLiteral(":artistName"), result.name());
 
     queryResult = d->mSelectCountAlbumsForArtistQuery.exec();
 
     if (!queryResult || !d->mSelectCountAlbumsForArtistQuery.isSelect() || !d->mSelectCountAlbumsForArtistQuery.isActive() || !d->mSelectCountAlbumsForArtistQuery.next()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::internalArtistFromId" << d->mSelectCountAlbumsForArtistQuery.lastQuery();
         qDebug() << "DatabaseInterface::internalArtistFromId" << d->mSelectCountAlbumsForArtistQuery.boundValues();
         qDebug() << "DatabaseInterface::internalArtistFromId" << d->mSelectCountAlbumsForArtistQuery.lastError();
 
         d->mSelectCountAlbumsForArtistQuery.finish();
 
         return result;
     }
 
     result.setAlbumsCount(d->mSelectCountAlbumsForArtistQuery.record().value(0).toInt());
 
     d->mSelectCountAlbumsForArtistQuery.finish();
 
     return result;
 }
 
 MusicAudioTrack DatabaseInterface::trackFromDatabaseId(qulonglong id)
 {
     auto result = MusicAudioTrack();
 
     if (!d) {
         return result;
     }
 
     auto transactionResult = startTransaction();
     if (!transactionResult) {
         return result;
     }
 
     result = internalTrackFromDatabaseId(id);
 
     transactionResult = finishTransaction();
     if (!transactionResult) {
         return result;
     }
 
     return result;
 }
 
 qulonglong DatabaseInterface::trackIdFromTitleAlbumTrackDiscNumber(const QString &title, const QString &artist, const QString &album,
                                                                    int trackNumber, int discNumber)
 {
     auto result = qulonglong(0);
 
     if (!d) {
         return result;
     }
 
     auto transactionResult = startTransaction();
     if (!transactionResult) {
         return result;
     }
 
     result = internalTrackIdFromTitleAlbumTracDiscNumber(title, artist, album, trackNumber, discNumber);
 
     transactionResult = finishTransaction();
     if (!transactionResult) {
         return result;
     }
 
     return result;
 }
 
 qulonglong DatabaseInterface::trackIdFromFileName(const QUrl &fileName)
 {
     auto result = qulonglong(0);
 
     if (!d) {
         return result;
     }
 
     auto transactionResult = startTransaction();
     if (!transactionResult) {
         return result;
     }
 
     result = internalTrackIdFromFileName(fileName);
 
     transactionResult = finishTransaction();
     if (!transactionResult) {
         return result;
     }
 
     return result;
 }
 
 void DatabaseInterface::applicationAboutToQuit()
 {
     d->mStopRequest = 1;
 }
 
 void DatabaseInterface::removeAllTracksFromSource(const QString &sourceName)
 {
     auto transactionResult = startTransaction();
     if (!transactionResult) {
         return;
     }
 
     d->mSelectMusicSource.bindValue(QStringLiteral(":name"), sourceName);
 
     auto queryResult = d->mSelectMusicSource.exec();
 
     if (!queryResult || !d->mSelectMusicSource.isSelect() || !d->mSelectMusicSource.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::insertMusicSource" << d->mSelectMusicSource.lastQuery();
         qDebug() << "DatabaseInterface::insertMusicSource" << d->mSelectMusicSource.boundValues();
         qDebug() << "DatabaseInterface::insertMusicSource" << d->mSelectMusicSource.lastError();
 
         d->mSelectMusicSource.finish();
 
         transactionResult = finishTransaction();
         if (!transactionResult) {
             return;
         }
 
         return;
     }
 
     if (!d->mSelectMusicSource.next()) {
         transactionResult = finishTransaction();
         if (!transactionResult) {
             return;
         }
 
         return;
     }
 
     qulonglong sourceId = d->mSelectMusicSource.record().value(0).toULongLong();
 
     d->mSelectMusicSource.finish();
 
     d->mSelectAllTrackFilesFromSourceQuery.bindValue(QStringLiteral(":discoverId"), sourceId);
 
     queryResult = d->mSelectAllTrackFilesFromSourceQuery.exec();
 
     if (!queryResult || !d->mSelectAllTrackFilesFromSourceQuery.isSelect() || !d->mSelectAllTrackFilesFromSourceQuery.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::insertMusicSource" << d->mSelectAllTrackFilesFromSourceQuery.lastQuery();
         qDebug() << "DatabaseInterface::insertMusicSource" << d->mSelectAllTrackFilesFromSourceQuery.boundValues();
         qDebug() << "DatabaseInterface::insertMusicSource" << d->mSelectAllTrackFilesFromSourceQuery.lastError();
 
         d->mSelectAllTrackFilesFromSourceQuery.finish();
 
         transactionResult = finishTransaction();
         if (!transactionResult) {
             return;
         }
 
         return;
     }
 
     QList<QUrl> allFileNames;
 
     while(d->mSelectAllTrackFilesFromSourceQuery.next()) {
         auto fileName = d->mSelectAllTrackFilesFromSourceQuery.record().value(0).toUrl();
 
         allFileNames.push_back(fileName);
     }
 
     d->mSelectAllTrackFilesFromSourceQuery.finish();
 
     internalRemoveTracksList(allFileNames, sourceId);
 
     transactionResult = finishTransaction();
     if (!transactionResult) {
         return;
     }
 }
 
 void DatabaseInterface::getAlbumFromAlbumId(qulonglong id)
 {
     auto result = MusicAlbum();
 
     auto transactionResult = startTransaction();
     if (!transactionResult) {
         Q_EMIT sentAlbumData(result);
     }
 
     result = internalAlbumFromId(id);
 
     transactionResult = finishTransaction();
     if (!transactionResult) {
         Q_EMIT sentAlbumData(result);
     }
 
     Q_EMIT sentAlbumData(result);
 }
 
 void DatabaseInterface::cleanInvalidTracks()
 {
     if (d->mStopRequest == 1) {
         return;
     }
 
     auto transactionResult = startTransaction();
     if (!transactionResult) {
         return;
     }
 
     auto queryResult = d->mFindInvalidTrackFilesQuery.exec();
 
     if (!queryResult || !d->mFindInvalidTrackFilesQuery.isSelect() || !d->mFindInvalidTrackFilesQuery.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::insertMusicSource" << d->mFindInvalidTrackFilesQuery.lastQuery();
         qDebug() << "DatabaseInterface::insertMusicSource" << d->mFindInvalidTrackFilesQuery.boundValues();
         qDebug() << "DatabaseInterface::insertMusicSource" << d->mFindInvalidTrackFilesQuery.lastError();
 
         d->mFindInvalidTrackFilesQuery.finish();
 
         transactionResult = finishTransaction();
         if (!transactionResult) {
             return;
         }
 
         return;
     }
 
     QList<QUrl> allFileNames;
     auto sourceId = qulonglong();
 
     while(d->mFindInvalidTrackFilesQuery.next()) {
         auto fileName = d->mFindInvalidTrackFilesQuery.record().value(0).toUrl();
         sourceId = d->mFindInvalidTrackFilesQuery.record().value(1).toULongLong();
         allFileNames.push_back(fileName);
     }
 
     d->mFindInvalidTrackFilesQuery.finish();
 
     internalRemoveTracksList(allFileNames, sourceId);
 
     transactionResult = finishTransaction();
     if (!transactionResult) {
         return;
     }
 }
 
 void DatabaseInterface::insertTracksList(const QList<MusicAudioTrack> &tracks, const QHash<QString, QUrl> &covers, const QString &musicSource)
 {
     if (d->mStopRequest == 1) {
         return;
     }
 
     auto transactionResult = startTransaction();
     if (!transactionResult) {
         return;
     }
 
     QSet<qulonglong> modifiedAlbumIds;
     QList<qulonglong> insertedTracks;
     QList<qulonglong> insertedAlbums;
 
     for(const auto &oneTrack : tracks) {
         d->mSelectTracksMapping.bindValue(QStringLiteral(":fileName"), oneTrack.resourceURI());
 
         auto result = d->mSelectTracksMapping.exec();
 
         if (!result || !d->mSelectTracksMapping.isSelect() || !d->mSelectTracksMapping.isActive()) {
             Q_EMIT databaseError();
 
             qDebug() << "DatabaseInterface::insertTracksList" << d->mSelectTracksMapping.lastQuery();
             qDebug() << "DatabaseInterface::insertTracksList" << d->mSelectTracksMapping.boundValues();
             qDebug() << "DatabaseInterface::insertTracksList" << d->mSelectTracksMapping.lastError();
 
             d->mSelectTracksMapping.finish();
 
             rollBackTransaction();
             return;
         }
 
         bool isNewTrack = !d->mSelectTracksMapping.next();
 
         if (isNewTrack) {
             insertTrackOrigin(oneTrack.resourceURI(), insertMusicSource(musicSource));
         } else {
             updateTrackOrigin(d->mSelectTracksMapping.record().value(0).toULongLong(), oneTrack.resourceURI());
         }
 
         d->mSelectTracksMapping.finish();
 
         const auto insertedTrackId = internalInsertTrack(oneTrack, covers, 0, modifiedAlbumIds,
                                                          (isNewTrack ? TrackFileInsertType::NewTrackFileInsert : TrackFileInsertType::ModifiedTrackFileInsert),
                                                          insertedAlbums);
 
         if (isNewTrack && insertedTrackId != 0) {
             insertedTracks.push_back(insertedTrackId);
         }
 
         if (d->mStopRequest == 1) {
             transactionResult = finishTransaction();
             if (!transactionResult) {
                 return;
             }
             return;
         }
     }
 
     QList<MusicAlbum> newAlbums;
     for (auto albumId : qAsConst(insertedAlbums)) {
         modifiedAlbumIds.remove(albumId);
         newAlbums.push_back(internalAlbumFromId(albumId));
     }
 
     if (!newAlbums.isEmpty()) {
         Q_EMIT albumsAdded(newAlbums);
     }
 
     const auto &constModifiedAlbumIds = modifiedAlbumIds;
     for (auto albumId : constModifiedAlbumIds) {
         Q_EMIT albumModified(internalAlbumFromId(albumId), albumId);
     }
 
     QList<MusicAudioTrack> newTracks;
     for (auto trackId : qAsConst(insertedTracks)) {
         newTracks.push_back(internalTrackFromDatabaseId(trackId));
     }
 
     if (!newTracks.isEmpty()) {
         Q_EMIT tracksAdded(newTracks);
     }
 
     transactionResult = finishTransaction();
     if (!transactionResult) {
         return;
     }
 }
 
 void DatabaseInterface::removeTracksList(const QList<QUrl> &removedTracks)
 {
     auto transactionResult = startTransaction();
     if (!transactionResult) {
         return;
     }
 
     internalRemoveTracksList(removedTracks);
 
     transactionResult = finishTransaction();
     if (!transactionResult) {
         return;
     }
 }
 
 void DatabaseInterface::modifyTracksList(const QList<MusicAudioTrack> &modifiedTracks, const QHash<QString, QUrl> &covers,
                                          const QString &musicSource)
 {
     auto transactionResult = startTransaction();
     if (!transactionResult) {
         return;
     }
 
     QSet<qulonglong> modifiedAlbumIds;
     QList<qulonglong> newAlbumIds;
 
     for (const auto &oneModifiedTrack : modifiedTracks) {
         if (oneModifiedTrack.albumArtist().isEmpty()) {
             continue;
         }
 
         bool modifyExistingTrack = internalTrackFromDatabaseId(oneModifiedTrack.databaseId()).isValid() ||
                 (internalTrackIdFromFileName(oneModifiedTrack.resourceURI()) != 0);
 
         auto originTrackId = oneModifiedTrack.databaseId();
         if (!originTrackId) {
             originTrackId = internalTrackIdFromFileName(oneModifiedTrack.resourceURI());
         }
 
         if (!modifyExistingTrack) {
             insertTrackOrigin(oneModifiedTrack.resourceURI(), insertMusicSource(musicSource));
         } else {
             updateTrackOrigin(originTrackId, oneModifiedTrack.resourceURI());
         }
 
         internalInsertTrack(oneModifiedTrack, covers, (modifyExistingTrack ? originTrackId : 0),
                             modifiedAlbumIds,
                             (modifyExistingTrack ? TrackFileInsertType::ModifiedTrackFileInsert : TrackFileInsertType::NewTrackFileInsert),
                             newAlbumIds);
     }
 
     QList<MusicAlbum> newAlbums;
     for (auto albumId : qAsConst(newAlbumIds)) {
         modifiedAlbumIds.remove(albumId);
         newAlbums.push_back(internalAlbumFromId(albumId));
     }
 
     if (!newAlbums.isEmpty()) {
         Q_EMIT albumsAdded(newAlbums);
     }
 
     for (auto albumId : qAsConst(modifiedAlbumIds)) {
         Q_EMIT albumModified(internalAlbumFromId(albumId), albumId);
     }
 
     transactionResult = finishTransaction();
     if (!transactionResult) {
         return;
     }
 }
 
 bool DatabaseInterface::startTransaction() const
 {
     auto result = false;
 
     auto transactionResult = d->mTracksDatabase.transaction();
     if (!transactionResult) {
         qDebug() << "transaction failed" << d->mTracksDatabase.lastError() << d->mTracksDatabase.lastError().driverText();
 
         return result;
     }
 
     result = true;
 
     return result;
 }
 
 bool DatabaseInterface::finishTransaction() const
 {
     auto result = false;
 
     auto transactionResult = d->mTracksDatabase.commit();
 
     if (!transactionResult) {
         qDebug() << "commit failed" << d->mTracksDatabase.lastError() << d->mTracksDatabase.lastError().nativeErrorCode();
 
         return result;
     }
 
     result = true;
 
     return result;
 }
 
 bool DatabaseInterface::rollBackTransaction() const
 {
     auto result = false;
 
     auto transactionResult = d->mTracksDatabase.rollback();
 
     if (!transactionResult) {
         qDebug() << "commit failed" << d->mTracksDatabase.lastError() << d->mTracksDatabase.lastError().nativeErrorCode();
 
         return result;
     }
 
     result = true;
 
     return result;
 }
 
 void DatabaseInterface::initDatabase() const
 {
     auto transactionResult = startTransaction();
     if (!transactionResult) {
         return;
     }
 
     auto listTables = d->mTracksDatabase.tables();
 
     if (!listTables.contains(QStringLiteral("DatabaseVersionV2"))) {
         for (const auto &oneTable : listTables) {
             QSqlQuery createSchemaQuery(d->mTracksDatabase);
 
             auto result = createSchemaQuery.exec(QStringLiteral("DROP TABLE ") + oneTable);
 
             if (!result) {
                 qDebug() << "DatabaseInterface::initDatabase" << createSchemaQuery.lastQuery();
                 qDebug() << "DatabaseInterface::initDatabase" << createSchemaQuery.lastError();
             }
         }
 
         listTables = d->mTracksDatabase.tables();
     }
 
     if (!listTables.contains(QStringLiteral("DatabaseVersionV2"))) {
         QSqlQuery createSchemaQuery(d->mTracksDatabase);
 
         const auto &result = createSchemaQuery.exec(QStringLiteral("CREATE TABLE `DatabaseVersionV2` (`Version` INTEGER PRIMARY KEY NOT NULL)"));
 
         if (!result) {
             qDebug() << "DatabaseInterface::initDatabase" << createSchemaQuery.lastQuery();
             qDebug() << "DatabaseInterface::initDatabase" << createSchemaQuery.lastError();
         }
     }
 
     if (!listTables.contains(QStringLiteral("DiscoverSource"))) {
         QSqlQuery createSchemaQuery(d->mTracksDatabase);
 
         const auto &result = createSchemaQuery.exec(QStringLiteral("CREATE TABLE `DiscoverSource` (`ID` INTEGER PRIMARY KEY NOT NULL, "
                                                                    "`Name` VARCHAR(55) NOT NULL, "
                                                                    "UNIQUE (`Name`))"));
 
         if (!result) {
             qDebug() << "DatabaseInterface::initDatabase" << createSchemaQuery.lastQuery();
             qDebug() << "DatabaseInterface::initDatabase" << createSchemaQuery.lastError();
         }
     }
 
     if (!listTables.contains(QStringLiteral("Artists"))) {
         QSqlQuery createSchemaQuery(d->mTracksDatabase);
 
         const auto &result = createSchemaQuery.exec(QStringLiteral("CREATE TABLE `Artists` (`ID` INTEGER PRIMARY KEY NOT NULL, "
                                                                    "`Name` VARCHAR(55) NOT NULL, "
                                                                    "UNIQUE (`Name`))"));
 
         if (!result) {
             qDebug() << "DatabaseInterface::initDatabase" << createSchemaQuery.lastQuery();
             qDebug() << "DatabaseInterface::initDatabase" << createSchemaQuery.lastError();
         }
     }
 
     if (!listTables.contains(QStringLiteral("Albums"))) {
         QSqlQuery createSchemaQuery(d->mTracksDatabase);
 
         const auto &result = createSchemaQuery.exec(QStringLiteral("CREATE TABLE `Albums` ("
                                                                    "`ID` INTEGER PRIMARY KEY NOT NULL, "
                                                                    "`Title` VARCHAR(55) NOT NULL, "
                                                                    "`CoverFileName` VARCHAR(255) NOT NULL, "
                                                                    "`TracksCount` INTEGER NOT NULL, "
                                                                    "`IsSingleDiscAlbum` BOOLEAN NOT NULL, "
                                                                    "`AlbumInternalID` VARCHAR(55))"));
 
         if (!result) {
             qDebug() << "DatabaseInterface::initDatabase" << createSchemaQuery.lastQuery();
             qDebug() << "DatabaseInterface::initDatabase" << createSchemaQuery.lastError();
         }
     }
 
     if (!listTables.contains(QStringLiteral("AlbumsArtists"))) {
         QSqlQuery createSchemaQuery(d->mTracksDatabase);
 
         const auto &result = createSchemaQuery.exec(QStringLiteral("CREATE TABLE `AlbumsArtists` ("
                                                                    "`AlbumID` INTEGER NOT NULL, "
                                                                    "`ArtistID` INTEGER NOT NULL, "
                                                                    "CONSTRAINT pk_albumsartists PRIMARY KEY (`AlbumID`, `ArtistID`), "
                                                                    "CONSTRAINT fk_albums FOREIGN KEY (`AlbumID`) REFERENCES `Albums`(`ID`) "
                                                                    "ON DELETE CASCADE, "
                                                                    "CONSTRAINT fk_artists FOREIGN KEY (`ArtistID`) REFERENCES `Artists`(`ID`) "
                                                                    "ON DELETE CASCADE)"));
 
         if (!result) {
             qDebug() << "DatabaseInterface::initDatabase" << createSchemaQuery.lastQuery();
             qDebug() << "DatabaseInterface::initDatabase" << createSchemaQuery.lastError();
         }
     }
 
     if (!listTables.contains(QStringLiteral("Tracks"))) {
         QSqlQuery createSchemaQuery(d->mTracksDatabase);
 
         const auto &result = createSchemaQuery.exec(QStringLiteral("CREATE TABLE `Tracks` ("
                                                                    "`ID` INTEGER PRIMARY KEY NOT NULL, "
                                                                    "`Title` VARCHAR(85) NOT NULL, "
                                                                    "`AlbumID` INTEGER NOT NULL, "
                                                                    "`TrackNumber` INTEGER NOT NULL, "
                                                                    "`DiscNumber` INTEGER DEFAULT -1, "
                                                                    "`Duration` INTEGER NOT NULL, "
                                                                    "`Rating` INTEGER NOT NULL DEFAULT 0, "
                                                                    "`Genre` VARCHAR(85) DEFAULT '', "
                                                                    "`Composer` VARCHAR(85) DEFAULT '', "
                                                                    "`Lyricist` VARCHAR(85) DEFAULT '', "
                                                                    "`Comment` VARCHAR(85) DEFAULT '', "
                                                                    "`Year` INTEGER DEFAULT 0, "
                                                                    "`Channels` INTEGER DEFAULT -1, "
                                                                    "`BitRate` INTEGER DEFAULT -1, "
                                                                    "`SampleRate` INTEGER DEFAULT -1, "
                                                                    "UNIQUE (`Title`, `AlbumID`, `TrackNumber`, `DiscNumber`), "
                                                                    "CONSTRAINT fk_tracks_album FOREIGN KEY (`AlbumID`) REFERENCES `Albums`(`ID`))"));
 
         if (!result) {
             qDebug() << "DatabaseInterface::initDatabase" << createSchemaQuery.lastQuery();
             qDebug() << "DatabaseInterface::initDatabase" << createSchemaQuery.lastError();
         }
     }
 
     if (!listTables.contains(QStringLiteral("TracksArtists"))) {
         QSqlQuery createSchemaQuery(d->mTracksDatabase);
 
         const auto &result = createSchemaQuery.exec(QStringLiteral("CREATE TABLE `TracksArtists` ("
                                                                    "`TrackID` INTEGER NOT NULL, "
                                                                    "`ArtistID` INTEGER NOT NULL, "
                                                                    "CONSTRAINT pk_tracksartists PRIMARY KEY (`TrackID`, `ArtistID`), "
                                                                    "CONSTRAINT fk_tracks FOREIGN KEY (`TrackID`) REFERENCES `Tracks`(`ID`) "
                                                                    "ON DELETE CASCADE, "
                                                                    "CONSTRAINT fk_artists FOREIGN KEY (`ArtistID`) REFERENCES `Artists`(`ID`) "
                                                                    "ON DELETE CASCADE)"));
 
         if (!result) {
             qDebug() << "DatabaseInterface::initDatabase" << createSchemaQuery.lastQuery();
             qDebug() << "DatabaseInterface::initDatabase" << createSchemaQuery.lastError();
         }
     }
 
     if (!listTables.contains(QStringLiteral("TracksMapping"))) {
         QSqlQuery createSchemaQuery(d->mTracksDatabase);
 
         const auto &result = createSchemaQuery.exec(QStringLiteral("CREATE TABLE `TracksMapping` ("
                                                                    "`TrackID` INTEGER NULL, "
                                                                    "`DiscoverID` INTEGER NOT NULL, "
                                                                    "`FileName` VARCHAR(255) NOT NULL, "
                                                                    "`Priority` INTEGER NOT NULL, "
                                                                    "`TrackValid` BOOLEAN NOT NULL, "
                                                                    "PRIMARY KEY (`FileName`), "
                                                                    "CONSTRAINT TracksUnique UNIQUE (`TrackID`, `Priority`), "
                                                                    "CONSTRAINT fk_tracksmapping_trackID FOREIGN KEY (`TrackID`) REFERENCES `Tracks`(`ID`), "
                                                                    "CONSTRAINT fk_tracksmapping_discoverID FOREIGN KEY (`DiscoverID`) REFERENCES `DiscoverSource`(`ID`))"));
 
         if (!result) {
             qDebug() << "DatabaseInterface::initDatabase" << createSchemaQuery.lastQuery();
             qDebug() << "DatabaseInterface::initDatabase" << createSchemaQuery.lastError();
         }
     }
 
     {
         QSqlQuery createTrackIndex(d->mTracksDatabase);
 
         const auto &result = createTrackIndex.exec(QStringLiteral("CREATE INDEX "
                                                                   "IF NOT EXISTS "
                                                                   "`TracksAlbumIndex` ON `Tracks` "
                                                                   "(`AlbumID`)"));
 
         if (!result) {
             qDebug() << "DatabaseInterface::initDatabase" << createTrackIndex.lastQuery();
             qDebug() << "DatabaseInterface::initDatabase" << createTrackIndex.lastError();
         }
     }
 
     {
         QSqlQuery createTrackIndex(d->mTracksDatabase);
 
         const auto &result = createTrackIndex.exec(QStringLiteral("CREATE INDEX "
                                                                   "IF NOT EXISTS "
                                                                   "`AlbumsArtistsArtistIndex` ON `AlbumsArtists` "
                                                                   "(`ArtistID`)"));
 
         if (!result) {
             qDebug() << "DatabaseInterface::initDatabase" << createTrackIndex.lastQuery();
             qDebug() << "DatabaseInterface::initDatabase" << createTrackIndex.lastError();
         }
     }
 
     {
         QSqlQuery createTrackIndex(d->mTracksDatabase);
 
         const auto &result = createTrackIndex.exec(QStringLiteral("CREATE INDEX "
                                                                   "IF NOT EXISTS "
                                                                   "`AlbumsArtistsAlbumIndex` ON `AlbumsArtists` "
                                                                   "(`AlbumID`)"));
 
         if (!result) {
             qDebug() << "DatabaseInterface::initDatabase" << createTrackIndex.lastError();
         }
     }
 
     {
         QSqlQuery createTrackIndex(d->mTracksDatabase);
 
         const auto &result = createTrackIndex.exec(QStringLiteral("CREATE INDEX "
                                                                   "IF NOT EXISTS "
                                                                   "`TracksArtistsArtistIndex` ON `TracksArtists` "
                                                                   "(`ArtistID`)"));
 
         if (!result) {
             qDebug() << "DatabaseInterface::initDatabase" << createTrackIndex.lastQuery();
             qDebug() << "DatabaseInterface::initDatabase" << createTrackIndex.lastError();
         }
     }
 
     {
         QSqlQuery createTrackIndex(d->mTracksDatabase);
 
         const auto &result = createTrackIndex.exec(QStringLiteral("CREATE INDEX "
                                                                   "IF NOT EXISTS "
                                                                   "`TracksArtistsTrackIndex` ON `TracksArtists` "
                                                                   "(`TrackID`)"));
 
         if (!result) {
             qDebug() << "DatabaseInterface::initDatabase" << createTrackIndex.lastQuery();
             qDebug() << "DatabaseInterface::initDatabase" << createTrackIndex.lastError();
         }
     }
 
     {
         QSqlQuery createTrackIndex(d->mTracksDatabase);
 
         const auto &result = createTrackIndex.exec(QStringLiteral("CREATE INDEX "
                                                                   "IF NOT EXISTS "
                                                                   "`TracksFileNameIndex` ON `TracksMapping` "
                                                                   "(`FileName`)"));
 
         if (!result) {
             qDebug() << "DatabaseInterface::initDatabase" << createTrackIndex.lastQuery();
             qDebug() << "DatabaseInterface::initDatabase" << createTrackIndex.lastError();
         }
     }
 
     transactionResult = finishTransaction();
     if (!transactionResult) {
         return;
     }
 }
 
 void DatabaseInterface::initRequest()
 {
     auto transactionResult = startTransaction();
     if (!transactionResult) {
         return;
     }
 
     {
         auto selectAlbumQueryText = QStringLiteral("SELECT "
                                                    "album.`ID`, "
                                                    "album.`Title`, "
                                                    "album.`AlbumInternalID`, "
                                                    "artist.`Name`, "
                                                    "album.`CoverFileName`, "
                                                    "album.`TracksCount`, "
                                                    "album.`IsSingleDiscAlbum` "
                                                    "FROM `Albums` album "
                                                    "LEFT JOIN `AlbumsArtists` albumArtist "
                                                    "ON "
                                                    "albumArtist.`AlbumID` = album.`ID` "
                                                    "LEFT JOIN `Artists` artist "
                                                    "ON "
                                                    "albumArtist.`ArtistID` = artist.`ID` "
                                                    "WHERE "
                                                    "album.`ID` = :albumId");
 
         auto result = d->mSelectAlbumQuery.prepare(selectAlbumQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectAlbumQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectAlbumQuery.lastError();
         }
     }
 
     {
         auto selectAllAlbumsText = QStringLiteral("SELECT "
                                                   "album.`ID`, "
                                                   "album.`Title`, "
                                                   "album.`AlbumInternalID`, "
                                                   "artist.`Name`, "
                                                   "album.`CoverFileName`, "
                                                   "album.`TracksCount`, "
                                                   "album.`IsSingleDiscAlbum` "
                                                   "FROM `Albums` album "
                                                   "LEFT JOIN `AlbumsArtists` albumArtist "
                                                   "ON "
                                                   "albumArtist.`AlbumID` = album.`ID` "
                                                   "LEFT JOIN `Artists` artist "
                                                   "ON "
                                                   "albumArtist.`ArtistID` = artist.`ID` "
                                                   "ORDER BY album.`Title`");
 
         auto result = d->mSelectAllAlbumsQuery.prepare(selectAllAlbumsText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectAllAlbumsQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectAllAlbumsQuery.lastError();
         }
     }
 
     {
         auto selectAllArtistsWithFilterText = QStringLiteral("SELECT `ID`, "
                                                              "`Name` "
                                                              "FROM `Artists`");
 
         auto result = d->mSelectAllArtistsQuery.prepare(selectAllArtistsWithFilterText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectAllArtistsQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectAllArtistsQuery.lastError();
         }
     }
 
     {
         auto selectAllTracksText = QStringLiteral("SELECT "
                                                   "tracks.`ID`, "
                                                   "tracks.`Title`, "
                                                   "tracks.`AlbumID`, "
                                                   "artist.`Name`, "
                                                   "artistAlbum.`Name`, "
                                                   "tracksMapping.`FileName`, "
                                                   "tracks.`TrackNumber`, "
                                                   "tracks.`DiscNumber`, "
                                                   "tracks.`Duration`, "
                                                   "album.`Title`, "
                                                   "tracks.`Rating`, "
                                                   "album.`CoverFileName`, "
                                                   "album.`IsSingleDiscAlbum`, "
                                                   "tracks.`Genre`, "
                                                   "tracks.`Composer`, "
                                                   "tracks.`Lyricist`, "
                                                   "tracks.`Comment`, "
                                                   "tracks.`Year`, "
                                                   "tracks.`Channels`, "
                                                   "tracks.`BitRate`, "
                                                   "tracks.`SampleRate` "
                                                   "FROM "
                                                   "`Tracks` tracks, `Artists` artist, `TracksArtists` trackArtist, "
                                                   "`Albums` album, `TracksMapping` tracksMapping "
                                                   "LEFT JOIN `AlbumsArtists` artistAlbumMapping ON artistAlbumMapping.`AlbumID` = album.`ID` "
                                                   "LEFT JOIN `Artists` artistAlbum ON artistAlbum.`ID` = artistAlbumMapping.`ArtistID` "
                                                   "WHERE "
                                                   "tracks.`ID` = trackArtist.`TrackID` AND "
                                                   "artist.`ID` = trackArtist.`ArtistID` AND "
                                                   "tracks.`AlbumID` = album.`ID` AND "
                                                   "tracksMapping.`TrackID` = tracks.`ID` AND "
                                                   "tracksMapping.`Priority` = (SELECT MIN(`Priority`) FROM `TracksMapping` WHERE `TrackID` = tracks.`ID`)");
 
         auto result = d->mSelectAllTracksQuery.prepare(selectAllTracksText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectAllTracksQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectAllTracksQuery.lastError();
         }
     }
 
     {
         auto selectAllInvalidTracksFromSourceQueryText = QStringLiteral("SELECT "
                                                                         "tracks.`ID`, "
                                                                         "tracks.`Title`, "
                                                                         "tracks.`AlbumID`, "
                                                                         "artist.`Name`, "
                                                                         "artistAlbum.`Name`, "
                                                                         "tracksMapping.`FileName`, "
                                                                         "tracks.`TrackNumber`, "
                                                                         "tracks.`DiscNumber`, "
                                                                         "tracks.`Duration`, "
                                                                         "album.`Title`, "
                                                                         "tracks.`Rating`, "
                                                                         "album.`CoverFileName`, "
                                                                         "album.`IsSingleDiscAlbum`, "
                                                                         "tracks.`Genre`, "
                                                                         "tracks.`Composer`, "
                                                                         "tracks.`Lyricist`, "
                                                                         "tracks.`Comment`, "
                                                                         "tracks.`Year`, "
                                                                         "tracks.`Channels`, "
                                                                         "tracks.`BitRate`, "
                                                                         "tracks.`SampleRate` "
                                                                         "FROM "
                                                                         "`Tracks` tracks, `Artists` artist, `TracksArtists` trackArtist, "
                                                                         "`Albums` album, `TracksMapping` tracksMapping, `DiscoverSource` source "
                                                                         "LEFT JOIN `AlbumsArtists` artistAlbumMapping ON artistAlbumMapping.`AlbumID` = album.`ID` "
                                                                         "LEFT JOIN `Artists` artistAlbum ON artistAlbum.`ID` = artistAlbumMapping.`ArtistID` "
                                                                         "WHERE "
                                                                         "tracks.`ID` = trackArtist.`TrackID` AND "
                                                                         "artist.`ID` = trackArtist.`ArtistID` AND "
                                                                         "tracks.`AlbumID` = album.`ID` AND "
                                                                         "source.`Name` = :source AND "
                                                                         "source.`ID` = tracksMapping.`DiscoverID` AND "
                                                                         "tracksMapping.`TrackValid` = 0 AND "
                                                                         "tracksMapping.`TrackID` = tracks.`ID`");
 
         auto result = d->mSelectAllInvalidTracksFromSourceQuery.prepare(selectAllInvalidTracksFromSourceQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectAllInvalidTracksFromSourceQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectAllInvalidTracksFromSourceQuery.lastError();
         }
     }
 
     {
         auto selectAllTracksFromSourceQueryText = QStringLiteral("SELECT "
                                                                  "tracks.`ID`, "
                                                                  "tracks.`Title`, "
                                                                  "tracks.`AlbumID`, "
                                                                  "artist.`Name`, "
                                                                  "artistAlbum.`Name`, "
                                                                  "tracksMapping.`FileName`, "
                                                                  "tracks.`TrackNumber`, "
                                                                  "tracks.`DiscNumber`, "
                                                                  "tracks.`Duration`, "
                                                                  "album.`Title`, "
                                                                  "tracks.`Rating`, "
                                                                  "album.`CoverFileName`, "
                                                                  "album.`IsSingleDiscAlbum`, "
                                                                  "tracks.`Genre`, "
                                                                  "tracks.`Composer`, "
                                                                  "tracks.`Lyricist`, "
                                                                  "tracks.`Comment`, "
                                                                  "tracks.`Year`, "
                                                                  "tracks.`Channels`, "
                                                                  "tracks.`BitRate`, "
                                                                  "tracks.`SampleRate` "
                                                                  "FROM "
                                                                  "`Tracks` tracks, `Artists` artist, `TracksArtists` trackArtist, "
                                                                  "`Albums` album, `TracksMapping` tracksMapping, `DiscoverSource` source "
                                                                  "LEFT JOIN `AlbumsArtists` artistAlbumMapping ON artistAlbumMapping.`AlbumID` = album.`ID` "
                                                                  "LEFT JOIN `Artists` artistAlbum ON artistAlbum.`ID` = artistAlbumMapping.`ArtistID` "
                                                                  "WHERE "
                                                                  "tracks.`ID` = trackArtist.`TrackID` AND "
                                                                  "artist.`ID` = trackArtist.`ArtistID` AND "
                                                                  "tracks.`AlbumID` = album.`ID` AND "
                                                                  "source.`Name` = :source AND "
                                                                  "source.`ID` = tracksMapping.`DiscoverID` AND "
                                                                  "tracksMapping.`TrackID` = tracks.`ID` AND "
                                                                  "tracksMapping.`Priority` = (SELECT MIN(`Priority`) FROM `TracksMapping` WHERE `TrackID` = tracks.`ID`)");
 
         auto result = d->mSelectAllTracksFromSourceQuery.prepare(selectAllTracksFromSourceQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectAllTracksFromSourceQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectAllTracksFromSourceQuery.lastError();
         }
     }
 
     {
         auto selectArtistByNameText = QStringLiteral("SELECT `ID`, "
                                                      "`Name` "
                                                      "FROM `Artists` "
                                                      "WHERE "
                                                      "`Name` = :name");
 
         auto result = d->mSelectArtistByNameQuery.prepare(selectArtistByNameText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectArtistByNameQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectArtistByNameQuery.lastError();
         }
     }
 
     {
         auto insertArtistsText = QStringLiteral("INSERT INTO `Artists` (`ID`, `Name`) "
                                                 "VALUES (:artistId, :name)");
 
         auto result = d->mInsertArtistsQuery.prepare(insertArtistsText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mInsertArtistsQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mInsertArtistsQuery.lastError();
         }
     }
 
     {
         auto selectTrackQueryText = QStringLiteral("SELECT "
                                                    "tracks.`ID`, "
                                                    "tracks.`Title`, "
                                                    "tracks.`AlbumID`, "
                                                    "artist.`Name`, "
                                                    "artistAlbum.`Name`, "
                                                    "tracksMapping.`FileName`, "
                                                    "tracks.`TrackNumber`, "
                                                    "tracks.`DiscNumber`, "
                                                    "tracks.`Duration`, "
                                                    "album.`Title`, "
                                                    "tracks.`Rating`, "
                                                    "album.`CoverFileName`, "
                                                    "album.`IsSingleDiscAlbum`, "
                                                    "tracks.`Genre`, "
                                                    "tracks.`Composer`, "
                                                    "tracks.`Lyricist`, "
                                                    "tracks.`Comment`, "
                                                    "tracks.`Year`, "
                                                    "tracks.`Channels`, "
                                                    "tracks.`BitRate`, "
                                                    "tracks.`SampleRate` "
                                                    "FROM "
                                                    "`Tracks` tracks, `Artists` artist, `TracksArtists` trackArtist, "
                                                    "`Albums` album, `TracksMapping` tracksMapping "
                                                    "LEFT JOIN `AlbumsArtists` artistAlbumMapping ON artistAlbumMapping.`AlbumID` = album.`ID` "
                                                    "LEFT JOIN `Artists` artistAlbum ON artistAlbum.`ID` = artistAlbumMapping.`ArtistID` "
                                                    "WHERE "
                                                    "tracks.`ID` = trackArtist.`TrackID` AND "
                                                    "artist.`ID` = trackArtist.`ArtistID` AND "
                                                    "tracksMapping.`TrackID` = tracks.`ID` AND "
                                                    "tracks.`AlbumID` = :albumId AND "
                                                    "album.`ID` = :albumId AND "
                                                    "tracksMapping.`Priority` = (SELECT MIN(`Priority`) FROM `TracksMapping` WHERE `TrackID` = tracks.`ID`) "
                                                    "ORDER BY tracks.`DiscNumber` ASC, "
                                                    "tracks.`TrackNumber` ASC");
 
         auto result = d->mSelectTrackQuery.prepare(selectTrackQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectTrackQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectTrackQuery.lastError();
         }
     }
     {
         auto selectTrackFromIdQueryText = QStringLiteral("SELECT "
                                                          "tracks.`Id`, "
                                                          "tracks.`Title`, "
                                                          "tracks.`AlbumID`, "
                                                          "artist.`Name`, "
                                                          "artistAlbum.`Name`, "
                                                          "tracksMapping.`FileName`, "
                                                          "tracks.`TrackNumber`, "
                                                          "tracks.`DiscNumber`, "
                                                          "tracks.`Duration`, "
                                                          "album.`Title`, "
                                                          "tracks.`Rating`, "
                                                          "album.`CoverFileName`, "
                                                          "album.`IsSingleDiscAlbum`, "
                                                          "tracks.`Genre`, "
                                                          "tracks.`Composer`, "
                                                          "tracks.`Lyricist`, "
                                                          "tracks.`Comment`, "
                                                          "tracks.`Year`, "
                                                          "tracks.`Channels`, "
                                                          "tracks.`BitRate`, "
                                                          "tracks.`SampleRate` "
                                                          "FROM "
                                                          "`Tracks` tracks, `Artists` artist, `TracksArtists` trackArtist, "
                                                          "`Albums` album, `TracksMapping` tracksMapping "
                                                          "LEFT JOIN `AlbumsArtists` artistAlbumMapping ON artistAlbumMapping.`AlbumID` = album.`ID` "
                                                          "LEFT JOIN `Artists` artistAlbum ON artistAlbum.`ID` = artistAlbumMapping.`ArtistID` "
                                                          "WHERE "
                                                          "tracks.`ID` = trackArtist.`TrackID` AND "
                                                          "artist.`ID` = trackArtist.`ArtistID` AND "
                                                          "tracks.`ID` = :trackId AND "
                                                          "tracks.`AlbumID` = album.`ID` AND "
                                                          "tracksMapping.`TrackID` = tracks.`ID` AND "
                                                          "tracksMapping.`Priority` = (SELECT MIN(`Priority`) FROM `TracksMapping` WHERE `TrackID` = tracks.`ID`)");
 
         auto result = d->mSelectTrackFromIdQuery.prepare(selectTrackFromIdQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectTrackFromIdQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectTrackFromIdQuery.lastError();
         }
     }
     {
         auto selectCountAlbumsQueryText = QStringLiteral("SELECT count(*) "
                                                          "FROM `Albums` album, `Artists` artist, `AlbumsArtists` albumArtist "
                                                          "WHERE artist.`Name` = :artistName AND "
                                                          "album.`ID` = albumArtist.`AlbumID` AND "
                                                          "artist.`ID` = albumArtist.`ArtistID`");
 
         const auto result = d->mSelectCountAlbumsForArtistQuery.prepare(selectCountAlbumsQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectCountAlbumsForArtistQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectCountAlbumsForArtistQuery.lastError();
         }
     }
     {
         auto selectAlbumIdFromTitleQueryText = QStringLiteral("SELECT "
                                                               "album.`ID` "
                                                               "FROM "
                                                               "`Albums` album, `Artists` artist, `AlbumsArtists` albumArtist "
                                                               "WHERE "
                                                               "artist.`Name` = :artistName AND "
                                                               "album.`ID` = albumArtist.`AlbumID` AND "
                                                               "artist.`ID` = albumArtist.`ArtistID` AND "
                                                               "album.`Title` = :title");
 
         auto result = d->mSelectAlbumIdFromTitleQuery.prepare(selectAlbumIdFromTitleQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectAlbumIdFromTitleQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectAlbumIdFromTitleQuery.lastError();
         }
     }
 
     {
         auto selectAlbumIdFromTitleAndArtistQueryText = QStringLiteral("SELECT "
                                                                        "album.`ID` "
                                                                        "FROM "
                                                                        "`Albums` album, "
                                                                        "`AlbumsArtists` albumArtist "
                                                                        "WHERE "
                                                                        "album.`ID` = albumArtist.`AlbumID` AND "
                                                                        "album.`Title` = :title AND "
                                                                        "albumArtist.`ArtistID` = :artistId");
 
         auto result = d->mSelectAlbumIdFromTitleAndArtistQuery.prepare(selectAlbumIdFromTitleAndArtistQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectAlbumIdFromTitleAndArtistQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectAlbumIdFromTitleAndArtistQuery.lastError();
         }
     }
 
     {
         auto selectAlbumIdFromTitleWithoutArtistQueryText = QStringLiteral("SELECT "
                                                                            "album.`ID` "
                                                                            "FROM "
                                                                            "`Albums` album "
                                                                            "WHERE "
                                                                            "album.`Title` = :title AND "
                                                                            "NOT EXISTS ("
                                                                            "SELECT "
                                                                            "albumArtist.`AlbumID` "
                                                                            "FROM "
                                                                            "`AlbumsArtists` albumArtist "
                                                                            "WHERE "
                                                                            "albumArtist.`AlbumID` = album.`ID`"
                                                                            ")");
 
         auto result = d->mSelectAlbumIdFromTitleWithoutArtistQuery.prepare(selectAlbumIdFromTitleWithoutArtistQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectAlbumIdFromTitleWithoutArtistQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectAlbumIdFromTitleWithoutArtistQuery.lastError();
         }
     }
 
     {
         auto insertAlbumQueryText = QStringLiteral("INSERT INTO Albums (`ID`, `Title`, `CoverFileName`, `TracksCount`, `IsSingleDiscAlbum`) "
                                                    "VALUES (:albumId, :title, :coverFileName, :tracksCount, :isSingleDiscAlbum)");
 
         auto result = d->mInsertAlbumQuery.prepare(insertAlbumQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mInsertAlbumQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mInsertAlbumQuery.lastError();
         }
     }
 
     {
         auto insertAlbumArtistQueryText = QStringLiteral("INSERT INTO `AlbumsArtists` (`AlbumID`, `ArtistID`) "
                                                          "VALUES (:albumId, :artistId)");
 
         auto result = d->mInsertAlbumArtistQuery.prepare(insertAlbumArtistQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mInsertAlbumArtistQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mInsertAlbumArtistQuery.lastError();
         }
     }
 
     {
         auto insertTrackArtistQueryText = QStringLiteral("INSERT INTO `TracksArtists` (`TrackID`, `ArtistID`) "
                                                          "VALUES (:trackId, :artistId)");
 
         auto result = d->mInsertTrackArtistQuery.prepare(insertTrackArtistQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mInsertTrackArtistQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mInsertTrackArtistQuery.lastError();
         }
     }
 
     {
         auto insertTrackMappingQueryText = QStringLiteral("INSERT INTO `TracksMapping` (`FileName`, `DiscoverID`, `Priority`, `TrackValid`) "
                                                           "VALUES (:fileName, :discoverId, :priority, 1)");
 
         auto result = d->mInsertTrackMapping.prepare(insertTrackMappingQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mInsertTrackMapping.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mInsertTrackMapping.lastError();
         }
     }
 
     {
         auto initialUpdateTracksValidityQueryText = QStringLiteral("UPDATE `TracksMapping` SET `TrackValid` = 0");
 
         auto result = d->mInitialUpdateTracksValidity.prepare(initialUpdateTracksValidityQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mInitialUpdateTracksValidity.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mInitialUpdateTracksValidity.lastError();
         }
     }
 
     {
         auto initialUpdateTracksValidityQueryText = QStringLiteral("UPDATE `TracksMapping` SET `TrackValid` = 1, `TrackID` = :trackId, `Priority` = :priority "
                                                                    "WHERE `FileName` = :fileName");
 
         auto result = d->mUpdateTrackMapping.prepare(initialUpdateTracksValidityQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mUpdateTrackMapping.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mUpdateTrackMapping.lastError();
         }
     }
 
     {
         auto removeTracksMappingFromSourceQueryText = QStringLiteral("DELETE FROM `TracksMapping` "
                                                                      "WHERE `FileName` = :fileName AND `DiscoverID` = :sourceId");
 
         auto result = d->mRemoveTracksMappingFromSource.prepare(removeTracksMappingFromSourceQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mRemoveTracksMappingFromSource.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mRemoveTracksMappingFromSource.lastError();
         }
     }
 
     {
         auto removeTracksMappingQueryText = QStringLiteral("DELETE FROM `TracksMapping` "
                                                            "WHERE `FileName` = :fileName");
 
         auto result = d->mRemoveTracksMapping.prepare(removeTracksMappingQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mRemoveTracksMapping.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mRemoveTracksMapping.lastError();
         }
     }
 
     {
         auto selectTracksWithoutMappingQueryText = QStringLiteral("SELECT "
                                                                   "tracks.`Id`, "
                                                                   "tracks.`Title`, "
                                                                   "tracks.`AlbumID`, "
                                                                   "artist.`Name`, "
                                                                   "artistAlbum.`Name`, "
                                                                   "\"\" as FileName, "
                                                                   "tracks.`TrackNumber`, "
                                                                   "tracks.`DiscNumber`, "
                                                                   "tracks.`Duration`, "
                                                                   "album.`Title`, "
                                                                   "tracks.`Rating`, "
                                                                   "album.`CoverFileName`, "
                                                                   "album.`IsSingleDiscAlbum`, "
                                                                   "tracks.`Genre`, "
                                                                   "tracks.`Composer`, "
                                                                   "tracks.`Lyricist`, "
                                                                   "tracks.`Comment`, "
                                                                   "tracks.`Year`, "
                                                                   "tracks.`Channels`, "
                                                                   "tracks.`BitRate`, "
                                                                   "tracks.`SampleRate` "
                                                                   "FROM "
                                                                   "`Tracks` tracks, "
                                                                   "`Artists` artist, "
                                                                   "`TracksArtists` trackArtist, "
                                                                   "`Albums` album "
                                                                   "LEFT JOIN `AlbumsArtists` artistAlbumMapping ON artistAlbumMapping.`AlbumID` = album.`ID` "
                                                                   "LEFT JOIN `Artists` artistAlbum ON artistAlbum.`ID` = artistAlbumMapping.`ArtistID` "
                                                                   "WHERE "
                                                                   "tracks.`ID` = trackArtist.`TrackID` AND "
                                                                   "artist.`ID` = trackArtist.`ArtistID` AND "
                                                                   "tracks.`AlbumID` = album.`ID` AND "
                                                                   "tracks.`ID` NOT IN (SELECT tracksMapping2.`TrackID` FROM `TracksMapping` tracksMapping2)");
 
         auto result = d->mSelectTracksWithoutMappingQuery.prepare(selectTracksWithoutMappingQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectTracksWithoutMappingQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectTracksWithoutMappingQuery.lastError();
         }
     }
 
     {
         auto selectTracksMappingQueryText = QStringLiteral("SELECT "
                                                            "`TrackID`, "
                                                            "`FileName`, "
                                                            "`DiscoverID`, "
                                                            "`Priority` "
                                                            "FROM "
                                                            "`TracksMapping` "
                                                            "WHERE "
                                                            "`FileName` = :fileName");
 
         auto result = d->mSelectTracksMapping.prepare(selectTracksMappingQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectTracksMapping.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectTracksMapping.lastError();
         }
     }
 
     {
         auto selectTracksMappingPriorityQueryText = QStringLiteral("SELECT "
                                                                    "`Priority` "
                                                                    "FROM "
                                                                    "`TracksMapping` "
                                                                    "WHERE "
                                                                    "`TrackID` = :trackId AND "
                                                                    "`FileName` = :fileName");
 
         auto result = d->mSelectTracksMappingPriority.prepare(selectTracksMappingPriorityQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectTracksMappingPriority.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectTracksMappingPriority.lastError();
         }
     }
 
     {
         auto selectTracksMappingPriorityQueryByTrackIdText = QStringLiteral("SELECT "
                                                                             "MAX(`Priority`) "
                                                                             "FROM "
                                                                             "`TracksMapping` "
                                                                             "WHERE "
                                                                             "`TrackID` = :trackId");
 
         auto result = d->mSelectTracksMappingPriorityByTrackId.prepare(selectTracksMappingPriorityQueryByTrackIdText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectTracksMappingPriorityByTrackId.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectTracksMappingPriorityByTrackId.lastError();
         }
     }
 
     {
         auto selectAllTrackFilesFromSourceQueryText = QStringLiteral("SELECT "
                                                                      "tracksMapping.`FileName` "
                                                                      "FROM "
                                                                      "`TracksMapping` tracksMapping "
                                                                      "WHERE "
                                                                      "tracksMapping.`DiscoverID` = :discoverId");
 
         auto result = d->mSelectAllTrackFilesFromSourceQuery.prepare(selectAllTrackFilesFromSourceQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectAllTrackFilesFromSourceQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectAllTrackFilesFromSourceQuery.lastError();
         }
     }
 
     {
         auto findInvalidTrackFilesText = QStringLiteral("SELECT "
                                                         "tracksMapping.`FileName`, "
                                                         "tracksMapping.`DiscoverID` "
                                                         "FROM "
                                                         "`TracksMapping` tracksMapping "
                                                         "WHERE "
                                                         "tracksMapping.`TrackValid` = 0");
 
         auto result = d->mFindInvalidTrackFilesQuery.prepare(findInvalidTrackFilesText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mFindInvalidTrackFilesQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mFindInvalidTrackFilesQuery.lastError();
         }
     }
 
     {
         auto insertMusicSourceQueryText = QStringLiteral("INSERT OR IGNORE INTO `DiscoverSource` (`ID`, `Name`) "
                                                          "VALUES (:discoverId, :name)");
 
         auto result = d->mInsertMusicSource.prepare(insertMusicSourceQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mInsertMusicSource.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mInsertMusicSource.lastError();
         }
     }
 
     {
         auto selectMusicSourceQueryText = QStringLiteral("SELECT `ID` FROM `DiscoverSource` WHERE `Name` = :name");
 
         auto result = d->mSelectMusicSource.prepare(selectMusicSourceQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectMusicSource.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectMusicSource.lastError();
         }
     }
 
     {
         auto selectTrackQueryText = QStringLiteral("SELECT "
                                                    "tracks.`ID`,  tracksMapping.`FileName` "
                                                    "FROM "
                                                    "`Tracks` tracks, `Artists` artist, `TracksArtists` trackArtist, "
                                                    "`TracksMapping` tracksMapping "
                                                    "WHERE "
                                                    "tracks.`Title` = :title AND "
                                                    "tracks.`AlbumID` = :album AND "
                                                    "artist.`Name` = :artist AND "
                                                    "tracks.`ID` = trackArtist.`TrackID` AND "
                                                    "artist.`ID` = trackArtist.`ArtistID` AND "
                                                    "tracksMapping.`TrackID` = tracks.`ID` AND "
                                                    "tracksMapping.`Priority` = (SELECT MIN(`Priority`) FROM `TracksMapping` WHERE `TrackID` = tracks.`ID`)");
 
         auto result = d->mSelectTrackIdFromTitleAlbumIdArtistQuery.prepare(selectTrackQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectTrackIdFromTitleAlbumIdArtistQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectTrackIdFromTitleAlbumIdArtistQuery.lastError();
         }
 
         auto insertTrackQueryText = QStringLiteral("INSERT INTO `Tracks` (`ID`, `Title`, `AlbumID`, `Genre`, `Composer`, `Lyricist`, `Comment`, `TrackNumber`, `DiscNumber`, `Channels`, `BitRate`, `SampleRate`, `Year`,  `Duration`, `Rating` ) "
                                                    "VALUES (:trackId, :title, :album, :genre, :composer, :lyricist, :comment, :trackNumber, :discNumber, :channels, :bitRate, :sampleRate, :year, :trackDuration, :trackRating)");
 
         result = d->mInsertTrackQuery.prepare(insertTrackQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mInsertTrackQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mInsertTrackQuery.lastError();
         }
     }
     {
         auto selectTrackQueryText = QStringLiteral("SELECT "
                                                    "tracks.ID "
                                                    "FROM "
                                                    "`Tracks` tracks, "
                                                    "`Albums` albums, "
                                                    "`TracksArtists` trackArtist, "
                                                    "`Artists` artist "
                                                    "WHERE "
                                                    "tracks.`Title` = :title AND "
                                                    "tracks.`AlbumID` = albums.`ID` AND "
                                                    "albums.`Title` = :album AND "
                                                    "tracks.`TrackNumber` = :trackNumber AND "
                                                    "tracks.`DiscNumber` = :discNumber AND "
                                                    "trackArtist.`TrackID` = tracks.`ID` AND "
                                                    "trackArtist.`ArtistID` = artist.`ID` AND "
                                                    "artist.`Name` = :artist");
 
         auto result = d->mSelectTrackIdFromTitleArtistAlbumTrackDiscNumberQuery.prepare(selectTrackQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectTrackIdFromTitleArtistAlbumTrackDiscNumberQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectTrackIdFromTitleArtistAlbumTrackDiscNumberQuery.lastError();
         }
     }
 
     {
         auto selectTrackQueryText = QStringLiteral("SELECT "
                                                    "tracks.ID "
                                                    "FROM "
                                                    "`Tracks` tracks, "
                                                    "`Albums` albums "
                                                    "WHERE "
                                                    "tracks.`Title` = :title AND "
                                                    "tracks.`AlbumID` = albums.`ID` AND "
                                                    "albums.`Title` = :album AND "
                                                    "tracks.`TrackNumber` = :trackNumber AND "
                                                    "tracks.`DiscNumber` = :discNumber AND "
                                                    "( "
                                                    "( NOT EXISTS (SELECT albumArtistMapping.`AlbumID` "
                                                    "FROM "
                                                    "`AlbumsArtists` albumArtistMapping "
                                                    "WHERE "
                                                    "albumArtistMapping.`AlbumID` = albums.`ID`) "
                                                    ") OR "
                                                    "( EXISTS (SELECT albumArtistMapping.`AlbumID` "
                                                    "FROM "
                                                    "`AlbumsArtists` albumArtistMapping, "
                                                    "`Artists` albumArtist "
                                                    "WHERE "
                                                    "albumArtist.`Name` = :albumArtist AND "
                                                    "albumArtist.`ID` = albumArtistMapping.`ArtistID` AND "
                                                    "albumArtistMapping.`AlbumID` = albums.`ID`) "
                                                    ") "
                                                    ")");
 
         auto result = d->mSelectTrackIdFromTitleAlbumTrackDiscNumberQuery.prepare(selectTrackQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectTrackIdFromTitleAlbumTrackDiscNumberQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectTrackIdFromTitleAlbumTrackDiscNumberQuery.lastError();
         }
     }
 
     {
         auto selectAlbumArtUriFromAlbumIdQueryText = QStringLiteral("SELECT `CoverFileName`"
                                                                     "FROM "
                                                                     "`Albums` "
                                                                     "WHERE "
                                                                     "`ID` = :albumId");
 
         auto result = d->mSelectAlbumArtUriFromAlbumIdQuery.prepare(selectAlbumArtUriFromAlbumIdQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectAlbumArtUriFromAlbumIdQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectAlbumArtUriFromAlbumIdQuery.lastError();
         }
     }
 
     {
         auto selectAlbumTrackCountQueryText = QStringLiteral("SELECT `TracksCount` "
                                                              "FROM `Albums`"
                                                              "WHERE "
                                                              "`ID` = :albumId");
 
         auto result = d->mSelectAlbumTrackCountQuery.prepare(selectAlbumTrackCountQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectAlbumTrackCountQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectAlbumTrackCountQuery.lastError();
         }
     }
     {
         auto updateAlbumQueryText = QStringLiteral("UPDATE `Albums` "
                                                    "SET `TracksCount` = (SELECT COUNT(*) FROM `Tracks` WHERE `AlbumID` = :albumId) "
                                                    "WHERE "
                                                    "`ID` = :albumId");
 
         auto result = d->mUpdateAlbumQuery.prepare(updateAlbumQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mUpdateAlbumQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mUpdateAlbumQuery.lastError();
         }
     }
 
     {
         auto updateIsSingleDiscAlbumFromIdQueryText = QStringLiteral("UPDATE `Albums` "
                                                                      "SET `IsSingleDiscAlbum` = (SELECT COUNT(DISTINCT DiscNumber) = 1 FROM `Tracks` WHERE `AlbumID` = :albumId) "
                                                                      "WHERE "
                                                                      "`ID` = :albumId");
 
         auto result = d->mUpdateIsSingleDiscAlbumFromIdQuery.prepare(updateIsSingleDiscAlbumFromIdQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mUpdateIsSingleDiscAlbumFromIdQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mUpdateIsSingleDiscAlbumFromIdQuery.lastError();
         }
     }
 
     {
         auto updateAlbumArtUriFromAlbumIdQueryText = QStringLiteral("UPDATE `Albums` "
                                                                     "SET `CoverFileName` = :coverFileName "
                                                                     "WHERE "
                                                                     "`ID` = :albumId");
 
         auto result = d->mUpdateAlbumArtUriFromAlbumIdQuery.prepare(updateAlbumArtUriFromAlbumIdQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mUpdateAlbumArtUriFromAlbumIdQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mUpdateAlbumArtUriFromAlbumIdQuery.lastError();
         }
     }
 
     {
         auto selectTracksFromArtistQueryText = QStringLiteral("SELECT "
                                                               "tracks.`ID`, "
                                                               "tracks.`Title`, "
                                                               "tracks.`AlbumID`, "
                                                               "artist.`Name`, "
                                                               "artistAlbum.`Name`, "
                                                               "tracksMapping.`FileName`, "
                                                               "tracks.`TrackNumber`, "
                                                               "tracks.`DiscNumber`, "
                                                               "tracks.`Duration`, "
                                                               "album.`Title`, "
                                                               "tracks.`Rating`, "
                                                               "album.`CoverFileName`, "
                                                               "album.`IsSingleDiscAlbum`, "
                                                               "tracks.`Genre`, "
                                                               "tracks.`Composer`, "
                                                               "tracks.`Lyricist`, "
                                                               "tracks.`Comment`, "
                                                               "tracks.`Year`, "
                                                               "tracks.`Channels`, "
                                                               "tracks.`BitRate`, "
                                                               "tracks.`SampleRate` "
                                                               "FROM `Tracks` tracks, `Albums` album, `Artists` artist, `TracksArtists` trackArtist, "
                                                               "`TracksMapping` tracksMapping "
                                                               "LEFT JOIN `AlbumsArtists` artistAlbumMapping ON artistAlbumMapping.`AlbumID` = album.`ID` "
                                                               "LEFT JOIN `Artists` artistAlbum ON artistAlbum.`ID` = artistAlbumMapping.`ArtistID` "
                                                               "WHERE "
                                                               "artist.`Name` = :artistName AND "
                                                               "tracks.`AlbumID` = album.`ID` AND "
                                                               "artist.`ID` = trackArtist.`ArtistID` AND "
                                                               "tracks.`ID` = trackArtist.`TrackID` AND "
                                                               "tracksMapping.`TrackID` = tracks.`ID` AND "
                                                               "tracksMapping.`Priority` = (SELECT MIN(`Priority`) FROM `TracksMapping` WHERE `TrackID` = tracks.`ID`) "
                                                               "ORDER BY tracks.`Title` ASC, "
                                                               "album.`Title` ASC");
 
         auto result = d->mSelectTracksFromArtist.prepare(selectTracksFromArtistQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectTracksFromArtist.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectTracksFromArtist.lastError();
         }
     }
 
     {
         auto selectAlbumIdsFromArtistQueryText = QStringLiteral("SELECT "
                                                                 "album.`ID` "
                                                                 "FROM "
                                                                 "`Albums` album, "
                                                                 "`Artists` artist,"
                                                                 "`AlbumsArtists` albumArtist "
                                                                 "WHERE "
                                                                 "album.`ID` = albumArtist.`AlbumID` AND "
                                                                 "artist.`ID` = albumArtist.`ArtistID` AND "
                                                                 "artist.`Name` = :artistName");
 
         auto result = d->mSelectAlbumIdsFromArtist.prepare(selectAlbumIdsFromArtistQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectAlbumIdsFromArtist.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectAlbumIdsFromArtist.lastError();
         }
     }
 
     {
         auto selectArtistQueryText = QStringLiteral("SELECT `ID`, "
                                                     "`Name` "
                                                     "FROM `Artists` "
                                                     "WHERE "
                                                     "`ID` = :artistId");
 
         auto result = d->mSelectArtistQuery.prepare(selectArtistQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectArtistQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectArtistQuery.lastError();
         }
     }
 
     {
         auto selectTrackFromFilePathQueryText = QStringLiteral("SELECT "
                                                                "tracks.`ID`, "
                                                                "tracks.`Title`, "
                                                                "tracks.`AlbumID`, "
                                                                "artist.`Name`, "
                                                                "artistAlbum.`Name`, "
                                                                "tracksMapping.`FileName`, "
                                                                "tracks.`TrackNumber`, "
                                                                "tracks.`DiscNumber`, "
                                                                "tracks.`Duration`, "
                                                                "album.`Title`, "
                                                                "tracks.`Rating`, "
                                                                "album.`CoverFileName`, "
                                                                "album.`IsSingleDiscAlbum`, "
                                                                "tracks.`Genre`, "
                                                                "tracks.`Composer`, "
                                                                "tracks.`Lyricist`, "
                                                                "tracks.`Comment`, "
                                                                "tracks.`Year`, "
                                                                "tracks.`Channels`, "
                                                                "tracks.`BitRate`, "
                                                                "tracks.`SampleRate` "
                                                                "FROM `Tracks` tracks, `Artists` artist, `Albums` album, `TracksArtists` trackArtist, "
                                                                "`TracksMapping` tracksMapping "
                                                                "LEFT JOIN `AlbumsArtists` artistAlbumMapping ON artistAlbumMapping.`AlbumID` = album.`ID` "
                                                                "LEFT JOIN `Artists` artistAlbum ON artistAlbum.`ID` = artistAlbumMapping.`ArtistID` "
                                                                "WHERE "
                                                                "tracks.`AlbumID` = album.`ID` AND "
                                                                "artist.`ID` = trackArtist.`ArtistID` AND "
                                                                "tracks.`ID` = trackArtist.`TrackID` AND "
                                                                "tracksMapping.`TrackID` = tracks.`ID` AND "
                                                                "tracksMapping.`FileName` = :filePath AND "
                                                                "tracksMapping.`Priority` = (SELECT MIN(`Priority`) FROM `TracksMapping` WHERE `TrackID` = tracks.`ID`)");
 
         auto result = d->mSelectTrackFromFilePathQuery.prepare(selectTrackFromFilePathQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectTrackFromFilePathQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mSelectTrackFromFilePathQuery.lastError();
         }
     }
 
     {
         auto removeTrackQueryText = QStringLiteral("DELETE FROM `Tracks` "
                                                    "WHERE "
                                                    "`ID` = :trackId");
 
         auto result = d->mRemoveTrackQuery.prepare(removeTrackQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mRemoveTrackQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mRemoveTrackQuery.lastError();
         }
     }
 
     {
         auto removeTrackArtistQueryText = QStringLiteral("DELETE FROM `TracksArtists` "
                                                          "WHERE "
                                                          "`TrackID` = :trackId");
 
         auto result = d->mRemoveTrackArtistQuery.prepare(removeTrackArtistQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mRemoveTrackArtistQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mRemoveTrackArtistQuery.lastError();
         }
     }
 
     {
         auto removeAlbumQueryText = QStringLiteral("DELETE FROM `Albums` "
                                                    "WHERE "
                                                    "`ID` = :albumId");
 
         auto result = d->mRemoveAlbumQuery.prepare(removeAlbumQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mRemoveAlbumQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mRemoveAlbumQuery.lastError();
         }
     }
 
     {
         auto removeAlbumArtistQueryText = QStringLiteral("DELETE FROM `AlbumsArtists` "
                                                          "WHERE "
                                                          "`AlbumID` = :albumId");
 
         auto result = d->mRemoveAlbumArtistQuery.prepare(removeAlbumArtistQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mRemoveAlbumArtistQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mRemoveAlbumArtistQuery.lastError();
         }
     }
 
     {
         auto removeAlbumQueryText = QStringLiteral("DELETE FROM `Artists` "
                                                    "WHERE "
                                                    "`ID` = :artistId");
 
         auto result = d->mRemoveArtistQuery.prepare(removeAlbumQueryText);
 
         if (!result) {
             qDebug() << "DatabaseInterface::initRequest" << d->mRemoveArtistQuery.lastQuery();
             qDebug() << "DatabaseInterface::initRequest" << d->mRemoveArtistQuery.lastError();
         }
     }
 
     transactionResult = finishTransaction();
 
     d->mInitFinished = true;
     Q_EMIT requestsInitDone();
 }
 
 qulonglong DatabaseInterface::insertAlbum(const QString &title, const QString &albumArtist, const QString &trackArtist,
                                           const QUrl &albumArtURI, int tracksCount, bool isSingleDiscAlbum,
                                           QList<qulonglong> &newAlbumIds)
 {
     auto result = qulonglong(0);
 
     if (title.isEmpty()) {
         return result;
     }
 
     if (!albumArtist.isEmpty() || !trackArtist.isEmpty()) {
         d->mSelectAlbumIdFromTitleAndArtistQuery.bindValue(QStringLiteral(":title"), title);
         if (!albumArtist.isEmpty()) {
             d->mSelectAlbumIdFromTitleAndArtistQuery.bindValue(QStringLiteral(":artistId"), insertArtist(albumArtist));
         } else {
             d->mSelectAlbumIdFromTitleAndArtistQuery.bindValue(QStringLiteral(":artistId"), insertArtist(trackArtist));
         }
 
         auto queryResult = d->mSelectAlbumIdFromTitleAndArtistQuery.exec();
 
         if (!queryResult || !d->mSelectAlbumIdFromTitleAndArtistQuery.isSelect() || !d->mSelectAlbumIdFromTitleAndArtistQuery.isActive()) {
             Q_EMIT databaseError();
 
             qDebug() << "DatabaseInterface::insertAlbum" << d->mSelectAlbumIdFromTitleAndArtistQuery.lastQuery();
             qDebug() << "DatabaseInterface::insertAlbum" << d->mSelectAlbumIdFromTitleAndArtistQuery.boundValues();
             qDebug() << "DatabaseInterface::insertAlbum" << d->mSelectAlbumIdFromTitleAndArtistQuery.lastError();
 
             d->mSelectAlbumIdFromTitleAndArtistQuery.finish();
 
             return result;
         }
 
         if (d->mSelectAlbumIdFromTitleAndArtistQuery.next()) {
             result = d->mSelectAlbumIdFromTitleAndArtistQuery.record().value(0).toULongLong();
 
             d->mSelectAlbumIdFromTitleAndArtistQuery.finish();
 
             return result;
         }
 
         d->mSelectAlbumIdFromTitleAndArtistQuery.finish();
     }
 
     if (result == 0) {
         d->mSelectAlbumIdFromTitleWithoutArtistQuery.bindValue(QStringLiteral(":title"), title);
 
         auto queryResult = d->mSelectAlbumIdFromTitleWithoutArtistQuery.exec();
 
         if (!queryResult || !d->mSelectAlbumIdFromTitleWithoutArtistQuery.isSelect() || !d->mSelectAlbumIdFromTitleWithoutArtistQuery.isActive()) {
             Q_EMIT databaseError();
 
             qDebug() << "DatabaseInterface::insertAlbum" << d->mSelectAlbumIdFromTitleWithoutArtistQuery.lastQuery();
             qDebug() << "DatabaseInterface::insertAlbum" << d->mSelectAlbumIdFromTitleWithoutArtistQuery.boundValues();
             qDebug() << "DatabaseInterface::insertAlbum" << d->mSelectAlbumIdFromTitleWithoutArtistQuery.lastError();
 
             d->mSelectAlbumIdFromTitleWithoutArtistQuery.finish();
 
             return result;
         }
 
         if (d->mSelectAlbumIdFromTitleWithoutArtistQuery.next()) {
             result = d->mSelectAlbumIdFromTitleWithoutArtistQuery.record().value(0).toULongLong();
 
             d->mSelectAlbumIdFromTitleWithoutArtistQuery.finish();
 
             return result;
         }
 
         d->mSelectAlbumIdFromTitleWithoutArtistQuery.finish();
     }
 
     d->mInsertAlbumQuery.bindValue(QStringLiteral(":albumId"), d->mAlbumId);
     d->mInsertAlbumQuery.bindValue(QStringLiteral(":title"), title);
     d->mInsertAlbumQuery.bindValue(QStringLiteral(":coverFileName"), albumArtURI);
     d->mInsertAlbumQuery.bindValue(QStringLiteral(":tracksCount"), tracksCount);
     d->mInsertAlbumQuery.bindValue(QStringLiteral(":isSingleDiscAlbum"), isSingleDiscAlbum);
 
     auto queryResult = d->mInsertAlbumQuery.exec();
 
     if (!queryResult || !d->mInsertAlbumQuery.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::insertAlbum" << d->mInsertAlbumQuery.lastQuery();
         qDebug() << "DatabaseInterface::insertAlbum" << d->mInsertAlbumQuery.boundValues();
         qDebug() << "DatabaseInterface::insertAlbum" << d->mInsertAlbumQuery.lastError();
 
         d->mInsertAlbumQuery.finish();
 
         return result;
     }
 
     result = d->mAlbumId;
 
     d->mInsertAlbumQuery.finish();
 
     if (!albumArtist.isEmpty()) {
         d->mInsertAlbumArtistQuery.bindValue(QStringLiteral(":albumId"), d->mAlbumId);
         d->mInsertAlbumArtistQuery.bindValue(QStringLiteral(":artistId"), insertArtist(albumArtist));
 
         queryResult = d->mInsertAlbumArtistQuery.exec();
 
         if (!queryResult || !d->mInsertAlbumArtistQuery.isActive()) {
             Q_EMIT databaseError();
 
             qDebug() << "DatabaseInterface::insertAlbum" << d->mInsertAlbumArtistQuery.lastQuery();
             qDebug() << "DatabaseInterface::insertAlbum" << d->mInsertAlbumArtistQuery.boundValues();
             qDebug() << "DatabaseInterface::insertAlbum" << d->mInsertAlbumArtistQuery.lastError();
 
             d->mInsertAlbumArtistQuery.finish();
 
             return result;
         }
 
         d->mInsertAlbumArtistQuery.finish();
     }
 
     ++d->mAlbumId;
 
     newAlbumIds.push_back(result);
 
     return result;
 }
 
 bool DatabaseInterface::updateAlbumFromId(qulonglong albumId, const QUrl &albumArtUri, const MusicAudioTrack &currentTrack)
 {
     auto modifiedAlbum = false;
 
     d->mUpdateIsSingleDiscAlbumFromIdQuery.bindValue(QStringLiteral(":albumId"), albumId);
 
     auto result = d->mUpdateIsSingleDiscAlbumFromIdQuery.exec();
 
     if (!result || !d->mUpdateIsSingleDiscAlbumFromIdQuery.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::updateIsSingleDiscAlbumFromId" << d->mUpdateIsSingleDiscAlbumFromIdQuery.lastQuery();
         qDebug() << "DatabaseInterface::updateIsSingleDiscAlbumFromId" << d->mUpdateIsSingleDiscAlbumFromIdQuery.boundValues();
         qDebug() << "DatabaseInterface::updateIsSingleDiscAlbumFromId" << d->mUpdateIsSingleDiscAlbumFromIdQuery.lastError();
 
         d->mUpdateIsSingleDiscAlbumFromIdQuery.finish();
 
         return modifiedAlbum;
     }
 
     modifiedAlbum = (d->mUpdateIsSingleDiscAlbumFromIdQuery.numRowsAffected() != 0);
     d->mUpdateIsSingleDiscAlbumFromIdQuery.finish();
 
     if (!albumArtUri.isValid()) {
         return modifiedAlbum;
     }
 
     auto storedAlbumArtUri = internalAlbumArtUriFromAlbumId(albumId);
 
     if (!storedAlbumArtUri.isValid() || storedAlbumArtUri == albumArtUri) {
         d->mUpdateAlbumArtUriFromAlbumIdQuery.bindValue(QStringLiteral(":albumId"), albumId);
         d->mUpdateAlbumArtUriFromAlbumIdQuery.bindValue(QStringLiteral(":coverFileName"), albumArtUri);
 
         result = d->mUpdateAlbumArtUriFromAlbumIdQuery.exec();
 
         if (!result || !d->mUpdateAlbumArtUriFromAlbumIdQuery.isActive()) {
             Q_EMIT databaseError();
 
             qDebug() << "DatabaseInterface::updateIsSingleDiscAlbumFromId" << d->mUpdateAlbumArtUriFromAlbumIdQuery.lastQuery();
             qDebug() << "DatabaseInterface::updateIsSingleDiscAlbumFromId" << d->mUpdateAlbumArtUriFromAlbumIdQuery.boundValues();
             qDebug() << "DatabaseInterface::updateIsSingleDiscAlbumFromId" << d->mUpdateAlbumArtUriFromAlbumIdQuery.lastError();
 
             d->mUpdateAlbumArtUriFromAlbumIdQuery.finish();
 
             return modifiedAlbum;
         }
 
         d->mUpdateAlbumArtUriFromAlbumIdQuery.finish();
 
         modifiedAlbum = true;
     }
 
     if (!isValidArtist(albumId) && currentTrack.isValidAlbumArtist()) {
         d->mRemoveAlbumArtistQuery.bindValue(QStringLiteral(":albumId"), albumId);
 
         result = d->mRemoveAlbumArtistQuery.exec();
 
         if (!result || !d->mRemoveAlbumArtistQuery.isActive()) {
             Q_EMIT databaseError();
 
             qDebug() << "DatabaseInterface::updateIsSingleDiscAlbumFromId" << d->mRemoveAlbumArtistQuery.lastQuery();
             qDebug() << "DatabaseInterface::updateIsSingleDiscAlbumFromId" << d->mRemoveAlbumArtistQuery.boundValues();
             qDebug() << "DatabaseInterface::updateIsSingleDiscAlbumFromId" << d->mRemoveAlbumArtistQuery.lastError();
 
             d->mRemoveAlbumArtistQuery.finish();
 
             return modifiedAlbum;
         }
 
         d->mRemoveAlbumArtistQuery.finish();
 
         d->mInsertAlbumArtistQuery.bindValue(QStringLiteral(":albumId"), albumId);
         d->mInsertAlbumArtistQuery.bindValue(QStringLiteral(":artistId"), insertArtist(currentTrack.albumArtist()));
 
         result = d->mInsertAlbumArtistQuery.exec();
 
         if (!result || !d->mInsertAlbumArtistQuery.isActive()) {
             Q_EMIT databaseError();
 
             qDebug() << "DatabaseInterface::updateIsSingleDiscAlbumFromId" << d->mInsertAlbumArtistQuery.lastQuery();
             qDebug() << "DatabaseInterface::updateIsSingleDiscAlbumFromId" << d->mInsertAlbumArtistQuery.boundValues();
             qDebug() << "DatabaseInterface::updateIsSingleDiscAlbumFromId" << d->mInsertAlbumArtistQuery.lastError();
 
             d->mInsertAlbumArtistQuery.finish();
 
             return modifiedAlbum;
         }
 
         d->mInsertAlbumArtistQuery.finish();
 
         modifiedAlbum = true;
     }
 
     return modifiedAlbum;
 }
 
 qulonglong DatabaseInterface::insertArtist(const QString &name)
 {
     auto result = qulonglong(0);
 
     if (name.isEmpty()) {
         return result;
     }
 
     d->mSelectArtistByNameQuery.bindValue(QStringLiteral(":name"), name);
 
     auto queryResult = d->mSelectArtistByNameQuery.exec();
 
     if (!queryResult || !d->mSelectArtistByNameQuery.isSelect() || !d->mSelectArtistByNameQuery.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::insertArtist" << d->mSelectArtistByNameQuery.lastQuery();
         qDebug() << "DatabaseInterface::insertArtist" << d->mSelectArtistByNameQuery.boundValues();
         qDebug() << "DatabaseInterface::insertArtist" << d->mSelectArtistByNameQuery.lastError();
 
         d->mSelectArtistByNameQuery.finish();
 
         return result;
     }
 
     if (d->mSelectArtistByNameQuery.next()) {
         result = d->mSelectArtistByNameQuery.record().value(0).toULongLong();
 
         d->mSelectArtistByNameQuery.finish();
 
         return result;
     }
 
     d->mSelectArtistByNameQuery.finish();
 
     d->mInsertArtistsQuery.bindValue(QStringLiteral(":artistId"), d->mArtistId);
     d->mInsertArtistsQuery.bindValue(QStringLiteral(":name"), name);
 
     queryResult = d->mInsertArtistsQuery.exec();
 
     if (!queryResult || !d->mInsertArtistsQuery.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::insertArtist" << d->mInsertArtistsQuery.lastQuery();
         qDebug() << "DatabaseInterface::insertArtist" << d->mInsertArtistsQuery.boundValues();
         qDebug() << "DatabaseInterface::insertArtist" << d->mInsertArtistsQuery.lastError();
 
         d->mInsertArtistsQuery.finish();
 
         return result;
     }
 
     result = d->mArtistId;
 
     ++d->mArtistId;
 
     d->mInsertArtistsQuery.finish();
 
     Q_EMIT artistAdded(internalArtistFromId(d->mArtistId - 1));
 
     return result;
 }
 
 void DatabaseInterface::insertTrackOrigin(const QUrl &fileNameURI, qulonglong discoverId)
 {
     d->mInsertTrackMapping.bindValue(QStringLiteral(":discoverId"), discoverId);
     d->mInsertTrackMapping.bindValue(QStringLiteral(":fileName"), fileNameURI);
     d->mInsertTrackMapping.bindValue(QStringLiteral(":priority"), 1);
 
     auto queryResult = d->mInsertTrackMapping.exec();
 
     if (!queryResult || !d->mInsertTrackMapping.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::insertArtist" << d->mInsertTrackMapping.lastQuery();
         qDebug() << "DatabaseInterface::insertArtist" << d->mInsertTrackMapping.boundValues();
         qDebug() << "DatabaseInterface::insertArtist" << d->mInsertTrackMapping.lastError();
 
         d->mInsertTrackMapping.finish();
 
         return;
     }
 
     d->mInsertTrackMapping.finish();
 }
 
 void DatabaseInterface::updateTrackOrigin(qulonglong trackId, const QUrl &fileName)
 {
     d->mUpdateTrackMapping.bindValue(QStringLiteral(":trackId"), trackId);
     d->mUpdateTrackMapping.bindValue(QStringLiteral(":fileName"), fileName);
     d->mUpdateTrackMapping.bindValue(QStringLiteral(":priority"), computeTrackPriority(trackId, fileName));
 
     auto queryResult = d->mUpdateTrackMapping.exec();
 
     if (!queryResult || !d->mUpdateTrackMapping.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::updateTrackOrigin" << d->mUpdateTrackMapping.lastQuery();
         qDebug() << "DatabaseInterface::updateTrackOrigin" << d->mUpdateTrackMapping.boundValues();
         qDebug() << "DatabaseInterface::updateTrackOrigin" << d->mUpdateTrackMapping.lastError();
 
         d->mUpdateTrackMapping.finish();
 
         return;
     }
 
     d->mInsertTrackMapping.finish();
 }
 
 int DatabaseInterface::computeTrackPriority(qulonglong trackId, const QUrl &fileName)
 {
     auto result = int(1);
 
     if (!d) {
         return result;
     }
 
     d->mSelectTracksMappingPriority.bindValue(QStringLiteral(":trackId"), trackId);
     d->mSelectTracksMappingPriority.bindValue(QStringLiteral(":fileName"), fileName);
 
     auto queryResult = d->mSelectTracksMappingPriority.exec();
 
     if (!queryResult || !d->mSelectTracksMappingPriority.isSelect() || !d->mSelectTracksMappingPriority.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::internalTrackIdFromFileName" << d->mSelectTracksMappingPriority.lastQuery();
         qDebug() << "DatabaseInterface::internalTrackIdFromFileName" << d->mSelectTracksMappingPriority.boundValues();
         qDebug() << "DatabaseInterface::internalTrackIdFromFileName" << d->mSelectTracksMappingPriority.lastError();
 
         d->mSelectTracksMappingPriority.finish();
 
         return result;
     }
 
     if (d->mSelectTracksMappingPriority.next()) {
         result = d->mSelectTracksMappingPriority.record().value(0).toInt();
 
         d->mSelectTracksMappingPriority.finish();
 
         return result;
     }
 
     d->mSelectTracksMappingPriority.finish();
 
     d->mSelectTracksMappingPriorityByTrackId.bindValue(QStringLiteral(":trackId"), trackId);
 
     queryResult = d->mSelectTracksMappingPriorityByTrackId.exec();
 
     if (!queryResult || !d->mSelectTracksMappingPriorityByTrackId.isSelect() || !d->mSelectTracksMappingPriorityByTrackId.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::internalTrackIdFromFileName" << d->mSelectTracksMappingPriorityByTrackId.lastQuery();
         qDebug() << "DatabaseInterface::internalTrackIdFromFileName" << d->mSelectTracksMappingPriorityByTrackId.boundValues();
         qDebug() << "DatabaseInterface::internalTrackIdFromFileName" << d->mSelectTracksMappingPriorityByTrackId.lastError();
 
         d->mSelectTracksMappingPriorityByTrackId.finish();
 
         return result;
     }
 
     if (d->mSelectTracksMappingPriorityByTrackId.next()) {
         result = d->mSelectTracksMappingPriorityByTrackId.record().value(0).toInt() + 1;
     }
 
     d->mSelectTracksMappingPriorityByTrackId.finish();
 
     return result;
 }
 
 qulonglong DatabaseInterface::internalInsertTrack(const MusicAudioTrack &oneTrack, const QHash<QString, QUrl> &covers,
-                                                  int originTrackId, QSet<qulonglong> &modifiedAlbumIds, TrackFileInsertType insertType,
+                                                  qulonglong originTrackId, QSet<qulonglong> &modifiedAlbumIds, TrackFileInsertType insertType,
                                                   QList<qulonglong> &newAlbumIds)
 {
     qulonglong resultId = 0;
 
     if (oneTrack.albumArtist().isEmpty()) {
         return resultId;
     }
 
     auto albumId = insertAlbum(oneTrack.albumName(), (oneTrack.isValidAlbumArtist() ? oneTrack.albumArtist() : QString()),
                                oneTrack.artist(), covers[oneTrack.resourceURI().toString()], 0, true, newAlbumIds);
 
     if (albumId == 0) {
         return resultId;
     }
 
     auto otherTrackId = getDuplicateTrackIdFromTitleAlbumTracDiscNumber(oneTrack.title(), oneTrack.albumName(), oneTrack.albumArtist(),
                                                                         oneTrack.trackNumber(), oneTrack.discNumber());
     bool isModifiedTrack = (otherTrackId != 0) || (insertType == TrackFileInsertType::ModifiedTrackFileInsert);
     bool isSameTrack = false;
 
     qulonglong oldAlbumId = 0;
 
     if (isModifiedTrack) {
         if (otherTrackId == 0) {
             otherTrackId = internalTrackIdFromFileName(oneTrack.resourceURI());
         }
 
         originTrackId = otherTrackId;
 
         const auto &oldTrack = internalTrackFromDatabaseId(originTrackId);
 
         isSameTrack = (oldTrack.title() == oneTrack.title());
         isSameTrack = isSameTrack && (oldTrack.albumName() == oneTrack.albumName());
         isSameTrack = isSameTrack && (oldTrack.artist() == oneTrack.artist());
         isSameTrack = isSameTrack && (oldTrack.trackNumber() == oneTrack.trackNumber());
         isSameTrack = isSameTrack && (oldTrack.discNumber() == oneTrack.discNumber());
         isSameTrack = isSameTrack && (oldTrack.duration() == oneTrack.duration());
         isSameTrack = isSameTrack && (oldTrack.rating() == oneTrack.rating());
         isSameTrack = isSameTrack && (oldTrack.resourceURI() == oneTrack.resourceURI());
         isSameTrack = isSameTrack && (oldTrack.genre() == oneTrack.genre());
         isSameTrack = isSameTrack && (oldTrack.composer() == oneTrack.composer());
         isSameTrack = isSameTrack && (oldTrack.lyricist() == oneTrack.lyricist());
         isSameTrack = isSameTrack && (oldTrack.comment() == oneTrack.comment());
         isSameTrack = isSameTrack && (oldTrack.year() == oneTrack.year());
         isSameTrack = isSameTrack && (oldTrack.channels() == oneTrack.channels());
         isSameTrack = isSameTrack && (oldTrack.bitRate() == oneTrack.bitRate());
         isSameTrack = isSameTrack && (oldTrack.sampleRate() == oneTrack.sampleRate());
 
 
         oldAlbumId = internalAlbumIdFromTitleAndArtist(oldTrack.albumName(), oldTrack.albumArtist());
 
         if (!isSameTrack) {
             removeTrackInDatabase(originTrackId);
         }
     } else {
         originTrackId = d->mTrackId;
     }
 
     resultId = originTrackId;
 
     if (!isSameTrack) {
         d->mInsertTrackQuery.bindValue(QStringLiteral(":trackId"), originTrackId);
         d->mInsertTrackQuery.bindValue(QStringLiteral(":title"), oneTrack.title());
         d->mInsertTrackQuery.bindValue(QStringLiteral(":album"), albumId);
         d->mInsertTrackQuery.bindValue(QStringLiteral(":trackNumber"), oneTrack.trackNumber());
         d->mInsertTrackQuery.bindValue(QStringLiteral(":discNumber"), oneTrack.discNumber());
         d->mInsertTrackQuery.bindValue(QStringLiteral(":trackDuration"), QVariant::fromValue<qlonglong>(oneTrack.duration().msecsSinceStartOfDay()));
         d->mInsertTrackQuery.bindValue(QStringLiteral(":trackRating"), oneTrack.rating());
         d->mInsertTrackQuery.bindValue(QStringLiteral(":genre"), oneTrack.genre());
         d->mInsertTrackQuery.bindValue(QStringLiteral(":composer"), oneTrack.composer());
         d->mInsertTrackQuery.bindValue(QStringLiteral(":lyricist"), oneTrack.lyricist());
         d->mInsertTrackQuery.bindValue(QStringLiteral(":comment"), oneTrack.comment());
         d->mInsertTrackQuery.bindValue(QStringLiteral(":year"), oneTrack.year());
         d->mInsertTrackQuery.bindValue(QStringLiteral(":channels"), oneTrack.channels());
         d->mInsertTrackQuery.bindValue(QStringLiteral(":bitRate"), oneTrack.bitRate());
         d->mInsertTrackQuery.bindValue(QStringLiteral(":sampleRate"), oneTrack.sampleRate());
 
         auto result = d->mInsertTrackQuery.exec();
 
         if (result && d->mInsertTrackQuery.isActive()) {
             d->mInsertTrackQuery.finish();
 
             d->mInsertTrackArtistQuery.bindValue(QStringLiteral(":trackId"), originTrackId);
             d->mInsertTrackArtistQuery.bindValue(QStringLiteral(":artistId"), insertArtist(oneTrack.artist()));
 
             result = d->mInsertTrackArtistQuery.exec();
 
             if (!result || !d->mInsertTrackArtistQuery.isActive()) {
                 Q_EMIT databaseError();
 
                 qDebug() << "DatabaseInterface::internalInsertTrack" << d->mInsertTrackArtistQuery.lastQuery();
                 qDebug() << "DatabaseInterface::internalInsertTrack" << d->mInsertTrackArtistQuery.boundValues();
                 qDebug() << "DatabaseInterface::internalInsertTrack" << d->mInsertTrackArtistQuery.lastError();
 
                 d->mInsertTrackArtistQuery.finish();
 
                 return resultId;
             }
 
             d->mInsertTrackArtistQuery.finish();
 
 
             if (!isModifiedTrack) {
                 ++d->mTrackId;
             }
 
             updateTrackOrigin(originTrackId, oneTrack.resourceURI());
 
             if (isModifiedTrack) {
                 Q_EMIT trackModified(internalTrackFromDatabaseId(originTrackId));
                 modifiedAlbumIds.insert(albumId);
                 if (oldAlbumId != 0) {
                     modifiedAlbumIds.insert(oldAlbumId);
                 }
             } else {
                 Q_EMIT trackAdded(originTrackId);
             }
 
             if (updateAlbumFromId(albumId, covers[oneTrack.resourceURI().toString()], oneTrack)) {
                 modifiedAlbumIds.insert(albumId);
             }
 
             if (updateTracksCount(albumId)) {
                 modifiedAlbumIds.insert(albumId);
             }
         } else {
             d->mInsertTrackQuery.finish();
 
             Q_EMIT databaseError();
 
             qDebug() << "DatabaseInterface::internalInsertTrack" << oneTrack << oneTrack.resourceURI();
             qDebug() << "DatabaseInterface::internalInsertTrack" << d->mInsertTrackQuery.lastQuery();
             qDebug() << "DatabaseInterface::internalInsertTrack" << d->mInsertTrackQuery.boundValues();
             qDebug() << "DatabaseInterface::internalInsertTrack" << d->mInsertTrackQuery.lastError();
         }
     }
 
     return resultId;
 }
 
 MusicAudioTrack DatabaseInterface::buildTrackFromDatabaseRecord(const QSqlRecord &trackRecord) const
 {
     auto result = MusicAudioTrack();
 
     result.setDatabaseId(trackRecord.value(0).toULongLong());
     result.setTitle(trackRecord.value(1).toString());
     result.setParentId(trackRecord.value(2).toString());
     result.setArtist(trackRecord.value(3).toString());
 
     if (trackRecord.value(4).isValid()) {
         result.setAlbumArtist(trackRecord.value(4).toString());
     }
 
     result.setResourceURI(trackRecord.value(5).toUrl());
     result.setTrackNumber(trackRecord.value(6).toInt());
     result.setDiscNumber(trackRecord.value(7).toInt());
     result.setDuration(QTime::fromMSecsSinceStartOfDay(trackRecord.value(8).toInt()));
     result.setAlbumName(trackRecord.value(9).toString());
     result.setRating(trackRecord.value(10).toInt());
     result.setAlbumCover(trackRecord.value(11).toUrl());
     result.setIsSingleDiscAlbum(trackRecord.value(12).toBool());
     result.setGenre(trackRecord.value(13).toString());
     result.setComposer(trackRecord.value(14).toString());
     result.setLyricist(trackRecord.value(15).toString());
     result.setComment(trackRecord.value(16).toString());
     result.setYear(trackRecord.value(17).toInt());
     result.setChannels(trackRecord.value(18).toInt());
     result.setBitRate(trackRecord.value(19).toInt());
     result.setSampleRate(trackRecord.value(20).toInt());
 
     result.setValid(true);
 
     return result;
 }
 
 void DatabaseInterface::internalRemoveTracksList(const QList<QUrl> &removedTracks)
 {
     for (const auto &removedTrackFileName : removedTracks) {
         d->mRemoveTracksMapping.bindValue(QStringLiteral(":fileName"), removedTrackFileName.toString());
 
         auto result = d->mRemoveTracksMapping.exec();
 
         if (!result || !d->mRemoveTracksMapping.isActive()) {
             Q_EMIT databaseError();
 
             qDebug() << "DatabaseInterface::internalRemoveTracksList" << d->mRemoveTracksMapping.lastQuery();
             qDebug() << "DatabaseInterface::internalRemoveTracksList" << d->mRemoveTracksMapping.boundValues();
             qDebug() << "DatabaseInterface::internalRemoveTracksList" << d->mRemoveTracksMapping.lastError();
 
             continue;
         }
 
         d->mRemoveTracksMapping.finish();
     }
 
     internalRemoveTracksWithoutMapping();
 }
 
 void DatabaseInterface::internalRemoveTracksList(const QList<QUrl> &removedTracks, qulonglong sourceId)
 {
     for (const auto &removedTrackFileName : removedTracks) {
         d->mRemoveTracksMappingFromSource.bindValue(QStringLiteral(":fileName"), removedTrackFileName.toString());
         d->mRemoveTracksMappingFromSource.bindValue(QStringLiteral(":sourceId"), sourceId);
 
         auto result = d->mRemoveTracksMappingFromSource.exec();
 
         if (!result || !d->mRemoveTracksMappingFromSource.isActive()) {
             Q_EMIT databaseError();
 
             qDebug() << "DatabaseInterface::removeTracksList" << d->mRemoveTracksMappingFromSource.lastQuery();
             qDebug() << "DatabaseInterface::removeTracksList" << d->mRemoveTracksMappingFromSource.boundValues();
             qDebug() << "DatabaseInterface::removeTracksList" << d->mRemoveTracksMappingFromSource.lastError();
 
             continue;
         }
 
         d->mRemoveTracksMappingFromSource.finish();
     }
 
     internalRemoveTracksWithoutMapping();
 }
 
 void DatabaseInterface::internalRemoveTracksWithoutMapping()
 {
     auto queryResult = d->mSelectTracksWithoutMappingQuery.exec();
 
     if (!queryResult || !d->mSelectTracksWithoutMappingQuery.isSelect() || !d->mSelectTracksWithoutMappingQuery.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::insertArtist" << d->mSelectTracksWithoutMappingQuery.lastQuery();
         qDebug() << "DatabaseInterface::insertArtist" << d->mSelectTracksWithoutMappingQuery.boundValues();
         qDebug() << "DatabaseInterface::insertArtist" << d->mSelectTracksWithoutMappingQuery.lastError();
 
         d->mSelectTracksWithoutMappingQuery.finish();
 
         return;
     }
 
     QList<MusicAudioTrack> willRemoveTrack;
 
     while (d->mSelectTracksWithoutMappingQuery.next()) {
         const auto &currentRecord = d->mSelectTracksWithoutMappingQuery.record();
 
         willRemoveTrack.push_back(buildTrackFromDatabaseRecord(currentRecord));
     }
 
     d->mSelectTracksWithoutMappingQuery.finish();
 
     QSet<qulonglong> modifiedAlbums;
 
     for (const auto &oneRemovedTrack : willRemoveTrack) {
         removeTrackInDatabase(oneRemovedTrack.databaseId());
 
         Q_EMIT trackRemoved(oneRemovedTrack.databaseId());
 
         const auto &modifiedAlbumId = internalAlbumIdFromTitleAndArtist(oneRemovedTrack.albumName(), oneRemovedTrack.albumArtist());
         const auto &allTracksFromArtist = internalTracksFromAuthor(oneRemovedTrack.artist());
         const auto &allAlbumsFromArtist = internalAlbumIdsFromAuthor(oneRemovedTrack.artist());
         const auto &removedArtistId = internalArtistIdFromName(oneRemovedTrack.artist());
         const auto &removedArtist = internalArtistFromId(removedArtistId);
 
         if (updateTracksCount(modifiedAlbumId)) {
             modifiedAlbums.insert(modifiedAlbumId);
         }
         updateAlbumFromId(modifiedAlbumId, oneRemovedTrack.albumCover(), oneRemovedTrack);
 
         if (allTracksFromArtist.isEmpty() && allAlbumsFromArtist.isEmpty()) {
             removeArtistInDatabase(removedArtistId);
             Q_EMIT artistRemoved(removedArtist);
         }
     }
 
     for (auto modifiedAlbumId : modifiedAlbums) {
         auto modifiedAlbum = internalAlbumFromId(modifiedAlbumId);
 
         if (modifiedAlbum.isValid() && !modifiedAlbum.isEmpty()) {
             Q_EMIT albumModified(modifiedAlbum, modifiedAlbumId);
         } else {
             removeAlbumInDatabase(modifiedAlbum.databaseId());
             Q_EMIT albumRemoved(modifiedAlbum, modifiedAlbumId);
 
             const auto &allTracksFromArtist = internalTracksFromAuthor(modifiedAlbum.artist());
             const auto &allAlbumsFromArtist = internalAlbumIdsFromAuthor(modifiedAlbum.artist());
             const auto &removedArtistId = internalArtistIdFromName(modifiedAlbum.artist());
             const auto &removedArtist = internalArtistFromId(removedArtistId);
 
             if (allTracksFromArtist.isEmpty() && allAlbumsFromArtist.isEmpty()) {
                 removeArtistInDatabase(removedArtistId);
                 Q_EMIT artistRemoved(removedArtist);
             }
         }
     }
 }
 
 QUrl DatabaseInterface::internalAlbumArtUriFromAlbumId(qulonglong albumId)
 {
     auto result = QUrl();
 
     d->mSelectAlbumArtUriFromAlbumIdQuery.bindValue(QStringLiteral(":albumId"), albumId);
 
     auto queryResult = d->mSelectAlbumArtUriFromAlbumIdQuery.exec();
 
     if (!queryResult || !d->mSelectAlbumArtUriFromAlbumIdQuery.isSelect() || !d->mSelectAlbumArtUriFromAlbumIdQuery.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::insertArtist" << d->mSelectAlbumArtUriFromAlbumIdQuery.lastQuery();
         qDebug() << "DatabaseInterface::insertArtist" << d->mSelectAlbumArtUriFromAlbumIdQuery.boundValues();
         qDebug() << "DatabaseInterface::insertArtist" << d->mSelectAlbumArtUriFromAlbumIdQuery.lastError();
 
         d->mSelectAlbumArtUriFromAlbumIdQuery.finish();
 
         return result;
     }
 
     if (!d->mSelectAlbumArtUriFromAlbumIdQuery.next()) {
         d->mSelectAlbumArtUriFromAlbumIdQuery.finish();
 
         return result;
     }
 
     result = d->mSelectAlbumArtUriFromAlbumIdQuery.record().value(0).toUrl();
 
     d->mSelectAlbumArtUriFromAlbumIdQuery.finish();
 
     return result;
 }
 
 bool DatabaseInterface::isValidArtist(qulonglong albumId)
 {
     auto result = false;
 
     d->mSelectAlbumQuery.bindValue(QStringLiteral(":albumId"), albumId);
 
     auto queryResult = d->mSelectAlbumQuery.exec();
 
     if (!queryResult || !d->mSelectAlbumQuery.isSelect() || !d->mSelectAlbumQuery.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::internalAlbumFromId" << d->mSelectAlbumQuery.lastQuery();
         qDebug() << "DatabaseInterface::internalAlbumFromId" << d->mSelectAlbumQuery.boundValues();
         qDebug() << "DatabaseInterface::internalAlbumFromId" << d->mSelectAlbumQuery.lastError();
 
         d->mSelectAlbumQuery.finish();
 
         return result;
     }
 
     if (!d->mSelectAlbumQuery.next()) {
         d->mSelectAlbumQuery.finish();
 
         return result;
     }
 
     const auto &currentRecord = d->mSelectAlbumQuery.record();
 
     result = !currentRecord.value(3).toString().isEmpty();
 
     return result;
 }
 
 qulonglong DatabaseInterface::internalArtistIdFromName(const QString &name)
 {
     auto result = qulonglong(0);
 
     if (name.isEmpty()) {
         return result;
     }
 
     d->mSelectArtistByNameQuery.bindValue(QStringLiteral(":name"), name);
 
     auto queryResult = d->mSelectArtistByNameQuery.exec();
 
     if (!queryResult || !d->mSelectArtistByNameQuery.isSelect() || !d->mSelectArtistByNameQuery.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::insertArtist" << d->mSelectArtistByNameQuery.lastQuery();
         qDebug() << "DatabaseInterface::insertArtist" << d->mSelectArtistByNameQuery.boundValues();
         qDebug() << "DatabaseInterface::insertArtist" << d->mSelectArtistByNameQuery.lastError();
 
         d->mSelectArtistByNameQuery.finish();
 
         return result;
     }
 
     if (!d->mSelectArtistByNameQuery.next()) {
         d->mSelectArtistByNameQuery.finish();
 
         return result;
     }
 
     result = d->mSelectArtistByNameQuery.record().value(0).toULongLong();
 
     d->mSelectArtistByNameQuery.finish();
 
     return result;
 }
 
 void DatabaseInterface::removeTrackInDatabase(qulonglong trackId)
 {
     d->mRemoveTrackArtistQuery.bindValue(QStringLiteral(":trackId"), trackId);
 
     auto result = d->mRemoveTrackArtistQuery.exec();
 
     if (!result || !d->mRemoveTrackArtistQuery.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::removeTrackInDatabase" << d->mRemoveTrackArtistQuery.lastQuery();
         qDebug() << "DatabaseInterface::removeTrackInDatabase" << d->mRemoveTrackArtistQuery.boundValues();
         qDebug() << "DatabaseInterface::removeTrackInDatabase" << d->mRemoveTrackArtistQuery.lastError();
     }
 
     d->mRemoveTrackArtistQuery.finish();
 
     d->mRemoveTrackQuery.bindValue(QStringLiteral(":trackId"), trackId);
 
     result = d->mRemoveTrackQuery.exec();
 
     if (!result || !d->mRemoveTrackQuery.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::removeTrackInDatabase" << d->mRemoveTrackQuery.lastQuery();
         qDebug() << "DatabaseInterface::removeTrackInDatabase" << d->mRemoveTrackQuery.boundValues();
         qDebug() << "DatabaseInterface::removeTrackInDatabase" << d->mRemoveTrackQuery.lastError();
     }
 
     d->mRemoveTrackQuery.finish();
 }
 
 void DatabaseInterface::removeAlbumInDatabase(qulonglong albumId)
 {
     d->mRemoveAlbumArtistQuery.bindValue(QStringLiteral(":albumId"), albumId);
 
     auto result = d->mRemoveAlbumArtistQuery.exec();
 
     if (!result || !d->mRemoveAlbumArtistQuery.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::removeAlbumInDatabase" << d->mRemoveAlbumArtistQuery.lastQuery();
         qDebug() << "DatabaseInterface::removeAlbumInDatabase" << d->mRemoveAlbumArtistQuery.boundValues();
         qDebug() << "DatabaseInterface::removeAlbumInDatabase" << d->mRemoveAlbumArtistQuery.lastError();
     }
 
     d->mRemoveAlbumArtistQuery.finish();
 
     d->mRemoveAlbumQuery.bindValue(QStringLiteral(":albumId"), albumId);
 
     result = d->mRemoveAlbumQuery.exec();
 
     if (!result || !d->mRemoveAlbumQuery.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::removeAlbumInDatabase" << d->mRemoveAlbumQuery.lastQuery();
         qDebug() << "DatabaseInterface::removeAlbumInDatabase" << d->mRemoveAlbumQuery.boundValues();
         qDebug() << "DatabaseInterface::removeAlbumInDatabase" << d->mRemoveAlbumQuery.lastError();
     }
 
     d->mRemoveAlbumQuery.finish();
 }
 
 void DatabaseInterface::removeArtistInDatabase(qulonglong artistId)
 {
     d->mRemoveArtistQuery.bindValue(QStringLiteral(":artistId"), artistId);
 
     auto result = d->mRemoveArtistQuery.exec();
 
     if (!result || !d->mRemoveArtistQuery.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::removeArtistInDatabase" << d->mRemoveArtistQuery.lastQuery();
         qDebug() << "DatabaseInterface::removeArtistInDatabase" << d->mRemoveArtistQuery.boundValues();
         qDebug() << "DatabaseInterface::removeArtistInDatabase" << d->mRemoveArtistQuery.lastError();
     }
 
     d->mRemoveArtistQuery.finish();
 }
 
 void DatabaseInterface::reloadExistingDatabase()
 {
     auto transactionResult = startTransaction();
     if (!transactionResult) {
         return;
     }
 
     d->mInitialUpdateTracksValidity.exec();
     qDebug() << "DatabaseInterface::reloadExistingDatabase";
 
     transactionResult = finishTransaction();
     if (!transactionResult) {
         return;
     }
 
     const auto restoredArtists = allArtists();
     for (const auto &oneArtist : restoredArtists) {
         d->mArtistId = std::max(d->mArtistId, oneArtist.databaseId());
         Q_EMIT artistAdded(oneArtist);
     }
     ++d->mArtistId;
 
     const auto restoredAlbums = allAlbums();
     for (const auto &oneAlbum : restoredAlbums) {
         d->mAlbumId = std::max(d->mAlbumId, oneAlbum.databaseId());
     }
     ++d->mAlbumId;
     if (!restoredAlbums.isEmpty()) {
         Q_EMIT albumsAdded(restoredAlbums);
     }
 
     const auto restoredTracks = allTracks();
     for (const auto &oneTrack : restoredTracks) {
         d->mTrackId = std::max(d->mTrackId, oneTrack.databaseId());
         Q_EMIT trackAdded(oneTrack.databaseId());
     }
     ++d->mTrackId;
     if (!restoredTracks.isEmpty()) {
         Q_EMIT tracksAdded(restoredTracks);
     }
 }
 
 qulonglong DatabaseInterface::insertMusicSource(const QString &name)
 {
     qulonglong result = 0;
 
     d->mSelectMusicSource.bindValue(QStringLiteral(":name"), name);
 
     auto queryResult = d->mSelectMusicSource.exec();
 
     if (!queryResult || !d->mSelectMusicSource.isSelect() || !d->mSelectMusicSource.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::insertMusicSource" << d->mSelectMusicSource.lastQuery();
         qDebug() << "DatabaseInterface::insertMusicSource" << d->mSelectMusicSource.boundValues();
         qDebug() << "DatabaseInterface::insertMusicSource" << d->mSelectMusicSource.lastError();
 
         d->mSelectMusicSource.finish();
 
         return result;
     }
 
     if (d->mSelectMusicSource.next()) {
         result = d->mSelectMusicSource.record().value(0).toULongLong();
 
         d->mSelectMusicSource.finish();
 
         return result;
     }
 
     d->mSelectMusicSource.finish();
 
     d->mInsertMusicSource.bindValue(QStringLiteral(":discoverId"), d->mDiscoverId);
     d->mInsertMusicSource.bindValue(QStringLiteral(":name"), name);
 
     queryResult = d->mInsertMusicSource.exec();
 
     if (!queryResult || !d->mInsertMusicSource.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::insertMusicSource" << d->mInsertMusicSource.lastQuery();
         qDebug() << "DatabaseInterface::insertMusicSource" << d->mInsertMusicSource.boundValues();
         qDebug() << "DatabaseInterface::insertMusicSource" << d->mInsertMusicSource.lastError();
 
         d->mInsertMusicSource.finish();
 
         return d->mDiscoverId;
     }
 
     d->mInsertMusicSource.finish();
 
     ++d->mDiscoverId;
 
     return d->mDiscoverId - 1;
 }
 
 QList<MusicAudioTrack> DatabaseInterface::fetchTracks(qulonglong albumId)
 {
     auto allTracks = QList<MusicAudioTrack>();
 
     d->mSelectTrackQuery.bindValue(QStringLiteral(":albumId"), albumId);
 
     auto result = d->mSelectTrackQuery.exec();
 
     if (!result || !d->mSelectTrackQuery.isSelect() || !d->mSelectTrackQuery.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::fetchTracks" << d->mSelectTrackQuery.lastQuery();
         qDebug() << "DatabaseInterface::fetchTracks" << d->mSelectTrackQuery.boundValues();
         qDebug() << "DatabaseInterface::fetchTracks" << d->mSelectTrackQuery.lastError();
     }
 
     while (d->mSelectTrackQuery.next()) {
         const auto &currentRecord = d->mSelectTrackQuery.record();
 
         allTracks.push_back(buildTrackFromDatabaseRecord(currentRecord));
     }
 
     d->mSelectTrackQuery.finish();
 
     updateTracksCount(albumId);
 
     return allTracks;
 }
 
 bool DatabaseInterface::updateTracksCount(qulonglong albumId)
 {
     bool isModified = false;
 
     d->mSelectAlbumTrackCountQuery.bindValue(QStringLiteral(":albumId"), albumId);
 
     auto result = d->mSelectAlbumTrackCountQuery.exec();
 
     if (!result || !d->mSelectAlbumTrackCountQuery.isSelect() || !d->mSelectAlbumTrackCountQuery.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::updateTracksCount" << d->mSelectAlbumTrackCountQuery.lastQuery();
         qDebug() << "DatabaseInterface::updateTracksCount" << d->mSelectAlbumTrackCountQuery.boundValues();
         qDebug() << "DatabaseInterface::updateTracksCount" << d->mSelectAlbumTrackCountQuery.lastError();
 
         d->mSelectAlbumTrackCountQuery.finish();
 
         return isModified;
     }
 
     if (!d->mSelectAlbumTrackCountQuery.next()) {
         d->mSelectAlbumTrackCountQuery.finish();
 
         return isModified;
     }
 
     auto oldTracksCount = d->mSelectAlbumTrackCountQuery.record().value(0).toInt();
 
     d->mUpdateAlbumQuery.bindValue(QStringLiteral(":albumId"), albumId);
 
     result = d->mUpdateAlbumQuery.exec();
 
     if (!result || !d->mUpdateAlbumQuery.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::updateTracksCount" << d->mUpdateAlbumQuery.lastQuery();
         qDebug() << "DatabaseInterface::updateTracksCount" << d->mUpdateAlbumQuery.boundValues();
         qDebug() << "DatabaseInterface::updateTracksCount" << d->mUpdateAlbumQuery.lastError();
 
         d->mUpdateAlbumQuery.finish();
 
         return isModified;
     }
 
     d->mUpdateAlbumQuery.finish();
 
     d->mSelectAlbumTrackCountQuery.bindValue(QStringLiteral(":albumId"), albumId);
 
     result = d->mSelectAlbumTrackCountQuery.exec();
 
     if (!result || !d->mSelectAlbumTrackCountQuery.isSelect() || !d->mSelectAlbumTrackCountQuery.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::updateTracksCount" << d->mSelectAlbumTrackCountQuery.lastQuery();
         qDebug() << "DatabaseInterface::updateTracksCount" << d->mSelectAlbumTrackCountQuery.boundValues();
         qDebug() << "DatabaseInterface::updateTracksCount" << d->mSelectAlbumTrackCountQuery.lastError();
 
         d->mSelectAlbumTrackCountQuery.finish();
 
         return isModified;
     }
 
     if (!d->mSelectAlbumTrackCountQuery.next()) {
         d->mSelectAlbumTrackCountQuery.finish();
 
         return isModified;
     }
 
     auto newTracksCount = d->mSelectAlbumTrackCountQuery.record().value(0).toInt();
 
     isModified = (newTracksCount != oldTracksCount);
 
     return isModified;
 }
 
 MusicAlbum DatabaseInterface::internalAlbumFromId(qulonglong albumId)
 {
     auto retrievedAlbum = MusicAlbum();
 
     d->mSelectAlbumQuery.bindValue(QStringLiteral(":albumId"), albumId);
 
     auto result = d->mSelectAlbumQuery.exec();
 
     if (!result || !d->mSelectAlbumQuery.isSelect() || !d->mSelectAlbumQuery.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::internalAlbumFromId" << d->mSelectAlbumQuery.lastQuery();
         qDebug() << "DatabaseInterface::internalAlbumFromId" << d->mSelectAlbumQuery.boundValues();
         qDebug() << "DatabaseInterface::internalAlbumFromId" << d->mSelectAlbumQuery.lastError();
 
         d->mSelectAlbumQuery.finish();
 
         return retrievedAlbum;
     }
 
     if (!d->mSelectAlbumQuery.next()) {
         d->mSelectAlbumQuery.finish();
 
         return retrievedAlbum;
     }
 
     const auto &currentRecord = d->mSelectAlbumQuery.record();
 
     retrievedAlbum.setDatabaseId(currentRecord.value(0).toULongLong());
     retrievedAlbum.setTitle(currentRecord.value(1).toString());
     retrievedAlbum.setId(currentRecord.value(2).toString());
     retrievedAlbum.setArtist(currentRecord.value(3).toString());
     retrievedAlbum.setAlbumArtURI(currentRecord.value(4).toUrl());
     retrievedAlbum.setTracksCount(currentRecord.value(5).toInt());
     retrievedAlbum.setIsSingleDiscAlbum(currentRecord.value(6).toBool());
     retrievedAlbum.setTracks(fetchTracks(albumId));
     retrievedAlbum.setValid(true);
 
     d->mSelectAlbumQuery.finish();
 
     return retrievedAlbum;
 }
 
 MusicAlbum DatabaseInterface::internalAlbumFromTitleAndArtist(const QString &title, const QString &artist)
 {
     auto result = MusicAlbum();
 
     auto albumId = internalAlbumIdFromTitleAndArtist(title, artist);
 
     if (albumId == 0) {
         return result;
     }
 
     result = internalAlbumFromId(albumId);
 
     return result;
 }
 
 qulonglong DatabaseInterface::internalAlbumIdFromTitleAndArtist(const QString &title, const QString &artist)
 {
     auto result = qulonglong(0);
 
     d->mSelectAlbumIdFromTitleQuery.bindValue(QStringLiteral(":title"), title);
     d->mSelectAlbumIdFromTitleQuery.bindValue(QStringLiteral(":artistName"), artist);
 
     auto queryResult = d->mSelectAlbumIdFromTitleQuery.exec();
 
     if (!queryResult || !d->mSelectAlbumIdFromTitleQuery.isSelect() || !d->mSelectAlbumIdFromTitleQuery.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::internalAlbumIdFromTitleAndArtist" << d->mSelectAlbumIdFromTitleQuery.lastQuery();
         qDebug() << "DatabaseInterface::internalAlbumIdFromTitleAndArtist" << d->mSelectAlbumIdFromTitleQuery.boundValues();
         qDebug() << "DatabaseInterface::internalAlbumIdFromTitleAndArtist" << d->mSelectAlbumIdFromTitleQuery.lastError();
 
         d->mSelectAlbumIdFromTitleQuery.finish();
 
         return result;
     }
 
     if (d->mSelectAlbumIdFromTitleQuery.next()) {
         result = d->mSelectAlbumIdFromTitleQuery.record().value(0).toULongLong();
     }
 
     d->mSelectAlbumIdFromTitleQuery.finish();
 
     if (result == 0) {
         d->mSelectAlbumIdFromTitleWithoutArtistQuery.bindValue(QStringLiteral(":title"), title);
 
         auto queryResult = d->mSelectAlbumIdFromTitleWithoutArtistQuery.exec();
 
         if (!queryResult || !d->mSelectAlbumIdFromTitleWithoutArtistQuery.isSelect() || !d->mSelectAlbumIdFromTitleWithoutArtistQuery.isActive()) {
             Q_EMIT databaseError();
 
             qDebug() << "DatabaseInterface::internalAlbumIdFromTitleAndArtist" << d->mSelectAlbumIdFromTitleWithoutArtistQuery.lastQuery();
             qDebug() << "DatabaseInterface::internalAlbumIdFromTitleAndArtist" << d->mSelectAlbumIdFromTitleWithoutArtistQuery.boundValues();
             qDebug() << "DatabaseInterface::internalAlbumIdFromTitleAndArtist" << d->mSelectAlbumIdFromTitleWithoutArtistQuery.lastError();
 
             d->mSelectAlbumIdFromTitleWithoutArtistQuery.finish();
 
             return result;
         }
 
         if (d->mSelectAlbumIdFromTitleWithoutArtistQuery.next()) {
             result = d->mSelectAlbumIdFromTitleWithoutArtistQuery.record().value(0).toULongLong();
         }
 
         d->mSelectAlbumIdFromTitleWithoutArtistQuery.finish();
     }
 
     return result;
 }
 
 MusicAudioTrack DatabaseInterface::internalTrackFromDatabaseId(qulonglong id)
 {
     auto result = MusicAudioTrack();
 
     if (!d || !d->mTracksDatabase.isValid() || !d->mInitFinished) {
         return result;
     }
 
     d->mSelectTrackFromIdQuery.bindValue(QStringLiteral(":trackId"), id);
 
     auto queryResult = d->mSelectTrackFromIdQuery.exec();
 
     if (!queryResult || !d->mSelectTrackFromIdQuery.isSelect() || !d->mSelectTrackFromIdQuery.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::internalTrackFromDatabaseId" << d->mSelectAlbumQuery.lastQuery();
         qDebug() << "DatabaseInterface::internalTrackFromDatabaseId" << d->mSelectAlbumQuery.boundValues();
         qDebug() << "DatabaseInterface::internalTrackFromDatabaseId" << d->mSelectAlbumQuery.lastError();
 
         d->mSelectTrackFromIdQuery.finish();
 
         return result;
     }
 
     if (!d->mSelectTrackFromIdQuery.next()) {
         d->mSelectTrackFromIdQuery.finish();
 
         return result;
     }
 
     const auto &currentRecord = d->mSelectTrackFromIdQuery.record();
 
     result = buildTrackFromDatabaseRecord(currentRecord);
 
     d->mSelectTrackFromIdQuery.finish();
 
     return result;
 }
 
 qulonglong DatabaseInterface::internalTrackIdFromTitleAlbumTracDiscNumber(const QString &title, const QString &artist, const QString &album,
                                                                           int trackNumber, int discNumber)
 {
     auto result = qulonglong(0);
 
     if (!d) {
         return result;
     }
 
     d->mSelectTrackIdFromTitleArtistAlbumTrackDiscNumberQuery.bindValue(QStringLiteral(":title"), title);
     d->mSelectTrackIdFromTitleArtistAlbumTrackDiscNumberQuery.bindValue(QStringLiteral(":artist"), artist);
     d->mSelectTrackIdFromTitleArtistAlbumTrackDiscNumberQuery.bindValue(QStringLiteral(":album"), album);
     d->mSelectTrackIdFromTitleArtistAlbumTrackDiscNumberQuery.bindValue(QStringLiteral(":trackNumber"), trackNumber);
     d->mSelectTrackIdFromTitleArtistAlbumTrackDiscNumberQuery.bindValue(QStringLiteral(":discNumber"), discNumber);
 
     auto queryResult = d->mSelectTrackIdFromTitleArtistAlbumTrackDiscNumberQuery.exec();
 
     if (!queryResult || !d->mSelectTrackIdFromTitleArtistAlbumTrackDiscNumberQuery.isSelect() || !d->mSelectTrackIdFromTitleArtistAlbumTrackDiscNumberQuery.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::trackIdFromTitleAlbumArtist" << d->mSelectTrackIdFromTitleArtistAlbumTrackDiscNumberQuery.lastQuery();
         qDebug() << "DatabaseInterface::trackIdFromTitleAlbumArtist" << d->mSelectTrackIdFromTitleArtistAlbumTrackDiscNumberQuery.boundValues();
         qDebug() << "DatabaseInterface::trackIdFromTitleAlbumArtist" << d->mSelectTrackIdFromTitleArtistAlbumTrackDiscNumberQuery.lastError();
 
         d->mSelectTrackIdFromTitleArtistAlbumTrackDiscNumberQuery.finish();
 
         return result;
     }
 
     if (d->mSelectTrackIdFromTitleArtistAlbumTrackDiscNumberQuery.next()) {
-        result = d->mSelectTrackIdFromTitleArtistAlbumTrackDiscNumberQuery.record().value(0).toInt();
+        result = d->mSelectTrackIdFromTitleArtistAlbumTrackDiscNumberQuery.record().value(0).toULongLong();
     }
 
     d->mSelectTrackIdFromTitleArtistAlbumTrackDiscNumberQuery.finish();
 
     return result;
 }
 
 qulonglong DatabaseInterface::getDuplicateTrackIdFromTitleAlbumTracDiscNumber(const QString &title, const QString &album,
                                                                               const QString &albumArtist, int trackNumber, int discNumber)
 {
     auto result = qulonglong(0);
 
     if (!d) {
         return result;
     }
 
     d->mSelectTrackIdFromTitleAlbumTrackDiscNumberQuery.bindValue(QStringLiteral(":title"), title);
     d->mSelectTrackIdFromTitleAlbumTrackDiscNumberQuery.bindValue(QStringLiteral(":album"), album);
     d->mSelectTrackIdFromTitleAlbumTrackDiscNumberQuery.bindValue(QStringLiteral(":albumArtist"), albumArtist);
     d->mSelectTrackIdFromTitleAlbumTrackDiscNumberQuery.bindValue(QStringLiteral(":trackNumber"), trackNumber);
     d->mSelectTrackIdFromTitleAlbumTrackDiscNumberQuery.bindValue(QStringLiteral(":discNumber"), discNumber);
 
     auto queryResult = d->mSelectTrackIdFromTitleAlbumTrackDiscNumberQuery.exec();
 
     if (!queryResult || !d->mSelectTrackIdFromTitleAlbumTrackDiscNumberQuery.isSelect() || !d->mSelectTrackIdFromTitleAlbumTrackDiscNumberQuery.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::trackIdFromTitleAlbumArtist" << d->mSelectTrackIdFromTitleAlbumTrackDiscNumberQuery.lastQuery();
         qDebug() << "DatabaseInterface::trackIdFromTitleAlbumArtist" << d->mSelectTrackIdFromTitleAlbumTrackDiscNumberQuery.boundValues();
         qDebug() << "DatabaseInterface::trackIdFromTitleAlbumArtist" << d->mSelectTrackIdFromTitleAlbumTrackDiscNumberQuery.lastError();
 
         d->mSelectTrackIdFromTitleAlbumTrackDiscNumberQuery.finish();
 
         return result;
     }
 
     if (d->mSelectTrackIdFromTitleAlbumTrackDiscNumberQuery.next()) {
-        result = d->mSelectTrackIdFromTitleAlbumTrackDiscNumberQuery.record().value(0).toInt();
+        result = d->mSelectTrackIdFromTitleAlbumTrackDiscNumberQuery.record().value(0).toULongLong();
     }
 
     d->mSelectTrackIdFromTitleAlbumTrackDiscNumberQuery.finish();
 
     return result;
 }
 
 qulonglong DatabaseInterface::internalTrackIdFromFileName(const QUrl &fileName)
 {
     auto result = qulonglong(0);
 
     if (!d) {
         return result;
     }
 
     d->mSelectTracksMapping.bindValue(QStringLiteral(":fileName"), fileName);
 
     auto queryResult = d->mSelectTracksMapping.exec();
 
     if (!queryResult || !d->mSelectTracksMapping.isSelect() || !d->mSelectTracksMapping.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::internalTrackIdFromFileName" << d->mSelectTracksMapping.lastQuery();
         qDebug() << "DatabaseInterface::internalTrackIdFromFileName" << d->mSelectTracksMapping.boundValues();
         qDebug() << "DatabaseInterface::internalTrackIdFromFileName" << d->mSelectTracksMapping.lastError();
 
         d->mSelectTracksMapping.finish();
 
         return result;
     }
 
     if (d->mSelectTracksMapping.next()) {
         const auto &currentRecordValue = d->mSelectTracksMapping.record().value(0);
         if (currentRecordValue.isValid()) {
-            result = currentRecordValue.toInt();
+            result = currentRecordValue.toULongLong();
         }
     }
 
     d->mSelectTracksMapping.finish();
 
     return result;
 }
 
 QList<MusicAudioTrack> DatabaseInterface::internalTracksFromAuthor(const QString &artistName)
 {
     auto allTracks = QList<MusicAudioTrack>();
 
     d->mSelectTracksFromArtist.bindValue(QStringLiteral(":artistName"), artistName);
 
     auto result = d->mSelectTracksFromArtist.exec();
 
     if (!result || !d->mSelectTracksFromArtist.isSelect() || !d->mSelectTracksFromArtist.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::tracksFromAuthor" << d->mSelectTracksFromArtist.lastQuery();
         qDebug() << "DatabaseInterface::tracksFromAuthor" << d->mSelectTracksFromArtist.boundValues();
         qDebug() << "DatabaseInterface::tracksFromAuthor" << d->mSelectTracksFromArtist.lastError();
 
         return allTracks;
     }
 
     while (d->mSelectTracksFromArtist.next()) {
         const auto &currentRecord = d->mSelectTracksFromArtist.record();
 
         allTracks.push_back(buildTrackFromDatabaseRecord(currentRecord));
     }
 
     d->mSelectTracksFromArtist.finish();
 
     return allTracks;
 }
 
 QList<qulonglong> DatabaseInterface::internalAlbumIdsFromAuthor(const QString &artistName)
 {
     auto allAlbumIds = QList<qulonglong>();
 
     d->mSelectAlbumIdsFromArtist.bindValue(QStringLiteral(":artistName"), artistName);
 
     auto result = d->mSelectAlbumIdsFromArtist.exec();
 
     if (!result || !d->mSelectAlbumIdsFromArtist.isSelect() || !d->mSelectAlbumIdsFromArtist.isActive()) {
         Q_EMIT databaseError();
 
         qDebug() << "DatabaseInterface::tracksFromAuthor" << d->mSelectAlbumIdsFromArtist.lastQuery();
         qDebug() << "DatabaseInterface::tracksFromAuthor" << d->mSelectAlbumIdsFromArtist.boundValues();
         qDebug() << "DatabaseInterface::tracksFromAuthor" << d->mSelectAlbumIdsFromArtist.lastError();
 
         return allAlbumIds;
     }
 
     while (d->mSelectAlbumIdsFromArtist.next()) {
         const auto &currentRecord = d->mSelectAlbumIdsFromArtist.record();
 
         allAlbumIds.push_back(currentRecord.value(0).toULongLong());
     }
 
     d->mSelectAlbumIdsFromArtist.finish();
 
     return allAlbumIds;
 }
 
 
 #include "moc_databaseinterface.cpp"
diff --git a/src/databaseinterface.h b/src/databaseinterface.h
index 7e4e475c..3856a8f0 100644
--- a/src/databaseinterface.h
+++ b/src/databaseinterface.h
@@ -1,214 +1,214 @@
 /*
  * Copyright 2016-2017 Matthieu Gallien <matthieu_gallien@yahoo.fr>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 3 of the License, or (at your option) any later version.
  *
  * This library 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #ifndef DATABASEINTERFACE_H
 #define DATABASEINTERFACE_H
 
 #include "musicalbum.h"
 #include "musicaudiotrack.h"
 #include "musicartist.h"
 
 #include <QObject>
 #include <QString>
 #include <QHash>
 #include <QList>
 #include <QVariant>
 #include <QUrl>
 
 #include <memory>
 
 class DatabaseInterfacePrivate;
 class QMutex;
 class QSqlRecord;
 
 class DatabaseInterface : public QObject
 {
     Q_OBJECT
 
 public:
 
     enum class AlbumData {
         Title,
         Artist,
         Image,
         TracksCount,
         Id,
     };
 
     explicit DatabaseInterface(QObject *parent = nullptr);
 
     ~DatabaseInterface() override;
 
     Q_INVOKABLE void init(const QString &dbName, const QString &databaseFileName = {});
 
     MusicAlbum albumFromTitleAndArtist(const QString &title, const QString &artist);
 
     QList<MusicAudioTrack> allTracks();
 
     QList<MusicAudioTrack> allTracksFromSource(const QString &musicSource);
 
     QList<MusicAudioTrack> allInvalidTracksFromSource(const QString &musicSource);
 
     QList<MusicAlbum> allAlbums();
 
     QList<MusicArtist> allArtists();
 
     QList<MusicAudioTrack> tracksFromAuthor(const QString &artistName);
 
     MusicAudioTrack trackFromDatabaseId(qulonglong id);
 
     qulonglong trackIdFromTitleAlbumTrackDiscNumber(const QString &title, const QString &artist, const QString &album,
                                                     int trackNumber, int discNumber);
 
     qulonglong trackIdFromFileName(const QUrl &fileName);
 
     void applicationAboutToQuit();
 
 Q_SIGNALS:
 
     void artistAdded(const MusicArtist &newArtist);
 
     void albumsAdded(const QList<MusicAlbum> &newAlbum);
 
     void trackAdded(qulonglong id);
 
     void tracksAdded(const QList<MusicAudioTrack> &allTracks);
 
     void artistRemoved(const MusicArtist &removedArtist);
 
     void albumRemoved(const MusicAlbum &removedAlbum, qulonglong removedAlbumId);
 
     void trackRemoved(qulonglong id);
 
     void artistModified(const MusicArtist &modifiedArtist);
 
     void albumModified(const MusicAlbum &modifiedAlbum, qulonglong modifiedAlbumId);
 
     void trackModified(const MusicAudioTrack &modifiedTrack);
 
     void sentAlbumData(const MusicAlbum albumData);
 
     void requestsInitDone();
 
     void databaseError();
 
 public Q_SLOTS:
 
     void insertTracksList(const QList<MusicAudioTrack> &tracks, const QHash<QString, QUrl> &covers, const QString &musicSource);
 
     void removeTracksList(const QList<QUrl> &removedTracks);
 
     void modifyTracksList(const QList<MusicAudioTrack> &modifiedTracks, const QHash<QString, QUrl> &covers, const QString &musicSource);
 
     void removeAllTracksFromSource(const QString &sourceName);
 
     void getAlbumFromAlbumId(qulonglong id);
 
     void cleanInvalidTracks();
 
 private:
 
     enum class TrackFileInsertType {
         NewTrackFileInsert,
         ModifiedTrackFileInsert,
     };
 
     bool startTransaction() const;
 
     bool finishTransaction() const;
 
     bool rollBackTransaction() const;
 
     QList<MusicAudioTrack> fetchTracks(qulonglong albumId);
 
     bool updateTracksCount(qulonglong albumId);
 
     MusicArtist internalArtistFromId(qulonglong artistId);
 
     MusicAlbum internalAlbumFromId(qulonglong albumId);
 
     MusicAlbum internalAlbumFromTitleAndArtist(const QString &title, const QString &artist);
 
     qulonglong internalAlbumIdFromTitleAndArtist(const QString &title, const QString &artist);
 
     MusicAudioTrack internalTrackFromDatabaseId(qulonglong id);
 
     qulonglong internalTrackIdFromTitleAlbumTracDiscNumber(const QString &title, const QString &artist, const QString &album,
                                                            int trackNumber, int discNumber);
 
     qulonglong getDuplicateTrackIdFromTitleAlbumTracDiscNumber(const QString &title, const QString &album, const QString &albumArtist,
                                                                int trackNumber, int discNumber);
 
     qulonglong internalTrackIdFromFileName(const QUrl &fileName);
 
     QList<MusicAudioTrack> internalTracksFromAuthor(const QString &artistName);
 
     QList<qulonglong> internalAlbumIdsFromAuthor(const QString &artistName);
 
     void initDatabase() const;
 
     void initRequest();
 
     qulonglong insertAlbum(const QString &title, const QString &albumArtist, const QString &trackArtist,
                            const QUrl &albumArtURI, int tracksCount, bool isSingleDiscAlbum,
                            QList<qulonglong> &newAlbumIds);
 
     bool updateAlbumFromId(qulonglong albumId, const QUrl &albumArtUri, const MusicAudioTrack &currentTrack);
 
     qulonglong insertArtist(const QString &name);
 
     qulonglong internalArtistIdFromName(const QString &name);
 
     void removeTrackInDatabase(qulonglong trackId);
 
     void removeAlbumInDatabase(qulonglong albumId);
 
     void removeArtistInDatabase(qulonglong artistId);
 
     void reloadExistingDatabase();
 
     qulonglong insertMusicSource(const QString &name);
 
     void insertTrackOrigin(const QUrl &fileNameURI, qulonglong discoverId);
 
     void updateTrackOrigin(qulonglong trackId, const QUrl &fileName);
 
     int computeTrackPriority(qulonglong trackId, const QUrl &fileName);
 
     qulonglong internalInsertTrack(const MusicAudioTrack &oneModifiedTrack, const QHash<QString, QUrl> &covers,
-                                   int originTrackId, QSet<qulonglong> &modifiedAlbumIds, TrackFileInsertType insertType,
+                                   qulonglong originTrackId, QSet<qulonglong> &modifiedAlbumIds, TrackFileInsertType insertType,
                                    QList<qulonglong> &newAlbumIds);
 
     MusicAudioTrack buildTrackFromDatabaseRecord(const QSqlRecord &trackRecord) const;
 
     void internalRemoveTracksList(const QList<QUrl> &removedTracks);
 
     void internalRemoveTracksList(const QList<QUrl> &removedTracks, qulonglong sourceId);
 
     void internalRemoveTracksWithoutMapping();
 
     QUrl internalAlbumArtUriFromAlbumId(qulonglong albumId);
 
     bool isValidArtist(qulonglong albumId);
 
     std::unique_ptr<DatabaseInterfacePrivate> d;
 
 };
 
 #endif // DATABASEINTERFACE_H
diff --git a/src/elisautils.cpp b/src/elisautils.cpp
index 6862aaf1..cecd6288 100644
--- a/src/elisautils.cpp
+++ b/src/elisautils.cpp
@@ -1,171 +1,171 @@
 /*
  * Copyright 2017 Matthieu Gallien <matthieu_gallien@yahoo.fr>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 3 of the License, or (at your option) any later version.
  *
  * This library 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "elisautils.h"
 
 #include <KFileMetaData/Properties>
 #include <KFileMetaData/ExtractorCollection>
 #include <KFileMetaData/Extractor>
 #include <KFileMetaData/SimpleExtractionResult>
 #include <KFileMetaData/UserMetaData>
 
 MusicAudioTrack ElisaUtils::scanOneFile(const QUrl &scanFile, const QMimeDatabase &mimeDatabase,
                                         const KFileMetaData::ExtractorCollection &allExtractors)
 {
     MusicAudioTrack newTrack;
 
     const auto &fileMimeType = mimeDatabase.mimeTypeForFile(scanFile.toLocalFile());
     if (!fileMimeType.name().startsWith(QStringLiteral("audio/"))) {
         return newTrack;
     }
 
     QString mimetype = fileMimeType.name();
 
     QList<KFileMetaData::Extractor*> exList = allExtractors.fetchExtractors(mimetype);
 
     if (exList.isEmpty()) {
         return newTrack;
     }
 
     KFileMetaData::Extractor* ex = exList.first();
     KFileMetaData::SimpleExtractionResult result(scanFile.toLocalFile(), mimetype,
                                                  KFileMetaData::ExtractionResult::ExtractMetaData);
 
     ex->extract(&result);
 
     const auto &allProperties = result.properties();
 
     auto titleProperty = allProperties.find(KFileMetaData::Property::Title);
     auto durationProperty = allProperties.find(KFileMetaData::Property::Duration);
     auto artistProperty = allProperties.find(KFileMetaData::Property::Artist);
     auto albumProperty = allProperties.find(KFileMetaData::Property::Album);
     auto albumArtistProperty = allProperties.find(KFileMetaData::Property::AlbumArtist);
     auto trackNumberProperty = allProperties.find(KFileMetaData::Property::TrackNumber);
     auto discNumberProperty = allProperties.find(KFileMetaData::Property::DiscNumber);
     auto genreProperty = allProperties.find(KFileMetaData::Property::Genre);
     auto yearProperty = allProperties.find(KFileMetaData::Property::ReleaseYear);
     auto composerProperty = allProperties.find(KFileMetaData::Property::Composer);
     auto lyricistProperty = allProperties.find(KFileMetaData::Property::Lyricist);
     auto channelsProperty = allProperties.find(KFileMetaData::Property::Channels);
     auto bitRateProperty = allProperties.find(KFileMetaData::Property::BitRate);
     auto sampleRateProperty = allProperties.find(KFileMetaData::Property::SampleRate);
     auto commentProperty = allProperties.find(KFileMetaData::Property::Comment);
 #if defined Q_OS_LINUX && !defined Q_OS_ANDROID
     auto fileData = KFileMetaData::UserMetaData(scanFile.toLocalFile());
 #endif
 
     if (albumProperty != allProperties.end()) {
         auto albumValue = albumProperty->toString();
 
         newTrack.setAlbumName(albumValue);
 
         if (artistProperty != allProperties.end()) {
             newTrack.setArtist(artistProperty->toStringList().join(QStringLiteral(", ")));
         }
 
         if (durationProperty != allProperties.end()) {
-            newTrack.setDuration(QTime::fromMSecsSinceStartOfDay(1000 * durationProperty->toDouble()));
+            newTrack.setDuration(QTime::fromMSecsSinceStartOfDay(int(1000 * durationProperty->toDouble())));
         }
 
         if (titleProperty != allProperties.end()) {
             newTrack.setTitle(titleProperty->toString());
         }
 
         if (trackNumberProperty != allProperties.end()) {
             newTrack.setTrackNumber(trackNumberProperty->toInt());
         }
 
         if (discNumberProperty != allProperties.end()) {
             newTrack.setDiscNumber(discNumberProperty->toInt());
         } else {
             newTrack.setDiscNumber(1);
         }
 
         if (albumArtistProperty != allProperties.end()) {
             newTrack.setAlbumArtist(albumArtistProperty->toStringList().join(QStringLiteral(", ")));
         }
 
         if (yearProperty != allProperties.end()) {
             newTrack.setYear(yearProperty->toInt());
         }
 
         if (channelsProperty != allProperties.end()) {
             newTrack.setChannels(channelsProperty->toInt());
         }
 
         if (bitRateProperty != allProperties.end()) {
             newTrack.setBitRate(bitRateProperty->toInt());
         }
 
         if (sampleRateProperty != allProperties.end()) {
             newTrack.setSampleRate(sampleRateProperty->toInt());
         }
 
         if (genreProperty != allProperties.end()) {
             newTrack.setGenre(genreProperty->toStringList().join(QStringLiteral(", ")));
         }
 
         if (composerProperty != allProperties.end()) {
             newTrack.setComposer(composerProperty->toStringList().join(QStringLiteral(", ")));
         }
 
         if (lyricistProperty != allProperties.end()) {
             newTrack.setLyricist(lyricistProperty->toStringList().join(QStringLiteral(", ")));
         }
 
         if (commentProperty != allProperties.end()) {
             newTrack.setComment(commentProperty->toString());
         }
 
         if (newTrack.artist().isEmpty()) {
             newTrack.setArtist(newTrack.albumArtist());
         }
 
         newTrack.setResourceURI(scanFile);
 
 #if defined Q_OS_LINUX && !defined Q_OS_ANDROID
         newTrack.setRating(fileData.rating());
 #else
         newTrack.setRating(0);
 #endif
 
         if (newTrack.title().isEmpty()) {
             return newTrack;
         }
 
         if (newTrack.artist().isEmpty()) {
             return newTrack;
         }
 
         if (newTrack.albumName().isEmpty()) {
             return newTrack;
         }
 
         if (!newTrack.duration().isValid()) {
             return newTrack;
         }
 
         newTrack.setValid(true);
     }
 
     return newTrack;
 }
 
 
 #include "moc_elisautils.cpp"
diff --git a/src/mediaplaylist.cpp b/src/mediaplaylist.cpp
index 5a148e09..b4b4e41b 100644
--- a/src/mediaplaylist.cpp
+++ b/src/mediaplaylist.cpp
@@ -1,1346 +1,1346 @@
 /*
  * Copyright 2015-2017 Matthieu Gallien <matthieu_gallien@yahoo.fr>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 3 of the License, or (at your option) any later version.
  *
  * This library 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "mediaplaylist.h"
 #include "databaseinterface.h"
 #include "musicaudiotrack.h"
 #include "musiclistenersmanager.h"
 
 #include <QUrl>
 #include <QPersistentModelIndex>
 #include <QList>
 #include <QMediaPlaylist>
 #include <QFileInfo>
 #include <QDebug>
 
 #include <algorithm>
 
 class MediaPlayListPrivate
 {
 public:
 
     QList<MediaPlayListEntry> mData;
 
     QList<MusicAudioTrack> mTrackData;
 
     MusicListenersManager* mMusicListenersManager = nullptr;
 
     QPersistentModelIndex mCurrentTrack;
 
+    QVariantMap mPersistentState;
+
+    QMediaPlaylist mLoadPlaylist;
+
     int mCurrentPlayListPosition = 0;
 
     bool mRandomPlay = false;
 
     bool mRepeatPlay = false;
 
-    QVariantMap mPersistentState;
-
-    QMediaPlaylist mLoadPlaylist;
-
 };
 
 MediaPlayList::MediaPlayList(QObject *parent) : QAbstractListModel(parent), d(new MediaPlayListPrivate)
 {
     connect(&d->mLoadPlaylist, &QMediaPlaylist::loaded, this, &MediaPlayList::loadPlayListLoaded);
     connect(&d->mLoadPlaylist, &QMediaPlaylist::loadFailed, this, &MediaPlayList::loadPlayListLoadFailed);
     seedRandomGenerator(QTime::currentTime().msec());
 }
 
 MediaPlayList::~MediaPlayList()
 = default;
 
 int MediaPlayList::rowCount(const QModelIndex &parent) const
 {
     if (parent.isValid()) {
         return 0;
     }
 
     return d->mData.size();
 }
 
 QHash<int, QByteArray> MediaPlayList::roleNames() const
 {
     auto roles = QAbstractItemModel::roleNames();
 
     roles[static_cast<int>(ColumnsRoles::IsValidRole)] = "isValid";
     roles[static_cast<int>(ColumnsRoles::TitleRole)] = "title";
     roles[static_cast<int>(ColumnsRoles::DurationRole)] = "duration";
     roles[static_cast<int>(ColumnsRoles::ArtistRole)] = "artist";
     roles[static_cast<int>(ColumnsRoles::AlbumArtistRole)] = "albumArtist";
     roles[static_cast<int>(ColumnsRoles::AlbumRole)] = "album";
     roles[static_cast<int>(ColumnsRoles::TrackNumberRole)] = "trackNumber";
     roles[static_cast<int>(ColumnsRoles::DiscNumberRole)] = "discNumber";
     roles[static_cast<int>(ColumnsRoles::RatingRole)] = "rating";
     roles[static_cast<int>(ColumnsRoles::GenreRole)] = "genre";
     roles[static_cast<int>(ColumnsRoles::LyricistRole)] = "lyricist";
     roles[static_cast<int>(ColumnsRoles::ComposerRole)] = "composer";
     roles[static_cast<int>(ColumnsRoles::CommentRole)] = "comment";
     roles[static_cast<int>(ColumnsRoles::YearRole)] = "year";
     roles[static_cast<int>(ColumnsRoles::ChannelsRole)] = "channels";
     roles[static_cast<int>(ColumnsRoles::BitRateRole)] = "bitRate";
     roles[static_cast<int>(ColumnsRoles::SampleRateRole)] = "sampleRate";
     roles[static_cast<int>(ColumnsRoles::ImageRole)] = "image";
     roles[static_cast<int>(ColumnsRoles::CountRole)] = "count";
     roles[static_cast<int>(ColumnsRoles::IsPlayingRole)] = "isPlaying";
     roles[static_cast<int>(ColumnsRoles::HasAlbumHeader)] = "hasAlbumHeader";
     roles[static_cast<int>(ColumnsRoles::IsSingleDiscAlbumHeader)] = "isSingleDiscAlbum";
     roles[static_cast<int>(ColumnsRoles::SecondaryTextRole)] = "secondaryText";
     roles[static_cast<int>(ColumnsRoles::ImageUrlRole)] = "imageUrl";
     roles[static_cast<int>(ColumnsRoles::ShadowForImageRole)] = "shadowForImage";
     roles[static_cast<int>(ColumnsRoles::ResourceRole)] = "trackResource";
     roles[static_cast<int>(ColumnsRoles::TrackDataRole)] = "trackData";
 
     return roles;
 }
 
 QVariant MediaPlayList::data(const QModelIndex &index, int role) const
 {
     auto result = QVariant();
 
     if (!index.isValid()) {
         return result;
     }
 
     if (index.row() < 0 || index.row() >= d->mData.size()) {
         return result;
     }
 
     if (d->mData[index.row()].mIsValid) {
         switch(role)
         {
         case ColumnsRoles::IsValidRole:
             result = d->mData[index.row()].mIsValid;
             break;
         case ColumnsRoles::TitleRole:
             if (!d->mTrackData[index.row()].title().isEmpty()) {
                 result = d->mTrackData[index.row()].title();
             } else {
                 if (d->mData[index.row()].mTrackUrl.isLocalFile()) {
                     auto localFile = QFileInfo(d->mData[index.row()].mTrackUrl.toLocalFile());
                     result = localFile.fileName();
                 } else {
                     result = d->mData[index.row()].mTrackUrl.toString();
                 }
             }
             break;
         case ColumnsRoles::DurationRole:
         {
             const QTime &trackDuration = d->mTrackData[index.row()].duration();
             if (trackDuration.hour() == 0) {
                 result = trackDuration.toString(QStringLiteral("mm:ss"));
             } else {
                 result = trackDuration.toString();
             }
             break;
         }
         case ColumnsRoles::MilliSecondsDurationRole:
             result = d->mTrackData[index.row()].duration().msecsSinceStartOfDay();
             break;
         case ColumnsRoles::ArtistRole:
             result = d->mTrackData[index.row()].artist();
             break;
         case ColumnsRoles::AlbumArtistRole:
             result = d->mTrackData[index.row()].albumArtist();
             break;
         case ColumnsRoles::AlbumRole:
             result = d->mTrackData[index.row()].albumName();
             break;
         case ColumnsRoles::TrackNumberRole:
             result = d->mTrackData[index.row()].trackNumber();
             break;
         case ColumnsRoles::DiscNumberRole:
             result = d->mTrackData[index.row()].discNumber();
             break;
         case ColumnsRoles::IsSingleDiscAlbumHeader:
             result = d->mTrackData[index.row()].isSingleDiscAlbum();
             break;
         case ColumnsRoles::ResourceRole:
             if (d->mTrackData[index.row()].resourceURI().isValid()) {
                 result = d->mTrackData[index.row()].resourceURI();
             } else {
                 result = d->mData[index.row()].mTrackUrl;
             }
             break;
         case ColumnsRoles::ImageRole:
         {
             auto albumArt = d->mTrackData[index.row()].albumCover();
             if (albumArt.isValid()) {
                 result = albumArt;
             }
             break;
         }
         case ColumnsRoles::HasAlbumHeader:
             result = rowHasHeader(index.row());
             break;
         case ColumnsRoles::RatingRole:
             result = d->mTrackData[index.row()].rating();
             break;
         case ColumnsRoles::GenreRole:
             result = d->mTrackData[index.row()].genre();
             break;
         case ColumnsRoles::LyricistRole:
             result = d->mTrackData[index.row()].lyricist();
             break;
         case ColumnsRoles::ComposerRole:
             result = d->mTrackData[index.row()].composer();
             break;
         case ColumnsRoles::CommentRole:
             result = d->mTrackData[index.row()].comment();
             break;
         case ColumnsRoles::YearRole:
             result = d->mTrackData[index.row()].year();
             break;
         case ColumnsRoles::ChannelsRole:
             result = d->mTrackData[index.row()].channels();
             break;
         case ColumnsRoles::BitRateRole:
             result = d->mTrackData[index.row()].bitRate();
             break;
         case ColumnsRoles::SampleRateRole:
             result = d->mTrackData[index.row()].sampleRate();
             break;
         case ColumnsRoles::CountRole:
             break;
         case ColumnsRoles::IsPlayingRole:
             result = d->mData[index.row()].mIsPlaying;
             break;
         case Qt::DisplayRole:
         {
             const auto &track = d->mTrackData[index.row()];
             auto displayText = QString();
             displayText = QStringLiteral("%1 - %2");
 
             if (track.isSingleDiscAlbum()) {
                 displayText = displayText.arg(track.trackNumber());
             } else {
                 auto numbersText = QString();
                 numbersText = QStringLiteral("%1 - %2");
                 numbersText = numbersText.arg(track.discNumber());
                 numbersText = numbersText.arg(track.trackNumber());
                 displayText = displayText.arg(numbersText);
             }
 
             result = displayText.arg(track.title());
             break;
         }
         case ColumnsRoles::SecondaryTextRole:
             break;
         case ColumnsRoles::ImageUrlRole:
         {
             const auto &albumArt = d->mTrackData[index.row()].albumCover();
             if (albumArt.isValid()) {
                 result = albumArt;
             } else {
                 result = QUrl(QStringLiteral("image://icon/media-optical-audio"));
             }
             break;
         }
         case ColumnsRoles::ShadowForImageRole:
             result = d->mTrackData[index.row()].albumCover().isValid();
             break;
         case ColumnsRoles::TrackDataRole:
             result = QVariant::fromValue(d->mTrackData[index.row()]);
             break;
         }
     } else {
         switch(role)
         {
         case ColumnsRoles::IsValidRole:
             result = d->mData[index.row()].mIsValid;
             break;
         case ColumnsRoles::TitleRole:
             if (!d->mData[index.row()].mTitle.isEmpty()) {
                 result = d->mData[index.row()].mTitle;
             } else if (d->mData[index.row()].mTrackUrl.isValid()) {
                 if (d->mData[index.row()].mTrackUrl.isLocalFile()) {
                     auto localFile = QFileInfo(d->mData[index.row()].mTrackUrl.toLocalFile());
                     result = localFile.fileName();
                 } else {
                     result = d->mData[index.row()].mTrackUrl.toString();
                 }
             }
             break;
         case ColumnsRoles::IsPlayingRole:
             result = d->mData[index.row()].mIsPlaying;
             break;
         case ColumnsRoles::ArtistRole:
             result = d->mData[index.row()].mArtist;
             break;
         case ColumnsRoles::AlbumArtistRole:
             result = d->mData[index.row()].mArtist;
             break;
         case ColumnsRoles::AlbumRole:
             result = d->mData[index.row()].mAlbum;
             break;
         case ColumnsRoles::TrackNumberRole:
             result = -1;
             break;
         case ColumnsRoles::HasAlbumHeader:
             result = rowHasHeader(index.row());
             break;
         case ColumnsRoles::DurationRole:
             break;
         case ColumnsRoles::DiscNumberRole:
             break;
         case ColumnsRoles::IsSingleDiscAlbumHeader:
             result = false;
             break;
         case ColumnsRoles::MilliSecondsDurationRole:
             break;
         case ColumnsRoles::ResourceRole:
             break;
         case ColumnsRoles::RatingRole:
             break;
         case ColumnsRoles::CountRole:
             break;
         case ColumnsRoles::ImageRole:
             result = QStringLiteral("");
             break;
         case Qt::DisplayRole:
             result = d->mTrackData[index.row()].title();
             break;
         case ColumnsRoles::SecondaryTextRole:
             result = QString();
             break;
         case ColumnsRoles::ImageUrlRole:
             result = QUrl(QStringLiteral("image://icon/error"));
             break;
         case ColumnsRoles::ShadowForImageRole:
             result = false;
             break;
         case ColumnsRoles::TrackDataRole:
             MusicAudioTrack emptyTrack;
             result = QVariant::fromValue(emptyTrack);
             break;
         }
     }
 
     return result;
 }
 
 bool MediaPlayList::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     bool modelModified = false;
 
     if (!index.isValid()) {
         return modelModified;
     }
 
     if (index.row() < 0 || index.row() >= d->mData.size()) {
         return modelModified;
     }
 
     if (role < ColumnsRoles::IsValidRole || role > ColumnsRoles::HasAlbumHeader) {
         return modelModified;
     }
 
-    ColumnsRoles convertedRole = static_cast<ColumnsRoles>(role);
+    auto convertedRole = static_cast<ColumnsRoles>(role);
 
     switch(convertedRole)
     {
     case ColumnsRoles::IsPlayingRole:
     {
         modelModified = true;
-        PlayState newState = static_cast<PlayState>(value.toInt());
+        auto newState = static_cast<PlayState>(value.toInt());
         d->mData[index.row()].mIsPlaying = newState;
         Q_EMIT dataChanged(index, index, {role});
 
         if (!d->mCurrentTrack.isValid()) {
             resetCurrentTrack();
         }
 
         break;
     }
     default:
         modelModified = false;
     }
 
     return modelModified;
 }
 
 bool MediaPlayList::removeRows(int row, int count, const QModelIndex &parent)
 {
     beginRemoveRows(parent, row, row + count - 1);
 
     bool hadAlbumHeader = false;
 
     if (rowCount() > row + count) {
         hadAlbumHeader = rowHasHeader(row + count);
     }
 
     for (int i = row, cpt = 0; cpt < count; ++i, ++cpt) {
         d->mData.removeAt(i);
         d->mTrackData.removeAt(i);
     }
     endRemoveRows();
 
     if (!d->mCurrentTrack.isValid()) {
         d->mCurrentTrack = index(d->mCurrentPlayListPosition, 0);
 
         if (d->mCurrentTrack.isValid()) {
             notifyCurrentTrackChanged();
         }
 
         if (!d->mCurrentTrack.isValid()) {
             Q_EMIT playListFinished();
             resetCurrentTrack();
             if (!d->mCurrentTrack.isValid()) {
                 notifyCurrentTrackChanged();
             }
         }
     }
 
     if (!d->mCurrentTrack.isValid() && rowCount(parent) <= row) {
         resetCurrentTrack();
     }
 
     Q_EMIT tracksCountChanged();
 
     if (hadAlbumHeader != rowHasHeader(row)) {
         Q_EMIT dataChanged(index(row, 0), index(row, 0), {ColumnsRoles::HasAlbumHeader});
 
         if (!d->mCurrentTrack.isValid()) {
             resetCurrentTrack();
         }
     }
 
     Q_EMIT persistentStateChanged();
 
     return false;
 }
 
 bool MediaPlayList::moveRows(const QModelIndex &sourceParent, int sourceRow, int count, const QModelIndex &destinationParent, int destinationChild)
 {
     if (sourceParent != destinationParent) {
         return false;
     }
 
     if (!beginMoveRows(sourceParent, sourceRow, sourceRow + count - 1, destinationParent, destinationChild)) {
         return false;
     }
 
     auto firstMovedTrackHasHeader = rowHasHeader(sourceRow);
     auto nextTrackHasHeader = rowHasHeader(sourceRow + count);
     auto futureNextTrackHasHeader = rowHasHeader(destinationChild);
     if (sourceRow < destinationChild) {
         nextTrackHasHeader = rowHasHeader(sourceRow + count);
     }
 
     for (auto cptItem = 0; cptItem < count; ++cptItem) {
         if (sourceRow < destinationChild) {
             d->mData.move(sourceRow, destinationChild - 1);
             d->mTrackData.move(sourceRow, destinationChild - 1);
         } else {
             d->mData.move(sourceRow, destinationChild);
             d->mTrackData.move(sourceRow, destinationChild);
         }
     }
 
     endMoveRows();
 
     if (sourceRow < destinationChild) {
         if (firstMovedTrackHasHeader != rowHasHeader(destinationChild - count)) {
             Q_EMIT dataChanged(index(destinationChild - count, 0), index(destinationChild - count, 0), {ColumnsRoles::HasAlbumHeader});
 
             if (!d->mCurrentTrack.isValid()) {
                 resetCurrentTrack();
             }
         }
     } else {
         if (firstMovedTrackHasHeader != rowHasHeader(destinationChild)) {
             Q_EMIT dataChanged(index(destinationChild, 0), index(destinationChild, 0), {ColumnsRoles::HasAlbumHeader});
 
             if (!d->mCurrentTrack.isValid()) {
                 resetCurrentTrack();
             }
         }
     }
 
     if (sourceRow < destinationChild) {
         if (nextTrackHasHeader != rowHasHeader(sourceRow)) {
             Q_EMIT dataChanged(index(sourceRow, 0), index(sourceRow, 0), {ColumnsRoles::HasAlbumHeader});
 
             if (!d->mCurrentTrack.isValid()) {
                 resetCurrentTrack();
             }
         }
     } else {
         if (nextTrackHasHeader != rowHasHeader(sourceRow + count)) {
             Q_EMIT dataChanged(index(sourceRow + count, 0), index(sourceRow + count, 0), {ColumnsRoles::HasAlbumHeader});
 
             if (!d->mCurrentTrack.isValid()) {
                 resetCurrentTrack();
             }
         }
     }
 
     if (sourceRow < destinationChild) {
         if (futureNextTrackHasHeader != rowHasHeader(destinationChild + count - 1)) {
             Q_EMIT dataChanged(index(destinationChild + count - 1, 0), index(destinationChild + count - 1, 0), {ColumnsRoles::HasAlbumHeader});
 
             if (!d->mCurrentTrack.isValid()) {
                 resetCurrentTrack();
             }
         }
     } else {
         if (futureNextTrackHasHeader != rowHasHeader(destinationChild + count)) {
             Q_EMIT dataChanged(index(destinationChild + count, 0), index(destinationChild + count, 0), {ColumnsRoles::HasAlbumHeader});
 
             if (!d->mCurrentTrack.isValid()) {
                 resetCurrentTrack();
             }
         }
     }
 
     Q_EMIT persistentStateChanged();
 
     return true;
 }
 
 void MediaPlayList::move(int from, int to, int n)
 {
     if (from < to) {
         moveRows({}, from, n, {}, to + 1);
     } else {
         moveRows({}, from, n, {}, to);
     }
 }
 
 void MediaPlayList::enqueue(qulonglong newTrackId)
 {
     enqueue(MediaPlayListEntry(newTrackId));
 }
 
 void MediaPlayList::enqueue(const MusicAudioTrack &newTrack)
 {
     enqueue(MediaPlayListEntry(newTrack), newTrack);
 }
 
 void MediaPlayList::enqueue(const MediaPlayListEntry &newEntry, const MusicAudioTrack &audioTrack)
 {
     beginInsertRows(QModelIndex(), d->mData.size(), d->mData.size());
     d->mData.push_back(newEntry);
     if (audioTrack.isValid()) {
         d->mTrackData.push_back(audioTrack);
     } else {
         d->mTrackData.push_back({});
     }
     endInsertRows();
 
     restorePlayListPosition();
     if (!d->mCurrentTrack.isValid()) {
         resetCurrentTrack();
     }
 
     Q_EMIT tracksCountChanged();
     Q_EMIT persistentStateChanged();
 
     if (!newEntry.mIsValid) {
         if (newEntry.mTrackUrl.isValid()) {
             qDebug() << "MediaPlayList::enqueue" << "newTrackByFileNameInList" << newEntry.mTrackUrl;
             if (newEntry.mTrackUrl.isLocalFile()) {
                 QFileInfo newTrackFile(newEntry.mTrackUrl.toLocalFile());
                 if (newTrackFile.exists()) {
                     d->mData.last().mIsValid = true;
                 }
                 Q_EMIT newTrackByFileNameInList(newEntry.mTrackUrl);
             }
         } else {
             Q_EMIT newTrackByNameInList(newEntry.mTitle, newEntry.mArtist, newEntry.mAlbum, newEntry.mTrackNumber, newEntry.mDiscNumber);
         }
     } else {
         Q_EMIT newTrackByIdInList(newEntry.mId);
     }
 
     Q_EMIT trackHasBeenAdded(data(index(d->mData.size() - 1, 0), ColumnsRoles::TitleRole).toString(), data(index(d->mData.size() - 1, 0), ColumnsRoles::ImageRole).toUrl());
 
     if (!newEntry.mIsValid) {
         Q_EMIT dataChanged(index(rowCount() - 1, 0), index(rowCount() - 1, 0), {MediaPlayList::HasAlbumHeader});
 
         if (!d->mCurrentTrack.isValid()) {
             resetCurrentTrack();
         }
     }
 }
 
 void MediaPlayList::enqueue(const MusicAlbum &album)
 {
     for (auto oneTrackIndex = 0; oneTrackIndex < album.tracksCount(); ++oneTrackIndex) {
         enqueue(album.trackFromIndex(oneTrackIndex));
     }
 }
 
 void MediaPlayList::enqueue(const MusicArtist &artist)
 {
     enqueue(artist.name());
 }
 
 void MediaPlayList::enqueue(const QString &artistName)
 {
     beginInsertRows(QModelIndex(), d->mData.size(), d->mData.size());
     d->mData.push_back(MediaPlayListEntry{artistName});
     d->mTrackData.push_back({});
     endInsertRows();
 
     restorePlayListPosition();
     if (!d->mCurrentTrack.isValid()) {
         resetCurrentTrack();
     }
 
     Q_EMIT tracksCountChanged();
     Q_EMIT newArtistInList(artistName);
     Q_EMIT persistentStateChanged();
 }
 
 void MediaPlayList::enqueue(const QUrl &fileName)
 {
     qDebug() << "MediaPlayList::enqueue" << fileName;
     enqueue(MediaPlayListEntry(fileName));
 }
 
 void MediaPlayList::enqueue(const QStringList &files)
 {
     qDebug() << "MediaPlayList::enqueue" << files;
     for (const auto &oneFileName : files) {
         enqueue(QUrl::fromLocalFile(oneFileName));
     }
 }
 
 void MediaPlayList::enqueueAndPlay(const QStringList &files)
 {
     if (files.size() > 0) {
         int previousTrackNumber = tracksCount();
         enqueue(files);
         switchTo(previousTrackNumber);
         Q_EMIT ensurePlay();
     }
 }
 
 void MediaPlayList::enqueue(const QList<qulonglong> &newTrackIds)
 {
     if (newTrackIds.isEmpty()) {
         return;
     }
 
     beginInsertRows(QModelIndex(), d->mData.size(), d->mData.size() + newTrackIds.size() - 1);
     for (auto newTrackId : newTrackIds) {
         d->mData.push_back(MediaPlayListEntry{newTrackId});
         d->mTrackData.push_back({});
         Q_EMIT newTrackByIdInList(newTrackId);
     }
     endInsertRows();
 
     restorePlayListPosition();
     if (!d->mCurrentTrack.isValid()) {
         resetCurrentTrack();
     }
 
     Q_EMIT tracksCountChanged();
     Q_EMIT persistentStateChanged();
 
     Q_EMIT dataChanged(index(rowCount() - 1, 0), index(rowCount() - 1, 0), {MediaPlayList::HasAlbumHeader});
 }
 
 void MediaPlayList::enqueue(const QList<MusicAlbum> &albums,
                             ElisaUtils::PlayListEnqueueMode enqueueMode,
                             ElisaUtils::PlayListEnqueueTriggerPlay triggerPlay)
 {
     if (albums.isEmpty()) {
         return;
     }
 
     auto tracksCount = 0;
     for (const auto &oneAlbum : albums) {
         for (auto oneTrackIndex = 0; oneTrackIndex < oneAlbum.tracksCount(); ++oneTrackIndex) {
             ++tracksCount;
         }
     }
 
     if (enqueueMode == ElisaUtils::ReplacePlayList) {
         clearPlayList();
     }
 
     beginInsertRows(QModelIndex(), d->mData.size(), d->mData.size() + tracksCount - 1);
     for (const auto &oneAlbum : albums) {
         for (auto oneTrackIndex = 0; oneTrackIndex < oneAlbum.tracksCount(); ++oneTrackIndex) {
             const auto &oneTrack = oneAlbum.trackFromIndex(oneTrackIndex);
             d->mData.push_back(MediaPlayListEntry{oneTrack.databaseId()});
             d->mTrackData.push_back(oneTrack);
         }
     }
     endInsertRows();
 
     restorePlayListPosition();
     if (!d->mCurrentTrack.isValid()) {
         resetCurrentTrack();
     }
 
     Q_EMIT tracksCountChanged();
     Q_EMIT persistentStateChanged();
 
     Q_EMIT dataChanged(index(rowCount() - 1, 0), index(rowCount() - 1, 0), {MediaPlayList::HasAlbumHeader});
 
     if (triggerPlay == ElisaUtils::TriggerPlay) {
         Q_EMIT ensurePlay();
     }
 }
 
 void MediaPlayList::enqueue(const QList<MusicAudioTrack> &tracks,
                             ElisaUtils::PlayListEnqueueMode enqueueMode,
                             ElisaUtils::PlayListEnqueueTriggerPlay triggerPlay)
 {
     if (tracks.isEmpty()) {
         return;
     }
 
     if (enqueueMode == ElisaUtils::ReplacePlayList) {
         clearPlayList();
     }
 
     beginInsertRows(QModelIndex(), d->mData.size(), d->mData.size() + tracks.size() - 1);
     for (const auto &oneTrack : tracks) {
         d->mData.push_back(MediaPlayListEntry{oneTrack.databaseId()});
         d->mTrackData.push_back(oneTrack);
     }
     endInsertRows();
 
     restorePlayListPosition();
     if (!d->mCurrentTrack.isValid()) {
         resetCurrentTrack();
     }
 
     Q_EMIT tracksCountChanged();
     Q_EMIT persistentStateChanged();
 
     Q_EMIT dataChanged(index(rowCount() - 1, 0), index(rowCount() - 1, 0), {MediaPlayList::HasAlbumHeader});
 
     if (triggerPlay == ElisaUtils::TriggerPlay) {
         Q_EMIT ensurePlay();
     }
 }
 
 void MediaPlayList::enqueueArtists(const QList<QString> &artistNames,
                                    ElisaUtils::PlayListEnqueueMode enqueueMode,
                                    ElisaUtils::PlayListEnqueueTriggerPlay triggerPlay)
 {
     if (artistNames.isEmpty()) {
         return;
     }
 
     if (enqueueMode == ElisaUtils::ReplacePlayList) {
         clearPlayList();
     }
 
     beginInsertRows(QModelIndex(), d->mData.size(), d->mData.size() + artistNames.size() - 1);
     for (const auto &artistName : artistNames) {
         d->mData.push_back(MediaPlayListEntry{artistName});
         d->mTrackData.push_back({});
         Q_EMIT newArtistInList(artistName);
     }
     endInsertRows();
 
     restorePlayListPosition();
     if (!d->mCurrentTrack.isValid()) {
         resetCurrentTrack();
     }
 
     Q_EMIT tracksCountChanged();
     Q_EMIT persistentStateChanged();
 
     if (triggerPlay == ElisaUtils::TriggerPlay) {
         Q_EMIT ensurePlay();
     }
 }
 
   void MediaPlayList::replaceAndPlay(qulonglong newTrackId)
 {
     clearPlayList();
     enqueue(MediaPlayListEntry(newTrackId));
     Q_EMIT ensurePlay();
 }
 
 void MediaPlayList::replaceAndPlay(const MusicAudioTrack &newTrack)
 {
     clearPlayList();
     enqueue(newTrack);
     Q_EMIT ensurePlay();
 }
 
 void MediaPlayList::replaceAndPlay(const MusicAlbum &album)
 {
     clearPlayList();
     enqueue(album);
     Q_EMIT ensurePlay();
 }
 
 void MediaPlayList::replaceAndPlay(const MusicArtist &artist)
 {
     clearPlayList();
     enqueue(artist.name());
     Q_EMIT ensurePlay();
 }
 
 void MediaPlayList::replaceAndPlay(const QString &artistName)
 {
     clearPlayList();
     enqueue(artistName);
     Q_EMIT ensurePlay();
 }
 
 void MediaPlayList::replaceAndPlay(const QUrl &fileName)
 {
     clearPlayList();
     enqueue(fileName);
     Q_EMIT ensurePlay();
 }
 
 void MediaPlayList::clearPlayList()
 {
     if (d->mData.isEmpty()) {
         return;
     }
 
     beginRemoveRows({}, 0, d->mData.count() - 1);
     d->mData.clear();
     d->mTrackData.clear();
     endRemoveRows();
 
     d->mCurrentPlayListPosition = 0;
     d->mCurrentTrack = QPersistentModelIndex{};
     notifyCurrentTrackChanged();
 
     Q_EMIT tracksCountChanged();
 }
 
 void MediaPlayList::loadPlaylist(const QUrl &fileName)
 {
     d->mLoadPlaylist.clear();
     d->mLoadPlaylist.load(fileName, "m3u");
 }
 
 bool MediaPlayList::savePlaylist(const QUrl &fileName)
 {
     QMediaPlaylist savePlaylist;
 
     for (int i = 0; i < d->mData.size(); ++i) {
         const auto &oneTrack = d->mData.at(i);
         const auto &oneTrackData = d->mTrackData.at(i);
         if (oneTrack.mIsValid) {
             savePlaylist.addMedia(oneTrackData.resourceURI());
         }
     }
 
     return savePlaylist.save(fileName, "m3u");
 }
 
 QVariantMap MediaPlayList::persistentState() const
 {
     auto currentState = QVariantMap();
     auto result = QList<QVariant>();
 
     for (int trackIndex = 0; trackIndex < d->mData.size(); ++trackIndex) {
         auto oneData = QList<QString>();
         const auto &oneEntry = d->mData[trackIndex];
         if (oneEntry.mIsValid) {
             const auto &oneTrack = d->mTrackData[trackIndex];
 
             oneData.push_back(oneTrack.title());
             oneData.push_back(oneTrack.artist());
             oneData.push_back(oneTrack.albumName());
             oneData.push_back(QString::number(oneTrack.trackNumber()));
             oneData.push_back(QString::number(oneTrack.discNumber()));
 
             result.push_back(QVariant(oneData));
         }
     }
 
     currentState[QStringLiteral("playList")] = result;
     currentState[QStringLiteral("currentTrack")] = d->mCurrentPlayListPosition;
     currentState[QStringLiteral("randomPlay")] = d->mRandomPlay;
     currentState[QStringLiteral("repeatPlay")] = d->mRepeatPlay;
 
     return currentState;
 }
 
 MusicListenersManager *MediaPlayList::musicListenersManager() const
 {
     return d->mMusicListenersManager;
 }
 
 int MediaPlayList::tracksCount() const
 {
     return rowCount();
 }
 
 QPersistentModelIndex MediaPlayList::currentTrack() const
 {
     return d->mCurrentTrack;
 }
 
 int MediaPlayList::currentTrackRow() const
 {
     return d->mCurrentTrack.row();
 }
 
 bool MediaPlayList::randomPlay() const
 {
     return d->mRandomPlay;
 }
 
 bool MediaPlayList::repeatPlay() const
 {
     return d->mRepeatPlay;
 }
 
 void MediaPlayList::setPersistentState(const QVariantMap &persistentStateValue)
 {
     if (d->mPersistentState == persistentStateValue) {
         return;
     }
 
     qDebug() << "MediaPlayList::setPersistentState" << persistentStateValue;
 
     d->mPersistentState = persistentStateValue;
 
     auto persistentState = d->mPersistentState[QStringLiteral("playList")].toList();
 
     for (auto &oneData : persistentState) {
         auto trackData = oneData.toStringList();
         if (trackData.size() != 5) {
             continue;
         }
 
         auto restoredTitle = trackData[0];
         auto restoredArtist = trackData[1];
         auto restoredAlbum = trackData[2];
         auto restoredTrackNumber = trackData[3].toInt();
         auto restoredDiscNumber = trackData[4].toInt();
 
         enqueue({restoredTitle, restoredArtist, restoredAlbum, restoredTrackNumber, restoredDiscNumber});
     }
 
     restorePlayListPosition();
     restoreRandomPlay();
     restoreRepeatPlay();
 
     Q_EMIT persistentStateChanged();
 }
 
 void MediaPlayList::removeSelection(QList<int> selection)
 {
     std::sort(selection.begin(), selection.end());
     std::reverse(selection.begin(), selection.end());
     for (auto oneItem : selection) {
         removeRow(oneItem);
     }
 }
 
 void MediaPlayList::albumAdded(const QList<MusicAudioTrack> &tracks)
 {
     for (int playListIndex = 0; playListIndex < d->mData.size(); ++playListIndex) {
         auto &oneEntry = d->mData[playListIndex];
 
         if (!oneEntry.mIsArtist || oneEntry.mIsValid) {
             continue;
         }
 
         if (oneEntry.mArtist != tracks.first().artist()) {
             continue;
         }
 
         d->mTrackData[playListIndex] = tracks.first();
         oneEntry.mId = tracks.first().databaseId();
         oneEntry.mIsValid = true;
         oneEntry.mIsArtist = false;
 
         Q_EMIT dataChanged(index(playListIndex, 0), index(playListIndex, 0), {});
 
         if (!d->mCurrentTrack.isValid()) {
             resetCurrentTrack();
         }
 
         if (tracks.size() > 1) {
             beginInsertRows(QModelIndex(), playListIndex + 1, playListIndex - 1 + tracks.size());
             for (int trackIndex = 1; trackIndex < tracks.size(); ++trackIndex) {
                 d->mData.push_back(MediaPlayListEntry{tracks[trackIndex].databaseId()});
                 d->mTrackData.push_back(tracks[trackIndex]);
             }
             endInsertRows();
 
             restorePlayListPosition();
             if (!d->mCurrentTrack.isValid()) {
                 resetCurrentTrack();
             }
 
             Q_EMIT tracksCountChanged();
         }
 
         Q_EMIT persistentStateChanged();
     }
 }
 
 void MediaPlayList::trackChanged(const MusicAudioTrack &track)
 {
     for (int i = 0; i < d->mData.size(); ++i) {
         auto &oneEntry = d->mData[i];
 
         if (!oneEntry.mIsArtist && oneEntry.mIsValid) {
             if (oneEntry.mTrackUrl.isValid() && track.resourceURI() != oneEntry.mTrackUrl) {
                 continue;
             }
 
             if (!oneEntry.mTrackUrl.isValid() && (oneEntry.mId == 0 || track.databaseId() != oneEntry.mId)) {
                 continue;
             }
 
             if (d->mTrackData[i] != track) {
                 d->mTrackData[i] = track;
 
                 Q_EMIT dataChanged(index(i, 0), index(i, 0), {});
 
                 if (!d->mCurrentTrack.isValid()) {
                     resetCurrentTrack();
                 }
             }
             continue;
         } else if (!oneEntry.mIsArtist && !oneEntry.mIsValid && !oneEntry.mTrackUrl.isValid()) {
             if (track.title() != oneEntry.mTitle) {
                 continue;
             }
 
             if (track.albumName() != oneEntry.mAlbum) {
                 continue;
             }
 
             if (track.trackNumber() != oneEntry.mTrackNumber) {
                 continue;
             }
 
             if (track.discNumber() != oneEntry.mDiscNumber) {
                 continue;
             }
 
             d->mTrackData[i] = track;
             oneEntry.mId = track.databaseId();
             oneEntry.mIsValid = true;
 
             Q_EMIT dataChanged(index(i, 0), index(i, 0), {});
 
             if (!d->mCurrentTrack.isValid()) {
                 resetCurrentTrack();
             }
 
             break;
         } else if (!oneEntry.mIsArtist && !oneEntry.mIsValid && oneEntry.mTrackUrl.isValid()) {
             qDebug() << "MediaPlayList::trackChanged" << oneEntry << track;
             qDebug() << "MediaPlayList::trackChanged" << track.resourceURI() << oneEntry.mTrackUrl;
             if (track.resourceURI() != oneEntry.mTrackUrl) {
                 continue;
             }
 
             d->mTrackData[i] = track;
             oneEntry.mId = track.databaseId();
             oneEntry.mIsValid = true;
 
             Q_EMIT dataChanged(index(i, 0), index(i, 0), {});
 
             restorePlayListPosition();
 
             if (!d->mCurrentTrack.isValid()) {
                 resetCurrentTrack();
             }
 
             break;
         }
     }
 }
 
 void MediaPlayList::trackRemoved(qulonglong trackId)
 {
     for (int i = 0; i < d->mData.size(); ++i) {
         auto &oneEntry = d->mData[i];
 
         if (oneEntry.mIsValid) {
             if (oneEntry.mId == trackId) {
                 oneEntry.mIsValid = false;
                 oneEntry.mTitle = d->mTrackData[i].title();
                 oneEntry.mArtist = d->mTrackData[i].artist();
                 oneEntry.mAlbum = d->mTrackData[i].albumName();
                 oneEntry.mTrackNumber = d->mTrackData[i].trackNumber();
                 oneEntry.mDiscNumber = d->mTrackData[i].discNumber();
 
                 Q_EMIT dataChanged(index(i, 0), index(i, 0), {});
 
                 if (!d->mCurrentTrack.isValid()) {
                     resetCurrentTrack();
                 }
             }
         }
     }
 }
 
 void MediaPlayList::setMusicListenersManager(MusicListenersManager *musicListenersManager)
 {
     if (d->mMusicListenersManager == musicListenersManager) {
         return;
     }
 
     d->mMusicListenersManager = musicListenersManager;
 
     if (d->mMusicListenersManager) {
         d->mMusicListenersManager->subscribeForTracks(this);
     }
 
     Q_EMIT musicListenersManagerChanged();
 }
 
 void MediaPlayList::setRandomPlay(bool value)
 {
     d->mRandomPlay = value;
     Q_EMIT randomPlayChanged();
 }
 
 void MediaPlayList::setRepeatPlay(bool value)
 {
     d->mRepeatPlay = value;
     Q_EMIT repeatPlayChanged();
 }
 
 void MediaPlayList::skipNextTrack()
 {
     if (!d->mCurrentTrack.isValid()) {
         return;
     }
 
     if (!d->mRandomPlay && (d->mCurrentTrack.row() >= (rowCount() - 1))) {
         if (!d->mRepeatPlay) {
             Q_EMIT playListFinished();
         }
 
         if (rowCount() == 1) {
             d->mCurrentTrack = QPersistentModelIndex{};
             notifyCurrentTrackChanged();
         }
 
         resetCurrentTrack();
 
         return;
     }
 
     if (d->mRandomPlay) {
         int randomValue = qrand();
         randomValue = randomValue % (rowCount());
         d->mCurrentTrack = index(randomValue, 0);
     } else {
         d->mCurrentTrack = index(d->mCurrentTrack.row() + 1, 0);
     }
 
     notifyCurrentTrackChanged();
 }
 
 void MediaPlayList::skipPreviousTrack()
 {
     if (!d->mCurrentTrack.isValid()) {
         return;
     }
 
     if (!d->mRandomPlay && !d->mRepeatPlay && d->mCurrentTrack.row() <= 0) {
         return;
     }
 
     if (d->mRandomPlay) {
         int randomValue = qrand();
         randomValue = randomValue % (rowCount());
         d->mCurrentTrack = index(randomValue, 0);
     } else {
         if (d->mRepeatPlay) {
             if (d->mCurrentTrack.row() == 0) {
                 d->mCurrentTrack = index(rowCount() - 1, 0);
             } else {
                 d->mCurrentTrack = index(d->mCurrentTrack.row() - 1, 0);
             }
         } else {
             d->mCurrentTrack = index(d->mCurrentTrack.row() - 1, d->mCurrentTrack.column(), d->mCurrentTrack.parent());
         }
     }
     notifyCurrentTrackChanged();
 }
 
 void MediaPlayList::seedRandomGenerator(uint seed)
 {
     qsrand(seed);
 }
 
 void MediaPlayList::switchTo(int row)
 {
     if (!d->mCurrentTrack.isValid()) {
         return;
     }
 
     d->mCurrentTrack = index(row, 0);
 
     notifyCurrentTrackChanged();
 }
 
 void MediaPlayList::trackInError(QUrl sourceInError, QMediaPlayer::Error playerError)
 {
     Q_UNUSED(playerError)
 
     for (int i = 0; i < d->mData.size(); ++i) {
         auto &oneTrack = d->mData[i];
         if (oneTrack.mIsValid) {
             const auto &oneTrackData = d->mTrackData.at(i);
 
             if (oneTrackData.resourceURI() == sourceInError) {
                 oneTrack.mIsValid = false;
                 Q_EMIT dataChanged(index(i, 0), index(i, 0), {ColumnsRoles::IsValidRole});
             }
         }
     }
 }
 
 bool MediaPlayList::rowHasHeader(int row) const
 {
     if (row >= rowCount()) {
         return false;
     }
 
     if (row < 0) {
         return false;
     }
 
     if (row - 1 < 0) {
         return true;
     }
 
     auto currentAlbumTitle = QString();
     auto currentAlbumArtist = QString();
     if (d->mData[row].mIsValid) {
         currentAlbumTitle = d->mTrackData[row].albumName();
         currentAlbumArtist = d->mTrackData[row].albumArtist();
     } else {
         currentAlbumTitle = d->mData[row].mAlbum;
         currentAlbumArtist = d->mData[row].mArtist;
     }
 
     auto previousAlbumTitle = QString();
     auto previousAlbumArtist = QString();
     if (d->mData[row - 1].mIsValid) {
         previousAlbumTitle = d->mTrackData[row - 1].albumName();
         previousAlbumArtist = d->mTrackData[row - 1].albumArtist();
     } else {
         previousAlbumTitle = d->mData[row - 1].mAlbum;
         previousAlbumArtist = d->mData[row - 1].mArtist;
     }
 
     if (currentAlbumTitle == previousAlbumTitle && currentAlbumArtist == previousAlbumArtist) {
         return false;
     }
 
     return true;
 }
 
 void MediaPlayList::loadPlayListLoaded()
 {
     clearPlayList();
 
     for (int i = 0; i < d->mLoadPlaylist.mediaCount(); ++i) {
         enqueue(d->mLoadPlaylist.media(i).canonicalUrl());
     }
 
     restorePlayListPosition();
     restoreRandomPlay();
     restoreRepeatPlay();
 
     Q_EMIT persistentStateChanged();
 
     d->mLoadPlaylist.clear();
     Q_EMIT playListLoaded();
 }
 
 void MediaPlayList::loadPlayListLoadFailed()
 {
     d->mLoadPlaylist.clear();
     Q_EMIT playListLoadFailed();
 }
 
 void MediaPlayList::resetCurrentTrack()
 {
     for(int row = 0; row < rowCount(); ++row) {
         auto candidateTrack = index(row, 0);
 
         if (candidateTrack.isValid() && candidateTrack.data(ColumnsRoles::IsValidRole).toBool()) {
             d->mCurrentTrack = candidateTrack;
             notifyCurrentTrackChanged();
             break;
         }
     }
 }
 
 void MediaPlayList::notifyCurrentTrackChanged()
 {
     Q_EMIT currentTrackChanged();
     Q_EMIT currentTrackRowChanged();
     bool currentTrackIsValid = d->mCurrentTrack.isValid();
     if (currentTrackIsValid) {
         d->mCurrentPlayListPosition = d->mCurrentTrack.row();
     }
 }
 
 void MediaPlayList::restorePlayListPosition()
 {
     auto playerCurrentTrack = d->mPersistentState.find(QStringLiteral("currentTrack"));
     if (playerCurrentTrack != d->mPersistentState.end()) {
         auto newIndex = index(playerCurrentTrack->toInt(), 0);
         if (newIndex.isValid() && (newIndex != d->mCurrentTrack)) {
             d->mCurrentTrack = newIndex;
             notifyCurrentTrackChanged();
 
             if (d->mCurrentTrack.isValid()) {
                 d->mPersistentState.erase(playerCurrentTrack);
             }
         }
     }
 }
 
 void MediaPlayList::restoreRandomPlay()
 {
     auto randomPlayStoredValue = d->mPersistentState.find(QStringLiteral("randomPlay"));
     if (randomPlayStoredValue != d->mPersistentState.end()) {
         setRandomPlay(randomPlayStoredValue->toBool());
         d->mPersistentState.erase(randomPlayStoredValue);
     }
 }
 
 void MediaPlayList::restoreRepeatPlay()
 {
     auto repeatPlayStoredValue = d->mPersistentState.find(QStringLiteral("repeatPlay"));
     if (repeatPlayStoredValue != d->mPersistentState.end()) {
         setRepeatPlay(repeatPlayStoredValue->toBool());
         d->mPersistentState.erase(repeatPlayStoredValue);
     }
 }
 
 QDebug operator<<(QDebug stream, const MediaPlayListEntry &data)
 {
     stream << data.mTitle << data.mAlbum << data.mArtist << data.mTrackUrl << data.mTrackNumber << data.mDiscNumber << data.mId << data.mIsValid;
     return stream;
 }
 
 #include "moc_mediaplaylist.cpp"
diff --git a/src/models/singlealbumproxymodel.cpp b/src/models/singlealbumproxymodel.cpp
index 08dec75f..c45280e5 100644
--- a/src/models/singlealbumproxymodel.cpp
+++ b/src/models/singlealbumproxymodel.cpp
@@ -1,107 +1,105 @@
 /*
  * Copyright 2017 Alexander Stippich <a.stippich@gmx.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 3 of the License, or (at your option) any later version.
  *
  * This library 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "singlealbumproxymodel.h"
 
 #include "albummodel.h"
 
 #include <QReadLocker>
 #include <QtConcurrentRun>
 
 SingleAlbumProxyModel::SingleAlbumProxyModel(QObject *parent) : AbstractMediaProxyModel(parent)
 {
 }
 
-SingleAlbumProxyModel::~SingleAlbumProxyModel()
-{
-}
+SingleAlbumProxyModel::~SingleAlbumProxyModel() = default;
 
 bool SingleAlbumProxyModel::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
 {
     bool result = false;
 
     for (int column = 0, columnCount = sourceModel()->columnCount(source_parent); column < columnCount; ++column) {
         auto currentIndex = sourceModel()->index(source_row, column, source_parent);
 
         const auto &titleValue = sourceModel()->data(currentIndex, AlbumModel::TitleRole).toString();
         const auto maximumRatingValue = sourceModel()->data(currentIndex, AlbumModel::RatingRole).toInt();
 
         if (maximumRatingValue < mFilterRating) {
             result = false;
             continue;
         }
 
         if (mFilterExpression.match(titleValue).hasMatch()) {
             result = true;
             continue;
         }
 
         if (result) {
             continue;
         }
 
         if (!result) {
             break;
         }
     }
 
     return result;
 }
 
 void SingleAlbumProxyModel::enqueueToPlayList()
 {
     QtConcurrent::run(&mThreadPool, [=] () {
         QReadLocker locker(&mDataLock);
         auto allTracks = QList<MusicAudioTrack>();
         allTracks.reserve(rowCount());
         for (int rowIndex = 0, maxRowCount = rowCount(); rowIndex < maxRowCount; ++rowIndex) {
             auto currentIndex = index(rowIndex, 0);
             allTracks.push_back(data(currentIndex, AlbumModel::ContainerDataRole).value<MusicAudioTrack>());
         }
         Q_EMIT trackToEnqueue(allTracks,
                               ElisaUtils::AppendPlayList,
                               ElisaUtils::DoNotTriggerPlay);
     });
 }
 
 void SingleAlbumProxyModel::replaceAndPlayOfPlayList()
 {
     QtConcurrent::run(&mThreadPool, [=] () {
         QReadLocker locker(&mDataLock);
         auto allTracks = QList<MusicAudioTrack>();
         allTracks.reserve(rowCount());
         for (int rowIndex = 0, maxRowCount = rowCount(); rowIndex < maxRowCount; ++rowIndex) {
             auto currentIndex = index(rowIndex, 0);
             allTracks.push_back(data(currentIndex, AlbumModel::ContainerDataRole).value<MusicAudioTrack>());
         }
         Q_EMIT trackToEnqueue(allTracks,
                               ElisaUtils::ReplacePlayList,
                               ElisaUtils::TriggerPlay);
     });
 }
 
 void SingleAlbumProxyModel::loadAlbumData(qulonglong databaseId)
 {
-    AlbumModel *albumSourceModel = qobject_cast<AlbumModel *>(this->sourceModel());
+    auto albumSourceModel = qobject_cast<AlbumModel *>(this->sourceModel());
     if(albumSourceModel) {
         albumSourceModel->loadAlbumData(databaseId);
     }
 }
 
 #include "moc_singlealbumproxymodel.cpp"
diff --git a/src/models/singleartistproxymodel.cpp b/src/models/singleartistproxymodel.cpp
index 0d8843b1..e4656607 100644
--- a/src/models/singleartistproxymodel.cpp
+++ b/src/models/singleartistproxymodel.cpp
@@ -1,127 +1,125 @@
 /*
  * Copyright 2016-2017 Matthieu Gallien <matthieu_gallien@yahoo.fr>
  * Copyright 2017 Alexander Stippich <a.stippich@gmx.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 3 of the License, or (at your option) any later version.
  *
  * This library 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "singleartistproxymodel.h"
 
 #include "allalbumsmodel.h"
 
 #include <QReadLocker>
 #include <QtConcurrentRun>
 
 SingleArtistProxyModel::SingleArtistProxyModel(QObject *parent) : AbstractMediaProxyModel(parent)
 {
 }
 
-SingleArtistProxyModel::~SingleArtistProxyModel()
-{
-}
+SingleArtistProxyModel::~SingleArtistProxyModel() = default;
 
 QString SingleArtistProxyModel::artistFilter() const
 {
     return mArtistFilter;
 }
 
 
 void SingleArtistProxyModel::setArtistFilterText(const QString &filterText)
 {
     if (mArtistFilter == filterText)
         return;
 
     mArtistFilter = filterText;
 
     mArtistExpression.setPattern(QStringLiteral(".*") + mArtistFilter + QStringLiteral(".*"));
     mArtistExpression.setPatternOptions(QRegularExpression::CaseInsensitiveOption);
     mArtistExpression.optimize();
 
     invalidate();
 
     Q_EMIT artistFilterTextChanged(mArtistFilter);
 }
 
 bool SingleArtistProxyModel::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
 {
     bool result = false;
 
     for (int column = 0, columnCount = sourceModel()->columnCount(source_parent); column < columnCount; ++column) {
         auto currentIndex = sourceModel()->index(source_row, column, source_parent);
 
         const auto &titleValue = sourceModel()->data(currentIndex, AllAlbumsModel::TitleRole).toString();
         const auto &artistValue = sourceModel()->data(currentIndex, AllAlbumsModel::AllArtistsRole).toString();
         const auto maximumRatingValue = sourceModel()->data(currentIndex, AllAlbumsModel::HighestTrackRating).toInt();
 
         if (maximumRatingValue < mFilterRating) {
             result = false;
             continue;
         }
 
         if (mArtistExpression.match(artistValue).hasMatch()) {
             if (mFilterExpression.match(titleValue).hasMatch()) {
                 result = true;
                 continue;
             }
 
         }
 
         if (result) {
             continue;
         }
 
         if (!result) {
             break;
         }
     }
 
     return result;
 }
 
 void SingleArtistProxyModel::enqueueToPlayList()
 {
     QtConcurrent::run(&mThreadPool, [=] () {
         QReadLocker locker(&mDataLock);
         auto allAlbums = QList<MusicAlbum>();
         allAlbums.reserve(rowCount());
         for (int rowIndex = 0, maxRowCount = rowCount(); rowIndex < maxRowCount; ++rowIndex) {
             auto currentIndex = index(rowIndex, 0);
             allAlbums.push_back(data(currentIndex, AllAlbumsModel::ContainerDataRole). value<MusicAlbum>());
         }
         Q_EMIT albumToEnqueue(allAlbums,
                               ElisaUtils::AppendPlayList,
                               ElisaUtils::DoNotTriggerPlay);
     });
 }
 
 void SingleArtistProxyModel::replaceAndPlayOfPlayList()
 {
     QtConcurrent::run(&mThreadPool, [=] () {
         QReadLocker locker(&mDataLock);
         auto allAlbums = QList<MusicAlbum>();
         allAlbums.reserve(rowCount());
         for (int rowIndex = 0, maxRowCount = rowCount(); rowIndex < maxRowCount; ++rowIndex) {
             auto currentIndex = index(rowIndex, 0);
             allAlbums.push_back(data(currentIndex, AllAlbumsModel::ContainerDataRole). value<MusicAlbum>());
         }
         Q_EMIT albumToEnqueue(allAlbums,
                               ElisaUtils::ReplacePlayList,
                               ElisaUtils::TriggerPlay);
     });
 }
 
 
 #include "moc_singleartistproxymodel.cpp"
diff --git a/src/mpris2/mediaplayer2player.cpp b/src/mpris2/mediaplayer2player.cpp
index aa73b475..537e0d94 100644
--- a/src/mpris2/mediaplayer2player.cpp
+++ b/src/mpris2/mediaplayer2player.cpp
@@ -1,412 +1,412 @@
 /***************************************************************************
  *   Copyright 2014 Sujith Haridasan <sujith.haridasan@kdemail.net>        *
  *   Copyright 2014 Ashish Madeti <ashishmadeti@gmail.com>                 *
  *   Copyright 2016 Matthieu Gallien <mgallien@mgallien.fr>                *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU 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 General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the                         *
  *   Free Software Foundation, Inc.,                                       *
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA .        *
  ***************************************************************************/
 
 #include "mediaplayer2player.h"
 #include "mpris2.h"
 
 #include "mediaplaylist.h"
 #include "manageaudioplayer.h"
 #include "managemediaplayercontrol.h"
 #include "manageheaderbar.h"
 #include "audiowrapper.h"
 
 #include <QCryptographicHash>
 #include <QStringList>
 #include <QMetaClassInfo>
 #include <QDBusMessage>
 #include <QDBusConnection>
 
 #include <QDebug>
 
 static const double MAX_RATE = 1.0;
 static const double MIN_RATE = 1.0;
 
 MediaPlayer2Player::MediaPlayer2Player(MediaPlayList *playListControler, ManageAudioPlayer *manageAudioPlayer,
                                        ManageMediaPlayerControl *manageMediaPlayerControl, ManageHeaderBar *manageHeaderBar, AudioWrapper *audioPlayer, QObject* parent)
     : QDBusAbstractAdaptor(parent), m_playListControler(playListControler), m_manageAudioPlayer(manageAudioPlayer),
       m_manageMediaPlayerControl(manageMediaPlayerControl), m_manageHeaderBar(manageHeaderBar), m_audioPlayer(audioPlayer)
 {
     if (!m_playListControler) {
         return;
     }
 
     connect(m_manageAudioPlayer, &ManageAudioPlayer::playerSourceChanged,
             this, &MediaPlayer2Player::playerSourceChanged, Qt::QueuedConnection);
     connect(m_manageMediaPlayerControl, &ManageMediaPlayerControl::playControlEnabledChanged,
             this, &MediaPlayer2Player::playControlEnabledChanged);
     connect(m_manageMediaPlayerControl, &ManageMediaPlayerControl::skipBackwardControlEnabledChanged,
             this, &MediaPlayer2Player::skipBackwardControlEnabledChanged);
     connect(m_manageMediaPlayerControl, &ManageMediaPlayerControl::skipForwardControlEnabledChanged,
             this, &MediaPlayer2Player::skipForwardControlEnabledChanged);
     connect(m_manageAudioPlayer, &ManageAudioPlayer::playerPlaybackStateChanged,
             this, &MediaPlayer2Player::playerPlaybackStateChanged);
     connect(m_manageAudioPlayer, &ManageAudioPlayer::playerIsSeekableChanged,
             this, &MediaPlayer2Player::playerIsSeekableChanged);
     connect(m_manageAudioPlayer, &ManageAudioPlayer::playerPositionChanged,
             this, &MediaPlayer2Player::audioPositionChanged);
     connect(m_manageAudioPlayer, &ManageAudioPlayer::audioDurationChanged,
             this, &MediaPlayer2Player::audioDurationChanged);
     connect(m_audioPlayer, &AudioWrapper::volumeChanged,
             this, &MediaPlayer2Player::playerVolumeChanged);
 
     m_volume = m_audioPlayer->volume();
     signalPropertiesChange(QStringLiteral("Volume"), Volume());
 
     m_mediaPlayerPresent = 1;
 }
 
 MediaPlayer2Player::~MediaPlayer2Player()
 = default;
 
 QString MediaPlayer2Player::PlaybackStatus() const
 {
     QString result;
 
     if (!m_playListControler) {
         result = QStringLiteral("Stopped");
         return result;
     }
 
     if (m_manageAudioPlayer->playerPlaybackState() == ManageAudioPlayer::StoppedState) {
         result = QStringLiteral("Stopped");
     } else if (m_manageAudioPlayer->playerPlaybackState() == ManageAudioPlayer::PlayingState) {
         result = QStringLiteral("Playing");
     } else {
         result = QStringLiteral("Paused");
     }
 
     return result;
 }
 
 bool MediaPlayer2Player::CanGoNext() const
 {
     return m_canGoNext;
 }
 
 void MediaPlayer2Player::Next()
 {
     emit next();
 
     if (m_playListControler) {
         m_playListControler->skipNextTrack();
     }
 }
 
 bool MediaPlayer2Player::CanGoPrevious() const
 {
     return m_canGoPrevious;
 }
 
 void MediaPlayer2Player::Previous()
 {
     emit previous();
 
     if (m_playListControler) {
         m_playListControler->skipPreviousTrack();
     }
 }
 
 bool MediaPlayer2Player::CanPause() const
 {
     return m_canPlay;
 }
 
 void MediaPlayer2Player::Pause()
 {
     if (m_playListControler) {
         m_manageAudioPlayer->ensurePause();
     }
 }
 
 void MediaPlayer2Player::PlayPause()
 {
     emit playPause();
 
     if (m_playListControler) {
         m_manageAudioPlayer->playPause();
     }
 }
 
 void MediaPlayer2Player::Stop()
 {
     emit stop();
 }
 
 bool MediaPlayer2Player::CanPlay() const
 {
     return m_canPlay;
 }
 
 void MediaPlayer2Player::Play()
 {
     if (m_playListControler) {
         m_manageAudioPlayer->ensurePlay();
     }
 }
 
 double MediaPlayer2Player::Volume() const
 {
     return m_volume;
 }
 
 void MediaPlayer2Player::setVolume(double volume)
 {
     m_volume= qBound(0.0, volume, 1.0);
     emit volumeChanged(m_volume);
 
     m_audioPlayer->setVolume(100 * m_volume);
 
     signalPropertiesChange(QStringLiteral("Volume"), Volume());
 }
 
 QVariantMap MediaPlayer2Player::Metadata() const
 {
     return m_metadata;
 }
 
 qlonglong MediaPlayer2Player::Position() const
 {
     return m_position;
 }
 
 void MediaPlayer2Player::setPropertyPosition(int newPositionInMs)
 {
     m_position = qlonglong(newPositionInMs) * 1000;
     signalPropertiesChange(QStringLiteral("Position"), Position());
 
     Q_EMIT Seeked(m_position);
 }
 
 double MediaPlayer2Player::Rate() const
 {
     return m_rate;
 }
 
 void MediaPlayer2Player::setRate(double newRate)
 {
     if (newRate == 0) {
         Pause();
     } else {
         m_rate = qBound(MinimumRate(), newRate, MaximumRate());
         emit rateChanged(m_rate);
 
         signalPropertiesChange(QStringLiteral("Rate"), Rate());
     }
 }
 
 double MediaPlayer2Player::MinimumRate() const
 {
     return MIN_RATE;
 }
 
 double MediaPlayer2Player::MaximumRate() const
 {
     return MAX_RATE;
 }
 
 bool MediaPlayer2Player::CanSeek() const
 {
     return m_playerIsSeekableChanged;
 }
 
 bool MediaPlayer2Player::CanControl() const
 {
     return true;
 }
 
 void MediaPlayer2Player::Seek(qlonglong Offset)
 {
     if (mediaPlayerPresent()) {
-        int offset = (m_position + Offset) / 1000;
-        m_manageAudioPlayer->playerSeek(offset);
+        auto offset = (m_position + Offset) / 1000;
+        m_manageAudioPlayer->playerSeek(int(offset));
     }
 }
 
 void MediaPlayer2Player::emitSeeked(int pos)
 {
     emit Seeked(qlonglong(pos) * 1000);
 }
 
 void MediaPlayer2Player::SetPosition(const QDBusObjectPath &trackId, qlonglong pos)
 {
     if (trackId.path() == m_currentTrackId) {
-        m_manageAudioPlayer->playerSeek(pos / 1000);
+        m_manageAudioPlayer->playerSeek(int(pos / 1000));
     }
 }
 
 void MediaPlayer2Player::OpenUri(const QString &uri)
 {
     Q_UNUSED(uri);
 }
 
 void MediaPlayer2Player::playerSourceChanged()
 {
     if (!m_playListControler) {
         return;
     }
 
     setCurrentTrack(m_manageAudioPlayer->playListPosition());
 }
 
 void MediaPlayer2Player::playControlEnabledChanged()
 {
     if (!m_playListControler) {
         return;
     }
 
     m_canPlay = m_manageMediaPlayerControl->playControlEnabled();
 
     signalPropertiesChange(QStringLiteral("CanPause"), CanPause());
     signalPropertiesChange(QStringLiteral("CanPlay"), CanPlay());
 
     emit canPauseChanged();
     emit canPlayChanged();
 }
 
 void MediaPlayer2Player::skipBackwardControlEnabledChanged()
 {
     if (!m_playListControler) {
         return;
     }
 
     m_canGoPrevious = m_manageMediaPlayerControl->skipBackwardControlEnabled();
 
     signalPropertiesChange(QStringLiteral("CanGoPrevious"), CanGoPrevious());
     emit canGoPreviousChanged();
 }
 
 void MediaPlayer2Player::skipForwardControlEnabledChanged()
 {
     if (!m_playListControler) {
         return;
     }
 
     m_canGoNext = m_manageMediaPlayerControl->skipForwardControlEnabled();
 
     signalPropertiesChange(QStringLiteral("CanGoNext"), CanGoNext());
     emit canGoNextChanged();
 }
 
 void MediaPlayer2Player::playerPlaybackStateChanged()
 {
     signalPropertiesChange(QStringLiteral("PlaybackStatus"), PlaybackStatus());
     emit playbackStatusChanged();
 
     playerIsSeekableChanged();
 }
 
 void MediaPlayer2Player::playerIsSeekableChanged()
 {
     m_playerIsSeekableChanged = m_manageAudioPlayer->playerIsSeekable();
 
     signalPropertiesChange(QStringLiteral("CanSeek"), CanSeek());
     emit canSeekChanged();
 }
 
 void MediaPlayer2Player::audioPositionChanged()
 {
     setPropertyPosition(m_manageAudioPlayer->playerPosition());
 }
 
 void MediaPlayer2Player::audioDurationChanged()
 {
     m_metadata = getMetadataOfCurrentTrack();
     signalPropertiesChange(QStringLiteral("Metadata"), Metadata());
 
     skipBackwardControlEnabledChanged();
     skipForwardControlEnabledChanged();
     playerPlaybackStateChanged();
     playerIsSeekableChanged();
     setPropertyPosition(m_manageAudioPlayer->playerPosition());
 }
 
 void MediaPlayer2Player::playerVolumeChanged()
 {
     setVolume(m_audioPlayer->volume() / 100.0);
 }
 
 int MediaPlayer2Player::currentTrack() const
 {
     return m_manageAudioPlayer->playListPosition();
 }
 
 void MediaPlayer2Player::setCurrentTrack(int newTrackPosition)
 {
     m_currentTrack = m_manageAudioPlayer->playerSource().toString();
     m_currentTrackId = QDBusObjectPath(QStringLiteral("/org/kde/elisa/playlist/") + QString::number(newTrackPosition)).path();
 
     emit currentTrackChanged();
 }
 
 QVariantMap MediaPlayer2Player::getMetadataOfCurrentTrack()
 {
     auto result = QVariantMap();
 
     result[QStringLiteral("mpris:trackid")] = QVariant::fromValue<QDBusObjectPath>(QDBusObjectPath(m_currentTrackId));
     result[QStringLiteral("mpris:length")] = qlonglong(m_manageAudioPlayer->audioDuration()) * 1000;
     //convert milli-seconds into micro-seconds
     result[QStringLiteral("xesam:title")] = m_manageHeaderBar->title();
     result[QStringLiteral("xesam:url")] = m_manageAudioPlayer->playerSource().toString();
     result[QStringLiteral("xesam:album")] = m_manageHeaderBar->album();
     result[QStringLiteral("xesam:artist")] = QStringList{m_manageHeaderBar->artist().toString()};
     result[QStringLiteral("mpris:artUrl")] = m_manageHeaderBar->image().toString();
 
     return result;
 }
 
 int MediaPlayer2Player::mediaPlayerPresent() const
 {
     return m_mediaPlayerPresent;
 }
 
 void MediaPlayer2Player::setMediaPlayerPresent(int status)
 {
     if (m_mediaPlayerPresent != status) {
         m_mediaPlayerPresent = status;
         emit mediaPlayerPresentChanged();
 
         signalPropertiesChange(QStringLiteral("CanGoNext"), CanGoNext());
         signalPropertiesChange(QStringLiteral("CanGoPrevious"), CanGoPrevious());
         signalPropertiesChange(QStringLiteral("CanPause"), CanPause());
         signalPropertiesChange(QStringLiteral("CanPlay"), CanPlay());
         emit canGoNextChanged();
         emit canGoPreviousChanged();
         emit canPauseChanged();
         emit canPlayChanged();
     }
 }
 
 void MediaPlayer2Player::signalPropertiesChange(const QString &property, const QVariant &value)
 {
     QVariantMap properties;
     properties[property] = value;
     const int ifaceIndex = metaObject()->indexOfClassInfo("D-Bus Interface");
     QDBusMessage msg = QDBusMessage::createSignal(QStringLiteral("/org/mpris/MediaPlayer2"),
         QStringLiteral("org.freedesktop.DBus.Properties"), QStringLiteral("PropertiesChanged"));
 
     msg << QLatin1String(metaObject()->classInfo(ifaceIndex).value());
     msg << properties;
     msg << QStringList();
 
     QDBusConnection::sessionBus().send(msg);
 }
 
 #include "moc_mediaplayer2player.cpp"
diff --git a/src/mpris2/mpris2.cpp b/src/mpris2/mpris2.cpp
index d852ccf0..29c06319 100644
--- a/src/mpris2/mpris2.cpp
+++ b/src/mpris2/mpris2.cpp
@@ -1,226 +1,226 @@
 /***************************************************************************
  *   Copyright 2014 Sujith Haridasan <sujith.haridasan@kdemail.net>        *
  *   Copyright 2014 Ashish Madeti <ashishmadeti@gmail.com>                 *
  *   Copyright 2016 Matthieu Gallien <mgallien@mgallien.fr>                *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU 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 General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the                         *
  *   Free Software Foundation, Inc.,                                       *
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA .        *
  ***************************************************************************/
 
 #include "mpris2.h"
 #include "mediaplayer2.h"
 #include "mediaplayer2player.h"
 #include "mediaplaylist.h"
 
 #include <QDBusConnection>
 #include <QDir>
 #include <QAbstractItemModel>
 
 #include <QtGlobal>
 
 #if defined Q_OS_WIN
 #include <Windows.h>
 #else
 #include <unistd.h>
 #endif
 
 Mpris2::Mpris2(QObject* parent)
     : QObject(parent)
 {
 }
 
 void Mpris2::initDBusService()
 {
     QString mspris2Name(QStringLiteral("org.mpris.MediaPlayer2.") + m_playerName);
 
     bool success = QDBusConnection::sessionBus().registerService(mspris2Name);
 
     // If the above failed, it's likely because we're not the first instance
     // or the name is already taken. In that event the MPRIS2 spec wants the
     // following:
     if (!success) {
 #if defined Q_OS_WIN
         success = QDBusConnection::sessionBus().registerService(mspris2Name + QStringLiteral(".instance") + QString::number(GetCurrentProcessId()));
 #else
         success = QDBusConnection::sessionBus().registerService(mspris2Name + QStringLiteral(".instance") + QString::number(getpid()));
 #endif
     }
 
     if (success) {
-        m_mp2 = new MediaPlayer2(this);
-        m_mp2p = new MediaPlayer2Player(m_playListControler, m_manageAudioPlayer, m_manageMediaPlayerControl, m_manageHeaderBar, m_audioPlayer, this);
+        m_mp2 = std::make_unique<MediaPlayer2>(this);
+        m_mp2p = std::make_unique<MediaPlayer2Player>(m_playListControler, m_manageAudioPlayer, m_manageMediaPlayerControl, m_manageHeaderBar, m_audioPlayer, this);
 
         QDBusConnection::sessionBus().registerObject(QStringLiteral("/org/mpris/MediaPlayer2"), this, QDBusConnection::ExportAdaptors);
 
-        connect(m_mp2, SIGNAL(raisePlayer()), this, SIGNAL(raisePlayer()));
+        connect(m_mp2.get(), SIGNAL(raisePlayer()), this, SIGNAL(raisePlayer()));
     }
 }
 
 Mpris2::~Mpris2()
 = default;
 
 QString Mpris2::playerName() const
 {
     return m_playerName;
 }
 
 QAbstractItemModel *Mpris2::playListModel() const
 {
     return m_playListModel;
 }
 
 MediaPlayList *Mpris2::playListControler() const
 {
     return m_playListControler;
 }
 
 ManageAudioPlayer *Mpris2::audioPlayerManager() const
 {
     return m_manageAudioPlayer;
 }
 
 ManageMediaPlayerControl *Mpris2::manageMediaPlayerControl() const
 {
     return m_manageMediaPlayerControl;
 }
 
 ManageHeaderBar *Mpris2::headerBarManager() const
 {
     return m_manageHeaderBar;
 }
 
 AudioWrapper *Mpris2::audioPlayer() const
 {
     return m_audioPlayer;
 }
 
 void Mpris2::setPlayerName(const QString &playerName)
 {
     if (m_playerName == playerName) {
         return;
     }
 
     m_playerName = playerName;
 
     if (m_playListModel && m_playListControler && m_manageAudioPlayer && m_manageMediaPlayerControl && m_manageHeaderBar && m_audioPlayer && !m_playerName.isEmpty()) {
         if (!m_mp2) {
             initDBusService();
         }
     }
 
     emit playerNameChanged();
 }
 
 void Mpris2::setPlayListModel(QAbstractItemModel *playListModel)
 {
     if (m_playListModel == playListModel) {
         return;
     }
 
     m_playListModel = playListModel;
 
     if (m_playListModel && m_playListControler && m_manageAudioPlayer && m_manageMediaPlayerControl && m_manageHeaderBar && m_audioPlayer && !m_playerName.isEmpty()) {
         if (!m_mp2) {
             initDBusService();
         }
     }
 
     emit playListModelChanged();
 }
 
 void Mpris2::setPlayListControler(MediaPlayList *playListControler)
 {
     if (m_playListControler == playListControler) {
         return;
     }
 
     m_playListControler = playListControler;
 
     if (m_playListModel && m_playListControler && m_manageAudioPlayer && m_manageMediaPlayerControl && m_manageHeaderBar && m_audioPlayer && !m_playerName.isEmpty()) {
         if (!m_mp2) {
             initDBusService();
         }
     }
 
     emit playListControlerChanged();
 }
 
 void Mpris2::setAudioPlayerManager(ManageAudioPlayer *manageAudioPlayer)
 {
     if (m_manageAudioPlayer == manageAudioPlayer) {
         return;
     }
 
     m_manageAudioPlayer = manageAudioPlayer;
 
     if (m_playListModel && m_playListControler && m_manageAudioPlayer && m_manageMediaPlayerControl && m_manageHeaderBar && m_audioPlayer && !m_playerName.isEmpty()) {
         if (!m_mp2) {
             initDBusService();
         }
     }
 
     emit audioPlayerManagerChanged();
 }
 
 void Mpris2::setManageMediaPlayerControl(ManageMediaPlayerControl *manageMediaPlayerControl)
 {
     if (m_manageMediaPlayerControl == manageMediaPlayerControl) {
         return;
     }
 
     m_manageMediaPlayerControl = manageMediaPlayerControl;
 
     if (m_playListModel && m_playListControler && m_manageAudioPlayer && m_manageMediaPlayerControl && m_manageHeaderBar && m_audioPlayer && !m_playerName.isEmpty()) {
         if (!m_mp2) {
             initDBusService();
         }
     }
 
     emit manageMediaPlayerControlChanged();
 }
 
 void Mpris2::setHeaderBarManager(ManageHeaderBar *manageHeaderBar)
 {
     if (m_manageHeaderBar == manageHeaderBar)
         return;
 
     m_manageHeaderBar = manageHeaderBar;
 
     if (m_playListModel && m_playListControler && m_manageAudioPlayer && m_manageMediaPlayerControl && m_manageHeaderBar && m_audioPlayer && !m_playerName.isEmpty()) {
         if (!m_mp2) {
             initDBusService();
         }
     }
 
     emit headerBarManagerChanged();
 }
 
 void Mpris2::setAudioPlayer(AudioWrapper *audioPlayer)
 {
     if (m_audioPlayer == audioPlayer)
         return;
 
     m_audioPlayer = audioPlayer;
 
     if (m_playListModel && m_playListControler && m_manageAudioPlayer && m_manageMediaPlayerControl && m_manageHeaderBar && m_audioPlayer && !m_playerName.isEmpty()) {
         if (!m_mp2) {
             initDBusService();
         }
     }
 
     emit audioPlayerChanged();
 }
 
 #include "moc_mpris2.cpp"
diff --git a/src/mpris2/mpris2.h b/src/mpris2/mpris2.h
index 2ec49f11..869ee3b3 100644
--- a/src/mpris2/mpris2.h
+++ b/src/mpris2/mpris2.h
@@ -1,143 +1,144 @@
 /***************************************************************************
  *   Copyright 2014 Sujith Haridasan <sujith.haridasan@kdemail.net>        *
  *   Copyright 2014 Ashish Madeti <ashishmadeti@gmail.com>                 *
  *   Copyright 2016 Matthieu Gallien <mgallien@mgallien.fr>                *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU 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 General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the                         *
  *   Free Software Foundation, Inc.,                                       *
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA .        *
  ***************************************************************************/
 
 #ifndef MEDIACENTER_MPRIS2_H
 #define MEDIACENTER_MPRIS2_H
 
 #include <QObject>
 #include <QSharedPointer>
 #include <QVariantMap>
+#include <memory>
 
 class MediaPlayer2Player;
 class MediaPlayer2;
 class QAbstractItemModel;
 class MediaPlayList;
 class ManageAudioPlayer;
 class ManageMediaPlayerControl;
 class ManageHeaderBar;
 class AudioWrapper;
 
 class Mpris2 : public QObject
 {
     Q_OBJECT
 
     Q_PROPERTY(QString playerName
                READ playerName
                WRITE setPlayerName
                NOTIFY playerNameChanged)
 
     Q_PROPERTY(QAbstractItemModel* playListModel
                READ playListModel
                WRITE setPlayListModel
                NOTIFY playListModelChanged)
 
     Q_PROPERTY(MediaPlayList* playListControler
                READ playListControler
                WRITE setPlayListControler
                NOTIFY playListControlerChanged)
 
     Q_PROPERTY(ManageAudioPlayer* audioPlayerManager
                READ audioPlayerManager
                WRITE setAudioPlayerManager
                NOTIFY audioPlayerManagerChanged)
 
     Q_PROPERTY(ManageMediaPlayerControl* manageMediaPlayerControl
                READ manageMediaPlayerControl
                WRITE setManageMediaPlayerControl
                NOTIFY manageMediaPlayerControlChanged)
 
     Q_PROPERTY(ManageHeaderBar* headerBarManager
                READ headerBarManager
                WRITE setHeaderBarManager
                NOTIFY headerBarManagerChanged)
 
     Q_PROPERTY(AudioWrapper* audioPlayer
                READ audioPlayer
                WRITE setAudioPlayer
                NOTIFY audioPlayerChanged)
 
 public:
     explicit Mpris2(QObject* parent = nullptr);
     ~Mpris2() override;
 
     QString playerName() const;
 
     QAbstractItemModel* playListModel() const;
 
     MediaPlayList* playListControler() const;
 
     ManageAudioPlayer* audioPlayerManager() const;
 
     ManageMediaPlayerControl* manageMediaPlayerControl() const;
 
     ManageHeaderBar* headerBarManager() const;
 
     AudioWrapper* audioPlayer() const;
 
 public Q_SLOTS:
 
     void setPlayerName(const QString &playerName);
 
     void setPlayListModel(QAbstractItemModel* playListModel);
 
     void setPlayListControler(MediaPlayList* playListControler);
 
     void setAudioPlayerManager(ManageAudioPlayer* audioPlayerManager);
 
     void setManageMediaPlayerControl(ManageMediaPlayerControl* manageMediaPlayerControl);
 
     void setHeaderBarManager(ManageHeaderBar* headerBarManager);
 
     void setAudioPlayer(AudioWrapper* audioPlayer);
 
 Q_SIGNALS:
     void raisePlayer();
 
     void playerNameChanged();
 
     void playListModelChanged();
 
     void playListControlerChanged();
 
     void audioPlayerManagerChanged();
 
     void manageMediaPlayerControlChanged();
 
     void headerBarManagerChanged();
 
     void audioPlayerChanged();
 
 private:
 
     void initDBusService();
 
-    MediaPlayer2 *m_mp2 = nullptr;
-    MediaPlayer2Player *m_mp2p = nullptr;
+    std::unique_ptr<MediaPlayer2> m_mp2;
+    std::unique_ptr<MediaPlayer2Player> m_mp2p;
     QString m_playerName;
     QAbstractItemModel* m_playListModel = nullptr;
     MediaPlayList* m_playListControler = nullptr;
     ManageAudioPlayer* m_manageAudioPlayer = nullptr;
     ManageMediaPlayerControl* m_manageMediaPlayerControl = nullptr;
     ManageHeaderBar* m_manageHeaderBar = nullptr;
     AudioWrapper* m_audioPlayer = nullptr;
 };
 
 #endif //MEDIACENTER_MPRIS2_H
diff --git a/src/musicartist.cpp b/src/musicartist.cpp
index ef5e0611..71ada306 100644
--- a/src/musicartist.cpp
+++ b/src/musicartist.cpp
@@ -1,125 +1,125 @@
 /*
  * Copyright 2016-2017 Matthieu Gallien <matthieu_gallien@yahoo.fr>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 3 of the License, or (at your option) any later version.
  *
  * This library 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "musicartist.h"
 
 #include <QtGlobal>
 #include <QString>
 #include <QDebug>
 
 class MusicArtistPrivate
 {
 public:
 
     QString mName;
 
-    qulonglong mDatabaseId;
+    qulonglong mDatabaseId = 0;
 
     int mAlbumsCount = 0;
 
     bool mIsValid = false;
 
 };
 
 MusicArtist::MusicArtist() : d(std::make_unique<MusicArtistPrivate>())
 {
 }
 
 MusicArtist::MusicArtist(MusicArtist &&other)
 {
     d.swap(other.d);
 }
 
 MusicArtist::MusicArtist(const MusicArtist &other) : d(std::make_unique<MusicArtistPrivate>(*other.d))
 {
 }
 
 MusicArtist& MusicArtist::operator=(MusicArtist &&other)
 {
     if (&other != this) {
         d.reset();
         d.swap(other.d);
     }
 
     return *this;
 }
 
 MusicArtist &MusicArtist::operator=(const MusicArtist &other)
 {
     if (&other != this) {
         (*d) = (*other.d);
     }
 
     return *this;
 }
 
 MusicArtist::~MusicArtist()
 = default;
 
 void MusicArtist::setValid(bool value)
 {
     d->mIsValid = value;
 }
 
 bool MusicArtist::isValid() const
 {
     return d->mIsValid;
 }
 
 void MusicArtist::setName(const QString &aName)
 {
     d->mName = aName;
 }
 
 QString MusicArtist::name() const
 {
     return d->mName;
 }
 
 void MusicArtist::setDatabaseId(qulonglong value)
 {
     d->mDatabaseId = value;
 }
 
 qulonglong MusicArtist::databaseId() const
 {
     return d->mDatabaseId;
 }
 
 void MusicArtist::setAlbumsCount(int value)
 {
     d->mAlbumsCount = value;
 }
 
 int MusicArtist::albumsCount() const
 {
     return d->mAlbumsCount;
 }
 
 QDebug& operator<<(QDebug &stream, const MusicArtist &data)
 {
     stream << data.name() << data.databaseId() << data.albumsCount() << (data.isValid() ? "is valid" : "is invalid");
 
     return stream;
 }
 
 bool operator==(const MusicArtist &artist1, const MusicArtist &artist2)
 {
     return artist1.name() == artist2.name() && artist1.albumsCount() == artist2.albumsCount();
 }
diff --git a/src/musicaudiotrack.cpp b/src/musicaudiotrack.cpp
index 55f47d74..08c1cab3 100644
--- a/src/musicaudiotrack.cpp
+++ b/src/musicaudiotrack.cpp
@@ -1,410 +1,409 @@
 /*
  * Copyright 2016-2017 Matthieu Gallien <matthieu_gallien@yahoo.fr>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 3 of the License, or (at your option) any later version.
  *
  * This library 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "musicaudiotrack.h"
 
 #include <QDebug>
 #include <utility>
 
 class MusicAudioTrackPrivate
 {
 public:
 
-    MusicAudioTrackPrivate()
-    {
-    }
+    MusicAudioTrackPrivate() = default;
 
     MusicAudioTrackPrivate(bool aValid, QString aId, QString aParentId,
                            QString aTitle, QString aArtist, QString aAlbumName, QString aAlbumArtist,
                            int aTrackNumber, int aDiscNumber, QTime aDuration, QUrl aResourceURI,
                            QUrl aAlbumCover, int rating, bool aIsSingleDiscAlbum)
         : mId(std::move(aId)), mParentId(std::move(aParentId)), mTitle(std::move(aTitle)), mArtist(std::move(aArtist)),
-          mAlbumName(std::move(aAlbumName)), mAlbumArtist(std::move(aAlbumArtist)), mTrackNumber(aTrackNumber),
-          mDiscNumber(aDiscNumber), mDuration(aDuration), mResourceURI(std::move(aResourceURI)),
-          mAlbumCover(std::move(aAlbumCover)), mRating(rating), mIsValid(aValid), mIsSingleDiscAlbum(aIsSingleDiscAlbum)
+          mAlbumName(std::move(aAlbumName)), mAlbumArtist(std::move(aAlbumArtist)),
+          mResourceURI(std::move(aResourceURI)), mAlbumCover(std::move(aAlbumCover)),
+          mTrackNumber(aTrackNumber), mDiscNumber(aDiscNumber), mDuration(aDuration),
+          mRating(rating), mIsValid(aValid), mIsSingleDiscAlbum(aIsSingleDiscAlbum)
     {
     }
 
     qulonglong mDatabaseId = 0;
 
     QString mId;
 
     QString mParentId;
 
     QString mTitle;
 
     QString mArtist;
 
     QString mAlbumName;
 
     QString mAlbumArtist;
 
     QString mGenre;
 
     QString mComposer;
 
     QString mLyricist;
 
     QString mComment;
 
+    QUrl mResourceURI;
+
+    QUrl mAlbumCover;
+
     int mTrackNumber = -1;
 
     int mDiscNumber = -1;
 
     int mChannels = -1;
 
     int mBitRate = -1;
 
     int mSampleRate = -1;
 
     int mYear = 0;
 
     QTime mDuration;
 
-    QUrl mResourceURI;
-
-    QUrl mAlbumCover;
-
     int mRating = -1;
 
     bool mIsValid = false;
 
     bool mIsSingleDiscAlbum = true;
 
 };
 
 MusicAudioTrack::MusicAudioTrack() : d(std::make_unique<MusicAudioTrackPrivate>())
 {
 }
 
 MusicAudioTrack::MusicAudioTrack(bool aValid, const QString &aId, const QString &aParentId,
                                  const QString &aTitle, const QString &aArtist, const QString &aAlbumName,
                                  const QString &aAlbumArtist, int aTrackNumber, int aDiscNumber,
                                  QTime aDuration, const QUrl &aResourceURI, const QUrl &aAlbumCover, int rating,
                                  bool aIsSingleDiscAlbum)
     : d(std::make_unique<MusicAudioTrackPrivate>(aValid, aId, aParentId, aTitle, aArtist, aAlbumName, aAlbumArtist,
                                                  aTrackNumber, aDiscNumber, aDuration, aResourceURI, aAlbumCover, rating,
                                                  aIsSingleDiscAlbum))
 {
 }
 
 MusicAudioTrack::MusicAudioTrack(MusicAudioTrack &&other)
 {
     d.swap(other.d);
 }
 
 MusicAudioTrack::MusicAudioTrack(const MusicAudioTrack &other) : d(std::make_unique<MusicAudioTrackPrivate>(*other.d))
 {
 }
 
 MusicAudioTrack::~MusicAudioTrack()
 = default;
 
 MusicAudioTrack& MusicAudioTrack::operator=(MusicAudioTrack &&other)
 {
     if (this != &other) {
         d.reset();
         d.swap(other.d);
     }
 
     return *this;
 }
 
 MusicAudioTrack& MusicAudioTrack::operator=(const MusicAudioTrack &other)
 {
     if (this != &other) {
         (*d) = (*other.d);
     }
 
     return *this;
 }
 
 bool MusicAudioTrack::operator <(const MusicAudioTrack &other) const
 {
     return d->mDiscNumber < other.d->mDiscNumber ||
             (d->mDiscNumber == other.d->mDiscNumber && d->mTrackNumber < other.d->mTrackNumber);
 }
 
 bool MusicAudioTrack::operator ==(const MusicAudioTrack &other) const
 {
     return d->mTitle == other.d->mTitle && d->mArtist == other.d->mArtist &&
             d->mAlbumName == other.d->mAlbumName && d->mAlbumArtist == other.d->mAlbumArtist &&
             d->mTrackNumber == other.d->mTrackNumber && d->mDiscNumber == other.d->mDiscNumber &&
             d->mDuration == other.d->mDuration && d->mResourceURI == other.d->mResourceURI &&
             d->mAlbumCover == other.d->mAlbumCover && d->mRating == other.d->mRating &&
             d->mGenre == other.d->mGenre && d->mComposer == other.d->mComposer &&
             d->mLyricist == other.d->mLyricist && d->mComment == other.d->mComment &&
             d->mYear == other.d->mYear && d->mChannels == other.d->mChannels &&
             d->mBitRate == other.d->mBitRate && d->mSampleRate == other.d->mSampleRate;
 
 }
 
 bool MusicAudioTrack::operator !=(const MusicAudioTrack &other) const
 {
     return d->mTitle != other.d->mTitle || d->mArtist != other.d->mArtist ||
             d->mAlbumName != other.d->mAlbumName || d->mAlbumArtist != other.d->mAlbumArtist ||
             d->mTrackNumber != other.d->mTrackNumber || d->mDiscNumber != other.d->mDiscNumber ||
             d->mDuration != other.d->mDuration || d->mResourceURI != other.d->mResourceURI ||
             d->mAlbumCover != other.d->mAlbumCover || d->mRating != other.d->mRating ||
             d->mGenre != other.d->mGenre || d->mComposer != other.d->mComposer ||
             d->mLyricist != other.d->mLyricist || d->mComment != other.d->mComment ||
             d->mYear != other.d->mYear || d->mChannels != other.d->mChannels ||
             d->mBitRate != other.d->mBitRate || d->mSampleRate != other.d->mSampleRate;
 }
 
 void MusicAudioTrack::setValid(bool value)
 {
     d->mIsValid = value;
 }
 
 bool MusicAudioTrack::isValid() const
 {
     return d->mIsValid;
 }
 
 void MusicAudioTrack::setDatabaseId(qulonglong value)
 {
     d->mDatabaseId = value;
 }
 
 qulonglong MusicAudioTrack::databaseId() const
 {
     return d->mDatabaseId;
 }
 
 void MusicAudioTrack::setId(const QString &value) const
 {
     d->mId = value;
 }
 
 QString MusicAudioTrack::id() const
 {
     return d->mId;
 }
 
 void MusicAudioTrack::setParentId(const QString &value) const
 {
     d->mParentId = value;
 }
 
 QString MusicAudioTrack::parentId() const
 {
     return d->mParentId;
 }
 
 void MusicAudioTrack::setTitle(const QString &value) const
 {
     d->mTitle = value;
 }
 
 QString MusicAudioTrack::title() const
 {
     return d->mTitle;
 }
 
 void MusicAudioTrack::setArtist(const QString &value) const
 {
     d->mArtist = value;
 }
 
 QString MusicAudioTrack::artist() const
 {
     return d->mArtist;
 }
 
 void MusicAudioTrack::setAlbumName(const QString &value) const
 {
     d->mAlbumName = value;
 }
 
 QString MusicAudioTrack::albumName() const
 {
     return d->mAlbumName;
 }
 
 void MusicAudioTrack::setAlbumArtist(const QString &value) const
 {
     d->mAlbumArtist = value;
 }
 
 QString MusicAudioTrack::albumArtist() const
 {
     return (d->mAlbumArtist.isEmpty() ? d->mArtist : d->mAlbumArtist);
 }
 
 bool MusicAudioTrack::isValidAlbumArtist() const
 {
     return !d->mAlbumArtist.isEmpty();
 }
 
 void MusicAudioTrack::setAlbumCover(const QUrl &value) const
 {
     d->mAlbumCover = value;
 }
 
 QUrl MusicAudioTrack::albumCover() const
 {
     return d->mAlbumCover;
 }
 
 void MusicAudioTrack::setGenre(const QString &value) const
 {
     d->mGenre = value;
 }
 
 QString MusicAudioTrack::genre() const
 {
     return d->mGenre;
 }
 
 void MusicAudioTrack::setComposer(const QString &value) const
 {
     d->mComposer = value;
 }
 
 QString MusicAudioTrack::composer() const
 {
     return d->mComposer;
 }
 
 void MusicAudioTrack::setLyricist(const QString &value) const
 {
     d->mLyricist = value;
 }
 
 QString MusicAudioTrack::lyricist() const
 {
     return d->mLyricist;
 }
 
 void MusicAudioTrack::setComment(const QString &value) const
 {
     d->mComment = value;
 }
 
 QString MusicAudioTrack::comment() const
 {
     return d->mComment;
 }
 
 void MusicAudioTrack::setTrackNumber(int value)
 {
     d->mTrackNumber = value;
 }
 
 int MusicAudioTrack::trackNumber() const
 {
     return d->mTrackNumber;
 }
 
 void MusicAudioTrack::setDiscNumber(int value)
 {
     d->mDiscNumber = value;
 }
 
 int MusicAudioTrack::discNumber() const
 {
     return d->mDiscNumber;
 }
 
 void MusicAudioTrack::setYear(int value)
 {
     d->mYear = value;
 }
 
 int MusicAudioTrack::year() const
 {
     return d->mYear;
 }
 
 void MusicAudioTrack::setChannels(int value)
 {
     d->mChannels = value;
 }
 
 int MusicAudioTrack::channels() const
 {
     return d->mChannels;
 }
 
 void MusicAudioTrack::setBitRate(int value)
 {
     d->mBitRate = value;
 }
 
 int MusicAudioTrack::bitRate() const
 {
     return d->mBitRate;
 }
 
 void MusicAudioTrack::setSampleRate(int value)
 {
     d->mSampleRate = value;
 }
 
 int MusicAudioTrack::sampleRate() const
 {
     return d->mSampleRate;
 }
 
 void MusicAudioTrack::setDuration(QTime value)
 {
     d->mDuration = value;
 }
 
 QTime MusicAudioTrack::duration() const
 {
     return d->mDuration;
 }
 
 void MusicAudioTrack::setResourceURI(const QUrl &value)
 {
     d->mResourceURI = value;
 }
 
 const QUrl &MusicAudioTrack::resourceURI() const
 {
     return d->mResourceURI;
 }
 
 void MusicAudioTrack::setRating(int value) const
 {
     d->mRating = value;
 }
 
 int MusicAudioTrack::rating() const
 {
     return d->mRating;
 }
 
 void MusicAudioTrack::setIsSingleDiscAlbum(bool value)
 {
     d->mIsSingleDiscAlbum = value;
 }
 
 bool MusicAudioTrack::isSingleDiscAlbum() const
 {
     return d->mIsSingleDiscAlbum;
 }
 
 QDebug operator<<(QDebug stream, const MusicAudioTrack &data)
 {
     stream << data.title() << data.artist() << data.albumName() << data.albumArtist() << data.duration();
     return stream;
 }
diff --git a/src/musiclistenersmanager.cpp b/src/musiclistenersmanager.cpp
index 825c6482..1c79dcdb 100644
--- a/src/musiclistenersmanager.cpp
+++ b/src/musiclistenersmanager.cpp
@@ -1,500 +1,501 @@
 /*
  * Copyright 2016-2017 Matthieu Gallien <matthieu_gallien@yahoo.fr>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 3 of the License, or (at your option) any later version.
  *
  * This library 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "musiclistenersmanager.h"
 
 #include "config-upnp-qt.h"
 
 #if defined UPNPQT_FOUND && UPNPQT_FOUND
 #include "upnp/upnplistener.h"
 #endif
 
 #if defined KF5Baloo_FOUND && KF5Baloo_FOUND
 #include "baloo/baloolistener.h"
 #endif
 
 #include "databaseinterface.h"
 #include "mediaplaylist.h"
 #include "file/filelistener.h"
 #include "file/localfilelisting.h"
 #include "trackslistener.h"
 #include "notificationitem.h"
 #include "elisaapplication.h"
 #include "elisa_settings.h"
 #include "models/allalbumsmodel.h"
 #include "models/allartistsmodel.h"
 #include "models/alltracksmodel.h"
 #include "models/albummodel.h"
 #include "models/abstractmediaproxymodel.h"
 #include "models/allalbumsproxymodel.h"
 #include "models/allartistsproxymodel.h"
 #include "models/alltracksproxymodel.h"
 #include "models/singleartistproxymodel.h"
 #include "models/singlealbumproxymodel.h"
 
 #include <KI18n/KLocalizedString>
 
 #include <QThread>
 #include <QMutex>
 #include <QStandardPaths>
 #include <QDir>
 #include <QCoreApplication>
 #include <QList>
 #include <QScopedPointer>
 #include <QPointer>
 #include <QFileSystemWatcher>
 
 #include <QAction>
 
 #include <list>
 
 class MusicListenersManagerPrivate
 {
 public:
 
     QThread mDatabaseThread;
 
     QThread mListenerThread;
 
 #if defined UPNPQT_FOUND && UPNPQT_FOUND
     UpnpListener mUpnpListener;
 #endif
 
 #if defined KF5Baloo_FOUND && KF5Baloo_FOUND
-    QScopedPointer<BalooListener> mBalooListener;
+    std::unique_ptr<BalooListener> mBalooListener;
 #endif
 
     std::list<std::unique_ptr<FileListener>> mFileListener;
 
     DatabaseInterface mDatabaseInterface;
 
     QFileSystemWatcher mConfigFileWatcher;
 
-    int mImportedTracksCount = 0;
-
-    int mTotalImportedTracksCount = 0;
-
-    int mActiveMusicListenersCount = 0;
-
-    bool mIndexingRunning = false;
-
     ElisaApplication *mElisaApplication = nullptr;
 
     AllAlbumsModel mAllAlbumsModel;
 
     AllArtistsModel mAllArtistsModel;
 
     AllTracksModel mAllTracksModel;
 
     AlbumModel mAlbumModel;
 
+    int mImportedTracksCount = 0;
+
+    int mTotalImportedTracksCount = 0;
+
+    int mActiveMusicListenersCount = 0;
+
+    bool mIndexingRunning = false;
+
     bool mIndexerBusy = false;
 
 };
 
 MusicListenersManager::MusicListenersManager(QObject *parent)
     : QObject(parent), d(std::make_unique<MusicListenersManagerPrivate>())
 {
     d->mListenerThread.start();
     d->mDatabaseThread.start();
 
     d->mDatabaseInterface.moveToThread(&d->mDatabaseThread);
 
     connect(&d->mDatabaseInterface, &DatabaseInterface::requestsInitDone,
             this, &MusicListenersManager::databaseReady);
 
     const auto &localDataPaths = QStandardPaths::standardLocations(QStandardPaths::AppDataLocation);
     auto databaseFileName = QString();
     if (!localDataPaths.isEmpty()) {
         QDir myDataDirectory;
         myDataDirectory.mkpath(localDataPaths.first());
         databaseFileName = localDataPaths.first() + QStringLiteral("/elisaDatabase.db");
     }
 
     QMetaObject::invokeMethod(&d->mDatabaseInterface, "init", Qt::QueuedConnection,
                               Q_ARG(QString, QStringLiteral("listeners")), Q_ARG(QString, databaseFileName));
 
     connect(&d->mDatabaseInterface, &DatabaseInterface::artistAdded,
             this, &MusicListenersManager::artistAdded);
     connect(&d->mDatabaseInterface, &DatabaseInterface::trackAdded,
             this, &MusicListenersManager::trackAdded);
     connect(&d->mDatabaseInterface, &DatabaseInterface::tracksAdded,
             this, &MusicListenersManager::tracksAdded);
     connect(&d->mDatabaseInterface, &DatabaseInterface::artistRemoved,
             this, &MusicListenersManager::artistRemoved);
     connect(&d->mDatabaseInterface, &DatabaseInterface::albumRemoved,
             this, &MusicListenersManager::albumRemoved);
     connect(&d->mDatabaseInterface, &DatabaseInterface::trackRemoved,
             this, &MusicListenersManager::trackRemoved);
     connect(&d->mDatabaseInterface, &DatabaseInterface::artistModified,
             this, &MusicListenersManager::artistModified);
     connect(&d->mDatabaseInterface, &DatabaseInterface::albumModified,
             this, &MusicListenersManager::albumModified);
     connect(&d->mDatabaseInterface, &DatabaseInterface::trackModified,
             this, &MusicListenersManager::trackModified);
 
     connect(QCoreApplication::instance(), &QCoreApplication::aboutToQuit,
             this, &MusicListenersManager::applicationAboutToQuit);
 
     connect(Elisa::ElisaConfiguration::self(), &Elisa::ElisaConfiguration::configChanged,
             this, &MusicListenersManager::configChanged);
 
     connect(&d->mConfigFileWatcher, &QFileSystemWatcher::fileChanged,
             this, &MusicListenersManager::configChanged);
 
     auto initialRootPath = Elisa::ElisaConfiguration::rootPath();
     if (initialRootPath.isEmpty()) {
         auto systemMusicPaths = QStandardPaths::standardLocations(QStandardPaths::MusicLocation);
         for (const auto &musicPath : qAsConst(systemMusicPaths)) {
             initialRootPath.push_back(musicPath);
         }
 
         Elisa::ElisaConfiguration::setRootPath(initialRootPath);
         Elisa::ElisaConfiguration::self()->save();
     }
 
     d->mConfigFileWatcher.addPath(Elisa::ElisaConfiguration::self()->config()->name());
 
     d->mAllAlbumsModel.setAllArtists(&d->mAllArtistsModel);
     d->mAllArtistsModel.setAllAlbums(&d->mAllAlbumsModel);
 
     connect(&d->mDatabaseInterface, &DatabaseInterface::albumsAdded,
             &d->mAllAlbumsModel, &AllAlbumsModel::albumsAdded);
     connect(&d->mDatabaseInterface, &DatabaseInterface::albumModified,
             &d->mAllAlbumsModel, &AllAlbumsModel::albumModified);
     connect(&d->mDatabaseInterface, &DatabaseInterface::albumRemoved,
             &d->mAllAlbumsModel, &AllAlbumsModel::albumRemoved);
 
     connect(&d->mDatabaseInterface, &DatabaseInterface::artistAdded,
             &d->mAllArtistsModel, &AllArtistsModel::artistAdded);
     connect(&d->mDatabaseInterface, &DatabaseInterface::artistModified,
             &d->mAllArtistsModel, &AllArtistsModel::artistModified);
     connect(&d->mDatabaseInterface, &DatabaseInterface::artistRemoved,
             &d->mAllArtistsModel, &AllArtistsModel::artistRemoved);
 
     connect(&d->mDatabaseInterface, &DatabaseInterface::tracksAdded,
             &d->mAllTracksModel, &AllTracksModel::tracksAdded);
     connect(&d->mDatabaseInterface, &DatabaseInterface::trackModified,
             &d->mAllTracksModel, &AllTracksModel::trackModified);
     connect(&d->mDatabaseInterface, &DatabaseInterface::trackRemoved,
             &d->mAllTracksModel, &AllTracksModel::trackRemoved);
 
     connect(&d->mDatabaseInterface, &DatabaseInterface::albumModified,
             &d->mAlbumModel, &AlbumModel::albumModified);
     connect(&d->mDatabaseInterface, &DatabaseInterface::albumRemoved,
             &d->mAlbumModel, &AlbumModel::albumRemoved);
     connect(&d->mAlbumModel, &AlbumModel::requestAlbumData,
             &d->mDatabaseInterface, &DatabaseInterface::getAlbumFromAlbumId);
     connect(&d->mDatabaseInterface, &DatabaseInterface::sentAlbumData,
             &d->mAlbumModel, &AlbumModel::setAlbumData);
 }
 
 MusicListenersManager::~MusicListenersManager()
 = default;
 
 DatabaseInterface *MusicListenersManager::viewDatabase() const
 {
     return &d->mDatabaseInterface;
 }
 
 void MusicListenersManager::subscribeForTracks(MediaPlayList *client)
 {
-    auto helper = new TracksListener(&d->mDatabaseInterface);
+    auto helper = std::make_unique<TracksListener>(&d->mDatabaseInterface);
 
     helper->moveToThread(&d->mDatabaseThread);
-    connect(&d->mDatabaseThread, &QThread::finished, helper, &QObject::deleteLater);
+    connect(&d->mDatabaseThread, &QThread::finished, helper.get(), &QObject::deleteLater);
 
-    connect(this, &MusicListenersManager::trackRemoved, helper, &TracksListener::trackRemoved);
-    connect(this, &MusicListenersManager::tracksAdded, helper, &TracksListener::tracksAdded);
-    connect(this, &MusicListenersManager::trackModified, helper, &TracksListener::trackModified);
+    connect(this, &MusicListenersManager::trackRemoved, helper.get(), &TracksListener::trackRemoved);
+    connect(this, &MusicListenersManager::tracksAdded, helper.get(), &TracksListener::tracksAdded);
+    connect(this, &MusicListenersManager::trackModified, helper.get(), &TracksListener::trackModified);
     connect(this, &MusicListenersManager::removeTracksInError, &d->mDatabaseInterface, &DatabaseInterface::removeTracksList);
-    connect(helper, &TracksListener::trackHasChanged, client, &MediaPlayList::trackChanged);
-    connect(helper, &TracksListener::trackHasBeenRemoved, client, &MediaPlayList::trackRemoved);
-    connect(helper, &TracksListener::albumAdded, client, &MediaPlayList::albumAdded);
-    connect(client, &MediaPlayList::newTrackByIdInList, helper, &TracksListener::trackByIdInList);
-    connect(client, &MediaPlayList::newTrackByNameInList, helper, &TracksListener::trackByNameInList);
-    connect(client, &MediaPlayList::newTrackByFileNameInList, helper, &TracksListener::trackByFileNameInList);
-    connect(client, &MediaPlayList::newArtistInList, helper, &TracksListener::newArtistInList);
+    connect(helper.get(), &TracksListener::trackHasChanged, client, &MediaPlayList::trackChanged);
+    connect(helper.get(), &TracksListener::trackHasBeenRemoved, client, &MediaPlayList::trackRemoved);
+    connect(helper.get(), &TracksListener::albumAdded, client, &MediaPlayList::albumAdded);
+    connect(client, &MediaPlayList::newTrackByIdInList, helper.get(), &TracksListener::trackByIdInList);
+    connect(client, &MediaPlayList::newTrackByNameInList, helper.get(), &TracksListener::trackByNameInList);
+    connect(client, &MediaPlayList::newTrackByFileNameInList, helper.get(), &TracksListener::trackByFileNameInList);
+    connect(client, &MediaPlayList::newArtistInList, helper.get(), &TracksListener::newArtistInList);
+    helper.release();
 }
 
 int MusicListenersManager::importedTracksCount() const
 {
     return d->mImportedTracksCount;
 }
 
 bool MusicListenersManager::isIndexingRunning() const
 {
     return d->mIndexingRunning;
 }
 
 ElisaApplication *MusicListenersManager::elisaApplication() const
 {
     return d->mElisaApplication;
 }
 
 QAbstractItemModel *MusicListenersManager::allAlbumsModel() const
 {
     return &d->mAllAlbumsModel;
 }
 
 QAbstractItemModel *MusicListenersManager::allArtistsModel() const
 {
     return &d->mAllArtistsModel;
 }
 
 QAbstractItemModel *MusicListenersManager::allTracksModel() const
 {
     return &d->mAllTracksModel;
 }
 
 QAbstractItemModel *MusicListenersManager::albumModel() const
 {
     return &d->mAlbumModel;
 }
 
 bool MusicListenersManager::indexerBusy() const
 {
     return d->mIndexerBusy;
 }
 
 void MusicListenersManager::databaseReady()
 {
     d->mIndexerBusy = true;
     Q_EMIT indexerBusyChanged();
 
     configChanged();
 }
 
 void MusicListenersManager::applicationAboutToQuit()
 {
     d->mDatabaseInterface.applicationAboutToQuit();
 
     Q_EMIT applicationIsTerminating();
 
     d->mDatabaseThread.exit();
     d->mDatabaseThread.wait();
 
     d->mListenerThread.exit();
     d->mListenerThread.wait();
 }
 
 void MusicListenersManager::showConfiguration()
 {
     auto configureAction = d->mElisaApplication->action(QStringLiteral("options_configure"));
 
     configureAction->trigger();
 }
 
 void MusicListenersManager::resetImportedTracksCounter()
 {
 #if defined KF5Baloo_FOUND && KF5Baloo_FOUND
     if (d->mBalooListener) {
         d->mBalooListener->resetImportedTracksCounter();
     }
 #endif
 
     for (const auto &itFileListener : d->mFileListener) {
         itFileListener->resetImportedTracksCounter();
     }
 }
 
 void MusicListenersManager::setElisaApplication(ElisaApplication *elisaApplication)
 {
     if (d->mElisaApplication == elisaApplication) {
         return;
     }
 
     d->mElisaApplication = elisaApplication;
     emit elisaApplicationChanged();
 }
 
 void MusicListenersManager::playBackError(QUrl sourceInError, QMediaPlayer::Error playerError)
 {
     qDebug() << "MusicListenersManager::playBackError" << sourceInError;
 
     if (playerError == QMediaPlayer::ResourceError) {
         Q_EMIT removeTracksInError({sourceInError});
 
         if (sourceInError.isLocalFile()) {
             Q_EMIT displayTrackError(sourceInError.toLocalFile());
         } else {
             Q_EMIT displayTrackError(sourceInError.toString());
         }
     }
 }
 
 void MusicListenersManager::configChanged()
 {
     auto currentConfiguration = Elisa::ElisaConfiguration::self();
 
     d->mConfigFileWatcher.addPath(currentConfiguration->config()->name());
 
     currentConfiguration->load();
 
 #if defined KF5Baloo_FOUND && KF5Baloo_FOUND
     if (currentConfiguration->balooIndexer() && !d->mBalooListener) {
-        d->mBalooListener.reset(new BalooListener);
+        d->mBalooListener = std::make_unique<BalooListener>();
         d->mBalooListener->moveToThread(&d->mListenerThread);
         d->mBalooListener->setDatabaseInterface(&d->mDatabaseInterface);
         connect(this, &MusicListenersManager::applicationIsTerminating,
-                d->mBalooListener.data(), &BalooListener::applicationAboutToQuit, Qt::DirectConnection);
-        connect(d->mBalooListener.data(), &BalooListener::indexingStarted,
+                d->mBalooListener.get(), &BalooListener::applicationAboutToQuit, Qt::DirectConnection);
+        connect(d->mBalooListener.get(), &BalooListener::indexingStarted,
                 this, &MusicListenersManager::monitorStartingListeners);
-        connect(d->mBalooListener.data(), &BalooListener::indexingFinished,
+        connect(d->mBalooListener.get(), &BalooListener::indexingFinished,
                 this, &MusicListenersManager::monitorEndingListeners);
-        connect(d->mBalooListener.data(), &BalooListener::clearDatabase,
+        connect(d->mBalooListener.get(), &BalooListener::clearDatabase,
                 &d->mDatabaseInterface, &DatabaseInterface::removeAllTracksFromSource);
-        connect(d->mBalooListener.data(), &BalooListener::importedTracksCountChanged,
+        connect(d->mBalooListener.get(), &BalooListener::importedTracksCountChanged,
                 this, &MusicListenersManager::computeImportedTracksCount);
-        connect(d->mBalooListener.data(), &BalooListener::newNotification,
+        connect(d->mBalooListener.get(), &BalooListener::newNotification,
                 this, &MusicListenersManager::newNotification);
-        connect(d->mBalooListener.data(), &BalooListener::closeNotification,
+        connect(d->mBalooListener.get(), &BalooListener::closeNotification,
                 this, &MusicListenersManager::closeNotification);
 
-        QMetaObject::invokeMethod(d->mBalooListener.data(), "performInitialScan", Qt::QueuedConnection);
+        QMetaObject::invokeMethod(d->mBalooListener.get(), "performInitialScan", Qt::QueuedConnection);
     } else if (!currentConfiguration->balooIndexer() && d->mBalooListener) {
-        QMetaObject::invokeMethod(d->mBalooListener.data(), "quitListener", Qt::QueuedConnection);
+        QMetaObject::invokeMethod(d->mBalooListener.get(), "quitListener", Qt::QueuedConnection);
         d->mBalooListener.reset();
     }
 #endif
 #if defined UPNPQT_FOUND && UPNPQT_FOUND
     d->mUpnpListener.setDatabaseInterface(&d->mDatabaseInterface);
     d->mUpnpListener.moveToThread(&d->mDatabaseThread);
     connect(this, &MusicListenersManager::applicationIsTerminating,
             &d->mUpnpListener, &UpnpListener::applicationAboutToQuit, Qt::DirectConnection);
 #endif
 
     if (currentConfiguration->elisaFilesIndexer())
     {
         const auto &allRootPaths = currentConfiguration->rootPath();
         for (auto itFileListener = d->mFileListener.begin(); itFileListener != d->mFileListener.end(); ) {
             const auto &currentRootPath = (*itFileListener)->localFileIndexer().rootPath();
             auto itPath = std::find(allRootPaths.begin(), allRootPaths.end(), currentRootPath);
 
             if (itPath == allRootPaths.end()) {
                 d->mDatabaseInterface.removeAllTracksFromSource((*itFileListener)->fileListing()->sourceName());
                 itFileListener = d->mFileListener.erase(itFileListener);
             } else {
                 ++itFileListener;
             }
         }
 
         for (const auto &oneRootPath : allRootPaths) {
             auto itPath = std::find_if(d->mFileListener.begin(), d->mFileListener.end(),
                                        [&oneRootPath](const auto &value)->bool {return value->localFileIndexer().rootPath() == oneRootPath;});
             if (itPath == d->mFileListener.end()) {
                 auto newFileIndexer = std::make_unique<FileListener>();
 
                 newFileIndexer->setDatabaseInterface(&d->mDatabaseInterface);
                 newFileIndexer->moveToThread(&d->mListenerThread);
                 connect(this, &MusicListenersManager::applicationIsTerminating,
                         newFileIndexer.get(), &FileListener::applicationAboutToQuit, Qt::DirectConnection);
                 connect(newFileIndexer.get(), &FileListener::indexingStarted,
                         this, &MusicListenersManager::monitorStartingListeners);
                 connect(newFileIndexer.get(), &FileListener::indexingFinished,
                         this, &MusicListenersManager::monitorEndingListeners);
                 connect(newFileIndexer.get(), &FileListener::importedTracksCountChanged,
                         this, &MusicListenersManager::computeImportedTracksCount);
                 connect(newFileIndexer.get(), &FileListener::newNotification,
                         this, &MusicListenersManager::newNotification);
                 connect(newFileIndexer.get(), &FileListener::closeNotification,
                         this, &MusicListenersManager::closeNotification);
 
                 newFileIndexer->setRootPath(oneRootPath);
 
                 QMetaObject::invokeMethod(newFileIndexer.get(), "performInitialScan", Qt::QueuedConnection);
 
                 d->mFileListener.emplace_back(std::move(newFileIndexer));
             }
         }
     }
 }
 
 void MusicListenersManager::computeImportedTracksCount()
 {
 #if defined KF5Baloo_FOUND && KF5Baloo_FOUND
     if (d->mBalooListener) {
         d->mImportedTracksCount = d->mBalooListener->importedTracksCount();
     } else {
         d->mImportedTracksCount = 0;
     }
 #else
     d->mImportedTracksCount = 0;
 #endif
 
     for (const auto &itFileListener : d->mFileListener) {
         d->mImportedTracksCount += itFileListener->importedTracksCount();
     }
 
     if (d->mImportedTracksCount && d->mIndexerBusy) {
         d->mIndexerBusy = false;
         Q_EMIT indexerBusyChanged();
     }
 
     if (d->mImportedTracksCount >= 4) {
         Q_EMIT closeNotification(QStringLiteral("notEnoughTracks"));
     }
 
     Q_EMIT importedTracksCountChanged();
 }
 
 void MusicListenersManager::monitorStartingListeners()
 {
     if (d->mActiveMusicListenersCount == 0) {
         d->mIndexingRunning = true;
         Q_EMIT indexingRunningChanged();
     }
 
     ++d->mActiveMusicListenersCount;
 }
 
 void MusicListenersManager::monitorEndingListeners(int tracksCount)
 {
     --d->mActiveMusicListenersCount;
 
     d->mTotalImportedTracksCount += tracksCount;
 
     if (d->mActiveMusicListenersCount == 0) {
         if (d->mTotalImportedTracksCount < 4 && d->mElisaApplication) {
             NotificationItem notEnoughTracks;
 
             notEnoughTracks.setNotificationId(QStringLiteral("notEnoughTracks"));
 
             notEnoughTracks.setTargetObject(this);
 
             notEnoughTracks.setMessage(i18nc("No track found message", "No track have been found"));
 
             auto configureAction = d->mElisaApplication->action(QStringLiteral("options_configure"));
 
             notEnoughTracks.setMainButtonText(configureAction->text());
             notEnoughTracks.setMainButtonIconName(configureAction->icon().name());
             notEnoughTracks.setMainButtonMethodName(QStringLiteral("showConfiguration"));
 
             Q_EMIT newNotification(notEnoughTracks);
         }
 
         d->mIndexingRunning = false;
         Q_EMIT indexingRunningChanged();
 
         QMetaObject::invokeMethod(&d->mDatabaseInterface, "cleanInvalidTracks", Qt::QueuedConnection);
     }
 }
 
 
 #include "moc_musiclistenersmanager.cpp"
diff --git a/src/progressindicator.h b/src/progressindicator.h
index f5f653a9..19f20735 100644
--- a/src/progressindicator.h
+++ b/src/progressindicator.h
@@ -1,67 +1,67 @@
 /*
  * Copyright 2016 Matthieu Gallien <matthieu_gallien@yahoo.fr>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 3 of the License, or (at your option) any later version.
  *
  * This library 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #ifndef PROGRESSINDICATOR_H
 #define PROGRESSINDICATOR_H
 
 #include <QObject>
 
 class ProgressIndicator : public QObject
 {
 
     Q_OBJECT
 
     Q_PROPERTY(int position
                READ position
                WRITE setPosition
                NOTIFY positionChanged)
 
     Q_PROPERTY(QString progressDuration
                READ progressDuration
                NOTIFY progressDurationChanged)
 
 public:
 
     explicit ProgressIndicator(QObject *parent = nullptr);
 
     ~ProgressIndicator() override;
 
     int position() const;
 
     QString progressDuration() const;
 
 Q_SIGNALS:
 
     void positionChanged();
 
     void progressDurationChanged();
 
 public Q_SLOTS:
 
     void setPosition(int position);
 
 private:
 
-    int mPosition;
+    int mPosition = 0;
 
     QString mProgressDuration;
 
 };
 
 #endif // PROGRESSINDICATOR_H
diff --git a/src/trackdatahelper.cpp b/src/trackdatahelper.cpp
index 2c70b0e4..8d79f018 100644
--- a/src/trackdatahelper.cpp
+++ b/src/trackdatahelper.cpp
@@ -1,170 +1,169 @@
 /*
  * Copyright 2018 Alexander Stippich <a.stippich@gmx.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 3 of the License, or (at your option) any later version.
  *
  * This library 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "trackdatahelper.h"
 
 TrackDataHelper::TrackDataHelper(QObject *parent) : QObject(parent)
 {
 }
 
 TrackDataHelper::~TrackDataHelper()
 = default;
 
 
-MusicAudioTrack TrackDataHelper::trackData() const
+const MusicAudioTrack &TrackDataHelper::trackData() const
 {
-    MusicAudioTrack temp = *this;
-    return temp;
+    return *this;
 }
 
 void TrackDataHelper::setTrackData(const MusicAudioTrack &track)
 {
     MusicAudioTrack::operator=(track);
     Q_EMIT trackDataChanged();
 }
 
 QString TrackDataHelper::trackNumber() const
 {
     return QString::number(MusicAudioTrack::trackNumber());
 }
 
 QString TrackDataHelper::discNumber() const
 {
     return QString::number(MusicAudioTrack::discNumber());
 }
 
 QString TrackDataHelper::channels() const
 {
     return QString::number(MusicAudioTrack::channels());
 }
 
 QString TrackDataHelper::bitRate() const
 {
     return QString::number(MusicAudioTrack::bitRate()/1000);
 }
 
 QString TrackDataHelper::sampleRate() const
 {
     return QString::number(MusicAudioTrack::sampleRate());
 }
 
 QString TrackDataHelper::year() const
 {
     return QString::number(MusicAudioTrack::year());
 }
 
 QString TrackDataHelper::duration() const
 {
     QString result;
     const QTime &trackDuration = MusicAudioTrack::duration();
     if (trackDuration.hour() == 0) {
         result = trackDuration.toString(QStringLiteral("mm:ss"));
     } else {
         result = trackDuration.toString(QStringLiteral("h:mm:ss"));
     }
     return result;
 }
 
 QString TrackDataHelper::resourceURI() const
 {
     return MusicAudioTrack::resourceURI().toString();
 }
 
 bool TrackDataHelper::hasValidTrackNumber() const
 {
     return MusicAudioTrack::trackNumber() > -1;
 }
 
 bool TrackDataHelper::hasValidDiscNumber() const
 {
     return MusicAudioTrack::discNumber() > -1;
 }
 
 bool TrackDataHelper::hasValidChannels() const
 {
     return MusicAudioTrack::channels() > -1;
 }
 
 bool TrackDataHelper::hasValidBitRate() const
 {
     return MusicAudioTrack::bitRate() > -1;
 }
 
 bool TrackDataHelper::hasValidSampleRate() const
 {
     return MusicAudioTrack::sampleRate() > -1;
 }
 
 bool TrackDataHelper::hasValidYear() const
 {
     return MusicAudioTrack::year() != 0;
 }
 
 bool TrackDataHelper::hasValidRating() const
 {
     return MusicAudioTrack::rating() > -1;
 }
 
 bool TrackDataHelper::hasValidTitle() const
 {
     return !MusicAudioTrack::title().isEmpty();
 }
 
 bool TrackDataHelper::hasValidArtist() const
 {
     return !MusicAudioTrack::artist().isEmpty();
 }
 
 bool TrackDataHelper::hasValidAlbumArtist() const
 {
     return !MusicAudioTrack::albumArtist().isEmpty();
 }
 
 bool TrackDataHelper::hasValidAlbumName() const
 {
     return !MusicAudioTrack::albumName().isEmpty();
 }
 
 bool TrackDataHelper::hasValidGenre() const
 {
     return !MusicAudioTrack::genre().isEmpty();
 }
 
 bool TrackDataHelper::hasValidComposer() const
 {
     return !MusicAudioTrack::composer().isEmpty();
 }
 
 bool TrackDataHelper::hasValidLyricist() const
 {
     return !MusicAudioTrack::lyricist().isEmpty();
 }
 
 bool TrackDataHelper::hasValidComment() const
 {
     return !MusicAudioTrack::comment().isEmpty();
 }
 
 bool TrackDataHelper::hasValidAlbumCover() const
 {
     return !MusicAudioTrack::albumCover().isEmpty();
 }
 
 #include "moc_trackdatahelper.cpp"
 
diff --git a/src/trackdatahelper.h b/src/trackdatahelper.h
index 56b39800..6e439bd5 100644
--- a/src/trackdatahelper.h
+++ b/src/trackdatahelper.h
@@ -1,179 +1,179 @@
 /*
  * Copyright 2018 Alexander Stippich <a.stippich@gmx.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 3 of the License, or (at your option) any later version.
  *
  * This library 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 
 #ifndef TRACKDATAHELPER_H
 #define TRACKDATAHELPER_H
 
 #include <QObject>
 #include "musicaudiotrack.h"
 
 class TrackDataHelper : public QObject, public MusicAudioTrack
 {
     Q_OBJECT
 
     Q_PROPERTY(MusicAudioTrack trackData
                READ trackData
                WRITE setTrackData
                NOTIFY trackDataChanged)
 
     Q_PROPERTY(QString title
                READ title
                NOTIFY trackDataChanged)
 
     Q_PROPERTY(QString artist
                READ artist
                NOTIFY trackDataChanged)
 
     Q_PROPERTY(QString albumName
                READ albumName
                NOTIFY trackDataChanged)
 
     Q_PROPERTY(QString albumArtist
                READ albumArtist
                NOTIFY trackDataChanged)
 
     Q_PROPERTY(QString genre
                READ genre
                NOTIFY trackDataChanged)
 
     Q_PROPERTY(QString composer
                READ composer
                NOTIFY trackDataChanged)
 
     Q_PROPERTY(QString lyricist
                READ lyricist
                NOTIFY trackDataChanged)
 
     Q_PROPERTY(QString comment
                READ comment
                NOTIFY trackDataChanged)
 
     Q_PROPERTY(QString year
                READ year
                NOTIFY trackDataChanged)
 
     Q_PROPERTY(QString trackNumber
                READ trackNumber
                NOTIFY trackDataChanged)
 
     Q_PROPERTY(QString discNumber
                READ discNumber
                NOTIFY trackDataChanged)
 
     Q_PROPERTY(QString channels
                READ channels
                NOTIFY trackDataChanged)
 
     Q_PROPERTY(QString bitRate
                READ bitRate
                NOTIFY trackDataChanged)
 
     Q_PROPERTY(QString sampleRate
                READ sampleRate
                NOTIFY trackDataChanged)
 
     Q_PROPERTY(QString resourceURI
                READ resourceURI
                NOTIFY trackDataChanged)
 
     Q_PROPERTY(QString duration
                READ duration
                NOTIFY trackDataChanged)
 
     Q_PROPERTY(int rating
                READ rating
                NOTIFY trackDataChanged)
 
     Q_PROPERTY(QUrl albumCover
                READ albumCover
                NOTIFY trackDataChanged)
 
     Q_PROPERTY(qulonglong databaseId
                READ databaseId
                NOTIFY trackDataChanged)
 
 public:
 
     explicit TrackDataHelper(QObject *parent = nullptr);
 
     ~TrackDataHelper() override;
 
     QString trackNumber() const;
 
     QString discNumber() const;
 
     QString channels() const;
 
     QString bitRate() const;
 
     QString sampleRate() const;
 
     QString year() const;
 
     QString duration() const;
 
     QString resourceURI() const;
 
-    MusicAudioTrack trackData() const;
+    const MusicAudioTrack& trackData() const;
 
     void setTrackData(const MusicAudioTrack &track);
 
 Q_SIGNALS:
 
     void trackDataChanged();
 
 public:
 
     Q_INVOKABLE bool hasValidTitle() const;
 
     Q_INVOKABLE bool hasValidArtist() const;
 
     Q_INVOKABLE bool hasValidAlbumName() const;
 
     Q_INVOKABLE bool hasValidAlbumArtist() const;
 
     Q_INVOKABLE bool hasValidGenre() const;
 
     Q_INVOKABLE bool hasValidComposer() const;
 
     Q_INVOKABLE bool hasValidLyricist() const;
 
     Q_INVOKABLE bool hasValidComment() const;
 
     Q_INVOKABLE bool hasValidTrackNumber() const;
 
     Q_INVOKABLE bool hasValidDiscNumber() const;
 
     Q_INVOKABLE bool hasValidChannels() const;
 
     Q_INVOKABLE bool hasValidRating() const;
 
     Q_INVOKABLE bool hasValidBitRate() const;
 
     Q_INVOKABLE bool hasValidSampleRate() const;
 
     Q_INVOKABLE bool hasValidYear() const;
 
     Q_INVOKABLE bool hasValidAlbumCover() const;
 };
 
 
 #endif // TRACKDATAHELPER_H