diff --git a/agents/archivemailagent/archivemailagent.cpp b/agents/archivemailagent/archivemailagent.cpp
index 3aeeaa287..834a20d12 100644
--- a/agents/archivemailagent/archivemailagent.cpp
+++ b/agents/archivemailagent/archivemailagent.cpp
@@ -1,152 +1,152 @@
 /*
    Copyright (C) 2012-2020 Laurent Montel <montel@kde.org>
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "archivemailagent.h"
 #include "archivemailagentadaptor.h"
 #include "archivemailmanager.h"
 #include "archivemailagentsettings.h"
 #include <AkonadiCore/ServerManager>
 
 #include <MailCommon/MailKernel>
-#include <KDBusConnectionPool>
+#include <QDBusConnection>
 #include <Monitor>
 #include <Session>
 #include <CollectionFetchScope>
 #include <KMime/Message>
 #include <QTimer>
 
 #include <Kdelibs4ConfigMigrator>
 
 //#define DEBUG_ARCHIVEMAILAGENT 1
 
 ArchiveMailAgent::ArchiveMailAgent(const QString &id)
     : Akonadi::AgentBase(id)
 {
     Kdelibs4ConfigMigrator migrate(QStringLiteral("archivemailagent"));
     migrate.setConfigFiles(QStringList() << QStringLiteral("akonadi_archivemail_agentrc") << QStringLiteral("akonadi_archivemail_agent.notifyrc"));
     migrate.migrate();
 
     connect(this, &Akonadi::AgentBase::reloadConfiguration, this, &ArchiveMailAgent::reload);
 
     mArchiveManager = new ArchiveMailManager(this);
     connect(mArchiveManager, &ArchiveMailManager::needUpdateConfigDialogBox, this, &ArchiveMailAgent::needUpdateConfigDialogBox);
 
     Akonadi::Monitor *collectionMonitor = new Akonadi::Monitor(this);
     collectionMonitor->setObjectName(QStringLiteral("ArchiveMailCollectionMonitor"));
     collectionMonitor->fetchCollection(true);
     collectionMonitor->ignoreSession(Akonadi::Session::defaultSession());
     collectionMonitor->collectionFetchScope().setAncestorRetrieval(Akonadi::CollectionFetchScope::All);
     collectionMonitor->setMimeTypeMonitored(KMime::Message::mimeType());
 
     new ArchiveMailAgentAdaptor(this);
-    KDBusConnectionPool::threadConnection().registerObject(QStringLiteral("/ArchiveMailAgent"), this, QDBusConnection::ExportAdaptors);
+    QDBusConnection::sessionBus().registerObject(QStringLiteral("/ArchiveMailAgent"), this, QDBusConnection::ExportAdaptors);
 
     const QString service = Akonadi::ServerManager::self()->agentServiceName(Akonadi::ServerManager::Agent, identifier());
 
-    KDBusConnectionPool::threadConnection().registerService(service);
+    QDBusConnection::sessionBus().registerService(service);
     connect(collectionMonitor, &Akonadi::Monitor::collectionRemoved, this, &ArchiveMailAgent::mailCollectionRemoved);
 
     if (enabledAgent()) {
 #ifdef DEBUG_ARCHIVEMAILAGENT
         QTimer::singleShot(1000, mArchiveManager, &ArchiveMailManager::load);
 #else
         QTimer::singleShot(1000 * 60 * 5, mArchiveManager, &ArchiveMailManager::load);
 #endif
     }
 
     mTimer = new QTimer(this);
     connect(mTimer, &QTimer::timeout, this, &ArchiveMailAgent::reload);
     mTimer->start(24 * 60 * 60 * 1000);
 }
 
 ArchiveMailAgent::~ArchiveMailAgent()
 {
 }
 
 void ArchiveMailAgent::setEnableAgent(bool enabled)
 {
     if (enabled != ArchiveMailAgentSettings::enabled()) {
         ArchiveMailAgentSettings::setEnabled(enabled);
         ArchiveMailAgentSettings::self()->save();
         if (!enabled) {
             mTimer->stop();
             pause();
         } else {
             mTimer->start();
         }
     }
 }
 
 bool ArchiveMailAgent::enabledAgent() const
 {
     return ArchiveMailAgentSettings::enabled();
 }
 
 void ArchiveMailAgent::mailCollectionRemoved(const Akonadi::Collection &collection)
 {
     mArchiveManager->removeCollection(collection);
 }
 
 void ArchiveMailAgent::doSetOnline(bool online)
 {
     if (online) {
         resume();
     } else {
         pause();
     }
 }
 
 void ArchiveMailAgent::reload()
 {
     if (isOnline() && enabledAgent()) {
         mArchiveManager->load();
         mTimer->start();
     }
 }
 
 void ArchiveMailAgent::pause()
 {
     if (isOnline() && enabledAgent()) {
         mArchiveManager->pause();
     }
 }
 
 void ArchiveMailAgent::resume()
 {
     if (isOnline() && enabledAgent()) {
         mArchiveManager->resume();
     }
 }
 
 QString ArchiveMailAgent::printArchiveListInfo() const
 {
     return mArchiveManager->printArchiveListInfo();
 }
 
 QString ArchiveMailAgent::printCurrentListInfo() const
 {
     return mArchiveManager->printCurrentListInfo();
 }
 
 void ArchiveMailAgent::archiveFolder(const QString &path, Akonadi::Collection::Id collectionId)
 {
     mArchiveManager->archiveFolder(path, collectionId);
 }
 
 AKONADI_AGENT_MAIN(ArchiveMailAgent)
diff --git a/agents/followupreminderagent/followupreminderagent.cpp b/agents/followupreminderagent/followupreminderagent.cpp
index df6122153..a3d5f0a23 100644
--- a/agents/followupreminderagent/followupreminderagent.cpp
+++ b/agents/followupreminderagent/followupreminderagent.cpp
@@ -1,123 +1,123 @@
 /*
    Copyright (C) 2014-2020 Laurent Montel <montel@kde.org>
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "followupreminderagent.h"
 #include "followupremindermanager.h"
 #include "FollowupReminder/FollowUpReminderUtil"
 #include "followupreminderadaptor.h"
 #include "followupreminderagentsettings.h"
 #include <KMime/Message>
 
 #include <AkonadiCore/ChangeRecorder>
 #include <AkonadiCore/ItemFetchScope>
-#include <KDBusConnectionPool>
+#include <QDBusConnection>
 
 #include <Kdelibs4ConfigMigrator>
 #include <AkonadiCore/Session>
 #include <AkonadiCore/CollectionFetchScope>
 #include <AkonadiCore/ServerManager>
 
 #include "followupreminderagent_debug.h"
 #include <QTimer>
 
 FollowUpReminderAgent::FollowUpReminderAgent(const QString &id)
     : Akonadi::AgentBase(id)
 {
     Kdelibs4ConfigMigrator migrate(QStringLiteral("followupreminderagent"));
     migrate.setConfigFiles(QStringList() << QStringLiteral("akonadi_followupreminder_agentrc") << QStringLiteral("akonadi_followupreminder_agent.notifyrc"));
     migrate.migrate();
 
     new FollowUpReminderAgentAdaptor(this);
-    KDBusConnectionPool::threadConnection().registerObject(QStringLiteral("/FollowUpReminder"), this, QDBusConnection::ExportAdaptors);
+    QDBusConnection::sessionBus().registerObject(QStringLiteral("/FollowUpReminder"), this, QDBusConnection::ExportAdaptors);
     const QString service = Akonadi::ServerManager::self()->agentServiceName(Akonadi::ServerManager::Agent, QStringLiteral("akonadi_followupreminder_agent"));
-    KDBusConnectionPool::threadConnection().registerService(service);
+    QDBusConnection::sessionBus().registerService(service);
     mManager = new FollowUpReminderManager(this);
     setNeedsNetwork(true);
 
     changeRecorder()->setMimeTypeMonitored(KMime::Message::mimeType());
     changeRecorder()->itemFetchScope().setCacheOnly(true);
     changeRecorder()->itemFetchScope().setFetchModificationTime(false);
     changeRecorder()->fetchCollection(true);
     changeRecorder()->setChangeRecordingEnabled(false);
     changeRecorder()->ignoreSession(Akonadi::Session::defaultSession());
     changeRecorder()->collectionFetchScope().setAncestorRetrieval(Akonadi::CollectionFetchScope::All);
     changeRecorder()->setCollectionMonitored(Akonadi::Collection::root(), true);
 
     if (FollowUpReminderAgentSettings::enabled()) {
         mManager->load();
     }
 
     mTimer = new QTimer(this);
     connect(mTimer, &QTimer::timeout, this, &FollowUpReminderAgent::reload);
     //Reload all each 24hours
     mTimer->start(24 * 60 * 60 * 1000);
 }
 
 FollowUpReminderAgent::~FollowUpReminderAgent()
 {
 }
 
 void FollowUpReminderAgent::setEnableAgent(bool enabled)
 {
     if (FollowUpReminderAgentSettings::self()->enabled() == enabled) {
         return;
     }
 
     FollowUpReminderAgentSettings::self()->setEnabled(enabled);
     FollowUpReminderAgentSettings::self()->save();
     if (enabled) {
         mManager->load();
         mTimer->start();
     } else {
         mTimer->stop();
     }
 }
 
 bool FollowUpReminderAgent::enabledAgent() const
 {
     return FollowUpReminderAgentSettings::self()->enabled();
 }
 
 void FollowUpReminderAgent::itemAdded(const Akonadi::Item &item, const Akonadi::Collection &collection)
 {
     if (!enabledAgent()) {
         return;
     }
 
     if (item.mimeType() != KMime::Message::mimeType()) {
         qCDebug(FOLLOWUPREMINDERAGENT_LOG) << "FollowUpReminderAgent::itemAdded called for a non-message item!";
         return;
     }
     mManager->checkFollowUp(item, collection);
 }
 
 void FollowUpReminderAgent::reload()
 {
     if (enabledAgent()) {
         mManager->load(true);
         mTimer->start();
     }
 }
 
 QString FollowUpReminderAgent::printDebugInfo() const
 {
     return mManager->printDebugInfo();
 }
 
 AKONADI_AGENT_MAIN(FollowUpReminderAgent)
diff --git a/agents/mailfilteragent/mailfilteragent.cpp b/agents/mailfilteragent/mailfilteragent.cpp
index b060175b8..ededfd512 100644
--- a/agents/mailfilteragent/mailfilteragent.cpp
+++ b/agents/mailfilteragent/mailfilteragent.cpp
@@ -1,438 +1,438 @@
 /*
     Copyright (c) 2011 Tobias Koenig <tokoe@kde.org>
 
     This library is free software; you can redistribute it and/or modify it
     under the terms of the GNU Library General Public License as published by
     the Free Software Foundation; either version 2 of the License, or (at your
     option) any later version.
 
     This library is distributed in the hope that it will be useful, but WITHOUT
     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
     License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to the
     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301, USA.
 */
 
 #include "mailfilteragent.h"
 
 #include "mailcommon/dbusoperators.h"
 #include "dummykernel.h"
 #include "filterlogdialog.h"
 #include "filtermanager.h"
 #include "mailfilteragentadaptor.h"
 #include <AkonadiCore/Pop3ResourceAttribute>
 
 #include <AkonadiCore/ServerManager>
 #include <AkonadiCore/changerecorder.h>
 #include <AkonadiCore/collectionfetchjob.h>
 #include <AkonadiCore/collectionfetchscope.h>
