Merge Deliverable 1 changes from Group 3 (/stats folder).

build.gradle

@@ -1,15 +1,20 @@
-apply plugin: 'com.android.application'
-
 buildscript {
     repositories {
         google()
         mavenCentral()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:8.2.1'
+        classpath 'com.android.tools.build:gradle:8.1.3'
     }
 }
 
+plugins {
+    id "org.sonarqube" version "3.5.0.2730"
+}
+
+
+apply plugin: 'com.android.application'
+
 allprojects {
     repositories {
         google()
@@ -116,8 +121,8 @@ android {
 
         if (variant.buildType.name == 'nightly') {
             variant.outputs.configureEach {
-                setVersionCodeOverride(getVersionCode())
-                setVersionNameOverride(getVersionName())
+                setVersionCodeOverride(getVersionCodeOverride())
+                setVersionNameOverride(getVersionNameOverride())
                 outputFileName = "${applicationId}_${variant.versionCode}.apk"
             }
         }
@@ -146,3 +151,4 @@ dependencies {
 
     androidTestUtil 'androidx.test:orchestrator:1.4.2'
 }
+

src/androidTest/java/de/dennisguse/opentracks/stats/TrackStatisticsUpdaterTest.java

@@ -87,7 +87,7 @@ public void addTrackPoint_TestingTrack() {
 
         assertEquals(2.5, statistics.getMinAltitude(), 0.01);
         assertEquals(32.5, statistics.getMaxAltitude(), 0.01);
-        assertEquals(36, statistics.getTotalAltitudeGain(), 0.01);
+        assertEquals(36,  0.01, statistics.getTotalAltitudeGain());
         assertEquals(36, statistics.getTotalAltitudeLoss(), 0.01);
 
         assertEquals(11.85, statistics.getMaxSpeed().toMPS(), 0.01);

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

@@ -56,8 +56,8 @@ public class TrackStatistics {
     private Duration movingTime;
     // The maximum speed (meters/second) that we believe is valid.
     private Speed maxSpeed;
-    private Float totalAltitudeGain_m = null;
-    private Float totalAltitudeLoss_m = null;
+    private Float totalAltitudeGainMeters = null;
+    private Float totalAltitudeLossMeters = null;
     // The average heart rate seen on this track
     private HeartRate avgHeartRate = null;
 
@@ -80,22 +80,22 @@ public TrackStatistics(TrackStatistics other) {
         movingTime = other.movingTime;
         maxSpeed = other.maxSpeed;
         altitudeExtremities.set(other.altitudeExtremities.getMin(), other.altitudeExtremities.getMax());
-        totalAltitudeGain_m = other.totalAltitudeGain_m;
-        totalAltitudeLoss_m = other.totalAltitudeLoss_m;
+        totalAltitudeGainMeters = other.totalAltitudeGainMeters;
+        totalAltitudeLossMeters = other.totalAltitudeLossMeters;
         avgHeartRate = other.avgHeartRate;
         isIdle = other.isIdle;
     }
 
     @VisibleForTesting
-    public TrackStatistics(String startTime, String stopTime, double totalDistance_m, int totalTime_s, int movingTime_s, float maxSpeed_mps, Float totalAltitudeGain_m, Float totalAltitudeLoss_m) {
+    public TrackStatistics(String startTime, String stopTime, double totalDistance_m, int totalTime_s, int movingTime_s, float maxSpeed_mps, Float totalAltitudeGainMeters, Float totalAltitudeLossMeters) {
         this.startTime = Instant.parse(startTime);
         this.stopTime = Instant.parse(stopTime);
         this.totalDistance = Distance.of(totalDistance_m);
         this.totalTime = Duration.ofSeconds(totalTime_s);
         this.movingTime = Duration.ofSeconds(movingTime_s);
         this.maxSpeed = Speed.of(maxSpeed_mps);
-        this.totalAltitudeGain_m = totalAltitudeGain_m;
-        this.totalAltitudeLoss_m = totalAltitudeLoss_m;
+        this.totalAltitudeGainMeters = totalAltitudeGainMeters;
+        this.totalAltitudeLossMeters = totalAltitudeLossMeters;
     }
 
     /**
@@ -137,22 +137,22 @@ public void merge(TrackStatistics other) {
             altitudeExtremities.update(other.altitudeExtremities.getMin());
             altitudeExtremities.update(other.altitudeExtremities.getMax());
         }
-        if (totalAltitudeGain_m == null) {
-            if (other.totalAltitudeGain_m != null) {
-                totalAltitudeGain_m = other.totalAltitudeGain_m;
+        if (totalAltitudeGainMeters == null) {
+            if (other.totalAltitudeGainMeters != null) {
+                totalAltitudeGainMeters = other.totalAltitudeGainMeters;
             }
         } else {
-            if (other.totalAltitudeGain_m != null) {
-                totalAltitudeGain_m += other.totalAltitudeGain_m;
+            if (other.totalAltitudeGainMeters != null) {
+                totalAltitudeGainMeters += other.totalAltitudeGainMeters;
             }
         }
-        if (totalAltitudeLoss_m == null) {
-            if (other.totalAltitudeLoss_m != null) {
-                totalAltitudeLoss_m = other.totalAltitudeLoss_m;
+        if (totalAltitudeLossMeters == null) {
+            if (other.totalAltitudeLossMeters != null) {
+                totalAltitudeLossMeters = other.totalAltitudeLossMeters;
             }
         } else {
-            if (other.totalAltitudeLoss_m != null) {
-                totalAltitudeLoss_m += other.totalAltitudeLoss_m;
+            if (other.totalAltitudeLossMeters != null) {
+                totalAltitudeLossMeters += other.totalAltitudeLossMeters;
             }
         }
     }
@@ -301,8 +301,8 @@ public double getMinAltitude() {
         return altitudeExtremities.getMin();
     }
 
-    public void setMinAltitude(double altitude_m) {
-        altitudeExtremities.setMin(altitude_m);
+    public void setMinAltitude(double altitudeMeter) {
+        altitudeExtremities.setMin(altitudeMeter);
     }
 
     public boolean hasAltitudeMax() {
@@ -317,8 +317,8 @@ public double getMaxAltitude() {
         return altitudeExtremities.getMax();
     }
 
-    public void setMaxAltitude(double altitude_m) {
-        altitudeExtremities.setMax(altitude_m);
+    public void setMaxAltitude(double altitudeMeter) {
+        altitudeExtremities.setMax(altitudeMeter);
     }
 
     public void updateAltitudeExtremities(Altitude altitude) {
@@ -334,45 +334,45 @@ public void setAverageHeartRate(HeartRate heartRate) {
     }
 
     public boolean hasTotalAltitudeGain() {
-        return totalAltitudeGain_m != null;
+        return totalAltitudeGainMeters != null;
     }
 
     @Nullable
     public Float getTotalAltitudeGain() {
-        return totalAltitudeGain_m;
+        return totalAltitudeGainMeters;
     }
 
-    public void setTotalAltitudeGain(Float totalAltitudeGain_m) {
-        this.totalAltitudeGain_m = totalAltitudeGain_m;
+    public void setTotalAltitudeGain(Float totalAltitudeGainMeters) {
+        this.totalAltitudeGainMeters = totalAltitudeGainMeters;
     }
 
     @VisibleForTesting(otherwise = VisibleForTesting.PACKAGE_PRIVATE)
     public void addTotalAltitudeGain(float gain_m) {
-        if (totalAltitudeGain_m == null) {
-            totalAltitudeGain_m = 0f;
+        if (totalAltitudeGainMeters == null) {
+            totalAltitudeGainMeters = 0f;
         }
-        totalAltitudeGain_m += gain_m;
+        totalAltitudeGainMeters += gain_m;
     }
 
     public boolean hasTotalAltitudeLoss() {
-        return totalAltitudeLoss_m != null;
+        return totalAltitudeLossMeters != null;
     }
 
     @Nullable
     public Float getTotalAltitudeLoss() {
-        return totalAltitudeLoss_m;
+        return totalAltitudeLossMeters;
     }
 
-    public void setTotalAltitudeLoss(Float totalAltitudeLoss_m) {
-        this.totalAltitudeLoss_m = totalAltitudeLoss_m;
+    public void setTotalAltitudeLoss(Float totalAltitudeLossMeters) {
+        this.totalAltitudeLossMeters = totalAltitudeLossMeters;
     }
 
     @VisibleForTesting(otherwise = VisibleForTesting.PACKAGE_PRIVATE)
-    public void addTotalAltitudeLoss(float loss_m) {
-        if (totalAltitudeLoss_m == null) {
-            totalAltitudeLoss_m = 0f;
+    public void addTotalAltitudeLoss(float lossM) {
+        if (totalAltitudeLossMeters == null) {
+            totalAltitudeLossMeters = 0f;
         }
-        totalAltitudeLoss_m += loss_m;
+        totalAltitudeLossMeters += lossM;
     }
 
     @Override
@@ -383,6 +383,14 @@ public boolean equals(Object o) {
         return toString().equals(o.toString());
     }
 
+    @Override
+    public int hashCode() {
+        final int primeNumber = 31;
+        int result = 1;
+        result = result * primeNumber + (startTime == null ? 0 : startTime.hashCode());
+        return result;
+    }
+
     @NonNull
     @Override
     public String toString() {

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

@@ -125,36 +125,7 @@ public void addTrackPoint(TrackPoint trackPoint) {
             currentSegment.setAverageHeartRate(HeartRate.of(averageHeartRateBPM));
         }
 
-        {
-            // Update total distance
-            Distance movingDistance = null;
-            if (trackPoint.hasSensorDistance()) {
-                movingDistance = trackPoint.getSensorDistance();
-            } else if (lastTrackPoint != null
-                    && lastTrackPoint.hasLocation()
-                    && trackPoint.hasLocation()) {
-                // GPS-based distance/speed
-                movingDistance = trackPoint.distanceToPrevious(lastTrackPoint);
-            }
-            if (movingDistance != null) {
-                currentSegment.setIdle(false);
-                currentSegment.addTotalDistance(movingDistance);
-            }
-
-            if (!currentSegment.isIdle() && !trackPoint.isSegmentManualStart()) {
-                if (lastTrackPoint != null) {
-                    currentSegment.addMovingTime(trackPoint, lastTrackPoint);
-                }
-            }
-
-            if (trackPoint.getType() == TrackPoint.Type.IDLE) {
-                currentSegment.setIdle(true);
-            }
-
-            if (trackPoint.hasSpeed()) {
-                updateSpeed(trackPoint);
-            }
-        }
+        updateDistanceAndSpeed(trackPoint);
 
         if (trackPoint.isSegmentManualEnd()) {
             reset(trackPoint);
@@ -164,6 +135,30 @@ public void addTrackPoint(TrackPoint trackPoint) {
         lastTrackPoint = trackPoint;
     }
 
+    // Extracted method for updating total distance and speed
+    private void updateDistanceAndSpeed(TrackPoint trackPoint) {
+        Distance movingDistance = null;
+        if (trackPoint.hasSensorDistance()) {
+            movingDistance = trackPoint.getSensorDistance();
+        } else if (lastTrackPoint != null && lastTrackPoint.hasLocation() && trackPoint.hasLocation()) {
+            // GPS-based distance/speed
+            movingDistance = trackPoint.distanceToPrevious(lastTrackPoint);
+        }
+        if (movingDistance != null) {
+            currentSegment.setIdle(false);
+            currentSegment.addTotalDistance(movingDistance);
+        }
+        if (!currentSegment.isIdle() && !trackPoint.isSegmentManualStart() && lastTrackPoint != null) {
+            currentSegment.addMovingTime(trackPoint, lastTrackPoint);
+        }
+        if (trackPoint.getType() == TrackPoint.Type.IDLE) {
+            currentSegment.setIdle(true);
+        }
+        if (trackPoint.hasSpeed()) {
+            updateSpeed(trackPoint);
+        }
+    }
+
     private void reset(TrackPoint trackPoint) {
         if (currentSegment.isInitialized()) {
             trackStatistics.merge(currentSegment);