Add binding support for sensor readings

Many of the sensors' QML "reading" value properties change with high
frequency. This makes them candidates to benefit from the more
performant bindable support.

This commit adds the bindable support for QML sensor 'reading' classes:
pressure, gyroscope, tap, compass, proximity, orientation, distance,
magnetometer, lid reading, tilt, rotation, humidity, holster, ambient
temperature, light sensor, altimeter, IR proximity, accelerometer,
ambient light, and sensor reading baseclass (timestamp common to all)

In addition to the 'reading' classes, the commit adds bindable support
for QmlSensor::reading, as it's change signal is emitted with high
frequency, on every sensor reading change.

Pick-to: 6.2
Task-number: QTBUG-92513
Task-number: QTBUG-92503
Task-number: QTBUG-92505
Change-Id: I413ddd8a758142b9b93596e55b3bc8c3c2c98252
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Alex Blasche <alexander.blasche@qt.io>
Reviewed-by: Ivan Solovev <ivan.solovev@qt.io>

6 files changed, 190 insertions, 38 deletions

diff --git a/tests/auto/common/test_backends.cpp b/tests/auto/common/test_backends.cpp
index 15419b0..a8ce7f3 100644
--- a/tests/auto/common/test_backends.cpp
+++ b/tests/auto/common/test_backends.cpp
@@ -62,41 +62,43 @@ void set_test_backend_busy(QSensor* sensor, bool busy)
     backend->sensorBusy(busy);
 }
 
