chore: format code

Add .clang-format. Format code that has been modified by commit
e6423c5.

Log: format code
Influence: e6423c5

.clang-format

@@ -0,0 +1,196 @@
+---
+# 语言: None, Cpp, Java, JavaScript, ObjC, Proto, TableGen, TextProto
+Language: Cpp
+# BasedOnStyle: LLVM
+# 访问说明符(public、private等)的偏移
+AccessModifierOffset: -4
+# 开括号(开圆括号、开尖括号、开方括号)后的对齐: Align, DontAlign, AlwaysBreak(总是在开括号后换行)
+AlignAfterOpenBracket: Align
+# 连续赋值时，对齐所有等号
+AlignConsecutiveAssignments: None
+# 连续声明时，对齐所有声明的变量名
+AlignConsecutiveDeclarations: None
+
+AlignEscapedNewlines: Right
+
+# 左对齐逃脱换行(使用反斜杠换行)的反斜杠
+#AlignEscapedNewlinesLeft: true
+# 水平对齐二元和三元表达式的操作数
+AlignOperands: true
+# 对齐连续的尾随的注释
+AlignTrailingComments: true
+
+# 允许函数声明的所有参数在放在下一行
+AllowAllParametersOfDeclarationOnNextLine: true
+# 允许短的块放在同一行
+AllowShortBlocksOnASingleLine: Empty
+# 允许短的case标签放在同一行
+AllowShortCaseLabelsOnASingleLine: false
+# 允许短的函数放在同一行: None, InlineOnly(定义在类中), Empty(空函数), Inline(定义在类中，空函数), All
+AllowShortFunctionsOnASingleLine: Inline
+# 允许短的if语句保持在同一行
+AllowShortIfStatementsOnASingleLine: false
+# 允许短的循环保持在同一行
+AllowShortLoopsOnASingleLine: false
+
+# 总是在定义返回类型后换行(deprecated)
+AlwaysBreakAfterDefinitionReturnType: None
+# 总是在返回类型后换行: None, All, TopLevel(顶级函数，不包括在类中的函数),
+# AllDefinitions(所有的定义，不包括声明), TopLevelDefinitions(所有的顶级函数的定义)
+AlwaysBreakAfterReturnType: None
+# 总是在多行string字面量前换行
+AlwaysBreakBeforeMultilineStrings: false
+# 总是在template声明后换行
+AlwaysBreakTemplateDeclarations: Yes
+# false表示函数实参要么都在同一行，要么都各自一行
+BinPackArguments: false
+# false表示所有形参要么都在同一行，要么都各自一行
+BinPackParameters: false
+# 大括号换行，只有当BreakBeforeBraces设置为Custom时才有效
+BraceWrapping:
+  # class定义后面
+  AfterClass: true
+  # 控制语句后面
+  AfterControlStatement: Never
+  # enum定义后面
+  AfterEnum: false
+  # 函数定义后面
+  AfterFunction: true
+  # 命名空间定义后面
+  AfterNamespace: false
+  # ObjC定义后面
+  AfterObjCDeclaration: false
+  # struct定义后面
+  AfterStruct: true
+  # union定义后面
+  AfterUnion: true
+
+  AfterExternBlock: false
+  # catch之前
+  BeforeCatch: false
+  # else之前
+  BeforeElse: false
+  # 缩进大括号
+  IndentBraces: false
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+
+# 在二元运算符前换行: None(在操作符后换行), NonAssignment(在非赋值的操作符前换行), All(在操作符前换行)
+BreakBeforeBinaryOperators: None
+# 在大括号前换行: Attach(始终将大括号附加到周围的上下文), Linux(除函数、命名空间和类定义，与Attach类似),
+#   Mozilla(除枚举、函数、记录定义，与Attach类似), Stroustrup(除函数定义、catch、else，与Attach类似),
+#   Allman(总是在大括号前换行), GNU(总是在大括号前换行，并对于控制语句的大括号增加额外的缩进), WebKit(在函数前换行), Custom
+#   注：这里认为语句块也属于函数
+BreakBeforeBraces: Custom
+# 在三元运算符前换行
+BreakBeforeTernaryOperators: false
+
+# 在构造函数的初始化列表的逗号前换行
+BreakConstructorInitializersBeforeComma: true
+BreakConstructorInitializers: BeforeColon
+# 每行字符的限制，0表示没有限制
+ColumnLimit: 130
+# 描述具有特殊意义的注释的正则表达式，它不应该被分割为多行或以其它方式改变
+CommentPragmas: '^ IWYU pragma:'
+CompactNamespaces: false
+# 构造函数的初始化列表要么都在同一行，要么都各自一行
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+# 构造函数的初始化列表的缩进宽度
+ConstructorInitializerIndentWidth: 4
+# 延续的行的缩进宽度
+ContinuationIndentWidth: 4
+# 去除C++11的列表初始化的大括号{后和}前的空格
+Cpp11BracedListStyle: true
+# 继承最常用的指针和引用的对齐方式
+DerivePointerAlignment: false
+# 关闭格式化
+DisableFormat: false
+# 自动检测函数的调用和定义是否被格式为每行一个参数(Experimental)
+ExperimentalAutoDetectBinPacking: false
+# 需要被解读为foreach循环而不是函数调用的宏
+ForEachMacros: [ foreach, Q_FOREACH, BOOST_FOREACH ]
+# 对#include进行排序，匹配了某正则表达式的#include拥有对应的优先级，匹配不到的则默认优先级为INT_MAX(优先级越小排序越靠前)，
+#   可以定义负数优先级从而保证某些#include永远在最前面
+IncludeCategories:
+  - Regex: '^"(llvm|llvm-c|clang|clang-c)/'
+    Priority: 2
+  - Regex: '^(<|"(gtest|isl|json)/)'
+    Priority: 3
+  - Regex: '.*'
+    Priority: 1
+# 缩进case标签
+IndentCaseLabels: true
+
+#IndentPPDirectives:  AfterHash
+# 缩进宽度
+IndentWidth: 4
+# 函数返回类型换行时，缩进函数声明或函数定义的函数名
+IndentWrappedFunctionNames: false
+# 保留在块开始处的空行
+KeepEmptyLinesAtTheStartOfBlocks: false
+# 开始一个块的宏的正则表达式
+MacroBlockBegin: ''
+# 结束一个块的宏的正则表达式
+MacroBlockEnd: ''
+# 连续空行的最大数量
+MaxEmptyLinesToKeep: 1
+# 命名空间的缩进: None, Inner(缩进嵌套的命名空间中的内容), All
+NamespaceIndentation: Inner
+# 使用ObjC块时缩进宽度
+ObjCBlockIndentWidth: 4
+# 在ObjC的@property后添加一个空格
+ObjCSpaceAfterProperty: false
+# 在ObjC的protocol列表前添加一个空格
+ObjCSpaceBeforeProtocolList: true
+
+
+# 在call(后对函数调用换行的penalty
+PenaltyBreakBeforeFirstCallParameter: 19
+# 在一个注释中引入换行的penalty
+PenaltyBreakComment: 300
+# 第一次在<<前换行的penalty
+PenaltyBreakFirstLessLess: 120
+# 在一个字符串字面量中引入换行的penalty
+PenaltyBreakString: 1000
+# 对于每个在行字符数限制之外的字符的penalty
+PenaltyExcessCharacter: 1000000
+# 将函数的返回类型放到它自己的行的penalty
+PenaltyReturnTypeOnItsOwnLine: 60
+
+# 指针和引用的对齐: Left, Right, Middle
+PointerAlignment: Right
+# 允许重新排版注释
+ReflowComments: true
+# 允许排序#include
+SortIncludes: Never
+
+# 在C风格类型转换后添加空格
+SpaceAfterCStyleCast: false
+
+SpaceAfterTemplateKeyword: true
+
+# 在赋值运算符之前添加空格
+SpaceBeforeAssignmentOperators: true
+# 开圆括号之前添加一个空格: Never, ControlStatements, Always
+SpaceBeforeParens: ControlStatements
+# 在空的圆括号中添加空格
+SpaceInEmptyParentheses: false
+# 在尾随的评论前添加的空格数(只适用于//)
+SpacesBeforeTrailingComments: 2
+# 在尖括号的<后和>前添加空格
+SpacesInAngles: false
+# 在容器(ObjC和JavaScript的数组和字典等)字面量中添加空格
+SpacesInContainerLiterals: false
+# 在C风格类型转换的括号中添加空格
+SpacesInCStyleCastParentheses: false
+# 在圆括号的(后和)前添加空格
+SpacesInParentheses: false
+# 在方括号的[后和]前添加空格，lamda表达式和未指明大小的数组的声明不受影响
+SpacesInSquareBrackets: false
+# 标准: Cpp03, Cpp11, Auto
+Standard: Auto
+# tab宽度
+TabWidth: 4
+# 使用tab字符: Never, ForIndentation, ForContinuationAndIndentation, Always
+UseTab: Never

