Merge lp:~zsombi/ubuntu-ui-toolkit/serviceproperties-component into lp:ubuntu-ui-toolkit/staging

[Zsombor Egri]

ServiceProperties component to Ubuntu.Components 1.1.

[Cris Dywan (kalikiana)]

We need a test case for when accountservice is not available - if we don't want a hard dependency it can't be causing errors at runtime.

995 + QVERIFY(watcher->property("error").toString().isEmpty());
1009 + QVERIFY(watcher->property("error").toString().isEmpty());
1039 + QCOMPARE(errorSpy.count(), 0);

Please change all 3 cases where error is checked to a COMPARE so that the error becomes visible in the log.

785 - _CMD="./$_TARGET"
786 + _CMD="dbus-test-runner --task ./$_TARGET -n $_TESTFILE -m 30"

This must be 300 otherwise some tests time out.

review: Needs Fixing

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1353
http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/1314/
Executed test runs:
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-vivid-touch/475
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-amd64-ci/47/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/47
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/47/artifact/work/output/*zip*/output.zip
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-i386-ci/47/console
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-runner-vivid-mako/420
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/475
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/475/artifact/work/output/*zip*/output.zip
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/16444

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/1314/rebuild

review: Needs Fixing (continuous-integration)

[lp:~zsombi/ubuntu-ui-toolkit/serviceproperties-component]

1354. By Zsombor Egri on 2014-12-03

review comments applied

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1354
http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/1316/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-vivid-touch/478
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-amd64-ci/49
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/49
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/49/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-i386-ci/49
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-runner-vivid-mako/422
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/478
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/478/artifact/work/output/*zip*/output.zip
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/16449

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/1316/rebuild

review: Approve (continuous-integration)

[Cris Dywan (kalikiana)]

It passed!

review: Approve

=== modified file 'debian/control'
--- debian/control	2014-11-21 08:23:22 +0000
+++ debian/control	2014-12-03 10:22:28 +0000
@@ -38,6 +38,8 @@
                libdbus-1-dev,
                libnih-dbus-dev,
                dbus,
+               dbus-test-runner,
+               accountsservice,
                xvfb,
                libgl1-mesa-dri,
                locales,

=== 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	2014-12-03 10:22:28 +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	2014-12-03 10:22:28 +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

=== 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	2014-12-03 10:22:28 +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	2014-12-03 10:22:28 +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	2014-12-03 10:22:28 +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-11-18 14:31:53 +0000
+++ tests/unit/runtest.sh	2014-12-03 10:22:28 +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	2014-12-03 10:22:28 +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	2014-12-03 10:22:28 +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	2014-12-03 10:22:28 +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	2014-12-03 10:22:28 +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	2014-12-03 10:22:28 +0000
@@ -0,0 +1,8 @@
+include(../test-include.pri)
+SOURCES += \
+    tst_serviceproperties.cpp
+
+OTHER_FILES += \
+    IncomingCallVibrateWatcher.qml \
+    InvalidPropertyWatcher.qml \
+    InvalidPropertyWatcher2.qml