-#include <KDBusConnectionPool>
+#include <QDBusConnection>
 #include <AkonadiCore/itemfetchscope.h>
 #include <Akonadi/KMime/MessageParts>
 #include <Akonadi/KMime/MessageStatus>
 #include <AkonadiCore/session.h>
 #include <MailCommon/MailKernel>
 #include <KLocalizedString>
 #include <QIcon>
 #include "mailfilteragent_debug.h"
 #include <KMime/Message>
 #include <KNotification>
 #include <KWindowSystem>
 #include <AgentManager>
 #include <ItemFetchJob>
 #include <AttributeFactory>
 #include <KConfigGroup>
 
 #include <QTimer>
 #include <KSharedConfig>
 
 #include <Kdelibs4ConfigMigrator>
 
 bool MailFilterAgent::isFilterableCollection(const Akonadi::Collection &collection) const
 {
     if (!collection.contentMimeTypes().contains(KMime::Message::mimeType())) {
         return false;
     }
 
     return m_filterManager->hasAllFoldersFilter() || MailCommon::Kernel::folderIsInbox(collection);
 
     //TODO: check got filter attribute here
 }
 
 MailFilterAgent::MailFilterAgent(const QString &id)
     : Akonadi::AgentBase(id)
     , m_filterLogDialog(nullptr)
 {
     Kdelibs4ConfigMigrator migrate(QStringLiteral("mailfilteragent"));
     migrate.setConfigFiles(QStringList() << QStringLiteral("akonadi_mailfilter_agentrc") << QStringLiteral("akonadi_mailfilter_agent.notifyrc"));
     migrate.migrate();
 
     Akonadi::AttributeFactory::registerAttribute<Akonadi::Pop3ResourceAttribute>();
     mMailFilterKernel = new DummyKernel(this);
     CommonKernel->registerKernelIf(mMailFilterKernel);   //register KernelIf early, it is used by the Filter classes
     CommonKernel->registerSettingsIf(mMailFilterKernel);   //SettingsIf is used in FolderTreeWidget
 
     m_filterManager = new FilterManager(this);
 
     connect(m_filterManager, &FilterManager::percent, this, &MailFilterAgent::emitProgress);
     connect(m_filterManager, &FilterManager::progressMessage, this, &MailFilterAgent::emitProgressMessage);
 
     Akonadi::Monitor *collectionMonitor = new Akonadi::Monitor(this);
     collectionMonitor->setObjectName(QStringLiteral("MailFilterCollectionMonitor"));
     collectionMonitor->fetchCollection(true);
     collectionMonitor->ignoreSession(Akonadi::Session::defaultSession());
     collectionMonitor->collectionFetchScope().setAncestorRetrieval(Akonadi::CollectionFetchScope::All);
     collectionMonitor->setMimeTypeMonitored(KMime::Message::mimeType());
 
     connect(collectionMonitor, &Akonadi::Monitor::collectionAdded, this, &MailFilterAgent::mailCollectionAdded);
     connect(collectionMonitor, qOverload<const Akonadi::Collection &>(&Akonadi::Monitor::collectionChanged),
             this, &MailFilterAgent::mailCollectionChanged);
 
     connect(collectionMonitor, &Akonadi::Monitor::collectionRemoved, this, &MailFilterAgent::mailCollectionRemoved);
     connect(Akonadi::AgentManager::self(), &Akonadi::AgentManager::instanceRemoved, this, &MailFilterAgent::slotInstanceRemoved);
 
     QTimer::singleShot(0, this, &MailFilterAgent::initializeCollections);
 
     qDBusRegisterMetaType<QList<qint64> >();
 
     new MailFilterAgentAdaptor(this);
 
-    KDBusConnectionPool::threadConnection().registerObject(QStringLiteral("/MailFilterAgent"), this, QDBusConnection::ExportAdaptors);
+    QDBusConnection::sessionBus().registerObject(QStringLiteral("/MailFilterAgent"), this, QDBusConnection::ExportAdaptors);
 
     const QString service = Akonadi::ServerManager::self()->agentServiceName(Akonadi::ServerManager::Agent, QStringLiteral("akonadi_mailfilter_agent"));
 
-    KDBusConnectionPool::threadConnection().registerService(service);
+    QDBusConnection::sessionBus().registerService(service);
     //Enabled or not filterlogdialog
     KSharedConfig::Ptr config = KSharedConfig::openConfig();
     if (config->hasGroup("FilterLog")) {
         KConfigGroup group(config, "FilterLog");
         if (group.readEntry("Enabled", false)) {
             KNotification *notify = new KNotification(QStringLiteral("mailfilterlogenabled"));
             notify->setComponentName(QApplication::applicationDisplayName());
             notify->setIconName(QStringLiteral("view-filter"));
             notify->setText(i18nc("Notification when the filter log was enabled", "Mail Filter Log Enabled"));
             notify->sendEvent();
         }
     }
 
     changeRecorder()->itemFetchScope().setAncestorRetrieval(Akonadi::ItemFetchScope::Parent);
     changeRecorder()->itemFetchScope().setCacheOnly(true);
     changeRecorder()->fetchCollection(true);
     changeRecorder()->setChangeRecordingEnabled(false);
 
     mProgressCounter = 0;
     mProgressTimer = new QTimer(this);
     connect(mProgressTimer, &QTimer::timeout, this, [this]() {
         emitProgress();
     });
 
     itemMonitor = new Akonadi::Monitor(this);
     itemMonitor->setObjectName(QStringLiteral("MailFilterItemMonitor"));
     itemMonitor->itemFetchScope().setFetchRemoteIdentification(true);
     itemMonitor->itemFetchScope().setAncestorRetrieval(Akonadi::ItemFetchScope::Parent);
     connect(itemMonitor, &Akonadi::Monitor::itemChanged, this, &MailFilterAgent::slotItemChanged);
 }
 
 MailFilterAgent::~MailFilterAgent()
 {
     delete m_filterLogDialog;
 }
 
 void MailFilterAgent::configure(WId windowId)
 {
     Q_UNUSED(windowId);
 }
 
 void MailFilterAgent::initializeCollections()
 {
     m_filterManager->readConfig();
 
     Akonadi::CollectionFetchJob *job = new Akonadi::CollectionFetchJob(Akonadi::Collection::root(),
                                                                        Akonadi::CollectionFetchJob::Recursive,
                                                                        this);
     job->fetchScope().setContentMimeTypes({ KMime::Message::mimeType() });
     connect(job, &Akonadi::CollectionFetchJob::result,
             this, &MailFilterAgent::initialCollectionFetchingDone);
 }
 
 void MailFilterAgent::initialCollectionFetchingDone(KJob *job)
 {
     if (job->error()) {
         qCWarning(MAILFILTERAGENT_LOG) << job->errorString();
         return; //TODO: proper error handling
     }
 
     const auto fetchJob = qobject_cast<Akonadi::CollectionFetchJob *>(job);
 
     const auto pop3ResourceMap = MailCommon::Kernel::pop3ResourceTargetCollection();
 
     const auto lstCols = fetchJob->collections();
     for (const Akonadi::Collection &collection : lstCols) {
         if (isFilterableCollection(collection)) {
             changeRecorder()->setCollectionMonitored(collection, true);
         } else {
             for (auto pop3ColId : pop3ResourceMap) {
                 if (collection.id() == pop3ColId) {
                     changeRecorder()->setCollectionMonitored(collection, true);
                     break;
                 }
             }
         }
     }
     Q_EMIT status(AgentBase::Idle, i18n("Ready"));
     Q_EMIT percent(100);
     QTimer::singleShot(2000, this, &MailFilterAgent::clearMessage);
 }
 
 void MailFilterAgent::clearMessage()
 {
     Q_EMIT status(AgentBase::Idle, QString());
 }
 
 void MailFilterAgent::itemAdded(const Akonadi::Item &item, const Akonadi::Collection &collection)
 {
     /* The monitor mimetype filter would override the collection filter, therefor we have to check
     * for the mimetype of the item here.
     */
     if (item.mimeType() != KMime::Message::mimeType()) {
         qCDebug(MAILFILTERAGENT_LOG) << "MailFilterAgent::itemAdded called for a non-message item!";
         return;
     }
 
     if (item.remoteId().isEmpty()) {
         itemMonitor->setItemMonitored(item);
     } else {
         filterItem(item, collection);
     }
 }
 
 void MailFilterAgent::slotItemChanged(const Akonadi::Item &item)
 {
     if (item.remoteId().isEmpty()) {
         return;
     }
 
     // now we have the remoteId
     itemMonitor->setItemMonitored(item, false);
     filterItem(item, item.parentCollection());
 }
 
 void MailFilterAgent::filterItem(const Akonadi::Item &item, const Akonadi::Collection &collection)
 {
     MailCommon::SearchRule::RequiredPart requiredPart = m_filterManager->requiredPart(collection.resource());
 
     Akonadi::ItemFetchJob *job = new Akonadi::ItemFetchJob(item);
     connect(job, &Akonadi::ItemFetchJob::itemsReceived,
             this, &MailFilterAgent::itemsReceiviedForFiltering);
     if (requiredPart == MailCommon::SearchRule::CompleteMessage) {
         job->fetchScope().fetchFullPayload();
     } else if (requiredPart == MailCommon::SearchRule::Header) {
         job->fetchScope().fetchPayloadPart(Akonadi::MessagePart::Header, true);
     } else {
         job->fetchScope().fetchPayloadPart(Akonadi::MessagePart::Envelope, true);
     }
     job->fetchScope().setAncestorRetrieval(Akonadi::ItemFetchScope::Parent);
     job->fetchScope().fetchAttribute<Akonadi::Pop3ResourceAttribute>();
     job->setProperty("resource", collection.resource());
 
     //TODO: Error handling?
 }
 
 void MailFilterAgent::itemsReceiviedForFiltering(const Akonadi::Item::List &items)
 {
     if (items.isEmpty()) {
         qCDebug(MAILFILTERAGENT_LOG) << "MailFilterAgent::itemsReceiviedForFiltering items is empty!";
         return;
     }
 
     Akonadi::Item item = items.first();
     /*
     * happens when item no longer exists etc, and queue compression didn't happen yet
     */
     if (!item.hasPayload()) {
         qCDebug(MAILFILTERAGENT_LOG) << "MailFilterAgent::itemsReceiviedForFiltering item has no payload!";
         return;
     }
 
     Akonadi::MessageStatus status;
     status.setStatusFromFlags(item.flags());
     if (status.isRead() || status.isSpam() || status.isIgnored()) {
         return;
     }
 
     QString resource = sender()->property("resource").toString();
     const Akonadi::Pop3ResourceAttribute *pop3ResourceAttribute = item.attribute<Akonadi::Pop3ResourceAttribute>();
     if (pop3ResourceAttribute) {
         resource = pop3ResourceAttribute->pop3AccountName();
     }
 
     emitProgressMessage(i18n("Filtering in %1", Akonadi::AgentManager::self()->instance(resource).name()));
     if (!m_filterManager->process(item, m_filterManager->requiredPart(resource), FilterManager::Inbound, true, resource)) {
         qCWarning(MAILFILTERAGENT_LOG) << "Impossible to process mails";
     }
 
     emitProgress(++mProgressCounter);
 
     mProgressTimer->start(1000);
 }
 
 void MailFilterAgent::mailCollectionAdded(const Akonadi::Collection &collection, const Akonadi::Collection &)
 {
     if (isFilterableCollection(collection)) {
         changeRecorder()->setCollectionMonitored(collection, true);
     }
 }
 
 void MailFilterAgent::mailCollectionChanged(const Akonadi::Collection &collection)
 {
     changeRecorder()->setCollectionMonitored(collection, isFilterableCollection(collection));
 }
 
 void MailFilterAgent::mailCollectionRemoved(const Akonadi::Collection &collection)
 {
     changeRecorder()->setCollectionMonitored(collection, false);
     m_filterManager->mailCollectionRemoved(collection);
 }
 
 QString MailFilterAgent::createUniqueName(const QString &nameTemplate)
 {
     return m_filterManager->createUniqueName(nameTemplate);
 }
 
 void MailFilterAgent::filterItems(const QList< qint64 > &itemIds, int filterSet)
 {
     Akonadi::Item::List items;
     items.reserve(itemIds.count());
     for (qint64 id : itemIds) {
         items << Akonadi::Item(id);
     }
 
     m_filterManager->applyFilters(items, static_cast<FilterManager::FilterSet>(filterSet));
 }
 
 void MailFilterAgent::filterCollections(const QList<qint64> &collections, int filterSet)
 {
     for (qint64 id: collections) {
         auto ifj = new Akonadi::ItemFetchJob{
             Akonadi::Collection{
                 id
             }, this
         };
         ifj->setDeliveryOption(Akonadi::ItemFetchJob::EmitItemsInBatches);
         connect(ifj, &Akonadi::ItemFetchJob::itemsReceived,
                 this, [=](const Akonadi::Item::List &items) {
             m_filterManager->applyFilters(items, static_cast<FilterManager::FilterSet>(filterSet));
         });
     }
 }
 
 void MailFilterAgent::applySpecificFilters(const QList< qint64 > &itemIds, int requiresPart, const QStringList &listFilters)
 {
     Akonadi::Item::List items;
     items.reserve(itemIds.count());
     for (qint64 id : itemIds) {
         items << Akonadi::Item(id);
     }
 
     m_filterManager->applySpecificFilters(items, static_cast<MailCommon::SearchRule::RequiredPart>(requiresPart), listFilters);
 }
 
 void MailFilterAgent::applySpecificFiltersOnCollections(const QList<qint64> &colIds, const QStringList &listFilters, int filterSet)
 {
     // TODO: Actually calculate this based on the listFilters' requirements
     const auto requiresParts = MailCommon::SearchRule::CompleteMessage;
 
     for (qint64 id : colIds) {
         auto ifj = new Akonadi::ItemFetchJob{
             Akonadi::Collection{
                 id
             }, this
         };
         ifj->setDeliveryOption(Akonadi::ItemFetchJob::EmitItemsInBatches);
         connect(ifj, &Akonadi::ItemFetchJob::itemsReceived,
                 this, [=](const Akonadi::Item::List &items) {
             m_filterManager->applySpecificFilters(items, requiresParts, listFilters, static_cast<FilterManager::FilterSet>(filterSet));
         });
     }
 }
 
 void MailFilterAgent::filterItem(qint64 item, int filterSet, const QString &resourceId)
 {
     m_filterManager->filter(Akonadi::Item(item), static_cast<FilterManager::FilterSet>(filterSet), resourceId);
 }
 
 void MailFilterAgent::filter(qint64 item, const QString &filterIdentifier, const QString &resourceId)
 {
     m_filterManager->filter(Akonadi::Item(item), filterIdentifier, resourceId);
 }
 
 void MailFilterAgent::reload()
 {
     const Akonadi::Collection::List collections = changeRecorder()->collectionsMonitored();
     for (const Akonadi::Collection &collection : collections) {
         changeRecorder()->setCollectionMonitored(collection, false);
     }
     initializeCollections();
 }
 
 void MailFilterAgent::showFilterLogDialog(qlonglong windowId)
 {
     if (!m_filterLogDialog) {
         m_filterLogDialog = new FilterLogDialog(nullptr);
         m_filterLogDialog->setAttribute(Qt::WA_NativeWindow, true);
     }
     KWindowSystem::setMainWindow(m_filterLogDialog->windowHandle(), windowId);
     m_filterLogDialog->show();
     m_filterLogDialog->raise();
     m_filterLogDialog->activateWindow();
     m_filterLogDialog->setModal(false);
 }
 
 void MailFilterAgent::emitProgress(int p)
 {
     if (p == 0) {
         mProgressTimer->stop();
         Q_EMIT status(AgentBase::Idle, QString());
     }
     mProgressCounter = p;
     Q_EMIT percent(p);
 }
 
 void MailFilterAgent::emitProgressMessage(const QString &message)
 {
     Q_EMIT status(AgentBase::Running, message);
 }
 
 QString MailFilterAgent::printCollectionMonitored() const
 {
     QString printDebugCollection;
     const Akonadi::Collection::List collections = changeRecorder()->collectionsMonitored();
     if (collections.isEmpty()) {
         printDebugCollection = QStringLiteral("No collection is monitored!");
     } else {
         for (const Akonadi::Collection &collection : collections) {
             if (!printDebugCollection.isEmpty()) {
                 printDebugCollection += QLatin1Char('\n');
             }
             printDebugCollection += QStringLiteral("Collection name: %1\n").arg(collection.name());
             printDebugCollection += QStringLiteral("Collection id: %1\n").arg(collection.id());
         }
     }
     return printDebugCollection;
 }
 
 void MailFilterAgent::expunge(qint64 collectionId)
 {
     mMailFilterKernel->expunge(collectionId, false);
 }
 
 void MailFilterAgent::slotInstanceRemoved(const Akonadi::AgentInstance &instance)
 {
     m_filterManager->agentRemoved(instance.identifier());
 }
 
 AKONADI_AGENT_MAIN(MailFilterAgent)
