Rebranding to OpenTracks (code).

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

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2009 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;
+
+/**
+ * This is a simple location listener policy that will always dictate the same
+ * polling interval.
+ *
+ * @author Sandor Dornbush
+ */
+public class AbsoluteLocationListenerPolicy implements LocationListenerPolicy {
+
+    private final long interval;
+
+    /**
+     * Constructor.
+     *
+     * @param interval the interval to request for gps signal
+     */
+    public AbsoluteLocationListenerPolicy(long interval) {
+        this.interval = interval;
+    }
+
+    @Override
+    public long getDesiredPollingInterval() {
+        return interval;
+    }
+
+    @Override
+    public int getMinDistance() {
+        return 0;
+    }
+
+    @Override
+    public void updateIdleTime(long idleTime) {
+        // Ignore
+    }
+}

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

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009 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;
+
+/**
+ * A {@link LocationListenerPolicy} that will change based on how long the user
+ * has been stationary. This policy will dictate a policy based on a min, max
+ * and idle time. The policy will dictate an interval bounded by min and max,
+ * and is half of the idle time.
+ *
+ * @author Sandor Dornbush
+ */
+public class AdaptiveLocationListenerPolicy implements LocationListenerPolicy {
+
+    private final long minInterval;
+    private final long maxInterval;
+    private final int minDistance;
+
+    // The time the user has been idle at the current location, in milliseconds.
+    private long idleTime;
+
+    /**
+     * Creates a policy that will be bounded by the given minInterval and
+     * maxInterval.
+     *
+     * @param minInterval the smallest interval this policy will dictate, in
+     *                    milliseconds
+     * @param maxInterval the largest interval this policy will dictate, in
+     *                    milliseconds
+     * @param minDistance the minimum distance in meters
+     */
+    public AdaptiveLocationListenerPolicy(long minInterval, long maxInterval, int minDistance) {
+        this.minInterval = minInterval;
+        this.maxInterval = maxInterval;
+        this.minDistance = minDistance;
+    }
+
+    /*
+     * Returns an interval half of the idle time, but bounded by minInteval and
+     * maxInterval.
+     */
+    @Override
+    public long getDesiredPollingInterval() {
+        long desiredInterval = idleTime / 2;
+        // Round to second to avoid setting the interval too often
+        desiredInterval = (desiredInterval / 1000) * 1000;
+        return Math.max(Math.min(maxInterval, desiredInterval), minInterval);
+    }
+
+    @Override
+    public int getMinDistance() {
+        return minDistance;
+    }
+
+    @Override
+    public void updateIdleTime(long newIdleTime) {
+        idleTime = newIdleTime;
+    }
+}

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

@@ -0,0 +1,133 @@
+/*
+ * Copyright 2011 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;
+
+import android.app.IntentService;
+import android.content.ComponentName;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.os.IBinder;
+
+import androidx.annotation.VisibleForTesting;
+
+import de.dennisguse.opentracks.widgets.TrackWidgetProvider;
+import de.dennisguse.opentracks.R;
+
+/**
+ * A service to control starting and stopping of a recording. This service,
+ * through the AndroidManifest.xml, is configured to only allow components of
+ * the same application to invoke it. Thus this service can be used my the
+ * app widget, {@link TrackWidgetProvider}, but not by other applications. This
+ * application delegates starting and stopping a recording to
+ * {@link TrackRecordingService} using RPC calls.
+ *
+ * @author Jimmy Shih
+ */
+public class ControlRecordingService extends IntentService implements ServiceConnection {
+
+    private static final String TAG = ControlRecordingService.class.getSimpleName();
+
+    private ITrackRecordingService trackRecordingService;
+    private boolean connected = false;
+
+    public ControlRecordingService() {
+        super(ControlRecordingService.class.getSimpleName());
+    }
+
+    @Override
+    public void onCreate() {
+        super.onCreate();
+
+        Intent newIntent = new Intent(this, TrackRecordingService.class);
+        startService(newIntent);
+        bindService(newIntent, this, 0);
+    }
+
+    @Override
+    public void onServiceConnected(ComponentName name, IBinder service) {
+        trackRecordingService = (ITrackRecordingService) service;
+        notifyConnected();
+    }
+
+    @Override
+    public void onServiceDisconnected(ComponentName name) {
+        connected = false;
+    }
+
+    /**
+     * Notifies all threads that connection to {@link TrackRecordingService} is
+     * available.
+     */
+    private synchronized void notifyConnected() {
+        connected = true;
+        notifyAll();
+    }
+
+    /**
+     * Waits until the connection to {@link TrackRecordingService} is available.
+     */
+    private synchronized void waitConnected() {
+        while (!connected) {
+            try {
+                wait();
+            } catch (InterruptedException e) {
+
+                // can safely ignore
+            }
+        }
+    }
+
+    @Override
+    protected void onHandleIntent(Intent intent) {
+        waitConnected();
+        onHandleIntent(intent, trackRecordingService);
+    }
+
+
+    /**
+     * Handles the intent to start or stop a recording.
+     *
+     * @param intent  to be handled
+     * @param service the trackRecordingService
+     */
+    @VisibleForTesting
+    void onHandleIntent(Intent intent, ITrackRecordingService service) {
+        String action = intent.getAction();
+        if (action != null) {
+            if (action.equals(getString(R.string.track_action_start))) {
+                service.startNewTrack();
+            } else if (action.equals(getString(R.string.track_action_end))) {
+                service.endCurrentTrack();
+            } else if (action.equals(getString(R.string.track_action_pause))) {
+                service.pauseCurrentTrack();
+            } else if (action.equals(getString(R.string.track_action_resume))) {
+                service.resumeCurrentTrack();
+            }
+        }
+        unbindService(this);
+        connected = false;
+    }
+
+    @Override
+    public void onDestroy() {
+        super.onDestroy();
+        if (connected) {
+            unbindService(this);
+            connected = false;
+        }
+    }
+}

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