.reuse/dep5

@@ -20,7 +20,7 @@ Copyright: None
 License: CC0-1.0
 
 # config
-Files: *.toml *.conf *.json
+Files: *.toml *.conf *.json .clang-format
 Copyright: None
 License: CC0-1.0
 

include/util/ddbusextendedabstractinterface.h

@@ -13,73 +13,68 @@ DCORE_BEGIN_NAMESPACE
 
 class DDBusExtendedPendingCallWatcher;
 
-class LIBDTKCORESHARED_EXPORT DDBusExtendedAbstractInterface
+class LIBDTKCORESHARED_EXPORT DDBusExtendedAbstractInterface : public QDBusAbstractInterface
-    : public QDBusAbstractInterface {
+{
-  Q_OBJECT
+    Q_OBJECT
 
 public:
-  virtual ~DDBusExtendedAbstractInterface();
+    virtual ~DDBusExtendedAbstractInterface();
 
-  Q_PROPERTY(bool sync READ sync WRITE setSync)
+    Q_PROPERTY(bool sync READ sync WRITE setSync)
-  inline bool sync() const { return m_sync; }
+    inline bool sync() const { return m_sync; }
-  void setSync(bool sync);
+    void setSync(bool sync);
-  void setSync(bool sync, bool autoStart);
+    void setSync(bool sync, bool autoStart);
 
-  Q_PROPERTY(bool useCache READ useCache WRITE setUseCache)
+    Q_PROPERTY(bool useCache READ useCache WRITE setUseCache)
-  inline bool useCache() const { return m_useCache; }
+    inline bool useCache() const { return m_useCache; }
-  inline void setUseCache(bool useCache) { m_useCache = useCache; }
+    inline void setUseCache(bool useCache) { m_useCache = useCache; }
 
-  void getAllProperties();
+    void getAllProperties();
-  inline QDBusError lastExtendedError() const { return m_lastExtendedError; }
+    inline QDBusError lastExtendedError() const { return m_lastExtendedError; }
 
 public Q_SLOTS:
-  void startServiceProcess();
+    void startServiceProcess();
 
 protected:
-  DDBusExtendedAbstractInterface(const QString &service, const QString &path,
+    DDBusExtendedAbstractInterface(
-                                 const char *interface,
+        const QString &service, const QString &path, const char *interface, const QDBusConnection &connection, QObject *parent);
-                                 const QDBusConnection &connection,
-                                 QObject *parent);
 
-  void connectNotify(const QMetaMethod &signal);
+    void connectNotify(const QMetaMethod &signal);
-  void disconnectNotify(const QMetaMethod &signal);
+    void disconnectNotify(const QMetaMethod &signal);
-  QVariant internalPropGet(const char *propname, void *propertyPtr);
+    QVariant internalPropGet(const char *propname, void *propertyPtr);
-  void internalPropSet(const char *propname, const QVariant &value,
+    void internalPropSet(const char *propname, const QVariant &value, void *propertyPtr);
-                       void *propertyPtr);
 
 Q_SIGNALS:
-  void serviceValidChanged(const bool valid) const;
+    void serviceValidChanged(const bool valid) const;
-  void serviceStartFinished(const quint32 ret) const;
+    void serviceStartFinished(const quint32 ret) const;
-  void propertyChanged(const QString &propertyName, const QVariant &value);
+    void propertyChanged(const QString &propertyName, const QVariant &value);
-  void propertyInvalidated(const QString &propertyName);
+    void propertyInvalidated(const QString &propertyName);
-  void asyncPropertyFinished(const QString &propertyName);
+    void asyncPropertyFinished(const QString &propertyName);
-  void asyncSetPropertyFinished(const QString &propertyName);
+    void asyncSetPropertyFinished(const QString &propertyName);
-  void asyncGetAllPropertiesFinished();
+    void asyncGetAllPropertiesFinished();
 
 private Q_SLOTS:
-  void onPropertiesChanged(const QString &interfaceName,
+    void onPropertiesChanged(const QString &interfaceName,
-                           const QVariantMap &changedProperties,
+                             const QVariantMap &changedProperties,
-                           const QStringList &invalidatedProperties);
+                             const QStringList &invalidatedProperties);
-  void onDBusNameOwnerChanged(const QString &name, const QString &oldOwner,
+    void onDBusNameOwnerChanged(const QString &name, const QString &oldOwner, const QString &newOwner);
-                              const QString &newOwner);
+    void onAsyncPropertyFinished(QDBusPendingCallWatcher *w);
-  void onAsyncPropertyFinished(QDBusPendingCallWatcher *w);
+    void onAsyncSetPropertyFinished(QDBusPendingCallWatcher *w);
-  void onAsyncSetPropertyFinished(QDBusPendingCallWatcher *w);
+    void onAsyncGetAllPropertiesFinished(QDBusPendingCallWatcher *watcher);
-  void onAsyncGetAllPropertiesFinished(QDBusPendingCallWatcher *watcher);
+    void onStartServiceProcessFinished(QDBusPendingCallWatcher *w);
-  void onStartServiceProcessFinished(QDBusPendingCallWatcher *w);
 
 private:
-  QVariant asyncProperty(const QString &propertyName);
+    QVariant asyncProperty(const QString &propertyName);
-  void asyncSetProperty(const QString &propertyName, const QVariant &value);
+    void asyncSetProperty(const QString &propertyName, const QVariant &value);
-  static QVariant demarshall(const QString &interface,
+    static QVariant
-                             const QMetaProperty &metaProperty,
+    demarshall(const QString &interface, const QMetaProperty &metaProperty, const QVariant &value, QDBusError *error);
-                             const QVariant &value, QDBusError *error);
 
-  bool m_sync;
+    bool m_sync;
-  bool m_useCache;
+    bool m_useCache;
-  QDBusPendingCallWatcher *m_getAllPendingCallWatcher;
+    QDBusPendingCallWatcher *m_getAllPendingCallWatcher;
-  QDBusError m_lastExtendedError;
+    QDBusError m_lastExtendedError;
-  QString m_dbusOwner;
+    QString m_dbusOwner;
-  bool m_propertiesChangedConnected;
+    bool m_propertiesChangedConnected;
 };
 DCORE_END_NAMESPACE
 

src/util/ddbusextendedabstractinterface.cpp

@@ -18,31 +18,34 @@
 DCORE_BEGIN_NAMESPACE
 
 Q_GLOBAL_STATIC_WITH_ARGS(QByteArray, dBusInterface, ("org.freedesktop.DBus"))
-Q_GLOBAL_STATIC_WITH_ARGS(QByteArray, dBusPropertiesInterface,
+Q_GLOBAL_STATIC_WITH_ARGS(QByteArray, dBusPropertiesInterface, ("org.freedesktop.DBus.Properties"))
-                          ("org.freedesktop.DBus.Properties"))
+Q_GLOBAL_STATIC_WITH_ARGS(QByteArray, dBusPropertiesChangedSignal, ("PropertiesChanged"))
-Q_GLOBAL_STATIC_WITH_ARGS(QByteArray, dBusPropertiesChangedSignal,
+Q_GLOBAL_STATIC_WITH_ARGS(QByteArray, propertyChangedSignature, ("propertyChanged(QString,QVariant)"))
-                          ("PropertiesChanged"))
+Q_GLOBAL_STATIC_WITH_ARGS(QByteArray, propertyInvalidatedSignature, ("propertyInvalidated(QString)"))
-Q_GLOBAL_STATIC_WITH_ARGS(QByteArray, propertyChangedSignature,
-                          ("propertyChanged(QString,QVariant)"))
-Q_GLOBAL_STATIC_WITH_ARGS(QByteArray, propertyInvalidatedSignature,
-                          ("propertyInvalidated(QString)"))
 
 DDBusExtendedAbstractInterface::DDBusExtendedAbstractInterface(
-    const QString &service, const QString &path, const char *interface,
+    const QString &service, const QString &path, const char *interface, const QDBusConnection &connection, QObject *parent)
-    const QDBusConnection &connection, QObject *parent)
+    : QDBusAbstractInterface(service, path, interface, connection, parent)
-    : QDBusAbstractInterface(service, path, interface, connection, parent),
+    , m_sync(true)
-      m_sync(true), m_useCache(false), m_getAllPendingCallWatcher(0),
+    , m_useCache(false)
-      m_propertiesChangedConnected(false) {
+    , m_getAllPendingCallWatcher(0)
-  const_cast<QDBusConnection &>(connection)
+    , m_propertiesChangedConnected(false)
-      .connect(QString("org.freedesktop.DBus"),
+{
-               QString("/org/freedesktop/DBus"),
+    const_cast<QDBusConnection &>(connection)
-               QString("org.freedesktop.DBus"), QString("NameOwnerChanged"),
+        .connect(QString("org.freedesktop.DBus"),
-               this, SLOT(onDBusNameOwnerChanged(QString, QString, QString)));
+                 QString("/org/freedesktop/DBus"),
+                 QString("org.freedesktop.DBus"),
+                 QString("NameOwnerChanged"),
+                 this,
+                 SLOT(onDBusNameOwnerChanged(QString, QString, QString)));
 }
 
 DDBusExtendedAbstractInterface::~DDBusExtendedAbstractInterface() {}
 
-void DDBusExtendedAbstractInterface::setSync(bool sync) { setSync(sync, true); }
+void DDBusExtendedAbstractInterface::setSync(bool sync)
+{
+    setSync(sync, true);
+}
 
 /*
  * @~english
@@ -51,485 +54,455 @@ void DDBusExtendedAbstractInterface::setSync(bool sync) { setSync(sync, true); }
  * through the changed signal when you get an property, and it's also a good
  * idea to save a cache yourself.
  */
-void DDBusExtendedAbstractInterface::setSync(bool sync, bool autoStart) {
+void DDBusExtendedAbstractInterface::setSync(bool sync, bool autoStart)
-  m_sync = sync;
+{
+    m_sync = sync;
 
-  // init all properties
+    // init all properties
-  if (autoStart && !m_sync && !isValid())
+    if (autoStart && !m_sync && !isValid())
-    startServiceProcess();
+        startServiceProcess();
 }
 
-void DDBusExtendedAbstractInterface::getAllProperties() {
+void DDBusExtendedAbstractInterface::getAllProperties()
-  m_lastExtendedError = QDBusError();
+{
-
-  if (!isValid()) {
-    QString errorMessage =
-        QStringLiteral("This Extended DBus interface is not valid yet.");
-    m_lastExtendedError =
-        QDBusMessage::createError(QDBusError::Failed, errorMessage);
-    qDebug() << Q_FUNC_INFO << errorMessage;
-    return;
-  }
-
-  if (!m_sync && m_getAllPendingCallWatcher) {
-    // Call already in place, not repeating ...
-    return;
-  }
-
-  QDBusMessage msg = QDBusMessage::createMethodCall(
-      service(), path(), *dBusPropertiesInterface(), QStringLiteral("GetAll"));
-  msg << interface();
-
-  if (m_sync) {
-    QDBusMessage reply = connection().call(msg);
-
-    if (reply.type() != QDBusMessage::ReplyMessage) {
-      m_lastExtendedError = QDBusError(reply);
-      qWarning() << Q_FUNC_INFO << m_lastExtendedError.message();
-      return;
-    }
-
-    if (reply.signature() != QLatin1String("a{sv}")) {
-      QString errorMessage =
-          QStringLiteral("Invalid signature \"%1\" in return from call to %2")
-              .arg(reply.signature(), QString(*dBusPropertiesInterface()));
-      qWarning() << Q_FUNC_INFO << errorMessage;
-      m_lastExtendedError =
-          QDBusError(QDBusError::InvalidSignature, errorMessage);
-      return;
-    }
-
-    QVariantMap value = reply.arguments().at(0).toMap();
-    onPropertiesChanged(interface(), value, QStringList());
-  } else {
-    QDBusPendingReply<QVariantMap> async = connection().asyncCall(msg);
-    m_getAllPendingCallWatcher = new QDBusPendingCallWatcher(async, this);
-
-    connect(m_getAllPendingCallWatcher,
-            SIGNAL(finished(QDBusPendingCallWatcher *)), this,
-            SLOT(onAsyncGetAllPropertiesFinished(QDBusPendingCallWatcher *)));
-    return;
-  }
-}
-
-void DDBusExtendedAbstractInterface::connectNotify(const QMetaMethod &signal) {
-  if (signal.methodType() == QMetaMethod::Signal &&
-      (signal.methodSignature() == *propertyChangedSignature() ||
-       signal.methodSignature() == *propertyInvalidatedSignature())) {
-    if (!m_propertiesChangedConnected) {
-      QStringList argumentMatch;
-      argumentMatch << interface();
-      connection().connect(
-          service(), path(), *dBusPropertiesInterface(),
-          *dBusPropertiesChangedSignal(), argumentMatch, QString(), this,
-          SLOT(onPropertiesChanged(QString, QVariantMap, QStringList)));
-
-      m_propertiesChangedConnected = true;
-      return;
-    }
-  } else {
-    QDBusAbstractInterface::connectNotify(signal);
-  }
-}
-
-void DDBusExtendedAbstractInterface::disconnectNotify(
-    const QMetaMethod &signal) {
-  if (signal.methodType() == QMetaMethod::Signal &&
-      (signal.methodSignature() == *propertyChangedSignature() ||
-       signal.methodSignature() == *propertyInvalidatedSignature())) {
-    if (m_propertiesChangedConnected &&
-        0 == receivers(propertyChangedSignature()->constData()) &&
-        0 == receivers(propertyInvalidatedSignature()->constData())) {
-      QStringList argumentMatch;
-      argumentMatch << interface();
-      connection().disconnect(
-          service(), path(), *dBusPropertiesInterface(),
-          *dBusPropertiesChangedSignal(), argumentMatch, QString(), this,
-          SLOT(onPropertiesChanged(QString, QVariantMap, QStringList)));
-
-      m_propertiesChangedConnected = false;
-      return;
-    }
-  } else {
-    QDBusAbstractInterface::disconnectNotify(signal);
-  }
-}
-
-QVariant DDBusExtendedAbstractInterface::internalPropGet(const char *propname,
-                                                         void *propertyPtr) {
-  m_lastExtendedError = QDBusError();
-
-  if (m_useCache) {
-    int propertyIndex = metaObject()->indexOfProperty(propname);
-    QMetaProperty metaProperty = metaObject()->property(propertyIndex);
-    return QVariant(metaProperty.userType(), propertyPtr);
-  }
-
-  if (m_sync) {
-    QVariant ret = property(propname);
-
-    QMetaType::construct(ret.userType(), propertyPtr, ret.constData());
-
-    return ret;
-  } else {
-    if (!isValid()) {
-      QString errorMessage =
-          QStringLiteral("This Extended DBus interface is not valid yet.");
-      m_lastExtendedError =
-          QDBusMessage::createError(QDBusError::Failed, errorMessage);
-      qDebug() << Q_FUNC_INFO << errorMessage;
-      return QVariant();
-    }
-
-    int propertyIndex = metaObject()->indexOfProperty(propname);
-
-    if (-1 == propertyIndex) {
-      QString errorMessage =
-          QStringLiteral("Got unknown property \"%1\" to read")
-              .arg(QString::fromLatin1(propname));
-      m_lastExtendedError =
-          QDBusMessage::createError(QDBusError::Failed, errorMessage);
-      qWarning() << Q_FUNC_INFO << errorMessage;
-      return QVariant();
-    }
-
-    QMetaProperty metaProperty = metaObject()->property(propertyIndex);
-
-    if (!metaProperty.isReadable()) {
-      QString errorMessage = QStringLiteral("Property \"%1\" is NOT readable")
-                                 .arg(QString::fromLatin1(propname));
-      m_lastExtendedError =
-          QDBusMessage::createError(QDBusError::Failed, errorMessage);
-      qWarning() << Q_FUNC_INFO << errorMessage;
-      return QVariant();
-    }
-
-    // is this metatype registered?
-    const char *expectedSignature = "";
-    if (int(metaProperty.type()) != QMetaType::QVariant) {
-      expectedSignature =
-          QDBusMetaType::typeToSignature(metaProperty.userType());
-      if (0 == expectedSignature) {
-        QString errorMessage =
-            QStringLiteral("Type %1 must be registered with Qt D-Bus "
-                           "before it can be used to read property "
-                           "%2.%3")
-                .arg(metaProperty.typeName(), interface(), propname);
-        m_lastExtendedError =
-            QDBusMessage::createError(QDBusError::Failed, errorMessage);
-        qWarning() << Q_FUNC_INFO << errorMessage;
-        return QVariant();
-      }
-    }
-
-    asyncProperty(propname);
-    return QVariant(metaProperty.userType(), propertyPtr);
-  }
-}
-
-void DDBusExtendedAbstractInterface::internalPropSet(const char *propname,
-                                                     const QVariant &value,
-                                                     void *propertyPtr) {
-  m_lastExtendedError = QDBusError();
-
-  if (m_sync) {
-    setProperty(propname, value);
-  } else {
-    if (!isValid()) {
-      QString errorMessage = QStringLiteral("This interface is not yet valid");
-      m_lastExtendedError =
-          QDBusMessage::createError(QDBusError::Failed, errorMessage);
-      qDebug() << Q_FUNC_INFO << errorMessage;
-      return;
-    }
-
-    int propertyIndex = metaObject()->indexOfProperty(propname);
-
-    if (-1 == propertyIndex) {
-      QString errorMessage =
-          QStringLiteral("Got unknown property \"%1\" to write")
-              .arg(QString::fromLatin1(propname));
-      m_lastExtendedError =
-          QDBusMessage::createError(QDBusError::Failed, errorMessage);
-      qWarning() << Q_FUNC_INFO << errorMessage;
-      return;
-    }
-
-    QMetaProperty metaProperty = metaObject()->property(propertyIndex);
-
-    if (!metaProperty.isWritable()) {
-      QString errorMessage = QStringLiteral("Property \"%1\" is NOT writable")
-                                 .arg(QString::fromLatin1(propname));
-      m_lastExtendedError =
-          QDBusMessage::createError(QDBusError::Failed, errorMessage);
-      qWarning() << Q_FUNC_INFO << errorMessage;
-      return;
-    }
-
-    QVariant variant = QVariant(metaProperty.type(), propertyPtr);
-    variant = value;
-
-    asyncSetProperty(propname, variant);
-  }
-}
-
-QVariant
-DDBusExtendedAbstractInterface::asyncProperty(const QString &propertyName) {
-  QDBusMessage msg = QDBusMessage::createMethodCall(
-      service(), path(), *dBusPropertiesInterface(), QStringLiteral("Get"));
-  msg << interface() << propertyName;
-  QDBusPendingReply<QVariant> async = connection().asyncCall(msg);
-  DDBusExtendedPendingCallWatcher *watcher =
-      new DDBusExtendedPendingCallWatcher(async, propertyName, QVariant(),
-                                          this);
-
-  connect(watcher, SIGNAL(finished(QDBusPendingCallWatcher *)), this,
-          SLOT(onAsyncPropertyFinished(QDBusPendingCallWatcher *)));
-
-  return QVariant();
-}
-
-void DDBusExtendedAbstractInterface::asyncSetProperty(
-    const QString &propertyName, const QVariant &value) {
-  QDBusMessage msg = QDBusMessage::createMethodCall(
-      service(), path(), *dBusPropertiesInterface(), QStringLiteral("Set"));
-
-  msg << interface() << propertyName
-      << QVariant::fromValue(QDBusVariant(value));
-  QDBusPendingReply<> async = connection().asyncCall(msg);
-  DDBusExtendedPendingCallWatcher *watcher =
-      new DDBusExtendedPendingCallWatcher(async, propertyName, value, this);
-
-  connect(watcher, SIGNAL(finished(QDBusPendingCallWatcher *)), this,
-          SLOT(onAsyncSetPropertyFinished(QDBusPendingCallWatcher *)));
-}
-
-void DDBusExtendedAbstractInterface::startServiceProcess() {
-  const QString &servName = service();
-
-  if (isValid()) {
-    qWarning() << "Service" << servName << "is already started.";
-    return;
-  }
-
-  QDBusMessage msg = QDBusMessage::createMethodCall(
-      "org.freedesktop.DBus", "/", *dBusInterface(),
-      QStringLiteral("StartServiceByName"));
-  msg << servName << quint32(0);
-  QDBusPendingReply<quint32> async = connection().asyncCall(msg);
-  QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(async, this);
-
-  connect(watcher, &QDBusPendingCallWatcher::finished, this,
-          &DDBusExtendedAbstractInterface::onStartServiceProcessFinished);
-}
-
-void DDBusExtendedAbstractInterface::onStartServiceProcessFinished(
-    QDBusPendingCallWatcher *w) {
-  if (w->isError()) {
-    m_lastExtendedError = w->error();
-  } else {
     m_lastExtendedError = QDBusError();
-  }
 
-  QDBusPendingReply<quint32> reply = *w;
+    if (!isValid()) {
+        QString errorMessage = QStringLiteral("This Extended DBus interface is not valid yet.");
+        m_lastExtendedError = QDBusMessage::createError(QDBusError::Failed, errorMessage);
+        qDebug() << Q_FUNC_INFO << errorMessage;
+        return;
+    }
 
-  Q_EMIT serviceStartFinished(reply.value());
+    if (!m_sync && m_getAllPendingCallWatcher) {
+        // Call already in place, not repeating ...
+        return;
+    }
 
-  w->deleteLater();
+    QDBusMessage msg = QDBusMessage::createMethodCall(service(), path(), *dBusPropertiesInterface(), QStringLiteral("GetAll"));
-}
+    msg << interface();
 
-void DDBusExtendedAbstractInterface::onAsyncPropertyFinished(
+    if (m_sync) {
-    QDBusPendingCallWatcher *w) {
+        QDBusMessage reply = connection().call(msg);
-  DDBusExtendedPendingCallWatcher *watcher =
-      qobject_cast<DDBusExtendedPendingCallWatcher *>(w);
-  Q_ASSERT(watcher);
 
-  QDBusPendingReply<QVariant> reply = *watcher;
+        if (reply.type() != QDBusMessage::ReplyMessage) {
+            m_lastExtendedError = QDBusError(reply);
+            qWarning() << Q_FUNC_INFO << m_lastExtendedError.message();
+            return;
+        }
 
-  if (reply.isError()) {
+        if (reply.signature() != QLatin1String("a{sv}")) {
-    m_lastExtendedError = reply.error();
+            QString errorMessage = QStringLiteral("Invalid signature \"%1\" in return from call to %2")
-  } else {
+                                       .arg(reply.signature(), QString(*dBusPropertiesInterface()));
-    int propertyIndex = metaObject()->indexOfProperty(
+            qWarning() << Q_FUNC_INFO << errorMessage;
-        watcher->asyncProperty().toLatin1().constData());
+            m_lastExtendedError = QDBusError(QDBusError::InvalidSignature, errorMessage);
-    QVariant value =
+            return;
-        demarshall(interface(), metaObject()->property(propertyIndex),
+        }
-                   reply.value(), &m_lastExtendedError);
 
-    if (m_lastExtendedError.isValid()) {
+        QVariantMap value = reply.arguments().at(0).toMap();
-      Q_EMIT propertyInvalidated(watcher->asyncProperty());
+        onPropertiesChanged(interface(), value, QStringList());
     } else {
-      Q_EMIT propertyChanged(watcher->asyncProperty(), value);
+        QDBusPendingReply<QVariantMap> async = connection().asyncCall(msg);
+        m_getAllPendingCallWatcher = new QDBusPendingCallWatcher(async, this);
+
+        connect(m_getAllPendingCallWatcher,
+                SIGNAL(finished(QDBusPendingCallWatcher *)),
+                this,
+                SLOT(onAsyncGetAllPropertiesFinished(QDBusPendingCallWatcher *)));
+        return;
     }
-  }
-
-  Q_EMIT asyncPropertyFinished(watcher->asyncProperty());
-  watcher->deleteLater();
 }
 
-void DDBusExtendedAbstractInterface::onAsyncSetPropertyFinished(
+void DDBusExtendedAbstractInterface::connectNotify(const QMetaMethod &signal)
-    QDBusPendingCallWatcher *w) {
+{
-  DDBusExtendedPendingCallWatcher *watcher =
+    if (signal.methodType() == QMetaMethod::Signal && (signal.methodSignature() == *propertyChangedSignature() ||
-      qobject_cast<DDBusExtendedPendingCallWatcher *>(w);
+                                                       signal.methodSignature() == *propertyInvalidatedSignature())) {
-  Q_ASSERT(watcher);
+        if (!m_propertiesChangedConnected) {
+            QStringList argumentMatch;
+            argumentMatch << interface();
+            connection().connect(service(),
+                                 path(),
+                                 *dBusPropertiesInterface(),
+                                 *dBusPropertiesChangedSignal(),
+                                 argumentMatch,
+                                 QString(),
+                                 this,
+                                 SLOT(onPropertiesChanged(QString, QVariantMap, QStringList)));
 
-  QDBusPendingReply<> reply = *watcher;
+            m_propertiesChangedConnected = true;
-
+            return;
-  if (reply.isError()) {
+        }
-    m_lastExtendedError = reply.error();
+    } else {
-  } else {
+        QDBusAbstractInterface::connectNotify(signal);
-    m_lastExtendedError = QDBusError();
+    }
-  }
-
-  Q_EMIT asyncSetPropertyFinished(watcher->asyncProperty());
-
-  // Resetting the property to its previous value after sending the
-  // finished signal
-  if (reply.isError()) {
-    m_lastExtendedError = QDBusError();
-    Q_EMIT propertyChanged(watcher->asyncProperty(), watcher->previousValue());
-  }
-
-  watcher->deleteLater();
 }
 
-void DDBusExtendedAbstractInterface::onAsyncGetAllPropertiesFinished(
+void DDBusExtendedAbstractInterface::disconnectNotify(const QMetaMethod &signal)
-    QDBusPendingCallWatcher *watcher) {
+{
-  m_getAllPendingCallWatcher = 0;
+    if (signal.methodType() == QMetaMethod::Signal && (signal.methodSignature() == *propertyChangedSignature() ||
+                                                       signal.methodSignature() == *propertyInvalidatedSignature())) {
+        if (m_propertiesChangedConnected && 0 == receivers(propertyChangedSignature()->constData()) &&
+            0 == receivers(propertyInvalidatedSignature()->constData())) {
+            QStringList argumentMatch;
+            argumentMatch << interface();
+            connection().disconnect(service(),
+                                    path(),
+                                    *dBusPropertiesInterface(),
+                                    *dBusPropertiesChangedSignal(),
+                                    argumentMatch,
+                                    QString(),
+                                    this,
+                                    SLOT(onPropertiesChanged(QString, QVariantMap, QStringList)));
 
-  QDBusPendingReply<QVariantMap> reply = *watcher;
+            m_propertiesChangedConnected = false;
-
+            return;
-  if (reply.isError()) {
+        }
-    m_lastExtendedError = reply.error();
+    } else {
-  } else {
+        QDBusAbstractInterface::disconnectNotify(signal);
-    m_lastExtendedError = QDBusError();
+    }
-  }
-
-  Q_EMIT asyncGetAllPropertiesFinished();
-
-  if (!reply.isError()) {
-    onPropertiesChanged(interface(), reply.value(), QStringList());
-  }
-
-  watcher->deleteLater();
 }
 
-void DDBusExtendedAbstractInterface::onPropertiesChanged(
+QVariant DDBusExtendedAbstractInterface::internalPropGet(const char *propname, void *propertyPtr)
-    const QString &interfaceName, const QVariantMap &changedProperties,
+{
-    const QStringList &invalidatedProperties) {
+    m_lastExtendedError = QDBusError();
-  if (interfaceName == interface()) {
-    QVariantMap::const_iterator i = changedProperties.constBegin();
-    while (i != changedProperties.constEnd()) {
-      int propertyIndex =
-          metaObject()->indexOfProperty(i.key().toLatin1().constData());
 
-      if (-1 == propertyIndex) {
+    if (m_useCache) {
-        qDebug() << Q_FUNC_INFO << "Got unknown changed property" << i.key();
+        int propertyIndex = metaObject()->indexOfProperty(propname);
-      } else {
+        QMetaProperty metaProperty = metaObject()->property(propertyIndex);
-        QVariant value =
+        return QVariant(metaProperty.userType(), propertyPtr);
-            demarshall(interface(), metaObject()->property(propertyIndex),
+    }
-                       i.value(), &m_lastExtendedError);
+
+    if (m_sync) {
+        QVariant ret = property(propname);
+
+        QMetaType::construct(ret.userType(), propertyPtr, ret.constData());
+
+        return ret;
+    } else {
+        if (!isValid()) {
+            QString errorMessage = QStringLiteral("This Extended DBus interface is not valid yet.");
+            m_lastExtendedError = QDBusMessage::createError(QDBusError::Failed, errorMessage);
+            qDebug() << Q_FUNC_INFO << errorMessage;
+            return QVariant();
+        }
+
+        int propertyIndex = metaObject()->indexOfProperty(propname);
+
+        if (-1 == propertyIndex) {
+            QString errorMessage = QStringLiteral("Got unknown property \"%1\" to read").arg(QString::fromLatin1(propname));
+            m_lastExtendedError = QDBusMessage::createError(QDBusError::Failed, errorMessage);
+            qWarning() << Q_FUNC_INFO << errorMessage;
+            return QVariant();
+        }
+
+        QMetaProperty metaProperty = metaObject()->property(propertyIndex);
+
+        if (!metaProperty.isReadable()) {
+            QString errorMessage = QStringLiteral("Property \"%1\" is NOT readable").arg(QString::fromLatin1(propname));
+            m_lastExtendedError = QDBusMessage::createError(QDBusError::Failed, errorMessage);
+            qWarning() << Q_FUNC_INFO << errorMessage;
+            return QVariant();
+        }
+
+        // is this metatype registered?
+        const char *expectedSignature = "";
+        if (int(metaProperty.type()) != QMetaType::QVariant) {
+            expectedSignature = QDBusMetaType::typeToSignature(metaProperty.userType());
+            if (0 == expectedSignature) {
+                QString errorMessage = QStringLiteral("Type %1 must be registered with Qt D-Bus "
+                                                      "before it can be used to read property "
+                                                      "%2.%3")
+                                           .arg(metaProperty.typeName(), interface(), propname);
+                m_lastExtendedError = QDBusMessage::createError(QDBusError::Failed, errorMessage);
+                qWarning() << Q_FUNC_INFO << errorMessage;
+                return QVariant();
+            }
+        }
+
+        asyncProperty(propname);
+        return QVariant(metaProperty.userType(), propertyPtr);
+    }
+}
+
+void DDBusExtendedAbstractInterface::internalPropSet(const char *propname, const QVariant &value, void *propertyPtr)
+{
+    m_lastExtendedError = QDBusError();
+
+    if (m_sync) {
+        setProperty(propname, value);
+    } else {
+        if (!isValid()) {
+            QString errorMessage = QStringLiteral("This interface is not yet valid");
+            m_lastExtendedError = QDBusMessage::createError(QDBusError::Failed, errorMessage);
+            qDebug() << Q_FUNC_INFO << errorMessage;
+            return;
+        }
+
+        int propertyIndex = metaObject()->indexOfProperty(propname);
+
+        if (-1 == propertyIndex) {
+            QString errorMessage = QStringLiteral("Got unknown property \"%1\" to write").arg(QString::fromLatin1(propname));
+            m_lastExtendedError = QDBusMessage::createError(QDBusError::Failed, errorMessage);
+            qWarning() << Q_FUNC_INFO << errorMessage;
+            return;
+        }
+
+        QMetaProperty metaProperty = metaObject()->property(propertyIndex);
+
+        if (!metaProperty.isWritable()) {
+            QString errorMessage = QStringLiteral("Property \"%1\" is NOT writable").arg(QString::fromLatin1(propname));
+            m_lastExtendedError = QDBusMessage::createError(QDBusError::Failed, errorMessage);
+            qWarning() << Q_FUNC_INFO << errorMessage;
+            return;
+        }
+
+        QVariant variant = QVariant(metaProperty.type(), propertyPtr);
+        variant = value;
+
+        asyncSetProperty(propname, variant);
+    }
+}
+
+QVariant DDBusExtendedAbstractInterface::asyncProperty(const QString &propertyName)
+{
+    QDBusMessage msg = QDBusMessage::createMethodCall(service(), path(), *dBusPropertiesInterface(), QStringLiteral("Get"));
+    msg << interface() << propertyName;
+    QDBusPendingReply<QVariant> async = connection().asyncCall(msg);
+    DDBusExtendedPendingCallWatcher *watcher = new DDBusExtendedPendingCallWatcher(async, propertyName, QVariant(), this);
+
+    connect(watcher, SIGNAL(finished(QDBusPendingCallWatcher *)), this, SLOT(onAsyncPropertyFinished(QDBusPendingCallWatcher *)));
+
+    return QVariant();
+}
+
+void DDBusExtendedAbstractInterface::asyncSetProperty(const QString &propertyName, const QVariant &value)
+{
+    QDBusMessage msg = QDBusMessage::createMethodCall(service(), path(), *dBusPropertiesInterface(), QStringLiteral("Set"));
+
+    msg << interface() << propertyName << QVariant::fromValue(QDBusVariant(value));
+    QDBusPendingReply<> async = connection().asyncCall(msg);
+    DDBusExtendedPendingCallWatcher *watcher = new DDBusExtendedPendingCallWatcher(async, propertyName, value, this);
+
+    connect(
+        watcher, SIGNAL(finished(QDBusPendingCallWatcher *)), this, SLOT(onAsyncSetPropertyFinished(QDBusPendingCallWatcher *)));
+}
+
+void DDBusExtendedAbstractInterface::startServiceProcess()
+{
+    const QString &servName = service();
+
+    if (isValid()) {
+        qWarning() << "Service" << servName << "is already started.";
+        return;
+    }
+
+    QDBusMessage msg =
+        QDBusMessage::createMethodCall("org.freedesktop.DBus", "/", *dBusInterface(), QStringLiteral("StartServiceByName"));
+    msg << servName << quint32(0);
+    QDBusPendingReply<quint32> async = connection().asyncCall(msg);
+    QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(async, this);
+
+    connect(watcher, &QDBusPendingCallWatcher::finished, this, &DDBusExtendedAbstractInterface::onStartServiceProcessFinished);
+}
+
+void DDBusExtendedAbstractInterface::onStartServiceProcessFinished(QDBusPendingCallWatcher *w)
+{
+    if (w->isError()) {
+        m_lastExtendedError = w->error();
+    } else {
+        m_lastExtendedError = QDBusError();
+    }
+
+    QDBusPendingReply<quint32> reply = *w;
+
+    Q_EMIT serviceStartFinished(reply.value());
+
+    w->deleteLater();
+}
+
+void DDBusExtendedAbstractInterface::onAsyncPropertyFinished(QDBusPendingCallWatcher *w)
+{
+    DDBusExtendedPendingCallWatcher *watcher = qobject_cast<DDBusExtendedPendingCallWatcher *>(w);
+    Q_ASSERT(watcher);
+
+    QDBusPendingReply<QVariant> reply = *watcher;
+
+    if (reply.isError()) {
+        m_lastExtendedError = reply.error();
+    } else {
+        int propertyIndex = metaObject()->indexOfProperty(watcher->asyncProperty().toLatin1().constData());
+        QVariant value = demarshall(interface(), metaObject()->property(propertyIndex), reply.value(), &m_lastExtendedError);
 
         if (m_lastExtendedError.isValid()) {
-          Q_EMIT propertyInvalidated(i.key());
+            Q_EMIT propertyInvalidated(watcher->asyncProperty());
         } else {
-          Q_EMIT propertyChanged(i.key(), value);
+            Q_EMIT propertyChanged(watcher->asyncProperty(), value);
         }
-      }
-
-      ++i;
     }
 
-    QStringList::const_iterator j = invalidatedProperties.constBegin();
+    Q_EMIT asyncPropertyFinished(watcher->asyncProperty());
-    while (j != invalidatedProperties.constEnd()) {
+    watcher->deleteLater();
-      if (-1 == metaObject()->indexOfProperty(j->toLatin1().constData())) {
-        qDebug() << Q_FUNC_INFO << "Got unknown invalidated property" << *j;
-      } else {
-        m_lastExtendedError = QDBusError();
-        Q_EMIT propertyInvalidated(*j);
-      }
-
-      ++j;
-    }
-  }
 }
 
-void DDBusExtendedAbstractInterface::onDBusNameOwnerChanged(
+void DDBusExtendedAbstractInterface::onAsyncSetPropertyFinished(QDBusPendingCallWatcher *w)
-    const QString &name, const QString &oldOwner, const QString &newOwner) {
+{
-  if (name == service() && oldOwner.isEmpty()) {
+    DDBusExtendedPendingCallWatcher *watcher = qobject_cast<DDBusExtendedPendingCallWatcher *>(w);
-    m_dbusOwner = newOwner;
+    Q_ASSERT(watcher);
-    Q_EMIT serviceValidChanged(true);
-  } else if (name == m_dbusOwner && newOwner.isEmpty()) {
-    m_dbusOwner.clear();
-    Q_EMIT serviceValidChanged(false);
-  }
-}
 
-QVariant DDBusExtendedAbstractInterface::demarshall(
+    QDBusPendingReply<> reply = *watcher;
-    const QString &interface, const QMetaProperty &metaProperty,
-    const QVariant &value, QDBusError *error) {
-  Q_ASSERT(metaProperty.isValid());
-  Q_ASSERT(error != 0);
 
-  if (value.userType() == metaProperty.userType()) {
+    if (reply.isError()) {
-    // No need demarshalling. Passing back straight away ...
+        m_lastExtendedError = reply.error();
-    *error = QDBusError();
-    return value;
-  }
-
-  QVariant result = QVariant(metaProperty.userType(), (void *)0);
-  QString errorMessage;
-  const char *expectedSignature =
-      QDBusMetaType::typeToSignature(metaProperty.userType());
-
-  if (value.userType() == qMetaTypeId<QDBusArgument>()) {
-    // demarshalling a DBus argument ...
-    QDBusArgument dbusArg = value.value<QDBusArgument>();
-
-    if (expectedSignature == dbusArg.currentSignature().toLatin1()) {
-      QDBusMetaType::demarshall(dbusArg, metaProperty.userType(),
-                                result.data());
-      if (!result.isValid()) {
-        errorMessage =
-            QStringLiteral("Unexpected failure demarshalling "
-                           "upon PropertiesChanged signal arrival "
-                           "for property `%3.%4' (expected type `%5' (%6))")
-                .arg(interface, QString::fromLatin1(metaProperty.name()),
-                     QString::fromLatin1(metaProperty.typeName()),
-                     expectedSignature);
-      }
     } else {
-      errorMessage =
+        m_lastExtendedError = QDBusError();
-          QStringLiteral("Unexpected `user type' (%2) "
-                         "upon PropertiesChanged signal arrival "
-                         "for property `%3.%4' (expected type `%5' (%6))")
-              .arg(dbusArg.currentSignature(), interface,
-                   QString::fromLatin1(metaProperty.name()),
-                   QString::fromLatin1(metaProperty.typeName()),
-                   QString::fromLatin1(expectedSignature));
     }
-  } else {
-    const char *actualSignature =
-        QDBusMetaType::typeToSignature(value.userType());
 
-    errorMessage =
+    Q_EMIT asyncSetPropertyFinished(watcher->asyncProperty());
-        QStringLiteral("Unexpected `%1' (%2) "
-                       "upon PropertiesChanged signal arrival "
-                       "for property `%3.%4' (expected type `%5' (%6))")
-            .arg(QString::fromLatin1(value.typeName()),
-                 QString::fromLatin1(actualSignature), interface,
-                 QString::fromLatin1(metaProperty.name()),
-                 QString::fromLatin1(metaProperty.typeName()),
-                 QString::fromLatin1(expectedSignature));
-  }
 
-  if (errorMessage.isEmpty()) {
+    // Resetting the property to its previous value after sending the
-    *error = QDBusError();
+    // finished signal
-  } else {
+    if (reply.isError()) {
-    *error =
+        m_lastExtendedError = QDBusError();
-        QDBusMessage::createError(QDBusError::InvalidSignature, errorMessage);
+        Q_EMIT propertyChanged(watcher->asyncProperty(), watcher->previousValue());
-    qDebug() << Q_FUNC_INFO << errorMessage;
+    }
-  }
 
-  return result;
+    watcher->deleteLater();
+}
+
+void DDBusExtendedAbstractInterface::onAsyncGetAllPropertiesFinished(QDBusPendingCallWatcher *watcher)
+{
+    m_getAllPendingCallWatcher = 0;
+
+    QDBusPendingReply<QVariantMap> reply = *watcher;
+
+    if (reply.isError()) {
+        m_lastExtendedError = reply.error();
+    } else {
+        m_lastExtendedError = QDBusError();
+    }
+
+    Q_EMIT asyncGetAllPropertiesFinished();
+
+    if (!reply.isError()) {
+        onPropertiesChanged(interface(), reply.value(), QStringList());
+    }
+
+    watcher->deleteLater();
+}
+
+void DDBusExtendedAbstractInterface::onPropertiesChanged(const QString &interfaceName,
+                                                         const QVariantMap &changedProperties,
+                                                         const QStringList &invalidatedProperties)
+{
+    if (interfaceName == interface()) {
+        QVariantMap::const_iterator i = changedProperties.constBegin();
+        while (i != changedProperties.constEnd()) {
+            int propertyIndex = metaObject()->indexOfProperty(i.key().toLatin1().constData());
+
+            if (-1 == propertyIndex) {
+                qDebug() << Q_FUNC_INFO << "Got unknown changed property" << i.key();
+            } else {
+                QVariant value = demarshall(interface(), metaObject()->property(propertyIndex), i.value(), &m_lastExtendedError);
+
+                if (m_lastExtendedError.isValid()) {
+                    Q_EMIT propertyInvalidated(i.key());
+                } else {
+                    Q_EMIT propertyChanged(i.key(), value);
+                }
+            }
+
+            ++i;
+        }
+
+        QStringList::const_iterator j = invalidatedProperties.constBegin();
+        while (j != invalidatedProperties.constEnd()) {
+            if (-1 == metaObject()->indexOfProperty(j->toLatin1().constData())) {
+                qDebug() << Q_FUNC_INFO << "Got unknown invalidated property" << *j;
+            } else {
+                m_lastExtendedError = QDBusError();
+                Q_EMIT propertyInvalidated(*j);
+            }
+
+            ++j;
+        }
+    }
+}
+
+void DDBusExtendedAbstractInterface::onDBusNameOwnerChanged(const QString &name, const QString &oldOwner, const QString &newOwner)
+{
+    if (name == service() && oldOwner.isEmpty()) {
+        m_dbusOwner = newOwner;
+        Q_EMIT serviceValidChanged(true);
+    } else if (name == m_dbusOwner && newOwner.isEmpty()) {
+        m_dbusOwner.clear();
+        Q_EMIT serviceValidChanged(false);
+    }
+}
+
+QVariant DDBusExtendedAbstractInterface::demarshall(const QString &interface,
+                                                    const QMetaProperty &metaProperty,
+                                                    const QVariant &value,
+                                                    QDBusError *error)
+{
+    Q_ASSERT(metaProperty.isValid());
+    Q_ASSERT(error != 0);
+
+    if (value.userType() == metaProperty.userType()) {
+        // No need demarshalling. Passing back straight away ...
+        *error = QDBusError();
+        return value;
+    }
+
+    QVariant result = QVariant(metaProperty.userType(), (void *)0);
+    QString errorMessage;
+    const char *expectedSignature = QDBusMetaType::typeToSignature(metaProperty.userType());
+
+    if (value.userType() == qMetaTypeId<QDBusArgument>()) {
+        // demarshalling a DBus argument ...
+        QDBusArgument dbusArg = value.value<QDBusArgument>();
+
+        if (expectedSignature == dbusArg.currentSignature().toLatin1()) {
+            QDBusMetaType::demarshall(dbusArg, metaProperty.userType(), result.data());
+            if (!result.isValid()) {
+                errorMessage = QStringLiteral("Unexpected failure demarshalling "
+                                              "upon PropertiesChanged signal arrival "
+                                              "for property `%3.%4' (expected type `%5' (%6))")
+                                   .arg(interface,
+                                        QString::fromLatin1(metaProperty.name()),
+                                        QString::fromLatin1(metaProperty.typeName()),
+                                        expectedSignature);
+            }
+        } else {
+            errorMessage = QStringLiteral("Unexpected `user type' (%2) "
+                                          "upon PropertiesChanged signal arrival "
+                                          "for property `%3.%4' (expected type `%5' (%6))")
+                               .arg(dbusArg.currentSignature(),
+                                    interface,
+                                    QString::fromLatin1(metaProperty.name()),
+                                    QString::fromLatin1(metaProperty.typeName()),
+                                    QString::fromLatin1(expectedSignature));
+        }
+    } else {
+        const char *actualSignature = QDBusMetaType::typeToSignature(value.userType());
+
+        errorMessage = QStringLiteral("Unexpected `%1' (%2) "
+                                      "upon PropertiesChanged signal arrival "
+                                      "for property `%3.%4' (expected type `%5' (%6))")
+                           .arg(QString::fromLatin1(value.typeName()),
+                                QString::fromLatin1(actualSignature),
+                                interface,
+                                QString::fromLatin1(metaProperty.name()),
+                                QString::fromLatin1(metaProperty.typeName()),
+                                QString::fromLatin1(expectedSignature));
+    }
+
+    if (errorMessage.isEmpty()) {
+        *error = QDBusError();
+    } else {
+        *error = QDBusMessage::createError(QDBusError::InvalidSignature, errorMessage);
+        qDebug() << Q_FUNC_INFO << errorMessage;
+    }
+
+    return result;
 }
 DCORE_END_NAMESPACE

src/util/ddbusextendedpendingcallwatcher.cpp

@@ -5,11 +5,15 @@
 #include "ddbusextendedpendingcallwatcher_p.h"
 
 DCORE_BEGIN_NAMESPACE
-DDBusExtendedPendingCallWatcher::DDBusExtendedPendingCallWatcher(
+DDBusExtendedPendingCallWatcher::DDBusExtendedPendingCallWatcher(const QDBusPendingCall &call,
-    const QDBusPendingCall &call, const QString &asyncProperty,
+                                                                 const QString &asyncProperty,
-    const QVariant &previousValue, QObject *parent)
+                                                                 const QVariant &previousValue,
-    : QDBusPendingCallWatcher(call, parent), m_asyncProperty(asyncProperty),
+                                                                 QObject *parent)
-      m_previousValue(previousValue) {}
+    : QDBusPendingCallWatcher(call, parent)
+    , m_asyncProperty(asyncProperty)
+    , m_previousValue(previousValue)
+{
+}
 
 DDBusExtendedPendingCallWatcher::~DDBusExtendedPendingCallWatcher() {}
 DCORE_END_NAMESPACE

src/util/ddbusextendedpendingcallwatcher_p.h

@@ -21,25 +21,26 @@
 #include <QDBusPendingCallWatcher>
 
 DCORE_BEGIN_NAMESPACE
-class DDBusExtendedPendingCallWatcher : public QDBusPendingCallWatcher {
+class DDBusExtendedPendingCallWatcher : public QDBusPendingCallWatcher
-  Q_OBJECT
+{
+    Q_OBJECT
 
 public:
-  explicit DDBusExtendedPendingCallWatcher(const QDBusPendingCall &call,
+    explicit DDBusExtendedPendingCallWatcher(const QDBusPendingCall &call,
-                                           const QString &asyncProperty,
+                                             const QString &asyncProperty,
-                                           const QVariant &previousValue,
+                                             const QVariant &previousValue,
-                                           QObject *parent = 0);
+                                             QObject *parent = 0);
-  ~DDBusExtendedPendingCallWatcher();
+    ~DDBusExtendedPendingCallWatcher();
 
-  Q_PROPERTY(QString AsyncProperty READ asyncProperty)
+    Q_PROPERTY(QString AsyncProperty READ asyncProperty)
-  inline QString asyncProperty() const { return m_asyncProperty; }
+    inline QString asyncProperty() const { return m_asyncProperty; }
 
-  Q_PROPERTY(QVariant PreviousValue READ previousValue)
+    Q_PROPERTY(QVariant PreviousValue READ previousValue)
-  inline QVariant previousValue() const { return m_previousValue; }
+    inline QVariant previousValue() const { return m_previousValue; }
 
 private:
-  QString m_asyncProperty;
+    QString m_asyncProperty;
-  QVariant m_previousValue;
+    QVariant m_previousValue;
 };
 DCORE_END_NAMESPACE