Update ChangeLog for v0.3.3

Add note on thread-safety of Variant and its const methods
Little fixes in tutorial code samples
2018-12-29 01:02:36 +01:00 · 2018-12-29 00:59:31 +01:00 · 2018-12-24 15:43:01 +01:00 · 2018-12-24 15:30:55 +01:00 · 2018-09-26 09:28:10 +02:00 · 2018-08-24 16:39:31 +02:00
47 changed files with 1316 additions and 469 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -0,0 +1,145 @@
+#-------------------------------
+# PROJECT INFORMATION
+#-------------------------------
+
+cmake_minimum_required(VERSION 3.8)
+
+project(sdbus-c++ VERSION 0.3.2 LANGUAGES C CXX)
+
+include(GNUInstallDirs) # Installation directories for `install` command and pkgconfig file
+
+#-------------------------------
+# PERFORMING CHECKS
+#-------------------------------
+
+find_package(PkgConfig REQUIRED)
+pkg_check_modules(SYSTEMD REQUIRED libsystemd>=236)
+
+#-------------------------------
+# SOURCE FILES CONFIGURATION
+#-------------------------------
+
+set(SDBUSCPP_SOURCE_DIR ${CMAKE_SOURCE_DIR}/src)
+set(SDBUSCPP_INCLUDE_SUBDIR sdbus-c++)
+set(SDBUSCPP_INCLUDE_DIR ${CMAKE_SOURCE_DIR}/include/${SDBUSCPP_INCLUDE_SUBDIR})
+
+set(SDBUSCPP_CPP_SRCS
+    ${SDBUSCPP_SOURCE_DIR}/Connection.cpp
+    ${SDBUSCPP_SOURCE_DIR}/ConvenienceClasses.cpp
+    ${SDBUSCPP_SOURCE_DIR}/Error.cpp
+    ${SDBUSCPP_SOURCE_DIR}/Message.cpp
+    ${SDBUSCPP_SOURCE_DIR}/MethodResult.cpp
+    ${SDBUSCPP_SOURCE_DIR}/Object.cpp
+    ${SDBUSCPP_SOURCE_DIR}/ObjectProxy.cpp
+    ${SDBUSCPP_SOURCE_DIR}/Types.cpp
+    ${SDBUSCPP_SOURCE_DIR}/VTableUtils.c)
+
+set(SDBUSCPP_HDR_SRCS
+    ${SDBUSCPP_SOURCE_DIR}/Connection.h
+    ${SDBUSCPP_SOURCE_DIR}/IConnection.h
+    ${SDBUSCPP_SOURCE_DIR}/MessageUtils.h
+    ${SDBUSCPP_SOURCE_DIR}/Object.h
+    ${SDBUSCPP_SOURCE_DIR}/ObjectProxy.h
+    ${SDBUSCPP_SOURCE_DIR}/ScopeGuard.h
+    ${SDBUSCPP_SOURCE_DIR}/VTableUtils.h)
+
+set(SDBUSCPP_PUBLIC_HDRS
+    ${SDBUSCPP_INCLUDE_DIR}/ConvenienceClasses.h
+    ${SDBUSCPP_INCLUDE_DIR}/ConvenienceClasses.inl
+    ${SDBUSCPP_INCLUDE_DIR}/Error.h
+    ${SDBUSCPP_INCLUDE_DIR}/IConnection.h
+    ${SDBUSCPP_INCLUDE_DIR}/Interfaces.h
+    ${SDBUSCPP_INCLUDE_DIR}/Introspection.h
+    ${SDBUSCPP_INCLUDE_DIR}/IObject.h
+    ${SDBUSCPP_INCLUDE_DIR}/IObjectProxy.h
+    ${SDBUSCPP_INCLUDE_DIR}/Message.h
+    ${SDBUSCPP_INCLUDE_DIR}/MethodResult.h
+    ${SDBUSCPP_INCLUDE_DIR}/sdbus-c++.h
+    ${SDBUSCPP_INCLUDE_DIR}/Types.h
+    ${SDBUSCPP_INCLUDE_DIR}/TypeTraits.h)
+
+set(SDBUSCPP_SRCS ${SDBUSCPP_CPP_SRCS} ${SDBUSCPP_HDR_SRCS} ${SDBUSCPP_PUBLIC_HDRS})
+
+#-------------------------------
+# GENERAL COMPILER CONFIGURATION
+#-------------------------------
+
+set(CMAKE_CXX_STANDARD 17)
+add_compile_options(-W -Wextra -Wall -Werror -pedantic)
+include_directories("${CMAKE_SOURCE_DIR}/include")
+include_directories("${CMAKE_SOURCE_DIR}/src")
+
+#----------------------------------
+# LIBRARY BUILD INFORMATION
+#----------------------------------
+
+set(SDBUSCPP_VERSION_MAJOR "${PROJECT_VERSION_MAJOR}")
+set(SDBUSCPP_VERSION "${PROJECT_VERSION}")
+
+# We are building in two steps: first objects, then link them into a library,
+# and that's because we need object files since unit tests link against them.
+add_library(sdbuscppobjects OBJECT ${SDBUSCPP_SRCS})
+target_include_directories(sdbuscppobjects PUBLIC ${SYSTEMD_INCLUDE_DIRS})
+target_compile_definitions(sdbuscppobjects PRIVATE BUILDLIB=1)
+set_target_properties(sdbuscppobjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
+
+add_library(sdbus-c++ SHARED $<TARGET_OBJECTS:sdbuscppobjects>)
+set_target_properties(sdbus-c++
+    PROPERTIES
+    PUBLIC_HEADER "${SDBUSCPP_PUBLIC_HDRS}"
+    VERSION "${SDBUSCPP_VERSION}"
+    SOVERSION "${SDBUSCPP_VERSION_MAJOR}"
+    OUTPUT_NAME "sdbus-c++")
+target_link_libraries(sdbus-c++ ${SYSTEMD_LIBRARIES})
+
+#----------------------------------
+# INSTALLATION
+#----------------------------------
+
+install(TARGETS sdbus-c++
+        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT libraries
+        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT libraries
+        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT static_libraries
+        PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${SDBUSCPP_INCLUDE_SUBDIR} COMPONENT dev)
+
+#----------------------------------
+# TESTS
+#----------------------------------
+
+option(ENABLE_TESTS "Build and install tests (default ON)" ON)
+
+if(ENABLE_TESTS)
+    enable_testing()
+    add_subdirectory("${CMAKE_SOURCE_DIR}/test")
+endif()
+
+#----------------------------------
+# UTILS
+#----------------------------------
+
+option(BUILD_CODE_GEN "Build and install interface stub code generator (default OFF)" OFF)
+
+if(BUILD_CODE_GEN)
+    add_subdirectory("${CMAKE_SOURCE_DIR}/stub-generator")
+endif()
+
+#----------------------------------
+# DOCUMENTATION
+#----------------------------------
+
+# TODO Build doxygen
+
+#----------------------------------
+# CMAKE CONFIG & PACKAGE CONFIG
+#----------------------------------
+
+set(SDBUSCPP_CONFIG_INSTALL_DIR ${CMAKE_INSTALL_LIBDIR}/cmake/sdbus-c++)
+
+configure_file(sdbus-c++-config.cmake.in sdbus-c++-config.cmake @ONLY)
+install(FILES ${CMAKE_BINARY_DIR}/sdbus-c++-config.cmake DESTINATION ${SDBUSCPP_CONFIG_INSTALL_DIR} COMPONENT dev)
+
+configure_file(sdbus-c++-config-version.cmake.in sdbus-c++-config-version.cmake @ONLY)
+install(FILES ${CMAKE_BINARY_DIR}/sdbus-c++-config-version.cmake DESTINATION ${SDBUSCPP_CONFIG_INSTALL_DIR} COMPONENT dev)
+
+configure_file(sdbus-c++.pc.in sdbus-c++.pc @ONLY)
+install(FILES ${CMAKE_BINARY_DIR}/sdbus-c++.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig COMPONENT dev)
--- a/22
+++ b/22
@ -12,3 +12,25 @@ v0.2.4
 v0.2.5
 - Real fix for issue with sdbus::Struct inherited constructors
 - Little code refactorings and improvements
+
+v0.2.6
+- Fixed memory leak in Message copy operations
+
+v0.3.0
+- Introduced support for asynchronous server-side methods
+- Refactored the concept of Message into distinctive concrete message types
+- As this release comes with breaking API changes:
+    * if you're using lower-level API, please rename 'Message' to whatever concrete message type (MethodCall, MethodReply, Signal) is needed there,
+    * if you're using higher-level API, please re-compile and re-link your application against sdbus-c++,
+    * if you're using generated stub headers, please re-compile and re-link your application against sdbus-c++.
+
+v0.3.1
+- Fixed hogging the CPU by server with async methods (issue #15)
+
+v0.3.2
+- Switched from autotools to CMake build system
+
+v0.3.3
+- Minor fixes in tutorial examples
+- Add comment on threading traits of Variant and its const methods
+- Fix broken invariant of const Variant::peekValueType() method
--- a/4
+++ b/4
@ -1,5 +1,7 @@
 Building:
-  $ ./autogen.sh ${CONFIGURE_FLAGS}
+  $ mkdir build
+  $ cd build
+  $ cmake .. ${CONFIGURE_FLAGS_IF_NECESSARY}
  $ make

 Installing:
--- a/Makefile.am
+++ b/Makefile.am
@ -1,22 +0,0 @@
-EXTRA_DIST = autogen.sh
-SUBDIRS = include src test 
-
-DISTCHECK_CONFIGURE_FLAGS=
-
-pkgconfigdir = $(libdir)/pkgconfig
-pkgconfig_DATA = sdbus-c++.pc
-
-CLEANFILES = *~ *.lo *.la
-
-MOSTLYCLEANFILES = *.o
-
-DISTCLEANFILES = \
-	*libtool* \
-	aclocal.m4 \
-	compile config.* configure \
-	depcomp install-sh \
-	ltmain.sh \
-	Makefile Makefile.in \
-	missing \
-	stamp-h1 \
-	sdbus-c++.pc
--- a/README.md
+++ b/README.md
@ -6,20 +6,26 @@ sdbus-c++ is a C++ API library for D-Bus IPC, based on sd-bus implementation.
 Building and installing the library
 -----------------------------------

+The library is built using CMake:
+
 ```bash
-$ ./autogen.sh ${CONFIGURE_FLAGS}
+$ mkdir build
+$ cd build
+$ cmake .. ${CONFIGURE_FLAGS_IF_NECESSARY}
 $ make
 $ sudo make install
 ```

-Use `--disable-tests` flag when configuring to disable building unit and integration tests for the library.
+By default, the library builds its unit and integration tests. That incorporates downloading and building static libraries of Google Test. Use `-DENABLE_TESTS=OFF` configure flag if you want to disable building the tests.
+
+By default, the library doesn't build the code generator for adaptor and proxy interfaces. Use `-DBUILD_CODE_GEN=ON` flag to also build the code generator.

 Dependencies
 ------------

 * `C++17` - the library uses C++17 `std::uncaught_exceptions()` feature. When building sdbus-c++ manually, make sure you use a compiler that supports that feature.
 * `libsystemd` - systemd library containing sd-bus implementation. Systemd v236 at least is needed for sdbus-c++ to compile.
-* `googletest` - google unit testing framework, only necessary when building tests
+* `googletest` - google unit testing framework, only necessary when building tests, will be downloaded and built automatically

 Licensing
 ---------
@ -41,4 +47,4 @@ Contributions that increase the library quality, functionality, or fix issues ar
 Contact
 -------

-stanislav.angelovic[at]kistler.com
+https://github.com/Kistler-Group/sdbus-cpp
--- a/autogen.sh
+++ b/autogen.sh
@ -1,10 +0,0 @@
-#! /bin/sh
-[ -e config.cache ] && rm -f config.cache
-
-libtoolize --automake
-aclocal ${OECORE_ACLOCAL_OPTS}
-autoconf
-autoheader
-automake -a
-./configure $@
-exit
--- a/configure.ac
+++ b/configure.ac
@ -1,62 +0,0 @@
-AC_PREREQ(2.61)
-
-# package version number (not shared library version)
-# odd micro numbers indicate in-progress development
-# even micro numbers indicate released versions
-m4_define(sdbus_cpp_version_major, 0)
-m4_define(sdbus_cpp_version_minor, 2)
-m4_define(sdbus_cpp_version_micro, 5)
-
-m4_define([sdbus_cpp_version],
-          [sdbus_cpp_version_major.sdbus_cpp_version_minor.sdbus_cpp_version_micro])
-m4_define([sdbus_cpp_api_version],
-          [sdbus_cpp_version_major.sdbus_cpp_version_minor])
-
-AC_INIT(libsdbus-c++, sdbus_cpp_version)
-AM_INIT_AUTOMAKE
-AC_CONFIG_HEADERS(config.h)
-
-# Checks for programs.
-AC_PROG_LIBTOOL
-AC_PROG_CXX
-AC_PROG_CC
-AC_PROG_INSTALL
-
-# enable pkg-config
-PKG_PROG_PKG_CONFIG
-
-PKG_CHECK_MODULES(SYSTEMD, [libsystemd >= 0.10.1],,
-    AC_MSG_ERROR([You need the libsystemd library (version 0.10.1 or better)]
-    [https://www.freedesktop.org/wiki/Software/systemd/])
-)
-
-# Checks for library functions.
-#AC_CHECK_FUNCS([memset])
-
-AC_SUBST(libsdbus_cpp_CFLAGS)
-AC_SUBST(libsdbus_cpp_LIBS)
-
-AC_ARG_ENABLE([tests],
-  [AS_HELP_STRING([--enable-tests],
-    [build and install tests @<:@default=yes@:>@])],
-  [],
-  [enable_tests=yes])
-AM_CONDITIONAL([ENABLE_TESTS], [test x$enable_tests = xyes])
-
-#icondir=${datadir}/icons/hicolor/32x32/apps
-#AC_SUBST(icondir)
-
-AC_OUTPUT([
-Makefile
-include/Makefile
-src/Makefile
-test/Makefile
-sdbus-c++.pc
-])
-
-echo ""
-echo "   sdbus-cpp $VERSION"
-echo "   ====================="
-echo ""
-echo "   To build the project, run \"make\""
-echo ""
--- a/doc/using-sdbus-c++.md
+++ b/doc/using-sdbus-c++.md
@ -12,8 +12,9 @@ Using sdbus-c++ library
 7. [Implementing the Concatenator example using basic sdbus-c++ API layer](#implementing-the-concatenator-example-using-basic-sdbus-c-api-layer)
 8. [Implementing the Concatenator example using convenience sdbus-c++ API layer](#implementing-the-concatenator-example-using-convenience-sdbus-c-api-layer)
 9. [Implementing the Concatenator example using sdbus-c++-generated stubs](#implementing-the-concatenator-example-using-sdbus-c-generated-stubs)
-10. [Using D-Bus properties](#using-d-bus-properties)
-11. [Conclusion](#conclusion)
+10. [Asynchronous server-side methods](#asynchronous-server-side-methods)
+11. [Using D-Bus properties](#using-d-bus-properties)
+12. [Conclusion](#conclusion)

 Introduction
 ------------
@ -92,10 +93,10 @@ The following diagram illustrates the major entities in sdbus-c++.
 * invoking remote methods of the corresponding object,
 * registering handlers for signals.

-`Message` class represents a message, which is the fundamental DBus concept. The message can be
-* a method call (with serialized parameters),
-* a method reply (with serialized return values),
-* or a signal (with serialized parameters).
+`Message` class represents a message, which is the fundamental DBus concept. There are three distinctive types of message that derive from the `Message` class:
+* `MethodCall` (with serialized parameters),
+* `MethodReply` (with serialized return values),
+* or a `Signal` (with serialized parameters).

 Multiple layers of sdbus-c++ API
 -------------------------------
@ -138,15 +139,15 @@ Overloaded versions of C++ insertion/extraction operators are used for serializa
 // to emit signals.
 sdbus::IObject* g_concatenator{};

-void concatenate(sdbus::Message& msg, sdbus::Message& reply)
+void concatenate(sdbus::MethodCall& call, sdbus::MethodReply& reply)
 {
    // Deserialize the collection of numbers from the message
    std::vector<int> numbers;
-    msg >> numbers;
+    call >> numbers;
    
    // Deserialize separator from the message
    std::string separator;
-    msg >> separator;
+    call >> separator;
    
    // Return error if there are no numbers in the collection
    if (numbers.empty())
@ -163,9 +164,9 @@ void concatenate(sdbus::Message& msg, sdbus::Message& reply)
    
    // Emit 'concatenated' signal
    const char* interfaceName = "org.sdbuscpp.Concatenator";
-    auto signalMsg = g_concatenator->createSignal(interfaceName, "concatenated");
-    signalMsg << result;
-    g_concatenator->emitSignal(signalMsg);
+    auto signal = g_concatenator->createSignal(interfaceName, "concatenated");
+    signal << result;
+    g_concatenator->emitSignal(signal);
 }

 int main(int argc, char *argv[])
@ -200,19 +201,19 @@ int main(int argc, char *argv[])
 #include <iostream>
 #include <unistd.h>

-void onConcatenated(sdbus::Message& signalMsg)
+void onConcatenated(sdbus::Signal& signal)
 {
    std::string concatenatedString;
-    msg >> concatenatedString;
+    signal >> concatenatedString;
    
    std::cout << "Received signal with concatenated string " << concatenatedString << std::endl;
 }

 int main(int argc, char *argv[])
 {
-    // Create proxy object for the concatenator object on the server side. Since we don't pass
-    // the D-Bus connection object to the proxy constructor, the proxy will internally create
-    // its own connection to the system bus.
+    // Create proxy object for the concatenator object on the server side. Since here
+    // we are creating the proxy instance without passing connection to it, the proxy
+    // will create its own connection automatically, and it will be system bus connection.
    const char* destinationName = "org.sdbuscpp.concatenator";
    const char* objectPath = "/org/sdbuscpp/concatenator";
    auto concatenatorProxy = sdbus::createObjectProxy(destinationName, objectPath);
@ -257,9 +258,9 @@ int main(int argc, char *argv[])
 }
 ```

-The object proxy is created without explicitly providing a D-Bus connection as an argument in its factory function. In that case, the proxy
-will create its own connection to the *system* bus and listen to signals on it in a separate thread. That means the `onConcatenated` method is invoked always
-in the context of a thread different from the main thread.
+The object proxy can be created by either explicitly passing the connection object to it, or without the connection object. In the former case, we have the freedom of creating our own connection (to either system bus or to session bus) and then we can just move that connection object as the first argument of the proxy factory. The latter option is more convenient (no messing with connection for proxy), the proxy will create and manage its own connection, but the limitation is that it will be the connection to the **system** bus only.
+
+If there are callbacks for signals, proxy will start listening to the signals upon the connection in a separate thread. That means the `onConcatenated` method is invoked always in the context of a thread different from the main thread.

 Implementing the Concatenator example using convenience sdbus-c++ API layer
 ---------------------------------------------------------------------------
@ -356,7 +357,7 @@ int main(int argc, char *argv[])
    
    // Let's subscribe for the 'concatenated' signals
    const char* interfaceName = "org.sdbuscpp.Concatenator";
-    concatenatorProxy->uponSignal("concatenated").onInterface(interfaceName).call([this](const std::string& str){ onConcatenated(str); });
+    concatenatorProxy->uponSignal("concatenated").onInterface(interfaceName).call([](const std::string& str){ onConcatenated(str); });
    concatenatorProxy->finishRegistration();
    
    std::vector<int> numbers = {1, 2, 3};
@ -629,10 +630,13 @@ protected:
 };
 ```

+In the above example, a proxy is created that creates and maintains its own system bus connection. However, there are `ProxyInterfaces` class template constructor overloads that also take the connection from the user as the first parameter, and pass that connection over to the underlying proxy. The connection instance is used for all D-Bus proxy interfaces listed in the `ProxyInterfaces` template parameter list.
+
 Now let's use this proxy to make remote calls and listen to signals in a real application.

 ```cpp
 #include "ConcatenatorProxy.h"
+#include <unistd.h>

 int main(int argc, char *argv[])
 {
@ -666,6 +670,104 @@ int main(int argc, char *argv[])
 }
 ```

+Asynchronous server-side methods
+--------------------------------
+
+So far in our tutorial, we have only considered simple server methods that are executed in a synchronous way. Sometimes the method call may take longer, however, and we don't want to block (potentially starve) other clients (whose requests may take relative short time). The solution is to execute the D-Bus methods asynchronously. How physically is that done is up to the server design (e.g. thread pool), but sdbus-c++ provides API supporting async methods.
+
+### Lower-level API
+
+Considering the Concatenator example based on lower-level API, if we wanted to write `concatenate` method in an asynchronous way, you only have to adapt method signature and its body (registering the method and all the other stuff stays the same):
+
+```c++
+void concatenate(sdbus::MethodCall& call, sdbus::MethodResult result)
+{
+    // Deserialize the collection of numbers from the message
+    std::vector<int> numbers;
+    call >> numbers;
+    
+    // Deserialize separator from the message
+    std::string separator;
+    call >> separator;
+    
+    // Launch a thread for async execution...
+    std::thread([numbers, separator, result = std::move(result)]()
+    {
+        // Return error if there are no numbers in the collection
+        if (numbers.empty())
+        {
+            // This will send the error reply message back to the client
+            result.returnError("org.sdbuscpp.Concatenator.Error", "No numbers provided");
+            return;
+        }
+        
+        std::string concatenatedStr;
+        for (auto number : numbers)
+        {
+            concatenatedStr += (result.empty() ? std::string() : separator) + std::to_string(number);
+        }
+        
+        // This will send the reply message back to the client
+        result.returnResults(concatenatedStr);
+        
+        // Note: emitting signals from other than D-Bus dispatcher thread is not supported yet...
+        /*
+        // Emit 'concatenated' signal
+        const char* interfaceName = "org.sdbuscpp.Concatenator";
+        auto signal = g_concatenator->createSignal(interfaceName, "concatenated");
+        signal << result;
+        g_concatenator->emitSignal(signal);
+        */
+    }).detach();
+}
+```
+
+Notice these differences as compared to the synchronous version:
+
+* Instead of `MethodReply` message given by reference, there is `MethodResult` as a second parameter of the callback, which will hold method results and can be written to from any thread.
+* You shall pass the result holder (`MethodResult` instance) by moving it to the thread of execution, and eventually write method results (or method error) to it via its `returnResults()` or `returnError()` method, respectively.
+* Unlike in sync methods, reporting errors cannot be done by throwing sdbus::Error, since the execution takes place out of context of the D-Bus dispatcher thread. Instead, just pass the error name and message to the `returnError` method of the result holder.
+
+That's all.
+
+Note: We can use the concept of asynchronous D-Bus methods in both the synchronous and asynchronous way. Whether we return the results directly in the callback in the synchronous way, or we pass the arguments and the result holder to a different thread, and compute and set the results in there, is irrelevant to sdbus-c++. This has the benefit that we can decide at run-time, per each method call, whether we execute it synchronously or (perhaps in case of complex operation) execute it asynchronously to e.g. a thread pool.
+
+### Convenience API
+
+Method callbacks in convenience sdbus-c++ API also need to take the result object as a parameter. The requirements are:
+
+* The result holder is of type `sdbus::Result<Types...>`, where `Types...` is a list of method output argument types.
+* The result object must be a first physical parameter of the callback taken by value.
+* The callback itself is physically a void-returning function.
+
+For example, we would have to change the concatenate callback signature from `std::string concatenate(const std::vector<int32_t>& numbers, const std::string& separator)` to `void concatenate(sdbus::Result<std::string> result, const std::vector<int32_t>& numbers, const std::string& separator)`.
+
+`sdbus::Result` class template has effectively the same API as `sdbus::MethodResult` class from above example (it inherits from MethodResult), so you use it in the very same way to send the results or an error back to the client.
+
+Nothing else has to be changed. The registration of the method callback (`implementedAs`) and all the mechanics around remains completely the same.
+
+### Marking async methods in the IDL
+
+sdbus-c++ stub generator can generate stub code for server-side async methods. We just need to annotate the method with the `annotate` element having the "org.freedesktop.DBus.Method.Async" name, like so:
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+
+<node name="/org/sdbuscpp/concatenator">
+    <interface name="org.sdbuscpp.Concatenator">
+        <method name="concatenate">
+            <annotation name="org.freedesktop.DBus.Method.Async" value="server" />
+            <arg type="ai" name="numbers" direction="in" />
+            <arg type="s" name="separator" direction="in" />
+            <arg type="s" name="concatenatedString" direction="out" />
+        </method>
+        <signal name="concatenated">
+            <arg type="s" name="concatenatedString" />
+        </signal>
+    </interface>
+</node>
+```
+
 Using D-Bus properties
 ----------------------

--- a/include/Makefile.am
+++ b/include/Makefile.am
@ -1,23 +0,0 @@
-
-# Distribution
-# Headers will be installed to $(includedir)/sdbus-c++ directory
-
-HEADER_DIR = sdbus-c++
-libsdbuscppdir = $(includedir)/$(HEADER_DIR)
-libsdbuscpp_HEADERS = \
-	$(HEADER_DIR)/ConvenienceClasses.h \
-	$(HEADER_DIR)/ConvenienceClasses.inl \
-	$(HEADER_DIR)/Error.h \
-	$(HEADER_DIR)/IConnection.h \
-	$(HEADER_DIR)/Interfaces.h \
-	$(HEADER_DIR)/Introspection.h \
-	$(HEADER_DIR)/IObject.h \
-	$(HEADER_DIR)/IObjectProxy.h \
-	$(HEADER_DIR)/Message.h \
-	$(HEADER_DIR)/Types.h \
-	$(HEADER_DIR)/TypeTraits.h \
-	$(HEADER_DIR)/sdbus-c++.h
-
-EXTRA_DIST = ($libsdbuscpp_HEADERS)
-
-DISTCLEANFILES = Makefile Makefile.in
--- a/include/sdbus-c++/ConvenienceClasses.h
+++ b/include/sdbus-c++/ConvenienceClasses.h
@ -27,7 +27,9 @@
 #define SDBUS_CXX_CONVENIENCECLASSES_H_

 #include <sdbus-c++/Message.h>
+#include <sdbus-c++/TypeTraits.h>
 #include <string>
+#include <type_traits>

 // Forward declarations
 namespace sdbus {
@ -43,7 +45,10 @@ namespace sdbus {
    public:
        MethodRegistrator(IObject& object, const std::string& methodName);
        MethodRegistrator& onInterface(const std::string& interfaceName);
-        template <typename _Function> void implementedAs(_Function&& callback);
+        template <typename _Function>
+        std::enable_if_t<!is_async_method_v<_Function>> implementedAs(_Function&& callback);
+        template <typename _Function>
+        std::enable_if_t<is_async_method_v<_Function>> implementedAs(_Function&& callback);

    private:
        IObject& object_;
@ -103,7 +108,7 @@ namespace sdbus {
    private:
        IObject& object_;
        const std::string& signalName_;
-        Message signal_;
+        Signal signal_;
        int exceptions_{}; // Number of active exceptions when SignalEmitter is constructed
    };

@ -122,7 +127,7 @@ namespace sdbus {
    private:
        IObjectProxy& objectProxy_;
        const std::string& methodName_;
-        Message method_;
+        MethodCall method_;
        int exceptions_{}; // Number of active exceptions when MethodInvoker is constructed
        bool methodCalled_{};
    };
--- a/include/sdbus-c++/ConvenienceClasses.inl
+++ b/include/sdbus-c++/ConvenienceClasses.inl
@ -29,6 +29,7 @@
 #include <sdbus-c++/IObject.h>
 #include <sdbus-c++/IObjectProxy.h>
 #include <sdbus-c++/Message.h>
+#include <sdbus-c++/MethodResult.h>
 #include <sdbus-c++/Types.h>
 #include <sdbus-c++/TypeTraits.h>
 #include <sdbus-c++/Error.h>
@ -52,7 +53,7 @@ namespace sdbus {
    }

    template <typename _Function>
-    inline void MethodRegistrator::implementedAs(_Function&& callback)
+    inline std::enable_if_t<!is_async_method_v<_Function>> MethodRegistrator::implementedAs(_Function&& callback)
    {
        SDBUS_THROW_ERROR_IF(interfaceName_.empty(), "DBus interface not specified when registering a DBus method", EINVAL);

@ -60,7 +61,7 @@ namespace sdbus {
                              , methodName_
                              , signature_of_function_input_arguments<_Function>::str()
                              , signature_of_function_output_arguments<_Function>::str()
-                              , [callback = std::forward<_Function>(callback)](Message& msg, Message& reply)
+                              , [callback = std::forward<_Function>(callback)](MethodCall& msg, MethodReply& reply)
        {
            // Create a tuple of callback input arguments' types, which will be used
            // as a storage for the argument values deserialized from the message.
@ -72,7 +73,7 @@ namespace sdbus {
            // Invoke callback with input arguments from the tuple.
            // For callbacks returning a non-void value, `apply' also returns that value.
            // For callbacks returning void, `apply' returns an empty tuple.
-            auto ret = apply(callback, inputArgs); // We don't yet have C++17's std::apply :-(
+            auto ret = sdbus::apply(callback, inputArgs); // We don't yet have C++17's std::apply :-(

            // The return value is stored to the reply message.
            // In case of void functions, ret is an empty tuple and thus nothing is stored.
@ -80,6 +81,29 @@ namespace sdbus {
        });
    }

+    template <typename _Function>
+    inline std::enable_if_t<is_async_method_v<_Function>> MethodRegistrator::implementedAs(_Function&& callback)
+    {
+        SDBUS_THROW_ERROR_IF(interfaceName_.empty(), "DBus interface not specified when registering a DBus method", EINVAL);
+
+        object_.registerMethod( interfaceName_
+                              , methodName_
+                              , signature_of_function_input_arguments<_Function>::str()
+                              , signature_of_function_output_arguments<_Function>::str() //signature_of<last_function_argument_t<_Function>>::str() // because last argument contains output types
+                              , [callback = std::forward<_Function>(callback)](MethodCall& msg, MethodResult result)
+        {
+            // Create a tuple of callback input arguments' types, which will be used
+            // as a storage for the argument values deserialized from the message.
+            tuple_of_function_input_arg_types_t<_Function> inputArgs;
+
+            // Deserialize input arguments from the message into the tuple,
+            // plus store the result object as a last item of the tuple.
+            msg >> inputArgs;
+
+            // Invoke callback with input arguments from the tuple.
+            sdbus::apply(callback, std::move(result), inputArgs); // TODO: Use std::apply when switching to full C++17 support
+        });
+    }

    // Moved into the library to isolate from C++17 dependency
    /*
@ -339,7 +363,7 @@ namespace sdbus {

        objectProxy_.registerSignalHandler( interfaceName_
                                          , signalName_
-                                          , [callback = std::forward<_Function>(callback)](Message& signal)
+                                          , [callback = std::forward<_Function>(callback)](Signal& signal)
        {
            // Create a tuple of callback input arguments' types, which will be used
            // as a storage for the argument values deserialized from the signal message.
@ -349,7 +373,7 @@ namespace sdbus {
            signal >> signalArgs;

            // Invoke callback with input arguments from the tuple.
-            apply(callback, signalArgs); // We don't yet have C++17's std::apply :-(
+            sdbus::apply(callback, signalArgs); // We don't yet have C++17's std::apply :-(
        });
    }

--- a/include/sdbus-c++/IObject.h
+++ b/include/sdbus-c++/IObject.h
@ -34,7 +34,7 @@

 // Forward declarations
 namespace sdbus {
-    class Message;
+    class Signal;
    class IConnection;
 }

@ -70,6 +70,28 @@ namespace sdbus {
                                   , const std::string& outputSignature
                                   , method_callback methodCallback ) = 0;

+        /*!
+        * @brief Registers method that the object will provide on D-Bus
+        *
+        * @param[in] interfaceName Name of an interface that the method will belong to
+        * @param[in] methodName Name of the method
+        * @param[in] inputSignature D-Bus signature of method input parameters
+        * @param[in] outputSignature D-Bus signature of method output parameters
+        * @param[in] asyncMethodCallback Callback that implements the body of the method
+        *
+        * This overload register a method callback that will have a freedom to execute
+        * its body in asynchronous contexts, and send the results from those contexts.
+        * This can help in e.g. long operations, which then don't block the D-Bus processing
+        * loop thread.
+        *
+        * @throws sdbus::Error in case of failure
+        */
+        virtual void registerMethod( const std::string& interfaceName
+                                   , const std::string& methodName
+                                   , const std::string& inputSignature
+                                   , const std::string& outputSignature
+                                   , async_method_callback asyncMethodCallback ) = 0;
+
        /*!
        * @brief Registers signal that the object will emit on D-Bus
        *
@ -138,7 +160,7 @@ namespace sdbus {
        *
        * @throws sdbus::Error in case of failure
        */
-        virtual Message createSignal(const std::string& interfaceName, const std::string& signalName) = 0;
+        virtual Signal createSignal(const std::string& interfaceName, const std::string& signalName) = 0;

        /*!
        * @brief Emits signal on D-Bus
@ -149,7 +171,7 @@ namespace sdbus {
        *
        * @throws sdbus::Error in case of failure
        */
-        virtual void emitSignal(const sdbus::Message& message) = 0;
+        virtual void emitSignal(const sdbus::Signal& message) = 0;

        /*!
        * @brief Registers method that the object will provide on D-Bus
--- a/include/sdbus-c++/IObjectProxy.h
+++ b/include/sdbus-c++/IObjectProxy.h
@ -33,7 +33,8 @@

 // Forward declarations
 namespace sdbus {
-    class Message;
+    class MethodCall;
+    class MethodReply;
    class IConnection;
 }

@ -65,7 +66,7 @@ namespace sdbus {
        *
        * @throws sdbus::Error in case of failure
        */
-        virtual Message createMethodCall(const std::string& interfaceName, const std::string& methodName) = 0;
+        virtual MethodCall createMethodCall(const std::string& interfaceName, const std::string& methodName) = 0;

        /*!
        * @brief Calls method on the proxied D-Bus object
@ -76,7 +77,7 @@ namespace sdbus {
        *
        * @throws sdbus::Error in case of failure
        */
-        virtual Message callMethod(const sdbus::Message& message) = 0;
+        virtual MethodReply callMethod(const sdbus::MethodCall& message) = 0;

        /*!
        * @brief Registers a handler for the desired signal emitted by the proxied D-Bus object
--- a/include/sdbus-c++/Interfaces.h
+++ b/include/sdbus-c++/Interfaces.h
@ -113,6 +113,14 @@ namespace sdbus {
        {
            getObject().finishRegistration();
        }
+
+        ProxyInterfaces(std::unique_ptr<sdbus::IConnection>&& connection, std::string destination, std::string objectPath)
+            : ObjectHolder<IObjectProxy>(createObjectProxy(std::move(connection), std::move(destination), std::move(objectPath)))
+            , _Interfaces(getObject())...
+        {
+            getObject().finishRegistration();
+        }
+        
    };

 }
--- a/include/sdbus-c++/Message.h
+++ b/include/sdbus-c++/Message.h
@ -44,6 +44,12 @@ namespace sdbus {
    class ObjectPath;
    class Signature;
    template <typename... _ValueTypes> class Struct;
+
+    class Message;
+    class MethodCall;
+    class MethodReply;
+    class Signal;
+    template <typename... _Results> class Result;
 }

 namespace sdbus {
@ -65,16 +71,8 @@ namespace sdbus {
    class Message
    {
    public:
-        enum class Type
-        {
-            ePlainMessage
-        ,   eMethodCall
-        ,   eMethodReply
-        ,   eSignal
-        };
-
        Message() = default;
-        Message(void *msg, Type type = Type::ePlainMessage) noexcept;
+        Message(void *msg) noexcept;
        Message(const Message&) noexcept;
        Message& operator=(const Message&) noexcept;
        Message(Message&& other) noexcept;
@ -137,21 +135,42 @@ namespace sdbus {
        void peekType(std::string& type, std::string& contents) const;
        bool isValid() const;
        bool isEmpty() const;
-        Type getType() const;

        void copyTo(Message& destination, bool complete) const;
        void seal();
        void rewind(bool complete);

-        Message createReply() const;
-        Message send() const;
+    protected:
+        void* getMsg() const;

    private:
        void* msg_{};
-        Type type_{Type::ePlainMessage};
        mutable bool ok_{true};
    };

+    class MethodCall : public Message
+    {
+    public:
+        using Message::Message;
+        MethodReply send() const;
+        MethodReply createReply() const;
+        MethodReply createErrorReply(const sdbus::Error& error) const;
+    };
+
+    class MethodReply : public Message
+    {
+    public:
+        using Message::Message;
+        void send() const;
+    };
+
+    class Signal : public Message
+    {
+    public:
+        using Message::Message;
+        void send() const;
+    };
+
    template <typename _Element>
    inline Message& operator<<(Message& msg, const std::vector<_Element>& items)
    {
--- a/include/sdbus-c++/MethodResult.h
+++ b/include/sdbus-c++/MethodResult.h
@ -0,0 +1,126 @@
+/**
+ * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ *
+ * @file ConvenienceClasses.h
+ *
+ * Created on: Nov 8, 2016
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef SDBUS_CXX_METHODRESULT_H_
+#define SDBUS_CXX_METHODRESULT_H_
+
+#include <sdbus-c++/Message.h>
+#include <cassert>
+
+// Forward declaration
+namespace sdbus {
+    namespace internal {
+        class Object;
+    }
+    class Error;
+}
+
+namespace sdbus {
+
+    /********************************************//**
+     * @class MethodResult
+     *
+     * Represents result of an asynchronous server-side method.
+     * An instance is provided to the method and shall be set
+     * by the method to either method return value or an error.
+     *
+     ***********************************************/
+    class MethodResult
+    {
+    protected:
+        friend sdbus::internal::Object;
+        MethodResult() = default;
+        MethodResult(const MethodCall& msg, sdbus::internal::Object& object);
+
+        template <typename... _Results> void returnResults(const _Results&... results) const;
+        void returnError(const Error& error) const;
+
+    private:
+        void send(const MethodReply& reply) const;
+
+    private:
+        MethodCall call_;
+        sdbus::internal::Object* object_{};
+    };
+
+    template <typename... _Results>
+    inline void MethodResult::returnResults(const _Results&... results) const
+    {
+        assert(call_.isValid());
+        auto reply = call_.createReply();
+#ifdef __cpp_fold_expressions
+        (reply << ... << results);
+#else
+        using _ = std::initializer_list<int>;
+        (void)_{(void(reply << results), 0)...};
+#endif
+        send(reply);
+    }
+
+    inline void MethodResult::returnError(const Error& error) const
+    {
+        auto reply = call_.createErrorReply(error);
+        send(reply);
+    }
+
+    /********************************************//**
+     * @class Result
+     *
+     * Represents result of an asynchronous server-side method.
+     * An instance is provided to the method and shall be set
+     * by the method to either method return value or an error.
+     *
+     ***********************************************/
+    template <typename... _Results>
+    class Result : protected MethodResult
+    {
+    public:
+        Result() = default;
+        Result(MethodResult result);
+        void returnResults(const _Results&... results) const;
+        void returnError(const Error& error) const;
+    };
+
+    template <typename... _Results>
+    inline Result<_Results...>::Result(MethodResult result)
+        : MethodResult(std::move(result))
+    {
+    }
+
+    template <typename... _Results>
+    inline void Result<_Results...>::returnResults(const _Results&... results) const
+    {
+        MethodResult::returnResults(results...);
+    }
+
+    template <typename... _Results>
+    inline void Result<_Results...>::returnError(const Error& error) const
+    {
+        MethodResult::returnError(error);
+    }
+
+}
+
+#endif /* SDBUS_CXX_METHODRESULT_H_ */
--- a/include/sdbus-c++/TypeTraits.h
+++ b/include/sdbus-c++/TypeTraits.h
@ -26,6 +26,7 @@
 #ifndef SDBUS_CXX_TYPETRAITS_H_
 #define SDBUS_CXX_TYPETRAITS_H_

+#include <type_traits>
 #include <string>
 #include <vector>
 #include <map>
@ -40,16 +41,21 @@ namespace sdbus {
    class ObjectPath;
    class Signature;
    class Message;
+    class MethodCall;
+    class MethodReply;
+    class Signal;
+    class MethodResult;
+    template <typename... _Results> class Result;
 }

 namespace sdbus {

-    using method_callback = std::function<void(Message& msg, Message& reply)>;
-    using signal_handler = std::function<void(Message& signal)>;
+    using method_callback = std::function<void(MethodCall& msg, MethodReply& reply)>;
+    using async_method_callback = std::function<void(MethodCall& msg, MethodResult result)>;
+    using signal_handler = std::function<void(Signal& signal)>;
    using property_set_callback = std::function<void(Message& msg)>;
    using property_get_callback = std::function<void(Message& reply)>;

-    // Primary template
    template <typename _T>
    struct signature_of
    {
@ -301,6 +307,9 @@ namespace sdbus {
        }
    };

+
+    // Function traits implementation inspired by (c) kennytm,
+    // https://github.com/kennytm/utils/blob/master/traits.hpp
    template <typename _Type>
    struct function_traits
        : public function_traits<decltype(&_Type::operator())>
@ -316,18 +325,32 @@ namespace sdbus {
        : public function_traits<_Type>
    {};

-    // Function traits implementation inspired by (c) kennytm,
-    // https://github.com/kennytm/utils/blob/master/traits.hpp
    template <typename _ReturnType, typename... _Args>
-    struct function_traits<_ReturnType(_Args...)>
+    struct function_traits_base
    {
        typedef _ReturnType result_type;
        typedef std::tuple<_Args...> arguments_type;
+        typedef std::tuple<std::decay_t<_Args>...> decayed_arguments_type;

        typedef _ReturnType function_type(_Args...);

        static constexpr std::size_t arity = sizeof...(_Args);

+//        template <size_t _Idx, typename _Enabled = void>
+//        struct arg;
+//
+//        template <size_t _Idx>
+//        struct arg<_Idx, std::enable_if_t<(_Idx < arity)>>
+//        {
+//            typedef std::tuple_element_t<_Idx, arguments_type> type;
+//        };
+//
+//        template <size_t _Idx>
+//        struct arg<_Idx, std::enable_if_t<!(_Idx < arity)>>
+//        {
+//            typedef void type;
+//        };
+
        template <size_t _Idx>
        struct arg
        {
@ -338,6 +361,20 @@ namespace sdbus {
        using arg_t = typename arg<_Idx>::type;
    };

+    template <typename _ReturnType, typename... _Args>
+    struct function_traits<_ReturnType(_Args...)>
+        : public function_traits_base<_ReturnType, _Args...>
+    {
+        static constexpr bool is_async = false;
+    };
+
+    template <typename... _Args, typename... _Results>
+    struct function_traits<void(Result<_Results...>, _Args...)>
+        : public function_traits_base<std::tuple<_Results...>, _Args...>
+    {
+        static constexpr bool is_async = true;
+    };
+
    template <typename _ReturnType, typename... _Args>
    struct function_traits<_ReturnType(*)(_Args...)>
        : public function_traits<_ReturnType(_Args...)>
@ -376,12 +413,39 @@ namespace sdbus {
        : public function_traits<FunctionType>
    {};

+    template <class _Function>
+    constexpr auto is_async_method_v = function_traits<_Function>::is_async;
+
+    template <typename _FunctionType>
+    using function_arguments_t = typename function_traits<_FunctionType>::arguments_type;
+
    template <typename _FunctionType, size_t _Idx>
    using function_argument_t = typename function_traits<_FunctionType>::template arg_t<_Idx>;

+    template <typename _FunctionType>
+    constexpr auto function_argument_count_v = function_traits<_FunctionType>::arity;
+
    template <typename _FunctionType>
    using function_result_t = typename function_traits<_FunctionType>::result_type;

+    template <typename _Function>
+    struct tuple_of_function_input_arg_types
+    {
+        typedef typename function_traits<_Function>::decayed_arguments_type type;
+    };
+
+    template <typename _Function>
+    using tuple_of_function_input_arg_types_t = typename tuple_of_function_input_arg_types<_Function>::type;
+
+    template <typename _Function>
+    struct tuple_of_function_output_arg_types
+    {
+        typedef typename function_traits<_Function>::result_type type;
+    };
+
+    template <typename _Function>
+    using tuple_of_function_output_arg_types_t = typename tuple_of_function_output_arg_types<_Function>::type;
+
    template <typename _Type>
    struct aggregate_signature
    {
@ -396,6 +460,7 @@ namespace sdbus {
    {
        static const std::string str()
        {
+            // TODO: This could be a fold expression in C++17...
            std::initializer_list<std::string> signatures{signature_of<std::decay_t<_Types>>::str()...};
            std::string signature;
            for (const auto& item : signatures)
@ -404,28 +469,6 @@ namespace sdbus {
        }
    };

-    // Get a tuple of function input argument types from function signature.
-    // But first, convert provided function signature to the standardized form `out(in...)'.
-    template <typename _Function>
-    struct tuple_of_function_input_arg_types
-        : public tuple_of_function_input_arg_types<typename function_traits<_Function>::function_type>
-    {};
-
-    // Get a tuple of function input argument types from function signature.
-    // Function signature is expected in the standardized form `out(in...)'.
-    template <typename _ReturnType, typename... _Args>
-    struct tuple_of_function_input_arg_types<_ReturnType(_Args...)>
-    {
-        // Arguments may be cv-qualified and may be references, so we have to strip cv and references
-        // with decay_t in order to get real 'naked' types.
-        // Example: for a function with signature void(const int i, const std::vector<float> v, double d)
-        // the `type' will be `std::tuple<int, std::vector<float>, double>'.
-        typedef std::tuple<std::decay_t<_Args>...> type;
-    };
-
-    template <typename _Function>
-    using tuple_of_function_input_arg_types_t = typename tuple_of_function_input_arg_types<_Function>::type;
-
    template <typename _Function>
    struct signature_of_function_input_arguments
    {
@ -440,12 +483,21 @@ namespace sdbus {
    {
        static const std::string str()
        {
-            return aggregate_signature<function_result_t<_Function>>::str();
+            return aggregate_signature<tuple_of_function_output_arg_types_t<_Function>>::str();
        }
    };

    namespace detail
    {
+        template <class _Function, class _Tuple, std::size_t... _I>
+        constexpr decltype(auto) apply_impl( _Function&& f
+                                           , MethodResult&& r
+                                           , _Tuple&& t
+                                           , std::index_sequence<_I...> )
+        {
+            return std::forward<_Function>(f)(std::move(r), std::get<_I>(std::forward<_Tuple>(t))...);
+        }
+
        // Version of apply_impl for functions returning non-void values.
        // In this case just forward function return value.
        template <class _Function, class _Tuple, std::size_t... _I>
@ -480,6 +532,16 @@ namespace sdbus {
                                 , std::make_index_sequence<std::tuple_size<std::decay_t<_Tuple>>::value>{} );
    }

+    // Convert tuple `t' of values into a list of arguments
+    // and invoke function `f' with those arguments.
+    template <class _Function, class _Tuple>
+    constexpr decltype(auto) apply(_Function&& f, MethodResult&& r, _Tuple&& t)
+    {
+        return detail::apply_impl( std::forward<_Function>(f)
+                                 , std::move(r)
+                                 , std::forward<_Tuple>(t)
+                                 , std::make_index_sequence<std::tuple_size<std::decay_t<_Tuple>>::value>{} );
+    }
 }

 #endif /* SDBUS_CXX_TYPETRAITS_H_ */
--- a/include/sdbus-c++/Types.h
+++ b/include/sdbus-c++/Types.h
@ -40,6 +40,12 @@ namespace sdbus {
     * @class Variant
     *
     * Variant can hold value of any D-Bus-supported type.
+     * 
+     * Note: Even though thread-aware, Variant objects are not thread-safe.
+     * Some const methods are conceptually const, but not physically const,
+     * thus are not thread-safe. This is by design: normally, clients
+     * should process a single Variant object in a single thread at a time.
+     * Otherwise they need to take care of synchronization by themselves.
     *
     ***********************************************/
    class Variant
--- a/include/sdbus-c++/sdbus-c++.h
+++ b/include/sdbus-c++/sdbus-c++.h
@ -28,6 +28,7 @@
 #include <sdbus-c++/IObjectProxy.h>
 #include <sdbus-c++/Interfaces.h>
 #include <sdbus-c++/Message.h>
+#include <sdbus-c++/MethodResult.h>
 #include <sdbus-c++/Types.h>
 #include <sdbus-c++/TypeTraits.h>
 #include <sdbus-c++/Introspection.h>
--- a/sdbus-c++-config-version.cmake.in
+++ b/sdbus-c++-config-version.cmake.in
@ -0,0 +1,11 @@
+set(PACKAGE_VERSION "@SDBUSCPP_VERSION@")
+
+# Check whether the requested PACKAGE_FIND_VERSION is compatible
+if("${PACKAGE_VERSION}" VERSION_LESS "${PACKAGE_FIND_VERSION}")
+  set(PACKAGE_VERSION_COMPATIBLE FALSE)
+else()
+  set(PACKAGE_VERSION_COMPATIBLE TRUE)
+  if ("${PACKAGE_VERSION}" VERSION_EQUAL "${PACKAGE_FIND_VERSION}")
+    set(PACKAGE_VERSION_EXACT TRUE)
+  endif()
+endif()
--- a/sdbus-c++-config.cmake.in
+++ b/sdbus-c++-config.cmake.in
@ -0,0 +1,14 @@
+# Config file for the sdbus-c++ package.
+#
+# It defines the following variables:
+#  SDBUSCPP_VERSION      - version of sdbus-c++
+#  SDBUSCPP_FOUND        - set to true
+#  SDBUSCPP_INCLUDE_DIRS - include directories for sdbus-c++
+#  SDBUSCPP_LIBRARY_DIR  - library directories for sdbus-c++
+#  SDBUSCPP_LIBRARIES    - libraries to link against
+
+set(SDBUSCPP_VERSION "@SDBUSCPP_VERSION@")
+set(SDBUSCPP_FOUND "TRUE")
+set(SDBUSCPP_INCLUDE_DIRS "@CMAKE_INSTALL_FULL_INCLUDEDIR@")
+set(SDBUSCPP_LIBRARY_DIR "@CMAKE_INSTALL_FULL_LIBDIR@")
+set(SDBUSCPP_LIBRARIES sdbus-c++)
--- a/sdbus-c++.pc.in
+++ b/sdbus-c++.pc.in
@ -1,11 +1,11 @@
-prefix=@prefix@
-exec_prefix=@exec_prefix@
-libdir=@libdir@
-includedir=@includedir@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=@CMAKE_INSTALL_PREFIX@
+libdir=@CMAKE_INSTALL_FULL_LIBDIR@
+includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@

-Name: @PACKAGE@
-Description: C++ bindings library for sd-bus
+Name: @PROJECT_NAME@
+Description: C++ library on top of sd-bus, a systemd D-Bus library
 Requires: libsystemd
-Version: @VERSION@
-Libs: -L${libdir} -lsdbus-c++
+Version: @SDBUSCPP_VERSION@
+Libs: -L${libdir} -l@PROJECT_NAME@
 Cflags: -I${includedir}
--- a/src/Connection.cpp
+++ b/src/Connection.cpp
@ -42,13 +42,13 @@ Connection::Connection(Connection::BusType type)

    finishHandshake(bus);

-    exitLoopFd_ = createProcessingExitDescriptor();
+    notificationFd_ = createLoopNotificationDescriptor();
 }

 Connection::~Connection()
 {
    leaveProcessingLoop();
-    closeProcessingExitDescriptor(exitLoopFd_);
+    closeLoopNotificationDescriptor(notificationFd_);
 }

 void Connection::requestName(const std::string& name)
@ -67,13 +67,15 @@ void Connection::enterProcessingLoop()
 {
    while (true)
    {
-        auto processed = processPendingRequest(bus_.get());
+        auto processed = processPendingRequest();
        if (processed)
            continue; // Process next one

-        auto success = waitForNextRequest(bus_.get(), exitLoopFd_);
+        auto success = waitForNextRequest();
        if (!success)
            break; // Exit processing loop
+        if (success.asyncMsgsToProcess)
+            processAsynchronousMessages();
    }
 }

@ -112,10 +114,10 @@ void Connection::removeObjectVTable(void* vtableHandle)
    sd_bus_slot_unref((sd_bus_slot *)vtableHandle);
 }

-sdbus::Message Connection::createMethodCall( const std::string& destination
-                                           , const std::string& objectPath
-                                           , const std::string& interfaceName
-                                           , const std::string& methodName ) const
+sdbus::MethodCall Connection::createMethodCall( const std::string& destination
+                                              , const std::string& objectPath
+                                              , const std::string& interfaceName
+                                              , const std::string& methodName ) const
 {
    sd_bus_message *sdbusMsg{};

@ -131,12 +133,12 @@ sdbus::Message Connection::createMethodCall( const std::string& destination

    SDBUS_THROW_ERROR_IF(r < 0, "Failed to create method call", -r);

-    return Message(sdbusMsg, Message::Type::eMethodCall);
+    return MethodCall(sdbusMsg);
 }

-sdbus::Message Connection::createSignal( const std::string& objectPath
-                                       , const std::string& interfaceName
-                                       , const std::string& signalName ) const
+sdbus::Signal Connection::createSignal( const std::string& objectPath
+                                      , const std::string& interfaceName
+                                      , const std::string& signalName ) const
 {
    sd_bus_message *sdbusSignal{};

@ -151,7 +153,7 @@ sdbus::Message Connection::createSignal( const std::string& objectPath

    SDBUS_THROW_ERROR_IF(r < 0, "Failed to create signal", -r);

-    return Message(sdbusSignal, Message::Type::eSignal);
+    return Signal(sdbusSignal);
 }

 void* Connection::registerSignalHandler( const std::string& objectPath
@ -175,6 +177,13 @@ void Connection::unregisterSignalHandler(void* handlerCookie)
    sd_bus_slot_unref((sd_bus_slot *)handlerCookie);
 }

+void Connection::sendReplyAsynchronously(const sdbus::MethodReply& reply)
+{
+    std::lock_guard<std::mutex> guard(mutex_);
+    asyncReplies_.push(reply);
+    notifyProcessingLoop();
+}
+
 std::unique_ptr<sdbus::internal::IConnection> Connection::clone() const
 {
    return std::make_unique<sdbus::internal::Connection>(busType_);
@ -211,27 +220,35 @@ void Connection::finishHandshake(sd_bus* bus)
    SDBUS_THROW_ERROR_IF(r < 0, "Failed to flush bus on opening", -r);
 }

-int Connection::createProcessingExitDescriptor()
+int Connection::createLoopNotificationDescriptor()
 {
-    // Mechanism for graceful termination of processing loop
-
-    auto r = eventfd(0, EFD_SEMAPHORE | EFD_CLOEXEC);
+    auto r = eventfd(0, EFD_SEMAPHORE | EFD_CLOEXEC | EFD_NONBLOCK);

    SDBUS_THROW_ERROR_IF(r < 0, "Failed to create event object", -errno);

    return r;
 }

-void Connection::closeProcessingExitDescriptor(int fd)
+void Connection::closeLoopNotificationDescriptor(int fd)
 {
    close(fd);
 }

+void Connection::notifyProcessingLoop()
+{
+    assert(notificationFd_ >= 0);
+
+    uint64_t value = 1;
+    auto r = write(notificationFd_, &value, sizeof(value));
+
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to notify processing loop", -errno);
+}
+
 void Connection::notifyProcessingLoopToExit()
 {
-    assert(exitLoopFd_ >= 0);
-    uint64_t value = 1;
-    write(exitLoopFd_, &value, sizeof(value));
+    exitLoopThread_ = true;
+
+    notifyProcessingLoop();
 }

 void Connection::joinWithProcessingLoop()
@ -240,8 +257,10 @@ void Connection::joinWithProcessingLoop()
        asyncLoopThread_.join();
 }

-bool Connection::processPendingRequest(sd_bus* bus)
+bool Connection::processPendingRequest()
 {
+    auto bus = bus_.get();
+
    assert(bus != nullptr);

    int r = sd_bus_process(bus, nullptr);
@ -251,10 +270,23 @@ bool Connection::processPendingRequest(sd_bus* bus)
    return r > 0;
 }

-bool Connection::waitForNextRequest(sd_bus* bus, int exitFd)
+void Connection::processAsynchronousMessages()
 {
+    std::lock_guard<std::mutex> guard(mutex_);
+    while (!asyncReplies_.empty())
+    {
+        auto reply = asyncReplies_.front();
+        asyncReplies_.pop();
+        reply.send();
+    }
+}
+
+Connection::WaitResult Connection::waitForNextRequest()
+{
+    auto bus = bus_.get();
+
    assert(bus != nullptr);
-    assert(exitFd != 0);
+    assert(notificationFd_ != 0);

    auto r = sd_bus_get_fd(bus);
    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus descriptor", -r);
@ -267,20 +299,31 @@ bool Connection::waitForNextRequest(sd_bus* bus, int exitFd)
    uint64_t usec;
    sd_bus_get_timeout(bus, &usec);

-    struct pollfd fds[] = {{sdbusFd, sdbusEvents, 0}, {exitFd, POLLIN, 0}};
+    struct pollfd fds[] = {{sdbusFd, sdbusEvents, 0}, {notificationFd_, POLLIN, 0}};
    auto fdsCount = sizeof(fds)/sizeof(fds[0]);

    r = poll(fds, fdsCount, usec == (uint64_t) -1 ? -1 : (usec+999)/1000);

    if (r < 0 && errno == EINTR)
-        return true; // Try again
+        return {true, false}; // Try again

    SDBUS_THROW_ERROR_IF(r < 0, "Failed to wait on the bus", -errno);

    if (fds[1].revents & POLLIN)
-        return false; // Got exit notification
+    {
+        if (exitLoopThread_)
+            return {false, false}; // Got exit notification

-    return true;
+        // Otherwise we have some async messages to process
+
+        uint64_t value{};
+        auto r = read(notificationFd_, &value, sizeof(value));
+        SDBUS_THROW_ERROR_IF(r < 0, "Failed to read from the event descriptor", -errno);
+
+        return {false, true};
+    }
+
+    return {true, false};
 }

 std::string Connection::composeSignalMatchFilter( const std::string& objectPath
--- a/src/Connection.h
+++ b/src/Connection.h
@ -27,12 +27,14 @@
 #define SDBUS_CXX_INTERNAL_CONNECTION_H_

 #include <sdbus-c++/IConnection.h>
+#include <sdbus-c++/Message.h>
+#include "IConnection.h"
 #include <systemd/sd-bus.h>
 #include <memory>
-#include <atomic>
 #include <thread>
-
-#include "IConnection.h"
+#include <atomic>
+#include <mutex>
+#include <queue>

 namespace sdbus { namespace internal {

@ -62,13 +64,13 @@ namespace sdbus { namespace internal {
                             , void* userData ) override;
        void removeObjectVTable(void* vtableHandle) override;

-        sdbus::Message createMethodCall( const std::string& destination
-                                       , const std::string& objectPath
-                                       , const std::string& interfaceName
-                                       , const std::string& methodName ) const override;
-        sdbus::Message createSignal( const std::string& objectPath
-                                   , const std::string& interfaceName
-                                   , const std::string& signalName ) const override;
+        sdbus::MethodCall createMethodCall( const std::string& destination
+                                          , const std::string& objectPath
+                                          , const std::string& interfaceName
+                                          , const std::string& methodName ) const override;
+        sdbus::Signal createSignal( const std::string& objectPath
+                                  , const std::string& interfaceName
+                                  , const std::string& signalName ) const override;

        void* registerSignalHandler( const std::string& objectPath
                                   , const std::string& interfaceName
@ -77,25 +79,41 @@ namespace sdbus { namespace internal {
                                   , void* userData ) override;
        void unregisterSignalHandler(void* handlerCookie) override;

+        void sendReplyAsynchronously(const sdbus::MethodReply& reply) override;
+
        std::unique_ptr<sdbus::internal::IConnection> clone() const override;

    private:
+        struct WaitResult
+        {
+            bool msgsToProcess;
+            bool asyncMsgsToProcess;
+            operator bool()
+            {
+                return msgsToProcess || asyncMsgsToProcess;
+            }
+        };
        static sd_bus* openBus(Connection::BusType type);
        static void finishHandshake(sd_bus* bus);
-        static int createProcessingExitDescriptor();
-        static void closeProcessingExitDescriptor(int fd);
-        static bool processPendingRequest(sd_bus* bus);
-        static bool waitForNextRequest(sd_bus* bus, int exitFd);
+        static int createLoopNotificationDescriptor();
+        static void closeLoopNotificationDescriptor(int fd);
+        bool processPendingRequest();
+        void processAsynchronousMessages();
+        WaitResult waitForNextRequest();
        static std::string composeSignalMatchFilter( const std::string& objectPath
                                                   , const std::string& interfaceName
                                                   , const std::string& signalName );
+        void notifyProcessingLoop();
        void notifyProcessingLoopToExit();
        void joinWithProcessingLoop();

    private:
        std::unique_ptr<sd_bus, decltype(&sd_bus_flush_close_unref)> bus_{nullptr, &sd_bus_flush_close_unref};
        std::thread asyncLoopThread_;
-        std::atomic<int> exitLoopFd_{-1};
+        std::mutex mutex_;
+        std::queue<MethodReply> asyncReplies_;
+        std::atomic<bool> exitLoopThread_;
+        int notificationFd_{-1};
        BusType busType_;

        static constexpr const uint64_t POLL_TIMEOUT_USEC = 500000;
--- a/src/IConnection.h
+++ b/src/IConnection.h
@ -32,7 +32,9 @@

 // Forward declaration
 namespace sdbus {
-    class Message;
+    class MethodCall;
+    class MethodReply;
+    class Signal;
 }

 namespace sdbus {
@ -47,14 +49,14 @@ namespace internal {
                                     , void* userData ) = 0;
        virtual void removeObjectVTable(void* vtableHandle) = 0;

-        virtual sdbus::Message createMethodCall( const std::string& destination
-                                               , const std::string& objectPath
-                                               , const std::string& interfaceName
-                                               , const std::string& methodName ) const = 0;
+        virtual sdbus::MethodCall createMethodCall( const std::string& destination
+                                                  , const std::string& objectPath
+                                                  , const std::string& interfaceName
+                                                  , const std::string& methodName ) const = 0;

-        virtual sdbus::Message createSignal( const std::string& objectPath
-                                           , const std::string& interfaceName
-                                           , const std::string& signalName ) const = 0;
+        virtual sdbus::Signal createSignal( const std::string& objectPath
+                                          , const std::string& interfaceName
+                                          , const std::string& signalName ) const = 0;

        virtual void* registerSignalHandler( const std::string& objectPath
                                           , const std::string& interfaceName
@ -66,6 +68,8 @@ namespace internal {
        virtual void enterProcessingLoopAsync() = 0;
        virtual void leaveProcessingLoop() = 0;

+        virtual void sendReplyAsynchronously(const sdbus::MethodReply& reply) = 0;
+
        virtual std::unique_ptr<sdbus::internal::IConnection> clone() const = 0;

        virtual ~IConnection() = default;
--- a/src/Makefile.am
+++ b/src/Makefile.am
@ -1,26 +0,0 @@
-
-lib_LTLIBRARIES = libsdbus-c++.la
-
-libsdbus_c___la_SOURCES = \
-	Connection.cpp \
-	ConvenienceClasses.cpp \
-	Message.cpp \
-	Object.cpp \
-	ObjectProxy.cpp \
-	Types.cpp \
-	Error.cpp \
-	VTableUtils.c
-
-libsdbus_c___la_LIBADD = @SYSTEMD_LIBS@
-
-# Setting per-file flags
-AM_CPPFLAGS = -I$(top_srcdir)/include
-AM_CXXFLAGS = @libsdbus_cpp_CFLAGS@ @SYSTEMD_CFLAGS@ -std=c++17 -pipe -pedantic -W -Wall
-AM_LDFLAGS = @libsdbus_cpp_LIBS@ @SYSTEMD_LIBS@ 
-
-libsdbus_c___la_LDFLAGS = -version-info 0:0:0
-
-# Cleaning
-CLEANFILES = *~ *.lo *.la
-MOSTLYCLEANFILES = *.o
-DISTCLEANFILES = Makefile Makefile.in
--- a/src/Message.cpp
+++ b/src/Message.cpp
@ -31,11 +31,10 @@
 #include <systemd/sd-bus.h>
 #include <cassert>

-namespace sdbus { /*namespace internal {*/
+namespace sdbus {

-Message::Message(void *msg, Type type) noexcept
+Message::Message(void *msg) noexcept
    : msg_(msg)
-    , type_(type)
 {
    assert(msg_ != nullptr);
    sd_bus_message_ref((sd_bus_message*)msg_);
@ -48,8 +47,10 @@ Message::Message(const Message& other) noexcept

 Message& Message::operator=(const Message& other) noexcept
 {
+    if (msg_)
+        sd_bus_message_unref((sd_bus_message*)msg_);
+
    msg_ = other.msg_;
-    type_ = other.type_;
    ok_ = other.ok_;

    sd_bus_message_ref((sd_bus_message*)msg_);
@ -64,10 +65,11 @@ Message::Message(Message&& other) noexcept

 Message& Message::operator=(Message&& other) noexcept
 {
+    if (msg_)
+        sd_bus_message_unref((sd_bus_message*)msg_);
+
    msg_ = other.msg_;
    other.msg_ = nullptr;
-    type_ = other.type_;
-    other.type_ = {};
    ok_ = other.ok_;
    other.ok_ = true;

@ -534,59 +536,6 @@ void Message::rewind(bool complete)
    SDBUS_THROW_ERROR_IF(r < 0, "Failed to rewind the message", -r);
 }

-Message Message::send() const
-{
-    if (type_ == Type::eMethodCall)
-    {
-        sd_bus_message* sdbusReply{};
-        SCOPE_EXIT{ sd_bus_message_unref(sdbusReply); }; // Returned message will become an owner of sdbusReply
-        sd_bus_error sdbusError = SD_BUS_ERROR_NULL;
-        SCOPE_EXIT{ sd_bus_error_free(&sdbusError); };
-
-        auto r = sd_bus_call(nullptr, (sd_bus_message*)msg_, 0, &sdbusError, &sdbusReply);
-
-        if (sd_bus_error_is_set(&sdbusError))
-        {
-            throw sdbus::Error(sdbusError.name, sdbusError.message);
-        }
-
-        SDBUS_THROW_ERROR_IF(r < 0, "Failed to call method", -r);
-
-        return Message(sdbusReply);
-    }
-    else if (type_ == Type::eMethodReply)
-    {
-        auto r = sd_bus_send(nullptr, (sd_bus_message*)msg_, nullptr);
-        SDBUS_THROW_ERROR_IF(r < 0, "Failed to send reply", -r);
-
-        return Message();
-    }
-    else if (type_ == Type::eSignal)
-    {
-        auto r = sd_bus_send(nullptr, (sd_bus_message*)msg_, nullptr);
-        SDBUS_THROW_ERROR_IF(r < 0, "Failed to emit signal", -r);
-
-        return Message();
-    }
-    else
-    {
-        assert(false);
-        return Message();
-    }
-}
-
-Message Message::createReply() const
-{
-    sd_bus_message *sdbusReply{};
-    SCOPE_EXIT{ sd_bus_message_unref(sdbusReply); }; // Returned message will become an owner of sdbusReply
-    auto r = sd_bus_message_new_method_return((sd_bus_message*)msg_, &sdbusReply);
-    SDBUS_THROW_ERROR_IF(r < 0, "Failed to create method reply", -r);
-
-    assert(sdbusReply != nullptr);
-
-    return Message(sdbusReply, Type::eMethodReply);
-}
-
 std::string Message::getInterfaceName() const
 {
    return sd_bus_message_get_interface((sd_bus_message*)msg_);
@ -617,9 +566,70 @@ bool Message::isEmpty() const
    return sd_bus_message_is_empty((sd_bus_message*)msg_);
 }

-Message::Type Message::getType() const
+void* Message::getMsg() const
 {
-    return type_;
+    return msg_;
+}
+
+MethodReply MethodCall::send() const
+{
+    sd_bus_message* sdbusReply{};
+    SCOPE_EXIT{ sd_bus_message_unref(sdbusReply); }; // Returned message will become an owner of sdbusReply
+    sd_bus_error sdbusError = SD_BUS_ERROR_NULL;
+    SCOPE_EXIT{ sd_bus_error_free(&sdbusError); };
+
+    auto r = sd_bus_call(nullptr, (sd_bus_message*)getMsg(), 0, &sdbusError, &sdbusReply);
+
+    if (sd_bus_error_is_set(&sdbusError))
+    {
+        throw sdbus::Error(sdbusError.name, sdbusError.message);
+    }
+
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to call method", -r);
+
+    return MethodReply(sdbusReply);
+}
+
+MethodReply MethodCall::createReply() const
+{
+    sd_bus_message *sdbusReply{};
+    SCOPE_EXIT{ sd_bus_message_unref(sdbusReply); }; // Returned message will become an owner of sdbusReply
+
+    auto r = sd_bus_message_new_method_return((sd_bus_message*)getMsg(), &sdbusReply);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to create method reply", -r);
+
+    assert(sdbusReply != nullptr);
+
+    return MethodReply(sdbusReply);
+}
+
+MethodReply MethodCall::createErrorReply(const Error& error) const
+{
+    sd_bus_error sdbusError = SD_BUS_ERROR_NULL;
+    SCOPE_EXIT{ sd_bus_error_free(&sdbusError); };
+    sd_bus_error_set(&sdbusError, error.getName().c_str(), error.getMessage().c_str());
+
+    sd_bus_message *sdbusErrorReply{};
+    SCOPE_EXIT{ sd_bus_message_unref(sdbusErrorReply); }; // Returned message will become an owner of sdbusErrorReply
+
+    auto r = sd_bus_message_new_method_error((sd_bus_message*)getMsg(), &sdbusErrorReply, &sdbusError);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to create method error reply", -r);
+
+    assert(sdbusErrorReply != nullptr);
+
+    return MethodReply(sdbusErrorReply);
+}
+
+void MethodReply::send() const
+{
+    auto r = sd_bus_send(nullptr, (sd_bus_message*)getMsg(), nullptr);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to send reply", -r);
+}
+
+void Signal::send() const
+{
+    auto r = sd_bus_send(nullptr, (sd_bus_message*)getMsg(), nullptr);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to emit signal", -r);
 }

 Message createPlainMessage()
@ -636,7 +646,7 @@ Message createPlainMessage()
    r = sd_bus_message_new(bus, &sdbusMsg, _SD_BUS_MESSAGE_TYPE_INVALID);
    SDBUS_THROW_ERROR_IF(r < 0, "Failed to create a new message", -r);

-    return Message(sdbusMsg, Message::Type::ePlainMessage);
+    return Message(sdbusMsg);
 }

-/*}*/}
+}
--- a/src/MethodResult.cpp
+++ b/src/MethodResult.cpp
@ -0,0 +1,43 @@
+/**
+ * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ *
+ * @file Object.cpp
+ *
+ * Created on: Nov 8, 2016
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <sdbus-c++/MethodResult.h>
+#include "Object.h"
+
+namespace sdbus {
+
+MethodResult::MethodResult(const MethodCall& msg, sdbus::internal::Object& object)
+    : call_(msg)
+    , object_(&object)
+{
+}
+
+void MethodResult::send(const MethodReply& reply) const
+{
+    assert(object_ != nullptr);
+    object_->sendReplyAsynchronously(reply);
+}
+
+}
--- a/src/Object.cpp
+++ b/src/Object.cpp
@ -27,6 +27,7 @@
 #include <sdbus-c++/IConnection.h>
 #include <sdbus-c++/Message.h>
 #include <sdbus-c++/Error.h>
+#include <sdbus-c++/MethodResult.h>
 #include "IConnection.h"
 #include "VTableUtils.h"
 #include <systemd/sd-bus.h>
@ -48,9 +49,36 @@ void Object::registerMethod( const std::string& interfaceName
 {
    SDBUS_THROW_ERROR_IF(!methodCallback, "Invalid method callback provided", EINVAL);

-    auto& interface = interfaces_[interfaceName];
+    auto syncCallback = [callback = std::move(methodCallback)](MethodCall& msg)
+    {
+        auto reply = msg.createReply();
+        callback(msg, reply);
+        reply.send();
+    };

-    InterfaceData::MethodData methodData{inputSignature, outputSignature, std::move(methodCallback)};
+    auto& interface = interfaces_[interfaceName];
+    InterfaceData::MethodData methodData{inputSignature, outputSignature, std::move(syncCallback)};
+    auto inserted = interface.methods_.emplace(methodName, std::move(methodData)).second;
+
+    SDBUS_THROW_ERROR_IF(!inserted, "Failed to register method: method already exists", EINVAL);
+}
+
+void Object::registerMethod( const std::string& interfaceName
+                           , const std::string& methodName
+                           , const std::string& inputSignature
+                           , const std::string& outputSignature
+                           , async_method_callback asyncMethodCallback )
+{
+    SDBUS_THROW_ERROR_IF(!asyncMethodCallback, "Invalid method callback provided", EINVAL);
+
+    auto asyncCallback = [this, callback = std::move(asyncMethodCallback)](MethodCall& msg)
+    {
+        MethodResult result{msg, *this};
+        callback(msg, result);
+    };
+
+    auto& interface = interfaces_[interfaceName];
+    InterfaceData::MethodData methodData{inputSignature, outputSignature, std::move(asyncCallback)};
    auto inserted = interface.methods_.emplace(methodName, std::move(methodData)).second;

    SDBUS_THROW_ERROR_IF(!inserted, "Failed to register method: method already exists", EINVAL);
@ -108,17 +136,24 @@ void Object::finishRegistration()
    }
 }

-sdbus::Message Object::createSignal(const std::string& interfaceName, const std::string& signalName)
+sdbus::Signal Object::createSignal(const std::string& interfaceName, const std::string& signalName)
 {
-    // Tell, don't ask
    return connection_.createSignal(objectPath_, interfaceName, signalName);
 }

-void Object::emitSignal(const sdbus::Message& message)
+void Object::emitSignal(const sdbus::Signal& message)
 {
+    // TODO: Make signal emitting asynchronous. Now signal can probably be emitted only from user code
+    // handled within the D-Bus processing loop thread, but not from any thread. In principle it will
+    // be the same as async replies.
    message.send();
 }

+void Object::sendReplyAsynchronously(const MethodReply& reply)
+{
+    connection_.sendReplyAsynchronously(reply);
+}
+
 const std::vector<sd_bus_vtable>& Object::createInterfaceVTable(InterfaceData& interfaceData)
 {
    auto& vtable = interfaceData.vtable_;
@ -190,27 +225,22 @@ void Object::activateInterfaceVTable( const std::string& interfaceName

 int Object::sdbus_method_callback(sd_bus_message *sdbusMessage, void *userData, sd_bus_error *retError)
 {
-    Message message(sdbusMessage, Message::Type::eMethodCall);
+    MethodCall message(sdbusMessage);

    auto* object = static_cast<Object*>(userData);
    // Note: The lookup can be optimized by using sorted vectors instead of associative containers
    auto& callback = object->interfaces_[message.getInterfaceName()].methods_[message.getMemberName()].callback_;
    assert(callback);

-    auto reply = message.createReply();
-
    try
    {
-        callback(message, reply);
+        callback(message);
    }
    catch (const sdbus::Error& e)
    {
        sd_bus_error_set(retError, e.getName().c_str(), e.getMessage().c_str());
-        return 1;
    }

-    reply.send();
-
    return 1;
 }

@ -222,7 +252,7 @@ int Object::sdbus_property_get_callback( sd_bus */*bus*/
                                       , void *userData
                                       , sd_bus_error *retError )
 {
-    Message reply(sdbusReply, Message::Type::ePlainMessage);
+    Message reply(sdbusReply);

    auto* object = static_cast<Object*>(userData);
    // Note: The lookup can be optimized by using sorted vectors instead of associative containers
@ -254,7 +284,7 @@ int Object::sdbus_property_set_callback( sd_bus */*bus*/
                                       , void *userData
                                       , sd_bus_error *retError )
 {
-    Message value(sdbusValue, Message::Type::ePlainMessage);
+    Message value(sdbusValue);

    auto* object = static_cast<Object*>(userData);
    // Note: The lookup can be optimized by using sorted vectors instead of associative containers
@ -268,7 +298,6 @@ int Object::sdbus_property_set_callback( sd_bus */*bus*/
    catch (const sdbus::Error& e)
    {
        sd_bus_error_set(retError, e.getName().c_str(), e.getMessage().c_str());
-        return 1;
    }

    return 1;
--- a/src/Object.h
+++ b/src/Object.h
@ -32,6 +32,7 @@
 #include <string>
 #include <map>
 #include <vector>
+#include <functional>
 #include <memory>
 #include <cassert>

@ -50,6 +51,12 @@ namespace internal {
                           , const std::string& outputSignature
                           , method_callback methodCallback ) override;

+        void registerMethod( const std::string& interfaceName
+                           , const std::string& methodName
+                           , const std::string& inputSignature
+                           , const std::string& outputSignature
+                           , async_method_callback asyncMethodCallback ) override;
+
        void registerSignal( const std::string& interfaceName
                           , const std::string& signalName
                           , const std::string& signature ) override;
@ -67,8 +74,10 @@ namespace internal {

        void finishRegistration() override;

-        sdbus::Message createSignal(const std::string& interfaceName, const std::string& signalName) override;
-        void emitSignal(const sdbus::Message& message) override;
+        sdbus::Signal createSignal(const std::string& interfaceName, const std::string& signalName) override;
+        void emitSignal(const sdbus::Signal& message) override;
+
+        void sendReplyAsynchronously(const MethodReply& reply);

    private:
        using InterfaceName = std::string;
@ -79,7 +88,7 @@ namespace internal {
            {
                std::string inputArgs_;
                std::string outputArgs_;
-                method_callback callback_;
+                std::function<void(MethodCall&)> callback_;
            };
            std::map<MethodName, MethodData> methods_;
            using SignalName = std::string;
--- a/src/ObjectProxy.cpp
+++ b/src/ObjectProxy.cpp
@ -60,13 +60,13 @@ ObjectProxy::~ObjectProxy()
        signalConnection_->leaveProcessingLoop();
 }

-Message ObjectProxy::createMethodCall(const std::string& interfaceName, const std::string& methodName)
+MethodCall ObjectProxy::createMethodCall(const std::string& interfaceName, const std::string& methodName)
 {
    // Tell, don't ask
    return connection_->createMethodCall(destination_, objectPath_, interfaceName, methodName);
 }

-Message ObjectProxy::callMethod(const Message& message)
+MethodReply ObjectProxy::callMethod(const MethodCall& message)
 {
    return message.send();
 }
@ -138,7 +138,7 @@ void ObjectProxy::registerSignalHandlers(sdbus::internal::IConnection& connectio

 int ObjectProxy::sdbus_signal_callback(sd_bus_message *sdbusMessage, void *userData, sd_bus_error */*retError*/)
 {
-    Message message(sdbusMessage, Message::Type::eSignal);
+    Signal message(sdbusMessage);

    auto* object = static_cast<ObjectProxy*>(userData);
    // Note: The lookup can be optimized by using sorted vectors instead of associative containers
--- a/src/ObjectProxy.h
+++ b/src/ObjectProxy.h
@ -52,8 +52,8 @@ namespace internal {
                   , std::string objectPath );
        ~ObjectProxy();

-        Message createMethodCall(const std::string& interfaceName, const std::string& methodName) override;
-        Message callMethod(const Message& message) override;
+        MethodCall createMethodCall(const std::string& interfaceName, const std::string& methodName) override;
+        MethodReply callMethod(const MethodCall& message) override;

        void registerSignalHandler( const std::string& interfaceName
                                  , const std::string& signalName
--- a/src/Types.cpp
+++ b/src/Types.cpp
@ -51,6 +51,7 @@ void Variant::deserializeFrom(Message& msg)

 std::string Variant::peekValueType() const
 {
+    msg_.rewind(false);
    std::string type;
    std::string contents;
    msg_.peekType(type, contents);
--- a/stub-generator/AdaptorGenerator.cpp
+++ b/stub-generator/AdaptorGenerator.cpp
@ -136,25 +136,47 @@ std::tuple<std::string, std::string> AdaptorGenerator::processMethods(const Node
    {
        auto methodName = method->get("name");

+        bool async{false};
+        Nodes annotations = (*method)["annotation"];
+
+        for (const auto& annotation : annotations)
+        {
+            if (annotation->get("name") == "org.freedesktop.DBus.Method.Async"
+                && (annotation->get("value") == "server" || annotation->get("value") == "clientserver"))
+            {
+                async = true;
+                break;
+            }
+        }
+
        Nodes args = (*method)["arg"];
        Nodes inArgs = args.select("direction" , "in");
        Nodes outArgs = args.select("direction" , "out");

        std::string argStr, argTypeStr;
        std::tie(argStr, argTypeStr, std::ignore) = argsToNamesAndTypes(inArgs);
+        
+        using namespace std::string_literals;

        registrationSS << tab << tab << "object_.registerMethod(\""
                << methodName << "\")"
                << ".onInterface(interfaceName)"
                << ".implementedAs("
                << "[this]("
+                << (async ? "sdbus::Result<" + outArgsToType(outArgs, true) + "> result" + (argTypeStr.empty() ? "" : ", ") : "")
                << argTypeStr
-                << "){ return this->" << methodName << "("
+                << "){ " << (async ? "" : "return ") << "this->" << methodName << "("
+                << (async ? "std::move(result)"s + (argTypeStr.empty() ? "" : ", ") : "")
                << argStr << "); });" << endl;

        declarationSS << tab
-                << "virtual " << outArgsToType(outArgs) << " " << methodName
-                << "(" << argTypeStr << ") = 0;" << endl;
+                << "virtual "
+                << (async ? "void" : outArgsToType(outArgs))
+                << " " << methodName
+                << "("
+                << (async ? "sdbus::Result<" + outArgsToType(outArgs, true) + "> result" + (argTypeStr.empty() ? "" : ", ") : "")
+                << argTypeStr
+                << ") = 0;" << endl;
    }

    return std::make_tuple(registrationSS.str(), declarationSS.str());
--- a/stub-generator/BaseGenerator.cpp
+++ b/stub-generator/BaseGenerator.cpp
@ -108,12 +108,21 @@ std::tuple<std::string, std::string, std::string> BaseGenerator::argsToNamesAndT
 {
    std::ostringstream argSS, argTypeSS, typeSS;

-    bool firstArg{true};
-    for (const auto& arg : args)
+    for (size_t i = 0; i < args.size(); ++i)
    {
-        if (firstArg) firstArg = false; else { argSS << ", "; argTypeSS << ", "; typeSS << ", "; }
+        auto arg = args.at(i);
+        if (i > 0)
+        {
+            argSS << ", ";
+            argTypeSS << ", ";
+            typeSS << ", ";
+        }

        auto argName = arg->get("name");
+        if (argName.empty())
+        {
+            argName = "arg" + std::to_string(i);
+        }
        auto type = signature_to_type(arg->get("type"));
        argSS << argName;
        argTypeSS << "const " << type << "& " << argName;
@ -126,12 +135,15 @@ std::tuple<std::string, std::string, std::string> BaseGenerator::argsToNamesAndT
 /**
 *
 */
-std::string BaseGenerator::outArgsToType(const Nodes& args) const
+std::string BaseGenerator::outArgsToType(const Nodes& args, bool bareList) const
 {
    std::ostringstream retTypeSS;

    if (args.size() == 0)
    {
+        if (bareList)
+            return "";
+
        retTypeSS << "void";
    }
    else if (args.size() == 1)
@ -141,7 +153,8 @@ std::string BaseGenerator::outArgsToType(const Nodes& args) const
    }
    else if (args.size() >= 2)
    {
-        retTypeSS << "std::tuple<";
+        if (!bareList)
+            retTypeSS << "std::tuple<";

        bool firstArg = true;
        for (const auto& arg : args)
@ -150,7 +163,8 @@ std::string BaseGenerator::outArgsToType(const Nodes& args) const
            retTypeSS << signature_to_type(arg->get("type"));
        }

-        retTypeSS << ">";
+        if (!bareList)
+            retTypeSS << ">";
    }

    return retTypeSS.str();
--- a/stub-generator/BaseGenerator.h
+++ b/stub-generator/BaseGenerator.h
@ -94,7 +94,7 @@ protected:
     * @param args
     * @return return type
     */
-    std::string outArgsToType(const sdbuscpp::xml::Nodes& args) const;
+    std::string outArgsToType(const sdbuscpp::xml::Nodes& args, bool bareList = false) const;

 };

--- a/stub-generator/CMakeLists.txt
+++ b/stub-generator/CMakeLists.txt
@ -1,13 +1,41 @@
-cmake_minimum_required (VERSION 3.3)
+#-------------------------------
+# PROJECT INFORMATION
+#-------------------------------

-add_definitions(-std=c++14)
+cmake_minimum_required(VERSION 3.5)

-project (sdbuscpp-xml2cpp)
+project(sdbuscpp-xml2cpp)

-add_executable(${PROJECT_NAME} xml2cpp.cpp xml.cpp generator_utils.cpp BaseGenerator.cpp AdaptorGenerator.cpp ProxyGenerator.cpp)
+include(GNUInstallDirs)

-find_package (EXPAT REQUIRED)
+#-------------------------------
+# PERFORMING CHECKS
+#-------------------------------
+
+find_package(EXPAT REQUIRED)
+
+#-------------------------------
+# SOURCE FILES CONFIGURATION
+#-------------------------------
+
+set(SDBUSCPP_XML2CPP_SRCS xml2cpp.cpp xml.cpp generator_utils.cpp BaseGenerator.cpp AdaptorGenerator.cpp ProxyGenerator.cpp)
+
+#-------------------------------
+# GENERAL COMPILER CONFIGURATION
+#-------------------------------
+
+set(CMAKE_CXX_STANDARD 17)
+
+#----------------------------------
+# EXECUTABLE BUILD INFORMATION
+#----------------------------------
+
+add_executable(${PROJECT_NAME} ${SDBUSCPP_XML2CPP_SRCS})

 target_link_libraries (${PROJECT_NAME} ${EXPAT_LIBRARIES})

-install(TARGETS ${PROJECT_NAME} EXPORT ${PROJECT_NAME} DESTINATION bin)
+#----------------------------------
+# INSTALLATION
+#----------------------------------
+
+install(TARGETS ${PROJECT_NAME} EXPORT ${PROJECT_NAME} DESTINATION ${CMAKE_INSTALL_BINDIR})
--- a/stub-generator/xml.cpp
+++ b/stub-generator/xml.cpp
@ -247,15 +247,15 @@ std::string Document::to_xml() const
 }

 void Document::Expat::start_doctype_decl_handler(
-        void* data,
-        const XML_Char* name,
-        const XML_Char* sysid,
-        const XML_Char *pubid,
-        int has_internal_subset)
+        void* /*data*/,
+        const XML_Char* /*name*/,
+        const XML_Char* /*sysid*/,
+        const XML_Char */*pubid*/,
+        int /*has_internal_subset*/)
 {
 }

-void Document::Expat::end_doctype_decl_handler(void* data)
+void Document::Expat::end_doctype_decl_handler(void* /*data*/)
 {
 }

@ -300,7 +300,7 @@ void Document::Expat::character_data_handler(void* data, const XML_Char* chars,
    nod->cdata = std::string(chars, x, y + 1);
 }

-void Document::Expat::end_element_handler(void* data, const XML_Char* name)
+void Document::Expat::end_element_handler(void* data, const XML_Char* /*name*/)
 {
    Document* doc = static_cast<Document*>(data);

--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@ -0,0 +1,100 @@
+#-------------------------------
+# DOWNLOAD AND BUILD OF GOOGLETEST
+# https://github.com/google/googletest/blob/master/googletest/README.md#incorporating-into-an-existing-cmake-project
+#-------------------------------
+
+configure_file(googletest-download/CMakeLists.txt.in googletest-download/CMakeLists.txt)
+
+execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
+    RESULT_VARIABLE result
+    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download)
+
+if(result)
+    message(FATAL_ERROR "CMake step for googletest failed: ${result}")
+endif()
+
+execute_process(COMMAND ${CMAKE_COMMAND} --build .
+    RESULT_VARIABLE result
+    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download)
+
+if(result)
+    message(FATAL_ERROR "Build step for googletest failed: ${result}")
+endif()
+
+set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+
+add_subdirectory(${CMAKE_CURRENT_BINARY_DIR}/googletest-src
+    ${CMAKE_CURRENT_BINARY_DIR}/googletest-build
+    EXCLUDE_FROM_ALL)
+
+#-------------------------------
+# SOURCE FILES CONFIGURATION
+#-------------------------------
+
+set(UNITTESTS_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/unittests)
+set(UNITTESTS_SRCS
+    ${UNITTESTS_SOURCE_DIR}/libsdbus-c++_unittests.cpp
+    ${UNITTESTS_SOURCE_DIR}/Message_test.cpp
+    ${UNITTESTS_SOURCE_DIR}/Types_test.cpp
+    ${UNITTESTS_SOURCE_DIR}/TypeTraits_test.cpp)
+
+set(INTEGRATIONTESTS_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/integrationtests)
+set(INTEGRATIONTESTS_SRCS
+    ${INTEGRATIONTESTS_SOURCE_DIR}/AdaptorAndProxy_test.cpp
+    ${INTEGRATIONTESTS_SOURCE_DIR}/Connection_test.cpp
+    ${INTEGRATIONTESTS_SOURCE_DIR}/libsdbus-c++_integrationtests.cpp
+    ${INTEGRATIONTESTS_SOURCE_DIR}/adaptor-glue.h
+    ${INTEGRATIONTESTS_SOURCE_DIR}/defs.h
+    ${INTEGRATIONTESTS_SOURCE_DIR}/proxy-glue.h
+    ${INTEGRATIONTESTS_SOURCE_DIR}/TestingAdaptor.h
+    ${INTEGRATIONTESTS_SOURCE_DIR}/TestingProxy.h)
+
+#-------------------------------
+# GENERAL COMPILER CONFIGURATION
+#-------------------------------
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+
+#----------------------------------
+# BUILD INFORMATION
+#----------------------------------
+
+# Turn off -isystem gcc option that CMake uses for imported
+# targets even when INTERFACE_INCLUDE_DIRECTORIES is used.
+set(CMAKE_NO_SYSTEM_FROM_IMPORTED "1")
+
+add_executable(libsdbus-c++_unittests ${UNITTESTS_SRCS} $<TARGET_OBJECTS:sdbuscppobjects>)
+target_link_libraries(libsdbus-c++_unittests ${SYSTEMD_LIBRARIES} gmock gmock_main)
+
+add_executable(libsdbus-c++_integrationtests ${INTEGRATIONTESTS_SRCS})
+target_link_libraries(libsdbus-c++_integrationtests sdbus-c++ gmock gmock_main)
+
+#----------------------------------
+# INSTALLATION
+#----------------------------------
+
+install(TARGETS libsdbus-c++_unittests DESTINATION /opt/test/bin)
+install(TARGETS libsdbus-c++_integrationtests DESTINATION /opt/test/bin)
+install(FILES ${INTEGRATIONTESTS_SOURCE_DIR}/files/libsdbus-cpp-test.conf DESTINATION ${CMAKE_INSTALL_SYSCONFDIR}/dbus-1/system.d)
+
+#----------------------------------
+# RUNNING THE TESTS UPON BUILD
+#----------------------------------
+
+if(CMAKE_CROSSCOMPILING)
+    if(NOT DEFINED UNIT_TESTS_RUNNER)
+        set(UNIT_TESTS_RUNNER $ENV{UNIT_TESTS_RUNNER})
+    endif()
+    if(NOT DEFINED TEST_DEVICE_IP)
+        set(TEST_DEVICE_IP $ENV{TEST_DEVICE_IP})
+    endif()
+
+    if(NOT (UNIT_TESTS_RUNNER AND TEST_DEVICE_IP))
+        message(WARNING "UNIT_TESTS_RUNNER and TEST_DEVICE_IP variables must be defined to run tests remotely")
+    endif()
+    add_test(NAME libsdbus-c++_unittests COMMAND ${UNIT_TESTS_RUNNER} --deviceip=${TEST_DEVICE_IP} --testbin=libsdbus-c++_unittests)
+    add_test(NAME libsdbus-c++_integrationtests COMMAND ${UNIT_TESTS_RUNNER} --deviceip=${TEST_DEVICE_IP} --testbin=libsdbus-c++_integrationtests)
+else()
+    add_test(NAME libsdbus-c++_unittests COMMAND libsdbus-c++_unittests)
+    add_test(NAME libsdbus-c++_integrationtests COMMAND libsdbus-c++_integrationtests)
+endif() 
--- a/test/Makefile.am
+++ b/test/Makefile.am
@ -1,68 +0,0 @@
-# Defines how to build and install libsdbus-c++ tests
-
-AUTOMAKE_OPTIONS = subdir-objects
-
-# Target dirs for test binaries, scripts and files
-testbindir = /opt/test/bin
-dbusconfdir = $(sysconfdir)/dbus-1/system.d
-
-# ENABLE_TESTS is defined by configure when user enables tests during configuration
-if ENABLE_TESTS
-testbin_PROGRAMS = libsdbus-c++_unittests libsdbus-c++_integrationtests
-dbusconf_DATA = integrationtests/files/libsdbus-cpp-test.conf
-endif
-
-# Setting per-file flags
-AM_CPPFLAGS = -I$(top_srcdir)/include -I$(top_srcdir)/src
-AM_CXXFLAGS = @libsdbus_cpp_CFLAGS@ @SYSTEMD_CFLAGS@ -W -Wall -Werror -pedantic -pipe -std=c++14
-AM_LDFLAGS = @libsdbus_cpp_LIBS@ @SYSTEMD_LIBS@
-
-CLEANFILES = *~ *.lo *.la
-MOSTLYCLEANFILES = *.o
-
-TESTS =
-
-# Configuration for libsdbus-c++_unittests
-libsdbus_c___unittests_SOURCES =       \
-unittests/libsdbus-c++_unittests.cpp   \
-unittests/TypeTraits_test.cpp \
-unittests/Types_test.cpp \
-unittests/Message_test.cpp
-
-libsdbus_c___unittests_LDFLAGS = -L$(top_builddir)/src
-
-libsdbus_c___unittests_LDADD = \
-	-lsdbus-c++ \
-	@libsdbus_cpp_LIBS@  \
-	@SYSTEMD_LIBS@ \
-	-lgmock
-
-TESTS += libsdbus-c++_unittests
-
-# Configuration for libsdbus-c++_integrationtests
-libsdbus_c___integrationtests_SOURCES =            \
-integrationtests/libsdbus-c++_integrationtests.cpp \
-integrationtests/Connection_test.cpp \
-integrationtests/AdaptorAndProxy_test.cpp
-
-libsdbus_c___integrationtests_LDFLAGS = -L$(top_builddir)/src
-
-libsdbus_c___integrationtests_LDADD = \
-	-lsdbus-c++ \
-	@libsdbus_cpp_LIBS@  \
-	@SYSTEMD_LIBS@ \
-	-lgmock \
-	-lpthread
-
-TESTS += libsdbus-c++_integrationtests
-
-check_PROGRAMS = libsdbus-c++_unittests libsdbus-c++_integrationtests
-
-DISTCLEANFILES = Makefile Makefile.in
-
-# Post-build action: executing tests from the IDE
-if ENABLE_TESTS
-all-local: libsdbus-c++_unittests libsdbus-c++_integrationtests
-	if [ "${UNIT_TESTS_RUNNER}" ]; then "${UNIT_TESTS_RUNNER}" --deviceip="${TEST_DEVICE_IP}" --testbin=.libs/libsdbus-c++_unittests; fi; exit 0
-	if [ "${UNIT_TESTS_RUNNER}" ]; then "${UNIT_TESTS_RUNNER}" --deviceip="${TEST_DEVICE_IP}" --testbin=.libs/libsdbus-c++_integrationtests; fi; exit 0
-endif
--- a/test/googletest-download/CMakeLists.txt.in
+++ b/test/googletest-download/CMakeLists.txt.in
@ -0,0 +1,17 @@
+# Taken from https://github.com/google/googletest/blob/master/googletest/README.md#incorporating-into-an-existing-cmake-project
+
+cmake_minimum_required(VERSION 2.8.2)
+
+project(googletest-download NONE)
+
+include(ExternalProject)
+
+ExternalProject_Add(googletest
+    GIT_REPOSITORY    https://github.com/google/googletest.git
+    GIT_TAG           master
+    SOURCE_DIR        "${CMAKE_CURRENT_BINARY_DIR}/googletest-src"
+    BINARY_DIR        "${CMAKE_CURRENT_BINARY_DIR}/googletest-build"
+    CONFIGURE_COMMAND ""
+    BUILD_COMMAND     ""
+    INSTALL_COMMAND   ""
+    TEST_COMMAND      "")
--- a/test/integrationtests/AdaptorAndProxy_test.cpp
+++ b/test/integrationtests/AdaptorAndProxy_test.cpp
@ -40,9 +40,12 @@
 #include <string>
 #include <thread>
 #include <tuple>
+#include <chrono>

 using ::testing::Eq;
 using ::testing::Gt;
+using ::testing::ElementsAre;
+using namespace std::chrono_literals;

 namespace
 {
@ -67,7 +70,7 @@ private:
    {
        m_adaptor = std::make_unique<TestingAdaptor>(m_connection);
        m_proxy = std::make_unique<TestingProxy>(INTERFACE_NAME, OBJECT_PATH);
-        usleep(50000); // Give time for the proxy to start listening to signals
+        std::this_thread::sleep_for(50ms); // Give time for the proxy to start listening to signals
    }

    void TearDown() override
@ -197,6 +200,62 @@ TEST_F(SdbusTestObject, CallsMethodWithComplexTypeSuccesfully)
    ASSERT_THAT(resComplex.count(0), Eq(1));
 }

+TEST_F(SdbusTestObject, DoesServerSideAsynchoronousMethodInParallel)
+{
+    // Yeah, this is kinda timing-dependent test, but times should be safe...
+    std::mutex mtx;
+    std::vector<uint32_t> results;
+    std::atomic<bool> invoke{};
+    std::atomic<int> startedCount{};
+    auto call = [&](uint32_t param)
+    {
+        TestingProxy proxy{INTERFACE_NAME, OBJECT_PATH};
+        ++startedCount;
+        while (!invoke) ;
+        auto result = proxy.doOperationAsync(param);
+        std::lock_guard<std::mutex> guard(mtx);
+        results.push_back(result);
+    };
+
+    std::thread invocations[]{std::thread{call, 1500}, std::thread{call, 1000}, std::thread{call, 500}};
+    while (startedCount != 3) ;
+    invoke = true;
+    std::for_each(std::begin(invocations), std::end(invocations), [](auto& t){ t.join(); });
+
+    ASSERT_THAT(results, ElementsAre(500, 1000, 1500));
+}
+
+TEST_F(SdbusTestObject, HandlesCorrectlyABulkOfParallelServerSideAsyncMethods)
+{
+    std::mutex mtx;
+    std::atomic<size_t> resultCount{};
+    std::atomic<bool> invoke{};
+    std::atomic<int> startedCount{};
+    auto call = [&]()
+    {
+        TestingProxy proxy{INTERFACE_NAME, OBJECT_PATH};
+        ++startedCount;
+        while (!invoke) ;
+
+        size_t localResultCount{};
+        for (size_t i = 0; i < 500; ++i)
+        {
+            auto result = proxy.doOperationAsync(i % 2);
+            if (result == (i % 2)) // Correct return value?
+                localResultCount++;
+        }
+
+        resultCount += localResultCount;
+    };
+
+    std::thread invocations[]{std::thread{call}, std::thread{call}, std::thread{call}};
+    while (startedCount != 3) ;
+    invoke = true;
+    std::for_each(std::begin(invocations), std::end(invocations), [](auto& t){ t.join(); });
+
+    ASSERT_THAT(resultCount, Eq(1500));
+}
+
 TEST_F(SdbusTestObject, FailsCallingNonexistentMethod)
 {
    ASSERT_THROW(m_proxy->callNonexistentMethod(), sdbus::Error);
--- a/test/integrationtests/TestingAdaptor.h
+++ b/test/integrationtests/TestingAdaptor.h
@ -27,6 +27,8 @@
 #define SDBUS_CPP_INTEGRATIONTESTS_TESTINGADAPTOR_H_

 #include "adaptor-glue.h"
+#include <thread>
+#include <chrono>

 class TestingAdaptor : public sdbus::Interfaces<testing_adaptor>
 {
@ -97,6 +99,30 @@ protected:
        return res;
    }

+    uint32_t doOperationSync(uint32_t param)
+    {
+        std::this_thread::sleep_for(std::chrono::milliseconds(param));
+        return param;
+    }
+
+    void doOperationAsync(uint32_t param, sdbus::Result<uint32_t> result)
+    {
+        if (param == 0)
+        {
+            // Don't sleep and return the result from this thread
+            result.returnResults(param);
+        }
+        else
+        {
+            // Process asynchronously in another thread and return the result from there
+            std::thread([param, result = std::move(result)]()
+            {
+                std::this_thread::sleep_for(std::chrono::milliseconds(param));
+                result.returnResults(param);
+            }).detach();
+        }
+    }
+
    sdbus::Signature getSignature() const { return SIGNATURE_VALUE; }
    sdbus::ObjectPath getObjectPath() const { return OBJECT_PATH_VALUE; }

--- a/test/integrationtests/adaptor-glue.h
+++ b/test/integrationtests/adaptor-glue.h
@ -82,6 +82,16 @@ protected:
            return this->sumVectorItems(a, b);
        });

+        object_.registerMethod("doOperationSync").onInterface(INTERFACE_NAME).implementedAs([this](uint32_t param)
+        {
+            return this->doOperationSync(param);
+        });
+
+        object_.registerMethod("doOperationAsync").onInterface(INTERFACE_NAME).implementedAs([this](sdbus::Result<uint32_t> result, uint32_t param)
+        {
+            this->doOperationAsync(param, std::move(result));
+        });
+
        object_.registerMethod("getSignature").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getSignature(); });
        object_.registerMethod("getObjectPath").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getObjectPath(); });

@ -139,6 +149,8 @@ protected:
    virtual sdbus::Struct<std::string, sdbus::Struct<std::map<int32_t, int32_t>>> getStructInStruct() const = 0;
    virtual int32_t sumStructItems(const sdbus::Struct<uint8_t, uint16_t>& a, const sdbus::Struct<int32_t, int64_t>& b) = 0;
    virtual uint32_t sumVectorItems(const std::vector<uint16_t>& a, const std::vector<uint64_t>& b) = 0;
+    virtual uint32_t doOperationSync(uint32_t param) = 0;
+    virtual void doOperationAsync(uint32_t param, sdbus::Result<uint32_t> result) = 0;
    virtual sdbus::Signature getSignature() const  = 0;
    virtual sdbus::ObjectPath getObjectPath() const = 0;
    virtual ComplexType getComplex() const = 0;
--- a/test/integrationtests/proxy-glue.h
+++ b/test/integrationtests/proxy-glue.h
@ -120,6 +120,20 @@ public:
        return result;
    }

+    uint32_t doOperationSync(uint32_t param)
+    {
+        uint32_t result;
+        object_.callMethod("doOperationSync").onInterface(INTERFACE_NAME).withArguments(param).storeResultsTo(result);
+        return result;
+    }
+
+    uint32_t doOperationAsync(uint32_t param)
+    {
+        uint32_t result;
+        object_.callMethod("doOperationAsync").onInterface(INTERFACE_NAME).withArguments(param).storeResultsTo(result);
+        return result;
+    }
+
    sdbus::Signature getSignature()
    {
        sdbus::Signature result;
--- a/test/unittests/Message_test.cpp
+++ b/test/unittests/Message_test.cpp
@ -110,13 +110,6 @@ TEST(AMessage, IsNotEmptyWhenContainsAValue)
    ASSERT_FALSE(msg.isEmpty());
 }

-TEST(AMessage, ReturnsItsTypeWhenAsked)
-{
-    sdbus::Message msg{sdbus::createPlainMessage()};
-
-    ASSERT_THAT(msg.getType(), Eq(sdbus::Message::Type::ePlainMessage));
-}
-
 TEST(AMessage, CanCarryASimpleInteger)
 {
    sdbus::Message msg{sdbus::createPlainMessage()};
--- a/test/unittests/TypeTraits_test.cpp
+++ b/test/unittests/TypeTraits_test.cpp
@ -28,6 +28,7 @@
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
 #include <cstdint>
+#include <type_traits>

 using ::testing::Eq;

@ -127,3 +128,42 @@ TYPED_TEST(Type2DBusTypeSignatureConversion, ConvertsTypeToProperDBusSignature)
 {
    ASSERT_THAT(sdbus::signature_of<TypeParam>::str(), Eq(this->dbusTypeSignature_));
 }
+
+TEST(FreeFunctionTypeTraits, DetectsTraitsOfTrivialSignatureFunction)
+{
+    void f();
+    using Fnc = decltype(f);
+
+    static_assert(!sdbus::is_async_method_v<Fnc>, "Free function incorrectly detected as async method");
+    static_assert(std::is_same<sdbus::function_arguments_t<Fnc>, std::tuple<>>::value, "Incorrectly detected free function parameters");
+    static_assert(std::is_same<sdbus::tuple_of_function_input_arg_types_t<Fnc>, std::tuple<>>::value, "Incorrectly detected tuple of free function parameters");
+    static_assert(std::is_same<sdbus::tuple_of_function_output_arg_types_t<Fnc>, void>::value, "Incorrectly detected tuple of free function return types");
+    static_assert(sdbus::function_argument_count_v<Fnc> == 0, "Incorrectly detected free function parameter count");
+    static_assert(std::is_void<sdbus::function_result_t<Fnc>>::value, "Incorrectly detected free function return type");
+}
+
+TEST(FreeFunctionTypeTraits, DetectsTraitsOfNontrivialSignatureFunction)
+{
+    std::tuple<char, int> f(double&, const char*, int);
+    using Fnc = decltype(f);
+
+    static_assert(!sdbus::is_async_method_v<Fnc>, "Free function incorrectly detected as async method");
+    static_assert(std::is_same<sdbus::function_arguments_t<Fnc>, std::tuple<double&, const char*, int>>::value, "Incorrectly detected free function parameters");
+    static_assert(std::is_same<sdbus::tuple_of_function_input_arg_types_t<Fnc>, std::tuple<double, const char*, int>>::value, "Incorrectly detected tuple of free function parameters");
+    static_assert(std::is_same<sdbus::tuple_of_function_output_arg_types_t<Fnc>, std::tuple<char, int>>::value, "Incorrectly detected tuple of free function return types");
+    static_assert(sdbus::function_argument_count_v<Fnc> == 3, "Incorrectly detected free function parameter count");
+    static_assert(std::is_same<sdbus::function_result_t<Fnc>, std::tuple<char, int>>::value, "Incorrectly detected free function return type");
+}
+
+TEST(FreeFunctionTypeTraits, DetectsTraitsOfAsyncFunction)
+{
+    void f(sdbus::Result<char, int>, double&, const char*, int);
+    using Fnc = decltype(f);
+
+    static_assert(sdbus::is_async_method_v<Fnc>, "Free async function incorrectly detected as sync method");
+    static_assert(std::is_same<sdbus::function_arguments_t<Fnc>, std::tuple<double&, const char*, int>>::value, "Incorrectly detected free function parameters");
+    static_assert(std::is_same<sdbus::tuple_of_function_input_arg_types_t<Fnc>, std::tuple<double, const char*, int>>::value, "Incorrectly detected tuple of free function parameters");
+    static_assert(std::is_same<sdbus::tuple_of_function_output_arg_types_t<Fnc>, std::tuple<char, int>>::value, "Incorrectly detected tuple of free function return types");
+    static_assert(sdbus::function_argument_count_v<Fnc> == 3, "Incorrectly detected free function parameter count");
+    static_assert(std::is_same<sdbus::function_result_t<Fnc>, std::tuple<char, int>>::value, "Incorrectly detected free function return type");
+}
Author	SHA1	Message	Date
Stanislav Angelovič	97372155a6	Update ChangeLog for v0.3.3	2018-12-29 01:02:36 +01:00
Stanislav Angelovič	1def4e247a	Add note on thread-safety of Variant and its const methods	2018-12-29 00:59:31 +01:00
Stanislav Angelovič	d764afec93	Little fixes in tutorial code samples Fixes #24	2018-12-24 15:43:01 +01:00
Jeremy Prater	eb58d2fa52	- Rewind Message prior to access for peekValueType. Fixes #8 (cherry picked from commit f8bed4b0faa2c0a2bc7037f3a55105060d56dbdb)	2018-12-24 15:30:55 +01:00
Stanislav Angelovič	a6bb8c070e	Switch from autotools to CMake build system (#23 ) * Switch from autotools to CMake * CMake: require at least cmake 3.8 * cmake: updates for tests	2018-09-26 09:28:10 +02:00
Lukas Durfina	108c33faac	stub-generator: fixed issue when <arg> in <method> does not have "name" property	2018-08-24 16:39:31 +02:00
sangelovic	ec06462713	Add missing constructor overload for ProxyInterfaces	2018-08-06 22:58:36 +02:00
Stanislav Angelovič	234145cade	Clarify proxy and connection stuff in case of ProxyInterfaces	2018-08-06 22:52:38 +02:00
Stanislav Angelovič	e971f95bad	Clarify system/session connection on proxy creation	2018-08-06 22:34:08 +02:00
Lukas Durfina	4f5dfbc301	Updated changelog for v0.3.1	2018-07-24 13:03:53 +02:00
Stanislav Angelovič	fa878e594c	Be explicit on apply function from sdbus namespace (#17 )	2018-07-24 12:55:33 +02:00
Stanislav Angelovič	d3d698f02a	Fix CPU hog on async methods: Clear the event descriptor by reading from it (#16 )	2018-07-24 12:54:31 +02:00
Stanislav Angelovič	d8fd053714	Introduce support for asynchronous server-side methods (#12 ) * Add preliminary changes for async server methods * Refactor the Message concept and break it into distinctive types * Continue working on async server methods (high-level API mainly) * Continue developing support for async server * Finishing async server methods * Finishing async server methods (fixing tests & cleaning up) * A little code cleaning * Add unit tests for type traits of free functions * Support for generating async server methods in stub headers * Update ChangeLog for v0.3.0 * Update the tutorial with how to use async server-side methods * Update the TOC in sdbus-c++ tutorial * Update numbering in TOC * Remove unnecessary code * Final cleanups	2018-07-02 11:22:00 +02:00
Stanislav Angelovic	b041f76bfc	Update changelog for v0.2.6	2018-06-24 21:27:58 +02:00
Stanislav Angelovic	f1ff05cb6f	Bump up micro revision number	2018-06-22 12:36:14 +02:00
Stanislav Angelovič	44be60555d	Merge pull request #11 from lukasdurfina/fix-memory-leak Fix leak in Message due to missing unref of sd_bus_message	2018-06-19 12:18:55 +02:00
Lukas Durfina	dfdc6b153e	Message: fix missing release of sd_bus_message	2018-06-19 08:56:28 +02:00