Merge lp:~gerboland/qtubuntu-sensors/add-gyro-magnet-sensors into lp:qtubuntu-sensors

[Gerry Boland]

Enable Gyroscope and Magnetic sensors

[Lorn Potter (lorn-potter)]

\0/

[Lorn Potter (lorn-potter)]

You will want to add the new sensors to QSensors.conf in data/ in order for these to be available to Qt/QML.

review: Needs Fixing

[lp:~gerboland/qtubuntu-sensors/add-gyro-magnet-sensors]

90. By Gerry Boland on 2016-02-10

Use lowercase for magnetometer plugin id, match other sensor ids

91. By Gerry Boland on 2016-02-10

Declare magnetometer & gyroscope sensors as being implemented in the plugin

[Gerry Boland (gerboland)]

So very sorry about that.

[Lorn Potter (lorn-potter)]

lgtm

review: Approve

[lp:~gerboland/qtubuntu-sensors/add-gyro-magnet-sensors]

92. By Gerry Boland on 2016-03-22

Fix typo

93. By Gerry Boland on 2016-03-22

Typo typo

94. By Gerry Boland on 2016-03-22

Fix signal name and thus build

95. By Gerry Boland on 2016-03-22

Fix signal name error

[Timo Jyrinki (timo-jyrinki)]

It seems this is pending in https://requests.ci-train.ubuntu.com/#/ticket/1099

Unmerged revisions

95. By Gerry Boland on 2016-03-22

Fix signal name error

94. By Gerry Boland on 2016-03-22

Fix signal name and thus build

93. By Gerry Boland on 2016-03-22

Typo typo

92. By Gerry Boland on 2016-03-22

Fix typo

91. By Gerry Boland on 2016-02-10

Declare magnetometer & gyroscope sensors as being implemented in the plugin

90. By Gerry Boland on 2016-02-10

Use lowercase for magnetometer plugin id, match other sensor ids

89. By Gerry Boland on 2016-01-08

Merge trunk

88. By Gerry Boland on 2016-01-08

Enable Gyroscope and Magnetic sensors

=== modified file 'data/Sensors.conf'
--- data/Sensors.conf	2014-01-07 07:58:10 +0000
+++ data/Sensors.conf	2016-03-22 17:02:47 +0000
@@ -1,3 +1,5 @@
 [Default]
 QAccelerometer = core.accelerometer
 QOrientationSensor = core.orientationsensor
+QGyroscope = core.gyroscope
+QMagnetometer = core.magnetometer
\ No newline at end of file

=== modified file 'plugins/sensors/CMakeLists.txt'
--- plugins/sensors/CMakeLists.txt	2014-01-10 16:51:27 +0000
+++ plugins/sensors/CMakeLists.txt	2016-03-22 17:02:47 +0000
@@ -10,14 +10,22 @@
   qtubuntu_sensors_plugins SHARED
 
   core_accelerometer.h
+  core_gyroscope.h
+  core_magnetometer.h
   core_orientation_sensor.h
   core_sensor_plugins.h
   core_shared_accelerometer.h
+  core_shared_gyroscope.h
+  core_shared_magnetometer.h
 
   core_accelerometer.cpp
+  core_gyroscope.cpp
+  core_magnetometer.cpp
   core_orientation_sensor.cpp
   core_sensor_plugins.cpp
   core_shared_accelerometer.cpp
+  core_shared_gyroscope.cpp
+  core_shared_magnetometer.cpp
 
   ${SENSORS_RESOURCES}
 )

