diff --git a/src/file/fileindexscheduler.h b/src/file/fileindexscheduler.h
--- a/src/file/fileindexscheduler.h
+++ b/src/file/fileindexscheduler.h
@@ -45,7 +45,7 @@
 public:
     FileIndexScheduler(Database* db, FileIndexerConfig* config, QObject* parent = nullptr);
     ~FileIndexScheduler() override;
-    int state() const { return m_indexerState; }
+    int state() const { return m_indexerStates.at(0); }
 
 Q_SIGNALS:
     Q_SCRIPTABLE void stateChanged(int state);
@@ -75,22 +75,23 @@
     void handleFileRemoved(const QString& file);
 
     void scheduleIndexing();
+    void halt();
 
-    Q_SCRIPTABLE void suspend() { setSuspend(true); }
-    Q_SCRIPTABLE void resume() { setSuspend(false); }
+    Q_SCRIPTABLE void suspend() { suspendContentIndexer(true); }
+    Q_SCRIPTABLE void resume() { suspendContentIndexer(false); }
     Q_SCRIPTABLE uint getRemainingTime();
     Q_SCRIPTABLE void checkUnindexedFiles();
     Q_SCRIPTABLE uint getBatchSize();
 
 private Q_SLOTS:
-    void powerManagementStatusChanged(bool isOnBattery);
+    void suspendContentIndexer(bool suspend);
 
 private:
-    void setSuspend(bool suspend);
-
     Database* m_db;
     FileIndexerConfig* m_config;
 
+    QList<Baloo::IndexerState> m_indexerStates;
+
     QStringList m_newFiles;
     QStringList m_modifiedFiles;
     QStringList m_xattrFiles;
@@ -102,7 +103,6 @@
 
     PowerStateMonitor m_powerMonitor;
 
-    IndexerState m_indexerState;
     TimeEstimator m_timeEstimator;
 
     bool m_checkUnindexedFiles;
diff --git a/src/file/fileindexscheduler.cpp b/src/file/fileindexscheduler.cpp
--- a/src/file/fileindexscheduler.cpp
+++ b/src/file/fileindexscheduler.cpp
@@ -39,24 +39,20 @@
     : QObject(parent)
     , m_db(db)
     , m_config(config)
+    , m_indexerStates(QList<Baloo::IndexerState>() << Idle)
     , m_provider(db)
     , m_contentIndexer(nullptr)
-    , m_indexerState(Idle)
     , m_timeEstimator(config, this)
     , m_checkUnindexedFiles(false)
 {
     Q_ASSERT(db);
     Q_ASSERT(config);
 
-    m_threadPool.setMaxThreadCount(1);
-
     connect(&m_powerMonitor, &PowerStateMonitor::powerManagementStatusChanged,
-            this, &FileIndexScheduler::powerManagementStatusChanged);
+            this, &FileIndexScheduler::suspendContentIndexer);
 
     m_contentIndexer = new FileContentIndexer(m_config, &m_provider, this);
     m_contentIndexer->setAutoDelete(false);
-    connect(m_contentIndexer, &FileContentIndexer::done, this,
-            &FileIndexScheduler::scheduleIndexing);
     connect(m_contentIndexer, &FileContentIndexer::newBatchTime, &m_timeEstimator,
             &TimeEstimator::handleNewBatchTime);
 