diff --git a/agents/sendlateragent/sendlateragent.cpp b/agents/sendlateragent/sendlateragent.cpp
index 48d7d6ee9..d8261b643 100644
--- a/agents/sendlateragent/sendlateragent.cpp
+++ b/agents/sendlateragent/sendlateragent.cpp
@@ -1,196 +1,196 @@
 /*
    Copyright (C) 2013-2020 Laurent Montel <montel@kde.org>
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "sendlateragent.h"
 #include "sendlatermanager.h"
 #include "sendlaterconfiguredialog.h"
 #include "sendlaterinfo.h"
 #include "sendlaterutil.h"
 #include "sendlateragentadaptor.h"
 #include "sendlateragentsettings.h"
 #include "sendlaterremovemessagejob.h"
 #include "sendlateragent_debug.h"
 #include <AkonadiCore/ServerManager>
 #include <Akonadi/KMime/SpecialMailCollections>
 #include <AgentInstance>
 #include <AgentManager>
-#include <KDBusConnectionPool>
+#include <QDBusConnection>
 #include <changerecorder.h>
 #include <itemfetchscope.h>
 #include <AkonadiCore/session.h>
 #include <AttributeFactory>
 #include <CollectionFetchScope>
 #include <KMime/Message>
 
 #include <KWindowSystem>
 #include <Kdelibs4ConfigMigrator>
 
 #include <QPointer>
 
 //#define DEBUG_SENDLATERAGENT 1
 
 SendLaterAgent::SendLaterAgent(const QString &id)
     : Akonadi::AgentBase(id)
     , mAgentInitialized(false)
 {
     Kdelibs4ConfigMigrator migrate(QStringLiteral("sendlateragent"));
     migrate.setConfigFiles(QStringList() << QStringLiteral("akonadi_sendlater_agentrc") << QStringLiteral("akonadi_sendlater_agent.notifyrc"));
     migrate.migrate();
 
     mManager = new SendLaterManager(this);
     connect(mManager, &SendLaterManager::needUpdateConfigDialogBox, this, &SendLaterAgent::needUpdateConfigDialogBox);
     new SendLaterAgentAdaptor(this);
-    KDBusConnectionPool::threadConnection().registerObject(QStringLiteral("/SendLaterAgent"), this, QDBusConnection::ExportAdaptors);
+    QDBusConnection::sessionBus().registerObject(QStringLiteral("/SendLaterAgent"), this, QDBusConnection::ExportAdaptors);
 
     const QString service = Akonadi::ServerManager::self()->agentServiceName(Akonadi::ServerManager::Agent, QStringLiteral("akonadi_sendlater_agent"));
 
-    KDBusConnectionPool::threadConnection().registerService(service);
+    QDBusConnection::sessionBus().registerService(service);
 
     changeRecorder()->setMimeTypeMonitored(KMime::Message::mimeType());
     changeRecorder()->itemFetchScope().setCacheOnly(true);
     changeRecorder()->itemFetchScope().setFetchModificationTime(false);
     changeRecorder()->setChangeRecordingEnabled(false);
     changeRecorder()->ignoreSession(Akonadi::Session::defaultSession());
     setNeedsNetwork(true);
 
     if (SendLaterAgentSettings::enabled()) {
 #ifdef DEBUG_SENDLATERAGENT
         QTimer::singleShot(1000, this, &SendLaterAgent::slotStartAgent);
 #else
         QTimer::singleShot(1000 * 60 * 4, this, &SendLaterAgent::slotStartAgent);
 #endif
     }
     // For extra safety, check list every hour, in case we didn't properly get
     // notified about the network going up or down.
     QTimer *reloadListTimer = new QTimer(this);
     connect(reloadListTimer, &QTimer::timeout, this, &SendLaterAgent::reload);
     reloadListTimer->start(1000 * 60 * 60); //1 hour
 }
 
 SendLaterAgent::~SendLaterAgent()
 {
 }
 
 void SendLaterAgent::slotStartAgent()
 {
     mAgentInitialized = true;
     if (isOnline()) {
         mManager->load();
     }
 }
 
 void SendLaterAgent::doSetOnline(bool online)
 {
     if (mAgentInitialized) {
         if (online) {
             reload();
         } else {
             mManager->stopAll();
         }
     }
 }
 
 void SendLaterAgent::reload()
 {
     qCDebug(SENDLATERAGENT_LOG) << " void SendLaterAgent::reload()";
     if (SendLaterAgentSettings::enabled()) {
         mManager->load(true);
     }
 }
 
 void SendLaterAgent::setEnableAgent(bool enabled)
 {
     if (SendLaterAgentSettings::enabled() == enabled) {
         return;
     }
 
     SendLaterAgentSettings::setEnabled(enabled);
     SendLaterAgentSettings::self()->save();
     if (enabled) {
         mManager->load();
     } else {
         mManager->stopAll();
     }
 }
 
 bool SendLaterAgent::enabledAgent() const
 {
     return SendLaterAgentSettings::enabled();
 }
 
 void SendLaterAgent::configure(WId windowId)
 {
     QPointer<SendLaterConfigureDialog> dialog = new SendLaterConfigureDialog();
     if (windowId) {
         dialog->setAttribute(Qt::WA_NativeWindow, true);
         KWindowSystem::setMainWindow(dialog->windowHandle(), windowId);
     }
     connect(this, &SendLaterAgent::needUpdateConfigDialogBox, dialog.data(), &SendLaterConfigureDialog::slotNeedToReloadConfig);
     connect(dialog.data(), &SendLaterConfigureDialog::sendNow, this, &SendLaterAgent::slotSendNow);
     if (dialog->exec()) {
         mManager->load();
         const QVector<Akonadi::Item::Id> listMessage = dialog->messagesToRemove();
         if (!listMessage.isEmpty()) {
             //Will delete in specific job when done.
             SendLaterRemoveMessageJob *sendlaterremovejob = new SendLaterRemoveMessageJob(listMessage, this);
             sendlaterremovejob->start();
         }
     }
     delete dialog;
 }
 
 void SendLaterAgent::removeItem(qint64 item)
 {
     if (mManager->itemRemoved(item)) {
         reload();
     }
 }
 
 void SendLaterAgent::slotSendNow(Akonadi::Item::Id id)
 {
     mManager->sendNow(id);
 }
 
 void SendLaterAgent::itemsRemoved(const Akonadi::Item::List &items)
 {
     bool needToReload = false;
     for (const Akonadi::Item &item : items) {
         if (mManager->itemRemoved(item.id())) {
             needToReload = true;
         }
     }
     if (needToReload) {
         reload();
     }
 }
 
 void SendLaterAgent::itemsMoved(const Akonadi::Item::List &items, const Akonadi::Collection & /*sourceCollection*/, const Akonadi::Collection &destinationCollection)
 {
     if (Akonadi::SpecialMailCollections::self()->specialCollectionType(destinationCollection) != Akonadi::SpecialMailCollections::Trash) {
         return;
     }
     itemsRemoved(items);
 }
 
 QString SendLaterAgent::printDebugInfo() const
 {
     return mManager->printDebugInfo();
 }
 
 AKONADI_AGENT_MAIN(SendLaterAgent)
