Merge lp:~zsombi/ubuntu-ui-toolkit/other-vibrations into lp:ubuntu-ui-toolkit/rtm

[Zsombor Egri]

isHapticsFeedbackEnabled context property exposed to drive HapticsFeedback in AbstractButton.

[Zsombor Egri (zsombi)]

DBusPropertyWatcher adaptation layer API added to support multiple DBus service watching. It has been added as adaptation layer API as prerequisite for the multi platform support (SDK must enable development on other platforms).

The property is a temporary workaround to support the feature requested. Future singleton API should be productised during the near future to replace this property.

[Jonas G. Drange (jonas-drange)]

Looks good, but I have added a couple of comments concerning names.

review: Needs Information

[Cris Dywan (kalikiana)]

Some comments with ideas to make the API simpler, and some concerns on the sync bits and eror handling. If we use this for more in the near future it's probably worth making it more robust even if it's for now internal.

84 +void DBusPropertyWatcher::syncProperties(const QString &serviceInterface)
100 +QVariant DBusPropertyWatcher::readProperty(const QString &interface, const QString &property)
117 +bool DBusPropertyWatcher::writeProperty(const QString &interface, const QString &property, const QVariant &value)

Sync isn't nice. By the looks of it, it's handy for testing - thing is, you're not actually testing the production code paths so you're not doing yourself a favor in the end.

What I'd like suggest is: a default value is given. the current property is read async after setup. the value is cached so read can be sync. write is async always. success can be seen in an error property & signal. the new value will be reflected by the propertiesChanged.
If we want multiple properties we can make that a list of names and defaults, and asking for something other than what you specified will be an error, giving you extra safety even if you're making a typo on the consumer side.

I'll be happy to look into the testing approach based on all-async.

This also automatically makes a QML-able API if we want it that looks and feels similar to "Binding".

163 +void DBusPropertyWatcher::setupInterface()

This needs to warn if the object name is invalid.
I presume we also need error handling for connect().