@@ -0,0 +1,113 @@
+/*
+ * Copyright 2008 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package de.dennisguse.opentracks.services;
+
+import android.location.Location;
+
+import de.dennisguse.opentracks.content.WaypointCreationRequest;
+import de.dennisguse.opentracks.content.sensor.SensorDataSet;
+import de.dennisguse.opentracks.content.sensor.SensorState;
+
+/**
+ * App's service.
+ * This service is the process that actually records and manages tracks.
+ */
+public interface ITrackRecordingService {
+
+    /**
+     * Starts gps.
+     */
+    void startGps();
+
+    /**
+     * Stops gps.
+     */
+    void stopGps();
+
+    /**
+     * Starts recording a new track.
+     *
+     * @return the track ID of the new track.
+     */
+    long startNewTrack();
+
+    /**
+     * Pauses the current recording track.
+     */
+    void pauseCurrentTrack();
+
+    /**
+     * Resumes the current recording track.
+     */
+    void resumeCurrentTrack();
+
+    /**
+     * Ends the current recording track.
+     */
+    void endCurrentTrack();
+
+    /**
+     * Returns true if currently recording a track.
+     */
+    boolean isRecording();
+
+    /**
+     * Returns true if the current recording track is paused. Returns true if not recording.
+     */
+    boolean isPaused();
+
+    /**
+     * Gets the current recording track ID. Returns -1 if not recording.
+     */
+    long getRecordingTrackId();
+
+    /**
+     * Gets the total time for the current recording track. Returns 0 if not recording.
+     */
+    long getTotalTime();
+
+    /**
+     * Inserts a waypoint in the current recording track.
+     *
+     * @param request the details of the waypoint to be inserted
+     * @return the ID of the inserted waypoint
+     */
+    long insertWaypoint(WaypointCreationRequest request);
+
+    /**
+     * Inserts a track point in the current recording track.
+     * <p>
+     * When recording a track, GPS locations are automatically inserted. This is used for
+     * inserting special track points or for testing.
+     *
+     * @param location the track point to be inserted
+     */
+    void insertTrackPoint(Location location);
+
+    /**
+     * Gets the current sensor data. Returns null if there is no data.
+     *
+     * @return SensorDataSet object.
+     */
+    SensorDataSet getSensorData();
+
+    /**
+     * Gets the current sensor manager state.
+     * <p>
+     * return a Sensor.SensorState enum value.
+     */
+    SensorState getSensorState();
+}

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

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2009 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;
+
+/**
+ * This is an interface for classes that will manage the location listener
+ * policy. Different policy options are: {@link AbsoluteLocationListenerPolicy}
+ * and {@link AdaptiveLocationListenerPolicy}.
+ *
+ * @author Sandor Dornbush
+ */
+public interface LocationListenerPolicy {
+
+    /**
+     * Returns the polling interval this policy would like at this moment.
+     *
+     * @return the polling interval
+     */
+    long getDesiredPollingInterval();
+
+    /**
+     * Returns the minimum distance between updates.
+     */
+    int getMinDistance();
+
+    /**
+     * Notifies the amount of time the user has been idle at his current location.
+     *
+     * @param idleTime the time that the user has been idle at his current
+     *                 location
+     */
+    void updateIdleTime(long idleTime);
+}

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

@@ -0,0 +1,75 @@
+/*
+ * 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.services;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.location.LocationListener;
+import android.location.LocationManager;
+import android.os.Handler;
+import android.os.Looper;
+
+/**
+ * Handles connection to {@link LocationManager}.
+ *
+ * @author Jimmy Shih
+ */
+public class LocationManagerConnector {
+
+    private final Handler handler;
+    private final LocationManager locationManager;
+
+    private LocationListener requestLocationUpdates;
+    private float requestLocationUpdatesDistance;
+    private long requestLocationUpdatesTime;
+
+    public LocationManagerConnector(Context context, Looper looper) {
+        this.handler = new Handler(looper);
+
+        locationManager = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
+    }
+
+    /**
+     * Requests location updates.
+     *
+     * @param minTime          the minimal time
+     * @param minDistance      the minimal distance
+     * @param locationListener the location listener
+     */
+    public void requestLocationUpdates(final long minTime, final float minDistance, final LocationListener locationListener) {
+        handler.post(new Runnable() {
+            @Override
+            @SuppressLint("MissingPermission")
+            public void run() {
+                requestLocationUpdatesTime = minTime;
+                requestLocationUpdatesDistance = minDistance;
+                requestLocationUpdates = locationListener;
+                locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, requestLocationUpdatesTime, requestLocationUpdatesDistance, locationListener);
+            }
+        });
+    }
+
+    /**
+     * Removes location updates.
+     *
+     * @param locationListener the location listener
+     */
+    public void removeLocationUpdates(final LocationListener locationListener) {
+        locationManager.removeUpdates(locationListener);
+        requestLocationUpdates = null;
+    }
+}

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