=== added file 'plugins/sensors/core_gyroscope.cpp'
--- plugins/sensors/core_gyroscope.cpp	1970-01-01 00:00:00 +0000
+++ plugins/sensors/core_gyroscope.cpp	2016-03-22 17:02:47 +0000
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2015 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 "core_gyroscope.h"
+#include "core_shared_gyroscope.h"
+
+#include <QDebug>
+
+core::Gyroscope::Gyroscope(QSensor *sensor)
+    : QSensorBackend(sensor)
+{
+    // Register the reading instance with the parent
+    setReading<QGyroscopeReading>(&m_reading);
+
+    const qreal minDelay = core::SharedGyroscope::instance().getMinDelay();
+    if (minDelay > -1)
+    {
+        // Min and max sensor sampling frequencies, in Hz
+        addDataRate(minDelay, minDelay * 10);
+    }
+    addOutputRange(core::SharedGyroscope::instance().getMinValue(),
+                   core::SharedGyroscope::instance().getMaxValue(),
+                   core::SharedGyroscope::instance().getResolution());
+
+    // Connect to the Gyroscope's readingChanged signal
+    // This has to be a queued connection as the sensor callback
+    // from the platform API can happen on an arbitrary thread.
+    connect(
+        &core::SharedGyroscope::instance(),
+        SIGNAL(gyroscopeReadingChanged(QSharedPointer<QGyroscopeReading>)),
+        this, 
+        SLOT(onGyroscopeReadingChanged(QSharedPointer<QGyroscopeReading>)),
+        Qt::QueuedConnection);
+
+    setDescription(QLatin1String("Gyroscope Sensor"));
+}
+
+void core::Gyroscope::start()
+{
+    core::SharedGyroscope::instance().start();
+}
+
+void core::Gyroscope::stop()
+{
+    core::SharedGyroscope::instance().stop();
+}
+
+void core::Gyroscope::onGyroscopeReadingChanged(QSharedPointer<QGyroscopeReading> reading)
+{
+    // Capture the coordinates from the Gyroscope device
+    m_reading.setX(reading->x());
+    m_reading.setY(reading->y());
+    m_reading.setZ(reading->z());
+    m_reading.setTimestamp(reading->timestamp());
+
+    newReadingAvailable();
+}

=== added file 'plugins/sensors/core_gyroscope.h'
--- plugins/sensors/core_gyroscope.h	1970-01-01 00:00:00 +0000
+++ plugins/sensors/core_gyroscope.h	2016-03-22 17:02:47 +0000
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2015 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 CORE_GYROSCOPE_H
+#define CORE_GYROSCOPE_H
+
+#include <QGyroscopeReading>
+
+#include <qsensorbackend.h>
+
+namespace core
+{
+class Gyroscope : public QSensorBackend
+{
+    Q_OBJECT
+public:
+    inline static const char* id()
+    {
+        return "core.gyroscope";
+    }
+
+    Gyroscope(QSensor *sensor);
+    virtual ~Gyroscope() = default;
+
+    void start();
+    void stop();
+
+public Q_SLOTS:
+    void onGyroscopeReadingChanged(QSharedPointer<QGyroscopeReading> reading);
+
+private:
+    QGyroscopeReading m_reading;
+};
+}
+
+#endif // CORE_GYROSCOPE_H

=== added file 'plugins/sensors/core_magnetometer.cpp'
--- plugins/sensors/core_magnetometer.cpp	1970-01-01 00:00:00 +0000
+++ plugins/sensors/core_magnetometer.cpp	2016-03-22 17:02:47 +0000
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2015 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 "core_magnetometer.h"
+#include "core_shared_magnetometer.h"
+
+#include <QDebug>
+
+core::Magnetometer::Magnetometer(QSensor *sensor)
+    : QSensorBackend(sensor)
+{
+    // Register the reading instance with the parent
+    setReading<QMagnetometerReading>(&m_reading);
+
+    const qreal minDelay = core::SharedMagnetometer::instance().getMinDelay();
+    if (minDelay > -1)
+    {
+        // Min and max sensor sampling frequencies, in Hz
+        addDataRate(minDelay, minDelay * 10);
+    }
+    addOutputRange(core::SharedMagnetometer::instance().getMinValue(),
+                   core::SharedMagnetometer::instance().getMaxValue(),
+                   core::SharedMagnetometer::instance().getResolution());
+
+    // Connect to the Magnetometer's readingChanged signal
+    // This has to be a queued connection as the sensor callback
+    // from the platform API can happen on an arbitrary thread.
+    connect(
+        &core::SharedMagnetometer::instance(),
+        SIGNAL(MagnetometerReadingChanged(QSharedPointer<QMagnetometerReading>)),
+        this, 
+        SLOT(onMagnetometerReadingChanged(QSharedPointer<QMagnetometerReading>)),
+        Qt::QueuedConnection);
+
+    setDescription(QLatin1String("Magnetometer Sensor"));
+}
+
+void core::Magnetometer::start()
+{
+    core::SharedMagnetometer::instance().start();
+}
+
+void core::Magnetometer::stop()
+{
+    core::SharedMagnetometer::instance().stop();
+}
+
+void core::Magnetometer::onMagnetometerReadingChanged(QSharedPointer<QMagnetometerReading> reading)
+{
+    // Capture the coordinates from the Magnetometer device
+    m_reading.setX(reading->x());
+    m_reading.setY(reading->y());
+    m_reading.setZ(reading->z());
+    m_reading.setTimestamp(reading->timestamp());
+
+    newReadingAvailable();
+}