diff --git a/agents/unifiedmailboxagent/unifiedmailboxagent.cpp b/agents/unifiedmailboxagent/unifiedmailboxagent.cpp
index 1c3ec538a..7369851d4 100644
--- a/agents/unifiedmailboxagent/unifiedmailboxagent.cpp
+++ b/agents/unifiedmailboxagent/unifiedmailboxagent.cpp
@@ -1,285 +1,285 @@
 /*
    Copyright (C) 2018 Daniel Vrátil <dvratil@kde.org>
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "unifiedmailboxagent.h"
 #include "unifiedmailbox.h"
 #include "unifiedmailboxagent_debug.h"
 #include "unifiedmailboxagentadaptor.h"
 #include "settingsdialog.h"
 #include "settings.h"
 #include "common.h"
 
 #include <AkonadiCore/ChangeRecorder>
 #include <AkonadiCore/Session>
 #include <AkonadiCore/CollectionFetchJob>
 #include <AkonadiCore/CollectionFetchScope>
 #include <AkonadiCore/CollectionDeleteJob>
 #include <AkonadiCore/SpecialCollectionAttribute>
 #include <AkonadiCore/EntityDisplayAttribute>
 #include <AkonadiCore/ItemFetchScope>
 #include <AkonadiCore/ItemFetchJob>
 #include <AkonadiCore/LinkJob>
 #include <AkonadiCore/UnlinkJob>
 #include <AkonadiCore/ServerManager>
 #include <Akonadi/KMime/SpecialMailCollections>
 
 #include <KIdentityManagement/IdentityManager>
 #include <KIdentityManagement/Identity>
 
 #include <KLocalizedString>
-#include <KDBusConnectionPool>
+#include <QDBusConnection>
 
 #include <QPointer>
 #include <QTimer>
 
 #include <memory>
 #include <unordered_set>
 #include <chrono>
 
 UnifiedMailboxAgent::UnifiedMailboxAgent(const QString &id)
     : Akonadi::ResourceBase(id)
     , mBoxManager(config())
 {
     setAgentName(i18n("Unified Mailboxes"));
 
     new UnifiedMailboxAgentAdaptor(this);
-    KDBusConnectionPool::threadConnection().registerObject(QStringLiteral("/UnifiedMailboxAgent"), this, QDBusConnection::ExportAdaptors);
+    QDBusConnection::sessionBus().registerObject(QStringLiteral("/UnifiedMailboxAgent"), this, QDBusConnection::ExportAdaptors);
     const auto service = Akonadi::ServerManager::agentServiceName(Akonadi::ServerManager::Resource, identifier());
-    KDBusConnectionPool::threadConnection().registerService(service);
+    QDBusConnection::sessionBus().registerService(service);
 
     connect(&mBoxManager, &UnifiedMailboxManager::updateBox,
             this, [this](const UnifiedMailbox *box) {
         if (box->collectionId() <= -1) {
             qCWarning(UNIFIEDMAILBOXAGENT_LOG) << "MailboxManager wants us to update Box but does not have its CollectionId!?";
             return;
         }
 
         // Schedule collection sync for the box
         synchronizeCollection(box->collectionId());
     });
 
     auto &ifs = changeRecorder()->itemFetchScope();
     ifs.setAncestorRetrieval(Akonadi::ItemFetchScope::None);
     ifs.setCacheOnly(true);
     ifs.fetchFullPayload(false);
 
     if (Settings::self()->enabled()) {
         QTimer::singleShot(0, this, &UnifiedMailboxAgent::delayedInit);
     }
 }
 
 void UnifiedMailboxAgent::configure(WId windowId)
 {
     QPointer<UnifiedMailboxAgent> agent(this);
     if (agent) {
         SettingsDialog(config(), mBoxManager, windowId).exec();
         synchronize();
         Q_EMIT configurationDialogAccepted();
     }
 }
 
 void UnifiedMailboxAgent::delayedInit()
 {
     qCDebug(UNIFIEDMAILBOXAGENT_LOG) << "delayed init";
 
     fixSpecialCollections();
     mBoxManager.loadBoxes([this]() {
         // boxes loaded, let's sync up
         synchronize();
     });
 }
 
 bool UnifiedMailboxAgent::enabledAgent() const
 {
     return Settings::self()->enabled();
 }
 
 void UnifiedMailboxAgent::setEnableAgent(bool enabled)
 {
     if (enabled != Settings::self()->enabled()) {
         Settings::self()->setEnabled(enabled);
         Settings::self()->save();
         if (!enabled) {
             setOnline(false);
             auto fetch = new Akonadi::CollectionFetchJob(Akonadi::Collection::root(), Akonadi::CollectionFetchJob::Recursive, this);
             fetch->fetchScope().setResource(identifier());
             connect(fetch, &Akonadi::CollectionFetchJob::collectionsReceived,
                     this, [this](const Akonadi::Collection::List &cols) {
                 for (const auto &col : cols) {
                     new Akonadi::CollectionDeleteJob(col, this);
                 }
             });
         } else {
             setOnline(true);
             delayedInit();
         }
     }
 }
 
 void UnifiedMailboxAgent::retrieveCollections()
 {
     if (!Settings::self()->enabled()) {
         collectionsRetrieved({});
         return;
     }
 
     Akonadi::Collection::List collections;
 
     Akonadi::Collection topLevel;
     topLevel.setName(identifier());
     topLevel.setRemoteId(identifier());
     topLevel.setParentCollection(Akonadi::Collection::root());
     topLevel.setContentMimeTypes({Akonadi::Collection::mimeType()});
     topLevel.setRights(Akonadi::Collection::ReadOnly);
     auto displayAttr = topLevel.attribute<Akonadi::EntityDisplayAttribute>(Akonadi::Collection::AddIfMissing);
     displayAttr->setDisplayName(i18n("Unified Mailboxes"));
     displayAttr->setActiveIconName(QStringLiteral("globe"));
     collections.push_back(topLevel);
 
     for (const auto &boxIt : mBoxManager) {
         const auto &box = boxIt.second;
         Akonadi::Collection col;
         col.setName(box->id());
         col.setRemoteId(box->id());
         col.setParentCollection(topLevel);
         col.setContentMimeTypes({Common::MailMimeType});
         col.setRights(Akonadi::Collection::CanChangeItem | Akonadi::Collection::CanDeleteItem);
         col.setVirtual(true);
         auto displayAttr = col.attribute<Akonadi::EntityDisplayAttribute>(Akonadi::Collection::AddIfMissing);
         displayAttr->setDisplayName(box->name());
         displayAttr->setIconName(box->icon());
         collections.push_back(std::move(col));
     }
 
     collectionsRetrieved(std::move(collections));
 
     // Add mapping between boxes and collections
     mBoxManager.discoverBoxCollections();
 }
 
 void UnifiedMailboxAgent::retrieveItems(const Akonadi::Collection &c)
 {
     if (!Settings::self()->enabled()) {
         itemsRetrieved({});
         return;
     }
 
     // First check that we have all Items from all source collections
     Q_EMIT status(Running, i18n("Synchronizing unified mailbox %1", c.displayName()));
     const auto unifiedBox = mBoxManager.unifiedMailboxFromCollection(c);
     if (!unifiedBox) {
         qCWarning(UNIFIEDMAILBOXAGENT_LOG) << "Failed to retrieve box ID for collection " << c.id();
         itemsRetrievedIncremental({}, {}); // fake incremental retrieval
         return;
     }
 
     const auto lastSeenEvent = QDateTime::fromSecsSinceEpoch(c.remoteRevision().toLongLong());
 
     const auto sources = unifiedBox->sourceCollections();
     for (auto source  : sources) {
         auto fetch = new Akonadi::ItemFetchJob(Akonadi::Collection(source), this);
         fetch->setDeliveryOption(Akonadi::ItemFetchJob::EmitItemsInBatches);
         fetch->fetchScope().setFetchVirtualReferences(true);
         fetch->fetchScope().setCacheOnly(true);
         connect(fetch, &Akonadi::ItemFetchJob::itemsReceived,
                 this, [this, c](const Akonadi::Item::List &items) {
             Akonadi::Item::List toLink;
             std::copy_if(items.cbegin(), items.cend(), std::back_inserter(toLink),
                          [&c](const Akonadi::Item &item) {
                 return !item.virtualReferences().contains(c);
             });
             if (!toLink.isEmpty()) {
                 new Akonadi::LinkJob(c, toLink, this);
             }
         });
     }
 
     auto fetch = new Akonadi::ItemFetchJob(c, this);
     fetch->setDeliveryOption(Akonadi::ItemFetchJob::EmitItemsInBatches);
     fetch->fetchScope().setCacheOnly(true);
     fetch->fetchScope().setAncestorRetrieval(Akonadi::ItemFetchScope::Parent);
     connect(fetch, &Akonadi::ItemFetchJob::itemsReceived,
             this, [this, unifiedBox, c](const Akonadi::Item::List &items) {
         Akonadi::Item::List toUnlink;
         std::copy_if(items.cbegin(), items.cend(), std::back_inserter(toUnlink),
                      [&unifiedBox](const Akonadi::Item &item) {
             return !unifiedBox->sourceCollections().contains(item.storageCollectionId());
         });
         if (!toUnlink.isEmpty()) {
             new Akonadi::UnlinkJob(c, toUnlink, this);
         }
     });
     connect(fetch, &Akonadi::ItemFetchJob::result,
             this, [this]() {
         itemsRetrievedIncremental({}, {});         // fake incremental retrieval
     });
 }
 
 bool UnifiedMailboxAgent::retrieveItem(const Akonadi::Item &item, const QSet<QByteArray> &parts)
 {
     // This method should never be called by Akonadi
     Q_UNUSED(parts);
     qCWarning(UNIFIEDMAILBOXAGENT_LOG) << "retrieveItem() for item" << item.id() << "called but we can't own any items! This is a bug in Akonadi";
     return false;
 }
 
 void UnifiedMailboxAgent::fixSpecialCollection(const QString &colId, Akonadi::SpecialMailCollections::Type type)
 {
     if (colId.isEmpty()) {
         return;
     }
     const auto id = colId.toLongLong();
     // SpecialMailCollection requires the Collection to have a Resource set as well, so
     // we have to retrieve it first.
     connect(new Akonadi::CollectionFetchJob(Akonadi::Collection(id), Akonadi::CollectionFetchJob::Base, this),
             &Akonadi::CollectionFetchJob::collectionsReceived,
             this, [type](const Akonadi::Collection::List &cols) {
         if (cols.count() != 1) {
             qCWarning(UNIFIEDMAILBOXAGENT_LOG) << "Identity special collection retrieval did not find a valid collection";
             return;
         }
         Akonadi::SpecialMailCollections::self()->registerCollection(type, cols.first());
     });
 }
 
 void UnifiedMailboxAgent::fixSpecialCollections()
 {
     // This is a tiny hack to assign proper SpecialCollectionAttribute to special collections
     // assigned trough Identities. This should happen automatically in KMail when user changes
     // the special collections on the identity page, but until recent master (2018-07-24) this
     // wasn't the case and there's no automatic migration, so we need to fix up manually here.
 
     if (Settings::self()->fixedSpecialCollections()) {
         return;
     }
 
     qCDebug(UNIFIEDMAILBOXAGENT_LOG) << "Fixing special collections assigned from Identities";
 
     for (const auto &identity : *KIdentityManagement::IdentityManager::self()) {
         if (!identity.disabledFcc()) {
             fixSpecialCollection(identity.fcc(), Akonadi::SpecialMailCollections::SentMail);
         }
         fixSpecialCollection(identity.drafts(), Akonadi::SpecialMailCollections::Drafts);
         fixSpecialCollection(identity.templates(), Akonadi::SpecialMailCollections::Templates);
     }
 
     Settings::self()->setFixedSpecialCollections(true);
 }
 
 AKONADI_RESOURCE_MAIN(UnifiedMailboxAgent)