@@ -0,0 +1,160 @@
+/*
+ * Copyright 2011 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;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.os.IBinder;
+import android.os.IBinder.DeathRecipient;
+import android.os.RemoteException;
+import android.util.Log;
+
+import de.dennisguse.opentracks.util.TrackRecordingServiceConnectionUtils;
+import de.dennisguse.opentracks.BuildConfig;
+
+/**
+ * Wrapper for the track recording service. This handles service
+ * start/bind/unbind/stop. The service must be started before it can be bound.
+ * Returns the service if it is started and bound.
+ *
+ * @author Rodrigo Damazio
+ */
+public class TrackRecordingServiceConnection {
+
+    private static final String TAG = TrackRecordingServiceConnection.class.getSimpleName();
+    private final Context context;
+    private final Runnable callback;
+    private ITrackRecordingService trackRecordingService;
+    private final DeathRecipient deathRecipient = new DeathRecipient() {
+        @Override
+        public void binderDied() {
+            Log.d(TAG, "Service died.");
+            setTrackRecordingService(null);
+        }
+    };
+    private final ServiceConnection serviceConnection = new ServiceConnection() {
+        @Override
+        public void onServiceConnected(ComponentName className, IBinder service) {
+            Log.i(TAG, "Connected to the service.");
+            try {
+                service.linkToDeath(deathRecipient, 0);
+            } catch (RemoteException e) {
+                Log.e(TAG, "Failed to bind a death recipient.", e);
+            }
+            setTrackRecordingService((ITrackRecordingService) service);
+        }
+
+        @Override
+        public void onServiceDisconnected(ComponentName className) {
+            Log.i(TAG, "Disconnected from the service.");
+            setTrackRecordingService(null);
+        }
+    };
+
+    /**
+     * Constructor.
+     *
+     * @param context  the context
+     * @param callback the callback to invoke when the service binding changes
+     */
+    public TrackRecordingServiceConnection(Context context, Runnable callback) {
+        this.context = context;
+        this.callback = callback;
+    }
+
+    /**
+     * Starts and binds the service.
+     */
+    public void startAndBind() {
+        bindService(true);
+    }
+
+    /**
+     * Binds the service if it is started.
+     */
+    public void bindIfStarted() {
+        bindService(false);
+    }
+
+    /**
+     * Unbinds and stops the service.
+     */
+    public void unbindAndStop() {
+        unbind();
+        context.stopService(new Intent(context, TrackRecordingService.class));
+    }
+
+    /**
+     * Unbinds the service (but leave it running).
+     */
+    public void unbind() {
+        try {
+            context.unbindService(serviceConnection);
+        } catch (IllegalArgumentException e) {
+            // Means not bound to the service. OK to ignore.
+        }
+        setTrackRecordingService(null);
+    }
+
+    /**
+     * Gets the track recording service if bound. Returns null otherwise
+     */
+    public ITrackRecordingService getServiceIfBound() {
+        return trackRecordingService;
+    }
+
+    /**
+     * Binds the service if it is started.
+     *
+     * @param startIfNeeded start the service if needed
+     */
+    private void bindService(boolean startIfNeeded) {
+        if (trackRecordingService != null) {
+            // Service is already started and bound.
+            return;
+        }
+
+        if (!startIfNeeded
+                && !TrackRecordingServiceConnectionUtils.isRecordingServiceRunning(context)) {
+            Log.d(TAG, "Service is not started. Not binding it.");
+            return;
+        }
+
+        if (startIfNeeded) {
+            Log.i(TAG, "Starting the service.");
+            context.startService(new Intent(context, TrackRecordingService.class));
+        }
+
+        Log.i(TAG, "Binding the service.");
+        int flags = BuildConfig.DEBUG ? Context.BIND_DEBUG_UNBIND : 0;
+        context.bindService(new Intent(context, TrackRecordingService.class), serviceConnection, flags);
+    }
+
+    /**
+     * Sets the trackRecordingService.
+     *
+     * @param value the value
+     */
+    private void setTrackRecordingService(ITrackRecordingService value) {
+        trackRecordingService = value;
+        if (callback != null) {
+            callback.run();
+        }
+    }
+}

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

@@ -0,0 +1,144 @@
+/*
+ * Copyright (C) 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.sensors;
+
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothGatt;
+import android.bluetooth.BluetoothGattCallback;
+import android.bluetooth.BluetoothGattCharacteristic;
+import android.bluetooth.BluetoothGattDescriptor;
+import android.bluetooth.BluetoothProfile;
+import android.content.Context;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Message;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+
+import de.dennisguse.opentracks.content.sensor.SensorDataSet;
+import de.dennisguse.opentracks.content.sensor.SensorState;
+
+import java.util.UUID;
+
+/**
+ * Manages connection to Bluetooth LE heart rate monitor.
+ * TODO: shutdown connection.
+ */
+public class BluetoothConnectionManager {
+
+    // Message types sent to handler
+    public static final int MESSAGE_DEVICE_NAME = 1;
+    public static final int MESSAGE_READ = 2;
+    public static final String KEY_DEVICE_NAME = "device_name";
+    private static final UUID HEART_RATE_SERVICE_UUID = new UUID(0x180D00001000L, 0x800000805f9b34fbL);
+    private static final UUID HEART_RATE_MEASUREMENT_CHAR_UUID = new UUID(0x2A3700001000L, 0x800000805f9b34fbL);
+    private static final UUID CLIENT_CHARACTERISTIC_CONFIG_UUID = new UUID(0x290200001000L, 0x800000805f9b34fbL);
+    private static final String TAG = BluetoothConnectionManager.class.getSimpleName();
+
+    private final Context context;
+    private final Handler handler;
+    private SensorState sensorState;
+
+    private BluetoothGattCallback connectCallback = new BluetoothGattCallback() {
+        @Override
+        public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
+            if (newState == BluetoothProfile.STATE_CONNECTED) {
+                gatt.discoverServices();
+                setState(SensorState.CONNECTED);
+
+                //Inform about status change
+                Message message = handler.obtainMessage(MESSAGE_DEVICE_NAME);
+                Bundle bundle = new Bundle();
+                bundle.putString(KEY_DEVICE_NAME, gatt.getDevice().getName());
+                message.setData(bundle);
+                handler.sendMessage(message);
+                return;
+            }
+            Log.d(TAG, "Could not connect to bluetooth sensor: " + gatt.getDevice());
+        }
+
+        @Override
+        public void onServicesDiscovered(@NonNull BluetoothGatt gatt, int status) {
+            BluetoothGattCharacteristic characteristic = gatt
+                    .getService(HEART_RATE_SERVICE_UUID)
+                    .getCharacteristic(HEART_RATE_MEASUREMENT_CHAR_UUID);
+
+            gatt.setCharacteristicNotification(characteristic, true);
+
+            BluetoothGattDescriptor descriptor = characteristic.getDescriptor(CLIENT_CHARACTERISTIC_CONFIG_UUID);
+            descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
+            gatt.writeDescriptor(descriptor);
+        }
+
+        @Override
+        public void onCharacteristicChanged(BluetoothGatt gatt, @NonNull BluetoothGattCharacteristic characteristic) {
+            int heartRate = BluetoothLEUtils.parseHeartRate(characteristic);
+
+            Log.d(TAG, "Received heart beat rate: " + heartRate);
+            SensorDataSet sensorDataSet = new SensorDataSet(heartRate, gatt.getDevice().getName(), gatt.getDevice().getAddress());
+            handler.obtainMessage(MESSAGE_READ, sensorDataSet).sendToTarget();
+        }
+    };
+
+    /**
+     * Constructor.
+     *
+     * @param handler a handler for sending messages back to the UI activity
+     */
+    public BluetoothConnectionManager(Context context, Handler handler) {
+        this.context = context;
+        this.handler = handler;
+        this.sensorState = SensorState.NONE;
+    }
+
+    /**
+     * Gets the sensor state.
+     */
+    public synchronized SensorState getSensorState() {
+        return sensorState;
+    }
+
+    /**
+     * Sets the sensor state.
+     *
+     * @param sensorState the sensor state
+     */
+    private synchronized void setState(SensorState sensorState) {
+        this.sensorState = sensorState;
+    }
+
+    /**
+     * Resets the bluetooth connection manager.
+     */
+    public synchronized void reset() {
+        //TODO Disconnect
+        setState(SensorState.NONE);
+    }
+
+    /**
+     * Connects to a bluetooth device.
+     *
+     * @param bluetoothDevice the bluetooth device
+     */
+    public synchronized void connect(BluetoothDevice bluetoothDevice) {
+        Log.d(TAG, "connect to: " + bluetoothDevice);
+
+        bluetoothDevice.connectGatt(this.context, false, this.connectCallback);
+        setState(SensorState.CONNECTING);
+    }
+}

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

