Release v3.7.4

Only the overall number of tracks is shown now (similar to import).

.github/workflows/test.yml

@@ -6,7 +6,7 @@ jobs:
     runs-on: macos-latest
     strategy:
       matrix:
-        api-level: [21, 29]
+        api-level: [29]
         target: [default]
     steps:
       - name: checkout

README.md

@@ -5,8 +5,9 @@ _OpenTracks_ is a sport tracking application that completely respects your priva
 <table>
     <tr>
         <th>Free</th>
-        <th>Paid</th>
+        <th>Paid (same as free)</th>
         <th>Donations</th>
+        <th>Translations</th>
     </tr>
     <tr>
         <td>
@@ -24,27 +25,34 @@ _OpenTracks_ is a sport tracking application that completely respects your priva
                 <img alt="Donate using Liberapay" src="https://liberapay.com/assets/widgets/donate.svg" height="45" align="middle">
             </a>
         </td>
+        <td>
+            <a href="https://www.transifex.com/opentracks/opentracks/">
+                Transifex
+            </a>
+        </td>
     </tr>
 </table>
 
 ## Features:
 * __Tracking:__ track your sport and outdoor activities 
 * __Photos and Markers:__ mark interesting locations while tracking (also with photos)
-* __Heart rate:__ supports Bluetooth LE sensors
+* __Bluetooth LE sensors:__ 
+  * heart rate
+  * cycling: speed and cadence
 * __Export data:__ export tracks either as KMZ (incl. photos), KML or GPX
 * __No Internet access:__ Internet is not used
 * __Voice announcements__
 * __No advertising__
 * __Privacy:__
     * _does not contain any in-app analytics_
-    * _does not have Google Play Services_ 
+    * _does not use Google Play Services_ 
     * _has no cloud integration_
     
 __Only required permissions:__
 * _ACCESS_FINE_LOCATION_: required to use the GPS.
 
 _Please note:_
-_Tracks_ does not contain a _map_ (as this would required Internet access).
+_OpenTracks_ does not contain a _map_ (as this would required Internet access).
 To show your tracks on a map, a 3rd party application (e.g., [OsmAnd](https://play.google.com/store/apps/details?id=net.osmand) or [MAPS.ME](https://play.google.com/store/apps/details?id=com.mapswithme.maps.pro)) needs to be installed.  
 
 ## Custom Dashboards
@@ -53,10 +61,12 @@ The reference implementation is [OSMDashboard](https://github.com/OpenTracksApp/
 
 ## Screenshots
 <div>
-    <img width="20%" src="fastlane/metadata/android/en-US/phoneScreenshots/screenshot_1.png">
-    <img width="20%" src="fastlane/metadata/android/en-US/phoneScreenshots/screenshot_2.png">
-    <img width="20%" src="fastlane/metadata/android/en-US/phoneScreenshots/screenshot_3.png">
-    <img width="20%" src="fastlane/metadata/android/en-US/phoneScreenshots/screenshot_4.png">
+    <img width="15%" src="fastlane/metadata/android/en-US/phoneScreenshots/screenshot_1.png">
+    <img width="15%" src="fastlane/metadata/android/en-US/phoneScreenshots/screenshot_2.png">
+    <img width="15%" src="fastlane/metadata/android/en-US/phoneScreenshots/screenshot_3.png">
+    <img width="15%" src="fastlane/metadata/android/en-US/phoneScreenshots/screenshot_4.png">
+    <img width="15%" src="fastlane/metadata/android/en-US/phoneScreenshots/screenshot_5.png">
+    <img width="15%" src="fastlane/metadata/android/en-US/phoneScreenshots/screenshot_6.png">
 </div>
 
 ## Project history

build.gradle

@@ -59,9 +59,9 @@ android {
                 applicationName: "@string/app_name"
         ]
 
-        versionCode 3333
+        versionCode 3396
         //versionCode getVersionCode() //Useful for debugging.
-        versionName "v3.6.1"
+        versionName "v3.7.4"
 
         buildConfigField "String", "VERSION_NAME_FULL", "\"${getVersionName()}\""
 
@@ -100,7 +100,7 @@ android {
 
 dependencies {
     implementation 'androidx.appcompat:appcompat:1.1.0'
-    implementation 'androidx.preference:preference:1.1.0'
+    implementation 'androidx.preference:preference:1.1.1'
     implementation 'androidx.documentfile:documentfile:1.0.1'
 
     androidTestImplementation 'androidx.test:core:1.2.0'
@@ -114,4 +114,5 @@ dependencies {
     testImplementation 'androidx.test:core:1.2.0'
     testImplementation 'org.mockito:mockito-core:3.0.0'
     implementation 'com.google.android.material:material:1.1.0'
+    implementation 'com.android.support.constraint:constraint-layout:1.1.3'
 }

doc/activities.txt

@@ -9,23 +9,34 @@ from every activity showing a menu.
 endlegend
 
 [*] --> TrackListActivity
-TrackListActivity --> TrackDetailActivity : Start recording
+TrackListActivity --> TrackRecordingActivity : Start recording
 TrackListActivity --> SearchListActivity
 TrackListActivity --> MarkerListActivity : Show all markers
-TrackListActivity --> TrackDetailActivity : Show track
+TrackListActivity --> TrackRecordedActivity : Show track
 TrackListActivity --> TrackDeleteActivity
 
 SearchListActivity --> MarkerDetailActivity : Search result
-SearchListActivity --> TrackDetailActivity : Search result
+SearchListActivity --> TrackRecordedActivity : Search result
 
-TrackDetailActivity --> TrackDeleteActivity
-TrackDetailActivity --> TrackEditActivity
-TrackDetailActivity --> MarkerListActivity
-TrackDetailActivity --> MarkerEditActivity : Add marker
-TrackDetailActivity --> CameraIntent : Add marker (with photo)
-TrackDetailActivity --> ShareFileIntent
-TrackDetailActivity --> DashboardIntent : Database cursor
-TrackDetailActivity --> TrackOnMapIntent : KMZ
+TrackRecordedActivity --> TrackDeleteActivity
+TrackRecordedActivity --> TrackEditActivity
+TrackRecordedActivity --> MarkerListActivity
+TrackRecordedActivity --> MarkerEditActivity : Add marker
+TrackRecordedActivity --> CameraIntent : Add marker (with photo)
+TrackRecordedActivity --> ShareFileIntent
+TrackRecordedActivity --> DashboardIntent : Database cursor
+TrackRecordedActivity --> TrackOnMapIntent : KMZ
+TrackRecordedActivity --> TrackRecordingActivity
+TrackRecordedActivity --> SettingsActivity
+TrackRecordedActivity --> TrackListActivity : Back button
+
+TrackRecordingActivity --> TrackOnMapIntent
+TrackRecordingActivity --> MarkerEditActivity : Add marker
+TrackRecordingActivity --> MarkerListActivity
+TrackRecordingActivity --> TrackEditActivity
+TrackRecordingActivity --> SettingsActivity
+TrackRecordingActivity --> TrackRecordedActivity : Stop recording
+TrackRecordingActivity --> TrackListActivity : Back button
 
 MarkerListActivity --> MarkerDetailActivity
 
@@ -37,4 +48,4 @@ SettingsActivity --> HelpActivity
 SettingsActivity --> ExportActivity
 SettingsActivity --> ImportActivity
 
-@enduml
+@enduml

fastlane/metadata/android/de-DE/full_description.txt

@@ -4,6 +4,7 @@ Erfasst deine Kilometer, ohne dass es jemand anderes tut.
 Funktionen & Features:
 * zeichnet Sport und andere Outdooraktivitäten auf
 * unterstützt das Markieren interessanter Orte, inkl. Foto-Funktion
-* zeichnet deine Herzfrequenz auf (unterstützt Bluetooth-LE-Sensoren)
+* zeichnet deine Herzfrequenz auf (Bluetooth LE)
+* nutze beim Radfahren deine Trittfrequenz- und Geschwindigkeitssensoren (Bluetooth LE)
 * exportiert deine Daten als KML oder GPX
 * funktioniert ganz ohne Internet

fastlane/metadata/android/en-US/changelogs/3335.txt

@@ -0,0 +1,4 @@
+v3.6.2: OpenTracks
+
+Bugfix:
+- Charts were not shown correctly (introduced in v3.6.0)

fastlane/metadata/android/en-US/changelogs/3369.txt

@@ -0,0 +1,13 @@
+v3.7.0: OpenTracks
+
+Changes:
+- Report speed/pace by activity type
+- Added workaround for GPS week rollover
+- (Experimental) Support for Bluetooth LE cycling sensors (cadence and speed)
+- KMZ/KML import enhanced
+
+Bugfix:
+- KMZ import: only import used images
+
+Developer:
+- Refactored TrackRecordingService

fastlane/metadata/android/en-US/changelogs/3372.txt

@@ -0,0 +1,7 @@
+v3.7.1: OpenTracks
+
+Workaround:
+- Hide start GPS button
+
+Bugfix:
+- Fixed null pointer

fastlane/metadata/android/en-US/changelogs/3381.txt

@@ -0,0 +1,6 @@
+v3.7.2: OpenTracks
+
+Bugfix:
+- Re-added start GPS button
+- Track name is not overwritten at the end of a recording
+- Markers: removing a photo also deletes the file

fastlane/metadata/android/en-US/changelogs/3386.txt

@@ -0,0 +1,7 @@
+v3.7.3: OpenTracks
+
+Bugfix:
+- Fixed computation of cadence and speed (via Bluetooth LE sensor)
+
+Developer:
+- Removed unused translations

fastlane/metadata/android/en-US/changelogs/3396.txt

@@ -0,0 +1,12 @@
+v3.7.4: OpenTracks
+
+Changes:
+- Sharing/export format configurable
+
+Bugfix:
+- Wheel diameter not stored correctly (for speed sensor)
+- Help: links are clickable
+
+Developer:
+- Split TrackDetailActivity
+- StatsFragement successor uses ConstraintLayout

fastlane/metadata/android/en-US/full_description.txt

@@ -3,6 +3,8 @@ OpenTracks is a sport tracking application that completely respects your privacy
 Features:
 * Sport tracking: track your sport and outdoor activities
 * Photos and markers: mark interesting locations while tracking
-* Heart rate: supports Bluetooth LE sensors
+* Supports Bluetooth LE sensors:
+  * heart rate
+  * cycling: speed and cadence
 * Export data: export tracks either as KML or GPX
 * No Internet access: Internet is not used

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,5 @@
-#Sun Apr 12 18:41:12 CEST 2020
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.3-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-5.6.4-all.zip

gradlew

@@ -82,6 +82,7 @@ esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
+
 # Determine the Java command to use to start the JVM.
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
@@ -129,6 +130,7 @@ fi
 if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    
     JAVACMD=`cygpath --unix "$JAVACMD"`
 
     # We build the pattern for arguments to be converted via cygpath
@@ -154,19 +156,19 @@ if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
         else
             eval `echo args$i`="\"$arg\""
         fi
-        i=$((i+1))
+        i=`expr $i + 1`
     done
     case $i in
-        (0) set -- ;;
-        (1) set -- "$args0" ;;
-        (2) set -- "$args0" "$args1" ;;
-        (3) set -- "$args0" "$args1" "$args2" ;;
-        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+        0) set -- ;;
+        1) set -- "$args0" ;;
+        2) set -- "$args0" "$args1" ;;
+        3) set -- "$args0" "$args1" "$args2" ;;
+        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
     esac
 fi
 
@@ -175,14 +177,9 @@ save () {
     for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
     echo " "
 }
-APP_ARGS=$(save "$@")
+APP_ARGS=`save "$@"`
 
 # Collect all arguments for the java command, following the shell quoting and substitution rules
 eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
 
-# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
-if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
-  cd "$(dirname "$0")"
-fi
-
 exec "$JAVACMD" "$@"

gradlew.bat

@@ -1,100 +1,104 @@
-@rem
-@rem Copyright 2015 the original author or authors.
-@rem
-@rem Licensed under the Apache License, Version 2.0 (the "License");
-@rem you may not use this file except in compliance with the License.
-@rem You may obtain a copy of the License at
-@rem
-@rem      https://www.apache.org/licenses/LICENSE-2.0
-@rem
-@rem Unless required by applicable law or agreed to in writing, software
-@rem distributed under the License is distributed on an "AS IS" BASIS,
-@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-@rem See the License for the specific language governing permissions and
-@rem limitations under the License.
-@rem
-
-@if "%DEBUG%" == "" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
-set APP_BASE_NAME=%~n0
-set APP_HOME=%DIRNAME%
-
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
-
-@rem Find java.exe
-if defined JAVA_HOME goto findJavaFromJavaHome
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
-
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto init
-
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:init
-@rem Get command-line arguments, handling Windows variants
-
-if not "%OS%" == "Windows_NT" goto win9xME_args
-
-:win9xME_args
-@rem Slurp the command line arguments.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-if "x%~1" == "x" goto execute
-
-set CMD_LINE_ARGS=%*
-
-:execute
-@rem Setup the command line
-
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
-
-@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
-
-:end
-@rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windows variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

src/androidTest/java/de/dennisguse/opentracks/TrackStubUtils.java

@@ -18,9 +18,7 @@ package de.dennisguse.opentracks;
 
 import android.location.Location;
 
-import de.dennisguse.opentracks.content.data.Track;
 import de.dennisguse.opentracks.content.data.TrackPoint;
-import de.dennisguse.opentracks.content.sensor.SensorDataSet;
 
 /**
  * Commons utilities for creating stubs of track, location.
@@ -37,23 +35,6 @@ public class TrackStubUtils {
     private static final float INITIAL_ACCURACY = 5;
     private static final float INITIAL_SPEED = 10;
     private static final float INITIAL_BEARING = 3.0f;
-    // Used to change the value of latitude, longitude, and altitude.
-    private static final double DIFFERENCE = 0.01;
-
-    /**
-     * Gets a a {@link Track} stub with specified number of locations.
-     *
-     * @param numberOfLocations the number of locations for the track
-     * @return a track stub.
-     */
-    public static Track createTrack(int numberOfLocations) {
-        Track track = new Track();
-        for (int i = 0; i < numberOfLocations; i++) {
-            track.addTrackPoint(createDefaultTrackPoint(INITIAL_LATITUDE + i * DIFFERENCE, INITIAL_LONGITUDE + i * DIFFERENCE, INITIAL_ALTITUDE + i * DIFFERENCE));
-        }
-
-        return track;
-    }
 
     /**
      * Create a MyTracks location with default values.
@@ -79,6 +60,6 @@ public class TrackStubUtils {
         location.setTime(INITIAL_TIME);
         location.setBearing(INITIAL_BEARING);
 
-        return new TrackPoint(location, new SensorDataSet(Float.NaN, Float.NaN));
+        return new TrackPoint(location);
     }
 }

src/androidTest/java/de/dennisguse/opentracks/content/DescriptionGeneratorTest.java

@@ -88,6 +88,40 @@ public class DescriptionGeneratorTest {
         Assert.assertEquals(expected, descriptionGenerator.generateTrackDescription(track, true));
     }
 
+    @Test
+    public void testGenerateTrackDescriptionWithoutMaxMinElevation() {
+        Track track = new Track();
+        TrackStatistics stats = new TrackStatistics();
+        stats.setTotalDistance(20000);
+        stats.setTotalTime(600000);
+        stats.setMovingTime(300000);
+        stats.setMaxSpeed(100);
+        stats.setMaxElevation(Double.POSITIVE_INFINITY);
+        stats.setMinElevation(Double.NEGATIVE_INFINITY);
+        stats.setTotalElevationGain(6000);
+        stats.setStartTime_ms(START_TIME);
+        track.setTrackStatistics(stats);
+        track.setCategory("hiking");
+        String expected = //"Created by"
+                "<a href='https://github.com/OpenTracksApp/OpenTracks'>OpenTracks</a><p>"
+                        + "Name: -<br>"
+                        + "Activity type: hiking<br>"
+                        + "Description: -<br>"
+                        + "Total distance: 20.00 km (12.4 mi)<br>"
+                        + "Total time: 10:00<br>"
+                        + "Moving time: 05:00<br>"
+                        + "Average speed: 120.00 km/h (74.6 mi/h)<br>"
+                        + "Average moving speed: 240.00 km/h (149.1 mi/h)<br>"
+                        + "Max speed: 360.00 km/h (223.7 mi/h)<br>"
+                        + "Average pace: 0:30 min/km (0:48 min/mi)<br>"
+                        + "Average moving pace: 0:15 min/km (0:24 min/mi)<br>"
+                        + "Fastest pace: 0:10 min/km (0:16 min/mi)<br>"
+                        + "Elevation gain: 6000 m (19685 ft)<br>"
+                        + "Recorded: " + StringUtils.formatDateTime(context, START_TIME) + "<br>";
+
+        Assert.assertEquals(expected, descriptionGenerator.generateTrackDescription(track, true));
+    }
+
 
     /**
      * Tests {@link DescriptionGenerator#writeDistance(double, StringBuilder, int, String)}.

src/androidTest/java/de/dennisguse/opentracks/content/SearchEngineTest.java

@@ -70,7 +70,7 @@ public class SearchEngineTest {
         providerUtils.deleteAllTracks(context);
     }
 
-    private long insertTrack(String title, String description, String category, double distance, long hoursAgo) {
+    private long insertTrack(String title, String description, String category, long hoursAgo) {
         Track track = new Track();
         track.setName(title);
         track.setDescription(description);
@@ -88,15 +88,11 @@ public class SearchEngineTest {
     }
 
     private long insertTrack(String title, String description, String category) {
-        return insertTrack(title, description, category, 0, -1);
-    }
-
-    private long insertTrack(String title, double distance) {
-        return insertTrack(title, "", "", distance, -1);
+        return insertTrack(title, description, category, -1);
     }
 
     private long insertTrack(String title, long hoursAgo) {
-        return insertTrack(title, "", "", 0.0, hoursAgo);
+        return insertTrack(title, "", "", hoursAgo);
     }
 
     private long insertWaypoint(String title, String description, String category, double distance, long hoursAgo, long trackId) {

src/androidTest/java/de/dennisguse/opentracks/content/data/TestDataUtil.java

@@ -1,6 +1,15 @@
 package de.dennisguse.opentracks.content.data;
 
+import android.content.Context;
 import android.location.Location;
+import android.net.Uri;
+import android.util.Pair;
+
+import java.io.File;
+import java.io.IOException;
+
+import de.dennisguse.opentracks.content.provider.ContentProviderUtils;
+import de.dennisguse.opentracks.util.FileUtils;
 
 public class TestDataUtil {
 
@@ -8,21 +17,40 @@ public class TestDataUtil {
     public static final double INITIAL_LONGITUDE = -57.0;
     public static final double ALTITUDE_INTERVAL = 2.5;
 
+    /**
+     * Create a track without any trackPoints.
+     */
+    public static Track createTrack(long trackId) {
+        Track track = new Track();
+        track.setId(trackId);
+        track.setName("Test: " + trackId);
+
+        return track;
+    }
+
     /**
      * Simulates a track which is used for testing.
      *
-     * @param id        the id of the track
-     * @param numPoints the location number in the track
-     * @return the simulated track
+     * @param trackId   the trackId of the track
+     * @param numPoints the trackPoints number in the track
      */
-    public static Track getTrack(long id, int numPoints) {
-        Track track = new Track();
-        track.setId(id);
-        track.setName("Test: " + id);
+    public static Pair<Track, TrackPoint[]> createTrack(long trackId, int numPoints) {
+        Track track = createTrack(trackId);
+
+        TrackPoint[] trackPoints = new TrackPoint[numPoints];
         for (int i = 0; i < numPoints; i++) {
-            track.addTrackPoint(createTrackPoint(i));
+            trackPoints[i] = (createTrackPoint(i));
         }
-        return track;
+
+        return new Pair<>(track, trackPoints);
+    }
+
+    public static Track createTrackAndInsert(ContentProviderUtils contentProviderUtils, long trackId, int numPoints) {
+        Pair<Track, TrackPoint[]> pair = createTrack(trackId, numPoints);
+
+        insertTrackWithLocations(contentProviderUtils, pair.first, pair.second);
+
+        return pair.first;
     }
 
     /**
@@ -40,4 +68,33 @@ public class TestDataUtil {
         location.setTime(i + 1);
         return new TrackPoint(location);
     }
+
+    /**
+     * Inserts a track with locations into the database.
+     *
+     * @param track       track to be inserted
+     * @param trackPoints trackPoints to be inserted
+     */
+    public static void insertTrackWithLocations(ContentProviderUtils contentProviderUtils, Track track, TrackPoint[] trackPoints) {
+        contentProviderUtils.insertTrack(track);
+        contentProviderUtils.bulkInsertTrackPoint(trackPoints, track.getId());
+    }
+
+    /**
+     * Creates a Waypoint with a photo.
+     *
+     * @param context  The context.
+     * @param trackId  The track id.
+     * @param location The location.
+     * @return the Waypoint created.
+     */
+    public static  Waypoint createWaypointWithPhoto(Context context, long trackId, Location location) throws IOException {
+        String photoUrl = "";
+        File dstFile = new File(FileUtils.getImageUrl(context, trackId));
+        dstFile.createNewFile();
+        Uri photoUri = FileUtils.getUriForFile(context, dstFile);
+        photoUrl = photoUri.toString();
+
+        return new Waypoint("Waypoint name", "Waypoint description", "Waypoint category", "", trackId, 0.0, 0, location, photoUrl);
+    }
 }

src/androidTest/java/de/dennisguse/opentracks/content/provider/CustomContentProviderUtilsTest.java

@@ -21,6 +21,7 @@ import android.content.ContentValues;
 import android.content.Context;
 import android.database.Cursor;
 import android.location.Location;
+import android.util.Pair;
 
 import androidx.test.core.app.ApplicationProvider;
 
@@ -31,7 +32,10 @@ import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnitRunner;
 
+import java.io.File;
+import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 
 import de.dennisguse.opentracks.content.data.TestDataUtil;
@@ -42,6 +46,7 @@ import de.dennisguse.opentracks.content.data.TracksColumns;
 import de.dennisguse.opentracks.content.data.Waypoint;
 import de.dennisguse.opentracks.content.data.WaypointsColumns;
 import de.dennisguse.opentracks.stats.TrackStatistics;
+import de.dennisguse.opentracks.util.FileUtils;
 
 import static org.mockito.Mockito.when;
 
@@ -57,6 +62,7 @@ public class CustomContentProviderUtilsTest {
     private static final String MOCK_DESC = "Mock Next Waypoint Desc!";
     private static final String TEST_DESC = "Test Desc!";
     private static final String TEST_DESC_NEW = "Test Desc new!";
+    private static final String TEST_NAME_NEW = "Test Name new!";
 
     private final Context context = ApplicationProvider.getApplicationContext();
     private ContentProviderUtils contentProviderUtils;
@@ -141,7 +147,7 @@ public class CustomContentProviderUtilsTest {
             loc.setAltitude(i * 2.5);
             trackPoints[i] = new TrackPoint(loc);
         }
-        contentProviderUtils.bulkInsertTrackPoint(trackPoints, numPoints, id);
+        contentProviderUtils.bulkInsertTrackPoint(trackPoints, id);
 
         // Load all inserted trackPoints.
         long lastPointId = -1;
@@ -194,10 +200,11 @@ public class CustomContentProviderUtilsTest {
     public void testDeleteAllTracks() {
         // Insert track, points and waypoint at first.
         long trackId = System.currentTimeMillis();
-        Track track = TestDataUtil.getTrack(trackId, 10);
-        insertTrackWithLocations(track);
-        Waypoint waypoint = new Waypoint();
+        Track track = TestDataUtil.createTrackAndInsert(contentProviderUtils, trackId, 10);
+
+        Waypoint waypoint = new Waypoint(contentProviderUtils.getLastValidTrackPoint(trackId));
         contentProviderUtils.insertWaypoint(waypoint);
+
         ContentResolver contentResolver = context.getContentResolver();
         Cursor tracksCursor = contentResolver.query(TracksColumns.CONTENT_URI, null, null, null, TracksColumns._ID);
         Assert.assertEquals(1, tracksCursor.getCount());
@@ -216,20 +223,58 @@ public class CustomContentProviderUtilsTest {
         Assert.assertEquals(0, waypointCursor.getCount());
     }
 
+    /**
+     * Tests the method {@link ContentProviderUtils#deleteAllTracks(Context)}
+     */
+    @Test
+    public void testDeleteAllTracks_withWaypointAndPhoto() throws IOException {
+        // Insert track, points and waypoint with photo at first.
+        long trackId = System.currentTimeMillis();
+        Track track = TestDataUtil.createTrackAndInsert(contentProviderUtils, trackId, 10);
+
+        TrackPoint trackPoint = contentProviderUtils.getLastValidTrackPoint(trackId);
+        Waypoint waypoint = TestDataUtil.createWaypointWithPhoto(context, trackId, trackPoint.getLocation());
+        contentProviderUtils.insertWaypoint(waypoint);
+
+        ContentResolver contentResolver = context.getContentResolver();
+        Cursor tracksCursor = contentResolver.query(TracksColumns.CONTENT_URI, null, null, null, TracksColumns._ID);
+        Assert.assertEquals(1, tracksCursor.getCount());
+        Cursor tracksPointsCursor = contentResolver.query(TrackPointsColumns.CONTENT_URI_BY_ID, null, null, null, TrackPointsColumns._ID);
+        Assert.assertEquals(10, tracksPointsCursor.getCount());
+        Cursor waypointCursor = contentResolver.query(WaypointsColumns.CONTENT_URI, null, null, null, WaypointsColumns._ID);
+        Assert.assertEquals(1, waypointCursor.getCount());
+        // Check waypoint has photo and it's in the external storage.
+        Assert.assertTrue(waypoint.hasPhoto());
+        File dir = FileUtils.getPhotoDir(context, trackId);
+        Assert.assertTrue(dir.isDirectory());
+        Assert.assertEquals(1, dir.list().length);
+        Assert.assertTrue(dir.exists());
+        // Delete all.
+        contentProviderUtils.deleteAllTracks(context);
+        // Check whether all have been deleted.
+        tracksCursor = contentResolver.query(TracksColumns.CONTENT_URI, null, null, null, TracksColumns._ID);
+        Assert.assertEquals(0, tracksCursor.getCount());
+        tracksPointsCursor = contentResolver.query(TrackPointsColumns.CONTENT_URI_BY_ID, null, null, null, TrackPointsColumns._ID);
+        Assert.assertEquals(0, tracksPointsCursor.getCount());
+        waypointCursor = contentResolver.query(WaypointsColumns.CONTENT_URI, null, null, null, WaypointsColumns._ID);
+        Assert.assertEquals(0, waypointCursor.getCount());
+        Assert.assertFalse(dir.exists());
+    }
+
     /**
      * Tests the method {@link ContentProviderUtils#deleteTrack(Context, long)}.
      */
     @Test
     public void testDeleteTrack() {
         // Insert three tracks, points of two tracks and way point of one track.
+
         long trackId = System.currentTimeMillis();
-        Track track = TestDataUtil.getTrack(trackId, 10);
+        TestDataUtil.createTrackAndInsert(contentProviderUtils, trackId, 0);
 
-        contentProviderUtils.insertTrack(track);
-        insertTrackWithLocations(TestDataUtil.getTrack(trackId + 1, 10));
-        insertTrackWithLocations(TestDataUtil.getTrack(trackId + 2, 10));
+        TestDataUtil.createTrackAndInsert(contentProviderUtils, trackId + 1, 10);
+        TestDataUtil.createTrackAndInsert(contentProviderUtils, trackId + 2, 10);
 
-        Waypoint waypoint = new Waypoint();
+        Waypoint waypoint = new Waypoint(contentProviderUtils.getLastValidTrackPoint(trackId + 1));
         waypoint.setTrackId(trackId);
         contentProviderUtils.insertWaypoint(waypoint);
 
@@ -251,15 +296,70 @@ public class CustomContentProviderUtilsTest {
         Assert.assertEquals(0, waypointCursor.getCount());
     }
 
+    /**
+     * Tests the method {@link ContentProviderUtils#deleteTrack(Context, long)}.
+     */
+    @Test
+    public void testDeleteTrack_withWaypointPhoto() throws IOException {
+        // Insert three tracks.
+        long trackId = System.currentTimeMillis();
+        TestDataUtil.createTrackAndInsert(contentProviderUtils, trackId, 10);
+        TestDataUtil.createTrackAndInsert(contentProviderUtils, trackId + 1, 10);
+        TestDataUtil.createTrackAndInsert(contentProviderUtils, trackId + 2, 10);
+
+        // Insert a waypoint in tracks trackId and trackId + 1.
+        TrackPoint trackPoint1 = contentProviderUtils.getLastValidTrackPoint(trackId);
+        Waypoint waypoint1 = TestDataUtil.createWaypointWithPhoto(context, trackId, trackPoint1.getLocation());
+        contentProviderUtils.insertWaypoint(waypoint1);
+        File dir1 = FileUtils.getPhotoDir(context, trackId);
+
+        TrackPoint trackPoint2 = contentProviderUtils.getLastValidTrackPoint(trackId + 1);
+        Waypoint waypoint2 = TestDataUtil.createWaypointWithPhoto(context, trackId + 1, trackPoint2.getLocation());
+        contentProviderUtils.insertWaypoint(waypoint2);
+        File dir2 = FileUtils.getPhotoDir(context, trackId + 1);
+
+        // Check.
+        ContentResolver contentResolver = context.getContentResolver();
+        Cursor tracksCursor = contentResolver.query(TracksColumns.CONTENT_URI, null, null, null, TracksColumns._ID);
+        Assert.assertEquals(3, tracksCursor.getCount());
+        Cursor tracksPointsCursor = contentResolver.query(TrackPointsColumns.CONTENT_URI_BY_ID, null, null, null, TrackPointsColumns._ID);
+        Assert.assertEquals(30, tracksPointsCursor.getCount());
+        Cursor waypointCursor = contentResolver.query(WaypointsColumns.CONTENT_URI, null, null, null, WaypointsColumns._ID);
+        Assert.assertEquals(2, waypointCursor.getCount());
+        Assert.assertTrue(waypoint1.hasPhoto());
+        Assert.assertTrue(dir1.isDirectory());
+        Assert.assertEquals(1, dir1.list().length);
+        Assert.assertTrue(dir1.exists());
+        Assert.assertTrue(dir2.isDirectory());
+        Assert.assertEquals(1, dir2.list().length);
+        Assert.assertTrue(dir2.exists());
+        // Delete one track.
+        contentProviderUtils.deleteTrack(context, trackId);
+        // Check whether all data of a track has been deleted.
+        tracksCursor = contentResolver.query(TracksColumns.CONTENT_URI, null, null, null, TracksColumns._ID);
+        Assert.assertEquals(2, tracksCursor.getCount());
+        tracksPointsCursor = contentResolver.query(TrackPointsColumns.CONTENT_URI_BY_ID, null, null, null, TrackPointsColumns._ID);
+        Assert.assertEquals(20, tracksPointsCursor.getCount());
+        waypointCursor = contentResolver.query(WaypointsColumns.CONTENT_URI, null, null, null, WaypointsColumns._ID);
+        Assert.assertEquals(1, waypointCursor.getCount());
+        Assert.assertFalse(dir1.exists());
+        Assert.assertTrue(dir2.exists());
+    }
+
     /**
      * Tests the method {@link ContentProviderUtils#getAllTracks()}
      */
     @Test
     public void testGetAllTracks() {
+        // given
         int initialTrackNumber = contentProviderUtils.getAllTracks().size();
         long trackId = System.currentTimeMillis();
-        contentProviderUtils.insertTrack(TestDataUtil.getTrack(trackId, 0));
+        contentProviderUtils.insertTrack(TestDataUtil.createTrack(trackId));
+
+        // when
         List<Track> allTracks = contentProviderUtils.getAllTracks();
+
+        // then
         Assert.assertEquals(initialTrackNumber + 1, allTracks.size());
         Assert.assertEquals(trackId, allTracks.get(allTracks.size() - 1).getId());
     }
@@ -270,7 +370,7 @@ public class CustomContentProviderUtilsTest {
     @Test
     public void testGetLastTrack() {
         long trackId = System.currentTimeMillis();
-        contentProviderUtils.insertTrack(TestDataUtil.getTrack(trackId, 0));
+        contentProviderUtils.insertTrack(TestDataUtil.createTrack(trackId));
         Assert.assertEquals(trackId, contentProviderUtils.getLastTrack().getId());
     }
 
@@ -280,7 +380,7 @@ public class CustomContentProviderUtilsTest {
     @Test
     public void testGetTrack() {
         long trackId = System.currentTimeMillis();
-        contentProviderUtils.insertTrack(TestDataUtil.getTrack(trackId, 0));
+        contentProviderUtils.insertTrack(TestDataUtil.createTrack(trackId));
         Assert.assertNotNull(contentProviderUtils.getTrack(trackId));
     }
 
@@ -289,11 +389,14 @@ public class CustomContentProviderUtilsTest {
      */
     @Test
     public void testUpdateTrack() {
+        // given
         long trackId = System.currentTimeMillis();
-        Track track = TestDataUtil.getTrack(trackId, 0);
+        Track track = TestDataUtil.createTrack(trackId);
         String nameOld = "name1";
         String nameNew = "name2";
         track.setName(nameOld);
+
+        // when / then
         contentProviderUtils.insertTrack(track);
         Assert.assertEquals(nameOld, contentProviderUtils.getTrack(trackId).getName());
         track.setName(nameNew);
@@ -307,7 +410,8 @@ public class CustomContentProviderUtilsTest {
     @Test
     public void testCreateContentValues_waypoint() {
         long trackId = System.currentTimeMillis();
-        Track track = TestDataUtil.getTrack(trackId, 10);
+        Pair<Track, TrackPoint[]> track = TestDataUtil.createTrack(trackId, 10);
+
         // Bottom
         long startTime = 1000L;
         // AverageSpeed
@@ -322,17 +426,10 @@ public class CustomContentProviderUtilsTest {
         statistics.setMaxElevation(1250.0);
         statistics.setMinElevation(1200.0);
 
-        track.setTrackStatistics(statistics);
-        contentProviderUtils.insertTrack(track);
+        track.first.setTrackStatistics(statistics);
+        contentProviderUtils.insertTrack(track.first);
 
-        // Insert at first.
-        Location location = new Location("test");
-        location.setLatitude(22);
-        location.setLongitude(22);
-        location.setAccuracy((float) 1 / 100.0f);
-        location.setAltitude(2.5);
-
-        Waypoint waypoint = new Waypoint(location);
+        Waypoint waypoint = new Waypoint(track.second[0]);
         waypoint.setDescription(TEST_DESC);
         contentProviderUtils.insertWaypoint(waypoint);
 
@@ -342,7 +439,7 @@ public class CustomContentProviderUtilsTest {
         waypoint.setId(waypointId);
         ContentValues contentValues = contentProviderUtils.createContentValues(waypoint);
         Assert.assertEquals(waypointId, contentValues.get(WaypointsColumns._ID));
-        Assert.assertEquals(22 * 1000000, contentValues.get(WaypointsColumns.LONGITUDE));
+        Assert.assertEquals((int) (TestDataUtil.INITIAL_LONGITUDE * 1000000), contentValues.get(WaypointsColumns.LONGITUDE));
         Assert.assertEquals(TEST_DESC, contentValues.get(WaypointsColumns.DESCRIPTION));
     }
 
@@ -382,66 +479,106 @@ public class CustomContentProviderUtilsTest {
 
     /**
      * Tests the method
-     * {@link ContentProviderUtils#deleteWaypoint(long)}
+     * {@link ContentProviderUtils#deleteWaypoint(Context, long)}
      * when there is only one waypoint in the track.
      */
     @Test
     public void testDeleteWaypoint_onlyOneWayPoint() {
         long trackId = System.currentTimeMillis();
-        Track track = TestDataUtil.getTrack(trackId, 10);
-        contentProviderUtils.insertTrack(track);
+        TestDataUtil.createTrackAndInsert(contentProviderUtils, trackId, 10);
 
         // Insert at first.
-        Waypoint waypoint1 = new Waypoint();
+        Waypoint waypoint1 = new Waypoint(contentProviderUtils.getLastValidTrackPoint(trackId));
         waypoint1.setDescription(TEST_DESC);
         waypoint1.setTrackId(trackId);
         contentProviderUtils.insertWaypoint(waypoint1);
 
-        // Delete
-        contentProviderUtils.deleteWaypoint(1);
+        // Check insert was done.
+        Assert.assertEquals(contentProviderUtils.getWaypointCount(trackId), 1);
 
-        Assert.assertNull(contentProviderUtils.getWaypoint(1));
+        // Get waypoint id that needs to delete.
+        long waypoint1Id = ContentUris.parseId(contentProviderUtils.insertWaypoint(waypoint1));
+
+        // Delete
+        contentProviderUtils.deleteWaypoint(context, waypoint1Id);
+
+        Assert.assertNull(contentProviderUtils.getWaypoint(waypoint1Id));
     }
 
     /**
      * Tests the method
-     * {@link ContentProviderUtils#deleteWaypoint(long)}
-     * when there is more than one waypoint in the track.
+     * {@link ContentProviderUtils#deleteWaypoint(Context, long)}
+     * when there is only one waypoint in the track.
+     */
+    @Test
+    public void testDeleteWaypoint_onlyOneWayPointWithPhotoUrl() throws IOException {
+        long trackId = System.currentTimeMillis();
+        TestDataUtil.createTrackAndInsert(contentProviderUtils, trackId, 10);
+
+        // Insert at first.
+        TrackPoint trackPoint = contentProviderUtils.getLastValidTrackPoint(trackId);
+        Waypoint waypoint1 = TestDataUtil.createWaypointWithPhoto(context, trackId, trackPoint.getLocation());
+        contentProviderUtils.insertWaypoint(waypoint1);
+
+        // Check insert was done.
+        Assert.assertEquals(contentProviderUtils.getWaypointCount(trackId), 1);
+
+        // Get waypoint id that needs to delete.
+        long waypoint1Id = ContentUris.parseId(contentProviderUtils.insertWaypoint(waypoint1));
+
+        // Check waypoint has photo and it's in the external storage.
+        Assert.assertTrue(waypoint1.hasPhoto());
+        File dir = FileUtils.getPhotoDir(context, trackId);
+        Assert.assertTrue(dir.isDirectory());
+        Assert.assertEquals(1, dir.list().length);
+        Assert.assertTrue(dir.exists());
+
+        // Delete
+        contentProviderUtils.deleteWaypoint(context, waypoint1Id);
+
+        // Check waypoint doesn't exists and photo folder was deleted.
+        Assert.assertNull(contentProviderUtils.getWaypoint(waypoint1Id));
+        Assert.assertFalse(dir.exists());
+    }
+
+    /**
+     * Tests the method {@link ContentProviderUtils#deleteWaypoint(Context, long)} when there is more than one waypoint in the track.
      */
     @Test
     public void testDeleteWaypoint_hasNextWayPoint() {
         long trackId = System.currentTimeMillis();
-        Track track = TestDataUtil.getTrack(trackId, 10);
-
-        TrackStatistics statistics = new TrackStatistics();
-        statistics.setStartTime_ms(1000L);
-        statistics.setStopTime_ms(2500L);
-        statistics.setTotalTime(1500L);
-        statistics.setMovingTime(700L);
-        statistics.setTotalDistance(750.0);
-        statistics.setTotalElevationGain(50.0);
-        statistics.setMaxSpeed(60.0);
-        statistics.setMaxElevation(1250.0);
-        statistics.setMinElevation(1200.0);
-
-        track.setTrackStatistics(statistics);
-        contentProviderUtils.insertTrack(track);
+        TestDataUtil.createTrackAndInsert(contentProviderUtils, trackId, 10);
 
+//        Track track = TestDataUtil.createTrackAndInsert(trackId, 10);
+//
+//        TrackStatistics statistics = new TrackStatistics();
+//        statistics.setStartTime_ms(1000L);
+//        statistics.setStopTime_ms(2500L);
+//        statistics.setTotalTime(1500L);
+//        statistics.setMovingTime(700L);
+//        statistics.setTotalDistance(750.0);
+//        statistics.setTotalElevationGain(50.0);
+//        statistics.setMaxSpeed(60.0);
+//        statistics.setMaxElevation(1250.0);
+//        statistics.setMinElevation(1200.0);
+//
+//        track.setTrackStatistics(statistics);
+//        TestDataUtil.insertTrackWithLocations(contentProviderUtils, track);
 
         // Insert at first.
-        Waypoint waypoint1 = new Waypoint();
+        Waypoint waypoint1 = new Waypoint(contentProviderUtils.getLastValidTrackPoint(trackId));
         waypoint1.setDescription(MOCK_DESC);
         waypoint1.setTrackId(trackId);
         long waypoint1Id = ContentUris.parseId(contentProviderUtils.insertWaypoint(waypoint1));
 
-        Waypoint waypoint2 = new Waypoint();
+        Waypoint waypoint2 = new Waypoint(contentProviderUtils.getLastValidTrackPoint(trackId));
         waypoint2.setDescription(MOCK_DESC);
         waypoint2.setTrackId(trackId);
         long waypoint2Id = ContentUris.parseId(contentProviderUtils.insertWaypoint(waypoint2));
 
         // Delete
         Assert.assertNotNull(contentProviderUtils.getWaypoint(waypoint1Id));
-        contentProviderUtils.deleteWaypoint(waypoint1Id);
+        contentProviderUtils.deleteWaypoint(context, waypoint1Id);
         Assert.assertNull(contentProviderUtils.getWaypoint(waypoint1Id));
 
         Assert.assertEquals(MOCK_DESC, contentProviderUtils.getWaypoint(waypoint2Id).getDescription());
@@ -453,16 +590,15 @@ public class CustomContentProviderUtilsTest {
     @Test
     public void testGetNextWaypointNumber() {
         long trackId = System.currentTimeMillis();
-        Track track = TestDataUtil.getTrack(trackId, 10);
-        contentProviderUtils.insertTrack(track);
+        TestDataUtil.createTrackAndInsert(contentProviderUtils, trackId, 10);
 
-        Waypoint waypoint1 = new Waypoint();
+        Waypoint waypoint1 = new Waypoint(contentProviderUtils.getLastValidTrackPoint(trackId));
         waypoint1.setTrackId(trackId);
-        Waypoint waypoint2 = new Waypoint();
+        Waypoint waypoint2 = new Waypoint(contentProviderUtils.getLastValidTrackPoint(trackId));
         waypoint2.setTrackId(trackId);
-        Waypoint waypoint3 = new Waypoint();
+        Waypoint waypoint3 = new Waypoint(contentProviderUtils.getLastValidTrackPoint(trackId));
         waypoint3.setTrackId(trackId);
-        Waypoint waypoint4 = new Waypoint();
+        Waypoint waypoint4 = new Waypoint(contentProviderUtils.getLastValidTrackPoint(trackId));
         waypoint4.setTrackId(trackId);
         contentProviderUtils.insertWaypoint(waypoint1);
         contentProviderUtils.insertWaypoint(waypoint2);
@@ -479,10 +615,9 @@ public class CustomContentProviderUtilsTest {
     @Test
     public void testInsertAndGetWaypoint() {
         long trackId = System.currentTimeMillis();
-        Track track = TestDataUtil.getTrack(trackId, 10);
-        contentProviderUtils.insertTrack(track);
+        TestDataUtil.createTrackAndInsert(contentProviderUtils, trackId, 10);
 
-        Waypoint waypoint = new Waypoint();
+        Waypoint waypoint = new Waypoint(contentProviderUtils.getLastValidTrackPoint(trackId));
         waypoint.setDescription(TEST_DESC);
         waypoint.setTrackId(trackId);
         long waypointId = ContentUris.parseId(contentProviderUtils.insertWaypoint(waypoint));
@@ -491,15 +626,15 @@ public class CustomContentProviderUtilsTest {
     }
 
     /**
-     * Tests the method {@link ContentProviderUtils#updateWaypoint(Waypoint)}.
+     * Tests the method {@link ContentProviderUtils#updateWaypoint(Context, Waypoint)}.
      */
     @Test
     public void testUpdateWaypoint() {
         long trackId = System.currentTimeMillis();
-        Track track = TestDataUtil.getTrack(trackId, 10);
-        contentProviderUtils.insertTrack(track);
+        TestDataUtil.createTrackAndInsert(contentProviderUtils, trackId, 10);
+
         // Insert at first.
-        Waypoint waypoint = new Waypoint();
+        Waypoint waypoint = new Waypoint(contentProviderUtils.getLastValidTrackPoint(trackId));
         waypoint.setDescription(TEST_DESC);
         waypoint.setTrackId(trackId);
         long waypointId = ContentUris.parseId(contentProviderUtils.insertWaypoint(waypoint));
@@ -507,84 +642,178 @@ public class CustomContentProviderUtilsTest {
         // Update
         waypoint = contentProviderUtils.getWaypoint(waypointId);
         waypoint.setDescription(TEST_DESC_NEW);
-        contentProviderUtils.updateWaypoint(waypoint);
+        contentProviderUtils.updateWaypoint(context, waypoint);
 
         Assert.assertEquals(TEST_DESC_NEW, contentProviderUtils.getWaypoint(waypointId).getDescription());
     }
 
     /**
-     * Tests the method {@link ContentProviderUtils#bulkInsertTrackPoint(TrackPoint[], int, long)}.
+     * Tests the method {@link ContentProviderUtils#updateWaypoint(Context, Waypoint)}.
+     */
+    @Test
+    public void testUpdateWaypoint_withPhoto() throws IOException {
+        // tests after update waypoint with photo the photo remains in the storage.
+
+        long trackId = System.currentTimeMillis();
+        TestDataUtil.createTrackAndInsert(contentProviderUtils, trackId, 10);
+
+        // Insert at first.
+        TrackPoint trackPoint = contentProviderUtils.getLastValidTrackPoint(trackId);
+        Waypoint waypoint = TestDataUtil.createWaypointWithPhoto(context, trackId, trackPoint.getLocation());
+        waypoint.setDescription(TEST_DESC);
+        waypoint.setTrackId(trackId);
+        long waypointId = ContentUris.parseId(contentProviderUtils.insertWaypoint(waypoint));
+
+        File dir = new File(FileUtils.getPhotoDir(context), "" + trackId);
+        Assert.assertTrue(dir.exists());
+        Assert.assertTrue(dir.isDirectory());
+        Assert.assertEquals(1, dir.list().length);
+
+        // Update
+        waypoint = contentProviderUtils.getWaypoint(waypointId);
+        waypoint.setName(TEST_NAME_NEW);
+        waypoint.setDescription(TEST_DESC_NEW);
+        contentProviderUtils.updateWaypoint(context, waypoint);
+
+        Assert.assertEquals(TEST_NAME_NEW, contentProviderUtils.getWaypoint(waypointId).getName());
+        Assert.assertEquals(TEST_DESC_NEW, contentProviderUtils.getWaypoint(waypointId).getDescription());
+        Assert.assertTrue(waypoint.hasPhoto());
+        Assert.assertTrue(dir.exists());
+        Assert.assertTrue(dir.isDirectory());
+        Assert.assertEquals(1, dir.list().length);
+    }
+
+    /**
+     * Tests the method {@link ContentProviderUtils#updateWaypoint(Context, Waypoint)}.
+     */
+    @Test
+    public void testUpdateWaypoint_delPhotoAndDir() throws IOException {
+        // tests after update waypoint if user deletes the photo then file photo is deleted from the storage. Also empty directory is deleted.
+
+        long trackId = System.currentTimeMillis();
+        TestDataUtil.createTrackAndInsert(contentProviderUtils, trackId, 10);
+
+        // Insert at first.
+        TrackPoint trackPoint = contentProviderUtils.getLastValidTrackPoint(trackId);
+        Waypoint waypoint = TestDataUtil.createWaypointWithPhoto(context, trackId, trackPoint.getLocation());
+        waypoint.setDescription(TEST_DESC);
+        waypoint.setTrackId(trackId);
+        long waypointId = ContentUris.parseId(contentProviderUtils.insertWaypoint(waypoint));
+
+        File dir = new File(FileUtils.getPhotoDir(context), "" + trackId);
+        Assert.assertTrue(dir.exists());
+        Assert.assertTrue(dir.isDirectory());
+        Assert.assertEquals(1, dir.list().length);
+
+        // Update
+        waypoint = contentProviderUtils.getWaypoint(waypointId);
+        waypoint.setName(TEST_NAME_NEW);
+        waypoint.setDescription(TEST_DESC_NEW);
+        waypoint.setPhotoUrl(null);
+        contentProviderUtils.updateWaypoint(context, waypoint);
+
+        Assert.assertEquals(TEST_NAME_NEW, contentProviderUtils.getWaypoint(waypointId).getName());
+        Assert.assertEquals(TEST_DESC_NEW, contentProviderUtils.getWaypoint(waypointId).getDescription());
+        Assert.assertFalse(waypoint.hasPhoto());
+        Assert.assertFalse(dir.exists());
+    }
+
+    /**
+     * Tests the method {@link ContentProviderUtils#updateWaypoint(Context, Waypoint)}.
+     */
+    @Test
+    public void testUpdateWaypoint_delPhotoNotDir() throws IOException {
+        // tests after update waypoint if user deletes the photo then file photo is deleted from the storage. Directory remains if there are more photos from other waypoints.
+
+        long trackId = System.currentTimeMillis();
+        TestDataUtil.createTrackAndInsert(contentProviderUtils, trackId, 10);
+
+        // Insert two waypoints with photos.
+        TrackPoint trackPoint = contentProviderUtils.getLastValidTrackPoint(trackId);
+        Waypoint waypoint = TestDataUtil.createWaypointWithPhoto(context, trackId, trackPoint.getLocation());
+        waypoint.setDescription(TEST_DESC);
+        waypoint.setTrackId(trackId);
+        Waypoint otherWaypoint = TestDataUtil.createWaypointWithPhoto(context, trackId, trackPoint.getLocation());
+        otherWaypoint.setDescription(TEST_DESC);
+        otherWaypoint.setTrackId(trackId);
+        long waypointId = ContentUris.parseId(contentProviderUtils.insertWaypoint(waypoint));
+        long otherWaypointId = ContentUris.parseId(contentProviderUtils.insertWaypoint(otherWaypoint));
+
+        File dir = new File(FileUtils.getPhotoDir(context), "" + trackId);
+        Assert.assertTrue(dir.exists());
+        Assert.assertTrue(dir.isDirectory());
+        Assert.assertEquals(2, dir.list().length);
+
+        // Update one waypoint deleting photo.
+        waypoint = contentProviderUtils.getWaypoint(waypointId);
+        waypoint.setPhotoUrl(null);
+        contentProviderUtils.updateWaypoint(context, waypoint);
+
+        Assert.assertEquals(TEST_DESC, contentProviderUtils.getWaypoint(waypointId).getDescription());
+        Assert.assertFalse(waypoint.hasPhoto());
+        Assert.assertTrue(dir.exists());
+        Assert.assertTrue(dir.isDirectory());
+        Assert.assertEquals(1, dir.list().length);
+    }
+
+    /**
+     * Tests the method {@link ContentProviderUtils#bulkInsertTrackPoint(TrackPoint[], long)}.
      */
     @Test
     public void testBulkInsertTrackPoint() {
-        // Insert track, point at first.
+        // given
         long trackId = System.currentTimeMillis();
-        Track track = TestDataUtil.getTrack(trackId, 10);
-        insertTrackWithLocations(track);
+        Pair<Track, TrackPoint[]> track = TestDataUtil.createTrack(trackId, 10);
+        TestDataUtil.insertTrackWithLocations(contentProviderUtils, track.first, track.second);
 
-        contentProviderUtils.bulkInsertTrackPoint(track.getTrackPoints().toArray(new TrackPoint[0]), -1, trackId);
+        // when / then
+        contentProviderUtils.bulkInsertTrackPoint(track.second, trackId);
         Assert.assertEquals(20, contentProviderUtils.getTrackPointCursor(trackId, -1L, 1000, false).getCount());
-        contentProviderUtils.bulkInsertTrackPoint(track.getTrackPoints().toArray(new TrackPoint[0]), 8, trackId);
+        contentProviderUtils.bulkInsertTrackPoint(Arrays.copyOfRange(track.second, 0, 8), trackId);
         Assert.assertEquals(28, contentProviderUtils.getTrackPointCursor(trackId, -1L, 1000, false).getCount());
     }
 
     /**
      * Tests the method {@link ContentProviderUtils#createTrackPoint(Cursor)}.
      */
+    //TODO incomplete
     @Test
     public void testCreateTrackPoint() {
-        // Set index.
-        int index = 1;
-        // Id
-        when(cursorMock.getColumnIndex(TrackPointsColumns._ID)).thenReturn(index++);
-        // Longitude
-        when(cursorMock.getColumnIndexOrThrow(TrackPointsColumns.LONGITUDE)).thenReturn(index++);
-        // Latitude
-        when(cursorMock.getColumnIndexOrThrow(TrackPointsColumns.LATITUDE)).thenReturn(index++);
-        // Time
-        when(cursorMock.getColumnIndexOrThrow(TrackPointsColumns.TIME))
-                .thenReturn(index++);
-        // Speed
-        when(cursorMock.getColumnIndexOrThrow(TrackPointsColumns.SPEED)).thenReturn(index++);
-        // Sensor
-        when(cursorMock.getColumnIndexOrThrow(TrackPointsColumns.SENSOR_HEARTRATE)).thenReturn(index++);
+        // given
+        when(cursorMock.getColumnIndex(TrackPointsColumns._ID)).thenReturn(1);
 
-        // Set return value of isNull().
-        index = 2;
-        // Longitude
-        when(cursorMock.isNull(index++)).thenReturn(false);
-        // Latitude
-        when(cursorMock.isNull(index++)).thenReturn(false);
-        // Time
-        when(cursorMock.isNull(index++)).thenReturn(false);
-        // Speed
-        when(cursorMock.isNull(index++)).thenReturn(false);
-        // Sensor
-        when(cursorMock.isNull(index++)).thenReturn(false);
-
-        // Set return value of isNull().
-        index = 2;
-        // Longitude
+        when(cursorMock.getColumnIndexOrThrow(TrackPointsColumns.LONGITUDE)).thenReturn(2);
+        when(cursorMock.isNull(2)).thenReturn(false);
         int longitude = 11;
-        when(cursorMock.getInt(index++)).thenReturn(longitude * 1000000);
-        // Latitude.
-        int latitude = 22;
-        when(cursorMock.getInt(index++)).thenReturn(latitude * 1000000);
-        // Time
-        long time = System.currentTimeMillis();
-        when(cursorMock.getLong(index++)).thenReturn(time);
-        // Speed
-        float speed = 2.2f;
-        when(cursorMock.getFloat(index++)).thenReturn(speed);
-        // Sensor
-        byte[] sensor = "Sensor state".getBytes();
-        when(cursorMock.getBlob(index++)).thenReturn(sensor);
+        when(cursorMock.getInt(2)).thenReturn(longitude * 1000000);
 
-        TrackPoint location = contentProviderUtils.createTrackPoint(cursorMock);
-        Assert.assertEquals(longitude, location.getLongitude(), 0.01);
-        Assert.assertEquals(latitude, location.getLatitude(), 0.01);
-        Assert.assertEquals(time, location.getTime(), 0.01);
-        Assert.assertEquals(speed, location.getSpeed(), 0.01);
+        when(cursorMock.getColumnIndexOrThrow(TrackPointsColumns.LATITUDE)).thenReturn(3);
+        when(cursorMock.isNull(3)).thenReturn(false);
+        int latitude = 22;
+        when(cursorMock.getInt(3)).thenReturn(latitude * 1000000);
+
+        when(cursorMock.getColumnIndexOrThrow(TrackPointsColumns.TIME)).thenReturn(4);
+        when(cursorMock.isNull(4)).thenReturn(false);
+        long time = System.currentTimeMillis();
+        when(cursorMock.getLong(4)).thenReturn(time);
+
+        when(cursorMock.getColumnIndexOrThrow(TrackPointsColumns.SPEED)).thenReturn(5);
+        when(cursorMock.isNull(5)).thenReturn(false);
+        float speed = 2.2f;
+        when(cursorMock.getFloat(5)).thenReturn(speed);
+
+        when(cursorMock.getColumnIndexOrThrow(TrackPointsColumns.SENSOR_HEARTRATE)).thenReturn(6);
+        when(cursorMock.isNull(6)).thenReturn(false);
+
+        // when
+        TrackPoint trackPoint = contentProviderUtils.createTrackPoint(cursorMock);
+
+        // then
+        Assert.assertEquals(longitude, trackPoint.getLongitude(), 0.01);
+        Assert.assertEquals(latitude, trackPoint.getLatitude(), 0.01);
+        Assert.assertEquals(time, trackPoint.getTime(), 0.01);
+        Assert.assertEquals(speed, trackPoint.getSpeed(), 0.01);
+        Assert.assertFalse(trackPoint.hasHeartRate());
     }
 
     /**
@@ -595,11 +824,32 @@ public class CustomContentProviderUtilsTest {
     public void testInsertTrackPoint() {
         // Insert track, point at first.
         long trackId = System.currentTimeMillis();
-        Track track = TestDataUtil.getTrack(trackId, 10);
-        insertTrackWithLocations(track);
+        Track track = TestDataUtil.createTrackAndInsert(contentProviderUtils, trackId, 10);
 
         contentProviderUtils.insertTrackPoint(TestDataUtil.createTrackPoint(22), trackId);
-        Assert.assertEquals(11, contentProviderUtils.getTrackPointCursor(trackId, -1L, 1000, false).getCount());
+        Assert.assertEquals(11, contentProviderUtils.getTrackPoints(trackId).size());
+    }
+
+    @Test
+    public void testInsertAndLoadTrackPoint() {
+        // given
+        long trackId = System.currentTimeMillis();
+        Track track = TestDataUtil.createTrackAndInsert(contentProviderUtils, trackId, 10);
+
+        TrackPoint trackPoint = TestDataUtil.createTrackPoint(5);
+        trackPoint.setHeartRate_bpm(1F);
+        trackPoint.setCyclingCadence_rpm(2F);
+        trackPoint.setPower(3F);
+
+        // when
+        contentProviderUtils.insertTrackPoint(trackPoint, trackId);
+
+        // then
+        List<TrackPoint> trackPoints = contentProviderUtils.getTrackPoints(trackId);
+        Assert.assertTrue(trackPoints.get(10).hasHeartRate());
+        Assert.assertEquals(trackPoint.getHeartRate_bpm(), trackPoints.get(10).getHeartRate_bpm(), 0.01);
+        Assert.assertEquals(trackPoint.getCyclingCadence_rpm(), trackPoints.get(10).getCyclingCadence_rpm(), 0.01);
+        Assert.assertEquals(trackPoint.getPower(), trackPoints.get(10).getPower(), 0.01);
     }
 
     /**
@@ -609,8 +859,7 @@ public class CustomContentProviderUtilsTest {
     public void testGetLastValidTrackPoint() {
         // Insert track, points at first.
         long trackId = System.currentTimeMillis();
-        Track track = TestDataUtil.getTrack(trackId, 10);
-        insertTrackWithLocations(track);
+        Track track = TestDataUtil.createTrackAndInsert(contentProviderUtils, trackId, 10);
 
         TrackPoint lastTrackPoint = contentProviderUtils.getLastValidTrackPoint(trackId);
         checkLocation(9, lastTrackPoint.getLocation());
@@ -621,17 +870,20 @@ public class CustomContentProviderUtilsTest {
      */
     @Test
     public void testGetTrackPointCursor_desc() {
-        // Insert track, points at first.
+        // given
         long trackId = System.currentTimeMillis();
-        Track track = TestDataUtil.getTrack(trackId, 10);
-        contentProviderUtils.insertTrack(track);
+        Pair<Track, TrackPoint[]> track = TestDataUtil.createTrack(trackId, 10);
+        contentProviderUtils.insertTrack(track.first);
 
-        long[] trackpointIds = new long[track.getTrackPoints().size()];
+        long[] trackpointIds = new long[track.second.length];
         for (int i = 0; i < trackpointIds.length; i++) {
-            trackpointIds[i] = ContentUris.parseId(contentProviderUtils.insertTrackPoint(track.getTrackPoints().get(i), track.getId()));
+            trackpointIds[i] = ContentUris.parseId(contentProviderUtils.insertTrackPoint(track.second[i], track.first.getId()));
         }
 
+        // when
         Cursor cursor = contentProviderUtils.getTrackPointCursor(trackId, trackpointIds[1], 5, true);
+
+        // then
         Assert.assertEquals(2, cursor.getCount());
     }
 
@@ -640,17 +892,20 @@ public class CustomContentProviderUtilsTest {
      */
     @Test
     public void testGetTrackPointCursor_asc() {
-        // Insert track, points at first.
+        // given
         long trackId = System.currentTimeMillis();
-        Track track = TestDataUtil.getTrack(trackId, 10);
-        contentProviderUtils.insertTrack(track);
+        Pair<Track, TrackPoint[]> track = TestDataUtil.createTrack(trackId, 10);
+        contentProviderUtils.insertTrack(track.first);
 
-        long[] trackpointIds = new long[track.getTrackPoints().size()];
+        long[] trackpointIds = new long[track.second.length];
         for (int i = 0; i < trackpointIds.length; i++) {
-            trackpointIds[i] = ContentUris.parseId(contentProviderUtils.insertTrackPoint(track.getTrackPoints().get(i), track.getId()));
+            trackpointIds[i] = ContentUris.parseId(contentProviderUtils.insertTrackPoint(track.second[i], track.first.getId()));
         }
 
+        // when
         Cursor cursor = contentProviderUtils.getTrackPointCursor(trackId, trackpointIds[8], 5, false);
+
+        // then
         Assert.assertEquals(2, cursor.getCount());
     }
 
@@ -659,19 +914,21 @@ public class CustomContentProviderUtilsTest {
      */
     @Test
     public void testGetTrackPointLocationIterator_desc() {
-        // Insert track, points at first.
+        // given
         long trackId = System.currentTimeMillis();
-        Track track = TestDataUtil.getTrack(trackId, 10);
-        contentProviderUtils.insertTrack(track);
+        Pair<Track, TrackPoint[]> track = TestDataUtil.createTrack(trackId, 10);
+        contentProviderUtils.insertTrack(track.first);
 
-        long[] trackpointIds = new long[track.getTrackPoints().size()];
+        long[] trackpointIds = new long[track.second.length];
         for (int i = 0; i < trackpointIds.length; i++) {
-            trackpointIds[i] = ContentUris.parseId(contentProviderUtils.insertTrackPoint(track.getTrackPoints().get(i), track.getId()));
+            trackpointIds[i] = ContentUris.parseId(contentProviderUtils.insertTrackPoint(track.second[i], track.first.getId()));
         }
 
         long startTrackPointId = trackpointIds[9];
-
+        // when
         TrackPointIterator trackPointIterator = contentProviderUtils.getTrackPointLocationIterator(trackId, startTrackPointId, true);
+
+        // then
         for (int i = 0; i < trackpointIds.length; i++) {
             Assert.assertTrue(trackPointIterator.hasNext());
             TrackPoint trackPoint = trackPointIterator.next();
@@ -686,33 +943,36 @@ public class CustomContentProviderUtilsTest {
      */
     @Test
     public void testGetTrackPointLocationIterator_asc() {
-        // Insert track, point at first.
+        // given
         long trackId = System.currentTimeMillis();
-        Track track = TestDataUtil.getTrack(trackId, 10);
-        contentProviderUtils.insertTrack(track);
+        Pair<Track, TrackPoint[]> track = TestDataUtil.createTrack(trackId, 10);
+        contentProviderUtils.insertTrack(track.first);
 
-        long[] trackpointIds = new long[track.getTrackPoints().size()];
+        long[] trackpointIds = new long[track.second.length];
         for (int i = 0; i < trackpointIds.length; i++) {
-            trackpointIds[i] = ContentUris.parseId(contentProviderUtils.insertTrackPoint(track.getTrackPoints().get(i), track.getId()));
+            trackpointIds[i] = ContentUris.parseId(contentProviderUtils.insertTrackPoint(track.second[i], track.first.getId()));
         }
 
         long startTrackPointId = trackpointIds[0];
 
-        TrackPointIterator locationIterator = contentProviderUtils.getTrackPointLocationIterator(trackId, startTrackPointId, false);
+        // when
+        TrackPointIterator trackPointIterator = contentProviderUtils.getTrackPointLocationIterator(trackId, startTrackPointId, false);
+
+        // then
         for (int i = 0; i < trackpointIds.length; i++) {
-            Assert.assertTrue(locationIterator.hasNext());
-            TrackPoint trackPoint = locationIterator.next();
-            Assert.assertEquals(startTrackPointId + i, locationIterator.getTrackPointId());
+            Assert.assertTrue(trackPointIterator.hasNext());
+            TrackPoint trackPoint = trackPointIterator.next();
+            Assert.assertEquals(startTrackPointId + i, trackPointIterator.getTrackPointId());
 
             checkLocation(i, trackPoint.getLocation());
         }
-        Assert.assertFalse(locationIterator.hasNext());
+        Assert.assertFalse(trackPointIterator.hasNext());
     }
 
     /**
      * Checks the value of a location.
      *
-     * @param i        the index of this location which created in the method {@link TestDataUtil#getTrack(long, int)}
+     * @param i        the index of this location which created in the method {@link TestDataUtil#createTrack(long, int)}
      * @param location the location to be checked
      */
     private void checkLocation(int i, Location location) {
@@ -722,15 +982,6 @@ public class CustomContentProviderUtilsTest {
         Assert.assertEquals(i * TestDataUtil.ALTITUDE_INTERVAL, location.getAltitude(), 0.01);
     }
 
-    /**
-     * Inserts a track with locations into the database.
-     *
-     * @param track track to be inserted
-     */
-    private void insertTrackWithLocations(Track track) {
-        contentProviderUtils.insertTrack(track);
-        contentProviderUtils.bulkInsertTrackPoint(track.getTrackPoints().toArray(new TrackPoint[0]), track.getTrackPoints().size(), track.getId());
-    }
 
     @Test
     public void testFormatIdListForUri() {

src/androidTest/java/de/dennisguse/opentracks/content/sensor/SensorDataCyclingTest.java

@@ -0,0 +1,118 @@
+package de.dennisguse.opentracks.content.sensor;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import de.dennisguse.opentracks.util.UintUtils;
+
+@RunWith(AndroidJUnit4.class)
+public class SensorDataCyclingTest {
+
+    @Test
+    public void compute_cadence_1() {
+        // given
+        SensorDataCycling.Cadence previous = new SensorDataCycling.Cadence("sensorAddress", "sensorName", 1, 1024); // 1s
+        SensorDataCycling.Cadence current = new SensorDataCycling.Cadence("sensorAddress", "sensorName", 2, 2048); // 2s
+
+        // when
+        current.compute(previous);
+
+        // then
+        Assert.assertEquals(60, current.getCadence_rpm(), 0.01);
+    }
+
+    @Test
+    public void compute_cadence_2() {
+        // given
+        SensorDataCycling.Cadence previous = new SensorDataCycling.Cadence("sensorAddress", "sensorName", 1, 6184);
+        SensorDataCycling.Cadence current = new SensorDataCycling.Cadence("sensorAddress", "sensorName", 2, 8016);
+
+        // when
+        current.compute(previous);
+
+        // then
+        Assert.assertEquals(33.53, current.getCadence_rpm(), 0.01);
+    }
+
+    @Test
+    public void compute_cadence_sameCount() {
+        // given
+        SensorDataCycling.Cadence previous = new SensorDataCycling.Cadence("sensorAddress", "sensorName", 1, 1024);
+        SensorDataCycling.Cadence current = new SensorDataCycling.Cadence("sensorAddress", "sensorName", 1, 2048);
+
+        // when
+        current.compute(previous);
+
+        // then
+        Assert.assertEquals(0, current.getCadence_rpm(), 0.01);
+    }
+
+
+    @Test
+    public void compute_cadence_sameTime() {
+        // given
+        SensorDataCycling.Cadence previous = new SensorDataCycling.Cadence("sensorAddress", "sensorName", 1, 1024);
+        SensorDataCycling.Cadence current = new SensorDataCycling.Cadence("sensorAddress", "sensorName", 2, 1024);
+
+        // when
+        current.compute(previous);
+
+        // then
+        Assert.assertFalse(current.hasCadence_rpm());
+    }
+
+    @Test
+    public void compute_cadence_rollOverTime() {
+        // given
+        SensorDataCycling.Cadence previous = new SensorDataCycling.Cadence("sensorAddress", "sensorName", 1, UintUtils.UINT16_MAX - 1024);
+        SensorDataCycling.Cadence current = new SensorDataCycling.Cadence("sensorAddress", "sensorName", 2, 0);
+
+        // when
+        current.compute(previous);
+
+        // then
+        Assert.assertEquals(60, current.getCadence_rpm(), 0.01);
+    }
+
+    @Test
+    public void compute_cadence_rollOverCount() {
+        // given
+        SensorDataCycling.Cadence previous = new SensorDataCycling.Cadence("sensorAddress", "sensorName", UintUtils.UINT32_MAX - 1, 1024);
+        SensorDataCycling.Cadence current = new SensorDataCycling.Cadence("sensorAddress", "sensorName", 0, 2048);
+
+        // when
+        current.compute(previous);
+
+        // then
+        Assert.assertEquals(60, current.getCadence_rpm(), 0.01);
+    }
+
+    @Test
+    public void compute_speed() {
+        // given
+        SensorDataCycling.Speed previous = new SensorDataCycling.Speed("sensorAddress", "sensorName", 1, 6184);
+        SensorDataCycling.Speed current = new SensorDataCycling.Speed("sensorAddress", "sensorName", 2, 8016);
+
+        // when
+        current.compute(previous, 2150);
+
+        // then
+        Assert.assertEquals(1.20, current.getSpeed_mps(), 0.01);
+    }
+
+    @Test
+    public void compute_speed_rollOverCount() {
+        // given
+        SensorDataCycling.Speed previous = new SensorDataCycling.Speed("sensorAddress", "sensorName", UintUtils.UINT16_MAX - 1, 1024);
+        SensorDataCycling.Speed current = new SensorDataCycling.Speed("sensorAddress", "sensorName", 0, 2048);
+
+        // when
+        current.compute(previous, 2000);
+
+        // then
+        Assert.assertEquals(2, current.getSpeed_mps(), 0.01);
+    }
+}

src/androidTest/java/de/dennisguse/opentracks/fragments/ChartFragmentTest.java

@@ -33,7 +33,6 @@ import de.dennisguse.opentracks.TrackStubUtils;
 import de.dennisguse.opentracks.chart.ChartPoint;
 import de.dennisguse.opentracks.chart.ChartView;
 import de.dennisguse.opentracks.content.data.TrackPoint;
-import de.dennisguse.opentracks.content.sensor.SensorDataSet;
 import de.dennisguse.opentracks.util.UnitConversions;
 
 /**
@@ -72,20 +71,13 @@ public class ChartFragmentTest {
      */
     @Test
     public void testCreatePendingPoint_sensorIncorrect() {
+        // given
         TrackPoint trackPoint = TrackStubUtils.createDefaultTrackPoint();
 
-        // No input.
+        // when
         ChartPoint point = chartFragment.createPendingPoint(trackPoint);
-        Assert.assertEquals(Float.NaN, point.getHeartRate(), 0.01);
-        Assert.assertEquals(Float.NaN, point.getCadence(), 0.01);
-        Assert.assertEquals(Float.NaN, point.getPower(), 0.01);
 
-        // Input incorrect state.
-        // Creates SensorData.
-        SensorDataSet sensorDataSet = new SensorDataSet(SensorDataSet.DATA_UNAVAILABLE, SensorDataSet.DATA_UNAVAILABLE);
-        trackPoint.setSensorDataSet(sensorDataSet);
-        // Test.
-        point = chartFragment.createPendingPoint(trackPoint);
+        // then
         Assert.assertEquals(Float.NaN, point.getHeartRate(), 0.01);
         Assert.assertEquals(Float.NaN, point.getCadence(), 0.01);
         Assert.assertEquals(Float.NaN, point.getPower(), 0.01);
@@ -96,20 +88,16 @@ public class ChartFragmentTest {
      */
     @Test
     public void testCreatePendingPoint_sensorCorrect() {
+        // given
         TrackPoint trackPoint = TrackStubUtils.createDefaultTrackPoint();
-        // No input.
+        trackPoint.setHeartRate_bpm(100f);
+        trackPoint.setCyclingCadence_rpm(101f);
+        trackPoint.setPower(102f);
+
+        // when
         ChartPoint point = chartFragment.createPendingPoint(trackPoint);
-        Assert.assertEquals(Float.NaN, point.getHeartRate(), 0.01);
-        Assert.assertEquals(Float.NaN, point.getCadence(), 0.01);
-        Assert.assertEquals(Float.NaN, point.getPower(), 0.01);
 
-        // Creates SensorData.
-        SensorDataSet sensorDataSet = new SensorDataSet(100, 101, 102);
-
-        // Creates SensorDataSet.
-        trackPoint.setSensorDataSet(sensorDataSet);
-        // Test.
-        point = chartFragment.createPendingPoint(trackPoint);
+        // then
         Assert.assertEquals(100.0, point.getHeartRate(), 0.01);
         Assert.assertEquals(101.0, point.getCadence(), 0.01);
         Assert.assertEquals(102.0, point.getPower(), 0.01);

src/androidTest/java/de/dennisguse/opentracks/io/file/importer/AbstractTestFileTrackImporter.java

@@ -101,7 +101,7 @@ public abstract class AbstractTestFileTrackImporter {
      * @param trackPointId the track point id
      */
     protected void expectFirstTrackPoint(TrackPoint trackPoint, long trackId, long trackPointId) {
-        when(contentProviderUtils.bulkInsertTrackPoint(trackPoint != null ? (TrackPoint[]) any() : (TrackPoint[]) any(), eq(1), eq(trackId))).thenReturn(1);
+        when(contentProviderUtils.bulkInsertTrackPoint(trackPoint != null ? (TrackPoint[]) any() : (TrackPoint[]) any(), eq(trackId))).thenReturn(1);
     }
 
     /**

src/androidTest/java/de/dennisguse/opentracks/io/file/importer/ExportImportTest.java

@@ -2,6 +2,7 @@ package de.dennisguse.opentracks.io.file.importer;
 
 import android.content.Context;
 import android.util.Log;
+import android.util.Pair;
 
 import androidx.test.core.app.ApplicationProvider;
 import androidx.test.filters.LargeTest;
@@ -53,15 +54,15 @@ public class ExportImportTest {
 
     @Before
     public void setUp() {
-        Track track = TestDataUtil.getTrack(trackId, 10);
-        track.setIcon(TRACK_ICON);
-        track.setCategory(TRACK_CATEGORY);
-        track.setDescription(TRACK_DESCRIPTION);
-        contentProviderUtils.insertTrack(track);
-        contentProviderUtils.bulkInsertTrackPoint(track.getTrackPoints().toArray(new TrackPoint[0]), track.getTrackPoints().size(), track.getId());
+        Pair<Track, TrackPoint[]> track = TestDataUtil.createTrack(trackId, 10);
+        track.first.setIcon(TRACK_ICON);
+        track.first.setCategory(TRACK_CATEGORY);
+        track.first.setDescription(TRACK_DESCRIPTION);
+        contentProviderUtils.insertTrack(track.first);
+        contentProviderUtils.bulkInsertTrackPoint(track.second, track.first.getId());
 
         for (int i = 0; i < 3; i++) {
-            Waypoint waypoint = new Waypoint(track.getTrackPoints().get(i).getLocation());
+            Waypoint waypoint = new Waypoint(track.second[i].getLocation());
             waypoint.setName("the waypoint " + i);
             waypoint.setDescription("the waypoint description " + i);
             waypoint.setCategory("the waypoint category" + i);
@@ -96,7 +97,7 @@ public class ExportImportTest {
         Track track = contentProviderUtils.getTrack(trackId);
 
         TrackFileFormat trackFileFormat = TrackFileFormat.KML_WITH_TRACKDETAIL;
-        TrackExporter trackExporter = trackFileFormat.newTrackExporter(context, new Track[]{track}, null);
+        TrackExporter trackExporter = trackFileFormat.newTrackExporter(context, new Track[]{track});
 
         // when
         // 1. export
@@ -114,7 +115,7 @@ public class ExportImportTest {
         // 1. track
         Track importedTrack = contentProviderUtils.getTrack(importTrackId);
         assertNotNull(importedTrack);
-        assertEquals(track.getTrackPoints(), importedTrack.getTrackPoints());
+        //TODO assertEquals(track.getTrackPoints(), importedTrack.getTrackPoints());
         assertEquals(track.getCategory(), importedTrack.getCategory());
         assertEquals(track.getDescription(), importedTrack.getDescription());
         assertEquals(track.getName(), importedTrack.getName());
@@ -168,7 +169,7 @@ public class ExportImportTest {
         Track track = contentProviderUtils.getTrack(trackId);
 
         TrackFileFormat trackFileFormat = TrackFileFormat.GPX;
-        TrackExporter trackExporter = trackFileFormat.newTrackExporter(context, new Track[]{track}, null);
+        TrackExporter trackExporter = trackFileFormat.newTrackExporter(context, new Track[]{track});
 
         // when
         // 1. export
@@ -184,7 +185,7 @@ public class ExportImportTest {
         // 1. track
         Track trackImported = contentProviderUtils.getTrack(importTrackId);
         assertNotNull(trackImported);
-        assertEquals(track.getTrackPoints(), trackImported.getTrackPoints());
+        //TODO assertEquals(track.getTrackPoints(), trackImported.getTrackPoints());
         assertEquals(track.getCategory(), trackImported.getCategory());
         assertEquals(track.getDescription(), trackImported.getDescription());
         assertEquals(track.getName(), trackImported.getName());

src/androidTest/java/de/dennisguse/opentracks/io/file/importer/GpxFileTrackImporterTest.java

@@ -30,7 +30,6 @@ import de.dennisguse.opentracks.content.data.TrackPoint;
 import de.dennisguse.opentracks.util.PreferencesUtils;
 
 import static org.mockito.Mockito.any;
-import static org.mockito.Mockito.anyInt;
 import static org.mockito.Mockito.anyLong;
 import static org.mockito.Mockito.atLeastOnce;
 import static org.mockito.Mockito.eq;
@@ -91,7 +90,7 @@ public class GpxFileTrackImporterTest extends AbstractTestFileTrackImporter {
         expectFirstTrackPoint(trackPoint0, TRACK_ID_0, TRACK_POINT_ID_0);
 
         // A flush happens at the end
-        when(contentProviderUtils.bulkInsertTrackPoint((TrackPoint[]) any(), eq(1), eq(TRACK_ID_0))).thenReturn(1);
+        when(contentProviderUtils.bulkInsertTrackPoint((TrackPoint[]) any(), eq(TRACK_ID_0))).thenReturn(1);
         when(contentProviderUtils.getLastTrackPointId(TRACK_ID_0)).thenReturn(TRACK_POINT_ID_1);
         when(contentProviderUtils.getTrack(PreferencesUtils.getRecordingTrackId(context))).thenReturn(null);
         ArgumentCaptor<Track> trackCaptor = ArgumentCaptor.forClass(Track.class);
@@ -120,7 +119,7 @@ public class GpxFileTrackImporterTest extends AbstractTestFileTrackImporter {
         when(contentProviderUtils.insertTrack((Track) any())).thenReturn(TRACK_ID_0_URI);
         expectFirstTrackPoint(trackPoint0, TRACK_ID_0, TRACK_POINT_ID_0);
         // A flush happens at the end
-        when(contentProviderUtils.bulkInsertTrackPoint((TrackPoint[]) any(), eq(5), eq(TRACK_ID_0))).thenReturn(5);
+        when(contentProviderUtils.bulkInsertTrackPoint((TrackPoint[]) any(), eq(TRACK_ID_0))).thenReturn(5);
         when(contentProviderUtils.getLastTrackPointId(TRACK_ID_0)).thenReturn(TRACK_POINT_ID_3);
         when(contentProviderUtils.getTrack(PreferencesUtils.getRecordingTrackId(context))).thenReturn(null);
 
@@ -152,7 +151,7 @@ public class GpxFileTrackImporterTest extends AbstractTestFileTrackImporter {
         expectFirstTrackPoint(null, TRACK_ID_0, TRACK_POINT_ID_0);
 
         // A flush happens at the end
-        when(contentProviderUtils.bulkInsertTrackPoint((TrackPoint[]) any(), eq(5), eq(TRACK_ID_0))).thenReturn(5);
+        when(contentProviderUtils.bulkInsertTrackPoint((TrackPoint[]) any(), eq(TRACK_ID_0))).thenReturn(5);
         when(contentProviderUtils.getLastTrackPointId(TRACK_ID_0)).thenReturn(TRACK_POINT_ID_3);
         when(contentProviderUtils.getTrack(PreferencesUtils.getRecordingTrackId(context))).thenReturn(null);
 
@@ -206,7 +205,7 @@ public class GpxFileTrackImporterTest extends AbstractTestFileTrackImporter {
         when(contentProviderUtils.insertTrack((Track) any())).thenReturn(TRACK_ID_0_URI);
 
         // For the following, use StubReturn since we don't care whether they are invoked or not.
-        when(contentProviderUtils.bulkInsertTrackPoint((TrackPoint[]) any(), anyInt(), anyLong())).thenReturn(1);
+        when(contentProviderUtils.bulkInsertTrackPoint((TrackPoint[]) any(), anyLong())).thenReturn(1);
         when(contentProviderUtils.getTrack(PreferencesUtils.getRecordingTrackId(context))).thenReturn(null);
         contentProviderUtils.deleteTrack(context, TRACK_ID_0);
 

src/androidTest/java/de/dennisguse/opentracks/io/file/importer/KmlFileTrackImporterTest.java

@@ -75,7 +75,7 @@ public class KmlFileTrackImporterTest extends AbstractTestFileTrackImporter {
         expectFirstTrackPoint(trackPoint0, TRACK_ID_0, TRACK_POINT_ID_0);
 
         // A flush happens at the end
-        when(contentProviderUtils.bulkInsertTrackPoint((TrackPoint[]) any(), eq(1), eq(TRACK_ID_0))).thenReturn(1);
+        when(contentProviderUtils.bulkInsertTrackPoint((TrackPoint[]) any(), eq(TRACK_ID_0))).thenReturn(1);
         when(contentProviderUtils.getLastTrackPointId(TRACK_ID_0)).thenReturn(TRACK_POINT_ID_1);
         when(contentProviderUtils.getTrack(PreferencesUtils.getRecordingTrackId(context))).thenReturn(null);
 
@@ -106,7 +106,7 @@ public class KmlFileTrackImporterTest extends AbstractTestFileTrackImporter {
         expectFirstTrackPoint(trackPoint0, TRACK_ID_0, TRACK_POINT_ID_0);
 
         // A flush happens at the end
-        when(contentProviderUtils.bulkInsertTrackPoint((TrackPoint[]) any(), eq(5), eq(TRACK_ID_0))).thenReturn(5);
+        when(contentProviderUtils.bulkInsertTrackPoint((TrackPoint[]) any(), eq(TRACK_ID_0))).thenReturn(5);
         when(contentProviderUtils.getLastTrackPointId(TRACK_ID_0)).thenReturn(TRACK_POINT_ID_3);
         when(contentProviderUtils.getTrack(PreferencesUtils.getRecordingTrackId(context))).thenReturn(null);
 

src/androidTest/java/de/dennisguse/opentracks/services/TrackRecordingServiceTest.java

@@ -24,6 +24,7 @@ import android.os.IBinder;
 
 import androidx.test.core.app.ApplicationProvider;
 import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.filters.FlakyTest;
 import androidx.test.filters.MediumTest;
 import androidx.test.filters.SmallTest;
 import androidx.test.rule.GrantPermissionRule;
@@ -43,6 +44,8 @@ import java.util.concurrent.TimeoutException;
 
 import de.dennisguse.opentracks.R;
 import de.dennisguse.opentracks.content.data.Track;
+import de.dennisguse.opentracks.content.data.TrackPoint;
+import de.dennisguse.opentracks.content.data.TrackPointsColumns;
 import de.dennisguse.opentracks.content.data.Waypoint;
 import de.dennisguse.opentracks.content.provider.ContentProviderUtils;
 import de.dennisguse.opentracks.content.provider.CustomContentProvider;
@@ -86,7 +89,7 @@ public class TrackRecordingServiceTest {
 
         // Let's use default values.
         SharedPreferences sharedPreferences = PreferencesUtils.getSharedPreferences(context);
-        sharedPreferences.edit().clear().apply();
+        sharedPreferences.edit().clear().commit();
 
         // Ensure that the database is empty before every test
         contentProviderUtils.deleteAllTracks(context);
@@ -121,13 +124,16 @@ public class TrackRecordingServiceTest {
     @MediumTest
     @Test
     public void testRecording_noTracks() throws Exception {
+        // given
         List<Track> tracks = contentProviderUtils.getAllTracks();
         Assert.assertTrue(tracks.isEmpty());
 
+        // when
         Intent startIntent = createStartIntent(context);
         mServiceRule.startService(startIntent);
         TrackRecordingServiceInterface service = ((TrackRecordingServiceInterface) mServiceRule.bindService(startIntent));
 
+        // then
         // Test if we start in no-recording mode by default.
         Assert.assertFalse(service.isRecording());
         Assert.assertEquals(-1L, service.getRecordingTrackId());
@@ -136,19 +142,92 @@ public class TrackRecordingServiceTest {
     @MediumTest
     @Test
     public void testRecording_oldTracks() throws Exception {
+        // given
         createDummyTrack(trackId, -1L, false);
 
+        // when
         TrackRecordingServiceInterface service = ((TrackRecordingServiceInterface) mServiceRule.bindService(createStartIntent(context)));
+
+        // then
         Assert.assertFalse(service.isRecording());
         Assert.assertEquals(PreferencesUtils.RECORDING_TRACK_ID_DEFAULT, service.getRecordingTrackId());
     }
 
     @MediumTest
     @Test
-    public void testRecording_orphanedRecordingTrack() throws Exception {
-        Intent startIntent = createStartIntent(context);
-        TrackRecordingServiceInterface service = ((TrackRecordingServiceInterface) mServiceRule.bindService(startIntent));
+    public void testRecording_serviceRestart_whileRecording() throws Exception {
+        // given
+        createDummyTrack(trackId, -1L, true);
 
+        //when
+        TrackRecordingServiceInterface service = ((TrackRecordingServiceInterface) mServiceRule.bindService(createStartIntent(context)));
+
+        // then
+        Assert.assertTrue(service.isRecording());
+    }
+
+    @MediumTest
+    @Test
+    public void testRecording_pauseAndResume() throws Exception {
+        // given
+        createDummyTrack(trackId, -1L, true);
+        TrackRecordingServiceInterface service = ((TrackRecordingServiceInterface) mServiceRule.bindService(createStartIntent(context)));
+        insertLocation(service);
+
+        // when
+        service.pauseCurrentTrack();
+
+        // then
+        Assert.assertEquals(2, contentProviderUtils.getTrackPoints(trackId).size());
+
+        //when
+        service.resumeTrack(trackId);
+        insertLocation(service);
+
+        // then
+        Assert.assertTrue(service.isRecording());
+        Assert.assertEquals(trackId, service.getRecordingTrackId());
+
+        List<TrackPoint> trackPoints = contentProviderUtils.getTrackPoints(trackId);
+        Assert.assertEquals(5, trackPoints.size());
+        Assert.assertEquals(TrackPointsColumns.PAUSE_LATITUDE, trackPoints.get(1).getLatitude(), 0.01);
+        Assert.assertEquals(TrackPointsColumns.PAUSE_LATITUDE, trackPoints.get(2).getLatitude(), 0.01);
+        Assert.assertEquals(TrackPointsColumns.RESUME_LATITUDE, trackPoints.get(3).getLatitude(), 0.01);
+    }
+
+    @MediumTest
+    @Test
+    public void testRecording_resumeStoppedTrack() throws Exception {
+        // given
+        createDummyTrack(trackId, -1L, true);
+        TrackRecordingServiceInterface service = ((TrackRecordingServiceInterface) mServiceRule.bindService(createStartIntent(context)));
+        insertLocation(service);
+        service.endCurrentTrack();
+
+        Assert.assertEquals(1, contentProviderUtils.getTrackPoints(trackId).size());
+
+        // when
+        service.resumeTrack(trackId);
+        insertLocation(service);
+
+        // then
+        Assert.assertTrue(service.isRecording());
+        Assert.assertEquals(trackId, service.getRecordingTrackId());
+
+        List<TrackPoint> trackPoints = contentProviderUtils.getTrackPoints(trackId);
+        Assert.assertEquals(4, trackPoints.size());
+        Assert.assertEquals(TrackPointsColumns.PAUSE_LATITUDE, trackPoints.get(1).getLatitude(), 0.01);
+        Assert.assertEquals(TrackPointsColumns.RESUME_LATITUDE, trackPoints.get(2).getLatitude(), 0.01);
+    }
+
+    @FlakyTest(detail = "Sometimes fails on CI.")
+    @MediumTest
+    @Test
+    public void testRecording_orphanedRecordingTrack() throws Exception {
+        // given
+        TrackRecordingServiceInterface service = ((TrackRecordingServiceInterface) mServiceRule.bindService(createStartIntent(context)));
+
+        // when
         // Just set recording track to a bogus value.
         // Make sure that the service will not start recording and will clear the bogus track.
         PreferencesUtils.setLong(context, R.string.recording_track_id_key, 123L);
@@ -161,33 +240,86 @@ public class TrackRecordingServiceTest {
     @MediumTest
     @Test
     public void testStartNewTrack_alreadyRecording() throws Exception {
+        // given
         TrackRecordingServiceInterface service = ((TrackRecordingServiceInterface) mServiceRule.bindService(createStartIntent(context)));
         service.startNewTrack();
         Assert.assertTrue(service.isRecording());
+
         long trackId = service.getRecordingTrackId();
 
+        // when
         long newTrackId = service.startNewTrack();
+
+        // then
         Assert.assertEquals(PreferencesUtils.RECORDING_TRACK_ID_DEFAULT, newTrackId);
 
         Assert.assertEquals(trackId, PreferencesUtils.getRecordingTrackId(context));
         Assert.assertEquals(trackId, service.getRecordingTrackId());
-
-        service.endCurrentTrack();
     }
 
     @MediumTest
     @Test
     public void testEndCurrentTrack_noRecording() throws Exception {
+        // given
         TrackRecordingServiceInterface service = ((TrackRecordingServiceInterface) mServiceRule.bindService(createStartIntent(context)));
         Assert.assertFalse(service.isRecording());
 
+        // when
         // Ending the current track when there is no recording should not result in any error.
         service.endCurrentTrack();
 
+        // then
         Assert.assertFalse(PreferencesUtils.isRecording(context));
         Assert.assertEquals(PreferencesUtils.RECORDING_TRACK_ID_DEFAULT, service.getRecordingTrackId());
     }
 
+    @MediumTest
+    @Test
+    public void testInsertWaypointMarker_noRecordingTrack() throws Exception {
+        // given
+        TrackRecordingServiceInterface service = ((TrackRecordingServiceInterface) mServiceRule.bindService(createStartIntent(context)));
+        Assert.assertFalse(service.isRecording());
+
+        // when
+        long waypointId = service.insertWaypoint(null, null, null, null);
+
+        // then
+        Assert.assertEquals(-1L, waypointId);
+    }
+
+    @MediumTest
+    @Test
+    public void testInsertWaypointMarker_validWaypoint() throws Exception {
+        // given
+        TrackRecordingServiceInterface service = ((TrackRecordingServiceInterface) mServiceRule.bindService(createStartIntent(context)));
+        service.startNewTrack();
+        Assert.assertTrue(service.isRecording());
+        insertLocation(service);
+        long trackId = service.getRecordingTrackId();
+
+        // when
+        long waypointId = service.insertWaypoint(null, null, null, null);
+
+        // then
+        Assert.assertNotEquals(-1L, waypointId);
+        Waypoint wpt = contentProviderUtils.getWaypoint(waypointId);
+        Assert.assertEquals(context.getString(R.string.marker_waypoint_icon_url), wpt.getIcon());
+        Assert.assertEquals(context.getString(R.string.marker_name_format, 1), wpt.getName());
+        Assert.assertEquals(trackId, wpt.getTrackId());
+        Assert.assertEquals(0.0, wpt.getLength(), 0.01);
+        Assert.assertNotNull(wpt.getLocation());
+
+        service.endCurrentTrack();
+    }
+
+    private void addTrack(Track track, boolean isRecording) {
+        Assert.assertTrue(track.getId() >= 0);
+        contentProviderUtils.insertTrack(track);
+        Assert.assertEquals(track.getId(), contentProviderUtils.getTrack(track.getId()).getId());
+        PreferencesUtils.setLong(context, R.string.recording_track_id_key, isRecording ? track.getId() : PreferencesUtils.RECORDING_TRACK_ID_DEFAULT);
+        PreferencesUtils.setBoolean(context, R.string.recording_track_paused_key, !isRecording);
+    }
+
     // NOTE: Do not use to create a track that is currently recording.
     private void createDummyTrack(long id, long stopTime, boolean isRecording) {
         Track dummyTrack = new Track();
@@ -199,58 +331,28 @@ public class TrackRecordingServiceTest {
         addTrack(dummyTrack, isRecording);
     }
 
-    private void addTrack(Track track, boolean isRecording) {
-        Assert.assertTrue(track.getId() >= 0);
-        contentProviderUtils.insertTrack(track);
-        Assert.assertEquals(track.getId(), contentProviderUtils.getTrack(track.getId()).getId());
-        PreferencesUtils.setLong(context, R.string.recording_track_id_key, isRecording ? track.getId() : PreferencesUtils.RECORDING_TRACK_ID_DEFAULT);
-        PreferencesUtils.setBoolean(context, R.string.recording_track_paused_key, !isRecording);
+    private static void insertLocation(TrackRecordingServiceInterface trackRecordingService) throws InterruptedException {
+        insertLocation(trackRecordingService, 45.0f, 35f, 5, 10, System.currentTimeMillis());
+    }
+
+    static void insertLocation(TrackRecordingServiceInterface trackRecordingService, double latitude, double longitude, float accuracy, long speed) throws InterruptedException {
+        insertLocation(trackRecordingService, latitude, longitude, accuracy, speed, System.currentTimeMillis());
     }
 
     /**
      * Inserts a location and waits for 200ms.
      */
-    private void insertLocation(TrackRecordingServiceInterface trackRecordingService) throws InterruptedException {
+    private static void insertLocation(TrackRecordingServiceInterface trackRecordingService, double latitude, double longitude, float accuracy, long speed, long time) throws InterruptedException {
         Location location = new Location("gps");
-        location.setLongitude(35.0f);
-        location.setLatitude(45.0f);
-        location.setAccuracy(5);
-        location.setSpeed(10);
-        location.setTime(System.currentTimeMillis());
+        location.setLongitude(longitude);
+        location.setLatitude(latitude);
+        location.setAccuracy(accuracy);
+        location.setSpeed(speed);
+        location.setTime(time);
         location.setBearing(3.0f);
         trackRecordingService.insertLocation(location);
 
+        //TODO Needed?
         Thread.sleep(200);
     }
-
-    @MediumTest
-    @Test
-    public void testInsertWaypointMarker_noRecordingTrack() throws Exception {
-        TrackRecordingServiceInterface service = ((TrackRecordingServiceInterface) mServiceRule.bindService(createStartIntent(context)));
-        Assert.assertFalse(service.isRecording());
-
-        long waypointId = service.insertWaypoint(null, null, null, null);
-        Assert.assertEquals(-1L, waypointId);
-    }
-
-    @MediumTest
-    @Test
-    public void testInsertWaypointMarker_validWaypoint() throws Exception {
-        TrackRecordingServiceInterface service = ((TrackRecordingServiceInterface) mServiceRule.bindService(createStartIntent(context)));
-        service.startNewTrack();
-        Assert.assertTrue(service.isRecording());
-        insertLocation(service);
-
-        long trackId = service.getRecordingTrackId();
-        long waypointId = service.insertWaypoint(null, null, null, null);
-        Assert.assertNotEquals(-1L, waypointId);
-        Waypoint wpt = contentProviderUtils.getWaypoint(waypointId);
-        Assert.assertEquals(context.getString(R.string.marker_waypoint_icon_url), wpt.getIcon());
-        Assert.assertEquals(context.getString(R.string.marker_name_format, 1), wpt.getName());
-        Assert.assertEquals(trackId, wpt.getTrackId());
-        Assert.assertEquals(0.0, wpt.getLength(), 0.01);
-        Assert.assertNotNull(wpt.getLocation());
-
-        service.endCurrentTrack();
-    }
 }

src/androidTest/java/de/dennisguse/opentracks/services/TrackRecordingServiceTestLocation.java

@@ -0,0 +1,327 @@
+package de.dennisguse.opentracks.services;
+
+import android.content.ContentProvider;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.os.Looper;
+
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.filters.MediumTest;
+import androidx.test.rule.GrantPermissionRule;
+import androidx.test.rule.ServiceTestRule;
+
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import de.dennisguse.opentracks.content.data.TrackPoint;
+import de.dennisguse.opentracks.content.data.TrackPointsColumns;
+import de.dennisguse.opentracks.content.provider.ContentProviderUtils;
+import de.dennisguse.opentracks.content.provider.CustomContentProvider;
+import de.dennisguse.opentracks.content.sensor.SensorDataHeartRate;
+import de.dennisguse.opentracks.content.sensor.SensorDataSet;
+import de.dennisguse.opentracks.services.sensors.BluetoothRemoteSensorManager;
+import de.dennisguse.opentracks.util.PreferencesUtils;
+
+/**
+ * Tests insert location.
+ * <p>
+ * //TODO ATTENTION: This tests deletes all stored tracks in the database.
+ * So, if it is executed on a real device, data might be lost.
+ */
+@RunWith(AndroidJUnit4.class)
+public class TrackRecordingServiceTestLocation {
+
+    @Rule
+    public final ServiceTestRule mServiceRule = ServiceTestRule.withTimeout(5, TimeUnit.SECONDS);
+
+    @Rule
+    public GrantPermissionRule mRuntimePermissionRule = GrantPermissionRule.grant(android.Manifest.permission.ACCESS_FINE_LOCATION);
+
+    private final Context context = ApplicationProvider.getApplicationContext();
+    private ContentProviderUtils contentProviderUtils;
+
+    private TrackRecordingServiceInterface service;
+
+    @BeforeClass
+    public static void preSetUp() {
+        // Prepare looper for Android's message queue
+        if (Looper.myLooper() == null) Looper.prepare();
+    }
+
+    @Before
+    public void setUp() throws TimeoutException {
+        // Set up the mock content resolver
+        ContentProvider customContentProvider = new CustomContentProvider() {
+        };
+        customContentProvider.attachInfo(context, null);
+
+        contentProviderUtils = new ContentProviderUtils(context);
+
+        // Let's use default values.
+        SharedPreferences sharedPreferences = PreferencesUtils.getSharedPreferences(context);
+        sharedPreferences.edit().clear().commit();
+
+        service = ((TrackRecordingServiceInterface) mServiceRule.bindService(TrackRecordingServiceTest.createStartIntent(context)));
+        //Disable executorService to not insert locations from GPS via LocationManager
+        service.enableLocationExecutor(false);
+    }
+
+    @After
+    public void tearDown() {
+        // Reset service (if some previous test failed)
+        service.enableLocationExecutor(true);
+        if (service.isRecording() || service.isPaused()) {
+            service.endCurrentTrack();
+        }
+
+        // Ensure that the database is empty after every test
+        contentProviderUtils.deleteAllTracks(context);
+    }
+
+    @MediumTest
+    @Test
+    public void testOnLocationChangedAsync_movingAccurate() throws Exception {
+        // given
+        long trackId = service.startNewTrack();
+
+        // when
+        TrackRecordingServiceTest.insertLocation(service, 45.0, 35.0, 5, 15);
+        TrackRecordingServiceTest.insertLocation(service, 45.0001, 35.0, 5, 15);
+        TrackRecordingServiceTest.insertLocation(service, 45.0002, 35.0, 5, 15);
+        TrackRecordingServiceTest.insertLocation(service, 45.0003, 35.0, 5, 15);
+        TrackRecordingServiceTest.insertLocation(service, 45.0004, 35.0, 5, 15);
+        TrackRecordingServiceTest.insertLocation(service, 45.0005, 35.0, 5, 15);
+
+        service.endCurrentTrack();
+
+        // then
+        Assert.assertFalse(service.isRecording());
+
+        List<TrackPoint> trackPoints = contentProviderUtils.getTrackPoints(trackId);
+        Assert.assertEquals(6, trackPoints.size());
+        Assert.assertEquals(45.0005, trackPoints.get(5).getLatitude(), 0.01);
+    }
+
+    @MediumTest
+    @Test
+    public void testOnLocationChangedAsync_movingInaccurate() throws Exception {
+        // given
+        long trackId = service.startNewTrack();
+
+        // when
+        TrackRecordingServiceTest.insertLocation(service, 45.0, 35.0, 5, 15);
+        TrackRecordingServiceTest.insertLocation(service, 45.1, 35.0, Long.MAX_VALUE, 15);
+        TrackRecordingServiceTest.insertLocation(service, 45.2, 35.0, Long.MAX_VALUE, 15);
+        TrackRecordingServiceTest.insertLocation(service, 45.3, 35.0, Long.MAX_VALUE, 15);
+        TrackRecordingServiceTest.insertLocation(service, 99.0, 35.0, Long.MAX_VALUE, 15);
+
+        service.endCurrentTrack();
+
+        // then
+        Assert.assertFalse(service.isRecording());
+
+        List<TrackPoint> trackPoints = contentProviderUtils.getTrackPoints(trackId);
+        Assert.assertEquals(1, trackPoints.size());
+        Assert.assertEquals(45.0, trackPoints.get(0).getLatitude(), 0.01);
+    }
+
+    @MediumTest
+    @Test
+    public void testOnLocationChangedAsync_slowMovingAccurate() throws Exception {
+        // given
+        long trackId = service.startNewTrack();
+
+        // when
+        TrackRecordingServiceTest.insertLocation(service, 45.0, 35.0, 5, 15);
+        TrackRecordingServiceTest.insertLocation(service, 45.000001, 35.0, 5, 15);
+        TrackRecordingServiceTest.insertLocation(service, 45.000002, 35.0, 5, 15);
+        TrackRecordingServiceTest.insertLocation(service, 45.000003, 35.0, 5, 15);
+        TrackRecordingServiceTest.insertLocation(service, 45.000004, 35.0, 5, 15);
+        TrackRecordingServiceTest.insertLocation(service, 45.000005, 35.0, 5, 15);
+
+        service.endCurrentTrack();
+
+        // then
+        Assert.assertFalse(service.isRecording());
+
+        List<TrackPoint> trackPoints = contentProviderUtils.getTrackPoints(trackId);
+        Assert.assertEquals(2, trackPoints.size());
+        Assert.assertEquals(45.000005, trackPoints.get(1).getLatitude(), 0.01);
+    }
+
+//    @MediumTest
+//    @Test
+//    public void testOnLocationChangedAsync_repeatedTime() throws Exception {
+//        // when
+//        TrackRecordingServiceTest.insertLocation(service, 45.0, 35.0, 5, 15, 5);
+//        TrackRecordingServiceTest.insertLocation(service, 55.0, 35.0, 5, 15, 5);
+//        TrackRecordingServiceTest.insertLocation(service, 65.0, 35.0, 5, 15, 5);
+//
+//        service.endCurrentTrack();
+//
+//        // then
+//        Assert.assertFalse(service.isRecording());
+//
+//        List<TrackPoint> trackPoints = contentProviderUtils.getTrackPoints(trackId);
+//        Assert.assertEquals(1, trackPoints.size());
+//        Assert.assertEquals(45.0, trackPoints.get(0).getLatitude(), 0.01);
+//    }
+
+    @MediumTest
+    @Test
+    public void testOnLocationChangedAsync_idle() throws Exception {
+        // given
+        long trackId = service.startNewTrack();
+
+        // when
+        TrackRecordingServiceTest.insertLocation(service, 45.0, 35.0, 1, 0);
+        TrackRecordingServiceTest.insertLocation(service, 45.0, 35.0, 2, 0);
+        TrackRecordingServiceTest.insertLocation(service, 45.0, 35.0, 3, 0);
+        TrackRecordingServiceTest.insertLocation(service, 45.0, 35.0, 4, 0);
+        TrackRecordingServiceTest.insertLocation(service, 45.0, 35.0, 5, 0);
+        TrackRecordingServiceTest.insertLocation(service, 45.0, 35.0, 6, 0);
+
+        service.endCurrentTrack();
+
+        // then
+        Assert.assertFalse(service.isRecording());
+
+        List<TrackPoint> trackPoints = contentProviderUtils.getTrackPoints(trackId);
+        Assert.assertEquals(3, trackPoints.size());
+        Assert.assertEquals(1, trackPoints.get(0).getAccuracy(), 0.01);
+        Assert.assertEquals(2, trackPoints.get(1).getAccuracy(), 0.01);
+        Assert.assertEquals(6, trackPoints.get(2).getAccuracy(), 0.01);
+    }
+
+    @MediumTest
+    @Test
+    public void testOnLocationChangedAsync_idle_withMovement() throws Exception {
+        // given
+        long trackId = service.startNewTrack();
+
+        // when
+        TrackRecordingServiceTest.insertLocation(service, 45.0, 35.0, 1, 15);
+        TrackRecordingServiceTest.insertLocation(service, 45.0, 35.0, 2, 0);
+        TrackRecordingServiceTest.insertLocation(service, 45.0, 35.0, 3, 0);
+        TrackRecordingServiceTest.insertLocation(service, 45.0, 35.0, 4, 0);
+        TrackRecordingServiceTest.insertLocation(service, 45.0, 35.0, 5, 0);
+        TrackRecordingServiceTest.insertLocation(service, 45.0, 35.0, 6, 15);
+
+        service.endCurrentTrack();
+
+        // then
+        Assert.assertFalse(service.isRecording());
+
+        List<TrackPoint> trackPoints = contentProviderUtils.getTrackPoints(trackId);
+        Assert.assertEquals(4, trackPoints.size());
+        Assert.assertEquals(1, trackPoints.get(0).getAccuracy(), 0.01);
+        Assert.assertEquals(2, trackPoints.get(1).getAccuracy(), 0.01);
+        Assert.assertEquals(5, trackPoints.get(2).getAccuracy(), 0.01); //TODO Check why this trackPoint is inserted.
+        Assert.assertEquals(6, trackPoints.get(3).getAccuracy(), 0.01);
+    }
+
+
+    @MediumTest
+    @Test
+    public void testOnLocationChangedAsync_idle_withSensorData() throws Exception {
+        // given
+        long trackId = service.startNewTrack();
+
+        service.setRemoteSensorManager(new BluetoothRemoteSensorManager(context) {
+
+            @Override
+            public boolean isEnabled() {
+                return true;
+            }
+
+            @Override
+            public SensorDataSet getSensorData() {
+                SensorDataSet sensorDataSet = new SensorDataSet();
+                sensorDataSet.set(new SensorDataHeartRate("sensorName", "sensorAddress", 5f));
+                return sensorDataSet;
+            }
+        });
+
+        // when
+        TrackRecordingServiceTest.insertLocation(service, 45.0, 35.0, 0, 0);
+        TrackRecordingServiceTest.insertLocation(service, 45.0, 35.0, 1, 0);
+        TrackRecordingServiceTest.insertLocation(service, 45.0, 35.0, 2, 0);
+        TrackRecordingServiceTest.insertLocation(service, 45.0, 35.0, 3, 0);
+        TrackRecordingServiceTest.insertLocation(service, 45.0, 35.0, 4, 0);
+        TrackRecordingServiceTest.insertLocation(service, 45.0, 35.0, 5, 0);
+
+        service.endCurrentTrack();
+
+        // then
+        Assert.assertFalse(service.isRecording());
+
+        List<TrackPoint> trackPoints = contentProviderUtils.getTrackPoints(trackId);
+        Assert.assertEquals(6, trackPoints.size());
+        Assert.assertEquals(0, trackPoints.get(0).getAccuracy(), 0.01);
+        Assert.assertEquals(1, trackPoints.get(1).getAccuracy(), 0.01);
+        Assert.assertEquals(2, trackPoints.get(2).getAccuracy(), 0.01);
+        Assert.assertEquals(3, trackPoints.get(3).getAccuracy(), 0.01);
+        Assert.assertEquals(4, trackPoints.get(4).getAccuracy(), 0.01);
+        Assert.assertEquals(5, trackPoints.get(5).getAccuracy(), 0.01);
+    }
+
+    @MediumTest
+    @Test
+    public void testOnLocationChangedAsync_segment() throws Exception {
+        // given
+        long trackId = service.startNewTrack();
+
+        // when
+        TrackRecordingServiceTest.insertLocation(service, 45.0, 35.0, 1, 0);
+        TrackRecordingServiceTest.insertLocation(service, 45.1, 35.0, 2, 0);
+        TrackRecordingServiceTest.insertLocation(service, 45.1, 35.0, 3, 0);
+        TrackRecordingServiceTest.insertLocation(service, 45.2, 35.0, 4, 0);
+        TrackRecordingServiceTest.insertLocation(service, 45.2, 35.0, 5, 0);
+
+        service.endCurrentTrack();
+
+        // then
+        Assert.assertFalse(service.isRecording());
+
+        List<TrackPoint> trackPoints = contentProviderUtils.getTrackPoints(trackId);
+        Assert.assertEquals(7, trackPoints.size());
+        Assert.assertEquals(1, trackPoints.get(0).getAccuracy(), 0.01);
+        Assert.assertEquals(TrackPointsColumns.PAUSE_LATITUDE, trackPoints.get(1).getLatitude(), 0.01);
+        Assert.assertEquals(2, trackPoints.get(2).getAccuracy(), 0.01);
+        Assert.assertEquals(3, trackPoints.get(3).getAccuracy(), 0.01);
+        Assert.assertEquals(TrackPointsColumns.PAUSE_LATITUDE, trackPoints.get(4).getLatitude(), 0.01);
+        Assert.assertEquals(4, trackPoints.get(5).getAccuracy(), 0.01);
+        Assert.assertEquals(5, trackPoints.get(6).getAccuracy(), 0.01);
+    }
+
+    @MediumTest
+    @Test
+    public void testOnLocationChangedAsync_firstTrackPointInvalid() throws Exception {
+        // given
+        long trackId = service.startNewTrack();
+
+        // when
+        service.insertLocation(TrackPoint.createPause().getLocation());
+        TrackRecordingServiceTest.insertLocation(service, 45.0, 35.0, 0, 0);
+        service.insertLocation(TrackPoint.createPause().getLocation());
+
+        service.endCurrentTrack();
+
+        // then
+        Assert.assertFalse(service.isRecording());
+
+        List<TrackPoint> trackPoints = contentProviderUtils.getTrackPoints(trackId);
+        Assert.assertEquals(1, trackPoints.size());
+        Assert.assertEquals(0, trackPoints.get(0).getAccuracy(), 0.01);
+    }
+}

src/androidTest/java/de/dennisguse/opentracks/util/AnnouncementUtilsTest.java

@@ -26,7 +26,7 @@ public class AnnouncementUtilsTest {
         stats.setTotalElevationGain(6000);
 
         // when
-        String announcement = AnnouncementUtils.getAnnouncement(context, stats);
+        String announcement = AnnouncementUtils.getAnnouncement(context, stats, "airplane");
 
         // then
         Assert.assertEquals("OpenTracks total distance 20.00 kilometers in 5 minutes 0 seconds at 240.0 kilometers per hour", announcement);

src/androidTest/java/de/dennisguse/opentracks/util/BluetoothUtilsTest.java

@@ -0,0 +1,76 @@
+package de.dennisguse.opentracks.util;
+
+import android.bluetooth.BluetoothGattCharacteristic;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import de.dennisguse.opentracks.content.sensor.SensorDataCycling;
+
+public class BluetoothUtilsTest {
+
+    @Test
+    public void parseHeartRate_uint8() {
+        // given
+        BluetoothGattCharacteristic characteristic = new BluetoothGattCharacteristic(BluetoothUtils.HEART_RATE_SERVICE_UUID, 0, 0);
+        characteristic.setValue(new byte[]{0x02, 0x3C});
+
+        // when
+        int heartRate = BluetoothUtils.parseHeartRate(characteristic);
+
+        // then
+        Assert.assertEquals(60, heartRate);
+    }
+
+    @Test
+    public void parseHeartRate_uint16() {
+        // given
+        BluetoothGattCharacteristic characteristic = new BluetoothGattCharacteristic(BluetoothUtils.HEART_RATE_SERVICE_UUID, 0, 0);
+        characteristic.setValue(new byte[]{0x01, 0x01, 0x01});
+
+        // when
+        int heartRate = BluetoothUtils.parseHeartRate(characteristic);
+
+        // then
+        Assert.assertEquals(257, heartRate);
+    }
+
+    @Test
+    public void parseCyclingSpeedCadence_crankOnly() {
+        BluetoothGattCharacteristic characteristic = new BluetoothGattCharacteristic(BluetoothUtils.CYCLING_SPEED_CADENCE_SERVICE_UUID, 0, 0);
+        characteristic.setValue(new byte[]{0x01, (byte) 0xC8, 0x00, 0x00, 0x00, 0x06, (byte) 0x99});
+
+        // when
+        SensorDataCycling.CadenceAndSpeed sensor = BluetoothUtils.parseCyclingCrankAndWheel("address", "sensorName", characteristic);
+
+        // then
+        Assert.assertEquals(200, sensor.getCadence().getCrankRevolutionsCount());
+        Assert.assertNull(sensor.getSpeed());
+    }
+
+    @Test
+    public void parseCyclingSpeedCadence_wheelOnly() {
+        BluetoothGattCharacteristic characteristic = new BluetoothGattCharacteristic(BluetoothUtils.CYCLING_SPEED_CADENCE_SERVICE_UUID, 0, 0);
+        characteristic.setValue(new byte[]{0x02, (byte) 0xE1, 0x00, 0x45, (byte) 0x99});
+
+        // when
+        SensorDataCycling.CadenceAndSpeed sensor = BluetoothUtils.parseCyclingCrankAndWheel("address", "sensorName", characteristic);
+
+        // then
+        Assert.assertNull(sensor.getCadence());
+        Assert.assertEquals(225, sensor.getSpeed().getWheelRevolutionsCount());
+    }
+
+    @Test
+    public void parseCyclingSpeedCadence_crankWheel() {
+        BluetoothGattCharacteristic characteristic = new BluetoothGattCharacteristic(BluetoothUtils.CYCLING_SPEED_CADENCE_SERVICE_UUID, 0, 0);
+        characteristic.setValue(new byte[]{0x03, (byte) 0xC8, 0x00, 0x00, 0x00, 0x06, (byte) 0x99, (byte) 0xE1, 0x00, 0x45, (byte) 0x99});
+
+        // when
+        SensorDataCycling.CadenceAndSpeed sensor = BluetoothUtils.parseCyclingCrankAndWheel("address", "sensorName", characteristic);
+
+        // then
+        Assert.assertEquals(200, sensor.getCadence().getCrankRevolutionsCount());
+        Assert.assertEquals(225, sensor.getSpeed().getWheelRevolutionsCount());
+    }
+}

src/androidTest/java/de/dennisguse/opentracks/util/PreferencesUtilsTest.java

@@ -0,0 +1,62 @@
+package de.dennisguse.opentracks.util;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import de.dennisguse.opentracks.R;
+import de.dennisguse.opentracks.io.file.TrackFileFormat;
+
+@RunWith(AndroidJUnit4.class)
+public class PreferencesUtilsTest {
+
+    private final Context context = ApplicationProvider.getApplicationContext();
+
+    @Test
+    public void ExportTrackFileFormat_ok() {
+        // given
+        SharedPreferences.Editor editor = PreferencesUtils.getSharedPreferences(context).edit();
+        editor.putString(context.getString(R.string.export_trackfileformat_key), TrackFileFormat.KMZ_WITH_TRACKDETAIL.name());
+        editor.commit();
+
+        // when
+        TrackFileFormat trackFileFormat = PreferencesUtils.getExportTrackFileFormat(context);
+
+        // then
+        Assert.assertEquals(TrackFileFormat.KMZ_WITH_TRACKDETAIL, trackFileFormat);
+    }
+
+    @Test
+    public void ExportTrackFileFormat_invalid() {
+        // given
+        SharedPreferences.Editor editor = PreferencesUtils.getSharedPreferences(context).edit();
+        editor.putString(context.getString(R.string.export_trackfileformat_key), "invalid");
+        editor.commit();
+
+        // when
+        TrackFileFormat trackFileFormat = PreferencesUtils.getExportTrackFileFormat(context);
+
+        // then
+        Assert.assertEquals(TrackFileFormat.KMZ_WITH_TRACKDETAIL_AND_SENSORDATA, trackFileFormat);
+    }
+
+    @Test
+    public void ExportTrackFileFormat_noValue() {
+        // given
+        SharedPreferences.Editor editor = PreferencesUtils.getSharedPreferences(context).edit();
+        editor.clear();
+        editor.commit();
+
+        // when
+        TrackFileFormat trackFileFormat = PreferencesUtils.getExportTrackFileFormat(context);
+
+        // then
+        Assert.assertEquals(TrackFileFormat.KMZ_WITH_TRACKDETAIL_AND_SENSORDATA, trackFileFormat);
+    }
+}

src/androidTest/java/de/dennisguse/opentracks/util/TrackPointUtilsTest.java

@@ -0,0 +1,52 @@
+package de.dennisguse.opentracks.util;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import de.dennisguse.opentracks.content.data.TrackPoint;
+
+public class TrackPointUtilsTest {
+
+    @Test
+    public void fixTime_none() {
+        // given
+        long time = System.currentTimeMillis();
+        TrackPoint trackPoint = new TrackPoint();
+        trackPoint.setTime(time);
+
+        // when
+        TrackPointUtils.fixTime(trackPoint);
+
+        // then
+        Assert.assertEquals(time, trackPoint.getTime());
+    }
+
+    @Test
+    public void fixTime_0() {
+        // given
+        long time = System.currentTimeMillis();
+        TrackPoint trackPoint = new TrackPoint();
+        trackPoint.setTime(0);
+
+        // when
+        TrackPointUtils.fixTime(trackPoint);
+
+        // then
+        Assert.assertEquals(time, trackPoint.getTime(), 1000);
+    }
+
+    @Test
+    public void fixTime_gpsWeekRollover() {
+        // given
+        long time = System.currentTimeMillis();
+        TrackPoint trackPoint = new TrackPoint();
+        trackPoint.setTime(time - 1024 * UnitConversions.ONE_WEEK_MS);
+
+        // when
+        TrackPointUtils.fixTime(trackPoint);
+
+        // then
+        Assert.assertEquals(time, trackPoint.getTime());
+    }
+
+}

src/main/AndroidManifest.xml

@@ -79,7 +79,11 @@ limitations under the License.
         </activity>
 
         <activity
-            android:name=".TrackDetailActivity"
+            android:name=".TrackRecordedActivity"
+            android:screenOrientation="userPortrait" />
+
+        <activity
+            android:name=".TrackRecordingActivity"
             android:screenOrientation="userPortrait" />
 
         <activity android:name=".TrackEditActivity" />

src/main/java/de/dennisguse/opentracks/AboutActivity.java

@@ -2,11 +2,13 @@ package de.dennisguse.opentracks;
 
 import android.os.Bundle;
 import android.view.Menu;
+import android.view.ViewGroup;
 import android.widget.TextView;
 
 import androidx.annotation.Nullable;
 
 import de.dennisguse.opentracks.util.SystemUtils;
+import de.dennisguse.opentracks.util.ViewUtils;
 
 public class AboutActivity extends AbstractActivity {
 
@@ -27,6 +29,8 @@ public class AboutActivity extends AbstractActivity {
 
         TextView textURL = findViewById(R.id.about_app_url);
         textURL.setText(getString(R.string.about_url, getString(R.string.app_web_url)));
+
+        ViewUtils.makeClickableLinks((ViewGroup) findViewById(android.R.id.content));
     }
 
     protected int getLayoutResId() {

src/main/java/de/dennisguse/opentracks/AbstractListActivity.java

@@ -26,7 +26,7 @@ import de.dennisguse.opentracks.util.PreferencesUtils;
 
 /**
  * An abstract class for the following common tasks across
- * {@link TrackListActivity}, {@link TrackDetailActivity}, and
+ * {@link TrackListActivity}, {@link TrackRecordedActivity}, and
  * {@link SearchListActivity}:
  * <p>
  * - share track <br>

src/main/java/de/dennisguse/opentracks/HelpActivity.java

@@ -1,7 +1,20 @@
 package de.dennisguse.opentracks;
 
+import android.os.Bundle;
+import android.view.ViewGroup;
+
+import androidx.annotation.Nullable;
+
+import de.dennisguse.opentracks.util.ViewUtils;
+
 public class HelpActivity extends AbstractActivity {
 
+    @Override
+    public void onCreate(@Nullable Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        ViewUtils.makeClickableLinks((ViewGroup) findViewById(android.R.id.content));
+    }
+
     @Override
     protected int getLayoutResId() {
         return R.layout.help;

src/main/java/de/dennisguse/opentracks/MarkerEditActivity.java

@@ -315,6 +315,6 @@ public class MarkerEditActivity extends AbstractActivity {
         waypoint.setDescription(waypointDescription.getText().toString());
         waypoint.setPhotoUrl(photoUri != null ? photoUri.toString() : null);
 
-        new ContentProviderUtils(this).updateWaypoint(waypoint);
+        new ContentProviderUtils(this).updateWaypoint(this, waypoint);
     }
 }

src/main/java/de/dennisguse/opentracks/SearchListActivity.java

@@ -214,11 +214,11 @@ public class SearchListActivity extends AbstractListActivity implements DeleteMa
                 Map<String, Object> item = arrayAdapter.getItem(position);
                 Long trackId = (Long) item.get(TRACK_ID_FIELD);
                 Long markerId = (Long) item.get(MARKER_ID_FIELD);
-                Intent intent = IntentUtils.newIntent(SearchListActivity.this, TrackDetailActivity.class);
+                Intent intent = IntentUtils.newIntent(SearchListActivity.this, TrackRecordedActivity.class);
                 if (markerId != null) {
-                    intent = intent.putExtra(TrackDetailActivity.EXTRA_MARKER_ID, markerId);
+                    intent = intent.putExtra(TrackRecordedActivity.EXTRA_MARKER_ID, markerId);
                 } else {
-                    intent = intent.putExtra(TrackDetailActivity.EXTRA_TRACK_ID, trackId);
+                    intent = intent.putExtra(TrackRecordedActivity.EXTRA_TRACK_ID, trackId);
                 }
                 startActivity(intent);
             }

src/main/java/de/dennisguse/opentracks/TrackActivityDataHubInterface.java

@@ -0,0 +1,10 @@
+package de.dennisguse.opentracks;
+
+import de.dennisguse.opentracks.content.TrackDataHub;
+
+/**
+ * Interface for communication between activities that use {@link de.dennisguse.opentracks.content.TrackDataHub} and their fragments that need thi data hub.
+ */
+public interface TrackActivityDataHubInterface {
+    TrackDataHub getTrackDataHub();
+}

src/main/java/de/dennisguse/opentracks/TrackListActivity.java

@@ -28,7 +28,6 @@ import android.location.LocationManager;
 import android.os.Bundle;
 import android.provider.Settings;
 import android.util.Log;
-import android.view.Gravity;
 import android.view.KeyEvent;
 import android.view.Menu;
 import android.view.MenuItem;
@@ -206,7 +205,7 @@ public class TrackListActivity extends AbstractListActivity implements ConfirmDe
             if (!PreferencesUtils.isRecording(recordingTrackId)) {
                 // Not recording -> Recording
                 updateMenuItems(false, true);
-                Intent newIntent = IntentUtils.newIntent(TrackListActivity.this, TrackDetailActivity.class);
+                Intent newIntent = IntentUtils.newIntent(TrackListActivity.this, TrackRecordingActivity.class);
                 startActivity(newIntent);
             } else if (recordingTrackPaused) {
                 // Paused -> Resume
@@ -251,9 +250,17 @@ public class TrackListActivity extends AbstractListActivity implements ConfirmDe
         listView.setEmptyView(findViewById(R.id.track_list_empty_view));
         listView.setOnItemClickListener(new OnItemClickListener() {
             @Override
-            public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
-                Intent newIntent = IntentUtils.newIntent(TrackListActivity.this, TrackDetailActivity.class)
-                        .putExtra(TrackDetailActivity.EXTRA_TRACK_ID, id);
+            public void onItemClick(AdapterView<?> parent, View view, int position, long trackId) {
+                Intent newIntent;
+                if (trackId == recordingTrackId) {
+                    // Is recording -> open record activity.
+                    newIntent = IntentUtils.newIntent(TrackListActivity.this, TrackRecordingActivity.class)
+                            .putExtra(TrackRecordedActivity.EXTRA_TRACK_ID, trackId);
+                } else {
+                    // Not recording -> open detail activity.
+                    newIntent = IntentUtils.newIntent(TrackListActivity.this, TrackRecordedActivity.class)
+                            .putExtra(TrackRecordedActivity.EXTRA_TRACK_ID, trackId);
+                }
                 startActivity(newIntent);
             }
         });
@@ -352,7 +359,6 @@ public class TrackListActivity extends AbstractListActivity implements ConfirmDe
 
         searchMenuItem = menu.findItem(R.id.track_list_search);
         ActivityUtils.configureSearchWidget(this, searchMenuItem, trackController);
-
         startGpsMenuItem = menu.findItem(R.id.track_list_start_gps);
 
         return super.onCreateOptionsMenu(menu);
@@ -382,11 +388,6 @@ public class TrackListActivity extends AbstractListActivity implements ConfirmDe
                 } else {
                     startGps = !ServiceUtils.isTrackRecordingServiceRunning(this);
 
-                    // Show toast
-                    Toast toast = Toast.makeText(this, startGps ? R.string.gps_starting : R.string.gps_stopping, Toast.LENGTH_SHORT);
-                    toast.setGravity(Gravity.CENTER, 0, 0);
-                    toast.show();
-
                     // Invoke trackRecordingService
                     if (startGps) {
                         trackRecordingServiceConnection.startAndBind(this);

src/main/java/de/dennisguse/opentracks/TrackRecordedActivity.java

@@ -0,0 +1,276 @@
+/*
+ * Copyright 2008 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package de.dennisguse.opentracks;
+
+import android.app.ActivityOptions;
+import android.content.Intent;
+import android.os.Bundle;
+import android.util.Log;
+import android.view.Menu;
+import android.view.MenuItem;
+
+import androidx.annotation.NonNull;
+import androidx.fragment.app.Fragment;
+import androidx.fragment.app.FragmentPagerAdapter;
+import androidx.viewpager.widget.ViewPager;
+
+import com.google.android.material.tabs.TabLayout;
+
+import de.dennisguse.opentracks.content.TrackDataHub;
+import de.dennisguse.opentracks.content.data.Track;
+import de.dennisguse.opentracks.content.data.Waypoint;
+import de.dennisguse.opentracks.content.provider.ContentProviderUtils;
+import de.dennisguse.opentracks.fragments.ChartFragment;
+import de.dennisguse.opentracks.fragments.ChooseActivityTypeDialogFragment;
+import de.dennisguse.opentracks.fragments.ConfirmDeleteDialogFragment;
+import de.dennisguse.opentracks.fragments.StatisticsRecordedFragment;
+import de.dennisguse.opentracks.services.TrackRecordingServiceConnection;
+import de.dennisguse.opentracks.settings.SettingsActivity;
+import de.dennisguse.opentracks.util.IntentUtils;
+import de.dennisguse.opentracks.util.PreferencesUtils;
+import de.dennisguse.opentracks.util.TrackIconUtils;
+import de.dennisguse.opentracks.util.TrackUtils;
+
+/**
+ * An activity to show the track detail, record a new track or resumes an existing one.
+ *
+ * @author Leif Hendrik Wilden
+ * @author Rodrigo Damazio
+ */
+public class TrackRecordedActivity extends AbstractListActivity implements ChooseActivityTypeDialogFragment.ChooseActivityTypeCaller, ConfirmDeleteDialogFragment.ConfirmDeleteCaller, TrackActivityDataHubInterface {
+
+    public static final String EXTRA_TRACK_ID = "track_id";
+    public static final String EXTRA_MARKER_ID = "marker_id";
+
+    private static final String TAG = TrackRecordedActivity.class.getSimpleName();
+
+    private static final String CURRENT_TAB_TAG_KEY = "current_tab_tag_key";
+
+    // The following are set in onCreate.
+    private ContentProviderUtils contentProviderUtils;
+    private TrackDataHub trackDataHub;
+    private ViewPager pager;
+
+    // From intent.
+    private long trackId;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        contentProviderUtils = new ContentProviderUtils(this);
+        handleIntent(getIntent());
+
+        trackDataHub = new TrackDataHub(this);
+
+        FragmentPagerAdapter adapter = new FragmentPagerAdapter(getSupportFragmentManager(), 1) {
+            @Override
+            public int getCount() {
+                return 3;
+            }
+
+            @NonNull
+            @Override
+            public Fragment getItem(int position) {
+                switch (position) {
+                    case 0:
+                        return new StatisticsRecordedFragment();
+                    case 1:
+                        return ChartFragment.newInstance(false);
+                    case 2:
+                        return ChartFragment.newInstance(true);
+                    default:
+                        throw new RuntimeException("There isn't Fragment associated with the position: " + position);
+                }
+            }
+
+            @Override
+            public CharSequence getPageTitle(int position) {
+                switch (position) {
+                    case 0:
+                        return getString(R.string.track_detail_stats_tab);
+                    case 1:
+                        return getString(R.string.settings_chart_by_time);
+                    case 2:
+                        return getString(R.string.settings_chart_by_distance);
+                }
+                return "Unknown Tab";
+            }
+        };
+        pager = findViewById(R.id.track_detail_activity_view_pager);
+        pager.setAdapter(adapter);
+        TabLayout tabs = findViewById(R.id.track_detail_activity_tablayout);
+        tabs.setupWithViewPager(pager);
+        if (savedInstanceState != null) {
+            pager.setCurrentItem(savedInstanceState.getInt(CURRENT_TAB_TAG_KEY));
+        }
+    }
+
+    @Override
+    protected void onStart() {
+        super.onStart();
+        trackDataHub.start();
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+
+        // Update UI
+        this.invalidateOptionsMenu();
+
+        if (trackId != -1L) {
+            trackDataHub.loadTrack(trackId);
+        }
+    }
+
+    @Override
+    protected void onStop() {
+        super.onStop();
+        trackDataHub.stop();
+    }
+
+    @Override
+    protected void onSaveInstanceState(@NonNull Bundle outState) {
+        super.onSaveInstanceState(outState);
+        outState.putInt(CURRENT_TAB_TAG_KEY, pager.getCurrentItem());
+    }
+
+    @Override
+    protected int getLayoutResId() {
+        return R.layout.track_detail;
+    }
+
+    @Override
+    public void onNewIntent(Intent intent) {
+        super.onNewIntent(intent);
+        setIntent(intent);
+        handleIntent(intent);
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        getMenuInflater().inflate(R.menu.track_detail, menu);
+        return super.onCreateOptionsMenu(menu);
+    }
+
+    @Override
+    public boolean onPrepareOptionsMenu(Menu menu) {
+        menu.findItem(R.id.track_detail_markers).setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM);
+        menu.findItem(R.id.track_detail_resume_track).setVisible(!PreferencesUtils.isRecording(this));
+        Track track = contentProviderUtils.getTrack(trackId);
+        setTitle(track != null ? track.getName() : "");
+        return super.onPrepareOptionsMenu(menu);
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        Intent intent;
+        switch (item.getItemId()) {
+            case R.id.track_detail_share:
+                intent = IntentUtils.newShareFileIntent(this, new long[]{trackId});
+                intent = Intent.createChooser(intent, null);
+                startActivity(intent);
+                return true;
+            case R.id.track_detail_menu_show_on_map:
+                IntentUtils.showTrackOnMap(this, new long[]{trackId});
+                return true;
+            case R.id.track_detail_markers:
+                intent = IntentUtils.newIntent(this, MarkerListActivity.class)
+                        .putExtra(MarkerListActivity.EXTRA_TRACK_ID, trackId);
+                startActivity(intent);
+                return true;
+            case R.id.track_detail_edit:
+                intent = IntentUtils.newIntent(this, TrackEditActivity.class)
+                        .putExtra(TrackEditActivity.EXTRA_TRACK_ID, trackId);
+                startActivity(intent);
+                return true;
+            case R.id.track_detail_delete:
+                deleteTracks(new long[]{trackId});
+                return true;
+            case R.id.track_detail_resume_track:
+                Intent newIntent = IntentUtils.newIntent(TrackRecordedActivity.this, TrackRecordingActivity.class)
+                        .putExtra(TrackRecordingActivity.EXTRA_TRACK_ID, trackId);
+                startActivity(newIntent);
+                overridePendingTransition(android.R.anim.fade_in, android.R.anim.fade_out);
+                finish();
+                return true;
+            case R.id.track_detail_settings:
+                intent = IntentUtils.newIntent(this, SettingsActivity.class);
+                startActivity(intent);
+                return true;
+            default:
+                return super.onOptionsItemSelected(item);
+        }
+    }
+
+    @Override
+    protected TrackRecordingServiceConnection getTrackRecordingServiceConnection() {
+        // Not needed.
+        return null;
+    }
+
+    @Override
+    protected void onDeleted() {
+        runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                finish();
+            }
+        });
+    }
+
+    /**
+     * Gets the {@link TrackDataHub}.
+     */
+    @Override
+    public TrackDataHub getTrackDataHub() {
+        return trackDataHub;
+    }
+
+    private void handleIntent(Intent intent) {
+        trackId = intent.getLongExtra(EXTRA_TRACK_ID, -1L);
+
+        long markerId = intent.getLongExtra(EXTRA_MARKER_ID, -1L);
+        if (markerId != -1L) {
+            // Use the trackId from the marker
+            Waypoint waypoint = contentProviderUtils.getWaypoint(markerId);
+            if (waypoint == null) {
+                finish();
+                return;
+            }
+            trackId = waypoint.getTrackId();
+        }
+
+        if (trackId == -1L) {
+            Log.e(TAG, "TrackDetailActivity needs EXTRA_TRACK_ID.");
+            finish();
+            return;
+        }
+    }
+
+    public void chooseActivityType(String category) {
+        ChooseActivityTypeDialogFragment.showDialog(getSupportFragmentManager(), category);
+    }
+
+    @Override
+    public void onChooseActivityTypeDone(String iconValue) {
+        Track track = contentProviderUtils.getTrack(trackId);
+        String category = getString(TrackIconUtils.getIconActivityType(iconValue));
+        TrackUtils.updateTrack(this, track, null, category, null, contentProviderUtils);
+    }
+}

src/main/java/de/dennisguse/opentracks/TrackRecordingActivity.java

@@ -1,21 +1,6 @@
-/*
- * Copyright 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-
 package de.dennisguse.opentracks;
 
+import android.app.ActivityOptions;
 import android.content.Intent;
 import android.content.SharedPreferences;
 import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
@@ -38,12 +23,10 @@ import com.google.android.material.tabs.TabLayout;
 
 import de.dennisguse.opentracks.content.TrackDataHub;
 import de.dennisguse.opentracks.content.data.Track;
-import de.dennisguse.opentracks.content.data.Waypoint;
 import de.dennisguse.opentracks.content.provider.ContentProviderUtils;
 import de.dennisguse.opentracks.fragments.ChartFragment;
 import de.dennisguse.opentracks.fragments.ChooseActivityTypeDialogFragment;
-import de.dennisguse.opentracks.fragments.ConfirmDeleteDialogFragment;
-import de.dennisguse.opentracks.fragments.StatsFragment;
+import de.dennisguse.opentracks.fragments.StatisticsRecordingFragment;
 import de.dennisguse.opentracks.services.TrackRecordingServiceConnection;
 import de.dennisguse.opentracks.services.TrackRecordingServiceInterface;
 import de.dennisguse.opentracks.settings.SettingsActivity;
@@ -58,12 +41,11 @@ import de.dennisguse.opentracks.util.TrackUtils;
  * @author Leif Hendrik Wilden
  * @author Rodrigo Damazio
  */
-public class TrackDetailActivity extends AbstractListActivity implements ChooseActivityTypeDialogFragment.ChooseActivityTypeCaller, ConfirmDeleteDialogFragment.ConfirmDeleteCaller {
+public class TrackRecordingActivity extends AbstractActivity implements ChooseActivityTypeDialogFragment.ChooseActivityTypeCaller, TrackActivityDataHubInterface {
 
     public static final String EXTRA_TRACK_ID = "track_id";
-    public static final String EXTRA_MARKER_ID = "marker_id";
 
-    private static final String TAG = TrackDetailActivity.class.getSimpleName();
+    private static final String TAG = TrackRecordingActivity.class.getSimpleName();
 
     private static final String CURRENT_TAB_TAG_KEY = "current_tab_tag_key";
 
@@ -89,7 +71,7 @@ public class TrackDetailActivity extends AbstractListActivity implements ChooseA
             runOnUiThread(new Runnable() {
                 @Override
                 public void run() {
-                    trackController.update(isRecording(), recordingTrackPaused);
+                    trackController.update(true, recordingTrackPaused);
                 }
             });
 
@@ -115,7 +97,7 @@ public class TrackDetailActivity extends AbstractListActivity implements ChooseA
                 }
 
                 // A recording track is on.
-                Toast.makeText(TrackDetailActivity.this, msg, Toast.LENGTH_SHORT).show();
+                Toast.makeText(TrackRecordingActivity.this, msg, Toast.LENGTH_SHORT).show();
                 trackDataHub.loadTrack(trackId);
                 trackController.update(true, false);
                 trackController.onResume(true, recordingTrackPaused);
@@ -126,23 +108,23 @@ public class TrackDetailActivity extends AbstractListActivity implements ChooseA
     private final OnSharedPreferenceChangeListener sharedPreferenceChangeListener = new OnSharedPreferenceChangeListener() {
         @Override
         public void onSharedPreferenceChanged(SharedPreferences preferences, String key) {
-            if (PreferencesUtils.isKey(TrackDetailActivity.this, R.string.recording_track_id_key, key)) {
-                recordingTrackId = PreferencesUtils.getRecordingTrackId(TrackDetailActivity.this);
+            if (PreferencesUtils.isKey(TrackRecordingActivity.this, R.string.recording_track_id_key, key)) {
+                recordingTrackId = PreferencesUtils.getRecordingTrackId(TrackRecordingActivity.this);
                 setLockscreenPolicy();
                 setScreenOnPolicy();
             }
 
-            if (PreferencesUtils.isKey(TrackDetailActivity.this, R.string.recording_track_paused_key, key)) {
-                recordingTrackPaused = PreferencesUtils.isRecordingTrackPaused(TrackDetailActivity.this);
+            if (PreferencesUtils.isKey(TrackRecordingActivity.this, R.string.recording_track_paused_key, key)) {
+                recordingTrackPaused = PreferencesUtils.isRecordingTrackPaused(TrackRecordingActivity.this);
                 setLockscreenPolicy();
                 setScreenOnPolicy();
             }
 
-            if (PreferencesUtils.isKey(TrackDetailActivity.this, R.string.stats_show_on_lockscreen_while_recording_key, key)) {
+            if (PreferencesUtils.isKey(TrackRecordingActivity.this, R.string.stats_show_on_lockscreen_while_recording_key, key)) {
                 setLockscreenPolicy();
             }
 
-            if (PreferencesUtils.isKey(TrackDetailActivity.this, R.string.stats_keep_screen_on_while_recording_key, key)) {
+            if (PreferencesUtils.isKey(TrackRecordingActivity.this, R.string.stats_keep_screen_on_while_recording_key, key)) {
                 setScreenOnPolicy();
             }
 
@@ -151,9 +133,8 @@ public class TrackDetailActivity extends AbstractListActivity implements ChooseA
             runOnUiThread(new Runnable() {
                 @Override
                 public void run() {
-                    TrackDetailActivity.this.invalidateOptionsMenu();
-                    boolean isRecording = isRecording();
-                    trackController.update(isRecording, recordingTrackPaused);
+                    TrackRecordingActivity.this.invalidateOptionsMenu();
+                    trackController.update(true, recordingTrackPaused);
                 }
             });
         }
@@ -161,8 +142,6 @@ public class TrackDetailActivity extends AbstractListActivity implements ChooseA
 
     private MenuItem insertMarkerMenuItem;
     private MenuItem markerListMenuItem;
-    private MenuItem shareMenuItem;
-    private MenuItem resumeMenuItem;
 
     private final OnClickListener recordListener = new OnClickListener() {
         @Override
@@ -184,8 +163,13 @@ public class TrackDetailActivity extends AbstractListActivity implements ChooseA
     private final OnClickListener stopListener = new OnClickListener() {
         @Override
         public void onClick(View v) {
-            trackRecordingServiceConnection.stopRecording(TrackDetailActivity.this, true);
+            trackRecordingServiceConnection.stopRecording(TrackRecordingActivity.this, true);
+            Intent newIntent = IntentUtils.newIntent(TrackRecordingActivity.this, TrackRecordedActivity.class)
+                    .putExtra(TrackRecordedActivity.EXTRA_TRACK_ID, trackId);
+            startActivity(newIntent);
+            overridePendingTransition(android.R.anim.fade_in, android.R.anim.fade_out);
             updateMenuItems(true);
+            finish();
         }
     };
 
@@ -212,12 +196,14 @@ public class TrackDetailActivity extends AbstractListActivity implements ChooseA
             @Override
             public Fragment getItem(int position) {
                 switch (position) {
+                    case 0:
+                        return new StatisticsRecordingFragment();
                     case 1:
                         return ChartFragment.newInstance(false);
                     case 2:
                         return ChartFragment.newInstance(true);
-                    default: //0
-                        return new StatsFragment();
+                    default:
+                        throw new RuntimeException("There isn't Fragment associated with the position: " + position);
                 }
             }
 
@@ -253,7 +239,7 @@ public class TrackDetailActivity extends AbstractListActivity implements ChooseA
     }
 
     private void setLockscreenPolicy() {
-        boolean showOnLockScreen = PreferencesUtils.shouldShowStatsOnLockscreen(TrackDetailActivity.this)
+        boolean showOnLockScreen = PreferencesUtils.shouldShowStatsOnLockscreen(TrackRecordingActivity.this)
                 && PreferencesUtils.isRecording(this);
 
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1) {
@@ -266,7 +252,7 @@ public class TrackDetailActivity extends AbstractListActivity implements ChooseA
     }
 
     private void setScreenOnPolicy() {
-        boolean keepScreenOn = PreferencesUtils.shouldKeepScreenOn(TrackDetailActivity.this)
+        boolean keepScreenOn = PreferencesUtils.shouldKeepScreenOn(TrackRecordingActivity.this)
                 && PreferencesUtils.isRecording(this);
 
         if (keepScreenOn) {
@@ -296,10 +282,10 @@ public class TrackDetailActivity extends AbstractListActivity implements ChooseA
 
         if (trackId != -1L) {
             trackDataHub.loadTrack(trackId);
-            trackController.onResume(isRecording(), recordingTrackPaused);
-        } else {
-            startRecording();
+            trackController.onResume(true, recordingTrackPaused);
         }
+
+        startRecording();
     }
 
     @Override
@@ -324,7 +310,7 @@ public class TrackDetailActivity extends AbstractListActivity implements ChooseA
 
     @Override
     protected int getLayoutResId() {
-        return R.layout.track_detail;
+        return R.layout.track_record;
     }
 
     @Override
@@ -336,12 +322,10 @@ public class TrackDetailActivity extends AbstractListActivity implements ChooseA
 
     @Override
     public boolean onCreateOptionsMenu(Menu menu) {
-        getMenuInflater().inflate(R.menu.track_detail, menu);
+        getMenuInflater().inflate(R.menu.track_record, menu);
 
         insertMarkerMenuItem = menu.findItem(R.id.track_detail_insert_marker);
-        shareMenuItem = menu.findItem(R.id.track_detail_share);
         markerListMenuItem = menu.findItem(R.id.track_detail_markers);
-        resumeMenuItem = menu.findItem(R.id.track_detail_resume_track);
 
         return super.onCreateOptionsMenu(menu);
     }
@@ -362,11 +346,6 @@ public class TrackDetailActivity extends AbstractListActivity implements ChooseA
                         .putExtra(MarkerEditActivity.EXTRA_TRACK_ID, trackId);
                 startActivity(intent);
                 return true;
-            case R.id.track_detail_share:
-                intent = IntentUtils.newShareFileIntent(this, new long[]{trackId});
-                intent = Intent.createChooser(intent, null);
-                startActivity(intent);
-                return true;
             case R.id.track_detail_menu_show_on_map:
                 IntentUtils.showTrackOnMap(this, new long[]{trackId});
                 return true;
@@ -380,12 +359,6 @@ public class TrackDetailActivity extends AbstractListActivity implements ChooseA
                         .putExtra(TrackEditActivity.EXTRA_TRACK_ID, trackId);
                 startActivity(intent);
                 return true;
-            case R.id.track_detail_delete:
-                deleteTracks(new long[]{trackId});
-                return true;
-            case R.id.track_detail_resume_track:
-                startRecording();
-                return true;
             case R.id.track_detail_settings:
                 intent = IntentUtils.newIntent(this, SettingsActivity.class);
                 startActivity(intent);
@@ -395,57 +368,25 @@ public class TrackDetailActivity extends AbstractListActivity implements ChooseA
         }
     }
 
-    @Override
-    protected TrackRecordingServiceConnection getTrackRecordingServiceConnection() {
-        return trackRecordingServiceConnection;
-    }
-
-    @Override
-    protected void onDeleted() {
-        runOnUiThread(new Runnable() {
-            @Override
-            public void run() {
-                finish();
-            }
-        });
-    }
-
     /**
      * Gets the {@link TrackDataHub}.
      */
+    @Override
     public TrackDataHub getTrackDataHub() {
         return trackDataHub;
     }
 
     private void handleIntent(Intent intent) {
         trackId = intent.getLongExtra(EXTRA_TRACK_ID, -1L);
-        long markerId = intent.getLongExtra(EXTRA_MARKER_ID, -1L);
-        if (markerId != -1L) {
-            // Use the trackId from the marker
-            Waypoint waypoint = contentProviderUtils.getWaypoint(markerId);
-            if (waypoint == null) {
-                finish();
-                return;
-            }
-            trackId = waypoint.getTrackId();
-            if (trackId == -1L) {
-                finish();
-                return;
-            }
-        }
-
         if (trackId == -1L) {
             return;
         }
         Track track = contentProviderUtils.getTrack(trackId);
         if (track == null) {
-            // Use the last track if markerId is not set
-            if (markerId == -1L) {
-                track = contentProviderUtils.getLastTrack();
-                if (track != null) {
-                    trackId = track.getId();
-                    return;
-                }
+            track = contentProviderUtils.getLastTrack();
+            if (track != null) {
+                trackId = track.getId();
+                return;
             }
             finish();
         }
@@ -455,20 +396,9 @@ public class TrackDetailActivity extends AbstractListActivity implements ChooseA
      * Updates the menu items.
      */
     private void updateMenuItems(boolean isPaused) {
-        insertMarkerMenuItem.setVisible(isRecording() && !isPaused);
-        shareMenuItem.setVisible(!isRecording());
-        markerListMenuItem.setShowAsAction(isRecording() ? MenuItem.SHOW_AS_ACTION_NEVER : MenuItem.SHOW_AS_ACTION_IF_ROOM);
-        String title;
-        if (isRecording()) {
-            title = getString(isPaused ? R.string.generic_paused : R.string.generic_recording);
-            resumeMenuItem.setVisible(false);
-        } else {
-            Track track = contentProviderUtils.getTrack(trackId);
-            title = track != null ? track.getName() : "";
-            // Only visible if there aren't other tracks that is recording.
-            resumeMenuItem.setVisible(recordingTrackId == -1L);
-        }
-        setTitle(title);
+        insertMarkerMenuItem.setVisible(!isPaused);
+        markerListMenuItem.setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER);
+        setTitle(getString(isPaused ? R.string.generic_paused : R.string.generic_recording));
     }
 
     public void chooseActivityType(String category) {
@@ -482,10 +412,6 @@ public class TrackDetailActivity extends AbstractListActivity implements ChooseA
         TrackUtils.updateTrack(this, track, null, category, null, contentProviderUtils);
     }
 
-    private boolean isRecording() {
-        return trackId == recordingTrackId;
-    }
-
     private void startRecording() {
         trackRecordingServiceConnection.startAndBind(this);
 

src/main/java/de/dennisguse/opentracks/chart/ChartPoint.java

@@ -3,7 +3,7 @@ package de.dennisguse.opentracks.chart;
 import androidx.annotation.NonNull;
 import androidx.annotation.VisibleForTesting;
 
-import de.dennisguse.opentracks.content.sensor.SensorDataSet;
+import de.dennisguse.opentracks.content.data.TrackPoint;
 import de.dennisguse.opentracks.stats.TrackStatistics;
 import de.dennisguse.opentracks.stats.TrackStatisticsUpdater;
 import de.dennisguse.opentracks.util.UnitConversions;
@@ -25,7 +25,7 @@ public class ChartPoint {
         this.elevation = elevation;
     }
 
-    public ChartPoint(@NonNull TrackStatisticsUpdater trackStatisticsUpdater, SensorDataSet sensorDataSet, boolean chartByDistance, boolean metricUnits) {
+    public ChartPoint(@NonNull TrackStatisticsUpdater trackStatisticsUpdater, TrackPoint trackPoint, boolean chartByDistance, boolean metricUnits) {
         TrackStatistics trackStatistics = trackStatisticsUpdater.getTrackStatistics();
 
         if (chartByDistance) {
@@ -48,15 +48,15 @@ public class ChartPoint {
             speed *= UnitConversions.KM_TO_MI;
         }
         pace = speed == 0 ? 0.0 : 60.0 / speed;
-        if (sensorDataSet != null) {
-            if (sensorDataSet.hasHeartRate()) {
-                heartRate = sensorDataSet.getHeartRate();
+        if (trackPoint != null) {
+            if (trackPoint.hasHeartRate()) {
+                heartRate = trackPoint.getHeartRate_bpm();
             }
-            if (sensorDataSet.hasCadence()) {
-                cadence = sensorDataSet.getCadence();
+            if (trackPoint.hasCyclingCadence()) {
+                cadence = trackPoint.getCyclingCadence_rpm();
             }
-            if (sensorDataSet.hasPower()) {
-                power = sensorDataSet.getPower();
+            if (trackPoint.hasPower()) {
+                power = trackPoint.getPower();
             }
         }
     }

src/main/java/de/dennisguse/opentracks/chart/ChartView.java

@@ -846,7 +846,7 @@ public class ChartView extends View {
             for (int i = 0; i < seriesList.size(); i++) {
                 ChartValueSeries chartValueSeries = seriesList.get(i);
 
-                if (chartValueSeries.isChartPointValid(dataPoint)) {
+                if (!chartValueSeries.isChartPointValid(dataPoint)) {
                     continue;
                 }
 

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

@@ -126,10 +126,14 @@ public class DescriptionGenerator {
         writePace(stats.getMaxSpeed(), builder, R.string.description_fastest_pace_in_minute, lineBreak);
 
         // Max elevation
-        writeElevation(stats.getMaxElevation(), builder, R.string.description_max_elevation, lineBreak);
+        if (stats.hasElevationMax()) {
+            writeElevation(stats.getMaxElevation(), builder, R.string.description_max_elevation, lineBreak);
+        }
 
         // Min elevation
-        writeElevation(stats.getMinElevation(), builder, R.string.description_min_elevation, lineBreak);
+        if (stats.hasElevationMin()) {
+            writeElevation(stats.getMinElevation(), builder, R.string.description_min_elevation, lineBreak);
+        }
 
         // Elevation gain
         writeElevation(stats.getTotalElevationGain(), builder, R.string.description_elevation_gain, lineBreak);

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

@@ -16,11 +16,6 @@
 
 package de.dennisguse.opentracks.content.data;
 
-import androidx.annotation.VisibleForTesting;
-
-import java.util.ArrayList;
-import java.util.List;
-
 import de.dennisguse.opentracks.stats.TrackStatistics;
 
 /**
@@ -40,9 +35,6 @@ public class Track {
 
     private TrackStatistics trackStatistics = new TrackStatistics();
 
-    // Location points (which may not have been loaded)
-    private List<TrackPoint> trackPoints = new ArrayList<>();
-
     public Track() {
     }
 
@@ -93,17 +85,4 @@ public class Track {
     public void setTrackStatistics(TrackStatistics trackStatistics) {
         this.trackStatistics = trackStatistics;
     }
-
-    @VisibleForTesting
-    public void addTrackPoint(TrackPoint location) {
-        trackPoints.add(location);
-    }
-
-    public List<TrackPoint> getTrackPoints() {
-        return trackPoints;
-    }
-
-    public void setTrackPoints(ArrayList<TrackPoint> trackPoints) {
-        this.trackPoints = trackPoints;
-    }
 }

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

@@ -20,8 +20,6 @@ import android.location.LocationManager;
 
 import androidx.annotation.NonNull;
 
-import de.dennisguse.opentracks.content.sensor.SensorDataSet;
-
 /**
  * This class extends the standard Android location with extra information.
  *
@@ -31,6 +29,10 @@ public class TrackPoint {
 
     private final Location location;
 
+    private Float heartRate_bpm = null;
+    private Float cyclingCadence_rpm = null;
+    private Float power = null;
+
     public TrackPoint() {
         this.location = new Location("");
     }
@@ -39,17 +41,13 @@ public class TrackPoint {
         this.location = location;
     }
 
-    public TrackPoint(@NonNull Location location, SensorDataSet sensorDataSet) {
-        this.location = location;
-        this.sensorDataSet = sensorDataSet;
-    }
-
-    public TrackPoint(@NonNull TrackPoint trackPoint, SensorDataSet sensorDataSet) {
+    public TrackPoint(@NonNull TrackPoint trackPoint) {
         this.location = trackPoint.getLocation();
-        this.sensorDataSet = sensorDataSet;
-    }
 
-    private SensorDataSet sensorDataSet = null;
+        this.heartRate_bpm = trackPoint.getHeartRate_bpm();
+        this.cyclingCadence_rpm = trackPoint.getCyclingCadence_rpm();
+        this.power = trackPoint.getPower();
+    }
 
     public TrackPoint(double latitude, double longitude, Double altitude, long time) {
         location = new Location(LocationManager.GPS_PROVIDER);
@@ -90,14 +88,6 @@ public class TrackPoint {
         return location;
     }
 
-    public SensorDataSet getSensorDataSet() {
-        return sensorDataSet;
-    }
-
-    public void setSensorDataSet(SensorDataSet sensorDataSet) {
-        this.sensorDataSet = sensorDataSet;
-    }
-
     public double getLatitude() {
         return location.getLatitude();
     }
@@ -181,4 +171,51 @@ public class TrackPoint {
     public float bearingTo(@NonNull Location dest) {
         return location.bearingTo(dest);
     }
+
+    // Sensor data
+    public boolean hasSensorData() {
+        return hasHeartRate() || hasCyclingCadence() || hasPower();
+    }
+
+    public boolean hasHeartRate() {
+        return heartRate_bpm != null && heartRate_bpm > 0;
+    }
+
+    public float getHeartRate_bpm() {
+        return heartRate_bpm;
+    }
+
+    public void setHeartRate_bpm(Float heartRate_bpm) {
+        this.heartRate_bpm = heartRate_bpm;
+    }
+
+    public boolean hasCyclingCadence() {
+        return cyclingCadence_rpm != null;
+    }
+
+    public Float getCyclingCadence_rpm() {
+        return cyclingCadence_rpm;
+    }
+
+    public void setCyclingCadence_rpm(Float cyclingCadence_rpm) {
+        this.cyclingCadence_rpm = cyclingCadence_rpm;
+    }
+
+    public boolean hasPower() {
+        return power != null;
+    }
+
+    public Float getPower() {
+        return power;
+    }
+
+    public void setPower(Float power) {
+        this.power = power;
+    }
+
+    @NonNull
+    @Override
+    public String toString() {
+        return "time=" + getTime() + ": lat=" + getLatitude() + " lng=" + getLongitude() + " acc=" + getAccuracy();
+    }
 }

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

@@ -38,14 +38,15 @@ public final class Waypoint {
     private long trackId = -1L;
     private double length = 0.0;
     private long duration = 0;
-    private Location location = null;
+    private Location location;
     private String photoUrl = "";
 
     @VisibleForTesting
-    public Waypoint() {
+    public Waypoint(@NonNull TrackPoint trackPoint) {
+        this.location = trackPoint.getLocation();
     }
 
-    public Waypoint(Location location) {
+    public Waypoint(@NonNull Location location) {
         this.location = location;
     }
 

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

@@ -40,7 +40,6 @@ import de.dennisguse.opentracks.content.data.TrackPointsColumns;
 import de.dennisguse.opentracks.content.data.TracksColumns;
 import de.dennisguse.opentracks.content.data.Waypoint;
 import de.dennisguse.opentracks.content.data.WaypointsColumns;
-import de.dennisguse.opentracks.content.sensor.SensorDataSet;
 import de.dennisguse.opentracks.stats.TrackStatistics;
 import de.dennisguse.opentracks.util.FileUtils;
 
@@ -55,19 +54,13 @@ public class ContentProviderUtils {
     private static final String TAG = ContentProviderUtils.class.getSimpleName();
     private static final int MAX_LATITUDE = 90000000;
 
-    /**
-     * The authority (the first part of the URI) for the app's content provider.
-     */
+    // The authority (the first part of the URI) for the app's content provider.
     static final String AUTHORITY_PACKAGE = BuildConfig.APPLICATION_ID + ".content";
 
-    /**
-     * The base URI for the app's content provider.
-     */
+    // The base URI for the app's content provider.
     public static final String CONTENT_BASE_URI = "content://" + AUTHORITY_PACKAGE;
 
-    /**
-     * Maximum number of waypoints that will be loaded at one time.
-     */
+    // Maximum number of waypoints that will be loaded at one time.
     public static final int MAX_LOADED_WAYPOINTS_POINTS = 10000;
     private static final String ID_SEPARATOR = ",";
 
@@ -87,7 +80,7 @@ public class ContentProviderUtils {
     }
 
     /**
-     * Clears a track: removes waypoints and trackpoints.
+     * Clears a track: removes waypoints and trackPoints.
      * Only keeps the track id.
      *
      * @param trackId the track id
@@ -168,7 +161,7 @@ public class ContentProviderUtils {
     }
 
     /**
-     * Deletes all tracks (including waypoints and track points).
+     * Deletes all tracks (including waypoints and trackPoints).
      */
     public void deleteAllTracks(Context context) {
         contentResolver.delete(TrackPointsColumns.CONTENT_URI_BY_ID, null, null);
@@ -177,7 +170,7 @@ public class ContentProviderUtils {
         contentResolver.delete(TracksColumns.CONTENT_URI, null, null);
 
         File dir = FileUtils.getPhotoDir(context);
-        deleteDirectoryRecurse(dir);
+        FileUtils.deleteDirectoryRecurse(dir);
     }
 
     /**
@@ -188,13 +181,15 @@ public class ContentProviderUtils {
     public void deleteTrack(Context context, long trackId) {
         deleteTrackPointsAndWaypoints(context, trackId);
 
-        // Delete track last since it triggers a database vaccum call
-        contentResolver.delete(TracksColumns.CONTENT_URI, TracksColumns._ID + "=?",
-                new String[]{Long.toString(trackId)});
+        // Delete track folder resources.
+        FileUtils.deleteDirectoryRecurse(FileUtils.getPhotoDir(context, trackId));
+
+        // Delete track last since it triggers a database vacuum call
+        contentResolver.delete(TracksColumns.CONTENT_URI, TracksColumns._ID + "=?", new String[]{Long.toString(trackId)});
     }
 
     /**
-     * Deletes track points and waypoints of a track.
+     * Deletes trackPoints and waypoints of a track.
      *
      * @param trackId the track id
      */
@@ -203,29 +198,13 @@ public class ContentProviderUtils {
         String[] selectionArgs = new String[]{Long.toString(trackId)};
         contentResolver.delete(TrackPointsColumns.CONTENT_URI_BY_ID, where, selectionArgs);
 
-        contentResolver.delete(WaypointsColumns.CONTENT_URI, WaypointsColumns.TRACKID + "=?",
-                new String[]{Long.toString(trackId)});
-        deleteDirectoryRecurse(FileUtils.getPhotoDir(context, trackId));
-    }
-
-    /**
-     * Delete the directory recursively.
-     *
-     * @param dir the directory
-     */
-    private void deleteDirectoryRecurse(File dir) {
-        if (dir != null && dir.exists() && dir.isDirectory()) {
-            for (File child : dir.listFiles()) {
-                deleteDirectoryRecurse(child);
-            }
-            dir.delete();
-        }
+        contentResolver.delete(WaypointsColumns.CONTENT_URI, WaypointsColumns.TRACKID + "=?", new String[]{Long.toString(trackId)});
     }
 
     /**
      * Gets all the tracks.
-     * If no track exists, an empty list is returned.
-     * NOTE: the returned tracks do not have any track points attached.
+     *
+     * @return the tracks do not have any trackPoints attached.
      */
     @VisibleForTesting
     public List<Track> getAllTracks() {
@@ -241,9 +220,6 @@ public class ContentProviderUtils {
         return tracks;
     }
 
-    /**
-     * Gets the last track or null.
-     */
     public Track getLastTrack() {
         try (Cursor cursor = getTrackCursor(null, null, TracksColumns.STARTTIME + " DESC")) {
             // Using the same order as shown in the track list
@@ -255,10 +231,8 @@ public class ContentProviderUtils {
     }
 
     /**
-     * Gets a track by a track id or null
-     * Note that the returned track doesn't have any track points attached.
-     *
      * @param trackId the track id.
+     * @return the track doesn't have any trackPoints attached
      */
     public Track getTrack(long trackId) {
         if (trackId < 0) {
@@ -286,7 +260,7 @@ public class ContentProviderUtils {
 
     /**
      * Inserts a track.
-     * NOTE: This doesn't insert any track points.
+     * NOTE: This doesn't insert any trackPoints.
      *
      * @param track the track
      * @return the content provider URI of the inserted track.
@@ -297,13 +271,12 @@ public class ContentProviderUtils {
 
     /**
      * Updates a track.
-     * NOTE: This doesn't update any track points.
+     * NOTE: This doesn't update any trackPoints.
      *
      * @param track the track
      */
     public void updateTrack(Track track) {
-        contentResolver.update(TracksColumns.CONTENT_URI, createContentValues(track),
-                TracksColumns._ID + "=?", new String[]{Long.toString(track.getId())});
+        contentResolver.update(TracksColumns.CONTENT_URI, createContentValues(track), TracksColumns._ID + "=?", new String[]{Long.toString(track.getId())});
     }
 
     private ContentValues createContentValues(Track track) {
@@ -407,35 +380,17 @@ public class ContentProviderUtils {
         return waypoint;
     }
 
-    /**
-     * Deletes a waypoint.
-     * If deleting a statistics waypoint, this will also correct the next statistics waypoint after the deleted one to reflect the  deletion.
-     * The generator is used to update the next statistics waypoint.
-     *
-     * @param waypointId the waypoint id
-     */
-
-    public void deleteWaypoint(long waypointId) {
+    public void deleteWaypoint(Context context, long waypointId) {
         final Waypoint waypoint = getWaypoint(waypointId);
-        if (waypoint != null && waypoint.hasPhoto()) {
-            Uri uri = waypoint.getPhotoURI();
-            File file = new File(uri.getPath());
-            if (file.exists()) {
-                File parent = file.getParentFile();
-                file.delete();
-                if (parent.listFiles().length == 0) {
-                    parent.delete();
-                }
-            }
-        }
+        deleteWaypointPhoto(context, waypoint);
         contentResolver.delete(WaypointsColumns.CONTENT_URI, WaypointsColumns._ID + "=?", new String[]{Long.toString(waypointId)});
     }
 
     /**
-     * Gets the next waypoint number for a type.
-     * Returns -1 if not able to get the next waypoint number.
+     * Gets the next waypoint number.
      *
      * @param trackId the track id
+     * @return -1 if not able to get the next waypoint number.
      */
     public int getNextWaypointNumber(long trackId) {
         if (trackId < 0) {
@@ -452,12 +407,6 @@ public class ContentProviderUtils {
         return -1;
     }
 
-    /**
-     * Gets a waypoint from a waypoint id.
-     * Returns null if not found.
-     *
-     * @param waypointId the waypoint id
-     */
     public Waypoint getWaypoint(long waypointId) {
         if (waypointId < 0) {
             return null;
@@ -478,8 +427,7 @@ public class ContentProviderUtils {
      * @param selection     the selection. Can be null
      * @param selectionArgs the selection arguments. Can be null
      * @param sortOrder     the sort order. Can be null
-     * @param maxWaypoints  the maximum number of waypoints to return. -1 for no
-     *                      limit
+     * @param maxWaypoints  the maximum number of waypoints to return. -1 for no limit
      */
     public Cursor getWaypointCursor(String selection, String[] selectionArgs, String sortOrder, int maxWaypoints) {
         return getWaypointCursor(null, selection, selectionArgs, sortOrder, maxWaypoints);
@@ -536,12 +484,13 @@ public class ContentProviderUtils {
         String[] projection = new String[]{"count(*) AS count"};
         String selection = WaypointsColumns.TRACKID + "=?";
         String[] selectionArgs = new String[]{Long.toString(trackId)};
-        Cursor cursor = contentResolver.query(WaypointsColumns.CONTENT_URI, projection, selection, selectionArgs, WaypointsColumns._ID);
-
-        cursor.moveToFirst();
-        int count = cursor.getInt(0);
-        cursor.close();
-        return count;
+        try (Cursor cursor = contentResolver.query(WaypointsColumns.CONTENT_URI, projection, selection, selectionArgs, WaypointsColumns._ID)) {
+            if (cursor == null) {
+                return 0;
+            }
+            cursor.moveToFirst();
+            return cursor.getInt(0);
+        }
     }
 
     /**
@@ -555,14 +504,38 @@ public class ContentProviderUtils {
         return contentResolver.insert(WaypointsColumns.CONTENT_URI, createContentValues(waypoint));
     }
 
+    /**
+     * Delete waypoint's photo if any.
+     *
+     * @param context  the context object.
+     * @param waypoint the waypoint object.
+     */
+    private void deleteWaypointPhoto(Context context, Waypoint waypoint) {
+        if (waypoint != null && waypoint.hasPhoto()) {
+            Uri uri = waypoint.getPhotoURI();
+            File file = FileUtils.getPhotoFileIfExists(context, waypoint.getTrackId(), uri);
+            if (file.exists()) {
+                File parent = file.getParentFile();
+                file.delete();
+                if (parent.listFiles().length == 0) {
+                    parent.delete();
+                }
+            }
+        }
+    }
+
     /**
      * Updates a waypoint.
      * Returns true if successful.
      *
-     * @param waypoint the waypoint
+     * @param updatedWaypoint the waypoint with updated data.
      */
-    public boolean updateWaypoint(Waypoint waypoint) {
-        int rows = contentResolver.update(WaypointsColumns.CONTENT_URI, createContentValues(waypoint), WaypointsColumns._ID + "=?", new String[]{Long.toString(waypoint.getId())});
+    public boolean updateWaypoint(Context context, Waypoint updatedWaypoint) {
+        Waypoint savedWaypoint = getWaypoint(updatedWaypoint.getId());
+        if (!updatedWaypoint.hasPhoto()) {
+            deleteWaypointPhoto(context, savedWaypoint);
+        }
+        int rows = contentResolver.update(WaypointsColumns.CONTENT_URI, createContentValues(updatedWaypoint), WaypointsColumns._ID + "=?", new String[]{Long.toString(updatedWaypoint.getId())});
         return rows == 1;
     }
 
@@ -582,19 +555,17 @@ public class ContentProviderUtils {
         values.put(WaypointsColumns.DURATION, waypoint.getDuration());
 
         Location location = waypoint.getLocation();
-        if (location != null) {
-            values.put(WaypointsColumns.LONGITUDE, (int) (location.getLongitude() * 1E6));
-            values.put(WaypointsColumns.LATITUDE, (int) (location.getLatitude() * 1E6));
-            values.put(WaypointsColumns.TIME, location.getTime());
-            if (location.hasAltitude()) {
-                values.put(WaypointsColumns.ALTITUDE, location.getAltitude());
-            }
-            if (location.hasAccuracy()) {
-                values.put(WaypointsColumns.ACCURACY, location.getAccuracy());
-            }
-            if (location.hasBearing()) {
-                values.put(WaypointsColumns.BEARING, location.getBearing());
-            }
+        values.put(WaypointsColumns.LONGITUDE, (int) (location.getLongitude() * 1E6));
+        values.put(WaypointsColumns.LATITUDE, (int) (location.getLatitude() * 1E6));
+        values.put(WaypointsColumns.TIME, location.getTime());
+        if (location.hasAltitude()) {
+            values.put(WaypointsColumns.ALTITUDE, location.getAltitude());
+        }
+        if (location.hasAccuracy()) {
+            values.put(WaypointsColumns.ACCURACY, location.getAccuracy());
+        }
+        if (location.hasBearing()) {
+            values.put(WaypointsColumns.BEARING, location.getBearing());
         }
 
         values.put(WaypointsColumns.PHOTOURL, waypoint.getPhotoUrl());
@@ -623,8 +594,8 @@ public class ContentProviderUtils {
     /**
      * Fills a {@link TrackPoint} from a cursor.
      *
-     * @param cursor   the cursor pointing to a trackPoint.
-     * @param indexes  the cached track points indexes
+     * @param cursor  the cursor pointing to a trackPoint.
+     * @param indexes the cached trackPoints indexes
      */
     static TrackPoint fillTrackPoint(Cursor cursor, CachedTrackPointsIndexes indexes) {
         TrackPoint trackPoint = new TrackPoint();
@@ -651,30 +622,30 @@ public class ContentProviderUtils {
             trackPoint.setBearing(cursor.getFloat(indexes.bearingIndex));
         }
 
-        float heartRate = cursor.isNull(indexes.sensorHeartRateIndex) ? SensorDataSet.DATA_UNAVAILABLE : cursor.getFloat(indexes.sensorHeartRateIndex);
-        float cadence = cursor.isNull(indexes.sensorCadenceIndex) ? SensorDataSet.DATA_UNAVAILABLE : cursor.getFloat(indexes.sensorCadenceIndex);
-        float power = cursor.isNull(indexes.sensorPowerIndex) ? SensorDataSet.DATA_UNAVAILABLE : cursor.getFloat(indexes.sensorPowerIndex);
-
-        trackPoint.setSensorDataSet(new SensorDataSet(heartRate, cadence, power, SensorDataSet.DATA_UNAVAILABLE, trackPoint.getTime()));
+        if (!cursor.isNull(indexes.sensorHeartRateIndex)) {
+            trackPoint.setHeartRate_bpm(cursor.getFloat(indexes.sensorHeartRateIndex));
+        }
+        if (!cursor.isNull(indexes.sensorCadenceIndex)) {
+            trackPoint.setCyclingCadence_rpm(cursor.getFloat(indexes.sensorCadenceIndex));
+        }
+        if (!cursor.isNull(indexes.sensorPowerIndex)) {
+            trackPoint.setPower(cursor.getFloat(indexes.sensorPowerIndex));
+        }
 
         return trackPoint;
     }
 
     /**
-     * Inserts multiple trackPoints points.
+     * Inserts multiple trackPoints.
      *
      * @param trackPoints an array of trackPoints
-     * @param length    the number of trackPoints (from the beginning of the array) to
-     *                  insert, or -1 for all of them
-     * @param trackId   the trackPoints id
-     * @return the number of points inserted
+     * @param trackId     the trackPoints id
+     * @return the number of trackPoints inserted
      */
-    public int bulkInsertTrackPoint(TrackPoint[] trackPoints, int length, long trackId) {
-        if (length == -1) {
-            length = trackPoints.length;
-        }
-        ContentValues[] values = new ContentValues[length];
-        for (int i = 0; i < length; i++) {
+    //TODO Only used for testing and file import; might be better to replace it.
+    public int bulkInsertTrackPoint(TrackPoint[] trackPoints, long trackId) {
+        ContentValues[] values = new ContentValues[trackPoints.length];
+        for (int i = 0; i < values.length; i++) {
             values[i] = createContentValues(trackPoints[i], trackId);
         }
         return contentResolver.bulkInsert(TrackPointsColumns.CONTENT_URI_BY_ID, values);
@@ -691,9 +662,7 @@ public class ContentProviderUtils {
         if (trackId < 0) {
             return -1L;
         }
-        String selection = TrackPointsColumns._ID + "=(select min(" + TrackPointsColumns._ID
-                + ") from " + TrackPointsColumns.TABLE_NAME + " WHERE " + TrackPointsColumns.TRACKID
-                + "=?)";
+        String selection = TrackPointsColumns._ID + "=(SELECT MIN(" + TrackPointsColumns._ID + ") FROM " + TrackPointsColumns.TABLE_NAME + " WHERE " + TrackPointsColumns.TRACKID + "=?)";
         String[] selectionArgs = new String[]{Long.toString(trackId)};
         try (Cursor cursor = getTrackPointCursor(new String[]{TrackPointsColumns._ID}, selection, selectionArgs, TrackPointsColumns._ID)) {
             if (cursor != null && cursor.moveToFirst()) {
@@ -714,9 +683,7 @@ public class ContentProviderUtils {
         if (trackId < 0) {
             return -1L;
         }
-        String selection = TrackPointsColumns._ID + "=(select max(" + TrackPointsColumns._ID
-                + ") from " + TrackPointsColumns.TABLE_NAME + " WHERE " + TrackPointsColumns.TRACKID
-                + "=?)";
+        String selection = TrackPointsColumns._ID + "=(SELECT MAX(" + TrackPointsColumns._ID + ") from " + TrackPointsColumns.TABLE_NAME + " WHERE " + TrackPointsColumns.TRACKID + "=?)";
         String[] selectionArgs = new String[]{Long.toString(trackId)};
         try (Cursor cursor = getTrackPointCursor(new String[]{TrackPointsColumns._ID}, selection, selectionArgs, TrackPointsColumns._ID)) {
             if (cursor != null && cursor.moveToFirst()) {
@@ -727,19 +694,17 @@ public class ContentProviderUtils {
     }
 
     /**
-     * Gets the track point id of a location.
+     * Gets the trackPoint id for a location.
      *
      * @param trackId  the track id
      * @param location the location
-     * @return track point id if the location is in the track. -1L otherwise.
+     * @return trackPoint id if the location is in the track. -1L otherwise.
      */
     public long getTrackPointId(long trackId, Location location) {
         if (trackId < 0) {
             return -1L;
         }
-        String selection = TrackPointsColumns._ID + "=(select max(" + TrackPointsColumns._ID
-                + ") from " + TrackPointsColumns.TABLE_NAME
-                + " WHERE " + TrackPointsColumns.TRACKID + "=? AND " + TrackPointsColumns.TIME + "=?)";
+        String selection = TrackPointsColumns._ID + "=(SELECT MAX(" + TrackPointsColumns._ID + ") FROM " + TrackPointsColumns.TABLE_NAME + " WHERE " + TrackPointsColumns.TRACKID + "=? AND " + TrackPointsColumns.TIME + "=?)";
         String[] selectionArgs = new String[]{Long.toString(trackId), Long.toString(location.getTime())};
         try (Cursor cursor = getTrackPointCursor(new String[]{TrackPointsColumns._ID}, selection, selectionArgs, TrackPointsColumns._ID)) {
             if (cursor != null && cursor.moveToFirst()) {
@@ -762,7 +727,7 @@ public class ContentProviderUtils {
      * Creates a location cursor. The caller owns the returned cursor and is responsible for closing it.
      *
      * @param trackId           the track id
-     * @param startTrackPointId the starting track point id. -1L to ignore
+     * @param startTrackPointId the starting trackPoint id. -1L to ignore
      * @param maxLocations      maximum number of locations to return. -1 for no limit
      * @param descending        true to sort the result in descending order (latest location first)
      */
@@ -775,8 +740,7 @@ public class ContentProviderUtils {
         String[] selectionArgs;
         if (startTrackPointId >= 0) {
             String comparison = descending ? "<=" : ">=";
-            selection = TrackPointsColumns.TRACKID + "=? AND " + TrackPointsColumns._ID + comparison
-                    + "?";
+            selection = TrackPointsColumns.TRACKID + "=? AND " + TrackPointsColumns._ID + comparison + "?";
             selectionArgs = new String[]{Long.toString(trackId), Long.toString(startTrackPointId)};
         } else {
             selection = TrackPointsColumns.TRACKID + "=?";
@@ -804,19 +768,17 @@ public class ContentProviderUtils {
         if (trackId < 0) {
             return null;
         }
-        String selection = TrackPointsColumns._ID + "=(select max(" + TrackPointsColumns._ID + ") from "
-                + TrackPointsColumns.TABLE_NAME + " WHERE " + TrackPointsColumns.TRACKID + "=? AND "
-                + TrackPointsColumns.LATITUDE + "<=" + MAX_LATITUDE + ")";
+        String selection = TrackPointsColumns._ID + "=(SELECT MAX(" + TrackPointsColumns._ID + ") FROM " + TrackPointsColumns.TABLE_NAME + " WHERE " + TrackPointsColumns.TRACKID + "=? AND " + TrackPointsColumns.LATITUDE + "<=" + MAX_LATITUDE + ")";
         String[] selectionArgs = new String[]{Long.toString(trackId)};
         return findTrackPointBy(selection, selectionArgs);
     }
 
     /**
-     * Inserts a track point.
+     * Inserts a trackPoint.
      *
      * @param trackPoint the trackPoint
-     * @param trackId  the track id
-     * @return the content provider URI of the inserted track point
+     * @param trackId    the track id
+     * @return the content provider URI of the inserted trackPoint
      */
     public Uri insertTrackPoint(TrackPoint trackPoint, long trackId) {
         return contentResolver.insert(TrackPointsColumns.CONTENT_URI_BY_ID, createContentValues(trackPoint, trackId));
@@ -826,7 +788,7 @@ public class ContentProviderUtils {
      * Creates the {@link ContentValues} for a {@link TrackPoint}.
      *
      * @param trackPoint the trackPoint
-     * @param trackId  the track id
+     * @param trackId    the track id
      */
     private ContentValues createContentValues(TrackPoint trackPoint, long trackId) {
         ContentValues values = new ContentValues();
@@ -848,16 +810,14 @@ public class ContentProviderUtils {
             values.put(TrackPointsColumns.BEARING, trackPoint.getBearing());
         }
 
-        //SensorData
-        SensorDataSet sensorDataSet = trackPoint.getSensorDataSet();
-        if (sensorDataSet != null && sensorDataSet.hasHeartRate()) {
-            values.put(TrackPointsColumns.SENSOR_HEARTRATE, trackPoint.getSensorDataSet().getHeartRate());
+        if (trackPoint.hasHeartRate()) {
+            values.put(TrackPointsColumns.SENSOR_HEARTRATE, trackPoint.getHeartRate_bpm());
         }
-        if (sensorDataSet != null && sensorDataSet.hasCadence()) {
-            values.put(TrackPointsColumns.SENSOR_CADENCE, trackPoint.getSensorDataSet().getCadence());
+        if (trackPoint.hasCyclingCadence()) {
+            values.put(TrackPointsColumns.SENSOR_CADENCE, trackPoint.getCyclingCadence_rpm());
         }
-        if (sensorDataSet != null && sensorDataSet.hasPower()) {
-            values.put(TrackPointsColumns.SENSOR_POWER, trackPoint.getSensorDataSet().getPower());
+        if (trackPoint.hasPower()) {
+            values.put(TrackPointsColumns.SENSOR_POWER, trackPoint.getPower());
         }
         return values;
     }
@@ -870,7 +830,7 @@ public class ContentProviderUtils {
      * When done with iteration, {@link TrackPointIterator#close()} must be called.
      *
      * @param trackId           the track id
-     * @param startTrackPointId the starting track point id. -1L to ignore
+     * @param startTrackPointId the starting trackPoint id. -1L to ignore
      * @param descending        true to sort the result in descending order (latest location first)
      */
     public TrackPointIterator getTrackPointLocationIterator(final long trackId, final long startTrackPointId, final boolean descending) {
@@ -887,7 +847,7 @@ public class ContentProviderUtils {
     }
 
     /**
-     * Gets a track point cursor.
+     * Gets a trackPoint cursor.
      *
      * @param projection    the projection
      * @param selection     the selection
@@ -898,6 +858,24 @@ public class ContentProviderUtils {
         return contentResolver.query(TrackPointsColumns.CONTENT_URI_BY_ID, projection, selection, selectionArgs, sortOrder);
     }
 
+    @VisibleForTesting
+    public List<TrackPoint> getTrackPoints(long trackId) {
+        List<TrackPoint> trackPoints = null;
+
+        try (Cursor trackPointCursor = getTrackPointCursor(trackId, -1L, -1, false)) {
+            if (trackPointCursor != null) {
+                trackPointCursor.moveToFirst();
+                trackPoints = new ArrayList<>(trackPointCursor.getCount());
+                for (int i = 0; i < trackPointCursor.getCount(); i++) {
+                    trackPoints.add(createTrackPoint(trackPointCursor));
+                    trackPointCursor.moveToNext();
+                }
+            }
+        }
+
+        return trackPoints;
+    }
+
     int getDefaultCursorBatchSize() {
         return defaultCursorBatchSize;
     }
@@ -915,7 +893,7 @@ public class ContentProviderUtils {
     /**
      * Formats an array of IDs as comma separated string value
      *
-     * @param ids   array with IDs
+     * @param ids array with IDs
      * @return comma separated list of ids
      */
     public static String formatIdListForUri(long[] ids) {

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

@@ -209,7 +209,7 @@ public class ShareContentProvider extends CustomContentProvider implements ICont
             tracks[i] = contentProviderUtils.getTrack(trackIds[i]);
         }
 
-        final TrackExporter trackExporter = getTrackFileFormat(uri).newTrackExporter(getContext(), tracks, null);
+        final TrackExporter trackExporter = getTrackFileFormat(uri).newTrackExporter(getContext(), tracks);
 
         PipeDataWriter pipeDataWriter = new PipeDataWriter<String>() {
             @Override

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

@@ -0,0 +1,39 @@
+package de.dennisguse.opentracks.content.sensor;
+
+import androidx.annotation.VisibleForTesting;
+
+import de.dennisguse.opentracks.services.sensors.BluetoothRemoteSensorManager;
+
+public class SensorData {
+
+    private String sensorAddress;
+    private String sensorName;
+
+    private long timestamp_ms;
+
+    SensorData(String sensorAddress, String sensorName) {
+        this(sensorAddress, sensorName, System.currentTimeMillis());
+    }
+
+    @VisibleForTesting
+    SensorData(String sensorAddress, String sensorName, long timestamp_ms) {
+        this.sensorAddress = sensorAddress;
+        this.sensorName = sensorName;
+        this.timestamp_ms = timestamp_ms;
+    }
+
+    public String getSensorAddress() {
+        return sensorAddress;
+    }
+
+    public String getSensorName() {
+        return sensorName;
+    }
+
+    /**
+     * Is the data recent considering the current time.
+     */
+    public boolean isRecent() {
+        return timestamp_ms + BluetoothRemoteSensorManager.MAX_SENSOR_DATE_SET_AGE_MS > System.currentTimeMillis();
+    }
+}

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

@@ -0,0 +1,175 @@
+package de.dennisguse.opentracks.content.sensor;
+
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import de.dennisguse.opentracks.util.UintUtils;
+import de.dennisguse.opentracks.util.UnitConversions;
+
+/**
+ * Provides cadence in rpm and speed in milliseconds from Bluetooth LE Cycling Cadence and Speed sensors.
+ * <p>
+ * https://www.bluetooth.org/docman/handlers/downloaddoc.ashx?doc_id=261449
+ */
+public final class SensorDataCycling {
+
+    private static final String TAG = SensorDataCycling.class.getSimpleName();
+
+    private static final int INVALID_VALUE_INT = -1;
+    private static final float INVALID_VALUE_FLOAT = Float.NaN;
+
+    private SensorDataCycling() {
+    }
+
+    public static class Cadence extends SensorData {
+
+        private long crankRevolutionsCount; // UINT32
+        private int crankRevolutionsTime; // UINT16; 1/1024s
+        private float cadence_rpm = INVALID_VALUE_FLOAT;
+
+        public Cadence(String sensorAddress, String sensorName, long crankRevolutionsCount, int crankRevolutionsTime) {
+            super(sensorAddress, sensorName);
+            this.crankRevolutionsCount = crankRevolutionsCount;
+            this.crankRevolutionsTime = crankRevolutionsTime;
+        }
+
+        /**
+         * Workaround for Wahoo CADENCE: provides speed instead of cadence
+         */
+        public Cadence(@NonNull SensorDataCycling.Speed speed) {
+            this(speed.getSensorAddress(), speed.getSensorName(), speed.getWheelRevolutionsCount(), speed.getWheelRevolutionsTime());
+        }
+
+        public boolean hasData() {
+            return crankRevolutionsCount != INVALID_VALUE_INT && crankRevolutionsTime != INVALID_VALUE_INT;
+        }
+
+        public long getCrankRevolutionsCount() {
+            return crankRevolutionsCount;
+        }
+
+        public int getCrankRevolutionsTime() {
+            return crankRevolutionsTime;
+        }
+
+        public boolean hasCadence_rpm() {
+            return !Float.isNaN(cadence_rpm);
+        }
+
+        public float getCadence_rpm() {
+            return cadence_rpm;
+        }
+
+        public void compute(Cadence previous) {
+            if (hasData() && previous != null && previous.hasData()) {
+                float timeDiff_ms = UintUtils.diff(crankRevolutionsTime, previous.crankRevolutionsTime, UintUtils.UINT16_MAX) / 1024f * UnitConversions.S_TO_MS;
+                if (timeDiff_ms <= 0) {
+                    Log.e(TAG, "Timestamps difference is invalid: cannot compute cadence.");
+                    cadence_rpm = INVALID_VALUE_FLOAT;
+                } else {
+                    long crankDiff = UintUtils.diff(crankRevolutionsCount, previous.crankRevolutionsCount, UintUtils.UINT32_MAX);
+                    float cadence_ms = crankDiff / timeDiff_ms;
+                    cadence_rpm = (float) (cadence_ms / UnitConversions.MS_TO_S / UnitConversions.S_TO_MIN);
+                }
+            }
+        }
+
+        @NonNull
+        @Override
+        public String toString() {
+            return "cadence=" + getCadence_rpm() + " time=" + getCrankRevolutionsTime() + " count=" + getCrankRevolutionsCount();
+        }
+
+        @Override
+        public boolean equals(@Nullable Object obj) {
+            if (!(obj instanceof Cadence)) return false;
+
+            Cadence comp = (Cadence) obj;
+            return getCrankRevolutionsCount() == comp.getCrankRevolutionsCount() && getCrankRevolutionsTime() == comp.getCrankRevolutionsTime();
+        }
+    }
+
+    public static class Speed extends SensorData {
+
+        private int wheelRevolutionsCount; // UINT16
+        private int wheelRevolutionsTime; // UINT16; 1/1024s
+        private float speed_mps = INVALID_VALUE_FLOAT;
+
+        public Speed(String sensorAddress, String sensorName, int wheelRevolutionsCount, int wheelRevolutionsTime) {
+            super(sensorAddress, sensorName);
+            this.wheelRevolutionsCount = wheelRevolutionsCount;
+            this.wheelRevolutionsTime = wheelRevolutionsTime;
+        }
+
+        public boolean hasData() {
+            return wheelRevolutionsCount != INVALID_VALUE_INT && wheelRevolutionsTime != INVALID_VALUE_INT;
+        }
+
+        public int getWheelRevolutionsCount() {
+            return wheelRevolutionsCount;
+        }
+
+        public int getWheelRevolutionsTime() {
+            return wheelRevolutionsTime;
+        }
+
+        public boolean hasSpeed_mps() {
+            return !Float.isNaN(speed_mps);
+        }
+
+        public float getSpeed_mps() {
+            return speed_mps;
+        }
+
+        public void compute(Speed 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) {
+                    Log.e(TAG, "Timestamps difference is invalid: cannot compute cadence.");
+                    speed_mps = INVALID_VALUE_FLOAT;
+                } else {
+                    long wheelDiff = UintUtils.diff(wheelRevolutionsCount, previous.wheelRevolutionsCount, UintUtils.UINT16_MAX);
+                    double timeDiff_s = timeDiff_ms * UnitConversions.MS_TO_S;
+                    speed_mps = (float) (wheelDiff * wheel_circumference_mm * UnitConversions.MM_TO_M / timeDiff_s);
+                }
+            }
+        }
+
+        @NonNull
+        @Override
+        public String toString() {
+            return "speed=" + getSpeed_mps() + " time=" + getWheelRevolutionsTime() + " count=" + getWheelRevolutionsCount();
+        }
+
+        @Override
+        public boolean equals(@Nullable Object obj) {
+            if (!(obj instanceof Speed)) return false;
+
+            Speed comp = (Speed) obj;
+            return getWheelRevolutionsCount() == comp.getWheelRevolutionsCount() && getWheelRevolutionsTime() == comp.getWheelRevolutionsTime();
+        }
+    }
+
+    public static class CadenceAndSpeed extends SensorData {
+
+        private Cadence cadence;
+        private Speed speed;
+
+        public CadenceAndSpeed(String sensorAddress, String sensorName, @NonNull Cadence cadence, @NonNull Speed speed) {
+            super(sensorAddress, sensorName);
+            this.cadence = cadence;
+            this.speed = speed;
+        }
+
+        public Cadence getCadence() {
+            return cadence;
+        }
+
+        public Speed getSpeed() {
+            return speed;
+        }
+    }
+}
+

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

@@ -0,0 +1,27 @@
+package de.dennisguse.opentracks.content.sensor;
+
+import androidx.annotation.NonNull;
+
+public class SensorDataHeartRate extends SensorData {
+
+    private float heartRate_bpm;
+
+    public SensorDataHeartRate(String name, String address, float heartRate_bpm) {
+        super(name, address);
+        this.heartRate_bpm = heartRate_bpm;
+    }
+
+    public boolean hasHeartRate_bpm() {
+        return !Float.isNaN(heartRate_bpm);
+    }
+
+    public float getHeartRate_bpm() {
+        return heartRate_bpm;
+    }
+
+    @NonNull
+    @Override
+    public String toString() {
+        return "heart=" + heartRate_bpm;
+    }
+}

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

@@ -1,94 +1,75 @@
 package de.dennisguse.opentracks.content.sensor;
 
+import androidx.annotation.NonNull;
+
+import de.dennisguse.opentracks.content.data.TrackPoint;
+
 public final class SensorDataSet {
 
-    public static final float DATA_UNAVAILABLE = Float.NaN;
+    private SensorDataHeartRate heartRate;
 
-    //TODO It might be necessary to consider: if sensor was connected as well.
-    private String sensorName;
-    private String sensorAddress;
-    private float heartRate;
-    private float cadence;
-    private float power;
-    private float batteryLevel;
-    private long creationTimestamp;
+    private SensorDataCycling.Cadence cyclingCadence;
 
-    public SensorDataSet(float heartRate, float cadence, float power, float batteryLevel, long creationTimestamp) {
-        this.heartRate = heartRate;
-        this.cadence = cadence;
-        this.power = power;
-        this.batteryLevel = batteryLevel;
-        this.creationTimestamp = creationTimestamp;
+    private SensorDataCycling.Speed cyclingSpeed;
+
+    public SensorDataSet() {
     }
 
-    public SensorDataSet(float heartRate, float cadence, float power, float batteryLevel) {
-        this(heartRate, cadence, power, batteryLevel, System.currentTimeMillis());
-    }
-
-    public SensorDataSet(float heartRate, float cadence, float power) {
-        this(heartRate, cadence, power, DATA_UNAVAILABLE, System.currentTimeMillis());
-    }
-
-    public SensorDataSet(float heartRate, float cadence) {
-        this(heartRate, cadence, DATA_UNAVAILABLE, DATA_UNAVAILABLE, System.currentTimeMillis());
-    }
-
-    public SensorDataSet(float heartRate, String sensorName, String sensorAddress) {
-        this(heartRate, DATA_UNAVAILABLE, DATA_UNAVAILABLE, DATA_UNAVAILABLE, System.currentTimeMillis());
-        this.sensorName = sensorName;
-        this.sensorAddress = sensorAddress;
-    }
-
-    public boolean hasHeartRate() {
-        return !Float.isNaN(heartRate) && heartRate > 0;
-    }
-
-    public float getHeartRate() {
+    public SensorDataHeartRate getHeartRate() {
         return heartRate;
     }
 
-    public boolean hasCadence() {
-        return !Float.isNaN(cadence);
+    public SensorDataCycling.Cadence getCyclingCadence() {
+        return cyclingCadence;
     }
 
-    public float getCadence() {
-        return cadence;
+    public SensorDataCycling.Speed getCyclingSpeed() {
+        return cyclingSpeed;
     }
 
-    public boolean hasPower() {
-        return !Float.isNaN(power);
+    public void set(SensorData data) {
+        if (data instanceof SensorDataHeartRate) {
+            this.heartRate = (SensorDataHeartRate) data;
+            return;
+        }
+
+        if (data instanceof SensorDataCycling.Cadence) {
+            this.cyclingCadence = (SensorDataCycling.Cadence) data;
+            return;
+        }
+        if (data instanceof SensorDataCycling.Speed) {
+            this.cyclingSpeed = (SensorDataCycling.Speed) data;
+            return;
+        }
+
+        throw new UnsupportedOperationException();
     }
 
-    public float getPower() {
-        return power;
+    public void clear() {
+        this.heartRate = null;
+        this.cyclingCadence = null;
+        this.cyclingSpeed = null;
     }
 
-    public long getCreationTime() {
-        return creationTimestamp;
+    public void fillTrackPoint(TrackPoint trackPoint) {
+        if (heartRate != null) {
+            trackPoint.setHeartRate_bpm(heartRate.getHeartRate_bpm());
+        }
+
+        if (cyclingCadence != null && cyclingCadence.hasCadence_rpm()) {
+            trackPoint.setCyclingCadence_rpm(cyclingCadence.getCadence_rpm());
+        }
+
+        if (cyclingSpeed != null && cyclingSpeed.hasSpeed_mps()) {
+            trackPoint.setSpeed(cyclingSpeed.getSpeed_mps());
+        }
     }
 
-    /**
-     * Is the data recent considering the current time.
-     *
-     * @param maxAge the maximal age in milliseconds.
-     */
-    public boolean isRecent(long maxAge) {
-        return creationTimestamp + maxAge > System.currentTimeMillis();
-    }
-
-    public boolean hasBatteryLevel() {
-        return !Float.isNaN(batteryLevel);
-    }
-
-    public float getBatteryLevel() {
-        return batteryLevel;
-    }
-
-    public String getSensorName() {
-        return sensorName;
-    }
-
-    public String getSensorAddress() {
-        return sensorAddress;
+    @NonNull
+    @Override
+    public String toString() {
+        return (getHeartRate() != null ? "" + getHeartRate() : "")
+                + (getCyclingCadence() != null ? " " + getCyclingCadence() : "")
+                + (getCyclingSpeed() != null ? " " + getCyclingSpeed() : "");
     }
 }

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

@@ -1,29 +0,0 @@
-package de.dennisguse.opentracks.content.sensor;
-
-import android.content.Context;
-
-import de.dennisguse.opentracks.R;
-
-public enum SensorState {
-    NONE,
-    CONNECTING,
-    CONNECTED,
-    DISCONNECTING,
-    DISCONNECTED;
-
-    public static String getStateAsString(SensorState state, Context c) {
-        switch (state) {
-            case NONE:
-                return c.getString(R.string.value_none);
-            case CONNECTING:
-                return c.getString(R.string.sensor_state_connecting);
-            case CONNECTED:
-                return c.getString(R.string.sensor_state_connected);
-            case DISCONNECTING:
-            case DISCONNECTED:
-                return c.getString(R.string.sensor_state_disconnected);
-            default:
-                return "";
-        }
-    }
-}

src/main/java/de/dennisguse/opentracks/fragments/ChartFragment.java

@@ -32,7 +32,7 @@ import java.util.ArrayList;
 import java.util.List;
 
 import de.dennisguse.opentracks.R;
-import de.dennisguse.opentracks.TrackDetailActivity;
+import de.dennisguse.opentracks.TrackActivityDataHubInterface;
 import de.dennisguse.opentracks.chart.ChartPoint;
 import de.dennisguse.opentracks.chart.ChartView;
 import de.dennisguse.opentracks.content.TrackDataHub;
@@ -75,6 +75,7 @@ public class ChartFragment extends Fragment implements TrackDataListener {
 
     //TODO Why is this needed?
     private int recordingDistanceInterval;
+    private String category = "";
 
     // Modes of operation
     private boolean chartByDistance;
@@ -100,7 +101,7 @@ public class ChartFragment extends Fragment implements TrackDataListener {
                 }
             }
             if (PreferencesUtils.isKey(getContext(), R.string.stats_rate_key, key)) {
-                boolean reportSpeed = PreferencesUtils.isReportSpeed(getContext());
+                boolean reportSpeed = PreferencesUtils.isReportSpeed(getContext(), category);
                 if (reportSpeed != chartView.getReportSpeed()) {
                     chartView.setReportSpeed(reportSpeed);
                     chartView.applyReportSpeed();
@@ -193,8 +194,16 @@ public class ChartFragment extends Fragment implements TrackDataListener {
         if (isResumed()) {
             if (track == null || track.getTrackStatistics() == null) {
                 startTime = -1L;
+                category = "";
                 return;
             }
+
+            category = track.getCategory();
+            boolean reportSpeed = PreferencesUtils.isReportSpeed(getContext(), category);
+            if (reportSpeed != chartView.getReportSpeed()) {
+                chartView.setReportSpeed(reportSpeed);
+                chartView.applyReportSpeed();
+            }
             startTime = track.getTrackStatistics().getStartTime_ms();
         }
     }
@@ -277,7 +286,7 @@ public class ChartFragment extends Fragment implements TrackDataListener {
      * Needs to be synchronized because trackDataHub can be accessed by multiple threads.
      */
     private synchronized void resumeTrackDataHub() {
-        trackDataHub = ((TrackDetailActivity) getActivity()).getTrackDataHub();
+        trackDataHub = ((TrackActivityDataHubInterface) getActivity()).getTrackDataHub();
         trackDataHub.registerTrackDataListener(this, true, true, true, true);
     }
 
@@ -313,7 +322,7 @@ public class ChartFragment extends Fragment implements TrackDataListener {
     @VisibleForTesting
     ChartPoint createPendingPoint(@NonNull TrackPoint trackPoint) {
         trackStatisticsUpdater.addTrackPoint(trackPoint, recordingDistanceInterval);
-        return new ChartPoint(trackStatisticsUpdater, trackPoint.getSensorDataSet(), chartByDistance, chartView.getMetricUnits());
+        return new ChartPoint(trackStatisticsUpdater, trackPoint, chartByDistance, chartView.getMetricUnits());
     }
 
     @VisibleForTesting

src/main/java/de/dennisguse/opentracks/fragments/DeleteMarkerDialogFragment.java

@@ -85,7 +85,7 @@ public class DeleteMarkerDialogFragment extends DialogFragment {
                             public void run() {
                                 ContentProviderUtils contentProviderUtils = new ContentProviderUtils(fragmentActivity);
                                 for (long markerId : markerIds) {
-                                    contentProviderUtils.deleteWaypoint(markerId);
+                                    contentProviderUtils.deleteWaypoint(getContext(), markerId);
                                 }
                                 caller.onDeleteMarkerDone();
                             }

src/main/java/de/dennisguse/opentracks/fragments/FileTypeDialogFragment.java

@@ -1,126 +0,0 @@
-/*
- * Copyright 2013 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-
-package de.dennisguse.opentracks.fragments;
-
-import android.app.AlertDialog;
-import android.app.Dialog;
-import android.content.Context;
-import android.content.DialogInterface;
-import android.content.DialogInterface.OnClickListener;
-import android.os.Bundle;
-
-import androidx.annotation.NonNull;
-import androidx.fragment.app.DialogFragment;
-import androidx.fragment.app.FragmentManager;
-
-import java.util.Locale;
-
-import de.dennisguse.opentracks.R;
-import de.dennisguse.opentracks.io.file.TrackFileFormat;
-
-/**
- * A DialogFragment to select a file type, gpx, kml, etc.
- *
- * @author Jimmy Shih
- */
-public class FileTypeDialogFragment extends DialogFragment {
-
-    private static final String FILE_TYPE_DIALOG_TAG = "fileType";
-    private static final String KEY_TITLE_ID = "titleId";
-    private static final String KEY_OPTION_ID = "optionId";
-
-    private FileTypeCaller caller;
-
-    public static void showDialog(FragmentManager fragmentManager, int titleId, int optionId) {
-        Bundle bundle = new Bundle();
-        bundle.putInt(KEY_TITLE_ID, titleId);
-        bundle.putInt(KEY_OPTION_ID, optionId);
-
-        FileTypeDialogFragment fileTypeDialogFragment = new FileTypeDialogFragment();
-        fileTypeDialogFragment.setArguments(bundle);
-        fileTypeDialogFragment.show(fragmentManager, FILE_TYPE_DIALOG_TAG);
-    }
-
-    @Override
-    public void onAttach(@NonNull Context context) {
-        super.onAttach(context);
-        try {
-            caller = (FileTypeCaller) context;
-        } catch (ClassCastException e) {
-            throw new ClassCastException(context + " must implement " + FileTypeCaller.class.getSimpleName());
-        }
-    }
-
-    @Override
-    @NonNull
-    public Dialog onCreateDialog(Bundle savedInstanceState) {
-        int optionId = getArguments().getInt(KEY_OPTION_ID);
-        final int titleId = getArguments().getInt(KEY_TITLE_ID);
-
-        final TrackFileFormat[] trackFileFormats = {TrackFileFormat.KMZ_WITH_TRACKDETAIL_AND_SENSORDATA_AND_PICTURES, TrackFileFormat.KMZ_WITH_TRACKDETAIL_AND_SENSORDATA, TrackFileFormat.KML_WITH_TRACKDETAIL_AND_SENSORDATA, TrackFileFormat.GPX};
-        String[] choices = new String[trackFileFormats.length];
-        for (int i = 0; i < choices.length; i++) {
-            TrackFileFormat trackFileFormat = trackFileFormats[i];
-            String trackFileFormatUpperCase = trackFileFormat.getExtension().toUpperCase(Locale.US); //ASCII upper case
-            int photoMessageId = trackFileFormat.includesPhotos() ? R.string.export_with_photos : R.string.export_without_photos;
-            String trackFileFormatDisplayName = String.format("%s (%s)", trackFileFormatUpperCase, getString(photoMessageId));
-            choices[i] = getString(optionId, trackFileFormatDisplayName);
-        }
-        return new AlertDialog.Builder(getActivity())
-                .setNegativeButton(R.string.generic_cancel, new OnClickListener() {
-                    @Override
-                    public void onClick(DialogInterface dialog, int which) {
-                        onDismissed();
-                    }
-                })
-                .setPositiveButton(R.string.generic_ok, new OnClickListener() {
-                    @Override
-                    public void onClick(DialogInterface dialog, int which) {
-                        int position = ((AlertDialog) dialog).getListView().getCheckedItemPosition();
-                        caller.onFileTypeDone(trackFileFormats[position]);
-                    }
-                })
-                .setSingleChoiceItems(choices, 0, null)
-                .setTitle(titleId)
-                .create();
-    }
-
-    @Override
-    public void onCancel(@NonNull DialogInterface dialog) {
-        onDismissed();
-    }
-
-    private void onDismissed() {
-        dismiss();
-        caller.onDismissed();
-    }
-
-    /**
-     * Interface for caller of this dialog fragment.
-     *
-     * @author Jimmy Shih
-     */
-    public interface FileTypeCaller {
-
-        /**
-         * Called when file type selection is done.
-         */
-        void onFileTypeDone(TrackFileFormat trackFileFormat);
-
-        void onDismissed();
-    }
-}

src/main/java/de/dennisguse/opentracks/fragments/StatisticsRecordedFragment.java

@@ -0,0 +1,310 @@
+/*
+ * Copyright 2008 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package de.dennisguse.opentracks.fragments;
+
+import android.content.SharedPreferences;
+import android.os.Bundle;
+import android.util.Pair;
+import android.view.KeyEvent;
+import android.view.LayoutInflater;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.Spinner;
+import android.widget.TextView;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.Fragment;
+
+import de.dennisguse.opentracks.R;
+import de.dennisguse.opentracks.TrackRecordedActivity;
+import de.dennisguse.opentracks.content.TrackDataHub;
+import de.dennisguse.opentracks.content.TrackDataListener;
+import de.dennisguse.opentracks.content.data.Track;
+import de.dennisguse.opentracks.content.data.TrackPoint;
+import de.dennisguse.opentracks.content.data.Waypoint;
+import de.dennisguse.opentracks.stats.TrackStatistics;
+import de.dennisguse.opentracks.util.PreferencesUtils;
+import de.dennisguse.opentracks.util.StringUtils;
+import de.dennisguse.opentracks.util.TrackIconUtils;
+
+/**
+ * A fragment to display track statistics to the user.
+ *
+ * @author Sandor Dornbush
+ * @author Rodrigo Damazio
+ */
+public class StatisticsRecordedFragment extends Fragment implements TrackDataListener {
+
+    private TrackStatistics trackStatistics = null;
+    private String category = "";
+
+    private final SharedPreferences.OnSharedPreferenceChangeListener sharedPreferenceChangeListener = new SharedPreferences.OnSharedPreferenceChangeListener() {
+        @Override
+        public void onSharedPreferenceChanged(SharedPreferences preferences, String key) {
+            if (PreferencesUtils.isKey(getContext(), R.string.stats_units_key, key) || PreferencesUtils.isKey(getContext(), R.string.stats_rate_key, key)) {
+                if (isResumed()) {
+                    getActivity().runOnUiThread(new Runnable() {
+                        @Override
+                        public void run() {
+                            if (isResumed()) {
+                                updateUI();
+                            }
+                        }
+                    });
+                }
+            }
+        }
+    };
+
+    @Override
+    public View onCreateView(@NonNull LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+        return inflater.inflate(R.layout.statistics_recorded, container, false);
+    }
+
+    /* Views */
+    private TextView totalTimeValueView;
+    private TextView distanceValue;
+    private TextView distanceUnit;
+    private View activityLabel;
+    private Spinner activitySpinner;
+    private TextView movingTimeValue;
+    private TextView speedAvgLabel;
+    private TextView speedAvgValue;
+    private TextView speedAvgUnit;
+    private TextView speedMaxLabel;
+    private TextView speedMaxValue;
+    private TextView speedMaxUnit;
+    private TextView speedMovingLabel;
+    private TextView speedMovingValue;
+    private TextView speedMovingUnit;
+
+    @Override
+    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
+        super.onViewCreated(view, savedInstanceState);
+
+        totalTimeValueView = view.findViewById(R.id.stats_total_time_value);
+
+        distanceValue = view.findViewById(R.id.stats_distance_value);
+        distanceUnit = view.findViewById(R.id.stats_distance_unit);
+
+        activityLabel = view.findViewById(R.id.stats_activity_type_label);
+        activitySpinner = view.findViewById(R.id.stats_activity_type_icon);
+
+        movingTimeValue = view.findViewById(R.id.stats_moving_time_value);
+
+        speedAvgLabel = view.findViewById(R.id.stats_average_speed_label);
+        speedAvgValue = view.findViewById(R.id.stats_average_speed_value);
+        speedAvgUnit = view.findViewById(R.id.stats_average_speed_unit);
+
+        speedMaxLabel = view.findViewById(R.id.stats_max_speed_label);
+        speedMaxValue = view.findViewById(R.id.stats_max_speed_value);
+        speedMaxUnit = view.findViewById(R.id.stats_max_speed_unit);
+
+        speedMovingLabel = view.findViewById(R.id.stats_moving_speed_label);
+        speedMovingValue = view.findViewById(R.id.stats_moving_speed_value);
+        speedMovingUnit = view.findViewById(R.id.stats_moving_speed_unit);
+    }
+
+    @Override
+    public void onActivityCreated(Bundle savedInstanceState) {
+        super.onActivityCreated(savedInstanceState);
+
+        Spinner activityTypeIcon = getView().findViewById(R.id.stats_activity_type_icon);
+        activityTypeIcon.setAdapter(TrackIconUtils.getIconSpinnerAdapter(getActivity(), ""));
+        activityTypeIcon.setOnTouchListener(new View.OnTouchListener() {
+            @Override
+            public boolean onTouch(View v, MotionEvent event) {
+                if (event.getAction() == MotionEvent.ACTION_UP) {
+                    ((TrackRecordedActivity) getActivity()).chooseActivityType(category);
+                }
+                return true;
+            }
+        });
+        activityTypeIcon.setOnKeyListener(new View.OnKeyListener() {
+            @Override
+            public boolean onKey(View v, int keyCode, KeyEvent event) {
+                if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER) {
+                    ((TrackRecordedActivity) getActivity()).chooseActivityType(category);
+                }
+                return true;
+            }
+        });
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        PreferencesUtils.register(getContext(), sharedPreferenceChangeListener);
+
+        TrackDataHub trackDataHub = ((TrackRecordedActivity) getActivity()).getTrackDataHub();
+        trackDataHub.registerTrackDataListener(this, true, false, true, true);
+    }
+
+    @Override
+    public void onPause() {
+        super.onPause();
+        PreferencesUtils.unregister(getContext(), sharedPreferenceChangeListener);
+
+        TrackDataHub trackDataHub = ((TrackRecordedActivity) getActivity()).getTrackDataHub();
+        trackDataHub.unregisterTrackDataListener(this);
+    }
+
+    @Override
+    public void onDestroyView() {
+        super.onDestroyView();
+
+        totalTimeValueView = null;
+
+        distanceValue = null;
+        distanceUnit = null;
+
+        activityLabel = null;
+        activitySpinner = null;
+
+        movingTimeValue = null;
+
+        speedAvgLabel = null;
+        speedAvgValue = null;
+        speedAvgUnit = null;
+
+        speedMaxLabel = null;
+        speedMaxValue = null;
+        speedMaxUnit = null;
+
+        speedMovingLabel = null;
+        speedMovingValue = null;
+        speedMovingUnit = null;
+    }
+
+    @Override
+    public void onTrackUpdated(final Track track) {
+        if (isResumed()) {
+            getActivity().runOnUiThread(new Runnable() {
+                @Override
+                public void run() {
+                    if (isResumed()) {
+                        trackStatistics = track != null ? track.getTrackStatistics() : null;
+                        category = track != null ? track.getCategory() : "";
+                        updateUI();
+                    }
+                }
+            });
+        }
+    }
+
+    @Override
+    public void clearTrackPoints() {
+        // We don't care.
+    }
+
+    @Override
+    public void onSampledInTrackPoint(TrackPoint trackPoint) {
+        // We don't care.
+    }
+
+    @Override
+    public void onSampledOutTrackPoint(TrackPoint trackPoint) {
+        // We don't care.
+    }
+
+    @Override
+    public void onNewTrackPointsDone() {
+        // We don't care.
+    }
+
+    @Override
+    public void clearWaypoints() {
+        // We don't care.
+    }
+
+    @Override
+    public void onNewWaypoint(Waypoint wpt) {
+        // We don't care.
+    }
+
+    @Override
+    public void onNewWaypointsDone() {
+        // We don't care.
+    }
+
+    private void updateUI() {
+        String trackIconValue = TrackIconUtils.getIconValue(getContext(), category);
+
+        boolean metricUnits = PreferencesUtils.isMetricUnits(getContext());
+        boolean reportSpeed = PreferencesUtils.isReportSpeed(getContext(), category);
+
+        // Set total distance
+        {
+            double totalDistance = trackStatistics == null ? Double.NaN : trackStatistics.getTotalDistance();
+            Pair<String, String> parts = StringUtils.getDistanceParts(getContext(), totalDistance, metricUnits);
+
+            distanceValue.setText(parts.first);
+            distanceUnit.setText(parts.second);
+        }
+
+        // Set activity type
+        {
+            activityLabel.setVisibility(trackIconValue != null ? View.VISIBLE : View.GONE);
+
+            activitySpinner.setVisibility(trackIconValue != null ? View.VISIBLE : View.GONE);
+            activitySpinner.setEnabled(false);
+            if (trackIconValue != null) {
+                TrackIconUtils.setIconSpinner(activitySpinner, trackIconValue);
+            }
+        }
+
+        // Set time and start datetime
+        if (trackStatistics != null) {
+            movingTimeValue.setText(StringUtils.formatElapsedTime(trackStatistics.getMovingTime()));
+            totalTimeValueView.setText(StringUtils.formatElapsedTime(trackStatistics.getTotalTime()));
+        }
+
+        // Set average speed/pace
+        {
+            double speed = trackStatistics != null ? trackStatistics.getAverageSpeed() : Double.NaN;
+            speedAvgLabel.setText(reportSpeed ? R.string.stats_average_speed : R.string.stats_average_pace);
+
+            Pair<String, String> parts = StringUtils.getSpeedParts(getContext(), speed, metricUnits, reportSpeed);
+            speedAvgValue.setText(parts.first);
+            speedAvgUnit.setText(parts.second);
+        }
+
+        // Set max speed/pace
+        {
+            double speed = trackStatistics == null ? Double.NaN : trackStatistics.getMaxSpeed();
+
+            speedMaxLabel.setText(reportSpeed ? R.string.stats_max_speed : R.string.stats_fastest_pace);
+
+            Pair<String, String> parts = StringUtils.getSpeedParts(getContext(), speed, metricUnits, reportSpeed);
+            speedMaxValue.setText(parts.first);
+            speedMaxUnit.setText(parts.second);
+        }
+
+        // Set moving speed/pace
+        {
+            double speed = trackStatistics != null ? trackStatistics.getAverageMovingSpeed() : Double.NaN;
+
+            speedMovingLabel.setText(reportSpeed ? R.string.stats_average_moving_speed : R.string.stats_average_moving_pace);
+
+            Pair<String, String> parts = StringUtils.getSpeedParts(getContext(), speed, metricUnits, reportSpeed);
+            speedMovingValue.setText(parts.first);
+            speedMovingUnit.setText(parts.second);
+        }
+    }
+}

src/main/java/de/dennisguse/opentracks/fragments/StatisticsRecordingFragment.java

@@ -1,19 +1,3 @@
-/*
- * Copyright 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-
 package de.dennisguse.opentracks.fragments;
 
 import android.content.SharedPreferences;
@@ -31,24 +15,27 @@ import android.widget.TextView;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
+import androidx.constraintlayout.widget.Group;
 import androidx.fragment.app.Fragment;
 
 import de.dennisguse.opentracks.R;
-import de.dennisguse.opentracks.TrackDetailActivity;
+import de.dennisguse.opentracks.TrackRecordingActivity;
 import de.dennisguse.opentracks.content.TrackDataHub;
 import de.dennisguse.opentracks.content.TrackDataListener;
 import de.dennisguse.opentracks.content.data.Track;
 import de.dennisguse.opentracks.content.data.TrackPoint;
 import de.dennisguse.opentracks.content.data.Waypoint;
+import de.dennisguse.opentracks.content.sensor.SensorDataCycling;
+import de.dennisguse.opentracks.content.sensor.SensorDataHeartRate;
 import de.dennisguse.opentracks.content.sensor.SensorDataSet;
 import de.dennisguse.opentracks.services.TrackRecordingServiceConnection;
 import de.dennisguse.opentracks.services.TrackRecordingServiceInterface;
-import de.dennisguse.opentracks.services.sensors.BluetoothRemoteSensorManager;
 import de.dennisguse.opentracks.stats.TrackStatistics;
 import de.dennisguse.opentracks.util.LocationUtils;
 import de.dennisguse.opentracks.util.PreferencesUtils;
 import de.dennisguse.opentracks.util.StringUtils;
 import de.dennisguse.opentracks.util.TrackIconUtils;
+import de.dennisguse.opentracks.util.TrackPointUtils;
 import de.dennisguse.opentracks.util.UnitConversions;
 
 /**
@@ -57,9 +44,9 @@ import de.dennisguse.opentracks.util.UnitConversions;
  * @author Sandor Dornbush
  * @author Rodrigo Damazio
  */
-public class StatsFragment extends Fragment implements TrackDataListener {
+public class StatisticsRecordingFragment extends Fragment implements TrackDataListener {
 
-    private static final String STATS_FRAGMENT_TAG = StatsFragment.class.getSimpleName();
+    private static final String TAG = StatisticsRecordingFragment.class.getSimpleName();
 
     private static final long UI_UPDATE_INTERVAL = UnitConversions.ONE_SECOND_MS;
 
@@ -109,13 +96,17 @@ public class StatsFragment extends Fragment implements TrackDataListener {
 
     @Override
     public View onCreateView(@NonNull LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
-        return inflater.inflate(R.layout.stats, container, false);
+        return inflater.inflate(R.layout.statistics_recording, container, false);
     }
 
     /* Views */
-    private View sensorContainerView;
+    private View sensorHorizontalLine;
+    private Group heartRateGroup;
     private TextView heartRateValueView;
     private TextView heartRateSensorView;
+    private Group cadenceGroup;
+    private TextView cadenceValueView;
+    private TextView cadenceSensorView;
 
     private TextView totalTimeValueView;
     private final Runnable updateUIeachSecond = new Runnable() {
@@ -144,16 +135,13 @@ public class StatsFragment extends Fragment implements TrackDataListener {
     private TextView speedMovingLabel;
     private TextView speedMovingValue;
     private TextView speedMovingUnit;
-    private View elevationSeparator;
-    private View elevationContainer;
-    private View speedContainer;
+    private Group elevationGroup;
     private TextView speedLabel;
     private TextView speedValue;
     private TextView speedUnit;
     private TextView elevationValue;
     private TextView elevationUnit;
-    private View coordinateSeparator;
-    private View coordinateContainer;
+    private Group coordinateGroup;
     private TextView latitudeValue;
     private TextView longitudeValue;
 
@@ -161,10 +149,16 @@ public class StatsFragment extends Fragment implements TrackDataListener {
     public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
         super.onViewCreated(view, savedInstanceState);
 
-        sensorContainerView = view.findViewById(R.id.stats_sensor_container);
+        sensorHorizontalLine = view.findViewById(R.id.stats_sensor_horizontal_line);
+
+        heartRateGroup = view.findViewById(R.id.stats_sensor_heart_rate_group);
         heartRateValueView = view.findViewById(R.id.stats_sensor_heart_rate_value);
         heartRateSensorView = view.findViewById(R.id.stats_sensor_heart_rate_sensor_value);
 
+        cadenceGroup = view.findViewById(R.id.stats_sensor_cadence_group);
+        cadenceValueView = view.findViewById(R.id.stats_sensor_cadence_value);
+        cadenceSensorView = view.findViewById(R.id.stats_sensor_cadence_sensor_value);
+
         totalTimeValueView = view.findViewById(R.id.stats_total_time_value);
 
         distanceValue = view.findViewById(R.id.stats_distance_value);
@@ -187,10 +181,8 @@ public class StatsFragment extends Fragment implements TrackDataListener {
         speedMovingValue = view.findViewById(R.id.stats_moving_speed_value);
         speedMovingUnit = view.findViewById(R.id.stats_moving_speed_unit);
 
-        elevationSeparator = view.findViewById(R.id.stats_elevation_separator);
-        elevationContainer = view.findViewById(R.id.stats_elevation_container);
+        elevationGroup = view.findViewById(R.id.stats_elevation_current_group);
 
-        speedContainer = view.findViewById(R.id.stats_speed);
         speedLabel = view.findViewById(R.id.stats_speed_label);
         speedValue = view.findViewById(R.id.stats_speed_value);
         speedUnit = view.findViewById(R.id.stats_speed_unit);
@@ -198,8 +190,7 @@ public class StatsFragment extends Fragment implements TrackDataListener {
         elevationValue = view.findViewById(R.id.stats_elevation_current_value);
         elevationUnit = view.findViewById(R.id.stats_elevation_current_unit);
 
-        coordinateSeparator = view.findViewById(R.id.stats_coordinate_separator);
-        coordinateContainer = view.findViewById(R.id.stats_coordinate_container);
+        coordinateGroup = view.findViewById(R.id.stats_coordinate_group);
 
         latitudeValue = view.findViewById(R.id.stats_latitude_value);
         longitudeValue = view.findViewById(R.id.stats_longitude_value);
@@ -219,7 +210,7 @@ public class StatsFragment extends Fragment implements TrackDataListener {
             @Override
             public boolean onTouch(View v, MotionEvent event) {
                 if (event.getAction() == MotionEvent.ACTION_UP) {
-                    ((TrackDetailActivity) getActivity()).chooseActivityType(category);
+                    ((TrackRecordingActivity) getActivity()).chooseActivityType(category);
                 }
                 return true;
             }
@@ -228,7 +219,7 @@ public class StatsFragment extends Fragment implements TrackDataListener {
             @Override
             public boolean onKey(View v, int keyCode, KeyEvent event) {
                 if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER) {
-                    ((TrackDetailActivity) getActivity()).chooseActivityType(category);
+                    ((TrackRecordingActivity) getActivity()).chooseActivityType(category);
                 }
                 return true;
             }
@@ -268,9 +259,14 @@ public class StatsFragment extends Fragment implements TrackDataListener {
     @Override
     public void onDestroyView() {
         super.onDestroyView();
-        sensorContainerView = null;
+        sensorHorizontalLine = null;
+
+        heartRateGroup = null;
         heartRateValueView = null;
         heartRateSensorView = null;
+        cadenceGroup = null;
+        cadenceValueView = null;
+        cadenceSensorView = null;
 
         totalTimeValueView = null;
 
@@ -294,10 +290,8 @@ public class StatsFragment extends Fragment implements TrackDataListener {
         speedMovingValue = null;
         speedMovingUnit = null;
 
-        elevationSeparator = null;
-        elevationContainer = null;
+        elevationGroup = null;
 
-        speedContainer = null;
         speedLabel = null;
         speedValue = null;
         speedUnit = null;
@@ -305,8 +299,7 @@ public class StatsFragment extends Fragment implements TrackDataListener {
         elevationValue = null;
         elevationUnit = null;
 
-        coordinateSeparator = null;
-        coordinateContainer = null;
+        coordinateGroup = null;
 
         latitudeValue = null;
         longitudeValue = null;
@@ -356,7 +349,7 @@ public class StatsFragment extends Fragment implements TrackDataListener {
 
                         if (lastTrackPoint != null) {
                             boolean hasFix = !LocationUtils.isLocationOld(lastTrackPoint.getLocation());
-                            boolean hasGoodFix = lastTrackPoint.hasAccuracy() && lastTrackPoint.getAccuracy() < recordingGpsAccuracy;
+                            boolean hasGoodFix = TrackPointUtils.fulfillsAccuracy(lastTrackPoint, recordingGpsAccuracy);
 
                             if (!hasFix || !hasGoodFix) {
                                 lastTrackPoint = null;
@@ -389,7 +382,7 @@ public class StatsFragment extends Fragment implements TrackDataListener {
      * Needs to be synchronized because trackDataHub can be accessed by multiple threads.
      */
     private synchronized void resumeTrackDataHub() {
-        trackDataHub = ((TrackDetailActivity) getActivity()).getTrackDataHub();
+        trackDataHub = ((TrackRecordingActivity) getActivity()).getTrackDataHub();
         trackDataHub.registerTrackDataListener(this, true, false, true, true);
     }
 
@@ -425,42 +418,88 @@ public class StatsFragment extends Fragment implements TrackDataListener {
     }
 
     /**
-     * Tries to fetch most recent {@link SensorDataSet} {@link de.dennisguse.opentracks.services.sensors.BluetoothRemoteSensorManager}.
+     * Tries to fetch most recent {@link SensorDataSet} from {@link de.dennisguse.opentracks.services.TrackRecordingService}.
      */
     private void updateSensorDataUI() {
         TrackRecordingServiceInterface trackRecordingService = trackRecordingServiceConnection.getServiceIfBound();
 
         SensorDataSet sensorDataSet = null;
         if (trackRecordingService == null) {
-            Log.d(STATS_FRAGMENT_TAG, "Cannot get the track recording service.");
+            Log.d(TAG, "Cannot get the track recording service.");
         } else {
-            //TODO sensorState = trackRecordingService.getSensorState();
             sensorDataSet = trackRecordingService.getSensorData();
         }
 
-        setHeartRateSensorData(sensorDataSet, isSelectedTrackRecording());
+        setHeartRateSensorData(sensorDataSet);
+        setCadenceSensorData(sensorDataSet);
+        setSpeedSensorData(sensorDataSet, isSelectedTrackRecording());
     }
 
-    private void setHeartRateSensorData(SensorDataSet sensorDataSet, boolean isRecording) {
-        // heart rate
+    private void setHeartRateSensorData(SensorDataSet sensorDataSet) {
         int isVisible = View.VISIBLE;
-        if (!isRecording || PreferencesUtils.isBluetoothHeartRateSensorAddressDefault(getContext())) {
-            isVisible = View.INVISIBLE;
+        if (PreferencesUtils.isBluetoothHeartRateSensorAddressNone(getContext())) {
+            isVisible = View.GONE;
         }
-        sensorContainerView.setVisibility(isVisible);
+        heartRateGroup.setVisibility(isVisible);
+        setVisibilitySensorHorizontalLine();
 
+        String sensorValue = getContext().getString(R.string.value_unknown);
+        String sensorName = getContext().getString(R.string.value_unknown);
+        if (sensorDataSet != null && sensorDataSet.getHeartRate() != null) {
+            SensorDataHeartRate data = sensorDataSet.getHeartRate();
+
+            sensorName = data.getSensorName();
+            if (data.hasHeartRate_bpm() && data.isRecent()) {
+                sensorValue = StringUtils.formatDecimal(data.getHeartRate_bpm(), 0);
+            }
+        }
+
+        heartRateSensorView.setText(sensorName);
+        heartRateValueView.setText(sensorValue);
+    }
+
+    private void setCadenceSensorData(SensorDataSet sensorDataSet) {
+        int isVisible = View.VISIBLE;
+        if (PreferencesUtils.isBluetoothCyclingCadenceSensorAddressNone(getContext())) {
+            isVisible = View.GONE;
+        }
+        cadenceGroup.setVisibility(isVisible);
+        setVisibilitySensorHorizontalLine();
+
+        String sensorValue = getContext().getString(R.string.value_unknown);
+        String sensorName = getContext().getString(R.string.value_unknown);
+        if (sensorDataSet != null && sensorDataSet.getCyclingCadence() != null) {
+            SensorDataCycling.Cadence data = sensorDataSet.getCyclingCadence();
+            sensorName = data.getSensorName();
+
+            if (data.hasCadence_rpm() && data.isRecent()) {
+                sensorValue = StringUtils.formatDecimal(data.getCadence_rpm(), 0);
+            }
+        }
+
+        cadenceSensorView.setText(sensorName);
+        cadenceValueView.setText(sensorValue);
+    }
+
+    /**
+     * If cadence and hear rate groups are invisible then sensor horizontal line hast to be invisible too.
+     */
+    private void setVisibilitySensorHorizontalLine() {
+        if (cadenceGroup.getVisibility() != View.VISIBLE && heartRateGroup.getVisibility() != View.VISIBLE) {
+            sensorHorizontalLine.setVisibility(View.GONE);
+        }
+
+    }
+
+    private void setSpeedSensorData(SensorDataSet sensorDataSet, boolean isRecording) {
         if (isRecording) {
-            String heartRate = getContext().getString(R.string.value_unknown);
-            String sensorName = getContext().getString(R.string.value_unknown);
-            if (sensorDataSet != null && sensorDataSet.isRecent(BluetoothRemoteSensorManager.MAX_SENSOR_DATE_SET_AGE_MS)) {
-                sensorName = sensorDataSet.getSensorName();
-                if (sensorDataSet.hasHeartRate()) {
-                    heartRate = StringUtils.formatDecimal(sensorDataSet.getHeartRate(), 0);
+            if (sensorDataSet != null && sensorDataSet.getCyclingSpeed() != null) {
+                SensorDataCycling.Speed data = sensorDataSet.getCyclingSpeed();
+
+                if (data.hasSpeed_mps() && data.isRecent()) {
+                    setSpeed(data.getSpeed_mps());
                 }
             }
-
-            heartRateSensorView.setText(sensorName);
-            heartRateValueView.setText(heartRate);
         }
     }
 
@@ -468,7 +507,7 @@ public class StatsFragment extends Fragment implements TrackDataListener {
         String trackIconValue = TrackIconUtils.getIconValue(getContext(), category);
 
         boolean metricUnits = PreferencesUtils.isMetricUnits(getContext());
-        boolean reportSpeed = PreferencesUtils.isReportSpeed(getContext());
+        boolean reportSpeed = PreferencesUtils.isReportSpeed(getContext(), category);
         boolean isRecording = isSelectedTrackRecording();
 
         // Set total distance
@@ -532,7 +571,7 @@ public class StatsFragment extends Fragment implements TrackDataListener {
         // Make elevation visible?
         {
             boolean showElevation = PreferencesUtils.isShowStatsElevation(getContext());
-            elevationSeparator.setVisibility(showElevation ? View.VISIBLE : View.GONE);
+            elevationGroup.setVisibility(showElevation ? View.VISIBLE : View.GONE);
         }
     }
 
@@ -561,23 +600,14 @@ public class StatsFragment extends Fragment implements TrackDataListener {
 
     private void setLocationValues() {
         boolean metricUnits = PreferencesUtils.isMetricUnits(getContext());
-        boolean reportSpeed = PreferencesUtils.isReportSpeed(getContext());
-        boolean isRecording = isSelectedTrackRecording();
 
         // Set speed/pace
-        speedContainer.setVisibility(isRecording ? View.VISIBLE : View.INVISIBLE);
-        if (isRecording) {
-            speedLabel.setText(reportSpeed ? R.string.stats_speed : R.string.stats_pace);
-
-            double speed = lastTrackPoint != null && lastTrackPoint.hasSpeed() ? lastTrackPoint.getSpeed() : Double.NaN;
-            Pair<String, String> parts = StringUtils.getSpeedParts(getContext(), speed, metricUnits, reportSpeed);
-            speedValue.setText(parts.first);
-            speedUnit.setText(parts.second);
-        }
+        double speed = lastTrackPoint != null && lastTrackPoint.hasSpeed() ? lastTrackPoint.getSpeed() : Double.NaN;
+        setSpeed(speed);
 
         // Set elevation
-        boolean showElevation = isRecording && PreferencesUtils.isShowStatsElevation(getContext());
-        elevationContainer.setVisibility(showElevation ? View.VISIBLE : View.GONE);
+        boolean showElevation = PreferencesUtils.isShowStatsElevation(getContext());
+        elevationGroup.setVisibility(showElevation ? View.VISIBLE : View.GONE);
 
         if (showElevation) {
             double altitude = lastTrackPoint != null && lastTrackPoint.hasAltitude() ? lastTrackPoint.getAltitude() : Double.NaN;
@@ -588,10 +618,9 @@ public class StatsFragment extends Fragment implements TrackDataListener {
         }
 
         // Set coordinate
-        boolean showCoordinate = isRecording && PreferencesUtils.isStatsShowCoordinate(getContext());
+        boolean showCoordinate = PreferencesUtils.isStatsShowCoordinate(getContext());
 
-        coordinateSeparator.setVisibility(showCoordinate ? View.VISIBLE : View.GONE);
-        coordinateContainer.setVisibility(showCoordinate ? View.VISIBLE : View.GONE);
+        coordinateGroup.setVisibility(showCoordinate ? View.VISIBLE : View.GONE);
         if (showCoordinate) {
             double latitude = lastTrackPoint != null ? lastTrackPoint.getLatitude() : Double.NaN;
             String latitudeText = Double.isNaN(latitude) || Double.isInfinite(latitude) ? getContext().getString(R.string.value_unknown) : StringUtils.formatCoordinate(latitude);
@@ -602,4 +631,15 @@ public class StatsFragment extends Fragment implements TrackDataListener {
             longitudeValue.setText(longitudeText);
         }
     }
+
+    private void setSpeed(double speed) {
+        boolean metricUnits = PreferencesUtils.isMetricUnits(getContext());
+        boolean reportSpeed = PreferencesUtils.isReportSpeed(getContext(), category);
+
+        speedLabel.setText(reportSpeed ? R.string.stats_speed : R.string.stats_pace);
+
+        Pair<String, String> parts = StringUtils.getSpeedParts(getContext(), speed, metricUnits, reportSpeed);
+        speedValue.setText(parts.first);
+        speedUnit.setText(parts.second);
+    }
 }

src/main/java/de/dennisguse/opentracks/io/file/TrackFileFormat.java

@@ -12,7 +12,6 @@ import de.dennisguse.opentracks.io.file.exporter.GpxTrackWriter;
 import de.dennisguse.opentracks.io.file.exporter.KmlTrackWriter;
 import de.dennisguse.opentracks.io.file.exporter.KmzTrackExporter;
 import de.dennisguse.opentracks.io.file.exporter.TrackExporter;
-import de.dennisguse.opentracks.io.file.exporter.TrackExporterListener;
 import de.dennisguse.opentracks.io.file.exporter.TrackWriter;
 
 /**
@@ -74,8 +73,8 @@ public enum TrackFileFormat {
             return new KmlTrackWriter(context, multiple, false, false, exportPhotos);
         }
 
-        public TrackExporter newTrackExporter(Context context, Track[] tracks, TrackExporterListener trackExporterListener) {
-            return newKmzTrackExporter(context, this.newTrackWriter(context, tracks.length > 1), tracks, trackExporterListener, exportPhotos);
+        public TrackExporter newTrackExporter(Context context, Track[] tracks) {
+            return newKmzTrackExporter(context, this.newTrackWriter(context, tracks.length > 1), tracks, exportPhotos);
         }
 
         @Override
@@ -101,8 +100,8 @@ public enum TrackFileFormat {
             return new KmlTrackWriter(context, multiple, true, false, exportPhotos);
         }
 
-        public TrackExporter newTrackExporter(Context context, Track[] tracks, TrackExporterListener trackExporterListener) {
-            return newKmzTrackExporter(context, this.newTrackWriter(context, tracks.length > 1), tracks, trackExporterListener, exportPhotos);
+        public TrackExporter newTrackExporter(Context context, Track[] tracks) {
+            return newKmzTrackExporter(context, this.newTrackWriter(context, tracks.length > 1), tracks, exportPhotos);
         }
 
         @Override
@@ -134,8 +133,8 @@ public enum TrackFileFormat {
             return MIME_KMZ;
         }
 
-        public TrackExporter newTrackExporter(Context context, Track[] tracks, TrackExporterListener trackExporterListener) {
-            return newKmzTrackExporter(context, this.newTrackWriter(context, tracks.length > 1), tracks, trackExporterListener, exportPhotos);
+        public TrackExporter newTrackExporter(Context context, Track[] tracks) {
+            return newKmzTrackExporter(context, this.newTrackWriter(context, tracks.length > 1), tracks, exportPhotos);
         }
 
         public String getExtension() {
@@ -163,8 +162,8 @@ public enum TrackFileFormat {
             return MIME_KMZ;
         }
 
-        public TrackExporter newTrackExporter(Context context, Track[] tracks, TrackExporterListener trackExporterListener) {
-            return newKmzTrackExporter(context, newTrackWriter(context, tracks.length > 1), tracks, trackExporterListener, exportPhotos);
+        public TrackExporter newTrackExporter(Context context, Track[] tracks) {
+            return newKmzTrackExporter(context, newTrackWriter(context, tracks.length > 1), tracks, exportPhotos);
         }
 
         public String getExtension() {
@@ -197,10 +196,10 @@ public enum TrackFileFormat {
 
     private static final String MIME_KML = "application/vnd.google-earth.kml+xml";
 
-    private static TrackExporter newKmzTrackExporter(Context context, TrackWriter trackWriter, Track[] tracks, TrackExporterListener trackExporterListener, boolean exportPhotos) {
+    private static TrackExporter newKmzTrackExporter(Context context, TrackWriter trackWriter, Track[] tracks, boolean exportPhotos) {
         ContentProviderUtils contentProviderUtils = new ContentProviderUtils(context);
 
-        FileTrackExporter fileTrackExporter = new FileTrackExporter(contentProviderUtils, trackWriter, tracks, trackExporterListener);
+        FileTrackExporter fileTrackExporter = new FileTrackExporter(contentProviderUtils, trackWriter, tracks);
 
         return new KmzTrackExporter(contentProviderUtils, fileTrackExporter, tracks, exportPhotos);
     }
@@ -210,10 +209,10 @@ public enum TrackFileFormat {
      */
     public abstract String getMimeType();
 
-    public TrackExporter newTrackExporter(Context context, Track[] tracks, TrackExporterListener trackExporterListener) {
+    public TrackExporter newTrackExporter(Context context, Track[] tracks) {
         ContentProviderUtils contentProviderUtils = new ContentProviderUtils(context);
         TrackWriter trackWriter = newTrackWriter(context, tracks.length > 1);
-        return new FileTrackExporter(contentProviderUtils, trackWriter, tracks, trackExporterListener);
+        return new FileTrackExporter(contentProviderUtils, trackWriter, tracks);
     }
 
     /**

src/main/java/de/dennisguse/opentracks/io/file/exporter/ExportActivity.java

@@ -24,26 +24,25 @@ import android.content.DialogInterface;
 import android.content.Intent;
 import android.net.Uri;
 import android.os.Bundle;
-import android.widget.Toast;
 
 import androidx.annotation.Nullable;
 import androidx.documentfile.provider.DocumentFile;
 import androidx.fragment.app.FragmentActivity;
 
 import de.dennisguse.opentracks.R;
-import de.dennisguse.opentracks.fragments.FileTypeDialogFragment;
 import de.dennisguse.opentracks.io.file.TrackFileFormat;
 import de.dennisguse.opentracks.util.DialogUtils;
 import de.dennisguse.opentracks.util.FileUtils;
+import de.dennisguse.opentracks.util.PreferencesUtils;
 
 /**
  * An activity for saving tracks to the external storage.
  *
  * @author Rodrigo Damazio
  */
-public class ExportActivity extends FragmentActivity implements FileTypeDialogFragment.FileTypeCaller {
+public class ExportActivity extends FragmentActivity {
 
-    private static final int EXTERNAL_STORAGE_PERMISSION_REQUEST_CODE = 6;
+    private static final int DIRECTORY_PICKER_REQUEST_CODE = 6;
 
     private static final int DIALOG_PROGRESS_ID = 0;
     private static final int DIALOG_RESULT_ID = 1;
@@ -56,65 +55,50 @@ public class ExportActivity extends FragmentActivity implements FileTypeDialogFr
     private int processedTrackCount;
     private int totalTrackCount;
 
-    private Uri directoryUri;
-
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT_TREE);
         intent.addFlags(Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
 
-        startActivityForResult(intent, EXTERNAL_STORAGE_PERMISSION_REQUEST_CODE);
+        startActivityForResult(intent, DIRECTORY_PICKER_REQUEST_CODE);
     }
 
     @Override
     protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent resultData) {
         super.onActivityResult(requestCode, resultCode, resultData);
-        if (requestCode == EXTERNAL_STORAGE_PERMISSION_REQUEST_CODE) {
+        if (requestCode == DIRECTORY_PICKER_REQUEST_CODE) {
             if (resultCode == Activity.RESULT_OK) {
-                directoryUri = resultData.getData();
-                fileTypeDialogStart();
+                Uri directoryUri = resultData.getData();
+                DocumentFile pickedDirectory = DocumentFile.fromTreeUri(this, directoryUri);
+                DocumentFile exportDirectory = pickedDirectory.findFile(FileUtils.EXPORT_DIR);
+                if (exportDirectory == null) {
+                    exportDirectory = pickedDirectory.createDirectory(FileUtils.EXPORT_DIR);
+                }
+
+                TrackFileFormat trackFileFormat = PreferencesUtils.getExportTrackFileFormat(this);
+
+                directoryDisplayName = FileUtils.getPath(exportDirectory);
+                exportAsyncTask = new ExportAsyncTask(this, trackFileFormat, exportDirectory);
+                exportAsyncTask.execute();
             } else {
-                Toast.makeText(this, R.string.external_storage_not_writable, Toast.LENGTH_LONG).show();
                 finish();
             }
         }
     }
 
-    private void fileTypeDialogStart() {
-        FileTypeDialogFragment.showDialog(getSupportFragmentManager(), R.string.export_all_title, R.string.export_all_option);
-    }
-
-    @Override
-    public void onFileTypeDone(TrackFileFormat trackFileFormat) {
-        DocumentFile pickedDirectory = DocumentFile.fromTreeUri(this, directoryUri);
-        DocumentFile exportDirectory = pickedDirectory.findFile(FileUtils.EXPORT_DIR);
-        if (exportDirectory == null) {
-            exportDirectory = pickedDirectory.createDirectory(FileUtils.EXPORT_DIR);
-        }
-
-        directoryDisplayName = FileUtils.getPath(exportDirectory);
-        exportAsyncTask = new ExportAsyncTask(this, trackFileFormat, exportDirectory);
-        exportAsyncTask.execute();
-    }
-
-    @Override
-    public void onDismissed() {
-        finish();
-    }
-
     @Override
     protected Dialog onCreateDialog(int id) {
         switch (id) {
             case DIALOG_PROGRESS_ID:
                 progressDialog = DialogUtils.createHorizontalProgressDialog(this,
-                        R.string.export_external_storage_progress_message,
+                        R.string.export_progress_message,
                         new DialogInterface.OnCancelListener() {
                             @Override
                             public void onCancel(DialogInterface dialog) {
                                 exportAsyncTask.cancel(true);
                                 dialog.dismiss();
-                                onDismissed();
+                                finish();
                             }
                         }, directoryDisplayName);
                 return progressDialog;
@@ -128,11 +112,11 @@ public class ExportActivity extends FragmentActivity implements FileTypeDialogFr
                     iconId = R.drawable.ic_dialog_success_24dp;
                     titleId = R.string.generic_success_title;
                     message = getString(
-                            R.string.export_external_storage_success, totalTracks, directoryDisplayName);
+                            R.string.export_success, totalTracks, directoryDisplayName);
                 } else {
                     iconId = R.drawable.ic_dialog_error_24dp;
                     titleId = R.string.generic_error_title;
-                    message = getString(R.string.export_external_storage_error, processedTrackCount, totalTracks, directoryDisplayName);
+                    message = getString(R.string.export_error, processedTrackCount, totalTracks, directoryDisplayName);
                 }
                 AlertDialog.Builder builder = new AlertDialog.Builder(this).setCancelable(true)
                         .setIcon(iconId).setMessage(message)
@@ -140,13 +124,13 @@ public class ExportActivity extends FragmentActivity implements FileTypeDialogFr
                             @Override
                             public void onCancel(DialogInterface dialog) {
                                 dialog.dismiss();
-                                onDismissed();
+                                finish();
                             }
                         }).setPositiveButton(R.string.generic_ok, new DialogInterface.OnClickListener() {
                             @Override
                             public void onClick(DialogInterface dialog, int arg1) {
                                 dialog.dismiss();
-                                onDismissed();
+                                finish();
                             }
                         }).setTitle(titleId);
                 return builder.create();

src/main/java/de/dennisguse/opentracks/io/file/exporter/ExportAsyncTask.java

@@ -16,7 +16,6 @@
 
 package de.dennisguse.opentracks.io.file.exporter;
 
-import android.content.Context;
 import android.database.Cursor;
 import android.os.AsyncTask;
 import android.os.PowerManager.WakeLock;
@@ -45,13 +44,10 @@ class ExportAsyncTask extends AsyncTask<Void, Integer, Boolean> {
     private static final String TAG = ExportAsyncTask.class.getSimpleName();
     private final TrackFileFormat trackFileFormat;
     private final DocumentFile directory;
-    private final Context context;
     private final ContentProviderUtils contentProviderUtils;
     private ExportActivity exportActivity;
     private WakeLock wakeLock;
 
-    private boolean completed = false;
-
     private int processedTrackCount = 0;
     private int totalTrackCount = 0;
 
@@ -66,8 +62,7 @@ class ExportAsyncTask extends AsyncTask<Void, Integer, Boolean> {
         this.exportActivity = exportActivity;
         this.trackFileFormat = trackFileFormat;
         this.directory = directory;
-        context = exportActivity.getApplicationContext();
-        contentProviderUtils = new ContentProviderUtils(context);
+        contentProviderUtils = new ContentProviderUtils(exportActivity);
     }
 
     @Override
@@ -99,7 +94,6 @@ class ExportAsyncTask extends AsyncTask<Void, Integer, Boolean> {
 
     @Override
     protected void onPostExecute(Boolean result) {
-        completed = true;
         if (exportActivity != null) {
             exportActivity.onAsyncTaskCompleted(processedTrackCount, totalTrackCount);
         }
@@ -107,7 +101,6 @@ class ExportAsyncTask extends AsyncTask<Void, Integer, Boolean> {
 
     @Override
     protected void onCancelled() {
-        completed = true;
         if (exportActivity != null) {
             exportActivity.onAsyncTaskCompleted(processedTrackCount, totalTrackCount);
         }
@@ -119,17 +112,7 @@ class ExportAsyncTask extends AsyncTask<Void, Integer, Boolean> {
      * @param track the track
      */
     private Boolean exportTrack(Track track) {
-        TrackExporterListener trackExporterListener = new TrackExporterListener() {
-            @Override
-            public void onProgressUpdate(int number, int max) {
-                //Update the progress dialog once every 500 points.
-                if (number % 500 == 0) {
-                    publishProgress(number, max);
-                }
-            }
-        };
-
-        TrackExporter trackExporter = trackFileFormat.newTrackExporter(context, new Track[]{track}, trackExporterListener);
+        TrackExporter trackExporter = trackFileFormat.newTrackExporter(exportActivity, new Track[]{track});
 
         String fileName = track.getId() + "." + trackFileFormat.getExtension();
 
@@ -139,8 +122,8 @@ class ExportAsyncTask extends AsyncTask<Void, Integer, Boolean> {
             file = directory.createFile(trackFileFormat.getMimeType(), fileName);
         }
 
-        try (OutputStream outputStream = context.getContentResolver().openOutputStream(file.getUri())) {
-            if (trackExporter.writeTrack(context, outputStream)) {
+        try (OutputStream outputStream = exportActivity.getContentResolver().openOutputStream(file.getUri())) {
+            if (trackExporter.writeTrack(exportActivity, outputStream)) {
                 return true;
             } else {
                 if (!file.delete()) {
@@ -167,6 +150,7 @@ class ExportAsyncTask extends AsyncTask<Void, Integer, Boolean> {
                 return false;
             }
             totalTrackCount = cursor.getCount();
+
             for (int i = 0; i < totalTrackCount; i++) {
                 if (isCancelled()) {
                     return false;

src/main/java/de/dennisguse/opentracks/io/file/exporter/FileTrackExporter.java

@@ -44,7 +44,6 @@ public class FileTrackExporter implements TrackExporter {
     private final ContentProviderUtils contentProviderUtils;
     private final Track[] tracks;
     private final TrackWriter trackWriter;
-    private final TrackExporterListener trackExporterListener;
 
     /**
      * Constructor.
@@ -52,13 +51,11 @@ public class FileTrackExporter implements TrackExporter {
      * @param contentProviderUtils  the content provider utils
      * @param trackWriter           the track writer
      * @param tracks                the tracks
-     * @param trackExporterListener the track export listener
      */
-    public FileTrackExporter(ContentProviderUtils contentProviderUtils, TrackWriter trackWriter, Track[] tracks, TrackExporterListener trackExporterListener) {
+    public FileTrackExporter(ContentProviderUtils contentProviderUtils, TrackWriter trackWriter, Track[] tracks) {
         this.contentProviderUtils = contentProviderUtils;
         this.tracks = tracks;
         this.trackWriter = trackWriter;
-        this.trackExporterListener = trackExporterListener;
     }
 
     @Override
@@ -158,9 +155,6 @@ public class FileTrackExporter implements TrackExporter {
 
                     // Write the current trackPoint
                     trackWriter.writeTrackPoint(trackPoint);
-                    if (trackExporterListener != null) {
-                        trackExporterListener.onProgressUpdate(locationNumber, trackPointIterator.getCount());
-                    }
                 } else {
                     if (wroteSegment) {
                         trackWriter.writeCloseSegment();

src/main/java/de/dennisguse/opentracks/io/file/exporter/KmlTrackWriter.java

@@ -18,7 +18,6 @@ package de.dennisguse.opentracks.io.file.exporter;
 import android.content.Context;
 import android.database.Cursor;
 import android.location.Location;
-import android.net.Uri;
 
 import java.io.OutputStream;
 import java.io.PrintWriter;
@@ -31,7 +30,7 @@ import de.dennisguse.opentracks.content.data.Track;
 import de.dennisguse.opentracks.content.data.TrackPoint;
 import de.dennisguse.opentracks.content.data.Waypoint;
 import de.dennisguse.opentracks.content.provider.ContentProviderUtils;
-import de.dennisguse.opentracks.content.sensor.SensorDataSet;
+import de.dennisguse.opentracks.util.FileUtils;
 import de.dennisguse.opentracks.util.StringUtils;
 
 /**
@@ -72,11 +71,11 @@ public class KmlTrackWriter implements TrackWriter {
     private TrackPoint startTrackPoint;
 
     /**
-     * @param context            the context
-     * @param hasMultipleTracks  should encode multiple tracks into one file?
-     * @param exportTrackDetail  should detailed information about the track be exported (e.g., title, description, waypoints, timing)?
-     * @param exportSensorData   should {@link SensorDataSet} be exported?
-     * @param exportPhotos       should pictures be exported (if true: exports to KMZ)?
+     * @param context           the context
+     * @param hasMultipleTracks should encode multiple tracks into one file?
+     * @param exportTrackDetail should detailed information about the track be exported (e.g., title, description, waypoints, timing)?
+     * @param exportSensorData  should {@link TrackPoint}'s sensor data be exported?
+     * @param exportPhotos      should pictures be exported (if true: exports to KMZ)?
      */
     public KmlTrackWriter(Context context, boolean hasMultipleTracks, boolean exportTrackDetail, boolean exportSensorData, boolean exportPhotos) {
         this.context = context;
@@ -162,9 +161,10 @@ public class KmlTrackWriter implements TrackWriter {
     @Override
     public void writeWaypoint(Waypoint waypoint) {
         if (printWriter != null && exportTrackDetail) {
-            if (waypoint.hasPhoto() && exportPhotos) {
+            boolean existsPhoto = FileUtils.getPhotoFileIfExists(context, waypoint.getTrackId(), waypoint.getPhotoURI()) != null;
+            if (waypoint.hasPhoto() && exportPhotos && existsPhoto) {
                 float heading = getHeading(waypoint.getTrackId(), waypoint.getLocation());
-                writePhotoOverlay(waypoint.getName(), waypoint.getCategory(), waypoint.getDescription(), waypoint.getLocation(), waypoint.getPhotoUrl(), heading);
+                writePhotoOverlay(waypoint, heading);
             } else {
                 writePlacemark(waypoint.getName(), waypoint.getCategory(), waypoint.getDescription(), WAYPOINT_STYLE, waypoint.getLocation());
             }
@@ -267,17 +267,14 @@ public class KmlTrackWriter implements TrackWriter {
             printWriter.println("<gx:coord>" + getCoordinates(trackPoint.getLocation(), " ") + "</gx:coord>");
 
             if (exportSensorData) {
-                SensorDataSet sensorDataSet = trackPoint.getSensorDataSet();
-                if (sensorDataSet != null) {
-                    if (sensorDataSet.hasHeartRate()) {
-                        heartRateList.add(sensorDataSet.getHeartRate());
-                    }
-                    if (sensorDataSet.hasCadence()) {
-                        cadenceList.add(sensorDataSet.getCadence());
-                    }
-                    if (sensorDataSet.hasPower()) {
-                        powerList.add(sensorDataSet.getPower());
-                    }
+                if (trackPoint.hasHeartRate()) {
+                    heartRateList.add(trackPoint.getHeartRate_bpm());
+                }
+                if (trackPoint.hasCyclingCadence()) {
+                    cadenceList.add(trackPoint.getCyclingCadence_rpm());
+                }
+                if (trackPoint.hasPower()) {
+                    powerList.add(trackPoint.getPower());
                 }
             }
         }
@@ -322,32 +319,29 @@ public class KmlTrackWriter implements TrackWriter {
     }
 
     /**
-     * Writes a photo overlay.
-     *  @param name        the name
-     * @param category    the category
-     * @param description the description
-     * @param location    the location
-     * @param photoUrl    the photo url
-     * @param heading     the heading
+     * Writes a photo overlay from waypoint.
+     *
+     * @param waypoint Waypoint object.
+     * @param heading  the heading.
      */
-    private void writePhotoOverlay(String name, String category, String description, Location location, String photoUrl, float heading) {
-        if (location != null && exportTrackDetail) {
+    private void writePhotoOverlay(Waypoint waypoint, float heading) {
+        if (exportTrackDetail) {
             printWriter.println("<PhotoOverlay>");
-            printWriter.println("<name>" + StringUtils.formatCData(name) + "</name>");
-            printWriter.println("<description>" + StringUtils.formatCData(description) + "</description>");
+            printWriter.println("<name>" + StringUtils.formatCData(waypoint.getName()) + "</name>");
+            printWriter.println("<description>" + StringUtils.formatCData(waypoint.getDescription()) + "</description>");
             printWriter.print("<Camera>");
-            printWriter.print("<longitude>" + location.getLongitude() + "</longitude>");
-            printWriter.print("<latitude>" + location.getLatitude() + "</latitude>");
+            printWriter.print("<longitude>" + waypoint.getLocation().getLongitude() + "</longitude>");
+            printWriter.print("<latitude>" + waypoint.getLocation().getLatitude() + "</latitude>");
             printWriter.print("<altitude>20</altitude>");
             printWriter.print("<heading>" + heading + "</heading>");
             printWriter.print("<tilt>90</tilt>");
             printWriter.println("</Camera>");
-            printWriter.println("<TimeStamp><when>" + getTime(location) + "</when></TimeStamp>");
+            printWriter.println("<TimeStamp><when>" + getTime(waypoint.getLocation()) + "</when></TimeStamp>");
             printWriter.println("<styleUrl>#" + KmlTrackWriter.WAYPOINT_STYLE + "</styleUrl>");
-            writeCategory(category);
+            writeCategory(waypoint.getCategory());
 
             if (exportPhotos) {
-                printWriter.println("<Icon><href>" + KmzTrackExporter.buildKmzImageFilePath(Uri.parse(photoUrl)) + "</href></Icon>");
+                printWriter.println("<Icon><href>" + KmzTrackExporter.buildKmzImageFilePath(waypoint) + "</href></Icon>");
             }
 
             printWriter.print("<ViewVolume>");
@@ -358,7 +352,7 @@ public class KmlTrackWriter implements TrackWriter {
             printWriter.print("<topFov>45</topFov>");
             printWriter.println("</ViewVolume>");
             printWriter.println("<Point>");
-            printWriter.println("<coordinates>" + getCoordinates(location, ",") + "</coordinates>");
+            printWriter.println("<coordinates>" + getCoordinates(waypoint.getLocation(), ",") + "</coordinates>");
             printWriter.println("</Point>");
             printWriter.println("</PhotoOverlay>");
         }
@@ -454,7 +448,7 @@ public class KmlTrackWriter implements TrackWriter {
     /**
      * Writes a sensor style.
      *
-     * @param name        the name of the sesnor
+     * @param name       the name of the sesnor
      * @param sensorType the sensor display name
      */
     private void writeSensorStyle(String name, String sensorType) {

src/main/java/de/dennisguse/opentracks/io/file/exporter/KmzTrackExporter.java

@@ -42,7 +42,7 @@ import de.dennisguse.opentracks.util.FileUtils;
  * @author Jimmy Shih
  */
 public class KmzTrackExporter implements TrackExporter {
-    public static final String KMZ_IMAGES_DIR = "images";
+    private static final String KMZ_IMAGES_DIR = "images";
     public static final String KMZ_KML_FILE = "doc.kml";
 
     private static final String TAG = KmzTrackExporter.class.getSimpleName();
@@ -112,7 +112,11 @@ public class KmzTrackExporter implements TrackExporter {
                         }
                         Waypoint waypoint = contentProviderUtils.createWaypoint(cursor);
                         if (waypoint.hasPhoto()) {
-                            addImage(context, zipOutputStream, waypoint.getPhotoUrl());
+                            Uri uriPhoto = waypoint.getPhotoURI();
+                            boolean existsPhoto = FileUtils.getPhotoFileIfExists(context, track.getId(), uriPhoto) != null;
+                            if (existsPhoto) {
+                                addImage(context, zipOutputStream, uriPhoto, waypoint);
+                            }
                         }
 
                         cursor.moveToNext();
@@ -122,11 +126,9 @@ public class KmzTrackExporter implements TrackExporter {
         }
     }
 
-    private void addImage(Context context, ZipOutputStream zipOutputStream, String photoUrl) throws IOException {
-        Uri uri = Uri.parse(photoUrl);
-
+    private void addImage(Context context, ZipOutputStream zipOutputStream, Uri uri, Waypoint waypoint) throws IOException {
         try (InputStream inputStream = context.getContentResolver().openInputStream(uri)) {
-            ZipEntry zipEntry = new ZipEntry(buildKmzImageFilePath(uri));
+            ZipEntry zipEntry = new ZipEntry(buildKmzImageFilePath(waypoint));
             zipOutputStream.putNextEntry(zipEntry);
 
             if (inputStream == null) throw new FileNotFoundException();
@@ -149,11 +151,13 @@ public class KmzTrackExporter implements TrackExporter {
     }
 
     /**
-     * Builds and returns the path for the file that will be saved inside KMZ_IMAGES_DIR.
+     * Builds and returns the path for the image that will be saved inside KMZ_IMAGES_DIR for the waypoint.
      *
-     * @param uri URI object.
+     * @param waypoint Waypoint object.
      */
-    public static String buildKmzImageFilePath(Uri uri) {
-        return KMZ_IMAGES_DIR + File.separatorChar + FileUtils.sanitizeFileName(uri.getLastPathSegment());
+    public static String buildKmzImageFilePath(Waypoint waypoint) {
+        String ext = FileUtils.getExtension(waypoint.getPhotoUrl());
+        ext = ext == null ? "" : "." + ext;
+        return KMZ_IMAGES_DIR + File.separatorChar + FileUtils.sanitizeFileName(waypoint.getId() + ext);
     }
 }

src/main/java/de/dennisguse/opentracks/io/file/exporter/TrackExporterListener.java

@@ -1,33 +0,0 @@
-/*
- * Copyright 2010 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package de.dennisguse.opentracks.io.file.exporter;
-
-/**
- * Listener for {@link TrackExporter} progress.
- *
- * @author Jimmy Shih
- */
-public interface TrackExporterListener {
-
-    /**
-     * Called to update progress.
-     *
-     * @param number the number of {@link de.dennisguse.opentracks.content.data.TrackPoint}s written
-     * @param max    the maximum number of {@link de.dennisguse.opentracks.content.data.TrackPoint}s in a {@link de.dennisguse.opentracks.content.data.Track}, for calculation of
-     *               completion percentage
-     */
-    void onProgressUpdate(int number, int max);
-}

src/main/java/de/dennisguse/opentracks/io/file/importer/AbstractFileTrackImporter.java

@@ -28,6 +28,7 @@ import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.Locale;
 
@@ -312,6 +313,9 @@ abstract class AbstractFileTrackImporter extends DefaultHandler implements Track
      */
     protected TrackPoint getTrackPoint() throws SAXException {
         TrackPoint trackPoint = createTrackPoint();
+        if (trackPoint == null) {
+            throw new SAXException(createErrorMessage("Invalid location detected: " + trackPoint));
+        }
 
         // Calculate derived attributes from the previous point
         if (trackData.lastLocationInCurrentSegment != null && trackData.lastLocationInCurrentSegment.getTime() != 0) {
@@ -379,23 +383,15 @@ abstract class AbstractFileTrackImporter extends DefaultHandler implements Track
             return null;
         }
 
-        Uri externalPhotoUri = Uri.parse(externalPhotoUrl);
-        if (externalPhotoUri == null) {
-            Log.w(TAG, "Could not parse external photo url.");
+        String importFileName = KmzTrackImporter.importNameForFilename(externalPhotoUrl);
+        File file = FileUtils.getPhotoFileIfExists(context, importTrackId, Uri.parse(importFileName));
+        if (file != null) {
+            Uri photoUri = FileUtils.getUriForFile(context, file);
+            return "" + photoUri;
+        }
+        else {
             return null;
         }
-        String filename = externalPhotoUri.getLastPathSegment();
-        if (filename == null) {
-            Log.w(TAG, "External photo contains no filename.");
-            return null;
-        }
-
-        File dir = FileUtils.getPhotoDir(context, importTrackId);
-        File file = new File(dir, filename);
-
-        Uri photoUri = FileUtils.getUriForFile(context, file);
-
-        return "" + photoUri;
     }
 
     /**
@@ -446,11 +442,11 @@ abstract class AbstractFileTrackImporter extends DefaultHandler implements Track
         }
         trackData.trackStatisticsUpdater.addTrackPoint(trackPoint, recordingDistanceInterval);
 
-        trackData.bufferedTrackPoints[trackData.numBufferedLocations] = trackPoint;
-        trackData.numBufferedLocations++;
+        trackData.bufferedTrackPoints[trackData.numBufferedTrackPoints] = trackPoint;
+        trackData.numBufferedTrackPoints++;
         trackData.numberOfLocations++;
 
-        if (trackData.numBufferedLocations >= MAX_BUFFERED_LOCATIONS) {
+        if (trackData.numBufferedTrackPoints >= MAX_BUFFERED_LOCATIONS) {
             flushLocations(trackData);
         }
     }
@@ -461,11 +457,11 @@ abstract class AbstractFileTrackImporter extends DefaultHandler implements Track
      * @param data the track data
      */
     private void flushLocations(TrackData data) {
-        if (data.numBufferedLocations <= 0) {
+        if (data.numBufferedTrackPoints <= 0) {
             return;
         }
-        contentProviderUtils.bulkInsertTrackPoint(data.bufferedTrackPoints, data.numBufferedLocations, data.track.getId());
-        data.numBufferedLocations = 0;
+        contentProviderUtils.bulkInsertTrackPoint(Arrays.copyOfRange(data.bufferedTrackPoints, 0, data.numBufferedTrackPoints), data.track.getId());
+        data.numBufferedTrackPoints = 0;
     }
 
     /**
@@ -506,6 +502,6 @@ abstract class AbstractFileTrackImporter extends DefaultHandler implements Track
         final TrackPoint[] bufferedTrackPoints = new TrackPoint[MAX_BUFFERED_LOCATIONS];
 
         // The number of buffered locations
-        int numBufferedLocations = 0;
+        int numBufferedTrackPoints = 0;
     }
 }

src/main/java/de/dennisguse/opentracks/io/file/importer/ImportActivity.java

@@ -24,26 +24,25 @@ import android.content.DialogInterface;
 import android.content.Intent;
 import android.net.Uri;
 import android.os.Bundle;
-import android.widget.Toast;
 
 import androidx.annotation.Nullable;
 import androidx.documentfile.provider.DocumentFile;
 import androidx.fragment.app.FragmentActivity;
 
 import de.dennisguse.opentracks.R;
-import de.dennisguse.opentracks.fragments.FileTypeDialogFragment;
 import de.dennisguse.opentracks.io.file.TrackFileFormat;
 import de.dennisguse.opentracks.util.DialogUtils;
 import de.dennisguse.opentracks.util.FileUtils;
+import de.dennisguse.opentracks.util.PreferencesUtils;
 
 /**
  * An activity to import files from the external storage.
  *
  * @author Rodrigo Damazio
  */
-public class ImportActivity extends FragmentActivity implements FileTypeDialogFragment.FileTypeCaller {
+public class ImportActivity extends FragmentActivity {
 
-    private static final int EXTERNAL_STORAGE_PERMISSION_REQUEST_CODE = 6;
+    private static final int DIRECTORY_PICKER_REQUEST_CODE = 6;
 
     private static final int DIALOG_PROGRESS_ID = 0;
     private static final int DIALOG_RESULT_ID = 1;
@@ -56,8 +55,6 @@ public class ImportActivity extends FragmentActivity implements FileTypeDialogFr
     private int importedTrackCount;
     private int totalTrackCount;
 
-    private Uri directoryUri;
-
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
@@ -65,43 +62,28 @@ public class ImportActivity extends FragmentActivity implements FileTypeDialogFr
         Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT_TREE);
         intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
 
-        startActivityForResult(intent, EXTERNAL_STORAGE_PERMISSION_REQUEST_CODE);
+        startActivityForResult(intent, DIRECTORY_PICKER_REQUEST_CODE);
     }
 
     @Override
     protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent resultData) {
         super.onActivityResult(requestCode, resultCode, resultData);
-        if (requestCode == EXTERNAL_STORAGE_PERMISSION_REQUEST_CODE) {
+        if (requestCode == DIRECTORY_PICKER_REQUEST_CODE) {
             if (resultCode == Activity.RESULT_OK) {
-                directoryUri = resultData.getData();
-                fileTypeDialogStart();
+                Uri directoryUri = resultData.getData();
+                DocumentFile pickedDirectory = DocumentFile.fromTreeUri(this, directoryUri);
+
+                directoryDisplayName = FileUtils.getPath(pickedDirectory);
+                TrackFileFormat trackFileFormat = PreferencesUtils.getExportTrackFileFormat(this);
+
+                importAsyncTask = new ImportAsyncTask(this, trackFileFormat, pickedDirectory);
+                importAsyncTask.execute();
             } else {
-                Toast.makeText(this, R.string.external_storage_not_writable, Toast.LENGTH_LONG).show();
                 finish();
             }
         }
     }
 
-
-    private void fileTypeDialogStart() {
-        FileTypeDialogFragment.showDialog(getSupportFragmentManager(), R.string.import_selection_title, R.string.import_selection_option);
-    }
-
-    @Override
-    public void onFileTypeDone(TrackFileFormat trackFileFormat) {
-        DocumentFile pickedDirectory = DocumentFile.fromTreeUri(this, directoryUri);
-
-        directoryDisplayName = FileUtils.getPath(pickedDirectory);
-
-        importAsyncTask = new ImportAsyncTask(this, trackFileFormat, pickedDirectory);
-        importAsyncTask.execute();
-    }
-
-    @Override
-    public void onDismissed() {
-        finish();
-    }
-
     @Override
     protected Dialog onCreateDialog(int id) {
         switch (id) {
@@ -112,7 +94,7 @@ public class ImportActivity extends FragmentActivity implements FileTypeDialogFr
                             public void onCancel(DialogInterface dialog) {
                                 importAsyncTask.cancel(true);
                                 dialog.dismiss();
-                                onDismissed();
+                                finish();
                             }
                         }, directoryDisplayName);
                 return progressDialog;
@@ -142,13 +124,13 @@ public class ImportActivity extends FragmentActivity implements FileTypeDialogFr
                             @Override
                             public void onCancel(DialogInterface dialogInterface) {
                                 dialogInterface.dismiss();
-                                onDismissed();
+                                finish();
                             }
                         }).setPositiveButton(R.string.generic_ok, new DialogInterface.OnClickListener() {
                             @Override
                             public void onClick(DialogInterface dialogInterface, int which) {
                                 dialogInterface.dismiss();
-                                onDismissed();
+                                finish();
                             }
                         }).setTitle(titleId).create();
             default:

src/main/java/de/dennisguse/opentracks/io/file/importer/ImportAsyncTask.java

@@ -16,7 +16,6 @@
 
 package de.dennisguse.opentracks.io.file.importer;
 
-import android.content.Context;
 import android.net.Uri;
 import android.os.AsyncTask;
 import android.os.PowerManager.WakeLock;
@@ -46,39 +45,23 @@ class ImportAsyncTask extends AsyncTask<Void, Integer, Boolean> {
     private static final String TAG = ImportAsyncTask.class.getSimpleName();
     private final TrackFileFormat trackFileFormat;
     private final DocumentFile directory;
-    // TODO Can be removed, or?
-    private Context context;
+
     // TODO Use weak reference
     private ImportActivity importActivity;
     private WakeLock wakeLock;
 
-    // true if the AsyncTask has completed
-    private boolean completed;
-
     private int importTrackCount;
-
     private int totalTrackCount;
+    private long lastSuccessfulTrackId;
 
-    // the last successfully imported track id
-    private long trackId;
-
-    /**
-     * Creates an AsyncTask.
-     *
-     * @param importActivity  the activity currently associated with this AsyncTask
-     * @param trackFileFormat the track file format
-     * @param directory            path to import GPX files
-     */
     public ImportAsyncTask(ImportActivity importActivity, TrackFileFormat trackFileFormat, DocumentFile directory) {
         this.importActivity = importActivity;
         this.trackFileFormat = trackFileFormat;
         this.directory = directory;
-        context = importActivity.getApplicationContext();
 
-        completed = false;
         importTrackCount = 0;
         totalTrackCount = 0;
-        trackId = -1L;
+        lastSuccessfulTrackId = -1L;
     }
 
     @Override
@@ -90,8 +73,6 @@ class ImportAsyncTask extends AsyncTask<Void, Integer, Boolean> {
 
     /**
      * Gets a list of files.
-     * If importAll is true, returns a list of the files under the path directory.
-     * If importAll is false, returns a list containing just the path file.
      */
     private static List<DocumentFile> getFiles(DocumentFile file, TrackFileFormat trackFileFormat) {
         List<DocumentFile> files = new ArrayList<>();
@@ -99,7 +80,7 @@ class ImportAsyncTask extends AsyncTask<Void, Integer, Boolean> {
         for (DocumentFile candidate : file.listFiles()) {
             if (!candidate.isDirectory()) {
                 String extension = FileUtils.getExtension(candidate.getName());
-                if (trackFileFormat.getExtension().equals(extension)) {
+                if (extension != null && trackFileFormat.getExtension().equals(extension)) {
                     files.add(candidate);
                 }
             } else {
@@ -119,7 +100,6 @@ class ImportAsyncTask extends AsyncTask<Void, Integer, Boolean> {
 
     @Override
     protected void onPostExecute(Boolean result) {
-        completed = true;
         if (importActivity != null) {
             importActivity.onAsyncTaskCompleted(importTrackCount, totalTrackCount);
         }
@@ -127,8 +107,6 @@ class ImportAsyncTask extends AsyncTask<Void, Integer, Boolean> {
 
     @Override
     protected void onCancelled() {
-        context = null;
-        completed = true;
         if (importActivity != null) {
             importActivity.onAsyncTaskCompleted(importTrackCount, totalTrackCount);
             importActivity = null;
@@ -186,13 +164,13 @@ class ImportAsyncTask extends AsyncTask<Void, Integer, Boolean> {
                 Uri uri = contentProviderUtils.insertTrack(new Track());
                 long newId = Long.parseLong(uri.getLastPathSegment());
 
-                trackImporter = new KmzTrackImporter(importActivity, newId);
+                trackImporter = new KmzTrackImporter(importActivity, newId, file.getUri());
             }
         }
 
-        try (InputStream inputStream = context.getContentResolver().openInputStream(file.getUri())) {
-            trackId = trackImporter.importFile(inputStream);
-            return trackId != -1L;
+        try (InputStream inputStream = importActivity.getContentResolver().openInputStream(file.getUri())) {
+            lastSuccessfulTrackId = trackImporter.importFile(inputStream);
+            return lastSuccessfulTrackId != -1L;
         } catch (IOException e) {
             Log.e(TAG, "Unable to import file", e);
             return false;

src/main/java/de/dennisguse/opentracks/io/file/importer/KmlFileTrackImporter.java

@@ -28,7 +28,6 @@ import java.util.ArrayList;
 
 import de.dennisguse.opentracks.content.data.TrackPoint;
 import de.dennisguse.opentracks.content.provider.ContentProviderUtils;
-import de.dennisguse.opentracks.content.sensor.SensorDataSet;
 import de.dennisguse.opentracks.io.file.exporter.KmlTrackWriter;
 
 /**
@@ -223,30 +222,17 @@ public class KmlFileTrackImporter extends AbstractFileTrackImporter {
         for (int i = 0; i < trackPoints.size(); i++) {
             TrackPoint trackPoint = trackPoints.get(i);
 
-            boolean hasSensorData = false;
-            float heartrate = SensorDataSet.DATA_UNAVAILABLE;
-            float cadence = SensorDataSet.DATA_UNAVAILABLE;
-            float power = SensorDataSet.DATA_UNAVAILABLE;
-
             if (i < heartRateList.size()) {
-                heartrate = heartRateList.get(i);
-                hasSensorData = true;
+                trackPoint.setHeartRate_bpm(heartRateList.get(i));
             }
             if (i < cadenceList.size()) {
-                cadence = cadenceList.get(i);
-                hasSensorData = true;
+                trackPoint.setCyclingCadence_rpm(cadenceList.get(i));
             }
             if (i < powerList.size()) {
-                power = powerList.get(i);
-                hasSensorData = true;
+                trackPoint.setPower(cadenceList.get(i));
             }
 
-            if (!hasSensorData) {
-                insertTrackPoint(trackPoint);
-            } else {
-                TrackPoint sensorDataSetLocation = new TrackPoint(trackPoint, new SensorDataSet(heartrate, cadence, power, SensorDataSet.DATA_UNAVAILABLE, trackPoint.getTime()));
-                insertTrackPoint(sensorDataSetLocation);
-            }
+            insertTrackPoint(trackPoint);
         }
     }
 

src/main/java/de/dennisguse/opentracks/io/file/importer/KmzTrackImporter.java

@@ -17,6 +17,7 @@
 package de.dennisguse.opentracks.io.file.importer;
 
 import android.content.Context;
+import android.net.Uri;
 import android.util.Log;
 
 import java.io.ByteArrayInputStream;
@@ -25,9 +26,13 @@ import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipInputStream;
 
+import de.dennisguse.opentracks.content.data.Waypoint;
 import de.dennisguse.opentracks.content.provider.ContentProviderUtils;
 import de.dennisguse.opentracks.io.file.exporter.KmzTrackExporter;
 import de.dennisguse.opentracks.util.FileUtils;
@@ -42,58 +47,185 @@ public class KmzTrackImporter implements TrackImporter {
 
     private static final String TAG = KmzTrackImporter.class.getSimpleName();
 
+    private static final List<String> KMZ_IMAGES_EXT = Arrays.asList("jpeg", "jpg", "png");
+
     private static final int BUFFER_SIZE = 4096;
 
     private final Context context;
     private final long importTrackId;
+    private Uri uriKmzFile;
 
     /**
      * Constructor.
      *
      * @param context       the context
      * @param importTrackId track id to import to. This should not be -1L so that images in the kmz file can be imported.
+     * @param uriFile       URI of the kmz file.
      */
-    KmzTrackImporter(Context context, long importTrackId) {
+    KmzTrackImporter(Context context, long importTrackId, Uri uriFile) {
         this.context = context;
         this.importTrackId = importTrackId;
+        this.uriKmzFile = uriFile;
     }
 
     @Override
     public long importFile(InputStream inputStream) {
-        long trackId = importTrackId;
-        try (ZipInputStream zipInputStream = new ZipInputStream(inputStream)) {
+        long trackId;
+
+        if (!copyKmzImages()) {
+            cleanImport(context, importTrackId);
+            return -1L;
+        }
+
+        trackId = findAndParseKmlFile(inputStream);
+        if (trackId == -1L) {
+            cleanImport(context, importTrackId);
+            return -1L;
+        }
+
+        deleteOrphanImages(context, trackId);
+
+        return trackId;
+    }
+
+    /**
+     * Copies all images that are inside KMZ to OpenTracks external storage.
+     *
+     * @return false if there are errors or true otherwise.
+     */
+    private boolean copyKmzImages() {
+        try (InputStream inputStream = context.getContentResolver().openInputStream(uriKmzFile);
+            ZipInputStream zipInputStream = new ZipInputStream(inputStream)) {
             ZipEntry zipEntry;
 
             while ((zipEntry = zipInputStream.getNextEntry()) != null) {
                 if (Thread.interrupted()) {
                     Log.d(TAG, "Thread interrupted");
-                    cleanImport(context, trackId);
+                    return false;
+                }
+
+                String fileName = zipEntry.getName();
+                if (hasImageExtension(fileName)) {
+                    readAndSaveImageFile(zipInputStream, importNameForFilename(fileName));
+                }
+
+                zipInputStream.closeEntry();
+            }
+
+            return true;
+        } catch (IOException e) {
+            Log.e(TAG, "Unable to import file", e);
+            return false;
+        }
+    }
+
+    /**
+     * From path fileName generates an import unique name and returns it.
+     * The name generator is simple: change the path fileName with '-' instead of File.separatorChar.
+     *
+     * @param fileName the file name.
+     */
+    public static String importNameForFilename(String fileName) {
+        // TODO this tricky code for maintain backward compatibility must be deleted some day.
+        /*
+         * In versions before v3.5.0 photo URL in KML files were wrong.
+         * For compatibility reasons it checks if fileName begins with "content://" or "file://".
+         * All fileName begins with "content:/" or "file://" are cooked.
+         * We cannot guess what's the folder name where images are so we use "images" that was the folder name expected in versions before v3.5.0.
+         */
+        if (fileName.startsWith("content://") || fileName.startsWith("file://")) {
+            fileName = "images/" + fileName.substring(fileName.lastIndexOf(File.separatorChar) + 1);
+        }
+
+        return fileName.replace(File.separatorChar, '-');
+    }
+
+    /**
+     * Returns true if fileName ends with some of the KMZ_IMAGES_EXT suffixes.
+     * Otherwise returns false.
+     */
+    private boolean hasImageExtension(String fileName)  {
+        if (fileName == null) {
+            return false;
+        }
+
+        String fileExt = FileUtils.getExtension(fileName.toLowerCase());
+        if (fileExt == null) {
+            return false;
+        }
+
+        return KMZ_IMAGES_EXT.contains(fileExt);
+    }
+
+    /**
+     * Finds KmzTrackExporter.KMZ_KML_FILE file inside kmz file (inputStream) and it parses it.
+     *
+     * @param inputStream kmz input stream.
+     * @return            -1 if error or the id of the track otherwise.
+     */
+    private long findAndParseKmlFile(InputStream inputStream) {
+        try (ZipInputStream zipInputStream = new ZipInputStream(inputStream)) {
+            ZipEntry zipEntry;
+            long trackId = -1L;
+
+            while ((zipEntry = zipInputStream.getNextEntry()) != null) {
+                if (Thread.interrupted()) {
+                    Log.d(TAG, "Thread interrupted");
                     return -1L;
                 }
+
                 String fileName = zipEntry.getName();
                 if (KmzTrackExporter.KMZ_KML_FILE.equals(fileName)) {
                     trackId = parseKml(zipInputStream);
                     if (trackId == -1L) {
                         Log.d(TAG, "Unable to parse kml in kmz");
-                        cleanImport(context, trackId);
                         return -1L;
                     }
-                } else {
-                    String prefix = KmzTrackExporter.KMZ_IMAGES_DIR + File.separatorChar;
-                    if (fileName.startsWith(prefix)) {
-                        readImageFile(zipInputStream, fileName.substring(prefix.length()));
-                    }
                 }
+
                 zipInputStream.closeEntry();
             }
             return trackId;
         } catch (IOException e) {
             Log.e(TAG, "Unable to import file", e);
-            cleanImport(context, trackId);
             return -1L;
         }
     }
 
+    /**
+     * Deletes all images that remained in external storage that doesn't have waypoint (marker) associated.
+     *
+     * @param context the Context object.
+     * @param trackId the id of the Track.
+     */
+    private void deleteOrphanImages(Context context, long trackId) {
+        if (trackId != 1L) {
+            // 1.- Gets all photo names in the waypoints of the track identified by id.
+            ContentProviderUtils contentProviderUtils = new ContentProviderUtils(context);
+            List<Waypoint> waypoints = contentProviderUtils.getWaypoints(trackId);
+            List<String> photosName = new ArrayList<>();
+            for (Waypoint w : waypoints) {
+                if (w.hasPhoto()) {
+                    String photoUrl = Uri.decode(w.getPhotoUrl());
+                    photosName.add(photoUrl.substring(photoUrl.lastIndexOf(File.separatorChar) + 1));
+                }
+            }
+
+            // 2.- Deletes all orphan photos from external storage.
+            File dir = FileUtils.getPhotoDir(context, trackId);
+            if (dir.exists() && dir.isDirectory()) {
+                for (File file : dir.listFiles()) {
+                    if (!photosName.contains(file.getName())) {
+                        file.delete();
+                    }
+                }
+                if (dir.listFiles().length == 0) {
+                    dir.delete();
+                }
+            }
+        }
+    }
+
     /**
      * Cleans up import.
      *
@@ -104,16 +236,6 @@ public class KmzTrackImporter implements TrackImporter {
             ContentProviderUtils contentProviderUtils = new ContentProviderUtils(context);
             contentProviderUtils.deleteTrack(context, trackId);
         }
-
-        if (importTrackId != -1L) {
-            File dir = FileUtils.getPhotoDir(context, importTrackId);
-            if (dir.exists() && dir.isDirectory()) {
-                for (File file : dir.listFiles()) {
-                    file.delete();
-                }
-                dir.delete();
-            }
-        }
     }
 
     /**
@@ -147,12 +269,12 @@ public class KmzTrackImporter implements TrackImporter {
     }
 
     /**
-     * Reads an image file.
+     * Reads an image file (zipInputStream) and save it in a file called fileName inside photo folder.
      *
      * @param zipInputStream the zip input stream
      * @param fileName       the file name
      */
-    private void readImageFile(ZipInputStream zipInputStream, String fileName) throws IOException {
+    private void readAndSaveImageFile(ZipInputStream zipInputStream, String fileName) throws IOException {
         if (importTrackId == -1L || fileName.equals("")) {
             return;
         }

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

@@ -33,14 +33,16 @@ import android.os.IBinder;
 import android.os.PowerManager.WakeLock;
 import android.util.Log;
 
+import androidx.annotation.NonNull;
+import androidx.annotation.VisibleForTesting;
 import androidx.core.app.TaskStackBuilder;
 
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
 import de.dennisguse.opentracks.R;
-import de.dennisguse.opentracks.TrackDetailActivity;
 import de.dennisguse.opentracks.TrackListActivity;
+import de.dennisguse.opentracks.TrackRecordingActivity;
 import de.dennisguse.opentracks.content.data.Track;
 import de.dennisguse.opentracks.content.data.TrackPoint;
 import de.dennisguse.opentracks.content.data.Waypoint;
@@ -59,6 +61,7 @@ import de.dennisguse.opentracks.util.PreferencesUtils;
 import de.dennisguse.opentracks.util.SystemUtils;
 import de.dennisguse.opentracks.util.TrackIconUtils;
 import de.dennisguse.opentracks.util.TrackNameUtils;
+import de.dennisguse.opentracks.util.TrackPointUtils;
 import de.dennisguse.opentracks.util.UnitConversions;
 
 /**
@@ -69,13 +72,11 @@ import de.dennisguse.opentracks.util.UnitConversions;
  */
 public class TrackRecordingService extends Service {
 
-    // Anything faster than that (in meters per second) will be considered moving.
     private static final String TAG = TrackRecordingService.class.getSimpleName();
 
-    public static final double MAX_NO_MOVEMENT_SPEED = 0.224;
-
     // The following variables are set in onCreate:
-    private ExecutorService executorService;
+    @Deprecated //TODO Should not be necessary
+    private ExecutorService locationExecutorService; // Enforces order of location changes.
     private ContentProviderUtils contentProviderUtils;
     private LocationManager locationManager;
     private PeriodicTaskExecutor voiceExecutor;
@@ -139,7 +140,6 @@ public class TrackRecordingService extends Service {
 
     private TrackStatisticsUpdater trackStatisticsUpdater;
     private TrackPoint lastTrackPoint;
-    private boolean currentSegmentHasLocation;
     private boolean isIdle;
 
     private TrackRecordingServiceBinder binder = new TrackRecordingServiceBinder(this);
@@ -147,10 +147,10 @@ public class TrackRecordingService extends Service {
 
         @Override
         public void onLocationChanged(final Location location) {
-            if (executorService == null || executorService.isShutdown() || executorService.isTerminated()) {
+            if (locationExecutorService == null || locationExecutorService.isShutdown() || locationExecutorService.isTerminated()) {
                 return;
             }
-            executorService.submit(new Runnable() {
+            locationExecutorService.submit(new Runnable() {
                 @Override
                 public void run() {
                     onLocationChangedAsync(location);
@@ -177,7 +177,7 @@ public class TrackRecordingService extends Service {
     @Override
     public void onCreate() {
         super.onCreate();
-        executorService = Executors.newSingleThreadExecutor();
+        locationExecutorService = Executors.newSingleThreadExecutor();
         contentProviderUtils = new ContentProviderUtils(this);
         locationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
         voiceExecutor = new PeriodicTaskExecutor(this, new AnnouncementPeriodicTaskFactory());
@@ -190,17 +190,7 @@ public class TrackRecordingService extends Service {
         PreferencesUtils.register(this, sharedPreferenceChangeListener);
         sharedPreferenceChangeListener.onSharedPreferenceChanged(null, null);
 
-        // Try to restart the previous recording track in case the service has been restarted by the system, which can sometimes happen.
-        Track track = contentProviderUtils.getTrack(recordingTrackId);
-        if (track != null) {
-            restartTrack(track);
-        } else {
-            if (isRecording()) {
-                Log.w(TAG, "track is null, but recordingTrackId not -1L. " + recordingTrackId);
-                updateRecordingState(PreferencesUtils.RECORDING_TRACK_ID_DEFAULT, true);
-            }
-            showNotification(false);
-        }
+        restartTrackAfterServiceRestart();
     }
 
     @Override
@@ -243,7 +233,7 @@ public class TrackRecordingService extends Service {
         wakeLock = SystemUtils.releaseWakeLock(wakeLock);
 
         // Shutdown the executorService last to avoid sending events to a dead executor.
-        executorService.shutdown();
+        locationExecutorService.shutdown();
         super.onDestroy();
     }
 
@@ -367,8 +357,8 @@ public class TrackRecordingService extends Service {
         track.getTrackStatistics().setStopTime_ms(System.currentTimeMillis());
         trackStatisticsUpdater = new TrackStatisticsUpdater(track.getTrackStatistics());
 
-        insertTrackPoint(track, TrackPoint.createPause(), null);
-        insertTrackPoint(track, TrackPoint.createResume(), null);
+        insertTrackPoint(track, TrackPoint.createPause());
+        insertTrackPoint(track, TrackPoint.createResume());
 
         // Update shared preferences.
         updateRecordingState(trackId, false);
@@ -376,13 +366,26 @@ public class TrackRecordingService extends Service {
         startRecording();
     }
 
-    private void restartTrack(Track track) {
+    /**
+     * Try to restart the previous recording track in case the service has been restarted by the system, which can sometimes happen.
+     */
+    private void restartTrackAfterServiceRestart() {
+        Track track = contentProviderUtils.getTrack(recordingTrackId);
+        if (track == null) {
+            if (isRecording()) {
+                Log.w(TAG, "track is null, but recordingTrackId not -1L. " + recordingTrackId);
+                updateRecordingState(PreferencesUtils.RECORDING_TRACK_ID_DEFAULT, true);
+            }
+            showNotification(false);
+            return;
+        }
+
         Log.d(TAG, "Restarting track: " + track.getId());
 
         trackStatisticsUpdater = new TrackStatisticsUpdater(track.getTrackStatistics().getStartTime_ms());
 
-        try (TrackPointIterator locationIterator = contentProviderUtils.getTrackPointLocationIterator(track.getId(), -1L, false)) {
-            trackStatisticsUpdater.addTrackPoint(locationIterator, recordingDistanceInterval);
+        try (TrackPointIterator trackPointIterator = contentProviderUtils.getTrackPointLocationIterator(track.getId(), -1L, false)) {
+            trackStatisticsUpdater.addTrackPoint(trackPointIterator, recordingDistanceInterval);
         } catch (RuntimeException e) {
             Log.e(TAG, "RuntimeException", e);
         }
@@ -395,14 +398,12 @@ public class TrackRecordingService extends Service {
             return;
         }
 
-        // Update shared preferences
-        recordingTrackPaused = false;
-        PreferencesUtils.setBoolean(this, R.string.recording_track_paused_key, false);
+        updateRecordingState(recordingTrackId, false);
 
         // Update database
         Track track = contentProviderUtils.getTrack(recordingTrackId);
         if (track != null) {
-            insertTrackPoint(track, TrackPoint.createResume(), null);
+            insertTrackPoint(track, TrackPoint.createResume());
         }
 
         startRecording();
@@ -416,7 +417,6 @@ public class TrackRecordingService extends Service {
         remoteSensorManager = new BluetoothRemoteSensorManager(this);
         remoteSensorManager.start();
         lastTrackPoint = null;
-        currentSegmentHasLocation = false;
         isIdle = false;
 
         startGps();
@@ -445,26 +445,21 @@ public class TrackRecordingService extends Service {
 
         // Need to remember the recordingTrackId before setting it to -1L
         long trackId = recordingTrackId;
-        boolean paused = recordingTrackPaused;
+        boolean wasPaused = recordingTrackPaused;
 
-        // Update shared preferences
         updateRecordingState(PreferencesUtils.RECORDING_TRACK_ID_DEFAULT, true);
 
         // Update database
         Track track = contentProviderUtils.getTrack(trackId);
         if (track != null) {
-            // If not paused, add the last location
-            if (!paused) {
-                insertTrackPoint(track, lastTrackPoint, getLastValidTrackPointInCurrentSegment(trackId));
+            // If not wasPaused, add the last location
+            if (!wasPaused) {
+                if (lastTrackPoint != null) {
+                    insertTrackPointIfNewer(track, lastTrackPoint);
+                }
 
                 // Update the recording track time
-                updateRecordingTrack(track);
-            }
-
-            String trackName = TrackNameUtils.getTrackName(this, trackId, track.getTrackStatistics().getStartTime_ms());
-            if (trackName != null && !trackName.equals(track.getName())) {
-                track.setName(trackName);
-                contentProviderUtils.updateTrack(track);
+                updateTrackTotalTime(track);
             }
         }
         endRecording(true);
@@ -476,16 +471,15 @@ public class TrackRecordingService extends Service {
             return;
         }
 
-        // Update shared preferences
-        recordingTrackPaused = true;
-        PreferencesUtils.setBoolean(this, R.string.recording_track_paused_key, true);
+        updateRecordingState(recordingTrackId, true);
 
         // Update database
         Track track = contentProviderUtils.getTrack(recordingTrackId);
         if (track != null) {
-            insertTrackPoint(track, lastTrackPoint, getLastValidTrackPointInCurrentSegment(track.getId()));
-
-            insertTrackPoint(track, TrackPoint.createPause(), null);
+            if (lastTrackPoint != null) {
+                insertTrackPointIfNewer(track, lastTrackPoint);
+            }
+            insertTrackPoint(track, TrackPoint.createPause());
         }
 
         endRecording(false);
@@ -535,14 +529,19 @@ public class TrackRecordingService extends Service {
      * @return the location or null
      */
     private TrackPoint getLastValidTrackPointInCurrentSegment(long trackId) {
-        if (!currentSegmentHasLocation) {
+        if (!currentSegmentHasTrackPoint()) {
             return null;
         }
         return contentProviderUtils.getLastValidTrackPoint(trackId);
     }
 
+    private boolean currentSegmentHasTrackPoint() {
+        return lastTrackPoint != null;
+    }
+
     /**
      * Updates the recording states.
+     * This will inform subscribed {@link OnSharedPreferenceChangeListener}.
      *
      * @param trackId the recording track id
      * @param paused  true if the recording is paused
@@ -571,93 +570,118 @@ public class TrackRecordingService extends Service {
             return;
         }
 
-        TrackPoint trackPoint = new TrackPoint(location, getSensorDataSet());
+        TrackPoint trackPoint = new TrackPoint(location);
+        fillWithSensorDataSet(trackPoint);
+
         notificationManager.updateTrackPoint(this, trackPoint, recordingGpsAccuracy);
 
-        if (!location.hasAccuracy() || location.getAccuracy() >= recordingGpsAccuracy) {
+        if (!TrackPointUtils.fulfillsAccuracy(trackPoint, recordingGpsAccuracy)) {
             Log.d(TAG, "Ignore onLocationChangedAsync. Poor accuracy.");
             return;
         }
 
-        //TODO Necessary?
-        // Fix for phones that do not set the time field
-        if (location.getTime() == 0L) {
-            location.setTime(System.currentTimeMillis());
-        }
+        TrackPointUtils.fixTime(trackPoint);
 
+        //TODO Figure out how to avoid loading the lastValidTrackPoint from the database
         TrackPoint lastValidTrackPoint = getLastValidTrackPointInCurrentSegment(track.getId());
         long idleTime = 0L;
-        if (lastValidTrackPoint != null && location.getTime() > lastValidTrackPoint.getLocation().getTime()) {
-            idleTime = location.getTime() - lastValidTrackPoint.getLocation().getTime();
+        if (TrackPointUtils.after(trackPoint, lastValidTrackPoint)) {
+            idleTime = trackPoint.getTime() - lastValidTrackPoint.getTime();
         }
+
         locationListenerPolicy.updateIdleTime(idleTime);
         if (currentRecordingInterval != locationListenerPolicy.getDesiredPollingInterval()) {
             registerLocationListener();
         }
 
+        //Storing trackPoint
 
         // Always insert the first segment location
-        if (!currentSegmentHasLocation) {
-            insertTrackPoint(track, trackPoint, null);
-            currentSegmentHasLocation = true;
+        if (!currentSegmentHasTrackPoint()) {
+            insertTrackPoint(track, trackPoint);
             lastTrackPoint = trackPoint;
             return;
         }
 
         if (!LocationUtils.isValidLocation(lastValidTrackPoint.getLocation())) {
+            // For some reason the previous first trackPoint was not stored, but currentSegmentHasLocation set true.
             // Should not happen. The current segment should have a location. Just insert the current location.
-            insertTrackPoint(track, trackPoint, null);
+            insertTrackPoint(track, trackPoint);
             lastTrackPoint = trackPoint;
             return;
         }
 
-        double distanceToLastTrackLocation = location.distanceTo(lastValidTrackPoint.getLocation());
+        double distanceToLastTrackLocation = trackPoint.distanceTo(lastValidTrackPoint);
         if (distanceToLastTrackLocation > maxRecordingDistance) {
-            insertTrackPoint(track, lastTrackPoint, lastValidTrackPoint);
-            insertTrackPoint(track, TrackPoint.createPause(), null);
+            insertTrackPointIfNewer(track, lastTrackPoint);
+            insertTrackPoint(track, TrackPoint.createPause());
 
-            insertTrackPoint(track, trackPoint, null);
+            insertTrackPoint(track, trackPoint);
             isIdle = false;
-        } else if (trackPoint.getSensorDataSet() != null || distanceToLastTrackLocation >= recordingDistanceInterval) {
-            insertTrackPoint(track, lastTrackPoint, lastValidTrackPoint);
-            insertTrackPoint(track, trackPoint, null);
-            isIdle = false;
-        } else if (!isIdle && location.hasSpeed() && location.getSpeed() < MAX_NO_MOVEMENT_SPEED) {
-            insertTrackPoint(track, lastTrackPoint, lastValidTrackPoint);
-            insertTrackPoint(track, trackPoint, null);
-            isIdle = true;
-        } else if (isIdle && location.hasSpeed() && location.getSpeed() >= MAX_NO_MOVEMENT_SPEED) {
-            insertTrackPoint(track, lastTrackPoint, lastValidTrackPoint);
-            insertTrackPoint(track, trackPoint, null);
-            isIdle = false;
-        } else {
-            Log.d(TAG, "Not recording location, idle");
+
+            lastTrackPoint = trackPoint;
+            return;
         }
+
+        if (trackPoint.hasSensorData() || distanceToLastTrackLocation >= recordingDistanceInterval) {
+            insertTrackPointIfNewer(track, lastTrackPoint);
+            insertTrackPoint(track, trackPoint);
+            isIdle = false;
+
+            lastTrackPoint = trackPoint;
+            return;
+        }
+
+        if (!isIdle && !TrackPointUtils.isMoving(trackPoint)) {
+            insertTrackPointIfNewer(track, lastTrackPoint);
+            insertTrackPoint(track, trackPoint);
+            isIdle = true;
+
+            lastTrackPoint = trackPoint;
+            return;
+        }
+
+        if (isIdle && TrackPointUtils.isMoving(trackPoint)) {
+            insertTrackPointIfNewer(track, lastTrackPoint);
+            insertTrackPoint(track, trackPoint);
+            isIdle = false;
+
+            lastTrackPoint = trackPoint;
+            return;
+        }
+
+        Log.d(TAG, "Not recording TrackPoint, idle");
         lastTrackPoint = trackPoint;
     }
 
+    /**
+     * Inserts a trackPoint if this trackPoint is different than lastValidTrackPoint.
+     *
+     * @param track      the track
+     * @param trackPoint the trackPoint
+     */
+    private void insertTrackPointIfNewer(@NonNull Track track, @NonNull TrackPoint trackPoint) {
+        TrackPoint lastValidTrackPoint = getLastValidTrackPointInCurrentSegment(track.getId());
+        if (TrackPointUtils.equalTime(trackPoint, lastValidTrackPoint)) {
+            // Do not insert if inserted already
+            Log.w(TAG, "Ignore insertTrackPoint. trackPoint time same as last valid track point time.");
+            return;
+        }
+
+        insertTrackPoint(track, trackPoint);
+    }
+
     /**
      * Inserts a trackPoint.
      *
-     * @param track               the track
-     * @param trackPoint          the trackPoint
-     * @param lastValidTrackPoint the last valid track point, can be null
+     * @param track      the track
+     * @param trackPoint the trackPoint
      */
-    private void insertTrackPoint(Track track, TrackPoint trackPoint, TrackPoint lastValidTrackPoint) {
-        if (trackPoint == null) {
-            Log.w(TAG, "Ignore insertLocation. trackPoint is null.");
-            return;
-        }
-        // Do not insert if inserted already
-        if (lastValidTrackPoint != null && lastValidTrackPoint.getTime() == trackPoint.getTime()) {
-            Log.w(TAG, "Ignore insertLocation. trackPoint time same as last valid track point time.");
-            return;
-        }
-
+    private void insertTrackPoint(@NonNull Track track, @NonNull TrackPoint trackPoint) {
         try {
             contentProviderUtils.insertTrackPoint(trackPoint, track.getId());
             trackStatisticsUpdater.addTrackPoint(trackPoint, recordingDistanceInterval);
-            updateRecordingTrack(track);
+            updateTrackTotalTime(track);
         } catch (SQLiteException e) {
             /*
              * Insert failed, most likely because of SqlLite error code 5 (SQLite_BUSY).
@@ -668,22 +692,31 @@ public class TrackRecordingService extends Service {
         voiceExecutor.update();
     }
 
+
     /**
      * Updates the recording track time.
      *
      * @param track the track
      */
-    private void updateRecordingTrack(Track track) {
+    private void updateTrackTotalTime(Track track) {
         trackStatisticsUpdater.updateTime(System.currentTimeMillis());
         track.setTrackStatistics(trackStatisticsUpdater.getTrackStatistics());
         contentProviderUtils.updateTrack(track);
     }
 
     SensorDataSet getSensorDataSet() {
-        if (remoteSensorManager == null || !remoteSensorManager.isEnabled() || !remoteSensorManager.isSensorDataSetValid()) {
+        if (remoteSensorManager == null || !remoteSensorManager.isEnabled()) {
             return null;
         }
-        return remoteSensorManager.getSensorDataSet();
+
+        return remoteSensorManager.getSensorData();
+    }
+
+    private void fillWithSensorDataSet(TrackPoint trackPoint) {
+        SensorDataSet sensorData = getSensorDataSet();
+        if (sensorData != null) {
+            sensorData.fillTrackPoint(trackPoint);
+        }
     }
 
     private void registerLocationListener() {
@@ -710,10 +743,10 @@ public class TrackRecordingService extends Service {
 
     private void showNotification(boolean isGpsStarted) {
         if (isRecording()) {
-            Intent intent = IntentUtils.newIntent(this, TrackDetailActivity.class)
-                    .putExtra(TrackDetailActivity.EXTRA_TRACK_ID, recordingTrackId);
+            Intent intent = IntentUtils.newIntent(this, TrackRecordingActivity.class)
+                    .putExtra(TrackRecordingActivity.EXTRA_TRACK_ID, recordingTrackId);
             PendingIntent pendingIntent = TaskStackBuilder.create(this)
-                    .addParentStack(TrackDetailActivity.class)
+                    .addParentStack(TrackRecordingActivity.class)
                     .addNextIntent(intent)
                     .getPendingIntent(0, PendingIntent.FLAG_UPDATE_CURRENT);
 
@@ -736,4 +769,22 @@ public class TrackRecordingService extends Service {
             notificationManager.cancelNotification();
         }
     }
+
+    /**
+     * Disables processing of location updates from {@link android.location.LocationManager}.
+     */
+    @VisibleForTesting
+    public void enableLocationExecutor(boolean enable) {
+        if (enable) {
+            locationExecutorService = Executors.newSingleThreadExecutor();
+        } else {
+            locationExecutorService.shutdownNow();
+            locationExecutorService = null;
+        }
+    }
+
+    @VisibleForTesting
+    public void setRemoteSensorManager(BluetoothRemoteSensorManager remoteSensorManager) {
+        this.remoteSensorManager = remoteSensorManager;
+    }
 }

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

@@ -5,6 +5,7 @@ import android.location.Location;
 import androidx.annotation.VisibleForTesting;
 
 import de.dennisguse.opentracks.content.sensor.SensorDataSet;
+import de.dennisguse.opentracks.services.sensors.BluetoothRemoteSensorManager;
 
 /**
  * TODO: There is a bug in Android that leaks Binder instances. This bug is
@@ -92,6 +93,18 @@ class TrackRecordingServiceBinder extends android.os.Binder implements TrackReco
         return trackRecordingService.getSensorDataSet();
     }
 
+    @VisibleForTesting
+    @Override
+    public void enableLocationExecutor(boolean enable) {
+        trackRecordingService.enableLocationExecutor(enable);
+    }
+
+    @VisibleForTesting
+    @Override
+    public void setRemoteSensorManager(BluetoothRemoteSensorManager remoteSensorManager) {
+        trackRecordingService.setRemoteSensorManager(remoteSensorManager);
+    }
+
     /**
      * Detaches from the track recording service. Clears the reference to the
      * outer class to minimize the leak.

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

@@ -51,12 +51,14 @@ public class TrackRecordingServiceConnection implements ServiceConnection, Death
 
     private TrackRecordingServiceInterface trackRecordingService;
 
+    public TrackRecordingServiceConnection() {
+        callback = null;
+    }
+
     /**
-     * Constructor.
-     *
      * @param callback the callback to invoke when the service binding changes
      */
-    public TrackRecordingServiceConnection(Runnable callback) {
+    public TrackRecordingServiceConnection(@NonNull Runnable callback) {
         this.callback = callback;
     }
 

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

@@ -20,6 +20,7 @@ import android.location.Location;
 import androidx.annotation.VisibleForTesting;
 
 import de.dennisguse.opentracks.content.sensor.SensorDataSet;
+import de.dennisguse.opentracks.services.sensors.BluetoothRemoteSensorManager;
 
 /**
  * App's service.
@@ -46,8 +47,6 @@ public interface TrackRecordingServiceInterface {
 
     /**
      * Resumes the track identified by trackId.
-     *
-     * @param trackId
      */
     void resumeTrack(long trackId);
 
@@ -94,8 +93,13 @@ public interface TrackRecordingServiceInterface {
     long insertWaypoint(String name, String category, String description, String photoUrl);
 
     /**
-     * ONLY FOR TESTING
+     * Gets the current sensor data. Returns null if there is no data.
      *
+     * @return SensorDataSet object.
+     */
+    SensorDataSet getSensorData();
+
+    /**
      * Inserts a location in the current recording track.
      * <p>
      * When recording a track, GPS locations are automatically inserted.
@@ -107,9 +111,11 @@ public interface TrackRecordingServiceInterface {
     void insertLocation(Location location);
 
     /**
-     * Gets the current sensor data. Returns null if there is no data.
-     *
-     * @return SensorDataSet object.
+     * Disables processing of location updates from {@link android.location.LocationManager}.
      */
-    SensorDataSet getSensorData();
+    @VisibleForTesting
+    void enableLocationExecutor(boolean enable);
+
+    @VisibleForTesting
+    void setRemoteSensorManager(BluetoothRemoteSensorManager remoteSensorManager);
 }

src/main/java/de/dennisguse/opentracks/services/sensors/BluetoothConnectionManager.java

@@ -24,40 +24,30 @@ import android.bluetooth.BluetoothGattDescriptor;
 import android.bluetooth.BluetoothGattService;
 import android.bluetooth.BluetoothProfile;
 import android.content.Context;
-import android.os.Handler;
 import android.util.Log;
 
 import androidx.annotation.NonNull;
 
 import java.util.UUID;
 
-import de.dennisguse.opentracks.content.sensor.SensorDataSet;
-import de.dennisguse.opentracks.content.sensor.SensorState;
+import de.dennisguse.opentracks.content.sensor.SensorData;
+import de.dennisguse.opentracks.content.sensor.SensorDataCycling;
+import de.dennisguse.opentracks.content.sensor.SensorDataHeartRate;
 import de.dennisguse.opentracks.util.BluetoothUtils;
 
 /**
- * Manages connection to Bluetooth LE heart rate monitor.
+ * Manages connection to a Bluetooth LE sensor and subscribes for onChange-notifications.
+ * Also parses the transferred data into {@link SensorDataObserver}.
  */
-public class BluetoothConnectionManager {
-
-    // Message types sent to handler
-    static final int MESSAGE_CONNECTING = 1;
-    static final int MESSAGE_CONNECTED = 2;
-    static final int MESSAGE_READ = 3;
-    static final int MESSAGE_DISCONNECTED = 4;
-
-    private static final UUID HEART_RATE_MEASUREMENT_CHAR_UUID = new UUID(0x2A3700001000L, 0x800000805f9b34fbL);
-    private static final UUID CLIENT_CHARACTERISTIC_CONFIG_UUID = new UUID(0x290200001000L, 0x800000805f9b34fbL);
+public abstract class BluetoothConnectionManager {
 
     private static final String TAG = BluetoothConnectionManager.class.getSimpleName();
 
-    private final Context context;
-    private final Handler handler;
-
-    private SensorState sensorState;
+    private final SensorDataObserver observer;
 
+    private final UUID serviceUUUID;
+    private final UUID measurementUUID;
     private BluetoothGatt bluetoothGatt;
-    private final BluetoothDevice bluetoothDevice;
 
     private final BluetoothGattCallback connectCallback = new BluetoothGattCallback() {
         @Override
@@ -65,86 +55,70 @@ public class BluetoothConnectionManager {
             switch (newState) {
                 case BluetoothProfile.STATE_CONNECTING:
                     Log.d(TAG, "Connecting to sensor: " + gatt.getDevice());
-                    setState(SensorState.CONNECTING);
-
-                    handler.obtainMessage(MESSAGE_CONNECTING, gatt.getDevice().getName()).sendToTarget();
                 case BluetoothProfile.STATE_CONNECTED:
                     Log.d(TAG, "Connected to sensor: " + gatt.getDevice());
-                    setState(SensorState.CONNECTED);
 
                     gatt.discoverServices();
-
-                    handler.obtainMessage(MESSAGE_CONNECTED, gatt.getDevice().getName()).sendToTarget();
                     break;
                 case BluetoothProfile.STATE_DISCONNECTING:
                     Log.d(TAG, "Disconnecting from sensor: " + gatt.getDevice());
-                    setState(SensorState.DISCONNECTING);
 
                 case BluetoothProfile.STATE_DISCONNECTED:
                     Log.d(TAG, "Disconnected from sensor: " + gatt.getDevice());
-                    setState(SensorState.DISCONNECTED);
-
-                    handler.obtainMessage(MESSAGE_DISCONNECTED, gatt.getDevice().getName()).sendToTarget();
             }
         }
 
         @Override
         public void onServicesDiscovered(@NonNull BluetoothGatt gatt, int status) {
-            BluetoothGattService service = gatt.getService(BluetoothUtils.HEART_RATE_SERVICE_UUID);
+            BluetoothGattService service = gatt.getService(serviceUUUID);
             if (service == null) {
-                Log.e(TAG, "Could not get heart rate service for " + gatt.getDevice().getAddress());
+                Log.e(TAG, "Could not get service for address=" + gatt.getDevice().getAddress() + " serviceUUID=" + serviceUUUID);
                 return;
             }
 
-
-            BluetoothGattCharacteristic characteristic = service.getCharacteristic(HEART_RATE_MEASUREMENT_CHAR_UUID);
+            BluetoothGattCharacteristic characteristic = service.getCharacteristic(measurementUUID);
             if (characteristic == null) {
-                Log.e(TAG, "Could not get BluetoothCharacteristic for " + gatt.getDevice().getAddress());
+                Log.e(TAG, "Could not get BluetoothCharacteristic for address=" + gatt.getDevice().getAddress() + " serviceUUID=" + serviceUUUID + " characteristicUUID=" + measurementUUID);
                 return;
             }
             gatt.setCharacteristicNotification(characteristic, true);
 
-            BluetoothGattDescriptor descriptor = characteristic.getDescriptor(CLIENT_CHARACTERISTIC_CONFIG_UUID);
+            // Register for updates.
+            BluetoothGattDescriptor descriptor = characteristic.getDescriptor(BluetoothUtils.CLIENT_CHARACTERISTIC_CONFIG_UUID);
             descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
             gatt.writeDescriptor(descriptor);
         }
 
         @Override
         public void onCharacteristicChanged(BluetoothGatt gatt, @NonNull BluetoothGattCharacteristic characteristic) {
-            int heartRate = BluetoothUtils.parseHeartRate(characteristic);
-            String deviceName = gatt.getDevice().getName();
+            String sensorName = gatt.getDevice().getName();
+            Log.d(TAG, "Received data from " + sensorName);
 
-            Log.d(TAG, "Received heart beat rate " + deviceName + ": " + heartRate);
-            SensorDataSet sensorDataSet = new SensorDataSet(heartRate, deviceName, gatt.getDevice().getAddress());
-            handler.obtainMessage(MESSAGE_READ, sensorDataSet).sendToTarget();
+            SensorData sensorData = parsePayload(sensorName, gatt.getDevice().getAddress(), characteristic);
+            if (sensorData != null) {
+                observer.onChanged(sensorData);
+            }
         }
     };
 
-    /**
-     * Constructor.
-     *
-     * @param handler a handler for sending messages back to the UI activity
-     */
-    BluetoothConnectionManager(@NonNull Context context, @NonNull BluetoothDevice bluetoothDevice, @NonNull Handler handler) {
-        this.context = context;
-        this.bluetoothDevice = bluetoothDevice;
-        this.handler = handler;
-        this.sensorState = SensorState.NONE;
+    BluetoothConnectionManager(UUID serviceUUUID, UUID measurementUUID, SensorDataObserver observer) {
+        this.serviceUUUID = serviceUUUID;
+        this.measurementUUID = measurementUUID;
+        this.observer = observer;
     }
 
-    public synchronized void connect() {
+    synchronized void connect(Context context, @NonNull BluetoothDevice device) {
         if (bluetoothGatt != null) {
             Log.w(TAG, "Already connected; ignoring.");
         }
 
-        Log.d(TAG, "Connecting to: " + bluetoothDevice);
+        Log.d(TAG, "Connecting to: " + device);
 
-        bluetoothGatt = bluetoothDevice.connectGatt(this.context, true, this.connectCallback);
+        bluetoothGatt = device.connectGatt(context, true, this.connectCallback);
 
-        setState(SensorState.CONNECTING);
     }
 
-    public synchronized void disconnect() {
+    synchronized void disconnect() {
         if (bluetoothGatt == null) {
             Log.w(TAG, "Cannot disconnect if not connected.");
             return;
@@ -153,15 +127,78 @@ public class BluetoothConnectionManager {
         bluetoothGatt = null;
     }
 
-    public synchronized boolean isSameBluetoothDevice(String address) {
-        return this.bluetoothDevice.getAddress().equals(address);
+    synchronized boolean isSameBluetoothDevice(String address) {
+        if (bluetoothGatt == null) {
+            return false;
+        }
+
+        return address.equals(bluetoothGatt.getDevice().getAddress());
     }
 
-    synchronized SensorState getSensorState() {
-        return sensorState;
+    /**
+     * @return null if data could not be parsed.
+     */
+    protected abstract de.dennisguse.opentracks.content.sensor.SensorData parsePayload(String sensorName, String address, BluetoothGattCharacteristic characteristic);
+
+    public static class HeartRate extends BluetoothConnectionManager {
+
+        HeartRate(@NonNull SensorDataObserver observer) {
+            super(BluetoothUtils.HEART_RATE_SERVICE_UUID, BluetoothUtils.HEART_RATE_MEASUREMENT_CHAR_UUID, observer);
+        }
+
+        @Override
+        protected SensorDataHeartRate parsePayload(String sensorName, String address, BluetoothGattCharacteristic characteristic) {
+            Integer heartRate = BluetoothUtils.parseHeartRate(characteristic);
+
+            return heartRate != null ? new SensorDataHeartRate(address, sensorName, heartRate) : null;
+        }
     }
 
-    private synchronized void setState(SensorState sensorState) {
-        this.sensorState = sensorState;
+    public static class CyclingCadence extends BluetoothConnectionManager {
+
+        CyclingCadence(SensorDataObserver observer) {
+            super(BluetoothUtils.CYCLING_SPEED_CADENCE_SERVICE_UUID, BluetoothUtils.CYCLING_SPPED_CADENCE_MEASUREMENT_CHAR_UUID, observer);
+        }
+
+        @Override
+        protected SensorDataCycling.Cadence parsePayload(String sensorName, String address, BluetoothGattCharacteristic characteristic) {
+            SensorDataCycling.CadenceAndSpeed cadenceAndSpeed = BluetoothUtils.parseCyclingCrankAndWheel(address, sensorName, characteristic);
+            if (cadenceAndSpeed == null) {
+                return null;
+            }
+
+            if (cadenceAndSpeed.getCadence() != null) {
+                return cadenceAndSpeed.getCadence();
+            }
+
+            //Workaround for Wahoo CADENCE: this sensor reports speed (instead of cadence)
+            if (cadenceAndSpeed.getSpeed() != null) {
+                return new SensorDataCycling.Cadence(cadenceAndSpeed.getSpeed());
+            }
+
+            return null;
+        }
+    }
+
+    public static class CyclingSpeed extends BluetoothConnectionManager {
+
+        CyclingSpeed(SensorDataObserver observer) {
+            super(BluetoothUtils.CYCLING_SPEED_CADENCE_SERVICE_UUID, BluetoothUtils.CYCLING_SPPED_CADENCE_MEASUREMENT_CHAR_UUID, observer);
+        }
+
+        @Override
+        protected SensorDataCycling.Speed parsePayload(String sensorName, String address, BluetoothGattCharacteristic characteristic) {
+            SensorDataCycling.CadenceAndSpeed cadenceAndSpeed = BluetoothUtils.parseCyclingCrankAndWheel(address, sensorName, characteristic);
+            if (cadenceAndSpeed != null) {
+                return cadenceAndSpeed.getSpeed();
+            }
+            return null;
+        }
+    }
+
+    interface SensorDataObserver {
+
+        void onChanged(SensorData sensorData);
+
     }
 }

src/main/java/de/dennisguse/opentracks/services/sensors/BluetoothRemoteSensorManager.java

@@ -20,90 +20,72 @@ import android.bluetooth.BluetoothAdapter;
 import android.bluetooth.BluetoothDevice;
 import android.content.Context;
 import android.content.SharedPreferences;
-import android.os.Handler;
-import android.os.Looper;
-import android.os.Message;
 import android.util.Log;
-import android.widget.Toast;
 
 import de.dennisguse.opentracks.R;
+import de.dennisguse.opentracks.content.sensor.SensorData;
+import de.dennisguse.opentracks.content.sensor.SensorDataCycling;
 import de.dennisguse.opentracks.content.sensor.SensorDataSet;
 import de.dennisguse.opentracks.util.BluetoothUtils;
 import de.dennisguse.opentracks.util.PreferencesUtils;
+import de.dennisguse.opentracks.util.UnitConversions;
 
 /**
- * Bluetooth LE sensor manager.
- * Should only be instantiated once!
+ * Bluetooth LE sensor manager: manages connections to Bluetooth LE sensors.
+ * <p>
+ * Note: should only be instantiated once.
+ * <p>
+ * TODO: listen for Bluetooth enabled/disabled events.
+ * <p>
+ * TODO: In case, a cycling (Cadence and Speed) sensor reports both values, testing is required.
+ * We establish two GATT separate GATT connections (as if two different sensors were used).
+ * However, it is not clear if this is allowed.
+ * Even if this works, it is not clear what happens if a user (while recording) changes one of the sensors in the settings as this will trigger a disconnect of one GATT.
  *
  * @author Sandor Dornbush
  */
-public class BluetoothRemoteSensorManager {
+public class BluetoothRemoteSensorManager implements BluetoothConnectionManager.SensorDataObserver {
 
-    public static final long MAX_SENSOR_DATE_SET_AGE_MS = 5000;
+    private static final String TAG = BluetoothRemoteSensorManager.class.getSimpleName();
 
-    private static final String TAG = BluetoothConnectionManager.class.getSimpleName();
+    public static final long MAX_SENSOR_DATE_SET_AGE_MS = 5 * UnitConversions.S_TO_MS;
 
     private static final BluetoothAdapter bluetoothAdapter = BluetoothUtils.getDefaultBluetoothAdapter(TAG);
 
     private final Context context;
-
     private final SharedPreferences sharedPreferences;
 
-    // Handler that gets information back from the bluetoothConnectionManager
-    private final Handler messageHandler = new Handler(Looper.getMainLooper()) {
-        @Override
-        public void handleMessage(Message message) {
-            String toastMessage;
-            switch (message.what) {
-                case BluetoothConnectionManager.MESSAGE_CONNECTING:
-                    //Ignore for now.
-                    toastMessage = context.getString(R.string.settings_sensor_connecting, message.obj);
-                    Toast.makeText(context, toastMessage, Toast.LENGTH_LONG).show();
-                    break;
-                case BluetoothConnectionManager.MESSAGE_CONNECTED:
-                    toastMessage = context.getString(R.string.settings_sensor_connected, message.obj);
-                    Toast.makeText(context, toastMessage, Toast.LENGTH_LONG).show();
-                    break;
-                case BluetoothConnectionManager.MESSAGE_READ:
-                    if (!(message.obj instanceof SensorDataSet)) {
-                        Log.e(TAG, "Received message did not contain a SensorDataSet.");
-                        sensorDataSet = null;
-                    } else {
-                        sensorDataSet = (SensorDataSet) message.obj;
-                    }
-                    break;
-                case BluetoothConnectionManager.MESSAGE_DISCONNECTED:
-                    toastMessage = context.getString(R.string.settings_sensor_disconnected, message.obj);
-                    Toast.makeText(context, toastMessage, Toast.LENGTH_LONG).show();
-                    break;
-                default:
-                    Log.e(TAG, "Got an undefined case. Please check.");
-                    break;
-            }
-        }
-    };
+    private boolean started = false;
+
+    private final BluetoothConnectionManager.HeartRate heartRate = new BluetoothConnectionManager.HeartRate(this);
+    private final BluetoothConnectionManager.CyclingCadence cyclingCadence = new BluetoothConnectionManager.CyclingCadence(this);
+    private final BluetoothConnectionManager.CyclingSpeed cyclingSpeed = new BluetoothConnectionManager.CyclingSpeed(this);
+
+    private final SensorDataSet sensorDataSet = new SensorDataSet();
+
     private final SharedPreferences.OnSharedPreferenceChangeListener sharedPreferenceChangeListener = new SharedPreferences.OnSharedPreferenceChangeListener() {
         @Override
         public void onSharedPreferenceChanged(SharedPreferences preferences, String key) {
-            if (bluetoothConnectionManager != null && PreferencesUtils.isKey(context, R.string.settings_sensor_bluetooth_heart_rate_key, key)) {
-                if (PreferencesUtils.isBluetoothHeartRateSensorAddressDefault(context)) {
-                    stop();
-                    return;
-                }
-                String address = PreferencesUtils.getBluetoothHeartRateSensorAddress(context);
-                if (bluetoothConnectionManager.isSameBluetoothDevice(address)) {
-                    return;
-                }
+            if (!started) return;
 
-                disconnect();
-                startCurrentSensor();
+            if (PreferencesUtils.isKey(context, R.string.settings_sensor_bluetooth_heart_rate_key, key)) {
+                String address = PreferencesUtils.getBluetoothHeartRateSensorAddress(context);
+                connect(heartRate, address);
+            }
+
+            if (PreferencesUtils.isKey(context, R.string.settings_sensor_bluetooth_cycling_cadence_key, key)) {
+                String address = PreferencesUtils.getBluetoothCyclingCadenceSensorAddress(context);
+                connect(cyclingCadence, address);
+            }
+
+            if (PreferencesUtils.isKey(context, R.string.settings_sensor_bluetooth_cycling_cadence_key, key)) {
+                String address = PreferencesUtils.getBluetoothCyclingSpeedSensorAddress(context);
+
+                connect(cyclingSpeed, address);
             }
         }
     };
 
-    private SensorDataSet sensorDataSet = null;
-    private BluetoothConnectionManager bluetoothConnectionManager;
-
     /**
      * @param context the context
      */
@@ -113,67 +95,81 @@ public class BluetoothRemoteSensorManager {
     }
 
     public void start() {
+        started = true;
         sharedPreferences.registerOnSharedPreferenceChangeListener(sharedPreferenceChangeListener);
-        startCurrentSensor();
+
+        //Trigger connection startup
+        sharedPreferenceChangeListener.onSharedPreferenceChanged(null, null);
     }
 
-    public void stop() {
-        disconnect();
+    public synchronized void stop() {
+        // Disconnecting
+        heartRate.disconnect();
+        cyclingCadence.disconnect();
+
+        sensorDataSet.clear();
+
         sharedPreferences.unregisterOnSharedPreferenceChangeListener(sharedPreferenceChangeListener);
+        started = false;
     }
 
-
     public boolean isEnabled() {
         return bluetoothAdapter != null && bluetoothAdapter.isEnabled();
     }
 
-    public SensorDataSet getSensorDataSet() {
-        return sensorDataSet;
-    }
-
-    public boolean isSensorDataSetValid() {
-        SensorDataSet sensorDataSet = getSensorDataSet();
-        if (sensorDataSet == null) {
-            return false;
-        }
-        return sensorDataSet.isRecent(MAX_SENSOR_DATE_SET_AGE_MS);
-    }
-
-    private void startCurrentSensor() {
+    private synchronized void connect(BluetoothConnectionManager connectionManager, String address) {
         if (!isEnabled()) {
             Log.w(TAG, "Bluetooth not enabled.");
             return;
         }
 
-        if (PreferencesUtils.isBluetoothHeartRateSensorAddressDefault(context)) {
-            Log.w(TAG, "No bluetooth address.");
+        if (PreferencesUtils.isBluetoothSensorAddressNone(context, address)) {
+            Log.w(TAG, "No Bluetooth address.");
             return;
         }
-        String address = PreferencesUtils.getBluetoothHeartRateSensorAddress(context);
+
+        // Check if there is an ongoing connection; if yes, check if the address changed.
+        if (connectionManager.isSameBluetoothDevice(address)) {
+            return;
+        } else {
+            connectionManager.disconnect();
+        }
+
         Log.i(TAG, "Connecting to bluetooth address: " + address);
-
-        BluetoothDevice device;
         try {
-            device = bluetoothAdapter.getRemoteDevice(address);
+            BluetoothDevice device = bluetoothAdapter.getRemoteDevice(address);
+            connectionManager.connect(context, device);
         } catch (IllegalArgumentException e) {
-            Log.w(TAG, "Unable to get remote device for: " + address, e);
-
-            String toastMessage = context.getString(R.string.sensor_not_known, address);
-            Toast.makeText(context, toastMessage, Toast.LENGTH_LONG).show();
-
-            return;
+            Log.e(TAG, "Unable to get remote device for: " + address, e);
         }
-
-        disconnect();
-
-        bluetoothConnectionManager = new BluetoothConnectionManager(context, device, messageHandler);
-        bluetoothConnectionManager.connect();
     }
 
-    private void disconnect() {
-        if (bluetoothConnectionManager != null) {
-            bluetoothConnectionManager.disconnect();
-            bluetoothConnectionManager = null;
+    public SensorDataSet getSensorData() {
+        return sensorDataSet;
+    }
+
+    @Override
+    public synchronized void onChanged(SensorData sensorData) {
+        if (sensorData instanceof SensorDataCycling.Cadence) {
+            SensorDataCycling.Cadence previous = sensorDataSet.getCyclingCadence();
+            Log.d(TAG, "previous " + previous + "; current" + sensorData);
+
+            if (sensorData.equals(previous)) {
+                Log.d(TAG, "onChanged: cadence data repeated.");
+                return;
+            }
+            ((SensorDataCycling.Cadence) sensorData).compute(previous);
         }
+        if (sensorData instanceof SensorDataCycling.Speed) {
+            SensorDataCycling.Speed previous = sensorDataSet.getCyclingSpeed();
+            Log.d(TAG, "previous " + previous + "; current" + sensorData);
+            if (sensorData.equals(previous)) {
+                Log.d(TAG, "onChanged: speed data repeated.");
+                return;
+            }
+            ((SensorDataCycling.Speed) sensorData).compute(previous, PreferencesUtils.getWheelCircumference(context));
+        }
+
+        sensorDataSet.set(sensorData);
     }
 }

src/main/java/de/dennisguse/opentracks/services/tasks/AnnouncementPeriodicTask.java

@@ -25,9 +25,12 @@ import android.util.Log;
 
 import java.util.Locale;
 
+import de.dennisguse.opentracks.content.data.Track;
+import de.dennisguse.opentracks.content.provider.ContentProviderUtils;
 import de.dennisguse.opentracks.services.TrackRecordingService;
 import de.dennisguse.opentracks.stats.TrackStatistics;
 import de.dennisguse.opentracks.util.AnnouncementUtils;
+import de.dennisguse.opentracks.util.PreferencesUtils;
 
 /**
  * This class will periodically announce the user's {@link TrackStatistics}.
@@ -47,6 +50,8 @@ public class AnnouncementPeriodicTask implements PeriodicTask {
 
     private final AudioManager audioManager;
 
+    private ContentProviderUtils contentProviderUtils;
+
     private final AudioManager.OnAudioFocusChangeListener audioFocusChangeListener = new AudioManager.OnAudioFocusChangeListener() {
         @Override
         public void onAudioFocusChange(int focusChange) {
@@ -103,6 +108,7 @@ public class AnnouncementPeriodicTask implements PeriodicTask {
     AnnouncementPeriodicTask(Context context) {
         this.context = context;
         audioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
+        contentProviderUtils = new ContentProviderUtils(context);
     }
 
     @Override
@@ -157,7 +163,9 @@ public class AnnouncementPeriodicTask implements PeriodicTask {
             Log.i(TAG, "Speech is not allowed at this time.");
             return;
         }
-        String announcement = AnnouncementUtils.getAnnouncement(context, trackStatistics);
+        Track track = contentProviderUtils.getTrack(PreferencesUtils.getRecordingTrackId(context));
+        String category = track != null ? track.getCategory() : "";
+        String announcement = AnnouncementUtils.getAnnouncement(context, trackStatistics, category);
         speakAnnouncement(announcement);
     }
 

src/main/java/de/dennisguse/opentracks/settings/SettingsActivity.java

@@ -11,8 +11,14 @@ import androidx.preference.ListPreference;
 import androidx.preference.Preference;
 import androidx.preference.PreferenceFragmentCompat;
 
+import java.util.Locale;
+
 import de.dennisguse.opentracks.R;
 import de.dennisguse.opentracks.fragments.ChooseActivityTypeDialogFragment;
+import de.dennisguse.opentracks.io.file.TrackFileFormat;
+import de.dennisguse.opentracks.settings.bluetooth.BluetoothLeCyclingCadenceAndSpeedPreference;
+import de.dennisguse.opentracks.settings.bluetooth.BluetoothLeHeartRatePreference;
+import de.dennisguse.opentracks.settings.bluetooth.BluetoothLeSensorPreference;
 import de.dennisguse.opentracks.util.BluetoothUtils;
 import de.dennisguse.opentracks.util.HackUtils;
 import de.dennisguse.opentracks.util.PreferencesUtils;
@@ -86,6 +92,8 @@ public class SettingsActivity extends AppCompatActivity implements ChooseActivit
 
                 setPreferencesFromResource(R.xml.settings, rootKey);
             }
+
+            setExportTrackFileFormatOptions();
         }
 
         @Override
@@ -111,8 +119,10 @@ public class SettingsActivity extends AppCompatActivity implements ChooseActivit
             } else if (preference instanceof ActivityTypePreference) {
                 activityPreferenceDialog = ActivityTypePreference.ActivityPreferenceDialog.newInstance(preference.getKey());
                 dialogFragment = activityPreferenceDialog;
-            } else if (preference instanceof BluetoothLePreference) {
-                dialogFragment = BluetoothLePreference.BluetoothLePreferenceDialog.newInstance(preference.getKey());
+            } else if (preference instanceof BluetoothLeHeartRatePreference) {
+                dialogFragment = BluetoothLeSensorPreference.BluetoothLeSensorPreferenceDialog.newInstance(preference.getKey(), BluetoothUtils.HEART_RATE_SERVICE_UUID);
+            } else if (preference instanceof BluetoothLeCyclingCadenceAndSpeedPreference) {
+                dialogFragment = BluetoothLeSensorPreference.BluetoothLeSensorPreferenceDialog.newInstance(preference.getKey(), BluetoothUtils.CYCLING_SPEED_CADENCE_SERVICE_UUID);
             }
 
             if (dialogFragment != null) {
@@ -139,7 +149,7 @@ public class SettingsActivity extends AppCompatActivity implements ChooseActivit
 
         private void updateBluetooth() {
             // Disable Bluetooth preference if device does not have Bluetooth
-            BluetoothLePreference bluetoothPreference = findPreference(getString(R.string.settings_sensor_bluetooth_heart_rate_key));
+            BluetoothLeSensorPreference bluetoothPreference = findPreference(getString(R.string.settings_sensor_bluetooth_heart_rate_key));
             bluetoothPreference.setVisible(BluetoothUtils.hasBluetooth(TAG));
         }
 
@@ -167,5 +177,24 @@ public class SettingsActivity extends AppCompatActivity implements ChooseActivit
 
             HackUtils.invalidatePreference(statsRatePreferences);
         }
+
+
+        private void setExportTrackFileFormatOptions() {
+            final TrackFileFormat[] trackFileFormats = {TrackFileFormat.KMZ_WITH_TRACKDETAIL_AND_SENSORDATA_AND_PICTURES, TrackFileFormat.KMZ_WITH_TRACKDETAIL_AND_SENSORDATA, TrackFileFormat.KML_WITH_TRACKDETAIL_AND_SENSORDATA, TrackFileFormat.GPX};
+            String[] entries = new String[trackFileFormats.length];
+            String[] entryValues = new String[trackFileFormats.length];
+
+            for (int i = 0; i < entries.length; i++) {
+                TrackFileFormat trackFileFormat = trackFileFormats[i];
+                String trackFileFormatUpperCase = trackFileFormat.getExtension().toUpperCase(Locale.US); //ASCII upper case
+                int photoMessageId = trackFileFormat.includesPhotos() ? R.string.export_with_photos : R.string.export_without_photos;
+                entries[i] = String.format("%s (%s)", trackFileFormatUpperCase, getString(photoMessageId));
+                entryValues[i] = trackFileFormat.name();
+            }
+
+            ListPreference listPreference = findPreference(getString(R.string.export_trackfileformat_key));
+            listPreference.setEntries(entries);
+            listPreference.setEntryValues(entryValues);
+        }
     }
 }

src/main/java/de/dennisguse/opentracks/settings/bluetooth/BluetoothLeCyclingCadenceAndSpeedPreference.java

@@ -0,0 +1,23 @@
+package de.dennisguse.opentracks.settings.bluetooth;
+
+import android.content.Context;
+import android.util.AttributeSet;
+
+public class BluetoothLeCyclingCadenceAndSpeedPreference extends BluetoothLeSensorPreference {
+
+    public BluetoothLeCyclingCadenceAndSpeedPreference(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
+        super(context, attrs, defStyleAttr, defStyleRes);
+    }
+
+    public BluetoothLeCyclingCadenceAndSpeedPreference(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+    }
+
+    public BluetoothLeCyclingCadenceAndSpeedPreference(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public BluetoothLeCyclingCadenceAndSpeedPreference(Context context) {
+        super(context);
+    }
+}

src/main/java/de/dennisguse/opentracks/settings/bluetooth/BluetoothLeHeartRatePreference.java

@@ -0,0 +1,23 @@
+package de.dennisguse.opentracks.settings.bluetooth;
+
+import android.content.Context;
+import android.util.AttributeSet;
+
+public class BluetoothLeHeartRatePreference extends BluetoothLeSensorPreference {
+
+    public BluetoothLeHeartRatePreference(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
+        super(context, attrs, defStyleAttr, defStyleRes);
+    }
+
+    public BluetoothLeHeartRatePreference(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+    }
+
+    public BluetoothLeHeartRatePreference(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public BluetoothLeHeartRatePreference(Context context) {
+        super(context);
+    }
+}

src/main/java/de/dennisguse/opentracks/settings/bluetooth/BluetoothLeSensorPreference.java

@@ -1,4 +1,4 @@
-package de.dennisguse.opentracks.settings;
+package de.dennisguse.opentracks.settings.bluetooth;
 
 import android.bluetooth.BluetoothAdapter;
 import android.bluetooth.le.BluetoothLeScanner;
@@ -21,8 +21,10 @@ import androidx.preference.PreferenceDialogFragmentCompat;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.UUID;
 
 import de.dennisguse.opentracks.R;
+import de.dennisguse.opentracks.settings.BluetoothLeAdapter;
 import de.dennisguse.opentracks.util.BluetoothUtils;
 import de.dennisguse.opentracks.util.PreferencesUtils;
 
@@ -30,25 +32,27 @@ import de.dennisguse.opentracks.util.PreferencesUtils;
  * Preference to select a discoverable Bluetooth LE device.
  * Based upon ListPreference.
  */
-public class BluetoothLePreference extends DialogPreference {
+public abstract class BluetoothLeSensorPreference extends DialogPreference {
 
-    private static final String TAG = BluetoothLePreference.class.getSimpleName();
+    private static final String TAG = BluetoothLeSensorPreference.class.getSimpleName();
+
+    private static final String ARG_BLUETOOTH_UUID = "bluetoothUUID";
 
     private static final int DEVICE_NONE_RESOURCEID = R.string.value_none;
 
-    public BluetoothLePreference(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
+    public BluetoothLeSensorPreference(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
         super(context, attrs, defStyleAttr, defStyleRes);
     }
 
-    public BluetoothLePreference(Context context, AttributeSet attrs, int defStyleAttr) {
+    public BluetoothLeSensorPreference(Context context, AttributeSet attrs, int defStyleAttr) {
         super(context, attrs, defStyleAttr);
     }
 
-    public BluetoothLePreference(Context context, AttributeSet attrs) {
+    public BluetoothLeSensorPreference(Context context, AttributeSet attrs) {
         super(context, attrs);
     }
 
-    public BluetoothLePreference(Context context) {
+    public BluetoothLeSensorPreference(Context context) {
         super(context);
     }
 
@@ -78,14 +82,14 @@ public class BluetoothLePreference extends DialogPreference {
 
     @Override
     public CharSequence getSummary() {
-        if (getValue() == null || PreferencesUtils.isBluetoothHeartRateSensorAddressDefault(getContext(), getValue())) {
+        if (getValue() == null || PreferencesUtils.isBluetoothSensorAddressNone(getContext(), getValue())) {
             return getContext().getString(DEVICE_NONE_RESOURCEID);
         }
 
         return getValue();
     }
 
-    public static class BluetoothLePreferenceDialog extends PreferenceDialogFragmentCompat {
+    public static class BluetoothLeSensorPreferenceDialog extends PreferenceDialogFragmentCompat {
 
         private int selectedEntryIndex;
         private final BluetoothLeAdapter listAdapter = new BluetoothLeAdapter();
@@ -116,10 +120,11 @@ public class BluetoothLePreference extends DialogPreference {
             }
         };
 
-        static BluetoothLePreferenceDialog newInstance(String key) {
-            final BluetoothLePreferenceDialog fragment = new BluetoothLePreferenceDialog();
+        public static BluetoothLeSensorPreferenceDialog newInstance(String preferenceKey, UUID sensorUUID) {
+            final BluetoothLeSensorPreferenceDialog fragment = new BluetoothLeSensorPreferenceDialog();
             final Bundle b = new Bundle(1);
-            b.putString(ARG_KEY, key);
+            b.putString(ARG_KEY, preferenceKey);
+            b.putSerializable(ARG_BLUETOOTH_UUID, sensorUUID);
             fragment.setArguments(b);
             return fragment;
         }
@@ -128,6 +133,9 @@ public class BluetoothLePreference extends DialogPreference {
         public void onCreate(Bundle savedInstanceState) {
             super.onCreate(savedInstanceState);
 
+            UUID sensorUUID = (UUID) getArguments().getSerializable(ARG_BLUETOOTH_UUID);
+            Log.i(TAG, "UUID: " + sensorUUID);
+
             BluetoothAdapter bluetoothAdapter = BluetoothUtils.getDefaultBluetoothAdapter(TAG);
             if (bluetoothAdapter == null || !bluetoothAdapter.isEnabled()) {
                 Log.w(TAG, "Bluetooth adapter is present or not enabled.");
@@ -137,7 +145,7 @@ public class BluetoothLePreference extends DialogPreference {
             }
 
             if (bluetoothAdapter.isDiscovering()) {
-                Log.i(TAG, "Cancelling ongoing bluetooth discovery.");
+                Log.i(TAG, "Cancelling ongoing B<aluetooth discovery.");
                 bluetoothAdapter.cancelDiscovery();
             }
 
@@ -152,14 +160,14 @@ public class BluetoothLePreference extends DialogPreference {
             listAdapter.add(getContext().getString(DEVICE_NONE_RESOURCEID), deviceNone);
             selectedEntryIndex = 0;
 
-            BluetoothLePreference preference = (BluetoothLePreference) getPreference();
+            BluetoothLeSensorPreference preference = (BluetoothLeSensorPreference) getPreference();
             String deviceSelected = preference.getValue();
             if (deviceSelected != null && !deviceNone.equals(deviceSelected)) {
                 listAdapter.add(preference.getValue(), preference.getValue());
                 selectedEntryIndex = 1;
             }
 
-            ScanFilter.Builder scanFilterBuilder = new ScanFilter.Builder().setServiceUuid(new ParcelUuid(BluetoothUtils.HEART_RATE_SERVICE_UUID));
+            ScanFilter.Builder scanFilterBuilder = new ScanFilter.Builder().setServiceUuid(new ParcelUuid(sensorUUID));
             List<ScanFilter> scanFilter = new ArrayList<>();
             scanFilter.add(scanFilterBuilder.build());
 
@@ -180,7 +188,7 @@ public class BluetoothLePreference extends DialogPreference {
                         public void onClick(DialogInterface dialog, int which) {
                             selectedEntryIndex = which;
 
-                            BluetoothLePreferenceDialog.this.onClick(dialog, DialogInterface.BUTTON_POSITIVE);
+                            BluetoothLeSensorPreferenceDialog.this.onClick(dialog, DialogInterface.BUTTON_POSITIVE);
                             dialog.dismiss();
                         }
                     });
@@ -196,7 +204,7 @@ public class BluetoothLePreference extends DialogPreference {
 
             if (positiveResult && selectedEntryIndex >= 0) {
                 String value = listAdapter.get(selectedEntryIndex).getAddress();
-                BluetoothLePreference preference = (BluetoothLePreference) getPreference();
+                BluetoothLeSensorPreference preference = (BluetoothLeSensorPreference) getPreference();
                 if (preference.callChangeListener(value)) {
                     preference.setValue(value);
                 }

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

@@ -176,6 +176,10 @@ public class TrackStatistics {
         this.maxSpeed_mps = maxSpeed;
     }
 
+    public boolean hasElevationMin() {
+        return !Double.isInfinite(getMinElevation());
+    }
+
     /**
      * Gets the minimum elevation.
      * This is calculated from the smoothed elevation, so this can actually be more than the current elevation.
@@ -193,6 +197,10 @@ public class TrackStatistics {
         elevationExtremities.setMin(elevation);
     }
 
+    public boolean hasElevationMax() {
+        return !Double.isInfinite(getMaxElevation());
+    }
+
     /**
      * Gets the maximum elevation.
      * This is calculated from the smoothed elevation, so this can actually be less than the current elevation.

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

@@ -18,19 +18,20 @@ package de.dennisguse.opentracks.stats;
 
 import android.util.Log;
 
+import androidx.annotation.NonNull;
 import androidx.annotation.VisibleForTesting;
 
 import de.dennisguse.opentracks.content.data.TrackPoint;
 import de.dennisguse.opentracks.content.data.TrackPointsColumns;
 import de.dennisguse.opentracks.content.provider.TrackPointIterator;
 import de.dennisguse.opentracks.util.LocationUtils;
-
-import static de.dennisguse.opentracks.services.TrackRecordingService.MAX_NO_MOVEMENT_SPEED;
+import de.dennisguse.opentracks.util.TrackPointUtils;
 
 /**
  * Updater for {@link TrackStatistics}.
  * For updating track {@link TrackStatistics} as new {@link TrackPoint}s are added.
  * NOTE: Some of the locations represent pause/resume separator.
+ * NOTE: Has still support for segments (at the moment unused).
  *
  * @author Sandor Dornbush
  * @author Rodrigo Damazio
@@ -116,16 +117,16 @@ public class TrackStatisticsUpdater {
      */
     public void addTrackPoint(TrackPoint trackPoint, int minRecordingDistance) {
         // Always update time
-        updateTime(trackPoint.getLocation().getTime());
+        updateTime(trackPoint.getTime());
         if (!LocationUtils.isValidLocation(trackPoint.getLocation())) {
             // Either pause or resume marker
-            if (trackPoint.getLocation().getLatitude() == TrackPointsColumns.PAUSE_LATITUDE) {
+            if (trackPoint.getLatitude() == TrackPointsColumns.PAUSE_LATITUDE) {
                 if (lastTrackPoint != null && lastMovingTrackPoint != null && lastTrackPoint != lastMovingTrackPoint) {
                     currentSegment.addTotalDistance(lastMovingTrackPoint.distanceTo(lastTrackPoint));
                 }
                 trackStatistics.merge(currentSegment);
             }
-            currentSegment = init(trackPoint.getLocation().getTime());
+            currentSegment = init(trackPoint.getTime());
             lastTrackPoint = null;
             lastMovingTrackPoint = null;
             elevationBuffer_m.reset();
@@ -143,7 +144,7 @@ public class TrackStatisticsUpdater {
         }
 
         double movingDistance = lastMovingTrackPoint.distanceTo(trackPoint);
-        if (movingDistance < minRecordingDistance && (!trackPoint.hasSpeed() || trackPoint.getSpeed() < MAX_NO_MOVEMENT_SPEED)) {
+        if (movingDistance < minRecordingDistance && !TrackPointUtils.isMoving(trackPoint)) {
             speedBuffer_ms.reset();
             lastTrackPoint = trackPoint;
             return;
@@ -162,7 +163,7 @@ public class TrackStatisticsUpdater {
 
         // Update max speed
         if (trackPoint.hasSpeed() && lastTrackPoint.hasSpeed()) {
-            updateSpeed(trackPoint.getTime(), trackPoint.getSpeed(), lastTrackPoint.getTime(), lastTrackPoint.getSpeed());
+            updateSpeed(trackPoint, lastTrackPoint);
         }
 
         lastTrackPoint = trackPoint;
@@ -190,23 +191,18 @@ public class TrackStatisticsUpdater {
 
     /**
      * Updates a speed reading while assuming the user is moving.
-     *
-     * @param time              the time
-     * @param speed             the speed
-     * @param lastLocationTime  the last location time
-     * @param lastLocationSpeed the last location speed
      */
     @VisibleForTesting
-    private void updateSpeed(long time, double speed, long lastLocationTime, double lastLocationSpeed) {
-        if (speed < MAX_NO_MOVEMENT_SPEED) {
+    private void updateSpeed(@NonNull TrackPoint trackPoint, @NonNull TrackPoint lastTrackPoint) {
+        if (!TrackPointUtils.isMoving(trackPoint)) {
             speedBuffer_ms.reset();
-        } else if (isValidSpeed(time, speed, lastLocationTime, lastLocationSpeed)) {
-            speedBuffer_ms.setNext(speed);
+        } else if (isValidSpeed(trackPoint, lastTrackPoint)) {
+            speedBuffer_ms.setNext(trackPoint.getSpeed());
             if (speedBuffer_ms.getAverage() > currentSegment.getMaxSpeed()) {
                 currentSegment.setMaxSpeed(speedBuffer_ms.getAverage());
             }
         } else {
-            Log.d(TAG, "Invalid speed. speed: " + speed + " lastLocationSpeed: " + lastLocationSpeed);
+            Log.d(TAG, "Invalid speed. speed: " + trackPoint.getSpeed() + " lastLocationSpeed: " + lastTrackPoint.getSpeed());
         }
     }
 
@@ -239,26 +235,21 @@ public class TrackStatisticsUpdater {
 
     /**
      * Returns true if the speed is valid.
-     *
-     * @param time              the time
-     * @param speed             the speed
-     * @param lastLocationTime  the last location time
-     * @param lastLocationSpeed the last location speed
      */
-    private boolean isValidSpeed(long time, double speed, long lastLocationTime, double lastLocationSpeed) {
+    private boolean isValidSpeed(@NonNull TrackPoint trackPoint, @NonNull TrackPoint lastTrackPoint) {
         // There are a lot of noisy speed readings. Do the cheapest checks first, most expensive last.
-        if (speed == 0) {
+        if (trackPoint.getSpeed() == 0) {
             return false;
         }
 
         // The following code will ignore unlikely readings. 128 m/s seems to be an internal android error code.
-        if (Math.abs(speed - 128) < 1) {
+        if (Math.abs(trackPoint.getSpeed() - 128) < 1) {
             return false;
         }
 
         // See if the speed seems physically likely. Ignore any speeds that imply acceleration greater than 2g.
-        long timeDifference = time - lastLocationTime;
-        double speedDifference = Math.abs(lastLocationSpeed - speed);
+        long timeDifference = trackPoint.getTime() - lastTrackPoint.getTime();
+        double speedDifference = Math.abs(lastTrackPoint.getSpeed() - trackPoint.getSpeed());
         if (speedDifference > MAX_ACCELERATION * timeDifference) {
             return false;
         }
@@ -266,8 +257,8 @@ public class TrackStatisticsUpdater {
         // Only check if the speed buffer is full. Check that the speed is less than 10X the smoothed average and the speed difference doesn't imply 2g acceleration.
         if (speedBuffer_ms.isFull()) {
             double average = speedBuffer_ms.getAverage();
-            double diff = Math.abs(average - speed);
-            return (speed < average * 10) && (diff < MAX_ACCELERATION * timeDifference);
+            double diff = Math.abs(average - trackPoint.getSpeed());
+            return (trackPoint.getSpeed() < average * 10) && (diff < MAX_ACCELERATION * timeDifference);
         }
 
         return true;

src/main/java/de/dennisguse/opentracks/util/AnnouncementUtils.java

@@ -9,9 +9,9 @@ public class AnnouncementUtils {
 
     private AnnouncementUtils() {}
 
-    public static String getAnnouncement(Context context, TrackStatistics trackStatistics) {
+    public static String getAnnouncement(Context context, TrackStatistics trackStatistics, String category) {
         boolean metricUnits = PreferencesUtils.isMetricUnits(context);
-        boolean reportSpeed = PreferencesUtils.isReportSpeed(context);
+        boolean reportSpeed = PreferencesUtils.isReportSpeed(context, category);
         double distance = trackStatistics.getTotalDistance() * UnitConversions.M_TO_KM;
         double distancePerTime = trackStatistics.getAverageMovingSpeed() * UnitConversions.MS_TO_KMH;
 

src/main/java/de/dennisguse/opentracks/util/BluetoothUtils.java

@@ -21,9 +21,13 @@ import android.os.Handler;
 import android.os.Looper;
 import android.util.Log;
 
+import androidx.annotation.NonNull;
+
 import java.util.ArrayList;
 import java.util.UUID;
 
+import de.dennisguse.opentracks.content.sensor.SensorDataCycling;
+
 /**
  * Utilities for dealing with bluetooth devices.
  *
@@ -31,11 +35,21 @@ import java.util.UUID;
  */
 public class BluetoothUtils {
 
+    public static final UUID CLIENT_CHARACTERISTIC_CONFIG_UUID = new UUID(0x290200001000L, 0x800000805f9b34fbL);
+
     public static final UUID HEART_RATE_SERVICE_UUID = new UUID(0x180D00001000L, 0x800000805f9b34fbL);
+    public static final UUID HEART_RATE_MEASUREMENT_CHAR_UUID = new UUID(0x2A3700001000L, 0x800000805f9b34fbL);
+
+    public static final UUID CYCLING_SPEED_CADENCE_SERVICE_UUID = new UUID(0x181600001000L, 0x800000805f9b34fbL);
+    public static final UUID CYCLING_SPPED_CADENCE_MEASUREMENT_CHAR_UUID = new UUID(0x2A5B00001000L, 0x800000805f9b34fbL);
 
     private BluetoothUtils() {
     }
 
+    /**
+     * If called from UI: use a background thread to get the default Bluetooth adapter.
+     * TODO Check if this is necessary.
+     */
     public static BluetoothAdapter getDefaultBluetoothAdapter(final String TAG) {
         // If from the main application thread, return directly
         if (Thread.currentThread().equals(Looper.getMainLooper().getThread())) {
@@ -77,12 +91,56 @@ public class BluetoothUtils {
         return BluetoothUtils.getDefaultBluetoothAdapter(TAG) != null;
     }
 
-    public static int parseHeartRate(BluetoothGattCharacteristic characteristic) {
+    public static Integer parseHeartRate(BluetoothGattCharacteristic characteristic) {
         //DOCUMENTATION https://www.bluetooth.com/specifications/gatt/characteristics/
         byte[] raw = characteristic.getValue();
-        int index = ((raw[0] & 0x1) == 1) ? 2 : 1;
-        int format = (index == 1) ? BluetoothGattCharacteristic.FORMAT_UINT8 : BluetoothGattCharacteristic.FORMAT_UINT16;
-        return characteristic.getIntValue(format, index);
+        if (raw.length == 0) {
+            return null;
+        }
+
+        boolean formatUINT16 = ((raw[0] & 0x1) == 1);
+        if (formatUINT16 && raw.length >= 3) {
+            return characteristic.getIntValue(BluetoothGattCharacteristic.FORMAT_UINT16, 1);
+        }
+        if (!formatUINT16 && raw.length >= 2) {
+            return characteristic.getIntValue(BluetoothGattCharacteristic.FORMAT_UINT8, 1);
+        }
+
+        return null;
     }
 
+    /**
+     * Documentation: https://www.bluetooth.org/docman/handlers/downloaddoc.ashx?doc_id=261449
+     */
+    public static SensorDataCycling.CadenceAndSpeed parseCyclingCrankAndWheel(String address, String sensorName, @NonNull BluetoothGattCharacteristic characteristic) {
+        int valueLength = characteristic.getValue().length;
+        if (valueLength == 0) {
+            return null;
+        }
+
+        int flags = characteristic.getValue()[0];
+        boolean hasCrank = (flags & 0x01) > 0;
+        boolean hasWheel = (flags & 0x02) > 0;
+
+        SensorDataCycling.Cadence cadence = null;
+        int index = 1;
+        if (hasCrank && valueLength - index >= 6) {
+            long crankCount = characteristic.getIntValue(BluetoothGattCharacteristic.FORMAT_UINT32, index);
+            index += 4;
+
+            int crankTime = characteristic.getIntValue(BluetoothGattCharacteristic.FORMAT_UINT16, index); // 1/1024s
+            index += 2;
+            cadence = new SensorDataCycling.Cadence(address, sensorName, crankCount, crankTime);
+        }
+
+        SensorDataCycling.Speed speed = null;
+        if (hasWheel && valueLength - index >= 4) {
+            int wheelCount = characteristic.getIntValue(BluetoothGattCharacteristic.FORMAT_UINT16, index);
+            index += 2;
+            int wheelTime = characteristic.getIntValue(BluetoothGattCharacteristic.FORMAT_UINT16, index); // 1/1024s
+            speed = new SensorDataCycling.Speed(address, sensorName, wheelCount, wheelTime);
+        }
+
+        return new SensorDataCycling.CadenceAndSpeed(address, sensorName, cadence, speed);
+    }
 }

src/main/java/de/dennisguse/opentracks/util/DialogUtils.java

@@ -85,7 +85,7 @@ public class DialogUtils {
      * @param formatArgs       the format arguments for the message id
      */
     private static ProgressDialog createProgressDialog(boolean spinner, final Context context, int messageId, DialogInterface.OnCancelListener onCancelListener, Object... formatArgs) {
-        final ProgressDialog progressDialog = new ProgressDialog(context);
+        final ProgressDialog progressDialog = new ProgressDialog(context, R.style.ThemeCustomNotTransparent);
         progressDialog.setCancelable(true);
         progressDialog.setCanceledOnTouchOutside(false);
         progressDialog.setIcon(R.drawable.ic_dialog_info_24dp);

src/main/java/de/dennisguse/opentracks/util/FileUtils.java

@@ -95,11 +95,15 @@ public class FileUtils {
 
     /**
      * Gets the extension from a file name.
-     * Returns null if there is no extension.
      *
      * @param fileName the file name
+     * @return null if there is no extension or fileName is null.
      */
     public static String getExtension(String fileName) {
+        if (fileName == null) {
+            return null;
+        }
+
         int index = fileName.lastIndexOf('.');
         if (index == -1) {
             return null;
@@ -250,4 +254,50 @@ public class FileUtils {
     public static Uri getUriForFile(Context context, File file) {
         return FileProvider.getUriForFile(context, FileUtils.FILEPROVIDER, file);
     }
+
+    /**
+     * Checks that there is a file inside track photo directory whose name is the same that uri file.
+     * If there is a file inside photo directory whose name is the same that uri then returns File. Otherwise returns null.
+     *
+     * @param context the Context.
+     * @param trackId the id of the Track.
+     * @param uri     the uri to check.
+     * @return        File object or null.
+     */
+    public static File getPhotoFileIfExists(Context context, long trackId, Uri uri) {
+        if (uri == null) {
+            Log.w(TAG, "URI object is null.");
+            return null;
+        }
+
+        String filename = uri.getLastPathSegment();
+        if (filename == null) {
+            Log.w(TAG, "External photo contains no filename.");
+            return null;
+        }
+
+        File dir = FileUtils.getPhotoDir(context, trackId);
+        File file = new File(dir, filename);
+        if (!file.exists()) {
+            return null;
+        }
+
+        return file;
+    }
+
+    /**
+     * Delete the directory recursively.
+     *
+     * @param file the directory
+     */
+    public static void deleteDirectoryRecurse(File file) {
+        if (file != null && file.exists() && file.isDirectory()) {
+            for (File child : file.listFiles()) {
+                deleteDirectoryRecurse(child);
+            }
+            file.delete();
+        } else if (file != null && file.isFile()) {
+            file.delete();
+        }
+    }
 }

src/main/java/de/dennisguse/opentracks/util/IntentDashboardUtils.java

@@ -17,9 +17,9 @@ import de.dennisguse.opentracks.content.provider.ContentProviderUtils;
  */
 public class IntentDashboardUtils {
 
-    public static final String ACTION_DASHBOARD = "Intent.OpenTracks-Dashboard";
+    private static final String ACTION_DASHBOARD = "Intent.OpenTracks-Dashboard";
 
-    public static final String ACTION_DASHBOARD_PAYLOAD = ACTION_DASHBOARD + ".Payload";
+    private static final String ACTION_DASHBOARD_PAYLOAD = ACTION_DASHBOARD + ".Payload";
 
     private IntentDashboardUtils() {
     }

src/main/java/de/dennisguse/opentracks/util/IntentUtils.java

@@ -92,9 +92,10 @@ public class IntentUtils {
             Track track = contentProviderUtils.getTrack(trackId);
             if (track == null) {
                 Log.e(TAG, "TrackId " + trackId + " could not be resolved.");
+                continue;
             }
 
-            Pair<Uri, String> uriAndMime = ShareContentProvider.createURI(new long[]{trackId}, track.getName(), TrackFileFormat.KMZ_WITH_TRACKDETAIL_AND_SENSORDATA_AND_PICTURES);
+            Pair<Uri, String> uriAndMime = ShareContentProvider.createURI(new long[]{trackId}, track.getName(), PreferencesUtils.getExportTrackFileFormat(context));
             uris.add(uriAndMime.first);
             mime = uriAndMime.second;
         }

src/main/java/de/dennisguse/opentracks/util/LocationUtils.java

@@ -22,7 +22,6 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Stack;
 
-import de.dennisguse.opentracks.content.data.Track;
 import de.dennisguse.opentracks.content.data.TrackPoint;
 
 /**
@@ -90,13 +89,13 @@ public class LocationUtils {
      *
      * @param tolerance in meters
      * @param trackPoints input
-     * @param decimated output
      */
     //TODO What was it used for? Sharing data with other apps?
-    private static void decimate(double tolerance, List<TrackPoint> trackPoints, List<TrackPoint> decimated) {
+    private static List<TrackPoint> decimate(double tolerance, List<TrackPoint> trackPoints) {
+        List<TrackPoint> decimated = new ArrayList<>();
         final int n = trackPoints.size();
         if (n < 1) {
-            return;
+            return null;
         }
         int idx;
         int maxIdx = 0;
@@ -142,18 +141,8 @@ public class LocationUtils {
             idx++;
         }
         Log.d(TAG, "Decimating " + n + " points to " + i + " w/ tolerance = " + tolerance);
-    }
 
-    /**
-     * Decimates the given track for the given precision.
-     *
-     * @param track     a track
-     * @param precision desired precision in meters
-     */
-    public static void decimate(Track track, double precision) {
-        ArrayList<TrackPoint> decimated = new ArrayList<>();
-        decimate(precision, track.getTrackPoints(), decimated);
-        track.setTrackPoints(decimated);
+        return decimated;
     }
 
     /**

src/main/java/de/dennisguse/opentracks/util/PreferencesUtils.java

@@ -24,6 +24,7 @@ import androidx.annotation.VisibleForTesting;
 import androidx.preference.PreferenceManager;
 
 import de.dennisguse.opentracks.R;
+import de.dennisguse.opentracks.io.file.TrackFileFormat;
 
 /**
  * Utilities to access preferences stored in {@link SharedPreferences}.
@@ -49,7 +50,7 @@ public class PreferencesUtils {
 
     @Deprecated
     //NOTE: is at the moment still used to determine if a track is currently recorded; better ask the service directly.
-    //NOTE: This was also used to recover from a reboot, but this data should not be exposed to the whole application.
+    //NOTE: This was also used to recover from a service restart, but this data should not be exposed to the whole application.
     public static final long RECORDING_TRACK_ID_DEFAULT = -1L;
 
     public static long getRecordingTrackId(Context context) {
@@ -197,9 +198,14 @@ public class PreferencesUtils {
         return STATS_UNIT.equals(getString(context, R.string.stats_units_key, STATS_UNIT));
     }
 
-    public static boolean isReportSpeed(Context context) {
+    public static boolean isReportSpeed(Context context, String category) {
         final String STATS_RATE_DEFAULT = context.getString(R.string.stats_rate_default);
-        return STATS_RATE_DEFAULT.equals(getString(context, R.string.stats_rate_key, STATS_RATE_DEFAULT));
+        String currentStatsRate = getString(context, R.string.stats_rate_key, STATS_RATE_DEFAULT);
+        if (currentStatsRate.equals(getString(context, R.string.stats_rate_speed_or_pace_default, STATS_RATE_DEFAULT))) {
+            return TrackIconUtils.isSpeedIcon(context, category);
+        }
+
+        return currentStatsRate.equals(context.getString(R.string.stats_rate_speed));
     }
 
     public static boolean isRecordingTrackPaused(Context context) {
@@ -215,20 +221,44 @@ public class PreferencesUtils {
         setBoolean(context, R.string.recording_track_paused_key, RECORDING_TRACK_PAUSED);
     }
 
-    private static String getBluetoothHeartRateSensorAddressNone(Context context) {
+    private static String getBluetoothSensorAddressNone(Context context) {
         return context.getString(R.string.sensor_type_value_none);
     }
 
-    public static boolean isBluetoothHeartRateSensorAddressDefault(Context context) {
-        return getBluetoothHeartRateSensorAddressNone(context).equals(getBluetoothHeartRateSensorAddress(context));
+    public static boolean isBluetoothSensorAddressNone(Context context, String currentValue) {
+        return getBluetoothSensorAddressNone(context).equals(currentValue);
     }
 
-    public static boolean isBluetoothHeartRateSensorAddressDefault(Context context, String currentValue) {
-        return getBluetoothHeartRateSensorAddressNone(context).equals(currentValue);
+
+    public static boolean isBluetoothHeartRateSensorAddressNone(Context context) {
+        return isBluetoothSensorAddressNone(context, getBluetoothHeartRateSensorAddress(context));
     }
 
     public static String getBluetoothHeartRateSensorAddress(Context context) {
-        return getString(context, R.string.settings_sensor_bluetooth_heart_rate_key, getBluetoothHeartRateSensorAddressNone(context));
+        return getString(context, R.string.settings_sensor_bluetooth_heart_rate_key, getBluetoothSensorAddressNone(context));
+    }
+
+
+    public static boolean isBluetoothCyclingCadenceSensorAddressNone(Context context) {
+        return isBluetoothSensorAddressNone(context, getBluetoothCyclingCadenceSensorAddress(context));
+    }
+
+    public static String getBluetoothCyclingCadenceSensorAddress(Context context) {
+        return getString(context, R.string.settings_sensor_bluetooth_cycling_cadence_key, getBluetoothSensorAddressNone(context));
+    }
+
+
+    public static boolean isBluetoothCyclingSpeedSensorAddressNone(Context context) {
+        return isBluetoothSensorAddressNone(context, getBluetoothCyclingSpeedSensorAddress(context));
+    }
+
+    public static String getBluetoothCyclingSpeedSensorAddress(Context context) {
+        return getString(context, R.string.settings_sensor_bluetooth_cycling_speed_key, getBluetoothSensorAddressNone(context));
+    }
+
+    public static int getWheelCircumference(Context context) {
+        final int DEFAULT = Integer.parseInt(context.getResources().getString(R.string.settings_sensor_bluetooth_cycling_speed_wheel_circumference_default));
+        return getInt(context, R.string.settings_sensor_bluetooth_cycling_speed_wheel_circumference_key, DEFAULT);
     }
 
     public static boolean shouldShowStatsOnLockscreen(Context context) {
@@ -291,6 +321,16 @@ public class PreferencesUtils {
         return getInt(context, R.string.recording_gps_accuracy_key, RECORDING_GPS_ACCURACY);
     }
 
+    public static TrackFileFormat getExportTrackFileFormat(Context context) {
+        final String TRACKFILEFORMAT_NAME_DEFAULT = getString(context, R.string.export_trackfileformat_default, null);
+        String trackFileFormatName = getString(context, R.string.export_trackfileformat_key, TRACKFILEFORMAT_NAME_DEFAULT);
+        try {
+            return TrackFileFormat.valueOf(trackFileFormatName);
+        } catch (Exception e) {
+            return TrackFileFormat.KMZ_WITH_TRACKDETAIL_AND_SENSORDATA;
+        }
+    }
+
     public static boolean isRecording(Context context) {
         long recordingTrackId = getRecordingTrackId(context);
         return isRecording(recordingTrackId);

src/main/java/de/dennisguse/opentracks/util/TrackIconUtils.java

@@ -59,6 +59,21 @@ public class TrackIconUtils {
     private static final int[] SNOW_BOARDING_LIST = new int[]{R.string.activity_type_snow_boarding};
     private static final int[] WALK_LIST = new int[]{R.string.activity_type_hiking, R.string.activity_type_off_trail_hiking, R.string.activity_type_speed_walking, R.string.activity_type_trail_hiking, R.string.activity_type_walking};
 
+    // List of icons whose sports associated use speed (in km/h or mi/h).
+    private static final int[] SPEED_ICON = {
+            // Unknown.
+            R.string.activity_type_unknown,
+            // All airplane categories.
+            R.string.activity_type_airplane, R.string.activity_type_commercial_airplane, R.string.activity_type_rc_airplane,
+            // All bike categories.
+            R.string.activity_type_biking, R.string.activity_type_cycling, R.string.activity_type_dirt_bike, R.string.activity_type_motor_bike, R.string.activity_type_mountain_biking, R.string.activity_type_road_biking, R.string.activity_type_track_cycling,
+            // All boat categories.
+            R.string.activity_type_boat, R.string.activity_type_ferry, R.string.activity_type_motor_boating, R.string.activity_type_rc_boat,
+            // All drive categories.
+            R.string.activity_type_atv, R.string.activity_type_driving, R.string.activity_type_driving_bus, R.string.activity_type_driving_car,
+
+    };
+
     private static final LinkedHashMap<String, Pair<Integer, Integer>> MAP = new LinkedHashMap<>();
 
     static {
@@ -192,4 +207,14 @@ public class TrackIconUtils {
         }
         return false;
     }
+
+    /**
+     * Returns true if category is in the SPEED_ICON array. Otherwise returns false.
+     *
+     * @param context  the context.
+     * @param category the name of the category, activity type.
+     */
+    public static boolean isSpeedIcon(Context context, String category) {
+        return inList(context, category, SPEED_ICON);
+    }
 }

src/main/java/de/dennisguse/opentracks/util/TrackPointUtils.java

@@ -0,0 +1,66 @@
+package de.dennisguse.opentracks.util;
+
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+
+import de.dennisguse.opentracks.content.data.TrackPoint;
+
+public class TrackPointUtils {
+
+    // Anything faster than that (in meters per second) will be considered moving.
+    private static final double MAX_NO_MOVEMENT_SPEED = 0.224;
+
+    private final static String TAG = TrackPointUtils.class.getSimpleName();
+
+    private TrackPointUtils() {
+    }
+
+    /**
+     * 1. Ancient fix for phones that do not set the time in {@link android.location.Location}.
+     * 2. Fix for GPS time rollover happening every 19.7 years: https://en.wikipedia.org/wiki/GPS_Week_Number_Rollover
+     */
+    public static void fixTime(@NonNull TrackPoint trackPoint) {
+        if (trackPoint.getTime() == 0L) {
+            Log.w(TAG, "Time of provided location was 0. Using current time.");
+            trackPoint.setTime(System.currentTimeMillis());
+            return;
+        }
+
+        {
+            long timeDiff = Math.abs(trackPoint.getTime() - System.currentTimeMillis());
+
+            if (timeDiff > 1023 * UnitConversions.ONE_WEEK_MS) {
+                Log.w(TAG, "GPS week rollover.");
+                trackPoint.setTime(trackPoint.getTime() + 1024 * UnitConversions.ONE_WEEK_MS);
+            }
+        }
+    }
+
+    public static boolean isMoving(@NonNull TrackPoint trackPoint) {
+        return trackPoint.hasSpeed() && trackPoint.getSpeed() >= MAX_NO_MOVEMENT_SPEED;
+    }
+
+    public static boolean equalTime(TrackPoint t1, TrackPoint t2) {
+        if (t1 == null || t2 == null) {
+            return false;
+        }
+
+        return t1.getTime() == t2.getTime();
+    }
+
+    public static boolean after(TrackPoint t1, TrackPoint t2) {
+        if (t1 == null || t2 == null) {
+            return false;
+        }
+
+        return t1.getTime() > t2.getTime();
+    }
+
+    /**
+     * Is accuracy better than threshold?
+     */
+    public static boolean fulfillsAccuracy(@NonNull TrackPoint trackPoint, int poorAccuracy) {
+        return trackPoint.hasAccuracy() && trackPoint.getAccuracy() < poorAccuracy;
+    }
+}

src/main/java/de/dennisguse/opentracks/util/UintUtils.java

@@ -0,0 +1,30 @@
+package de.dennisguse.opentracks.util;
+
+public class UintUtils {
+
+    public static int UINT16_MAX = 0xFFFF;
+    public static long UINT32_MAX = 0xFFFFFFFFL;
+
+    private UintUtils() {
+    }
+
+    /**
+     * Computes a - b for UINT with overflow (b < a).
+     *
+     * @return diff or -1 (invalid)
+     */
+    public static long diff(long a, long b, final long UINT_MAX) {
+        if (a < 0 || b < 0) {
+            return -1;
+        }
+        if (a > UINT_MAX || b > UINT_MAX) {
+            return -1;
+        }
+
+        if (a >= b) {
+            return a - b;
+        }
+
+        return (UINT_MAX - b) + a;
+    }
+}

src/main/java/de/dennisguse/opentracks/util/UnitConversions.java

@@ -29,6 +29,9 @@ public class UnitConversions {
     // 1 second in milliseconds
     public static final long ONE_SECOND_MS = UnitConversions.S_TO_MS;
     public static final long ONE_MINUTE_MS = (long) (UnitConversions.MIN_TO_S * UnitConversions.S_TO_MS);
+    public static final long ONE_HOUR_MS = 60 * ONE_MINUTE_MS;
+    public static final long ONE_DAY_MS = 24 * ONE_HOUR_MS;
+    public static final long ONE_WEEK_MS = 7 * ONE_DAY_MS;
 
     // multiplication factor to convert milliseconds to seconds
     public static final double MS_TO_S = 1d / S_TO_MS;
@@ -43,6 +46,8 @@ public class UnitConversions {
     // multiplication factor to convert kilometers to miles
     public static final double KM_TO_MI = 0.621371192;
 
+    public static final double MM_TO_M = 0.001;
+
     // Distance
     // multiplication factor to convert miles to feet
     public static final double MI_TO_FT = 5280.0;

src/main/java/de/dennisguse/opentracks/util/ViewUtils.java

@@ -0,0 +1,30 @@
+package de.dennisguse.opentracks.util;
+
+import android.text.method.LinkMovementMethod;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.TextView;
+
+public class ViewUtils {
+
+    private ViewUtils() {
+    }
+
+    /**
+     * Traverses all childs of {@link View} recursively and makes links within {@link TextView}s clickable.
+     */
+    public static void makeClickableLinks(ViewGroup view) {
+        if (view == null) {
+            return;
+        }
+
+        for (int i = 0; i < view.getChildCount(); i++) {
+            final View child = view.getChildAt(i);
+            if (child instanceof ViewGroup) {
+                makeClickableLinks((ViewGroup) child);
+            } else if (child instanceof TextView) {
+                ((TextView) child).setMovementMethod(LinkMovementMethod.getInstance());
+            }
+        }
+    }
+}