Add support for dynamic min/max state values

libnymea-app/thingmanager.cpp

@@ -118,18 +118,26 @@ void ThingManager::notificationReceived(const QVariantMap &data)
 {
     qCDebug(dcThingManager()) << "ThingManager notifications received:" << qUtf8Printable(QJsonDocument::fromVariant(data).toJson());
     QString notification = data.value("notification").toString();
+    QVariantMap params = data.value("params").toMap();
     if (notification == "Integrations.StateChanged") {
-        Thing *thing = m_things->getThing(data.value("params").toMap().value("thingId").toUuid());
+        Thing *thing = m_things->getThing(params.value("thingId").toUuid());
         if (!thing) {
             if (!m_fetchingData) {
                 qCWarning(dcThingManager()) << "Thing state change notification received for an unknown thing";
             }
             return;
         }
-        QUuid stateTypeId = data.value("params").toMap().value("stateTypeId").toUuid();
+        QUuid stateTypeId = params.value("stateTypeId").toUuid();
-        QVariant value = data.value("params").toMap().value("value");
+        QVariant value = params.value("value");
 //        qDebug() << "Thing state changed for:" << dev->name() << "State name:" << dev->thingClass()->stateTypes()->getStateType(stateTypeId) << "value:" << value;
-        thing->setStateValue(stateTypeId, value);
+        State *state = thing->state(stateTypeId);
+        state->setValue(value);
+        if (params.contains("minValue")) {
+            state->setMinValue(params.value("minValue"));
+        }
+        if (params.contains("maxValue")) {
+            state->setMaxValue(params.value("maxValue"));
+        }
         emit thingStateChanged(thing->id(), stateTypeId, value);
     } else if (notification == "Integrations.ThingAdded") {
         Thing *thing = unpackThing(this, data.value("params").toMap().value("thing").toMap(), m_thingClasses);
@@ -967,12 +975,24 @@ Thing* ThingManager::unpackThing(ThingManager *thingManager, const QVariantMap &
         states = new States(thing);
     }
     foreach (const QVariant &stateVariant, thingMap.value("states").toList()) {
-        State *state = states->getState(stateVariant.toMap().value("stateTypeId").toUuid());
+        QVariantMap stateMap = stateVariant.toMap();
+        State *state = states->getState(stateMap.value("stateTypeId").toUuid());
         if (!state) {
-            state = new State(thing->id(), stateVariant.toMap().value("stateTypeId").toUuid(), stateVariant.toMap().value("value"), states);
+            state = new State(thing->id(), stateMap.value("stateTypeId").toUuid(), stateMap.value("value"), states);
             states->addState(state);
         } else {
-            state->setValue(stateVariant.toMap().value("value"));
+            state->setValue(stateMap.value("value"));
+        }
+        StateType *stateType = thing->thingClass()->stateTypes()->getStateType(state->stateTypeId());
+        if (stateMap.contains("minValue")) {
+            state->setMinValue(stateMap.value("minValue"));
+        } else {
+            state->setMinValue(stateType->minValue());
+        }
+        if (stateMap.contains("maxValue")) {
+            state->setMaxValue(stateMap.value("maxValue"));
+        } else {
+            state->setMaxValue(stateType->maxValue());
         }
     }
     thing->setStates(states);

libnymea-app/types/state.cpp

@@ -57,7 +57,33 @@ QVariant State::value() const
 
 void State::setValue(const QVariant &value)
 {
-    m_value = value;
+    if (m_value != value) {
-    emit valueChanged();
+        m_value = value;
+        emit valueChanged();
+    }
 }
 
+QVariant State::minValue() const
+{
+    return m_minValue;
+}
+
+void State::setMinValue(const QVariant &minValue) {
+    if (m_minValue != minValue) {
+        m_minValue = minValue;
+        emit minValueChanged();
+    }
+}
+
+QVariant State::maxValue() const
+{
+    return m_maxValue;
+}
+
+void State::setMaxValue(const QVariant &maxValue)
+{
+    if (m_maxValue != maxValue) {
+        m_maxValue = maxValue;
+        emit maxValueChanged();
+    }
+}

libnymea-app/types/state.h

@@ -41,6 +41,8 @@ class State : public QObject
     Q_PROPERTY(QUuid thingId READ thingId CONSTANT)
     Q_PROPERTY(QUuid stateTypeId READ stateTypeId CONSTANT)
     Q_PROPERTY(QVariant value READ value NOTIFY valueChanged)
+    Q_PROPERTY(QVariant minValue READ minValue NOTIFY minValueChanged)
+    Q_PROPERTY(QVariant maxValue READ maxValue NOTIFY maxValueChanged)
 
 public:
     explicit State(const QUuid &thingId, const QUuid &stateTypeId, const QVariant &value, QObject *parent = nullptr);
@@ -51,13 +53,23 @@ public:
     QVariant value() const;
     void setValue(const QVariant &value);
 
+    QVariant minValue() const;
+    void setMinValue(const QVariant &minValue);
+
+    QVariant maxValue() const;
+    void setMaxValue(const QVariant &maxValue);
+
 private:
     QUuid m_thingId;
     QUuid m_stateTypeId;
     QVariant m_value;
+    QVariant m_minValue;
+    QVariant m_maxValue;
 
 signals:
     void valueChanged();
+    void minValueChanged();
+    void maxValueChanged();
 
 };