@@ -71,72 +67,89 @@
 
 void FileIndexScheduler::scheduleIndexing()
 {
-    if (m_threadPool.activeThreadCount() || m_indexerState == Suspended) {
-        return;
-    }
+    auto runnableStateChanged = [=] (Baloo::IndexerState state, bool starting) {
+        if (starting) {
+            m_indexerStates.prepend(state);
+        } else {
+            m_indexerStates.removeOne(state);
+        }
+
+        Q_EMIT stateChanged(m_indexerStates.at(0));
+    };
 
     if (m_config->isInitialRun()) {
+        runnableStateChanged(FirstRun, true);
         auto runnable = new FirstRunIndexer(m_db, m_config, m_config->includeFolders());
-        connect(runnable, &FirstRunIndexer::done, this, &FileIndexScheduler::scheduleIndexing);
+        connect(runnable, &FirstRunIndexer::done, this, [=] () {
+            runnableStateChanged(FirstRun, false);
+            scheduleIndexing();
+        });
+        m_threadPool.start(runnable, 1);
 
-        m_threadPool.start(runnable);
-        m_indexerState = FirstRun;
-        Q_EMIT stateChanged(m_indexerState);
         return;
     }
 
-    if (!m_newFiles.isEmpty()) {
-        auto runnable = new NewFileIndexer(m_db, m_config, m_newFiles);
-        connect(runnable, &NewFileIndexer::done, this, &FileIndexScheduler::scheduleIndexing);
+    if (m_checkUnindexedFiles) {
+        runnableStateChanged(UnindexedFileCheck, true);
+
+        auto runnable = new UnindexedFileIndexer(m_db, m_config);
+        connect(runnable, &UnindexedFileIndexer::done, this, [=] () {
+            runnableStateChanged(UnindexedFileCheck, false);
+            m_checkUnindexedFiles = false;
+            scheduleIndexing();
+        });
+        m_threadPool.start(runnable, 1);
 
-        m_threadPool.start(runnable);
-        m_newFiles.clear();
-        m_indexerState = NewFiles;
-        Q_EMIT stateChanged(m_indexerState);
         return;
     }
 
-    if (!m_modifiedFiles.isEmpty()) {
-        auto runnable = new ModifiedFileIndexer(m_db, m_config, m_modifiedFiles);
-        connect(runnable, &ModifiedFileIndexer::done, this, &FileIndexScheduler::scheduleIndexing);
+    if (!m_newFiles.isEmpty()) {
+        runnableStateChanged(NewFiles, true);
+
+        auto runnable = new NewFileIndexer(m_db, m_config, m_newFiles);
+        connect(runnable, &NewFileIndexer::done, this, [=] () {
+            runnableStateChanged(NewFiles, false);
+            m_newFiles.clear();
+            scheduleIndexing();
+        });
+        m_threadPool.start(runnable, 1);
 
-        m_threadPool.start(runnable);
-        m_modifiedFiles.clear();
-        m_indexerState = ModifiedFiles;
-        Q_EMIT stateChanged(m_indexerState);
         return;
     }
 
     if (!m_xattrFiles.isEmpty()) {
+        runnableStateChanged(XAttrFiles, true);
+
         auto runnable = new XAttrIndexer(m_db, m_config, m_xattrFiles);
-        connect(runnable, &XAttrIndexer::done, this, &FileIndexScheduler::scheduleIndexing);
+        connect(runnable, &XAttrIndexer::done, this, [=] () {
+            runnableStateChanged(XAttrFiles, false);
+            m_xattrFiles.clear();
+        });
 
         m_threadPool.start(runnable);
-        m_xattrFiles.clear();
-        m_indexerState = XAttrFiles;
-        Q_EMIT stateChanged(m_indexerState);
-        return;
-    }
+   }
 
-    if (m_provider.size() && !m_powerMonitor.isOnBattery()) {
-        m_threadPool.start(m_contentIndexer);
-        m_indexerState = ContentIndexing;
-        Q_EMIT stateChanged(m_indexerState);
-        return;
-    }
+   if (!m_modifiedFiles.isEmpty()) {
+        runnableStateChanged(ModifiedFiles, true);
 
-    if (m_checkUnindexedFiles) {
-        auto runnable = new UnindexedFileIndexer(m_db, m_config);
-        connect(runnable, &UnindexedFileIndexer::done, this, &FileIndexScheduler::scheduleIndexing);
+        auto runnable = new ModifiedFileIndexer(m_db, m_config, m_modifiedFiles);
+        connect(runnable, &ModifiedFileIndexer::done, this, [=] () {
+            runnableStateChanged(ModifiedFiles, false);
+            m_modifiedFiles.clear();
+        });
 
         m_threadPool.start(runnable);
-        m_checkUnindexedFiles = false;
-        m_indexerState = UnindexedFileCheck;
-        Q_EMIT stateChanged(m_indexerState);
-        return;
     }
-    m_indexerState = Idle;
-    Q_EMIT stateChanged(m_indexerState);
+
+    if ((m_provider.size() > 0) && !m_indexerStates.contains(Suspended)) {
+            runnableStateChanged(ContentIndexing, true);
+
+        connect(m_contentIndexer, &FileContentIndexer::done, this, [=] () {
+            runnableStateChanged(ContentIndexing, false);
+        });
+
+        m_threadPool.start(m_contentIndexer, -1);
+    }
 }
 
 static void removeStartsWith(QStringList& list, const QString& dir)
@@ -156,48 +169,39 @@
         m_newFiles.removeOne(file);
         m_modifiedFiles.removeOne(file);
         m_xattrFiles.removeOne(file);
-    }
-    else {
+    } else {
         removeStartsWith(m_newFiles, file);
         removeStartsWith(m_modifiedFiles, file);
         removeStartsWith(m_xattrFiles, file);
     }
 }
 