@@ -0,0 +1,18 @@
+package de.dennisguse.opentracks.services.sensors;
+
+import android.bluetooth.BluetoothGattCharacteristic;
+
+public final class BluetoothLEUtils {
+
+    private BluetoothLEUtils() {
+    }
+
+    public static int parseHeartRate(BluetoothGattCharacteristic characteristic) {
+        //DOCUMENTATION https://www.bluetooth.com/specifications/gatt/characteristics/
+        byte[] raw = characteristic.getValue();
+        int index = ((raw[0] & 0x1) == 1) ? 2 : 1;
+        int format = (index == 1) ? BluetoothGattCharacteristic.FORMAT_UINT8 : BluetoothGattCharacteristic.FORMAT_UINT16;
+        int heartRate = characteristic.getIntValue(format, index);
+        return heartRate;
+    }
+}

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

@@ -0,0 +1,159 @@
+/*
+ * 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.sensors;
+
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.content.Context;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+import android.util.Log;
+
+import de.dennisguse.opentracks.content.sensor.SensorDataSet;
+import de.dennisguse.opentracks.content.sensor.SensorState;
+import de.dennisguse.opentracks.util.PreferencesUtils;
+import de.dennisguse.opentracks.util.UnitConversions;
+import de.dennisguse.opentracks.R;
+
+import java.util.ArrayList;
+
+/**
+ * Bluetooth sensor manager.
+ * <p>
+ * TODO: Handle a BluetoothGatt.STATE_DISCONNECTED
+ *
+ * @author Sandor Dornbush
+ */
+public class BluetoothSensorManager extends SensorManager {
+
+    private static final String TAG = BluetoothConnectionManager.class.getSimpleName();
+    private static final BluetoothAdapter bluetoothAdapter = getDefaultBluetoothAdapter();
+    private final Context context;
+    private final BluetoothConnectionManager bluetoothConnectionManager;
+    private SensorDataSet sensorDataSet = null;
+    // Handler that gets information back from the bluetoothConnectionManager
+    private final Handler messageHandler = new Handler(Looper.getMainLooper()) {
+        @Override
+        public void handleMessage(Message message) {
+            switch (message.what) {
+                case BluetoothConnectionManager.MESSAGE_DEVICE_NAME:
+                    String deviceName = message.getData().getString(BluetoothConnectionManager.KEY_DEVICE_NAME);
+                    break;
+                case BluetoothConnectionManager.MESSAGE_READ:
+                    if (!(message.obj instanceof SensorDataSet)) {
+                        Log.e(TAG, "Received message did not contain a SensorDataSet.");
+                        sensorDataSet = null;
+                    } else {
+                        sensorDataSet = (SensorDataSet) message.obj;
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+    };
+
+    /**
+     * @param context the context
+     */
+    public BluetoothSensorManager(Context context) {
+        this.context = context;
+        bluetoothConnectionManager = new BluetoothConnectionManager(context, messageHandler);
+    }
+
+    private static BluetoothAdapter getDefaultBluetoothAdapter() {
+        // If from the main application thread, return directly
+        if (Thread.currentThread().equals(Looper.getMainLooper().getThread())) {
+            return BluetoothAdapter.getDefaultAdapter();
+        }
+
+        // Get the default adapter from the main application thread
+        final ArrayList<BluetoothAdapter> adapters = new ArrayList<>(1);
+        final Object mutex = new Object();
+
+        Handler handler = new Handler(Looper.getMainLooper());
+        handler.post(new Runnable() {
+            @Override
+            public void run() {
+                adapters.add(BluetoothAdapter.getDefaultAdapter());
+                synchronized (mutex) {
+                    mutex.notify();
+                }
+            }
+        });
+
+        while (adapters.isEmpty()) {
+            synchronized (mutex) {
+                try {
+                    mutex.wait(UnitConversions.ONE_SECOND);
+                } catch (InterruptedException e) {
+                    Log.e(TAG, "Interrupted while waiting for default bluetooth adapter", e);
+                }
+            }
+        }
+
+        if (adapters.get(0) == null) {
+            Log.w(TAG, "No bluetooth adapter found.");
+            return null;
+        }
+        return adapters.get(0);
+    }
+
+    @Override
+    public boolean isEnabled() {
+        return bluetoothAdapter != null && bluetoothAdapter.isEnabled();
+    }
+
+    @Override
+    protected void setUpChannel() {
+        if (!isEnabled()) {
+            Log.w(TAG, "Bluetooth not enabled.");
+            return;
+        }
+        String address = PreferencesUtils.getString(context, R.string.bluetooth_sensor_key, PreferencesUtils.BLUETOOTH_SENSOR_DEFAULT);
+        if (PreferencesUtils.BLUETOOTH_SENSOR_DEFAULT.equals(address)) {
+            Log.w(TAG, "No bluetooth address.");
+            return;
+        }
+        Log.w(TAG, "Connecting to bluetooth address: " + address);
+
+        BluetoothDevice device;
+        try {
+            device = bluetoothAdapter.getRemoteDevice(address);
+        } catch (IllegalArgumentException e) {
+            Log.d(TAG, "Unable to get remote device for: " + address, e);
+            return;
+        }
+        bluetoothConnectionManager.connect(device);
+    }
+
+    @Override
+    protected void tearDownChannel() {
+        bluetoothConnectionManager.reset();
+    }
+
+    @Override
+    public SensorState getSensorState() {
+        return bluetoothConnectionManager.getSensorState();
+    }
+
+    @Override
+    public SensorDataSet getSensorDataSet() {
+        return sensorDataSet;
+    }
+}

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

@@ -0,0 +1,138 @@
+/*
+ * 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.sensors;
+
+import android.util.Log;
+
+import de.dennisguse.opentracks.content.sensor.SensorDataSet;
+import de.dennisguse.opentracks.content.sensor.SensorState;
+
+import java.util.Timer;
+import java.util.TimerTask;
+
+/**
+ * Manage the connection to a sensor.
+ *
+ * @author Sandor Dornbush
+ */
+public abstract class SensorManager {
+
+    public static final long MAX_SENSOR_DATE_SET_AGE = 5000;
+    public static final long MAX_SENSOR_STATE_AGE = 20000;
+
+    private static final String TAG = SensorManager.class.getSimpleName();
+    private static final int RETRY_PERIOD = 20000;
+
+    private SensorState sensorState = SensorState.NONE;
+    private long sensorStateTimestamp = System.currentTimeMillis();
+
+    private TimerTask timerTask;
+    private Timer timer;
+
+    /**
+     * Returns true if the sensor is enabled.
+     */
+    public abstract boolean isEnabled();
+
+    /**
+     * Sets up the sensor channel.
+     */
+    protected abstract void setUpChannel();
+
+    /**
+     * Tears down the sensor channel.
+     */
+    protected abstract void tearDownChannel();
+
+    /**
+     * Gets the sensor data set.
+     */
+    public abstract SensorDataSet getSensorDataSet();
+
+    /**
+     * Starts the sensor.
+     */
+    public void startSensor() {
+        setUpChannel();
+        timerTask = new TimerTask() {
+            @Override
+            public void run() {
+                switch (getSensorState()) {
+                    case CONNECTING:
+                        if (System.currentTimeMillis() - sensorStateTimestamp > MAX_SENSOR_STATE_AGE) {
+                            Log.i(TAG, "Retry setUpChannel");
+                            setUpChannel();
+                        }
+                        break;
+                    case NONE:
+                    case DISCONNECTED:
+                        setUpChannel();
+                        break;
+                    default:
+                        // CONNECTED or SENDING
+                        break;
+                }
+            }
+        };
+        timer = new Timer(SensorManager.class.getSimpleName());
+        timer.schedule(timerTask, RETRY_PERIOD, RETRY_PERIOD);
+    }
+
+    /**
+     * Stops the sensor.
+     */
+    public void stopSensor() {
+        if (timerTask != null) {
+            timerTask.cancel();
+            timerTask = null;
+        }
+        if (timer != null) {
+            timer.cancel();
+            timer.purge();
+            timer = null;
+        }
+        tearDownChannel();
+    }
+
+    /**
+     * Gets the sensor state.
+     */
+    public SensorState getSensorState() {
+        return sensorState;
+    }
+
+    /**
+     * Sets the sensor state.
+     *
+     * @param sensorState the sensor state
+     */
+    public void setSensorState(SensorState sensorState) {
+        sensorStateTimestamp = System.currentTimeMillis();
+        this.sensorState = sensorState;
+    }
+
+    /**
+     * Returns true if the sensor data set is valid.
+     */
+    public boolean isSensorDataSetValid() {
+        SensorDataSet sensorDataSet = getSensorDataSet();
+        if (sensorDataSet == null) {
+            return false;
+        }
+        return sensorDataSet.isRecent(MAX_SENSOR_DATE_SET_AGE);
+    }
+}

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

@@ -0,0 +1,92 @@
+/*
+ * Copyright 2009 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.sensors;
+
+import android.content.Context;
+
+/**
+ * A factory of {@link SensorManager}.
+ *
+ * @author Sandor Dornbush
+ */
+public class SensorManagerFactory {
+
+    private static SensorManager systemSensorManager = null;
+    private static SensorManager sensorManagerTemporary = null;
+
+    private SensorManagerFactory() {
+    }
+
+    /**
+     * Gets the system sensor manager.
+     *
+     * @param context the context
+     */
+    public static SensorManager getSystemSensorManager(Context context) {
+        releaseSensorManagerTemporary();
+        releaseSystemSensorManager();
+        systemSensorManager = getSensorManager(context);
+        if (systemSensorManager != null) {
+            systemSensorManager.startSensor();
+        }
+        return systemSensorManager;
+    }
+
+    /**
+     * Releases the system sensor manager.
+     */
+    public static void releaseSystemSensorManager() {
+        if (systemSensorManager != null) {
+            systemSensorManager.stopSensor();
+        }
+        systemSensorManager = null;
+    }
+
+    /**
+     * Gets the temp sensor manager.
+     */
+    public static SensorManager getSensorManagerTemporary(Context context) {
+        releaseSensorManagerTemporary();
+        if (systemSensorManager != null) {
+            return null;
+        }
+        sensorManagerTemporary = getSensorManager(context);
+        if (sensorManagerTemporary != null) {
+            sensorManagerTemporary.startSensor();
+        }
+        return sensorManagerTemporary;
+    }
+
+    /**
+     * Releases the temp sensor manager.
+     */
+    public static void releaseSensorManagerTemporary() {
+        if (sensorManagerTemporary != null) {
+            sensorManagerTemporary.stopSensor();
+        }
+        sensorManagerTemporary = null;
+    }
+
+    /**
+     * Gets the sensor manager.
+     *
+     * @param context the context
+     */
+    private static SensorManager getSensorManager(Context context) {
+        return new BluetoothSensorManager(context);
+    }
+}

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

@@ -0,0 +1,324 @@
+/*
+ * Copyright 2009 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.media.AudioManager;
+import android.speech.tts.TextToSpeech;
+import android.speech.tts.TextToSpeech.OnInitListener;
+import android.speech.tts.UtteranceProgressListener;
+import android.telephony.PhoneStateListener;
+import android.telephony.TelephonyManager;
+import android.util.Log;
+
+import androidx.annotation.VisibleForTesting;
+
+import de.dennisguse.opentracks.services.TrackRecordingService;
+import de.dennisguse.opentracks.stats.TripStatistics;
+import de.dennisguse.opentracks.util.PreferencesUtils;
+import de.dennisguse.opentracks.util.StringUtils;
+import de.dennisguse.opentracks.util.UnitConversions;
+import de.dennisguse.opentracks.R;
+
+import java.util.Locale;
+
+/**
+ * This class will periodically announce the user's trip statistics.
+ *
+ * @author Sandor Dornbush
+ */
+public class AnnouncementPeriodicTask implements PeriodicTask {
+
+    /**
+     * The rate at which announcements are spoken.
+     */
+    @VisibleForTesting
+    static final float TTS_SPEECH_RATE = 0.9f;
+
+    private static final String TAG = AnnouncementPeriodicTask.class.getSimpleName();
+    private final Context context;
+    private final AudioManager audioManager;
+    private final UtteranceProgressListener utteranceListener = new UtteranceProgressListener() {
+        @Override
+        public void onStart(String utteranceId) {
+        }
+
+        @Override
+        public void onDone(String utteranceId) {
+            int result = audioManager.abandonAudioFocus(null);
+            if (result == AudioManager.AUDIOFOCUS_REQUEST_FAILED) {
+                Log.w(TAG, "Failed to relinquish audio focus.");
+            }
+        }
+
+        @Override
+        public void onError(String utteranceId) {
+        }
+    };
+    private TextToSpeech tts;
+    // Response from TTS after its initialization
+    private int initStatus = TextToSpeech.ERROR;
+    // True if TTS engine is ready
+    private boolean ready = false;
+    // True if speech is allowed
+    private boolean speechAllowed;
+    /**
+     * Listener which updates {@link #speechAllowed} when the phone state changes.
+     */
+    private final PhoneStateListener phoneStateListener = new PhoneStateListener() {
+        @Override
+        public void onCallStateChanged(int state, String incomingNumber) {
+            speechAllowed = state == TelephonyManager.CALL_STATE_IDLE;
+            if (!speechAllowed && tts != null && tts.isSpeaking()) {
+                // If we're already speaking, stop it.
+                tts.stop();
+            }
+        }
+    };
+
+    public AnnouncementPeriodicTask(Context context) {
+        this.context = context;
+        audioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
+    }
+
+    @Override
+    public void start() {
+        if (tts == null) {
+            tts = newTextToSpeech(context, new OnInitListener() {
+                @Override
+                public void onInit(int status) {
+                    initStatus = status;
+                }
+            });
+        }
+        speechAllowed = true;
+        listenToPhoneState(phoneStateListener, PhoneStateListener.LISTEN_CALL_STATE);
+    }
+
+    @Override
+    public void run(TrackRecordingService trackRecordingService) {
+        if (trackRecordingService == null) {
+            Log.e(TAG, "TrackRecordingService is null.");
+            return;
+        }
+        announce(trackRecordingService.getTripStatistics());
+    }
+
+    /**
+     * Runs this task.
+     *
+     * @param tripStatistics the trip statistics
+     */
+    @VisibleForTesting
+    void announce(TripStatistics tripStatistics) {
+        if (tripStatistics == null) {
+            Log.e(TAG, "TripStatistics is null.");
+            return;
+        }
+
+        synchronized (this) {
+            if (!ready) {
+                ready = initStatus == TextToSpeech.SUCCESS;
+                if (ready) {
+                    onTtsReady();
+                }
+            }
+            if (!ready) {
+                Log.i(TAG, "TTS not ready.");
+                return;
+            }
+        }
+
+        if (!speechAllowed) {
+            Log.i(TAG, "Speech is not allowed at this time.");
+            return;
+        }
+        speakAnnouncement(getAnnouncement(tripStatistics));
+    }
+
+    @Override
+    public void shutdown() {
+        listenToPhoneState(phoneStateListener, PhoneStateListener.LISTEN_NONE);
+        if (tts != null) {
+            tts.shutdown();
+            tts = null;
+        }
+    }
+
+    /**
+     * Called when TTS is ready.
+     */
+    private void onTtsReady() {
+        Locale locale = Locale.getDefault();
+        int languageAvailability = tts.isLanguageAvailable(locale);
+        if (languageAvailability == TextToSpeech.LANG_MISSING_DATA
+                || languageAvailability == TextToSpeech.LANG_NOT_SUPPORTED) {
+            Log.w(TAG, "Default locale not available, use English.");
+            locale = Locale.ENGLISH;
+            /*
+             * TODO: instead of using english, load the language if missing and show a
+             * toast if not supported. Not able to change the resource strings to
+             * English.
+             */
+        }
+        tts.setLanguage(locale);
+
+        // Slow down the speed just a bit as it is hard to hear when exercising.
+        tts.setSpeechRate(TTS_SPEECH_RATE);
+
+        tts.setOnUtteranceProgressListener(utteranceListener);
+    }
+
+    /**
+     * Speaks the announcement.
+     *
+     * @param announcement the announcement
+     */
+    private void speakAnnouncement(String announcement) {
+        int result = audioManager.requestAudioFocus(
+                null, TextToSpeech.Engine.DEFAULT_STREAM, AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK);
+        if (result == AudioManager.AUDIOFOCUS_REQUEST_FAILED) {
+            Log.w(TAG, "Failed to request audio focus.");
+        }
+
+        /*
+         * 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");
+    }
+
+    /**
+     * Create a new {@link TextToSpeech}.
+     *
+     * @param aContext       a context
+     * @param onInitListener an on init listener
+     */
+    @VisibleForTesting
+    protected TextToSpeech newTextToSpeech(Context aContext, OnInitListener onInitListener) {
+        return new TextToSpeech(aContext, onInitListener);
+    }
+
+    /**
+     * Gets the announcement.
+     *
+     * @param tripStatistics the trip statistics
+     */
+    @VisibleForTesting
+    protected String getAnnouncement(TripStatistics tripStatistics) {
+        boolean metricUnits = PreferencesUtils.isMetricUnits(context);
+        boolean reportSpeed = PreferencesUtils.isReportSpeed(context);
+        double distance = tripStatistics.getTotalDistance() * UnitConversions.M_TO_KM;
+        double speed = tripStatistics.getAverageMovingSpeed() * UnitConversions.MS_TO_KMH;
+
+        if (distance == 0) {
+            return context.getString(R.string.voice_total_distance_zero);
+        }
+
+        if (!metricUnits) {
+            distance *= UnitConversions.KM_TO_MI;
+            speed *= UnitConversions.KM_TO_MI;
+        }
+
+        String rate;
+        if (reportSpeed) {
+            int speedId = metricUnits ? R.plurals.voiceSpeedKilometersPerHour
+                    : R.plurals.voiceSpeedMilesPerHour;
+            rate = context.getResources().getQuantityString(speedId, getQuantityCount(speed), speed);
+        } else {
+            speed = speed == 0 ? 0.0 : 1 / speed;
+            int paceId = metricUnits ? R.string.voice_pace_per_kilometer : R.string.voice_pace_per_mile;
+            long time = Math.round(
+                    speed * UnitConversions.HR_TO_MIN * UnitConversions.MIN_TO_S * UnitConversions.S_TO_MS);
+            rate = context.getString(paceId, getAnnounceTime(time));
+        }
+
+        int totalDistanceId = metricUnits ? R.plurals.voiceTotalDistanceKilometers
+                : R.plurals.voiceTotalDistanceMiles;
+        String totalDistance = context.getResources()
+                .getQuantityString(totalDistanceId, getQuantityCount(distance), distance);
+
+        return context.getString(R.string.voice_template, totalDistance,
+                getAnnounceTime(tripStatistics.getMovingTime()), rate);
+    }
+
+    /**
+     * Listens to phone state.
+     *
+     * @param listener the listener
+     * @param events   the interested events
+     */
+    @VisibleForTesting
+    protected void listenToPhoneState(PhoneStateListener listener, int events) {
+        TelephonyManager telephony = (TelephonyManager) context.getSystemService(
+                Context.TELEPHONY_SERVICE);
+        if (telephony != null) {
+            telephony.listen(listener, events);
+        }
+    }
+
+    /**
+     * Gets the announce time.
+     *
+     * @param time the time
+     */
+    @VisibleForTesting
+    String getAnnounceTime(long time) {
+        int[] parts = StringUtils.getTimeParts(time);
+        String seconds = context.getResources()
+                .getQuantityString(R.plurals.voiceSeconds, parts[0], parts[0]);
+        String minutes = context.getResources()
+                .getQuantityString(R.plurals.voiceMinutes, parts[1], parts[1]);
+        String hours = context.getResources()
+                .getQuantityString(R.plurals.voiceHours, parts[2], parts[2]);
+        StringBuilder sb = new StringBuilder();
+        if (parts[2] != 0) {
+            sb.append(hours);
+            sb.append(" ");
+        }
+        sb.append(minutes);
+        sb.append(" ");
+        sb.append(seconds);
+        return sb.toString();
+    }
+
+    /**
+     * Gets the plural count to be used by getQuantityString. getQuantityString
+     * only supports integer quantities, not a double quantity like "2.2".
+     * <p>
+     * As a temporary workaround, we convert a double quantity to an integer
+     * quantity. If the double quantity is exactly 0, 1, or 2, then we can return
+     * these integer quantities. Otherwise, we cast the double quantity to an
+     * integer quantity. However, we need to make sure that if the casted value is
+     * 0, 1, or 2, we don't return those, instead, return the next biggest integer
+     * 3.
+     *
+     * @param d the double value
+     */
+    private int getQuantityCount(double d) {
+        if (d == 0) {
+            return 0;
+        } else if (d == 1) {
+            return 1;
+        } else if (d == 2) {
+            return 2;
+        } else {
+            int count = (int) d;
+            return count < 3 ? 3 : count;
+        }
+    }
+}

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

@@ -0,0 +1,31 @@
+/*
+ * 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);
+    }
+}

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

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2009 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 de.dennisguse.opentracks.services.TrackRecordingService;
+
+/**
+ * This is interface for a task that will be executed on some schedule.
+ *
+ * @author Sandor Dornbush
+ */
+public interface PeriodicTask {
+    /**
+     * Sets up this task for subsequent calls to the run method.
+     */
+    void start();
+
+    /**
+     * This method will be called periodically.
+     *
+     * @param trackRecordingService the track recording service
+     */
+    void run(TrackRecordingService trackRecordingService);
+
+    /**
+     * Shuts down this task and clean up resources.
+     */
+    void shutdown();
+}

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

@@ -0,0 +1,202 @@
+/*
+ * 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.util.Log;
+
+import de.dennisguse.opentracks.services.TrackRecordingService;
+import de.dennisguse.opentracks.stats.TripStatistics;
+import de.dennisguse.opentracks.util.PreferencesUtils;
+import de.dennisguse.opentracks.util.UnitConversions;
+
+/**
+ * Execute a periodic task on a time or distance schedule.
+ *
+ * @author Sandor Dornbush
+ */
+public class PeriodicTaskExecutor {
+
+    private static final String TAG = PeriodicTaskExecutor.class.getSimpleName();
+    private static final long MINUTE_TO_MILLISECONDS = 60000L;
+
+    private final TrackRecordingService trackRecordingService;
+    private final PeriodicTaskFactory periodicTaskFactory;
+
+    /**
+     * The task frequency. A positive value is a time frequency (minutes). A
+     * negative value is a distance frequency (km or mi). A zero value is to turn
+     * off periodic task.
+     */
+    private int taskFrequency = PreferencesUtils.FREQUENCY_OFF;
+
+    private PeriodicTask periodicTask;
+
+    // Time periodic task executor
+    private TimerTaskExecutor timerTaskExecutor = null;
+
+    private boolean metricUnits;
+
+    // The next distance for the distance periodic task
+    private double nextTaskDistance = Double.MAX_VALUE;
+
+    public PeriodicTaskExecutor(
+            TrackRecordingService trackRecordingService, PeriodicTaskFactory periodicTaskFactory) {
+        this.trackRecordingService = trackRecordingService;
+        this.periodicTaskFactory = periodicTaskFactory;
+    }
+
+    /**
+     * Restores the executor.
+     */
+    public void restore() {
+        if (!trackRecordingService.isRecording() || trackRecordingService.isPaused()) {
+            Log.d(TAG, "Not recording or paused.");
+            return;
+        }
+
+        if (!isTimeFrequency()) {
+            if (timerTaskExecutor != null) {
+                timerTaskExecutor.shutdown();
+                timerTaskExecutor = null;
+            }
+        }
+        if (taskFrequency == PreferencesUtils.FREQUENCY_OFF) {
+            Log.d(TAG, "Task frequency is off.");
+            return;
+        }
+
+        periodicTask = periodicTaskFactory.create(trackRecordingService);
+
+        // Returning null is ok
+        if (periodicTask == null) {
+            Log.d(TAG, "Periodic task is null.");
+            return;
+        }
+        periodicTask.start();
+
+        if (isTimeFrequency()) {
+            if (timerTaskExecutor == null) {
+                timerTaskExecutor = new TimerTaskExecutor(periodicTask, trackRecordingService);
+            }
+            timerTaskExecutor.scheduleTask(taskFrequency * MINUTE_TO_MILLISECONDS);
+        } else {
+            // For distance periodic task
+            calculateNextTaskDistance();
+        }
+    }
+
+    /**
+     * Shuts down the executor.
+     */
+    public void shutdown() {
+        if (periodicTask != null) {
+            periodicTask.shutdown();
+            periodicTask = null;
+        }
+        if (timerTaskExecutor != null) {
+            timerTaskExecutor.shutdown();
+            timerTaskExecutor = null;
+        }
+    }
+
+    /**
+     * Updates the executor.
+     */
+    public void update() {
+        if (!isDistanceFrequency() || periodicTask == null) {
+            return;
+        }
+        TripStatistics tripStatistics = trackRecordingService.getTripStatistics();
+        if (tripStatistics == null) {
+            return;
+        }
+        double distance = tripStatistics.getTotalDistance()
+                * UnitConversions.M_TO_KM;
+        if (!metricUnits) {
+            distance *= UnitConversions.KM_TO_MI;
+        }
+
+        if (distance > nextTaskDistance) {
+            periodicTask.run(trackRecordingService);
+            calculateNextTaskDistance();
+        }
+    }
+
+    /**
+     * 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();
+    }
+
+    /**
+     * Calculates the next distance for the distance periodic task.
+     */
+    private void calculateNextTaskDistance() {
+        if (!trackRecordingService.isRecording() || trackRecordingService.isPaused()
+                || periodicTask == null) {
+            return;
+        }
+
+        TripStatistics tripStatistics = trackRecordingService.getTripStatistics();
+        if (tripStatistics == null) {
+            return;
+        }
+
+        if (!isDistanceFrequency()) {
+            nextTaskDistance = Double.MAX_VALUE;
+            Log.d(TAG, "SplitManager: Distance splits disabled.");
+            return;
+        }
+
+        double distance = tripStatistics.getTotalDistance()
+                * UnitConversions.M_TO_KM;
+        if (!metricUnits) {
+            distance *= UnitConversions.KM_TO_MI;
+        }
+        // The index will be negative since the frequency is negative.
+        int index = (int) (distance / taskFrequency);
+        index -= 1;
+        nextTaskDistance = taskFrequency * index;
+    }
+
+    /**
+     * True if time frequency.
+     */
+    private boolean isTimeFrequency() {
+        return taskFrequency > 0;
+    }
+
+    /**
+     * True if distance frequency.
+     */
+    private boolean isDistanceFrequency() {
+        return taskFrequency < 0;
+    }
+}

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

@@ -0,0 +1,34 @@
+/*
+ * 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;
+
+/**
+ * An interface for classes that can create {@link PeriodicTask}.
+ *
+ * @author Sandor Dornbush
+ */
+public interface PeriodicTaskFactory {
+
+    /**
+     * Creates a {@link PeriodicTask}.
+     *
+     * @return the task, or null if the task is not supported
+     */
+    PeriodicTask create(Context context);
+}

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

@@ -0,0 +1,41 @@
+/*
+ * 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 de.dennisguse.opentracks.content.WaypointCreationRequest;
+import de.dennisguse.opentracks.services.TrackRecordingService;
+
+/**
+ * A simple task to insert statistics markers periodically.
+ *
+ * @author Sandor Dornbush
+ */
+public class SplitPeriodicTask implements PeriodicTask {
+
+    @Override
+    public void start() {
+    }
+
+    @Override
+    public void run(TrackRecordingService trackRecordingService) {
+        trackRecordingService.insertWaypoint(WaypointCreationRequest.DEFAULT_STATISTICS);
+    }
+
+    @Override
+    public void shutdown() {
+    }
+}

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

@@ -0,0 +1,32 @@
+/*
+ * 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.services.tasks;
+
+import android.content.Context;
+
+/**
+ * A {@link PeriodicTaskFactory} for {@link SplitPeriodicTask}.
+ *
+ * @author Jimmy Shih
+ */
+public class SplitPeriodicTaskFactory implements PeriodicTaskFactory {
+
+    @Override
+    public PeriodicTask create(Context context) {
+        return new SplitPeriodicTask();
+    }
+}

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

@@ -0,0 +1,91 @@
+/*
+ * Copyright 2009 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 de.dennisguse.opentracks.services.TrackRecordingService;
+import de.dennisguse.opentracks.stats.TripStatistics;
+
+import java.util.Date;
+import java.util.Timer;
+import java.util.TimerTask;
+
+/**
+ * This class will periodically perform a task.
+ *
+ * @author Sandor Dornbush
+ */
+public class TimerTaskExecutor {
+
+    private final PeriodicTask periodicTask;
+    private final TrackRecordingService trackRecordingService;
+
+    private TimerTask timerTask;
+    private Timer timer;
+
+    public TimerTaskExecutor(PeriodicTask periodicTask, TrackRecordingService trackRecordingService) {
+        this.periodicTask = periodicTask;
+        this.trackRecordingService = trackRecordingService;
+    }
+
+    /**
+     * Schedules the periodic task at an interval.
+     *
+     * @param interval the interval in milliseconds
+     */
+    public void scheduleTask(long interval) {
+        if (interval <= 0) {
+            return;
+        }
+
+        if (!trackRecordingService.isRecording() || trackRecordingService.isPaused()) {
+            return;
+        }
+
+        TripStatistics tripStatistics = trackRecordingService.getTripStatistics();
+        if (tripStatistics == null) {
+            return;
+        }
+
+        shutdown();
+        periodicTask.start();
+        timerTask = new TimerTask() {
+            @Override
+            public void run() {
+                periodicTask.run(trackRecordingService);
+            }
+        };
+        timer = new Timer(TimerTaskExecutor.class.getSimpleName());
+        long next = System.currentTimeMillis() + interval - (tripStatistics.getTotalTime() % interval);
+        timer.scheduleAtFixedRate(timerTask, new Date(next), interval);
+    }
+
+    /**
+     * Shuts down.
+     */
+    public void shutdown() {
+        if (timerTask != null) {
+            timerTask.cancel();
+            timerTask = null;
+        }
+        if (timer != null) {
+            timer.cancel();
+            timer.purge();
+            timer = null;
+        }
+        periodicTask.shutdown();
+    }
+}