12 files changed, 104 insertions, 93 deletions

diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt
index f6847a7..2ece210 100644
--- a/common/CMakeLists.txt
+++ b/common/CMakeLists.txt
@@ -1,19 +1,6 @@
+include_directories(${CMAKE_CURRENT_BINARY_DIR})
+
 project(akonadi2common)
-generate_flatbuffers(
-    commands/commandcompletion
-    commands/createentity
-    commands/deleteentity
-    commands/fetchentity
-    commands/handshake
-    commands/modifyentity
-    commands/revisionupdate
-    commands/synchronize
-    commands/notification
-    domain/event
-    entity
-    metadata
-    queuedcommand
-)
 
 if (STORAGE_unqlite)
     add_definitions(-DUNQLITE_ENABLE_THREADS -fpermissive)
@@ -41,8 +28,27 @@ set(command_SRCS
     ${storage_SRCS})
 
 add_library(${PROJECT_NAME} SHARED ${command_SRCS})
+
+generate_flatbuffers(
+    ${PROJECT_NAME}
+
+    commands/commandcompletion
+    commands/createentity
+    commands/deleteentity
+    commands/fetchentity
+    commands/handshake
+    commands/modifyentity
+    commands/revisionupdate
+    commands/synchronize
+    commands/notification
+    domain/event
+    entity
+    metadata
+    queuedcommand
+)
+
 generate_export_header(${PROJECT_NAME} BASE_NAME Akonadi2Common EXPORT_FILE_NAME akonadi2common_export.h)
 SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES LINKER_LANGUAGE CXX)
 qt5_use_modules(${PROJECT_NAME} Network)
-target_link_libraries(${PROJECT_NAME} ${storage_LIBS} akonadi2async)
+target_link_libraries(${PROJECT_NAME} ${storage_LIBS} KF5::Async)
 install(TARGETS ${PROJECT_NAME} ${KDE_INSTALL_TARGETS_DEFAULT_ARGS})
