diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index b9d67552..8f5bbb2b 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,364 +1,368 @@
 include_directories(${elisa_BINARY_DIR})
 
 set(elisaLib_SOURCES
     mediaplaylist.cpp
     musicalbum.cpp
     musicaudiotrack.cpp
     musicartist.cpp
     musicaudiogenre.cpp
     progressindicator.cpp
     databaseinterface.cpp
     musiclistenersmanager.cpp
     managemediaplayercontrol.cpp
     manageheaderbar.cpp
     manageaudioplayer.cpp
     trackslistener.cpp
     elisaapplication.cpp
     audiowrapper.cpp
     notificationitem.cpp
     topnotificationmanager.cpp
     elisautils.cpp
     datatype.cpp
     trackdatahelper.cpp
     modeldatacache.cpp
     abstractfile/abstractfilelistener.cpp
     abstractfile/abstractfilelisting.cpp
     filescanner.cpp
     file/filelistener.cpp
     file/localfilelisting.cpp
     models/albummodel.cpp
     models/allalbumsmodel.cpp
     models/allartistsmodel.cpp
     models/alltracksmodel.cpp
     models/allgenresmodel.cpp
     models/abstractmediaproxymodel.cpp
     models/allalbumsproxymodel.cpp
     models/allartistsproxymodel.cpp
     models/alltracksproxymodel.cpp
     models/singleartistproxymodel.cpp
     models/singlealbumproxymodel.cpp
     models/genericdatamodel.cpp
 )
 
 if (KF5KIO_FOUND)
     set(elisaLib_SOURCES
         ${elisaLib_SOURCES}
         models/filebrowsermodel.cpp
         models/filebrowserproxymodel.cpp
     )
 endif()
 
 if (KF5Baloo_FOUND)
     if (Qt5DBus_FOUND)
         set(elisaLib_SOURCES
             ${elisaLib_SOURCES}
             baloo/localbaloofilelisting.cpp
             baloo/baloolistener.cpp
             )
 