-void FileIndexScheduler::powerManagementStatusChanged(bool isOnBattery)
+void FileIndexScheduler::suspendContentIndexer(bool suspend)
 {
-    qDebug() << "Power state changed";
-    if (isOnBattery && m_indexerState == ContentIndexing) {
-        qDebug() << "On battery stopping content indexer";
+    if (suspend && !m_indexerStates.contains(Suspended)) {
+        qDebug() << "Suspending content indexing";
+
+        m_indexerStates.prepend(Suspended);
         m_contentIndexer->quit();
-        //TODO: Maybe we can add a special state for suspended due to being on battery.
-        m_indexerState = Idle;
-        Q_EMIT stateChanged(m_indexerState);
-    } else if (!isOnBattery) {
+    } else if (m_indexerStates.contains(Suspended)) {
+        qDebug() << "Resuming content indexing";
+
+        m_indexerStates.removeOne(Suspended);
         scheduleIndexing();
     }
 }
 
-void FileIndexScheduler::setSuspend(bool suspend)
+void FileIndexScheduler::halt()
 {
-    if (suspend) {
-        qDebug() << "Suspending";
-        if (m_indexerState == ContentIndexing) {
-            m_contentIndexer->quit();
-        }
-        m_indexerState = Suspended;
-        Q_EMIT stateChanged(m_indexerState);
-    } else {
-        qDebug() << "Resuming";
-        m_indexerState = Idle;
-        // No need to emit here we'll be emitting in scheduling
-        scheduleIndexing();
-    }
+    m_indexerStates = QList<Baloo::IndexerState>() << Idle;
+    m_contentIndexer->quit();
+    m_threadPool.clear();
+    m_threadPool.waitForDone();
 }
 
 uint FileIndexScheduler::getRemainingTime()
 {
-    if (m_indexerState != ContentIndexing) {
+    if (m_indexerStates.at(0) != ContentIndexing) {
         return 0;
     }
     return m_timeEstimator.calculateTimeLeft(m_provider.size());
diff --git a/src/file/mainhub.cpp b/src/file/mainhub.cpp
--- a/src/file/mainhub.cpp
+++ b/src/file/mainhub.cpp
@@ -42,7 +42,9 @@
     connect(&m_fileWatcher, &FileWatch::indexXAttr, &m_fileIndexScheduler, &FileIndexScheduler::indexXAttrFile);
     connect(&m_fileWatcher, &FileWatch::fileRemoved, &m_fileIndexScheduler, &FileIndexScheduler::handleFileRemoved);
 
-    connect(&m_fileWatcher, &FileWatch::installedWatches, &m_fileIndexScheduler, &FileIndexScheduler::scheduleIndexing);
+    connect(&m_fileWatcher, &FileWatch::installedWatches, &m_fileIndexScheduler, &FileIndexScheduler::checkUnindexedFiles);
+
+    connect(QCoreApplication::instance(), &QCoreApplication::aboutToQuit, &m_fileIndexScheduler, &FileIndexScheduler::halt);
 
     MainAdaptor* main = new MainAdaptor(this);
     Q_UNUSED(main)
@@ -61,9 +63,9 @@
 
 void MainHub::updateConfig()
 {
+    m_fileIndexScheduler.halt();
+
     m_config->forceConfigUpdate();
-    // FIXME!!
-    //m_fileIndexer.updateConfig();
     m_fileWatcher.updateIndexedFoldersWatches();
 }
 
diff --git a/src/file/powerstatemonitor.cpp b/src/file/powerstatemonitor.cpp
--- a/src/file/powerstatemonitor.cpp
+++ b/src/file/powerstatemonitor.cpp
@@ -54,11 +54,12 @@
         }
         watch->deleteLater();
     });
-
 }
 
 void PowerStateMonitor::slotPowerManagementStatusChanged(bool conserveResources)
 {
-    m_isOnBattery = conserveResources;
-    Q_EMIT powerManagementStatusChanged(conserveResources);
+    if (m_isOnBattery != conserveResources) {
+        m_isOnBattery = conserveResources;
+        Q_EMIT powerManagementStatusChanged(conserveResources);
+    }
 }
diff --git a/src/tools/balooctl/main.cpp b/src/tools/balooctl/main.cpp
--- a/src/tools/balooctl/main.cpp
+++ b/src/tools/balooctl/main.cpp
@@ -80,8 +80,8 @@
     parser.addPositionalArgument(QStringLiteral("start"), i18n("Start the file indexer"));
     parser.addPositionalArgument(QStringLiteral("stop"), i18n("Stop the file indexer"));
     parser.addPositionalArgument(QStringLiteral("restart"), i18n("Restart the file indexer"));
-    parser.addPositionalArgument(QStringLiteral("suspend"), i18n("Suspend the file indexer"));
-    parser.addPositionalArgument(QStringLiteral("resume"), i18n("Resume the file indexer"));
+    parser.addPositionalArgument(QStringLiteral("suspend"), i18n("Suspend content indexing"));
+    parser.addPositionalArgument(QStringLiteral("resume"), i18n("Resume content indexing"));
     parser.addPositionalArgument(QStringLiteral("check"), i18n("Check for any unindexed files and index them"));
     parser.addPositionalArgument(QStringLiteral("index"), i18n("Index the specified files"));
     parser.addPositionalArgument(QStringLiteral("clear"), i18n("Forget the specified files"));