Release: v3.18.1

Translated using Weblate (Ukrainian)
Currently translated at 100.0% (530 of 530 strings) Translation: OpenTracks/opentracks.src-main-res-values-strings-xml--main Translate-URL: https://weblate.bubu1.eu/projects/OpenTracks/opentracks/uk/
2021-05-19 18:16:45 +02:00 · 2021-05-19 17:15:57 +02:00 · 2021-05-19 17:15:57 +02:00 · 2021-05-19 17:15:57 +02:00 · 2021-05-19 17:15:57 +02:00 · 2021-05-19 17:15:57 +02:00
130 changed files with 41702 additions and 2219 deletions
@@ -15,7 +15,7 @@ jobs:

    steps:
    - name: Checkout repository
-      uses: actions/checkout@v2
+      uses: actions/checkout@v2.3.4
      with:
        fetch-depth: 2

@@ -6,14 +6,14 @@ jobs:
    runs-on: macos-latest
    strategy:
      matrix:
-        api-level: [29]
+        api-level: [ 23, 26, 29 ]
        target: [default]
    steps:
      - name: checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v2.3.4

      - name: run tests
-        uses: reactivecircus/android-emulator-runner@v2
+        uses: reactivecircus/android-emulator-runner@v2.16.0
        with:
          api-level: ${{ matrix.api-level }}
          target: ${{ matrix.target }}
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="true" project-jdk-name="1.8" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_11" default="true" project-jdk-name="1.8" project-jdk-type="JavaSDK">
    <output url="file://$PROJECT_DIR$/build/classes" />
  </component>
  <component name="ProjectType">
@@ -3,6 +3,7 @@
  <component name="RunConfigurationProducerService">
    <option name="ignoredProducers">
      <set>
+        <option value="com.android.tools.idea.compose.preview.runconfiguration.ComposePreviewRunConfigurationProducer" />
        <option value="org.jetbrains.plugins.gradle.execution.test.runner.AllInPackageGradleConfigurationProducer" />
        <option value="org.jetbrains.plugins.gradle.execution.test.runner.TestClassGradleConfigurationProducer" />
        <option value="org.jetbrains.plugins.gradle.execution.test.runner.TestMethodGradleConfigurationProducer" />
@@ -49,39 +49,6 @@ _OpenTracks_ is a sport tracking application that completely respects your priva
    </tr>
 </table>