+        qt5_add_dbus_interface(elisaLib_SOURCES
+            ${BALOO_DBUS_INTERFACES_DIR}/org.kde.baloo.main.xml
+            baloo/main)
+
         qt5_add_dbus_interface(elisaLib_SOURCES
             ${BALOO_DBUS_INTERFACES_DIR}/org.kde.baloo.fileindexer.xml
             baloo/fileindexer)
 
         qt5_add_dbus_interface(elisaLib_SOURCES
             ${BALOO_DBUS_INTERFACES_DIR}/org.kde.baloo.scheduler.xml
             baloo/scheduler)
 
         qt5_add_dbus_adaptor(elisaLib_SOURCES
             ${BALOO_DBUS_INTERFACES_DIR}/org.kde.BalooWatcherApplication.xml
             baloo/localbaloofilelisting.h LocalBalooFileListing)
     endif()
 endif()
 
 if (Qt5DBus_FOUND)
     set(elisaLib_SOURCES
         ${elisaLib_SOURCES}
         mpris2/mpris2.cpp
         mpris2/mediaplayer2.cpp
         mpris2/mediaplayer2player.cpp
     )
 endif()
 
 if (UPNPQT_FOUND)
     set(elisaLib_SOURCES
         ${elisaLib_SOURCES}
         upnp/upnpcontrolcontentdirectory.cpp
         upnp/upnpcontentdirectorymodel.cpp
         upnp/upnpcontrolconnectionmanager.cpp
         upnp/upnpcontrolmediaserver.cpp
         upnp/didlparser.cpp
         upnp/upnplistener.cpp
         upnp/upnpdiscoverallmusic.cpp
         )
 endif()
 
 if (KF5Baloo_FOUND)
     if (Qt5DBus_FOUND)
         qt5_add_dbus_interface(elisaLib_SOURCES
             ${BALOO_DBUS_INTERFACES_DIR}/org.kde.baloo.fileindexer.xml
             baloo/fileindexer)
 
         qt5_add_dbus_interface(elisaLib_SOURCES
             ${BALOO_DBUS_INTERFACES_DIR}/org.kde.baloo.scheduler.xml
             baloo/scheduler)
 
         set(elisaLib_SOURCES
             ${elisaLib_SOURCES}
             ../src/baloo/baloolistener.cpp
             ../src/baloo/localbaloofilelisting.cpp
             )
     endif()
 endif()
 
 kconfig_add_kcfg_files(elisaLib_SOURCES ../src/elisa_settings.kcfgc )
 set(elisaLib_SOURCES
     ${elisaLib_SOURCES}
     ../src/elisa_core.kcfg
 )
 
 add_library(elisaLib ${elisaLib_SOURCES})
 target_link_libraries(elisaLib
     LINK_PUBLIC
         Qt5::Multimedia
     LINK_PRIVATE
         Qt5::Core Qt5::Sql Qt5::Widgets Qt5::Concurrent Qt5::Qml
         KF5::I18n KF5::CoreAddons
         KF5::ConfigCore KF5::ConfigGui)
 
 if (KF5FileMetaData_FOUND)
     target_link_libraries(elisaLib
         LINK_PRIVATE
             KF5::FileMetaData
     )
 endif()
 
 if (KF5KIO_FOUND)
     target_link_libraries(elisaLib
         LINK_PUBLIC
             KF5::KIOCore KF5::KIOFileWidgets KF5::KIOWidgets
     )
 endif()
 
 if (KF5XmlGui_FOUND)
     target_link_libraries(elisaLib
         LINK_PUBLIC
             KF5::XmlGui
     )
 endif()
 
 if (KF5ConfigWidgets_FOUND)
     target_link_libraries(elisaLib
         LINK_PUBLIC
             KF5::ConfigWidgets
     )
 endif()
 
 if (KF5KCMUtils_FOUND)
     target_link_libraries(elisaLib
         LINK_PUBLIC
             KF5::KCMUtils
     )
 endif()
 
 if (KF5Baloo_FOUND)
     if (Qt5DBus_FOUND)
         target_link_libraries(elisaLib
             LINK_PUBLIC
                 KF5::Baloo
         )
     endif()
 endif()
 
 if (Qt5DBus_FOUND)
     target_link_libraries(elisaLib
         LINK_PUBLIC
             Qt5::DBus
     )
 
     if (KF5DBusAddons_FOUND)
         target_link_libraries(elisaLib
             LINK_PUBLIC
                 KF5::DBusAddons
         )
     endif()
 endif()
 
 generate_export_header(elisaLib BASE_NAME ElisaLib EXPORT_FILE_NAME elisaLib_export.h)
 
 set_target_properties(elisaLib PROPERTIES
     VERSION 0.1
     SOVERSION 0
     EXPORT_NAME ElisaLib
 )
 
 install(TARGETS elisaLib ${INSTALL_TARGETS_DEFAULT_ARGS})
 
 set(elisaqmlplugin_SOURCES
     elisaqmlplugin.cpp
     datatype.cpp
     elisautils.cpp
 )
 
 add_library(elisaqmlplugin SHARED ${elisaqmlplugin_SOURCES})
 target_link_libraries(elisaqmlplugin
     LINK_PRIVATE
         Qt5::Quick Qt5::Widgets
         KF5::ConfigCore KF5::ConfigGui
         elisaLib
 )
 
 if (KF5FileMetaData_FOUND)
     target_link_libraries(elisaqmlplugin
         LINK_PRIVATE
             KF5::FileMetaData
     )
 endif()
 
 set_target_properties(elisaqmlplugin PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin/org/kde/elisa)
 
 install(TARGETS elisaqmlplugin DESTINATION ${QML_INSTALL_DIR}/org/kde/elisa/)
 
 install(FILES qmldir DESTINATION ${QML_INSTALL_DIR}/org/kde/elisa)
 
 add_custom_target(copy)
 add_custom_target(copy2)
 
 file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/bin/org/kde/elisa)
 
 add_custom_command(TARGET copy PRE_BUILD
     COMMAND ${CMAKE_COMMAND} -E
     copy ${CMAKE_CURRENT_SOURCE_DIR}/qmldir ${CMAKE_BINARY_DIR}/bin/org/kde/elisa/)
 
 add_custom_command(TARGET copy2 PRE_BUILD
     COMMAND ${CMAKE_COMMAND} -E
     copy ${CMAKE_CURRENT_SOURCE_DIR}/plugins.qmltypes ${CMAKE_BINARY_DIR}/bin/org/kde/elisa/)
 
 add_dependencies(elisaqmlplugin copy copy2)
 
 if (Qt5Quick_FOUND AND Qt5Widgets_FOUND)
     set(elisa_SOURCES
         main.cpp
 
         windows/WindowsTheme.qml
         windows/PlatformIntegration.qml
 
         android/ElisaMainWindow.qml
         android/AndroidTheme.qml
         android/PlatformIntegration.qml
 
         qml/ElisaMainWindow.qml
         qml/ApplicationMenu.qml
         qml/BaseTheme.qml
         qml/Theme.qml
         qml/PlatformIntegration.qml
         qml/LabelWithToolTip.qml
 
         qml/RatingStar.qml
         qml/PlayListEntry.qml
         qml/MediaBrowser.qml
         qml/DraggableItem.qml
         qml/PassiveNotification.qml
         qml/TopNotification.qml
         qml/TopNotificationItem.qml
         qml/TrackImportNotification.qml
 
         qml/HeaderBar.qml
         qml/NavigationActionBar.qml
         qml/MediaPlayerControl.qml
         qml/ContextView.qml
         qml/ContentView.qml
         qml/ViewSelector.qml
         qml/ViewManager.qml
 
         qml/MediaPlayListView.qml
         qml/MediaTrackDelegate.qml
         qml/MediaAlbumTrackDelegate.qml
         qml/MediaTrackMetadataView.qml
         qml/GridBrowserView.qml
         qml/GridBrowserDelegate.qml
         qml/ListBrowserView.qml
         qml/FileBrowserDelegate.qml
         qml/FileBrowserView.qml
     )
 
     qt5_add_resources(elisa_SOURCES resources.qrc)
      set_property(SOURCE qrc_resources.cpp PROPERTY SKIP_AUTOMOC ON)
 
     set(elisa_ICONS_PNG
         ../icons/128-apps-elisa.png
         ../icons/64-apps-elisa.png
         ../icons/48-apps-elisa.png
         ../icons/32-apps-elisa.png
         ../icons/22-apps-elisa.png
         ../icons/16-apps-elisa.png
     )
 
     # add icons to application sources, to have them bundled
     ecm_add_app_icon(elisa_SOURCES ICONS ${elisa_ICONS_PNG})
 
     add_executable(elisa ${elisa_SOURCES})
 
     target_include_directories(elisa PRIVATE ${KDSoap_INCLUDE_DIRS})
 
     target_link_libraries(elisa
         LINK_PRIVATE
             elisaLib
             Qt5::Widgets Qt5::QuickControls2 Qt5::Svg
             KF5::I18n KF5::CoreAddons KF5::ConfigCore KF5::ConfigGui
     )
 
     if (ANDROID)
         target_link_libraries(elisa
             LINK_PRIVATE
             Qt5::AndroidExtras
         )
     endif()
 
     if (KF5Crash_FOUND)
         target_link_libraries(elisa
             LINK_PRIVATE
             KF5::Crash
         )
     endif()
 
     if (KF5Declarative_FOUND)
         target_link_libraries(elisa
             LINK_PRIVATE
                 KF5::Declarative
         )
     endif()
 
     install(TARGETS elisa ${INSTALL_TARGETS_DEFAULT_ARGS})
 endif()
 
 if (KF5ConfigWidgets_FOUND AND KF5Declarative_FOUND)
     add_subdirectory(localFileConfiguration)
 endif()
 
 set(elisaImport_SOURCES
     elisaimport.cpp
     elisaimportapplication.cpp
 )
 
 kconfig_add_kcfg_files(elisaImport_SOURCES ../src/elisa_settings.kcfgc )
 set(elisaImport_SOURCES
     ${elisaImport_SOURCES}
     ../src/elisa_core.kcfg
 )
 
 add_executable(elisaImport ${elisaImport_SOURCES})
 
 target_link_libraries(elisaImport
     LINK_PRIVATE
         KF5::ConfigCore KF5::ConfigGui
         elisaLib
 )
 
 if (KF5FileMetaData_FOUND)
     target_link_libraries(elisaImport
         LINK_PRIVATE
             KF5::FileMetaData
     )
 endif()
 
 set(QML_IMPORT_PATH ${CMAKE_BINARY_DIR}/bin CACHE INTERNAL "qml import path" FORCE)
