diff --git a/src/abstractfile/abstractfilelistener.cpp b/src/abstractfile/abstractfilelistener.cpp
index c5a7bb67..586602bb 100644
--- a/src/abstractfile/abstractfilelistener.cpp
+++ b/src/abstractfile/abstractfilelistener.cpp
@@ -1,110 +1,115 @@
 /*
  * Copyright 2016-2017 Matthieu Gallien <matthieu_gallien@yahoo.fr>
  *
  * This program is free software: you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 3 of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
 #include "abstractfilelistener.h"
 
 #include "abstractfilelisting.h"
 #include "databaseinterface.h"
 
 #include <QThread>
 
 class AbstractFileListenerPrivate
 {
 public:
 
     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::insertTracksList);
         connect(d->mFileListing, &AbstractFileListing::askRestoredTracks,
                 model, &DatabaseInterface::askRestoredTracks);
         connect(model, &DatabaseInterface::restoredTracks,
                 d->mFileListing, &AbstractFileListing::restoredTracks);
         connect(model, &DatabaseInterface::cleanedDatabase,
                 d->mFileListing, &AbstractFileListing::refreshContent);
         connect(model, &DatabaseInterface::finishRemovingTracksList,
                 d->mFileListing, &AbstractFileListing::databaseFinishedRemovingTracksList);
         connect(model, &DatabaseInterface::finishInsertingTracksList,
                 d->mFileListing, &AbstractFileListing::databaseFinishedInsertingTracksList);
     }
 
     Q_EMIT databaseInterfaceChanged();
 }
 
 void AbstractFileListener::applicationAboutToQuit()
 {
     d->mFileListing->applicationAboutToQuit();
 
     d->mFileQueryThread.exit();
     d->mFileQueryThread.wait();
 }
 
 void AbstractFileListener::quitListener()
 {
     applicationAboutToQuit();
 
     Q_EMIT clearDatabase();
 }
 
 void AbstractFileListener::setAllRootPaths(const QStringList &allRootPaths)
 {
     d->mFileListing->setAllRootPaths(allRootPaths);
 }
 
 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);
 }
 
 AbstractFileListing *AbstractFileListener::fileListing() const
 {
     return d->mFileListing;
 }
 
+bool AbstractFileListener::canHandleRootPaths() const
+{
+    return d->mFileListing->canHandleRootPaths();
+}
+
 
 #include "moc_abstractfilelistener.cpp"
diff --git a/src/abstractfile/abstractfilelistener.h b/src/abstractfile/abstractfilelistener.h
index 5e175431..7bf0359c 100644
--- a/src/abstractfile/abstractfilelistener.h
+++ b/src/abstractfile/abstractfilelistener.h
@@ -1,86 +1,88 @@
 /*
  * Copyright 2016-2017 Matthieu Gallien <matthieu_gallien@yahoo.fr>
  *
  * This program is free software: you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 3 of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
 #ifndef ABSTRACTFILELISTENER_H
 #define ABSTRACTFILELISTENER_H
 
 #include <QObject>
 #include <QVector>
 #include <QString>
 
 #include "datatypes.h"
 
 #include <memory>
 
 class AbstractFileListenerPrivate;
 class DatabaseInterface;
 class MusicAudioTrack;
 class AbstractFileListing;
 
 class AbstractFileListener : public QObject
 {
     Q_OBJECT
 
     Q_PROPERTY(DatabaseInterface* databaseInterface
                READ databaseInterface
                WRITE setDatabaseInterface
                NOTIFY databaseInterfaceChanged)
 
 public:
     explicit AbstractFileListener(QObject *parent = nullptr);
 
     ~AbstractFileListener() override;
 
     DatabaseInterface* databaseInterface() const;
 
     AbstractFileListing* fileListing() const;
 
+    bool canHandleRootPaths() const;
+
 Q_SIGNALS:
 
     void databaseInterfaceChanged();
 
     void newTrackFile(const DataTypes::TrackDataType &newTrack);
 
     void indexingStarted();
 
     void indexingFinished();
 
     void configurationChanged();
 
     void clearDatabase();
 
 public Q_SLOTS:
 
     void setDatabaseInterface(DatabaseInterface* databaseInterface);
 
     void applicationAboutToQuit();
 
     void quitListener();
 
     void setAllRootPaths(const QStringList &allRootPaths);
 
 protected:
 
     void setFileListing(AbstractFileListing *fileIndexer);
 
 private:
 
     std::unique_ptr<AbstractFileListenerPrivate> d;
 
 };
 
 #endif // ABSTRACTFILELISTENER_H
diff --git a/src/abstractfile/abstractfilelisting.cpp b/src/abstractfile/abstractfilelisting.cpp
index 7e03f42d..80183505 100644
--- a/src/abstractfile/abstractfilelisting.cpp
+++ b/src/abstractfile/abstractfilelisting.cpp
@@ -1,460 +1,466 @@
 /*
  * Copyright 2016-2017 Matthieu Gallien <matthieu_gallien@yahoo.fr>
  *
  * This program is free software: you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 3 of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
 #include "abstractfilelisting.h"
 
 #include "config-upnp-qt.h"
 
 #include "abstractfile/indexercommon.h"
 
 #include "filescanner.h"
 
 #include <QThread>
 #include <QHash>
 #include <QFileInfo>
 #include <QFile>
 #include <QDir>
 #include <QFileSystemWatcher>
 #include <QSet>
 #include <QPair>
 #include <QAtomicInt>
 
 #include <QtGlobal>
 
 #include <algorithm>
 #include <utility>
 
 class AbstractFileListingPrivate
 {
 public:
 
     QStringList mAllRootPaths;
 
     QFileSystemWatcher mFileSystemWatcher;
 
     QHash<QString, QUrl> mAllAlbumCover;
 
     QHash<QUrl, QSet<QPair<QUrl, bool>>> mDiscoveredFiles;
 
     FileScanner mFileScanner;
 
     QHash<QUrl, QDateTime> mAllFiles;
 
     QAtomicInt mStopRequest = 0;
 
     int mImportedTracksCount = 0;
 
     int mNewFilesEmitInterval = 1;
 
     bool mHandleNewFiles = true;
 
     bool mWaitEndTrackRemoval = false;
 
     bool mErrorWatchingFileSystemChanges = false;
 
 };
 
 AbstractFileListing::AbstractFileListing(QObject *parent) : QObject(parent), d(std::make_unique<AbstractFileListingPrivate>())
 {
     connect(&d->mFileSystemWatcher, &QFileSystemWatcher::directoryChanged,
             this, &AbstractFileListing::directoryChanged);
     connect(&d->mFileSystemWatcher, &QFileSystemWatcher::fileChanged,
             this, &AbstractFileListing::fileChanged);
 }
 
 AbstractFileListing::~AbstractFileListing()
 = default;
 
 void AbstractFileListing::init()
 {
+    qCDebug(orgKdeElisaIndexer()) << "AbstractFileListing::init";
     Q_EMIT askRestoredTracks();
 }
 
 void AbstractFileListing::newTrackFile(const DataTypes::TrackDataType &partialTrack)
 {
     auto scanFileInfo = QFileInfo(partialTrack.resourceURI().toLocalFile());
     const auto &newTrack = scanOneFile(partialTrack.resourceURI(), scanFileInfo);
 
     if (newTrack.isValid() && newTrack != partialTrack) {
         Q_EMIT modifyTracksList({newTrack}, d->mAllAlbumCover);
     }
 }
 
 void AbstractFileListing::restoredTracks(QHash<QUrl, QDateTime> allFiles)
 {
     executeInit(std::move(allFiles));
 
     refreshContent();
 }
 
 void AbstractFileListing::setAllRootPaths(const QStringList &allRootPaths)
 {
     d->mAllRootPaths = allRootPaths;
 }
 
 void AbstractFileListing::databaseFinishedInsertingTracksList()
 {
 }
 
 void AbstractFileListing::databaseFinishedRemovingTracksList()
 {
     if (waitEndTrackRemoval()) {
         Q_EMIT indexingFinished();
         setWaitEndTrackRemoval(false);
     }
 }
 
 void AbstractFileListing::applicationAboutToQuit()
 {
     d->mStopRequest = 1;
 }
 
 const QStringList &AbstractFileListing::allRootPaths() const
 {
     return d->mAllRootPaths;
 }
 
+bool AbstractFileListing::canHandleRootPaths() const
+{
+    return true;
+}
+
 void AbstractFileListing::scanDirectory(DataTypes::ListTrackDataType &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, oneEntry);
 
         if (newTrack.isValid() && d->mStopRequest == 0) {
             addCover(newTrack);
 
             addFileInDirectory(newTrack.resourceURI(), path);
             newFiles.push_back(newTrack);
 
             ++d->mImportedTracksCount;
 
             if (newFiles.size() > d->mNewFilesEmitInterval && d->mStopRequest == 0) {
                 d->mNewFilesEmitInterval = std::min(50, 1 + d->mNewFilesEmitInterval * d->mNewFilesEmitInterval);
                 emitNewFiles(newFiles);
                 newFiles.clear();
             }
         } else {
             qCDebug(orgKdeElisaIndexer()) << "AbstractFileListing::scanDirectory" << newFilePath << "is not a valid track";
         }
 
         if (d->mStopRequest == 1) {
             break;
         }
     }
 }
 
 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();
 }
 
 void AbstractFileListing::fileChanged(const QString &modifiedFileName)
 {
     QFileInfo modifiedFileInfo(modifiedFileName);
     auto modifiedFile = QUrl::fromLocalFile(modifiedFileName);
 
     auto modifiedTrack = scanOneFile(modifiedFile, modifiedFileInfo);
 
     if (modifiedTrack.isValid()) {
         Q_EMIT modifyTracksList({modifiedTrack}, d->mAllAlbumCover);
     }
 }
 
 void AbstractFileListing::executeInit(QHash<QUrl, QDateTime> allFiles)
 {
     d->mAllFiles = std::move(allFiles);
 }
 
 void AbstractFileListing::triggerRefreshOfContent()
 {
     d->mImportedTracksCount = 0;
 }
 
 void AbstractFileListing::refreshContent()
 {
     triggerRefreshOfContent();
 }
 
 DataTypes::TrackDataType AbstractFileListing::scanOneFile(const QUrl &scanFile, const QFileInfo &scanFileInfo)
 {
     DataTypes::TrackDataType newTrack;
 
     qCDebug(orgKdeElisaIndexer) << "AbstractFileListing::scanOneFile" << scanFile;
 
     auto localFileName = scanFile.toLocalFile();
 
     if (!d->mFileScanner.shouldScanFile(localFileName)) {
         return newTrack;
     }
 
     if (scanFileInfo.exists()) {
         auto itExistingFile = d->mAllFiles.find(scanFile);
         if (itExistingFile != d->mAllFiles.end()) {
             if (*itExistingFile >= scanFileInfo.metadataChangeTime()) {
                 d->mAllFiles.erase(itExistingFile);
                 return newTrack;
             }
         }
     }
 
     newTrack = d->mFileScanner.scanOneFile(scanFile);
 
     if (newTrack.isValid()) {
         newTrack[DataTypes::HasEmbeddedCover] = checkEmbeddedCoverImage(localFileName);
         newTrack[DataTypes::FileModificationTime] = scanFileInfo.metadataChangeTime();
 
         if (scanFileInfo.exists()) {
             watchPath(scanFile.toLocalFile());
         }
     }
 
     return newTrack;
 }
 
 void AbstractFileListing::watchPath(const QString &pathName)
 {
     if (!d->mFileSystemWatcher.addPath(pathName)) {
         qCDebug(orgKdeElisaIndexer) << "AbstractFileListing::watchPath" << "fail for" << pathName;
 
         if (!d->mErrorWatchingFileSystemChanges) {
             d->mErrorWatchingFileSystemChanges = true;
             Q_EMIT errorWatchingFileSystemChanges();
         }
     }
 }
 
 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 = DataTypes::ListTrackDataType();
 
     qCDebug(orgKdeElisaIndexer()) << "AbstractFileListing::scanDirectoryTree" << path;
 
     scanDirectory(newFiles, QUrl::fromLocalFile(path));
 
     if (!newFiles.isEmpty() && d->mStopRequest == 0) {
         emitNewFiles(newFiles);
     }
 }
 
 void AbstractFileListing::setHandleNewFiles(bool handleThem)
 {
     d->mHandleNewFiles = handleThem;
 }
 
 void AbstractFileListing::emitNewFiles(const DataTypes::ListTrackDataType &tracks)
 {
     Q_EMIT tracksList(tracks, d->mAllAlbumCover);
 }
 
 void AbstractFileListing::addCover(const DataTypes::TrackDataType &newTrack)
 {
     auto itCover = d->mAllAlbumCover.find(newTrack.album());
     if (itCover != d->mAllAlbumCover.end()) {
         return;
     }
 
     auto coverUrl = d->mFileScanner.searchForCoverFile(newTrack.resourceURI().toLocalFile());
     if (!coverUrl.isEmpty()) {
         d->mAllAlbumCover[newTrack.resourceURI().toString()] = coverUrl;
     }
 }
 
 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);
     }
 }
 
 QHash<QUrl, QDateTime> &AbstractFileListing::allFiles()
 {
     return d->mAllFiles;
 }
 
 void AbstractFileListing::checkFilesToRemove()
 {
     QList<QUrl> allRemovedFiles;
 
     for (auto itFile = d->mAllFiles.begin(); itFile != d->mAllFiles.end(); ++itFile) {
         allRemovedFiles.push_back(itFile.key());
     }
 
     qCDebug(orgKdeElisaIndexer()) << "AbstractFileListing::checkFilesToRemove" << allRemovedFiles.size();
 
     if (!allRemovedFiles.isEmpty()) {
         setWaitEndTrackRemoval(true);
         Q_EMIT removedTracksList(allRemovedFiles);
     }
 }
 
 FileScanner &AbstractFileListing::fileScanner()
 {
     return d->mFileScanner;
 }
 
 bool AbstractFileListing::checkEmbeddedCoverImage(const QString &localFileName)
 {
     return d->mFileScanner.checkEmbeddedCoverImage(localFileName);
 }
 
 bool AbstractFileListing::waitEndTrackRemoval() const
 {
     return d->mWaitEndTrackRemoval;
 }
 
 void AbstractFileListing::setWaitEndTrackRemoval(bool wait)
 {
     d->mWaitEndTrackRemoval = wait;
 }
 
 
 #include "moc_abstractfilelisting.cpp"
diff --git a/src/abstractfile/abstractfilelisting.h b/src/abstractfile/abstractfilelisting.h
index 1bcd5796..5d85df3d 100644
--- a/src/abstractfile/abstractfilelisting.h
+++ b/src/abstractfile/abstractfilelisting.h
@@ -1,136 +1,138 @@
 /*
  * Copyright 2016-2017 Matthieu Gallien <matthieu_gallien@yahoo.fr>
  *
  * This program is free software: you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 3 of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
 #ifndef ABSTRACTFILELISTING_H
 #define ABSTRACTFILELISTING_H
 
 #include "elisaLib_export.h"
 #include "datatypes.h"
 
 #include <QObject>
 #include <QString>
 #include <QUrl>
 #include <QHash>
 #include <QVector>
 #include <QDateTime>
 
 #include <memory>
 
 class AbstractFileListingPrivate;
 class FileScanner;
 class QFileInfo;
 
 class ELISALIB_EXPORT AbstractFileListing : public QObject
 {
 
     Q_OBJECT
 
 public:
 
     explicit AbstractFileListing(QObject *parent = nullptr);
 
     ~AbstractFileListing() override;
 
     virtual void applicationAboutToQuit();
 
     const QStringList& allRootPaths() const;
 
+    virtual bool canHandleRootPaths() const;
+
 Q_SIGNALS:
 
     void tracksList(const DataTypes::ListTrackDataType &tracks, const QHash<QString, QUrl> &covers);
 
     void removedTracksList(const QList<QUrl> &removedTracks);
 
     void modifyTracksList(const DataTypes::ListTrackDataType &modifiedTracks, const QHash<QString, QUrl> &covers);
 
     void indexingStarted();
 
     void indexingFinished();
 
     void askRestoredTracks();
 
     void errorWatchingFileSystemChanges();
 
 public Q_SLOTS:
 
     void refreshContent();
 
     void init();
 
     void newTrackFile(const DataTypes::TrackDataType &partialTrack);
 
     void restoredTracks(QHash<QUrl, QDateTime> allFiles);
 
     void setAllRootPaths(const QStringList &allRootPaths);
 
     void databaseFinishedInsertingTracksList();
 
     void databaseFinishedRemovingTracksList();
 
 protected Q_SLOTS:
 
     void directoryChanged(const QString &path);
 
     void fileChanged(const QString &modifiedFileName);
 
 protected:
 
     virtual void executeInit(QHash<QUrl, QDateTime> allFiles);
 
     virtual void triggerRefreshOfContent();
 
     void scanDirectory(DataTypes::ListTrackDataType &newFiles, const QUrl &path);
 
     virtual DataTypes::TrackDataType scanOneFile(const QUrl &scanFile, const QFileInfo &scanFileInfo);
 
     void watchPath(const QString &pathName);
 
     void addFileInDirectory(const QUrl &newFile, const QUrl &directoryName);
 
     void scanDirectoryTree(const QString &path);
 
     void setHandleNewFiles(bool handleThem);
 
     void emitNewFiles(const DataTypes::ListTrackDataType &tracks);
 
     void addCover(const DataTypes::TrackDataType &newTrack);
 
     void removeDirectory(const QUrl &removedDirectory, QList<QUrl> &allRemovedFiles);
 
     void removeFile(const QUrl &oneRemovedTrack, QList<QUrl> &allRemovedFiles);
 
     QHash<QUrl, QDateTime>& allFiles();
 
     void checkFilesToRemove();
 
     FileScanner& fileScanner();
 
     bool checkEmbeddedCoverImage(const QString &localFileName);
 
     bool waitEndTrackRemoval() const;
 
     void setWaitEndTrackRemoval(bool wait);
 
 private:
 
     std::unique_ptr<AbstractFileListingPrivate> d;
 
 };
 
 
 
 #endif // ABSTRACTFILELISTING_H
diff --git a/src/baloo/localbaloofilelisting.cpp b/src/baloo/localbaloofilelisting.cpp
index dcb15e3f..12da27ec 100644
--- a/src/baloo/localbaloofilelisting.cpp
+++ b/src/baloo/localbaloofilelisting.cpp
@@ -1,420 +1,430 @@
 /*
  * Copyright 2016-2017 Matthieu Gallien <matthieu_gallien@yahoo.fr>
  *
  * This program is free software: you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 3 of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
 #include "localbaloofilelisting.h"
 
 #include "baloo/baloocommon.h"
 
 #include "elisa_settings.h"
 #include "elisautils.h"
 
 #include "baloo/scheduler.h"
 #include "baloo/fileindexer.h"
 #include "baloo/main.h"
 
 #include "baloowatcherapplicationadaptor.h"
 
 #include "filescanner.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;
 
     QDBusServiceWatcher mServiceWatcher;
 
     QScopedPointer<org::kde::baloo::main> mBalooMainInterface;
 
     QScopedPointer<org::kde::baloo::fileindexer> mBalooIndexer;
 
     QScopedPointer<org::kde::baloo::scheduler> mBalooScheduler;
 
     BalooWatcherApplicationAdaptor *mDbusAdaptor = nullptr;
 
     QAtomicInt mStopRequest = 0;
 
     bool mIsRegisteredToBaloo = false;
 
     bool mIsRegisteringToBaloo = false;
 
     bool mIsRegisteredToBalooWatcher = false;
 
     bool mIsRegisteringToBalooWatcher = false;
 
 };
 
 LocalBalooFileListing::LocalBalooFileListing(QObject *parent)
     : AbstractFileListing(parent), d(std::make_unique<LocalBalooFileListingPrivate>())
 {
     d->mQuery.addType(QStringLiteral("Audio"));
     setHandleNewFiles(false);
 
     auto sessionBus = QDBusConnection::sessionBus();
 
     d->mDbusAdaptor = new BalooWatcherApplicationAdaptor(this);
 
     sessionBus.registerObject(QStringLiteral("/org/kde/BalooWatcherApplication"), d->mDbusAdaptor, QDBusConnection::ExportAllContents);
 
     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()
 {
 }
 
 void LocalBalooFileListing::applicationAboutToQuit()
 {
     AbstractFileListing::applicationAboutToQuit();
     d->mStopRequest = 1;
 }
 
+bool LocalBalooFileListing::canHandleRootPaths() const
+{
+    return false;
+}
+
 void LocalBalooFileListing::newBalooFile(const QString &fileName)
 {
     qCDebug(orgKdeElisaBaloo()) << "LocalBalooFileListing::newBalooFile" << fileName;
 
     auto scanFileInfo = QFileInfo(fileName);
 
     if (!scanFileInfo.exists()) {
         return;
     }
 
     if (!fileScanner().shouldScanFile(fileName)) {
         return;
     }
 
     Q_EMIT indexingStarted();
 
     auto newFile = QUrl::fromLocalFile(fileName);
 
     auto newTrack = scanOneFile(newFile, scanFileInfo);
 
     if (newTrack.isValid()) {
         QFileInfo newFileInfo(fileName);
 
         addFileInDirectory(newFile, QUrl::fromLocalFile(newFileInfo.absoluteDir().absolutePath()));
 
         emitNewFiles({newTrack});
     }
 
     Q_EMIT indexingFinished();
 }
 
 void LocalBalooFileListing::registeredToBaloo(QDBusPendingCallWatcher *watcher)
 {
     qCDebug(orgKdeElisaBaloo) << "LocalBalooFileListing::registeredToBaloo";
 
     if (!watcher) {
         return;
     }
 
     QDBusPendingReply<> reply = *watcher;
     if (reply.isError()) {
         qCDebug(orgKdeElisaBaloo) << "LocalBalooFileListing::registeredToBaloo" << reply.error().name() << reply.error().message();
         d->mIsRegisteredToBaloo = false;
     } else {
         d->mIsRegisteredToBaloo = true;
     }
 
     d->mIsRegisteringToBaloo = false;
 
     watcher->deleteLater();
 }
 
 void LocalBalooFileListing::registeredToBalooWatcher(QDBusPendingCallWatcher *watcher)
 {
     qCDebug(orgKdeElisaBaloo) << "LocalBalooFileListing::registeredToBalooWatcher";
 
     if (!watcher) {
         return;
     }
 
     QDBusPendingReply<> reply = *watcher;
     if (reply.isError()) {
         qCDebug(orgKdeElisaBaloo) << "LocalBalooFileListing::registeredToBalooWatcher" << reply.error().name() << reply.error().message();
         d->mIsRegisteredToBalooWatcher = false;
     } else {
         d->mIsRegisteredToBalooWatcher = true;
     }
 
     d->mIsRegisteringToBalooWatcher = false;
 
     watcher->deleteLater();
 }
 
 void LocalBalooFileListing::registerToBaloo()
 {
     if (d->mIsRegisteringToBaloo || d->mIsRegisteringToBalooWatcher) {
         qCDebug(orgKdeElisaBaloo) << "LocalBalooFileListing::registerToBaloo" << "already registering";
         return;
     }
 
     qCDebug(orgKdeElisaBaloo) << "LocalBalooFileListing::registerToBaloo";
 
     d->mIsRegisteringToBaloo = true;
     d->mIsRegisteringToBalooWatcher = true;
 
     auto sessionBus = QDBusConnection::sessionBus();
 
     d->mBalooMainInterface.reset(new org::kde::baloo::main(QStringLiteral("org.kde.baloo"), QStringLiteral("/"),
                                                            sessionBus, this));
 
     if (!d->mBalooMainInterface->isValid()) {
         qCDebug(orgKdeElisaBaloo) << "LocalBalooFileListing::registerToBaloo" << "invalid org.kde.baloo/main interface";
         return;
     }
 
     d->mBalooIndexer.reset(new org::kde::baloo::fileindexer(QStringLiteral("org.kde.baloo"), QStringLiteral("/fileindexer"),
                                                             sessionBus, this));
 
     if (!d->mBalooIndexer->isValid()) {
         qCDebug(orgKdeElisaBaloo) << "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()) {
         qCDebug(orgKdeElisaBaloo) << "LocalBalooFileListing::registerToBaloo" << "invalid org.kde.baloo/scheduler interface";
         return;
     }
 
     qCDebug(orgKdeElisaBaloo) << "LocalBalooFileListing::registerToBaloo" << "call registerMonitor";
     auto answer = d->mBalooIndexer->registerMonitor();
 
     if (answer.isError()) {
         qCDebug(orgKdeElisaBaloo) << "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);
     }
 
     auto pendingCall = d->mBalooMainInterface->registerBalooWatcher(QStringLiteral("org.mpris.MediaPlayer2.elisa/org/kde/BalooWatcherApplication"));
     qCDebug(orgKdeElisaBaloo) << "LocalBalooFileListing::registerToBaloo" << "call registerBalooWatcher";
     auto pendingCallWatcher2 = new QDBusPendingCallWatcher(pendingCall);
 
     connect(pendingCallWatcher2, &QDBusPendingCallWatcher::finished, this, &LocalBalooFileListing::registeredToBalooWatcher);
     if (pendingCallWatcher2->isFinished()) {
         registeredToBalooWatcher(pendingCallWatcher2);
     }
 }
 
 void LocalBalooFileListing::renamedFiles(const QString &from, const QString &to, const QStringList &listFiles)
 {
     qCDebug(orgKdeElisaBaloo) << "LocalBalooFileListing::renamedFiles" << from << to << listFiles;
 }
 
 void LocalBalooFileListing::serviceOwnerChanged(const QString &serviceName, const QString &oldOwner, const QString &newOwner)
 {
     Q_UNUSED(oldOwner);
     Q_UNUSED(newOwner);
 
     qCDebug(orgKdeElisaBaloo) << "LocalBalooFileListing::serviceOwnerChanged" << serviceName << oldOwner << newOwner;
 
     if (serviceName == QLatin1String("org.kde.baloo") && !newOwner.isEmpty()) {
         d->mIsRegisteredToBaloo = false;
         d->mIsRegisteredToBalooWatcher = false;
         registerToBaloo();
     }
 }
 
 void LocalBalooFileListing::serviceRegistered(const QString &serviceName)
 {
     qCDebug(orgKdeElisaBaloo) << "LocalBalooFileListing::serviceRegistered" << serviceName;
 
     if (serviceName == QLatin1String("org.kde.baloo")) {
         registerToBaloo();
     }
 }
 
 void LocalBalooFileListing::serviceUnregistered(const QString &serviceName)
 {
     qCDebug(orgKdeElisaBaloo) << "LocalBalooFileListing::serviceUnregistered" << serviceName;
 
     if (serviceName == QLatin1String("org.kde.baloo")) {
         d->mIsRegisteredToBaloo = false;
         d->mIsRegisteredToBalooWatcher = false;
     }
 }
 
+void LocalBalooFileListing::stop()
+{
+    qCInfo(orgKdeElisaBaloo()) << "LocalBalooFileListing::stop";
+}
+
 void LocalBalooFileListing::executeInit(QHash<QUrl, QDateTime> allFiles)
 {
     AbstractFileListing::executeInit(std::move(allFiles));
 }
 
 void LocalBalooFileListing::triggerRefreshOfContent()
 {
     qCDebug(orgKdeElisaBaloo()) << "LocalBalooFileListing::triggerRefreshOfContent";
     Q_EMIT indexingStarted();
 
     AbstractFileListing::triggerRefreshOfContent();
 
     const auto &rootPaths = allRootPaths();
     bool hasSingleRootPath = (rootPaths.size() == 1);
     auto singleRootPath = rootPaths.at(0);
 
     auto resultIterator = d->mQuery.exec();
     auto newFiles = DataTypes::ListTrackDataType();
 
     while(resultIterator.next() && d->mStopRequest == 0) {
         const auto &fileName = resultIterator.filePath();
 
         if (hasSingleRootPath) {
             if (!fileName.startsWith(singleRootPath)) {
                 qCDebug(orgKdeElisaBaloo()) << "LocalBalooFileListing::triggerRefreshOfContent" << fileName << "does not match root paths";
                 continue;
             }
         } else {
             bool isIncluded = false;
             for (const auto &oneRootPath : rootPaths) {
                 if (fileName.startsWith(oneRootPath)) {
                     isIncluded = true;
                     break;
                 }
             }
             if (!isIncluded) {
                 qCDebug(orgKdeElisaBaloo()) << "LocalBalooFileListing::triggerRefreshOfContent" << fileName << "does not match root paths";
                 continue;
             }
         }
 
         const auto &newFileUrl = QUrl::fromLocalFile(resultIterator.filePath());
 
         auto scanFileInfo = QFileInfo(fileName);
 
         if (!scanFileInfo.exists()) {
             qCDebug(orgKdeElisaBaloo()) << "LocalBalooFileListing::triggerRefreshOfContent" << fileName << "file does not exists";
             continue;
         }
 
         auto itExistingFile = allFiles().find(newFileUrl);
         if (itExistingFile != allFiles().end()) {
             if (*itExistingFile >= scanFileInfo.metadataChangeTime()) {
                 allFiles().erase(itExistingFile);
                 qCDebug(orgKdeElisaBaloo()) << "LocalBalooFileListing::triggerRefreshOfContent" << fileName << "file not modified since last scan";
                 continue;
             }
         }
 
         const auto currentDirectory = QUrl::fromLocalFile(scanFileInfo.absoluteDir().absolutePath());
 
         addFileInDirectory(newFileUrl, currentDirectory);
 
         const auto &newTrack = scanOneFile(newFileUrl, scanFileInfo);
 
         if (newTrack.isValid()) {
             newFiles.push_back(newTrack);
             if (newFiles.size() > 500 && d->mStopRequest == 0) {
                 qCDebug(orgKdeElisaBaloo()) << "LocalBalooFileListing::triggerRefreshOfContent" << "insert new tracks in database" << newFiles.count();
                 emitNewFiles(newFiles);
                 newFiles.clear();
             }
         } else {
             qCDebug(orgKdeElisaBaloo()) << "LocalBalooFileListing::triggerRefreshOfContent" << fileName << "invalid track" << newTrack;
         }
     }
 
     if (!newFiles.isEmpty() && d->mStopRequest == 0) {
         qCDebug(orgKdeElisaBaloo()) << "LocalBalooFileListing::triggerRefreshOfContent" << "insert new tracks in database" << newFiles.count();
         emitNewFiles(newFiles);
     }
 
     setWaitEndTrackRemoval(false);
 
     checkFilesToRemove();
 
     if (!waitEndTrackRemoval()) {
         Q_EMIT indexingFinished();
     }
 }
 
 DataTypes::TrackDataType LocalBalooFileListing::scanOneFile(const QUrl &scanFile, const QFileInfo &scanFileInfo)
 {
     DataTypes::TrackDataType trackData;
 
     auto localFileName = scanFile.toLocalFile();
 
     Baloo::File match(localFileName);
 
     match.load();
     fileScanner().scanProperties(match, trackData);
     trackData[DataTypes::FileModificationTime] = scanFileInfo.metadataChangeTime();
     trackData[DataTypes::ResourceRole] = scanFile;
 
     if (!trackData.isValid()) {
         qCDebug(orgKdeElisaBaloo) << "LocalBalooFileListing::scanOneFile" << scanFile << "falling back to plain file metadata analysis";
         trackData = AbstractFileListing::scanOneFile(scanFile, scanFileInfo);
     }
 
     if (trackData.isValid()) {
         trackData[DataTypes::HasEmbeddedCover] = checkEmbeddedCoverImage(localFileName);
         addCover(trackData);
     } else {
         qCDebug(orgKdeElisaBaloo) << "LocalBalooFileListing::scanOneFile" << scanFile << "invalid track";
     }
 
     return trackData;
 }
 
 
 #include "moc_localbaloofilelisting.cpp"
diff --git a/src/baloo/localbaloofilelisting.h b/src/baloo/localbaloofilelisting.h
index 44c0017c..874a4bc5 100644
--- a/src/baloo/localbaloofilelisting.h
+++ b/src/baloo/localbaloofilelisting.h
@@ -1,81 +1,85 @@
 /*
  * Copyright 2016 Matthieu Gallien <matthieu_gallien@yahoo.fr>
  *
  * This program is free software: you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 3 of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
 #ifndef LOCALBALOOFILELISTING_H
 #define LOCALBALOOFILELISTING_H
 
 #include "../abstractfile/abstractfilelisting.h"
 
 #include <QObject>
 #include <QString>
 #include <QUrl>
 #include <QHash>
 #include <QVector>
 
 #include <memory>
 
 class LocalBalooFileListingPrivate;
 class QDBusPendingCallWatcher;
 
 class LocalBalooFileListing : public AbstractFileListing
 {
 
     Q_OBJECT
 
 public:
 
     explicit LocalBalooFileListing(QObject *parent = nullptr);
 
     ~LocalBalooFileListing() override;
 
     void applicationAboutToQuit() override;
 
+    bool canHandleRootPaths() const override;
+
 Q_SIGNALS:
 
 public Q_SLOTS:
 
     void renamedFiles(const QString &from, const QString &to, const QStringList &listFiles);
 
     void serviceOwnerChanged(const QString &serviceName, const QString &oldOwner, const QString &newOwner);
 
     void serviceRegistered(const QString &serviceName);
 
     void serviceUnregistered(const QString &serviceName);
 
+    void stop();
+
 private Q_SLOTS:
 
     void newBalooFile(const QString &fileName);
 
     void registeredToBaloo(QDBusPendingCallWatcher *watcher);
 
     void registeredToBalooWatcher(QDBusPendingCallWatcher *watcher);
 
 private:
 
     void registerToBaloo();
 
     void executeInit(QHash<QUrl, QDateTime> allFiles) override;
 
     void triggerRefreshOfContent() override;
 
     DataTypes::TrackDataType scanOneFile(const QUrl &scanFile, const QFileInfo &scanFileInfo) override;
 
     std::unique_ptr<LocalBalooFileListingPrivate> d;
 
 };
 
 #endif // LOCALBALOOFILELISTING_H
diff --git a/src/musiclistenersmanager.cpp b/src/musiclistenersmanager.cpp
index 979adc5a..88ef0c07 100644
--- a/src/musiclistenersmanager.cpp
+++ b/src/musiclistenersmanager.cpp
@@ -1,525 +1,531 @@
 /*
  * Copyright 2016-2017 Matthieu Gallien <matthieu_gallien@yahoo.fr>
  *
  * This program is free software: you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 3 of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
 #include "musiclistenersmanager.h"
 
 #include "config-upnp-qt.h"
 
 #include "indexersManager.h"
 
 #if defined UPNPQT_FOUND && UPNPQT_FOUND
 #include "upnp/upnplistener.h"
 #endif
 
 #if defined KF5Baloo_FOUND && KF5Baloo_FOUND
 #include "baloo/baloolistener.h"
 #include "baloo/baloodetector.h"
 #endif
 
 #if defined Qt5AndroidExtras_FOUND && Qt5AndroidExtras_FOUND
 #include "android/androidmusiclistener.h"
 #endif
 
 #include "databaseinterface.h"
 #include "mediaplaylist.h"
 #include "file/filelistener.h"
 #include "file/localfilelisting.h"
 #include "trackslistener.h"
 #include "elisaapplication.h"
 #include "elisa_settings.h"
 #include "modeldataloader.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 <QDebug>
 
 #include <list>
 
 class MusicListenersManagerPrivate
 {
 public:
 
     QThread mDatabaseThread;
 
     QThread mListenerThread;
 
 #if defined UPNPQT_FOUND && UPNPQT_FOUND
     UpnpListener mUpnpListener;
 #endif
 
 #if defined KF5Baloo_FOUND && KF5Baloo_FOUND
     BalooDetector mBalooDetector;
 
     BalooListener mBalooListener;
 #endif
 
     FileListener mFileListener;
 
 #if defined Qt5AndroidExtras_FOUND && Qt5AndroidExtras_FOUND
     std::unique_ptr<AndroidMusicListener> mAndroidMusicListener;
 #endif
 
     DatabaseInterface mDatabaseInterface;
 
     std::unique_ptr<TracksListener> mTracksListener;
 
     QFileSystemWatcher mConfigFileWatcher;
 
     ElisaApplication *mElisaApplication = nullptr;
 
     int mImportedTracksCount = 0;
 
     bool mIndexerBusy = false;
 
     bool mFileSystemIndexerActive = false;
 
     bool mBalooIndexerActive = false;
 
     bool mBalooIndexerAvailable = false;
 
     bool mAndroidIndexerActive = false;
 
     bool mAndroidIndexerAvailable = false;
 
 };
 
 MusicListenersManager::MusicListenersManager(QObject *parent)
     : QObject(parent), d(std::make_unique<MusicListenersManagerPrivate>())
 {
     connect(&d->mDatabaseInterface, &DatabaseInterface::tracksAdded,
             this, &MusicListenersManager::increaseImportedTracksCount);
 
 #if defined KF5Baloo_FOUND && KF5Baloo_FOUND
     connect(&d->mBalooDetector, &BalooDetector::balooAvailabilityChanged,
             this, &MusicListenersManager::balooAvailabilityChanged);
 #endif
 
     connect(&d->mDatabaseInterface, &DatabaseInterface::requestsInitDone,
             this, &MusicListenersManager::databaseReady);
     connect(this, &MusicListenersManager::clearDatabase,
             &d->mDatabaseInterface, &DatabaseInterface::clearData);
     connect(&d->mDatabaseInterface, &DatabaseInterface::cleanedDatabase,
             this, &MusicListenersManager::cleanedDatabase);
 
     connect(QCoreApplication::instance(), &QCoreApplication::aboutToQuit,
             this, &MusicListenersManager::applicationAboutToQuit);
 
     connect(&d->mConfigFileWatcher, &QFileSystemWatcher::fileChanged,
             this, &MusicListenersManager::configChanged);
 
     d->mListenerThread.start();
     d->mDatabaseThread.start();
 
     d->mDatabaseInterface.moveToThread(&d->mDatabaseThread);
 
     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));
 
     qCInfo(orgKdeElisaIndexersManager) << "Local file system indexer is inactive";
     qCInfo(orgKdeElisaIndexersManager) << "Baloo indexer is unavailable";
     qCInfo(orgKdeElisaIndexersManager) << "Baloo indexer is inactive";
 }
 
 MusicListenersManager::~MusicListenersManager()
 = default;
 
 DatabaseInterface *MusicListenersManager::viewDatabase() const
 {
     return &d->mDatabaseInterface;
 }
 
 void MusicListenersManager::subscribeForTracks(MediaPlayList *client)
 {
     createTracksListener();
     connect(d->mTracksListener.get(), &TracksListener::trackHasChanged, client, &MediaPlayList::trackChanged);
     connect(d->mTracksListener.get(), &TracksListener::trackHasBeenRemoved, client, &MediaPlayList::trackRemoved);
     connect(d->mTracksListener.get(), &TracksListener::tracksListAdded, client, &MediaPlayList::tracksListAdded);
     connect(client, &MediaPlayList::newEntryInList, d->mTracksListener.get(), &TracksListener::newEntryInList);
     connect(client, &MediaPlayList::newUrlInList, d->mTracksListener.get(), &TracksListener::newUrlInList);
     connect(client, &MediaPlayList::newTrackByNameInList, d->mTracksListener.get(), &TracksListener::trackByNameInList);
 }
 
 int MusicListenersManager::importedTracksCount() const
 {
     return d->mImportedTracksCount;
 }
 
 ElisaApplication *MusicListenersManager::elisaApplication() const
 {
     return d->mElisaApplication;
 }
 
 TracksListener *MusicListenersManager::tracksListener() const
 {
     return d->mTracksListener.get();
 }
 
 bool MusicListenersManager::indexerBusy() const
 {
     return d->mIndexerBusy;
 }
 
 bool MusicListenersManager::fileSystemIndexerActive() const
 {
     return d->mFileSystemIndexerActive;
 }
 
 bool MusicListenersManager::balooIndexerActive() const
 {
     return d->mBalooIndexerActive;
 }
 
 bool MusicListenersManager::balooIndexerAvailable() const
 {
     return d->mBalooIndexerAvailable;
 }
 
 bool MusicListenersManager::androidIndexerActive() const
 {
     return d->mAndroidIndexerActive;
 }
 
 bool MusicListenersManager::androidIndexerAvailable() const
 {
     return d->mAndroidIndexerAvailable;
 }
 
 auto MusicListenersManager::initializeRootPath()
 {
     auto initialRootPath = QStringList{};
     auto systemMusicPaths = QStandardPaths::standardLocations(QStandardPaths::MusicLocation);
     for (const auto &musicPath : qAsConst(systemMusicPaths)) {
         initialRootPath.push_back(musicPath);
     }
 
     Elisa::ElisaConfiguration::setRootPath(initialRootPath);
     Elisa::ElisaConfiguration::self()->save();
 
     return initialRootPath;
 }
 
 void MusicListenersManager::databaseReady()
 {
     auto initialRootPath = Elisa::ElisaConfiguration::rootPath();
     if (initialRootPath.isEmpty()) {
         initializeRootPath();
     }
 
     d->mConfigFileWatcher.addPath(Elisa::ElisaConfiguration::self()->config()->name());
 
     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::setElisaApplication(ElisaApplication *elisaApplication)
 {
     if (d->mElisaApplication == elisaApplication) {
         return;
     }
 
     d->mElisaApplication = elisaApplication;
     emit elisaApplicationChanged();
 }
 
 void MusicListenersManager::playBackError(const QUrl &sourceInError, QMediaPlayer::Error playerError)
 {
     qCDebug(orgKdeElisaIndexersManager) << "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::deleteElementById(ElisaUtils::PlayListEntryType entryType, qulonglong databaseId)
 {
     switch(entryType)
     {
     case ElisaUtils::Radio:
         QMetaObject::invokeMethod(&d->mDatabaseInterface, "removeRadio", Qt::QueuedConnection,
                                   Q_ARG(qulonglong, databaseId));
         break;
     case ElisaUtils::Album:
     case ElisaUtils::Artist:
     case ElisaUtils::Genre:
     case ElisaUtils::Lyricist:
     case ElisaUtils::Composer:
     case ElisaUtils::Track:
     case ElisaUtils::FileName:
     case ElisaUtils::Unknown:
         break;
     }
 }
 
 void MusicListenersManager::connectModel(ModelDataLoader *dataLoader)
 {
     dataLoader->moveToThread(&d->mDatabaseThread);
 }
 
 void MusicListenersManager::resetMusicData()
 {
     Q_EMIT clearDatabase();
 }
 
 void MusicListenersManager::configChanged()
 {
     auto currentConfiguration = Elisa::ElisaConfiguration::self();
 
     d->mConfigFileWatcher.addPath(currentConfiguration->config()->name());
 
     currentConfiguration->load();
     currentConfiguration->read();
 
     //resolve symlinks
     QStringList allRootPaths;
     auto inputRootPath = currentConfiguration->rootPath();
     for (const auto &onePath : inputRootPath) {
         auto workPath = onePath;
         if (workPath.startsWith(QLatin1String("file:/"))) {
             auto urlPath = QUrl{workPath};
             workPath = urlPath.toLocalFile();
         }
 
         QFileInfo pathFileInfo(workPath);
         auto directoryPath = pathFileInfo.canonicalFilePath();
         if (!directoryPath.isEmpty()) {
             if (directoryPath.rightRef(1) != QLatin1Char('/'))
             {
                 directoryPath.append(QLatin1Char('/'));
             }
             allRootPaths.push_back(directoryPath);
         }
     }
 
     if (allRootPaths.isEmpty()) {
         allRootPaths = initializeRootPath();
     }
 
     d->mFileListener.setAllRootPaths(allRootPaths);
 
 #if defined KF5Baloo_FOUND && KF5Baloo_FOUND
     d->mBalooListener.setAllRootPaths(allRootPaths);
 #endif
 
     if (!d->mBalooIndexerActive && !d->mFileSystemIndexerActive) {
         testBalooIndexerAvailability();
     }
-    if (d->mBalooIndexerActive) {
+    if (d->mBalooIndexerActive && d->mBalooListener.canHandleRootPaths()) {
+        qCInfo(orgKdeElisaIndexersManager()) << "trigger init of baloo file indexer";
 #if defined KF5Baloo_FOUND && KF5Baloo_FOUND
         QMetaObject::invokeMethod(d->mBalooListener.fileListing(), "init", Qt::QueuedConnection);
 #endif
     } else if (d->mFileSystemIndexerActive) {
+        if (d->mBalooIndexerActive && !d->mBalooListener.canHandleRootPaths()) {
+            qCInfo(orgKdeElisaIndexersManager()) << "trigger stop of baloo file indexer";
+            QMetaObject::invokeMethod(d->mBalooListener.fileListing(), "stop", Qt::QueuedConnection);
+        }
+        qCInfo(orgKdeElisaIndexersManager()) << "trigger init of local file indexer";
         QMetaObject::invokeMethod(d->mFileListener.fileListing(), "init", Qt::QueuedConnection);
     }
 
 #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 defined Qt5AndroidExtras_FOUND && Qt5AndroidExtras_FOUND
     if (!d->mAndroidMusicListener) {
         d->mAndroidMusicListener = std::make_unique<AndroidMusicListener>();
         d->mAndroidMusicListener->moveToThread(&d->mListenerThread);
         d->mAndroidMusicListener->setDatabaseInterface(&d->mDatabaseInterface);
         connect(this, &MusicListenersManager::applicationIsTerminating,
                 d->mAndroidMusicListener.get(), &AndroidMusicListener::applicationAboutToQuit, Qt::DirectConnection);
         connect(d->mAndroidMusicListener.get(), &AndroidMusicListener::indexingStarted,
                 this, &MusicListenersManager::monitorStartingListeners);
         connect(d->mAndroidMusicListener.get(), &AndroidMusicListener::indexingFinished,
                 this, &MusicListenersManager::monitorEndingListeners);
         connect(d->mAndroidMusicListener.get(), &AndroidMusicListener::clearDatabase,
                 &d->mDatabaseInterface, &DatabaseInterface::removeAllTracksFromSource);
     }
 #endif
 }
 
 void MusicListenersManager::increaseImportedTracksCount(const DataTypes::ListTrackDataType &allTracks)
 {
     d->mImportedTracksCount += allTracks.size();
 
     Q_EMIT importedTracksCountChanged();
 }
 
 void MusicListenersManager::decreaseImportedTracksCount()
 {
     --d->mImportedTracksCount;
 
     Q_EMIT importedTracksCountChanged();
 }
 
 void MusicListenersManager::monitorStartingListeners()
 {
     d->mIndexerBusy = true;
     Q_EMIT indexerBusyChanged();
 }
 
 void MusicListenersManager::monitorEndingListeners()
 {
     d->mIndexerBusy = false;
     Q_EMIT indexerBusyChanged();
 }
 
 void MusicListenersManager::cleanedDatabase()
 {
     d->mImportedTracksCount = 0;
     Q_EMIT importedTracksCountChanged();
     Q_EMIT clearedDatabase();
 }
 
 void MusicListenersManager::balooAvailabilityChanged()
 {
 #if defined KF5Baloo_FOUND && KF5Baloo_FOUND
     if (!d->mBalooDetector.balooAvailability()) {
 #else
     if (true) {
 #endif
         if (!d->mFileSystemIndexerActive) {
             startLocalFileSystemIndexing();
         }
 
         return;
     }
 
     qCInfo(orgKdeElisaIndexersManager) << "Baloo indexer is available";
     d->mBalooIndexerAvailable = true;
     Q_EMIT balooIndexerAvailableChanged();
     startBalooIndexing();
 }
 
 void MusicListenersManager::testBalooIndexerAvailability()
 {
 #if defined KF5Baloo_FOUND && KF5Baloo_FOUND
     d->mBalooDetector.checkBalooAvailability();
 #else
     qCInfo(orgKdeElisaIndexersManager) << "Baloo indexer is unavailable";
     d->mBalooIndexerAvailable = false;
     Q_EMIT balooIndexerAvailableChanged();
 
     qCInfo(orgKdeElisaIndexersManager) << "Baloo indexer is inactive";
     d->mBalooIndexerActive = false;
     Q_EMIT balooIndexerActiveChanged();
 
     startLocalFileSystemIndexing();
 #endif
 }
 
 void MusicListenersManager::startLocalFileSystemIndexing()
 {
     if (d->mFileSystemIndexerActive) {
         return;
     }
 
     d->mFileListener.setDatabaseInterface(&d->mDatabaseInterface);
     d->mFileListener.moveToThread(&d->mListenerThread);
     connect(this, &MusicListenersManager::applicationIsTerminating,
             &d->mFileListener, &FileListener::applicationAboutToQuit, Qt::DirectConnection);
     connect(&d->mFileListener, &FileListener::indexingStarted,
             this, &MusicListenersManager::monitorStartingListeners);
     connect(&d->mFileListener, &FileListener::indexingFinished,
             this, &MusicListenersManager::monitorEndingListeners);
 
     qCInfo(orgKdeElisaIndexersManager) << "Local file system indexer is active";
 
     d->mFileSystemIndexerActive = true;
     Q_EMIT fileSystemIndexerActiveChanged();
 }
 
 void MusicListenersManager::startBalooIndexing()
 {
 #if defined KF5Baloo_FOUND && KF5Baloo_FOUND
     d->mBalooListener.moveToThread(&d->mListenerThread);
     d->mBalooListener.setDatabaseInterface(&d->mDatabaseInterface);
     connect(this, &MusicListenersManager::applicationIsTerminating,
             &d->mBalooListener, &BalooListener::applicationAboutToQuit, Qt::DirectConnection);
     connect(&d->mBalooListener, &BalooListener::indexingStarted,
             this, &MusicListenersManager::monitorStartingListeners);
     connect(&d->mBalooListener, &BalooListener::indexingFinished,
             this, &MusicListenersManager::monitorEndingListeners);
     connect(&d->mBalooListener, &BalooListener::clearDatabase,
             &d->mDatabaseInterface, &DatabaseInterface::clearData);
 
     qCInfo(orgKdeElisaIndexersManager) << "Baloo indexer is active";
 
     d->mBalooIndexerActive = true;
     Q_EMIT balooIndexerActiveChanged();
 #endif
 }
 
 void MusicListenersManager::createTracksListener()
 {
     if (!d->mTracksListener) {
         d->mTracksListener = std::make_unique<TracksListener>(&d->mDatabaseInterface);
         d->mTracksListener->moveToThread(&d->mDatabaseThread);
 
         connect(this, &MusicListenersManager::removeTracksInError,
                 &d->mDatabaseInterface, &DatabaseInterface::removeTracksList);
 
         connect(&d->mDatabaseInterface, &DatabaseInterface::trackRemoved, d->mTracksListener.get(), &TracksListener::trackRemoved);
         connect(&d->mDatabaseInterface, &DatabaseInterface::tracksAdded, d->mTracksListener.get(), &TracksListener::tracksAdded);
         connect(&d->mDatabaseInterface, &DatabaseInterface::trackModified, d->mTracksListener.get(), &TracksListener::trackModified);
         Q_EMIT tracksListenerChanged();
     }
 }
 
 
 #include "moc_musiclistenersmanager.cpp"