diff --git a/common/clientapi.cpp b/common/clientapi.cpp
index e4608c8..d287fcf 100644
--- a/common/clientapi.cpp
+++ b/common/clientapi.cpp
@@ -42,7 +42,7 @@ QByteArray getTypeName<AkonadiResource>()
 void Store::shutdown(const QByteArray &identifier)
 {
     Trace() << "shutdown";
-    ResourceAccess::connectToServer(identifier).then<void, QSharedPointer<QLocalSocket>>([identifier](const QSharedPointer<QLocalSocket> &socket, Async::Future<void> &future) {
+    ResourceAccess::connectToServer(identifier).then<void, QSharedPointer<QLocalSocket>>([identifier](const QSharedPointer<QLocalSocket> &socket, KAsync::Future<void> &future) {
         //We can't currently reuse the socket
         socket->close();
         auto resourceAccess = QSharedPointer<Akonadi2::ResourceAccess>::create(identifier);
diff --git a/common/clientapi.h b/common/clientapi.h
index 1bd8bdc..c098bb5 100644
--- a/common/clientapi.h
+++ b/common/clientapi.h
@@ -28,8 +28,10 @@
 #include <QEventLoop>
 #include <functional>
 #include <memory>
+
+#include <Async/Async>
+
 #include "threadboundary.h"
-#include "async/src/async.h"
 #include "resultprovider.h"
 
 namespace async {
@@ -228,10 +230,10 @@ class StoreFacade {
 public:
     virtual ~StoreFacade(){};
     QByteArray type() const { return ApplicationDomain::getTypeName<DomainType>(); }
-    virtual Async::Job<void> create(const DomainType &domainObject) = 0;
-    virtual Async::Job<void> modify(const DomainType &domainObject) = 0;
-    virtual Async::Job<void> remove(const DomainType &domainObject) = 0;
-    virtual Async::Job<void> load(const Query &query, const QSharedPointer<ResultProvider<typename DomainType::Ptr> > &resultProvider) = 0;
+    virtual KAsync::Job<void> create(const DomainType &domainObject) = 0;
+    virtual KAsync::Job<void> modify(const DomainType &domainObject) = 0;
+    virtual KAsync::Job<void> remove(const DomainType &domainObject) = 0;
+    virtual KAsync::Job<void> load(const Query &query, const QSharedPointer<ResultProvider<typename DomainType::Ptr> > &resultProvider) = 0;
 };
 
 
@@ -341,8 +343,8 @@ public:
         //The result provider must be threadsafe.
         async::run([query, resultSet](){
             // Query all resources and aggregate results
-            Async::iterate(query.resources)
-            .template each<void, QByteArray>([query, resultSet](const QByteArray &resource, Async::Future<void> &future) {
+            KAsync::iterate(query.resources)
+            .template each<void, QByteArray>([query, resultSet](const QByteArray &resource, KAsync::Future<void> &future) {
                 //TODO pass resource identifier to factory
                 auto facade = FacadeFactory::instance().getFacade<DomainType>(resource);
                 if (facade) {
diff --git a/common/facade.h b/common/facade.h
index 8c6578f..5743aa2 100644
--- a/common/facade.h
+++ b/common/facade.h
@@ -23,7 +23,8 @@
 
 #include <QByteArray>
 
-#include "async/src/async.h"
+#include <Async/Async>
+
 #include "resourceaccess.h"
 #include "commands.h"
 #include "createentity_generated.h"
@@ -44,13 +45,13 @@ class QueryRunner : public QObject
 {
     Q_OBJECT
 public:
-    typedef std::function<Async::Job<qint64>(qint64 oldRevision, qint64 newRevision)> QueryFunction;
+    typedef std::function<KAsync::Job<qint64>(qint64 oldRevision, qint64 newRevision)> QueryFunction;
 
     QueryRunner(const Akonadi2::Query &query) : mLatestRevision(0) {};
     /**
      * Starts query
      */
-    Async::Job<void> run(qint64 newRevision = 0)
+    KAsync::Job<void> run(qint64 newRevision = 0)
     {
         //TODO: JOBAPI: that last empty .then should not be necessary
         return queryFunction(mLatestRevision, newRevision).then<void, qint64>([this](qint64 revision) {
@@ -120,7 +121,7 @@ public:
         return Akonadi2::ApplicationDomain::getTypeName<DomainType>();
     }
 
-    Async::Job<void> create(const Akonadi2::ApplicationDomain::Event &domainObject) Q_DECL_OVERRIDE
+    KAsync::Job<void> create(const Akonadi2::ApplicationDomain::Event &domainObject) Q_DECL_OVERRIDE
     {
         if (!mDomainTypeAdaptorFactory) {
             Warning() << "No domain type adaptor factory available";
@@ -130,25 +131,25 @@ public:
         return sendCreateCommand(bufferTypeForDomainType(), QByteArray::fromRawData(reinterpret_cast<const char*>(entityFbb.GetBufferPointer()), entityFbb.GetSize()));
     }
 
-    Async::Job<void> modify(const Akonadi2::ApplicationDomain::Event &domainObject) Q_DECL_OVERRIDE
+    KAsync::Job<void> modify(const Akonadi2::ApplicationDomain::Event &domainObject) Q_DECL_OVERRIDE
     {
         //TODO
-        return Async::null<void>();
+        return KAsync::null<void>();
     }
 
-    Async::Job<void> remove(const Akonadi2::ApplicationDomain::Event &domainObject) Q_DECL_OVERRIDE
+    KAsync::Job<void> remove(const Akonadi2::ApplicationDomain::Event &domainObject) Q_DECL_OVERRIDE
     {
         //TODO
-        return Async::null<void>();
+        return KAsync::null<void>();
     }
 
     //TODO JOBAPI return job from sync continuation to execute it as subjob?
-    Async::Job<void> load(const Akonadi2::Query &query, const QSharedPointer<Akonadi2::ResultProvider<typename DomainType::Ptr> > &resultProvider) Q_DECL_OVERRIDE
+    KAsync::Job<void> load(const Akonadi2::Query &query, const QSharedPointer<Akonadi2::ResultProvider<typename DomainType::Ptr> > &resultProvider) Q_DECL_OVERRIDE
     {
         auto runner = QSharedPointer<QueryRunner>::create(query);
         QWeakPointer<Akonadi2::ResultProvider<typename DomainType::Ptr> > weakResultProvider = resultProvider;
-        runner->setQuery([this, weakResultProvider, query] (qint64 oldRevision, qint64 newRevision) -> Async::Job<qint64> {
-            return Async::start<qint64>([this, weakResultProvider, query, oldRevision, newRevision](Async::Future<qint64> &future) {
+        runner->setQuery([this, weakResultProvider, query] (qint64 oldRevision, qint64 newRevision) -> KAsync::Job<qint64> {
+            return KAsync::start<qint64>([this, weakResultProvider, query, oldRevision, newRevision](KAsync::Future<qint64> &future) {
                 auto resultProvider = weakResultProvider.toStrongRef();
                 if (!resultProvider) {
                     Warning() << "Tried executing query after result provider is already gone";
@@ -175,7 +176,7 @@ public:
         }
 
         //We have to capture the runner to keep it alive
-        return synchronizeResource(query.syncOnDemand, query.processAll).template then<void>([runner](Async::Future<void> &future) {
+        return synchronizeResource(query.syncOnDemand, query.processAll).template then<void>([runner](KAsync::Future<void> &future) {
             runner->run().then<void>([&future]() {
                 future.setFinished();
             }).exec();
@@ -183,7 +184,7 @@ public:
     }
 
 protected:
-    Async::Job<void> sendCreateCommand(const QByteArray &resourceBufferType, const QByteArray &buffer)
+    KAsync::Job<void> sendCreateCommand(const QByteArray &resourceBufferType, const QByteArray &buffer)
     {
         flatbuffers::FlatBufferBuilder fbb;
         //This is the resource buffer type and not the domain type
@@ -195,7 +196,7 @@ protected:
         return mResourceAccess->sendCommand(Akonadi2::Commands::CreateEntityCommand, fbb);
     }
 
-    Async::Job<void> synchronizeResource(bool sync, bool processAll)
+    KAsync::Job<void> synchronizeResource(bool sync, bool processAll)
     {
         //TODO check if a sync is necessary
         //TODO Only sync what was requested
@@ -203,17 +204,17 @@ protected:
         //TODO the synchronization should normally not be necessary: We just return what is already available.
 
         if (sync || processAll) {
-            return Async::start<void>([=](Async::Future<void> &future) {
+            return KAsync::start<void>([=](KAsync::Future<void> &future) {
                 mResourceAccess->open();
                 mResourceAccess->synchronizeResource(sync, processAll).then<void>([&future]() {
                     future.setFinished();
                 }).exec();
             });
         }
-        return Async::null<void>();
+        return KAsync::null<void>();
     }
 
-    virtual Async::Job<qint64> load(const Akonadi2::Query &query, const QSharedPointer<Akonadi2::ResultProvider<Akonadi2::ApplicationDomain::Event::Ptr> > &resultProvider, qint64 oldRevision, qint64 newRevision) { return Async::null<qint64>(); };
+    virtual KAsync::Job<qint64> load(const Akonadi2::Query &query, const QSharedPointer<Akonadi2::ResultProvider<Akonadi2::ApplicationDomain::Event::Ptr> > &resultProvider, qint64 oldRevision, qint64 newRevision) { return KAsync::null<qint64>(); };
 
 protected:
     //TODO use one resource access instance per application => make static
diff --git a/common/genericresource.cpp b/common/genericresource.cpp
index ea6413b..2394b80 100644
--- a/common/genericresource.cpp
+++ b/common/genericresource.cpp
@@ -61,33 +61,33 @@ private slots:
         }).exec();
     }
 
-    Async::Job<void> processQueuedCommand(const Akonadi2::QueuedCommand *queuedCommand)
+    KAsync::Job<void> processQueuedCommand(const Akonadi2::QueuedCommand *queuedCommand)
     {
         Log() << "Processing command: " << Akonadi2::Commands::name(queuedCommand->commandId());
         //Throw command into appropriate pipeline
         switch (queuedCommand->commandId()) {
             case Akonadi2::Commands::DeleteEntityCommand:
                 //mPipeline->removedEntity
-                return Async::null<void>();
+                return KAsync::null<void>();
             case Akonadi2::Commands::ModifyEntityCommand:
                 //mPipeline->modifiedEntity
-                return Async::null<void>();
+                return KAsync::null<void>();
             case Akonadi2::Commands::CreateEntityCommand:
                 return mPipeline->newEntity(queuedCommand->command()->Data(), queuedCommand->command()->size());
             default:
-                return Async::error<void>(-1, "Unhandled command");
+                return KAsync::error<void>(-1, "Unhandled command");
         }
-        return Async::null<void>();
+        return KAsync::null<void>();
     }
 
     //Process all messages of this queue
-    Async::Job<void> processQueue(MessageQueue *queue)
+    KAsync::Job<void> processQueue(MessageQueue *queue)
     {
         //TODO use something like:
-        //Async::foreach("pass iterator here").each("process value here").join();
-        //Async::foreach("pass iterator here").parallel("process value here").join();
-        return Async::dowhile(
-            [this, queue](Async::Future<bool> &future) {
+        //KAsync::foreach("pass iterator here").each("process value here").join();
+        //KAsync::foreach("pass iterator here").parallel("process value here").join();
+        return KAsync::dowhile(
+            [this, queue](KAsync::Future<bool> &future) {
                 if (queue->isEmpty()) {
                     future.setValue(false);
                     future.setFinished();
@@ -133,13 +133,13 @@ private slots:
         );
     }
 
-    Async::Job<void> processPipeline()
+    KAsync::Job<void> processPipeline()
     {
         //Go through all message queues
         auto it = QSharedPointer<QListIterator<MessageQueue*> >::create(mCommandQueues);
-        return Async::dowhile(
+        return KAsync::dowhile(
             [it]() { return it->hasNext(); },
-            [it, this](Async::Future<void> &future) {
+            [it, this](KAsync::Future<void> &future) {
                 auto queue = it->next();
                 processQueue(queue).then<void>([&future]() {
                     Trace() << "Queue processed";
@@ -206,12 +206,12 @@ void GenericResource::processCommand(int commandId, const QByteArray &data, uint
     enqueueCommand(mUserQueue, commandId, data);
 }
 
-Async::Job<void> GenericResource::processAllMessages()
+KAsync::Job<void> GenericResource::processAllMessages()
 {
     //We have to wait for all items to be processed to ensure the synced items are available when a query gets executed.
     //TODO: report errors while processing sync?
     //TODO JOBAPI: A helper that waits for n events and then continues?
-    return Async::start<void>([this](Async::Future<void> &f) {
+    return KAsync::start<void>([this](KAsync::Future<void> &f) {
         if (mSynchronizerQueue.isEmpty()) {
             f.setFinished();
         } else {
@@ -219,7 +219,7 @@ Async::Job<void> GenericResource::processAllMessages()
                 f.setFinished();
             });
         }
-    }).then<void>([this](Async::Future<void> &f) {
+    }).then<void>([this](KAsync::Future<void> &f) {
         if (mUserQueue.isEmpty()) {
             f.setFinished();
         } else {
diff --git a/common/genericresource.h b/common/genericresource.h
index 36fa567..ac28575 100644
--- a/common/genericresource.h
+++ b/common/genericresource.h
@@ -38,8 +38,8 @@ public:
     virtual ~GenericResource();
 
     virtual void processCommand(int commandId, const QByteArray &data, uint size, Pipeline *pipeline) Q_DECL_OVERRIDE;
-    virtual Async::Job<void> synchronizeWithSource(Pipeline *pipeline) Q_DECL_OVERRIDE = 0;
-    virtual Async::Job<void> processAllMessages() Q_DECL_OVERRIDE;
+    virtual KAsync::Job<void> synchronizeWithSource(Pipeline *pipeline) Q_DECL_OVERRIDE = 0;
+    virtual KAsync::Job<void> processAllMessages() Q_DECL_OVERRIDE;
 
     virtual void configurePipeline(Pipeline *pipeline) Q_DECL_OVERRIDE;
     int error() const;
diff --git a/common/pipeline.cpp b/common/pipeline.cpp
index e2f23ed..21cf1c5 100644
--- a/common/pipeline.cpp
+++ b/common/pipeline.cpp
@@ -29,7 +29,6 @@
 #include "metadata_generated.h"
 #include "createentity_generated.h"
 #include "entitybuffer.h"
-#include "async/src/async.h"
 #include "log.h"
 
 namespace Akonadi2
@@ -94,7 +93,7 @@ void Pipeline::null()
     // state.step();
 }
 
-Async::Job<void> Pipeline::newEntity(void const *command, size_t size)
+KAsync::Job<void> Pipeline::newEntity(void const *command, size_t size)
 {
     Log() << "Pipeline: New Entity";
 
@@ -107,7 +106,7 @@ Async::Job<void> Pipeline::newEntity(void const *command, size_t size)
         flatbuffers::Verifier verifyer(reinterpret_cast<const uint8_t *>(command), size);
         if (!Akonadi2::Commands::VerifyCreateEntityBuffer(verifyer)) {
             qWarning() << "invalid buffer, not a create entity buffer";
-            return Async::error<void>();
+            return KAsync::error<void>();
         }
     }
     auto createEntity = Akonadi2::Commands::GetCreateEntity(command);
@@ -118,7 +117,7 @@ Async::Job<void> Pipeline::newEntity(void const *command, size_t size)
         flatbuffers::Verifier verifyer(reinterpret_cast<const uint8_t *>(createEntity->delta()->Data()), createEntity->delta()->size());
         if (!Akonadi2::VerifyEntityBuffer(verifyer)) {
             qWarning() << "invalid buffer, not an entity buffer";
-            return Async::error<void>();
+            return KAsync::error<void>();
         }
     }
     auto entity = Akonadi2::GetEntity(createEntity->delta()->Data());
@@ -139,7 +138,7 @@ Async::Job<void> Pipeline::newEntity(void const *command, size_t size)
     storage().setMaxRevision(newRevision);
     Log() << "Pipeline: wrote entity: "<< newRevision;
 
-    return Async::start<void>([this, key, entityType](Async::Future<void> &future) {
+    return KAsync::start<void>([this, key, entityType](KAsync::Future<void> &future) {
         PipelineState state(this, NewPipeline, key, d->newPipeline[entityType], [&future]() {
             future.setFinished();
         });
diff --git a/common/pipeline.h b/common/pipeline.h
index a574d27..b695bde 100644
--- a/common/pipeline.h
+++ b/common/pipeline.h
@@ -27,7 +27,8 @@
 
 #include <akonadi2common_export.h>
 #include <storage.h>
-#include "async/src/async.h"
+
+#include <Async/Async>
 
 #include "entity_generated.h"
 
@@ -53,7 +54,7 @@ public:
 
     void null();
 
-    Async::Job<void> newEntity(void const *command, size_t size);
+    KAsync::Job<void> newEntity(void const *command, size_t size);
     void modifiedEntity(const QString &entityType, const QByteArray &key, void *data, size_t size);
     void deletedEntity(const QString &entityType, const QByteArray &key);
 
diff --git a/common/resource.cpp b/common/resource.cpp
index e158a40..bd69afd 100644
--- a/common/resource.cpp
+++ b/common/resource.cpp
@@ -53,16 +53,16 @@ void Resource::processCommand(int commandId, const QByteArray &data, uint size,
     pipeline->null();
 }
 
-Async::Job<void> Resource::synchronizeWithSource(Pipeline *pipeline)
+KAsync::Job<void> Resource::synchronizeWithSource(Pipeline *pipeline)
 {
-    return Async::start<void>([pipeline](Async::Future<void> &f) {
+    return KAsync::start<void>([pipeline](KAsync::Future<void> &f) {
         pipeline->null();
     });
 }
 
-Async::Job<void> Resource::processAllMessages()
+KAsync::Job<void> Resource::processAllMessages()
 {
-    return Async::null<void>();
+    return KAsync::null<void>();
 }
 
 class ResourceFactory::Private
diff --git a/common/resource.h b/common/resource.h
index 18a6827..ea1e9d8 100644
--- a/common/resource.h
+++ b/common/resource.h
@@ -21,7 +21,8 @@
 #include <akonadi2common_export.h>
 #include <clientapi.h>
 #include <pipeline.h>
-#include <async/src/async.h>
+
+#include <Async/Async>
 
 namespace Akonadi2
 {
@@ -36,8 +37,8 @@ public:
     virtual ~Resource();
 
     virtual void processCommand(int commandId, const QByteArray &data, uint size, Pipeline *pipeline);
-    virtual Async::Job<void> synchronizeWithSource(Pipeline *pipeline);
-    virtual Async::Job<void> processAllMessages();
+    virtual KAsync::Job<void> synchronizeWithSource(Pipeline *pipeline);
+    virtual KAsync::Job<void> processAllMessages();
 
     virtual void configurePipeline(Pipeline *pipeline);
 
diff --git a/common/resourceaccess.cpp b/common/resourceaccess.cpp
index b7d569b..feffcf4 100644
--- a/common/resourceaccess.cpp
+++ b/common/resourceaccess.cpp
@@ -70,8 +70,8 @@ class ResourceAccess::Private
 {
 public:
     Private(const QByteArray &name, ResourceAccess *ra);
-    Async::Job<void> tryToConnect();
-    Async::Job<void> initializeSocket();
+    KAsync::Job<void> tryToConnect();
+    KAsync::Job<void> initializeSocket();
     QByteArray resourceName;
     QSharedPointer<QLocalSocket> socket;
     QByteArray partialMessageBuffer;
@@ -89,10 +89,10 @@ ResourceAccess::Private::Private(const QByteArray &name, ResourceAccess *q)
 }
 
 //Connects to server and returns connected socket on success
-Async::Job<QSharedPointer<QLocalSocket> > ResourceAccess::connectToServer(const QByteArray &identifier)
+KAsync::Job<QSharedPointer<QLocalSocket> > ResourceAccess::connectToServer(const QByteArray &identifier)
 {
     auto s = QSharedPointer<QLocalSocket>::create();
-    return Async::start<QSharedPointer<QLocalSocket> >([identifier, s](Async::Future<QSharedPointer<QLocalSocket> > &future) {
+    return KAsync::start<QSharedPointer<QLocalSocket> >([identifier, s](KAsync::Future<QSharedPointer<QLocalSocket> > &future) {
         s->setServerName(identifier);
         auto context = new QObject;
         QObject::connect(s.data(), &QLocalSocket::connected, context, [&future, &s, context]() {
@@ -109,15 +109,15 @@ Async::Job<QSharedPointer<QLocalSocket> > ResourceAccess::connectToServer(const
     });
 }
 
-Async::Job<void> ResourceAccess::Private::tryToConnect()
+KAsync::Job<void> ResourceAccess::Private::tryToConnect()
 {
-    return Async::dowhile([this]() -> bool {
+    return KAsync::dowhile([this]() -> bool {
         //TODO abort after N retries?
         return !socket;
     },
-    [this](Async::Future<void> &future) {
+    [this](KAsync::Future<void> &future) {
         Trace() << "Loop";
-        Async::wait(50)
+        KAsync::wait(50)
         .then(connectToServer(resourceName))
         .then<void, QSharedPointer<QLocalSocket> >([this, &future](const QSharedPointer<QLocalSocket> &s) {
             Q_ASSERT(s);
@@ -130,9 +130,9 @@ Async::Job<void> ResourceAccess::Private::tryToConnect()
     });
 }
 
-Async::Job<void> ResourceAccess::Private::initializeSocket()
+KAsync::Job<void> ResourceAccess::Private::initializeSocket()
 {
-    return Async::start<void>([this](Async::Future<void> &future) {
+    return KAsync::start<void>([this](KAsync::Future<void> &future) {
         Trace() << "Trying to connect";
         connectToServer(resourceName).then<void, QSharedPointer<QLocalSocket> >([this, &future](const QSharedPointer<QLocalSocket> &s) {
             Trace() << "Connected to resource, without having to start it.";
@@ -189,9 +189,9 @@ void ResourceAccess::registerCallback(uint messageId, const std::function<void(i
     d->resultHandler.insert(messageId, callback);
 }
 
-Async::Job<void> ResourceAccess::sendCommand(int commandId)
+KAsync::Job<void> ResourceAccess::sendCommand(int commandId)
 {
-    return Async::start<void>([this, commandId](Async::Future<void> &f) {
+    return KAsync::start<void>([this, commandId](KAsync::Future<void> &f) {
         auto continuation = [&f](int error, const QString &errorMessage) {
             if (error) {
                 f.setError(error, errorMessage);
@@ -205,11 +205,11 @@ Async::Job<void> ResourceAccess::sendCommand(int commandId)
     });
 }
 
-Async::Job<void>  ResourceAccess::sendCommand(int commandId, flatbuffers::FlatBufferBuilder &fbb)
+KAsync::Job<void>  ResourceAccess::sendCommand(int commandId, flatbuffers::FlatBufferBuilder &fbb)
 {
     //The flatbuffer is transient, but we want to store it until the job is executed
     QByteArray buffer(reinterpret_cast<const char*>(fbb.GetBufferPointer()), fbb.GetSize());
-    return Async::start<void>([commandId, buffer, this](Async::Future<void> &f) {
+    return KAsync::start<void>([commandId, buffer, this](KAsync::Future<void> &f) {
         auto callback = [&f](int error, const QString &errorMessage) {
             if (error) {
                 f.setError(error, errorMessage);
@@ -225,7 +225,7 @@ Async::Job<void>  ResourceAccess::sendCommand(int commandId, flatbuffers::FlatBu
     });
 }
 
-Async::Job<void> ResourceAccess::synchronizeResource(bool sourceSync, bool localSync)
+KAsync::Job<void> ResourceAccess::synchronizeResource(bool sourceSync, bool localSync)
 {
     auto command = Akonadi2::CreateSynchronize(d->fbb, sourceSync, localSync);
     Akonadi2::FinishSynchronizeBuffer(d->fbb, command);
diff --git a/common/resourceaccess.h b/common/resourceaccess.h
index c16a9d2..b779db9 100644
--- a/common/resourceaccess.h
+++ b/common/resourceaccess.h
@@ -24,8 +24,9 @@
 #include <QObject>
 #include <QTimer>
 
+#include <Async/Async>
+
 #include <flatbuffers/flatbuffers.h>
-#include <async/src/async.h>
 
 namespace Akonadi2
 {
@@ -43,13 +44,13 @@ public:
     QByteArray resourceName() const;
     bool isReady() const;
 
-    Async::Job<void> sendCommand(int commandId);
-    Async::Job<void> sendCommand(int commandId, flatbuffers::FlatBufferBuilder &fbb);
-    Async::Job<void> synchronizeResource(bool remoteSync, bool localSync);
+    KAsync::Job<void> sendCommand(int commandId);
+    KAsync::Job<void> sendCommand(int commandId, flatbuffers::FlatBufferBuilder &fbb);
+    KAsync::Job<void> synchronizeResource(bool remoteSync, bool localSync);
     /**
      * Tries to connect to server, and returns a connected socket on success.
      */
-    static Async::Job<QSharedPointer<QLocalSocket> > connectToServer(const QByteArray &identifier);
+    static KAsync::Job<QSharedPointer<QLocalSocket> > connectToServer(const QByteArray &identifier);
 
 public Q_SLOTS:
     void open();