Value objects distance and speed.

#679

src/main/java/de/dennisguse/opentracks/content/DescriptionGenerator.java

@@ -24,6 +24,8 @@ import androidx.annotation.VisibleForTesting;
 import java.time.Duration;
 
 import de.dennisguse.opentracks.R;
+import de.dennisguse.opentracks.content.data.Distance;
+import de.dennisguse.opentracks.content.data.Speed;
 import de.dennisguse.opentracks.content.data.Track;
 import de.dennisguse.opentracks.stats.TrackStatistics;
 import de.dennisguse.opentracks.util.StringUtils;
@@ -163,9 +165,9 @@ public class DescriptionGenerator {
      * @param lineBreak line break string
      */
     @VisibleForTesting
-    void writeDistance(double distance, StringBuilder builder, int resId, String lineBreak) {
-        double distanceInKm = distance * UnitConversions.M_TO_KM;
-        double distanceInMi = distanceInKm * UnitConversions.KM_TO_MI;
+    void writeDistance(Distance distance, StringBuilder builder, int resId, String lineBreak) {
+        double distanceInKm = distance.toKM();
+        double distanceInMi = distance.toMI();
         builder.append(context.getString(resId, distanceInKm, distanceInMi));
         builder.append(lineBreak);
     }
@@ -193,21 +195,18 @@ public class DescriptionGenerator {
      * @param lineBreak line break string
      */
     @VisibleForTesting
-    void writeSpeed(double speed, StringBuilder builder, int resId, String lineBreak) {
-        double speedInKmHr = speed * UnitConversions.MPS_TO_KMH;
-        double speedInMiHr = speedInKmHr * UnitConversions.KM_TO_MI;
-        builder.append(context.getString(resId, speedInKmHr, speedInMiHr));
+    void writeSpeed(Speed speed, StringBuilder builder, int resId, String lineBreak) {
+        builder.append(context.getString(resId, speed.toKMH(), speed.toMPH()));
         builder.append(lineBreak);
     }
 
     /**
-     * @param speed     speed in meters per second
      * @param builder   StringBuilder to append pace
      * @param resId     resource id of pace string
      * @param lineBreak line break string
      */
     @VisibleForTesting
-    void writePace(double speed, StringBuilder builder, int resId, String lineBreak) {
+    void writePace(Speed speed, StringBuilder builder, int resId, String lineBreak) {
         Pair<String, String> paceInMetrics = StringUtils.getSpeedParts(context, speed, true, false);
         Pair<String, String> paceInImperial = StringUtils.getSpeedParts(context, speed, false, false);
 

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

@@ -0,0 +1,116 @@
+package de.dennisguse.opentracks.content.data;
+
+import androidx.annotation.NonNull;
+
+import java.util.Objects;
+
+import de.dennisguse.opentracks.util.UnitConversions;
+
+public class Distance {
+
+    public static Distance of(double distance_m) {
+        return new Distance(distance_m);
+    }
+
+    public static Distance of(String distance_m) {
+        return of(Float.parseFloat(distance_m));
+    }
+
+    public static Distance ofMile(double distance_mile) {
+        return of(distance_mile * UnitConversions.MI_TO_M);
+    }
+
+    public static Distance invalid() {
+        return of(Double.NaN);
+    }
+
+    private final double distance_m;
+
+    private Distance(double distance_m) {
+        this.distance_m = distance_m;
+    }
+
+    public Distance plus(@NonNull Distance distance) {
+        return new Distance(distance_m + distance.distance_m);
+    }
+
+    public Distance multipliedBy(double factor) {
+        return new Distance(factor * distance_m);
+    }
+
+    public boolean isZero() {
+        return distance_m == 0;
+    }
+
+    public boolean isInvalid() {
+        return Double.isNaN(distance_m) || Double.isInfinite(distance_m);
+    }
+
+    public boolean lessThan(@NonNull Distance distance) {
+        return !greaterThan(distance);
+    }
+
+    public boolean greaterThan(@NonNull Distance distance) {
+        return distance_m > distance.distance_m;
+    }
+
+    public boolean greaterOrEqualThan(@NonNull Distance distance) {
+        return distance_m >= distance.distance_m;
+    }
+
+    public double toM() {
+        return distance_m;
+    }
+
+    public double toKM() {
+        return distance_m * UnitConversions.M_TO_KM;
+    }
+
+    public double toFT() {
+        return distance_m * UnitConversions.M_TO_FT;
+    }
+
+    public double toMI() {
+        return toKM() * UnitConversions.KM_TO_MI;
+    }
+
+    public double to(boolean metricUnit) {
+        return to(metricUnit ? Unit.KM : Unit.MILES);
+    }
+
+    public double to(Unit unit) {
+        switch (unit) {
+            case KM:
+                return toKM();
+            case MILES:
+                return toMI();
+            default:
+                throw new RuntimeException("Not implemented");
+        }
+    }
+
+    public enum Unit {
+        KM,
+        MILES
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Distance distance = (Distance) o;
+        return Double.compare(distance.distance_m, distance_m) == 0;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(distance_m);
+    }
+
+    @Override
+    public String toString() {
+        return "Distance{" +
+                "distance_m=" + distance_m +
+                '}';
+    }
+}

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

@@ -28,12 +28,15 @@ import java.time.Duration;
 import java.time.Instant;
 import java.util.Objects;
 
+import de.dennisguse.opentracks.stats.TrackStatistics;
+
 /**
  * NOTE: A marker is indirectly (via it's location) assigned to one {@link TrackPoint} with trackPoint.hasLocation() == true.
  *
  * @author Leif Hendrik Wilden
  * @author Rodrigo Damazio
  */
+//TODO All data should be final; no default values.
 public final class Marker {
 
     private Id id;
@@ -51,7 +54,7 @@ public final class Marker {
     private Float bearing;
 
     //TODO It is the distance from the track starting point; rename to something more meaningful
-    private double length = 0.0;
+    private Distance length;
     private Duration duration;
 
     @Deprecated //TODO Make an URI instead of String
@@ -62,6 +65,7 @@ public final class Marker {
         this.time = time;
     }
 
+    @Deprecated //TODO Marker cannot be created without length AND duration!
     public Marker(@Nullable Track.Id trackId, @NonNull TrackPoint trackPoint) {
         this.trackId = trackId;
 
@@ -75,16 +79,19 @@ public final class Marker {
         if (trackPoint.hasAccuracy()) this.accuracy = trackPoint.getAccuracy();
         if (trackPoint.hasAltitude()) this.altitude_m = trackPoint.getAltitude();
         if (trackPoint.hasBearing()) this.bearing = trackPoint.getBearing();
+
+        this.length = Distance.of(0); //TODO Not cool!
+        this.duration = Duration.ofMillis(0); //TODO Not cool!
     }
 
-    public Marker(String name, String description, String category, String icon, @NonNull Track.Id trackId, double length, @NonNull Duration duration, @NonNull TrackPoint trackPoint, String photoUrl) {
+    public Marker(String name, String description, String category, String icon, @NonNull Track.Id trackId, @NonNull TrackStatistics statistics, @NonNull TrackPoint trackPoint, String photoUrl) {
         this(trackId, trackPoint);
         this.name = name;
         this.description = description;
         this.category = category;
         this.icon = icon;
-        this.length = length;
-        this.duration = duration;
+        this.length = statistics.getTotalDistance();
+        this.duration = statistics.getTotalTime();
         this.photoUrl = photoUrl;
     }
 
@@ -218,11 +225,11 @@ public final class Marker {
         this.bearing = bearing;
     }
 
-    public double getLength() {
+    public Distance getLength() {
         return length;
     }
 
-    public void setLength(double length) {
+    public void setLength(Distance length) {
         this.length = length;
     }
 

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

@@ -0,0 +1,145 @@
+package de.dennisguse.opentracks.content.data;
+
+import java.time.Duration;
+import java.util.Objects;
+
+import de.dennisguse.opentracks.util.UnitConversions;
+
+public class Speed {
+
+    public static Speed of(Distance distance, Duration duration) {
+        if (duration.isZero()) {
+            return zero();
+        }
+
+        return new Speed(distance.toM() / (duration.toMillis() * UnitConversions.MS_TO_S));
+    }
+
+    public static Speed of(double speed_mps) {
+        return new Speed(speed_mps);
+    }
+
+    public static Speed of(String speed_mps) {
+        return of(Float.parseFloat(speed_mps));
+    }
+
+    public static Speed invalid() {
+        return of(Double.NaN);
+    }
+
+    public static Speed zero() {
+        return of(0.0);
+    }
+
+    public static Speed max(Speed speed1, Speed speed2) {
+        if (speed1.greaterThan(speed2)) {
+            return speed1;
+        }
+
+        return speed2;
+    }
+
+    public static Speed absDiff(Speed speed1, Speed speed2) {
+        //TODO Why Math.abs? Seems to be a leftover.
+        return Speed.of(Math.abs(speed1.speed_mps - speed2.speed_mps));
+    }
+
+
+    // Anything faster than that (in meters per second) will be considered moving.
+    private static final double MAX_NO_MOVEMENT_SPEED = 0.224;
+
+    private final double speed_mps;
+
+    private Speed(double speed_mps) {
+        this.speed_mps = speed_mps;
+    }
+
+    public Speed mul(double factor) {
+        return new Speed(factor * speed_mps);
+    }
+
+    public boolean isZero() {
+        return speed_mps == 0;
+    }
+
+    public boolean isInvalid() {
+        return Double.isNaN(speed_mps) || Double.isInfinite(speed_mps);
+    }
+
+    public boolean isMoving() {
+        return !isInvalid() && speed_mps >= MAX_NO_MOVEMENT_SPEED;
+    }
+
+    public boolean lessThan(Speed speed) {
+        return !greaterThan(speed);
+    }
+
+    public boolean greaterThan(Speed speed) {
+        return speed_mps > speed.speed_mps;
+    }
+
+    public boolean greaterOrEqualThan(Speed speed) {
+        return speed_mps >= speed.speed_mps;
+    }
+
+    public double toMPS() {
+        return speed_mps;
+    }
+
+    public double toKMH() {
+        return speed_mps * UnitConversions.MPS_TO_KMH;
+    }
+
+    public double toMPH() {
+        return toKMH() * UnitConversions.KM_TO_MI;
+    }
+
+    public Duration toPace(boolean metricUnit) {
+        if (isZero()) {
+            return Duration.ofSeconds(0);
+        }
+
+        double distance = speed_mps * (metricUnit ? UnitConversions.M_TO_KM : UnitConversions.M_TO_MI);
+        return Duration.ofSeconds(Math.round(1 / distance));
+    }
+
+    public double to(boolean metricUnit) {
+        return to(metricUnit ? Unit.KMH : Unit.MPH);
+    }
+
+    public double to(Unit unit) {
+        switch (unit) {
+            case KMH:
+                return toKMH();
+            case MPH:
+                return toMPH();
+            default:
+                throw new RuntimeException("Not implemented");
+        }
+    }
+
+    public enum Unit {
+        KMH,
+        MPH,
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Speed speed = (Speed) o;
+        return Double.compare(speed.speed_mps, speed_mps) == 0;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(speed_mps);
+    }
+
+    @Override
+    public String toString() {
+        return "Speed{" +
+                "speed_mps=" + speed_mps +
+                '}';
+    }
+}

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

@@ -45,9 +45,6 @@ public class TrackPoint {
 
     private static final Duration MAX_LOCATION_AGE = Duration.ofMinutes(1);
 
-    // Anything faster than that (in meters per second) will be considered moving.
-    private static final double MAX_NO_MOVEMENT_SPEED = 0.224;
-
     private TrackPoint.Id id;
 
     private Instant time;
@@ -55,9 +52,9 @@ public class TrackPoint {
     private Double longitude;
     private Float accuracy;
     private Double altitude_m;
-    private Float speed_mps;
+    private Speed speed;
     private Float bearing;
-    private Float sensorDistance_m;
+    private Distance sensorDistance_m;
 
     public enum Type {
         SEGMENT_START_MANUAL(-2), //Start of a segment due to user interaction (start, resume)
@@ -106,7 +103,7 @@ public class TrackPoint {
         this.latitude = location.getLatitude();
         this.longitude = location.getLongitude();
         this.altitude_m = location.getAltitude();
-        this.speed_mps = location.getSpeed();
+        this.speed = Speed.of(location.getSpeed());
         this.accuracy = location.getAccuracy();
 
         setTime(Instant.now());
@@ -272,19 +269,19 @@ public class TrackPoint {
     }
 
     public boolean hasSpeed() {
-        return speed_mps != null;
+        return speed != null;
     }
 
-    public float getSpeed() {
-        return speed_mps;
+    public Speed getSpeed() {
+        return speed;
     }
 
-    public void setSpeed(Float speed) {
-        this.speed_mps = speed;
+    public void setSpeed(Speed speed) {
+        this.speed = speed;
     }
 
     public boolean isMoving() {
-        return hasSpeed() && getSpeed() >= MAX_NO_MOVEMENT_SPEED;
+        return hasSpeed() && getSpeed().isMoving();
     }
 
     public boolean hasBearing() {
@@ -311,12 +308,12 @@ public class TrackPoint {
         this.accuracy = horizontalAccuracy;
     }
 
-    public float distanceToPrevious(@NonNull TrackPoint previous) {
+    public Distance distanceToPrevious(@NonNull TrackPoint previous) {
         if (hasSensorDistance()) {
             return getSensorDistance();
         }
 
-        return getLocation().distanceTo(previous.getLocation());
+        return Distance.of(getLocation().distanceTo(previous.getLocation()));
     }
 
     public boolean fulfillsAccuracy(int poorAccuracy) {
@@ -336,11 +333,11 @@ public class TrackPoint {
         return sensorDistance_m != null;
     }
 
-    public Float getSensorDistance() {
+    public Distance getSensorDistance() {
         return sensorDistance_m;
     }
 
-    public void setSensorDistance(Float distance_m) {
+    public void setSensorDistance(Distance distance_m) {
         this.sensorDistance_m = distance_m;
     }
 

src/main/java/de/dennisguse/opentracks/content/provider/ContentProviderUtils.java

@@ -39,8 +39,10 @@ import java.util.List;
 import java.util.UUID;
 
 import de.dennisguse.opentracks.BuildConfig;
+import de.dennisguse.opentracks.content.data.Distance;
 import de.dennisguse.opentracks.content.data.Marker;
 import de.dennisguse.opentracks.content.data.MarkerColumns;
+import de.dennisguse.opentracks.content.data.Speed;
 import de.dennisguse.opentracks.content.data.Track;
 import de.dennisguse.opentracks.content.data.TrackPoint;
 import de.dennisguse.opentracks.content.data.TrackPointsColumns;
@@ -127,7 +129,7 @@ public class ContentProviderUtils {
             trackStatistics.setStopTime(Instant.ofEpochMilli(cursor.getLong(stopTimeIndex)));
         }
         if (!cursor.isNull(totalDistanceIndex)) {
-            trackStatistics.setTotalDistance(cursor.getFloat(totalDistanceIndex));
+            trackStatistics.setTotalDistance(Distance.of(cursor.getFloat(totalDistanceIndex)));
         }
         if (!cursor.isNull(totalTimeIndex)) {
             trackStatistics.setTotalTime(Duration.ofMillis(cursor.getLong(totalTimeIndex)));
@@ -136,7 +138,7 @@ public class ContentProviderUtils {
             trackStatistics.setMovingTime(Duration.ofMillis(cursor.getLong(movingTimeIndex)));
         }
         if (!cursor.isNull(maxSpeedIndex)) {
-            trackStatistics.setMaxSpeed(cursor.getFloat(maxSpeedIndex));
+            trackStatistics.setMaxSpeed(Speed.of(cursor.getFloat(maxSpeedIndex)));
         }
         if (!cursor.isNull(minAltitudeIndex)) {
             trackStatistics.setMinAltitude(cursor.getFloat(minAltitudeIndex));
@@ -278,12 +280,12 @@ public class ContentProviderUtils {
         if (trackStatistics.getStopTime() != null) {
             values.put(TracksColumns.STOPTIME, trackStatistics.getStopTime().toEpochMilli());
         }
-        values.put(TracksColumns.TOTALDISTANCE, trackStatistics.getTotalDistance());
+        values.put(TracksColumns.TOTALDISTANCE, trackStatistics.getTotalDistance().toM());
         values.put(TracksColumns.TOTALTIME, trackStatistics.getTotalTime().toMillis());
         values.put(TracksColumns.MOVINGTIME, trackStatistics.getMovingTime().toMillis());
-        values.put(TracksColumns.AVGSPEED, trackStatistics.getAverageSpeed());
-        values.put(TracksColumns.AVGMOVINGSPEED, trackStatistics.getAverageMovingSpeed());
-        values.put(TracksColumns.MAXSPEED, trackStatistics.getMaxSpeed());
+        values.put(TracksColumns.AVGSPEED, trackStatistics.getAverageSpeed().toMPS());
+        values.put(TracksColumns.AVGMOVINGSPEED, trackStatistics.getAverageMovingSpeed().toMPS());
+        values.put(TracksColumns.MAXSPEED, trackStatistics.getMaxSpeed().toMPS());
         values.put(TracksColumns.MIN_ALTITUDE, trackStatistics.getMinAltitude());
         values.put(TracksColumns.MAX_ALTITUDE, trackStatistics.getMaxAltitude());
         values.put(TracksColumns.ALTITUDE_GAIN, trackStatistics.getTotalAltitudeGain());
@@ -343,7 +345,7 @@ public class ContentProviderUtils {
             marker.setIcon(cursor.getString(iconIndex));
         }
         if (!cursor.isNull(lengthIndex)) {
-            marker.setLength(cursor.getFloat(lengthIndex));
+            marker.setLength(Distance.of(cursor.getFloat(lengthIndex)));
         }
         if (!cursor.isNull(durationIndex)) {
             marker.setDuration(Duration.ofMillis(cursor.getLong(durationIndex)));
@@ -480,7 +482,7 @@ public class ContentProviderUtils {
         values.put(MarkerColumns.CATEGORY, marker.getCategory());
         values.put(MarkerColumns.ICON, marker.getIcon());
         values.put(MarkerColumns.TRACKID, marker.getTrackId().getId());
-        values.put(MarkerColumns.LENGTH, marker.getLength());
+        values.put(MarkerColumns.LENGTH, marker.getLength().toM());
         values.put(MarkerColumns.DURATION, marker.getDuration().toMillis());
 
         values.put(MarkerColumns.LONGITUDE, (int) (marker.getLongitude() * 1E6));
@@ -543,7 +545,7 @@ public class ContentProviderUtils {
             trackPoint.setAccuracy(cursor.getFloat(indexes.accuracyIndex));
         }
         if (!cursor.isNull(indexes.speedIndex)) {
-            trackPoint.setSpeed(cursor.getFloat(indexes.speedIndex));
+            trackPoint.setSpeed(Speed.of(cursor.getFloat(indexes.speedIndex)));
         }
         if (!cursor.isNull(indexes.bearingIndex)) {
             trackPoint.setBearing(cursor.getFloat(indexes.bearingIndex));
@@ -556,7 +558,7 @@ public class ContentProviderUtils {
             trackPoint.setCyclingCadence_rpm(cursor.getFloat(indexes.sensorCadenceIndex));
         }
         if (!cursor.isNull(indexes.sensorDistanceIndex)) {
-            trackPoint.setSensorDistance(cursor.getFloat(indexes.sensorDistanceIndex));
+            trackPoint.setSensorDistance(Distance.of(cursor.getFloat(indexes.sensorDistanceIndex)));
         }
         if (!cursor.isNull(indexes.sensorPowerIndex)) {
             trackPoint.setPower(cursor.getFloat(indexes.sensorPowerIndex));
@@ -694,7 +696,7 @@ public class ContentProviderUtils {
             values.put(TrackPointsColumns.ACCURACY, trackPoint.getAccuracy());
         }
         if (trackPoint.hasSpeed()) {
-            values.put(TrackPointsColumns.SPEED, trackPoint.getSpeed());
+            values.put(TrackPointsColumns.SPEED, trackPoint.getSpeed().toMPS());
         }
         if (trackPoint.hasBearing()) {
             values.put(TrackPointsColumns.BEARING, trackPoint.getBearing());
@@ -707,7 +709,7 @@ public class ContentProviderUtils {
             values.put(TrackPointsColumns.SENSOR_CADENCE, trackPoint.getCyclingCadence_rpm());
         }
         if (trackPoint.hasSensorDistance()) {
-            values.put(TrackPointsColumns.SENSOR_DISTANCE, trackPoint.getSensorDistance());
+            values.put(TrackPointsColumns.SENSOR_DISTANCE, trackPoint.getSensorDistance().toM());
         }
         if (trackPoint.hasPower()) {
             values.put(TrackPointsColumns.SENSOR_POWER, trackPoint.getPower());

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

@@ -6,6 +6,10 @@ import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.core.util.Pair;
 
+import java.time.Duration;
+
+import de.dennisguse.opentracks.content.data.Distance;
+import de.dennisguse.opentracks.content.data.Speed;
 import de.dennisguse.opentracks.util.UintUtils;
 import de.dennisguse.opentracks.util.UnitConversions;
 
@@ -122,21 +126,21 @@ public final class SensorDataCycling {
         public void compute(DistanceSpeed previous, int wheel_circumference_mm) {
             if (hasData() && previous != null && previous.hasData()) {
                 float timeDiff_ms = UintUtils.diff(wheelRevolutionsTime, previous.wheelRevolutionsTime, UintUtils.UINT16_MAX) / 1024f * UnitConversions.S_TO_MS;
-                if (timeDiff_ms <= 0) {
+                Duration timeDiff = Duration.ofMillis((long) timeDiff_ms);
+                if (timeDiff.isZero() || timeDiff.isNegative()) {
                     Log.e(TAG, "Timestamps difference is invalid: cannot compute cadence.");
                     value = null;
                 } else {
                     long wheelDiff = UintUtils.diff(wheelRevolutionsCount, previous.wheelRevolutionsCount, UintUtils.UINT16_MAX);
-                    wheelDiff = Math.abs(wheelDiff); //HACK for Garmin Speed 2 as it some of those seem to count backwards
+                    wheelDiff = Math.abs(wheelDiff); //HACK for Garmin Speed 2 as some of those seem to count backwards
 
-                    double timeDiff_s = timeDiff_ms * UnitConversions.MS_TO_S;
-                    float distance_m = (float) (wheelDiff * wheel_circumference_mm * UnitConversions.MM_TO_M);
-                    float distance_overall_m = distance_m;
+                    Distance distance = Distance.of(wheelDiff * wheel_circumference_mm * UnitConversions.MM_TO_M);
+                    Distance distanceOverall = distance;
                     if (previous.hasValue()) {
-                        distance_overall_m += previous.getValue().distance_overall_m;
+                        distanceOverall = distance.plus(previous.getValue().distanceOverall);
                     }
-                    float speed_mps = (float) (distance_m / timeDiff_s);
-                    value = new Data(distance_m, distance_overall_m, speed_mps);
+                    Speed speed_mps = Speed.of(distance, timeDiff);
+                    value = new Data(distance, distanceOverall, speed_mps);
                 }
             }
         }
@@ -144,7 +148,7 @@ public final class SensorDataCycling {
         @Override
         public void reset() {
             if (value != null) {
-                value = new Data(value.distance_m, 0, value.speed_mps);
+                value = new Data(value.distance, Distance.of(0), value.speed);
             }
         }
 
@@ -167,22 +171,22 @@ public final class SensorDataCycling {
         }
 
         public static class Data {
-            public final float distance_m;
-            public final float distance_overall_m;
-            public final float speed_mps;
+            public final Distance distance;
+            public final Distance distanceOverall;
+            public final Speed speed;
 
-            private Data(float distance_m, float distance_overall_m, float speed_mps) {
-                this.distance_m = distance_m;
-                this.distance_overall_m = distance_overall_m;
-                this.speed_mps = speed_mps;
+            private Data(Distance distance, Distance distanceOverall, Speed speed) {
+                this.distance = distance;
+                this.distanceOverall = distanceOverall;
+                this.speed = speed;
             }
 
             @Override
             public String toString() {
                 return "Data{" +
-                        "distance_m=" + distance_m +
-                        ", distance_overall_m=" + distance_overall_m +
-                        ", speed_mps=" + speed_mps +
+                        "distance_m=" + distance +
+                        ", distance_overall_m=" + distanceOverall +
+                        ", speed_mps=" + speed +
                         '}';
             }
         }

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

@@ -58,8 +58,8 @@ public final class SensorDataSet {
         }
 
         if (cyclingDistanceSpeed != null && cyclingDistanceSpeed.hasValue()) {
-            trackPoint.setSensorDistance(cyclingDistanceSpeed.getValue().distance_overall_m);
-            trackPoint.setSpeed(cyclingDistanceSpeed.getValue().speed_mps);
+            trackPoint.setSensorDistance(cyclingDistanceSpeed.getValue().distanceOverall);
+            trackPoint.setSpeed(cyclingDistanceSpeed.getValue().speed);
         }
 
         if (cyclingPower != null && cyclingPower.hasValue()) {