-void set_test_backend_reading(QSensor* sensor, const QJsonObject& values)
+void set_test_backend_reading(QSensor* sensor, const QVariantMap& values)
 {
     Q_ASSERT(sensor->isConnectedToBackend());
     QSensorBackend* backend = sensorToBackend.value(sensor);
-    backend->reading()->setTimestamp(values["timestamp"].toInt()); // timestamp is common to all
+    // timestamp is common to all readings
+    if (values.contains("timestamp"))
+        backend->reading()->setTimestamp(values["timestamp"].toInt());
     if (sensor->type() == "QAccelerometer") {
         QAccelerometerReading* reading = static_cast<QAccelerometerReading*>(backend->reading());
-        reading->setX(values["x"].toDouble());
-        reading->setY(values["y"].toDouble());
-        reading->setZ(values["z"].toDouble());
+        if (values.contains("x")) reading->setX(values["x"].value<qreal>());
+        if (values.contains("y")) reading->setY(values["y"].value<qreal>());
+        if (values.contains("z")) reading->setZ(values["z"].value<qreal>());
         backend->newReadingAvailable();
     } else if (sensor->type() == "QPressureSensor") {
         QPressureReading* reading = static_cast<QPressureReading*>(backend->reading());
-        reading->setPressure(values["pressure"].toDouble());
-        reading->setTemperature(values["temperature"].toDouble());
+        if (values.contains("pressure")) reading->setPressure(values["pressure"].value<qreal>());
+        if (values.contains("temperature")) reading->setTemperature(values["temperature"].value<qreal>());
         backend->newReadingAvailable();
     } else if (sensor->type() == "QGyroscope") {
         QGyroscopeReading* reading = static_cast<QGyroscopeReading*>(backend->reading());
-        reading->setX(values["x"].toDouble());
-        reading->setY(values["y"].toDouble());
-        reading->setZ(values["z"].toDouble());
+        if (values.contains("x")) reading->setX(values["x"].value<qreal>());
+        if (values.contains("y")) reading->setY(values["y"].value<qreal>());
+        if (values.contains("z")) reading->setZ(values["z"].value<qreal>());
         backend->newReadingAvailable();
     } else if (sensor->type() == "QTapSensor") {
         QTapReading* reading = static_cast<QTapReading*>(backend->reading());
-        reading->setDoubleTap(values["doubleTap"].toBool());
-        reading->setTapDirection(QTapReading::TapDirection(values["tapDirection"].toInt()));
+        if (values.contains("doubleTap")) reading->setDoubleTap(values["doubleTap"].value<bool>());
+        if (values.contains("tapDirection")) reading->setTapDirection(QTapReading::TapDirection(values["tapDirection"].toInt()));
         backend->newReadingAvailable();
     } else if (sensor->type() == "QCompass") {
         QCompassReading* reading = static_cast<QCompassReading*>(backend->reading());
-        reading->setAzimuth(values["azimuth"].toDouble());
-        reading->setCalibrationLevel(values["calibrationLevel"].toDouble());
+        if (values.contains("azimuth")) reading->setAzimuth(values["azimuth"].value<qreal>());
+        if (values.contains("calibrationLevel")) reading->setCalibrationLevel(values["calibrationLevel"].value<qreal>());
         backend->newReadingAvailable();
     } else if (sensor->type() == "QProximitySensor") {
         QProximityReading* reading = static_cast<QProximityReading*>(backend->reading());
-        reading->setClose(values["near"].toBool());
+        reading->setClose(values["near"].value<bool>());
         backend->newReadingAvailable();
     } else if (sensor->type() == "QOrientationSensor") {
         QOrientationReading* reading = static_cast<QOrientationReading*>(backend->reading());
@@ -104,7 +106,7 @@ void set_test_backend_reading(QSensor* sensor, const QJsonObject& values)
         backend->newReadingAvailable();
     } else if (sensor->type() == "QDistanceSensor") {
         QDistanceReading* reading = static_cast<QDistanceReading*>(backend->reading());
-        reading->setDistance(values["distance"].toDouble());
+        reading->setDistance(values["distance"].value<qreal>());
         backend->newReadingAvailable();
     } else if (sensor->type() == "QAmbientLightSensor") {
         QAmbientLightReading* reading = static_cast<QAmbientLightReading*>(backend->reading());
@@ -112,49 +114,49 @@ void set_test_backend_reading(QSensor* sensor, const QJsonObject& values)
         backend->newReadingAvailable();
     } else if (sensor->type() == "QMagnetometer") {
         QMagnetometerReading* reading = static_cast<QMagnetometerReading*>(backend->reading());
-        reading->setX(values["x"].toDouble());
-        reading->setY(values["y"].toDouble());
-        reading->setZ(values["z"].toDouble());
-        reading->setCalibrationLevel(values["calibrationLevel"].toDouble());
+        if (values.contains("x")) reading->setX(values["x"].value<qreal>());
+        if (values.contains("y")) reading->setY(values["y"].value<qreal>());
+        if (values.contains("z")) reading->setZ(values["z"].value<qreal>());
+        if (values.contains("calibrationLevel")) reading->setCalibrationLevel(values["calibrationLevel"].value<qreal>());
         backend->newReadingAvailable();
     } else if (sensor->type() == "QLidSensor") {
         QLidReading* reading = static_cast<QLidReading*>(backend->reading());
-        reading->setBackLidClosed(values["backLidClosed"].toBool());
-        reading->setFrontLidClosed(values["frontLidClosed"].toBool());
+        if (values.contains("backLidClosed")) reading->setBackLidClosed(values["backLidClosed"].value<bool>());
+        if (values.contains("frontLidClosed")) reading->setFrontLidClosed(values["frontLidClosed"].value<bool>());
         backend->newReadingAvailable();
     } else if (sensor->type() == "QTiltSensor") {
         QTiltReading* reading = static_cast<QTiltReading*>(backend->reading());
-        reading->setYRotation(values["yRotation"].toDouble());
-        reading->setXRotation(values["xRotation"].toDouble());
+        if (values.contains("yRotation")) reading->setYRotation(values["yRotation"].value<qreal>());
+        if (values.contains("xRotation")) reading->setXRotation(values["xRotation"].value<qreal>());
         backend->newReadingAvailable();
     } else if (sensor->type() == "QRotationSensor") {
         QRotationReading* reading = static_cast<QRotationReading*>(backend->reading());
-        reading->setFromEuler(values["x"].toDouble(), values["y"].toDouble(), values["z"].toDouble());
+        reading->setFromEuler(values["x"].value<qreal>(), values["y"].value<qreal>(), values["z"].value<qreal>());
         backend->newReadingAvailable();
     } else if (sensor->type() == "QHumiditySensor") {
         QHumidityReading* reading = static_cast<QHumidityReading*>(backend->reading());
-        reading->setRelativeHumidity(values["relativeHumidity"].toDouble());
-        reading->setAbsoluteHumidity(values["absoluteHumidity"].toDouble());
+        if (values.contains("relativeHumidity")) reading->setRelativeHumidity(values["relativeHumidity"].value<qreal>());
+        if (values.contains("absoluteHumidity")) reading->setAbsoluteHumidity(values["absoluteHumidity"].value<qreal>());
         backend->newReadingAvailable();
     } else if (sensor->type() == "QHolsterSensor") {
         QHolsterReading* reading = static_cast<QHolsterReading*>(backend->reading());
-        reading->setHolstered(values["holstered"].toBool());
+        reading->setHolstered(values["holstered"].value<bool>());
         backend->newReadingAvailable();
     } else if (sensor->type() == "QAmbientTemperatureSensor") {
         QAmbientTemperatureReading* reading = static_cast<QAmbientTemperatureReading*>(backend->reading());
-        reading->setTemperature(values["temperature"].toDouble());
+        reading->setTemperature(values["temperature"].value<qreal>());
         backend->newReadingAvailable();
     } else if (sensor->type() == "QLightSensor") {
         QLightReading* reading = static_cast<QLightReading*>(backend->reading());
-        reading->setLux(values["illuminance"].toDouble());
+        reading->setLux(values["illuminance"].value<qreal>());
         backend->newReadingAvailable();
     } else if (sensor->type() == "QAltimeter") {
         QAltimeterReading* reading = static_cast<QAltimeterReading*>(backend->reading());
-        reading->setAltitude(values["altitude"].toDouble());
+        reading->setAltitude(values["altitude"].value<qreal>());
         backend->newReadingAvailable();
     } else if (sensor->type() == "QIRProximitySensor") {
         QIRProximityReading* reading = static_cast<QIRProximityReading*>(backend->reading());
-        reading->setReflectance(values["reflectance"].toDouble());
+        reading->setReflectance(values["reflectance"].value<qreal>());
         backend->newReadingAvailable();
     } else {
         qWarning() << "Unsupported test sensor backend:" << sensor->type();
diff --git a/tests/auto/common/test_backends.h b/tests/auto/common/test_backends.h
index 66699b5..80d6913 100644
--- a/tests/auto/common/test_backends.h
+++ b/tests/auto/common/test_backends.h
@@ -34,7 +34,7 @@
 
 void register_test_backends();
 void unregister_test_backends();
-void set_test_backend_reading(QSensor* sensor, const QJsonObject& values);
+void set_test_backend_reading(QSensor* sensor, const QVariantMap& values);
 void set_test_backend_busy(QSensor* sensor, bool busy);
 
 #include <qaccelerometer.h>
@@ -89,6 +89,7 @@ void set_test_backend_busy(QSensor* sensor, bool busy);
 #endif
 
 PREPARE_SENSORINTERFACE(QAccelerometer, QAccelerometerReading, QAccelerometerFilter, {
+    reading->setTimestamp(1);
     reading->setX(1.0);
     reading->setY(1.0);
     reading->setZ(1.0);
diff --git a/tests/auto/qml/qml_cpp/CMakeLists.txt b/tests/auto/qml/qml_cpp/CMakeLists.txt
index 1ceb766..45c3230 100644
--- a/tests/auto/qml/qml_cpp/CMakeLists.txt
+++ b/tests/auto/qml/qml_cpp/CMakeLists.txt
@@ -1,12 +1,12 @@
-
 qt_internal_add_test(tst_sensors_qmlcpp
     SOURCES
+        ../../common/test_backends.cpp ../../common/test_backends.h
         qtemplategestureplugin.cpp qtemplategestureplugin.h
         qtemplaterecognizer.cpp qtemplaterecognizer.h
         tst_sensors_qmlcpp.cpp
-    PUBLIC_LIBRARIES
-        Qt::Qml
     LIBRARIES
+        Qt::Qml
         Qt::SensorsPrivate
         Qt::SensorsQuickPrivate
+        Qt::TestPrivate
 )
diff --git a/tests/auto/qml/qml_cpp/tst_sensors_qmlcpp.cpp b/tests/auto/qml/qml_cpp/tst_sensors_qmlcpp.cpp
index acc4d92..4b81aad 100644
--- a/tests/auto/qml/qml_cpp/tst_sensors_qmlcpp.cpp
+++ b/tests/auto/qml/qml_cpp/tst_sensors_qmlcpp.cpp
@@ -30,6 +30,7 @@
 #include <QtTest/QSignalSpy>
 #include <QtCore/QDebug>
 
+#include <QtTest/private/qpropertytesthelper_p.h>
 #include <QtSensorsQuick/private/qmlsensor_p.h>
 #include <QtSensorsQuick/private/qmlsensorgesture_p.h>
 
@@ -39,6 +40,27 @@
 #include <qsensorbackend.h>
 #include "qsensormanager.h"
 
+#include "../../common/test_backends.h"
+#include <QtSensorsQuick/private/qmlaccelerometer_p.h>
+#include <QtSensorsQuick/private/qmlpressuresensor_p.h>
+#include <QtSensorsQuick/private/qmlgyroscope_p.h>
+#include <QtSensorsQuick/private/qmltapsensor_p.h>
+#include <QtSensorsQuick/private/qmlcompass_p.h>
+#include <QtSensorsQuick/private/qmlproximitysensor_p.h>
+#include <QtSensorsQuick/private/qmlorientationsensor_p.h>
+#include <QtSensorsQuick/private/qmldistancesensor_p.h>
+#include <QtSensorsQuick/private/qmlambientlightsensor_p.h>
+#include <QtSensorsQuick/private/qmlmagnetometer_p.h>
+#include <QtSensorsQuick/private/qmllidsensor_p.h>
+#include <QtSensorsQuick/private/qmltiltsensor_p.h>
+#include <QtSensorsQuick/private/qmlrotationsensor_p.h>
+#include <QtSensorsQuick/private/qmlhumiditysensor_p.h>
+#include <QtSensorsQuick/private/qmlholstersensor_p.h>
+#include <QtSensorsQuick/private/qmlambienttemperaturesensor_p.h>
+#include <QtSensorsQuick/private/qmllightsensor_p.h>
+#include <QtSensorsQuick/private/qmlaltimeter_p.h>
+#include <QtSensorsQuick/private/qmlirproximitysensor_p.h>
+
 QT_USE_NAMESPACE
 
 QT_BEGIN_NAMESPACE
@@ -49,6 +71,7 @@ class tst_sensors_qmlcpp : public QObject
 
 private slots:
     void initTestCase();
+    void testReadingBindings();
     void testGesture();
     void testSensorRanges();
 };
@@ -58,6 +81,132 @@ void tst_sensors_qmlcpp::initTestCase()
     qputenv("QT_SENSORS_LOAD_PLUGINS", "0"); // Do not load plugins
 }
 
+template<typename SensorClass, typename ReadingClass, typename ValueType>
+void testSensorReadings(const char* identifier, const QVariantMap& values)
+{
+    SensorClass sensor;
+    sensor.setIdentifier(identifier);
+    sensor.componentComplete();
+    sensor.start();
+
+    for (const auto& key : values.keys()) {
+        ValueType initialValue = values[key].toList()[0].value<ValueType>();
+        ValueType changedValue = values[key].toList()[1].value<ValueType>();
+        QTestPrivate::testReadOnlyPropertyBasics<ReadingClass, ValueType>(
+                    *static_cast<ReadingClass*>(sensor.reading()),
+                    initialValue, changedValue, key.toStdString().c_str(),
+                    [&](){ set_test_backend_reading(sensor.sensor(), {{key, changedValue}}); });
+        if (QTest::currentTestFailed()) {
+            qWarning() << identifier << "::" << key << "test failed.";
+            return;
+        }
+    }
+}
+
+void tst_sensors_qmlcpp::testReadingBindings()
+{
+    register_test_backends();
+
+    testSensorReadings<QmlAccelerometer, QmlAccelerometerReading, qreal>(
+                "QAccelerometer",
+                {{"x", QVariantList{1.0, 2.0}},
+                 {"y", QVariantList{1.0, 2.0}},
+                 {"z", QVariantList{1.0, 2.0}}});
+    testSensorReadings<QmlAccelerometer, QmlAccelerometerReading, quint64>(
+                "QAccelerometer",
+                {{"timestamp", QVariantList{1.0, 2.0}}});
+    testSensorReadings<QmlAmbientLightSensor, QmlAmbientLightSensorReading, QAmbientLightReading::LightLevel>(
+                "QAmbientLightSensor",
+                {{"lightLevel", QVariantList{QAmbientLightReading::Twilight, QAmbientLightReading::Sunny}}});
+    testSensorReadings<QmlPressureSensor, QmlPressureReading, qreal>(
+                "QPressureSensor",
+                {{"pressure", QVariantList{1.0, 2.0}},
+                 {"temperature", QVariantList{1.0, 2.0}}});
+    testSensorReadings<QmlGyroscope, QmlGyroscopeReading, qreal>(
+                "QGyroscope",
+                {{"x", QVariantList{1.0, 2.0}},
+                 {"y", QVariantList{1.0, 2.0}},
+                 {"z", QVariantList{1.0, 2.0}}});
+    testSensorReadings<QmlTapSensor, QmlTapSensorReading, bool>(
+                "QTapSensor",
+                {{"doubleTap", QVariantList{true, false}}});
+    testSensorReadings<QmlTapSensor, QmlTapSensorReading, QTapReading::TapDirection>(
+                "QTapSensor",
+                {{"tapDirection", QVariantList{QTapReading::Z_Both, QTapReading::X_Both}}});
+    testSensorReadings<QmlCompass, QmlCompassReading, qreal>(
+                "QCompass",
+                {{"azimuth", QVariantList{1.0, 2.0}},
+                 {"calibrationLevel", QVariantList{1.0, 2.0}}});
+    testSensorReadings<QmlProximitySensor, QmlProximitySensorReading, bool>(
+                "QProximitySensor",
+                {{"near", QVariantList{true, false}}});
+    testSensorReadings<QmlOrientationSensor, QmlOrientationSensorReading, QOrientationReading::Orientation>(
+                "QOrientationSensor",
+                {{"orientation", QVariantList{QOrientationReading::LeftUp, QOrientationReading::RightUp}}});
+    testSensorReadings<QmlDistanceSensor, QmlDistanceReading, qreal>(
+                "QDistanceSensor",
+                {{"distance", QVariantList{1.0, 2.0}}});
+    testSensorReadings<QmlMagnetometer, QmlMagnetometerReading, qreal>(
+                "QMagnetometer",
+                {{"x", QVariantList{1.0, 2.0}},
+                 {"y", QVariantList{1.0, 2.0}},
+                 {"z", QVariantList{1.0, 2.0}},
+                 {"calibrationLevel", QVariantList{1.0, 2.0}}});
+    testSensorReadings<QmlLidSensor, QmlLidReading, bool>(
+                "QLidSensor",
+                {{"backLidClosed", QVariantList{true, false}},
+                 {"frontLidClosed", QVariantList{true, false}}});
+    testSensorReadings<QmlTiltSensor, QmlTiltSensorReading, qreal>(
+                "QTiltSensor",
+                {{"yRotation", QVariantList{1.0, 2.0}},
+                 {"xRotation", QVariantList{1.0, 2.0}}});
+    // rotation sensor properties need to be tested separately because the setter function is
+    // not symmetric with getter functions ("setFromEuler()" vs. "x() & y() & z()")
+    testSensorReadings<QmlRotationSensor, QmlRotationSensorReading, qreal>(
+                "QRotationSensor",
+                {{"x", QVariantList{1.0, 2.0}}});
+    testSensorReadings<QmlRotationSensor, QmlRotationSensorReading, qreal>(
+                "QRotationSensor",
+                {{"y", QVariantList{1.0, 2.0}}});
+    testSensorReadings<QmlRotationSensor, QmlRotationSensorReading, qreal>(
+                "QRotationSensor",
+                {{"z", QVariantList{1.0, 2.0}}});
+    testSensorReadings<QmlHumiditySensor, QmlHumidityReading, qreal>(
+                "QHumiditySensor",
+                {{"relativeHumidity", QVariantList{1.0, 2.0}},
+                 {"absoluteHumidity", QVariantList{1.0, 2.0}}});
+    testSensorReadings<QmlHolsterSensor, QmlHolsterReading, bool>(
+                "QHolsterSensor",
+                {{"holstered", QVariantList{true, false}}});
+    testSensorReadings<QmlAmbientTemperatureSensor, QmlAmbientTemperatureReading, qreal>(
+                "QAmbientTemperatureSensor",
+                {{"temperature", QVariantList{30.0, 40.0}}});
+    testSensorReadings<QmlLightSensor, QmlLightSensorReading, qreal>(
+                "QLightSensor",
+                {{"illuminance", QVariantList{1.0, 2.0}}});
+    testSensorReadings<QmlAltimeter, QmlAltimeterReading, qreal>(
+                "QAltimeter",
+                {{"altitude", QVariantList{8848, 9959}}});
+    testSensorReadings<QmlIRProximitySensor, QmlIRProximitySensorReading, qreal>(
+                "QIRProximitySensor",
+                {{"reflectance", QVariantList{0.5, 0.6}}});
+
+    // The following tests QmlSensor (the baseclass) 'readingChanged' which is
+    // emitted every time a sensor value changes. For that we instantiate a
+    // concrete sensor. The actual 'reading' value (a QObject pointer) of the
+    // 'readingChanged' property will not change, but rather the
+    // 'readingChanged' is used to indicate that the value it contains has changed.
+    QmlAccelerometer accelerometer;
+    accelerometer.setIdentifier("QAccelerometer");
+    accelerometer.componentComplete();
+    accelerometer.start();
+    QTestPrivate::testReadOnlyPropertyBasics<QmlSensor, QmlSensorReading*>(
+                accelerometer, accelerometer.reading(), accelerometer.reading(), "reading",
+                [&](){ set_test_backend_reading(accelerometer.sensor(), {{"x", 2.0}}); });
+
+    unregister_test_backends();
+}
+
 void tst_sensors_qmlcpp::testGesture()
 {
     QTemplateGesturePlugin* plugin = new QTemplateGesturePlugin();
diff --git a/tests/auto/qml/qml_quick/tst_sensors_basic.qml b/tests/auto/qml/qml_quick/tst_sensors_basic.qml
index 37895ba..f6553df 100644
--- a/tests/auto/qml/qml_quick/tst_sensors_basic.qml
+++ b/tests/auto/qml/qml_quick/tst_sensors_basic.qml
@@ -208,7 +208,7 @@ TestCase {
 
     function test_reading_data() {
         return [
-                    {tag: "Accelerometer", initialReading: {timestamp: 0, x: 1.0, y: 1.0, z: 1.0}, newReading: {timestamp: 1, x: 2.0, y: 3.0, z: 4.0}},
+                    {tag: "Accelerometer", initialReading: {timestamp: 1, x: 1.0, y: 1.0, z: 1.0}, newReading: {timestamp: 2, x: 2.0, y: 3.0, z: 4.0}},
                     {tag: "PressureSensor", initialReading: {pressure: 1.0, temperature: 1.0}, newReading: {pressure: 2.0, temperature: 3.0}},
                     {tag: "Gyroscope", initialReading: {x : 1.0, y: 1.0, z: 1.0}, newReading: {x : 2.0, y: 3.0, z: 4.0}},
                     {tag: "TapSensor", initialReading: {doubleTap: true, tapDirection: TapReading.Z_Both}, newReading: {doubleTap: false, tapDirection: TapReading.X_Both}},
diff --git a/tests/auto/qml/qml_quick/tst_sensors_qmlquick.cpp b/tests/auto/qml/qml_quick/tst_sensors_qmlquick.cpp
index 8162601..9bab11f 100644
--- a/tests/auto/qml/qml_quick/tst_sensors_qmlquick.cpp
+++ b/tests/auto/qml/qml_quick/tst_sensors_qmlquick.cpp
@@ -52,7 +52,7 @@ public slots:
         unregister_test_backends();
     }
 
-    void setSensorReading(const QmlSensor* qmlSensor, const QJsonObject& values) {
+    void setSensorReading(const QmlSensor* qmlSensor, const QVariantMap& values) {
         set_test_backend_reading(qmlSensor->sensor(), values);
     }