-## Features:
-* __Tracking:__ track your sport and outdoor activities
-* __Photos and Markers:__ mark interesting locations while tracking (also with photos)
-* __Bluetooth LE sensors:__
-  * heart rate
-  * cycling: speed and cadence
-  * cycling: power meter
-* __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 use Google Play Services_
-    * _has no cloud integration_
-
-__Only required permissions:__
-* _ACCESS_FINE_LOCATION_: required to use the GPS.
-
-An overview of Bluetooth LE sensors that are known to work with OpenTracks is in [README_TESTED_SENSORS.md](README_TESTED_SENSORS.md).
-
-_Please note:_
-_OpenTracks_ does not contain a _map_ (as this would require internet access).
-
-## Custom Dashboards (incl. Map)
-As of v3.3.1 OpenTracks enables to use custom dashboards.
-The reference implementation is [OSMDashboard](https://github.com/OpenTracksApp/OSMDashboard), which presents an OpenStreetMap map (showing the current track, incl. updates).
-The developer documentation is in [README_API.md](README_API.md).
-
-Alternatively, recorded tracks can be shared as KMZ/GPX to installed applications (e.g., [OsmAnd](https://play.google.com/store/apps/details?id=net.osmand)).
-However, this is rather slow and does not provide updates while recording.
-
-
 ## Screenshots
 <div>
    <img width="23%" src="fastlane/metadata/android/en-US/phoneScreenshots/screenshot1.png">
@@ -96,12 +63,54 @@ However, this is rather slow and does not provide updates while recording.
 	<img width="23%" src="fastlane/metadata/android/en-US/phoneScreenshots/screenshot8.png">
 </div>

+## Features
+* __Tracking:__ track your sport and outdoor activities
+* __Voice announcements__
+* __Photos and Markers:__ mark interesting locations while tracking
+* __Export:__
+  * export tracks either as KMZ (incl. photos), KML, or GPX
+  * export automatically after each recording (e.g., to sync)
+  * avoid duplication: each exported file contain a random unique identifier (i.e., `opentracks:trackid`)
+* __Altitude:__
+  * gain/loss via barometric sensor (if present)
+  * shown in EGM2008 (above mean sea level); exported as WGS84
+* __Bluetooth LE sensors:__
+  * heart rate
+  * cycling: speed and distance
+  * cycling: cadence
+  * cycling: power meter
+
+### Gadgetbridge integration
+
+OpenTracks can be used with [Gadgetbridge](https://www.gadgetbridge.org/):
+* shows statistics via notification on smart watches (requires Gadgetbridge 0.56.1 or later), and
+* Gadgetbridge's GPX exporter generates `opentracks:trackid` to avoid duplication (Gadgetbridge 0.53.0 or later).
+
+### Privacy
+* __No Internet access:__ Internet is not used
+* __No advertising__
+* __No in-app analytics__
+* __No use of Google Play Services__
+
+__Only required permission:__
+* _ACCESS_FINE_LOCATION_: required to use the GPS.
+
+An overview of Bluetooth LE sensors that are known to work with OpenTracks is in [README_TESTED_SENSORS.md](README_TESTED_SENSORS.md).
+
+## Custom Dashboards (incl. map)
+As of v3.3.1, OpenTracks supports custom dashboards.
+The reference implementation is [OSMDashboard](https://github.com/OpenTracksApp/OSMDashboard), which presents an OpenStreetMap map (showing the current track, incl. updates).
+The developer documentation is in [README_API.md](README_API.md).
+
+Alternatively, recorded tracks can be shared as KMZ/GPX with installed applications (e.g., [OsmAnd](https://play.google.com/store/apps/details?id=net.osmand)).
+However, this is rather slow and does not provide updates while recording.
+
 ## Project history

 _OpenTracks_ is based upon Google _My Tracks app_ ([code](https://code.google.com/archive/p/mytracks/)).
 Initially, _My Tracks_ was initially released by Google in 2010 as [open-source software](http://google-latlong.blogspot.fr/2010/05/code-for-my-tracks-is-now-yours.html).
 In 2016, [Google decided to discontinue](https://support.google.com/maps/answer/6333516) _My Tracks_ and stopped distributing it via the Google Play store in April 2016.
-The [Plonk42](https://github.com/plonk42) conducted some maintenance work until 2016, so _My Tracks_ could still be used (based upon version _Google's MyTracks_ version 2.0.6).
+Then [Plonk42](https://github.com/plonk42) conducted some maintenance work until 2016, so _My Tracks_ could still be used (based upon version _Google's MyTracks_ version 2.0.6).
 Plonk42's version is available [here](https://github.com/Plonk42/mytracks).
 In 2019, _OpenTracks_ was forked from Plonk42's _My Tracks_ and major rework was conducted.

@@ -114,11 +123,11 @@ Rework of _OpenTracks_ included:
 * removing calorie estimation and activity estimation,
 * removing support for ANT+ and Classic Bluetooth,
 * adding support for Bluetooth LE heart rate sensors,
-* removing Protobuf (store sensosensorr data in SQLite columns directly), and
+* removing Protobuf (store sensor data in SQLite columns directly), and
 * removing Android Service API for other apps.

 Artwork, logos and user interface remained more or less unchanged.

 More information about _Google My Tracks_:
 * [Wikipedia page](https://en.wikipedia.org/wiki/MyTracks)
-* [Google code archive](https://code.google.com/archive/p/mytracks/)
+* [Google code archive](https://code.google.com/archive/p/mytracks/)
@@ -28,6 +28,8 @@ However, often only one value is provided.

 * Wahoo Speed (Model: WFRPMSPD)

+* CooSpo cadence and speed sensor (model: BK467)
+
 ### Cadence

 * Garmin Cadence Sensor 2
@@ -3,17 +3,17 @@ apply plugin: 'com.android.application'
 buildscript {
    repositories {
        google()
-        jcenter()
+        mavenCentral()
    }
    dependencies {
-        classpath 'com.android.tools.build:gradle:4.1.3'
+        classpath 'com.android.tools.build:gradle:4.2.1'
    }
 }

 allprojects {
    repositories {
        google()
-        jcenter()
+        mavenCentral()
    }
 }

@@ -49,10 +49,14 @@ android {
        viewBinding = true
    }

+    aaptOptions {
+        cruncherEnabled = false
+    }
+
    defaultConfig {
        applicationId "de.dennisguse.opentracks"
-        versionCode 3981
-        versionName "v3.17.0"
+        versionCode 4092
+        versionName "v3.18.1"

        buildConfigField "String", "VERSION_NAME_FULL", "\"${getVersionName()}\""

@@ -86,10 +90,10 @@ android {
 }

 dependencies {
-    androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0-alpha05'
+    androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0-alpha06'
    coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:1.1.5'

-    implementation 'androidx.appcompat:appcompat:1.2.0'
+    implementation 'androidx.appcompat:appcompat:1.3.0'
    implementation 'androidx.preference:preference:1.1.1'
    implementation 'androidx.documentfile:documentfile:1.0.1'
    implementation 'com.google.android.material:material:1.3.0'
@@ -99,5 +103,5 @@ dependencies {
    androidTestImplementation 'androidx.test.ext:junit:1.1.2'
    androidTestImplementation 'androidx.test:rules:1.3.0'
    androidTestImplementation 'androidx.test:runner:1.3.0'
-    androidTestImplementation 'org.mockito:mockito-android:3.8.0'
+    androidTestImplementation 'org.mockito:mockito-android:3.10.0'
 }
@@ -0,0 +1,7 @@
+v3.17.1: OpenTracks
+
+
+Bugfix:
+- Interval length in meters instead of kilometers (introduced in v3.17.0)
+- Elevation gain/loss not recorded (introduced in v3.17.0)
+- Announcements not working on Android 11
@@ -0,0 +1,8 @@
+v3.17.2: OpenTracks
+
+WARNING: The v3.17.0+ releases contain a memory leak.
+This issues is NOT FIXED by this release.
+It is recommended to not upgrade if you still use a release before v3.17.0
+
+Bugfix:
+- Crash while using voice announcements
@@ -0,0 +1,11 @@
+v3.17.3: OpenTracks
+
+WARNING: The v3.17.0+ releases contain a memory leak.
+This issues is NOT FIXED by this release.
+It is recommended to not upgrade if you still use a release before v3.17.0
+
+Bugfix:
+- Crash if using pace for voice announcements (introduced in v3.17.0)
+- Statistics showed pace initially (introduced in v3.17.0)
+- Rare crash when deleting tracks
+
@@ -0,0 +1,15 @@
+v3.18.0: OpenTracks
+
+Changes:
+- Altitude is shown in EGM2008 (stored/exported as WGS84)
+
+Bugfix:
+- Fixed memory leak (introduced in v3.17.0)
+- Charts: altitude should be in M/FT (introduced in v3.17.1)
+- Charts: while recording was not correctly updated (introduced in v3.17.3)
+- TrackDataHub did not account for recordingDistanceInterval (introduced in v3.17.2)
+
+Developer:
+- Disable PNG crunching (reproducible build)
+- Refactored TrackImporter and optimized KMZ import
+- Use LiveData for TrackRecordingService to UI communication (removing memory leak)
@@ -0,0 +1,13 @@
+v3.18.1: OpenTracks
+
+Changes:
+- Deleting tracks is handled by a service
+- Uninstall deletes all data (i.e., hasFragileData=false)
+
+Bugfixes:
+- Race condition: crash while recording and switching OpenTracks into background
+- Search in track list was not working
+- Cycling speed sensor: distance computation was wrong (only affected statistics)
+
+Developer:
+- ControllerFragment replaces TrackController
@@ -3,9 +3,9 @@ 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
-* Supports Bluetooth LE sensors:
-  * heart rate
-  * cycling: speed and cadence
-  * cycling: power meter
-* Export data: export tracks either as KML or GPX
-* No Internet access: Internet is not used
+* Altitude gain and loss: via barometric sensor
+* Altitude shown in EGM2008 (above mean sea level); exported as WGS84
+* Voice announcements
+* Supports Bluetooth LE sensors: heart rate, speed and distance (cycling), cadence (cycling), and power meter (cycling)
+* Export data: export tracks either as KMZ (incl. photos), KML,  or GPX
+* No Internet access: Internet is not used
@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.5-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.0-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
@@ -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
@@ -1,103 +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 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
+@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
@@ -0,0 +1,285 @@
+package de.dennisguse.opentracks;
+
+
+import android.app.ActivityManager;
+import android.app.Instrumentation;
+import android.content.Context;
+import android.util.Log;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewParent;
+import android.widget.ListView;
+
+import androidx.test.espresso.Espresso;
+import androidx.test.espresso.IdlingResource;
+import androidx.test.espresso.UiController;
+import androidx.test.espresso.ViewAction;
+import androidx.test.espresso.ViewInteraction;
+import androidx.test.espresso.action.MotionEvents;
+import androidx.test.espresso.assertion.ViewAssertions;
+import androidx.test.ext.junit.rules.ActivityScenarioRule;
+import androidx.test.filters.LargeTest;
+import androidx.test.platform.app.InstrumentationRegistry;
+import androidx.test.rule.GrantPermissionRule;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import org.hamcrest.Description;
+import org.hamcrest.Matcher;
+import org.hamcrest.TypeSafeMatcher;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import de.dennisguse.opentracks.services.TrackDeleteService;
+
+import static androidx.test.espresso.Espresso.onData;
+import static androidx.test.espresso.Espresso.onView;
+import static androidx.test.espresso.Espresso.pressBack;
+import static androidx.test.espresso.action.ViewActions.click;
+import static androidx.test.espresso.action.ViewActions.scrollTo;
+import static androidx.test.espresso.assertion.ViewAssertions.matches;
+import static androidx.test.espresso.matcher.ViewMatchers.isDisplayed;
+import static androidx.test.espresso.matcher.ViewMatchers.withContentDescription;
+import static androidx.test.espresso.matcher.ViewMatchers.withId;
+import static androidx.test.espresso.matcher.ViewMatchers.withText;
+import static org.hamcrest.Matchers.allOf;
+import static org.hamcrest.Matchers.anything;
+
+@LargeTest
+@RunWith(AndroidJUnit4.class)
+public class EspressoDeleteTrackTest {
+
+    @Rule
+    public ActivityScenarioRule<TrackListActivity> mActivityTestRule = new ActivityScenarioRule<>(TrackListActivity.class);
+
+    @Rule
+    public GrantPermissionRule mGrantPermissionRule = GrantPermissionRule.grant("android.permission.ACCESS_FINE_LOCATION");
+
+    private MyIdlingResource idlingResource;
+
+    @Before
+    public void registerIntentServiceIdlingResource() {
+        Instrumentation instrumentation
+                = InstrumentationRegistry.getInstrumentation();
+        idlingResource = new MyIdlingResource(instrumentation.getTargetContext());
+        Espresso.registerIdlingResources(idlingResource);
+    }
+
+    @After
+    public void unregisterIntentServiceIdlingResource() {
+        Espresso.unregisterIdlingResources(idlingResource);
+    }
+
+    @Test
+    public void espressoDeleteTrackTest() {
+        int countBefore;
+
+        {
+            // TrackListActivity: start recording
+            ViewInteraction trackControllerRecordButton = onView(withId(R.id.controller_record));
+            trackControllerRecordButton.perform(click());
+        }
+
+        {
+            // TrackRecordingActivity
+            ViewInteraction trackControllerRecordButton = onView(withId(R.id.controller_record));
+            ViewInteraction trackControllerStopButton = onView(withId(R.id.controller_stop));
+
+            // wait; stay recording
+            trackControllerRecordButton.perform(waitFor(5000));
+
+            // stop;
+            trackControllerStopButton.perform(veryLongTouch(1600));
+        }
+
+        // back
+        pressBack();
+
+        // get number of items before deleting a track
+        countBefore = numberOfItemsListView();
+
+        // select track
+        onData(anything()).inAdapterView(withId(R.id.track_list)).atPosition(0).perform(veryLongTouch(5000));
+
+        // open menu and delete selected track
+        ViewInteraction overflowMenuButton = onView(
+                allOf(withContentDescription("More options"),
+                        childAtPosition(
+                                childAtPosition(
+                                        withId(R.id.toolbar),
+                                        2),
+                                2),
+                        isDisplayed()));
+        overflowMenuButton.perform(click());
+
+        ViewInteraction appCompatTextView = onView(
+                allOf(withId(R.id.title), withText("Delete"),
+                        childAtPosition(
+                                childAtPosition(
+                                        withId(R.id.content),
+                                        0),
+                                0),
+                        isDisplayed()));
+        appCompatTextView.perform(click());
+
+        ViewInteraction appCompatButton = onView(
+                allOf(withId(android.R.id.button1), withText("Yes"),
+                        childAtPosition(
+                                childAtPosition(
+                                        withId(R.id.buttonPanel),
+                                        0),
+                                3)));
+        appCompatButton.perform(scrollTo(), click());
+
+        // check number of items after delete
+        onView(withId(R.id.track_list)).check(ViewAssertions.matches(withListSize(countBefore - 1)));
+    }
+
+    private static Matcher<View> childAtPosition(
+            final Matcher<View> parentMatcher, final int position) {
+
+        return new TypeSafeMatcher<View>() {
+            @Override
+            public void describeTo(Description description) {
+                description.appendText("Child at position " + position + " in parent ");
+                parentMatcher.describeTo(description);
+            }
+
+            @Override
+            public boolean matchesSafely(View view) {
+                ViewParent parent = view.getParent();
+                return parent instanceof ViewGroup && parentMatcher.matches(parent)
+                        && view.equals(((ViewGroup) parent).getChildAt(position));
+            }
+        };
+    }
+
+    public static Matcher<View> withListSize (final int size) {
+        return new TypeSafeMatcher<View> () {
+            @Override public boolean matchesSafely (final View view) {
+                return ((ListView) view).getCount () == size;
+            }
+
+            @Override public void describeTo (final Description description) {
+                description.appendText ("ListView should have " + size + " items");
+            }
+        };
+    }
+
+    private static ViewAction waitFor(final long duration_ms) {
+        return new ViewAction() {
+
+            @Override
+            public String getDescription() {
+                return "Wait for milliseconds.";
+            }
+
+            @Override
+            public Matcher<View> getConstraints() {
+                return isDisplayed();
+            }
+
+            @Override
+            public void perform(UiController uiController, final View view) {
+                uiController.loopMainThreadForAtLeast(duration_ms);
+            }
+        };
+    }
+
+    private static ViewAction veryLongTouch(final int duration_ms) {
+        return new ViewAction() {
+            @Override
+            public String getDescription() {
+                return "Perform long touch.";
+            }
+
+            @Override
+            public Matcher<View> getConstraints() {
+                return isDisplayed();
+            }
+
+            @Override
+            public void perform(UiController uiController, final View view) {
+                // Get view absolute position
+                int[] location = new int[2];
+                view.getLocationOnScreen(location);
+
+                // Offset coordinates by view position
+                float[] coordinates = new float[]{location[0] + 1, location[1] + 1};
+
+                // Send down event, pause, and send up
+                MotionEvent down = MotionEvents.sendDown(uiController, coordinates, new float[]{1f, 1f}).down;
+                uiController.loopMainThreadForAtLeast(duration_ms);
+                MotionEvents.sendUp(uiController, down, coordinates);
+            }
+        };
+    }
+
+    private int numberOfItemsListView() {
+        final int[] counts = new int[1];
+        onView(withId(R.id.track_list)).check(matches(new TypeSafeMatcher<View>() {
+            @Override
+            public boolean matchesSafely(View view) {
+                ListView listView = (ListView) view;
+
+                counts[0] = listView.getCount();
+
+                return true;
+            }
+
+            @Override
+            public void describeTo(Description description) {
+
+            }
+        }));
+
+        return counts[0];
+    }
+
+
+    private class MyIdlingResource implements IdlingResource {
+
+        private Context context;
+        private ResourceCallback resourceCallback;
+
+        public MyIdlingResource(Context context) {
+            this.context = context;
+        }
+
+        @Override
+        public String getName() {
+            return MyIdlingResource.class.getName();
+        }
+
+        @Override
+        public void registerIdleTransitionCallback(IdlingResource.ResourceCallback resourceCallback) {
+            this.resourceCallback = resourceCallback;
+        }
+
+        @Override
+        public boolean isIdleNow() {
+            boolean idle = !isDeleteServiceRunning();
+            if (idle && resourceCallback != null) {
+                resourceCallback.onTransitionToIdle();
+            }
+            return idle;
+        }
+
+        private boolean isDeleteServiceRunning() {
+            ActivityManager manager =
+                    (ActivityManager) context.getSystemService(
+                            Context.ACTIVITY_SERVICE);
+            for (ActivityManager.RunningServiceInfo info :
+                    manager.getRunningServices(Integer.MAX_VALUE)) {
+                if (TrackDeleteService.class.getName().equals(
+                        info.service.getClassName())) {
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+}
@@ -19,10 +19,13 @@ import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;

+import static androidx.test.espresso.Espresso.onData;
 import static androidx.test.espresso.Espresso.onView;
 import static androidx.test.espresso.action.ViewActions.click;
+import static androidx.test.espresso.assertion.ViewAssertions.matches;
 import static androidx.test.espresso.matcher.ViewMatchers.isDisplayed;
 import static androidx.test.espresso.matcher.ViewMatchers.withId;
+import static org.hamcrest.Matchers.anything;

@LargeTest
@RunWith(AndroidJUnit4.class)
@@ -39,13 +42,13 @@ public class EspressoUITest {
    public void record_pause_resume_stop() {
        {
            // TrackListActivity: start recording
-            ViewInteraction trackControllerRecordButton = onView(withId(R.id.track_controller_record));
+            ViewInteraction trackControllerRecordButton = onView(withId(R.id.controller_record));
            trackControllerRecordButton.perform(click());
        }
        {
            // TrackRecordingActivity
-            ViewInteraction trackControllerRecordButton = onView(withId(R.id.track_controller_record));
-            ViewInteraction trackControllerStopButton = onView(withId(R.id.track_controller_stop));
+            ViewInteraction trackControllerRecordButton = onView(withId(R.id.controller_record));
+            ViewInteraction trackControllerStopButton = onView(withId(R.id.controller_stop));

            // wait; stay recording
            trackControllerRecordButton.perform(waitFor(5000));
@@ -72,13 +75,13 @@ public class EspressoUITest {
    public void record_move_through_tabs() {
        {
            // TrackListActivity: start recording
-            ViewInteraction trackControllerRecordButton = onView(withId(R.id.track_controller_record));
+            ViewInteraction trackControllerRecordButton = onView(withId(R.id.controller_record));
            trackControllerRecordButton.perform(click());
        }
        {
            // TrackRecordingActivity
            ViewInteraction tabLayout = onView(withId(R.id.track_detail_activity_tablayout));
-            ViewInteraction trackControllerStopButton = onView(withId(R.id.track_controller_stop));
+            ViewInteraction trackControllerStopButton = onView(withId(R.id.controller_stop));

            tabLayout.perform(selectTabAtIndex(1));
            tabLayout.perform(waitFor(1000));
@@ -97,6 +100,13 @@ public class EspressoUITest {
        }
    }

+    @LargeTest
+    @Test
+    public void selectAndDeleteTrack() {
+        onView(withId(R.id.track_list)).check(matches(isDisplayed()));
+        onData(anything()).inAdapterView(withId(R.id.track_list)).atPosition(0).perform(veryLongTouch(2000));
+    }
+
    private static ViewAction veryLongTouch(final int duration_ms) {
        return new ViewAction() {
            @Override
@@ -0,0 +1,94 @@
+package de.dennisguse.opentracks.chart;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.time.Duration;
+
+import de.dennisguse.opentracks.content.data.Distance;
+import de.dennisguse.opentracks.content.data.Speed;
+import de.dennisguse.opentracks.content.data.TrackPoint;
+import de.dennisguse.opentracks.fragments.TrackStubUtils;
+import de.dennisguse.opentracks.stats.TrackStatistics;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+@RunWith(AndroidJUnit4.class)
+public class ChartPointTest {
+
+    @Test
+    public void create_by_time() {
+        // given
+        TrackStatistics statistics = new TrackStatistics();
+        statistics.setTotalTime(Duration.ofSeconds(1000));
+
+        // when
+        ChartPoint point = new ChartPoint(statistics, TrackStubUtils.createDefaultTrackPoint(), Speed.of(0), 0, false, false);
+
+        // then
+        assertEquals(1000000, (long) point.getTimeOrDistance());
+    }
+
+    @Test
+    public void create_by_distance() {
+        // given
+        TrackStatistics statistics = new TrackStatistics();
+        statistics.setTotalDistance(Distance.of(1000));
+
+        // when
+        ChartPoint point = new ChartPoint(statistics, TrackStubUtils.createDefaultTrackPoint(), Speed.of(0), 0, true, true);
+
+        // then
+        assertEquals(1, (long) point.getTimeOrDistance());
+    }
+
+    @Test
+    public void create_get_altitude_speed_and_pace() {
+        // given
+        TrackStatistics statistics = new TrackStatistics();
+
+        // when
+        ChartPoint point = new ChartPoint(statistics, TrackStubUtils.createDefaultTrackPoint(), Speed.of(10), 50, false, true);
+
+        // then
+        assertEquals(50, point.getAltitude(), 0.01);
+        assertEquals(36, point.getSpeed(), 0.01);
+        assertEquals(1.66, point.getPace(), 0.01);
+    }
+
+    @Test
+    public void create_sensorNotAvailable() {
+        // given
+        TrackStatistics statistics = new TrackStatistics();
+
+        // when
+        ChartPoint point = new ChartPoint(statistics, TrackStubUtils.createDefaultTrackPoint(), Speed.of(10), 50, false, true);
+
+        // then
+        assertNull(point.getHeartRate());
+        assertNull(point.getCadence());
+        assertNull(point.getPower());
+    }
+
+    @Test
+    public void create_sensorAvailable() {
+        // given
+        TrackPoint trackPoint = TrackStubUtils.createDefaultTrackPoint();
+        trackPoint.setHeartRate_bpm(100f);
+        trackPoint.setCyclingCadence_rpm(101f);
+        trackPoint.setPower(102f);
+
+        TrackStatistics statistics = new TrackStatistics();
+
+        // when
+        ChartPoint point = new ChartPoint(statistics, trackPoint, Speed.of(10), 50, false, true);
+
+        // then
+        assertEquals(100.0, point.getHeartRate(), 0.01);
+        assertEquals(101.0, point.getCadence(), 0.01);
+        assertEquals(102.0, point.getPower(), 0.01);
+    }
+}
@@ -44,7 +44,7 @@ public class ChartValueSeriesTest {
                ApplicationProvider.getApplicationContext(),
                Integer.MIN_VALUE,
                Integer.MAX_VALUE,
-                new int[]{100, 1000},
+                new int[]{1, 100, 1000},
                R.string.description_altitude_metric,
                R.string.description_altitude_imperial,
                R.color.chart_altitude_fill,
@@ -52,7 +52,7 @@ public class ChartValueSeriesTest {
                15,
                18) {
            @Override
-            double extractDataFromChartPoint(@NonNull ChartPoint chartPoint) {
+            Double extractDataFromChartPoint(@NonNull ChartPoint chartPoint) {
                return chartPoint.getAltitude();
            }

@@ -77,6 +77,17 @@ public class ChartValueSeriesTest {
        assertFalse(series.isEnabled());
    }

+    @Test
+    public void testVerySmallUpdates() {
+        series.update(new ChartPoint(1f));
+        series.update(new ChartPoint(2f));
+        series.update(new ChartPoint(3f));
+        series.updateDimension();
+        assertEquals(1, series.getInterval());
+        assertEquals(1, series.getMinMarkerValue());
+        assertEquals(6, series.getMaxMarkerValue());
+    }
+
    @Test
    public void testSmallUpdates() {
        series.update(new ChartPoint(0));
@@ -1,10 +1,13 @@
 package de.dennisguse.opentracks.content.data;

+import android.location.Location;
+
 import org.junit.Test;

 import java.time.Instant;
 import java.time.temporal.ChronoUnit;

+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;

@@ -25,4 +28,35 @@ public class TrackPointTest {

        assertFalse(tp.isRecent());
    }
+
+    @Test
+    public void distanceToPrevious() {
+        Location l1 = new Location("test");
+        l1.setLatitude(0);
+        l1.setLongitude(0.0001);
+        TrackPoint tp1 = new TrackPoint(l1);
+
+        Location l2 = new Location("test");
+        l2.setLatitude(0);
+        l2.setLongitude(0.0002);
+        TrackPoint tp2 = new TrackPoint(l2);
+
+        // without sensor distance
+        assertEquals(11.13, tp2.distanceToPrevious(tp1).toM(), 0.01);
+
+        // tp1 has sensor distance
+        tp1.setSensorDistance(Distance.of(5));
+        tp1.setSensorDistance(null);
+        assertEquals(11.13, tp2.distanceToPrevious(tp1).toM(), 0.01);
+
+        // tp2 has sensor distance
+        tp1.setSensorDistance(null);
+        tp2.setSensorDistance(Distance.of(5));
+        assertEquals(5, tp2.distanceToPrevious(tp1).toM(), 0.01);
+
+        // tp1 and tp2 have sensor distance
+        tp1.setSensorDistance(Distance.of(10));
+        tp2.setSensorDistance(Distance.of(5));
+        assertEquals(5, tp2.distanceToPrevious(tp1).toM(), 0.01);
+    }
 }
@@ -5,6 +5,7 @@ import androidx.test.ext.junit.runners.AndroidJUnit4;
 import org.junit.Test;
 import org.junit.runner.RunWith;

+import de.dennisguse.opentracks.content.data.Distance;
 import de.dennisguse.opentracks.util.UintUtils;

 import static org.junit.Assert.assertEquals;
@@ -100,7 +101,7 @@ public class SensorDataCyclingTest {
        SensorDataCycling.DistanceSpeed current = new SensorDataCycling.DistanceSpeed("sensorAddress", "sensorName", 2, 8016);

        // when
-        current.compute(previous, 2150);
+        current.compute(previous, Distance.ofMM(2150));

        // then
        assertEquals(2.15, current.getValue().distance.toM(), 0.01);
@@ -114,7 +115,7 @@ public class SensorDataCyclingTest {
        SensorDataCycling.DistanceSpeed current = new SensorDataCycling.DistanceSpeed("sensorAddress", "sensorName", 0, 2048);

        // when
-        current.compute(previous, 2000);
+        current.compute(previous, Distance.ofMM(2000));

        // then
        assertEquals(2, current.getValue().distance.toM(), 0.01);
@@ -16,7 +16,6 @@

 package de.dennisguse.opentracks.fragments;

-import android.location.Location;
 import android.os.Looper;

 import androidx.test.core.app.ApplicationProvider;
@@ -28,23 +27,14 @@ import org.junit.BeforeClass;
 import org.junit.Test;
 import org.junit.runner.RunWith;

-import java.time.Duration;
-import java.time.Instant;
-
-import de.dennisguse.opentracks.chart.ChartPoint;
 import de.dennisguse.opentracks.chart.ChartView;
-import de.dennisguse.opentracks.content.data.Distance;
-import de.dennisguse.opentracks.content.data.Speed;
-import de.dennisguse.opentracks.content.data.TrackPoint;
-import de.dennisguse.opentracks.util.UnitConversions;
-
-import static org.junit.Assert.assertEquals;

 /**
 * Tests {@link ChartFragment}.
 *
 * @author Youtao Liu
 */
+//TODO Add tests that check ChartFragment
@RunWith(AndroidJUnit4.class)
 public class ChartFragmentTest {

@@ -68,264 +58,10 @@ public class ChartFragmentTest {
        boolean chartByDistance = false;
        chartFragment = ChartFragment.newInstance(chartByDistance);
        chartFragment.setChartView(new ChartView(ApplicationProvider.getApplicationContext(), chartByDistance));
-        chartFragment.setRecordingDistanceInterval(Distance.of(50));
    }

-    /**
-     * Tests the logic to get the incorrect values of sensor in {@link ChartFragment#createPendingPoint(TrackPoint)}.
-     */
    @Test
-    public void testCreatePendingPoint_sensorIncorrect() {
-        // given
-        TrackPoint trackPoint = TrackStubUtils.createDefaultTrackPoint();
-
-        // when
-        ChartPoint point = chartFragment.createPendingPoint(trackPoint);
-
-        // then
-        assertEquals(Float.NaN, point.getHeartRate(), 0.01);
-        assertEquals(Float.NaN, point.getCadence(), 0.01);
-        assertEquals(Float.NaN, point.getPower(), 0.01);
-    }
-
-    /**
-     * Tests the logic to get the correct values of sensor in {@link ChartFragment#createPendingPoint(TrackPoint)}.
-     */
-    @Test
-    public void testCreatePendingPoint_sensorCorrect() {
-        // given
-        TrackPoint trackPoint = TrackStubUtils.createDefaultTrackPoint();
-        trackPoint.setHeartRate_bpm(100f);
-        trackPoint.setCyclingCadence_rpm(101f);
-        trackPoint.setPower(102f);
-
-        // when
-        ChartPoint point = chartFragment.createPendingPoint(trackPoint);
-
-        // then
-        assertEquals(100.0, point.getHeartRate(), 0.01);
-        assertEquals(101.0, point.getCadence(), 0.01);
-        assertEquals(102.0, point.getPower(), 0.01);
-    }
-
-    /**
-     * Tests the logic to get the value of metric Distance in {@link ChartFragment#createPendingPoint(TrackPoint)}.
-     */
-    @Test
-    public void testCreatePendingPoint_distanceMetric() {
-        chartFragment.setChartByDistance(true);
-        // Resets last location and writes first location.
-        TrackPoint trackPoint1 = TrackStubUtils.createDefaultTrackPoint();
-        ChartPoint point = chartFragment.createPendingPoint(trackPoint1);
-        assertEquals(0.0, point.getTimeOrDistance(), 0.01);
-
-        // The second is a same location, just different time.
-        TrackPoint trackPoint2 = TrackStubUtils.createDefaultTrackPoint();
-        point = chartFragment.createPendingPoint(trackPoint2);
-        assertEquals(0.0, point.getTimeOrDistance(), 0.01);
-
-        // The third location is a new location, and use metric.
-        TrackPoint trackPoint3 = TrackStubUtils.createDefaultTrackPoint();
-        trackPoint3.setLatitude(23);
-        point = chartFragment.createPendingPoint(trackPoint3);
-
-        // Computes the distance between Latitude 22 and 23.
-        float[] results = new float[4];
-        Location.distanceBetween(trackPoint2.getLatitude(), trackPoint2.getLongitude(),
-                trackPoint3.getLatitude(), trackPoint3.getLongitude(), results);
-        double distance1 = results[0] * UnitConversions.M_TO_KM;
-        assertEquals(distance1, point.getTimeOrDistance(), 0.01);
-
-        // The fourth location is a new location, and use metric.
-        TrackPoint trackPoint4 = TrackStubUtils.createDefaultTrackPoint();
-        trackPoint4.setLatitude(24);
-        point = chartFragment.createPendingPoint(trackPoint4);
-
-        // Computes the distance between Latitude 23 and 24.
-        Location.distanceBetween(trackPoint3.getLatitude(), trackPoint3.getLongitude(),
-                trackPoint4.getLatitude(), trackPoint4.getLongitude(), results);
-        double distance2 = results[0] * UnitConversions.M_TO_KM;
-        assertEquals((distance1 + distance2), point.getTimeOrDistance(), 0.01);
-    }
-
-    /**
-     * Tests the logic to get the value of imperial Distance in {@link ChartFragment#createPendingPoint(TrackPoint)}.
-     */
-    @Test
-    public void testCreatePendingPoint_distanceImperial() {
-        // By distance.
-        chartFragment.setChartByDistance(true);
-        // Setups to use imperial.
-        chartFragment.setMetricUnits(false);
-
-        // The first is a same location, just different time.
-        TrackPoint trackPoint1 = TrackStubUtils.createDefaultTrackPoint();
-        ChartPoint point = chartFragment.createPendingPoint(trackPoint1);
-        assertEquals(0.0, point.getTimeOrDistance(), 0.01);
-
-        // The second location is a new location, and use imperial.
-        TrackPoint trackPoint2 = TrackStubUtils.createDefaultTrackPoint();
-        trackPoint2.setLatitude(23);
-        point = chartFragment.createPendingPoint(trackPoint2);
-
-        /*
-         * Computes the distance between Latitude 22 and 23.
-         * And for we set using * imperial, the distance should be multiplied by UnitConversions.KM_TO_MI.
-         */
-        float[] results = new float[4];
-        Location.distanceBetween(trackPoint1.getLatitude(), trackPoint1.getLongitude(), trackPoint2.getLatitude(), trackPoint2.getLongitude(), results);
-        double distance1 = results[0] * UnitConversions.M_TO_KM * UnitConversions.KM_TO_MI;
-        assertEquals(distance1, point.getTimeOrDistance(), 0.01);
-
-        // The third location is a new location, and use imperial.
-        TrackPoint trackPoint3 = TrackStubUtils.createDefaultTrackPoint();
-        trackPoint3.setLatitude(24);
-        point = chartFragment.createPendingPoint(trackPoint3);
-
-        /*
-         * Computes the distance between Latitude 23 and 24.
-         * And for we set using * imperial, the distance should be multiplied by UnitConversions.KM_TO_MI.
-         */
-        Location.distanceBetween(trackPoint2.getLatitude(), trackPoint2.getLongitude(), trackPoint3.getLatitude(), trackPoint3.getLongitude(), results);
-        double distance2 = results[0] * UnitConversions.M_TO_KM * UnitConversions.KM_TO_MI;
-        assertEquals(distance1 + distance2, point.getTimeOrDistance(), 0.01);
-    }
-
-    /**
-     * Tests the logic to get the values of time in {@link ChartFragment#createPendingPoint(TrackPoint)}.
-     */
-    @Test
-    public void testCreatePendingPoint_time() {
-        // given
-        chartFragment.setChartByDistance(false);
-        TrackPoint trackPoint1 = TrackStubUtils.createDefaultTrackPoint();
-        trackPoint1.setTime(Instant.ofEpochMilli(TrackStubUtils.INITIAL_TIME)); //Keep old TrackPoint behavior of having time=0 for this test
-
-        // when
-        ChartPoint point = chartFragment.createPendingPoint(trackPoint1);
-
-        // then
-        assertEquals(0.0, point.getTimeOrDistance(), 0.01);
-        Duration timeSpan = Duration.ofMillis(222);
-        TrackPoint trackPoint2 = TrackStubUtils.createDefaultTrackPoint();
-        trackPoint2.setTime(Instant.ofEpochMilli(TrackStubUtils.INITIAL_TIME).plus(timeSpan));
-        point = chartFragment.createPendingPoint(trackPoint2);
-        assertEquals(timeSpan, Duration.ofMillis((long) point.getTimeOrDistance()));
-    }
-
-    /**
-     * Tests the logic to get the value of altitude in {@link ChartFragment#createPendingPoint(TrackPoint)} by one and two points.
-     */
-    @Test
-    public void testCreatePendingPoint_altitude() {
-        TrackPoint trackPoint1 = TrackStubUtils.createDefaultTrackPoint();
-
-        /*
-         * At first, clear old points of altitude, so give true to the second parameter.
-         * Then only one value INITIAL_ALTITUDE in buffer.
-         */
-        ChartPoint point = chartFragment.createPendingPoint(trackPoint1);
-        assertEquals(TrackStubUtils.INITIAL_ALTITUDE, point.getAltitude(), 0.01);
-
-        /*
-         * Send another value to buffer, now there are two values, INITIAL_ALTITUDE and INITIAL_ALTITUDE * 2.
-         */
-        TrackPoint trackPoint2 = TrackStubUtils.createDefaultTrackPoint();
-        trackPoint2.setAltitude(TrackStubUtils.INITIAL_ALTITUDE * 2);
-        point = chartFragment.createPendingPoint(trackPoint2);
-        assertEquals((TrackStubUtils.INITIAL_ALTITUDE + TrackStubUtils.INITIAL_ALTITUDE * 2) / 2.0, point.getAltitude(), 0.01);
-    }
-
-    /**
-     * Tests the logic to get the value of speed in {@link ChartFragment#createPendingPoint(TrackPoint)}.
-     * In this test, firstly remove all points in memory, and then fill in two points one by one.
-     * The speed values of these points are 129, 130.
-     */
-    @Test
-    public void testCreatePendingPoint_speed() {
-        /*
-         * At first, clear old points of speed, so give true to the second parameter.
-         * It will not be filled in to the speed buffer.
-         */
-        TrackPoint trackPoint1 = TrackStubUtils.createDefaultTrackPoint();
-        trackPoint1.setSpeed(Speed.of(128.5f));
-        ChartPoint point = chartFragment.createPendingPoint(trackPoint1);
-        assertEquals(0.0, point.getSpeed(), 0.01);
-
-        /*
-         * Tests the logic when both metricUnits and reportSpeed are true.
-         * This location will be filled into speed buffer.
-         */
-        TrackPoint trackPoint2 = TrackStubUtils.createDefaultTrackPoint();
-
-        /*
-         * Add a time span here to make sure the second point is valid, the value 222 here is doesn't matter.
-         */
-        trackPoint2.setTime(trackPoint1.getTime().plusMillis(222));
-        trackPoint2.setSpeed(Speed.of(130f));
-        point = chartFragment.createPendingPoint(trackPoint2);
-        assertEquals(130.0 * UnitConversions.MPS_TO_KMH, point.getSpeed(), 0.01);
-    }
-
-    /**
-     * Tests the logic to compute speed when use Imperial.
-     */
-    @Test
-    public void testCreatePendingPoint_speedImperial() {
-        chartFragment.setMetricUnits(false);
-
-        // First data point is not added to the speed buffer
-        TrackPoint trackPoint1 = TrackStubUtils.createDefaultTrackPoint();
-        trackPoint1.setSpeed(Speed.of(100.0f));
-        ChartPoint point = chartFragment.createPendingPoint(trackPoint1);
-        assertEquals(0.0, point.getSpeed(), 0.01);
-
-        TrackPoint trackPoint2 = TrackStubUtils.createDefaultTrackPoint();
-
-        /*
-         * Add a time span here to make sure the second point and the speed is valid.
-         * Speed is valid if: speedDifference > Constants.MAX_ACCELERATION * timeDifference speedDifference = 102 -100 timeDifference = 222
-         */
-        trackPoint2.setTime(trackPoint2.getTime().plusMillis(222));
-        trackPoint2.setSpeed(Speed.of(102f));
-        point = chartFragment.createPendingPoint(trackPoint2);
-        assertEquals(102.0 * UnitConversions.MPS_TO_KMH * UnitConversions.KM_TO_MI, point.getSpeed(), 0.01);
-    }
-
-    /**
-     * Tests the logic to get pace value when reportSpeed is false.
-     */
-    @Test
-    public void testCreatePendingPoint_pace_nonZeroSpeed() {
-        chartFragment.setReportSpeed(false);
-
-        // First data point is not added to the speed buffer
-        TrackPoint trackPoint1 = TrackStubUtils.createDefaultTrackPoint();
-        trackPoint1.setSpeed(Speed.of(100.0f));
-        ChartPoint point = chartFragment.createPendingPoint(trackPoint1);
-        assertEquals(0.0, point.getSpeed(), 0.01);
-
-        TrackPoint trackPoint2 = TrackStubUtils.createDefaultTrackPoint();
-
-        /*
-         * Add a time span here to make sure the second point and the speed is valid.
-         * Speed is valid if: speedDifference > Constants.MAX_ACCELERATION * timeDifference speedDifference = 102 -100 timeDifference = 222
-         */
-        trackPoint2.setTime(trackPoint2.getTime().plusMillis(222));
-        trackPoint2.setSpeed(Speed.of(102f));
-        point = chartFragment.createPendingPoint(trackPoint2);
-        assertEquals(HOURS_PER_UNIT / (102.0 * UnitConversions.MPS_TO_KMH), point.getPace(), 0.01);
-    }
-
-    /**
-     * Tests the logic to get pace value when reportSpeed is false and average speed is zero.
-     */
-    @Test
-    public void testCreatePendingPoint_pace_zeroSpeed() {
-        chartFragment.setReportSpeed(false);
-        TrackPoint trackPoint = TrackStubUtils.createDefaultTrackPoint();
-        trackPoint.setSpeed(Speed.of(0f));
-        ChartPoint point = chartFragment.createPendingPoint(trackPoint);
-        assertEquals(0.0, point.getPace(), 0.01);
+    public void nothing() {
+        //TODO
    }
 }
@@ -3,24 +3,26 @@ package de.dennisguse.opentracks.io.file.importer;
 import android.content.Context;
 import android.content.Intent;
 import android.content.SharedPreferences;
+import android.net.Uri;
 import android.os.Looper;
 import android.util.Log;

 import androidx.preference.PreferenceManager;
 import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
 import androidx.test.filters.LargeTest;
 import androidx.test.rule.GrantPermissionRule;
 import androidx.test.rule.ServiceTestRule;

 import org.junit.After;
+import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;

-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
 import java.io.InputStream;
 import java.time.Instant;
 import java.util.ArrayList;
@@ -30,6 +32,7 @@ import java.util.concurrent.TimeoutException;
 import java.util.stream.Collectors;

 import de.dennisguse.opentracks.R;
+import de.dennisguse.opentracks.content.data.Altitude;
 import de.dennisguse.opentracks.content.data.Distance;
 import de.dennisguse.opentracks.content.data.Marker;
 import de.dennisguse.opentracks.content.data.Speed;
@@ -41,7 +44,6 @@ import de.dennisguse.opentracks.io.file.TrackFileFormat;
 import de.dennisguse.opentracks.io.file.exporter.TrackExporter;
 import de.dennisguse.opentracks.services.TrackRecordingService;
 import de.dennisguse.opentracks.stats.TrackStatistics;
-import de.dennisguse.opentracks.util.PreferencesUtils;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
@@ -53,7 +55,7 @@ import static org.junit.Assert.assertTrue;
 * Export a track to {@link TrackFileFormat} and verify that the import is identical.
 * <p>
 */
-@RunWith(JUnit4.class)
+@RunWith(AndroidJUnit4.class)
 public class ExportImportTest {

    private static final String TAG = ExportImportTest.class.getSimpleName();
@@ -71,7 +73,6 @@ public class ExportImportTest {
    }

    private final Context context = ApplicationProvider.getApplicationContext();
-    private final SharedPreferences sharedPreferences = PreferencesUtils.getSharedPreferences(context);

    private final ContentProviderUtils contentProviderUtils = new ContentProviderUtils(context);

@@ -79,6 +80,9 @@ public class ExportImportTest {
    private static final String TRACK_CATEGORY = "the category";
    private static final String TRACK_DESCRIPTION = "the description";

+    private File tmpFile;
+    private Uri tmpFileUri;
+
    private Track track;
    private List<Marker> markers = new ArrayList<>();
    private List<TrackPoint> trackPoints = new ArrayList<>();
@@ -86,6 +90,18 @@ public class ExportImportTest {
    private Track.Id trackId;
    private Track.Id importTrackId;

+    @Before
+    public void fileSetup() throws IOException {
+        tmpFile = File.createTempFile("test", "test", context.getFilesDir());
+        tmpFileUri = Uri.fromFile(tmpFile);
+    }
+
+    @After
+    public void FileTearDown() {
+        tmpFile.deleteOnExit();
+        tmpFileUri = null;
+    }
+
    public void setUp(boolean hasSensorDistance) throws TimeoutException {
        TrackRecordingService service = ((TrackRecordingService.Binder) mServiceRule.bindService(new Intent(context, TrackRecordingService.class)))
                .getService();
@@ -138,7 +154,7 @@ public class ExportImportTest {

    @LargeTest
    @Test
-    public void kml_with_trackdetail() throws TimeoutException {
+    public void kml_with_trackdetail() throws TimeoutException, IOException {
        setUp(false);

        // given
@@ -148,13 +164,12 @@ public class ExportImportTest {

        // when
        // 1. export
-        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
-        trackExporter.writeTrack(track, outputStream);
+        trackExporter.writeTrack(track, context.getContentResolver().openOutputStream(tmpFileUri));
        contentProviderUtils.deleteTrack(context, trackId);

        // 2. import
-        InputStream inputStream = new ByteArrayInputStream(outputStream.toByteArray());
-        AbstractFileTrackImporter trackImporter = new KmlFileTrackImporter(context);
+        InputStream inputStream = context.getContentResolver().openInputStream(tmpFileUri);
+        XMLImporter trackImporter = new XMLImporter(new KmlFileTrackImporter(context));
        importTrackId = trackImporter.importFile(inputStream).get(0);

        // then
@@ -179,7 +194,7 @@ public class ExportImportTest {

    @LargeTest
    @Test
-    public void kml_with_trackdetail_and_sensordata() throws TimeoutException {
+    public void kml_with_trackdetail_and_sensordata() throws TimeoutException, IOException {
        setUp(true);

        // given
@@ -189,13 +204,12 @@ public class ExportImportTest {

        // when
        // 1. export
-        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
-        trackExporter.writeTrack(track, outputStream);
+        trackExporter.writeTrack(track, context.getContentResolver().openOutputStream(tmpFileUri));
        contentProviderUtils.deleteTrack(context, trackId);

        // 2. import
-        InputStream inputStream = new ByteArrayInputStream(outputStream.toByteArray());
-        AbstractFileTrackImporter trackImporter = new KmlFileTrackImporter(context);
+        InputStream inputStream = context.getContentResolver().openInputStream(tmpFileUri);
+        XMLImporter trackImporter = new XMLImporter(new KmlFileTrackImporter(context));
        importTrackId = trackImporter.importFile(inputStream).get(0);

        // then
@@ -217,9 +231,48 @@ public class ExportImportTest {
        assertMarkers();
    }

+    //TODO Does not test images
+    @LargeTest
+    @Test
+    public void kmz_with_trackdetail_and_sensordata() throws TimeoutException, IOException {
+        setUp(true);
+
+        // given
+        Track track = contentProviderUtils.getTrack(trackId);
+
+        TrackExporter trackExporter = TrackFileFormat.KMZ_WITH_TRACKDETAIL_AND_SENSORDATA.createTrackExporter(context);
+
+        // when
+        // 1. export
+        trackExporter.writeTrack(track, context.getContentResolver().openOutputStream(tmpFileUri));
+        contentProviderUtils.deleteTrack(context, trackId);
+
+        // 2. import
+        KmzTrackImporter trackImporter = new KmzTrackImporter();
+        importTrackId = trackImporter.importFile(context, tmpFileUri).get(0);
+
+        // then
+        // 1. track
+        Track importedTrack = contentProviderUtils.getTrack(importTrackId);
+        assertNotNull(importedTrack);
+        assertEquals(track.getCategory(), importedTrack.getCategory());
+        assertEquals(track.getDescription(), importedTrack.getDescription());
+        assertEquals(track.getName(), importedTrack.getName());
+        assertEquals(track.getIcon(), importedTrack.getIcon());
+
+        // 2. trackpoints
+        assertTrackpoints(trackPoints, true, true, true, true, true, true);
+
+        // 2. trackstatistics
+        assertTrackStatistics(false, true, true);
+
+        // 4. markers
+        assertMarkers();
+    }
+
    @LargeTest
    @Test(expected = ImportAlreadyExistsException.class)
-    public void kml_with_trackdetail_and_sensordata_duplicate_trackUUID() throws TimeoutException {
+    public void kml_with_trackdetail_and_sensordata_duplicate_trackUUID() throws TimeoutException, IOException {
        setUp(false);

        // given
@@ -231,13 +284,11 @@ public class ExportImportTest {
        TrackExporter trackExporter = TrackFileFormat.KML_WITH_TRACKDETAIL_AND_SENSORDATA.createTrackExporter(context);

        // when
-        // 1. export
-        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
-        trackExporter.writeTrack(track, outputStream);
+        trackExporter.writeTrack(track, context.getContentResolver().openOutputStream(tmpFileUri));

        // 2. import
-        InputStream inputStream = new ByteArrayInputStream(outputStream.toByteArray());
-        AbstractFileTrackImporter trackImporter = new KmlFileTrackImporter(context);
+        InputStream inputStream = context.getContentResolver().openInputStream(tmpFileUri);
+        XMLImporter trackImporter = new XMLImporter(new KmlFileTrackImporter(context));
        importTrackId = trackImporter.importFile(inputStream).get(0);

        // then
@@ -247,7 +298,7 @@ public class ExportImportTest {

    @LargeTest
    @Test
-    public void gpx() throws TimeoutException {
+    public void gpx() throws TimeoutException, IOException {
        setUp(true);

        // given
@@ -257,13 +308,12 @@ public class ExportImportTest {

        // when
        // 1. export
-        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
-        trackExporter.writeTrack(track, outputStream);
+        trackExporter.writeTrack(track, context.getContentResolver().openOutputStream(tmpFileUri));
        contentProviderUtils.deleteTrack(context, trackId);

        // 2. import
-        InputStream inputStream = new ByteArrayInputStream(outputStream.toByteArray());
-        AbstractFileTrackImporter trackImporter = new GpxFileTrackImporter(context, contentProviderUtils);
+        InputStream inputStream = context.getContentResolver().openInputStream(tmpFileUri);
+        XMLImporter trackImporter = new XMLImporter(new GpxFileTrackImporter(context, contentProviderUtils));
        importTrackId = trackImporter.importFile(inputStream).get(0);

        // then
@@ -295,7 +345,7 @@ public class ExportImportTest {

    @LargeTest
    @Test(expected = ImportAlreadyExistsException.class)
-    public void gpx_duplicate_trackUUID() throws TimeoutException {
+    public void gpx_duplicate_trackUUID() throws TimeoutException, IOException {
        setUp(false);

        // given
@@ -308,12 +358,11 @@ public class ExportImportTest {

        // when
        // 1. export
-        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
-        trackExporter.writeTrack(track, outputStream);
+        trackExporter.writeTrack(track, context.getContentResolver().openOutputStream(tmpFileUri));

        // 2. import
-        InputStream inputStream = new ByteArrayInputStream(outputStream.toByteArray());
-        AbstractFileTrackImporter trackImporter = new GpxFileTrackImporter(context, contentProviderUtils);
+        InputStream inputStream = context.getContentResolver().openInputStream(tmpFileUri);
+        XMLImporter trackImporter = new XMLImporter(new GpxFileTrackImporter(context, contentProviderUtils));
        importTrackId = trackImporter.importFile(inputStream).get(0);

        // then
@@ -368,7 +417,7 @@ public class ExportImportTest {
            }
            assertEquals(trackPoint.hasAltitude(), importedTrackPoint.hasAltitude());
            if (trackPoint.hasAltitude()) {
-                assertEquals(trackPoint.getAltitude(), importedTrackPoint.getAltitude(), 0.001);
+                assertEquals(trackPoint.getAltitude().toM(), importedTrackPoint.getAltitude().toM(), 0.001);
            }

            if (type.equals(TrackPoint.Type.SEGMENT_START_MANUAL) || type.equals(TrackPoint.Type.SEGMENT_END_MANUAL)) {
@@ -438,7 +487,7 @@ public class ExportImportTest {
    }

    private static TrackPoint createTrackPoint(long time, double latitude, double longitude, float accuracy, float speed, float altitude, float altitudeGain, float heartRate, float cyclingCadence, float power, Distance distance) {
-        TrackPoint tp = new TrackPoint(latitude, longitude, (double) altitude, Instant.ofEpochMilli(time));
+        TrackPoint tp = new TrackPoint(latitude, longitude, Altitude.WGS84.of(altitude), Instant.ofEpochMilli(time));
        tp.setAccuracy(accuracy);
        tp.setSpeed(Speed.of(speed));
        tp.setHeartRate_bpm(heartRate);
@@ -11,6 +11,7 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;

+import java.io.IOException;
 import java.io.InputStream;
 import java.util.List;

@@ -48,9 +49,9 @@ public class LegacyImportTest {
     */
    @LargeTest
    @Test
-    public void kml_with_statistics_marker() {
+    public void kml_with_statistics_marker() throws IOException {
        // given
-        KmlFileTrackImporter trackImporter = new KmlFileTrackImporter(context);
+        XMLImporter trackImporter = new XMLImporter(new KmlFileTrackImporter(context));
        InputStream inputStream = InstrumentationRegistry.getInstrumentation().getContext().getResources().openRawResource(de.dennisguse.opentracks.debug.test.R.raw.legacy_kml_statistics_marker);

        // when
@@ -90,9 +91,9 @@ public class LegacyImportTest {
     */
    @LargeTest
    @Test(expected = ImportParserException.class)
-    public void kml_without_locations() {
+    public void kml_without_locations() throws IOException {
        // given
-        KmlFileTrackImporter trackImporter = new KmlFileTrackImporter(context);
+        XMLImporter trackImporter = new XMLImporter(new KmlFileTrackImporter(context));
        InputStream inputStream = InstrumentationRegistry.getInstrumentation().getContext().getResources().openRawResource(de.dennisguse.opentracks.debug.test.R.raw.legacy_kml_empty);

        // when
@@ -104,9 +105,9 @@ public class LegacyImportTest {
     */
    @LargeTest
    @Test
-    public void gpx_with_pause_resume() {
+    public void gpx_with_pause_resume() throws IOException {
        // given
-        GpxFileTrackImporter trackImporter = new GpxFileTrackImporter(context);
+        XMLImporter trackImporter = new XMLImporter(new GpxFileTrackImporter(context));
        InputStream inputStream = InstrumentationRegistry.getInstrumentation().getContext().getResources().openRawResource(de.dennisguse.opentracks.debug.test.R.raw.legacy_gpx_pause_resume);

        // when
@@ -151,7 +152,7 @@ public class LegacyImportTest {
        if (altitude == null) {
            assertFalse(trackPoint.hasAltitude());
        } else {
-            assertEquals(altitude, (Double) trackPoint.getAltitude());
+            assertEquals(altitude, (Double) trackPoint.getAltitude().toM());
        }

    }
@@ -31,6 +31,7 @@ import androidx.test.rule.GrantPermissionRule;
 import androidx.test.rule.ServiceTestRule;

 import org.junit.After;
+import org.junit.AfterClass;
 import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Rule;
@@ -83,6 +84,10 @@ public class TrackRecordingServiceTest {
        if (Looper.myLooper() == null) Looper.prepare();
    }

+    @AfterClass
+    public static void finalTearDown() {
+        if (Looper.myLooper() != null) Looper.myLooper().quit();
+    }

    private final Context context = ApplicationProvider.getApplicationContext();
    private final SharedPreferences sharedPreferences = PreferencesUtils.getSharedPreferences(context);
@@ -13,6 +13,7 @@ import androidx.test.rule.GrantPermissionRule;
 import androidx.test.rule.ServiceTestRule;

 import org.junit.After;
+import org.junit.AfterClass;
 import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Rule;
@@ -44,6 +45,7 @@ import static org.junit.Assert.assertNotNull;
 * So, if it is executed on a real device, data might be lost.
 */
@RunWith(AndroidJUnit4.class)
+//TODO Implement as mock test; no need to store data in database
 public class TrackRecordingServiceTestLocation {

    @Rule
@@ -63,6 +65,11 @@ public class TrackRecordingServiceTestLocation {
        if (Looper.myLooper() == null) Looper.prepare();
    }

+    @AfterClass
+    public static void finalTearDown() {
+        if (Looper.myLooper() != null) Looper.myLooper().quit();
+    }
+
    @Before
    public void setUp() throws TimeoutException {
        // Set up the mock content resolver
@@ -1,59 +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.services.tasks;
-
-import android.content.Context;
-import android.os.Looper;
-
-import androidx.test.core.app.ApplicationProvider;
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-
-import org.junit.AfterClass;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import static org.junit.Assert.assertTrue;
-
-/**
- * Tests for {@link AnnouncementPeriodicTaskFactory}.
- *
- * @author Rodrigo Damazio
- */
-@RunWith(AndroidJUnit4.class)
-public class AnnouncementPeriodicTaskFactoryTest {
-
-    private final Context context = ApplicationProvider.getApplicationContext();
-
-    @BeforeClass
-    public static void preSetUp() {
-        // Prepare looper for Android's message queue
-        if (Looper.myLooper() == null) Looper.prepare();
-    }
-
-    @AfterClass
-    public static void finalTearDown() {
-        if (Looper.myLooper() != null) Looper.myLooper().quit();
-    }
-
-    @Test
-    public void testCreate() {
-        PeriodicTaskFactory factory = new AnnouncementPeriodicTaskFactory();
-        PeriodicTask task = factory.create(context);
-        assertTrue(task instanceof AnnouncementPeriodicTask);
-    }
-}
@@ -0,0 +1,69 @@
+package de.dennisguse.opentracks.services.tasks;
+
+import android.content.Context;
+import android.content.Intent;
+import android.os.Looper;
+
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.rule.GrantPermissionRule;
+import androidx.test.rule.ServiceTestRule;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import de.dennisguse.opentracks.content.data.Distance;
+import de.dennisguse.opentracks.services.TrackRecordingService;
+import de.dennisguse.opentracks.stats.TrackStatistics;
+
+import static org.junit.Assert.assertEquals;
+
+@RunWith(AndroidJUnit4.class)
+public class PeriodicTaskExecutorTest {
+
+    @Rule
+    public final ServiceTestRule mServiceRule = ServiceTestRule.withTimeout(5, TimeUnit.SECONDS);
+
+    @Rule
+    public GrantPermissionRule mRuntimePermissionRule = GrantPermissionRule.grant(android.Manifest.permission.ACCESS_FINE_LOCATION);
+
+    @BeforeClass
+    public static void preSetUp() {
+        // Prepare looper for Android's message queue
+        if (Looper.myLooper() == null) Looper.prepare();
+    }
+
+    @AfterClass
+    public static void finalTearDown() {
+        if (Looper.myLooper() != null) Looper.myLooper().quit();
+    }
+
+
+    private final Context context = ApplicationProvider.getApplicationContext();
+
+    @Test
+    public void calculateNextTaskDistance() throws TimeoutException {
+        // given
+        TrackRecordingService service = ((TrackRecordingService.Binder) mServiceRule.bindService(new Intent(context, TrackRecordingService.class)))
+                .getService();
+
+        PeriodicTaskExecutor periodicTaskExecutor = new PeriodicTaskExecutor(service, new AnnouncementPeriodicTask.Factory());
+        periodicTaskExecutor.setMetricUnits(true);
+        periodicTaskExecutor.setTaskFrequency(-5);
+
+        // when
+        TrackStatistics statistics = new TrackStatistics();
+        statistics.setTotalDistance(Distance.of(13000));
+        assertEquals(Distance.of(15000), periodicTaskExecutor.calculateNextTaskDistance(statistics));
+
+        statistics.setTotalDistance(Distance.of(15100));
+        assertEquals(Distance.of(20000), periodicTaskExecutor.calculateNextTaskDistance(statistics));
+    }
+
+}
@@ -9,6 +9,7 @@ import org.junit.runner.RunWith;
 import java.time.Duration;
 import java.time.Instant;

+import de.dennisguse.opentracks.content.data.Altitude;
 import de.dennisguse.opentracks.content.data.Distance;
 import de.dennisguse.opentracks.content.data.Speed;
 import de.dennisguse.opentracks.content.data.TestDataUtil;
@@ -53,8 +54,8 @@ public class TrackStatisticsUpdaterTest {
        TrackStatisticsUpdater subject = new TrackStatisticsUpdater();

        TrackPoint tp1 = new TrackPoint(TrackPoint.Type.SEGMENT_START_MANUAL, Instant.ofEpochMilli(1000));
-        TrackPoint tp2 = new TrackPoint(0, 0, 5.0, Instant.ofEpochMilli(2000));
-        TrackPoint tp3 = new TrackPoint(0.00001, 0, 5.0, Instant.ofEpochMilli(3000));
+        TrackPoint tp2 = new TrackPoint(0, 0, Altitude.WGS84.of(5.0), Instant.ofEpochMilli(2000));
+        TrackPoint tp3 = new TrackPoint(0.00001, 0, Altitude.WGS84.of(5.0), Instant.ofEpochMilli(3000));

        // when
        subject.addTrackPoint(tp1, GPS_DISTANCE);
@@ -71,8 +72,8 @@ public class TrackStatisticsUpdaterTest {
        TrackStatisticsUpdater subject = new TrackStatisticsUpdater();

        TrackPoint tp1 = new TrackPoint(TrackPoint.Type.SEGMENT_START_MANUAL, Instant.ofEpochMilli(1000));
-        TrackPoint tp2 = new TrackPoint(0, 0, 5.0, Instant.ofEpochMilli(2000));
-        TrackPoint tp3 = new TrackPoint(0.00001, 0, 5.0, Instant.ofEpochMilli(3000));
+        TrackPoint tp2 = new TrackPoint(0, 0, Altitude.WGS84.of(5.0), Instant.ofEpochMilli(2000));
+        TrackPoint tp3 = new TrackPoint(0.00001, 0, Altitude.WGS84.of(5.0), Instant.ofEpochMilli(3000));
        tp3.setSpeed(Speed.of(5f));

        // when
@@ -90,11 +91,11 @@ public class TrackStatisticsUpdaterTest {
        TrackStatisticsUpdater subject = new TrackStatisticsUpdater();

        TrackPoint tp1 = new TrackPoint(TrackPoint.Type.SEGMENT_START_MANUAL, Instant.ofEpochMilli(1000));
-        TrackPoint tp2 = new TrackPoint(0, 0, 5.0, Instant.ofEpochMilli(2000));
+        TrackPoint tp2 = new TrackPoint(0, 0, Altitude.WGS84.of(5.0), Instant.ofEpochMilli(2000));
        tp2.setSpeed(Speed.of(5f));
-        TrackPoint tp3 = new TrackPoint(0.001, 0, 5.0, Instant.ofEpochMilli(3000));
+        TrackPoint tp3 = new TrackPoint(0.001, 0, Altitude.WGS84.of(5.0), Instant.ofEpochMilli(3000));
        tp2.setSpeed(Speed.of(5f));
-        TrackPoint tp4 = new TrackPoint(0.001, 0, 5.0, Instant.ofEpochMilli(4000));
+        TrackPoint tp4 = new TrackPoint(0.001, 0, Altitude.WGS84.of(5.0), Instant.ofEpochMilli(4000));
        tp2.setSpeed(Speed.of(5f));
        tp4.setSensorDistance(Distance.of(5f));
        TrackPoint tp5 = new TrackPoint(TrackPoint.Type.SEGMENT_END_MANUAL, Instant.ofEpochMilli(5000));
@@ -122,9 +123,9 @@ public class TrackStatisticsUpdaterTest {
        TrackStatisticsUpdater subject = new TrackStatisticsUpdater();

        TrackPoint tp1 = new TrackPoint(TrackPoint.Type.SEGMENT_START_MANUAL, Instant.ofEpochMilli(1000));
-        TrackPoint tp2 = new TrackPoint(0, 0, 5.0, Instant.ofEpochMilli(2000));
-        TrackPoint tp3 = new TrackPoint(0.00001, 0, 5.0, Instant.ofEpochMilli(3000));
-        TrackPoint tp4 = new TrackPoint(0.00001, 0, 5.0, Instant.ofEpochMilli(4000));
+        TrackPoint tp2 = new TrackPoint(0, 0, Altitude.WGS84.of(5.0), Instant.ofEpochMilli(2000));
+        TrackPoint tp3 = new TrackPoint(0.00001, 0, Altitude.WGS84.of(5.0), Instant.ofEpochMilli(3000));
+        TrackPoint tp4 = new TrackPoint(0.00001, 0, Altitude.WGS84.of(5.0), Instant.ofEpochMilli(4000));
        tp4.setSensorDistance(Distance.of(5f));
        TrackPoint tp5 = new TrackPoint(TrackPoint.Type.SEGMENT_END_MANUAL, Instant.ofEpochMilli(5000));
        tp5.setSensorDistance(Distance.of(10f));
@@ -145,6 +146,34 @@ public class TrackStatisticsUpdaterTest {
        assertEquals(15, subject.getTrackStatistics().getTotalDistance().toM(), 0.01);
    }

+    @Test
+    public void addTrackPoint_distance_from_GPS_moving_and_sensor_disconnecting() {
+        // given
+        TrackStatisticsUpdater subject = new TrackStatisticsUpdater();
+
+        TrackPoint tp1 = new TrackPoint(TrackPoint.Type.SEGMENT_START_MANUAL, Instant.ofEpochMilli(1000));
+        TrackPoint tp2 = new TrackPoint(0, 0, Altitude.WGS84.of(5.0), Instant.ofEpochMilli(2000));
+        TrackPoint tp3 = new TrackPoint(0.00001, 0, Altitude.WGS84.of(5.0), Instant.ofEpochMilli(3000));
+        tp3.setSensorDistance(Distance.of(5f));
+        TrackPoint tp4 = new TrackPoint(0.0005, 0, Altitude.WGS84.of(5.0), Instant.ofEpochMilli(4000));
+        TrackPoint tp5 = new TrackPoint(TrackPoint.Type.SEGMENT_END_MANUAL, Instant.ofEpochMilli(5000));
+
+        // when
+        subject.addTrackPoint(tp1, GPS_DISTANCE);
+        subject.addTrackPoint(tp2, GPS_DISTANCE);
+        subject.addTrackPoint(tp3, GPS_DISTANCE);
+
+        // then
+        assertEquals(5, subject.getTrackStatistics().getTotalDistance().toM(), 0.01);
+
+        // when
+        subject.addTrackPoint(tp4, GPS_DISTANCE);
+        subject.addTrackPoint(tp5, GPS_DISTANCE);
+
+        // then
+        assertEquals(59.18, subject.getTrackStatistics().getTotalDistance().toM(), 0.01);
+    }
+
    @Ignore("TODO: create a concept ont to compute speed from GPS and sensor")
    @Test
    public void addTrackPoint_speed_from_GPS_not_moving() {
@@ -27,7 +27,7 @@ public class AnnouncementUtilsTest {
    private final Context context = ApplicationProvider.getApplicationContext();

    @Test
-    public void getAnnouncement_metric() {
+    public void getAnnouncement_metric_speed() {
        TrackStatistics stats = new TrackStatistics();
        stats.setTotalDistance(Distance.of(20000));
        stats.setTotalTime(Duration.ofHours(2).plusMinutes(5).plusSeconds(10));
@@ -43,7 +43,7 @@ public class AnnouncementUtilsTest {
    }

    @Test
-    public void getAnnouncement_withInterval_metric() {
+    public void getAnnouncement_withInterval_metric_speed() {
        TrackStatistics stats = new TrackStatistics();
        stats.setTotalDistance(Distance.of(20000));
        stats.setTotalTime(Duration.ofHours(2).plusMinutes(5).plusSeconds(10));
@@ -61,4 +61,112 @@ public class AnnouncementUtilsTest {
        // then
        assertEquals("OpenTracks total distance 20.00 kilometers in 1 hour 5 minutes 10 seconds at 18.4 kilometers per hour Lap speed of 51.2 kilometers per hour", announcement);
    }
+
+    @Test
+    public void getAnnouncement_metric_pace() {
+        TrackStatistics stats = new TrackStatistics();
+        stats.setTotalDistance(Distance.of(20000));
+        stats.setTotalTime(Duration.ofHours(2).plusMinutes(5).plusSeconds(10));
+        stats.setMovingTime(Duration.ofHours(1).plusMinutes(5).plusSeconds(10));
+        stats.setMaxSpeed(Speed.of(100));
+        stats.setTotalAltitudeGain(6000f);
+
+        // when
+        String announcement = AnnouncementUtils.getAnnouncement(context, stats, true, false, null);
+
+        // then
+        assertEquals("OpenTracks total distance 20.00 kilometers in 1 hour 5 minutes 10 seconds at 3 minutes 15 seconds per kilometer", announcement);
+    }
+
+    @Test
+    public void getAnnouncement_withInterval_metric_pace() {
+        TrackStatistics stats = new TrackStatistics();
+        stats.setTotalDistance(Distance.of(20000));
+        stats.setTotalTime(Duration.ofHours(2).plusMinutes(5).plusSeconds(10));
+        stats.setMovingTime(Duration.ofHours(1).plusMinutes(5).plusSeconds(10));
+        stats.setMaxSpeed(Speed.of(100));
+        stats.setTotalAltitudeGain(6000f);
+
+        List<TrackPoint> trackPoints = TestDataUtil.createTrack(new Track.Id(System.currentTimeMillis()), 10).second;
+        IntervalStatistics intervalStatistics = new IntervalStatistics(trackPoints, Distance.of(1000));
+        IntervalStatistics.Interval lastInterval = intervalStatistics.getIntervalList().get(intervalStatistics.getIntervalList().size() - 1);
+
+        // when
+        String announcement = AnnouncementUtils.getAnnouncement(context, stats, true, false, lastInterval);
+
+        // then
+        assertEquals("OpenTracks total distance 20.00 kilometers in 1 hour 5 minutes 10 seconds at 3 minutes 15 seconds per kilometer Lap time of 1 minute 10 seconds per kilometer", announcement);
+    }
+
+    @Test
+    public void getAnnouncement_imperial_speed() {
+        TrackStatistics stats = new TrackStatistics();
+        stats.setTotalDistance(Distance.of(20000));
+        stats.setTotalTime(Duration.ofHours(2).plusMinutes(5).plusSeconds(10));
+        stats.setMovingTime(Duration.ofHours(1).plusMinutes(5).plusSeconds(10));
+        stats.setMaxSpeed(Speed.of(100));
+        stats.setTotalAltitudeGain(6000f);
+
+        // when
+        String announcement = AnnouncementUtils.getAnnouncement(context, stats, false, true, null);
+
+        // then
+        assertEquals("OpenTracks total distance 12.43 miles in 1 hour 5 minutes 10 seconds at 11.4 miles per hour", announcement);
+    }
+
+    @Test
+    public void getAnnouncement_withInterval_imperial_speed() {
+        TrackStatistics stats = new TrackStatistics();
+        stats.setTotalDistance(Distance.of(20000));
+        stats.setTotalTime(Duration.ofHours(2).plusMinutes(5).plusSeconds(10));
+        stats.setMovingTime(Duration.ofHours(1).plusMinutes(5).plusSeconds(10));
+        stats.setMaxSpeed(Speed.of(100));
+        stats.setTotalAltitudeGain(6000f);
+
+        List<TrackPoint> trackPoints = TestDataUtil.createTrack(new Track.Id(System.currentTimeMillis()), 10).second;
+        IntervalStatistics intervalStatistics = new IntervalStatistics(trackPoints, Distance.of(1000));
+        IntervalStatistics.Interval lastInterval = intervalStatistics.getIntervalList().get(intervalStatistics.getIntervalList().size() - 1);
+
+        // when
+        String announcement = AnnouncementUtils.getAnnouncement(context, stats, false, true, lastInterval);
+
+        // then
+        assertEquals("OpenTracks total distance 12.43 miles in 1 hour 5 minutes 10 seconds at 11.4 miles per hour Lap speed of 31.8 miles per hour", announcement);
+    }
+
+    @Test
+    public void getAnnouncement_imperial_pace() {
+        TrackStatistics stats = new TrackStatistics();
+        stats.setTotalDistance(Distance.of(20000));
+        stats.setTotalTime(Duration.ofHours(2).plusMinutes(5).plusSeconds(10));
+        stats.setMovingTime(Duration.ofHours(1).plusMinutes(5).plusSeconds(10));
+        stats.setMaxSpeed(Speed.of(100));
+        stats.setTotalAltitudeGain(6000f);
+
+        // when
+        String announcement = AnnouncementUtils.getAnnouncement(context, stats, false, false, null);
+
+        // then
+        assertEquals("OpenTracks total distance 12.43 miles in 1 hour 5 minutes 10 seconds at 5 minutes 15 seconds per mile", announcement);
+    }
+
+    @Test
+    public void getAnnouncement_withInterval_imperial_pace() {
+        TrackStatistics stats = new TrackStatistics();
+        stats.setTotalDistance(Distance.of(20000));
+        stats.setTotalTime(Duration.ofHours(2).plusMinutes(5).plusSeconds(10));
+        stats.setMovingTime(Duration.ofHours(1).plusMinutes(5).plusSeconds(10));
+        stats.setMaxSpeed(Speed.of(100));
+        stats.setTotalAltitudeGain(6000f);
+
+        List<TrackPoint> trackPoints = TestDataUtil.createTrack(new Track.Id(System.currentTimeMillis()), 10).second;
+        IntervalStatistics intervalStatistics = new IntervalStatistics(trackPoints, Distance.of(1000));
+        IntervalStatistics.Interval lastInterval = intervalStatistics.getIntervalList().get(intervalStatistics.getIntervalList().size() - 1);
+
+        // when
+        String announcement = AnnouncementUtils.getAnnouncement(context, stats, false, false, lastInterval);
+
+        // then
+        assertEquals("OpenTracks total distance 12.43 miles in 1 hour 5 minutes 10 seconds at 5 minutes 15 seconds per mile Lap time of 1 minute 53 seconds per mile", announcement);
+    }
 }
@@ -0,0 +1,229 @@
+package de.dennisguse.opentracks.util;
+
+import android.content.Context;
+
+import androidx.test.core.app.ApplicationProvider;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.DataInputStream;
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+import java.time.Instant;
+
+import de.dennisguse.opentracks.content.data.TrackPoint;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+
+@RunWith(JUnit4.class)
+public class EGM2008UtilsTest {
+
+    private static final double MAX_BILINEAR_ERROR = 0.478;
+
+    private final Context context = ApplicationProvider.getApplicationContext();
+
+    @Test
+    public void fileVerification() throws IOException {
+        // given
+        int expectedLength = 18671444;
+        int expectedHeaderLength = 404;
+
+        String expectedHeader = "P5\n" +
+                "# Geoid file in PGM format for the GeographicLib::Geoid class\n" +
+                "# Description WGS84 EGM2008, 5-minute grid\n" +
+                "# URL http://earth-info.nga.mil/GandG/wgs84/gravitymod/egm2008\n" +
+                "# DateTime 2009-08-29 18:45:00\n" +
+                "# MaxBilinearError 0.478\n" +
+                "# RMSBilinearError 0.012\n" +
+                "# MaxCubicError 0.294\n" +
+                "# RMSCubicError 0.005\n" +
+                "# Offset -108\n" +
+                "# Scale 0.003\n" +
+                "# Origin 90N 0E\n" +
+                "# AREA_OR_POINT Point\n" +
+                "# Vertical_Datum WGS84\n" +
+                "4320    2161\n" +
+                "65535" +
+                "\n";
+
+        // when
+        try (InputStream inputStream = context.getResources().openRawResource(EGM2008Utils.EGM2008_5_DATA)) {
+            assertEquals(expectedLength, inputStream.available());
+
+            InputStreamReader reader = new InputStreamReader(inputStream, StandardCharsets.US_ASCII);
+            char[] data = new char[expectedHeaderLength];
+            int length = reader.read(data);
+
+            // then
+            assertEquals(expectedHeaderLength, length);
+            assertEquals(expectedHeader, new String(data));
+        }
+    }
+
+    @Test
+    public void data_Northpole() throws IOException {
+        // given
+        TrackPoint trackPoint = new TrackPoint(TrackPoint.Type.TRACKPOINT, Instant.ofEpochMilli(0));
+        trackPoint.setLatitude(90);
+        trackPoint.setLongitude(0.1);
+        trackPoint.setAltitude(0);
+
+        // when
+        EGM2008Utils.EGM2008Correction altitude_egm2008 = EGM2008Utils.createCorrection(context, trackPoint.getLocation());
+
+        // then
+        assertEquals(-14.8980, altitude_egm2008.correctAltitude(trackPoint.getLocation()), MAX_BILINEAR_ERROR);
+    }
+
+    @Test
+    public void data_Southpole() throws IOException {
+        // given
+        TrackPoint trackPoint = new TrackPoint(TrackPoint.Type.TRACKPOINT, Instant.ofEpochMilli(0));
+        trackPoint.setLatitude(-90);
+        trackPoint.setLongitude(0);
+        trackPoint.setAltitude(0);
+
+        // when
+        EGM2008Utils.EGM2008Correction altitude_egm2008 = EGM2008Utils.createCorrection(context, trackPoint.getLocation());
+
+        // then
+        assertEquals(30.15, altitude_egm2008.correctAltitude(trackPoint.getLocation()), MAX_BILINEAR_ERROR);
+    }
+
+    @Test
+    public void data_Southpole2() throws IOException {
+        // given
+        TrackPoint trackPoint = new TrackPoint(TrackPoint.Type.TRACKPOINT, Instant.ofEpochMilli(0));
+        trackPoint.setLatitude(-90);
+        trackPoint.setLongitude(180);
+        trackPoint.setAltitude(0);
+
+        // when
+        EGM2008Utils.EGM2008Correction altitude_egm2008 = EGM2008Utils.createCorrection(context, trackPoint.getLocation());
+
+        // then
+        assertEquals(30.15, altitude_egm2008.correctAltitude(trackPoint.getLocation()), MAX_BILINEAR_ERROR);
+    }
+
+    @Test
+    public void data_Southpole3() throws IOException {
+        // given
+        TrackPoint trackPoint = new TrackPoint(TrackPoint.Type.TRACKPOINT, Instant.ofEpochMilli(0));
+        trackPoint.setLatitude(-90);
+        trackPoint.setLongitude(-180);
+        trackPoint.setAltitude(0);
+
+        // when
+        EGM2008Utils.EGM2008Correction altitude_egm2008 = EGM2008Utils.createCorrection(context, trackPoint.getLocation());
+
+        // then
+        assertEquals(30.15, altitude_egm2008.correctAltitude(trackPoint.getLocation()), MAX_BILINEAR_ERROR);
+    }
+
+    @Test
+    public void data_0() throws IOException {
+        // given
+        TrackPoint trackPoint = new TrackPoint(TrackPoint.Type.TRACKPOINT, Instant.ofEpochMilli(0));
+        trackPoint.setLatitude(0);
+        trackPoint.setLongitude(0);
+        trackPoint.setAltitude(0);
+
+        // when
+        EGM2008Utils.EGM2008Correction altitude_egm2008 = EGM2008Utils.createCorrection(context, trackPoint.getLocation());
+
+        // then
+        assertEquals(-17.2260, altitude_egm2008.correctAltitude(trackPoint.getLocation()), MAX_BILINEAR_ERROR);
+    }
+
+    @Test
+    public void data_Berlin() throws IOException {
+        // given
+        TrackPoint trackPoint = new TrackPoint(TrackPoint.Type.TRACKPOINT, Instant.ofEpochMilli(0));
+        trackPoint.setLatitude(52.530644);
+        trackPoint.setLongitude(13.383068);
+        trackPoint.setAltitude(0);
+
+        // when
+        EGM2008Utils.EGM2008Correction altitude_egm2008 = EGM2008Utils.createCorrection(context, trackPoint.getLocation());
+
+        // then
+        assertEquals(-39.4865, altitude_egm2008.correctAltitude(trackPoint.getLocation()), MAX_BILINEAR_ERROR);
+    }
+
+    @Test
+    public void data_Berlin_Caching() throws IOException {
+        // given
+        TrackPoint trackPoint1 = new TrackPoint(TrackPoint.Type.TRACKPOINT, Instant.ofEpochMilli(0));
+        trackPoint1.setLatitude(52.530644);
+        trackPoint1.setLongitude(13.383068);
+        trackPoint1.setAltitude(0);
+
+        TrackPoint trackPoint2 = new TrackPoint(TrackPoint.Type.TRACKPOINT, Instant.ofEpochMilli(0));
+        trackPoint2.setLatitude(52.530000);
+        trackPoint2.setLongitude(13.380000);
+        trackPoint2.setAltitude(0);
+
+        // when
+        EGM2008Utils.EGM2008Correction altitude_egm2008 = EGM2008Utils.createCorrection(context, trackPoint1.getLocation());
+
+        // then
+        assertNotEquals(altitude_egm2008.correctAltitude(trackPoint1.getLocation()), altitude_egm2008.correctAltitude(trackPoint2.getLocation()), 0.0001);
+    }
+
+    @Test
+    public void data_MaxUndulation() throws IOException {
+        // given
+        TrackPoint trackPoint = new TrackPoint(TrackPoint.Type.TRACKPOINT, Instant.ofEpochMilli(0));
+        trackPoint.setLatitude(-8.417);
+        trackPoint.setLongitude(147.367);
+        trackPoint.setAltitude(0);
+
+        // when
+        EGM2008Utils.EGM2008Correction altitude_egm2008 = EGM2008Utils.createCorrection(context, trackPoint.getLocation());
+
+        // then
+        assertEquals(-85.824, altitude_egm2008.correctAltitude(trackPoint.getLocation()), MAX_BILINEAR_ERROR);
+    }
+
+    @Test
+    public void getIndices() {
+        TrackPoint trackPoint = new TrackPoint(TrackPoint.Type.TRACKPOINT, Instant.ofEpochMilli(0));
+        trackPoint.setLatitude(90);
+        trackPoint.setLongitude(0);
+        assertEquals(new EGM2008Utils.Indices(0, 0), EGM2008Utils.getIndices(trackPoint.getLocation()));
+
+        trackPoint.setLatitude(0);
+        trackPoint.setLongitude(0);
+        assertEquals(new EGM2008Utils.Indices(1080, 0), EGM2008Utils.getIndices(trackPoint.getLocation()));
+
+        trackPoint.setLatitude(-90);
+        trackPoint.setLongitude(180);
+        assertEquals(new EGM2008Utils.Indices(2160, 4320 / 2), EGM2008Utils.getIndices(trackPoint.getLocation()));
+
+        trackPoint.setLatitude(-90);
+        trackPoint.setLongitude(-180);
+        assertEquals(new EGM2008Utils.Indices(2160, 0), EGM2008Utils.getIndices(trackPoint.getLocation()));
+    }
+
+    @Test
+    public void getUndulationRaw_ok() throws IOException {
+        try (DataInputStream dataInputStream = new DataInputStream(context.getResources().openRawResource(EGM2008Utils.EGM2008_5_DATA))) {
+            assertEquals(40966, EGM2008Utils.getUndulationRaw(dataInputStream, new EGM2008Utils.Indices(0, 0)));
+            assertEquals(41742, EGM2008Utils.getUndulationRaw(dataInputStream, new EGM2008Utils.Indices(1081, 0)));
+            assertEquals(25950, EGM2008Utils.getUndulationRaw(dataInputStream, new EGM2008Utils.Indices(2160, 4319)));
+        }
+    }
+
+    @Test(expected = EOFException.class)
+    public void getUndulationRaw_error() throws IOException {
+        try (DataInputStream dataInputStream = new DataInputStream(context.getResources().openRawResource(EGM2008Utils.EGM2008_5_DATA))) {
+            assertEquals(0, EGM2008Utils.getUndulationRaw(dataInputStream, new EGM2008Utils.Indices(2161, 4320)), 0.01);
+        }
+    }
+}
@@ -0,0 +1,7 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
+
+    <application
+        android:hasFragileUserData="true"
+        tools:replace="android:hasFragileUserData" />
+</manifest>
@@ -51,7 +51,7 @@ limitations under the License.
        android:name=".Startup"
        android:allowBackup="false"
        android:hardwareAccelerated="true"
-        android:hasFragileUserData="true"
+        android:hasFragileUserData="false"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:supportsRtl="true"
@@ -59,10 +59,6 @@ limitations under the License.

        <activity android:name=".AboutActivity" />

-        <activity
-            android:name=".TrackDeleteActivity"
-            android:theme="@style/TrackDeleteActivity" />
-
        <activity
            android:name=".HelpActivity"
            android:label="@string/menu_help" />
@@ -350,5 +346,18 @@ limitations under the License.
            android:name=".io.file.importer.ImportService"
            android:exported="false"
            android:permission="android.permission.BIND_JOB_SERVICE" />
+
+        <service
+            android:name=".services.TrackDeleteService"
+            android:enabled="true"
+            android:exported="false"
+            android:icon="@drawable/ic_logo_color_24dp"
+            android:label="@string/delete_service" />
    </application>
+
+    <queries>
+        <intent>
+            <action android:name="android.intent.action.TTS_SERVICE" />
+        </intent>
+    </queries>
 </manifest>
@@ -1,7 +1,6 @@
 package de.dennisguse.opentracks;

 import android.os.Bundle;
-import android.view.Menu;
 import android.view.View;

 import androidx.annotation.Nullable;
@@ -32,9 +31,4 @@ public class AboutActivity extends AbstractActivity {
        viewBinding = AboutBinding.inflate(getLayoutInflater());
        return viewBinding.getRoot();
    }
-
-    @Override
-    public boolean onCreateOptionsMenu(Menu menu) {
-        return false;
-    }
 }
@@ -1,96 +0,0 @@
-/*
- * Copyright 2012 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.content.Intent;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-
-import de.dennisguse.opentracks.content.data.Track;
-import de.dennisguse.opentracks.fragments.ConfirmDeleteDialogFragment;
-import de.dennisguse.opentracks.fragments.ConfirmDeleteDialogFragment.ConfirmDeleteCaller;
-import de.dennisguse.opentracks.services.TrackRecordingServiceConnection;
-import de.dennisguse.opentracks.util.IntentUtils;
-
-/**
- * An abstract class for the following common tasks across
- * {@link TrackListActivity}, {@link TrackRecordedActivity}, and {@link TrackRecordedActivity}:
- * <p>
- * - share track <br>
- * - delete tracks <br>
- *
- * @author Jimmy Shih
- */
-public abstract class AbstractListActivity extends AbstractActivity implements ConfirmDeleteCaller {
-
-    private static final String TAG = AbstractListActivity.class.getSimpleName();
-
-    protected static final int GPS_REQUEST_CODE = 6;
-    private static final int DELETE_REQUEST_CODE = 3;
-
-    protected Track.Id recordingTrackId;
-
-    @Override
-    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
-        if (requestCode == DELETE_REQUEST_CODE) {
-            onTrackDeleted();
-        } else {
-            super.onActivityResult(requestCode, resultCode, data);
-        }
-    }
-
-    /**
-     * Delete tracks.
-     *
-     * @param trackIds the track ids
-     */
-    protected void deleteTracks(Track.Id... trackIds) {
-        ConfirmDeleteDialogFragment.showDialog(getSupportFragmentManager(), trackIds);
-    }
-
-    @Override
-    public void onConfirmDeleteDone(Track.Id... trackIds) {
-        boolean stopRecording = false;
-
-        for (Track.Id trackId : trackIds) {
-            if (trackId.equals(recordingTrackId)) {
-                stopRecording = true;
-                break;
-            }
-        }
-
-        if (stopRecording) {
-            getTrackRecordingServiceConnection().stopRecording(this);
-        }
-        Intent intent = IntentUtils.newIntent(this, TrackDeleteActivity.class);
-        intent.putParcelableArrayListExtra(TrackDeleteActivity.EXTRA_TRACK_IDS, new ArrayList<>(Arrays.asList(trackIds)));
-        startActivityForResult(intent, DELETE_REQUEST_CODE);
-        overridePendingTransition(android.R.anim.fade_in, android.R.anim.fade_out);
-    }
-
-    /**
-     * Gets the track recording service connection.
-     * For stopping the current recording if need to delete the current recording track.
-     */
-    abstract protected TrackRecordingServiceConnection getTrackRecordingServiceConnection();
-
-    /**
-     * Called after {@link TrackDeleteActivity} returns its result.
-     */
-    abstract protected void onTrackDeleted();
-}
@@ -0,0 +1,125 @@
+/*
+ * Copyright 2012 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 androidx.annotation.Nullable;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+import de.dennisguse.opentracks.content.data.Track;
+import de.dennisguse.opentracks.fragments.ConfirmDeleteDialogFragment;
+import de.dennisguse.opentracks.fragments.ConfirmDeleteDialogFragment.ConfirmDeleteCaller;
+import de.dennisguse.opentracks.services.TrackDeleteService;
+import de.dennisguse.opentracks.services.TrackDeleteServiceConnection;
+import de.dennisguse.opentracks.services.TrackRecordingServiceConnection;
+
+/**
+ * An abstract class for the following common tasks across
+ * {@link TrackListActivity} and {@link TrackRecordedActivity}:
+ * <p>
+ * - delete tracks <br>
+ *
+ * @author Jimmy Shih
+ */
+//TODO Check if this class is still such a good idea; inheritance might limit maintainability
+public abstract class AbstractTrackDeleteActivity extends AbstractActivity implements ConfirmDeleteCaller, TrackDeleteServiceConnection.Listener {
+
+    private static final String TAG = AbstractTrackDeleteActivity.class.getSimpleName();
+
+    private TrackDeleteServiceConnection trackDeleteServiceConnection;
+
+    @Override
+    protected void onStart() {
+        super.onStart();
+        trackDeleteServiceConnection = new TrackDeleteServiceConnection(this);
+        trackDeleteServiceConnection.bind(this);
+    }
+
+    @Override
+    protected void onStop() {
+        super.onStop();
+        if (trackDeleteServiceConnection != null) {
+            trackDeleteServiceConnection.unbind(this);
+            trackDeleteServiceConnection = null;
+        }
+    }
+
+    /**
+     * Delete tracks.
+     *
+     * @param trackIds the track ids
+     */
+    protected void deleteTracks(Track.Id... trackIds) {
+        ConfirmDeleteDialogFragment.showDialog(getSupportFragmentManager(), trackIds);
+    }
+
+    @Override
+    public void onConfirmDeleteDone(Track.Id... trackIds) {
+        boolean stopRecording = false;
+
+        onDeleteConfirmed();
+
+        for (Track.Id trackId : trackIds) {
+            if (trackId.equals(getRecordingTrackId())) {
+                stopRecording = true;
+                break;
+            }
+        }
+
+        if (stopRecording) {
+            getTrackRecordingServiceConnection().stopRecording(this);
+        }
+
+        trackDeleteServiceConnection = new TrackDeleteServiceConnection(this);
+        trackDeleteServiceConnection.startAndBind(this, new ArrayList<>(Arrays.asList(trackIds)));
+    }
+
+    /**
+     * Gets the track recording service connection.
+     * For stopping the current recording if need to delete the current recording track.
+     */
+    protected TrackRecordingServiceConnection getTrackRecordingServiceConnection() {
+        return null;
+    }
+
+    /**
+     * Called every time a track is deleted.
+     */
+    protected void onTrackDeleteStatus(TrackDeleteService.DeleteStatus deleteStatus) {
+        if (deleteStatus.isFinished() && trackDeleteServiceConnection != null) {
+            trackDeleteServiceConnection.unbind(this);
+            trackDeleteServiceConnection = null;
+        }
+    }
+
+    protected abstract void onDeleteConfirmed();
+
+    @Nullable
+    protected Track.Id getRecordingTrackId() {
+        return null;
+    }
+
+    @Override
+    public void connected() {
+        TrackDeleteService service = trackDeleteServiceConnection.getServiceIfBound();
+        if (service == null) {
+            return;
+        }
+        service.getDeletingStatusObservable().observe(AbstractTrackDeleteActivity.this, status -> onTrackDeleteStatus(status));
+    }
+}
@@ -0,0 +1,299 @@
+/*
+ * Copyright 2012 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.annotation.SuppressLint;
+import android.graphics.drawable.TransitionDrawable;
+import android.os.Bundle;
+import android.os.Handler;
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.accessibility.AccessibilityEvent;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.Fragment;
+
+import java.time.Duration;
+
+import de.dennisguse.opentracks.databinding.ControllerFragmentBinding;
+import de.dennisguse.opentracks.services.TrackRecordingService;
+import de.dennisguse.opentracks.services.TrackRecordingServiceConnection;
+import de.dennisguse.opentracks.util.ActivityUtils;
+import de.dennisguse.opentracks.util.StringUtils;
+
+/**
+ * Track controller for record, pause, resume, and stop.
+ *
+ * @author Jimmy Shih
+ */
+//TODO Move buttons into separate components
+public class ControllerFragment extends Fragment implements View.OnTouchListener {
+
+    private static final String TAG = ControllerFragment.class.getSimpleName();
+
+    @Deprecated
+    //TODO TrackRecordingService should provide LifeData for time (replace internal timer)
+    private static final Duration UI_UPDATE_INTERVAL = Duration.ofSeconds(1);
+    @Deprecated
+    private Handler handlerUpdateTotalTime;
+
+    private Runnable buttonDelay;
+    private int buttonDelayDuration;
+
+    private ControllerFragmentBinding viewBinding;
+    private TransitionDrawable transition;
+
+    private TrackRecordingServiceConnection trackRecordingServiceConnection;
+    private TrackRecordingService.RecordingStatus recordingStatus;
+    private Duration totalTime;
+
+    private final Runnable bindChangedCallback = new Runnable() {
+        @Override
+        public void run() {
+            TrackRecordingService service = trackRecordingServiceConnection.getServiceIfBound();
+            if (service == null) {
+                Log.w(TAG, "could not get TrackRecordingService");
+                return;
+            }
+
+            service.getRecordingStatusObservable()
+                    .observe(ControllerFragment.this, status -> onRecordingStatusChanged(status));
+        }
+    };
+
+    // A runnable to update the total time.
+    @Deprecated
+    private final Runnable updateTotalTimeRunnable = new Runnable() {
+        public void run() {
+            if (isResumed() && recordingStatus.isRecordingAndNotPaused()) {
+                updateTotalTime();
+                setTotalTime();
+                handlerUpdateTotalTime.postDelayed(this, UI_UPDATE_INTERVAL.toMillis());
+            }
+        }
+    };
+
+    @Override
+    public void onCreate(@Nullable Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        buttonDelayDuration = getResources().getInteger(R.integer.buttonDelayMillis);
+
+        trackRecordingServiceConnection = new TrackRecordingServiceConnection(bindChangedCallback);
+        handlerUpdateTotalTime = new Handler();
+        recordingStatus = TrackRecordingService.STATUS_DEFAULT;
+    }
+
+    @Nullable
+    @Override
+    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
+        viewBinding = ControllerFragmentBinding.inflate(inflater, container, false);
+
+        viewBinding.controllerRecord.setOnTouchListener(this);
+        viewBinding.controllerRecord.setOnClickListener((view) -> {
+            if (buttonDelay != null || recordingStatus.isRecordingAndNotPaused()) {
+                return;
+            }
+
+            getCallback().recordStart();
+        });
+
+        viewBinding.controllerStop.setOnTouchListener(this);
+        transition = (TransitionDrawable) viewBinding.controllerContainer.getBackground();
+
+        onRecordingStatusChanged(recordingStatus);
+
+        return viewBinding.getRoot();
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        trackRecordingServiceConnection.startConnection(getContext());
+    }
+
+    @Override
+    public void onPause() {
+        super.onPause();
+        handlerUpdateTotalTime.removeCallbacks(updateTotalTimeRunnable);
+    }
+
+    @Override
+    public void onStop() {
+        super.onStop();
+        trackRecordingServiceConnection.unbind(getContext());
+    }
+
+    @Override
+    public void onDestroyView() {
+        super.onDestroyView();
+        viewBinding = null;
+        transition = null;
+    }
+
+    @Override
+    public void onDestroy() {
+        super.onDestroy();
+        trackRecordingServiceConnection = null;
+        handlerUpdateTotalTime = null;
+        recordingStatus = null;
+    }
+
+    //TODO Move into a separate object
+    @SuppressLint("ClickableViewAccessibility") //We do accessibility manually.
+    @Override
+    public boolean onTouch(final View view, MotionEvent event) {
+        if (!isResumed()) {
+            Log.w(TAG, "The UI is already gone, no need to update anything; seen on Android 7.1.2");
+            return false;
+        }
+        if (event.getAction() == MotionEvent.ACTION_MOVE) {
+            return false;
+        }
+
+        if (buttonDelay != null && event.getAction() == MotionEvent.ACTION_UP) {
+            handlerUpdateTotalTime.removeCallbacks(buttonDelay);
+            buttonDelay = null;
+            view.setPressed(false);
+
+            transition.resetTransition();
+
+            showStatusSetDefaultText();
+
+            return false;
+        }
+
+        //Trigger button pressed animation
+        view.setPressed(true);
+
+        //To pause a recording
+        if (viewBinding.controllerRecord.equals(view)
+                && event.getAction() == MotionEvent.ACTION_DOWN
+                && recordingStatus.isRecordingAndNotPaused()) {
+
+            transition.startTransition(buttonDelayDuration);
+
+            ActivityUtils.vibrate(getContext(), 150);
+            viewBinding.controllerStatus.setText(R.string.hold_to_pause);
+
+            buttonDelay = () -> {
+                view.sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);
+                view.performClick();
+                getCallback().recordPause();
+
+                transition.resetTransition();
+
+                ActivityUtils.vibrate(getContext(), 1000);
+            };
+            handlerUpdateTotalTime.postDelayed(buttonDelay, buttonDelayDuration);
+            return true;
+        }
+
+        //To stop a recording
+        if (viewBinding.controllerStop.equals(view)
+                && event.getAction() == MotionEvent.ACTION_DOWN
+                && recordingStatus.isRecording()) {
+
+
+            transition.startTransition(buttonDelayDuration);
+
+            ActivityUtils.vibrate(getContext(), 150);
+            viewBinding.controllerStatus.setText(R.string.hold_to_stop);
+
+            buttonDelay = () -> {
+                view.sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);
+                getCallback().recordStop();
+                ActivityUtils.vibrate(getContext(), 1000);
+
+                transition.resetTransition();
+            };
+            handlerUpdateTotalTime.postDelayed(buttonDelay, buttonDelayDuration);
+            return true;
+        }
+
+        return false;
+    }
+
+    public void hide() {
+        viewBinding.controllerContainer.setVisibility(View.GONE);
+    }
+
+    public void show() {
+        viewBinding.controllerContainer.setVisibility(View.VISIBLE);
+    }
+
+    private void updateTotalTime() {
+        TrackRecordingService trackRecordingService = trackRecordingServiceConnection.getServiceIfBound();
+        if (trackRecordingService != null) {
+            totalTime = trackRecordingService.getTotalTime();
+        }
+    }
+
+    private void setTotalTime() {
+        if (totalTime != null) {
+            viewBinding.controllerTotalTime.setText(StringUtils.formatElapsedTimeWithHour(totalTime));
+        }
+    }
+
+    private void showStatusSetDefaultText() {
+        viewBinding.controllerStatus.setText(recordingStatus.isPaused() ? R.string.generic_paused : R.string.generic_recording);
+    }
+
+    private Callback getCallback() {
+        return (Callback) getActivity();
+    }
+
+    public interface Callback {
+        void recordStart();
+
+        void recordPause();
+
+        void recordStop();
+    }
+
+    private void onRecordingStatusChanged(TrackRecordingService.RecordingStatus status) {
+        recordingStatus = status;
+
+        if (!recordingStatus.isRecording()) {
+            handlerUpdateTotalTime.removeCallbacks(updateTotalTimeRunnable);
+        }
+        if (recordingStatus.isRecordingAndNotPaused()) {
+            handlerUpdateTotalTime.postDelayed(updateTotalTimeRunnable, UI_UPDATE_INTERVAL.toMillis());
+        }
+
+        viewBinding.controllerRecord.setImageResource(recordingStatus.isRecordingAndNotPaused() ? R.drawable.ic_button_pause : R.drawable.button_record);
+        viewBinding.controllerRecord.setContentDescription(getContext().getString(recordingStatus.isRecordingAndNotPaused() ? R.string.image_pause : R.string.image_record));
+
+        viewBinding.controllerStop.setEnabled(recordingStatus.isRecording());
+
+        viewBinding.controllerStatus.setVisibility(recordingStatus.isRecording() ? View.VISIBLE : View.INVISIBLE);
+        if (recordingStatus.isRecording()) {
+            viewBinding.controllerStatus.setTextColor(getContext().getResources().getColor(recordingStatus.isPaused() ? android.R.color.white : R.color.recording_text));
+            showStatusSetDefaultText();
+        }
+
+        viewBinding.controllerTotalTime.setVisibility(recordingStatus.isRecording() ? View.VISIBLE : View.INVISIBLE);
+
+        if (recordingStatus.isRecording()) {
+            updateTotalTime();
+            setTotalTime();
+        }
+    }
+}
@@ -20,6 +20,7 @@ import android.app.SearchManager;
 import android.content.Intent;
 import android.database.Cursor;
 import android.os.Bundle;
+import android.util.Log;
 import android.view.KeyEvent;
 import android.view.Menu;
 import android.view.MenuItem;
@@ -42,7 +43,6 @@ import de.dennisguse.opentracks.fragments.DeleteMarkerDialogFragment;
 import de.dennisguse.opentracks.fragments.DeleteMarkerDialogFragment.DeleteMarkerCaller;
 import de.dennisguse.opentracks.services.TrackRecordingService;
 import de.dennisguse.opentracks.services.TrackRecordingServiceConnection;
-import de.dennisguse.opentracks.services.TrackRecordingServiceStatus;
 import de.dennisguse.opentracks.util.ActivityUtils;
 import de.dennisguse.opentracks.util.IntentUtils;

@@ -51,7 +51,7 @@ import de.dennisguse.opentracks.util.IntentUtils;
 *
 * @author Leif Hendrik Wilden
 */
-public class MarkerListActivity extends AbstractActivity implements DeleteMarkerCaller, TrackRecordingServiceStatus.Listener {
+public class MarkerListActivity extends AbstractActivity implements DeleteMarkerCaller {

    public static final String EXTRA_TRACK_ID = "track_id";

@@ -59,8 +59,8 @@ public class MarkerListActivity extends AbstractActivity implements DeleteMarker

    private ContentProviderUtils contentProviderUtils;

-    private Track.Id recordingTrackId;
-    private boolean recordingTrackPaused;
+    private TrackRecordingService.RecordingStatus recordingStatus = TrackRecordingService.STATUS_DEFAULT;
+
    private Track track;
    private MarkerResourceCursorAdapter resourceCursorAdapter;

@@ -74,9 +74,13 @@ public class MarkerListActivity extends AbstractActivity implements DeleteMarker
        @Override
        public void run() {
            TrackRecordingService service = trackRecordingServiceConnection.getServiceIfBound();
-            if (service != null) {
-                service.addListener(MarkerListActivity.this);
+            if (service == null) {
+                Log.w(TAG, "could not get TrackRecordingService");
+                return;
            }
+
+            service.getRecordingStatusObservable()
+                    .observe(MarkerListActivity.this, status -> onRecordingStatusChanged(status));
        }
    };

@@ -171,14 +175,14 @@ public class MarkerListActivity extends AbstractActivity implements DeleteMarker
        insertMarkerMenuItem = menu.findItem(R.id.marker_list_insert_marker);

        searchMenuItem = menu.findItem(R.id.marker_list_search);
-        ActivityUtils.configureSearchWidget(this, searchMenuItem, null);
+        ActivityUtils.configureSearchWidget(this, searchMenuItem);

        return super.onCreateOptionsMenu(menu);
    }

    @Override
    public boolean onPrepareOptionsMenu(Menu menu) {
-        insertMarkerMenuItem.setVisible(track != null && track.getId().equals(recordingTrackId) && !recordingTrackPaused);
+        insertMarkerMenuItem.setVisible(track != null && track.getId().equals(recordingStatus.getTrackId()) && !recordingStatus.isPaused());
        return super.onPrepareOptionsMenu(menu);
    }

@@ -257,15 +261,16 @@ public class MarkerListActivity extends AbstractActivity implements DeleteMarker

    @Override
    public void onBackPressed() {
+        SearchView searchView = (SearchView) searchMenuItem.getActionView();
+        if (!searchView.isIconified()) {
+            searchView.setIconified(true);
+        }
+
        if (loaderCallbacks.getSearchQuery() != null) {
            loaderCallbacks.setSearch(null);
            return;
        }
-        SearchView searchView = (SearchView) searchMenuItem.getActionView();
-        if (!searchView.isIconified()) {
-            searchView.setIconified(true);
-            return;
-        }
+
        super.onBackPressed();
    }

@@ -290,6 +295,10 @@ public class MarkerListActivity extends AbstractActivity implements DeleteMarker
        // Do nothing
    }

+    private void onRecordingStatusChanged(TrackRecordingService.RecordingStatus status) {
+        recordingStatus = status;
+    }
+
    private class MarkerLoaderCallback implements LoaderManager.LoaderCallbacks<Cursor> {

        private String searchQuery = null;
@@ -344,14 +353,4 @@ public class MarkerListActivity extends AbstractActivity implements DeleteMarker
            resourceCursorAdapter.swapCursor(null);
        }
    }
-
-    @Override
-    public void onTrackRecordingPaused(boolean isPaused) {
-        recordingTrackPaused = isPaused;
-    }
-
-    @Override
-    public void onTrackRecordingId(Track.Id trackId) {
-        recordingTrackId = trackId;
-    }
 }
@@ -1,246 +0,0 @@
-/*
- * Copyright 2012 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.annotation.SuppressLint;
-import android.app.Activity;
-import android.graphics.drawable.TransitionDrawable;
-import android.os.Handler;
-import android.view.MotionEvent;
-import android.view.View;
-import android.view.accessibility.AccessibilityEvent;
-
-import java.time.Duration;
-
-import de.dennisguse.opentracks.databinding.TrackControllerBinding;
-import de.dennisguse.opentracks.services.TrackRecordingService;
-import de.dennisguse.opentracks.services.TrackRecordingServiceConnection;
-import de.dennisguse.opentracks.util.ActivityUtils;
-import de.dennisguse.opentracks.util.StringUtils;
-
-/**
- * Track controller for record, pause, resume, and stop.
- *
- * @author Jimmy Shih
- */
-public class TrackController implements View.OnTouchListener {
-
-    private static final String TAG = TrackController.class.getSimpleName();
-
-    private static final Duration UI_UPDATE_INTERVAL = Duration.ofSeconds(1);
-
-    private final Activity activity;
-    private final TrackRecordingServiceConnection trackRecordingServiceConnection;
-    private final Handler handlerUpdateTotalTime = new Handler();
-    private final boolean alwaysShow;
-
-    private Runnable buttonDelay;
-    private final int buttonDelayDuration;
-
-    private final TrackControllerBinding viewBinding;
-    private final TransitionDrawable transition;
-
-    private boolean isRecording;
-    private boolean isRecordingPaused;
-    private Duration totalTime;
-    private boolean isResumed = false;
-
-    private final Callback callback;
-
-    // A runnable to update the total time.
-    private final Runnable updateTotalTimeRunnable = new Runnable() {
-        public void run() {
-            if (isResumed && isRecording && !isRecordingPaused) {
-                updateTotalTime();
-                setTotalTime();
-                handlerUpdateTotalTime.postDelayed(this, UI_UPDATE_INTERVAL.toMillis());
-            }
-        }
-    };
-
-    @SuppressLint("ClickableViewAccessibility")
-    TrackController(Activity activity, TrackControllerBinding viewBinding, TrackRecordingServiceConnection trackRecordingServiceConnection, boolean alwaysShow, Callback callback) {
-        this.activity = activity;
-        this.viewBinding = viewBinding;
-        this.trackRecordingServiceConnection = trackRecordingServiceConnection;
-        this.alwaysShow = alwaysShow;
-        this.callback = callback;
-
-        buttonDelayDuration = activity.getResources().getInteger(R.integer.buttonDelayMillis);
-
-        viewBinding.trackControllerRecord.setOnTouchListener(this);
-        viewBinding.trackControllerRecord.setOnClickListener((view) -> {
-            if (buttonDelay != null || (isRecording && !isRecordingPaused)) {
-                return;
-            }
-
-            callback.recordStart();
-        });
-
-        viewBinding.trackControllerStop.setOnTouchListener(this);
-        transition = (TransitionDrawable) viewBinding.trackControllerContainer.getBackground();
-    }
-
-    @SuppressLint("ClickableViewAccessibility") //We do accessibility manually.
-    @Override
-    public boolean onTouch(final View view, MotionEvent event) {
-        if (event.getAction() == MotionEvent.ACTION_MOVE) {
-            return false;
-        }
-
-        if (buttonDelay != null && event.getAction() == MotionEvent.ACTION_UP) {
-            handlerUpdateTotalTime.removeCallbacks(buttonDelay);
-            buttonDelay = null;
-            view.setPressed(false);
-
-            transition.resetTransition();
-
-            showStatusSetDefaultText();
-
-            return false;
-        }
-
-        //Trigger button pressed animation
-        view.setPressed(true);
-
-        //To pause a recording
-        if (viewBinding.trackControllerRecord.equals(view)
-                && event.getAction() == MotionEvent.ACTION_DOWN
-                && isRecording && !isRecordingPaused) {
-
-            transition.startTransition(buttonDelayDuration);
-
-            ActivityUtils.vibrate(activity, 150);
-            viewBinding.trackControllerStatus.setText(R.string.hold_to_pause);
-
-            buttonDelay = () -> {
-                view.sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);
-                view.performClick();
-                callback.recordPause();
-
-                transition.resetTransition();
-
-                ActivityUtils.vibrate(activity, 1000);
-            };
-            handlerUpdateTotalTime.postDelayed(buttonDelay, buttonDelayDuration);
-            return true;
-        }
-
-        //To stop a recording
-        if (viewBinding.trackControllerStop.equals(view)
-                && event.getAction() == MotionEvent.ACTION_DOWN
-                && isRecording) {
-
-
-            transition.startTransition(buttonDelayDuration);
-
-            ActivityUtils.vibrate(activity, 150);
-            viewBinding.trackControllerStatus.setText(R.string.hold_to_stop);
-
-            buttonDelay = () -> {
-                view.sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);
-                callback.recordStop();
-                ActivityUtils.vibrate(activity, 1000);
-
-                transition.resetTransition();
-            };
-            handlerUpdateTotalTime.postDelayed(buttonDelay, buttonDelayDuration);
-            return true;
-        }
-
-        return false;
-    }
-
-    public void update(boolean recording, boolean paused) {
-        if (!isResumed) {
-            handlerUpdateTotalTime.removeCallbacks(updateTotalTimeRunnable);
-            return;
-        }
-        isRecording = recording;
-        isRecordingPaused = paused;
-        boolean visible = alwaysShow || isRecording;
-        viewBinding.trackControllerContainer.setVisibility(visible ? View.VISIBLE : View.GONE);
-
-        if (!visible) {
-            handlerUpdateTotalTime.removeCallbacks(updateTotalTimeRunnable);
-            return;
-        }
-
-        if (isRecording && !isRecordingPaused) {
-            handlerUpdateTotalTime.postDelayed(updateTotalTimeRunnable, UI_UPDATE_INTERVAL.toMillis());
-        }
-
-        viewBinding.trackControllerRecord.setImageResource(isRecording && !isRecordingPaused ? R.drawable.ic_button_pause : R.drawable.button_record);
-        viewBinding.trackControllerRecord.setContentDescription(activity.getString(isRecording && !isRecordingPaused ? R.string.image_pause : R.string.image_record));
-
-        viewBinding.trackControllerStop.setEnabled(isRecording);
-
-        viewBinding.trackControllerStatus.setVisibility(isRecording ? View.VISIBLE : View.INVISIBLE);
-        if (isRecording) {
-            viewBinding.trackControllerStatus.setTextColor(activity.getResources().getColor(isRecordingPaused ? android.R.color.white : R.color.recording_text));
-            showStatusSetDefaultText();
-        }
-
-        viewBinding.trackControllerTotalTime.setVisibility(isRecording ? View.VISIBLE : View.INVISIBLE);
-
-        if (isRecording) {
-            updateTotalTime();
-            setTotalTime();
-        }
-    }
-
-    void onResume(boolean recording, boolean paused) {
-        isResumed = true;
-        update(recording, paused);
-    }
-
-    void onPause() {
-        isResumed = false;
-        handlerUpdateTotalTime.removeCallbacks(updateTotalTimeRunnable);
-    }
-
-    public void hide() {
-        viewBinding.trackControllerContainer.setVisibility(View.GONE);
-    }
-
-    public void show() {
-        viewBinding.trackControllerContainer.setVisibility(View.VISIBLE);
-    }
-
-    private void updateTotalTime() {
-        TrackRecordingService trackRecordingService = trackRecordingServiceConnection.getServiceIfBound();
-        if (trackRecordingService != null) {
-            totalTime = trackRecordingService.getTotalTime();
-        }
-    }
-
-    private void setTotalTime() {
-        if (totalTime != null) {
-            viewBinding.trackControllerTotalTime.setText(StringUtils.formatElapsedTimeWithHour(totalTime));
-        }
-    }
-
-    private void showStatusSetDefaultText() {
-        viewBinding.trackControllerStatus.setText(isRecordingPaused ? R.string.generic_paused : R.string.generic_recording);
-    }
-
-    public interface Callback {
-        void recordStart();
-        void recordPause();
-        void recordStop();
-    }
-}
@@ -1,98 +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;
-
-import android.content.Intent;
-import android.os.Bundle;
-import android.os.PowerManager;
-import android.view.View;
-
-import java.util.List;
-
-import de.dennisguse.opentracks.content.data.Track;
-import de.dennisguse.opentracks.content.provider.ContentProviderUtils;
-import de.dennisguse.opentracks.databinding.TrackDeleteBinding;
-import de.dennisguse.opentracks.util.SystemUtils;
-
-/**
- * An activity for deleting tracks.
- *
- * @author Jimmy Shih
- */
-public class TrackDeleteActivity extends AbstractActivity {
-
-    public static final String EXTRA_TRACK_IDS = "track_ids";
-
-    private List<Track.Id> trackIds;
-
-    private Thread deleteThread;
-
-    private TrackDeleteBinding viewBinding;
-
-    @Override
-    public void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-
-        setResult(RESULT_CANCELED);
-
-        Intent intent = getIntent();
-        trackIds = intent.getParcelableArrayListExtra(EXTRA_TRACK_IDS);
-        deleteThread = new Thread(() -> {
-            ContentProviderUtils contentProviderUtils = new ContentProviderUtils(TrackDeleteActivity.this);
-
-            PowerManager.WakeLock wakeLock = SystemUtils.acquireWakeLock(TrackDeleteActivity.this, null);
-            contentProviderUtils.deleteTracks(TrackDeleteActivity.this, trackIds);
-
-            wakeLock = SystemUtils.releaseWakeLock(wakeLock);
-            if (Thread.interrupted()) {
-                return;
-            }
-
-            runOnUiThread(TrackDeleteActivity.this::onAsyncTaskCompleted);
-        });
-    }
-
-    @Override
-    protected void onStart() {
-        super.onStart();
-        deleteThread.start();
-    }
-
-    @Override
-    protected void onStop() {
-        super.onStop();
-        deleteThread.interrupt();
-    }
-
-    @Override
-    protected void onDestroy() {
-        super.onDestroy();
-        viewBinding = null;
-    }
-
-    @Override
-    protected View getRootView() {
-        viewBinding = TrackDeleteBinding.inflate(getLayoutInflater());
-        return viewBinding.getRoot();
-    }
-
-    public void onAsyncTaskCompleted() {
-        viewBinding.progressbar.setVisibility(View.INVISIBLE);
-        setResult(RESULT_OK);
-        finish();
-    }
-}
@@ -38,6 +38,7 @@ import android.view.View;
 import android.widget.Toast;

 import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import androidx.appcompat.widget.SearchView;
 import androidx.appcompat.widget.Toolbar;
 import androidx.core.app.ActivityCompat;
@@ -55,7 +56,6 @@ import de.dennisguse.opentracks.databinding.TrackListBinding;
 import de.dennisguse.opentracks.fragments.ConfirmDeleteDialogFragment;
 import de.dennisguse.opentracks.services.TrackRecordingService;
 import de.dennisguse.opentracks.services.TrackRecordingServiceConnection;
-import de.dennisguse.opentracks.services.TrackRecordingServiceStatus;
 import de.dennisguse.opentracks.services.handlers.GpsStatusValue;
 import de.dennisguse.opentracks.settings.SettingsActivity;
 import de.dennisguse.opentracks.util.ActivityUtils;
@@ -71,16 +71,16 @@ import de.dennisguse.opentracks.util.TrackIconUtils;
 *
 * @author Leif Hendrik Wilden
 */
-public class TrackListActivity extends AbstractListActivity implements ConfirmDeleteDialogFragment.ConfirmDeleteCaller, TrackController.Callback, TrackRecordingServiceStatus.Listener {
+public class TrackListActivity extends AbstractTrackDeleteActivity implements ConfirmDeleteDialogFragment.ConfirmDeleteCaller, ControllerFragment.Callback {

    private static final String TAG = TrackListActivity.class.getSimpleName();

+    protected static final int GPS_REQUEST_CODE = 6;
+
    // The following are set in onCreate
    private SharedPreferences sharedPreferences;
    private TrackRecordingServiceConnection trackRecordingServiceConnection;
-    private TrackController trackController;
    private ResourceCursorAdapter resourceCursorAdapter;
-    private GpsStatusValue gpsStatusValue;

    private TrackListBinding viewBinding;

@@ -89,7 +89,8 @@ public class TrackListActivity extends AbstractListActivity implements ConfirmDe
    // Preferences
    private boolean metricUnits = true;

-    private boolean recordingTrackPaused = true;
+    private GpsStatusValue gpsStatusValue = TrackRecordingService.STATUS_GPS_DEFAULT;
+    private TrackRecordingService.RecordingStatus recordingStatus = TrackRecordingService.STATUS_DEFAULT;

    // Callback when an item is selected in the contextual action mode
    private final ContextualActionModeCallback contextualActionModeCallback = new ContextualActionModeCallback() {
@@ -118,7 +119,6 @@ public class TrackListActivity extends AbstractListActivity implements ConfirmDe
                runOnUiThread(() -> {
                    TrackListActivity.this.invalidateOptionsMenu();
                    loaderCallbacks.restart();
-                    trackController.update(isRecording(), recordingTrackPaused);
                });
            }
        }
@@ -132,28 +132,27 @@ public class TrackListActivity extends AbstractListActivity implements ConfirmDe
    private final Runnable bindChangedCallback = new Runnable() {
        @Override
        public void run() {
-            // After binding changes (e.g., becomes available), update the total time in trackController.
-            runOnUiThread(() -> trackController.update(isRecording(), recordingTrackPaused));
-
            TrackRecordingService service = trackRecordingServiceConnection.getServiceIfBound();
            if (service == null) {
-                Log.d(TAG, "service not available to start gps or a new recording");
-                gpsStatusValue = GpsStatusValue.GPS_NONE;
+                Log.e(TAG, "service not available to start gps or a new recording");
                return;
            }

+            service.getRecordingStatusObservable()
+                    .observe(TrackListActivity.this, status -> onRecordingStatusChanged(status));
+
            // Get GPS status and listen GPS status changes.
-            gpsStatusValue = service.getGpsStatus();
-            updateGpsMenuItem(true, isRecording());
-            service.addListener(TrackListActivity.this);
+            service.getGpsStatusObservable()
+                    .observe(TrackListActivity.this, status -> onGpsStatusChanged(status));

-            if (isGpsStarted()) {
+            updateGpsMenuItem(true, recordingStatus.isRecording());
+
+            if (service.getGpsStatusObservable().getValue().isGpsStarted()) {
                return;
            }

+            //TODO Not cool to do this in a callback that might be called more than once!
            service.tryStartGps();
-            gpsStatusValue = GpsStatusValue.GPS_ENABLED;
-            updateGpsMenuItem(true, isRecording());
        }
    };

@@ -165,23 +164,13 @@ public class TrackListActivity extends AbstractListActivity implements ConfirmDe
        super.onCreate(savedInstanceState);
        setDefaultKeyMode(DEFAULT_KEYS_SEARCH_LOCAL);

-        gpsStatusValue = GpsStatusValue.GPS_NONE;
-
        sharedPreferences = PreferencesUtils.getSharedPreferences(this);

        trackRecordingServiceConnection = new TrackRecordingServiceConnection(bindChangedCallback);
-        trackController = new TrackController(this, viewBinding.trackControllerContainer, trackRecordingServiceConnection, true, this);
-
-
-        // Show trackController when search dialog is dismissed
-        SearchManager searchManager = (SearchManager) getSystemService(SEARCH_SERVICE);
-        if (searchManager != null) {
-            searchManager.setOnDismissListener(() -> trackController.show());
-        }

        viewBinding.trackList.setEmptyView(viewBinding.trackListEmptyView);
        viewBinding.trackList.setOnItemClickListener((parent, view, position, trackId) -> {
-            if (isRecording() && trackId == recordingTrackId.getId()) {
+            if (recordingStatus.isRecording() && trackId == recordingStatus.getTrackId().getId()) {
                // Is recording -> open record activity.
                Intent newIntent = IntentUtils.newIntent(TrackListActivity.this, TrackRecordingActivity.class)
                        .putExtra(TrackRecordedActivity.EXTRA_TRACK_ID, new Track.Id(trackId));
@@ -211,7 +200,7 @@ public class TrackListActivity extends AbstractListActivity implements ConfirmDe
                int markerCountIndex = cursor.getColumnIndexOrThrow(TracksColumns.MARKER_COUNT);

                Track.Id trackId = new Track.Id(cursor.getLong(idIndex));
-                boolean isRecording = trackId.equals(recordingTrackId);
+                boolean isRecording = trackId.equals(recordingStatus.getTrackId());
                String icon = cursor.getString(iconIndex);
                int iconId = TrackIconUtils.getIconDrawable(icon);
                String name = cursor.getString(nameIndex);
@@ -222,7 +211,7 @@ public class TrackListActivity extends AbstractListActivity implements ConfirmDe
                String category = icon != null && !icon.equals("") ? null : cursor.getString(categoryIndex);
                String description = cursor.getString(descriptionIndex);

-                ListItemUtils.setListItem(TrackListActivity.this, view, isRecording, recordingTrackPaused,
+                ListItemUtils.setListItem(TrackListActivity.this, view, isRecording, recordingStatus.isPaused(),
                        iconId, R.string.image_track, name, totalTime, totalDistance, markerCount,
                        startTime, true, category, description, false);
            }
@@ -250,14 +239,6 @@ public class TrackListActivity extends AbstractListActivity implements ConfirmDe
        trackRecordingServiceConnection.startConnection(this);
    }

-    @Override
-    protected void onPause() {
-        super.onPause();
-
-        // Update UI
-        trackController.onPause();
-    }
-
    @Override
    protected void onResume() {
        super.onResume();
@@ -265,7 +246,6 @@ public class TrackListActivity extends AbstractListActivity implements ConfirmDe
        // Update UI
        this.invalidateOptionsMenu();
        LoaderManager.getInstance(this).restartLoader(0, null, loaderCallbacks);
-        trackController.onResume(isRecording(), recordingTrackPaused);
    }

    @Override
@@ -298,7 +278,13 @@ public class TrackListActivity extends AbstractListActivity implements ConfirmDe
        getMenuInflater().inflate(R.menu.track_list, menu);

        searchMenuItem = menu.findItem(R.id.track_list_search);
-        ActivityUtils.configureSearchWidget(this, searchMenuItem, trackController);
+        SearchView searchView = ActivityUtils.configureSearchWidget(this, searchMenuItem);
+        searchView.setOnCloseListener(() -> {
+            searchView.clearFocus();
+            searchMenuItem.setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM);
+            return true;
+        });
+
        startGpsMenuItem = menu.findItem(R.id.track_list_start_gps);

        return super.onCreateOptionsMenu(menu);
@@ -306,7 +292,7 @@ public class TrackListActivity extends AbstractListActivity implements ConfirmDe

    @Override
    public boolean onPrepareOptionsMenu(Menu menu) {
-        updateMenuItems(isGpsStarted(), isRecording());
+        updateGpsMenuItem(gpsStatusValue.isGpsStarted(), recordingStatus.isRecording());

        SearchView searchView = (SearchView) searchMenuItem.getActionView();
        searchView.setQuery("", false);
@@ -322,7 +308,7 @@ public class TrackListActivity extends AbstractListActivity implements ConfirmDe
                startActivity(new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS));
            } else {
                // Invoke trackRecordingService
-                if (!isGpsStarted()) {
+                if (!gpsStatusValue.isGpsStarted()) {
                    trackRecordingServiceConnection.startAndBind(this);
                    bindChangedCallback.run();
                } else {
@@ -355,6 +341,12 @@ public class TrackListActivity extends AbstractListActivity implements ConfirmDe
            return true;
        }

+        if (item.getItemId() == R.id.track_list_search) {
+            SearchView searchView = (SearchView) searchMenuItem.getActionView();
+            searchView.setIconified(false);
+            searchMenuItem.setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS);
+        }
+
        return super.onOptionsItemSelected(item);
    }

@@ -366,17 +358,23 @@ public class TrackListActivity extends AbstractListActivity implements ConfirmDe
        return super.onKeyUp(keyCode, event);
    }

+    @Override
+    public void overridePendingTransition(int enterAnim, int exitAnim) {
+        //Disable animations as it is weird going into searchMode; looks okay for SplashScreen.
+    }
+
    @Override
    public void onBackPressed() {
+        SearchView searchView = (SearchView) searchMenuItem.getActionView();
+        if (!searchView.isIconified()) {
+            searchView.setIconified(true);
+        }
+
        if (loaderCallbacks.getSearchQuery() != null) {
            loaderCallbacks.setSearch(null);
            return;
        }
-        SearchView searchView = (SearchView) searchMenuItem.getActionView();
-        if (!searchView.isIconified()) {
-            searchView.setIconified(true);
-            return;
-        }
+
        super.onBackPressed();
    }

@@ -396,25 +394,20 @@ public class TrackListActivity extends AbstractListActivity implements ConfirmDe
        loaderCallbacks.setSearch(searchQuery);
    }

-    @Override
-    public boolean onSearchRequested() {
-        // Hide trackController when search dialog is shown
-        trackController.hide();
-        return super.onSearchRequested();
-    }
-
    @Override
    protected TrackRecordingServiceConnection getTrackRecordingServiceConnection() {
        return trackRecordingServiceConnection;
    }

    @Override
-    protected void onTrackDeleted() {
+    protected void onDeleteConfirmed() {
        // Do nothing
    }

-    private boolean isGpsStarted() {
-        return gpsStatusValue != GpsStatusValue.GPS_NONE && gpsStatusValue != GpsStatusValue.GPS_DISABLED;
+    @Nullable
+    @Override
+    protected Track.Id getRecordingTrackId() {
+        return recordingStatus.getTrackId();
    }

    private void requestGPSPermissions() {
@@ -423,22 +416,13 @@ public class TrackListActivity extends AbstractListActivity implements ConfirmDe
        }
    }

-    /**
-     * Updates the menu items with not fixed icon for gps option.
-     *
-     * @param isGpsStarted true if gps is started
-     * @param isRecording  true if recording
-     */
-    private void updateMenuItems(boolean isGpsStarted, boolean isRecording) {
-        updateGpsMenuItem(isGpsStarted, isRecording);
-    }
-
    /**
     * Updates the menu items with the icon specified.
     *
     * @param isGpsStarted true if gps is started
     * @param isRecording  true if recording
     */
+    //TODO Check if if can be avoided to call this outside of onGpsStatusChanged()
    private void updateGpsMenuItem(boolean isGpsStarted, boolean isRecording) {
        if (startGpsMenuItem != null) {
            startGpsMenuItem.setVisible(!isRecording);
@@ -477,7 +461,6 @@ public class TrackListActivity extends AbstractListActivity implements ConfirmDe
            return true;
        }

-
        if (itemId == R.id.list_context_menu_edit) {
            Intent intent = IntentUtils.newIntent(this, TrackEditActivity.class)
                    .putExtra(TrackEditActivity.EXTRA_TRACK_ID, trackIds[0]);
@@ -489,6 +472,7 @@ public class TrackListActivity extends AbstractListActivity implements ConfirmDe
            deleteTracks(trackIds);
            return true;
        }
+
        if (itemId == R.id.list_context_menu_select_all) {
            for (int i = 0; i < viewBinding.trackList.getCount(); i++) {
                viewBinding.trackList.setItemChecked(i, true);
@@ -554,55 +538,36 @@ public class TrackListActivity extends AbstractListActivity implements ConfirmDe

    @Override
    public void recordStart() {
-        if (recordingTrackId == null) {
+        if (recordingStatus.getTrackId() == null) {
            // Not recording -> Recording
-            updateMenuItems(false, true);
+            updateGpsMenuItem(false, true);
            Intent newIntent = IntentUtils.newIntent(TrackListActivity.this, TrackRecordingActivity.class);
            startActivity(newIntent);
-        } else if (recordingTrackPaused) {
+        } else if (recordingStatus.isPaused()) {
            // Paused -> Resume
-            updateMenuItems(false, true);
+            updateGpsMenuItem(false, true);
            trackRecordingServiceConnection.resumeTrack();
-            trackController.update(true, false);
        }
    }

    @Override
    public void recordPause() {
-        updateMenuItems(false, true);
+        updateGpsMenuItem(false, true);
        trackRecordingServiceConnection.pauseTrack();
-        trackController.update(true, true);
    }

    @Override
    public void recordStop() {
-        updateMenuItems(false, false);
+        updateGpsMenuItem(false, false);
        trackRecordingServiceConnection.stopRecording(TrackListActivity.this);
    }

-    private boolean isRecording() {
-        return recordingTrackId != null;
-    }
-
-    @Override
-    public void onGpsStatus(GpsStatusValue newStatus) {
+    public void onGpsStatusChanged(GpsStatusValue newStatus) {
        gpsStatusValue = newStatus;
-        updateGpsMenuItem(true, isRecording());
+        updateGpsMenuItem(true, recordingStatus.isRecording());
    }

-    @Override
-    public void onTrackRecordingPaused(boolean isPaused) {
-        if (recordingTrackPaused != isPaused) {
-            trackController.update(isRecording(), isPaused);
-        }
-        recordingTrackPaused = isPaused;
-    }
-
-    @Override
-    public void onTrackRecordingId(Track.Id trackId) {
-        if (!isRecording() && trackId != null) {
-            trackController.update(true, recordingTrackPaused);
-        }
-        recordingTrackId = trackId;
+    private void onRecordingStatusChanged(TrackRecordingService.RecordingStatus status) {
+        recordingStatus = status;
    }
 }
@@ -17,6 +17,7 @@
 package de.dennisguse.opentracks;

 import android.content.Intent;
+import android.content.SharedPreferences;
 import android.os.Bundle;
 import android.util.Log;
 import android.view.Menu;
@@ -24,6 +25,7 @@ import android.view.MenuItem;
 import android.view.View;

 import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import androidx.core.view.ViewCompat;
 import androidx.fragment.app.Fragment;
 import androidx.fragment.app.FragmentActivity;
@@ -40,12 +42,13 @@ import de.dennisguse.opentracks.fragments.ChartFragment;
 import de.dennisguse.opentracks.fragments.ConfirmDeleteDialogFragment;
 import de.dennisguse.opentracks.fragments.IntervalsFragment;
 import de.dennisguse.opentracks.fragments.StatisticsRecordedFragment;
+import de.dennisguse.opentracks.services.TrackDeleteService;
 import de.dennisguse.opentracks.services.TrackRecordingService;
 import de.dennisguse.opentracks.services.TrackRecordingServiceConnection;
-import de.dennisguse.opentracks.services.TrackRecordingServiceStatus;
 import de.dennisguse.opentracks.settings.SettingsActivity;
 import de.dennisguse.opentracks.util.IntentDashboardUtils;
 import de.dennisguse.opentracks.util.IntentUtils;
+import de.dennisguse.opentracks.util.PreferencesUtils;

 /**
 * An activity to show the track detail, record a new track or resumes an existing one.
@@ -53,7 +56,8 @@ import de.dennisguse.opentracks.util.IntentUtils;
 * @author Leif Hendrik Wilden
 * @author Rodrigo Damazio
 */
-public class TrackRecordedActivity extends AbstractListActivity implements ConfirmDeleteDialogFragment.ConfirmDeleteCaller, TrackActivityDataHubInterface, TrackRecordingServiceStatus.Listener {
+//TODO Should not use TrackRecordingServiceConnection; only used to determine if there is NO current recording, to enable resume functionality.
+public class TrackRecordedActivity extends AbstractTrackDeleteActivity implements ConfirmDeleteDialogFragment.ConfirmDeleteCaller, TrackActivityDataHubInterface {

    private static final String TAG = TrackRecordedActivity.class.getSimpleName();

@@ -66,11 +70,13 @@ public class TrackRecordedActivity extends AbstractListActivity implements Confi

    // The following are set in onCreate.
    private ContentProviderUtils contentProviderUtils;
+    private SharedPreferences sharedPreferences;
    private TrackDataHub trackDataHub;

    private TrackRecordedBinding viewBinding;

    private Track.Id trackId;
+    private TrackRecordingService.RecordingStatus recordingStatus = TrackRecordingService.STATUS_DEFAULT;

    private TrackRecordingServiceConnection trackRecordingServiceConnection;

@@ -78,8 +84,22 @@ public class TrackRecordedActivity extends AbstractListActivity implements Confi
        @Override
        public void run() {
            TrackRecordingService service = trackRecordingServiceConnection.getServiceIfBound();
-            if (service != null) {
-                service.addListener(TrackRecordedActivity.this);
+            if (service == null) {
+                Log.w(TAG, "could not get TrackRecordingService");
+                return;
+            }
+
+            service.getRecordingStatusObservable()
+                    .observe(TrackRecordedActivity.this, status -> onRecordingStatusChanged(status));
+
+        }
+    };
+
+    private final SharedPreferences.OnSharedPreferenceChangeListener sharedPreferenceChangeListener = new SharedPreferences.OnSharedPreferenceChangeListener() {
+        @Override
+        public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
+            if (PreferencesUtils.isKey(TrackRecordedActivity.this, R.string.recording_distance_interval_key, key)) {
+                trackDataHub.setRecordingDistanceInterval(PreferencesUtils.getRecordingDistanceInterval(sharedPreferences, TrackRecordedActivity.this));
            }
        }
    };
@@ -89,6 +109,8 @@ public class TrackRecordedActivity extends AbstractListActivity implements Confi
        super.onCreate(savedInstanceState);

        contentProviderUtils = new ContentProviderUtils(this);
+        sharedPreferences = PreferencesUtils.getSharedPreferences(this);
+
        handleIntent(getIntent());

        trackDataHub = new TrackDataHub(this);
@@ -109,6 +131,10 @@ public class TrackRecordedActivity extends AbstractListActivity implements Confi
    @Override
    protected void onStart() {
        super.onStart();
+
+        sharedPreferences.registerOnSharedPreferenceChangeListener(sharedPreferenceChangeListener);
+        sharedPreferenceChangeListener.onSharedPreferenceChanged(sharedPreferences, null);
+
        trackDataHub.start();
    }

@@ -131,6 +157,7 @@ public class TrackRecordedActivity extends AbstractListActivity implements Confi
        super.onStop();
        trackRecordingServiceConnection.unbind(this);
        trackDataHub.stop();
+        sharedPreferences.unregisterOnSharedPreferenceChangeListener(sharedPreferenceChangeListener);
    }

    @Override
@@ -161,7 +188,7 @@ public class TrackRecordedActivity extends AbstractListActivity implements Confi
    @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(recordingTrackId == null);
+        menu.findItem(R.id.track_detail_resume_track).setVisible(!recordingStatus.isRecording());
        Track track = contentProviderUtils.getTrack(trackId);
        setTitle(track != null ? track.getName() : "");
        return super.onPrepareOptionsMenu(menu);
@@ -216,14 +243,23 @@ public class TrackRecordedActivity extends AbstractListActivity implements Confi
        return super.onOptionsItemSelected(item);
    }

+    @Nullable
    @Override
-    protected TrackRecordingServiceConnection getTrackRecordingServiceConnection() {
-        // Not needed.
-        return null;
+    protected Track.Id getRecordingTrackId() {
+        return recordingStatus.getTrackId();
    }

    @Override
-    protected void onTrackDeleted() {
+    protected void onTrackDeleteStatus(TrackDeleteService.DeleteStatus deleteStatus) {
+        super.onTrackDeleteStatus(deleteStatus);
+        Log.e("probando", "trackId: " + trackId);
+        if (deleteStatus.isDeleted(trackId)) {
+            runOnUiThread(this::finish);
+        }
+    }
+
+    @Override
+    protected void onDeleteConfirmed() {
        runOnUiThread(this::finish);
    }

@@ -299,13 +335,12 @@ public class TrackRecordedActivity extends AbstractListActivity implements Confi
        }
    }

-    public void startPostponedEnterTransitionWith(View viewIcon, View viewName) {
+    public void startPostponedEnterTransitionWith(View viewIcon) {
        ViewCompat.setTransitionName(viewIcon, TrackRecordedActivity.VIEW_TRACK_ICON);
        startPostponedEnterTransition();
    }

-    @Override
-    public void onTrackRecordingId(Track.Id trackId) {
-        recordingTrackId = trackId;
+    private void onRecordingStatusChanged(TrackRecordingService.RecordingStatus status) {
+        recordingStatus = status;
    }
 }
@@ -28,7 +28,6 @@ import de.dennisguse.opentracks.fragments.IntervalsFragment;
 import de.dennisguse.opentracks.fragments.StatisticsRecordingFragment;
 import de.dennisguse.opentracks.services.TrackRecordingService;
 import de.dennisguse.opentracks.services.TrackRecordingServiceConnection;
-import de.dennisguse.opentracks.services.TrackRecordingServiceStatus;
 import de.dennisguse.opentracks.settings.SettingsActivity;
 import de.dennisguse.opentracks.util.IntentDashboardUtils;
 import de.dennisguse.opentracks.util.IntentUtils;
@@ -44,7 +43,7 @@ import de.dennisguse.opentracks.util.TrackUtils;
 */
 //NOTE: This activity does NOT react to preference changes of R.string.recording_track_id_key.
 //This mode of communication should be removed anyhow.
-public class TrackRecordingActivity extends AbstractActivity implements ChooseActivityTypeDialogFragment.ChooseActivityTypeCaller, TrackActivityDataHubInterface, TrackController.Callback, TrackRecordingServiceStatus.Listener {
+public class TrackRecordingActivity extends AbstractActivity implements ChooseActivityTypeDialogFragment.ChooseActivityTypeCaller, TrackActivityDataHubInterface, ControllerFragment.Callback {

    public static final String EXTRA_TRACK_ID = "track_id";

@@ -57,25 +56,27 @@ public class TrackRecordingActivity extends AbstractActivity implements ChooseAc
    private SharedPreferences sharedPreferences;
    private TrackRecordingServiceConnection trackRecordingServiceConnection;
    private TrackDataHub trackDataHub;
-    private TrackController trackController;

    private TrackRecordingBinding viewBinding;

    // Initialized from Intent; if a new track recording is started, a new TrackId will be provided by TrackRecordingService
+    @Deprecated
    private Track.Id trackId;
-    private boolean recordingTrackPaused;
+
+    private TrackRecordingService.RecordingStatus recordingStatus = TrackRecordingService.STATUS_DEFAULT;

    private final Runnable bindChangedCallback = new Runnable() {
        @Override
        public void run() {
-            // After binding changes (is available), update the total time in trackController.
-            runOnUiThread(() -> trackController.update(true, recordingTrackPaused));
-
            TrackRecordingService service = trackRecordingServiceConnection.getServiceIfBound();
            if (service == null) {
-                Log.d(TAG, "could not get TrackRecordingService");
+                Log.w(TAG, "could not get TrackRecordingService");
                return;
            }
+
+            service.getRecordingStatusObservable()
+                    .observe(TrackRecordingActivity.this, status -> onRecordingStatusChanged(status));
+
            if (!service.isRecording()) {
                if (trackId == null) {
                    // trackId isn't initialized -> leads a new recording.
@@ -87,10 +88,8 @@ public class TrackRecordingActivity extends AbstractActivity implements ChooseAc

                // A recording track is on.
                trackDataHub.loadTrack(trackId);
-                trackController.update(true, false);
-                trackController.onResume(true, recordingTrackPaused);
+                trackDataHub.setRecordingStatus(recordingStatus);
            }
-            service.addListener(TrackRecordingActivity.this);
        }
    };

@@ -106,11 +105,12 @@ public class TrackRecordingActivity extends AbstractActivity implements ChooseAc
            if (PreferencesUtils.isKey(TrackRecordingActivity.this, R.string.stats_fullscreen_while_recording_key, key)) {
                setFullscreenPolicy();
            }
+            if (PreferencesUtils.isKey(TrackRecordingActivity.this, R.string.recording_distance_interval_key, key)) {
+                trackDataHub.setRecordingDistanceInterval(PreferencesUtils.getRecordingDistanceInterval(sharedPreferences, TrackRecordingActivity.this));
+            }
            if (key == null) return;
-            runOnUiThread(() -> {
-                TrackRecordingActivity.this.invalidateOptionsMenu();
-                trackController.update(true, recordingTrackPaused);
-            });
+
+            runOnUiThread(TrackRecordingActivity.this::invalidateOptionsMenu);
        }
    };

@@ -145,8 +145,6 @@ public class TrackRecordingActivity extends AbstractActivity implements ChooseAc
        if (savedInstanceState != null) {
            viewBinding.trackDetailActivityViewPager.setCurrentItem(savedInstanceState.getInt(CURRENT_TAB_TAG_KEY));
        }
-
-        trackController = new TrackController(this, viewBinding.trackControllerContainer, trackRecordingServiceConnection, false, this);
    }

    @Override
@@ -205,11 +203,12 @@ public class TrackRecordingActivity extends AbstractActivity implements ChooseAc
        super.onResume();

        // Update UI
-        this.invalidateOptionsMenu();
+        invalidateOptionsMenu();

        if (trackId != null) {
+            //TODO Pass recordingStatus directly to them
            trackDataHub.loadTrack(trackId);
-            trackController.onResume(true, recordingTrackPaused);
+            trackDataHub.setRecordingStatus(recordingStatus);
        }

        /*
@@ -228,12 +227,6 @@ public class TrackRecordingActivity extends AbstractActivity implements ChooseAc
        outState.putParcelable(EXTRA_TRACK_ID, trackId);
    }

-    @Override
-    protected void onPause() {
-        super.onPause();
-        trackController.onPause();
-    }
-
    @Override
    protected void onStop() {
        super.onStop();
@@ -260,7 +253,7 @@ public class TrackRecordingActivity extends AbstractActivity implements ChooseAc

    @Override
    public boolean onPrepareOptionsMenu(Menu menu) {
-        updateMenuItems(recordingTrackPaused);
+        updateMenuItems(recordingStatus.isPaused());
        return super.onPrepareOptionsMenu(menu);
    }

@@ -335,14 +328,12 @@ public class TrackRecordingActivity extends AbstractActivity implements ChooseAc
    public void recordStart() {
        updateMenuItems(false);
        trackRecordingServiceConnection.resumeTrack();
-        trackController.update(true, false);
    }

    @Override
    public void recordPause() {
        updateMenuItems(true);
        trackRecordingServiceConnection.pauseTrack();
-        trackController.update(true, true);
    }

    @Override
@@ -400,21 +391,12 @@ public class TrackRecordingActivity extends AbstractActivity implements ChooseAc
        }
    }

-    @Override
-    public void onTrackRecordingPaused(boolean isPaused) {
-        if (recordingTrackPaused != isPaused) {
-            trackController.update(true, isPaused);
-        }
-        recordingTrackPaused = isPaused;
+    private void onRecordingStatusChanged(TrackRecordingService.RecordingStatus status) {
+        recordingStatus = status;
+
+        trackDataHub.setRecordingStatus(recordingStatus);
+
        setLockscreenPolicy();
        setScreenOnPolicy();
    }
-
-    @Override
-    public void onTrackRecordingId(Track.Id newTrackId) {
-        if (newTrackId != null && !newTrackId.equals(trackId)) {
-            trackId = newTrackId;
-            trackController.update(true, recordingTrackPaused);
-        }
-    }
 }
@@ -3,9 +3,10 @@ package de.dennisguse.opentracks.chart;
 import androidx.annotation.NonNull;
 import androidx.annotation.VisibleForTesting;

+import de.dennisguse.opentracks.content.data.Distance;
+import de.dennisguse.opentracks.content.data.Speed;
 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;

 public class ChartPoint {
@@ -13,44 +14,38 @@ public class ChartPoint {
    private double timeOrDistance;

    //Y-axis
-    private double altitude;
-    private double speed;
-    private double pace;
-    private double heartRate = Double.NaN;
-    private double cadence = Double.NaN;
-    private double power = Double.NaN;
+    private final double altitude;
+    private Double speed;
+    private Double pace;
+    private Double heartRate;
+    private Double cadence;
+    private Double power;

+    @Deprecated
    @VisibleForTesting
    ChartPoint(double altitude) {
        this.altitude = altitude;
    }

-    public ChartPoint(@NonNull TrackStatisticsUpdater trackStatisticsUpdater, TrackPoint trackPoint, boolean chartByDistance, boolean metricUnits) {
-        TrackStatistics trackStatistics = trackStatisticsUpdater.getTrackStatistics();
-
+    public ChartPoint(@NonNull TrackStatistics trackStatistics, @NonNull TrackPoint trackPoint, Speed smoothedSpeed, double smoothedAltitude_m, boolean chartByDistance, boolean metricUnits) {
        if (chartByDistance) {
-            timeOrDistance = trackStatistics.getTotalDistance().to(metricUnits);
+            timeOrDistance = trackStatistics.getTotalDistance().toKM_Miles(metricUnits);
        } else {
            timeOrDistance = trackStatistics.getTotalTime().toMillis();
        }

-        altitude = trackStatisticsUpdater.getSmoothedAltitude();
-        if (!metricUnits) {
-            altitude *= UnitConversions.M_TO_FT;
-        }
+        altitude = Distance.of(smoothedAltitude_m).toM_FT(metricUnits);

-        speed = trackStatisticsUpdater.getSmoothedSpeed().to(metricUnits);
-        pace = trackStatisticsUpdater.getSmoothedSpeed().toPace(metricUnits).toMillis() * UnitConversions.MS_TO_S * UnitConversions.S_TO_MIN;
-        if (trackPoint != null) {
-            if (trackPoint.hasHeartRate()) {
-                heartRate = trackPoint.getHeartRate_bpm();
-            }
-            if (trackPoint.hasCyclingCadence()) {
-                cadence = trackPoint.getCyclingCadence_rpm();
-            }
-            if (trackPoint.hasPower()) {
-                power = trackPoint.getPower();
-            }
+        speed = smoothedSpeed.to(metricUnits);
+        pace = smoothedSpeed.toPace(metricUnits).toMillis() * UnitConversions.MS_TO_S * UnitConversions.S_TO_MIN;
+        if (trackPoint.hasHeartRate()) {
+            heartRate = (double) trackPoint.getHeartRate_bpm();
+        }
+        if (trackPoint.hasCyclingCadence()) {
+            cadence = (double) trackPoint.getCyclingCadence_rpm();
+        }
+        if (trackPoint.hasPower()) {
+            power = (double) trackPoint.getPower();
        }
    }

@@ -58,39 +53,32 @@ public class ChartPoint {
        return timeOrDistance;
    }

-    public double getAltitude() {
+    public Double getAltitude() {
        return altitude;
    }

-    public double getSpeed() {
+    public Double getSpeed() {
        return speed;
    }

-    public double getPace() {
+    public Double getPace() {
        return pace;
    }

-    public boolean hasHeartRate() {
-        return Double.isNaN(heartRate);
-    }
-
-    public double getHeartRate() {
+    public Double getHeartRate() {
        return heartRate;
    }

-    public boolean hasCadence() {
-        return Double.isNaN(cadence);
-    }
-
-    public double getCadence() {
+    public Double getCadence() {
        return cadence;
    }

-    public boolean hasPower() {
-        return Double.isNaN(power);
-    }
-
-    public double getPower() {
+    public Double getPower() {
        return power;
    }
+
+    @Override
+    public String toString() {
+        return "ChartPoint{" + "timeOrDistance=" + timeOrDistance + '}';
+    }
 }
@@ -132,10 +132,10 @@ abstract class ChartValueSeries {
        }
    }

-    abstract double extractDataFromChartPoint(@NonNull ChartPoint chartPoint);
+    abstract Double extractDataFromChartPoint(@NonNull ChartPoint chartPoint);

    boolean isChartPointValid(@NonNull ChartPoint chartPoint) {
-        return !Double.isNaN(extractDataFromChartPoint(chartPoint));
+        return extractDataFromChartPoint(chartPoint) != null;
    }

    protected abstract boolean drawIfChartPointHasNoData();
@@ -40,8 +40,8 @@ import androidx.core.view.GestureDetectorCompat;
 import java.text.NumberFormat;
 import java.time.Duration;
 import java.util.ArrayList;
+import java.util.Iterator;
 import java.util.List;
-import java.util.Optional;

 import de.dennisguse.opentracks.MarkerDetailActivity;
 import de.dennisguse.opentracks.R;
@@ -206,7 +206,7 @@ public class ChartView extends View {
                fontSizeSmall,
                fontSizeMedium) {
            @Override
-            protected double extractDataFromChartPoint(@NonNull ChartPoint chartPoint) {
+            protected Double extractDataFromChartPoint(@NonNull ChartPoint chartPoint) {
                return chartPoint.getAltitude();
            }

@@ -227,7 +227,7 @@ public class ChartView extends View {
                fontSizeSmall,
                fontSizeMedium) {
            @Override
-            protected double extractDataFromChartPoint(@NonNull ChartPoint chartPoint) {
+            protected Double extractDataFromChartPoint(@NonNull ChartPoint chartPoint) {
                return chartPoint.getSpeed();
            }

@@ -249,7 +249,7 @@ public class ChartView extends View {
                fontSizeSmall,
                fontSizeMedium) {
            @Override
-            protected double extractDataFromChartPoint(@NonNull ChartPoint chartPoint) {
+            protected Double extractDataFromChartPoint(@NonNull ChartPoint chartPoint) {
                return chartPoint.getPace();
            }

@@ -271,7 +271,7 @@ public class ChartView extends View {
                fontSizeSmall,
                fontSizeMedium) {
            @Override
-            protected double extractDataFromChartPoint(@NonNull ChartPoint chartPoint) {
+            protected Double extractDataFromChartPoint(@NonNull ChartPoint chartPoint) {
                return chartPoint.getHeartRate();
            }

@@ -292,7 +292,7 @@ public class ChartView extends View {
                fontSizeSmall,
                fontSizeMedium) {
            @Override
-            protected double extractDataFromChartPoint(@NonNull ChartPoint chartPoint) {
+            protected Double extractDataFromChartPoint(@NonNull ChartPoint chartPoint) {
                return chartPoint.getCadence();
            }

@@ -312,7 +312,7 @@ public class ChartView extends View {
                fontSizeSmall,
                fontSizeMedium) {
            @Override
-            protected double extractDataFromChartPoint(@NonNull ChartPoint chartPoint) {
+            protected Double extractDataFromChartPoint(@NonNull ChartPoint chartPoint) {
                return chartPoint.getPower();
            }

@@ -424,7 +424,7 @@ public class ChartView extends View {
                }
            }
            updateDimensions();
-            updatePaths();
+            updateSeries();
        }
    }

@@ -471,7 +471,7 @@ public class ChartView extends View {
    private void zoomIn() {
        if (canZoomIn()) {
            zoomLevel++;
-            updatePaths();
+            updateSeries();
            invalidate();
        }
    }
@@ -486,7 +486,7 @@ public class ChartView extends View {
                scrollX = maxWidth;
                scrollTo(scrollX, 0);
            }
-            updatePaths();
+            updateSeries();
            invalidate();
        }
    }
@@ -853,63 +853,49 @@ public class ChartView extends View {
    }

    /**
-     * Updates paths.
     * The path needs to be updated any time after the data or the dimensions change.
     */
-    private void updatePaths() {
+    private void updateSeries() {
        synchronized (chartPoints) {
-            for (ChartValueSeries chartValueSeries : seriesList) {
-                chartValueSeries.getPath().reset();
-            }
-            drawPaths();
-            closePaths();
+            seriesList.stream().forEach(this::updateSerie);
        }
    }

-    private void drawPaths() {
-        boolean[] hasMoved = new boolean[seriesList.size()];
+    private void updateSerie(ChartValueSeries series) {
+        final int yCorner = topBorder + effectiveHeight;
+        final Path path = series.getPath();

-        for (ChartPoint dataPoint : chartPoints) {
-            for (int i = 0; i < seriesList.size(); i++) {
-                ChartValueSeries chartValueSeries = seriesList.get(i);
+        boolean drawFirstPoint = false;
+        path.rewind();

-                if (!chartValueSeries.isChartPointValid(dataPoint)) {
-                    continue;
-                }
+        Iterator<ChartPoint> iterator = chartPoints.iterator();
+        while (iterator.hasNext()) {
+            ChartPoint point = iterator.next();
+            if (!series.isChartPointValid(point)) {
+                continue;
+            }

-                double value = chartValueSeries.extractDataFromChartPoint(dataPoint);
-                Path path = chartValueSeries.getPath();
-                int x = getX(dataPoint.getTimeOrDistance());
-                int y = getY(chartValueSeries, value);
-                if (!hasMoved[i]) {
-                    hasMoved[i] = true;
-                    path.moveTo(x, y);
-                } else {
-                    path.lineTo(x, y);
-                }
+            double value = series.extractDataFromChartPoint(point);
+            int x = getX(point.getTimeOrDistance());
+            int y = getY(series, value);
+
+            // start from lower left corner
+            if (!drawFirstPoint) {
+                path.moveTo(x, yCorner);
+                drawFirstPoint = true;
+            }
+
+            // draw graph
+            path.lineTo(x, y);
+
+            // last point: move to lower right
+            if (!iterator.hasNext()) {
+                path.lineTo(x, yCorner);
            }
        }
-    }

-    private void closePaths() {
-        for (ChartValueSeries chartValueSeries : seriesList) {
-            Optional<ChartPoint> firstValid = chartPoints.stream().filter(chartValueSeries::isChartPointValid)
-                    .findFirst();
-            Optional<ChartPoint> lastValid = chartPoints.stream().filter(chartValueSeries::isChartPointValid)
-                    .reduce((first, second) -> second);
-
-            if (firstValid.isPresent() && lastValid.isPresent()) {
-                Path path = chartValueSeries.getPath();
-
-                int yCorner = topBorder + effectiveHeight;
-
-                path.lineTo(getX(lastValid.get().getTimeOrDistance()), yCorner);
-                path.lineTo(getX(firstValid.get().getTimeOrDistance()), yCorner);
-
-                double value = chartValueSeries.extractDataFromChartPoint(firstValid.get());
-                path.lineTo(getX(firstValid.get().getTimeOrDistance()), getY(chartValueSeries, value));
-            }
-        }
+        // back to lower left corner
+        path.close();
    }

    /**
@@ -961,7 +947,7 @@ public class ChartView extends View {
            width = newWidth;
            height = newHeight;
            updateEffectiveDimensions();
-            updatePaths();
+            updateSeries();
        }
    }

@@ -993,7 +979,7 @@ public class ChartView extends View {

    private double getMarkerXValue(Marker marker) {
        if (chartByDistance) {
-            return marker.getLength().to(metricUnits);
+            return marker.getLength().toKM_Miles(metricUnits);
        } else {
            return marker.getDuration().toMillis();
        }
@@ -27,9 +27,12 @@ import android.util.Log;
 import androidx.annotation.NonNull;
 import androidx.annotation.VisibleForTesting;

+import java.io.IOException;
 import java.util.Collections;
 import java.util.Set;

+import de.dennisguse.opentracks.content.data.Altitude;
+import de.dennisguse.opentracks.content.data.Distance;
 import de.dennisguse.opentracks.content.data.Marker;
 import de.dennisguse.opentracks.content.data.MarkerColumns;
 import de.dennisguse.opentracks.content.data.Track;
@@ -39,8 +42,8 @@ import de.dennisguse.opentracks.content.data.TracksColumns;
 import de.dennisguse.opentracks.content.provider.ContentProviderUtils;
 import de.dennisguse.opentracks.content.provider.TrackPointIterator;
 import de.dennisguse.opentracks.services.TrackRecordingService;
-import de.dennisguse.opentracks.services.TrackRecordingServiceConnection;
-import de.dennisguse.opentracks.services.TrackRecordingServiceStatus;
+import de.dennisguse.opentracks.stats.TrackStatisticsUpdater;
+import de.dennisguse.opentracks.util.EGM2008Utils;

 /**
 * Track data hub.
@@ -50,7 +53,8 @@ import de.dennisguse.opentracks.services.TrackRecordingServiceStatus;
 *
 * @author Rodrigo Damazio
 */
-public class TrackDataHub implements TrackRecordingServiceStatus.Listener {
+//TODO register contentobserver only for exact URL (incl. trackId) to not filter here.
+public class TrackDataHub {

    /**
     * Target number of track points displayed by the diagrams (recommended).
@@ -71,34 +75,29 @@ public class TrackDataHub implements TrackRecordingServiceStatus.Listener {
    private final ContentProviderUtils contentProviderUtils;
    private final int targetNumPoints;

+    private EGM2008Utils.EGM2008Correction egm2008Correction;
+
    private boolean started;
    private HandlerThread handlerThread;
    private Handler handler;

-    private TrackRecordingServiceConnection trackRecordingServiceConnection;
-
-    // Preference values
    private Track.Id selectedTrackId;
-    private Track.Id recordingTrackId;
-    private boolean recordingTrackPaused;
+
+    private Distance recordingDistanceInterval;
+
+    private TrackRecordingService.RecordingStatus recordingStatus = TrackRecordingService.STATUS_DEFAULT;

    // Track points sampling state
    private int numLoadedPoints;
    private TrackPoint.Id firstSeenTrackPointId;
    private TrackPoint.Id lastSeenTrackPointId;
+    private TrackStatisticsUpdater trackStatisticsUpdater;

    // Registered listeners
    private ContentObserver tracksTableObserver;
    private ContentObserver markersTableObserver;
    private ContentObserver trackPointsTableObserver;

-    private final Runnable bindCallback = () -> {
-        TrackRecordingService service = trackRecordingServiceConnection.getServiceIfBound();
-        if (service != null) {
-            service.addListener(TrackDataHub.this);
-        }
-    };
-
    public TrackDataHub(Context context) {
        this(context, new TrackDataManager(), new ContentProviderUtils(context), TARGET_DISPLAYED_TRACKPOINTS);
    }
@@ -147,15 +146,6 @@ public class TrackDataHub implements TrackRecordingServiceStatus.Listener {
            }
        };
        contentResolver.registerContentObserver(TrackPointsColumns.CONTENT_URI_BY_ID, false, trackPointsTableObserver);
-
-        trackRecordingServiceConnection = new TrackRecordingServiceConnection(bindCallback);
-        trackRecordingServiceConnection.bind(context);
-
-        handler.post(() -> {
-            if (started) {
-                loadDataForAll();
-            }
-        });
    }

    public void stop() {
@@ -177,8 +167,7 @@ public class TrackDataHub implements TrackRecordingServiceStatus.Listener {
            handlerThread = null;
        }
        handler = null;
-
-        trackRecordingServiceConnection.unbind(context);
+        trackStatisticsUpdater = null;
    }

    public void loadTrack(final @NonNull Track.Id trackId) {
@@ -219,14 +208,14 @@ public class TrackDataHub implements TrackRecordingServiceStatus.Listener {
     * Returns true if the selected track is recording.
     */
    public boolean isSelectedTrackRecording() {
-        return selectedTrackId != null && selectedTrackId.equals(recordingTrackId);
+        return selectedTrackId != null && selectedTrackId.equals(recordingStatus.getTrackId());
    }

    /**
     * Returns true if the selected track is paused.
     */
    public boolean isSelectedTrackPaused() {
-        return selectedTrackId != null && selectedTrackId.equals(recordingTrackId) && recordingTrackPaused;
+        return selectedTrackId != null && selectedTrackId.equals(recordingStatus.getTrackId()) && recordingStatus.isPaused();
    }

    /**
@@ -374,6 +363,8 @@ public class TrackDataHub implements TrackRecordingServiceStatus.Listener {
                    break;
                }

+                correctAltitude(trackPoint);
+
                if (localFirstSeenTrackPointId == null) {
                    localFirstSeenTrackPointId = trackPointId;
                }
@@ -383,15 +374,16 @@ public class TrackDataHub implements TrackRecordingServiceStatus.Listener {
                    samplingFrequency = 1 + (int) (numTotalPoints / targetNumPoints);
                }

+                trackStatisticsUpdater.addTrackPoint(trackPoint, recordingDistanceInterval);

                // Also include the last point if the selected track is not recording.
                if ((localNumLoadedTrackPoints % samplingFrequency == 0) || (trackPointId == lastTrackPointId && !isSelectedTrackRecording())) {
                    for (TrackDataListener trackDataListener : sampledInListeners) {
-                        trackDataListener.onSampledInTrackPoint(trackPoint);
+                        trackDataListener.onSampledInTrackPoint(trackPoint, trackStatisticsUpdater.getTrackStatistics(), trackStatisticsUpdater.getSmoothedSpeed(), trackStatisticsUpdater.getSmoothedAltitude());
                    }
                } else {
                    for (TrackDataListener trackDataListener : sampledOutListeners) {
-                        trackDataListener.onSampledOutTrackPoint(trackPoint);
+                        trackDataListener.onSampledOutTrackPoint(trackPoint, trackStatisticsUpdater.getTrackStatistics());
                    }
                }

@@ -411,11 +403,29 @@ public class TrackDataHub implements TrackRecordingServiceStatus.Listener {

        if (trackPoint != null) {
            for (TrackDataListener listener : sampledInListeners) {
-                listener.onNewTrackPointsDone(trackPoint);
+                listener.onNewTrackPointsDone(trackPoint, trackStatisticsUpdater.getTrackStatistics());
            }
        }
    }

+    private void correctAltitude(TrackPoint trackPoint) {
+        if (!trackPoint.hasLocation() || !trackPoint.hasAltitude()) {
+            Log.d(TAG, "No altitude correction necessary.");
+            return;
+        }
+
+        if (egm2008Correction == null || !egm2008Correction.canCorrect(trackPoint.getLocation())) {
+            try {
+                egm2008Correction = EGM2008Utils.createCorrection(context, trackPoint.getLocation());
+            } catch (IOException e) {
+                Log.e(TAG, "Could not load altitude correction for " + trackPoint, e);
+                return;
+            }
+        }
+
+        trackPoint.setAltitude(Altitude.EGM2008.of(egm2008Correction.correctAltitude(trackPoint.getLocation())));
+    }
+
    /**
     * Resets the track points sampling states.
     */
@@ -423,15 +433,14 @@ public class TrackDataHub implements TrackRecordingServiceStatus.Listener {
        numLoadedPoints = 0;
        firstSeenTrackPointId = null;
        lastSeenTrackPointId = null;
+        trackStatisticsUpdater = new TrackStatisticsUpdater();
    }

-    @Override
-    public void onTrackRecordingPaused(boolean isPaused) {
-        recordingTrackPaused = isPaused;
+    public void setRecordingStatus(TrackRecordingService.RecordingStatus recordingStatus) {
+        this.recordingStatus = recordingStatus;
    }

-    @Override
-    public void onTrackRecordingId(Track.Id trackId) {
-        recordingTrackId = trackId;
+    public void setRecordingDistanceInterval(Distance recordingDistanceInterval) {
+        this.recordingDistanceInterval = recordingDistanceInterval;
    }
 }
@@ -19,8 +19,10 @@ package de.dennisguse.opentracks.content;
 import androidx.annotation.NonNull;

 import de.dennisguse.opentracks.content.data.Marker;
+import de.dennisguse.opentracks.content.data.Speed;
 import de.dennisguse.opentracks.content.data.Track;
 import de.dennisguse.opentracks.content.data.TrackPoint;
+import de.dennisguse.opentracks.stats.TrackStatistics;

 /**
 * Listener for track data changes.
@@ -47,20 +49,23 @@ public interface TrackDataListener {
     *
     * @param trackPoint the trackPoint
     */
-    void onSampledInTrackPoint(@NonNull TrackPoint trackPoint);
+    default void onSampledInTrackPoint(@NonNull TrackPoint trackPoint, @NonNull TrackStatistics trackStatistics, Speed smoothedSpeed, double smoothedAltitude_m) {
+    }

    /**
     * Called when a sampled out track point is read.
     *
     * @param trackPoint the trackPoint
     */
-    void onSampledOutTrackPoint(@NonNull TrackPoint trackPoint);
+    default void onSampledOutTrackPoint(@NonNull TrackPoint trackPoint, @NonNull TrackStatistics trackStatistics) {
+    }

    /**
     * Called when finish sending new track points.
-     * This gets called after every batch of calls to {@link #onSampledInTrackPoint(TrackPoint)} and {@link #onSampledOutTrackPoint(TrackPoint)}.
+     * This gets called after every batch of calls to {@link #onSampledInTrackPoint(TrackPoint, TrackStatistics, Speed, double)} and {@link #onSampledOutTrackPoint(TrackPoint, TrackStatistics)}.
     */
-    void onNewTrackPointsDone(@NonNull TrackPoint lastTrackPoint);
+    default void onNewTrackPointsDone(@NonNull TrackPoint lastTrackPoint, @NonNull TrackStatistics trackStatistics) {
+    }

    /**
     * Called to clear previously sent markers.
@@ -41,10 +41,10 @@ class TrackDataManager {
    }

    void unregisterTrackDataListener(TrackDataListener trackDataListener) {
-        dataListenerTracks.add(trackDataListener);
-        dataListenerMarkers.add(trackDataListener);
-        dataListenerTrackPoints_SampledIn.add(trackDataListener);
-        dataListenerTrackPoints_SampledOut.add(trackDataListener);
+        dataListenerTracks.remove(trackDataListener);
+        dataListenerMarkers.remove(trackDataListener);
+        dataListenerTrackPoints_SampledIn.remove(trackDataListener);
+        dataListenerTrackPoints_SampledOut.remove(trackDataListener);
    }

    boolean hasListeners() {
@@ -0,0 +1,39 @@
+package de.dennisguse.opentracks.content.data;
+
+public abstract class Altitude {
+
+    private final double altitude_m;
+
+    private Altitude(double altitude_m) {
+        this.altitude_m = altitude_m;
+    }
+
+    public double toM() {
+        return altitude_m;
+    }
+
+    public static class WGS84 extends Altitude {
+
+        private WGS84(double altitude_m) {
+            super(altitude_m);
+        }
+
+
+        public static Altitude of(double altitude_m) {
+            return new WGS84(altitude_m);
+        }
+    }
+
+    public static class EGM2008 extends Altitude {
+
+        private EGM2008(double altitude_m) {
+            super(altitude_m);
+        }
+
+
+        public static Altitude of(double altitude_m) {
+            return new EGM2008(altitude_m);
+        }
+    }
+}
+
@@ -20,9 +20,17 @@ public class Distance {
        return of(distance_mile * UnitConversions.MI_TO_M);
    }

+    public static Distance ofKilometer(double distance_km) {
+        return of(distance_km * UnitConversions.KM_TO_M);
+    }
+
+    public static Distance ofMM(double distance_mm) {
+        return of(distance_mm * UnitConversions.MM_TO_M);
+    }
+
    public static Distance one(boolean metricUnit) {
        if (metricUnit) {
-            return Distance.of(1);
+            return Distance.ofKilometer(1);
        } else {
            return Distance.ofMile(1);
        }
@@ -94,24 +102,12 @@ public class Distance {
        return toKM() * UnitConversions.KM_TO_MI;
    }

-    public double to(boolean metricUnit) {
-        return to(metricUnit ? Unit.KM : Unit.MILES);
+    public double toKM_Miles(boolean metricUnit) {
+        return metricUnit ? toKM() : toMI();
    }

-    public double to(Unit unit) {
-        switch (unit) {
-            case KM:
-                return toKM();
-            case MILES:
-                return toMI();
-            default:
-                throw new RuntimeException("Not implemented");
-        }
-    }
-
-    public enum Unit {
-        KM,
-        MILES
+    public double toM_FT(boolean metricUnit) {
+        return metricUnit ? toM() : toFT();
    }

    @Override
@@ -50,7 +50,7 @@ public final class Marker {
    private Double latitude;
    private Double longitude;
    private Float accuracy;
-    private Double altitude_m;
+    private Altitude altitude;
    private Float bearing;

    //TODO It is the distance from the track starting point; rename to something more meaningful
@@ -77,7 +77,7 @@ public final class Marker {
        this.latitude = trackPoint.getLatitude();
        this.longitude = trackPoint.getLongitude();
        if (trackPoint.hasAccuracy()) this.accuracy = trackPoint.getAccuracy();
-        if (trackPoint.hasAltitude()) this.altitude_m = trackPoint.getAltitude();
+        if (trackPoint.hasAltitude()) this.altitude = trackPoint.getAltitude();
        if (trackPoint.hasBearing()) this.bearing = trackPoint.getBearing();

        this.length = Distance.of(0); //TODO Not cool!
@@ -167,7 +167,7 @@ public final class Marker {
            location.setAccuracy(accuracy);
        }
        if (hasAltitude()) {
-            location.setAltitude(altitude_m);
+            location.setAltitude(altitude.toM());
        }

        return location;
@@ -202,15 +202,15 @@ public final class Marker {
    }

    public boolean hasAltitude() {
-        return altitude_m != null;
+        return altitude != null;
    }

-    public Double getAltitude() {
-        return altitude_m;
+    public Altitude getAltitude() {
+        return altitude;
    }

-    public void setAltitude(double altitude_m) {
-        this.altitude_m = altitude_m;
+    public void setAltitude(Altitude altitude) {
+        this.altitude = altitude;
    }

    public boolean hasBearing() {
@@ -20,6 +20,7 @@ import android.os.Parcel;

 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;

 import java.time.Duration;
 import java.time.Instant;
@@ -51,7 +52,7 @@ public class TrackPoint {
    private Double latitude;
    private Double longitude;
    private Float accuracy;
-    private Double altitude_m;
+    private Altitude altitude;
    private Speed speed;
    private Float bearing;
    private Distance sensorDistance_m;
@@ -102,7 +103,7 @@ public class TrackPoint {

        this.latitude = location.getLatitude();
        this.longitude = location.getLongitude();
-        this.altitude_m = location.getAltitude();
+        this.altitude = Altitude.WGS84.of(location.getAltitude());
        this.speed = Speed.of(location.getSpeed());
        this.accuracy = location.getAccuracy();

@@ -114,11 +115,11 @@ public class TrackPoint {
        this.time = time;
    }

-    public TrackPoint(double latitude, double longitude, Double altitude, Instant time) {
+    public TrackPoint(double latitude, double longitude, Altitude altitude, Instant time) {
        this(Type.TRACKPOINT);
        this.latitude = latitude;
        this.longitude = longitude;
-        this.altitude_m = altitude;
+        this.altitude = altitude;
        this.time = time;
    }

@@ -212,7 +213,7 @@ public class TrackPoint {
            location.setAccuracy(accuracy);
        }
        if (hasAltitude()) {
-            location.setAltitude(altitude_m);
+            location.setAltitude(altitude.toM());
        }

        return location;
@@ -257,15 +258,20 @@ public class TrackPoint {


    public boolean hasAltitude() {
-        return altitude_m != null;
+        return altitude != null;
    }

-    public double getAltitude() {
-        return altitude_m;
+    public Altitude getAltitude() {
+        return altitude;
    }

-    public void setAltitude(double altitude) {
-        this.altitude_m = altitude;
+    @VisibleForTesting
+    public void setAltitude(double altitude_m) {
+        this.altitude = Altitude.WGS84.of(altitude_m);
+    }
+
+    public void setAltitude(Altitude altitude) {
+        this.altitude = altitude;
    }

    public boolean hasSpeed() {
@@ -39,6 +39,7 @@ import java.util.List;
 import java.util.UUID;

 import de.dennisguse.opentracks.BuildConfig;
+import de.dennisguse.opentracks.content.data.Altitude;
 import de.dennisguse.opentracks.content.data.Distance;
 import de.dennisguse.opentracks.content.data.Marker;
 import de.dennisguse.opentracks.content.data.MarkerColumns;
@@ -60,7 +61,6 @@ import de.dennisguse.opentracks.util.UUIDUtils;
 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.
    @VisibleForTesting
@@ -160,8 +160,10 @@ public class ContentProviderUtils {

    @VisibleForTesting
    public void deleteAllTracks(Context context) {
+        //TODO Both calls should not be necessary
        contentResolver.delete(TrackPointsColumns.CONTENT_URI_BY_ID, null, null);
        contentResolver.delete(MarkerColumns.CONTENT_URI, null, null);
+
        // Delete tracks last since it triggers a database vaccum call
        contentResolver.delete(TracksColumns.CONTENT_URI, null, null);

@@ -189,6 +191,7 @@ public class ContentProviderUtils {
    }

    //TODO Only use for tests; also move to tests.
+    @VisibleForTesting
    public List<Track> getTracks() {
        ArrayList<Track> tracks = new ArrayList<>();
        try (Cursor cursor = getTrackCursor(null, null, TracksColumns._ID)) {
@@ -202,9 +205,6 @@ public class ContentProviderUtils {
        return tracks;
    }

-    /**
-     * @param trackId the track id.
-     */
    public Track getTrack(Track.Id trackId) {
        if (trackId == null) {
            return null;
@@ -217,9 +217,6 @@ public class ContentProviderUtils {
        return null;
    }

-    /**
-     * @param trackUUID the track uuid.
-     */
    public Track getTrack(@NonNull UUID trackUUID) {
        String trackUUIDsearch = UUIDUtils.toHex(trackUUID);
        try (Cursor cursor = getTrackCursor("hex(" + TracksColumns.UUID + ")=?", new String[]{trackUUIDsearch}, null)) {
@@ -320,7 +317,7 @@ public class ContentProviderUtils {
            marker.setLatitude(((double) cursor.getInt(latitudeIndex)) / 1E6);
        }
        if (!cursor.isNull(altitudeIndex)) {
-            marker.setAltitude(cursor.getFloat(altitudeIndex));
+            marker.setAltitude(Altitude.WGS84.of(cursor.getFloat(altitudeIndex)));
        }
        if (!cursor.isNull(accuracyIndex)) {
            marker.setAccuracy(cursor.getFloat(accuracyIndex));
@@ -489,7 +486,7 @@ public class ContentProviderUtils {
        values.put(MarkerColumns.LATITUDE, (int) (marker.getLatitude() * 1E6));
        values.put(MarkerColumns.TIME, marker.getTime().toEpochMilli());
        if (marker.hasAltitude()) {
-            values.put(MarkerColumns.ALTITUDE, marker.getAltitude());
+            values.put(MarkerColumns.ALTITUDE, marker.getAltitude().toM());
        }
        if (marker.hasAccuracy()) {
            values.put(MarkerColumns.ACCURACY, marker.getAccuracy());
@@ -539,7 +536,7 @@ public class ContentProviderUtils {
            trackPoint.setTime(Instant.ofEpochMilli(cursor.getLong(indexes.timeIndex)));
        }
        if (!cursor.isNull(indexes.altitudeIndex)) {
-            trackPoint.setAltitude(cursor.getFloat(indexes.altitudeIndex));
+            trackPoint.setAltitude(Altitude.WGS84.of(cursor.getFloat(indexes.altitudeIndex)));
        }
        if (!cursor.isNull(indexes.accuracyIndex)) {
            trackPoint.setAccuracy(cursor.getFloat(indexes.accuracyIndex));
@@ -608,6 +605,7 @@ public class ContentProviderUtils {
     * @param location the location
     * @return trackPoint id if the location is in the track. -1L otherwise.
     */
+    @Deprecated
    public TrackPoint.Id getTrackPointId(Track.Id trackId, Location location) {
        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.getId()), Long.toString(location.getTime())};
@@ -690,7 +688,7 @@ public class ContentProviderUtils {
        }
        values.put(TrackPointsColumns.TIME, trackPoint.getTime().toEpochMilli());
        if (trackPoint.hasAltitude()) {
-            values.put(TrackPointsColumns.ALTITUDE, trackPoint.getAltitude());
+            values.put(TrackPointsColumns.ALTITUDE, trackPoint.getAltitude().toM());
        }
        if (trackPoint.hasAccuracy()) {
            values.put(TrackPointsColumns.ACCURACY, trackPoint.getAccuracy());
@@ -739,6 +737,7 @@ public class ContentProviderUtils {
        return new TrackPointIterator(this, trackId, startTrackPointId);
    }

+    @Deprecated
    private TrackPoint findTrackPointBy(String selection, String[] selectionArgs) {
        try (Cursor cursor = getTrackPointCursor(null, selection, selectionArgs, TrackPointsColumns._ID)) {
            if (cursor != null && cursor.moveToNext()) {
@@ -123,7 +123,7 @@ public final class SensorDataCycling {
            return wheelRevolutionsTime;
        }

-        public void compute(DistanceSpeed previous, int wheel_circumference_mm) {
+        public void compute(DistanceSpeed previous, Distance wheelCircumference) {
            if (hasData() && previous != null && previous.hasData()) {
                float timeDiff_ms = UintUtils.diff(wheelRevolutionsTime, previous.wheelRevolutionsTime, UintUtils.UINT16_MAX) / 1024f * UnitConversions.S_TO_MS;
                Duration timeDiff = Duration.ofMillis((long) timeDiff_ms);
@@ -134,7 +134,7 @@ public final class SensorDataCycling {
                    long wheelDiff = UintUtils.diff(wheelRevolutionsCount, previous.wheelRevolutionsCount, UintUtils.UINT16_MAX);
                    wheelDiff = Math.abs(wheelDiff); //HACK for Garmin Speed 2 as some of those seem to count backwards

-                    Distance distance = Distance.of(wheelDiff * wheel_circumference_mm * UnitConversions.MM_TO_M);
+                    Distance distance = wheelCircumference.multipliedBy(wheelDiff);
                    Distance distanceOverall = distance;
                    if (previous.hasValue()) {
                        distanceOverall = distance.plus(previous.getValue().distanceOverall);
@@ -39,6 +39,7 @@ import de.dennisguse.opentracks.content.TrackDataHub;
 import de.dennisguse.opentracks.content.TrackDataListener;
 import de.dennisguse.opentracks.content.data.Distance;
 import de.dennisguse.opentracks.content.data.Marker;
+import de.dennisguse.opentracks.content.data.Speed;
 import de.dennisguse.opentracks.content.data.Track;
 import de.dennisguse.opentracks.content.data.TrackPoint;
 import de.dennisguse.opentracks.databinding.ChartBinding;
@@ -72,7 +73,6 @@ public class ChartFragment extends Fragment implements TrackDataListener {
    private TrackDataHub trackDataHub;

    // Stats gathered from the received data
-    private TrackStatisticsUpdater trackStatisticsUpdater = new TrackStatisticsUpdater();
    private final List<ChartPoint> pendingPoints = new ArrayList<>();
    private String category = "";

@@ -217,7 +217,6 @@ public class ChartFragment extends Fragment implements TrackDataListener {
    @Override
    public void clearTrackPoints() {
        if (isResumed()) {
-            trackStatisticsUpdater = new TrackStatisticsUpdater();
            pendingPoints.clear();
            chartView.reset();
            runOnUiThread(() -> {
@@ -228,24 +227,15 @@ public class ChartFragment extends Fragment implements TrackDataListener {
        }
    }

-    @Override
-    public void onSampledInTrackPoint(@NonNull TrackPoint trackPoint) {
+    public void onSampledInTrackPoint(@NonNull TrackPoint trackPoint, @NonNull TrackStatistics trackStatistics, Speed smoothedSpeed, double smoothedAltitude_m) {
        if (isResumed()) {
-            pendingPoints.add(createPendingPoint(trackPoint));
+            ChartPoint point = new ChartPoint(trackStatistics, trackPoint, smoothedSpeed, smoothedAltitude_m, chartByDistance, chartView.getMetricUnits());
+            pendingPoints.add(point);
        }
    }

    @Override
-    public void onSampledOutTrackPoint(@NonNull TrackPoint trackPoint) {
-        if (isResumed()) {
-            if (trackStatisticsUpdater != null) {
-                trackStatisticsUpdater.addTrackPoint(trackPoint, recordingDistanceInterval);
-            }
-        }
-    }
-
-    @Override
-    public void onNewTrackPointsDone(@NonNull TrackPoint unused) {
+    public void onNewTrackPointsDone(@NonNull TrackPoint unused, @NonNull TrackStatistics alsoUnused) {
        if (isResumed()) {
            chartView.addChartPoints(pendingPoints);
            pendingPoints.clear();
@@ -306,6 +296,8 @@ public class ChartFragment extends Fragment implements TrackDataListener {
     * Returns true if the selected track is recording.
     * Needs to be synchronized because trackDataHub can be accessed by multiple threads.
     */
+    @Deprecated
+    //TODO Should not be dynamic but instead set while instantiating, i.e., newFragment().
    private synchronized boolean isSelectedTrackRecording() {
        return trackDataHub != null && trackDataHub.isSelectedTrackRecording();
    }
@@ -322,34 +314,8 @@ public class ChartFragment extends Fragment implements TrackDataListener {
        }
    }

-    @VisibleForTesting
-    ChartPoint createPendingPoint(@NonNull TrackPoint trackPoint) {
-        trackStatisticsUpdater.addTrackPoint(trackPoint, recordingDistanceInterval);
-        return new ChartPoint(trackStatisticsUpdater, trackPoint, chartByDistance, chartView.getMetricUnits());
-    }
-
    @VisibleForTesting
    void setChartView(ChartView view) {
        chartView = view;
    }
-
-    @VisibleForTesting
-    void setMetricUnits(boolean value) {
-        chartView.setMetricUnits(value);
-    }
-
-    @VisibleForTesting
-    void setReportSpeed(boolean value) {
-        chartView.setReportSpeed(value);
-    }
-
-    @VisibleForTesting
-    void setChartByDistance(boolean value) {
-        chartByDistance = value;
-    }
-
-    @VisibleForTesting
-    void setRecordingDistanceInterval(Distance value) {
-        recordingDistanceInterval = value;
-    }
 }
@@ -25,9 +25,11 @@ import de.dennisguse.opentracks.adapters.IntervalStatisticsAdapter;
 import de.dennisguse.opentracks.content.TrackDataHub;
 import de.dennisguse.opentracks.content.TrackDataListener;
 import de.dennisguse.opentracks.content.data.Marker;
+import de.dennisguse.opentracks.content.data.Speed;
 import de.dennisguse.opentracks.content.data.Track;
 import de.dennisguse.opentracks.content.data.TrackPoint;
 import de.dennisguse.opentracks.databinding.IntervalListViewBinding;
+import de.dennisguse.opentracks.stats.TrackStatistics;
 import de.dennisguse.opentracks.util.PreferencesUtils;
 import de.dennisguse.opentracks.viewmodels.IntervalStatistics;
 import de.dennisguse.opentracks.viewmodels.IntervalStatisticsModel;
@@ -229,21 +231,21 @@ public class IntervalsFragment extends Fragment implements TrackDataListener {
    }

    @Override
-    public void onSampledInTrackPoint(@NonNull TrackPoint trackPoint) {
+    public void onSampledInTrackPoint(@NonNull TrackPoint trackPoint, @NonNull TrackStatistics unused, Speed unused2, double unused3) {
        if (isResumed()) {
            viewModel.add(trackPoint);
        }
    }

    @Override
-    public void onSampledOutTrackPoint(@NonNull TrackPoint trackPoint) {
+    public void onSampledOutTrackPoint(@NonNull TrackPoint trackPoint, @NonNull TrackStatistics unused) {
        if (isResumed()) {
            viewModel.add(trackPoint);
        }
    }

    @Override
-    public void onNewTrackPointsDone(@NonNull TrackPoint unused) {
+    public void onNewTrackPointsDone(@NonNull TrackPoint unused, @NonNull TrackStatistics alsoUnused) {
        if (isResumed()) {
            runOnUiThread(viewModel::onNewTrackPoints);
        }
@@ -18,6 +18,7 @@ package de.dennisguse.opentracks.fragments;

 import android.content.SharedPreferences;
 import android.os.Bundle;
+import android.util.Log;
 import android.util.Pair;
 import android.view.LayoutInflater;
 import android.view.View;
@@ -54,6 +55,8 @@ import de.dennisguse.opentracks.viewmodels.SensorDataModel;
 */
 public class StatisticsRecordedFragment extends Fragment {

+    private static final String TAG = StatisticsRecordedFragment.class.getSimpleName();
+
    private static final String TRACK_ID_KEY = "trackId";

    public static StatisticsRecordedFragment newInstance(Track.Id trackId) {
@@ -154,19 +157,25 @@ public class StatisticsRecordedFragment extends Fragment {
            getActivity().runOnUiThread(() -> {
                if (isResumed()) {
                    Track track = contentProviderUtils.getTrack(trackId);
-                    sensorStatistics = contentProviderUtils.getSensorStats(trackId);
-
-                    if ((this.track == null && track != null) || (this.track != null && track != null && !this.track.getCategory().equals(track.getCategory()))) {
-                        sharedPreferenceChangeListener.onSharedPreferenceChanged(sharedPreferences, getString(R.string.stats_rate_key));
+                    if (track == null) {
+                        Log.e(TAG, "track cannot be null");
+                        getActivity().finish();
+                        return;
                    }

+                    sensorStatistics = contentProviderUtils.getSensorStats(trackId);
+
+                    boolean prefsChanged = this.track == null || (!this.track.getCategory().equals(track.getCategory()));
                    this.track = track;
+                    if (prefsChanged) {
+                        sharedPreferenceChangeListener.onSharedPreferenceChanged(sharedPreferences, getString(R.string.stats_rate_key));
+                    }

                    loadTrackDescription(track);
                    updateUI();
                    updateSensorUI();

-                    ((TrackRecordedActivity) getActivity()).startPostponedEnterTransitionWith(viewBinding.statsActivityTypeIcon, viewBinding.statsNameValue);
+                    ((TrackRecordedActivity) getActivity()).startPostponedEnterTransitionWith(viewBinding.statsActivityTypeIcon);
                }
            });
        }
@@ -34,6 +34,7 @@ import de.dennisguse.opentracks.content.sensor.SensorDataSet;
 import de.dennisguse.opentracks.databinding.StatisticsRecordingBinding;
 import de.dennisguse.opentracks.services.TrackRecordingService;
 import de.dennisguse.opentracks.services.TrackRecordingServiceConnection;
+import de.dennisguse.opentracks.stats.TrackStatistics;
 import de.dennisguse.opentracks.util.PreferencesUtils;
 import de.dennisguse.opentracks.util.StringUtils;
 import de.dennisguse.opentracks.util.TrackIconUtils;
@@ -211,17 +212,7 @@ public class StatisticsRecordingFragment extends Fragment implements TrackDataLi
    }

    @Override
-    public void onSampledInTrackPoint(@NonNull TrackPoint trackPoint) {
-        // We don't care.
-    }
-
-    @Override
-    public void onSampledOutTrackPoint(@NonNull TrackPoint trackPoint) {
-        // We don't care.
-    }
-
-    @Override
-    public void onNewTrackPointsDone(@NonNull TrackPoint newLastTrackPoint) {
+    public void onNewTrackPointsDone(@NonNull TrackPoint newLastTrackPoint, @NonNull TrackStatistics trackStatistics) {
        if (isResumed()) {
            getActivity().runOnUiThread(() -> {
                if (isResumed()) {
@@ -388,7 +379,7 @@ public class StatisticsRecordingFragment extends Fragment implements TrackDataLi
        }

        // Set time
-        if (track != null && track.getTrackStatistics() != null) {
+        if (track != null) {
            viewBinding.statsMovingTimeValue.setText(StringUtils.formatElapsedTime(track.getTrackStatistics().getMovingTime()));
            updateTotalTime();
        }
@@ -453,7 +444,7 @@ public class StatisticsRecordingFragment extends Fragment implements TrackDataLi

        if (preferenceShowAltitude) {
            // Current altitude
-            Float altitude = lastTrackPoint != null && lastTrackPoint.hasAltitude() ? (float) lastTrackPoint.getAltitude() : null;
+            Float altitude = lastTrackPoint != null && lastTrackPoint.hasAltitude() ? (float) lastTrackPoint.getAltitude().toM() : null;
            Pair<String, String> parts = StringUtils.formatAltitude(getContext(), altitude, preferenceMetricUnits);
            viewBinding.statsAltitudeCurrentValue.setText(parts.first);
            viewBinding.statsAltitudeCurrentUnit.setText(parts.second);
@@ -237,7 +237,7 @@ public class GPXTrackExporter implements TrackExporter {
        if (printWriter != null) {
            printWriter.println("<wpt " + formatLocation(marker.getLatitude(), marker.getLongitude()) + ">");
            if (marker.hasAltitude()) {
-                printWriter.println("<ele>" + ALTITUDE_FORMAT.format(marker.getAltitude()) + "</ele>");
+                printWriter.println("<ele>" + ALTITUDE_FORMAT.format(marker.getAltitude().toM()) + "</ele>");
            }
            printWriter.println("<time>" + StringUtils.formatDateTimeIso8601(marker.getTime()) + "</time>");
            printWriter.println("<name>" + StringUtils.formatCData(marker.getName()) + "</name>");
@@ -281,7 +281,7 @@ public class GPXTrackExporter implements TrackExporter {
            printWriter.println("<trkpt " + formatLocation(trackPoint.getLatitude(), trackPoint.getLongitude()) + ">");

            if (trackPoint.hasAltitude()) {
-                printWriter.println("<ele>" + ALTITUDE_FORMAT.format(trackPoint.getAltitude()) + "</ele>");
+                printWriter.println("<ele>" + ALTITUDE_FORMAT.format(trackPoint.getAltitude().toM()) + "</ele>");
            }

            printWriter.println("<time>" + StringUtils.formatDateTimeIso8601(trackPoint.getTime()) + "</time>");
@@ -518,13 +518,12 @@ public class KMLTrackExporter implements TrackExporter {
        return location.getBearing();
    }

-    private String getCoordinates(Location location, String separator) {
-        StringBuilder builder = new StringBuilder();
-        builder.append(location.getLongitude()).append(separator).append(location.getLatitude());
+    private static String getCoordinates(Location location, String separator) {
+        String result = location.getLongitude() + separator + location.getLatitude();
        if (location.hasAltitude()) {
-            builder.append(separator).append(location.getAltitude());
+            result += separator + location.getAltitude();
        }
-        return builder.toString();
+        return result;
    }

    /**
@@ -18,7 +18,6 @@ package de.dennisguse.opentracks.io.file.importer;

 import android.content.Context;
 import android.content.SharedPreferences;
-import android.database.sqlite.SQLiteConstraintException;
 import android.net.Uri;
 import android.util.Log;

@@ -29,8 +28,6 @@ import org.xml.sax.SAXException;
 import org.xml.sax.helpers.DefaultHandler;

 import java.io.File;
-import java.io.IOException;
-import java.io.InputStream;
 import java.time.Duration;
 import java.time.Instant;
 import java.util.ArrayList;
@@ -38,10 +35,8 @@ import java.util.List;
 import java.util.Locale;
 import java.util.UUID;

-import javax.xml.parsers.ParserConfigurationException;
-import javax.xml.parsers.SAXParserFactory;
-
 import de.dennisguse.opentracks.R;
+import de.dennisguse.opentracks.content.data.Altitude;
 import de.dennisguse.opentracks.content.data.Distance;
 import de.dennisguse.opentracks.content.data.Marker;
 import de.dennisguse.opentracks.content.data.Speed;
@@ -62,7 +57,7 @@ import de.dennisguse.opentracks.util.TrackIconUtils;
 *
 * @author Jimmy Shih
 */
-abstract class AbstractFileTrackImporter extends DefaultHandler implements TrackImporter {
+abstract class AbstractFileTrackImporter extends DefaultHandler implements XMLImporter.TrackParser {

    private static final String TAG = AbstractFileTrackImporter.class.getSimpleName();

@@ -127,24 +122,6 @@ abstract class AbstractFileTrackImporter extends DefaultHandler implements Track
        }
    }

-    @Override
-    @NonNull
-    public List<Track.Id> importFile(InputStream inputStream) {
-        try {
-            SAXParserFactory.newInstance().newSAXParser().parse(inputStream, this);
-            return trackIds;
-        } catch (IOException | SAXException | ParserConfigurationException | ParsingException e) {
-            Log.e(TAG, "Unable to import file", e);
-            if (trackIds.size() > 0) {
-                cleanImport();
-            }
-            throw new ImportParserException(e);
-        } catch (SQLiteConstraintException e) {
-            Log.e(TAG, "Unable to import file", e);
-            throw new ImportAlreadyExistsException(e);
-        }
-    }
-
    protected void onFileEnd() {
        // Add markers to the last imported track
        int size = trackIds.size();
@@ -430,7 +407,7 @@ abstract class AbstractFileTrackImporter extends DefaultHandler implements Track
        return null;
    }

-    private TrackPoint createTrackPoint() throws ParsingException {
+    protected TrackPoint createTrackPoint() throws ParsingException {
        TrackPoint trackPoint = new TrackPoint(TrackPoint.Type.TRACKPOINT);

        try {
@@ -450,68 +427,14 @@ abstract class AbstractFileTrackImporter extends DefaultHandler implements Track
            throw new ParsingException(createErrorMessage(String.format(Locale.US, "Unable to parse latitude longitude: %s %s", latitude, longitude)), e);
        }

-
        if (altitude != null) {
            try {
-                trackPoint.setAltitude(Double.parseDouble(altitude));
+                trackPoint.setAltitude(Altitude.WGS84.of(Double.parseDouble(altitude)));
            } catch (NumberFormatException e) {
                throw new ParsingException(createErrorMessage(String.format(Locale.US, "Unable to parse altitude: %s", altitude)), e);
            }
        }

-        if (speed != null) {
-            try {
-                trackPoint.setSpeed(Speed.of(speed));
-            } catch (Exception e) {
-                throw new ParsingException(createErrorMessage(String.format(Locale.US, "Unable to parse speed: %s", speed)), e);
-            }
-        }
-        if (heartrate != null) {
-            try {
-                trackPoint.setHeartRate_bpm(Float.parseFloat(heartrate));
-            } catch (Exception e) {
-                throw new ParsingException(createErrorMessage(String.format(Locale.US, "Unable to parse heart rate: %s", heartrate)), e);
-            }
-        }
-
-        if (cadence != null) {
-            try {
-                trackPoint.setCyclingCadence_rpm(Float.parseFloat(cadence));
-            } catch (Exception e) {
-                throw new ParsingException(createErrorMessage(String.format(Locale.US, "Unable to parse cadence: %s", cadence)), e);
-            }
-        }
-
-        if (power != null) {
-            try {
-                trackPoint.setPower(Float.parseFloat(power));
-            } catch (Exception e) {
-                throw new ParsingException(createErrorMessage(String.format(Locale.US, "Unable to parse power: %s", power)), e);
-            }
-        }
-
-        if (gain != null) {
-            try {
-                trackPoint.setAltitudeGain(Float.parseFloat(gain));
-            } catch (Exception e) {
-                throw new ParsingException(createErrorMessage(String.format(Locale.US, "Unable to parse altitude gain: %s", gain)), e);
-            }
-        }
-        if (loss != null) {
-            try {
-                trackPoint.setAltitudeLoss(Float.parseFloat(loss));
-            } catch (Exception e) {
-                throw new ParsingException(createErrorMessage(String.format(Locale.US, "Unable to parse altitude loss: %s", loss)), e);
-            }
-        }
-        if (distance != null) {
-            try {
-                trackPoint.setSensorDistance(Distance.of(distance));
-            } catch (Exception e) {
-                throw new ParsingException(createErrorMessage(String.format(Locale.US, "Unable to parse distance: %s", distance)), e);
-            }
-        }
-
        return trackPoint;
    }

@@ -538,10 +461,12 @@ abstract class AbstractFileTrackImporter extends DefaultHandler implements Track
        }
    }

-    /**
-     * Cleans up import.
-     */
-    private void cleanImport() {
+    @Override
+    public List<Track.Id> getImportTrackIds() {
+        return trackIds;
+    }
+
+    public void cleanImport() {
        contentProviderUtils.deleteTracks(context, trackIds);
    }

@@ -571,7 +496,7 @@ abstract class AbstractFileTrackImporter extends DefaultHandler implements Track
            super(message);
        }

-        private ParsingException(@NonNull String message, Exception cause) {
+        protected ParsingException(@NonNull String message, Exception cause) {
            super(message, cause);
        }

@@ -22,7 +22,12 @@ import androidx.annotation.VisibleForTesting;

 import org.xml.sax.Attributes;
 import org.xml.sax.SAXException;
+import org.xml.sax.helpers.DefaultHandler;

+import java.util.Locale;
+
+import de.dennisguse.opentracks.content.data.Distance;
+import de.dennisguse.opentracks.content.data.Speed;
 import de.dennisguse.opentracks.content.data.TrackPoint;
 import de.dennisguse.opentracks.content.provider.ContentProviderUtils;

@@ -79,6 +84,11 @@ public class GpxFileTrackImporter extends AbstractFileTrackImporter {
        super(context, contentProviderUtils);
    }

+    @Override
+    public DefaultHandler getHandler() {
+        return this;
+    }
+
    @Override
    public void startElement(String uri, String localName, String tag, Attributes attributes) throws SAXException {
        switch (tag) {
@@ -199,6 +209,66 @@ public class GpxFileTrackImporter extends AbstractFileTrackImporter {
        category = null;
    }

+    @Override
+    protected TrackPoint createTrackPoint() throws ParsingException {
+        TrackPoint trackPoint = super.createTrackPoint();
+
+        if (speed != null) {
+            try {
+                trackPoint.setSpeed(Speed.of(speed));
+            } catch (Exception e) {
+                throw new ParsingException(createErrorMessage(String.format(Locale.US, "Unable to parse speed: %s", speed)), e);
+            }
+        }
+        if (heartrate != null) {
+            try {
+                trackPoint.setHeartRate_bpm(Float.parseFloat(heartrate));
+            } catch (Exception e) {
+                throw new ParsingException(createErrorMessage(String.format(Locale.US, "Unable to parse heart rate: %s", heartrate)), e);
+            }
+        }
+
+        if (cadence != null) {
+            try {
+                trackPoint.setCyclingCadence_rpm(Float.parseFloat(cadence));
+            } catch (Exception e) {
+                throw new ParsingException(createErrorMessage(String.format(Locale.US, "Unable to parse cadence: %s", cadence)), e);
+            }
+        }
+
+        if (power != null) {
+            try {
+                trackPoint.setPower(Float.parseFloat(power));
+            } catch (Exception e) {
+                throw new ParsingException(createErrorMessage(String.format(Locale.US, "Unable to parse power: %s", power)), e);
+            }
+        }
+
+        if (gain != null) {
+            try {
+                trackPoint.setAltitudeGain(Float.parseFloat(gain));
+            } catch (Exception e) {
+                throw new ParsingException(createErrorMessage(String.format(Locale.US, "Unable to parse altitude gain: %s", gain)), e);
+            }
+        }
+        if (loss != null) {
+            try {
+                trackPoint.setAltitudeLoss(Float.parseFloat(loss));
+            } catch (Exception e) {
+                throw new ParsingException(createErrorMessage(String.format(Locale.US, "Unable to parse altitude loss: %s", loss)), e);
+            }
+        }
+        if (distance != null) {
+            try {
+                trackPoint.setSensorDistance(Distance.of(distance));
+            } catch (Exception e) {
+                throw new ParsingException(createErrorMessage(String.format(Locale.US, "Unable to parse distance: %s", distance)), e);
+            }
+        }
+
+        return trackPoint;
+    }
+
    /**
     * On track point start.
     *
@@ -13,7 +13,6 @@ import androidx.core.app.JobIntentService;
 import androidx.documentfile.provider.DocumentFile;

 import java.io.IOException;
-import java.io.InputStream;
 import java.util.ArrayList;

 import de.dennisguse.opentracks.R;
@@ -47,23 +46,22 @@ public class ImportService extends JobIntentService {
    }

    private void importFile(DocumentFile file) {
-        TrackImporter trackImporter;
+        ArrayList<Track.Id> trackIds = new ArrayList<>();
+
        String fileExtension = FileUtils.getExtension(file);
+        try {

-        if (TrackFileFormat.GPX.getExtension().equals(fileExtension)) {
-            trackImporter = new GpxFileTrackImporter(this);
-        } else if (TrackFileFormat.KML_WITH_TRACKDETAIL_AND_SENSORDATA.getExtension().equals(fileExtension)) {
-            trackImporter = new KmlFileTrackImporter(this);
-        } else if (TrackFileFormat.KMZ_WITH_TRACKDETAIL_AND_SENSORDATA_AND_PICTURES.getExtension().equals(fileExtension)) {
-            trackImporter = new KmzTrackImporter(this, file.getUri());
-        } else {
-            Log.d(TAG, "Unsupported file format.");
-            sendResult(ImportServiceResultReceiver.RESULT_CODE_ERROR, null, file, getString(R.string.import_unsupported_format));
-            return;
-        }
-
-        try (InputStream inputStream = getContentResolver().openInputStream(file.getUri())) {
-            ArrayList<Track.Id> trackIds = new ArrayList<>(trackImporter.importFile(inputStream));
+            if (TrackFileFormat.GPX.getExtension().equals(fileExtension)) {
+                trackIds.addAll(new XMLImporter(new GpxFileTrackImporter(this)).importFile(this, file.getUri()));
+            } else if (TrackFileFormat.KML_WITH_TRACKDETAIL_AND_SENSORDATA.getExtension().equals(fileExtension)) {
+                trackIds.addAll(new XMLImporter(new KmlFileTrackImporter(this)).importFile(this, file.getUri()));
+            } else if (TrackFileFormat.KMZ_WITH_TRACKDETAIL_AND_SENSORDATA_AND_PICTURES.getExtension().equals(fileExtension)) {
+                trackIds.addAll(new KmzTrackImporter().importFile(this, file.getUri()));
+            } else {
+                Log.d(TAG, "Unsupported file format.");
+                sendResult(ImportServiceResultReceiver.RESULT_CODE_ERROR, null, file, getString(R.string.import_unsupported_format));
+                return;
+            }

            if (!trackIds.isEmpty()) {
                sendResult(ImportServiceResultReceiver.RESULT_CODE_IMPORTED, trackIds, file, getString(R.string.import_file_imported, file.getName()));
@@ -23,6 +23,7 @@ import androidx.annotation.VisibleForTesting;

 import org.xml.sax.Attributes;
 import org.xml.sax.SAXException;
+import org.xml.sax.helpers.DefaultHandler;

 import java.util.ArrayList;

@@ -37,7 +38,6 @@ import de.dennisguse.opentracks.io.file.exporter.KMLTrackExporter;
 *
 * @author Jimmy Shih
 */
-//TODO Do not use AbstractFileTrackImporter as TrackPoint sensor generation is done differently here.
 public class KmlFileTrackImporter extends AbstractFileTrackImporter {

    private static final String TAG = KmlFileTrackImporter.class.getSimpleName();
@@ -84,6 +84,11 @@ public class KmlFileTrackImporter extends AbstractFileTrackImporter {
        super(context, contentProviderUtils);
    }

+    @Override
+    public DefaultHandler getHandler() {
+        return this;
+    }
+
    @Override
    public void startElement(String uri, String localName, String tag, Attributes attributes) throws SAXException {
        switch (tag) {
@@ -22,10 +22,9 @@ import android.util.Log;

 import androidx.annotation.NonNull;

-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.FileOutputStream;
+import java.io.FilterInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.ArrayList;
@@ -46,35 +45,23 @@ import de.dennisguse.opentracks.util.FileUtils;
 *
 * @author Jimmy Shih
 */
-public class KmzTrackImporter implements TrackImporter {
+public class KmzTrackImporter {

    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 Context context;

-    private final Context context;
-    private final Uri uriKmzFile;
-
-    /**
-     * @param context the context
-     * @param uriFile URI of the kmz file.
-     */
-    public KmzTrackImporter(Context context, Uri uriFile) {
+    @NonNull
+    public List<Track.Id> importFile(Context context, Uri fileUri) throws IOException {
        this.context = context;
-        this.uriKmzFile = uriFile;
-    }
+        List<Track.Id> trackIds = findAndParseKmlFile(fileUri);

-    @Override
-    public @NonNull
-    List<Track.Id> importFile(InputStream inputStream) {
-        List<Track.Id> trackIds = findAndParseKmlFile(inputStream);
-
-        ArrayList<Track.Id> trackIdsWithImages = new ArrayList<>();
+        List<Track.Id> trackIdsWithImages = new ArrayList<>();

        for (Track.Id trackId : trackIds) {
-            if (copyKmzImages(trackId)) {
+            if (copyKmzImages(fileUri, trackId)) {
                trackIdsWithImages.add(trackId);
                deleteOrphanImages(trackId);
            } else {
@@ -90,8 +77,8 @@ public class KmzTrackImporter implements TrackImporter {
     *
     * @return false if there are errors or true otherwise.
     */
-    private boolean copyKmzImages(Track.Id trackId) {
-        try (InputStream inputStream = context.getContentResolver().openInputStream(uriKmzFile);
+    private boolean copyKmzImages(Uri uri, Track.Id trackId) throws IOException {
+        try (InputStream inputStream = context.getContentResolver().openInputStream(uri);
             ZipInputStream zipInputStream = new ZipInputStream(inputStream)) {
            ZipEntry zipEntry;

@@ -110,9 +97,6 @@ public class KmzTrackImporter implements TrackImporter {
            }

            return true;
-        } catch (IOException e) {
-            Log.e(TAG, "Unable to import file", e);
-            return false;
        }
    }

@@ -154,13 +138,9 @@ public class KmzTrackImporter implements TrackImporter {
        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.
-     */
-    private List<Track.Id> findAndParseKmlFile(InputStream inputStream) {
-        try (ZipInputStream zipInputStream = new ZipInputStream(inputStream)) {
+    private List<Track.Id> findAndParseKmlFile(Uri uri) throws IOException {
+        try (InputStream inputStream = context.getContentResolver().openInputStream(uri);
+             ZipInputStream zipInputStream = new ZipInputStream(inputStream)) {
            ZipEntry zipEntry;
            ArrayList<Track.Id> trackIds = new ArrayList<>();

@@ -190,9 +170,6 @@ public class KmzTrackImporter implements TrackImporter {
        } catch (ImportParserException | ImportAlreadyExistsException e) {
            Log.e(TAG, "Unable to import file", e);
            throw e;
-        } catch (IOException e) {
-            Log.e(TAG, "Unable to import file", e);
-            throw new ImportParserException(e);
        }
    }

@@ -227,32 +204,17 @@ public class KmzTrackImporter implements TrackImporter {
        }
    }

-    private List<Track.Id> parseKml(ZipInputStream zipInputStream) {
-        KmlFileTrackImporter kmlFileTrackImporter = new KmlFileTrackImporter(context);
+    private List<Track.Id> parseKml(ZipInputStream zipInputStream) throws IOException {
+        XMLImporter kmlFileTrackImporter = new XMLImporter(new KmlFileTrackImporter(context));

-        try (ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(getKml(zipInputStream))) {
-            return kmlFileTrackImporter.importFile(byteArrayInputStream);
-        } catch (ImportParserException | ImportAlreadyExistsException e) {
-            throw e;
-        } catch (Exception e) {
-            throw new ImportParserException(e);
-        }
-    }
-
-    /**
-     * Gets the kml as byte array.
-     *
-     * @param zipInputStream the zip input stream
-     */
-    private byte[] getKml(ZipInputStream zipInputStream) throws IOException {
-        try (ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()) {
-            byte[] buffer = new byte[BUFFER_SIZE];
-            int count;
-            while ((count = zipInputStream.read(buffer)) != -1) {
-                byteArrayOutputStream.write(buffer, 0, count);
+        InputStream nonClosableInputStream = new FilterInputStream(zipInputStream) {
+            @Override
+            public void close() {
+                // SAX2 always tries close InputStreams; but that would also close our ZIP file.
            }
-            return byteArrayOutputStream.toByteArray();
-        }
+        };
+
+        return kmlFileTrackImporter.importFile(nonClosableInputStream);
    }

    /**
@@ -262,6 +224,7 @@ public class KmzTrackImporter implements TrackImporter {
     * @param trackId        the track's id which image belongs to.
     * @param fileName       the file name
     */
+    @Deprecated //TODO Use JDK9's inputStream.transferTo() instead of manual buffer
    private void readAndSaveImageFile(ZipInputStream zipInputStream, Track.Id trackId, String fileName) throws IOException {
        if (trackId == null || fileName.equals("")) {
            return;
@@ -271,7 +234,7 @@ public class KmzTrackImporter implements TrackImporter {
        File file = new File(dir, fileName);

        try (FileOutputStream fileOutputStream = new FileOutputStream(file)) {
-            byte[] buffer = new byte[BUFFER_SIZE];
+            byte[] buffer = new byte[4096];
            int count;
            while ((count = zipInputStream.read(buffer)) != -1) {
                fileOutputStream.write(buffer, 0, count);
@@ -1,39 +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.io.file.importer;
-
-import androidx.annotation.NonNull;
-
-import java.io.InputStream;
-import java.util.List;
-
-import de.dennisguse.opentracks.content.data.Track;
-
-/**
- * Interface for a track importer.
- *
- * @author Jimmy Shih
- */
-public interface TrackImporter {
-
-    /**
-     * Import a file.
-     *
-     * @param inputStream the file's input stream
-     */
-    @NonNull
-    List<Track.Id> importFile(InputStream inputStream) throws ImportParserException;
-}
@@ -0,0 +1,67 @@
+package de.dennisguse.opentracks.io.file.importer;
+
+import android.content.Context;
+import android.database.sqlite.SQLiteConstraintException;
+import android.net.Uri;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+
+import org.xml.sax.SAXException;
+import org.xml.sax.helpers.DefaultHandler;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.parsers.SAXParserFactory;
+
+import de.dennisguse.opentracks.content.data.Track;
+
+/**
+ * Uses SAX2 to parse XML files.
+ * <p>
+ * NOTE: SAX2 always closes InputStreams after processing.
+ */
+public class XMLImporter {
+
+    private static final String TAG = XMLImporter.class.getSimpleName();
+
+    private final TrackParser parser;
+
+    public XMLImporter(TrackParser parser) {
+        this.parser = parser;
+    }
+
+    @NonNull
+    public List<Track.Id> importFile(Context context, Uri uri) throws ImportParserException, ImportAlreadyExistsException, IOException {
+        try (InputStream inputStream = context.getContentResolver().openInputStream(uri)) {
+            return importFile(inputStream);
+        }
+    }
+
+    public List<Track.Id> importFile(InputStream inputStream) throws ImportParserException, ImportAlreadyExistsException, IOException {
+        try {
+            SAXParserFactory.newInstance().newSAXParser().parse(inputStream, parser.getHandler());
+            return parser.getImportTrackIds();
+        } catch (SAXException | ParserConfigurationException | AbstractFileTrackImporter.ParsingException e) {
+            Log.e(TAG, "Unable to import file", e);
+            if (parser.getImportTrackIds().size() > 0) {
+                parser.cleanImport();
+            }
+            throw new ImportParserException(e);
+        } catch (SQLiteConstraintException e) {
+            Log.e(TAG, "Unable to import file", e);
+            throw new ImportAlreadyExistsException(e);
+        }
+    }
+
+    interface TrackParser {
+        DefaultHandler getHandler();
+
+        List<Track.Id> getImportTrackIds();
+
+        void cleanImport();
+    }
+}
@@ -0,0 +1,171 @@
+package de.dennisguse.opentracks.services;
+
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.Service;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Build;
+import android.os.IBinder;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.core.app.NotificationCompat;
+import androidx.lifecycle.LiveData;
+import androidx.lifecycle.MutableLiveData;
+
+import java.util.ArrayList;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import de.dennisguse.opentracks.R;
+import de.dennisguse.opentracks.content.data.Track;
+import de.dennisguse.opentracks.content.provider.ContentProviderUtils;
+
+public class TrackDeleteService extends Service {
+
+    private static final String CHANNEL_ID = TrackDeleteService.class.getSimpleName();
+    private static final int NOTIFICATION_ID = 1;
+
+    static final String EXTRA_TRACK_IDS = "extra_track_ids";
+
+    private final Binder binder = new Binder();
+    private ExecutorService serviceExecutor;
+    private MutableLiveData<DeleteStatus> deleteResultObservable;
+    private NotificationManager notificationManager;
+    private NotificationCompat.Builder notificationBuilder;
+
+    @Override
+    public void onCreate() {
+        serviceExecutor = Executors.newSingleThreadExecutor();
+        deleteResultObservable = new MutableLiveData<>();
+    }
+
+    @Override
+    public void onDestroy() {
+        super.onDestroy();
+        if (serviceExecutor != null) {
+            serviceExecutor.shutdownNow();
+            serviceExecutor = null;
+        }
+        deleteResultObservable = null;
+    }
+
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        ArrayList<Track.Id> trackIds = intent.getParcelableArrayListExtra(EXTRA_TRACK_IDS);
+        createAndShowNotification(trackIds.size());
+        deleteTracks(trackIds);
+        return START_NOT_STICKY;
+    }
+
+    private void deleteTracks(@NonNull ArrayList<Track.Id> trackIds) {
+        sendResult(null,0, trackIds.size());
+        serviceExecutor.execute(() -> {
+            ContentProviderUtils contentProviderUtils = new ContentProviderUtils(this);
+            for (int i = 0; i < trackIds.size(); i++) {
+                updateNotification(i + 1, trackIds.size());
+                contentProviderUtils.deleteTrack(this, trackIds.get(i));
+                sendResult(trackIds.get(i), i + 1, trackIds.size());
+            }
+            stopSelf();
+        });
+    }
+
+    private void sendResult(Track.Id trackId, int deletes, int total) {
+        if (deleteResultObservable != null) {
+            deleteResultObservable.postValue(new DeleteStatus(trackId, deletes, total));
+        }
+    }
+
+    @Override
+    public IBinder onBind(Intent intent) {
+        return binder;
+    }
+
+    public LiveData<DeleteStatus> getDeletingStatusObservable() {
+        return deleteResultObservable;
+    }
+
+    /**
+     * Starts and shows the notification.
+     *
+     * @param tracksToDelete number of tracks to be deleted.
+     */
+    private void createAndShowNotification(int tracksToDelete) {
+        notificationManager = (NotificationManager) this.getSystemService(Context.NOTIFICATION_SERVICE);
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            NotificationChannel notificationChannel = new NotificationChannel(CHANNEL_ID, this.getString(R.string.app_name), NotificationManager.IMPORTANCE_LOW);
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                notificationChannel.setAllowBubbles(true);
+            }
+
+            notificationManager.createNotificationChannel(notificationChannel);
+        }
+
+        notificationBuilder = new NotificationCompat.Builder(this, CHANNEL_ID);
+        notificationBuilder
+                .setContentTitle(this.getString(R.string.track_delete_progress_message))
+                .setContentText(this.getString(R.string.track_delete_progress, 0, tracksToDelete))
+                .setSmallIcon(R.drawable.ic_logo_color_24dp)
+                .setProgress(tracksToDelete, 0, false);
+
+        startForeground(NOTIFICATION_ID, notificationBuilder.build());
+    }
+
+    /**
+     * Updates notification progress.
+     *
+     * @param progress number of tracks already deleted.
+     * @param total    total of tracks to be deleted.
+     */
+    private void updateNotification(int progress, int total) {
+        notificationBuilder.setProgress(total, progress, false);
+        notificationBuilder.setContentText(this.getString(R.string.track_delete_progress, progress, total));
+        notificationManager.notify(NOTIFICATION_ID, notificationBuilder.build());
+    }
+
+    public class Binder extends android.os.Binder {
+
+        private Binder() {
+            super();
+        }
+
+        public TrackDeleteService getService() {
+            return TrackDeleteService.this;
+        }
+    }
+
+    public static class DeleteStatus {
+        private int progress;
+        private int max;
+        private Track.Id trackId;
+
+        /**
+         * @param trackId  Track.Id just deleted if any.
+         * @param progress number of deletes.
+         * @param max      total of deletes to be done.
+         */
+        private DeleteStatus(@Nullable Track.Id trackId, int progress, int max) {
+            this.trackId = trackId;
+            this.progress = progress;
+            this.max = max;
+        }
+
+        public boolean isFinished() {
+            return progress == max;
+        }
+
+        public boolean isDeleted(Track.Id trackId) {
+            return this.trackId != null && this.trackId.equals(trackId);
+        }
+
+        @Override
+        public String toString() {
+            return "DeleteStatus{" +
+                    "number of deletes=" + progress +
+                    ", total=" + max +
+                    '}';
+        }
+    }
+}
@@ -0,0 +1,70 @@
+package de.dennisguse.opentracks.services;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.os.IBinder;
+
+import androidx.annotation.NonNull;
+
+import java.util.ArrayList;
+
+import de.dennisguse.opentracks.BuildConfig;
+import de.dennisguse.opentracks.content.data.Track;
+
+import static de.dennisguse.opentracks.services.TrackDeleteService.EXTRA_TRACK_IDS;
+
+public class TrackDeleteServiceConnection implements ServiceConnection {
+
+    final private Listener listener;
+    private TrackDeleteService trackDeleteService;
+
+    public TrackDeleteServiceConnection(@NonNull Listener listener) {
+        this.listener = listener;
+    }
+
+    @Override
+    public void onServiceConnected(ComponentName name, IBinder service) {
+        trackDeleteService = ((TrackDeleteService.Binder) service).getService();
+        listener.connected();
+    }
+
+    @Override
+    public void onServiceDisconnected(ComponentName name) {
+        trackDeleteService = null;
+    }
+
+    public void startAndBind(Context context, ArrayList<Track.Id> trackIds) {
+        if (trackDeleteService != null) {
+            return;
+        }
+
+        Intent intent = new Intent(context, TrackDeleteService.class)
+                .putParcelableArrayListExtra(EXTRA_TRACK_IDS, trackIds);
+        context.startService(intent);
+
+        bind(context);
+    }
+
+    public void bind(Context context) {
+        if (trackDeleteService != null) {
+            return;
+        }
+
+        context.bindService(new Intent(context, TrackDeleteService.class), this, BuildConfig.DEBUG ? Context.BIND_DEBUG_UNBIND : 0);
+    }
+
+    public void unbind(Context context) {
+        context.unbindService(this);
+        trackDeleteService = null;
+    }
+
+    public TrackDeleteService getServiceIfBound() {
+        return trackDeleteService;
+    }
+
+    public interface Listener {
+        void connected();
+    }
+}
@@ -33,6 +33,8 @@ import android.util.Log;
 import androidx.annotation.NonNull;
 import androidx.annotation.VisibleForTesting;
 import androidx.core.app.TaskStackBuilder;
+import androidx.lifecycle.LiveData;
+import androidx.lifecycle.MutableLiveData;

 import java.time.Duration;
 import java.time.Instant;
@@ -52,7 +54,7 @@ import de.dennisguse.opentracks.services.handlers.GpsStatusValue;
 import de.dennisguse.opentracks.services.handlers.HandlerServer;
 import de.dennisguse.opentracks.services.sensors.AltitudeSumManager;
 import de.dennisguse.opentracks.services.sensors.BluetoothRemoteSensorManager;
-import de.dennisguse.opentracks.services.tasks.AnnouncementPeriodicTaskFactory;
+import de.dennisguse.opentracks.services.tasks.AnnouncementPeriodicTask;
 import de.dennisguse.opentracks.services.tasks.PeriodicTaskExecutor;
 import de.dennisguse.opentracks.settings.SettingsActivity;
 import de.dennisguse.opentracks.stats.TrackStatistics;
@@ -74,6 +76,9 @@ public class TrackRecordingService extends Service implements HandlerServer.Hand

    private static final String TAG = TrackRecordingService.class.getSimpleName();

+    public static final RecordingStatus STATUS_DEFAULT = new RecordingStatus(null, false);
+    public static final GpsStatusValue STATUS_GPS_DEFAULT = GpsStatusValue.GPS_NONE;
+
    // The following variables are set in onCreate:
    private ContentProviderUtils contentProviderUtils;
    private PeriodicTaskExecutor voiceExecutor;
@@ -119,16 +124,22 @@ public class TrackRecordingService extends Service implements HandlerServer.Hand

    private HandlerServer handlerServer;

-    private final TrackRecordingServiceStatus serviceStatus = new TrackRecordingServiceStatus();
+    private RecordingStatus recordingStatus;
+    private MutableLiveData<RecordingStatus> recordingStatusObservable;
+    private MutableLiveData<GpsStatusValue> gpsStatusObservable;

    @Override
    public void onCreate() {
        super.onCreate();

+        recordingStatusObservable = new MutableLiveData<>();
+        updateRecordingStatus(STATUS_DEFAULT);
+        gpsStatusObservable = new MutableLiveData<>(STATUS_GPS_DEFAULT);
+
        handlerServer = new HandlerServer(this);

        contentProviderUtils = new ContentProviderUtils(this);
-        voiceExecutor = new PeriodicTaskExecutor(this, new AnnouncementPeriodicTaskFactory());
+        voiceExecutor = new PeriodicTaskExecutor(this, new AnnouncementPeriodicTask.Factory());

        notificationManager = new TrackRecordingServiceNotificationManager(this);

@@ -149,8 +160,6 @@ public class TrackRecordingService extends Service implements HandlerServer.Hand

    @Override
    public void onDestroy() {
-        serviceStatus.onStop();
-
        handlerServer.stop(this);
        handlerServer = null;

@@ -181,15 +190,22 @@ public class TrackRecordingService extends Service implements HandlerServer.Hand
        // This should be the next to last operation
        wakeLock = SystemUtils.releaseWakeLock(wakeLock);

+        recordingStatusObservable = null;
+        gpsStatusObservable = null;
+
        super.onDestroy();
    }

    public boolean isRecording() {
-        return serviceStatus.isRecording();
+        return recordingStatus.isRecording();
    }

    public boolean isPaused() {
-        return serviceStatus.getRecordingTrackPaused();
+        return recordingStatus.isPaused();
+    }
+
+    public Track.Id getRecordingTrackId() {
+        return recordingStatus.getTrackId();
    }

    public TrackStatistics getTrackStatistics() {
@@ -219,14 +235,14 @@ public class TrackRecordingService extends Service implements HandlerServer.Hand
        }

        if (name == null) {
-            Integer nextMarkerNumber = contentProviderUtils.getNextMarkerNumber(serviceStatus.getRecordingTrackId());
+            Integer nextMarkerNumber = contentProviderUtils.getNextMarkerNumber(getRecordingTrackId());
            if (nextMarkerNumber == null) {
                nextMarkerNumber = 1;
            }
            name = getString(R.string.marker_name_format, nextMarkerNumber + 1);
        }

-        TrackPoint trackPoint = getLastValidTrackPointInCurrentSegment(serviceStatus.getRecordingTrackId());
+        TrackPoint trackPoint = getLastValidTrackPointInCurrentSegment(getRecordingTrackId());
        if (trackPoint == null) {
            Log.i(TAG, "Could not create a marker as trackPoint is unknown.");
            return null;
@@ -240,7 +256,7 @@ public class TrackRecordingService extends Service implements HandlerServer.Hand
        TrackStatistics stats = trackStatisticsUpdater.getTrackStatistics();

        // Insert marker
-        Marker marker = new Marker(name, description, category, icon, serviceStatus.getRecordingTrackId(), stats, trackPoint, photoUrl);
+        Marker marker = new Marker(name, description, category, icon, getRecordingTrackId(), stats, trackPoint, photoUrl);
        Uri uri = contentProviderUtils.insertMarker(marker);
        return new Marker.Id(ContentUris.parseId(uri));
    }
@@ -252,7 +268,7 @@ public class TrackRecordingService extends Service implements HandlerServer.Hand
     */
    public Track.Id startNewTrack() {
        if (isRecording()) {
-            Log.d(TAG, "Ignore startNewTrack. Already recording.");
+            Log.w(TAG, "Ignore startNewTrack. Already recording.");
            return null;
        }

@@ -262,7 +278,7 @@ public class TrackRecordingService extends Service implements HandlerServer.Hand
        Track.Id trackId = new Track.Id(ContentUris.parseId(uri));

        // Set recording status
-        serviceStatus.onChange(trackId, false);
+        updateRecordingStatus(new RecordingStatus(trackId, false));

        // Update database
        track.setId(trackId);
@@ -304,7 +320,7 @@ public class TrackRecordingService extends Service implements HandlerServer.Hand
        insertTrackPoint(track, TrackPoint.createSegmentStartManual());

        // Set recording status
-        serviceStatus.onChange(trackId, false);
+        updateRecordingStatus(new RecordingStatus(trackId, false));

        startRecording();
    }
@@ -312,15 +328,15 @@ public class TrackRecordingService extends Service implements HandlerServer.Hand
    @VisibleForTesting(otherwise = VisibleForTesting.PACKAGE_PRIVATE)
    public void resumeCurrentTrack() {
        if (!isRecording() || !isPaused()) {
-            Log.d(TAG, "Ignore resumeCurrentTrack. Not recording or not paused.");
+            Log.w(TAG, "Ignore resumeCurrentTrack. Not recording or not paused.");
            return;
        }

        // Set recording status
-        serviceStatus.onChange(false);
+        updateRecordingStatus(new RecordingStatus(getRecordingTrackId(), false));

        // Update database
-        Track track = contentProviderUtils.getTrack(serviceStatus.getRecordingTrackId());
+        Track track = contentProviderUtils.getTrack(getRecordingTrackId());
        if (track != null) {
            insertTrackPoint(track, TrackPoint.createSegmentStartManual());
        }
@@ -361,18 +377,18 @@ public class TrackRecordingService extends Service implements HandlerServer.Hand
    }

    @VisibleForTesting(otherwise = VisibleForTesting.PACKAGE_PRIVATE)
-    public Track.Id endCurrentTrack() {
+    public void endCurrentTrack() {
        if (!isRecording()) {
-            Log.d(TAG, "Ignore endCurrentTrack. Not recording.");
-            return null;
+            Log.w(TAG, "Ignore endCurrentTrack. Not recording.");
+            return;
        }

        // Need to remember the recordingTrackId before setting it to null
        boolean wasPause = isPaused();
-        Track.Id trackId = serviceStatus.getRecordingTrackId();
+        Track.Id trackId = getRecordingTrackId();

        // Set recording status
-        serviceStatus.onChange(null, true);
+        updateRecordingStatus(STATUS_DEFAULT);

        if (!wasPause) {
            // Update database
@@ -390,22 +406,20 @@ public class TrackRecordingService extends Service implements HandlerServer.Hand
        ExportUtils.postWorkoutExport(this, track, new ExportServiceResultReceiver(new Handler(), this));

        endRecording(true);
-
-        return trackId;
    }

    @VisibleForTesting(otherwise = VisibleForTesting.PACKAGE_PRIVATE)
    public void pauseCurrentTrack() {
        if (!isRecording() || isPaused()) {
-            Log.d(TAG, "Ignore pauseCurrentTrack. Not recording or paused.");
+            Log.w(TAG, "Ignore pauseCurrentTrack. Not recording or paused.");
            return;
        }

        // Set recording status
-        serviceStatus.onChange(true);
+        updateRecordingStatus(new RecordingStatus(getRecordingTrackId(), true));

        // Update database
-        Track track = contentProviderUtils.getTrack(serviceStatus.getRecordingTrackId());
+        Track track = contentProviderUtils.getTrack(getRecordingTrackId());
        if (track != null) {
            if (lastTrackPoint != null) {
                insertTrackPointIfNewer(track, lastTrackPoint);
@@ -488,7 +502,7 @@ public class TrackRecordingService extends Service implements HandlerServer.Hand
            return;
        }

-        Track track = contentProviderUtils.getTrack(serviceStatus.getRecordingTrackId());
+        Track track = contentProviderUtils.getTrack(getRecordingTrackId());
        if (track == null) {
            Log.w(TAG, "Ignore newTrackPoint. No track.");
            return;
@@ -562,11 +576,11 @@ public class TrackRecordingService extends Service implements HandlerServer.Hand
    @Override
    public void newGpsStatus(GpsStatusValue gpsStatusValue) {
        notificationManager.updateContent(getString(gpsStatusValue.message));
-        serviceStatus.onChange(gpsStatusValue);
-    }

-    public void addListener(@NonNull TrackRecordingServiceStatus.Listener listener) {
-        serviceStatus.addListener(listener);
+        //TODO This check should not be necessary, but prevents a crash; somehow the shutdown is not working correctly as we should not receive a notification then.
+        if (gpsStatusObservable != null) {
+            gpsStatusObservable.postValue(gpsStatusValue);
+        }
    }

    /**
@@ -658,7 +672,7 @@ public class TrackRecordingService extends Service implements HandlerServer.Hand
    private void showNotification(boolean isGpsStarted) {
        if (isRecording()) {
            Intent intent = IntentUtils.newIntent(this, TrackRecordingActivity.class)
-                    .putExtra(TrackRecordingActivity.EXTRA_TRACK_ID, serviceStatus.getRecordingTrackId());
+                    .putExtra(TrackRecordingActivity.EXTRA_TRACK_ID, getRecordingTrackId());
            PendingIntent pendingIntent = TaskStackBuilder.create(this)
                    .addParentStack(TrackRecordingActivity.class)
                    .addNextIntent(intent)
@@ -694,8 +708,18 @@ public class TrackRecordingService extends Service implements HandlerServer.Hand
        this.altitudeSumManager = altitudeSumManager;
    }

-    public GpsStatusValue getGpsStatus() {
-        return handlerServer.getGpsStatus();
+    public LiveData<GpsStatusValue> getGpsStatusObservable() {
+        return gpsStatusObservable;
+    }
+
+    public LiveData<RecordingStatus> getRecordingStatusObservable() {
+        return recordingStatusObservable;
+    }
+
+    private void updateRecordingStatus(RecordingStatus status) {
+        Log.i(TAG, "new status " + recordingStatus + " -> " + status);
+        recordingStatus = status;
+        recordingStatusObservable.postValue(recordingStatus);
    }

    @Override
@@ -709,6 +733,7 @@ public class TrackRecordingService extends Service implements HandlerServer.Hand
        }
    }

+
    public class Binder extends android.os.Binder {

        private Binder() {
@@ -719,4 +744,52 @@ public class TrackRecordingService extends Service implements HandlerServer.Hand
            return TrackRecordingService.this;
        }
    }
+
+    public static class RecordingStatus {
+        private final Track.Id trackId;
+        private final boolean paused;
+
+        public RecordingStatus(Track.Id trackId, boolean paused) {
+            this.trackId = trackId;
+            this.paused = paused;
+        }
+
+        public Track.Id getTrackId() {
+            return trackId;
+        }
+
+        public boolean isRecording() {
+            return trackId != null;
+        }
+
+        public boolean isPaused() {
+            return paused;
+        }
+
+        public boolean isRecordingAndNotPaused() {
+            return isRecording() && !isPaused();
+        }
+
+//      TODO Use
+//        public RecordingStatus pause() {
+//            return new RecordingStatus(getTrackId(), true);
+//        }
+//
+//        public RecordingStatus record(@NonNull Track.Id trackId) {
+//            return new RecordingStatus(trackId, false);
+//        }
+
+        public RecordingStatus stop() {
+            return STATUS_DEFAULT;
+        }
+
+
+        @Override
+        public String toString() {
+            return "RecordingStatus{" +
+                    "trackId=" + trackId +
+                    ", paused=" + paused +
+                    '}';
+        }
+    }
 }
@@ -1,79 +0,0 @@
-package de.dennisguse.opentracks.services;
-
-import androidx.annotation.NonNull;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import de.dennisguse.opentracks.content.data.Track;
-import de.dennisguse.opentracks.services.handlers.GpsStatusValue;
-
-/**
- * This class handles the status of the recording service.
- * Also offer an interface through which to know the recording Track.Id, pause status and GPS status.
- */
-public class TrackRecordingServiceStatus {
-
-    private Track.Id recordingTrackId;
-    private boolean recordingTrackPaused;
-
-    private final List<Listener> listeners = new ArrayList<>();
-
-    public void addListener(@NonNull Listener listener) {
-        if (this.listeners.contains(listener)) {
-            return;
-        }
-        this.listeners.add(listener);
-        listener.onTrackRecordingId(recordingTrackId);
-        listener.onTrackRecordingPaused(recordingTrackPaused);
-    }
-
-    public boolean getRecordingTrackPaused() {
-        return this.recordingTrackPaused;
-    }
-
-    public Track.Id getRecordingTrackId() {
-        return this.recordingTrackId;
-    }
-
-    public void onStop() {
-        for (Listener listener : listeners) {
-            listener.onGpsStatus(GpsStatusValue.GPS_NONE);
-            listener.onTrackRecordingId(null);
-            listener.onTrackRecordingPaused(true);
-        }
-        listeners.clear();
-    }
-
-    public boolean isRecording() {
-        return recordingTrackId != null;
-    }
-
-    void onChange(Track.Id trackId, boolean paused) {
-        recordingTrackId = trackId;
-        recordingTrackPaused = paused;
-        for (Listener listener : listeners) {
-            listener.onTrackRecordingId(recordingTrackId);
-            listener.onTrackRecordingPaused(recordingTrackPaused);
-        }
-    }
-
-    void onChange(boolean paused) {
-        recordingTrackPaused = paused;
-        for (Listener listener : listeners) {
-            listener.onTrackRecordingPaused(recordingTrackPaused);
-        }
-    }
-
-    void onChange(GpsStatusValue statusValue) {
-        for (Listener listener : listeners) {
-            listener.onGpsStatus(statusValue);
-        }
-    }
-
-    public interface Listener {
-        default void onGpsStatus(GpsStatusValue newValue) {}
-        default void onTrackRecordingPaused(boolean paused) {}
-        default void onTrackRecordingId(Track.Id trackId) {}
-    }
-}
@@ -14,7 +14,7 @@ import de.dennisguse.opentracks.content.data.TrackPoint;
 import de.dennisguse.opentracks.util.PreferencesUtils;

 /**
- * This class handle GPS status according to received locations and some thresholds.
+ * This class handle GPS status according to received locations` and some thresholds.
 */
 //TODO should handle sharedpreference changes
 class GpsStatus {
@@ -56,6 +56,7 @@ class GpsStatus {

        public void stop() {
            stopped = true;
+            sendStatus(gpsStatus, GpsStatusValue.GPS_NONE);
        }
    }

@@ -75,10 +76,15 @@ class GpsStatus {
        gpsStatusHandler = new Handler();
    }

+    public void start() {
+        client.onGpsStatusChanged(GpsStatusValue.GPS_NONE, GpsStatusValue.GPS_ENABLED);
+    }
+
    /**
     * The client that uses GpsStatus has to call this method to stop the Runnable if needed.
     */
    public void stop() {
+        client.onGpsStatusChanged(gpsStatus, GpsStatusValue.GPS_NONE);
        client = null;
        if (gpsStatusRunner != null) {
            gpsStatusRunner.stop();
@@ -20,4 +20,8 @@ public enum GpsStatusValue {
        this.icon = icon;
        this.message = message;
    }
+
+    public boolean isGpsStarted() {
+        return this != GpsStatusValue.GPS_NONE && this != GpsStatusValue.GPS_DISABLED;
+    }
 }
@@ -63,10 +63,6 @@ public class HandlerServer {
        service.newGpsStatus(gpsStatusValue);
    }

-    public GpsStatusValue getGpsStatus() {
-        return locationHandler.getGpsStatus();
-    }
-
    public interface HandlerServerInterface {
        void newTrackPoint(TrackPoint trackPoint, int gpsAccuracy);
        void newGpsStatus(GpsStatusValue gpsStatusValue);
@@ -38,6 +38,7 @@ class LocationHandler implements HandlerServer.Handler, LocationListener, GpsSta
        gpsStatus = new GpsStatus(context, this);
        locationManager = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
        registerLocationListener();
+        gpsStatus.start();
    }

    @Override
@@ -40,7 +40,7 @@ public class AltitudeSumManager implements SensorEventListener {
            Log.w(TAG, "No pressure sensor available.");
            isConnected = false;
        } else {
-            isConnected = sensorManager.registerListener(this, pressureSensor, (int) SAMPLING_RATE.toNanos());
+            isConnected = sensorManager.registerListener(this, pressureSensor, SensorManager.SENSOR_DELAY_FASTEST);
        }

        lastAcceptedPressureValue_hPa = Float.NaN;
@@ -25,6 +25,7 @@ import android.util.Log;
 import java.time.Duration;

 import de.dennisguse.opentracks.R;
+import de.dennisguse.opentracks.content.data.Distance;
 import de.dennisguse.opentracks.content.sensor.SensorData;
 import de.dennisguse.opentracks.content.sensor.SensorDataCycling;
 import de.dennisguse.opentracks.content.sensor.SensorDataSet;
@@ -57,7 +58,7 @@ public class BluetoothRemoteSensorManager implements BluetoothConnectionManager.
    private boolean started = false;

    private final SharedPreferences sharedPreferences;
-    private int preferenceWheelCircumference;
+    private Distance preferenceWheelCircumference;

    private final BluetoothConnectionManager.HeartRate heartRate = new BluetoothConnectionManager.HeartRate(this);
    private final BluetoothConnectionManager.CyclingCadence cyclingCadence = new BluetoothConnectionManager.CyclingCadence(this);
@@ -23,7 +23,10 @@ import android.speech.tts.TextToSpeech;
 import android.speech.tts.UtteranceProgressListener;
 import android.util.Log;

+import androidx.annotation.NonNull;
+
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Locale;

 import de.dennisguse.opentracks.content.data.Distance;
@@ -32,7 +35,6 @@ import de.dennisguse.opentracks.content.data.TrackPoint;
 import de.dennisguse.opentracks.content.provider.ContentProviderUtils;
 import de.dennisguse.opentracks.content.provider.TrackPointIterator;
 import de.dennisguse.opentracks.services.TrackRecordingService;
-import de.dennisguse.opentracks.services.TrackRecordingServiceStatus;
 import de.dennisguse.opentracks.stats.TrackStatistics;
 import de.dennisguse.opentracks.util.AnnouncementUtils;
 import de.dennisguse.opentracks.util.PreferencesUtils;
@@ -58,8 +60,6 @@ public class AnnouncementPeriodicTask implements PeriodicTask {

    private final ContentProviderUtils contentProviderUtils;

-    private Track.Id recordingTrackId;
-
    private final AudioManager.OnAudioFocusChangeListener audioFocusChangeListener = new AudioManager.OnAudioFocusChangeListener() {
        @Override
        public void onAudioFocusChange(int focusChange) {
@@ -137,18 +137,8 @@ public class AnnouncementPeriodicTask implements PeriodicTask {
    }

    @Override
-    public void run(TrackRecordingService trackRecordingService) {
-        if (trackRecordingService == null) {
-            Log.e(TAG, "TrackRecordingService is null.");
-            return;
-        }
-        trackRecordingService.addListener(new TrackRecordingServiceStatus.Listener() {
-            @Override
-            public void onTrackRecordingId(Track.Id trackId) {
-                recordingTrackId = trackId;
-            }
-        });
-        announce(trackRecordingService.getTrackStatistics());
+    public void run(@NonNull TrackRecordingService trackRecordingService) {
+        announce(trackRecordingService.getRecordingTrackId(), trackRecordingService.getTrackStatistics());
    }

    /**
@@ -156,7 +146,7 @@ public class AnnouncementPeriodicTask implements PeriodicTask {
     *
     * @param trackStatistics the track statistics
     */
-    private void announce(TrackStatistics trackStatistics) {
+    private void announce(Track.Id trackId, TrackStatistics trackStatistics) {
        if (trackStatistics == null) {
            Log.e(TAG, "TrackStatistics is null.");
            return;
@@ -175,13 +165,18 @@ public class AnnouncementPeriodicTask implements PeriodicTask {
            }
        }

-        if (audioManager.getMode() == AudioManager.MODE_IN_CALL || audioManager.getMode() == AudioManager.MODE_IN_COMMUNICATION) {
+        if (Arrays.asList(AudioManager.MODE_IN_CALL, AudioManager.MODE_IN_COMMUNICATION)
+                .contains(audioManager.getMode())) {
            Log.i(TAG, "Speech is not allowed at this time.");
            return;
        }

-        Track track = contentProviderUtils.getTrack(recordingTrackId);
-        String category = track != null ? track.getCategory() : "";
+        Track track = contentProviderUtils.getTrack(trackId);
+        if (track == null) {
+            Log.i(TAG, "It doesn't exists a track with trackid = " + track);
+            return;
+        }
+        String category = track.getCategory();

        //TODO Querying all TrackPoints all the time is inefficient; use TrackDataHub or something else.
        TrackPointIterator trackPointIterator = contentProviderUtils.getTrackPointLocationIterator(track.getId(), null);
@@ -233,4 +228,18 @@ public class AnnouncementPeriodicTask implements PeriodicTask {
        // We don't care about the utterance id. It is supplied here to force onUtteranceCompleted to be called.
        tts.speak(announcement, TextToSpeech.QUEUE_FLUSH, null, "not used");
    }
+
+    /**
+     * A {@link PeriodicTaskFactory} for text-to-speech announcement periodic task.
+     *
+     * @author Rodrigo Damazio
+     */
+    public static class Factory implements PeriodicTaskFactory {
+
+        @Override
+        @NonNull
+        public PeriodicTask create(Context context) {
+            return new AnnouncementPeriodicTask(context);
+        }
+    }
 }
@@ -1,31 +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.services.tasks;
-
-import android.content.Context;
-
-/**
- * A {@link PeriodicTaskFactory} for text-to-speech announcement periodic task.
- *
- * @author Rodrigo Damazio
- */
-public class AnnouncementPeriodicTaskFactory implements PeriodicTaskFactory {
-
-    @Override
-    public PeriodicTask create(Context context) {
-        return new AnnouncementPeriodicTask(context);
-    }
-}
@@ -16,6 +16,8 @@

 package de.dennisguse.opentracks.services.tasks;

+import androidx.annotation.NonNull;
+
 import de.dennisguse.opentracks.services.TrackRecordingService;

 /**
@@ -35,7 +37,7 @@ public interface PeriodicTask {
     *
     * @param trackRecordingService the track recording service
     */
-    void run(TrackRecordingService trackRecordingService);
+    void run(@NonNull TrackRecordingService trackRecordingService);

    /**
     * Shuts down this task and clean up resources.
@@ -17,6 +17,9 @@ package de.dennisguse.opentracks.services.tasks;

 import android.util.Log;

+import androidx.annotation.NonNull;
+import androidx.annotation.VisibleForTesting;
+
 import java.time.Duration;

 import de.dennisguse.opentracks.R;
@@ -52,14 +55,13 @@ public class PeriodicTaskExecutor {

    private boolean metricUnits;

-    // The next distance for the distance periodic task
-    private double nextTaskDistance = Double.MAX_VALUE;
+    private Distance nextTaskDistance = Distance.of(Double.MAX_VALUE);

-    public PeriodicTaskExecutor(TrackRecordingService trackRecordingService, PeriodicTaskFactory periodicTaskFactory) {
+    public PeriodicTaskExecutor(@NonNull TrackRecordingService trackRecordingService, PeriodicTaskFactory periodicTaskFactory) {
        this.trackRecordingService = trackRecordingService;
        this.periodicTaskFactory = periodicTaskFactory;

-        TASK_FREQUENCY_OFF = Integer.parseInt(trackRecordingService.getBaseContext().getResources().getString(R.string.frequency_off));
+        TASK_FREQUENCY_OFF = Integer.parseInt(trackRecordingService.getString(R.string.frequency_off));
        taskFrequency = TASK_FREQUENCY_OFF;
    }

@@ -97,7 +99,7 @@ public class PeriodicTaskExecutor {
            timerTaskExecutor.scheduleTask(Duration.ofMinutes(taskFrequency));
        } else {
            // For distance periodic task
-            calculateNextTaskDistance();
+            updateNextTaskDistance();
        }
    }

@@ -128,59 +130,48 @@ public class PeriodicTaskExecutor {
            return;
        }

-        Distance distance = trackStatistics.getTotalDistance();
-
-        if (distance.greaterThan(Distance.of(nextTaskDistance))) {
+        if (trackStatistics.getTotalDistance().greaterThan(nextTaskDistance)) {
            periodicTask.run(trackRecordingService);
-            calculateNextTaskDistance();
+            updateNextTaskDistance();
        }
    }

-    /**
-     * Sets task frequency.
-     *
-     * @param taskFrequency the task frequency
-     */
    public void setTaskFrequency(int taskFrequency) {
        this.taskFrequency = taskFrequency;
        restore();
    }

-    /**
-     * Sets metricUnits.
-     *
-     * @param metricUnits true to use metric units
-     */
    public void setMetricUnits(boolean metricUnits) {
        this.metricUnits = metricUnits;
-        calculateNextTaskDistance();
+        updateNextTaskDistance();
    }

-    /**
-     * Calculates the next distance for the distance periodic task.
-     */
-    private void calculateNextTaskDistance() {
+    private void updateNextTaskDistance() {
        if (!trackRecordingService.isRecording() || trackRecordingService.isPaused() || periodicTask == null) {
            return;
        }

+        if (!isDistanceFrequency()) {
+            nextTaskDistance = Distance.of(Double.MAX_VALUE);
+            Log.d(TAG, "SplitManager: Distance splits disabled.");
+            return;
+        }
+
        TrackStatistics trackStatistics = trackRecordingService.getTrackStatistics();
        if (trackStatistics == null) {
            return;
        }

-        if (!isDistanceFrequency()) {
-            nextTaskDistance = Double.MAX_VALUE;
-            Log.d(TAG, "SplitManager: Distance splits disabled.");
-            return;
-        }
+        nextTaskDistance = calculateNextTaskDistance(trackStatistics);
+    }

-        double distance = trackStatistics.getTotalDistance().to(metricUnits);
+    @VisibleForTesting
+    public Distance calculateNextTaskDistance(TrackStatistics trackStatistics) {
+        Distance distance = trackStatistics.getTotalDistance();

-        // The index will be negative since the frequency is negative.
-        int index = (int) (distance / taskFrequency);
-        index -= 1;
-        nextTaskDistance = taskFrequency * index;
+        Distance announcementInterval = Distance.one(metricUnits).multipliedBy(Math.abs(taskFrequency));
+        int index = (int) (distance.dividedBy(announcementInterval));
+        return announcementInterval.multipliedBy(index + 1);
    }

    /**
@@ -18,6 +18,8 @@ package de.dennisguse.opentracks.services.tasks;

 import android.content.Context;

+import androidx.annotation.NonNull;
+
 /**
 * An interface for classes that can create {@link PeriodicTask}.
 *
@@ -30,5 +32,6 @@ interface PeriodicTaskFactory {
     *
     * @return the task, or null if the task is not supported
     */
+    @NonNull
    PeriodicTask create(Context context);
 }
@@ -3,10 +3,12 @@ package de.dennisguse.opentracks.settings;
 import android.content.Intent;
 import android.content.SharedPreferences;
 import android.os.Bundle;
+import android.speech.tts.TextToSpeech;
 import android.util.Log;
 import android.view.View;
 import android.widget.Toast;

+import androidx.annotation.Nullable;
 import androidx.appcompat.app.AlertDialog;
 import androidx.appcompat.widget.Toolbar;
 import androidx.documentfile.provider.DocumentFile;
@@ -20,12 +22,10 @@ import java.util.Locale;

 import de.dennisguse.opentracks.AbstractActivity;
 import de.dennisguse.opentracks.R;
-import de.dennisguse.opentracks.content.data.Track;
 import de.dennisguse.opentracks.fragments.ChooseActivityTypeDialogFragment;
 import de.dennisguse.opentracks.io.file.TrackFileFormat;
 import de.dennisguse.opentracks.services.TrackRecordingService;
 import de.dennisguse.opentracks.services.TrackRecordingServiceConnection;
-import de.dennisguse.opentracks.services.TrackRecordingServiceStatus;
 import de.dennisguse.opentracks.settings.bluetooth.BluetoothLeCyclingCadenceAndSpeedPreference;
 import de.dennisguse.opentracks.settings.bluetooth.BluetoothLeCyclingPowerPreference;
 import de.dennisguse.opentracks.settings.bluetooth.BluetoothLeHeartRatePreference;
@@ -93,7 +93,10 @@ public class SettingsActivity extends AbstractActivity implements ChooseActivity
        getSupportFragmentManager().beginTransaction().replace(R.id.settings_fragment, prefsFragment).commit();
    }

-    public static class PrefsFragment extends PreferenceFragmentCompat implements TrackRecordingServiceStatus.Listener {
+    public static class PrefsFragment extends PreferenceFragmentCompat {
+
+        private TextToSpeech tts;
+        private int ttsInitStatus;

        private SharedPreferences sharedPreferences;

@@ -107,21 +110,42 @@ public class SettingsActivity extends AbstractActivity implements ChooseActivity
        };

        private TrackRecordingServiceConnection trackRecordingServiceConnection;
-        private boolean isRecording;
+        private TrackRecordingService.RecordingStatus recordingStatus = TrackRecordingService.STATUS_DEFAULT;

        private final Runnable bindServiceCallback = new Runnable() {
            @Override
            public void run() {
                TrackRecordingService service = trackRecordingServiceConnection.getServiceIfBound();
-                if (service != null) {
-                    service.addListener(PrefsFragment.this);
+                if (service == null) {
+                    Log.w(TAG, "could not get TrackRecordingService");
+                    return;
                }
+
+                service.getRecordingStatusObservable()
+                        .observe(PrefsFragment.this, status -> onRecordingStatusChanged(status));
+
            }
        };

        // Used to forward update from ChooseActivityTypeDialogFragment; TODO Could be replaced with LiveData.
        private ActivityTypePreference.ActivityPreferenceDialog activityPreferenceDialog;

+        private Preference voiceAnnouncements;
+
+        @Override
+        public void onCreate(@Nullable Bundle savedInstanceState) {
+            super.onCreate(savedInstanceState);
+            ttsInitStatus = TextToSpeech.ERROR;
+            tts = new TextToSpeech(getContext(), status -> {
+                ttsInitStatus = status;
+                Log.i(TAG, "TextToSpeech initialized with status " + status);
+
+                if (voiceAnnouncements != null) {
+                    updateVoiceAnnouncements();
+                }
+            });
+        }
+
        @Override
        public void onCreatePreferences(Bundle savedInstanceState, String rootKey) {
            sharedPreferences = PreferencesUtils.getSharedPreferences(getContext());
@@ -147,6 +171,9 @@ public class SettingsActivity extends AbstractActivity implements ChooseActivity
                //Use same value for not set as Androidx ListPreference and EditTextPreference
                return directory != null ? directory.getName() : getString(R.string.not_set);
            });
+
+            voiceAnnouncements = findPreference(getString(R.string.voice_frequency_key));
+            updateVoiceAnnouncements();
        }

        @Override
@@ -205,6 +232,8 @@ public class SettingsActivity extends AbstractActivity implements ChooseActivity
            super.onDestroy();
            trackRecordingServiceConnection.unbind(getContext());
            sharedPreferences = null;
+            voiceAnnouncements = null;
+            tts = null;
        }

        public void setDefaultActivity(String iconValue) {
@@ -218,6 +247,7 @@ public class SettingsActivity extends AbstractActivity implements ChooseActivity
            Preference importPreference = findPreference(getString(R.string.settings_import));
            Preference exportPreference = findPreference(getString(R.string.settings_export));

+            boolean isRecording = recordingStatus.isRecording();
            resetPreference.setSummary(isRecording ? getString(R.string.settings_not_while_recording) : "");
            importPreference.setSummary(isRecording ? getString(R.string.settings_not_while_recording) : "");
            exportPreference.setSummary(isRecording ? getString(R.string.settings_not_while_recording) : "");
@@ -292,13 +322,15 @@ public class SettingsActivity extends AbstractActivity implements ChooseActivity
            });
        }

-        @Override
-        public void onTrackRecordingId(Track.Id trackId) {
-            if (trackId != null && !isRecording && isAdded()) {
-                isRecording = true;
+        private void updateVoiceAnnouncements() {
+            voiceAnnouncements.setEnabled(ttsInitStatus == TextToSpeech.SUCCESS);
+        }
+
+        private void onRecordingStatusChanged(TrackRecordingService.RecordingStatus status) {
+            this.recordingStatus = status;
+            if (!status.isRecording() && isAdded()) {
                updatePrefsDependOnRecording();
            }
        }
    }
-
 }
@@ -18,6 +18,7 @@ package de.dennisguse.opentracks.stats;

 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;

 import java.time.Duration;
 import java.time.Instant;
@@ -193,6 +194,7 @@ public class TrackStatistics {
        this.movingTime = movingTime;
    }

+    @VisibleForTesting(otherwise = VisibleForTesting.PACKAGE_PRIVATE)
    public void addMovingTime(Duration time) {
        movingTime = movingTime.plus(time);
    }
@@ -265,6 +267,7 @@ public class TrackStatistics {
        this.totalAltitudeGain_m = totalAltitudeGain_m;
    }

+    @VisibleForTesting(otherwise = VisibleForTesting.PACKAGE_PRIVATE)
    public void addTotalAltitudeGain(float gain_m) {
        if (totalAltitudeGain_m == null) {
            totalAltitudeGain_m = 0f;
@@ -285,6 +288,7 @@ public class TrackStatistics {
        this.totalAltitudeLoss_m = totalAltitudeLoss_m;
    }

+    @VisibleForTesting(otherwise = VisibleForTesting.PACKAGE_PRIVATE)
    public void addTotalAltitudeLoss(float loss_m) {
        if (totalAltitudeLoss_m == null) {
            totalAltitudeLoss_m = 0f;
@@ -106,7 +106,7 @@ public class TrackStatisticsUpdater {
     */
    public void addTrackPoint(TrackPoint trackPoint, Distance minGPSDistance) {
        internalAddTrackPoint(trackPoint, minGPSDistance);
-        Log.d(TAG, this.toString());
+        Log.v(TAG, this.toString());
    }

    private void internalAddTrackPoint(TrackPoint trackPoint, Distance minGPSDistance) {
@@ -148,7 +148,7 @@ public class TrackStatisticsUpdater {

        //Update absolute (GPS-based) altitude
        if (trackPoint.hasAltitude()) {
-            updateAbsoluteAltitude(trackPoint.getAltitude());
+            updateAbsoluteAltitude(trackPoint.getAltitude().toM());
        }

        if (lastTrackPoint == null || lastMovingTrackPoint == null) {
@@ -159,7 +159,7 @@ public class TrackStatisticsUpdater {

        if (!trackPoint.hasSensorDistance()) {
            // GPS-based distance/speed
-            Distance movingDistance = lastMovingTrackPoint.distanceToPrevious(trackPoint);
+            Distance movingDistance = trackPoint.distanceToPrevious(lastMovingTrackPoint);
            if (movingDistance.lessThan(minGPSDistance) && !trackPoint.isMoving()) {
                speedBuffer_mps.reset();
                lastTrackPoint = trackPoint;
@@ -23,7 +23,6 @@ import java.util.ArrayList;

 import de.dennisguse.opentracks.ContextualActionModeCallback;
 import de.dennisguse.opentracks.R;
-import de.dennisguse.opentracks.TrackController;

 import static android.content.Context.VIBRATOR_SERVICE;

@@ -88,7 +87,7 @@ public class ActivityUtils {
        });
    }

-    public static void configureSearchWidget(Activity activity, final MenuItem menuItem, final TrackController trackController) {
+    public static SearchView configureSearchWidget(Activity activity, final MenuItem menuItem) {
        final SearchView searchView = (SearchView) menuItem.getActionView();
        SearchManager searchManager = (SearchManager) activity.getSystemService(Context.SEARCH_SERVICE);
        if (searchManager != null) {
@@ -97,47 +96,12 @@ public class ActivityUtils {
        } else {
            Log.w(TAG, "Could not retrieve SearchManager.");
        }
-        searchView.setQueryRefinementEnabled(true);
        searchView.setSubmitButtonEnabled(true);
-        searchView.setOnQueryTextFocusChangeListener((v, hasFocus) -> {
-            // Hide and show trackController when searchable widget has focus/no focus
-            if (trackController != null) {
-                if (hasFocus) {
-                    trackController.hide();
-                } else {
-                    trackController.show();
-                }
-            }
-        });
-
-        searchView.setOnQueryTextListener(new SearchView.OnQueryTextListener() {
-            @Override
-            public boolean onQueryTextSubmit(String query) {
-                menuItem.collapseActionView();
-                return false;
-            }
-
-            @Override
-            public boolean onQueryTextChange(String newText) {
-                return false;
-            }
-        });
-        searchView.setOnSuggestionListener(new SearchView.OnSuggestionListener() {
-            @Override
-            public boolean onSuggestionSelect(int position) {
-                return false;
-            }
-
-            @Override
-            public boolean onSuggestionClick(int position) {
-                menuItem.collapseActionView();
-                return false;
-            }
-        });
+        return searchView;
    }

-    public static void vibrate(Activity activity, int milliseconds) {
-        final Vibrator vibrator = (Vibrator) activity.getSystemService(VIBRATOR_SERVICE);
+    public static void vibrate(Context context, int milliseconds) {
+        final Vibrator vibrator = (Vibrator) context.getSystemService(VIBRATOR_SERVICE);
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            vibrator.vibrate(VibrationEffect.createOneShot(milliseconds, VibrationEffect.DEFAULT_AMPLITUDE));
        } else {
@@ -43,13 +43,13 @@ public class AnnouncementUtils {
            int paceId = isMetricUnits ? R.string.voice_pace_per_kilometer : R.string.voice_pace_per_mile;
            rate = context.getString(paceId, getAnnounceTime(context, time));

-            Duration currentTime = currentDistancePerTime.toPace(isMetricUnits);
+            Duration currentTime = currentDistancePerTime != null ? currentDistancePerTime.toPace(isMetricUnits) : Duration.ofMillis(0);
            currentRate = context.getString(paceId, getAnnounceTime(context, currentTime));
            currentRateMsg = context.getString(R.string.voice_pace_lap, currentRate);
        }

        int totalDistanceId = isMetricUnits ? R.plurals.voiceTotalDistanceKilometers : R.plurals.voiceTotalDistanceMiles;
-        double distanceInUnit = distance.to(isMetricUnits);
+        double distanceInUnit = distance.toKM_Miles(isMetricUnits);
        String totalDistance = context.getResources().getQuantityString(totalDistanceId, getQuantityCount(distanceInUnit), distanceInUnit);

        currentRateMsg = currentInterval == null ? "" : " " + currentRateMsg;
@@ -0,0 +1,176 @@
+package de.dennisguse.opentracks.util;
+
+import android.content.Context;
+import android.location.Location;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.VisibleForTesting;
+
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.util.Objects;
+
+import de.dennisguse.opentracks.R;
+
+/**
+ * Converts WGS84 altitude to EGM2008 (should be close to height above sea level).
+ * <p>
+ * Uses <a href="https://geographiclib.sourceforge.io/">GeographicLib</a>] EGM2008 5minute undulation data.
+ * https://geographiclib.sourceforge.io/html/geoid.html
+ * <p>
+ * File starts at 90N, 0E (North pole) and is encoded in parallel bands as unsigned shorts.
+ */
+public class EGM2008Utils {
+
+    static final int EGM2008_5_DATA = R.raw.egm2008_5;
+
+    private static final int HEADER_LENGTH = 404;
+
+    private static final int RESOLUTION_IN_MINUTES = 60 / 5;
+
+    private static final int LATITUDE_CORRECTION = 360 * RESOLUTION_IN_MINUTES;
+
+    private EGM2008Utils() {
+    }
+
+    public static EGM2008Correction createCorrection(Context context, Location location) throws IOException {
+        Indices indices = getIndices(location);
+
+        try (DataInputStream dataInputStream = new DataInputStream(context.getResources().openRawResource(EGM2008_5_DATA))) {
+            return new EGM2008Correction(indices, dataInputStream);
+        }
+    }
+
+    @VisibleForTesting
+    static int getUndulationRaw(DataInputStream dataInputStream, Indices indices) throws IOException {
+        dataInputStream.reset();
+        int absoluteIndex = indices.getAbsoluteIndex();
+        return getUndulationRaw(dataInputStream, absoluteIndex);
+    }
+
+    private static int getUndulationRaw(DataInputStream dataInputStream, int undulationIndex) throws IOException {
+        dataInputStream.reset();
+        int index = HEADER_LENGTH + undulationIndex * 2;  //byte size is 2
+        long ignored = dataInputStream.skip(index);
+
+        return dataInputStream.readUnsignedShort();
+    }
+
+    @VisibleForTesting
+    static Indices getIndices(Location location) {
+        double latitude = -location.getLatitude() + 90;
+        int latitudeIndex = (int) (latitude * RESOLUTION_IN_MINUTES);
+
+        double longitude;
+        if (location.getLongitude() >= 0) {
+            longitude = location.getLongitude();
+        } else {
+            longitude = 180 + Math.abs(location.getLongitude());
+        }
+        int longitudeIndex = (int) (longitude * RESOLUTION_IN_MINUTES);
+
+        if (longitudeIndex >= 360 * RESOLUTION_IN_MINUTES) {
+            longitudeIndex = 0;
+        }
+        return new Indices(latitudeIndex, longitudeIndex);
+    }
+
+    public static class EGM2008Correction {
+
+        protected final Indices indices;
+
+        protected final int v00;
+        protected final int v10;
+        protected final int v01;
+        protected final int v11;
+
+        private EGM2008Correction(Indices indices, DataInputStream dataInputStream) throws IOException {
+            this.indices = indices;
+
+            v00 = getUndulationRaw(dataInputStream, indices);
+            if (!isSouthPole()) {
+                v10 = getUndulationRaw(dataInputStream, indices.offset(0, 1));
+                v01 = getUndulationRaw(dataInputStream, indices.offset(1, 0));
+                v11 = getUndulationRaw(dataInputStream, indices.offset(1, 1));
+            } else {
+                v10 = 0;
+                v01 = 0;
+                v11 = 0;
+            }
+        }
+
+        public boolean canCorrect(@NonNull Location location) {
+            return indices.getAbsoluteIndex() == getIndices(location).getAbsoluteIndex();
+        }
+
+        public double correctAltitude(@NonNull Location location) {
+            if (!canCorrect(location))
+                throw new RuntimeException("Undulation data not loaded for this location.");
+            if (!location.hasAltitude())
+                throw new RuntimeException("Location has no altitude");
+
+            double undulationRaw;
+            if (isSouthPole()) {
+                // No bilinear interpolation on South Pole (not worth the time)
+                undulationRaw = v00;
+            } else {
+                double fLongitude = location.getLongitude() * RESOLUTION_IN_MINUTES -
+                        (int) (location.getLongitude() * RESOLUTION_IN_MINUTES);
+
+                double fLatitude = (-location.getLatitude() + 90) * RESOLUTION_IN_MINUTES
+                        - (int) ((-location.getLatitude() + 90) * RESOLUTION_IN_MINUTES);
+
+                // Bilinear interpolation (optimized; taken from GeopgrahicLib/Geoid.cpp)
+                double
+                        a = (1 - fLongitude) * v00 + fLongitude * v01,
+                        b = (1 - fLongitude) * v10 + fLongitude * v11;
+                undulationRaw = (1 - fLatitude) * a + fLatitude * b;
+            }
+            // Bilinear interpolation (not optimized)
+            //undulationRaw = v00 * (1 - fLongitude) * (1 - fLatitude)
+            //        + v10 * fLongitude * (1 - fLatitude)
+            //        + v01 * (1 - fLongitude) * fLatitude
+            //        + v11 * fLongitude * fLatitude;
+
+            double h = 0.003 * undulationRaw - 108;
+
+            return location.getAltitude() - h;
+        }
+
+        private boolean isSouthPole() {
+            return indices.latitudeIndex == 2160;
+        }
+    }
+
+    @VisibleForTesting
+    static class Indices {
+        final int latitudeIndex;
+        final int longitudeIndex;
+
+        Indices(int latitudeIndex, int longitudeIndex) {
+            this.latitudeIndex = latitudeIndex;
+            this.longitudeIndex = longitudeIndex;
+        }
+
+        Indices offset(int latitudeOffset, int longitudeOffset) {
+            return new Indices(latitudeIndex + latitudeOffset, longitudeIndex + longitudeOffset);
+        }
+
+        int getAbsoluteIndex() {
+            return latitudeIndex * LATITUDE_CORRECTION + longitudeIndex;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (o == null || getClass() != o.getClass()) return false;
+            Indices indices = (Indices) o;
+            return latitudeIndex == indices.latitudeIndex &&
+                    longitudeIndex == indices.longitudeIndex;
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(latitudeIndex, longitudeIndex);
+        }
+    }
+}
@@ -142,9 +142,9 @@ public class PreferencesUtils {
        return getString(sharedPreferences, context, R.string.settings_sensor_bluetooth_cycling_speed_key, getBluetoothSensorAddressNone(context));
    }

-    public static int getWheelCircumference(SharedPreferences sharedPreferences, Context context) {
+    public static Distance getWheelCircumference(SharedPreferences sharedPreferences, Context context) {
        final int DEFAULT = Integer.parseInt(context.getResources().getString(R.string.settings_sensor_bluetooth_cycling_speed_wheel_circumference_default));
-        return getInt(sharedPreferences, context, R.string.settings_sensor_bluetooth_cycling_speed_wheel_circumference_key, DEFAULT);
+        return Distance.ofMM(getInt(sharedPreferences, context, R.string.settings_sensor_bluetooth_cycling_speed_wheel_circumference_key, DEFAULT));
    }

    public static String getBluetoothCyclingPowerSensorAddress(SharedPreferences sharedPreferences, Context context) {
@@ -35,7 +35,7 @@ public class IntervalStatisticsModel extends AndroidViewModel {
                }

                intervalsLiveData = new MutableLiveData<>();
-                distanceInterval = interval.getValue();
+                distanceInterval = interval.getDistance(metricUnits);
                loadIntervalStatistics();
            }
            return intervalsLiveData;
@@ -73,7 +73,7 @@ public class IntervalStatisticsModel extends AndroidViewModel {
                interval = IntervalOption.OPTION_1;
            }

-            distanceInterval = interval.getValue();
+            distanceInterval = interval.getDistance(metricUnits);
            loadIntervalStatistics();
        }
    }
@@ -91,19 +91,21 @@ public class IntervalStatisticsModel extends AndroidViewModel {
        OPTION_20(20),
        OPTION_50(50);

-        private final Distance value;
+        private final int multiplier;

-        IntervalOption(int value) {
-            this.value = Distance.of(value);
+        IntervalOption(int multiplier) {
+            this.multiplier = multiplier;
        }

-        public Distance getValue() {
-            return value;
+        public Distance getDistance(boolean metricUnits) {
+            return Distance
+                    .one(metricUnits)
+                    .multipliedBy(multiplier);
        }

        @Override
        public String toString() {
-            return "" + (int) value.toM(); //TODO Somehow IntervalsFragment relies on a parsable Integer.
+            return "" + multiplier; //TODO Somehow IntervalsFragment relies on a parsable Integer.
        }
    }
 }
@@ -0,0 +1,66 @@
+<?xml version="1.0" encoding="utf-8"?><!--
+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.
+-->
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/controller_container"
+    android:layout_width="wrap_content"
+    android:layout_height="match_parent"
+    android:background="@drawable/controller_background"
+    android:orientation="vertical"
+    android:paddingStart="8dp"
+    android:paddingEnd="8dp">
+
+    <ImageButton
+        android:id="@+id/controller_record"
+        android:layout_width="wrap_content"
+        android:layout_height="0dp"
+        android:layout_weight="10"
+        android:background="@android:color/transparent"
+        android:contentDescription="@string/image_record"
+        android:src="@drawable/ic_button_record" />
+
+    <RelativeLayout
+        android:layout_width="match_parent"
+        android:layout_height="0dp"
+        android:layout_weight="6">
+
+        <TextView
+            android:id="@+id/controller_total_time"
+            style="@style/TextSmall"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_centerInParent="true"
+            android:textColor="@android:color/white" />
+
+        <TextView
+            android:id="@+id/controller_status"
+            style="@style/TextMicro"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_above="@id/controller_total_time"
+            android:layout_centerHorizontal="true"
+            android:singleLine="true" />
+    </RelativeLayout>
+
+    <ImageButton
+        android:id="@+id/controller_stop"
+        android:layout_width="match_parent"
+        android:layout_height="0dp"
+        android:layout_weight="10"
+        android:background="@android:color/transparent"
+        android:contentDescription="@string/image_stop"
+        android:src="@drawable/button_stop" />
+
+</LinearLayout>
@@ -1,69 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?><!--
-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.
-->
-<merge xmlns:android="http://schemas.android.com/apk/res/android">
-
-    <LinearLayout
-        android:id="@+id/track_controller_container"
-        android:layout_width="wrap_content"
-        android:layout_height="match_parent"
-        android:background="@drawable/track_controller_background"
-        android:orientation="vertical"
-        android:paddingStart="8dp"
-        android:paddingEnd="8dp">
-
-        <ImageButton
-            android:id="@+id/track_controller_record"
-            android:layout_width="wrap_content"
-            android:layout_height="0dp"
-            android:layout_weight="10"
-            android:background="@android:color/transparent"
-            android:contentDescription="@string/image_record"
-            android:src="@drawable/ic_button_record" />
-
-        <RelativeLayout
-            android:layout_width="match_parent"
-            android:layout_height="0dp"
-            android:layout_weight="6">
-
-            <TextView
-                android:id="@+id/track_controller_total_time"
-                style="@style/TextSmall"
-                android:layout_width="wrap_content"
-                android:layout_height="wrap_content"
-                android:layout_centerInParent="true"
-                android:textColor="@android:color/white" />
-
-            <TextView
-                android:id="@+id/track_controller_status"
-                style="@style/TextMicro"
-                android:layout_width="wrap_content"
-                android:layout_height="wrap_content"
-                android:layout_above="@id/track_controller_total_time"
-                android:layout_centerHorizontal="true"
-                android:singleLine="true" />
-        </RelativeLayout>
-
-        <ImageButton
-            android:id="@+id/track_controller_stop"
-            android:layout_width="match_parent"
-            android:layout_height="0dp"
-            android:layout_weight="10"
-            android:background="@android:color/transparent"
-            android:contentDescription="@string/image_stop"
-            android:src="@drawable/button_stop" />
-
-    </LinearLayout>
-</merge>
@@ -27,9 +27,11 @@ limitations under the License.
        android:baselineAligned="false"
        android:orientation="horizontal">

-        <include
-            android:id="@+id/track_controller_container"
-            layout="@layout/track_controller" />
+        <androidx.fragment.app.FragmentContainerView
+            android:id="@+id/controller_fragment"
+            android:name="de.dennisguse.opentracks.ControllerFragment"
+            android:layout_width="wrap_content"
+            android:layout_height="match_parent" />

        <ListView
            android:id="@+id/track_list"
@@ -11,9 +11,11 @@
        android:layout_height="match_parent"
        android:orientation="horizontal">

-        <include
-            android:id="@+id/track_controller_container"
-            layout="@layout/track_controller" />
+        <androidx.fragment.app.FragmentContainerView
+            android:id="@+id/controller_fragment"
+            android:name="de.dennisguse.opentracks.ControllerFragment"
+            android:layout_width="wrap_content"
+            android:layout_height="match_parent" />

        <LinearLayout
            android:layout_width="match_parent"
@@ -16,31 +16,28 @@
            android:orientation="vertical"
            android:padding="20dp">

-            <ImageView
-                android:id="@+id/imageView"
-                android:layout_width="match_parent"
-                android:layout_height="239dp"
-                android:contentDescription="@string/app_name"
-                android:scaleType="fitCenter"
-                android:src="@drawable/ic_logo_color_24dp" />
-
-            <TextView
-                style="@style/TextLarge"
+            <LinearLayout
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
-                android:gravity="center"
-                android:text="@string/app_name"
-                android:textSize="24sp" />
+                android:orientation="horizontal"
+                android:layout_margin="8dp">

-            <View style="@style/StatsHorizontalLine" />
+                <ImageView
+                    android:id="@+id/imageView"
+                    android:layout_width="30dp"
+                    android:layout_height="match_parent"
+                    android:contentDescription="@string/app_name"
+                    android:scaleType="fitCenter"
+                    android:src="@drawable/ic_logo_color_24dp" />

-            <TextView
-                android:id="@+id/about_text_description"
-                style="@style/TextMedium"
-                android:layout_width="match_parent"
-                android:layout_height="wrap_content"
-                android:gravity="center"
-                android:padding="12dp" />
+                <TextView
+                    android:id="@+id/about_text_description"
+                    style="@style/TextMedium"
+                    android:layout_width="match_parent"
+                    android:layout_height="match_parent"
+                    android:gravity="center"
+                    android:padding="12dp" />
+            </LinearLayout>

            <View style="@style/StatsHorizontalLine" />

@@ -74,12 +71,28 @@
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:gravity="center"
-                android:padding="6dp"
                android:linksClickable="true"
+                android:padding="6dp"
                android:text="@string/about_history" />

            <View style="@style/StatsHorizontalLine" />

+            <TextView
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:gravity="center"
+                android:padding="12dp"
+                android:text="@string/about_third_party_data" />
+
+            <TextView
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:gravity="center"
+                android:padding="12dp"
+                android:text="@string/third_party_data" />
+
+            <View style="@style/StatsHorizontalLine" />
+
            <TextView
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
@@ -0,0 +1,72 @@
+<?xml version="1.0" encoding="utf-8"?><!--
+Copyright 2012 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.
+-->
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:id="@+id/controller_container"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:background="@drawable/controller_background"
+    android:paddingTop="8dp"
+    android:paddingBottom="8dp">
+
+    <ImageButton
+        android:id="@+id/controller_record"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_weight="10"
+        android:background="@android:color/transparent"
+        android:contentDescription="@string/image_record"
+        android:src="@drawable/ic_button_record" />
+
+    <RelativeLayout
+        android:layout_width="0dp"
+        android:layout_height="match_parent"
+        android:layout_gravity="center"
+        android:layout_weight="6">
+
+        <TextView
+            android:id="@+id/controller_total_time"
+            style="@style/TextSmall"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_alignParentStart="true"
+            android:layout_centerVertical="true"
+            android:gravity="center"
+            android:textColor="@android:color/white"
+            tools:text="0:12:34" />
+
+        <TextView
+            android:id="@+id/controller_status"
+            style="@style/TextMicro"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_above="@id/controller_total_time"
+            android:layout_alignParentStart="true"
+            android:gravity="center"
+            android:singleLine="true"
+            tools:text="@string/generic_recording" />
+    </RelativeLayout>
+
+    <ImageButton
+        android:id="@+id/controller_stop"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_weight="10"
+        android:background="@android:color/transparent"
+        android:contentDescription="@string/image_stop"
+        android:src="@drawable/button_stop" />
+
+</LinearLayout>
--- a/Show More
+++ b/Show More