Sensor: adding Running Speed and Cadence.

Fixes #891.

src/main/java/de/dennisguse/opentracks/content/data/Distance.java

@@ -25,7 +25,15 @@ public class Distance {
     }
 
     public static Distance ofMM(double distance_mm) {
-        return of(distance_mm * UnitConversions.MM_TO_M);
+        return of(0.001 * distance_mm);
+    }
+
+    public static Distance ofCM(double distance_cm) {
+        return of(0.01 * distance_cm);
+    }
+
+    public static Distance ofDM(double distance_dm) {
+        return of(0.1 * distance_dm);
     }
 
     public static Distance one(boolean metricUnit) {

src/main/java/de/dennisguse/opentracks/content/sensor/SensorDataRunning.java

@@ -0,0 +1,109 @@
+package de.dennisguse.opentracks.content.sensor;
+
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+
+import de.dennisguse.opentracks.content.data.Distance;
+import de.dennisguse.opentracks.content.data.Speed;
+
+/**
+ * Provides cadence in rpm and speed in milliseconds from Bluetooth LE Running Speed and Cadence sensors.
+ */
+public final class SensorDataRunning extends SensorData<SensorDataRunning.Data> {
+
+    private static final String TAG = SensorDataRunning.class.getSimpleName();
+
+    private final Speed speed;
+
+    private final Float cadence;
+
+    private final Distance totalDistance;
+
+    public SensorDataRunning(String sensorAddress) {
+        super(sensorAddress);
+        this.speed = null;
+        this.cadence = null;
+        this.totalDistance = null;
+    }
+
+    public SensorDataRunning(String sensorAddress, String sensorName, Speed speed, Float cadence, Distance totalDistance) {
+        super(sensorAddress, sensorName);
+        this.speed = speed;
+        this.cadence = cadence;
+        this.totalDistance = totalDistance;
+    }
+
+    private boolean hasTotalDistance() {
+        return totalDistance != null;
+    }
+
+
+    public Float getCadence() {
+        return cadence;
+    }
+
+    @VisibleForTesting
+    public Speed getSpeed() {
+        return speed;
+    }
+
+    @VisibleForTesting
+    public Distance getTotalDistance() {
+        return totalDistance;
+    }
+
+    public void compute(SensorDataRunning previous) {
+        Distance overallDistance = null;
+        if (hasTotalDistance() && previous != null && previous.hasTotalDistance()) {
+            overallDistance = this.totalDistance.minus(previous.totalDistance);
+            if (previous.hasValue() && previous.getValue().getDistance() != null) {
+                overallDistance = overallDistance.plus(previous.getValue().getDistance());
+            }
+        }
+
+        value = new Data(speed, cadence, overallDistance);
+    }
+
+    @Override
+    public void reset() {
+        if (value != null) {
+            value = new Data(value.speed, value.cadence, Distance.of(0));
+        }
+    }
+
+    public static class Data {
+        private final Speed speed;
+        private final Float cadence;
+
+        @Nullable
+        private final Distance distance;
+
+        public Data(Speed speed, Float cadence, @Nullable Distance distance) {
+            this.speed = speed;
+            this.cadence = cadence;
+            this.distance = distance;
+        }
+
+        public Speed getSpeed() {
+            return speed;
+        }
+
+        public Float getCadence() {
+            return cadence;
+        }
+
+        public Distance getDistance() {
+            return distance;
+        }
+
+        @Override
+        public String toString() {
+            return "Data{" +
+                    "speed=" + speed +
+                    ", cadence=" + cadence +
+                    ", distance=" + distance +
+                    '}';
+        }
+    }
+}
+

src/main/java/de/dennisguse/opentracks/content/sensor/SensorDataSet.java

@@ -14,6 +14,8 @@ public final class SensorDataSet {
 
     private SensorDataCyclingPower cyclingPower;
 
+    private SensorDataRunning runningDistanceSpeedCadence;
+
     public SensorDataSet() {
     }
 
@@ -22,6 +24,7 @@ public final class SensorDataSet {
         this.cyclingCadence = toCopy.cyclingCadence;
         this.cyclingDistanceSpeed = toCopy.cyclingDistanceSpeed;
         this.cyclingPower = toCopy.cyclingPower;
+        this.runningDistanceSpeedCadence = toCopy.runningDistanceSpeedCadence;
     }
 
     public SensorDataHeartRate getHeartRate() {
@@ -40,6 +43,10 @@ public final class SensorDataSet {
         return cyclingPower;
     }
 
+    public SensorDataRunning getRunningDistanceSpeedCadence() {
+        return runningDistanceSpeedCadence;
+    }
+
     public void set(SensorData<?> data) {
         set(data, data);
     }
@@ -53,6 +60,7 @@ public final class SensorDataSet {
         this.cyclingCadence = null;
         this.cyclingDistanceSpeed = null;
         this.cyclingPower = null;
+        this.runningDistanceSpeedCadence = null;
     }
 
     public void fillTrackPoint(TrackPoint trackPoint) {
@@ -72,6 +80,12 @@ public final class SensorDataSet {
         if (cyclingPower != null && cyclingPower.hasValue()) {
             trackPoint.setPower(cyclingPower.getValue());
         }
+
+        if (runningDistanceSpeedCadence != null && runningDistanceSpeedCadence.hasValue()) {
+            trackPoint.setSensorDistance(runningDistanceSpeedCadence.getValue().getDistance());
+            trackPoint.setSpeed(runningDistanceSpeedCadence.getValue().getSpeed());
+            trackPoint.setCyclingCadence_rpm(runningDistanceSpeedCadence.getValue().getCadence());
+        }
     }
 
     public void reset() {
@@ -79,6 +93,8 @@ public final class SensorDataSet {
         if (cyclingCadence != null) cyclingCadence.reset();
         if (cyclingDistanceSpeed != null) cyclingDistanceSpeed.reset();
         if (cyclingPower != null) cyclingPower.reset();
+
+        if (runningDistanceSpeedCadence != null) runningDistanceSpeedCadence.reset();
     }
 
     @NonNull
@@ -87,7 +103,8 @@ public final class SensorDataSet {
         return (getHeartRate() != null ? "" + getHeartRate() : "")
                 + (getCyclingCadence() != null ? " " + getCyclingCadence() : "")
                 + (getCyclingDistanceSpeed() != null ? " " + getCyclingDistanceSpeed() : "")
-                + (getCyclingPower() != null ? " " + getCyclingPower() : "");
+                + (getCyclingPower() != null ? " " + getCyclingPower() : "")
+                + (getRunningDistanceSpeedCadence() != null ? " " + getRunningDistanceSpeedCadence() : "");
     }
 
     private void set(@NonNull SensorData<?> type, SensorData<?> data) {
@@ -110,6 +127,11 @@ public final class SensorDataSet {
             return;
         }
 
+        if (type instanceof SensorDataRunning) {
+            this.runningDistanceSpeedCadence = (SensorDataRunning) data;
+            return;
+        }
+
         throw new UnsupportedOperationException(type.getClass().getCanonicalName());
     }
 }