Track only has Statistics (instead of SegmentStatisticsUpdater).

src/main/java/de/dennisguse/opentracks/data/ContentProviderUtils.java

@@ -41,6 +41,8 @@ import java.util.UUID;
 import de.dennisguse.opentracks.BuildConfig;
 import de.dennisguse.opentracks.data.models.ActivityType;
 import de.dennisguse.opentracks.data.models.Altitude;
+import de.dennisguse.opentracks.data.models.AltitudeExtremities;
+import de.dennisguse.opentracks.data.models.AltitudeGainLoss;
 import de.dennisguse.opentracks.data.models.Cadence;
 import de.dennisguse.opentracks.data.models.Distance;
 import de.dennisguse.opentracks.data.models.HeartRate;
@@ -54,7 +56,6 @@ import de.dennisguse.opentracks.data.models.TrackPoint;
 import de.dennisguse.opentracks.data.tables.MarkerColumns;
 import de.dennisguse.opentracks.data.tables.TrackPointsColumns;
 import de.dennisguse.opentracks.data.tables.TracksColumns;
-import de.dennisguse.opentracks.stats.SegmentStatisticUpdater;
 import de.dennisguse.opentracks.stats.SensorStatistics;
 import de.dennisguse.opentracks.ui.markers.MarkerUtils;
 import de.dennisguse.opentracks.util.FileUtils;
@@ -117,7 +118,6 @@ public class ContentProviderUtils {
         int altitudeLossIndex = cursor.getColumnIndexOrThrow(TracksColumns.ALTITUDE_LOSS);
 
         Track track = new Track(ZoneOffset.ofTotalSeconds(cursor.getInt(startTimeOffsetIndex)));
-        SegmentStatisticUpdater trackStatistics = track.getTrackStatistics();
         if (!cursor.isNull(idIndex)) {
             track.setId(new Track.Id(cursor.getLong(idIndex)));
         }
@@ -137,37 +137,25 @@ public class ContentProviderUtils {
             track.setActivityTypeLocalized(cursor.getString(activityTypeLocalizedIndex));
         }
 
-        if (!cursor.isNull(startTimeIndex)) {
-            trackStatistics.setStartTime(Instant.ofEpochMilli(cursor.getLong(startTimeIndex)));
-        }
-        if (!cursor.isNull(stopTimeIndex)) {
-            trackStatistics.setStopTime(Instant.ofEpochMilli(cursor.getLong(stopTimeIndex)));
-        }
-        if (!cursor.isNull(totalDistanceIndex)) {
-            trackStatistics.setTotalDistance(Distance.of(cursor.getFloat(totalDistanceIndex)));
-        }
-        if (!cursor.isNull(totalTimeIndex)) {
-            trackStatistics.setTotalTime(Duration.ofMillis(cursor.getLong(totalTimeIndex)));
-        }
-        if (!cursor.isNull(movingTimeIndex)) {
-            trackStatistics.setMovingTime(Duration.ofMillis(cursor.getLong(movingTimeIndex)));
-        }
-        if (!cursor.isNull(maxSpeedIndex)) {
-            trackStatistics.setMaxSpeed(Speed.of(cursor.getFloat(maxSpeedIndex)));
-        }
-        if (!cursor.isNull(minAltitudeIndex)) {
-            trackStatistics.setMinAltitude(cursor.getFloat(minAltitudeIndex));
-        }
-        if (!cursor.isNull(maxAltitudeIndex)) {
-            trackStatistics.setMaxAltitude(cursor.getFloat(maxAltitudeIndex));
-        }
-        if (!cursor.isNull(altitudeGainIndex)) {
-            trackStatistics.setTotalAltitudeGain(cursor.getFloat(altitudeGainIndex));
-        }
-        if (!cursor.isNull(altitudeLossIndex)) {
-            trackStatistics.setTotalAltitudeLoss(cursor.getFloat(altitudeLossIndex));
-        }
+        Statistics trackStatistics = new Statistics(
+                cursor.isNull(startTimeIndex) ? null : Instant.ofEpochMilli(cursor.getLong(startTimeIndex)),
+                cursor.isNull(stopTimeIndex) ? null : Instant.ofEpochMilli(cursor.getLong(stopTimeIndex)),
+                cursor.isNull(totalTimeIndex) ? null : Duration.ofMillis(cursor.getLong(totalTimeIndex)),
+                cursor.isNull(movingTimeIndex) ? null : Duration.ofMillis(cursor.getLong(movingTimeIndex)),
 
+                cursor.isNull(totalDistanceIndex) ? null : Distance.of(cursor.getFloat(totalDistanceIndex)),
+
+                false,
+
+                cursor.isNull(maxSpeedIndex) ? null : Speed.of(cursor.getFloat(maxSpeedIndex)),
+                cursor.isNull(minAltitudeIndex) || cursor.isNull(maxAltitudeIndex) ? null : new AltitudeExtremities(cursor.getFloat(minAltitudeIndex), cursor.getFloat(maxAltitudeIndex)),
+                cursor.isNull(altitudeGainIndex) || cursor.isNull(altitudeLossIndex) ? null : new AltitudeGainLoss(cursor.getFloat(altitudeGainIndex), cursor.getFloat(altitudeLossIndex)),
+
+                null,
+                null
+        );
+
+        track.setStatistics(trackStatistics);
         return track;
     }
 

