diff --git a/src/file/fileindexscheduler.h b/src/file/fileindexscheduler.h
--- a/src/file/fileindexscheduler.h
+++ b/src/file/fileindexscheduler.h
@@ -45,14 +45,14 @@
 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);
 
 public Q_SLOTS:
     void indexNewFile(const QString& file) {
-        if (!m_newFiles.contains(file)) {
+        if (!m_newFiles.contains(file) && !m_indexerStates.contains(UnindexedFileCheck)) {
             m_newFiles << file;
             QTimer::singleShot(0, this, &FileIndexScheduler::scheduleIndexing);
         }
@@ -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
@@ -41,24 +41,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);
 
@@ -73,72 +69,87 @@
 
 void FileIndexScheduler::scheduleIndexing()
 {
-    if (m_threadPool.activeThreadCount() || m_indexerState == Suspended) {
-        return;
-    }
+    auto runnableStarted = [=] (Baloo::IndexerState state) {
+        m_indexerStates.prepend(state);
+        Q_EMIT stateChanged(m_indexerStates.at(0));
+    };
+
+    auto runnableStopped = [=] (Baloo::IndexerState state) {
+        m_indexerStates.removeOne(state);
+        Q_EMIT stateChanged(m_indexerStates.at(0));
+        scheduleIndexing();
+    };
 
-    if (m_config->isInitialRun()) {
+    if (m_config->isInitialRun() && !m_indexerStates.contains(FirstRun)) {
         auto runnable = new FirstRunIndexer(m_db, m_config, m_config->includeFolders());
-        connect(runnable, &FirstRunIndexer::done, this, &FileIndexScheduler::scheduleIndexing);
+        connect(runnable, &FirstRunIndexer::done, this, [=] () {
+            runnableStopped(FirstRun);
+        });
+
+        m_threadPool.start(runnable, -(int)FirstRun);
+        runnableStarted(FirstRun);
 
-        m_threadPool.start(runnable);
-        m_indexerState = FirstRun;
-        Q_EMIT stateChanged(m_indexerState);
+        return;
+    } else if (m_indexerStates.contains(FirstRun)) {
         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
+      && !m_indexerStates.contains(NewFiles)
+      && !m_indexerStates.contains(UnindexedFileCheck)) {
+        auto runnable = new UnindexedFileIndexer(m_db, m_config);
+        connect(runnable, &UnindexedFileIndexer::done, this, [=] () {
+            m_checkUnindexedFiles = false;
+            runnableStopped(UnindexedFileCheck);
+        });
 
-        m_threadPool.start(runnable);
-        m_newFiles.clear();
-        m_indexerState = NewFiles;
-        Q_EMIT stateChanged(m_indexerState);
-        return;
+        m_threadPool.start(runnable, -(int)UnindexedFileCheck);
+        runnableStarted(UnindexedFileCheck);
     }
 
-    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() && !m_indexerStates.contains(NewFiles)) {
+        auto runnable = new NewFileIndexer(m_db, m_config, m_newFiles);
+        connect(runnable, &NewFileIndexer::done, this, [=] () {
+            m_newFiles.clear();
+            runnableStopped(NewFiles);
+        });
 
-        m_threadPool.start(runnable);
-        m_modifiedFiles.clear();
-        m_indexerState = ModifiedFiles;
-        Q_EMIT stateChanged(m_indexerState);
-        return;
+        m_threadPool.start(runnable, -(int)NewFiles);
+        runnableStarted(NewFiles);
     }
 
-    if (!m_xattrFiles.isEmpty()) {
+    if (!m_xattrFiles.isEmpty() && !m_indexerStates.contains(XAttrFiles)) {
         auto runnable = new XAttrIndexer(m_db, m_config, m_xattrFiles);
-        connect(runnable, &XAttrIndexer::done, this, &FileIndexScheduler::scheduleIndexing);
+        connect(runnable, &XAttrIndexer::done, this, [=] () {
+            m_xattrFiles.clear();
+            runnableStopped(XAttrFiles);
+        });
 
-        m_threadPool.start(runnable);
-        m_xattrFiles.clear();
-        m_indexerState = XAttrFiles;
-        Q_EMIT stateChanged(m_indexerState);
-        return;
-    }
+        m_threadPool.start(runnable, -(int)XAttrFiles);
+        runnableStarted(XAttrFiles);
+   }
 
-    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() && !m_indexerStates.contains(ModifiedFiles)) {
+        auto runnable = new ModifiedFileIndexer(m_db, m_config, m_modifiedFiles);
+        connect(runnable, &ModifiedFileIndexer::done, this, [=] () {
+            m_modifiedFiles.clear();
+            runnableStopped(ModifiedFiles);
+        });
+
+        m_threadPool.start(runnable, -(int)ModifiedFiles);
+        runnableStarted(ModifiedFiles);
     }
 
-    if (m_checkUnindexedFiles) {
-        auto runnable = new UnindexedFileIndexer(m_db, m_config);
-        connect(runnable, &UnindexedFileIndexer::done, this, &FileIndexScheduler::scheduleIndexing);
+    if ((m_provider.size() > 0)
+      && !m_indexerStates.contains(ContentIndexing)
+      && !m_indexerStates.contains(Suspended)) {
+        connect(m_contentIndexer, &FileContentIndexer::done, this, [=] () {
+            runnableStopped(ContentIndexing);
+        });
 
-        m_threadPool.start(runnable);
-        m_checkUnindexedFiles = false;
-        m_indexerState = UnindexedFileCheck;
-        Q_EMIT stateChanged(m_indexerState);
-        return;
+        m_threadPool.start(m_contentIndexer, -(int)ContentIndexing);
+        runnableStarted(ContentIndexing);
     }
-    m_indexerState = Idle;
-    Q_EMIT stateChanged(m_indexerState);
 }
 
 static void removeStartsWith(QStringList& list, const QString& dir)
@@ -156,48 +167,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/indexerstate.h b/src/file/indexerstate.h
--- a/src/file/indexerstate.h
+++ b/src/file/indexerstate.h
@@ -30,11 +30,11 @@
         Idle,
         Suspended,
         FirstRun,
+        UnindexedFileCheck,
         NewFiles,
         ModifiedFiles,
         XAttrFiles,
-        ContentIndexing,
-        UnindexedFileCheck
+        ContentIndexing
 };
 
 inline QString stateString(IndexerState state)