=== added file 'plugins/sensors/core_magnetometer.h'
--- plugins/sensors/core_magnetometer.h	1970-01-01 00:00:00 +0000
+++ plugins/sensors/core_magnetometer.h	2016-03-22 17:02:47 +0000
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2015 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 CORE_MAGNETOMETER_H
+#define CORE_MAGNETOMETER_H
+
+#include <QMagnetometerReading>
+
+#include <qsensorbackend.h>
+
+namespace core
+{
+class Magnetometer : public QSensorBackend
+{
+    Q_OBJECT
+public:
+    inline static const char* id()
+    {
+        return "core.magnetometer";
+    }
+
+    Magnetometer(QSensor *sensor);
+    virtual ~Magnetometer() = default;
+
+    void start();
+    void stop();
+
+public Q_SLOTS:
+    void onMagnetometerReadingChanged(QSharedPointer<QMagnetometerReading> reading);
+
+private:
+    QMagnetometerReading m_reading;
+};
+}
+
+#endif // CORE_MAGNETOMETER_H

=== modified file 'plugins/sensors/core_sensor_plugins.cpp'
--- plugins/sensors/core_sensor_plugins.cpp	2014-06-18 14:08:07 +0000
+++ plugins/sensors/core_sensor_plugins.cpp	2016-03-22 17:02:47 +0000
@@ -15,6 +15,8 @@
  */
 
 #include "core_accelerometer.h"
+#include "core_gyroscope.h"
+#include "core_magnetometer.h"
 #include "core_orientation_sensor.h"
 #include "core_sensor_plugins.h"
 
@@ -35,6 +37,16 @@
                 QAccelerometer::type,
                 core::Accelerometer::id(),
                 this);
+
+    QSensorManager::registerBackend(
+                QGyroscope::type,
+                core::Gyroscope::id(),
+                this);
+
+    QSensorManager::registerBackend(
+                QMagnetometer::type,
+                core::Magnetometer::id(),
+                this);
 }
 
 // Instantiate all sensor backends here:
@@ -49,5 +61,11 @@
     if (sensor->identifier() == core::Accelerometer::id())
         return new core::Accelerometer(sensor);
 
+    if (sensor->identifier() == core::Gyroscope::id())
+        return new core::Gyroscope(sensor);
+
+    if (sensor->identifier() == core::Magnetometer::id())
+        return new core::Magnetometer(sensor);
+
     return NULL;
 }

=== modified file 'plugins/sensors/core_sensor_plugins.h'
--- plugins/sensors/core_sensor_plugins.h	2014-01-07 10:35:49 +0000
+++ plugins/sensors/core_sensor_plugins.h	2016-03-22 17:02:47 +0000
@@ -20,10 +20,6 @@
 #include <qsensorplugin.h>
 #include <qsensorbackend.h>
 #include <qsensormanager.h>