diff --git a/src/baloo/localbaloofilelisting.cpp b/src/baloo/localbaloofilelisting.cpp
index aee4eb7d..fcc6197c 100644
--- a/src/baloo/localbaloofilelisting.cpp
+++ b/src/baloo/localbaloofilelisting.cpp
@@ -1,402 +1,442 @@
 /*
  * 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 "musicaudiotrack.h"
 #include "notificationitem.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;
 
     QHash<QString, QVector<MusicAudioTrack>> mAllAlbums;
 
     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;
 
-    BalooWatcherApplicationAdaptor *mDbusAdaptor = nullptr;
+    bool mIsRegisteredToBaloo = false;
 
-    bool mIsRegistered = false;
+    bool mIsRegisteringToBaloo = false;
 
-    bool mIsRegistering = false;
+    bool mIsRegisteredToBalooWatcher = false;
+
+    bool mIsRegisteringToBalooWatcher = 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();
 
     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()
 {
     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;
+        qDebug() << "LocalBalooFileListing::registeredToBaloo" << reply.error().name() << reply.error().message();
+        d->mIsRegisteredToBaloo = false;
+    } else {
+        d->mIsRegisteredToBaloo = true;
+
+        if (d->mIsRegisteredToBaloo && d->mIsRegisteredToBalooWatcher) {
+            triggerRefreshOfContent();
+        }
+    }
+
+    d->mIsRegisteringToBaloo = false;
+
+    watcher->deleteLater();
+}
+
+void LocalBalooFileListing::registeredToBalooWatcher(QDBusPendingCallWatcher *watcher)
+{
+    qDebug() << "LocalBalooFileListing::registeredToBalooWatcher";
+
+    if (!watcher) {
+        return;
+    }
+
+    QDBusPendingReply<> reply = *watcher;
+    if (reply.isError()) {
+        qDebug() << "LocalBalooFileListing::registeredToBalooWatcher" << reply.error().name() << reply.error().message();
+        d->mIsRegisteredToBalooWatcher = false;
     } else {
-        d->mIsRegistered = true;
+        d->mIsRegisteredToBalooWatcher = true;
+
+        if (d->mIsRegisteredToBaloo && d->mIsRegisteredToBalooWatcher) {
+            triggerRefreshOfContent();
+        }
     }
 
-    d->mIsRegistering = false;
+    d->mIsRegisteringToBalooWatcher = false;
 
     watcher->deleteLater();
 }
 
 void LocalBalooFileListing::registerToBaloo()
 {
-    if (d->mIsRegistering) {
+    if (d->mIsRegisteringToBaloo || d->mIsRegisteringToBalooWatcher) {
         qDebug() << "LocalBalooFileListing::registerToBaloo" << "already registering";
         return;
     }
 
     qDebug() << "LocalBalooFileListing::registerToBaloo";
 
-    d->mIsRegistering = true;
+    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()) {
+        qDebug() << "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()) {
         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);
     }
 
-    QDBusMessage registerBalooWatcher = QDBusMessage::createMethodCall(QStringLiteral("org.kde.baloo"),
-                                                                       QStringLiteral("/"),
-                                                                       QStringLiteral("org.kde.baloo.main"),
-                                                                       QStringLiteral("registerBalooWatcher"));
-
-    registerBalooWatcher.setArguments({QStringLiteral("org.mpris.MediaPlayer2.elisa/org/kde/BalooWatcherApplication")});
-
-    auto pendingCall = sessionBus.asyncCall(registerBalooWatcher);
+    auto pendingCall = d->mBalooMainInterface->registerBalooWatcher(QStringLiteral("org.mpris.MediaPlayer2.elisa/org/kde/BalooWatcherApplication"));
     qDebug() << "LocalBalooFileListing::registerToBaloo" << "call registerBalooWatcher";
     auto pendingCallWatcher2 = new QDBusPendingCallWatcher(pendingCall);
 
-    connect(pendingCallWatcher2, &QDBusPendingCallWatcher::finished, this, &LocalBalooFileListing::registeredToBaloo);
+    connect(pendingCallWatcher2, &QDBusPendingCallWatcher::finished, this, &LocalBalooFileListing::registeredToBalooWatcher);
     if (pendingCallWatcher2->isFinished()) {
-        registeredToBaloo(pendingCallWatcher2);
+        registeredToBalooWatcher(pendingCallWatcher2);
     }
 }
 
 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;
+        d->mIsRegisteredToBaloo = false;
+        d->mIsRegisteredToBalooWatcher = 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;
+        d->mIsRegisteredToBaloo = false;
+        d->mIsRegisteredToBalooWatcher = false;
     }
 }
 
 void LocalBalooFileListing::executeInit(QHash<QUrl, QDateTime> allFiles)
 {
     AbstractFileListing::executeInit(std::move(allFiles));
 }
 
 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);
             if (newFiles.size() > 500 && d->mStopRequest == 0) {
                 emitNewFiles(newFiles);
                 newFiles.clear();
             }
         }
     }
 
     if (!newFiles.isEmpty() && d->mStopRequest == 0) {
         emitNewFiles(newFiles);
     }
 
     checkFilesToRemove();
 
     Q_EMIT indexingFinished();
 }
 
 MusicAudioTrack LocalBalooFileListing::scanOneFile(const QUrl &scanFile)
 {
     auto newTrack = MusicAudioTrack();
 
     auto localFileName = scanFile.toLocalFile();
     auto scanFileInfo = QFileInfo(localFileName);
 
     if (scanFileInfo.exists()) {
         watchPath(localFileName);
     } else {
         return newTrack;
     }
 
     auto itExistingFile = allFiles().find(scanFile);
     if (itExistingFile != allFiles().end()) {
         if (*itExistingFile >= scanFileInfo.fileTime(QFile::FileModificationTime)) {
             allFiles().erase(itExistingFile);
             return newTrack;
         }
     }
 
     Baloo::File match(localFileName);
 
     match.load();
 
     newTrack.setFileModificationTime(scanFileInfo.fileTime(QFile::FileModificationTime));
     newTrack.setResourceURI(scanFile);
 
     fileScanner().scanProperties(match, newTrack);
 
     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/baloo/localbaloofilelisting.h b/src/baloo/localbaloofilelisting.h
index f8372c07..b51193a7 100644
--- a/src/baloo/localbaloofilelisting.h
+++ b/src/baloo/localbaloofilelisting.h
@@ -1,86 +1,88 @@
 /*
  * 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 MusicAudioTrack;
 class QDBusPendingCallWatcher;
 
 class LocalBalooFileListing : public AbstractFileListing
 {
 
     Q_OBJECT
 
 public:
 
     explicit LocalBalooFileListing(QObject *parent = nullptr);
 
     ~LocalBalooFileListing() override;
 
     void applicationAboutToQuit() 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 fixBalooConfiguration();
 
     void disableBalooIndexer();
 
 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;
 
     MusicAudioTrack scanOneFile(const QUrl &scanFile) override;
 
     bool checkBalooConfiguration();
 
     std::unique_ptr<LocalBalooFileListingPrivate> d;
 
 };
 
 #endif // LOCALBALOOFILELISTING_H