@@ -50,6 +50,9 @@
     case FirstRun:
         status =  i18n("Initial Indexing");
         break;
+    case UnindexedFileCheck:
+        status = i18n("Checking for unindexed files");
+        break;
     case NewFiles:
         status = i18n("Indexing new files");
         break;
@@ -61,9 +64,6 @@
         break;
     case ContentIndexing:
         status = i18n("Indexing file content");
-        break;
-    case UnindexedFileCheck:
-        status = i18n("Checking for unindexed files");
     }
     return status;
 }
diff --git a/src/file/mainhub.cpp b/src/file/mainhub.cpp
--- a/src/file/mainhub.cpp
+++ b/src/file/mainhub.cpp
@@ -44,6 +44,8 @@
 
     connect(&m_fileWatcher, &FileWatch::installedWatches, &m_fileIndexScheduler, &FileIndexScheduler::scheduleIndexing);
 
+    connect(QCoreApplication::instance(), &QCoreApplication::aboutToQuit, &m_fileIndexScheduler, &FileIndexScheduler::halt);
+
     MainAdaptor* main = new MainAdaptor(this);
     Q_UNUSED(main)
 
@@ -61,6 +63,8 @@
 
 void MainHub::updateConfig()
 {
+    m_fileIndexScheduler.halt();
+
     m_config->forceConfigUpdate();
     // FIXME!!
     //m_fileIndexer.updateConfig();
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"));