-#include <QAccelerometer>
-#include <QOrientationSensor>
-
-#include <QDebug>
 
 namespace core
 {

=== added file 'plugins/sensors/core_shared_gyroscope.cpp'
--- plugins/sensors/core_shared_gyroscope.cpp	1970-01-01 00:00:00 +0000
+++ plugins/sensors/core_shared_gyroscope.cpp	2016-03-22 17:02:47 +0000
@@ -0,0 +1,131 @@
+/*
+ * Copyright (C) 2015 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 "core_shared_gyroscope.h"
+
+#include <QDebug>
+#include <QMetaType>
+#include <qmath.h>
+
+Q_DECLARE_METATYPE(QSharedPointer<QGyroscopeReading>)
+
+core::SharedGyroscope& core::SharedGyroscope::instance()
+{
+    static core::SharedGyroscope instance;
+    return instance;
+}
+
+core::SharedGyroscope::SharedGyroscope(QObject *parent)
+    : QObject(parent),
+      m_minDelay(-1),
+      m_minValue(0.0),
+      m_maxValue(0.0),
+      m_resolution(0.0),
+      m_available(false)
+{
+    qRegisterMetaType<QSharedPointer<QGyroscopeReading> >("QSharedPointer<QGyroscopeReading>");
+    m_gyroscope = ua_sensors_gyroscope_new();
+    if (m_gyroscope == NULL)
+        return;
+
+    ua_sensors_gyroscope_set_reading_cb(
+                m_gyroscope,
+                core::SharedGyroscope::onGyroscopeReadingCb,
+                static_cast<void *>(this));
+
+    // Get the minimum sensor reading delay
+    m_minDelay = ua_sensors_gyroscope_get_min_delay(m_gyroscope);
+
+    float value;
+    if (ua_sensors_gyroscope_get_min_value(m_gyroscope, &value) == U_STATUS_SUCCESS)
+        m_minValue = value;
+
+    if (ua_sensors_gyroscope_get_max_value(m_gyroscope, &value) == U_STATUS_SUCCESS)
+        m_maxValue = value;
+
+    if (ua_sensors_gyroscope_get_resolution(m_gyroscope, &value) == U_STATUS_SUCCESS)
+        m_resolution = value;
+
+    m_available = true;
+
+}
+
+void core::SharedGyroscope::start()
+{
+    if (m_available)
+        ua_sensors_gyroscope_enable(m_gyroscope);
+}
+
+void core::SharedGyroscope::stop()
+{
+    if (m_available)
+        ua_sensors_gyroscope_disable(m_gyroscope);
+}
+
+qreal core::SharedGyroscope::getMinDelay() const
+{
+    return m_minDelay;
+}
+
+qreal core::SharedGyroscope::getMinValue() const
+{
+    return m_minValue;
+}
+
+qreal core::SharedGyroscope::getMaxValue() const
+{
+    return m_maxValue;
+}
+
+qreal core::SharedGyroscope::getResolution() const
+{
+    return m_resolution;
+}
+
+void core::SharedGyroscope::setDelay(quint32 delay_us)
+{
+    ua_sensors_gyroscope_set_event_rate(m_gyroscope, delay_us * 1000);
+}
+
+void core::SharedGyroscope::onGyroscopeReadingCb(UASGyroscopeEvent *event, void *context)
+{
+    SharedGyroscope* ac = static_cast<SharedGyroscope*>(context);
+    if (ac != NULL)
+        ac->onGyroscopeReading(event);
+}
+
+void core::SharedGyroscope::onGyroscopeReading(UASGyroscopeEvent *event)
+{
+    Q_ASSERT(event != NULL);
+
+    // TODO(tvoss): We should rely on an object pool to recycle Gyroscope reading
+    // instances here. We could use a custom deleter for the shared pointer to put
+    // instances that have been successfully delivered to slots back into the pool.
+    QSharedPointer<QGyroscopeReading> reading(new QGyroscopeReading());
+
+    float value = -1.;
+
+    if (uas_gyroscope_event_get_rate_of_rotation_around_x(event, &value) == U_STATUS_SUCCESS)
+        reading->setX(qRadiansToDegrees(value));
+    if (uas_gyroscope_event_get_rate_of_rotation_around_y(event, &value) == U_STATUS_SUCCESS)
+        reading->setY(qRadiansToDegrees(value));
+    if (uas_gyroscope_event_get_rate_of_rotation_around_z(event, &value) == U_STATUS_SUCCESS)
+        reading->setZ(qRadiansToDegrees(value));
+
+    reading->setTimestamp(uas_gyroscope_event_get_timestamp(event));
+
+    Q_EMIT gyroscopeReadingChanged(reading);
+}

=== added file 'plugins/sensors/core_shared_gyroscope.h'
--- plugins/sensors/core_shared_gyroscope.h	1970-01-01 00:00:00 +0000
+++ plugins/sensors/core_shared_gyroscope.h	2016-03-22 17:02:47 +0000
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2015 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 CORE_SHARED_GYROSCOPE_H
+#define CORE_SHARED_GYROSCOPE_H
+
+#include <ubuntu/application/sensors/gyroscope.h>
+
+#include <QGyroscopeReading>
+#include <QObject>
+#include <QSharedPointer>
+
+namespace core
+{
+class SharedGyroscope : public QObject
+{
+    Q_OBJECT
+
+public:
+    static SharedGyroscope& instance();
+
+    void start();
+    void stop();
+
+    qreal getMinDelay() const;
+    qreal getMinValue() const;
+    qreal getMaxValue() const;
+    qreal getResolution() const;
+    void setDelay(quint32 delay_us);
+
+Q_SIGNALS:
+    void gyroscopeReadingChanged(QSharedPointer<QGyroscopeReading> reading);
+
+private:
+    SharedGyroscope(QObject *parent = NULL);
+
+    UASensorsGyroscope *m_gyroscope;
+
+    qreal m_minDelay;
+    qreal m_minValue;
+    qreal m_maxValue;
+    qreal m_resolution;
+    bool m_available;
+
+    // Gets called by the underlying platform when there is a new Gyroscope reading
+    static void onGyroscopeReadingCb(UASGyroscopeEvent *event, void *context);
+    void onGyroscopeReading(UASGyroscopeEvent *event);
+};
+}
+
+#endif // CORE_SHARED_GYROSCOPE_H

=== added file 'plugins/sensors/core_shared_magnetometer.cpp'
--- plugins/sensors/core_shared_magnetometer.cpp	1970-01-01 00:00:00 +0000
+++ plugins/sensors/core_shared_magnetometer.cpp	2016-03-22 17:02:47 +0000
@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) 2015 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 "core_shared_magnetometer.h"
+
+#include <QDebug>
+#include <QMetaType>
+
+Q_DECLARE_METATYPE(QSharedPointer<QMagnetometerReading>)
+
+core::SharedMagnetometer& core::SharedMagnetometer::instance()
+{
+    static core::SharedMagnetometer instance;
+    return instance;
+}
+
+core::SharedMagnetometer::SharedMagnetometer(QObject *parent)
+    : QObject(parent),
+      m_minDelay(-1),
+      m_minValue(0.0),
+      m_maxValue(0.0),
+      m_resolution(0.0),
+      m_available(false)
+{
+    qRegisterMetaType<QSharedPointer<QMagnetometerReading> >("QSharedPointer<QMagnetometerReading>");
+    m_magnetometer = ua_sensors_magnetic_new();
+    if (m_magnetometer == NULL)
+        return;
+
+    ua_sensors_magnetic_set_reading_cb(
+                m_magnetometer,
+                core::SharedMagnetometer::onMagnetometerReadingCb,
+                static_cast<void *>(this));
+
+    // Get the minimum sensor reading delay
+    m_minDelay = ua_sensors_magnetic_get_min_delay(m_magnetometer);
+
+    float value;
+    if (ua_sensors_magnetic_get_min_value(m_magnetometer, &value) == U_STATUS_SUCCESS)
+        m_minValue = value;
+
+    if (ua_sensors_magnetic_get_max_value(m_magnetometer, &value) == U_STATUS_SUCCESS)
+        m_maxValue = value;
+
+    if (ua_sensors_magnetic_get_resolution(m_magnetometer, &value) == U_STATUS_SUCCESS)
+        m_resolution = value;
+
+    m_available = true;
+
+}
+
+void core::SharedMagnetometer::start()
+{
+    if (m_available)
+        ua_sensors_magnetic_enable(m_magnetometer);
+}
+
+void core::SharedMagnetometer::stop()
+{
+    if (m_available)
+        ua_sensors_magnetic_disable(m_magnetometer);
+}
+
+qreal core::SharedMagnetometer::getMinDelay() const
+{
+    return m_minDelay;
+}
+
+qreal core::SharedMagnetometer::getMinValue() const
+{
+    return m_minValue;
+}
+
+qreal core::SharedMagnetometer::getMaxValue() const
+{
+    return m_maxValue;
+}
+
+qreal core::SharedMagnetometer::getResolution() const
+{
+    return m_resolution;
+}
+
+void core::SharedMagnetometer::setDelay(quint32 delay_us)
+{
+    ua_sensors_magnetic_set_event_rate(m_magnetometer, delay_us * 1000);
+}
+
+void core::SharedMagnetometer::onMagnetometerReadingCb(UASMagneticEvent *event, void *context)
+{
+    SharedMagnetometer* ac = static_cast<SharedMagnetometer*>(context);
+    if (ac != NULL)
+        ac->onMagnetometerReading(event);
+}
+
+void core::SharedMagnetometer::onMagnetometerReading(UASMagneticEvent *event)
+{
+    Q_ASSERT(event != NULL);
+
+    // TODO(tvoss): We should rely on an object pool to recycle Magnetometer reading
+    // instances here. We could use a custom deleter for the shared pointer to put
+    // instances that have been successfully delivered to slots back into the pool.
+    QSharedPointer<QMagnetometerReading> reading(new QMagnetometerReading());
+
+    float value = -1.;
+
+    if (uas_magnetic_event_get_magnetic_field_x(event, &value) == U_STATUS_SUCCESS)
+        reading->setX(value);
+    if (uas_magnetic_event_get_magnetic_field_y(event, &value) == U_STATUS_SUCCESS)
+        reading->setY(value);
+    if (uas_magnetic_event_get_magnetic_field_z(event, &value) == U_STATUS_SUCCESS)
+        reading->setZ(value);
+
+    reading->setTimestamp(uas_magnetic_event_get_timestamp(event));
+
+    Q_EMIT MagnetometerReadingChanged(reading);
+}

=== added file 'plugins/sensors/core_shared_magnetometer.h'
--- plugins/sensors/core_shared_magnetometer.h	1970-01-01 00:00:00 +0000
+++ plugins/sensors/core_shared_magnetometer.h	2016-03-22 17:02:47 +0000
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2015 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 CORE_SHARED_MAGNETOMETER_H
+#define CORE_SHARED_MAGNETOMETER_H
+
+#include <ubuntu/application/sensors/magnetic.h>
+
+#include <QMagnetometerReading>
+#include <QObject>
+#include <QSharedPointer>
+
+namespace core
+{
+class SharedMagnetometer : public QObject
+{
+    Q_OBJECT
+
+public:
+    static SharedMagnetometer& instance();
+
+    void start();
+    void stop();
+
+    qreal getMinDelay() const;
+    qreal getMinValue() const;
+    qreal getMaxValue() const;
+    qreal getResolution() const;
+    void setDelay(quint32 delay_us);
+
+Q_SIGNALS:
+    void MagnetometerReadingChanged(QSharedPointer<QMagnetometerReading> reading);
+
+private:
+    SharedMagnetometer(QObject *parent = NULL);
+
+    UASensorsMagnetic *m_magnetometer;
+
+    qreal m_minDelay;
+    qreal m_minValue;
+    qreal m_maxValue;
+    qreal m_resolution;
+    bool m_available;
+
+    // Gets called by the underlying platform when there is a new Magnetometer reading
+    static void onMagnetometerReadingCb(UASMagneticEvent *event, void *context);
+    void onMagnetometerReading(UASMagneticEvent *event);
+};
+}
+
+#endif // CORE_SHARED_MAGNETOMETER_H