9 + if (isHapticsFeedbackEnabled) {

As an idea, by simplifying the API a bit we could use DBusWatcher in QML and avoid the context property. Or we could have a little internal "settings" object if we re-use it in the future.

review: Needs Fixing

[Zsombor Egri (zsombi)]

> Looks good, but I have added a couple of comments concerning names.

Thanks for the comments, I tried to reply inline, hopefully it'll get in.

[Zsombor Egri (zsombi)]

Jonas, looks like replying to an inline-comitter comment does not land with the reply to the inline comments...

[Zsombor Egri (zsombi)]

> Some comments with ideas to make the API simpler, and some concerns on the
> sync bits and eror handling. If we use this for more in the near future it's
> probably worth making it more robust even if it's for now internal.
>
> 84 +void DBusPropertyWatcher::syncProperties(const QString
> &serviceInterface)
> 100 +QVariant DBusPropertyWatcher::readProperty(const QString &interface,
> const QString &property)
> 117 +bool DBusPropertyWatcher::writeProperty(const QString &interface,
> const QString &property, const QVariant &value)
>
> Sync isn't nice. By the looks of it, it's handy for testing - thing is, you're
> not actually testing the production code paths so you're not doing yourself a
> favor in the end.

The first one (syncProperties) initiates reading of the watched properties. Yet synchronously. Calls the readProperty() for each watched property, so if we have async read, we will get this async as well. Anyway, the property values read are reported by propertyChanged() signal.

Even if we'd have read/write async, we may want also to keep the sync version of them. And yes, error codes/messages we receive from DBus should be exported, so that part we must also add.

>
> What I'd like suggest is: a default value is given. the current property is
> read async after setup. the value is cached so read can be sync. write is
> async always. success can be seen in an error property & signal. the new value
> will be reflected by the propertiesChanged.

Yep, I agree on this. So far the default is like that, just the current values are read synchronously. Yet we only use write in testing, and tbh the only reason I added the writeProperty() was to be able to test the watching functionality, as I wanted to have a module test which is not DBus-agnostic, and uses the same connection/interface instances the watcher uses. After all, a write method in a watcher doesn't really has its place. But if we have write, the "watcher" might not be the best name anymore, it's rather a DBusService.

> If we want multiple properties we can make that a list of names and defaults,
> and asking for something other than what you specified will be an error,
> giving you extra safety even if you're making a typo on the consumer side.

I'm not sure the intention of DBusWatcher was that. The SystemSettings otoh keeps the defaults and initiates the watcher(s) to get the correct settings - yet we have only one watcher, for the accounts, but we could have more. Each service watcher can watch for several properties on the same service interface, but all defaults are handled in the SystemSettings.
>
> I'll be happy to look into the testing approach based on all-async.

Thanks, but I'd not have any CPO yet for this, as it's more like an internal component.

>
> This also automatically makes a QML-able API if we want it that looks and
> feels similar to "Binding".

Aaah, now I get why you want to see a default in the watcher. In that case, yes, it would be beneficial to have a default on that level.

>
> 163 +void DBusPropertyWatcher::setupInterface()
>
> This needs to warn if the object name is invalid.
> I presume we also need error handling for connect...

[lp:~zsombi/ubuntu-ui-toolkit/other-vibrations]

1142. By Zsombor Egri on 2014-11-26

API changed

[Cris Dywan (kalikiana)]

64 +#define DYNAMIC_PROPERTY "__q_proeprty"
81 + // crear all previous connections
914 + property bool thisIsAndInvalidPropertyToWatch: true

Typos.

Also, can we test with valid *and* invalid? To make sure the error won't be overridden by the valid one. From the code it doesn't seem to stop the loop in that case at least.

review: Needs Fixing

[Zsombor Egri (zsombi)]

> 64 +#define DYNAMIC_PROPERTY "__q_proeprty"
> 81 + // crear all previous connections
> 914 + property bool thisIsAndInvalidPropertyToWatch: true
>
> Typos.

Ups... I should have an ibus filter which fixes proeprty, teh and si (is) typos :D

>
> Also, can we test with valid *and* invalid? To make sure the error won't be
> overridden by the valid one. From the code it doesn't seem to stop the loop in
> that case at least.

Yes, I will add one. The error will not be cleared ever if there was an error set. So a valid property won't clear the previous invalid property reported.

[lp:~zsombi/ubuntu-ui-toolkit/other-vibrations]

1143. By Zsombor Egri on 2014-11-27

review comments applied

[Cris Dywan (kalikiana)]

Thanks for taking my comments into account. Looking nice now!

review: Approve

[lp:~zsombi/ubuntu-ui-toolkit/other-vibrations]

1144. By Zsombor Egri on 2014-12-03

test and launch updates

1145. By Zsombor Egri on 2015-02-04

adding build dependencies

1146. By Zsombor Egri on 2015-02-04

rtm merge

1147. By Zsombor Egri on 2015-02-04

typo fixed

1148. By Zsombor Egri on 2015-02-04

one more typo

=== modified file 'components.api'
--- components.api	2014-11-07 13:39:31 +0000
+++ components.api	2015-02-04 14:00:19 +0000
@@ -915,6 +915,18 @@
     Signal {
     name: "sourceChanged"
     Parameter { type: "QUrl" }
+    name: "UCServiceProperties"
+    prototype: "QObject"
+    exports: ["ServiceProperties 1.1"]
+    name: "ServiceType"
+    name: "Status"
+    Property { name: "type"; revision: 1; type: "ServiceType" }
+    Property { name: "service"; revision: 1; type: "string" }
+    Property { name: "path"; revision: 1; type: "string" }
+    Property { name: "serviceInterface"; revision: 1; type: "string" }
+    Property { name: "adaptorInterface"; revision: 1; type: "string" }
+    Property { name: "error"; revision: 1; type: "string"; isReadonly: true }
+    Property { name: "status"; revision: 1; type: "Status"; isReadonly: true }
     name: "UCStateSaver"
     prototype: "QObject"
     exports: ["StateSaver 0.1", "StateSaver 1.0"]

=== modified file 'debian/control'
--- debian/control	2014-10-16 11:21:39 +0000
+++ debian/control	2015-02-04 14:00:19 +0000
@@ -37,6 +37,9 @@
                language-pack-en-base,
                libdbus-1-dev,
                libnih-dbus-dev,
+               dbus,
+               dbus-test-runner,
+               accountsservice,
                xvfb,
                libgl1-mesa-dri,
                locales,

=== modified file 'modules/Ubuntu/Components/AbstractButton.qml'
--- modules/Ubuntu/Components/AbstractButton.qml	2014-09-02 05:52:32 +0000
+++ modules/Ubuntu/Components/AbstractButton.qml	2015-02-04 14:00:19 +0000
@@ -104,7 +104,7 @@
 
         onClicked: {
             if (button.__acceptEvents) {
-                pressEffect.start()
+                pressEffect.start();
                 button.clicked()
             }
         }

=== added file 'modules/Ubuntu/Components/plugin/adapters/dbuspropertywatcher_p.cpp'
--- modules/Ubuntu/Components/plugin/adapters/dbuspropertywatcher_p.cpp	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/plugin/adapters/dbuspropertywatcher_p.cpp	2015-02-04 14:00:19 +0000
@@ -0,0 +1,226 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program 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; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "dbuspropertywatcher_p.h"
+#include <QtDBus/QDBusReply>
+#include <unistd.h>
+#include <sys/types.h>
+#include "i18n.h"
+#include <QtQml/QQmlInfo>
+
+#define DYNAMIC_PROPERTY    "__q_property"
+
+UCServicePropertiesPrivate *createServicePropertiesAdapter(UCServiceProperties *owner)
+{
+    return new DBusServiceProperties(owner);
+}
+
+DBusServiceProperties::DBusServiceProperties(UCServiceProperties *qq)
+    : UCServicePropertiesPrivate(qq)
+    , connection("")
+    , watcher(0)
+    , iface(0)
+{
+}
+
+bool DBusServiceProperties::init()
+{
+    // crear previous connections
+    setStatus(UCServiceProperties::Inactive);
+    delete iface;
+    iface = 0;
+    delete watcher;
+    watcher = 0;
+    setError(QString());
+
+    if (service.isEmpty() || path.isEmpty()) {
+        setStatus(UCServiceProperties::ConnectionError);
+        setError(UbuntuI18n::instance().tr("No service/path specified"));
+        return false;
+    }
+
+    switch (type) {
+        case UCServiceProperties::System:
+        {
+            connection = QDBusConnection::systemBus();
+            break;
+        }
+        case UCServiceProperties::Session:
+        {
+            connection = QDBusConnection::sessionBus();
+            break;
+        }
+        default:
+        {
+            setStatus(UCServiceProperties::ConnectionError);
+            setError(UbuntuI18n::instance().tr("Invalid bus type: %1.").arg(type));
+            return false;
+        }
+    }
+
+    Q_Q(UCServiceProperties);
+    // connect dbus watcher to catch OwnerChanged
+    watcher = new QDBusServiceWatcher(service, connection, QDBusServiceWatcher::WatchForOwnerChange, q);
+    // connect interface
+    iface = new QDBusInterface(service, path, interface, connection, q);
+    if (!iface->isValid()) {
+        setStatus(UCServiceProperties::ConnectionError);
+        setError(iface->lastError().message());
+        return false;
+    }
+    // connect watcher to get owner changes
+    QObject::connect(watcher, SIGNAL(serviceOwnerChanged(QString,QString,QString)),
+                     this, SLOT(changeServiceOwner(QString,QString,QString)));
+    return setupInterface();
+}
+
+/*
+ * Connect dbus signal identified by (service, path, iface, name) quaduple to a
+ * slot to receive property changes.
+ */
+bool DBusServiceProperties::setupInterface()
+{
+    QDBusReply<QDBusObjectPath> dbusObjectPath = iface->call("FindUserById", qlonglong(getuid()));
+    if (dbusObjectPath.isValid()) {
+        objectPath = dbusObjectPath.value().path();
+        iface->connection().connect(
+            service,
+            objectPath,
+            "org.freedesktop.DBus.Properties",
+            "PropertiesChanged",
+            this,
+            SLOT(updateProperties(QString,QVariantMap,QStringList)));
+        return true;
+    }
+
+    setStatus(UCServiceProperties::ConnectionError);
+    setError(dbusObjectPath.error().message());
+    return false;
+}
+
+bool DBusServiceProperties::fetchPropertyValues()
+{
+    scannedProperties = properties;
+    Q_FOREACH(QString property, properties) {
+        readProperty(property);
+    }
+    return true;
+}
+
+/*
+ * Reads a property value from the adaptorInterface asynchronously.
+ */
+bool DBusServiceProperties::readProperty(const QString &property)
+{
+    if ((status < UCServiceProperties::Synchronizing) || objectPath.isEmpty()) {
+        return false;
+    }
+    Q_Q(UCServiceProperties);
+    QDBusInterface readIFace(iface->interface(), objectPath, "org.freedesktop.DBus.Properties", connection);
+    if (!readIFace.isValid()) {
+        // report invalid interface only if the property's first letter was with capital one!
+        if (property[0].isUpper()) {
+            qmlInfo(q) << readIFace.lastError().message();
+        }
+        return false;
+    }
+    QDBusPendingCall pending = readIFace.asyncCall("Get", adaptor, property);
+    if (pending.isError()) {
+        qmlInfo(q) << pending.error().message();
+        return false;
+    }
+    QDBusPendingCallWatcher *callWatcher = new QDBusPendingCallWatcher(pending, q);
+    QObject::connect(callWatcher, SIGNAL(finished(QDBusPendingCallWatcher*)),
+                     this, SLOT(readFinished(QDBusPendingCallWatcher*)));
+
+    // set a dynamic property so we know which property are we reading
+    callWatcher->setProperty(DYNAMIC_PROPERTY, property);
+    return true;
+}
+
+/*
+ * Writes a property value to theadaptorInterface synchronously. It is for pure testing purposes.
+ */
+bool DBusServiceProperties::testProperty(const QString &property, const QVariant &value)
+{
+    if (objectPath.isEmpty()) {
+        return false;
+    }
+    QDBusInterface writeIFace(iface->interface(), objectPath, "org.freedesktop.DBus.Properties", connection);
+    if (!writeIFace.isValid()) {
+        // invalid interface
+        return false;
+    }
+    QDBusMessage msg = writeIFace.call("Set", adaptor, property, QVariant::fromValue(QDBusVariant(value)));
+    return msg.type() == QDBusMessage::ReplyMessage;
+}
+
+/*
+ * Slot called when the async read operation finishes.
+ */
+void DBusServiceProperties::readFinished(QDBusPendingCallWatcher *call)
+{
+    Q_Q(UCServiceProperties);
+    QDBusPendingReply<QVariant> reply = *call;
+    QString property = call->property(DYNAMIC_PROPERTY).toString();
+    scannedProperties.removeAll(property);
+    if (reply.isError()) {
+        // remove the property from being watched, as it has no property like that
+        properties.removeAll(property);
+        if (property[0].isUpper()) {
+            // report error!
+            qmlInfo(q) << reply.error().message();
+        }
+    } else {
+        // update watched property value
+        // make sure we have lower case when the property value is updated
+        property[0] = property[0].toLower();
+        q->setProperty(property.toLocal8Bit().constData(), reply.value());
+    }
+
+    if ((status == UCServiceProperties::Synchronizing) && scannedProperties.isEmpty()) {
+        // set status to active
+        setStatus(UCServiceProperties::Active);
+    }
+
+    // delete watcher
+    call->deleteLater();
+}
+
+/*
+ * Slot called when service owner is changed.
+ */
+void DBusServiceProperties::changeServiceOwner(const QString &serviceName, const QString &oldOwner, const QString &newOwner)
+{
+    Q_UNUSED(oldOwner);
+    Q_UNUSED(newOwner);
+    if (serviceName != service) {
+        return;
+    }
+    setupInterface();
+}
+
+/*
+ * Slot called when the properties are changed in the service.
+ */
+void DBusServiceProperties::updateProperties(const QString &onInterface, const QVariantMap &map, const QStringList &invalidated)
+{
+    Q_UNUSED(onInterface);
+    Q_UNUSED(map);
+    Q_FOREACH(const QString &property, invalidated) {
+        readProperty(property);
+    }
+}

=== added file 'modules/Ubuntu/Components/plugin/adapters/dbuspropertywatcher_p.h'
--- modules/Ubuntu/Components/plugin/adapters/dbuspropertywatcher_p.h	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/plugin/adapters/dbuspropertywatcher_p.h	2015-02-04 14:00:19 +0000
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program 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; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef DBUSPROPERTYWATCHER_P_H
+#define DBUSPROPERTYWATCHER_P_H
+
+#include <QtCore/QObject>
+#include <QtDBus/QDBusConnection>
+#include <QtDBus/QDBusServiceWatcher>
+#include <QtDBus/QDBusInterface>
+
+#include "ucserviceproperties_p.h"
+
+class QDBusPendingCallWatcher;
+class DBusServiceProperties : public QObject, public UCServicePropertiesPrivate
+{
+    Q_OBJECT
+    Q_DECLARE_PUBLIC(UCServiceProperties)
+public:
+    DBusServiceProperties(UCServiceProperties *qq);
+
+    bool init();
+    bool fetchPropertyValues();
+    bool readProperty(const QString &property);
+    // for testing purposes only!!!
+    bool testProperty(const QString &property, const QVariant &value);
+
+    QStringList scannedProperties;
+    QDBusConnection connection;
+    QDBusServiceWatcher *watcher;
+    QDBusInterface *iface;
+    QString objectPath;
+
+    bool setupInterface();
+
+public Q_SLOTS:
+    void readFinished(QDBusPendingCallWatcher *watcher);
+    void changeServiceOwner(const QString &serviceName, const QString &oldOwner, const QString &newOwner);
+    void updateProperties(const QString &iface, const QVariantMap &map, const QStringList &invalidated);
+};
+
+#endif // DBUSPROPERTYWATCHER_P_H

=== modified file 'modules/Ubuntu/Components/plugin/plugin.cpp'
--- modules/Ubuntu/Components/plugin/plugin.cpp	2014-10-07 14:37:16 +0000
+++ modules/Ubuntu/Components/plugin/plugin.cpp	2015-02-04 14:00:19 +0000
@@ -52,6 +52,7 @@
 #include "ucaction.h"
 #include "ucactioncontext.h"
 #include "ucactionmanager.h"
+#include "ucserviceproperties.h"
 
 #include <sys/types.h>
 #include <unistd.h>
@@ -162,6 +163,7 @@
     qmlRegisterType<QSortFilterProxyModelQML>(uri, 1, 1, "SortFilterModel");
     qmlRegisterUncreatableType<FilterBehavior>(uri, 1, 1, "FilterBehavior", "Not instantiable");
     qmlRegisterUncreatableType<SortBehavior>(uri, 1, 1, "SortBehavior", "Not instantiable");
+    qmlRegisterType<UCServiceProperties, 1>(uri, 1, 1, "ServiceProperties");
 }
 
 void UbuntuComponentsPlugin::initializeEngine(QQmlEngine *engine, const char *uri)

=== modified file 'modules/Ubuntu/Components/plugin/plugin.pro'
--- modules/Ubuntu/Components/plugin/plugin.pro	2014-10-07 14:37:16 +0000
+++ modules/Ubuntu/Components/plugin/plugin.pro	2015-02-04 14:00:19 +0000
@@ -68,7 +68,10 @@
     ucaction.h \
     ucactioncontext.h \
     ucactionmanager.h \
-    adapters/actionsproxy_p.h
+    adapters/actionsproxy_p.h \
+    adapters/dbuspropertywatcher_p.h \
+    ucserviceproperties.h \
+    ucserviceproperties_p.h
 
 SOURCES += plugin.cpp \
     uctheme.cpp \
@@ -105,7 +108,9 @@
     ucaction.cpp \
     ucactioncontext.cpp \
     ucactionmanager.cpp \
-    adapters/actionsproxy_p.cpp
+    adapters/actionsproxy_p.cpp \
+    adapters/dbuspropertywatcher_p.cpp \
+    ucserviceproperties.cpp
 
 # adapters
 SOURCES += adapters/alarmsadapter_organizer.cpp

=== added file 'modules/Ubuntu/Components/plugin/ucserviceproperties.cpp'
--- modules/Ubuntu/Components/plugin/ucserviceproperties.cpp	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/plugin/ucserviceproperties.cpp	2015-02-04 14:00:19 +0000
@@ -0,0 +1,317 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program 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; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "ucserviceproperties.h"
+#include "ucserviceproperties_p.h"
+#include "i18n.h"
+#include <QtQml/QQmlInfo>
+#include <QtCore/QMetaProperty>
+#include <QtQml/QQmlProperty>
+#include <QtQml/private/qqmlproperty_p.h>
+
+UCServicePropertiesPrivate::UCServicePropertiesPrivate(UCServiceProperties *qq)
+    : q_ptr(qq)
+    , ready(false)
+    , status(UCServiceProperties::Inactive)
+    , type(UCServiceProperties::System)
+{
+}
+
+UCServicePropertiesPrivate::~UCServicePropertiesPrivate()
+{
+}
+
+UCServicePropertiesPrivate *UCServicePropertiesPrivate::get(UCServiceProperties *service)
+{
+    return service->d_func();
+}
+
+void UCServicePropertiesPrivate::setError(const QString &msg)
+{
+    if (error == msg) {
+        return;
+    }
+    error = msg;
+    Q_EMIT q_ptr->errorChanged();
+}
+
+void UCServicePropertiesPrivate::setStatus(UCServiceProperties::Status status)
+{
+    if (this->status == status) {
+        return;
+    }
+    this->status = status;
+    Q_EMIT q_ptr->statusChanged();
+}
+
+void printLocked(UCServiceProperties *owner)
+{
+    qmlInfo(owner) << UbuntuI18n::instance().tr("Changing connection parameters forbidden.");
+}
+
+/*!
+ * \qmltype ServiceProperties
+ * \instantiates UCServiceProperties
+ * \inqmlmodule Ubuntu.Components 1.1
+ * \since Ubuntu.Components 1.1
+ * \ingroup ubuntu-services
+ * \brief The component enables accessing service properties from QML.
+ *
+ * The services accessed by the component are ones providing their interfaces
+ * through DBus. The component is specialized to read properties exposed by these
+ * services, andf to keep these property values up to date. It is not meant to
+ * access signals or slots exposed, nor to change the values of the properties
+ * watched.
+ *
+ * Properties watched should be declared within the body of the component like
+ * any other QML property, preferably defining a default value for them. The component
+ * will enumerate these properties and will ask the service to provide values for
+ * those. When enumerating properties, each property will be checked twice, with
+ * the case specified as well as with the first letter capitalized.
+ * \qml
+ * import QtQuick 2.3
+ * import Ubuntu.Components 1.1
+ *
+ * ServiceProperties {
+ *     service: "org.freenode.AccountsService"
+ *     path: "/org/freenode/AccountsService"
+ *     serviceInterface: "org.freenode.AccountsService"
+ *     adaptorInterface: "com.ubuntu.touch.Accounts.Sound"
+ *     // listing properties to watch
+ *     // each property name existence will be checked against the current case
+ *     // as well as with first character capitalized
+ *     property bool incomingCallVibrate: true
+ * }
+ * \endqml
+ *
+ * Note that there are few properties which must be set in order the component
+ * to work. These are \l service, \l path and \l adaptorInterface. Also, once
+ * specified, \l service, \l serviceInterface and \l adaptorInterface values
+ * should not be changed as it cannot be guaranteed that properties watched will
+ * be available on those service. Therefore any change on these properties after
+ * the component completion will be ignored. Property bindings on properties
+ * watched will be ignored as well, as service will report changes in these property
+ * values.
+ *
+ * The service is connected once the component gets completed (Component.onCompleted).
+ * The \l error property specifies any error occured during connection, and the
+ * \l status property notifies whether the connection to the service is active or not.
+ *
+ * \note Pay attention when chosing the service watched, and set your application's
+ * AppArmor rights to ensure a successful service connection.
+ */
+UCServiceProperties::UCServiceProperties(QObject *parent)
+    : QObject(parent)
+    , d_ptr(createServicePropertiesAdapter(this))
+{
+}
+UCServiceProperties::~UCServiceProperties()
+{
+    delete d_ptr;
+    d_ptr = 0;
+}
+
+void UCServiceProperties::classBegin()
+{
+}
+
+void UCServiceProperties::componentComplete()
+{
+    Q_D(UCServiceProperties);
+    d->ready = true;
+    // enumerate properties
+    const QMetaObject *mo = metaObject();
+    for (int i = mo->propertyOffset(); i < mo->propertyCount(); i++) {
+        const QMetaProperty prop = mo->property(i);
+        QString property(prop.name());
+
+        // check the binding on the property and warn if there is one.
+        QQmlProperty qmlProperty(this, property);
+        if (QQmlPropertyPrivate::binding(qmlProperty)) {
+            qmlInfo(this) << UbuntuI18n::instance().
+                             tr("Binding detected on property '%1' will be removed by the service updates.").
+                             arg(property);
+        }
+        // insert both the declared and capitalized first character properties
+        d->properties << property;
+        property[0] = property[0].toUpper();
+        d->properties << property;
+    }
+    // initialize DBus
+    if (d->init()) {
+        d->setStatus(UCServiceProperties::Synchronizing);
+        d->fetchPropertyValues();
+    }
+}
+
+/*!
+ * \qmlproperty enum ServiceProperties::type
+ * Specifies the DBus connection session type. It can get the following values:
+ * \list
+ *  \li - \e ServiceProperties.System when system bus is used (default)
+ *  \li - \e ServiceProperties.Session when session bus is used
+ * \endlist
+ */
+UCServiceProperties::ServiceType UCServiceProperties::type() const
+{
+    Q_D(const UCServiceProperties);
+    return d->type;
+}
+void UCServiceProperties::setType(ServiceType type)
+{
+    Q_D(UCServiceProperties);
+    if (d->type == type) {
+        return;
+    }
+    if (d->ready) {
+        printLocked(this);
+        return;
+    }
+    d->type = type;
+    Q_EMIT typeChanged();
+}
+
+/*!
+ * \qmlproperty string ServiceProperties::service
+ * The proeprty specifies the DBus service URI. It is mandatory to be specified.
+ */
+QString UCServiceProperties::service() const
+{
+    Q_D(const UCServiceProperties);
+    return d->service;
+}
+void UCServiceProperties::setService(const QString &value)
+{
+    Q_D(UCServiceProperties);
+    if (d->service == value) {
+        return;
+    }
+    if (d->ready) {
+        printLocked(this);
+        return;
+    }
+    d->service = value;
+    Q_EMIT serviceChanged();
+}
+
+/*!
+ * \qmlproperty string ServiceProperties::path
+ * The property specifies the DBus service connection path. It is mandatory to be
+ * specified.
+ */
+QString UCServiceProperties::path() const
+{
+    Q_D(const UCServiceProperties);
+    return d->path;
+}
+void UCServiceProperties::setPath(const QString &value)
+{
+    Q_D(UCServiceProperties);
+    if (d->path == value) {
+        return;
+    }
+    d->path = value;
+    Q_EMIT pathChanged();
+    if (d->ready) {
+        // need to re-initialize connections
+        d->init();
+    }
+}
+
+/*!
+ * \qmlproperty string ServiceProperties::serviceInterface
+ * The property specifies the service intertface. If it is an empty string, the
+ * component will refer to the merging of all interfaces found in the service.
+ */
+QString UCServiceProperties::interface() const
+{
+    Q_D(const UCServiceProperties);
+    return d->interface;
+}
+void UCServiceProperties::setInterface(const QString &value)
+{
+    Q_D(UCServiceProperties);
+    if (d->interface == value) {
+        return;
+    }
+    if (d->ready) {
+        printLocked(this);
+        return;
+    }
+    d->interface = value;
+    Q_EMIT serviceInterfaceChanged();
+}
+/*!
+ * \qmlproperty string ServiceProperties::adaptorInterface
+ * The proeprty specifies the dbus adaptor interface which provides the properties
+ * watched. This can be a different interface that the one specified in \l serviceInterface,
+ * and in the same way, it can be empty, in which case all the properties from all
+ * interfaces of the service will be watched.
+ */
+QString UCServiceProperties::adaptor() const
+{
+    Q_D(const UCServiceProperties);
+    return d->adaptor;
+}
+void UCServiceProperties::setAdaptor(const QString &value)
+{
+    Q_D(UCServiceProperties);
+    if (d->adaptor == value) {
+        return;
+    }
+    if (d->ready) {
+        printLocked(this);
+        return;
+    }
+    d->adaptor = value;
+    Q_EMIT adaptorInterfaceChanged();
+}
+
+/*!
+ * \qmlproperty string ServiceProperties::error
+ * The property is set with a human readablestring each time an error occurrs
+ * during the service connection. Empty string means no error.
+ */
+QString UCServiceProperties::error()
+{
+    Q_D(UCServiceProperties);
+    return d->error;
+}
+
+/*!
+ * \qmlproperty enum ServiceProperties::status
+ * The property presents the status of the component.
+ * \list
+ *  \li - \e ServiceProperties.Inactive - the component is inactive, initial state
+ *  \li - \e ServiceProperties.ConnectionError - there was a connection error, the
+ *      \l error contains the error string.
+ *  \li - \e ServiceProperties.Synchronizing - the connection to the service succeeded,
+ *      and the properties are being synchronized;
+ *  \li - \e ServiceProperties.Active - the service watcher is active and initial
+ *      property synchronization completed.
+ * \endlist
+ * \note While the status is set to \e Synchronizing, the properties are checked
+ * against their existence in the service. Each proeprty will be checked as declared
+ * as well with capital first letter. If neither of these exists in the service,
+ * it will be reported in the \l error property separately.
+ */
+UCServiceProperties::Status UCServiceProperties::status() const
+{
+    Q_D(const UCServiceProperties);
+    return d->status;
+}
+
+#include "moc_ucserviceproperties.cpp"

=== added file 'modules/Ubuntu/Components/plugin/ucserviceproperties.h'
--- modules/Ubuntu/Components/plugin/ucserviceproperties.h	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/plugin/ucserviceproperties.h	2015-02-04 14:00:19 +0000
@@ -0,0 +1,83 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program 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; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef UCSERVICEPROPERTIES_H
+#define UCSERVICEPROPERTIES_H
+
+#include <QtCore/QObject>
+#include <QtQml/QQmlParserStatus>
+
+class UCServicePropertiesPrivate;
+class UCServiceProperties : public QObject, public QQmlParserStatus
+{
+    Q_OBJECT
+    Q_INTERFACES(QQmlParserStatus)
+
+    Q_PROPERTY(ServiceType type READ type WRITE setType NOTIFY typeChanged REVISION 1)
+    Q_PROPERTY(QString service READ service WRITE setService NOTIFY serviceChanged REVISION 1)
+    Q_PROPERTY(QString path READ path WRITE setPath NOTIFY pathChanged REVISION 1)
+    Q_PROPERTY(QString serviceInterface READ interface WRITE setInterface NOTIFY serviceInterfaceChanged REVISION 1)
+    Q_PROPERTY(QString adaptorInterface READ adaptor WRITE setAdaptor NOTIFY adaptorInterfaceChanged REVISION 1)
+    Q_PROPERTY(QString error READ error NOTIFY errorChanged REVISION 1)
+    Q_PROPERTY(Status status READ status NOTIFY statusChanged REVISION 1)
+
+    Q_ENUMS(ServiceType Status)
+public:
+    enum ServiceType {
+        Undefined,
+        System,
+        Session
+    };
+    enum Status {
+        Inactive,
+        ConnectionError,
+        Synchronizing,
+        Active
+    };
+
+    explicit UCServiceProperties(QObject *parent = 0);
+    ~UCServiceProperties();
+    void classBegin();
+    void componentComplete();
+
+    ServiceType type() const;
+    void setType(ServiceType type);
+    QString service() const;
+    void setService(const QString &value);
+    QString path() const;
+    void setPath(const QString &value);
+    QString interface() const;
+    void setInterface(const QString &value);
+    QString adaptor() const;
+    void setAdaptor(const QString &value);
+    QString error();
+    Status status() const;
+
+Q_SIGNALS:
+    void typeChanged();
+    void serviceChanged();
+    void pathChanged();
+    void serviceInterfaceChanged();
+    void adaptorInterfaceChanged();
+    void errorChanged();
+    void statusChanged();
+
+private:
+    UCServicePropertiesPrivate *d_ptr;
+    Q_DECLARE_PRIVATE_D(d_ptr, UCServiceProperties)
+};
+
+#endif // UCSERVICEPROPERTIES_H

=== added file 'modules/Ubuntu/Components/plugin/ucserviceproperties_p.h'
--- modules/Ubuntu/Components/plugin/ucserviceproperties_p.h	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/plugin/ucserviceproperties_p.h	2015-02-04 14:00:19 +0000
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program 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; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef UCSERVICEPROPERTIES_P_H
+#define UCSERVICEPROPERTIES_P_H
+
+#include "ucserviceproperties.h"
+#include <QtCore/QStringList>
+
+class UCServicePropertiesPrivate
+{
+public:
+    UCServicePropertiesPrivate(UCServiceProperties *qq);
+    virtual ~UCServicePropertiesPrivate();
+
+    static UCServicePropertiesPrivate *get(UCServiceProperties *service);
+    void setError(const QString &msg);
+    void setStatus(UCServiceProperties::Status status);
+
+    virtual bool init() = 0;
+    virtual bool fetchPropertyValues() = 0;
+    virtual bool readProperty(const QString &property) = 0;
+    virtual bool testProperty(const QString &property, const QVariant &value) = 0;
+
+    // data
+    UCServiceProperties *q_ptr;
+    bool ready:1;
+    UCServiceProperties::Status status;
+    UCServiceProperties::ServiceType type;
+    QString service;
+    QString path;
+    QString interface;
+    QString adaptor;
+    QString error;
+    QStringList properties;
+};
+
+UCServicePropertiesPrivate *createServicePropertiesAdapter(UCServiceProperties *owner);
+
+#endif // UCSERVICEPROPERTIES_P_H

=== modified file 'tests/unit/runtest.sh'
--- tests/unit/runtest.sh	2014-09-16 08:19:14 +0000
+++ tests/unit/runtest.sh	2015-02-04 14:00:19 +0000
@@ -22,18 +22,18 @@
 _TESTFILE=$2
 _MINIMAL=$3
 _XML="../../test_$_TARGET_$_TESTFILE.xml"
-_ARGS="-o $_XML,xunitxml -o -,txt"
+_ARGS="-p -o -p $_XML,xunitxml -p -o -p -,txt"
 set +e
 
 function create_test_cmd {
-  _CMD="./$_TARGET"
+  _CMD="dbus-test-runner --task ./$_TARGET -n $_TESTFILE -m 300"
   if [ "$_MINIMAL" = "minimal" ]; then
-      _CMD="$_CMD -platform minimal"
+      _CMD="$_CMD -p -platform -p minimal"
   fi
   if [ $_TARGET != $_TESTFILE ]; then
-      _CMD="$_CMD -input $_TESTFILE"
+      _CMD="$_CMD -p -input -p $_TESTFILE"
   fi
-  _CMD="$_CMD -maxwarnings 40"
+  _CMD="$_CMD -p -maxwarnings -p 40"
 }
 
 function execute_test_cmd {

=== added directory 'tests/unit_x11/tst_serviceproperties'
=== added file 'tests/unit_x11/tst_serviceproperties/IncomingCallVibrateWatcher.qml'
--- tests/unit_x11/tst_serviceproperties/IncomingCallVibrateWatcher.qml	1970-01-01 00:00:00 +0000
+++ tests/unit_x11/tst_serviceproperties/IncomingCallVibrateWatcher.qml	2015-02-04 14:00:19 +0000
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program 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; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.3
+import Ubuntu.Components 1.1
+
+Item {
+    property alias service: service
+    ServiceProperties {
+        id: service
+        service: "org.freedesktop.Accounts"
+        serviceInterface: "org.freedesktop.Accounts"
+        path: "/org/freedesktop/Accounts"
+        adaptorInterface: "com.ubuntu.touch.AccountsService.Sound"
+
+        property bool incomingCallVibrate: true
+    }
+}

=== added file 'tests/unit_x11/tst_serviceproperties/InvalidPropertyWatcher.qml'
--- tests/unit_x11/tst_serviceproperties/InvalidPropertyWatcher.qml	1970-01-01 00:00:00 +0000
+++ tests/unit_x11/tst_serviceproperties/InvalidPropertyWatcher.qml	2015-02-04 14:00:19 +0000
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program 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; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.3
+import Ubuntu.Components 1.1
+
+Item {
+    property alias service: service
+    ServiceProperties {
+        id: service
+        service: "org.freedesktop.Accounts"
+        serviceInterface: "org.freedesktop.Accounts"
+        path: "/org/freedesktop/Accounts"
+        adaptorInterface: "com.ubuntu.touch.AccountsService.Sound"
+
+        property bool thisIsAnInvalidPropertyToWatch: true
+    }
+}

=== added file 'tests/unit_x11/tst_serviceproperties/InvalidPropertyWatcher2.qml'
--- tests/unit_x11/tst_serviceproperties/InvalidPropertyWatcher2.qml	1970-01-01 00:00:00 +0000
+++ tests/unit_x11/tst_serviceproperties/InvalidPropertyWatcher2.qml	2015-02-04 14:00:19 +0000
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program 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; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.3
+import Ubuntu.Components 1.1
+
+Item {
+    property alias service: service
+    ServiceProperties {
+        id: service
+        service: "org.freedesktop.Accounts"
+        serviceInterface: "org.freedesktop.Accounts"
+        path: "/org/freedesktop/Accounts"
+        adaptorInterface: "com.ubuntu.touch.AccountsService.Sound"
+
+        property bool thisIsAnInvalidPropertyToWatch: true
+        property bool incomingCallVibrate: true
+    }
+}

=== added file 'tests/unit_x11/tst_serviceproperties/tst_serviceproperties.cpp'
--- tests/unit_x11/tst_serviceproperties/tst_serviceproperties.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit_x11/tst_serviceproperties/tst_serviceproperties.cpp	2015-02-04 14:00:19 +0000
@@ -0,0 +1,146 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This program 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; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "uctestcase.h"
+#include "ucserviceproperties.h"
+#include "ucserviceproperties_p.h"
+#include <QtCore/QString>
+#include <QtCore/QDebug>
+#include <QtTest/QTest>
+#include <QtTest/QSignalSpy>
+
+class tst_ServiceProperties : public QObject
+{
+    Q_OBJECT
+
+public:
+    tst_ServiceProperties() {}
+
+private:
+
+    QString error;
+
+    // FIXME use UbuntuTestCase::ignoreWaring in Vivid
+    void ignoreWarning(const QString& fileName, uint line, uint column, const QString& message, uint occurences=1)
+    {
+        for (uint i = 0; i < occurences; i++) {
+            QString url(QUrl::fromLocalFile(QFileInfo(fileName).absoluteFilePath()).toEncoded());
+            QString warning(QString("%1:%2:%3: %4").arg(url).arg(line).arg(column).arg(message));
+            QTest::ignoreMessage(QtWarningMsg, warning.toUtf8());
+        }
+    }
+
+
+private Q_SLOTS:
+
+    void initTestCase()
+    {
+        // check if the connection is possible, otherwise we must skip all tests
+        QScopedPointer<UbuntuTestCase> test(new UbuntuTestCase("IncomingCallVibrateWatcher.qml"));
+        UCServiceProperties *watcher = static_cast<UCServiceProperties*>(test->rootObject()->property("service").value<QObject*>());
+        QVERIFY(watcher);
+        if (watcher->status() == UCServiceProperties::Synchronizing ||
+            watcher->status() == UCServiceProperties::Inactive) {
+            QSignalSpy wait(watcher, SIGNAL(statusChanged()));
+            wait.wait();
+        }
+        if (watcher->status() == UCServiceProperties::ConnectionError) {
+            error = "Skip test: " + watcher->error();
+        }
+    }
+
+    void test_change_property()
+    {
+        if (!error.isEmpty()) {
+            QSKIP(qPrintable(error));
+        }
+        QScopedPointer<UbuntuTestCase> test(new UbuntuTestCase("IncomingCallVibrateWatcher.qml"));
+        UCServiceProperties *watcher = static_cast<UCServiceProperties*>(test->rootObject()->property("service").value<QObject*>());
+        QVERIFY(watcher);
+
+        bool backup = watcher->property("incomingCallVibrate").toBool();
+        UCServicePropertiesPrivate *pWatcher = UCServicePropertiesPrivate::get(watcher);
+        QSignalSpy spy(watcher, SIGNAL(incomingCallVibrateChanged()));
+        pWatcher->testProperty("IncomingCallVibrate", !backup);
+        spy.wait(400);
+        QCOMPARE(spy.count(), 1);
+        QCOMPARE(watcher->property("incomingCallVibrate").toBool(), !backup);
+
+        // restore value
+        spy.clear();
+        pWatcher->testProperty("IncomingCallVibrate", backup);
+        spy.wait(400);
+    }
+
+    void test_invalid_property()
+    {
+        if (!error.isEmpty()) {
+            QSKIP(qPrintable(error));
+        }
+        ignoreWarning("InvalidPropertyWatcher.qml", 22, 5, "QML ServiceProperties: No such property 'ThisIsAnInvalidPropertyToWatch'");
+        QScopedPointer<UbuntuTestCase> test(new UbuntuTestCase("InvalidPropertyWatcher.qml"));
+        UCServiceProperties *watcher = static_cast<UCServiceProperties*>(test->rootObject()->property("service").value<QObject*>());
+        QVERIFY(watcher);
+        // error should not be set
+        QCOMPARE(watcher->property("error").toString(), QString());
+    }
+
+    void test_one_valid_one_invalid_property()
+    {
+        if (!error.isEmpty()) {
+            QSKIP(qPrintable(error));
+        }
+        ignoreWarning("InvalidPropertyWatcher2.qml", 22, 5, "QML ServiceProperties: No such property 'ThisIsAnInvalidPropertyToWatch'");
+        QScopedPointer<UbuntuTestCase> test(new UbuntuTestCase("InvalidPropertyWatcher2.qml"));
+        UCServiceProperties *watcher = static_cast<UCServiceProperties*>(test->rootObject()->property("service").value<QObject*>());
+        QVERIFY(watcher);
+        // error should not be set
+        QCOMPARE(watcher->property("error").toString(), QString());
+    }
+
+    void test_change_connection_props_data()
+    {
+        QTest::addColumn<QString>("property");
+        QTest::addColumn<QString>("value");
+
+        QTest::newRow("Changing servcie") << "service" << "anything.else";
+        QTest::newRow("Changing interface") << "serviceInterface" << "anything.else";
+        QTest::newRow("Changing adaptor") << "adaptorInterface" << "anything.else";
+    }
+    void test_change_connection_props()
+    {
+        QFETCH(QString, property);
+        QFETCH(QString, value);
+
+        if (!error.isEmpty()) {
+            QSKIP(qPrintable(error));
+        }
+        ignoreWarning("IncomingCallVibrateWatcher.qml", 22, 5, "QML ServiceProperties: Changing connection parameters forbidden.");
+        QScopedPointer<UbuntuTestCase> test(new UbuntuTestCase("IncomingCallVibrateWatcher.qml"));
+        UCServiceProperties *watcher = static_cast<UCServiceProperties*>(test->rootObject()->property("service").value<QObject*>());
+        QVERIFY(watcher);
+
+        // try to change the property
+        watcher->setProperty(property.toLocal8Bit().constData(), value);
+        // no error should be reported
+        QCOMPARE(watcher->property("error").toString(), QString());
+    }
+
+};
+
+QTEST_MAIN(tst_ServiceProperties)
+
+#include "tst_serviceproperties.moc"

=== added file 'tests/unit_x11/tst_serviceproperties/tst_serviceproperties.pro'
--- tests/unit_x11/tst_serviceproperties/tst_serviceproperties.pro	1970-01-01 00:00:00 +0000
+++ tests/unit_x11/tst_serviceproperties/tst_serviceproperties.pro	2015-02-04 14:00:19 +0000
@@ -0,0 +1,8 @@
+include(../test-include.pri)
+SOURCES += \
+    tst_serviceproperties.cpp
+
+OTHER_FILES += \
+    IncomingCallVibrateWatcher.qml \
+    InvalidPropertyWatcher.qml \
+    InvalidPropertyWatcher2.qml

=== modified file 'tests/unit_x11/unit_x11.pro'
--- tests/unit_x11/unit_x11.pro	2014-08-13 11:21:04 +0000
+++ tests/unit_x11/unit_x11.pro	2015-02-04 14:00:19 +0000
@@ -11,4 +11,5 @@
     tst_orientation \
     tst_layouts \
     tst_mousefilters \
-    tst_animator
+    tst_animator \
+    tst_serviceproperties