src/main/java/de/dennisguse/opentracks/data/models/Statistics.java

@@ -22,6 +22,8 @@ public record Statistics(
 
         @Nullable
         AltitudeGainLoss altitudeGainLoss,
+
+        //NOTE: The following values are not persisted.
         @Nullable
         HeartRate avgHeartRate,
         @Nullable

src/main/java/de/dennisguse/opentracks/data/models/Track.java

@@ -49,18 +49,25 @@ public class Track {
 
     private ActivityType activityType;
 
+    //TODO Move to Statistics?
     private ZoneOffset zoneOffset;
 
-    @Deprecated // TODO Replace with Statistic
-    private SegmentStatisticUpdater trackStatistics = new SegmentStatisticUpdater();
+    @NonNull
+    private Statistics trackStatistics;
 
     @VisibleForTesting
     public Track() {
         this(ZoneOffset.UTC);
     }
 
+    @Deprecated //TODO Remove
     public Track(@NonNull ZoneOffset zoneOffset) {
-        setZoneOffset(zoneOffset);
+        this(zoneOffset, new SegmentStatisticUpdater().getStatistics());
+    }
+
+    public Track(@NonNull ZoneOffset zoneOffset, @NonNull Statistics trackStatistics) {
+        this.zoneOffset = zoneOffset;
+        this.trackStatistics = trackStatistics;
     }
 
     /**
@@ -130,32 +137,25 @@ public class Track {
 
     public OffsetDateTime getStartTime() {
         return trackStatistics
-                .getStartTime().atOffset(zoneOffset);
+                .startTime().atOffset(zoneOffset);
     }
 
     public OffsetDateTime getStopTime() {
         return trackStatistics
-                .getStopTime().atOffset(zoneOffset);
+                .stopTime().atOffset(zoneOffset);
     }
 
     public Statistics getStatistics() {
-        return trackStatistics.getStatistics();
-    }
-
-    public void setStatistics(Statistics statistics) {
-        //TODO Implementation is used for refactoring: this.statistics = statistics;
-        setTrackStatistics(new SegmentStatisticUpdater(statistics));
-    }
-
-    @Deprecated
-    @NonNull
-    public SegmentStatisticUpdater getTrackStatistics() {
         return trackStatistics;
     }
 
+    public void setStatistics(Statistics trackStatistics) {
+        this.trackStatistics = trackStatistics;
+    }
+
     @Deprecated
     public void setTrackStatistics(@NonNull SegmentStatisticUpdater trackStatistics) {
-        this.trackStatistics = trackStatistics;
+        setStatistics(trackStatistics.getStatistics());
     }
 
     @NonNull

src/main/java/de/dennisguse/opentracks/services/TrackRecordingManager.java

@@ -98,7 +98,7 @@ public class TrackRecordingManager implements SharedPreferences.OnSharedPreferen
             return false;
         }
 
-        trackStatisticsUpdater = new TrackStatisticsUpdater(track.getTrackStatistics());
+        trackStatisticsUpdater = new TrackStatisticsUpdater(track.getStatistics());
         onNewTrackPoint(trackPointCreator.createSegmentStartManual());
 
         reset();

src/main/java/de/dennisguse/opentracks/stats/TrackStatisticsUpdater.java

@@ -58,7 +58,12 @@ public class TrackStatisticsUpdater {
         this(new SegmentStatisticUpdater());
     }
 
-    public TrackStatisticsUpdater(SegmentStatisticUpdater segmentStatisticUpdater) {
+    public TrackStatisticsUpdater(Statistics statistics) {
+        this(new SegmentStatisticUpdater(statistics));
+    }
+
+    @Deprecated
+    private TrackStatisticsUpdater(SegmentStatisticUpdater segmentStatisticUpdater) {
         this.segmentStatisticUpdater = segmentStatisticUpdater;
         this.currentSegment = new SegmentStatisticUpdater();