TrackDetailView: show connected bluetooth device.

src/androidTest/java/com/google/android/apps/mytracks/BootReceiverTest.java

@@ -0,0 +1,100 @@
+/*
+ * 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 com.google.android.apps.mytracks;
+
+import android.app.ActivityManager;
+import android.app.ActivityManager.RunningServiceInfo;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.platform.app.InstrumentationRegistry;
+
+import com.google.android.apps.mytracks.services.TrackRecordingService;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.util.List;
+
+/**
+ * Tests for the BootReceiver.
+ *
+ * @author Youtao Liu
+ */
+@RunWith(AndroidJUnit4.class)
+public class BootReceiverTest  {
+  private static final String SERVICE_NAME = "com.google.android.apps.mytracks.services.TrackRecordingService";
+
+  /**
+   * Tests the behavior when receive notification which is the phone boot.
+   */
+  @Test
+  public void testOnReceive_startService() {
+    // Make sure no TrackRecordingService
+    Intent stopIntent = new Intent(InstrumentationRegistry.getInstrumentation().getContext(), TrackRecordingService.class);
+    InstrumentationRegistry.getInstrumentation().getContext().stopService(stopIntent);
+    Assert.assertFalse(isServiceExisted(InstrumentationRegistry.getInstrumentation().getContext(), SERVICE_NAME));
+
+    BootReceiver bootReceiver = new BootReceiver();
+    Intent intent = new Intent();
+    intent.setAction(Intent.ACTION_BOOT_COMPLETED);
+    bootReceiver.onReceive(InstrumentationRegistry.getInstrumentation().getContext(), intent);
+    // Check if the service is started
+    Assert.assertFalse(isServiceExisted(InstrumentationRegistry.getInstrumentation().getContext(), SERVICE_NAME));
+  }
+
+  /**
+   * Tests the behavior when receive notification which is not the phone boot.
+   */
+  @Test
+  public void testOnReceive_noStartService() {
+    // Make sure no TrackRecordingService
+    Intent stopIntent = new Intent(InstrumentationRegistry.getInstrumentation().getContext(), TrackRecordingService.class);
+    InstrumentationRegistry.getInstrumentation().getContext().stopService(stopIntent);
+    Assert.assertFalse(isServiceExisted(InstrumentationRegistry.getInstrumentation().getContext(), SERVICE_NAME));
+
+    BootReceiver bootReceiver = new BootReceiver();
+    Intent intent = new Intent();
+    intent.setAction(Intent.ACTION_BUG_REPORT);
+    bootReceiver.onReceive(InstrumentationRegistry.getInstrumentation().getContext(), intent);
+
+    // Check if the service is not started
+    Assert.assertFalse(isServiceExisted(InstrumentationRegistry.getInstrumentation().getContext(), SERVICE_NAME));
+  }
+
+  /**
+   * Checks if a service is started in a context.
+   *
+   * @param context the context for checking a service
+   * @param serviceName the service name to find if existed
+   */
+  private boolean isServiceExisted(Context context, String serviceName) {
+    ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
+    List<ActivityManager.RunningServiceInfo> serviceList = activityManager.getRunningServices(Integer.MAX_VALUE);
+
+    for (int i = 0; i < serviceList.size(); i++) {
+      RunningServiceInfo serviceInfo = serviceList.get(i);
+      ComponentName componentName = serviceInfo.service;
+      if (componentName.getClassName().equals(serviceName)) { 
+        return true; 
+      }
+    }
+    return false;
+  }
+}

src/androidTest/java/com/google/android/apps/mytracks/ChartValueSeriesTest.java

@@ -0,0 +1,87 @@
+/*
+ * 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 com.google.android.apps.mytracks;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.platform.app.InstrumentationRegistry;
+
+import com.google.android.maps.mytracks.R;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.runner.RunWith;
+
+/**
+ * Tests {@link ChartValueSeries}.
+ * 
+ * @author Sandor Dornbush
+ */
+@RunWith(AndroidJUnit4.class)
+public class ChartValueSeriesTest {
+  private ChartValueSeries series;
+
+  @Before
+  protected void setUp() {
+    series = new ChartValueSeries(
+        InstrumentationRegistry.getInstrumentation().getContext(),
+        Integer.MIN_VALUE,
+        Integer.MAX_VALUE,
+        new int[] {100, 1000 },
+        R.string.description_elevation_metric,
+        R.string.description_elevation_imperial,
+        R.color.chart_elevation_fill,
+        R.color.chart_elevation_border);
+  }
+
+  public void testInitialConditions() {
+    Assert.assertEquals(1, series.getInterval());
+    Assert.assertEquals(0, series.getMinMarkerValue());
+    Assert.assertEquals(5, series.getMaxMarkerValue());
+    Assert.assertTrue(series.isEnabled());
+  }
+
+  public void testEnabled() {
+    series.setEnabled(false);
+    Assert.assertFalse(series.isEnabled());
+  }
+
+  public void testSmallUpdates() {
+    series.update(0);
+    series.update(10);
+    series.updateDimension();
+    Assert.assertEquals(100, series.getInterval());
+    Assert.assertEquals(0, series.getMinMarkerValue());
+    Assert.assertEquals(500, series.getMaxMarkerValue());
+  }
+
+  public void testBigUpdates() {
+    series.update(0);
+    series.update(901);
+    series.updateDimension();
+    Assert.assertEquals(1000, series.getInterval());
+    Assert.assertEquals(0, series.getMinMarkerValue());
+    Assert.assertEquals(5000, series.getMaxMarkerValue());
+  }
+
+  public void testNotZeroBasedUpdates() {
+    series.update(220);
+    series.update(250);
+    series.updateDimension();
+    Assert.assertEquals(100, series.getInterval());
+    Assert.assertEquals(200, series.getMinMarkerValue());
+    Assert.assertEquals(700, series.getMaxMarkerValue());
+  }
+}

src/androidTest/java/com/google/android/apps/mytracks/TrackStubUtils.java

@@ -0,0 +1,90 @@
+/*
+ * 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 com.google.android.apps.mytracks;
+
+import android.location.Location;
+
+import com.google.android.apps.mytracks.content.MyTracksLocation;
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.content.sensor.Sensor.SensorDataSet;
+
+/**
+ * Commons utilities for creating stubs of track, location. The class will be
+ * enriched if needs more similar stubs for test.
+ * 
+ * @author Youtao Liu
+ */
+public class TrackStubUtils {
+
+  static final String LOCATION_PROVIDER = "gps";
+  public static final double INITIAL_LATITUDE = 22;
+  public static final double INITIAL_LONGITUDE = 22;
+  public static final double INITIAL_ALTITUDE = 22;
+  static final float INITIAL_ACCURACY = 5;
+  static final float INITIAL_SPEED = 10;
+  public static final long INITIAL_TIME = 1000L;
+  static final float INITIAL_BEARING = 3.0f;
+  // Used to change the value of latitude, longitude, and altitude.
+  static final double DIFFERENCE = 0.01;
+
+  /**
+   * Gets a a {@link Track} stub with specified number of locations.
+   * 
+   * @param numberOfLocations the number of locations for the track
+   * @return a track stub.
+   */
+  public static Track createTrack(int numberOfLocations) {
+    Track track = new Track();
+    for (int i = 0; i < numberOfLocations; i++) {
+      track.addLocation(createMyTracksLocation(INITIAL_LATITUDE + i * DIFFERENCE, INITIAL_LONGITUDE
+          + i * DIFFERENCE, INITIAL_ALTITUDE + i * DIFFERENCE));
+    }
+
+    return track;
+  }
+
+  /**
+   * Create a MyTracks location with default values.
+   * 
+   * @return a track stub.
+   */
+  public static MyTracksLocation createMyTracksLocation() {
+    return createMyTracksLocation(INITIAL_LATITUDE, INITIAL_LONGITUDE, INITIAL_ALTITUDE);
+  }
+
+  /**
+   * Creates a {@link MyTracksLocation} stub with specified values.
+   * 
+   * @return a MyTracksLocation stub.
+   */
+  public static MyTracksLocation createMyTracksLocation(double latitude, double longitude,
+      double altitude) {
+    // Initial Location
+    Location loc = new Location(LOCATION_PROVIDER);
+    loc.setLatitude(latitude);
+    loc.setLongitude(longitude);
+    loc.setAltitude(altitude);
+    loc.setAccuracy(INITIAL_ACCURACY);
+    loc.setSpeed(INITIAL_SPEED);
+    loc.setTime(INITIAL_TIME);
+    loc.setBearing(INITIAL_BEARING);
+    SensorDataSet sd = SensorDataSet.newBuilder().build();
+
+    return new MyTracksLocation(loc, sd);
+  }
+
+}

src/androidTest/java/com/google/android/apps/mytracks/content/DescriptionGeneratorImplTest.java

@@ -0,0 +1,204 @@
+/*
+ * 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 com.google.android.apps.mytracks.content;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.platform.app.InstrumentationRegistry;
+
+import com.google.android.apps.mytracks.stats.TripStatistics;
+import com.google.android.apps.mytracks.util.StringUtils;
+import com.google.android.maps.mytracks.R;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.runner.RunWith;
+
+/**
+ * Tests for {@link DescriptionGeneratorImpl}.
+ *
+ * @author Jimmy Shih
+ */
+@RunWith(AndroidJUnit4.class)
+public class DescriptionGeneratorImplTest {
+
+  private static final long START_TIME = 1288721514000L;
+  private DescriptionGeneratorImpl descriptionGenerator;
+
+  @Before
+  protected void setUp() throws Exception {
+    descriptionGenerator = new DescriptionGeneratorImpl(InstrumentationRegistry.getInstrumentation().getContext());
+  }
+
+  /**
+   * Tests {@link DescriptionGeneratorImpl#generateTrackDescription(Track,
+   * java.util.Vector, java.util.Vector, boolean)}.
+   */
+  public void testGenerateTrackDescription() {
+    Track track = new Track();
+    TripStatistics stats = new TripStatistics();
+    stats.setTotalDistance(20000);
+    stats.setTotalTime(600000);
+    stats.setMovingTime(300000);
+    stats.setMaxSpeed(100);
+    stats.setMaxElevation(550);
+    stats.setMinElevation(-500);
+    stats.setTotalElevationGain(6000);
+    stats.setMaxGrade(0.42);
+    stats.setMinGrade(0.11);
+    stats.setStartTime(START_TIME);
+    track.setTripStatistics(stats);
+    track.setCategory("hiking");
+    String expected = "Created by" 
+      + " <a href='http://www.google.com/mobile/mytracks'>Google My Tracks</a> on Android<p>" 
+      + "Name: -<br>"
+      + "Activity type: hiking<br>"
+      + "Description: -<br>"
+      + "Total distance: 20.00 km (12.4 mi)<br>"
+      + "Total time: 10:00<br>"
+      + "Moving time: 05:00<br>"
+      + "Average speed: 120.00 km/h (74.6 mi/h)<br>"
+      + "Average moving speed: 240.00 km/h (149.1 mi/h)<br>"
+      + "Max speed: 360.00 km/h (223.7 mi/h)<br>"
+      + "Average pace: 0:30 min/km (0:48 min/mi)<br>"
+      + "Average moving pace: 0:15 min/km (0:24 min/mi)<br>"
+      + "Fastest pace: 0:10 min/km (0:16 min/mi)<br>"
+      + "Max elevation: 550 m (1804 ft)<br>"
+      + "Min elevation: -500 m (-1640 ft)<br>"
+      + "Elevation gain: 6000 m (19685 ft)<br>"
+      + "Max grade: 42 %<br>"
+      + "Min grade: 11 %<br>"
+      + "Recorded: " + StringUtils.formatDateTime(InstrumentationRegistry.getInstrumentation().getContext(), START_TIME) + "<br>";
+    Assert.assertEquals(expected, descriptionGenerator.generateTrackDescription(track, null, null, true));
+  }
+
+  /**
+   * Tests {@link DescriptionGeneratorImpl#generateWaypointDescription(TripStatistics)}.
+   */
+  public void testGenerateWaypointDescription() {
+    Waypoint waypoint = new Waypoint();
+    TripStatistics stats = new TripStatistics();
+    stats.setTotalDistance(20000);
+    stats.setTotalTime(600000);
+    stats.setMovingTime(300000);
+    stats.setMaxSpeed(100);
+    stats.setMaxElevation(550);
+    stats.setMinElevation(-500);
+    stats.setTotalElevationGain(6000);
+    stats.setMaxGrade(0.42);
+    stats.setMinGrade(0.11);
+    stats.setStartTime(START_TIME);
+    waypoint.setTripStatistics(stats);
+    String expected = "Total distance: 20.00 km (12.4 mi)\n"
+      + "Total time: 10:00\n"
+      + "Moving time: 05:00\n"
+      + "Average speed: 120.00 km/h (74.6 mi/h)\n"
+      + "Average moving speed: 240.00 km/h (149.1 mi/h)\n"
+      + "Max speed: 360.00 km/h (223.7 mi/h)\n"
+      + "Average pace: 0:30 min/km (0:48 min/mi)\n"
+      + "Average moving pace: 0:15 min/km (0:24 min/mi)\n"
+      + "Fastest pace: 0:10 min/km (0:16 min/mi)\n"
+      + "Max elevation: 550 m (1804 ft)\n"
+      + "Min elevation: -500 m (-1640 ft)\n"
+      + "Elevation gain: 6000 m (19685 ft)\n"
+      + "Max grade: 42 %\n"
+      + "Min grade: 11 %\n"
+      + "Recorded: " + StringUtils.formatDateTime(InstrumentationRegistry.getInstrumentation().getContext(), START_TIME) + "\n";
+    Assert.assertEquals(
+        expected, descriptionGenerator.generateWaypointDescription(waypoint.getTripStatistics()));
+  }
+
+  /**
+   * Tests {@link DescriptionGeneratorImpl#writeDistance(double, StringBuilder,
+   * int, String)}.
+   */
+  public void testWriteDistance() {
+    StringBuilder builder = new StringBuilder();
+    descriptionGenerator.writeDistance(1100, builder, R.string.description_total_distance, "<br>");
+    Assert.assertEquals("Total distance: 1.10 km (0.7 mi)<br>", builder.toString());
+  }
+
+  /**
+   * Tests {@link DescriptionGeneratorImpl#writeTime(long, StringBuilder, int,
+   * String)}.
+   */
+  public void testWriteTime() {
+    StringBuilder builder = new StringBuilder();
+    descriptionGenerator.writeTime(1000, builder, R.string.description_total_time, "<br>");
+    Assert.assertEquals("Total time: 00:01<br>", builder.toString());
+  }
+
+  /**
+   * Tests {@link DescriptionGeneratorImpl#writeSpeed(double, StringBuilder,
+   * int, String)}.
+   */
+  public void testWriteSpeed() {
+    StringBuilder builder = new StringBuilder();
+    descriptionGenerator.writeSpeed(1.1, builder, R.string.description_average_speed, "\n");
+    Assert.assertEquals("Average speed: 3.96 km/h (2.5 mi/h)\n", builder.toString());
+  }
+
+  /**
+   * Tests {@link DescriptionGeneratorImpl#writeElevation(double, StringBuilder,
+   * int, String)}.
+   */
+  public void testWriteElevation() {
+    StringBuilder builder = new StringBuilder();
+    descriptionGenerator.writeElevation(4.2, builder, R.string.description_min_elevation, "<br>");
+    Assert.assertEquals("Min elevation: 4 m (14 ft)<br>", builder.toString());
+  }
+
+  /**
+   * Tests {@link DescriptionGeneratorImpl#writePace(double, StringBuilder, int,
+   * String)}.
+   */
+  public void testWritePace() {
+    StringBuilder builder = new StringBuilder();
+    descriptionGenerator.writePace(1.1, builder, R.string.description_average_pace_in_minute, "\n");
+    Assert.assertEquals("Average pace: 15:09 min/km (24:23 min/mi)\n", builder.toString());
+  }
+
+  /**
+   * Tests {@link DescriptionGeneratorImpl#writeGrade(double, StringBuilder,
+   * int, String)}.
+   */
+  public void testWriteGrade() {
+    StringBuilder builder = new StringBuilder();
+    descriptionGenerator.writeGrade(.042, builder, R.string.description_max_grade, "<br>");
+    Assert.assertEquals("Max grade: 4 %<br>", builder.toString());
+  }
+
+  /**
+   * Tests {@link DescriptionGeneratorImpl#writeGrade(double, StringBuilder,
+   * int, String)} with a NaN.
+   */
+  public void testWriteGrade_nan() {
+    StringBuilder builder = new StringBuilder();
+    descriptionGenerator.writeGrade(Double.NaN, builder, R.string.description_max_grade, "<br>");
+    Assert.assertEquals("Max grade: 0 %<br>", builder.toString());
+  }
+
+  /**
+   * Tests {@link DescriptionGeneratorImpl#writeGrade(double, StringBuilder,
+   * int, String)} with an infinite number.
+   */
+  public void testWriteGrade_infinite() {
+    StringBuilder builder = new StringBuilder();
+    descriptionGenerator.writeGrade(
+        Double.POSITIVE_INFINITY, builder, R.string.description_max_grade, "<br>");
+    Assert.assertEquals("Max grade: 0 %<br>", builder.toString());
+  }
+}

src/androidTest/java/com/google/android/apps/mytracks/content/MyTracksProviderTest.java

@@ -0,0 +1,143 @@
+/*
+ * 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 com.google.android.apps.mytracks.content;
+
+import android.database.sqlite.SQLiteDatabase;
+import android.net.Uri;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.platform.app.InstrumentationRegistry;
+
+import com.google.android.apps.mytracks.content.MyTracksProvider.DatabaseHelper;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.runner.RunWith;
+
+/**
+ * Tests {@link MyTracksProvider}.
+ * 
+ * @author Youtao Liu
+ */
+@RunWith(AndroidJUnit4.class)
+public class MyTracksProviderTest {
+
+  private static final String DATABASE_NAME = "mytrackstest.db";
+
+  private SQLiteDatabase db;
+  private MyTracksProvider myTracksProvider;
+
+  @Before
+  protected void setUp()  {
+    InstrumentationRegistry.getInstrumentation().getContext().deleteDatabase(DATABASE_NAME);
+    db = (new DatabaseHelper(InstrumentationRegistry.getInstrumentation().getContext(), DATABASE_NAME)).getWritableDatabase();
+    myTracksProvider = new MyTracksProvider();
+  }
+
+  /**
+   * Tests {@link MyTracksProvider.DatabaseHelper#onCreate(SQLiteDatabase)}.
+   */
+  public void testDatabaseHelper_OnCreate() {
+    Assert.assertTrue(hasTable(TracksColumns.TABLE_NAME));
+    Assert.assertTrue(hasTable(TrackPointsColumns.TABLE_NAME));
+    Assert.assertTrue(hasTable(WaypointsColumns.TABLE_NAME));
+  }
+
+  /**
+   * Tests {@link MyTracksProvider#onCreate(android.content.Context)}.
+   */
+  public void testOnCreate() {
+    Assert.assertTrue(myTracksProvider.onCreate(InstrumentationRegistry.getInstrumentation().getContext()));
+  }
+
+  /**
+   * Tests {@link MyTracksProvider#getType(Uri)}.
+   */
+  public void testGetType() {
+    Assert.assertEquals(TracksColumns.CONTENT_TYPE, myTracksProvider.getType(TracksColumns.CONTENT_URI));
+    Assert.assertEquals(
+        TrackPointsColumns.CONTENT_TYPE, myTracksProvider.getType(TrackPointsColumns.CONTENT_URI));
+    Assert.assertEquals(
+        WaypointsColumns.CONTENT_TYPE, myTracksProvider.getType(WaypointsColumns.CONTENT_URI));
+  }
+
+  /**
+   * Creates a table, containing one column.
+   * 
+   * @param table the table name
+   */
+  private void createTable(String table) {
+    db.execSQL("CREATE TABLE " + table + " (test INTEGER)");
+  }
+
+  /**
+   * Drops a table in database.
+   * 
+   * @param table the table name
+   */
+  private void dropTable(String table) {
+    db.execSQL("Drop TABLE " + table);
+  }
+
+  /**
+   * Returns true if the table exists.
+   * 
+   * @param table the table name
+   */
+  private boolean hasTable(String table) {
+    try {
+      db.rawQuery("select count(*) from " + table, null);
+      return true;
+    } catch (Exception e) {
+      return false;
+    }
+  }
+
+  /**
+   * Returns true if the column in the table exists.
+   * 
+   * @param table the table name
+   * @param column the column name
+   */
+  private boolean hasColumn(String table, String column) {
+    try {
+      db.execSQL("SElECT count(*) from  " + table + " order by  " + column);
+    } catch (Exception e) {
+      if (e.getMessage().indexOf("no such column") > -1) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Sets up upgrade.
+   * 
+   * @param oldVersion thd old database version
+   */
+  private void setupUpgrade(int oldVersion) {
+    dropTable(TracksColumns.TABLE_NAME);
+    dropTable(TrackPointsColumns.TABLE_NAME);
+    dropTable(WaypointsColumns.TABLE_NAME);
+    createTable(TracksColumns.TABLE_NAME);
+    createTable(TrackPointsColumns.TABLE_NAME);
+    createTable(WaypointsColumns.TABLE_NAME);
+
+    DatabaseHelper databaseHelper = new DatabaseHelper(InstrumentationRegistry.getInstrumentation().getContext());
+    databaseHelper.onUpgrade(db, oldVersion, MyTracksProvider.DATABASE_VERSION);
+  }
+}

src/androidTest/java/com/google/android/apps/mytracks/content/MyTracksProviderUtilsImplTest.java

@@ -0,0 +1,912 @@
+/*
+ * 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 com.google.android.apps.mytracks.content;
+
+import android.content.ContentResolver;
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.location.Location;
+import android.test.RenamingDelegatingContext;
+import android.test.mock.MockContentResolver;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils.LocationFactory;
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils.LocationIterator;
+import com.google.android.apps.mytracks.content.Waypoint.WaypointType;
+import com.google.android.apps.mytracks.services.TrackRecordingServiceTest.MockContext;
+import com.google.android.apps.mytracks.stats.TripStatistics;
+import com.google.android.testing.mocking.AndroidMock;
+import com.google.android.testing.mocking.UsesMocks;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.runner.RunWith;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Vector;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * A unit test for {@link MyTracksProviderUtilsImpl}.
+ *
+ * @author Bartlomiej Niechwiej
+ * @author Youtao Liu
+ */
+@RunWith(AndroidJUnit4.class)
+public class MyTracksProviderUtilsImplTest {
+  private Context context;
+  private MyTracksProviderUtils providerUtils;
+  
+  private static final String NAME_PREFIX = "test name";    
+  private static final String MOCK_DESC = "Mock Next Waypoint Desc!";
+  private static final String TEST_DESC = "Test Desc!";
+  private static final String TEST_DESC_NEW = "Test Desc new!";
+  private double INITIAL_LATITUDE = 37.0;
+  private double INITIAL_LONGITUDE = -57.0;
+  private double ALTITUDE_INTERVAL = 2.5;
+
+  @Before
+  protected void setUp() {
+    MockContentResolver mockContentResolver = new MockContentResolver();
+    RenamingDelegatingContext targetContext = new RenamingDelegatingContext(
+        getContext(), getContext(), "test.");
+    context = new MockContext(mockContentResolver, targetContext);
+    MyTracksProvider provider = new MyTracksProvider();
+    provider.attachInfo(context, null);
+    mockContentResolver.addProvider(MyTracksProviderUtils.AUTHORITY, provider);
+    setContext(context);
+
+    providerUtils = MyTracksProviderUtils.Factory.get(context);
+    providerUtils.deleteAllTracks(context);
+  }
+
+  public void testLocationIterator_noPoints() {
+    testIterator(1, 0, 1, false, MyTracksProviderUtils.DEFAULT_LOCATION_FACTORY);
+  }
+
+  public void testLocationIterator_customFactory() {
+    final Location location = new Location("test_location");
+    final AtomicInteger counter = new AtomicInteger();
+    testIterator(1, 15, 4, false, new LocationFactory() {
+      @Override
+      public Location createLocation() {
+        counter.incrementAndGet();
+        return location;
+      }
+    });
+    // Make sure we were called exactly as many times as we had track points.
+    Assert.assertEquals(15, counter.get());
+  }
+  
+  public void testLocationIterator_nullFactory() {
+    try {
+      testIterator(1, 15, 4, false, null);
+      fail("Expecting IllegalArgumentException");
+    } catch (IllegalArgumentException e) {
+      // Expected.
+    }
+  }
+
+  public void testLocationIterator_noBatchAscending() {
+    testIterator(1, 50, 100, false, MyTracksProviderUtils.DEFAULT_LOCATION_FACTORY);
+    testIterator(2, 50, 50, false, MyTracksProviderUtils.DEFAULT_LOCATION_FACTORY);
+  }
+  
+  public void testLocationIterator_noBatchDescending() {
+    testIterator(1, 50, 100, true, MyTracksProviderUtils.DEFAULT_LOCATION_FACTORY);
+    testIterator(2, 50, 50, true, MyTracksProviderUtils.DEFAULT_LOCATION_FACTORY);
+  }
+ 
+  public void testLocationIterator_batchAscending() {
+    testIterator(1, 50, 11, false, MyTracksProviderUtils.DEFAULT_LOCATION_FACTORY);
+    testIterator(2, 50, 25, false, MyTracksProviderUtils.DEFAULT_LOCATION_FACTORY);
+  }
+ 
+  public void testLocationIterator_batchDescending() {
+    testIterator(1, 50, 11, true, MyTracksProviderUtils.DEFAULT_LOCATION_FACTORY);
+    testIterator(2, 50, 25, true, MyTracksProviderUtils.DEFAULT_LOCATION_FACTORY);
+  }
+  
+  public void testLocationIterator_largeTrack() {
+    testIterator(1, 20000, 2000, false, MyTracksProviderUtils.DEFAULT_LOCATION_FACTORY);
+  }
+
+  private List<Location> testIterator(long trackId, int numPoints, int batchSize,
+      boolean descending, LocationFactory locationFactory) {
+    long lastPointId = initializeTrack(trackId, numPoints);
+    ((MyTracksProviderUtilsImpl) providerUtils).setDefaultCursorBatchSize(batchSize);
+    List<Location> locations = new ArrayList<Location>(numPoints);
+    LocationIterator it = providerUtils.getTrackPointLocationIterator(
+        trackId, -1L, descending, locationFactory);
+    try {
+      while (it.hasNext()) {
+        Location loc = it.next();
+        Assert.assertNotNull(loc);
+        locations.add(loc);
+        // Make sure the IDs are returned in the right order.
+        Assert.assertEquals(descending ? lastPointId - locations.size() + 1
+            : lastPointId - numPoints + locations.size(), it.getLocationId());
+      }
+      Assert.assertEquals(numPoints, locations.size());
+    } finally {
+      it.close();
+    }
+    return locations;
+  }
+  
+  private long initializeTrack(long id, int numPoints) {
+    Track track = new Track();
+    track.setId(id);
+    track.setName("Test: " + id);
+    track.setNumberOfPoints(numPoints);
+    providerUtils.insertTrack(track);
+    track = providerUtils.getTrack(id);
+    Assert.assertNotNull(track);
+    
+    Location[] locations = new Location[numPoints];
+    for (int i = 0; i < numPoints; ++i) {
+      Location loc = new Location("test");
+      loc.setLatitude(37.0 + (double) i / 10000.0);
+      loc.setLongitude(57.0 - (double) i / 10000.0);
+      loc.setAccuracy((float) i / 100.0f);
+      loc.setAltitude(i * 2.5);
+      locations[i] = loc;
+    }
+    providerUtils.bulkInsertTrackPoint(locations, numPoints, id);
+    
+    // Load all inserted locations. 
+    long lastPointId = -1;
+    int counter = 0;
+    LocationIterator it = providerUtils.getTrackPointLocationIterator(id, -1L, false,
+        MyTracksProviderUtils.DEFAULT_LOCATION_FACTORY);
+    try {
+      while (it.hasNext()) {
+        it.next();
+        lastPointId = it.getLocationId();
+        counter++;
+      }
+    } finally {
+      it.close();
+    }
+
+    Assert.assertTrue(numPoints == 0 || lastPointId > 0);
+    Assert.assertEquals(numPoints, track.getNumberOfPoints());
+    Assert.assertEquals(numPoints, counter);
+    
+    return lastPointId;
+  }
+  
+  /**
+   * Tests the method {@link MyTracksProviderUtilsImpl#createTrack(Cursor)}.
+   */
+  @UsesMocks(Cursor.class)
+  public void testCreateTrack() {
+    Cursor cursorMock = AndroidMock.createNiceMock(Cursor.class);
+    int startColumnIndex = 1;
+    int columnIndex = startColumnIndex;
+    AndroidMock.expect(cursorMock.getColumnIndexOrThrow(TracksColumns._ID))
+        .andReturn(columnIndex++);
+    AndroidMock.expect(cursorMock.getColumnIndexOrThrow(TracksColumns.NAME)).andReturn(
+        columnIndex++);
+    columnIndex = startColumnIndex;
+    // Id
+    AndroidMock.expect(cursorMock.isNull(columnIndex++)).andReturn(false);
+    // Name
+    AndroidMock.expect(cursorMock.isNull(columnIndex++)).andReturn(false);
+    long trackId = System.currentTimeMillis();
+    columnIndex = startColumnIndex;
+    // Id
+    AndroidMock.expect(cursorMock.getLong(columnIndex++)).andReturn(trackId);
+    // Name
+    String name = NAME_PREFIX + trackId;
+    AndroidMock.expect(cursorMock.getString(columnIndex++)).andReturn(name);
+    AndroidMock.replay(cursorMock);
+    Track track = providerUtils.createTrack(cursorMock);
+    Assert.assertEquals(trackId, track.getId());
+    Assert.assertEquals(name, track.getName());
+    AndroidMock.verify(cursorMock);
+  }
+
+  /**
+   * Tests the method {@link MyTracksProviderUtilsImpl#deleteAllTracks(Context)}
+   */
+  public void testDeleteAllTracks() {
+    // Insert track, points and waypoint at first.
+    long trackId = System.currentTimeMillis();
+    Track track = getTrack(trackId, 10);
+    insertTrackWithLocations(track);
+    Waypoint waypoint = new Waypoint();
+    providerUtils.insertWaypoint(waypoint);
+    ContentResolver contentResolver = context.getContentResolver();
+    Cursor tracksCursor = contentResolver.query(TracksColumns.CONTENT_URI, null, null, null,
+        TracksColumns._ID);
+    Assert.assertEquals(1, tracksCursor.getCount());
+    Cursor tracksPointsCursor = contentResolver.query(TrackPointsColumns.CONTENT_URI, null, null,
+        null, TrackPointsColumns._ID);
+    Assert.assertEquals(10, tracksPointsCursor.getCount());
+    Cursor waypointCursor = contentResolver.query(WaypointsColumns.CONTENT_URI, null, null,
+        null, WaypointsColumns._ID);
+    Assert.assertEquals(1, waypointCursor.getCount());
+    // Delete all.
+    providerUtils.deleteAllTracks(context);
+    // Check whether all have been deleted. 
+    tracksCursor = contentResolver.query(TracksColumns.CONTENT_URI, null, null, null,
+        TracksColumns._ID);
+    Assert.assertEquals(0, tracksCursor.getCount());
+    tracksPointsCursor = contentResolver.query(TrackPointsColumns.CONTENT_URI, null, null,
+        null, TrackPointsColumns._ID);
+    Assert.assertEquals(0, tracksPointsCursor.getCount());
+    waypointCursor = contentResolver.query(WaypointsColumns.CONTENT_URI, null, null,
+        null, WaypointsColumns._ID);
+    Assert.assertEquals(0, waypointCursor.getCount());
+  }
+
+  /**
+   * Tests the method {@link MyTracksProviderUtilsImpl#deleteTrack(Context, long)}.
+   */
+  public void testDeleteTrack() {
+    // Insert three tracks, points of two tracks and way point of one track.
+    long trackId = System.currentTimeMillis();
+    Track track = getTrack(trackId, 10);
+    
+    providerUtils.insertTrack(track);   
+    insertTrackWithLocations(getTrack(trackId + 1, 10));
+    insertTrackWithLocations(getTrack(trackId + 2, 10));
+    
+    Waypoint waypoint = new Waypoint();
+    waypoint.setTrackId(trackId);
+    providerUtils.insertWaypoint(waypoint);
+    
+    ContentResolver contentResolver = context.getContentResolver();
+    Cursor tracksCursor = contentResolver.query(TracksColumns.CONTENT_URI, null, null, null,
+        TracksColumns._ID);
+    Assert.assertEquals(3, tracksCursor.getCount());
+    Cursor tracksPointsCursor = contentResolver.query(TrackPointsColumns.CONTENT_URI, null, null,
+        null, TrackPointsColumns._ID);
+    Assert.assertEquals(20, tracksPointsCursor.getCount());
+    Cursor waypointCursor = contentResolver.query(WaypointsColumns.CONTENT_URI, null, null,
+        null, WaypointsColumns._ID);
+    Assert.assertEquals(1, waypointCursor.getCount());
+    // Delete one track.
+    providerUtils.deleteTrack(context, trackId);
+    // Check whether all data of a track has been deleted. 
+    tracksCursor = contentResolver.query(TracksColumns.CONTENT_URI, null, null, null,
+        TracksColumns._ID);
+    Assert.assertEquals(2, tracksCursor.getCount());
+    tracksPointsCursor = contentResolver.query(TrackPointsColumns.CONTENT_URI, null, null,
+        null, TrackPointsColumns._ID);
+    Assert.assertEquals(20, tracksPointsCursor.getCount());
+    waypointCursor = contentResolver.query(WaypointsColumns.CONTENT_URI, null, null,
+        null, WaypointsColumns._ID);
+    Assert.assertEquals(0, waypointCursor.getCount());
+  }
+
+  /**
+   * Tests the method {@link MyTracksProviderUtilsImpl#getAllTracks()}
+   */
+  public void testGetAllTracks() {
+    int initialTrackNumber = providerUtils.getAllTracks().size();
+    long trackId = System.currentTimeMillis();
+    providerUtils.insertTrack(getTrack(trackId, 0));
+    List<Track> allTracks = providerUtils.getAllTracks();
+    Assert.assertEquals(initialTrackNumber + 1, allTracks.size());
+    Assert.assertEquals(trackId, allTracks.get(allTracks.size() - 1).getId());
+  }
+  
+  /**
+   * Tests the method {@link MyTracksProviderUtilsImpl#getLastTrack()}
+   */
+  public void testGetLastTrack() {
+    long trackId = System.currentTimeMillis();
+    providerUtils.insertTrack(getTrack(trackId, 0));
+    Assert.assertEquals(trackId, providerUtils.getLastTrack().getId());
+  }
+
+  /**
+   * Tests the method {@link MyTracksProviderUtilsImpl#getTrack(long)}
+   */
+  public void testGetTrack() {
+    long trackId = System.currentTimeMillis();
+    providerUtils.insertTrack(getTrack(trackId, 0));
+    Assert.assertNotNull(providerUtils.getTrack(trackId));
+  }
+  
+  /**
+   * Tests the method {@link MyTracksProviderUtilsImpl#updateTrack(Track)}
+   */
+  public void testUpdateTrack() {
+    long trackId = System.currentTimeMillis();
+    Track track = getTrack(trackId, 0);
+    String nameOld = "name1";
+    String nameNew = "name2";
+    track.setName(nameOld);
+    providerUtils.insertTrack(track);
+    Assert.assertEquals(nameOld, providerUtils.getTrack(trackId).getName());
+    track.setName(nameNew);
+    providerUtils.updateTrack(track);
+    Assert.assertEquals(nameNew, providerUtils.getTrack(trackId).getName());
+  }
+  
+  /**
+   * Tests the method {@link MyTracksProviderUtilsImpl#createContentValues(Waypoint)}.
+   */
+  public void testCreateContentValues_waypoint() {
+    long trackId = System.currentTimeMillis();
+    Track track = getTrack(trackId, 10);
+    providerUtils.insertTrack(track);
+    // Bottom
+    long startTime = 1000L;
+    // AverageSpeed
+    double minGrade = -20.11;
+    TripStatistics statistics = new TripStatistics();
+    statistics.setStartTime(startTime);
+    statistics.setStopTime(2500L);
+    statistics.setTotalTime(1500L);
+    statistics.setMovingTime(700L);
+    statistics.setTotalDistance(750.0);
+    statistics.setTotalElevationGain(50.0);
+    statistics.setMaxSpeed(60.0);
+    statistics.setMaxElevation(1250.0);
+    statistics.setMinElevation(1200.0);
+    statistics.setMaxGrade(15.0);
+    statistics.setMinGrade(minGrade);
+    statistics.setBounds(-10000, 20000, 30000, -40000);
+    // Insert at first.
+    Waypoint waypoint = new Waypoint();
+    waypoint.setDescription(TEST_DESC);
+    waypoint.setType(WaypointType.STATISTICS);
+    waypoint.setTripStatistics(statistics);
+    
+    Location loc = new Location("test");
+    loc.setLatitude(22);
+    loc.setLongitude(22);
+    loc.setAccuracy((float) 1 / 100.0f);
+    loc.setAltitude(2.5);
+    waypoint.setLocation(loc);
+    providerUtils.insertWaypoint(waypoint);
+  
+    MyTracksProviderUtilsImpl myTracksProviderUtilsImpl = new MyTracksProviderUtilsImpl(
+        new MockContentResolver());
+    
+    long waypointId = System.currentTimeMillis();
+    waypoint.setId(waypointId);
+    ContentValues contentValues = myTracksProviderUtilsImpl.createContentValues(waypoint);
+    Assert.assertEquals(waypointId, contentValues.get(WaypointsColumns._ID));
+    Assert.assertEquals(22 * 1000000, contentValues.get(WaypointsColumns.LONGITUDE));
+    Assert.assertEquals(TEST_DESC, contentValues.get(WaypointsColumns.DESCRIPTION));
+    Assert.assertEquals(startTime, contentValues.get(WaypointsColumns.STARTTIME));
+    Assert.assertEquals(minGrade, contentValues.get(WaypointsColumns.MINGRADE));
+  }
+
+  /**
+   * Tests the method {@link MyTracksProviderUtilsImpl#createWaypoint(Cursor)}.
+   */
+  @UsesMocks(Cursor.class)
+  public void testCreateWaypoint() {
+    Cursor cursorMock = AndroidMock.createNiceMock(Cursor.class);
+    int startColumnIndex = 1;
+    int columnIndex = startColumnIndex;
+    AndroidMock.expect(cursorMock.getColumnIndexOrThrow(WaypointsColumns._ID))
+        .andReturn(columnIndex++);
+    AndroidMock.expect(cursorMock.getColumnIndexOrThrow(WaypointsColumns.NAME)).andReturn(
+        columnIndex++);
+    AndroidMock.expect(cursorMock.getColumnIndexOrThrow(WaypointsColumns.TRACKID)).andReturn(
+        columnIndex++);
+    columnIndex = startColumnIndex;
+    // Id
+    AndroidMock.expect(cursorMock.isNull(columnIndex++)).andReturn(false);
+    // Name
+    AndroidMock.expect(cursorMock.isNull(columnIndex++)).andReturn(false);
+    // trackIdIndex
+    AndroidMock.expect(cursorMock.isNull(columnIndex++)).andReturn(false);
+    long id = System.currentTimeMillis();
+    columnIndex = startColumnIndex;
+    // Id
+    AndroidMock.expect(cursorMock.getLong(columnIndex++)).andReturn(id);
+    // Name
+    String name = NAME_PREFIX + id;
+    AndroidMock.expect(cursorMock.getString(columnIndex++)).andReturn(name);
+    // trackIdIndex
+    long trackId = 11L;
+    AndroidMock.expect(cursorMock.getLong(columnIndex++)).andReturn(trackId);
+    AndroidMock.replay(cursorMock);
+    Waypoint waypoint = providerUtils.createWaypoint(cursorMock);
+    Assert.assertEquals(id, waypoint.getId());
+    Assert.assertEquals(name, waypoint.getName());
+    Assert.assertEquals(trackId, waypoint.getTrackId());
+    AndroidMock.verify(cursorMock);
+  }
+
+  /**
+   * Tests the method
+   * {@link MyTracksProviderUtilsImpl#deleteWaypoint(Context, long, DescriptionGenerator)}
+   * when there is only one waypoint in the track.
+   */
+  public void testDeleteWaypoint_onlyOneWayPoint() {
+    long trackId = System.currentTimeMillis();
+    Track track = getTrack(trackId, 10);
+    providerUtils.insertTrack(track);
+  
+    // Insert at first.
+    Waypoint waypoint1 = new Waypoint();
+    waypoint1.setDescription(TEST_DESC);
+    waypoint1.setTrackId(trackId);
+    waypoint1.setType(WaypointType.STATISTICS);
+    providerUtils.insertWaypoint(waypoint1);
+  
+    // Delete
+    DescriptionGenerator descriptionGenerator = new DescriptionGenerator() {
+  
+      @Override
+      public String generateWaypointDescription(TripStatistics tripStatistics) {
+        return MyTracksProviderUtilsImplTest.MOCK_DESC;
+      }
+  
+      @Override
+      public String generateTrackDescription(Track aTrack, Vector<Double> distances,
+          Vector<Double> elevations, boolean html) {
+        return null;
+      }
+    };
+    providerUtils.deleteWaypoint(context, 1, descriptionGenerator);
+  
+    Assert.assertNull(providerUtils.getWaypoint(1));
+  }
+
+  /**
+   * Tests the method
+   * {@link MyTracksProviderUtilsImpl#deleteWaypoint(Context, long, DescriptionGenerator)}
+   * when there is more than one waypoint in the track.
+   */
+  public void testDeleteWaypoint_hasNextWayPoint() {
+    long trackId = System.currentTimeMillis();
+    Track track = getTrack(trackId, 10);
+    providerUtils.insertTrack(track);
+  
+    TripStatistics statistics = new TripStatistics();
+    statistics.setStartTime(1000L);
+    statistics.setStopTime(2500L);
+    statistics.setTotalTime(1500L);
+    statistics.setMovingTime(700L);
+    statistics.setTotalDistance(750.0);
+    statistics.setTotalElevationGain(50.0);
+    statistics.setMaxSpeed(60.0);
+    statistics.setMaxElevation(1250.0);
+    statistics.setMinElevation(1200.0);
+    statistics.setMaxGrade(15.0);
+    statistics.setMinGrade(-25.0);
+    statistics.setBounds(-10000, 20000, 30000, -40000);
+    // Insert at first.
+    Waypoint waypoint1 = new Waypoint();
+    waypoint1.setDescription(Long.toString(trackId));
+    waypoint1.setTrackId(trackId);
+    waypoint1.setType(WaypointType.STATISTICS);
+    waypoint1.setTripStatistics(statistics);
+    providerUtils.insertWaypoint(waypoint1);
+    Waypoint waypoint2 = new Waypoint();
+    waypoint2.setDescription(Long.toString(trackId));
+    waypoint2.setTrackId(trackId);
+    waypoint2.setType(WaypointType.STATISTICS);
+    waypoint2.setTripStatistics(statistics);
+    providerUtils.insertWaypoint(waypoint2);
+  
+    // Delete
+    DescriptionGenerator descriptionGenerator = new DescriptionGenerator() {
+      @Override
+      public String generateWaypointDescription(TripStatistics tripStatistics) {
+        return MyTracksProviderUtilsImplTest.MOCK_DESC;
+      }
+  
+      @Override
+      public String generateTrackDescription(Track aTrack, Vector<Double> distances,
+          Vector<Double> elevations, boolean html) {
+        return null;
+      }
+    };
+    providerUtils.deleteWaypoint(context, 1, descriptionGenerator);
+  
+    Assert.assertNull(providerUtils.getWaypoint(1));
+    Assert.assertEquals(MyTracksProviderUtilsImplTest.MOCK_DESC, providerUtils.getWaypoint(2)
+        .getDescription());
+  }
+
+  /**
+   * Tests the method {@link MyTracksProviderUtilsImpl#getFirstWaypointId(long)}.
+   */
+  public void testGetFirstWaypointId() {
+    long trackId = System.currentTimeMillis();
+    Track track = getTrack(trackId, 10);
+    providerUtils.insertTrack(track);
+    
+    Waypoint waypoint1 = new Waypoint();
+    waypoint1.setTrackId(trackId);
+    Waypoint waypoint2 = new Waypoint();
+    waypoint2.setTrackId(trackId);
+    providerUtils.insertWaypoint(waypoint1);
+    providerUtils.insertWaypoint(waypoint2);
+    
+    Assert.assertEquals(-1L, providerUtils.getFirstWaypointId(-1));
+    Assert.assertEquals(1L, providerUtils.getFirstWaypointId(trackId));
+  }
+
+  /**
+   * Tests the method {@link MyTracksProviderUtilsImpl#getNextWaypointNumber(long, WaypointType)}.
+   */
+  public void testGetNextWaypointNumber() {
+    long trackId = System.currentTimeMillis();
+    Track track = getTrack(trackId, 10);
+    providerUtils.insertTrack(track);
+    
+    Waypoint waypoint1 = new Waypoint();
+    waypoint1.setType(WaypointType.STATISTICS);
+    waypoint1.setTrackId(trackId);
+    Waypoint waypoint2 = new Waypoint();
+    waypoint2.setType(WaypointType.WAYPOINT);
+    waypoint2.setTrackId(trackId);
+    Waypoint waypoint3 = new Waypoint();
+    waypoint3.setType(WaypointType.STATISTICS);
+    waypoint3.setTrackId(trackId);
+    Waypoint waypoint4 = new Waypoint();
+    waypoint4.setType(WaypointType.WAYPOINT);
+    waypoint4.setTrackId(trackId);
+    providerUtils.insertWaypoint(waypoint1);
+    providerUtils.insertWaypoint(waypoint2);
+    providerUtils.insertWaypoint(waypoint3);
+    providerUtils.insertWaypoint(waypoint4);
+    
+    Assert.assertEquals(2, providerUtils.getNextWaypointNumber(trackId, WaypointType.STATISTICS));
+    Assert.assertEquals(3, providerUtils.getNextWaypointNumber(trackId, WaypointType.WAYPOINT));
+  }
+
+  /**
+   * Tests the method
+   * {@link MyTracksProviderUtils#getLastWaypoint(long, WaypointType)}.
+   */
+  public void testGetLastStatisticsWaypoint() {
+    long trackId = System.currentTimeMillis();
+    Track track = getTrack(trackId, 10);
+    providerUtils.insertTrack(track);
+
+    Waypoint waypoint1 = new Waypoint();
+    waypoint1.setTrackId(trackId);
+    waypoint1.setType(WaypointType.STATISTICS);
+    waypoint1.setDescription("Desc1");
+    Waypoint waypoint2 = new Waypoint();
+    waypoint2.setTrackId(trackId);
+    waypoint2.setType(WaypointType.STATISTICS);
+    waypoint2.setDescription("Desc2");
+    Waypoint waypoint3 = new Waypoint();
+    waypoint3.setTrackId(trackId);
+    waypoint3.setType(WaypointType.WAYPOINT);
+    waypoint3.setDescription("Desc3");
+    providerUtils.insertWaypoint(waypoint1);
+    providerUtils.insertWaypoint(waypoint2);
+    providerUtils.insertWaypoint(waypoint3);
+
+    Assert.assertEquals("Desc2", providerUtils.getLastWaypoint(trackId, WaypointType.STATISTICS).getDescription());
+  }
+
+  /**
+   * Tests the method {@link MyTracksProviderUtilsImpl#insertWaypoint(Waypoint)} and
+   * {@link MyTracksProviderUtilsImpl#getWaypoint(long)}.
+   */
+  public void testInsertAndGetWaypoint() {
+    long trackId = System.currentTimeMillis();
+    Track track = getTrack(trackId, 10);
+    providerUtils.insertTrack(track);
+    
+    Waypoint waypoint = new Waypoint();
+    waypoint.setDescription(TEST_DESC);
+    waypoint.setTrackId(trackId);
+    providerUtils.insertWaypoint(waypoint);
+    
+    Assert.assertEquals(TEST_DESC, providerUtils.getWaypoint(1).getDescription());
+  }
+  
+  /**
+   * Tests the method {@link MyTracksProviderUtilsImpl#updateWaypoint(Waypoint)}.
+   */
+  public void testUpdateWaypoint() {
+    long trackId = System.currentTimeMillis();
+    Track track = getTrack(trackId, 10);
+    providerUtils.insertTrack(track);
+    // Insert at first.
+    Waypoint waypoint = new Waypoint();
+    waypoint.setDescription(TEST_DESC);
+    waypoint.setTrackId(trackId);
+    providerUtils.insertWaypoint(waypoint);
+    // Update
+    waypoint = providerUtils.getWaypoint(1);
+    waypoint.setDescription(TEST_DESC_NEW);
+    providerUtils.updateWaypoint(waypoint);
+  
+    Assert.assertEquals(TEST_DESC_NEW, providerUtils.getWaypoint(1).getDescription());
+  }
+
+  /**
+   * Tests the method {@link MyTracksProviderUtilsImpl#bulkInsertTrackPoint(Location[],
+   * int, long)}.
+   */
+  public void testBulkInsertTrackPoint() {
+    // Insert track, point at first.
+    long trackId = System.currentTimeMillis();
+    Track track = getTrack(trackId, 10);
+    insertTrackWithLocations(track);
+  
+    providerUtils.bulkInsertTrackPoint(track.getLocations().toArray(new Location[0]), -1, trackId);
+    Assert.assertEquals(20, providerUtils.getTrackPointCursor(trackId, -1L, 1000, false).getCount());
+    providerUtils.bulkInsertTrackPoint(track.getLocations().toArray(new Location[0]), 8, trackId);
+    Assert.assertEquals(28, providerUtils.getTrackPointCursor(trackId, -1L, 1000, false).getCount());
+  }
+
+  /**
+   * Tests the method {@link MyTracksProviderUtilsImpl#createTrackPoint(Cursor)}.
+   */
+  @UsesMocks(Cursor.class)
+  public void testCreateTrackPoint() {
+    Cursor cursorMock = AndroidMock.createNiceMock(Cursor.class);
+  
+    // Set index.
+    int index = 1;
+    // Id
+    AndroidMock.expect(cursorMock.getColumnIndex(TrackPointsColumns._ID)).andReturn(index++);
+    // Longitude
+    AndroidMock.expect(cursorMock.getColumnIndexOrThrow(TrackPointsColumns.LONGITUDE)).andReturn(
+        index++);
+    // Latitude
+    AndroidMock.expect(cursorMock.getColumnIndexOrThrow(TrackPointsColumns.LATITUDE)).andReturn(
+        index++);
+    // Time
+    AndroidMock.expect(cursorMock.getColumnIndexOrThrow(TrackPointsColumns.TIME))
+        .andReturn(index++);
+    // Speed
+    AndroidMock.expect(cursorMock.getColumnIndexOrThrow(TrackPointsColumns.SPEED)).andReturn(
+        index++);
+    // Sensor
+    AndroidMock.expect(cursorMock.getColumnIndexOrThrow(TrackPointsColumns.SENSOR_HEARTRATE)).andReturn(
+        index++);
+  
+    // Set return value of isNull().
+    index = 2;
+    // Longitude
+    AndroidMock.expect(cursorMock.isNull(index++)).andReturn(false);
+    // Latitude
+    AndroidMock.expect(cursorMock.isNull(index++)).andReturn(false);
+    // Time
+    AndroidMock.expect(cursorMock.isNull(index++)).andReturn(false);
+    // Speed
+    AndroidMock.expect(cursorMock.isNull(index++)).andReturn(false);
+    // Sensor
+    AndroidMock.expect(cursorMock.isNull(index++)).andReturn(false);
+  
+    // Set return value of isNull().
+    index = 2;
+    // Longitude
+    int longitude = 11;
+    AndroidMock.expect(cursorMock.getInt(index++)).andReturn(longitude * 1000000);
+    // Latitude.
+    int latitude = 22;
+    AndroidMock.expect(cursorMock.getInt(index++)).andReturn(latitude * 1000000);
+    // Time
+    long time = System.currentTimeMillis();
+    AndroidMock.expect(cursorMock.getLong(index++)).andReturn(time);
+    // Speed
+    float speed = 2.2f;
+    AndroidMock.expect(cursorMock.getFloat(index++)).andReturn(speed);
+    // Sensor
+    byte[] sensor = "Sensor state".getBytes();
+    AndroidMock.expect(cursorMock.getBlob(index++)).andReturn(sensor);
+  
+    AndroidMock.replay(cursorMock);
+    Location location = providerUtils.createTrackPoint(cursorMock);
+    Assert.assertEquals((double) longitude, location.getLongitude());
+    Assert.assertEquals((double) latitude, location.getLatitude());
+    Assert.assertEquals(time, location.getTime());
+    Assert.assertEquals(speed, location.getSpeed());
+    AndroidMock.verify(cursorMock);
+  }
+
+  /**
+   * Tests the method
+   * {@link MyTracksProviderUtilsImpl#insertTrackPoint(Location, long)}.
+   */
+  public void testInsertTrackPoint() {
+    // Insert track, point at first.
+    long trackId = System.currentTimeMillis();
+    Track track = getTrack(trackId, 10);
+    insertTrackWithLocations(track);
+
+    providerUtils.insertTrackPoint(createLocation(22), trackId);
+    Assert.assertEquals(11, providerUtils.getTrackPointCursor(trackId, -1L, 1000, false).getCount());
+  }
+
+  /**
+   * Tests the method {@link MyTracksProviderUtilsImpl#getFirstTrackPointId(long)}.
+   */
+  public void testGetFirstTrackPointId() {
+    // Insert track, point at first.
+    long trackId = System.currentTimeMillis();
+    Track track = getTrack(trackId, 10);
+    insertTrackWithLocations(track);
+  
+    Assert.assertEquals(1, providerUtils.getFirstTrackPointId(trackId));
+  }
+  
+  /**
+   * Tests the method {@link MyTracksProviderUtilsImpl#getLastTrackPointId(long)}.
+   */
+  public void testGetLastTrackPointId() {
+    // Insert track, point at first.
+    long trackId = System.currentTimeMillis();
+    Track track = getTrack(trackId, 10);
+    insertTrackWithLocations(track);
+  
+    Assert.assertEquals(10, providerUtils.getLastTrackPointId(trackId));
+  }
+
+  /**
+   * Tests the method {@link MyTracksProviderUtilsImpl#getLastValidTrackPoint(long)}.
+   */
+  public void testGetLastValidTrackPoint() {
+    // Insert track, points at first.
+    long trackId = System.currentTimeMillis();
+    Track track = getTrack(trackId, 10);
+    insertTrackWithLocations(track);
+
+    Location lastLocation = providerUtils.getLastValidTrackPoint(trackId);
+    checkLocation(9, lastLocation);
+  }
+
+  /**
+   * Tests the method
+   * {@link MyTracksProviderUtilsImpl#getTrackPointCursor(long, long, int, boolean)}
+   * in descending.
+   */
+  public void testGetTrackPointCursor_desc() {
+    // Insert track, points at first.
+    long trackId = System.currentTimeMillis();
+    Track track = getTrack(trackId, 10);
+    insertTrackWithLocations(track);
+
+    Cursor cursor = providerUtils.getTrackPointCursor(trackId, 2L, 5, true);
+    Assert.assertEquals(2, cursor.getCount());
+  }
+  
+  /**
+   * Tests the method
+   * {@link MyTracksProviderUtilsImpl#getTrackPointCursor(long, long, int, boolean)}
+   * in ascending.
+   */
+  public void testGetTrackPointCursor_asc() {
+    // Insert track, points at first.
+    long trackId = System.currentTimeMillis();
+    Track track = getTrack(trackId, 10);
+    insertTrackWithLocations(track);
+
+    Cursor cursor = providerUtils.getTrackPointCursor(trackId, 2L, 5, false);
+    Assert.assertEquals(5, cursor.getCount());
+  }
+  
+  /**
+   * Tests the method
+   * {@link MyTracksProviderUtilsImpl#getTrackPointLocationIterator(long, long, boolean, LocationFactory)}
+   * in descending.
+   */
+  public void testGetTrackPointLocationIterator_desc() {
+    // Insert track, points at first.
+    long trackId = System.currentTimeMillis();
+    Track track = getTrack(trackId, 10);
+    insertTrackWithLocations(track);
+
+    long startTrackPointId = 2L;
+
+    LocationIterator locationIterator = providerUtils.getTrackPointLocationIterator(trackId,
+        startTrackPointId, true, MyTracksProviderUtils.DEFAULT_LOCATION_FACTORY);
+    for (int i = 1; i >= 0; i--) {
+      Assert.assertTrue(locationIterator.hasNext());
+      Location location = locationIterator.next();
+      Assert.assertEquals(2 + (i - 1), locationIterator.getLocationId());
+      checkLocation(i, location);
+    }
+    Assert.assertFalse(locationIterator.hasNext());
+  }
+  
+  /**
+   * Tests the method
+   * {@link MyTracksProviderUtilsImpl#getTrackPointLocationIterator(long, long, boolean, LocationFactory)}
+   * in ascending.
+   */
+  public void testGetTrackPointLocationIterator_asc() {
+    // Insert track, point at first.
+    long trackId = System.currentTimeMillis();
+    Track track = getTrack(trackId, 10);
+    insertTrackWithLocations(track);
+
+    long startTrackPointId = 2L;
+
+    LocationIterator locationIterator = providerUtils.getTrackPointLocationIterator(trackId,
+        startTrackPointId, false, MyTracksProviderUtils.DEFAULT_LOCATION_FACTORY);
+    
+    for (int i = 1; i < 10; i++) {
+      Assert.assertTrue(locationIterator.hasNext());
+      Location location = locationIterator.next();
+      Assert.assertEquals(2 + (i - 1), locationIterator.getLocationId());
+      checkLocation(i, location);
+    }
+    Assert.assertFalse(locationIterator.hasNext());
+  }
+
+  /**
+   * Simulates a track which is used for testing.
+   * 
+   * @param id the id of the track
+   * @param numPoints the location number in the track
+   * @return the simulated track
+   */
+  private Track getTrack(long id,int numPoints) {
+    Track track = new Track();
+    track.setId(id);
+    track.setName("Test: " + id);
+    track.setNumberOfPoints(numPoints);
+    for(int i = 0; i < numPoints; i++) {
+      track.addLocation(createLocation(i));
+    }
+    return track;
+  }
+  
+  /**
+   * Creates a location.
+   * @param i the index to set the value of location.
+   * @return created location
+   */
+  private Location createLocation(int i) {
+    
+    Location loc = new Location("test");
+    loc.setLatitude(INITIAL_LATITUDE + (double) i / 10000.0);
+    loc.setLongitude(INITIAL_LONGITUDE - (double) i / 10000.0);
+    loc.setAccuracy((float) i / 100.0f);
+    loc.setAltitude(i * ALTITUDE_INTERVAL);
+    return loc;
+  }
+  
+  /**
+   * Checks the value of a location.
+   * 
+   * @param i the index of this location which created in the method
+   *          {@link MyTracksProviderUtilsImplTest#getTrack(long, int)}
+   * @param location the location to be checked
+   */
+  private void checkLocation(int i, Location location) {
+    Assert.assertEquals(INITIAL_LATITUDE + (double) i / 10000.0, location.getLatitude());
+    Assert.assertEquals(INITIAL_LONGITUDE - (double) i / 10000.0, location.getLongitude());
+    Assert.assertEquals((float) i / 100.0f, location.getAccuracy());
+    Assert.assertEquals(i * ALTITUDE_INTERVAL, location.getAltitude());
+  }
+  
+  /**
+   * Inserts a track with locations into the database.
+   * 
+   * @param track track to be inserted
+   */
+  private void insertTrackWithLocations(Track track) {
+    providerUtils.insertTrack(track);
+    providerUtils.bulkInsertTrackPoint(track.getLocations().toArray(new Location[0]), track
+        .getLocations().size(), track.getId());
+  }
+}

src/androidTest/java/com/google/android/apps/mytracks/content/SearchEngineTest.java

@@ -0,0 +1,328 @@
+/*
+ * 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 com.google.android.apps.mytracks.content;
+
+import android.content.ContentUris;
+import android.location.Location;
+import android.net.Uri;
+import android.test.RenamingDelegatingContext;
+import android.test.mock.MockContentResolver;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import com.google.android.apps.mytracks.content.SearchEngine.ScoredResult;
+import com.google.android.apps.mytracks.content.SearchEngine.SearchQuery;
+import com.google.android.apps.mytracks.services.TrackRecordingServiceTest.MockContext;
+import com.google.android.apps.mytracks.stats.TripStatistics;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.runner.RunWith;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Tests for {@link SearchEngine}.
+ * These are not meant to be quality tests, but instead feature-by-feature tests
+ * (in other words, they don't test the mixing of different score boostings, just
+ * each boosting separately)
+ *
+ * @author Rodrigo Damazio
+ */
+@RunWith(AndroidJUnit4.class)
+public class SearchEngineTest {
+
+  private static final Location HERE = new Location("gps");
+  private static final long NOW = 1234567890000L;  // After OLDEST_ALLOWED_TIMESTAMP
+  private MyTracksProviderUtils providerUtils;
+  private SearchEngine engine;
+
+  @Before
+  protected void setUp() {
+    MockContentResolver mockContentResolver = new MockContentResolver();
+    RenamingDelegatingContext targetContext = new RenamingDelegatingContext(
+        getContext(), getContext(), "test.");
+    MockContext context = new MockContext(mockContentResolver, targetContext);
+    MyTracksProvider provider = new MyTracksProvider();
+    provider.attachInfo(context, null);
+    mockContentResolver.addProvider(MyTracksProviderUtils.AUTHORITY, provider);
+    setContext(context);
+
+    providerUtils = MyTracksProviderUtils.Factory.get(context);
+    engine = new SearchEngine(providerUtils);
+  }
+
+  @After
+  protected void tearDown() throws Exception {
+    providerUtils.deleteAllTracks(getContext());
+  }
+
+  private long insertTrack(String title, String description, String category, double distance, long hoursAgo) {
+    Track track = new Track();
+    track.setName(title);
+    track.setDescription(description);
+    track.setCategory(category);
+
+    TripStatistics stats = track.getTripStatistics();
+    if (hoursAgo > 0) {
+      // Started twice hoursAgo, so the average time is hoursAgo.
+      stats.setStartTime(NOW - hoursAgo * 1000L * 60L * 60L * 2);
+      stats.setStopTime(NOW);
+    }
+
+    int latitude = (int) ((HERE.getLatitude() + distance) * 1E6);
+    int longitude = (int) ((HERE.getLongitude() + distance) * 1E6);
+    stats.setBounds(latitude, longitude, latitude, longitude);
+
+    Uri uri = providerUtils.insertTrack(track);
+    return ContentUris.parseId(uri);
+  }
+
+  private long insertTrack(String title, String description, String category) {
+    return insertTrack(title, description, category, 0, -1);
+  }
+
+  private long insertTrack(String title, double distance) {
+    return insertTrack(title, "", "", distance, -1);
+  }
+
+  private long insertTrack(String title, long hoursAgo) {
+    return insertTrack(title, "", "", 0.0, hoursAgo);
+  }
+
+  private long insertWaypoint(String title, String description, String category, double distance, long hoursAgo, long trackId) {
+    Waypoint waypoint = new Waypoint();
+    waypoint.setName(title);
+    waypoint.setDescription(description);
+    waypoint.setCategory(category);
+    waypoint.setTrackId(trackId);
+
+    Location location = new Location(HERE);
+    location.setLatitude(location.getLatitude() + distance);
+    location.setLongitude(location.getLongitude() + distance);
+    if (hoursAgo >= 0) {
+      location.setTime(NOW - hoursAgo * 1000L * 60L * 60L);
+    }
+    waypoint.setLocation(location);
+
+    Uri uri = providerUtils.insertWaypoint(waypoint);
+    return ContentUris.parseId(uri);
+  }
+
+  private long insertWaypoint(String title, String description, String category) {
+    return insertWaypoint(title, description, category, 0.0, -1, -1);
+  }
+
+  private long insertWaypoint(String title, double distance) {
+    return insertWaypoint(title, "", "", distance, -1, -1);
+  }
+
+  private long insertWaypoint(String title, long hoursAgo) {
+    return insertWaypoint(title, "", "", 0.0, hoursAgo, -1);
+  }
+
+  private long insertWaypoint(String title, long hoursAgo, long trackId) {
+    return insertWaypoint(title, "", "", 0.0, hoursAgo, trackId);
+  }
+
+  public void testSearchText() {
+    // Insert 7 tracks (purposefully out of result order):
+    // - one which won't match
+    // - one which will match the description
+    // - one which will match the category
+    // - one which will match the title
+    // - one which will match in title and category
+    // - one which will match in title and description
+    // - one which will match in all fields
+    insertTrack("bb", "cc", "dd");
+    long descriptionMatchId = insertTrack("bb", "aa", "cc");
+    long categoryMatchId = insertTrack("bb", "cc", "aa");
+    long titleMatchId = insertTrack("aa", "bb", "cc");
+    long titleCategoryMatchId = insertTrack("aa", "bb", "ca");
+    long titleDescriptionMatchId = insertTrack("aa", "ba", "cc");
+    long allMatchId = insertTrack("aa", "ba", "ca");
+
+    SearchQuery query = new SearchQuery("a", null, -1, NOW);
+    ArrayList<ScoredResult> results = new ArrayList<ScoredResult>(engine.search(query));
+
+    // Title > Description > Category.
+    assertTrackResults(results,
+        allMatchId, titleDescriptionMatchId, titleCategoryMatchId, titleMatchId, descriptionMatchId,
+        categoryMatchId);
+  }
+
+  public void testSearchWaypointText() {
+    // Insert 7 waypoints (purposefully out of result order):
+    // - one which won't match
+    // - one which will match the description
+    // - one which will match the category
+    // - one which will match the title
+    // - one which will match in title and category
+    // - one which will match in title and description
+    // - one which will match in all fields
+    insertWaypoint("bb", "cc", "dd");
+    long descriptionMatchId = insertWaypoint("bb", "aa", "cc");
+    long categoryMatchId = insertWaypoint("bb", "cc", "aa");
+    long titleMatchId = insertWaypoint("aa", "bb", "cc");
+    long titleCategoryMatchId = insertWaypoint("aa", "bb", "ca");
+    long titleDescriptionMatchId = insertWaypoint("aa", "ba", "cc");
+    long allMatchId = insertWaypoint("aa", "ba", "ca");
+
+    SearchQuery query = new SearchQuery("a", null, -1, NOW);
+    ArrayList<ScoredResult> results = new ArrayList<ScoredResult>(engine.search(query));
+
+    // Title > Description > Category.
+    assertWaypointResults(results,
+        allMatchId, titleDescriptionMatchId, titleCategoryMatchId, titleMatchId, descriptionMatchId,
+        categoryMatchId);
+  }
+
+  public void testSearchMixedText() {
+    // Insert 5 entries (purposefully out of result order):
+    // - one waypoint which will match by description
+    // - one waypoint which won't match
+    // - one waypoint which will match by title
+    // - one track which won't match
+    // - one track which will match by title
+    long descriptionWaypointId = insertWaypoint("bb", "aa", "cc");
+    insertWaypoint("bb", "cc", "dd");
+    long titleWaypointId = insertWaypoint("aa", "bb", "cc");
+    insertTrack("bb", "cc", "dd");
+    long trackId = insertTrack("aa", "bb", "cc");
+
+    SearchQuery query = new SearchQuery("a", null, -1, NOW);
+    ArrayList<ScoredResult> results = new ArrayList<ScoredResult>(engine.search(query));
+
+    // Title > Description > Category.
+    assertEquals(results.toString(), 3, results.size());
+    assertTrackResult(trackId, results.get(0));
+    assertWaypointResult(titleWaypointId, results.get(1));
+    assertWaypointResult(descriptionWaypointId, results.get(2));
+  }
+
+  public void testSearchTrackDistance() {
+    // All results match text, but they're at difference distances from the user.
+    long farFarAwayId = insertTrack("aa", 0.3);
+    long nearId = insertTrack("ab", 0.1);
+    long farId = insertTrack("ac", 0.2);
+
+    SearchQuery query = new SearchQuery("a", HERE, -1, NOW);
+    ArrayList<ScoredResult> results = new ArrayList<ScoredResult>(engine.search(query));
+
+    // Distance order.
+    assertTrackResults(results, nearId, farId, farFarAwayId);
+  }
+
+  public void testSearchWaypointDistance() {
+    // All results match text, but they're at difference distances from the user.
+    long farFarAwayId = insertWaypoint("aa", 0.3);
+    long nearId = insertWaypoint("ab", 0.1);
+    long farId = insertWaypoint("ac", 0.2);
+
+    SearchQuery query = new SearchQuery("a", HERE, -1, NOW);
+    ArrayList<ScoredResult> results = new ArrayList<ScoredResult>(engine.search(query));
+
+    // Distance order.
+    assertWaypointResults(results, nearId, farId, farFarAwayId);
+  }
+
+  public void testSearchTrackRecent() {
+    // All results match text, but they're were recorded at different times.
+    long oldestId = insertTrack("aa", 3);
+    long recentId = insertTrack("ab", 1);
+    long oldId = insertTrack("ac", 2);
+
+    SearchQuery query = new SearchQuery("a", null, -1, NOW);
+    ArrayList<ScoredResult> results = new ArrayList<ScoredResult>(engine.search(query));
+
+    // Reverse time order.
+    assertTrackResults(results, recentId, oldId, oldestId);
+  }
+
+  public void testSearchWaypointRecent() {
+    // All results match text, but they're were recorded at different times.
+    long oldestId = insertWaypoint("aa", 2);
+    long recentId = insertWaypoint("ab", 0);
+    long oldId = insertWaypoint("ac", 1);
+
+    SearchQuery query = new SearchQuery("a", null, -1, NOW);
+    ArrayList<ScoredResult> results = new ArrayList<ScoredResult>(engine.search(query));
+
+    // Reverse time order.
+    assertWaypointResults(results, recentId, oldId, oldestId);
+  }
+
+  public void testSearchCurrentTrack() {
+    // All results match text, but one of them is the current track.
+    long currentId = insertTrack("ab", 1);
+    long otherId = insertTrack("aa", 1);
+
+    SearchQuery query = new SearchQuery("a", null, currentId, NOW);
+    ArrayList<ScoredResult> results = new ArrayList<ScoredResult>(engine.search(query));
+
+    // Current track should be demoted.
+    assertTrackResults(results, otherId, currentId);
+  }
+
+  public void testSearchCurrentTrackWaypoint() {
+    // All results match text, but one of them is in the current track.
+    long otherId = insertWaypoint("aa", 1, 456);
+    long currentId = insertWaypoint("ab", 1, 123);
+
+    SearchQuery query = new SearchQuery("a", null, 123, NOW);
+    ArrayList<ScoredResult> results = new ArrayList<ScoredResult>(engine.search(query));
+
+    // Waypoint in current track should be promoted.
+    assertWaypointResults(results, currentId, otherId);
+  }
+
+  private void assertTrackResult(long trackId, ScoredResult result) {
+    assertNotNull("Not a track", result.track);
+    assertNull("Ambiguous result", result.waypoint);
+    assertEquals(trackId, result.track.getId());
+  }
+
+  private void assertTrackResults(List<ScoredResult> results, long... trackIds) {
+    String errMsg = "Expected IDs=" + Arrays.toString(trackIds) + "; results=" + results;
+    assertEquals(results.size(), trackIds.length);
+    for (int i = 0; i < results.size(); i++) {
+      ScoredResult result = results.get(i);
+      assertNotNull(errMsg, result.track);
+      assertNull(errMsg, result.waypoint);
+      assertEquals(errMsg, trackIds[i], result.track.getId());
+    }
+  }
+
+  private void assertWaypointResult(long waypointId, ScoredResult result) {
+    assertNotNull("Not a waypoint", result.waypoint);
+    assertNull("Ambiguous result", result.track);
+    assertEquals(waypointId, result.waypoint.getId());
+  }
+
+  private void assertWaypointResults(List<ScoredResult> results, long... waypointIds) {
+    String errMsg = "Expected IDs=" + Arrays.toString(waypointIds) + "; results=" + results;
+    assertEquals(results.size(), waypointIds.length);
+    for (int i = 0; i < results.size(); i++) {
+      ScoredResult result = results.get(i);
+      assertNotNull(errMsg, result.waypoint);
+      assertNull(errMsg, result.track);
+      assertEquals(errMsg, waypointIds[i], result.waypoint.getId());
+    }
+  }
+}

src/androidTest/java/com/google/android/apps/mytracks/content/TrackDataHubTest.java

@@ -0,0 +1,809 @@
+/*
+ * 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 com.google.android.apps.mytracks.content;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
+import android.database.ContentObserver;
+import android.database.Cursor;
+import android.database.MatrixCursor;
+import android.location.Location;
+import android.provider.BaseColumns;
+import android.test.RenamingDelegatingContext;
+import android.test.mock.MockContentResolver;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import com.google.android.apps.mytracks.Constants;
+import com.google.android.apps.mytracks.TrackStubUtils;
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils.LocationFactory;
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils.LocationIterator;
+import com.google.android.apps.mytracks.services.TrackRecordingServiceTest.MockContext;
+import com.google.android.apps.mytracks.util.PreferencesUtils;
+import com.google.android.maps.mytracks.R;
+import com.google.android.testing.mocking.AndroidMock;
+import com.google.android.testing.mocking.UsesMocks;
+
+import org.easymock.Capture;
+import org.easymock.IAnswer;
+import org.junit.Before;
+import org.junit.runner.RunWith;
+
+import java.util.EnumSet;
+import java.util.HashSet;
+import java.util.Set;
+
+import static com.google.android.testing.mocking.AndroidMock.capture;
+import static com.google.android.testing.mocking.AndroidMock.eq;
+import static com.google.android.testing.mocking.AndroidMock.expect;
+import static com.google.android.testing.mocking.AndroidMock.isA;
+
+/**
+ * Tests for {@link TrackDataHub}.
+ * 
+ * @author Rodrigo Damazio
+ */
+@RunWith(AndroidJUnit4.class)
+public class TrackDataHubTest {
+
+  private static final long TRACK_ID = 42L;
+  private static final int TARGET_POINTS = 50;
+
+  private MockContext context;
+  private SharedPreferences sharedPreferences;
+  private MyTracksProviderUtils myTracksProviderUtils;
+  private DataSource dataSource;
+  private TrackDataManager trackDataManager;
+  private TrackDataHub trackDataHub;
+  private TrackDataListener trackDataListener1;
+  private TrackDataListener trackDataListener2;
+  private Capture<OnSharedPreferenceChangeListener> preferenceChangeListenerCapture = new Capture<
+      SharedPreferences.OnSharedPreferenceChangeListener>();
+
+  @Before
+  @UsesMocks({ MyTracksProviderUtils.class, DataSource.class, TrackDataListener.class })
+  @Override
+  protected void setUp() {
+    context = new MockContext(new MockContentResolver(), new RenamingDelegatingContext(
+        getContext(), getContext(), "test."));
+    sharedPreferences = context.getSharedPreferences(Constants.SETTINGS_NAME, Context.MODE_PRIVATE);
+    myTracksProviderUtils = AndroidMock.createMock(MyTracksProviderUtils.class);
+    dataSource = AndroidMock.createMock(DataSource.class, context);
+    trackDataManager = new TrackDataManager();
+    trackDataHub = new TrackDataHub(
+        context, trackDataManager, myTracksProviderUtils, TARGET_POINTS) {
+        @Override
+      protected DataSource newDataSource() {
+        return dataSource;
+      }
+
+        @Override
+      protected void runInHanderThread(Runnable runnable) {
+        // Run everything in the same thread
+        runnable.run();
+      }
+    };
+
+    trackDataListener1 = AndroidMock.createStrictMock(
+        "trackDataListener1", TrackDataListener.class);
+    trackDataListener2 = AndroidMock.createStrictMock(
+        "trackDataListener2", TrackDataListener.class);
+    PreferencesUtils.setLong(context, R.string.recording_track_id_key, TRACK_ID);
+  }
+
+  @Override
+  protected void tearDown() throws Exception {
+    AndroidMock.reset(dataSource);
+
+    // Expect everything to be unregistered.
+    dataSource.unregisterContentObserver(isA(ContentObserver.class));
+    AndroidMock.expectLastCall().times(3);
+    dataSource.unregisterOnSharedPreferenceChangeListener(
+        isA(OnSharedPreferenceChangeListener.class));
+    AndroidMock.replay(dataSource);
+
+    trackDataHub.stop();
+    trackDataHub = null;
+    super.tearDown();
+  }
+
+  /**
+   * Tests registering for tracks table update.
+   */
+  public void testTracksTableUpdate() {
+
+    // Register two listeners
+    Capture<ContentObserver> contentObserverCapture = new Capture<ContentObserver>();
+    Track track = new Track();
+    expect(myTracksProviderUtils.getTrack(TRACK_ID)).andStubReturn(track);
+    dataSource.registerContentObserver(
+        eq(TracksColumns.CONTENT_URI), capture(contentObserverCapture));
+    trackDataListener1.onTrackUpdated(track);
+    trackDataListener2.onTrackUpdated(track);
+    replay();
+
+    trackDataHub.start();
+    trackDataHub.loadTrack(TRACK_ID);
+    trackDataHub.registerTrackDataListener(
+        trackDataListener1, EnumSet.of(TrackDataType.TRACKS_TABLE));
+    trackDataHub.registerTrackDataListener(
+        trackDataListener2, EnumSet.of(TrackDataType.TRACKS_TABLE));
+    verifyAndReset();
+
+    // Causes tracks table update
+    ContentObserver contentObserver = contentObserverCapture.getValue();
+    expect(myTracksProviderUtils.getTrack(TRACK_ID)).andStubReturn(track);
+    trackDataListener1.onTrackUpdated(track);
+    trackDataListener2.onTrackUpdated(track);
+    replay();
+
+    contentObserver.onChange(false);
+    verifyAndReset();
+
+    // Unregister one listener
+    expect(myTracksProviderUtils.getTrack(TRACK_ID)).andStubReturn(track);
+    trackDataListener2.onTrackUpdated(track);
+    replay();
+
+    trackDataHub.unregisterTrackDataListener(trackDataListener1);
+    contentObserver.onChange(false);
+    verifyAndReset();
+
+    // Unregister the second listener
+    dataSource.unregisterContentObserver(contentObserver);
+    replay();
+
+    trackDataHub.unregisterTrackDataListener(trackDataListener2);
+    contentObserver.onChange(false);
+    verifyAndReset();
+  }
+
+  /**
+   * Tests registering for waypoints table update.
+   */
+  public void testWaypointsTableUpdate() {
+    Waypoint waypoint1 = new Waypoint();
+    Waypoint waypoint2 = new Waypoint();
+    Waypoint waypoint3 = new Waypoint();
+    Waypoint waypoint4 = new Waypoint();
+    Location location = new Location("gps");
+    location.setLatitude(10.0);
+    location.setLongitude(8.0);
+    waypoint1.setLocation(location);
+    waypoint2.setLocation(location);
+    waypoint3.setLocation(location);
+    waypoint4.setLocation(location);
+
+    // Register two listeners
+    Capture<ContentObserver> contentObserverCapture = new Capture<ContentObserver>();
+    expect(myTracksProviderUtils.getWaypointCursor(
+        eq(TRACK_ID), AndroidMock.leq(-1L), eq(TrackDataHub.MAX_DISPLAYED_WAYPOINTS)))
+        .andStubAnswer(new FixedSizeCursorAnswer(2));
+    expect(myTracksProviderUtils.createWaypoint(isA(Cursor.class)))
+        .andReturn(waypoint1).andReturn(waypoint2).andReturn(waypoint1).andReturn(waypoint2);
+    dataSource.registerContentObserver(
+        eq(WaypointsColumns.CONTENT_URI), capture(contentObserverCapture));
+    trackDataListener1.clearWaypoints();
+    trackDataListener2.clearWaypoints();
+    trackDataListener1.onNewWaypoint(waypoint1);
+    trackDataListener2.onNewWaypoint(waypoint1);
+    trackDataListener1.onNewWaypoint(waypoint2);
+    trackDataListener2.onNewWaypoint(waypoint2);
+    trackDataListener1.onNewWaypointsDone();
+    trackDataListener2.onNewWaypointsDone();
+    replay();
+
+    trackDataHub.start();
+    trackDataHub.loadTrack(TRACK_ID);
+    trackDataHub.registerTrackDataListener(
+        trackDataListener1, EnumSet.of(TrackDataType.WAYPOINTS_TABLE));
+    trackDataHub.registerTrackDataListener(
+        trackDataListener2, EnumSet.of(TrackDataType.WAYPOINTS_TABLE));
+    verifyAndReset();
+
+    // Cause waypoints table update
+    ContentObserver contentObserver = contentObserverCapture.getValue();
+    expect(myTracksProviderUtils.getWaypointCursor(
+        eq(TRACK_ID), AndroidMock.leq(-1L), eq(TrackDataHub.MAX_DISPLAYED_WAYPOINTS)))
+        .andStubAnswer(new FixedSizeCursorAnswer(3));
+    expect(myTracksProviderUtils.createWaypoint(isA(Cursor.class)))
+        .andReturn(waypoint1).andReturn(waypoint2).andReturn(waypoint3);
+    trackDataListener1.clearWaypoints();
+    trackDataListener2.clearWaypoints();
+    trackDataListener1.onNewWaypoint(waypoint1);
+    trackDataListener2.onNewWaypoint(waypoint1);
+    trackDataListener1.onNewWaypoint(waypoint2);
+    trackDataListener2.onNewWaypoint(waypoint2);
+    trackDataListener1.onNewWaypoint(waypoint3);
+    trackDataListener2.onNewWaypoint(waypoint3);
+    trackDataListener1.onNewWaypointsDone();
+    trackDataListener2.onNewWaypointsDone();
+    replay();
+
+    contentObserver.onChange(false);
+    verifyAndReset();
+
+    // Unregister one listener
+    expect(myTracksProviderUtils.getWaypointCursor(
+        eq(TRACK_ID), AndroidMock.leq(-1L), eq(TrackDataHub.MAX_DISPLAYED_WAYPOINTS)))
+        .andStubAnswer(new FixedSizeCursorAnswer(4));
+    expect(myTracksProviderUtils.createWaypoint(isA(Cursor.class)))
+        .andReturn(waypoint1).andReturn(waypoint2).andReturn(waypoint3).andReturn(waypoint4);
+    trackDataListener2.clearWaypoints();
+    trackDataListener2.onNewWaypoint(waypoint1);
+    trackDataListener2.onNewWaypoint(waypoint2);
+    trackDataListener2.onNewWaypoint(waypoint3);
+    trackDataListener2.onNewWaypoint(waypoint4);
+    trackDataListener2.onNewWaypointsDone();
+    replay();
+
+    trackDataHub.unregisterTrackDataListener(trackDataListener1);
+    contentObserver.onChange(false);
+    verifyAndReset();
+
+    // Unregister the second listener
+    dataSource.unregisterContentObserver(contentObserver);
+    replay();
+
+    trackDataHub.unregisterTrackDataListener(trackDataListener2);
+    contentObserver.onChange(false);
+    verifyAndReset();
+  }
+
+  /**
+   * Tests track points table update.
+   */
+  public void testTrackPointsTableUpdate() {
+    // Register one listener
+    Capture<ContentObserver> contentObserverCapture = new Capture<ContentObserver>();
+    dataSource.registerContentObserver(
+        eq(TrackPointsColumns.CONTENT_URI), capture(contentObserverCapture));
+
+    FixedSizeLocationIterator locationIterator = new FixedSizeLocationIterator(1, 10, 5);
+    expect(myTracksProviderUtils.getTrackPointLocationIterator(
+        eq(TRACK_ID), eq(0L), eq(false), isA(LocationFactory.class))).andReturn(locationIterator);
+    expect(myTracksProviderUtils.getLastTrackPointId(TRACK_ID)).andReturn(10L);
+    trackDataListener1.clearTrackPoints();
+    locationIterator.expectLocationsDelivered(trackDataListener1);
+    trackDataListener1.onNewTrackPointsDone();
+    replay();
+
+    trackDataHub.start();
+    trackDataHub.loadTrack(TRACK_ID);
+    trackDataHub.registerTrackDataListener(
+        trackDataListener1, EnumSet.of(TrackDataType.SAMPLED_IN_TRACK_POINTS_TABLE));
+    verifyAndReset();
+
+    // Register a second listener
+    locationIterator = new FixedSizeLocationIterator(1, 10, 5);
+    expect(myTracksProviderUtils.getTrackPointLocationIterator(
+        eq(TRACK_ID), eq(0L), eq(false), isA(LocationFactory.class))).andReturn(locationIterator);
+    expect(myTracksProviderUtils.getLastTrackPointId(TRACK_ID)).andReturn(10L);
+    trackDataListener2.clearTrackPoints();
+    locationIterator.expectLocationsDelivered(trackDataListener2);
+    trackDataListener2.onNewTrackPointsDone();
+    replay();
+
+    trackDataHub.registerTrackDataListener(
+        trackDataListener2, EnumSet.of(TrackDataType.SAMPLED_IN_TRACK_POINTS_TABLE));
+    verifyAndReset();
+
+    // Deliver more points - should go to both listeners without clearing
+    ContentObserver contentObserver = contentObserverCapture.getValue();
+    locationIterator = new FixedSizeLocationIterator(11, 10, 1);
+    expect(myTracksProviderUtils.getTrackPointLocationIterator(
+        eq(TRACK_ID), eq(11L), eq(false), isA(LocationFactory.class))).andReturn(locationIterator);
+    expect(myTracksProviderUtils.getLastTrackPointId(TRACK_ID)).andReturn(20L);
+    locationIterator.expectLocationsDelivered(trackDataListener1);
+    locationIterator.expectLocationsDelivered(trackDataListener2);
+    trackDataListener1.onNewTrackPointsDone();
+    trackDataListener2.onNewTrackPointsDone();
+    replay();
+
+    contentObserver.onChange(false);
+    verifyAndReset();
+
+    // Unregister one listener and change track
+    locationIterator = new FixedSizeLocationIterator(101, 10);
+    expect(myTracksProviderUtils.getTrackPointLocationIterator(
+        eq(TRACK_ID + 1), eq(0L), eq(false), isA(LocationFactory.class)))
+        .andReturn(locationIterator);
+    expect(myTracksProviderUtils.getLastTrackPointId(TRACK_ID + 1)).andReturn(110L);
+    trackDataListener2.clearTrackPoints();
+    locationIterator.expectLocationsDelivered(trackDataListener2);
+    trackDataListener2.onNewTrackPointsDone();
+    replay();
+
+    trackDataHub.unregisterTrackDataListener(trackDataListener1);
+    trackDataHub.loadTrack(TRACK_ID + 1);
+    verifyAndReset();
+  }
+
+  /**
+   * Tests track points table update with registering the same listener.
+   */
+  public void testTrackPointsTableUpdate_reRegister() {
+
+    // Register one listener
+    Capture<ContentObserver> contentObserverCapture = new Capture<ContentObserver>();
+    dataSource.registerContentObserver(
+        eq(TrackPointsColumns.CONTENT_URI), capture(contentObserverCapture));
+
+    FixedSizeLocationIterator locationIterator = new FixedSizeLocationIterator(1, 10, 5);
+    expect(myTracksProviderUtils.getTrackPointLocationIterator(
+        eq(TRACK_ID), eq(0L), eq(false), isA(LocationFactory.class))).andReturn(locationIterator);
+    expect(myTracksProviderUtils.getLastTrackPointId(TRACK_ID)).andReturn(10L);
+
+    trackDataListener1.clearTrackPoints();
+    locationIterator.expectLocationsDelivered(trackDataListener1);
+    trackDataListener1.onNewTrackPointsDone();
+    replay();
+
+    trackDataHub.start();
+    trackDataHub.loadTrack(TRACK_ID);
+    trackDataHub.registerTrackDataListener(
+        trackDataListener1, EnumSet.of(TrackDataType.SAMPLED_IN_TRACK_POINTS_TABLE));
+    verifyAndReset();
+
+    // Unregister the listener
+    ContentObserver observer = contentObserverCapture.getValue();
+    dataSource.unregisterContentObserver(observer);
+    replay();
+
+    trackDataHub.unregisterTrackDataListener(trackDataListener1);
+    verifyAndReset();
+
+    // Register again
+    dataSource.registerContentObserver(
+        eq(TrackPointsColumns.CONTENT_URI), capture(contentObserverCapture));
+    locationIterator = new FixedSizeLocationIterator(1, 10, 5);
+    expect(myTracksProviderUtils.getTrackPointLocationIterator(
+        eq(TRACK_ID), eq(0L), eq(false), isA(LocationFactory.class))).andReturn(locationIterator);
+    expect(myTracksProviderUtils.getLastTrackPointId(TRACK_ID)).andReturn(10L);
+    trackDataListener1.clearTrackPoints();
+    locationIterator.expectLocationsDelivered(trackDataListener1);
+    trackDataListener1.onNewTrackPointsDone();
+    replay();
+
+    trackDataHub.registerTrackDataListener(
+        trackDataListener1, EnumSet.of(TrackDataType.SAMPLED_IN_TRACK_POINTS_TABLE));
+    verifyAndReset();
+  }
+
+  /**
+   * Tests tracks point able change. Register a listener after a track change.
+   */
+  public void testTrackPointsTableUpdate_reRegisterAfterTrackChange() {
+
+    // Register one listener
+    Capture<ContentObserver> observerCapture = new Capture<ContentObserver>();
+    dataSource.registerContentObserver(
+        eq(TrackPointsColumns.CONTENT_URI), capture(observerCapture));
+
+    FixedSizeLocationIterator locationIterator = new FixedSizeLocationIterator(1, 10, 5);
+    expect(myTracksProviderUtils.getTrackPointLocationIterator(
+        eq(TRACK_ID), eq(0L), eq(false), isA(LocationFactory.class))).andReturn(locationIterator);
+    expect(myTracksProviderUtils.getLastTrackPointId(TRACK_ID)).andReturn(10L);
+    trackDataListener1.clearTrackPoints();
+    locationIterator.expectLocationsDelivered(trackDataListener1);
+    trackDataListener1.onNewTrackPointsDone();
+    replay();
+
+    trackDataHub.start();
+    trackDataHub.loadTrack(TRACK_ID);
+    trackDataHub.registerTrackDataListener(
+        trackDataListener1, EnumSet.of(TrackDataType.SAMPLED_IN_TRACK_POINTS_TABLE));
+    verifyAndReset();
+
+    // Unregister the listener
+    ContentObserver observer = observerCapture.getValue();
+    dataSource.unregisterContentObserver(observer);
+    replay();
+
+    trackDataHub.unregisterTrackDataListener(trackDataListener1);
+    verifyAndReset();
+
+    // Register the listener after a new track
+    dataSource.registerContentObserver(
+        eq(TrackPointsColumns.CONTENT_URI), capture(observerCapture));
+    locationIterator = new FixedSizeLocationIterator(1, 10);
+    expect(myTracksProviderUtils.getTrackPointLocationIterator(
+        eq(TRACK_ID + 1), eq(0L), eq(false), isA(LocationFactory.class)))
+        .andReturn(locationIterator);
+    expect(myTracksProviderUtils.getLastTrackPointId(TRACK_ID + 1)).andReturn(10L);
+    trackDataListener1.clearTrackPoints();
+    locationIterator.expectLocationsDelivered(trackDataListener1);
+    trackDataListener1.onNewTrackPointsDone();
+    replay();
+
+    trackDataHub.loadTrack(TRACK_ID + 1);
+    trackDataHub.registerTrackDataListener(
+        trackDataListener1, EnumSet.of(TrackDataType.SAMPLED_IN_TRACK_POINTS_TABLE));
+    verifyAndReset();
+  }
+
+  /**
+   * Tests track points table update with large track sampling.
+   */
+  public void testTrackPointsTableUpdate_largeTrackSampling() {
+    Capture<ContentObserver> contentObserverCapture = new Capture<ContentObserver>();
+    dataSource.registerContentObserver(
+        eq(TrackPointsColumns.CONTENT_URI), capture(contentObserverCapture));
+
+    expect(myTracksProviderUtils.getLastTrackPointId(TRACK_ID)).andReturn(200L);
+    AndroidMock.expectLastCall().anyTimes();
+    FixedSizeLocationIterator locationIterator1 = new FixedSizeLocationIterator(
+        1, 200, 4, 25, 71, 120);
+    expect(myTracksProviderUtils.getTrackPointLocationIterator(
+        eq(TRACK_ID), eq(0L), eq(false), isA(LocationFactory.class))).andReturn(locationIterator1);
+    FixedSizeLocationIterator locationIterator2 = new FixedSizeLocationIterator(
+        1, 200, 4, 25, 71, 120);
+    expect(myTracksProviderUtils.getTrackPointLocationIterator(
+        eq(TRACK_ID), eq(0L), eq(false), isA(LocationFactory.class))).andReturn(locationIterator2);
+
+    trackDataListener1.clearTrackPoints();
+    locationIterator1.expectSampledLocationsDelivered(trackDataListener1, 4, false);
+    trackDataListener1.onNewTrackPointsDone();
+    trackDataListener2.clearTrackPoints();
+    locationIterator2.expectSampledLocationsDelivered(trackDataListener2, 4, true);
+    trackDataListener2.onNewTrackPointsDone();
+    replay();
+
+    trackDataHub.start();
+    trackDataHub.loadTrack(TRACK_ID);
+    trackDataHub.registerTrackDataListener(
+        trackDataListener1, EnumSet.of(TrackDataType.SAMPLED_IN_TRACK_POINTS_TABLE));
+    trackDataHub.registerTrackDataListener(trackDataListener2, EnumSet.of(
+        TrackDataType.SAMPLED_IN_TRACK_POINTS_TABLE, TrackDataType.SAMPLED_OUT_TRACK_POINTS_TABLE));
+    verifyAndReset();
+  }
+
+  /**
+   * Tests track points table update with resampling.
+   */
+  public void testTrackPointsTableUpdate_resampling() {
+    Capture<ContentObserver> observerCapture = new Capture<ContentObserver>();
+    dataSource.registerContentObserver(
+        eq(TrackPointsColumns.CONTENT_URI), capture(observerCapture));
+
+    // Deliver 30 points (no sampling happens)
+    FixedSizeLocationIterator locationIterator = new FixedSizeLocationIterator(1, 30, 5);
+    expect(myTracksProviderUtils.getTrackPointLocationIterator(
+        eq(TRACK_ID), eq(0L), eq(false), isA(LocationFactory.class))).andReturn(locationIterator);
+    expect(myTracksProviderUtils.getLastTrackPointId(TRACK_ID)).andReturn(30L);
+
+    trackDataListener1.clearTrackPoints();
+    locationIterator.expectLocationsDelivered(trackDataListener1);
+    trackDataListener1.onNewTrackPointsDone();
+    replay();
+
+    trackDataHub.start();
+    trackDataHub.loadTrack(TRACK_ID);
+    trackDataHub.registerTrackDataListener(
+        trackDataListener1, EnumSet.of(TrackDataType.SAMPLED_IN_TRACK_POINTS_TABLE));
+    verifyAndReset();
+
+    // Now deliver 30 more (incrementally sampled)
+    ContentObserver observer = observerCapture.getValue();
+    locationIterator = new FixedSizeLocationIterator(31, 30);
+    expect(myTracksProviderUtils.getTrackPointLocationIterator(
+        eq(TRACK_ID), eq(31L), eq(false), isA(LocationFactory.class))).andReturn(locationIterator);
+    expect(myTracksProviderUtils.getLastTrackPointId(TRACK_ID)).andReturn(60L);
+    locationIterator.expectSampledLocationsDelivered(trackDataListener1, 2, false);
+    trackDataListener1.onNewTrackPointsDone();
+    replay();
+
+    observer.onChange(false);
+    verifyAndReset();
+
+    // Now another 30 (triggers resampling)
+    locationIterator = new FixedSizeLocationIterator(1, 90);
+    expect(myTracksProviderUtils.getTrackPointLocationIterator(
+        eq(TRACK_ID), eq(0L), eq(false), isA(LocationFactory.class))).andReturn(locationIterator);
+    expect(myTracksProviderUtils.getLastTrackPointId(TRACK_ID)).andReturn(90L);
+    trackDataListener1.clearTrackPoints();
+    locationIterator.expectSampledLocationsDelivered(trackDataListener1, 2, false);
+    trackDataListener1.onNewTrackPointsDone();
+    replay();
+
+    observer.onChange(false);
+    verifyAndReset();
+  }
+
+  /**
+   * Tests preferences change.
+   */
+  public void testPreferencesChange() throws Exception {
+
+    // Register two listeners
+    PreferencesUtils.setString(
+        context, R.string.stats_rate_key, PreferencesUtils.STATS_RATE_DEFAULT);
+    PreferencesUtils.setString(
+        context, R.string.stats_units_key, PreferencesUtils.STATS_UNITS_DEFAULT);
+    PreferencesUtils.setInt(context, R.string.recording_gps_accuracy_key,
+        PreferencesUtils.RECORDING_GPS_ACCURACY_DEFAULT);
+    PreferencesUtils.setInt(context, R.string.recording_distance_interval_key,
+        PreferencesUtils.RECORDING_DISTANCE_INTERVAL_DEFAULT);
+
+    dataSource.registerOnSharedPreferenceChangeListener(capture(preferenceChangeListenerCapture));
+    expect(trackDataListener1.onMetricUnitsChanged(true)).andReturn(false);
+    expect(trackDataListener1.onReportSpeedChanged(true)).andReturn(false);
+    expect(
+        trackDataListener1.onRecordingGpsAccuracy(PreferencesUtils.RECORDING_GPS_ACCURACY_DEFAULT))
+        .andReturn(false);
+    expect(trackDataListener1.onRecordingDistanceIntervalChanged(
+        PreferencesUtils.RECORDING_DISTANCE_INTERVAL_DEFAULT)).andReturn(false);
+    expect(trackDataListener1.onMapTypeChanged(PreferencesUtils.MAP_TYPE_DEFAUlT)).andReturn(false);
+    
+    expect(trackDataListener2.onMetricUnitsChanged(true)).andReturn(false);
+    expect(trackDataListener2.onReportSpeedChanged(true)).andReturn(false);
+    expect(
+        trackDataListener2.onRecordingGpsAccuracy(PreferencesUtils.RECORDING_GPS_ACCURACY_DEFAULT))
+        .andReturn(false);
+    expect(trackDataListener2.onRecordingDistanceIntervalChanged(
+        PreferencesUtils.RECORDING_DISTANCE_INTERVAL_DEFAULT)).andReturn(false);
+    expect(trackDataListener2.onMapTypeChanged(PreferencesUtils.MAP_TYPE_DEFAUlT)).andReturn(false);
+    replay();
+
+    trackDataHub.start();
+    trackDataHub.registerTrackDataListener(
+        trackDataListener1, EnumSet.of(TrackDataType.PREFERENCE));
+    trackDataHub.registerTrackDataListener(
+        trackDataListener2, EnumSet.of(TrackDataType.PREFERENCE));
+    verifyAndReset();
+
+    // Change report speed to false
+    expect(trackDataListener1.onReportSpeedChanged(false)).andReturn(false);
+    expect(trackDataListener2.onReportSpeedChanged(false)).andReturn(false);
+    replay();
+
+    PreferencesUtils.setString(
+        context, R.string.stats_rate_key, context.getString(R.string.stats_rate_pace));
+    OnSharedPreferenceChangeListener listener = preferenceChangeListenerCapture.getValue();
+    listener.onSharedPreferenceChanged(
+        sharedPreferences, PreferencesUtils.getKey(context, R.string.stats_rate_key));
+    verifyAndReset();
+
+    // Change metric units to false
+    expect(trackDataListener1.onMetricUnitsChanged(false)).andReturn(false);
+    expect(trackDataListener2.onMetricUnitsChanged(false)).andReturn(false);
+    replay();
+
+    String imperialUnits = context.getString(R.string.stats_units_imperial);
+    PreferencesUtils.setString(context, R.string.stats_units_key, imperialUnits);
+    listener.onSharedPreferenceChanged(
+        sharedPreferences, PreferencesUtils.getKey(context, R.string.stats_units_key));
+    verifyAndReset();
+  }
+
+  /**
+   * Replays mocks.
+   */
+  private void replay() {
+    AndroidMock.replay(myTracksProviderUtils, dataSource, trackDataListener1, trackDataListener2);
+  }
+
+  /**
+   * Verifies and resets mocks.
+   */
+  private void verifyAndReset() {
+    AndroidMock.verify(myTracksProviderUtils, dataSource, trackDataListener1, trackDataListener2);
+    AndroidMock.reset(myTracksProviderUtils, dataSource, trackDataListener1, trackDataListener2);
+  }
+
+  /**
+   * Fixed size cursor answer.
+   * 
+   * @author Jimmy Shih
+   */
+  private static class FixedSizeCursorAnswer implements IAnswer<Cursor> {
+    private final int size;
+
+    public FixedSizeCursorAnswer(int size) {
+      this.size = size;
+    }
+
+    @Override
+    public Cursor answer() throws Throwable {
+      MatrixCursor cursor = new MatrixCursor(new String[] { BaseColumns._ID });
+      for (long i = 0; i < size; i++) {
+        cursor.addRow(new Object[] { i });
+      }
+      return cursor;
+    }
+  }
+
+  /**
+   * Fixed size location iterator.
+   * 
+   * @author Jimmy Shih
+   */
+  private static class FixedSizeLocationIterator implements LocationIterator {
+    private final long startId;
+    private final Location[] locations;
+    private final Set<Integer> splitIndexSet = new HashSet<Integer>();
+    private int currentIndex = -1;
+
+    public FixedSizeLocationIterator(long startId, int size) {
+      this(startId, size, null);
+    }
+
+    public FixedSizeLocationIterator(long startId, int size, int... splitIndexes) {
+      this.startId = startId;
+      this.locations = new Location[size];
+
+      for (int i = 0; i < size; i++) {
+        Location location = new Location("gps");
+        location.setLatitude(-15.0 + i / 1000.0);
+        location.setLongitude(37 + i / 1000.0);
+        location.setAltitude(i);
+        locations[i] = location;
+      }
+
+      if (splitIndexes != null) {
+        for (int splitIndex : splitIndexes) {
+          splitIndexSet.add(splitIndex);
+
+          Location splitLocation = locations[splitIndex];
+          splitLocation.setLatitude(100.0);
+          splitLocation.setLongitude(200.0);
+        }
+      }
+    }
+
+    public void expectLocationsDelivered(TrackDataListener listener) {
+      for (int i = 0; i < locations.length; i++) {
+        if (splitIndexSet.contains(i)) {
+          listener.onSegmentSplit(locations[i]);
+        } else {
+          listener.onSampledInTrackPoint(locations[i]);
+        }
+      }
+    }
+
+    public void expectSampledLocationsDelivered(
+        TrackDataListener listener, int sampleFrequency, boolean includeSampledOut) {
+      boolean includeNext = false;
+      for (int i = 0; i < locations.length; i++) {
+        if (splitIndexSet.contains(i)) {
+          listener.onSegmentSplit(locations[i]);
+          includeNext = true;
+        } else if (includeNext || (i % sampleFrequency == 0)) {
+          listener.onSampledInTrackPoint(locations[i]);
+          includeNext = false;
+        } else if (includeSampledOut) {
+          listener.onSampledOutTrackPoint(locations[i]);
+        }
+      }
+    }
+
+    @Override
+    public boolean hasNext() {
+      return currentIndex < locations.length - 1;
+    }
+
+    @Override
+    public Location next() {
+      currentIndex++;
+      return locations[currentIndex];
+    }
+
+    @Override
+    public void remove() {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public long getLocationId() {
+      return startId + currentIndex;
+    }
+
+    @Override
+    public void close() {
+      // Do nothing
+    }
+  }
+
+  /**
+   * Tests the method {@link TrackDataHub#start()}.
+   */
+  public void testRegisterTracksTableListener() {
+    Capture<ContentObserver> observerCapture = new Capture<ContentObserver>();
+    dataSource.registerContentObserver(eq(TracksColumns.CONTENT_URI), capture(observerCapture));
+    Track track = TrackStubUtils.createTrack(1);
+    expect(myTracksProviderUtils.getTrack(capture(new Capture<Long>()))).andReturn(track);
+    // Make the track id is unique.
+    PreferencesUtils.setLong(context, R.string.recording_track_id_key, System.currentTimeMillis());
+    trackDataListener1.onTrackUpdated(track);
+    replay();
+    trackDataHub.start();
+    trackDataHub.registerTrackDataListener(
+        trackDataListener1, EnumSet.of(TrackDataType.TRACKS_TABLE));
+    verifyAndReset();
+  }
+
+  /**
+   * Tests the method {@link TrackDataHub#start()}.
+   */
+  public void testRegisterWaypointsTableListener() {
+    Capture<ContentObserver> observerCapture = new Capture<ContentObserver>();
+    dataSource.registerContentObserver(eq(WaypointsColumns.CONTENT_URI), capture(observerCapture));
+    expect(myTracksProviderUtils.getWaypointCursor(
+        capture(new Capture<Long>()), capture(new Capture<Long>()),
+        capture(new Capture<Integer>()))).andReturn(null);
+    trackDataListener1.clearWaypoints();
+    trackDataListener1.onNewWaypointsDone();
+    replay();
+    trackDataHub.start();
+    trackDataHub.registerTrackDataListener(
+        trackDataListener1, EnumSet.of(TrackDataType.WAYPOINTS_TABLE));
+    verifyAndReset();
+  }
+
+  /**
+   * Tests the method {@link TrackDataHub#notifyPreferenceChanged(String)} when
+   * the key is R.string.min_required_accuracy_key.
+   */
+  public void testNotifyPreferenceChanged_minRequiredAccuracy() {
+    int value = 1;
+    PreferencesUtils.setInt(context, R.string.recording_gps_accuracy_key, value);
+    trackDataHub.notifyPreferenceChanged(PreferencesUtils
+        .getKey(context, R.string.recording_gps_accuracy_key));
+    assertEquals(value, trackDataHub.getRecordingGpsAccuracy());
+    PreferencesUtils.setInt(context, R.string.recording_gps_accuracy_key, value + 1);
+    trackDataHub.notifyPreferenceChanged(PreferencesUtils
+        .getKey(context, R.string.recording_gps_accuracy_key));
+    assertEquals(value + 1, trackDataHub.getRecordingGpsAccuracy());
+  }
+  
+  /**
+   * Tests the method {@link TrackDataHub#notifyPreferenceChanged(String)} when
+   * the key is R.string.metric_units_key.
+   */
+  public void testNotifyPreferenceChanged_metricUnitsNoNotify() {
+    String imperialUnits = context.getString(R.string.stats_units_imperial);
+
+    PreferencesUtils.setString(context, R.string.stats_units_key, imperialUnits);
+    trackDataHub.notifyPreferenceChanged(
+        PreferencesUtils.getKey(context, R.string.stats_units_key));
+    assertEquals(false, trackDataHub.isMetricUnits());
+    PreferencesUtils.setString(
+        context, R.string.stats_units_key, PreferencesUtils.STATS_UNITS_DEFAULT);
+    trackDataHub.notifyPreferenceChanged(
+        PreferencesUtils.getKey(context, R.string.stats_units_key));
+    assertEquals(true, trackDataHub.isMetricUnits());
+  }
+  
+  
+  /**
+   * Tests the method {@link TrackDataHub#notifyPreferenceChanged(String)} when
+   * the key is R.string.metric_units_key.
+   */
+  public void testNotifyPreferenceChanged_reportSpeedNoNotify() {
+    String value = context.getString(R.string.stats_rate_pace);
+    PreferencesUtils.setString(context, R.string.stats_rate_key, value);
+    trackDataHub.notifyPreferenceChanged(PreferencesUtils
+        .getKey(context, R.string.stats_rate_key));
+    assertEquals(false, trackDataHub.isReportSpeed());
+    
+    value = context.getString(R.string.stats_rate_speed);
+    PreferencesUtils.setString(context, R.string.stats_rate_key, value);
+    trackDataHub.notifyPreferenceChanged(PreferencesUtils
+        .getKey(context, R.string.stats_rate_key));
+    assertEquals(true, trackDataHub.isReportSpeed());
+  }
+}

src/androidTest/java/com/google/android/apps/mytracks/content/WaypointCreationRequestTest.java

@@ -0,0 +1,63 @@
+/*
+ * 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 com.google.android.apps.mytracks.content;
+
+import android.os.Parcel;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import com.google.android.apps.mytracks.content.Waypoint.WaypointType;
+
+import org.junit.Assert;
+import org.junit.runner.RunWith;
+
+/**
+ * Tests for the WaypointCreationRequest class.
+ * {@link WaypointCreationRequest}
+ *
+ * @author Sandor Dornbush
+ */
+@RunWith(AndroidJUnit4.class)
+public class WaypointCreationRequestTest {
+
+  public void testTypeParceling() {
+    WaypointCreationRequest original = WaypointCreationRequest.DEFAULT_WAYPOINT;
+    Parcel p = Parcel.obtain();
+    original.writeToParcel(p, 0);
+    p.setDataPosition(0);
+    WaypointCreationRequest copy = WaypointCreationRequest.CREATOR.createFromParcel(p);
+    Assert.assertEquals(original.getType(), copy.getType());
+    Assert.assertFalse(copy.isTrackStatistics());
+    Assert.assertNull(copy.getName());
+    Assert.assertNull(copy.getDescription());
+    Assert.assertNull(copy.getIconUrl());
+  }
+
+  public void testAllAttributesParceling() {
+    WaypointCreationRequest original = new WaypointCreationRequest(
+        WaypointType.WAYPOINT, false, "name", "category", "description", "img.png", null);
+    Parcel p = Parcel.obtain();
+    original.writeToParcel(p, 0);
+    p.setDataPosition(0);
+    WaypointCreationRequest copy = WaypointCreationRequest.CREATOR.createFromParcel(p);
+    Assert.assertEquals(original.getType(), copy.getType());
+    Assert.assertFalse(copy.isTrackStatistics());
+    Assert.assertEquals("name", copy.getName());
+    Assert.assertEquals("category", copy.getCategory());
+    Assert.assertEquals("description", copy.getDescription());
+    Assert.assertEquals("img.png", copy.getIconUrl());
+  }
+}

src/androidTest/java/com/google/android/apps/mytracks/fragments/ChartFragmentTest.java

@@ -0,0 +1,357 @@
+/*
+ * 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 com.google.android.apps.mytracks.fragments;
+
+import android.location.Location;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.platform.app.InstrumentationRegistry;
+
+import com.google.android.apps.mytracks.ChartView;
+import com.google.android.apps.mytracks.TrackStubUtils;
+import com.google.android.apps.mytracks.content.MyTracksLocation;
+import com.google.android.apps.mytracks.content.sensor.Sensor;
+import com.google.android.apps.mytracks.content.sensor.Sensor.SensorDataSet;
+import com.google.android.apps.mytracks.util.UnitConversions;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.runner.RunWith;
+
+/**
+ * Tests {@link ChartFragment}.
+ * 
+ * @author Youtao Liu
+ */
+@RunWith(AndroidJUnit4.class)
+public class ChartFragmentTest {
+
+  private static final double HOURS_PER_UNIT = 60.0;
+
+  private ChartFragment chartFragment;
+
+  @Before
+  protected void setUp() {
+    chartFragment = new ChartFragment();
+    chartFragment.setChartView(new ChartView(InstrumentationRegistry.getInstrumentation().getContext()));
+    chartFragment.setTripStatisticsUpdater(TrackStubUtils.INITIAL_TIME);
+  }
+
+  /**
+   * Tests the logic to get the incorrect values of sensor in {@link ChartFragment#fillDataPoint(Location,
+   * double[])}
+   */
+  public void testFillDataPoint_sensorIncorrect() {
+    MyTracksLocation myTracksLocation = TrackStubUtils.createMyTracksLocation();
+
+    // No input.
+    double[] point = fillDataPointTestHelper(myTracksLocation);
+    Assert.assertEquals(Double.NaN, point[ChartView.HEART_RATE_SERIES + 1]);
+    Assert.assertEquals(Double.NaN, point[ChartView.CADENCE_SERIES + 1]);
+    Assert.assertEquals(Double.NaN, point[ChartView.POWER_SERIES + 1]);
+
+    // Input incorrect state.
+    // Creates SensorData.
+    Sensor.SensorData.Builder heartRateData = Sensor.SensorData.newBuilder()
+        .setValue(100).setState(Sensor.SensorState.NONE);
+    Sensor.SensorData.Builder cadenceData = Sensor.SensorData.newBuilder()
+        .setValue(101).setState(Sensor.SensorState.NONE);
+    Sensor.SensorData.Builder powerData = Sensor.SensorData.newBuilder()
+        .setValue(102).setState(Sensor.SensorState.NONE);
+
+    // Creates SensorDataSet.
+    SensorDataSet sensorDataSet = myTracksLocation.getSensorDataSet();
+    sensorDataSet = sensorDataSet.toBuilder()
+        .setHeartRate(heartRateData).setCadence(cadenceData).setPower(powerData).build();
+    myTracksLocation.setSensorDataSet(sensorDataSet);
+    // Test.
+    point = fillDataPointTestHelper(myTracksLocation);
+    Assert.assertEquals(Double.NaN, point[ChartView.HEART_RATE_SERIES + 1]);
+    Assert.assertEquals(Double.NaN, point[ChartView.CADENCE_SERIES + 1]);
+    Assert.assertEquals(Double.NaN, point[ChartView.POWER_SERIES + 1]);
+  }
+
+  /**
+   * Tests the logic to get the correct values of sensor in {@link ChartFragment#fillDataPoint(Location,
+   * double[])}.
+   */
+  public void testFillDataPoint_sensorCorrect() {
+    MyTracksLocation myTracksLocation = TrackStubUtils.createMyTracksLocation();
+    // No input.
+    double[] point = fillDataPointTestHelper(myTracksLocation);
+    Assert.assertEquals(Double.NaN, point[ChartView.HEART_RATE_SERIES + 1]);
+    Assert.assertEquals(Double.NaN, point[ChartView.CADENCE_SERIES + 1]);
+    Assert.assertEquals(Double.NaN, point[ChartView.POWER_SERIES + 1]);
+
+    // Creates SensorData.
+    Sensor.SensorData.Builder heartRateData = Sensor.SensorData.newBuilder()
+        .setValue(100).setState(Sensor.SensorState.SENDING);
+    Sensor.SensorData.Builder cadenceData = Sensor.SensorData.newBuilder()
+        .setValue(101).setState(Sensor.SensorState.SENDING);
+    Sensor.SensorData.Builder powerData = Sensor.SensorData.newBuilder()
+        .setValue(102).setState(Sensor.SensorState.SENDING);
+
+    // Creates SensorDataSet.
+    SensorDataSet sensorDataSet = myTracksLocation.getSensorDataSet();
+    sensorDataSet = sensorDataSet.toBuilder()
+        .setHeartRate(heartRateData).setCadence(cadenceData).setPower(powerData).build();
+    myTracksLocation.setSensorDataSet(sensorDataSet);
+    // Test.
+    point = fillDataPointTestHelper(myTracksLocation);
+    Assert.assertEquals(100.0, point[ChartView.HEART_RATE_SERIES + 1]);
+    Assert.assertEquals(101.0, point[ChartView.CADENCE_SERIES + 1]);
+    Assert.assertEquals(102.0, point[ChartView.POWER_SERIES + 1]);
+  }
+
+  /**
+   * Tests the logic to get the value of metric Distance in {@link ChartFragment#fillDataPoint(Location,
+   * double[])}.
+   */
+  public void testFillDataPoint_distanceMetric() {
+    // By distance.
+    chartFragment.setChartByDistance(true);
+    // Resets last location and writes first location.
+    MyTracksLocation myTracksLocation1 = TrackStubUtils.createMyTracksLocation();
+    double[] point = fillDataPointTestHelper(myTracksLocation1);
+    Assert.assertEquals(0.0, point[0]);
+
+    // The second is a same location, just different time.
+    MyTracksLocation myTracksLocation2 = TrackStubUtils.createMyTracksLocation();
+    point = fillDataPointTestHelper(myTracksLocation2);
+    Assert.assertEquals(0.0, point[0]);
+
+    // The third location is a new location, and use metric.
+    MyTracksLocation myTracksLocation3 = TrackStubUtils.createMyTracksLocation();
+    myTracksLocation3.setLatitude(23);
+    point = fillDataPointTestHelper(myTracksLocation3);
+
+    // Computes the distance between Latitude 22 and 23.
+    float[] results = new float[4];
+    Location.distanceBetween(myTracksLocation2.getLatitude(), myTracksLocation2.getLongitude(),
+        myTracksLocation3.getLatitude(), myTracksLocation3.getLongitude(), results);
+    double distance1 = results[0] * UnitConversions.M_TO_KM;
+    Assert.assertEquals(distance1, point[0]);
+
+    // The fourth location is a new location, and use metric.
+    MyTracksLocation myTracksLocation4 = TrackStubUtils.createMyTracksLocation();
+    myTracksLocation4.setLatitude(24);
+    point = fillDataPointTestHelper(myTracksLocation4);
+
+    // Computes the distance between Latitude 23 and 24.
+    Location.distanceBetween(myTracksLocation3.getLatitude(), myTracksLocation3.getLongitude(),
+        myTracksLocation4.getLatitude(), myTracksLocation4.getLongitude(), results);
+    double distance2 = results[0] * UnitConversions.M_TO_KM;
+    Assert.assertEquals((distance1 + distance2), point[0]);
+  }
+
+  /**
+   * Tests the logic to get the value of imperial Distance in {@link ChartFragment#fillDataPoint(Location,
+   * double[])}.
+   */
+  public void testFillDataPoint_distanceImperial() {
+    // By distance.
+    chartFragment.setChartByDistance(true);
+    // Setups to use imperial.
+    chartFragment.setMetricUnits(false);
+
+    // The first is a same location, just different time.
+    MyTracksLocation myTracksLocation1 = TrackStubUtils.createMyTracksLocation();
+    double[] point = fillDataPointTestHelper(myTracksLocation1);
+    Assert.assertEquals(0.0, point[0]);
+
+    // The second location is a new location, and use imperial.
+    MyTracksLocation myTracksLocation2 = TrackStubUtils.createMyTracksLocation();
+    myTracksLocation2.setLatitude(23);
+    point = fillDataPointTestHelper(myTracksLocation2);
+
+    /*
+     * 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(myTracksLocation1.getLatitude(), myTracksLocation1.getLongitude(),
+        myTracksLocation2.getLatitude(), myTracksLocation2.getLongitude(), results);
+    double distance1 = results[0] * UnitConversions.M_TO_KM * UnitConversions.KM_TO_MI;
+    Assert.assertEquals(distance1, point[0]);
+
+    // The third location is a new location, and use imperial.
+    MyTracksLocation myTracksLocation3 = TrackStubUtils.createMyTracksLocation();
+    myTracksLocation3.setLatitude(24);
+    point = fillDataPointTestHelper(myTracksLocation3);
+
+    /*
+     * 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(myTracksLocation2.getLatitude(), myTracksLocation2.getLongitude(),
+        myTracksLocation3.getLatitude(), myTracksLocation3.getLongitude(), results);
+    double distance2 = results[0] * UnitConversions.M_TO_KM * UnitConversions.KM_TO_MI;
+    Assert.assertEquals(distance1 + distance2, point[0]);
+  }
+
+  /**
+   * Tests the logic to get the values of time in {@link ChartFragment#fillDataPoint(Location,
+   * double[])}.
+   */
+  public void testFillDataPoint_time() {
+    // By time
+    chartFragment.setChartByDistance(false);
+    MyTracksLocation myTracksLocation1 = TrackStubUtils.createMyTracksLocation();
+    double[] point = fillDataPointTestHelper(myTracksLocation1);
+    Assert.assertEquals(0.0, point[0]);
+    long timeSpan = 222;
+    MyTracksLocation myTracksLocation2 = TrackStubUtils.createMyTracksLocation();
+    myTracksLocation2.setTime(myTracksLocation1.getTime() + timeSpan);
+    point = fillDataPointTestHelper(myTracksLocation2);
+    Assert.assertEquals((double) timeSpan, point[0]);
+  }
+
+  /**
+   * Tests the logic to get the value of elevation in {@link ChartFragment#fillDataPoint(Location,
+   * double[])} by one and two points.
+   */
+  public void testFillDataPoint_elevation() {
+    MyTracksLocation myTracksLocation1 = TrackStubUtils.createMyTracksLocation();
+
+    /*
+     * At first, clear old points of elevation, so give true to the second
+     * parameter. Then only one value INITIALLONGTITUDE in buffer.
+     */
+    double[] point = fillDataPointTestHelper(myTracksLocation1);
+    Assert.assertEquals(TrackStubUtils.INITIAL_ALTITUDE, point[ChartView.ELEVATION_SERIES + 1]);
+
+    /*
+     * Send another value to buffer, now there are two values, INITIALALTITUDE
+     * and INITIALALTITUDE * 2.
+     */
+    MyTracksLocation myTracksLocation2 = TrackStubUtils.createMyTracksLocation();
+    myTracksLocation2.setAltitude(TrackStubUtils.INITIAL_ALTITUDE * 2);
+    point = fillDataPointTestHelper(myTracksLocation2);
+    Assert.assertEquals((TrackStubUtils.INITIAL_ALTITUDE + TrackStubUtils.INITIAL_ALTITUDE * 2) / 2.0,
+        point[ChartView.ELEVATION_SERIES + 1]);
+  }
+
+  /**
+   * Tests the logic to get the value of speed in {@link ChartFragment#fillDataPoint(Location,
+   * double[])}. 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.
+   */
+  public void testFillDataPoint_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.
+     */
+    MyTracksLocation myTracksLocation1 = TrackStubUtils.createMyTracksLocation();
+    myTracksLocation1.setSpeed(128.5f);
+    double[] point = fillDataPointTestHelper(myTracksLocation1);
+    Assert.assertEquals(0.0, point[ChartView.SPEED_SERIES + 1]);
+
+    /*
+     * Tests the logic when both metricUnits and reportSpeed are true.This
+     * location will be filled into speed buffer.
+     */
+    MyTracksLocation myTracksLocation2 = TrackStubUtils.createMyTracksLocation();
+
+    /*
+     * Add a time span here to make sure the second point is valid, the value
+     * 222 here is doesn't matter.
+     */
+    myTracksLocation2.setTime(myTracksLocation1.getTime() + 222);
+    myTracksLocation2.setSpeed(130);
+    point = fillDataPointTestHelper(myTracksLocation2);
+    Assert.assertEquals(130.0 * UnitConversions.MS_TO_KMH, point[ChartView.SPEED_SERIES + 1]);
+  }
+
+  /**
+   * Tests the logic to compute speed when use Imperial.
+   */
+  public void testFillDataPoint_speedImperial() {
+    // Setups to use imperial.
+    chartFragment.setMetricUnits(false);
+
+    // First data point is not added to the speed buffer
+    MyTracksLocation myTracksLocation1 = TrackStubUtils.createMyTracksLocation();
+    myTracksLocation1.setSpeed(100.0f);
+    double[] point = fillDataPointTestHelper(myTracksLocation1);
+    Assert.assertEquals(0.0, point[ChartView.SPEED_SERIES + 1]);
+
+    MyTracksLocation myTracksLocation2 = TrackStubUtils.createMyTracksLocation();
+
+    /*
+     * Add a time span here to make sure the second point is valid and the speed
+     * is valid. Speed is valid if: speedDifference > Constants.MAX_ACCELERATION
+     * * timeDifference speedDifference = 102 -100 timeDifference = 222
+     */
+    myTracksLocation2.setTime(myTracksLocation2.getTime() + 222);
+    myTracksLocation2.setSpeed(102);
+    point = fillDataPointTestHelper(myTracksLocation2);
+    Assert.assertEquals(102.0 * UnitConversions.MS_TO_KMH * UnitConversions.KM_TO_MI, point[ChartView.SPEED_SERIES + 1]);
+  }
+
+  /**
+   * Tests the logic to get pace value when reportSpeed is false.
+   */
+  public void testFillDataPoint_pace_nonZeroSpeed() {
+    // Setups reportSpeed to false.
+    chartFragment.setReportSpeed(false);
+
+    // First data point is not added to the speed buffer
+    MyTracksLocation myTracksLocation1 = TrackStubUtils.createMyTracksLocation();
+    myTracksLocation1.setSpeed(100.0f);
+    double[] point = fillDataPointTestHelper(myTracksLocation1);
+    Assert.assertEquals(0.0, point[ChartView.SPEED_SERIES + 1]);
+
+    MyTracksLocation myTracksLocation2 = TrackStubUtils.createMyTracksLocation();
+
+    /*
+     * Add a time span here to make sure the second point is valid and the speed
+     * is valid. Speed is valid if: speedDifference > Constants.MAX_ACCELERATION
+     * * timeDifference speedDifference = 102 -100 timeDifference = 222
+     */
+    myTracksLocation2.setTime(myTracksLocation2.getTime() + 222);
+    myTracksLocation2.setSpeed(102);
+    point = fillDataPointTestHelper(myTracksLocation2);
+    Assert.assertEquals(HOURS_PER_UNIT / (102.0 * UnitConversions.MS_TO_KMH), point[ChartView.PACE_SERIES + 1]);
+  }
+
+  /**
+   * Tests the logic to get pace value when reportSpeed is false and average
+   * speed is zero.
+   */
+  public void testFillDataPoint_pace_zeroSpeed() {
+    // Setups reportSpeed to false.
+    chartFragment.setReportSpeed(false);
+    MyTracksLocation myTracksLocation = TrackStubUtils.createMyTracksLocation();
+    myTracksLocation.setSpeed(0);
+    double[] point = fillDataPointTestHelper(myTracksLocation);
+    Assert.assertEquals(0.0, point[ChartView.PACE_SERIES + 1]);
+  }
+
+  /**
+   * Helper method to test fillDataPoint.
+   * 
+   * @param location location to fill
+   * @return data of this location
+   */
+  private double[] fillDataPointTestHelper(Location location) {
+    double[] point = new double[ChartView.NUM_SERIES + 1];
+    chartFragment.fillDataPoint(location, point);
+    return point;
+  }
+
+}

src/androidTest/java/com/google/android/apps/mytracks/io/file/importer/AbstractTestFileTrackImporter.java

@@ -0,0 +1,164 @@
+/*
+ * 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 com.google.android.apps.mytracks.io.file.importer;
+
+import static com.google.android.testing.mocking.AndroidMock.eq;
+import static com.google.android.testing.mocking.AndroidMock.expect;
+
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils;
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils.Factory;
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.content.TracksColumns;
+import com.google.android.apps.mytracks.content.Waypoint;
+import com.google.android.apps.mytracks.content.WaypointsColumns;
+import com.google.android.apps.mytracks.testing.TestingProviderUtilsFactory;
+import com.google.android.testing.mocking.AndroidMock;
+import com.google.android.testing.mocking.UsesMocks;
+
+import android.content.ContentUris;
+import android.location.Location;
+import android.location.LocationManager;
+import android.net.Uri;
+import android.test.AndroidTestCase;
+
+import java.text.SimpleDateFormat;
+import java.util.Locale;
+import java.util.SimpleTimeZone;
+
+import org.easymock.Capture;
+
+/**
+ * Abstract class for testing file track importers.
+ * 
+ * @author Jimmy Shih.
+ */
+public class AbstractTestFileTrackImporter extends AndroidTestCase {
+
+  protected static final String TRACK_NAME_0 = "blablub";
+  protected static final String TRACK_DESCRIPTION_0 = "s'Laebe isch koi Schlotzer";
+
+  protected static final String TRACK_NAME_1 = "another track";
+  protected static final String TRACK_DESCRIPTION_1 = "another description";
+
+  protected static final double TRACK_LATITUDE = 48.768364;
+  protected static final double TRACK_LONGITUDE = 9.177886;
+  protected static final double TRACK_ELEVATION = 324.0;
+
+  protected static final String TRACK_TIME_0 = "2010-04-22T18:21:00Z";
+  protected static final String TRACK_TIME_1 = "2010-04-22T18:21:50.123";
+  protected static final String TRACK_TIME_2 = "2010-04-22T18:23:00.123";
+  protected static final String TRACK_TIME_3 = "2010-04-22T18:24:50.123";
+
+  protected static final SimpleDateFormat DATE_FORMAT_0 = new SimpleDateFormat(
+      "yyyy-MM-dd'T'hh:mm:ss'Z'", Locale.US);
+  protected static final SimpleDateFormat DATE_FORMAT_1 = new SimpleDateFormat(
+      "yyyy-MM-dd'T'HH:mm:ss.SSS", Locale.US);
+
+  static {
+    /*
+     * We can't omit the timezones in the test, otherwise it'll use the local
+     * timezone and fail depending on where the test runner is.
+     */
+    SimpleTimeZone utc = new SimpleTimeZone(0, "UTC");
+    DATE_FORMAT_0.setTimeZone(utc);
+    DATE_FORMAT_1.setTimeZone(utc);
+  }
+
+  protected static final long TRACK_ID_0 = 1;
+  protected static final long TRACK_ID_1 = 2;
+  protected static final long TRACK_POINT_ID_0 = 1;
+  protected static final long TRACK_POINT_ID_1 = 2;
+  protected static final long TRACK_POINT_ID_3 = 4;
+  protected static final long WAYPOINT_ID_0 = 1;
+
+  protected static final Uri TRACK_ID_0_URI = ContentUris.appendId(
+      TracksColumns.CONTENT_URI.buildUpon(), TRACK_ID_0).build();
+  protected static final Uri TRACK_ID_1_URI = ContentUris.appendId(
+      TracksColumns.CONTENT_URI.buildUpon(), TRACK_ID_1).build();
+  protected static final Uri WAYPOINT_ID_O_URI = ContentUris.appendId(
+      WaypointsColumns.CONTENT_URI.buildUpon(), WAYPOINT_ID_0).build();
+
+  protected MyTracksProviderUtils myTracksProviderUtils;
+
+  private Factory oldMyTracksProviderUtilsFactory;
+
+  @UsesMocks(MyTracksProviderUtils.class)
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    myTracksProviderUtils = AndroidMock.createMock(MyTracksProviderUtils.class);
+    oldMyTracksProviderUtilsFactory = TestingProviderUtilsFactory.installWithInstance(
+        myTracksProviderUtils);
+  }
+
+  @Override
+  protected void tearDown() throws Exception {
+    TestingProviderUtilsFactory.restoreOldFactory(oldMyTracksProviderUtilsFactory);
+    super.tearDown();
+  }
+  
+  protected Location createLocation(int index, long time) {
+    Location location = new Location(LocationManager.GPS_PROVIDER);
+    location.setLatitude(TRACK_LATITUDE + index);
+    location.setLongitude(TRACK_LONGITUDE + index);
+    location.setAltitude(TRACK_ELEVATION + index);
+    location.setTime(time);
+    return location;
+  }
+
+  /**
+   * Expects the first track point to be added.
+   * 
+   * @param location the location
+   * @param trackId the track id
+   * @param trackPointId the track point id
+   */
+  protected void expectFirstTrackPoint(Location location, long trackId, long trackPointId) {
+    expect(myTracksProviderUtils.bulkInsertTrackPoint(
+        location != null ? LocationsMatcher.eqLoc(location) : (Location[]) AndroidMock.anyObject(),
+        eq(1), eq(trackId))).andReturn(1);
+    expect(myTracksProviderUtils.getFirstTrackPointId(trackId)).andReturn(trackPointId);
+    expect(myTracksProviderUtils.getLastTrackPointId(trackId)).andReturn(trackPointId);
+  }
+
+  /**
+   * Expects the track to be updated.
+   * 
+   * @param track the track
+   * @param lastTrack true if it is the last track in the gpx
+   * @param trackId the track id
+   */
+  protected void expectUpdateTrack(Capture<Track> track, boolean lastTrack, long trackId) {
+    myTracksProviderUtils.updateTrack(AndroidMock.capture(track));
+    expect(myTracksProviderUtils.insertWaypoint((Waypoint) AndroidMock.anyObject()))
+        .andReturn(WAYPOINT_ID_O_URI);
+    if (lastTrack) {
+      // Return null to not add waypoints
+      expect(myTracksProviderUtils.getTrack(trackId)).andReturn(null);
+    }
+  }
+
+  protected void verifyTrack(Track track, String name, String description, long time) {
+    assertEquals(name, track.getName());
+    assertEquals(description, track.getDescription());
+    if (time != -1L) {
+      assertEquals(time, track.getTripStatistics().getStartTime());
+    }
+    assertNotSame(-1, track.getStartId());
+    assertNotSame(-1, track.getStopId());
+  }  
+}

src/androidTest/java/com/google/android/apps/mytracks/io/file/importer/GpxFileTrackImporterTest.java

@@ -0,0 +1,257 @@
+/*
+ * 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 com.google.android.apps.mytracks.io.file.importer;
+
+import static com.google.android.testing.mocking.AndroidMock.eq;
+import static com.google.android.testing.mocking.AndroidMock.expect;
+
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.util.PreferencesUtils;
+import com.google.android.maps.mytracks.R;
+import com.google.android.testing.mocking.AndroidMock;
+
+import android.location.Location;
+
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+
+import org.easymock.Capture;
+
+/**
+ * Tests for {@link GpxFileTrackImporter}.
+ * 
+ * @author Steffen Horlacher
+ */
+public class GpxFileTrackImporterTest extends AbstractTestFileTrackImporter {
+
+  private static String getNameAndDescription(String name, String description) {
+    return "<name><![CDATA[" + name + "]]></name>" + "<desc><![CDATA[" + description + "]]></desc>";
+  }
+
+  private static String getTrackPoint(int index, String time) {
+    String latitude = Double.toString(TRACK_LATITUDE + index);
+    String longitude = Double.toString(TRACK_LONGITUDE + index);
+    String elevation = Double.toString(TRACK_ELEVATION + index);
+    StringBuffer buffer = new StringBuffer();
+    buffer.append(
+        "<trkpt lat=\"" + latitude + "\" lon=\"" + longitude + "\"><ele>" + elevation + "</ele>");
+    if (time != null) {
+      buffer.append("<time>" + time + "</time>");
+    }
+    buffer.append("</trkpt>");
+    return buffer.toString();
+  }
+
+  private static final String VALID_ONE_TRACK_ONE_SEGMENT_GPX = "<gpx><trk>"
+      + getNameAndDescription(TRACK_NAME_0, TRACK_DESCRIPTION_0) + "<trkseg>"
+      + getTrackPoint(0, TRACK_TIME_0) + getTrackPoint(1, TRACK_TIME_1) + "</trkseg></trk></gpx>";
+  private static final String VALID_ONE_TRACK_TWO_SEGMENTS_GPX = "<gpx><trk>"
+      + getNameAndDescription(TRACK_NAME_0, TRACK_DESCRIPTION_0) + "<trkseg>"
+      + getTrackPoint(0, TRACK_TIME_0) + getTrackPoint(1, TRACK_TIME_1) + "</trkseg><trkseg>"
+      + getTrackPoint(2, TRACK_TIME_2) + getTrackPoint(3, TRACK_TIME_3) + "</trkseg></trk></gpx>";
+  private static final String VALID_ONE_TRACK_TWO_SEGMENTS_NO_TIME_GPX = "<gpx><trk>"
+      + getNameAndDescription(TRACK_NAME_0, TRACK_DESCRIPTION_0) + "<trkseg>"
+      + getTrackPoint(0, null) + getTrackPoint(1, null) + "</trkseg><trkseg>"
+      + getTrackPoint(2, null) + getTrackPoint(3, null) + "</trkseg></trk></gpx>";
+
+  private static final String INVALID_XML_GPX = VALID_ONE_TRACK_ONE_SEGMENT_GPX.substring(
+      0, VALID_ONE_TRACK_ONE_SEGMENT_GPX.length() - 50);
+  private static final String INVALID_LOCATION_GPX = VALID_ONE_TRACK_ONE_SEGMENT_GPX.replaceAll(
+      Double.toString(TRACK_LATITUDE), "1000.0");
+  private static final String INVALID_TIME_GPX = VALID_ONE_TRACK_ONE_SEGMENT_GPX.replaceAll(
+      TRACK_TIME_0, "invalid");
+  private static final String INVALID_ALTITUDE_GPX = VALID_ONE_TRACK_ONE_SEGMENT_GPX.replaceAll(
+      Double.toString(TRACK_ELEVATION), "invalid");
+  private static final String INVALID_LATITUDE_GPX = VALID_ONE_TRACK_ONE_SEGMENT_GPX.replaceAll(
+      Double.toString(TRACK_LATITUDE), "invalid");
+  private static final String INVALID_LONGITUDE_GPX = VALID_ONE_TRACK_ONE_SEGMENT_GPX.replaceAll(
+      Double.toString(TRACK_LONGITUDE), "invalid");
+
+  /**
+   * Tests one track with one segment.
+   */
+  public void testOneTrackOneSegment() throws Exception {
+    Capture<Track> track = new Capture<Track>();
+
+    Location location0 = createLocation(0, DATE_FORMAT_0.parse(TRACK_TIME_0).getTime());
+    Location location1 = createLocation(1, DATE_FORMAT_1.parse(TRACK_TIME_1).getTime());
+
+    expect(myTracksProviderUtils.insertTrack((Track) AndroidMock.anyObject()))
+        .andReturn(TRACK_ID_0_URI);
+    expectFirstTrackPoint(location0, TRACK_ID_0, TRACK_POINT_ID_0);
+
+    // A flush happens at the end
+    expect(myTracksProviderUtils.bulkInsertTrackPoint(
+        LocationsMatcher.eqLoc(location1), eq(1), eq(TRACK_ID_0))).andReturn(1);
+    expect(myTracksProviderUtils.getLastTrackPointId(TRACK_ID_0)).andReturn(TRACK_POINT_ID_1);
+    expect(
+        myTracksProviderUtils.getTrack(PreferencesUtils.getLong(getContext(),
+            R.string.recording_track_id_key))).andStubReturn(null);
+    expectUpdateTrack(track, true, TRACK_ID_0);
+    AndroidMock.replay(myTracksProviderUtils);
+
+    InputStream inputStream = new ByteArrayInputStream(VALID_ONE_TRACK_ONE_SEGMENT_GPX.getBytes());
+    GpxFileTrackImporter gpxFileTrackImporter = new GpxFileTrackImporter(
+        getContext(), myTracksProviderUtils);
+    long trackId = gpxFileTrackImporter.importFile(inputStream);
+    assertEquals(TRACK_ID_0, trackId);
+
+    long time0 = DATE_FORMAT_0.parse(TRACK_TIME_0).getTime();
+    long time1 = DATE_FORMAT_1.parse(TRACK_TIME_1).getTime();
+    assertEquals(time1 - time0, track.getValue().getTripStatistics().getTotalTime());
+    AndroidMock.verify(myTracksProviderUtils);
+    verifyTrack(track.getValue(), TRACK_NAME_0, TRACK_DESCRIPTION_0, time0);
+  }
+
+  /**
+   * Tests one track with two segments.
+   */
+  public void testOneTrackTwoSegments() throws Exception {
+    Capture<Track> track = new Capture<Track>();
+
+    Location location0 = createLocation(0, DATE_FORMAT_0.parse(TRACK_TIME_0).getTime());
+
+    expect(myTracksProviderUtils.insertTrack((Track) AndroidMock.anyObject()))
+        .andReturn(TRACK_ID_0_URI);
+    expectFirstTrackPoint(location0, TRACK_ID_0, TRACK_POINT_ID_0);
+    // A flush happens at the end
+    expect(myTracksProviderUtils.bulkInsertTrackPoint(
+        (Location[]) AndroidMock.anyObject(), eq(5), eq(TRACK_ID_0))).andStubReturn(5);
+    expect(myTracksProviderUtils.getLastTrackPointId(TRACK_ID_0)).andReturn(TRACK_POINT_ID_3);
+    expect(
+        myTracksProviderUtils.getTrack(PreferencesUtils.getLong(getContext(),
+            R.string.recording_track_id_key))).andStubReturn(null);
+    expectUpdateTrack(track, true, TRACK_ID_0);
+    AndroidMock.replay(myTracksProviderUtils);
+
+    InputStream inputStream = new ByteArrayInputStream(VALID_ONE_TRACK_TWO_SEGMENTS_GPX.getBytes());
+    GpxFileTrackImporter gpxFileTrackImporter = new GpxFileTrackImporter(
+        getContext(), myTracksProviderUtils);
+    long trackId = gpxFileTrackImporter.importFile(inputStream);
+    assertEquals(TRACK_ID_0, trackId);
+
+    long time0 = DATE_FORMAT_0.parse(TRACK_TIME_0).getTime();
+    long time1 = DATE_FORMAT_1.parse(TRACK_TIME_1).getTime();
+    long time2 = DATE_FORMAT_1.parse(TRACK_TIME_2).getTime();
+    long time3 = DATE_FORMAT_1.parse(TRACK_TIME_3).getTime();
+    assertEquals(
+        time1 - time0 + time3 - time2, track.getValue().getTripStatistics().getTotalTime());
+
+    AndroidMock.verify(myTracksProviderUtils);
+    verifyTrack(track.getValue(), TRACK_NAME_0, TRACK_DESCRIPTION_0,
+        DATE_FORMAT_0.parse(TRACK_TIME_0).getTime());
+  }
+
+  /**
+   * Tests one track with two segments, but no time in the track points.
+   */
+  public void testOneTrackTwoSegmentsNoTime() throws Exception {
+    Capture<Track> track = new Capture<Track>();
+
+    expect(myTracksProviderUtils.insertTrack((Track) AndroidMock.anyObject()))
+        .andReturn(TRACK_ID_0_URI);
+    expectFirstTrackPoint(null, TRACK_ID_0, TRACK_POINT_ID_0);
+
+    // A flush happens at the end
+    expect(myTracksProviderUtils.bulkInsertTrackPoint(
+        (Location[]) AndroidMock.anyObject(), eq(5), eq(TRACK_ID_0))).andStubReturn(5);
+    expect(myTracksProviderUtils.getLastTrackPointId(TRACK_ID_0)).andReturn(TRACK_POINT_ID_3);
+    expect(
+        myTracksProviderUtils.getTrack(PreferencesUtils.getLong(getContext(),
+            R.string.recording_track_id_key))).andStubReturn(null);
+    expectUpdateTrack(track, true, TRACK_ID_0);
+    AndroidMock.replay(myTracksProviderUtils);
+
+    InputStream inputStream = new ByteArrayInputStream(
+        VALID_ONE_TRACK_TWO_SEGMENTS_NO_TIME_GPX.getBytes());
+    GpxFileTrackImporter gpxFileTrackImporter = new GpxFileTrackImporter(
+        getContext(), myTracksProviderUtils);
+    long trackId = gpxFileTrackImporter.importFile(inputStream);
+    assertEquals(TRACK_ID_0, trackId);
+    assertEquals(0, track.getValue().getTripStatistics().getTotalTime());
+
+    AndroidMock.verify(myTracksProviderUtils);
+    verifyTrack(track.getValue(), TRACK_NAME_0, TRACK_DESCRIPTION_0, -1L);
+  }
+
+  /**
+   * Test an invalid xml input.
+   */
+  public void testInvalidXml() throws Exception {
+    testInvalidGpx(INVALID_XML_GPX);
+  }
+
+  /**
+   * Test an invalid location.
+   */
+  public void testInvalidLocation() throws Exception {
+    testInvalidGpx(INVALID_LOCATION_GPX);
+  }
+
+  /**
+   * Test an invalid time.
+   */
+  public void testInvalidTime() throws Exception {
+    testInvalidGpx(INVALID_TIME_GPX);
+  }
+
+  /**
+   * Test an invalid altitude.
+   */
+  public void testInvalidAltitude() throws Exception {
+    testInvalidGpx(INVALID_ALTITUDE_GPX);
+  }
+
+  /**
+   * Test an invalid latitude.
+   */
+  public void testInvalidLatitude() throws Exception {
+    testInvalidGpx(INVALID_LATITUDE_GPX);
+  }
+
+  /**
+   * Test an invalid longitude.
+   */
+  public void testInvalidLongitude() throws Exception {
+    testInvalidGpx(INVALID_LONGITUDE_GPX);
+  }
+
+  private void testInvalidGpx(String xml) throws Exception {
+    expect(myTracksProviderUtils.insertTrack((Track) AndroidMock.anyObject()))
+        .andReturn(TRACK_ID_0_URI);
+
+    // For the following, use StubReturn since we don't care whether they are
+    // invoked or not.
+    expect(myTracksProviderUtils.bulkInsertTrackPoint(
+        (Location[]) AndroidMock.anyObject(), AndroidMock.anyInt(), AndroidMock.anyLong()))
+        .andStubReturn(1);
+    expect(myTracksProviderUtils.getFirstTrackPointId(TRACK_ID_0)).andStubReturn(TRACK_POINT_ID_0);
+    expect(myTracksProviderUtils.getLastTrackPointId(TRACK_ID_0)).andStubReturn(TRACK_POINT_ID_0);
+    expect(
+        myTracksProviderUtils.getTrack(PreferencesUtils.getLong(getContext(),
+            R.string.recording_track_id_key))).andStubReturn(null);
+    myTracksProviderUtils.deleteTrack(getContext(), TRACK_ID_0);
+    AndroidMock.replay(myTracksProviderUtils);
+
+    InputStream inputStream = new ByteArrayInputStream(xml.getBytes());
+    GpxFileTrackImporter gpxFileTrackImporter = new GpxFileTrackImporter(
+          getContext(), myTracksProviderUtils);
+    long trackId = gpxFileTrackImporter.importFile(inputStream);
+    assertEquals(-1L, trackId);
+    AndroidMock.verify(myTracksProviderUtils);
+  }
+}

src/androidTest/java/com/google/android/apps/mytracks/io/file/importer/KmlFileTrackImporterTest.java

@@ -0,0 +1,141 @@
+/*
+ * 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 com.google.android.apps.mytracks.io.file.importer;
+
+import static com.google.android.testing.mocking.AndroidMock.eq;
+import static com.google.android.testing.mocking.AndroidMock.expect;
+
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.util.PreferencesUtils;
+import com.google.android.maps.mytracks.R;
+import com.google.android.testing.mocking.AndroidMock;
+
+import android.location.Location;
+
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+
+import org.easymock.Capture;
+
+/**
+ * Tests for {@link KmlFileTrackImporter}.
+ * 
+ * @author Jimmy Shih
+ */
+public class KmlFileTrackImporterTest extends AbstractTestFileTrackImporter {
+
+  private static String getNameAndDescription(String name, String description) {
+    return "<name><![CDATA[" + name + "]]></name><description><![CDATA[" + description
+        + "]]></description>";
+  }
+
+  private static String getTrackPoint(int index, String time) {
+    String latitude = Double.toString(TRACK_LATITUDE + index);
+    String longitude = Double.toString(TRACK_LONGITUDE + index);
+    String altitude = Double.toString(TRACK_ELEVATION + index);
+    StringBuffer buffer = new StringBuffer();
+    buffer.append("<when>" + time + "</when>" + "<gx:coord>" + longitude + " " + latitude + " "
+        + altitude + "</gx:coord>");
+    return buffer.toString();
+  }
+
+  private static final String VALID_ONE_TRACK_ONE_SEGMENT_GPX =
+      "<kml xmlns:gx=\"http://www.google.com/kml/ext/2.2\"><Placemark>"
+      + getNameAndDescription(TRACK_NAME_0, TRACK_DESCRIPTION_0) + "<gx:MultiTrack><gx:Track>"
+      + getTrackPoint(0, TRACK_TIME_0) + getTrackPoint(1, TRACK_TIME_1)
+      + "</gx:Track></gx:MultiTrack></Placemark></kml>";
+  private static final String VALID_ONE_TRACK_TWO_SEGMENTS_GPX =
+      "<kml xmlns:gx=\"http://www.google.com/kml/ext/2.2\"><Placemark>"
+      + getNameAndDescription(TRACK_NAME_0, TRACK_DESCRIPTION_0) + "<gx:MultiTrack><gx:Track>"
+      + getTrackPoint(0, TRACK_TIME_0) + getTrackPoint(1, TRACK_TIME_1) + "</gx:Track><gx:Track>"
+      + getTrackPoint(2, TRACK_TIME_2) + getTrackPoint(3, TRACK_TIME_3)
+      + "</gx:Track></gx:MultiTrack></Placemark></kml>";
+
+  /**
+   * Tests one track with one segment.
+   */
+  public void testOneTrackOneSegment() throws Exception {
+    Capture<Track> track = new Capture<Track>();
+
+    Location location0 = createLocation(0, DATE_FORMAT_0.parse(TRACK_TIME_0).getTime());
+    Location location1 = createLocation(1, DATE_FORMAT_1.parse(TRACK_TIME_1).getTime());
+
+    myTracksProviderUtils.clearTrack(getContext(), TRACK_ID_0);
+    expectFirstTrackPoint(location0, TRACK_ID_0, TRACK_POINT_ID_0);
+
+    // A flush happens at the end
+    expect(myTracksProviderUtils.bulkInsertTrackPoint(
+        LocationsMatcher.eqLoc(location1), eq(1), eq(TRACK_ID_0))).andReturn(1);
+    expect(myTracksProviderUtils.getLastTrackPointId(TRACK_ID_0)).andReturn(TRACK_POINT_ID_1);
+    expect(
+        myTracksProviderUtils.getTrack(PreferencesUtils.getLong(getContext(),
+            R.string.recording_track_id_key))).andStubReturn(null);
+    expectUpdateTrack(track, true, TRACK_ID_0);
+    AndroidMock.replay(myTracksProviderUtils);
+
+    InputStream inputStream = new ByteArrayInputStream(VALID_ONE_TRACK_ONE_SEGMENT_GPX.getBytes());
+    KmlFileTrackImporter kmlFileTrackImporter = new KmlFileTrackImporter(
+        getContext(), TRACK_ID_0, myTracksProviderUtils);
+    long trackId = kmlFileTrackImporter.importFile(inputStream);
+    assertEquals(TRACK_ID_0, trackId);
+
+    long time0 = DATE_FORMAT_0.parse(TRACK_TIME_0).getTime();
+    long time1 = DATE_FORMAT_1.parse(TRACK_TIME_1).getTime();
+    assertEquals(time1 - time0, track.getValue().getTripStatistics().getTotalTime());
+    AndroidMock.verify(myTracksProviderUtils);
+    verifyTrack(track.getValue(), TRACK_NAME_0, TRACK_DESCRIPTION_0, time0);
+  }
+
+  /**
+   * Tests one track with two segments.
+   */
+  public void testOneTrackTwoSegments() throws Exception {
+    Capture<Track> track = new Capture<Track>();
+
+    Location location0 = createLocation(0, DATE_FORMAT_0.parse(TRACK_TIME_0).getTime());
+
+    myTracksProviderUtils.clearTrack(getContext(), TRACK_ID_0);
+    expectFirstTrackPoint(location0, TRACK_ID_0, TRACK_POINT_ID_0);
+
+    // A flush happens at the end
+    expect(myTracksProviderUtils.bulkInsertTrackPoint(
+        (Location[]) AndroidMock.anyObject(), eq(5), eq(TRACK_ID_0))).andStubReturn(5);
+    expect(myTracksProviderUtils.getLastTrackPointId(TRACK_ID_0)).andReturn(TRACK_POINT_ID_3);
+    expect(
+        myTracksProviderUtils.getTrack(PreferencesUtils.getLong(getContext(),
+            R.string.recording_track_id_key))).andStubReturn(null);
+    expectUpdateTrack(track, true, TRACK_ID_0);
+    AndroidMock.replay(myTracksProviderUtils);
+
+    InputStream inputStream = new ByteArrayInputStream(VALID_ONE_TRACK_TWO_SEGMENTS_GPX.getBytes());
+    KmlFileTrackImporter kmlFileTrackImporter = new KmlFileTrackImporter(
+        getContext(), TRACK_ID_0, myTracksProviderUtils);
+    long trackId = kmlFileTrackImporter.importFile(inputStream);
+    assertEquals(TRACK_ID_0, trackId);
+
+    long time0 = DATE_FORMAT_0.parse(TRACK_TIME_0).getTime();
+    long time1 = DATE_FORMAT_1.parse(TRACK_TIME_1).getTime();
+    long time2 = DATE_FORMAT_1.parse(TRACK_TIME_2).getTime();
+    long time3 = DATE_FORMAT_1.parse(TRACK_TIME_3).getTime();
+    assertEquals(
+        time1 - time0 + time3 - time2, track.getValue().getTripStatistics().getTotalTime());
+
+    AndroidMock.verify(myTracksProviderUtils);
+    verifyTrack(track.getValue(), TRACK_NAME_0, TRACK_DESCRIPTION_0,
+        DATE_FORMAT_0.parse(TRACK_TIME_0).getTime());
+  }
+}

src/androidTest/java/com/google/android/apps/mytracks/io/file/importer/LocationsMatcher.java

@@ -0,0 +1,81 @@
+/*
+ * 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 com.google.android.apps.mytracks.io.file.importer;
+
+import com.google.android.testing.mocking.AndroidMock;
+
+import android.location.Location;
+
+import java.util.Arrays;
+
+import org.easymock.IArgumentMatcher;
+
+/**
+ * Locations matcher. Workaround because of capture bug 2617107 in easymock:
+ * http://sourceforge.net/tracker/?func=detail&aid=2617107&group_id=82958&atid=567837
+ * 
+ * @author Jimmy Shih
+ */
+public class LocationsMatcher implements IArgumentMatcher {
+
+  public static Location[] eqLoc(Location expected) {
+    return eqLoc(new Location[] { expected });
+  }
+
+  public static Location[] eqLoc(Location[] expected) {
+    IArgumentMatcher matcher = new LocationsMatcher(expected);
+    AndroidMock.reportMatcher(matcher);
+    return null;
+  }
+
+  private final Location[] expectedLocations;
+
+  private LocationsMatcher(Location[] expected) {
+    this.expectedLocations = expected;
+  }
+
+  @Override
+  public void appendTo(StringBuffer buf) {
+    buf.append("eqLoc(").append(Arrays.toString(expectedLocations)).append(")");
+  }
+
+  @Override
+  public boolean matches(Object obj) {
+    if (!(obj instanceof Location[])) {
+      return false;
+    }
+    Location[] locations = (Location[]) obj;
+    if (locations.length < expectedLocations.length) {
+      return false;
+    }
+
+    // Only check the first elements (those that will be taken into account)
+    for (int i = 0; i < expectedLocations.length; i++) {
+      if (!matchLocation(locations[i], expectedLocations[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  private boolean matchLocation(Location location1, Location location2) {
+    return (location1.getTime() == location2.getTime())
+        && (location1.getLatitude() == location2.getLatitude())
+        && (location1.getLongitude() == location2.getLongitude())
+        && (location1.getAltitude() == location2.getAltitude());
+  }
+}

src/androidTest/java/com/google/android/apps/mytracks/services/AdaptiveLocationListenerPolicyTest.java

@@ -0,0 +1,76 @@
+/*
+ * 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 com.google.android.apps.mytracks.services;
+
+import junit.framework.TestCase;
+
+/**
+ * Tests the {@link AdaptiveLocationListenerPolicy}.
+ * 
+ * @author youtaol
+ */
+public class AdaptiveLocationListenerPolicyTest extends TestCase {
+
+  private AdaptiveLocationListenerPolicy adocationListenerPolicy;
+  private static final long MIN = 1000;
+  private static final long MAX = 3000;
+  private static final int MIN_DISTANCE = 10;
+  private static final long NEW_IDLE_TIME_BIG = 10000;
+  private static final long NEW_IDLE_TIME_NORMAL = 5000;
+  private static final long NEW_IDLE_TIME_SMALL = 2000;
+  private static final long NEW_IDLE_TIME_LESS_THAN_MIN = 500;
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    adocationListenerPolicy = new AdaptiveLocationListenerPolicy(MIN, MAX, MIN_DISTANCE);
+  }
+
+  /**
+   * Tests the
+   * {@link AdaptiveLocationListenerPolicy#getDesiredPollingInterval()} in four
+   * situations.
+   * <ul>
+   * <li>The newIdleTime is bigger than max interval.</li>
+   * <li>The newIdleTime is between min and max interval.</li>
+   * <li>The newIdleTime is smaller than max interval.</li>
+   * <li>The newIdleTime is smaller than the smallest interval unit.</li>
+   * </ul>
+   */
+  public void testGetDesiredPollingInterval() {
+    adocationListenerPolicy.updateIdleTime(NEW_IDLE_TIME_BIG);
+    assertEquals(MAX, adocationListenerPolicy.getDesiredPollingInterval());
+
+    adocationListenerPolicy.updateIdleTime(NEW_IDLE_TIME_NORMAL);
+    // First get the half of NEW_IDLE_TIME_NORMAL, and then round it to the
+    // nearest second.
+    assertEquals((NEW_IDLE_TIME_NORMAL / 2 / 1000) * 1000,
+        adocationListenerPolicy.getDesiredPollingInterval());
+
+    adocationListenerPolicy.updateIdleTime(NEW_IDLE_TIME_SMALL);
+    assertEquals(MIN, adocationListenerPolicy.getDesiredPollingInterval());
+
+    adocationListenerPolicy.updateIdleTime(NEW_IDLE_TIME_LESS_THAN_MIN);
+    assertEquals(MIN, adocationListenerPolicy.getDesiredPollingInterval());
+  }
+
+  /**
+   * Tests the method {@link AdaptiveLocationListenerPolicy#getMinDistance()}.
+   */
+  public void testGetMinDistance() {
+    assertEquals(MIN_DISTANCE, adocationListenerPolicy.getMinDistance());
+  }
+}

src/androidTest/java/com/google/android/apps/mytracks/services/ControlRecordingServiceTest.java

@@ -0,0 +1,105 @@
+/*
+ * 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 com.google.android.apps.mytracks.services;
+
+import com.google.android.maps.mytracks.R;
+import com.google.android.testing.mocking.UsesMocks;
+
+import android.content.Context;
+import android.content.Intent;
+import android.os.RemoteException;
+import android.test.ServiceTestCase;
+
+import org.easymock.EasyMock;
+
+/**
+ * Tests {@link ControlRecordingService}.
+ * 
+ * @author Youtao Liu
+ */
+public class ControlRecordingServiceTest extends ServiceTestCase<ControlRecordingService> {
+
+  private Context context;
+  private ControlRecordingService controlRecordingService;
+
+  public ControlRecordingServiceTest() {
+    super(ControlRecordingService.class);
+  }
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    context = getContext();
+  }
+
+  /**
+   * Tests the start of {@link ControlRecordingService} and tests the method
+   * {@link ControlRecordingService#onHandleIntent(Intent, ITrackRecordingService)}
+   * to start a track recording.
+   */
+  @UsesMocks(ITrackRecordingService.class)
+  public void testStartRecording() {
+    assertNull(controlRecordingService);
+    Intent intent = startControlRecordingService(context.getString(R.string.track_action_start));
+    assertNotNull(controlRecordingService);
+
+    ITrackRecordingService iTrackRecordingServiceMock = EasyMock
+        .createStrictMock(ITrackRecordingService.class);
+    try {
+      EasyMock.expect(iTrackRecordingServiceMock.startNewTrack()).andReturn(1L);
+      EasyMock.replay(iTrackRecordingServiceMock);
+      controlRecordingService.onHandleIntent(intent, iTrackRecordingServiceMock);
+      EasyMock.verify(iTrackRecordingServiceMock);
+    } catch (RemoteException e) {
+      fail();
+    }
+  }
+
+  /**
+   * Tests the method
+   * {@link ControlRecordingService#onHandleIntent(Intent, ITrackRecordingService)}
+   * to stop a track recording.
+   */
+  @UsesMocks(ITrackRecordingService.class)
+  public void testStopRecording() {
+    Intent intent = startControlRecordingService(context.getString(R.string.track_action_end));
+    
+    ITrackRecordingService iTrackRecordingServiceMock = EasyMock
+        .createStrictMock(ITrackRecordingService.class);
+    try {
+      iTrackRecordingServiceMock.endCurrentTrack();
+      EasyMock.replay(iTrackRecordingServiceMock);
+      controlRecordingService.onHandleIntent(intent, iTrackRecordingServiceMock);
+      EasyMock.verify(iTrackRecordingServiceMock);
+    } catch (RemoteException e) {
+      fail();
+    }
+  }
+  
+  /**
+   * Starts a ControlRecordingService with a specified action.
+   * 
+   * @param action the action string in the start intent
+   */
+  private Intent startControlRecordingService(String action) {
+    Intent intent = new Intent(context, ControlRecordingService.class);
+    intent.setAction(action);
+    startService(intent);
+    controlRecordingService = getService();
+    return intent;
+  }
+
+}

src/androidTest/java/com/google/android/apps/mytracks/services/TrackRecordingServiceTest.java

@@ -0,0 +1,761 @@
+/*
+ * 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 com.google.android.apps.mytracks.services;
+
+import android.content.BroadcastReceiver;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.ContextWrapper;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.SharedPreferences;
+import android.database.Cursor;
+import android.location.Location;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.IBinder;
+import android.os.RemoteException;
+import android.provider.Settings;
+import android.test.RenamingDelegatingContext;
+import android.test.ServiceTestCase;
+import android.test.mock.MockContentProvider;
+import android.test.mock.MockContentResolver;
+import android.test.suitebuilder.annotation.MediumTest;
+import android.test.suitebuilder.annotation.SmallTest;
+import android.util.Log;
+
+import com.google.android.apps.mytracks.Constants;
+import com.google.android.apps.mytracks.content.MyTracksProvider;
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils;
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.content.Waypoint;
+import com.google.android.apps.mytracks.content.Waypoint.WaypointType;
+import com.google.android.apps.mytracks.content.WaypointCreationRequest;
+import com.google.android.apps.mytracks.stats.TripStatistics;
+import com.google.android.apps.mytracks.util.PreferencesUtils;
+import com.google.android.maps.mytracks.R;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Tests for the MyTracks track recording service.
+ * <p>
+ * TODO: The original class, ServiceTestCase, has a few limitations, e.g. it's
+ * not possible to properly shutdown the service, unless tearDown() is called,
+ * which prevents from testing multiple scenarios in a single test (see
+ * runFunctionTest for more details).
+ * 
+ * @author Bartlomiej Niechwiej
+ */
+public class TrackRecordingServiceTest extends ServiceTestCase<TestRecordingService> {
+
+  private Context context;
+  private MyTracksProviderUtils providerUtils;
+
+  /*
+   * In order to support starting and binding to the service in the same unit
+   * test, we provide a workaround, as the original class doesn't allow to bind
+   * after the service has been previously started.
+   */
+
+  private boolean bound;
+  private Intent serviceIntent;
+
+  public TrackRecordingServiceTest() {
+    super(TestRecordingService.class);
+  }
+
+  /**
+   * A context wrapper with the user provided {@link ContentResolver}. TODO:
+   * Move to test utils package.
+   */
+  public static class MockContext extends ContextWrapper {
+    private final ContentResolver contentResolver;
+
+    public MockContext(ContentResolver contentResolver, Context base) {
+      super(base);
+      this.contentResolver = contentResolver;
+    }
+
+    @Override
+    public ContentResolver getContentResolver() {
+      return contentResolver;
+    }
+  }
+
+  @Override
+  protected IBinder bindService(Intent intent) {
+    if (getService() != null) {
+      if (bound) {
+        throw new IllegalStateException("Service: " + getService() + " is already bound");
+      }
+      bound = true;
+      serviceIntent = intent.cloneFilter();
+      return getService().onBind(intent);
+    } else {
+      return super.bindService(intent);
+    }
+  }
+
+  @Override
+  protected void shutdownService() {
+    if (bound) {
+      assertNotNull(getService());
+      getService().onUnbind(serviceIntent);
+      bound = false;
+    }
+    super.shutdownService();
+  }
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+
+    /*
+     * Create a mock context that uses a mock content resolver and a renaming
+     * delegating context.
+     */
+    MockContentResolver mockContentResolver = new MockContentResolver();
+    RenamingDelegatingContext renamingDelegatingContext = new RenamingDelegatingContext(
+        getContext(), getContext(), "test.");
+    context = new MockContext(mockContentResolver, renamingDelegatingContext);
+
+    // Set up the mock content resolver
+    MyTracksProvider myTracksProvider = new MyTracksProvider();
+    myTracksProvider.attachInfo(context, null);
+    mockContentResolver.addProvider(MyTracksProviderUtils.AUTHORITY, myTracksProvider);
+
+    MockContentProvider settingsProvider = new MockContentProvider(context) {
+        @Override
+      public Bundle call(String method, String arg, Bundle extras) {
+        return null;
+      }
+
+        @Override
+      public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
+          String sortOrder) {
+        return null;
+      }
+    };
+    mockContentResolver.addProvider(Settings.AUTHORITY, settingsProvider);
+
+    // Set the context
+    setContext(context);
+
+    providerUtils = MyTracksProviderUtils.Factory.get(context);
+
+    SharedPreferences sharedPreferences = context.getSharedPreferences(Constants.SETTINGS_NAME, Context.MODE_PRIVATE);
+    // Let's use default values.
+    sharedPreferences.edit().clear().apply();
+
+    // Disable auto resume by default.
+    updateAutoResumePrefs(PreferencesUtils.AUTO_RESUME_TRACK_CURRENT_RETRY_DEFAULT, 0);
+    // No recording track.
+    PreferencesUtils.setLong(
+        context, R.string.recording_track_id_key, PreferencesUtils.RECORDING_TRACK_ID_DEFAULT);
+  }
+
+  @SmallTest
+  public void testStartable() {
+    startService(createStartIntent());
+    assertNotNull(getService());
+  }
+
+  @MediumTest
+  public void testBindable() {
+    IBinder service = bindService(createStartIntent());
+    assertNotNull(service);
+  }
+
+  @MediumTest
+  public void testResumeAfterReboot_shouldResume() throws Exception {
+    // Insert a dummy track and mark it as recording track.
+    createDummyTrack(123L, System.currentTimeMillis(), true);
+
+    // Clear the number of attempts and set the timeout to 10 min.
+    updateAutoResumePrefs(PreferencesUtils.AUTO_RESUME_TRACK_CURRENT_RETRY_DEFAULT,
+        PreferencesUtils.AUTO_RESUME_TRACK_TIMEOUT_DEFAULT);
+
+    // Start the service in "resume" mode (simulates the on-reboot action).
+    Intent startIntent = createStartIntent();
+    startIntent.putExtra(TrackRecordingService.RESUME_TRACK_EXTRA_NAME, true);
+    startService(startIntent);
+    assertNotNull(getService());
+
+    // We expect to resume the previous track.
+    assertTrue(getService().isRecording());
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertEquals(123L, service.getRecordingTrackId());
+  }
+
+  /*
+   * TODO: shutdownService() has a bug and doesn't set mServiceCreated to false,
+   * thus preventing from a second call to onCreate(). Report the bug to Android
+   * team. Until then, the following tests and checks must be commented out.
+   * 
+   * TODO: If fixed, remove "disabled" prefix from the test name.
+   */
+  @MediumTest
+  public void disabledTestResumeAfterReboot_simulateReboot() throws Exception {
+    updateAutoResumePrefs(PreferencesUtils.AUTO_RESUME_TRACK_CURRENT_RETRY_DEFAULT,
+        PreferencesUtils.AUTO_RESUME_TRACK_TIMEOUT_DEFAULT);
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertFalse(service.isRecording());
+
+    // Simulate recording a track.
+    long id = service.startNewTrack();
+    assertTrue(service.isRecording());
+    assertEquals(id, service.getRecordingTrackId());
+    shutdownService();
+    assertEquals(id, PreferencesUtils.getLong(context, R.string.recording_track_id_key));
+
+    // Start the service in "resume" mode (simulates the on-reboot action).
+    Intent startIntent = createStartIntent();
+    startIntent.putExtra(TrackRecordingService.RESUME_TRACK_EXTRA_NAME, true);
+    startService(startIntent);
+    assertNotNull(getService());
+
+    assertTrue(getService().isRecording());
+  }
+
+  @MediumTest
+  public void testResumeAfterReboot_noRecordingTrack() throws Exception {
+    // Insert a dummy track and mark it as recording track.
+    createDummyTrack(123L, System.currentTimeMillis(), false);
+
+    // Clear the number of attempts and set the timeout to 10 min.
+    updateAutoResumePrefs(PreferencesUtils.AUTO_RESUME_TRACK_CURRENT_RETRY_DEFAULT,
+        PreferencesUtils.AUTO_RESUME_TRACK_TIMEOUT_DEFAULT);
+
+    // Start the service in "resume" mode (simulates the on-reboot action).
+    Intent startIntent = createStartIntent();
+    startIntent.putExtra(TrackRecordingService.RESUME_TRACK_EXTRA_NAME, true);
+    startService(startIntent);
+    assertNotNull(getService());
+
+    // We don't expect to resume the previous track, because it was stopped.
+    assertFalse(getService().isRecording());
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertEquals(-1L, service.getRecordingTrackId());
+  }
+
+  @MediumTest
+  public void testResumeAfterReboot_expiredTrack() throws Exception {
+    // Insert a dummy track last updated 20 min ago.
+    createDummyTrack(123L, System.currentTimeMillis() - 20 * 60 * 1000, true);
+
+    // Clear the number of attempts and set the timeout to 10 min.
+    updateAutoResumePrefs(PreferencesUtils.AUTO_RESUME_TRACK_CURRENT_RETRY_DEFAULT,
+        PreferencesUtils.AUTO_RESUME_TRACK_TIMEOUT_DEFAULT);
+
+    // Start the service in "resume" mode (simulates the on-reboot action).
+    Intent startIntent = createStartIntent();
+    startIntent.putExtra(TrackRecordingService.RESUME_TRACK_EXTRA_NAME, true);
+    startService(startIntent);
+    assertNotNull(getService());
+
+    // We don't expect to resume the previous track, because it has expired.
+    assertFalse(getService().isRecording());
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertEquals(-1L, service.getRecordingTrackId());
+  }
+
+  @MediumTest
+  public void testResumeAfterReboot_tooManyAttempts() throws Exception {
+    // Insert a dummy track.
+    createDummyTrack(123L, System.currentTimeMillis(), true);
+
+    // Set the number of attempts to max.
+    updateAutoResumePrefs(TrackRecordingService.MAX_AUTO_RESUME_TRACK_RETRY_ATTEMPTS,
+        PreferencesUtils.AUTO_RESUME_TRACK_TIMEOUT_DEFAULT);
+
+    // Start the service in "resume" mode (simulates the on-reboot action).
+    Intent startIntent = createStartIntent();
+    startIntent.putExtra(TrackRecordingService.RESUME_TRACK_EXTRA_NAME, true);
+    startService(startIntent);
+    assertNotNull(getService());
+
+    // We don't expect to resume the previous track, because there were already
+    // too many attempts.
+    assertFalse(getService().isRecording());
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertEquals(-1L, service.getRecordingTrackId());
+  }
+
+  @MediumTest
+  public void testRecording_noTracks() throws Exception {
+    List<Track> tracks = providerUtils.getAllTracks();
+    assertTrue(tracks.isEmpty());
+
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    // Test if we start in no-recording mode by default.
+    assertFalse(service.isRecording());
+    assertEquals(-1L, service.getRecordingTrackId());
+  }
+
+  @MediumTest
+  public void testRecording_oldTracks() throws Exception {
+    createDummyTrack(123L, -1L, false);
+
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertFalse(service.isRecording());
+    assertEquals(-1L, service.getRecordingTrackId());
+  }
+
+  @MediumTest
+  public void testRecording_orphanedRecordingTrack() throws Exception {
+    // Just set recording track to a bogus value.
+    PreferencesUtils.setLong(context, R.string.recording_track_id_key, 256L);
+
+    // Make sure that the service will not start recording and will clear
+    // the bogus track.
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertFalse(service.isRecording());
+    assertEquals(-1L, service.getRecordingTrackId());
+  }
+
+  /**
+   * Synchronous/waitable broadcast receiver to be used in testing.
+   */
+  private class BlockingBroadcastReceiver extends BroadcastReceiver {
+    private static final long MAX_WAIT_TIME_MS = 10000;
+    private List<Intent> receivedIntents = new ArrayList<Intent>();
+
+    public List<Intent> getReceivedIntents() {
+      return receivedIntents;
+    }
+
+    @Override
+    public void onReceive(Context ctx, Intent intent) {
+      Log.d("MyTracksTest", "Got broadcast: " + intent);
+      synchronized (receivedIntents) {
+        receivedIntents.add(intent);
+        receivedIntents.notifyAll();
+      }
+    }
+
+    public boolean waitUntilReceived(int receiveCount) {
+      long deadline = System.currentTimeMillis() + MAX_WAIT_TIME_MS;
+      synchronized (receivedIntents) {
+        while (receivedIntents.size() < receiveCount) {
+          try {
+            // Wait releases synchronized lock until it returns
+            receivedIntents.wait(500);
+          } catch (InterruptedException e) {
+            // Do nothing
+          }
+
+          if (System.currentTimeMillis() > deadline) {
+            return false;
+          }
+        }
+      }
+
+      return true;
+    }
+  }
+
+  @MediumTest
+  public void testStartNewTrack_noRecording() throws Exception {
+    // NOTICE: due to the way Android permissions work, if this fails,
+    // uninstall the test apk then retry - the test must be installed *after*
+    // My Tracks (go figure).
+    // Reference: http://code.google.com/p/android/issues/detail?id=5521
+    BlockingBroadcastReceiver startReceiver = new BlockingBroadcastReceiver();
+    String startAction = context.getString(R.string.track_started_broadcast_action);
+    context.registerReceiver(startReceiver, new IntentFilter(startAction));
+
+    List<Track> tracks = providerUtils.getAllTracks();
+    assertTrue(tracks.isEmpty());
+
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertFalse(service.isRecording());
+
+    long id = service.startNewTrack();
+    assertTrue(id >= 0);
+    assertTrue(service.isRecording());
+    Track track = providerUtils.getTrack(id);
+    assertNotNull(track);
+    assertEquals(id, track.getId());
+    assertEquals(PreferencesUtils.getString(
+        context, R.string.default_activity_key, PreferencesUtils.DEFAULT_ACTIVITY_DEFAULT),
+        track.getCategory());
+    assertEquals(id, PreferencesUtils.getLong(context, R.string.recording_track_id_key));
+    assertEquals(id, service.getRecordingTrackId());
+
+    // Verify that the start broadcast was received.
+    assertTrue(startReceiver.waitUntilReceived(1));
+    List<Intent> receivedIntents = startReceiver.getReceivedIntents();
+    assertEquals(1, receivedIntents.size());
+    Intent broadcastIntent = receivedIntents.get(0);
+    assertEquals(startAction, broadcastIntent.getAction());
+    assertEquals(id,
+        broadcastIntent.getLongExtra(context.getString(R.string.track_id_broadcast_extra), -1L));
+
+    context.unregisterReceiver(startReceiver);
+  }
+
+  @MediumTest
+  public void testStartNewTrack_alreadyRecording() throws Exception {
+    createDummyTrack(123L, -1L, true);
+
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertTrue(service.isRecording());
+
+    // Starting a new track when there is a recording should just return -1L.
+    long newTrack = service.startNewTrack();
+    assertEquals(-1L, newTrack);
+
+    assertEquals(123L, PreferencesUtils.getLong(context, R.string.recording_track_id_key));
+    assertEquals(123L, service.getRecordingTrackId());
+  }
+
+  @MediumTest
+  public void testEndCurrentTrack_alreadyRecording() throws Exception {
+    // See comment above if this fails randomly.
+    BlockingBroadcastReceiver stopReceiver = new BlockingBroadcastReceiver();
+    String stopAction = context.getString(R.string.track_stopped_broadcast_action);
+    context.registerReceiver(stopReceiver, new IntentFilter(stopAction));
+
+    createDummyTrack(123L, -1L, true);
+
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertTrue(service.isRecording());
+
+    // End the current track.
+    service.endCurrentTrack();
+    assertFalse(service.isRecording());
+    assertEquals(PreferencesUtils.RECORDING_TRACK_ID_DEFAULT,
+        PreferencesUtils.getLong(context, R.string.recording_track_id_key));
+    assertEquals(PreferencesUtils.RECORDING_TRACK_ID_DEFAULT, service.getRecordingTrackId());
+
+    // Verify that the stop broadcast was received.
+    assertTrue(stopReceiver.waitUntilReceived(1));
+    List<Intent> receivedIntents = stopReceiver.getReceivedIntents();
+    assertEquals(1, receivedIntents.size());
+    Intent broadcastIntent = receivedIntents.get(0);
+    assertEquals(stopAction, broadcastIntent.getAction());
+    assertEquals(123L,
+        broadcastIntent.getLongExtra(context.getString(R.string.track_id_broadcast_extra), -1L));
+
+    context.unregisterReceiver(stopReceiver);
+  }
+
+  @MediumTest
+  public void testEndCurrentTrack_noRecording() throws Exception {
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertFalse(service.isRecording());
+
+    /*
+     * Ending the current track when there is no recording should not result in
+     * any error.
+     */
+    service.endCurrentTrack();
+
+    assertEquals(PreferencesUtils.RECORDING_TRACK_ID_DEFAULT,
+        PreferencesUtils.getLong(context, R.string.recording_track_id_key));
+    assertEquals(PreferencesUtils.RECORDING_TRACK_ID_DEFAULT, service.getRecordingTrackId());
+  }
+
+  @MediumTest
+  public void testIntegration_completeRecordingSession() throws Exception {
+    List<Track> tracks = providerUtils.getAllTracks();
+    assertTrue(tracks.isEmpty());
+    fullRecordingSession();
+  }
+
+  @MediumTest
+  public void testInsertStatisticsMarker_noRecordingTrack() throws Exception {
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertFalse(service.isRecording());
+
+    long waypointId = service.insertWaypoint(WaypointCreationRequest.DEFAULT_STATISTICS);
+    assertEquals(-1L, waypointId);
+  }
+
+  @MediumTest
+  public void testInsertStatisticsMarker_validLocation() throws Exception {
+    createDummyTrack(123L, -1L, true);
+
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertTrue(service.isRecording());
+    assertFalse(service.isPaused());
+    insertLocation(service);
+
+    assertEquals(1, service.insertWaypoint(WaypointCreationRequest.DEFAULT_STATISTICS));
+    assertEquals(2, service.insertWaypoint(WaypointCreationRequest.DEFAULT_STATISTICS));
+
+    Waypoint wpt = providerUtils.getWaypoint(2);
+    assertEquals(getContext().getString(R.string.marker_statistics_icon_url), wpt.getIcon());
+    assertEquals(getContext().getString(R.string.marker_split_name_format, 1), wpt.getName());
+    assertEquals(WaypointType.STATISTICS, wpt.getType());
+    assertEquals(123L, wpt.getTrackId());
+    assertEquals(0.0, wpt.getLength());
+    assertNotNull(wpt.getLocation());
+    assertNotNull(wpt.getTripStatistics());
+    // TODO check the rest of the params.
+
+    // TODO: Check waypoint 2.
+  }
+
+  @MediumTest
+  public void testInsertWaypointMarker_noRecordingTrack() throws Exception {
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertFalse(service.isRecording());
+
+    long waypointId = service.insertWaypoint(WaypointCreationRequest.DEFAULT_WAYPOINT);
+    assertEquals(-1L, waypointId);
+  }
+
+  @MediumTest
+  public void testInsertWaypointMarker_validWaypoint() throws Exception {
+    createDummyTrack(123L, -1L, true);
+
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertTrue(service.isRecording());
+    insertLocation(service);
+
+    assertEquals(1, service.insertWaypoint(WaypointCreationRequest.DEFAULT_WAYPOINT));
+    Waypoint wpt = providerUtils.getWaypoint(1);
+    assertEquals(getContext().getString(R.string.marker_waypoint_icon_url), wpt.getIcon());
+    assertEquals(getContext().getString(R.string.marker_name_format, 1), wpt.getName());
+    assertEquals(WaypointType.WAYPOINT, wpt.getType());
+    assertEquals(123L, wpt.getTrackId());
+    assertEquals(0.0, wpt.getLength());
+    assertNotNull(wpt.getLocation());
+    assertNull(wpt.getTripStatistics());
+  }
+
+  @MediumTest
+  public void testWithProperties_voiceFrequencyDefault() throws Exception {
+    PreferencesUtils.setInt(
+        context, R.string.voice_frequency_key, PreferencesUtils.VOICE_FREQUENCY_DEFAULT);
+    fullRecordingSession();
+  }
+
+  @MediumTest
+  public void testWithProperties_voiceFrequencyByDistance() throws Exception {
+    PreferencesUtils.setInt(context, R.string.voice_frequency_key, -1);
+    fullRecordingSession();
+  }
+
+  @MediumTest
+  public void testWithProperties_voiceFrequencyByTime() throws Exception {
+    PreferencesUtils.setInt(context, R.string.voice_frequency_key, 1);
+    fullRecordingSession();
+  }
+
+  @MediumTest
+  public void testWithProperties_maxRecordingDistanceDefault() throws Exception {
+    PreferencesUtils.setInt(context, R.string.max_recording_distance_key,
+        PreferencesUtils.MAX_RECORDING_DISTANCE_DEFAULT);
+    fullRecordingSession();
+  }
+
+  @MediumTest
+  public void testWithProperties_maxRecordingDistance() throws Exception {
+    PreferencesUtils.setInt(context, R.string.max_recording_distance_key, 50);
+    fullRecordingSession();
+  }
+
+  @MediumTest
+  public void testWithProperties_minRecordingDistanceDefault() throws Exception {
+    PreferencesUtils.setInt(context, R.string.recording_distance_interval_key,
+        PreferencesUtils.RECORDING_DISTANCE_INTERVAL_DEFAULT);
+    fullRecordingSession();
+  }
+
+  @MediumTest
+  public void testWithProperties_minRecordingDistance() throws Exception {
+    PreferencesUtils.setInt(context, R.string.recording_distance_interval_key, 2);
+    fullRecordingSession();
+  }
+
+  @MediumTest
+  public void testWithProperties_splitFrequencyDefault() throws Exception {
+    PreferencesUtils.setInt(
+        context, R.string.split_frequency_key, PreferencesUtils.SPLIT_FREQUENCY_DEFAULT);
+    fullRecordingSession();
+  }
+
+  @MediumTest
+  public void testWithProperties_splitFrequencyByDistance() throws Exception {
+    PreferencesUtils.setInt(context, R.string.split_frequency_key, -1);
+    fullRecordingSession();
+  }
+
+  @MediumTest
+  public void testWithProperties_splitFrequencyByTime() throws Exception {
+    PreferencesUtils.setInt(context, R.string.split_frequency_key, 1);
+    fullRecordingSession();
+  }
+
+  @MediumTest
+  public void testWithProperties_metricUnitsDefault() throws Exception {
+    PreferencesUtils.setString(
+        context, R.string.stats_units_key, PreferencesUtils.STATS_UNITS_DEFAULT);
+    fullRecordingSession();
+  }
+
+  @MediumTest
+  public void testWithProperties_metricUnitsDisabled() throws Exception {
+    PreferencesUtils.setString(
+        context, R.string.stats_units_key, context.getString(R.string.stats_units_imperial));
+    fullRecordingSession();
+  }
+
+  @MediumTest
+  public void testWithProperties_minRecordingIntervalDefault() throws Exception {
+    PreferencesUtils.setInt(context, R.string.min_recording_interval_key,
+        PreferencesUtils.MIN_RECORDING_INTERVAL_DEFAULT);
+    fullRecordingSession();
+  }
+
+  @MediumTest
+  public void testWithProperties_minRecordingInterval() throws Exception {
+    PreferencesUtils.setInt(context, R.string.min_recording_interval_key, 2);
+    fullRecordingSession();
+  }
+
+  @MediumTest
+  public void testWithProperties_minRequiredAccuracyDefault() throws Exception {
+    PreferencesUtils.setInt(context, R.string.recording_gps_accuracy_key,
+        PreferencesUtils.RECORDING_GPS_ACCURACY_DEFAULT);
+    fullRecordingSession();
+  }
+
+  @MediumTest
+  public void testWithProperties_minRequiredAccuracy() throws Exception {
+    PreferencesUtils.setInt(context, R.string.recording_gps_accuracy_key, 500);
+    fullRecordingSession();
+  }
+
+  @MediumTest
+  public void testWithProperties_sensorTypeDefault() throws Exception {
+    PreferencesUtils.setString(
+        context, R.string.sensor_type_key, PreferencesUtils.SENSOR_TYPE_DEFAULT);
+    fullRecordingSession();
+  }
+
+  @MediumTest
+  public void testWithProperties_sensorTypeZephyr() throws Exception {
+    PreferencesUtils.setString(
+        context, R.string.sensor_type_key, context.getString(R.string.sensor_type_value_zephyr));
+    fullRecordingSession();
+  }
+
+  private ITrackRecordingService bindAndGetService(Intent intent) {
+    ITrackRecordingService service = ITrackRecordingService.Stub.asInterface(bindService(intent));
+    assertNotNull(service);
+    return service;
+  }
+
+  private Track createDummyTrack(long id, long stopTime, boolean isRecording) {
+    Track dummyTrack = new Track();
+    dummyTrack.setId(id);
+    dummyTrack.setName("Dummy Track");
+    TripStatistics tripStatistics = new TripStatistics();
+    tripStatistics.setStopTime(stopTime);
+    dummyTrack.setTripStatistics(tripStatistics);
+    addTrack(dummyTrack, isRecording);
+    return dummyTrack;
+  }
+
+  private void updateAutoResumePrefs(int attempts, int timeoutMins) {
+    PreferencesUtils.setInt(context, R.string.auto_resume_track_current_retry_key, attempts);
+    PreferencesUtils.setInt(context, R.string.auto_resume_track_timeout_key, timeoutMins);
+  }
+
+  private Intent createStartIntent() {
+    Intent startIntent = new Intent();
+    startIntent.setClass(context, TrackRecordingService.class);
+    return startIntent;
+  }
+
+  private void addTrack(Track track, boolean isRecording) {
+    assertTrue(track.getId() >= 0);
+    providerUtils.insertTrack(track);
+    assertEquals(track.getId(), providerUtils.getTrack(track.getId()).getId());
+    PreferencesUtils.setLong(context, R.string.recording_track_id_key,
+        isRecording ? track.getId() : PreferencesUtils.RECORDING_TRACK_ID_DEFAULT);
+    PreferencesUtils.setBoolean(context, R.string.recording_track_paused_key, !isRecording);
+  }
+
+  private void fullRecordingSession() throws Exception {
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertFalse(service.isRecording());
+
+    // Start a track.
+    long id = service.startNewTrack();
+    assertTrue(id >= 0);
+    assertTrue(service.isRecording());
+    Track track = providerUtils.getTrack(id);
+    assertNotNull(track);
+    assertEquals(id, track.getId());
+    assertEquals(id, PreferencesUtils.getLong(context, R.string.recording_track_id_key));
+    assertEquals(id, service.getRecordingTrackId());
+
+    // Insert a few points, markers and statistics.
+    long startTime = System.currentTimeMillis();
+    for (int i = 0; i < 30; i++) {
+      Location loc = new Location("gps");
+      loc.setLongitude(35.0f + i / 10.0f);
+      loc.setLatitude(45.0f - i / 5.0f);
+      loc.setAccuracy(5);
+      loc.setSpeed(10);
+      loc.setTime(startTime + i * 10000);
+      loc.setBearing(3.0f);
+      service.insertTrackPoint(loc);
+
+      if (i % 10 == 0) {
+        service.insertWaypoint(WaypointCreationRequest.DEFAULT_STATISTICS);
+      } else if (i % 7 == 0) {
+        service.insertWaypoint(WaypointCreationRequest.DEFAULT_WAYPOINT);
+      }
+    }
+
+    // Stop the track. Validate if it has correct data.
+    service.endCurrentTrack();
+    assertFalse(service.isRecording());
+    assertEquals(-1L, service.getRecordingTrackId());
+    track = providerUtils.getTrack(id);
+    assertNotNull(track);
+    assertEquals(id, track.getId());
+    TripStatistics tripStatistics = track.getTripStatistics();
+    assertNotNull(tripStatistics);
+    assertTrue(tripStatistics.getStartTime() > 0);
+    assertTrue(tripStatistics.getStopTime() >= tripStatistics.getStartTime());
+  }
+
+  /**
+   * Inserts a location and waits for 100ms.
+   * 
+   * @param trackRecordingService the track recording service
+   */
+  private void insertLocation(ITrackRecordingService trackRecordingService)
+      throws RemoteException, InterruptedException {
+    Location location = new Location("gps");
+    location.setLongitude(35.0f);
+    location.setLatitude(45.0f);
+    location.setAccuracy(5);
+    location.setSpeed(10);
+    location.setTime(System.currentTimeMillis());
+    location.setBearing(3.0f);
+    trackRecordingService.insertTrackPoint(location);
+    Thread.sleep(200);
+  }
+}

src/androidTest/java/com/google/android/apps/mytracks/services/tasks/AnnouncementPeriodicTaskFactoryTest.java

@@ -0,0 +1,38 @@
+/*
+ * 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 com.google.android.apps.mytracks.services.tasks;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.platform.app.InstrumentationRegistry;
+
+import org.junit.Assert;
+import org.junit.runner.RunWith;
+
+/**
+ * Tests for {@link AnnouncementPeriodicTaskFactory}.
+ * These tests require Donut+ to run.
+ *
+ * @author Rodrigo Damazio
+ */
+@RunWith(AndroidJUnit4.class)
+public class AnnouncementPeriodicTaskFactoryTest {
+  public void testCreate() {
+    PeriodicTaskFactory factory = new AnnouncementPeriodicTaskFactory();
+    PeriodicTask task = factory.create(InstrumentationRegistry.getInstrumentation().getContext());
+    Assert.assertTrue(task instanceof AnnouncementPeriodicTask);
+  }
+}

src/androidTest/java/com/google/android/apps/mytracks/services/tasks/AnnouncementPeriodicTaskTest.java

@@ -0,0 +1,533 @@
+/*
+ * 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 com.google.android.apps.mytracks.services.tasks;
+
+import static com.google.android.testing.mocking.AndroidMock.capture;
+import static com.google.android.testing.mocking.AndroidMock.eq;
+import static com.google.android.testing.mocking.AndroidMock.expect;
+import static com.google.android.testing.mocking.AndroidMock.same;
+
+import com.google.android.apps.mytracks.stats.TripStatistics;
+import com.google.android.apps.mytracks.util.StringUtils;
+import com.google.android.testing.mocking.AndroidMock;
+import com.google.android.testing.mocking.UsesMocks;
+
+import android.content.Context;
+import android.speech.tts.TextToSpeech;
+import android.speech.tts.TextToSpeech.OnInitListener;
+import android.speech.tts.TextToSpeech.OnUtteranceCompletedListener;
+import android.telephony.PhoneStateListener;
+import android.telephony.TelephonyManager;
+import android.test.AndroidTestCase;
+
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.easymock.Capture;
+import org.easymock.EasyMock;
+
+/**
+ * Tests for {@link AnnouncementPeriodicTask}.
+ * WARNING: I'm not responsible if your eyes start bleeding while reading this
+ *          code. You have been warned. It's still better than no test, though.
+ *
+ * @author Rodrigo Damazio
+ */
+public class AnnouncementPeriodicTaskTest extends AndroidTestCase {
+
+  // Use something other than our hardcoded value
+  private static final Locale DEFAULT_LOCALE = Locale.KOREAN;
+  private static final String ANNOUNCEMENT = "I can haz cheeseburger?";
+  private Locale oldDefaultLocale;
+
+  private AnnouncementPeriodicTask task;
+  private AnnouncementPeriodicTask mockTask;
+  private Capture<OnInitListener> initListenerCapture;
+  private Capture<PhoneStateListener> phoneListenerCapture;
+  private TextToSpeechDelegate ttsDelegate;
+  private TextToSpeechInterface tts;
+
+  /**
+   * Mockable interface that we delegate TTS calls to.
+   */
+  interface TextToSpeechInterface {
+    int addEarcon(String earcon, String packagename, int resourceId);
+    int addEarcon(String earcon, String filename);
+    int addSpeech(String text, String packagename, int resourceId);
+    int addSpeech(String text, String filename);
+    boolean areDefaultsEnforced();
+    String getDefaultEngine();
+    Locale getLanguage();
+    int isLanguageAvailable(Locale loc);
+    boolean isSpeaking();
+    int playEarcon(String earcon, int queueMode,
+        HashMap<String, String> params);
+    int playSilence(long durationInMs, int queueMode,
+        HashMap<String, String> params);
+    int setEngineByPackageName(String enginePackageName);
+    int setLanguage(Locale loc);
+    int setOnUtteranceCompletedListener(OnUtteranceCompletedListener listener);
+    int setPitch(float pitch);
+    int setSpeechRate(float speechRate);
+    void shutdown();
+    int speak(String text, int queueMode, HashMap<String, String> params);
+    int stop();
+    int synthesizeToFile(String text, HashMap<String, String> params,
+        String filename);
+  }
+
+  /**
+   * Subclass of {@link TextToSpeech} which delegates calls to the interface
+   * above.
+   * The logic here is stupid and the author is ashamed of having to write it
+   * like this, but basically the issue is that TextToSpeech cannot be mocked
+   * without running its constructor, its constructor runs async operations
+   * which call other methods (and then if the methods are part of a mock we'd
+   * have to set a behavior, but we can't 'cause the object hasn't been fully
+   * built yet).
+   * The logic is that calls made during the constructor (when tts is not yet
+   * set) will go up to the original class, but after tts is set we'll forward
+   * them all to the mock.
+   */
+  private class TextToSpeechDelegate
+      extends TextToSpeech implements TextToSpeechInterface {
+    public TextToSpeechDelegate(Context context, OnInitListener listener) {
+      super(context, listener);
+    }
+
+    @Override
+    public int addEarcon(String earcon, String packagename, int resourceId) {
+      if (tts == null) {
+        return super.addEarcon(earcon, packagename, resourceId);
+      }
+      return tts.addEarcon(earcon, packagename, resourceId);
+    }
+
+    @Override
+    public int addEarcon(String earcon, String filename) {
+      if (tts == null) {
+        return super.addEarcon(earcon, filename);
+      }
+      return tts.addEarcon(earcon, filename);
+    }
+
+    @Override
+    public int addSpeech(String text, String packagename, int resourceId) {
+      if (tts == null) {
+        return super.addSpeech(text, packagename, resourceId);
+      }
+      return tts.addSpeech(text, packagename, resourceId);
+    }
+
+    @Override
+    public int addSpeech(String text, String filename) {
+      if (tts == null) {
+        return super.addSpeech(text, filename);
+      }
+      return tts.addSpeech(text, filename);
+    }
+
+    @Override
+    public Locale getLanguage() {
+      if (tts == null) {
+        return super.getLanguage();
+      }
+      return tts.getLanguage();
+    }
+
+    @Override
+    public int isLanguageAvailable(Locale loc) {
+      if (tts == null) {
+        return super.isLanguageAvailable(loc);
+      }
+      return tts.isLanguageAvailable(loc);
+    }
+
+    @Override
+    public boolean isSpeaking() {
+      if (tts == null) {
+        return super.isSpeaking();
+      }
+      return tts.isSpeaking();
+    }
+
+    @Override
+    public int playEarcon(String earcon, int queueMode,
+        HashMap<String, String> params) {
+      if (tts == null) {
+        return super.playEarcon(earcon, queueMode, params);
+      }
+      return tts.playEarcon(earcon, queueMode, params);
+    }
+
+    @Override
+    public int playSilence(long durationInMs, int queueMode,
+        HashMap<String, String> params) {
+      if (tts == null) {
+        return super.playSilence(durationInMs, queueMode, params);
+      }
+      return tts.playSilence(durationInMs, queueMode, params);
+    }
+
+    @Override
+    public int setLanguage(Locale loc) {
+      if (tts == null) {
+        return super.setLanguage(loc);
+      }
+      return tts.setLanguage(loc);
+    }
+
+    @Override
+    public int setOnUtteranceCompletedListener(
+        OnUtteranceCompletedListener listener) {
+      if (tts == null) {
+        return super.setOnUtteranceCompletedListener(listener);
+      }
+      return tts.setOnUtteranceCompletedListener(listener);
+    }
+
+    @Override
+    public int setPitch(float pitch) {
+      if (tts == null) {
+        return super.setPitch(pitch);
+      }
+      return tts.setPitch(pitch);
+    }
+
+    @Override
+    public int setSpeechRate(float speechRate) {
+      if (tts == null) {
+        return super.setSpeechRate(speechRate);
+      }
+      return tts.setSpeechRate(speechRate);
+    }
+
+    @Override
+    public void shutdown() {
+      if (tts == null) {
+        super.shutdown();
+        return;
+      }
+      tts.shutdown();
+    }
+
+    @Override
+    public int speak(
+        String text, int queueMode, HashMap<String, String> params) {
+      if (tts == null) {
+        return super.speak(text, queueMode, params);
+      }
+      return tts.speak(text, queueMode, params);
+    }
+
+    @Override
+    public int stop() {
+      if (tts == null) {
+        return super.stop();
+      }
+      return tts.stop();
+    }
+
+    @Override
+    public int synthesizeToFile(String text, HashMap<String, String> params,
+        String filename) {
+      if (tts == null) {
+        return super.synthesizeToFile(text, params, filename);
+      }
+      return tts.synthesizeToFile(text, params, filename);
+    }
+  }
+
+  @UsesMocks({
+    AnnouncementPeriodicTask.class,
+    StringUtils.class,
+  })
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+
+    oldDefaultLocale = Locale.getDefault();
+    Locale.setDefault(DEFAULT_LOCALE);
+
+    // Eww, the effort required just to mock TextToSpeech is insane
+    final AtomicBoolean listenerCalled = new AtomicBoolean();
+    OnInitListener blockingListener = new OnInitListener() {
+      @Override
+      public void onInit(int status) {
+        synchronized (this) {
+          listenerCalled.set(true);
+          notify();
+        }
+      }
+    };
+
+    ttsDelegate = new TextToSpeechDelegate(getContext(), blockingListener);
+
+    // Wait for all async operations done in the constructor to finish.
+    synchronized (blockingListener) {
+      while (!listenerCalled.get()) {
+        // Releases the synchronized lock until we're woken up.
+        blockingListener.wait();
+      }
+    }
+
+    // Phew, done, now we can start forwarding calls
+    tts = AndroidMock.createMock(TextToSpeechInterface.class);
+
+    initListenerCapture = new Capture<OnInitListener>();
+    phoneListenerCapture = new Capture<PhoneStateListener>();
+
+    // Create a partial forwarding mock
+    mockTask = AndroidMock.createMock(AnnouncementPeriodicTask.class, getContext());
+    task = new AnnouncementPeriodicTask(getContext()) {
+      @Override
+      protected TextToSpeech newTextToSpeech(Context ctx,
+          OnInitListener onInitListener) {
+        return mockTask.newTextToSpeech(ctx, onInitListener);
+      }
+
+      @Override
+      protected String getAnnouncement(TripStatistics stats) {
+        return mockTask.getAnnouncement(stats);
+      }
+
+      @Override
+      protected void listenToPhoneState(
+          PhoneStateListener listener, int events) {
+        mockTask.listenToPhoneState(listener, events);
+      }
+    };
+  }
+
+  @Override
+  protected void tearDown() {
+    Locale.setDefault(oldDefaultLocale);
+  }
+
+  public void testStart() {
+    doStart();
+    OnInitListener ttsInitListener = initListenerCapture.getValue();
+    assertNotNull(ttsInitListener);
+
+    AndroidMock.replay(tts);
+
+    ttsInitListener.onInit(TextToSpeech.SUCCESS);
+
+    AndroidMock.verify(mockTask, tts);
+  }
+
+  public void testStart_notReady() {
+    doStart();
+    OnInitListener ttsInitListener = initListenerCapture.getValue();
+    assertNotNull(ttsInitListener);
+
+    AndroidMock.replay(tts);
+
+    ttsInitListener.onInit(TextToSpeech.ERROR);
+
+    AndroidMock.verify(mockTask, tts);
+  }
+
+  public void testShutdown() {
+    // First, start
+    doStart();
+    AndroidMock.verify(mockTask);
+    AndroidMock.reset(mockTask);
+
+    // Then, shut down
+    PhoneStateListener phoneListener = phoneListenerCapture.getValue();
+    mockTask.listenToPhoneState(
+        same(phoneListener), eq(PhoneStateListener.LISTEN_NONE));
+    tts.shutdown();
+    AndroidMock.replay(mockTask, tts);
+    task.shutdown();
+    AndroidMock.verify(mockTask, tts);
+  }
+
+  public void testRun() throws Exception {
+    // Expect service data calls
+    TripStatistics stats = new TripStatistics();
+
+    // Expect announcement building call
+    expect(mockTask.getAnnouncement(same(stats))).andStubReturn(ANNOUNCEMENT);
+
+    // Put task in "ready" state
+    startTask(TextToSpeech.SUCCESS);
+
+    expect(tts.isLanguageAvailable(DEFAULT_LOCALE)).andStubReturn(TextToSpeech.LANG_AVAILABLE);
+    expect(tts.setLanguage(DEFAULT_LOCALE)).andReturn(TextToSpeech.LANG_AVAILABLE);
+    expect(tts.setSpeechRate(AnnouncementPeriodicTask.TTS_SPEECH_RATE)).andReturn(
+        TextToSpeech.SUCCESS);
+    expect(tts.setOnUtteranceCompletedListener((OnUtteranceCompletedListener) EasyMock.anyObject()))
+        .andReturn(0);
+
+    // Expect actual announcement call
+    expect(
+        tts.speak(eq(ANNOUNCEMENT), eq(TextToSpeech.QUEUE_FLUSH),
+            eq(AnnouncementPeriodicTask.SPEECH_PARAMS))).andReturn(0);
+
+    // Run the announcement
+    AndroidMock.replay(tts);
+    task.announce(stats);
+    AndroidMock.verify(mockTask, tts);
+  }
+
+  public void testRun_notReady() throws Exception {
+    // Put task in "not ready" state
+    startTask(TextToSpeech.ERROR);
+
+    // Run the announcement
+    AndroidMock.replay(tts);
+    task.run(null);
+    AndroidMock.verify(mockTask, tts);
+  }
+
+  public void testRun_duringCall() throws Exception {
+    startTask(TextToSpeech.SUCCESS);
+
+    expect(tts.isSpeaking()).andStubReturn(false);
+
+    // Run the announcement
+    AndroidMock.replay(tts);
+    PhoneStateListener phoneListener = phoneListenerCapture.getValue();
+    phoneListener.onCallStateChanged(TelephonyManager.CALL_STATE_OFFHOOK, null);
+    task.run(null);
+    AndroidMock.verify(mockTask, tts);
+  }
+
+  public void testRun_ringWhileSpeaking() throws Exception {
+    startTask(TextToSpeech.SUCCESS);
+
+    expect(tts.isSpeaking()).andStubReturn(true);
+    expect(tts.stop()).andReturn(TextToSpeech.SUCCESS);
+
+    AndroidMock.replay(tts);
+
+    // Update the state to ringing - this should stop the current announcement.
+    PhoneStateListener phoneListener = phoneListenerCapture.getValue();
+    phoneListener.onCallStateChanged(TelephonyManager.CALL_STATE_RINGING, null);
+
+    // Run the announcement - this should do nothing.
+    task.run(null);
+
+    AndroidMock.verify(mockTask, tts);
+  }
+
+  public void testRun_whileRinging() throws Exception {
+    startTask(TextToSpeech.SUCCESS);
+
+    expect(tts.isSpeaking()).andStubReturn(false);
+
+    // Run the announcement
+    AndroidMock.replay(tts);
+    PhoneStateListener phoneListener = phoneListenerCapture.getValue();
+    phoneListener.onCallStateChanged(TelephonyManager.CALL_STATE_RINGING, null);
+    task.run(null);
+    AndroidMock.verify(mockTask, tts);
+  }
+
+  public void testRun_noService() throws Exception {
+    startTask(TextToSpeech.SUCCESS);
+
+    // Run the announcement
+    AndroidMock.replay(tts);
+    task.run(null);
+    AndroidMock.verify(mockTask, tts);
+  }
+
+  public void testRun_noStats() throws Exception {
+    // Expect service data calls
+
+    startTask(TextToSpeech.SUCCESS);
+
+    // Run the announcement
+    AndroidMock.replay(tts);
+    task.run(null);
+    AndroidMock.verify(mockTask, tts);
+  }
+  
+  /**
+   * Tests {@link AnnouncementPeriodicTask#getAnnounceTime(long)} with time zero.
+   */
+  public void testGetAnnounceTime_time_zero() {
+    long time = 0; // 0 seconds
+    assertEquals("0 minutes 0 seconds", task.getAnnounceTime(time));
+  }
+
+  /**
+   * Tests {@link AnnouncementPeriodicTask#getAnnounceTime(long)} with time one.
+   */
+  public void testGetAnnounceTime_time_one() {
+    long time = 1 * 1000; // 1 second
+    assertEquals("0 minutes 1 second", task.getAnnounceTime(time));
+  }
+
+  /**
+   * Tests {@link AnnouncementPeriodicTask#getAnnounceTime(long)} with singular
+   * numbers with the hour unit.
+   */
+  public void testGetAnnounceTime_singular_has_hour() {
+    long time = (1 * 60 * 60 * 1000) + (1 * 60 * 1000) + (1 * 1000); // 1 hour 1 minute 1 second
+    assertEquals("1 hour 1 minute 1 second", task.getAnnounceTime(time));
+  }
+
+  /**
+   * Tests {@link AnnouncementPeriodicTask#getAnnounceTime(long)} with plural numbers
+   * with the hour unit.
+   */
+  public void testGetAnnounceTime_plural_has_hour() {
+    long time = (2 * 60 * 60 * 1000) + (2 * 60 * 1000) + (2 * 1000); // 2 hours 2 minutes 2 seconds
+    assertEquals("2 hours 2 minutes 2 seconds", task.getAnnounceTime(time));
+  }
+  
+  /**
+   * Tests {@link AnnouncementPeriodicTask#getAnnounceTime(long)} with singular
+   * numbers without the hour unit.
+   */
+  public void testGetAnnounceTime_singular_no_hour() {
+    long time = (1 * 60 * 1000) + (1 * 1000); // 1 minute 1 second
+    assertEquals("1 minute 1 second", task.getAnnounceTime(time));
+  }
+
+  /**
+   * Tests {@link AnnouncementPeriodicTask#getAnnounceTime(long)} with plural numbers
+   * without the hour unit.
+   */
+  public void testGetAnnounceTime_plural_no_hour() {
+    long time = (2 * 60 * 1000) + (2 * 1000); // 2 minutes 2 seconds
+    assertEquals("2 minutes 2 seconds", task.getAnnounceTime(time));
+  }
+  
+  private void startTask(int state) {
+    AndroidMock.resetToNice(tts);
+    AndroidMock.replay(tts);
+    doStart();
+    OnInitListener ttsInitListener = initListenerCapture.getValue();
+    ttsInitListener.onInit(state);
+    AndroidMock.resetToDefault(tts);
+  }
+
+  private void doStart() {
+    mockTask.listenToPhoneState(capture(phoneListenerCapture),
+        eq(PhoneStateListener.LISTEN_CALL_STATE));
+    expect(mockTask.newTextToSpeech(
+        same(getContext()), capture(initListenerCapture)))
+        .andStubReturn(ttsDelegate);
+    AndroidMock.replay(mockTask);
+    task.start();
+  }
+}

src/androidTest/java/com/google/android/apps/mytracks/stats/TripStatisticsTest.java

@@ -0,0 +1,105 @@
+/*
+ * 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 com.google.android.apps.mytracks.stats;
+
+import junit.framework.TestCase;
+
+/**
+ * Tests for {@link TripStatistics}.
+ * This only tests non-trivial pieces of that class.
+ *
+ * @author Rodrigo Damazio
+ */
+public class TripStatisticsTest extends TestCase {
+
+  private TripStatistics statistics;
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+
+    statistics = new TripStatistics();
+  }
+
+  public void testSetBounds() {
+    // This is not a trivial setter, conversion happens in it
+    statistics.setBounds(12345, -34567, 56789, -98765);
+    assertEquals(12345, statistics.getLeft());
+    assertEquals(-34567, statistics.getTop());
+    assertEquals(56789, statistics.getRight());
+    assertEquals(-98765, statistics.getBottom());
+  }
+
+  public void testMerge() {
+    TripStatistics statistics2 = new TripStatistics();
+    statistics.setStartTime(1000L);  // Resulting start time
+    statistics.setStopTime(2500L);
+    statistics2.setStartTime(3000L);
+    statistics2.setStopTime(4000L);  // Resulting stop time
+    statistics.setTotalTime(1500L);
+    statistics2.setTotalTime(1000L);  // Result: 1500+1000
+    statistics.setMovingTime(700L);
+    statistics2.setMovingTime(600L);  // Result: 700+600
+    statistics.setTotalDistance(750.0);
+    statistics2.setTotalDistance(350.0);  // Result: 750+350
+    statistics.setTotalElevationGain(50.0);
+    statistics2.setTotalElevationGain(850.0);  // Result: 850+50
+    statistics.setMaxSpeed(60.0);  // Resulting max speed
+    statistics2.setMaxSpeed(30.0);
+    statistics.setMaxElevation(1250.0);
+    statistics.setMinElevation(1200.0);  // Resulting min elevation
+    statistics2.setMaxElevation(3575.0);  // Resulting max elevation
+    statistics2.setMinElevation(2800.0);
+    statistics.setMaxGrade(15.0);
+    statistics.setMinGrade(-25.0);  // Resulting min grade
+    statistics2.setMaxGrade(35.0);  // Resulting max grade
+    statistics2.setMinGrade(0.0);
+
+    // Resulting bounds: -10000, 35000, 30000, -40000
+    statistics.setBounds(-10000, 20000, 30000, -40000);
+    statistics2.setBounds(-5000, 35000, 0, 20000);
+
+    statistics.merge(statistics2);
+
+    assertEquals(1000L, statistics.getStartTime());
+    assertEquals(4000L, statistics.getStopTime());
+    assertEquals(2500L, statistics.getTotalTime());
+    assertEquals(1300L, statistics.getMovingTime());
+    assertEquals(1100.0, statistics.getTotalDistance());
+    assertEquals(900.0, statistics.getTotalElevationGain());
+    assertEquals(statistics.getTotalDistance()/ (statistics.getMovingTime() / 1000.0), statistics.getMaxSpeed());
+    assertEquals(-10000, statistics.getLeft());
+    assertEquals(30000, statistics.getRight());
+    assertEquals(35000, statistics.getTop());
+    assertEquals(-40000, statistics.getBottom());
+    assertEquals(1200.0, statistics.getMinElevation());
+    assertEquals(3575.0, statistics.getMaxElevation());
+    assertEquals(-25.0, statistics.getMinGrade());
+    assertEquals(35.0, statistics.getMaxGrade());
+  }
+
+  public void testGetAverageSpeed() {
+    statistics.setTotalDistance(1000.0);
+    statistics.setTotalTime(50000);  // in milliseconds
+    assertEquals(20.0, statistics.getAverageSpeed());
+  }
+
+  public void testGetAverageMovingSpeed() {
+    statistics.setTotalDistance(1000.0);
+    statistics.setMovingTime(20000);  // in milliseconds
+    assertEquals(50.0, statistics.getAverageMovingSpeed());
+  }
+}

src/androidTest/java/com/google/android/apps/mytracks/util/FileUtilsTest.java

@@ -0,0 +1,121 @@
+/*
+ * 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 com.google.android.apps.mytracks.util;
+
+import android.os.Environment;
+
+import java.io.File;
+
+import junit.framework.TestCase;
+
+/**
+ * Tests for {@link FileUtils}.
+ * 
+ * @author Rodrigo Damazio
+ */
+public class FileUtilsTest extends TestCase {
+
+  /**
+   * Tests {@link FileUtils#getPath(String...)}.
+   */
+  public void testBuildExternalDirectoryPath() {
+    String expectedName = Environment.getExternalStorageDirectory() + File.separator
+        + FileUtils.SDCARD_TOP_DIR + File.separator + "a" + File.separator + "b" + File.separator
+        + "c";
+    String dirName = FileUtils.getPath("a", "b", "c");
+    assertEquals(expectedName, dirName);
+  }
+
+  /**
+   * Tests {@link FileUtils#buildUniqueFileName(File, String, String)} when the
+   * file is new.
+   */
+  public void testBuildUniqueFileName_new() {
+    String filename = FileUtils.buildUniqueFileName(new File("/dir"), "Filename", "ext");
+    assertEquals("Filename.ext", filename);
+  }
+
+  /**
+   * Tests {@link FileUtils#buildUniqueFileName(File, String, String)} when the
+   * file exists already.
+   */
+  public void testBuildUniqueFileName_exist() {
+    // Expect "/default.prop" to exist on the phone/emulator
+    String filename = FileUtils.buildUniqueFileName(new File("/"), "default", "prop");
+    assertEquals("default(1).prop", filename);
+  }
+
+  /**
+   * Tests {@link FileUtils#sanitizeFileName(String)} with special characters.
+   * Verifies that they are sanitized.
+   */
+  public void testSanitizeFileName() {
+    String name = "Swim\10ming-^across:/the/ pacific (ocean).";
+    String expected = "Swim_ming-^across_the_ pacific (ocean)_";
+    assertEquals(expected, FileUtils.sanitizeFileName(name));
+  }
+
+  /**
+   * Tests {@link FileUtils#sanitizeFileName(String)} with i18n characters (in
+   * Chinese and Russian). Verifies that they are allowed.
+   */
+  public void testSanitizeFileName_i18n() {
+    String name = "您好-привет";
+    String expected = "您好-привет";
+    assertEquals(expected, FileUtils.sanitizeFileName(name));
+  }
+
+  /**
+   * Tests {@link FileUtils#sanitizeFileName(String)} with special FAT32
+   * characters. Verifies that they are allowed.
+   */
+  public void testSanitizeFileName_special_characters() {
+    String name = "$%'-_@~`!(){}^#&+,;=[] ";
+    String expected = "$%'-_@~`!(){}^#&+,;=[] ";
+    assertEquals(expected, FileUtils.sanitizeFileName(name));
+  }
+
+  /**
+   * Tests {@link FileUtils#sanitizeFileName(String)} with multiple escaped
+   * characters in a row. Verifies that they are collapsed into one underscore.
+   */
+  public void testSanitizeFileName_collapse() {
+    String name = "hello//there";
+    String expected = "hello_there";
+    assertEquals(expected, FileUtils.sanitizeFileName(name));
+  }
+
+  /**
+   * Tests {@link FileUtils#truncateFileName(File, String, String)}. Verifies
+   * the a long file name is truncated.
+   */
+  public void testTruncateFileName() {
+    File directory = new File("/dir1/dir2/");
+    String suffix = ".gpx";
+    char[] name = new char[FileUtils.MAX_FAT32_PATH_LENGTH];
+    for (int i = 0; i < name.length; i++) {
+      name[i] = 'a';
+    }
+    String nameString = new String(name);
+    String truncated = FileUtils.truncateFileName(directory, nameString, suffix);
+
+    for (int i = 0; i < truncated.length(); i++) {
+      assertEquals('a', truncated.charAt(i));
+    }
+    assertEquals(FileUtils.MAX_FAT32_PATH_LENGTH,
+        new File(directory, truncated + suffix).getPath().length());
+  }
+}

src/androidTest/java/com/google/android/apps/mytracks/util/StringUtilsTest.java

@@ -0,0 +1,188 @@
+/*
+ * 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 com.google.android.apps.mytracks.util;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.platform.app.InstrumentationRegistry;
+
+import org.junit.Assert;
+import org.junit.runner.RunWith;
+
+import java.util.GregorianCalendar;
+import java.util.TimeZone;
+
+/**
+ * Tests for {@link StringUtils}.
+ *
+ * @author Rodrigo Damazio
+ */
+@RunWith(AndroidJUnit4.class)
+public class StringUtilsTest {
+
+  /**
+   * Tests {@link StringUtils#formatDateTimeIso8601(long)}.
+   */
+  public void testFormatDateTimeIso8601() {
+    Assert.assertEquals("1970-01-01T00:00:12.345Z", StringUtils.formatDateTimeIso8601(12345));
+  }
+
+  /**
+   * Tests {@link StringUtils#formatElapsedTime(long)}.
+   */
+  public void testformatElapsedTime() {
+    // 1 second
+    Assert.assertEquals("00:01", StringUtils.formatElapsedTime(1000));
+    // 10 seconds
+    Assert.assertEquals("00:10", StringUtils.formatElapsedTime(10000));
+    // 1 minute
+    Assert.assertEquals("01:00", StringUtils.formatElapsedTime(60000));
+    // 10 minutes
+    Assert.assertEquals("10:00", StringUtils.formatElapsedTime(600000));
+    // 1 hour
+    Assert.assertEquals("1:00:00", StringUtils.formatElapsedTime(3600000));
+    // 10 hours
+    Assert.assertEquals("10:00:00", StringUtils.formatElapsedTime(36000000));
+    // 100 hours
+    Assert.assertEquals("100:00:00", StringUtils.formatElapsedTime(360000000));
+  }
+
+  /**
+   * Tests {@link StringUtils#formatElapsedTimeWithHour(long)}.
+   */
+  public void testformatElapsedTimeWithHour() {
+    // 1 second
+    Assert.assertEquals("0:00:01", StringUtils.formatElapsedTimeWithHour(1000));
+    // 10 seconds
+    Assert.assertEquals("0:00:10", StringUtils.formatElapsedTimeWithHour(10000));
+    // 1 minute
+    Assert.assertEquals("0:01:00", StringUtils.formatElapsedTimeWithHour(60000));
+    // 10 minutes
+    Assert.assertEquals("0:10:00", StringUtils.formatElapsedTimeWithHour(600000));
+    // 1 hour
+    Assert.assertEquals("1:00:00", StringUtils.formatElapsedTimeWithHour(3600000));
+    // 10 hours
+    Assert.assertEquals("10:00:00", StringUtils.formatElapsedTimeWithHour(36000000));
+    // 100 hours
+    Assert.assertEquals("100:00:00", StringUtils.formatElapsedTimeWithHour(360000000));
+  }
+
+  /**
+   * Tests {@link StringUtils#formatDistance(android.content.Context, double,
+   * boolean)}.
+   */
+  public void testFormatDistance() {
+    // A large number in metric
+    Assert.assertEquals("5.00 km", StringUtils.formatDistance(InstrumentationRegistry.getInstrumentation().getContext(), 5000, true));
+    // A large number in imperial
+    Assert.assertEquals("3.11 mi", StringUtils.formatDistance(InstrumentationRegistry.getInstrumentation().getContext(), 5000, false));
+    // A small number in metric
+    Assert.assertEquals("100.00 m", StringUtils.formatDistance(InstrumentationRegistry.getInstrumentation().getContext(), 100, true));
+    // A small number in imperial
+    Assert.assertEquals("328.08 ft", StringUtils.formatDistance(InstrumentationRegistry.getInstrumentation().getContext(), 100, false));
+  }
+
+  /**
+   * Tests {@link StringUtils#formatCData(String)}.
+   */
+  public void testFormatCData() {
+    Assert.assertEquals("<![CDATA[hello]]>", StringUtils.formatCData("hello"));
+    Assert.assertEquals("<![CDATA[hello]]]]><![CDATA[>there]]>", StringUtils.formatCData("hello]]>there"));
+  }
+  
+  /**
+   * Tests {@link StringUtils#getTime(String)}.
+   */
+  public void testGetTime() {
+    assertGetTime("2010-05-04T03:02:01", 2010, 5, 4, 3, 2, 1, 0);
+    assertGetTime("2010-05-04T03:02:01Z", 2010, 5, 4, 3, 2, 1, 0);
+  }
+
+  /**
+   * Tests {@link StringUtils#getTime(String)} with fractional seconds.
+   */
+  public void testGetTime_fractional() {
+    assertGetTime("2010-05-04T03:02:01.3", 2010, 5, 4, 3, 2, 1, 300);
+    assertGetTime("2010-05-04T03:02:01.35", 2010, 5, 4, 3, 2, 1, 350);
+    assertGetTime("2010-05-04T03:02:01.352Z", 2010, 5, 4, 3, 2, 1, 352);
+    assertGetTime("2010-05-04T03:02:01.3525Z", 2010, 5, 4, 3, 2, 1, 352);
+  }
+
+  /**
+   * Tests {@link StringUtils#getTime(String)} with time zone.
+   */
+  public void testGetTime_timezone() {
+    assertGetTime("2010-05-04T03:02:01Z", 2010, 5, 4, 3, 2, 1, 0);
+    assertGetTime("2010-05-04T03:02:01+00:00", 2010, 5, 4, 3, 2, 1, 0);
+    assertGetTime("2010-05-04T03:02:01-00:00", 2010, 5, 4, 3, 2, 1, 0);
+    assertGetTime("2010-05-04T03:02:01+01:00", 2010, 5, 4, 2, 2, 1, 0);
+    assertGetTime("2010-05-04T03:02:01+10:30", 2010, 5, 3, 16, 32, 1, 0);
+    assertGetTime("2010-05-04T03:02:01-09:30", 2010, 5, 4, 12, 32, 1, 0);
+    assertGetTime("2010-05-04T03:02:01-05:00", 2010, 5, 4, 8, 2, 1, 0);
+  }
+
+  /**
+   * Tests {@link StringUtils#getTime(String)} with fractional seconds and time
+   * zone.
+   */
+  public void testGetTime_fractionalAndTimezone() {
+    assertGetTime("2010-05-04T03:02:01.352Z", 2010, 5, 4, 3, 2, 1, 352);
+    assertGetTime("2010-05-04T03:02:01.47+00:00", 2010, 5, 4, 3, 2, 1, 470);
+    assertGetTime("2010-05-04T03:02:01.5791+03:00", 2010, 5, 4, 0, 2, 1, 579);
+    assertGetTime("2010-05-04T03:02:01.8-05:30", 2010, 5, 4, 8, 32, 1, 800);
+  }
+
+  /**
+   * Asserts the {@link StringUtils#getTime(String)} returns the expected
+   * values.
+   *
+   * @param xmlDateTime the xml date time string
+   * @param year the expected year
+   * @param month the expected month
+   * @param day the expected day
+   * @param hour the expected hour
+   * @param minute the expected minute
+   * @param second the expected second
+   * @param millisecond the expected milliseconds
+   */
+  private void assertGetTime(String xmlDateTime, int year, int month, int day, int hour, int minute,
+      int second, int millisecond) {
+    GregorianCalendar calendar = new GregorianCalendar(TimeZone.getTimeZone("UTC"));
+    calendar.set(year, month - 1, day, hour, minute, second);
+    calendar.set(GregorianCalendar.MILLISECOND, millisecond);
+    Assert.assertEquals(calendar.getTimeInMillis(), StringUtils.getTime(xmlDateTime));
+  }
+
+  /**
+   * Tests {@link StringUtils#getTimeParts(long)} with a positive number.
+   */
+  public void testGetTimeParts_postive() {
+      int[] parts = StringUtils.getTimeParts(61000);
+    Assert.assertEquals(1, parts[0]);
+    Assert.assertEquals(1, parts[1]);
+    Assert.assertEquals(0, parts[2]);
+  }
+
+  /**
+   * Tests {@link StringUtils#getTimeParts(long)} with a negative number.
+   */
+  public void testGetTimeParts_negative() {
+      int[] parts = StringUtils.getTimeParts(-61000);
+    Assert.assertEquals(-1, parts[0]);
+    Assert.assertEquals(-1, parts[1]);
+    Assert.assertEquals(0, parts[2]);
+  }
+}

src/androidTest/java/com/google/android/apps/mytracks/util/TrackNameUtilsTest.java

@@ -0,0 +1,77 @@
+/*
+ * 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 com.google.android.apps.mytracks.util;
+
+import android.content.Context;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.platform.app.InstrumentationRegistry;
+
+import com.google.android.maps.mytracks.R;
+
+import org.junit.Assert;
+import org.junit.runner.RunWith;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Locale;
+
+/**
+ * Tests {@link TrackNameUtils}.
+ * 
+ * @author Matthew Simmons
+ */
+@RunWith(AndroidJUnit4.class)
+public class TrackNameUtilsTest {
+
+  private static final long TRACK_ID = 1L;
+  private static final long START_TIME = 1288213406000L;
+
+  private static final Context CONTEXT = InstrumentationRegistry.getInstrumentation().getContext();
+
+  /**
+   * Tests when the track_name_key is
+   * settings_recording_track_name_date_local_value.
+   */
+  public void testTrackName_date_local() {
+    PreferencesUtils.setString(CONTEXT, R.string.track_name_key, CONTEXT.getString(R.string.settings_recording_track_name_date_local_value));
+    Assert.assertEquals(StringUtils.formatDateTime(CONTEXT, START_TIME),
+        TrackNameUtils.getTrackName(CONTEXT, TRACK_ID, START_TIME, null));
+  }
+
+  /**
+   * Tests when the track_name_key is
+   * settings_recording_track_name_date_iso_8601_value.
+   */
+  public void testTrackName_date_iso_8601() {
+    PreferencesUtils.setString(CONTEXT, R.string.track_name_key, CONTEXT.getString(R.string.settings_recording_track_name_date_iso_8601_value));
+    SimpleDateFormat simpleDateFormat = new SimpleDateFormat(
+        TrackNameUtils.ISO_8601_FORMAT, Locale.US);
+    Assert.assertEquals(simpleDateFormat.format(new Date(START_TIME)),
+        TrackNameUtils.getTrackName(CONTEXT, TRACK_ID, START_TIME, null));
+  }
+
+  /**
+   * Tests when the track_name_key is
+   * settings_recording_track_name_number_value.
+   */
+  public void testTrackName_number() {
+    PreferencesUtils.setString(CONTEXT, R.string.track_name_key, CONTEXT.getString(R.string.settings_recording_track_name_number_value));
+    Assert.assertEquals(
+        "Track " + TRACK_ID, TrackNameUtils.getTrackName(CONTEXT, TRACK_ID, START_TIME, null));
+  }
+}

src/androidTest/res/.readme

@@ -0,0 +1 @@
+This hidden file is here to ensure there is a res folder.

src/main/AndroidManifest.xml

@@ -0,0 +1,251 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+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.
+-->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+  xmlns:tools="http://schemas.android.com/tools"
+  android:installLocation="auto"
+  android:versionCode="74"
+  android:versionName="2.0.6"
+  package="com.google.android.maps.mytracks" >
+  <!-- Permission to initialize services -->
+  <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+  <!-- Permissions to record locations -->
+  <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+  <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+  <uses-permission android:name="android.permission.WAKE_LOCK" />
+  <!-- Permissions to access sensors -->
+  <uses-permission android:name="android.permission.BLUETOOTH" />
+  <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
+  <!-- Permission for Android sync provider -->
+  <uses-permission android:name="android.permission.READ_SYNC_STATS" />
+  <uses-permission android:name="android.permission.READ_SYNC_SETTINGS" />
+  <uses-permission android:name="android.permission.WRITE_SYNC_SETTINGS" />
+  <!-- Permission to read phone state so voice announcement will not interrupt ongoing calls -->
+  <uses-permission android:name="android.permission.READ_PHONE_STATE" />
+  <!-- Permission to read/write external storage -->
+  <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
+  <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+  <!-- Permissions to access My Tracks data -->
+  <uses-permission android:name="com.google.android.apps.mytracks.MYTRACKS_NOTIFICATIONS" />
+  <uses-permission android:name="com.google.android.apps.mytracks.READ_TRACK_DATA" />
+  <uses-permission android:name="com.google.android.apps.mytracks.WRITE_TRACK_DATA" />
+  <!-- Permission to receive My Tracks internal broadcasts -->
+  <permission
+    android:description="@string/permission_notification_label"
+    android:label="@string/permission_notification_label"
+    android:name="com.google.android.apps.mytracks.MYTRACKS_NOTIFICATIONS"
+    android:permissionGroup="android.permission-group.LOCATION"
+    android:protectionLevel="signature" />
+  <!-- Permission to read track data -->
+  <permission
+    android:description="@string/permission_read_description"
+    android:label="@string/permission_read_label"
+    android:name="com.google.android.apps.mytracks.READ_TRACK_DATA"
+    android:permissionGroup="android.permission-group.LOCATION"
+    android:protectionLevel="dangerous" />
+  <!-- Permission to receive track start/end broadcasts -->
+  <permission
+    android:description="@string/permission_notification_description"
+    android:label="@string/permission_notification_label"
+    android:name="com.google.android.apps.mytracks.TRACK_NOTIFICATIONS"
+    android:permissionGroup="android.permission-group.LOCATION"
+    android:protectionLevel="dangerous" />
+  <!-- Permission to write track data, either directly or through service calls -->
+  <permission
+    android:description="@string/permission_write_description"
+    android:label="@string/permission_write_label"
+    android:name="com.google.android.apps.mytracks.WRITE_TRACK_DATA"
+    android:permissionGroup="android.permission-group.LOCATION"
+    android:protectionLevel="dangerous" />
+  <!-- Permission for map view v2. Note the prefix must be the application package name -->
+  <permission
+    android:name="com.google.android.maps.mytracks.permission.MAPS_RECEIVE"
+    android:protectionLevel="signature" />
+  <uses-permission android:name="com.google.android.maps.mytracks.permission.MAPS_RECEIVE" />
+  <!-- Required features -->
+  <uses-feature
+    android:glEsVersion="0x00020000"
+    android:required="true" />
+  <uses-feature
+    android:name="android.hardware.location"
+    android:required="true" />
+  <uses-feature
+    android:name="android.hardware.location.gps"
+    android:required="true" />
+  <!-- Optional features -->
+  <uses-feature
+    android:name="android.hardware.bluetooth"
+    android:required="false" />
+  <uses-feature
+    android:name="android.hardware.camera"
+    android:required="false" />
+  <uses-feature
+    android:name="android.hardware.faketouch"
+    android:required="false" />
+  <uses-feature
+    android:name="android.hardware.location.network"
+    android:required="false" />
+  <uses-feature
+    android:name="android.hardware.sensor.compass"
+    android:required="false" />
+  <uses-feature
+    android:name="android.hardware.telephony"
+    android:required="false" />
+  <uses-feature
+    android:name="android.hardware.telephony.gsm"
+    android:required="false" />
+  <uses-feature
+    android:name="android.hardware.touchscreen"
+    android:required="false" />
+  <uses-feature
+    android:name="android.hardware.touchscreen.multitouch"
+    android:required="false" />
+  <supports-screens
+    android:anyDensity="true"
+    android:largeScreens="true"
+    android:normalScreens="true"
+    android:smallScreens="true"
+    android:xlargeScreens="true" />
+  <application
+    android:allowBackup="true"
+    android:hardwareAccelerated="true"
+    android:icon="@drawable/ic_launcher_my_tracks"
+    android:label="@string/my_tracks_app_name"
+    android:theme="@style/ThemeMyTracks"
+    tools:replace="android:label" >
+    <!-- Activities -->
+    <activity
+      android:label="@string/menu_aggregated_statistics"
+      android:name="com.google.android.apps.mytracks.AggregatedStatsActivity" />
+    <activity android:name="com.google.android.apps.mytracks.DeleteActivity" />
+      <activity android:name="com.google.android.apps.mytracks.io.file.importer.ImportActivity" >
+      <intent-filter>
+        <action android:name="android.intent.action.ATTACH_DATA" />
+        <action android:name="android.intent.action.VIEW" />
+        <category android:name="android.intent.category.BROWSABLE" />
+        <category android:name="android.intent.category.DEFAULT" />
+        <data android:mimeType="application/gpx" />
+        <data android:mimeType="application/gpx+xml" />
+        <data android:mimeType="application/vnd.google-earth.gpx" />
+        <data android:mimeType="application/vnd.google-earth.gpx+xml" />
+        <data android:scheme="file" />
+      </intent-filter>
+    </activity>
+    <activity android:name="com.google.android.apps.mytracks.MarkerEditActivity" />
+    <activity android:name="com.google.android.apps.mytracks.MarkerDetailActivity" />
+    <activity
+      android:label="@string/menu_markers"
+      android:name="com.google.android.apps.mytracks.MarkerListActivity" >
+      <meta-data
+        android:name="android.app.default_searchable"
+        android:value="com.google.android.apps.mytracks.SearchListActivity" />
+    </activity>
+    <activity
+      android:launchMode="singleTop"
+      android:name="com.google.android.apps.mytracks.SearchListActivity" >
+      <intent-filter>
+        <action android:name="android.intent.action.SEARCH" />
+      </intent-filter>
+      <meta-data
+        android:name="android.app.searchable"
+        android:resource="@xml/search" />
+    </activity>
+    <activity
+      android:name="com.google.android.apps.mytracks.TrackDetailActivity"
+      android:parentActivityName="com.google.android.apps.mytracks.TrackListActivity" >
+      <meta-data
+        android:name="android.support.PARENT_ACTIVITY"
+        android:value="com.google.android.apps.mytracks.TrackListActivity" />
+    </activity>
+    <activity android:name="com.google.android.apps.mytracks.TrackEditActivity" />
+    <activity android:name="com.google.android.apps.mytracks.TrackListActivity" >
+      <intent-filter>
+        <action android:name="android.intent.action.MAIN" />
+        <category android:name="android.intent.category.LAUNCHER" />
+      </intent-filter>
+      <meta-data
+        android:name="android.app.default_searchable"
+        android:value="com.google.android.apps.mytracks.SearchListActivity" />
+    </activity>
+    <activity android:name="com.google.android.apps.mytracks.settings.AdvancedSettingsActivity" />
+    <activity android:name="com.google.android.apps.mytracks.settings.ChartSettingsActivity" />
+      <activity android:name="com.google.android.apps.mytracks.settings.RecordingSettingsActivity" />
+    <activity android:name="com.google.android.apps.mytracks.settings.SensorSettingsActivity" />
+    <activity android:name="com.google.android.apps.mytracks.settings.SettingsActivity" />
+    <activity android:name="com.google.android.apps.mytracks.settings.StatsSettingsActivity" />
+    <activity
+      android:label="@string/track_widget_config_title"
+      android:name="com.google.android.apps.mytracks.widgets.TrackWidgetConfigActivity" >
+      <intent-filter>
+        <action android:name="android.appwidget.action.APPWIDGET_CONFIGURE" />
+      </intent-filter>
+    </activity>
+    <service
+      android:exported="false"
+      android:name="com.google.android.apps.mytracks.services.ControlRecordingService" />
+    <service
+      android:enabled="true"
+      android:exported="true"
+      android:icon="@drawable/ic_arrow_320"
+      android:label="@string/my_tracks_recording_service"
+      android:name="com.google.android.apps.mytracks.services.TrackRecordingService"
+      android:permission="com.google.android.apps.mytracks.WRITE_TRACK_DATA" />
+    <!-- Receivers -->
+    <receiver android:name="com.google.android.apps.mytracks.BootReceiver" >
+      <intent-filter>
+        <action android:name="android.intent.action.BOOT_COMPLETED" />
+      </intent-filter>
+    </receiver>
+    <receiver android:name="com.google.android.apps.mytracks.widgets.TrackWidgetProvider" >
+      <intent-filter>
+        <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
+        <action android:name="com.google.android.apps.mytracks.TRACK_PAUSED" />
+        <action android:name="com.google.android.apps.mytracks.TRACK_RESUMED" />
+        <action android:name="com.google.android.apps.mytracks.TRACK_STARTED" />
+        <action android:name="com.google.android.apps.mytracks.TRACK_STOPPED" />
+        <action android:name="com.google.android.apps.mytracks.TRACK_UPDATE" />
+      </intent-filter>
+      <meta-data
+        android:name="android.appwidget.provider"
+        android:resource="@xml/track_widget_info" />
+    </receiver>
+    <!-- Providers -->
+    <!-- My Tracks data provider -->
+    <provider
+      android:authorities="com.google.android.maps.mytracks"
+      android:exported="true"
+      android:grantUriPermissions="true"
+      android:name="com.google.android.apps.mytracks.content.MyTracksProvider"
+      android:readPermission="com.google.android.apps.mytracks.READ_TRACK_DATA"
+      android:writePermission="com.google.android.apps.mytracks.WRITE_TRACK_DATA" />
+    <!-- Search suggestion provider -->
+    <provider
+      android:authorities="com.google.android.maps.mytracks.search"
+      android:exported="false"
+      android:name="com.google.android.apps.mytracks.content.SearchEngineProvider" />
+
+    <provider
+        android:name="androidx.core.content.FileProvider"
+        android:authorities="com.google.android.apps.mytracks.fileprovider"
+        android:exported="false"
+        android:grantUriPermissions="true">
+      <meta-data
+          android:name="android.support.FILE_PROVIDER_PATHS"
+          android:resource="@xml/file_paths" />
+    </provider>
+  </application>
+</manifest>

src/main/java/com/google/android/apps/mytracks/AbstractActivity.java

@@ -0,0 +1,89 @@
+/*
+ * 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 com.google.android.apps.mytracks;
+
+import android.app.ActionBar;
+import android.os.Bundle;
+import android.speech.tts.TextToSpeech;
+import android.view.Menu;
+import android.view.MenuItem;
+
+import androidx.fragment.app.FragmentActivity;
+
+import com.google.android.apps.mytracks.util.TrackIconUtils;
+
+/**
+ * An abstract class for all My Tracks activities.
+ * 
+ * @author Jimmy Shih
+ */
+public abstract class AbstractActivity extends FragmentActivity {
+
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+
+    // Set volume control stream for text to speech
+    setVolumeControlStream(TextToSpeech.Engine.DEFAULT_STREAM);
+
+    setContentView(getLayoutResId());
+
+    // Configure action bar must be after setContentView
+    if (configureActionBarHomeAsUp()) {
+      ActionBar actionBar = this.getActionBar();
+      if (actionBar != null) {
+        actionBar.setHomeButtonEnabled(true);
+        actionBar.setDisplayHomeAsUpEnabled(true);
+      }
+    }
+  }
+
+  /**
+   * Gets the layout resource id.
+   */
+  protected abstract int getLayoutResId();
+
+  /**
+   * Returns true to configure the action bar home button as the up button (go to previous activity).
+   */
+  protected boolean configureActionBarHomeAsUp() {
+    return true;
+  }
+
+  @Override
+  public boolean onCreateOptionsMenu(Menu menu) {
+    TrackIconUtils.setMenuIconColor(menu);
+    return super.onCreateOptionsMenu(menu);
+  }
+
+  @Override
+  public boolean onOptionsItemSelected(MenuItem item) {
+    // Handles actionBar's home menu item (arrow top left corner) and triggers, up navigation to previous activity.
+    if (item.getItemId() == android.R.id.home) {
+      onHomeSelected();
+      return true;
+    }
+    return super.onOptionsItemSelected(item);
+  }
+
+  /**
+   * Callback when the home menu item is selected. E.g., setup the back stack when home is selected.
+   */
+  protected void onHomeSelected() {
+    finish();
+  }
+}

src/main/java/com/google/android/apps/mytracks/AbstractTrackActivity.java

@@ -0,0 +1,212 @@
+/*
+ * 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 com.google.android.apps.mytracks;
+
+import android.app.Activity;
+import android.app.SearchManager;
+import android.content.Context;
+import android.content.Intent;
+import android.util.SparseBooleanArray;
+import android.view.ActionMode;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.widget.AbsListView;
+import android.widget.ListView;
+import android.widget.SearchView;
+
+import com.google.android.apps.mytracks.fragments.ConfirmDeleteDialogFragment;
+import com.google.android.apps.mytracks.fragments.ConfirmDeleteDialogFragment.ConfirmDeleteCaller;
+import com.google.android.apps.mytracks.services.TrackRecordingServiceConnection;
+import com.google.android.apps.mytracks.util.IntentUtils;
+import com.google.android.apps.mytracks.util.PreferencesUtils;
+import com.google.android.apps.mytracks.util.TrackRecordingServiceConnectionUtils;
+import com.google.android.maps.mytracks.R;
+
+import java.util.ArrayList;
+
+/**
+ * An abstract class for the following common tasks across
+ * {@link TrackListActivity}, {@link TrackDetailActivity}, and
+ * {@link SearchListActivity}:
+ * <p>
+ * - share track <br>
+ * - delete tracks <br>
+ *
+ * @author Jimmy Shih
+ */
+public abstract class AbstractTrackActivity extends AbstractActivity implements ConfirmDeleteCaller {
+
+  private static final int DELETE_REQUEST_CODE = 3;
+  protected static final int GPS_REQUEST_CODE = 6;
+
+    @Override
+  protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+      if (requestCode == DELETE_REQUEST_CODE) {
+          onDeleted();
+      } else {
+          super.onActivityResult(requestCode, resultCode, data);
+      }
+  }
+
+  public static void configureListViewContextualMenu(final ListView listView, final ContextualActionModeCallback contextualActionModeCallback) {
+    listView.setChoiceMode(ListView.CHOICE_MODE_MULTIPLE_MODAL);
+    listView.setMultiChoiceModeListener(new AbsListView.MultiChoiceModeListener() {
+
+      @Override
+      public boolean onCreateActionMode(ActionMode mode, Menu menu) {
+        mode.getMenuInflater().inflate(R.menu.list_context_menu, menu);
+        return true;
+      }
+
+      @Override
+      public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
+        contextualActionModeCallback.onPrepare(menu, getCheckedPositions(listView), listView.getCheckedItemIds(), true);
+        return true;
+      }
+
+      @Override
+      public void onDestroyActionMode(ActionMode mode) {
+        // Do nothing
+      }
+
+      @Override
+      public void onItemCheckedStateChanged(ActionMode mode, int position, long id, boolean checked) {
+        mode.invalidate();
+      }
+
+      @Override
+      public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
+        if (contextualActionModeCallback.onClick(item.getItemId(), getCheckedPositions(listView), listView.getCheckedItemIds())) {
+          mode.finish();
+        }
+        return true;
+      }
+
+      /**
+       * Gets the checked positions in a list view.
+       *
+       * @param list the list view
+       */
+      private int[] getCheckedPositions(ListView list) {
+        SparseBooleanArray positions  = list.getCheckedItemPositions();
+        ArrayList<Integer> arrayList = new ArrayList<>();
+        for (int i = 0; i < positions.size(); i++) {
+          int key = positions.keyAt(i);
+          if (positions.valueAt(i)) {
+            arrayList.add(key);
+          }
+        }
+        int[] result = new int[arrayList.size()];
+        for (int i = 0; i < arrayList.size(); i++) {
+          result[i] = arrayList.get(i);
+        }
+        return result;
+      }
+    });
+  }
+
+    public static void configureSearchWidget(Activity activity, final MenuItem menuItem, final TrackController trackController) {
+        SearchManager searchManager = (SearchManager) activity.getSystemService(Context.SEARCH_SERVICE);
+        SearchView searchView = (SearchView) menuItem.getActionView();
+        searchView.setSearchableInfo(searchManager.getSearchableInfo(activity.getComponentName()));
+        searchView.setQueryRefinementEnabled(true);
+        searchView.setOnQueryTextFocusChangeListener(new View.OnFocusChangeListener() {
+
+            @Override
+            public void onFocusChange(View v, boolean hasFocus) {
+                // Hide and show trackController when search 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;
+            }
+        });
+    }
+
+      /**
+   * Delete tracks.
+   * 
+   * @param trackIds the track ids
+   */
+  protected void deleteTracks(long[] trackIds) {
+    ConfirmDeleteDialogFragment.newInstance(trackIds)
+        .show(getSupportFragmentManager(), ConfirmDeleteDialogFragment.CONFIRM_DELETE_DIALOG_TAG);
+  }
+  
+  @Override
+  public void onConfirmDeleteDone(long[] trackIds) {
+    boolean stopRecording = false;
+    if (trackIds.length == 1 && trackIds[0] == -1L) {
+      stopRecording = true;
+    } else {
+      long recordingTrackId = PreferencesUtils.getLong(this, R.string.recording_track_id_key);
+      for (long trackId : trackIds) {
+        if (trackId == recordingTrackId) {
+          stopRecording = true;
+          break;
+        }
+      }
+    }
+    if (stopRecording) {
+      TrackRecordingServiceConnectionUtils.stopRecording(
+          this, getTrackRecordingServiceConnection(), false);
+    }
+    Intent intent = IntentUtils.newIntent(this, DeleteActivity.class);
+    intent.putExtra(DeleteActivity.EXTRA_TRACK_IDS, trackIds);
+    startActivityForResult(intent, DELETE_REQUEST_CODE);
+  }
+
+  /**
+   * 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 DeleteActivity} returns its result.
+   */
+  abstract protected void onDeleted();
+}

src/main/java/com/google/android/apps/mytracks/AggregatedStatsActivity.java

@@ -0,0 +1,63 @@
+/*
+ * 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 com.google.android.apps.mytracks;
+
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils;
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.stats.TripStatistics;
+import com.google.android.apps.mytracks.util.StatsUtils;
+import com.google.android.maps.mytracks.R;
+
+import android.os.Bundle;
+
+import java.util.List;
+
+/**
+ * An activity to view aggregated stats from all recorded tracks.
+ *
+ * @author Fergus Nelson
+ */
+public class AggregatedStatsActivity extends AbstractActivity {
+
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    StatsUtils.setTripStatisticsValues(this, this, null, getTripStatistics(), null);
+    StatsUtils.setLocationValues(this, this, null, null, false);
+  }
+
+  @Override
+  protected int getLayoutResId() {
+    return R.layout.stats;
+  }
+
+  /**
+   * Gets the aggregated trip statistics for all the recorded tracks or null if
+   * there is no track.
+   */
+  private TripStatistics getTripStatistics() {
+    List<Track> tracks = MyTracksProviderUtils.Factory.get(this).getAllTracks();
+    TripStatistics tripStatistics = null;
+    if (!tracks.isEmpty()) {
+      tripStatistics = new TripStatistics(tracks.iterator().next().getTripStatistics());
+      for (int i = 1; i < tracks.size(); i++) {
+        tripStatistics.merge(tracks.get(i).getTripStatistics());
+      }
+    }
+    return tripStatistics;
+  }
+}

src/main/java/com/google/android/apps/mytracks/BootReceiver.java

@@ -0,0 +1,57 @@
+/*
+ * 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 com.google.android.apps.mytracks;
+
+import static android.content.Intent.ACTION_BOOT_COMPLETED;
+
+import com.google.android.apps.mytracks.services.TrackRecordingService;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.util.Log;
+
+/**
+ * This class handles MyTracks related broadcast messages.
+ *
+ * One example of a broadcast message that this class is interested in,
+ * is notification about the phone boot.  We may want to resume a previously
+ * started tracking session if the phone crashed (hopefully not), or the user
+ * decided to swap the battery or some external event occurred which forced
+ * a phone reboot.
+ *
+ * This class simply delegates to {@link TrackRecordingService} to make a
+ * decision whether to continue with the previous track (if any), or just
+ * abandon it.
+ * 
+ * @author Bartlomiej Niechwiej
+ */
+public class BootReceiver extends BroadcastReceiver {
+
+  private static final String TAG = BootReceiver.class.getSimpleName();
+  
+  @Override
+  public void onReceive(Context context, Intent intent) {
+    Log.d(TAG, "BootReceiver.onReceive: " + intent.getAction());
+    if (ACTION_BOOT_COMPLETED.equals(intent.getAction())) {
+      Intent startIntent = new Intent(context, TrackRecordingService.class)
+          .putExtra(TrackRecordingService.RESUME_TRACK_EXTRA_NAME, true);
+      context.startService(startIntent);     
+    } else {
+      Log.w(TAG, "BootReceiver: unsupported action");
+    }
+  }
+}

src/main/java/com/google/android/apps/mytracks/ChartValueSeries.java

@@ -0,0 +1,263 @@
+/*
+ * 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 com.google.android.apps.mytracks;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.Paint.Align;
+import android.graphics.Paint.Style;
+import android.graphics.Path;
+import androidx.annotation.VisibleForTesting;
+
+import com.google.android.apps.mytracks.stats.ExtremityMonitor;
+
+import java.text.NumberFormat;
+
+/**
+ * This class encapsulates the meta data for one series of the chart values.
+ * 
+ * @author Sandor Dornbush
+ */
+public class ChartValueSeries {
+
+  private static final float STROKE_WIDTH = 2f;
+
+  private final int absoluteMin;
+  private final int absoluteMax;
+  private final int[] intervalValues;
+  private final int metricTitleId;
+  private final int imperialTitleId;
+  private final Paint fillPaint;
+  private final Paint strokePaint;
+  private final Paint titlePaint;
+  private final Paint markerPaint;
+  private final ExtremityMonitor extremityMonitor;
+  private final NumberFormat numberFormat;
+  private final Path path;
+  
+  private int interval = 1;
+  private int minMarkerValue = 0;
+  private int maxMarkerValue = interval * ChartView.Y_AXIS_INTERVALS;
+  private boolean enabled = true;
+
+  /**
+   * Constructor.
+   * 
+   * @param context the context
+   * @param absoluteMin the absolute min value
+   * @param absoluteMax the absolute max value
+   * @param intervalValues the list of interval values
+   * @param metricTitleId the metric title id
+   * @param imperialTitleId the imperial title id
+   * @param fillColor the fill color
+   * @param strokeColor the stroke color
+   */
+  public ChartValueSeries(Context context, int absoluteMin, int absoluteMax, int[] intervalValues,
+      int metricTitleId, int imperialTitleId, int fillColor, int strokeColor) {
+    this.absoluteMin = absoluteMin;
+    this.absoluteMax = absoluteMax;
+    this.intervalValues = intervalValues;
+    this.metricTitleId = metricTitleId;
+    this.imperialTitleId = imperialTitleId;
+
+    fillPaint = new Paint();
+    fillPaint.setStyle(Style.FILL);
+    fillPaint.setColor(context.getResources().getColor(fillColor));
+    fillPaint.setAntiAlias(true);
+
+    strokePaint = new Paint();
+    strokePaint.setStyle(Style.STROKE);
+    strokePaint.setColor(context.getResources().getColor(strokeColor));
+    strokePaint.setAntiAlias(true);
+
+    float scale = context.getResources().getDisplayMetrics().density;
+    
+    // Make copies of the stroke paint with the default thickness
+    titlePaint = new Paint(strokePaint);
+    titlePaint.setTextSize(ChartView.MEDIUM_TEXT_SIZE * scale);
+    titlePaint.setTextAlign(Align.CENTER);
+
+    markerPaint = new Paint(strokePaint);
+    markerPaint.setTextSize(ChartView.SMALL_TEXT_SIZE * scale);
+    markerPaint.setTextAlign(Align.RIGHT);
+
+    // Set stroke paint thickness
+    strokePaint.setStrokeWidth(STROKE_WIDTH);
+
+    extremityMonitor = new ExtremityMonitor();
+    numberFormat = NumberFormat.getIntegerInstance();
+    path = new Path();
+  }
+
+  /**
+   * Sets the series enabled value.
+   * 
+   * @param enabled true to enable
+   */
+  public void setEnabled(boolean enabled) {
+    this.enabled = enabled;
+  }
+
+  /**
+   * Returns true if the series is enabled.
+   */
+  public boolean isEnabled() {
+    return enabled;
+  }
+
+  /**
+   * Returns true if the series has data.
+   */
+  public boolean hasData() {
+    return extremityMonitor.hasData();
+  }
+
+  /**
+   * Updates the series with a new value.
+   * 
+   * @param value the new value
+   */
+  public void update(double value) {
+    extremityMonitor.update(value);
+  }
+
+  /**
+   * Gets the path.
+   */
+  public Path getPath() {
+    return path;
+  }
+
+  /**
+   * Draws the path on canvas.
+   * 
+   * @param canvas the canvas
+   */
+  public void drawPath(Canvas canvas) {
+    canvas.drawPath(path, fillPaint);
+    canvas.drawPath(path, strokePaint);
+  }
+
+  /**
+   * Updates the y axis dimension.
+   */
+  public void updateDimension() {
+    double min = hasData() ? extremityMonitor.getMin() : 0.0;
+    double max = hasData() ? extremityMonitor.getMax() : 1.0;
+    min = Math.max(min, absoluteMin);
+    max = Math.min(max, absoluteMax);
+    interval = getInterval(min, max);
+    minMarkerValue = getMinMarkerValue(min, interval);
+    maxMarkerValue = minMarkerValue + interval * ChartView.Y_AXIS_INTERVALS;
+  }
+
+  /**
+   * Gets the interval value.
+   * 
+   * @param min the min value
+   * @param max the max value
+   */
+  private int getInterval(double min, double max) {
+    for (int intervalValue : intervalValues) {
+      int minValue = getMinMarkerValue(min, intervalValue);
+      double targetInterval = (max - minValue) / ChartView.Y_AXIS_INTERVALS;
+      if (intervalValue >= targetInterval) {
+        return intervalValue;
+      }
+    }
+    // Return the largest interval
+    return intervalValues[intervalValues.length - 1];
+  }
+
+  /**
+   * Gets the min marker value.
+   * 
+   * @param min the min series value
+   * @param intervalValue the interval value
+   */
+  private int getMinMarkerValue(double min, int intervalValue) {
+    // Round down to the nearest intervalValue
+    int value = ((int) (min / intervalValue)) * intervalValue;
+    // value > min if min is negative
+    if (value > min) {
+      return value - intervalValue;
+    }
+    return value;
+  }
+
+  /**
+   * Gets the interval value.
+   */
+  public int getInterval() {
+    return interval;
+  }
+
+  /**
+   * Gets the min marker value.
+   */
+  public int getMinMarkerValue() {
+    return minMarkerValue;
+  }
+
+  /**
+   * Gets the max marker value.
+   */
+  @VisibleForTesting
+  int getMaxMarkerValue() {
+    return maxMarkerValue;
+  }
+
+  /**
+   * Gets the title id.
+   */
+  public int getTitleId(boolean metricUnits) {
+    return metricUnits ? metricTitleId : imperialTitleId;
+  }
+
+  /**
+   * Gets the title paint.
+   */
+  public Paint getTitlePaint() {
+    return titlePaint;
+  }
+
+  /**
+   * Gets the marker paint.
+   */
+  public Paint getMarkerPaint() {
+    return markerPaint;
+  }
+
+  /**
+   * Gets the largest marker.
+   */
+  public String getLargestMarker() {
+    String minMarker = numberFormat.format(getMinMarkerValue());
+    String maxMarker = numberFormat.format(getMaxMarkerValue());
+    return minMarker.length() >= maxMarker.length() ? minMarker : maxMarker;
+  }
+
+  /**
+   * Formats a marker value.
+   * 
+   * @param value the value
+   */
+  public String formatMarker(int value) {
+    return numberFormat.format(value);
+  }
+}

src/main/java/com/google/android/apps/mytracks/ChartView.java

@@ -0,0 +1,979 @@
+/*
+ * 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 com.google.android.apps.mytracks;
+
+import android.content.Context;
+import android.content.Intent;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.DashPathEffect;
+import android.graphics.Paint;
+import android.graphics.Paint.Align;
+import android.graphics.Paint.Style;
+import android.graphics.Path;
+import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
+import android.view.MotionEvent;
+import android.view.VelocityTracker;
+import android.view.View;
+import android.view.ViewConfiguration;
+import android.widget.Scroller;
+
+import com.google.android.apps.mytracks.content.Waypoint;
+import com.google.android.apps.mytracks.stats.ExtremityMonitor;
+import com.google.android.apps.mytracks.util.IntentUtils;
+import com.google.android.apps.mytracks.util.StringUtils;
+import com.google.android.apps.mytracks.util.UnitConversions;
+import com.google.android.maps.mytracks.R;
+
+import java.text.NumberFormat;
+import java.util.ArrayList;
+
+/**
+ * Visualization of the chart.
+ * 
+ * @author Sandor Dornbush
+ * @author Leif Hendrik Wilden
+ */
+public class ChartView extends View {
+
+  public static final float MEDIUM_TEXT_SIZE = 18f;
+  public static final float SMALL_TEXT_SIZE = 12f;
+
+  public static final int Y_AXIS_INTERVALS = 5;
+
+  public static final int NUM_SERIES = 6;
+  public static final int ELEVATION_SERIES = 0;
+  public static final int SPEED_SERIES = 1;
+  public static final int PACE_SERIES = 2;
+  public static final int HEART_RATE_SERIES = 3;
+  public static final int CADENCE_SERIES = 4;
+  public static final int POWER_SERIES = 5;
+
+  private static final int TARGET_X_AXIS_INTERVALS = 4;
+
+  private static final int MIN_ZOOM_LEVEL = 1;
+  private static final int MAX_ZOOM_LEVEL = 10;
+
+  private static final NumberFormat X_NUMBER_FORMAT = NumberFormat.getIntegerInstance();
+  private static final NumberFormat X_FRACTION_FORMAT = NumberFormat.getNumberInstance();
+  static {
+    X_FRACTION_FORMAT.setMaximumFractionDigits(1);
+    X_FRACTION_FORMAT.setMinimumFractionDigits(1);
+  }
+
+  private static final int BORDER = 8;
+  private static final int SPACER = 4;
+  private static final int Y_AXIS_OFFSET = 16;
+
+  private final ChartValueSeries[] series = new ChartValueSeries[NUM_SERIES];
+  private final ArrayList<double[]> chartData = new ArrayList<>();
+  private final ArrayList<Waypoint> waypoints = new ArrayList<>();
+  private final ExtremityMonitor xExtremityMonitor = new ExtremityMonitor();
+  private double maxX = 1.0;
+
+  private final Paint axisPaint;
+  private final Paint xAxisMarkerPaint;
+  private final Paint gridPaint;
+
+  private final Drawable pointer;
+  private final int markerWidth;
+  private final int markerHeight;
+
+  private final Scroller scroller;
+  private VelocityTracker velocityTracker = null;
+  private float lastMotionEventX = -1;
+  private int zoomLevel = 1;
+
+  private int leftBorder = BORDER;
+  private int topBorder = BORDER;
+  private int bottomBorder = BORDER;
+  private int rightBorder = BORDER;
+  private int spacer = SPACER;
+  private int yAxisOffset = Y_AXIS_OFFSET;
+
+  private int width = 0;
+  private int height = 0;
+  private int effectiveWidth = 0;
+  private int effectiveHeight = 0;
+
+  private boolean chartByDistance = true;
+  private boolean metricUnits = true;
+  private boolean reportSpeed = true;
+  private boolean showPointer = false;
+
+  /**
+   * Constructor.
+   * 
+   * @param context the context
+   */
+  public ChartView(Context context) {
+    super(context);
+
+    series[ELEVATION_SERIES] = new ChartValueSeries(context,
+        Integer.MIN_VALUE,
+        Integer.MAX_VALUE,
+        new int[] { 5, 10, 25, 50, 100, 250, 500, 1000, 2500, 5000 },
+        R.string.description_elevation_metric,
+        R.string.description_elevation_imperial,
+        R.color.chart_elevation_fill,
+        R.color.chart_elevation_border);
+    series[SPEED_SERIES] = new ChartValueSeries(context,
+        0,
+        Integer.MAX_VALUE,
+        new int[] {1, 5, 10, 20, 50, 100 },
+        R.string.description_speed_metric,
+        R.string.description_speed_imperial,
+        R.color.chart_speed_fill,
+        R.color.chart_speed_border);
+    series[PACE_SERIES] = new ChartValueSeries(context,
+        0,
+        Integer.MAX_VALUE,
+        new int[] {1, 2, 5, 10, 15, 20, 30, 60, 120 },
+        R.string.description_pace_metric,
+        R.string.description_pace_imperial,
+        R.color.chart_pace_fill,
+        R.color.chart_pace_border);
+    series[HEART_RATE_SERIES] = new ChartValueSeries(context,
+        0,
+        Integer.MAX_VALUE,
+        new int[] {25, 50 },
+        R.string.description_sensor_heart_rate,
+        R.string.description_sensor_heart_rate,
+        R.color.chart_heart_rate_fill,
+        R.color.chart_heart_rate_border);
+    series[CADENCE_SERIES] = new ChartValueSeries(context,
+        0,
+        Integer.MAX_VALUE,
+        new int[] {5, 10, 25, 50 },
+        R.string.description_sensor_cadence,
+        R.string.description_sensor_cadence,
+        R.color.chart_cadence_fill,
+        R.color.chart_cadence_border);
+    series[POWER_SERIES] = new ChartValueSeries(context,
+        0,
+        1000,
+        new int[] { 5, 50, 100, 200 },
+        R.string.description_sensor_power,
+        R.string.description_sensor_power,
+        R.color.chart_power_fill,
+        R.color.chart_power_border);
+
+    float scale = context.getResources().getDisplayMetrics().density;
+
+    axisPaint = new Paint();
+    axisPaint.setStyle(Style.STROKE);
+    axisPaint.setColor(context.getResources().getColor(android.R.color.black));
+    axisPaint.setAntiAlias(true);
+    axisPaint.setTextSize(SMALL_TEXT_SIZE * scale);
+
+    xAxisMarkerPaint = new Paint(axisPaint);
+    xAxisMarkerPaint.setTextAlign(Align.CENTER);
+
+    gridPaint = new Paint();
+    gridPaint.setStyle(Style.STROKE);
+    gridPaint.setColor(context.getResources().getColor(android.R.color.darker_gray));
+    gridPaint.setAntiAlias(false);
+    gridPaint.setPathEffect(new DashPathEffect(new float[] { 3, 2 }, 0));
+
+    Paint markerPaint = new Paint();
+    markerPaint.setStyle(Style.STROKE);
+    markerPaint.setColor(context.getResources().getColor(android.R.color.darker_gray));
+    markerPaint.setAntiAlias(false);
+
+    pointer = context.getResources().getDrawable(R.drawable.ic_arrow_180);
+    pointer.setBounds(0, 0, pointer.getIntrinsicWidth(), pointer.getIntrinsicHeight());
+
+    Drawable statisticsMarker = getResources().getDrawable(R.drawable.ic_marker_yellow_pushpin);
+    markerWidth = statisticsMarker.getIntrinsicWidth();
+    markerHeight = statisticsMarker.getIntrinsicHeight();
+    statisticsMarker.setBounds(0, 0, markerWidth, markerHeight);
+
+    Drawable waypointMarker = getResources().getDrawable(R.drawable.ic_marker_blue_pushpin);
+    waypointMarker.setBounds(0, 0, markerWidth, markerHeight);
+
+    scroller = new Scroller(context);
+    setFocusable(true);
+    setClickable(true);
+    updateDimensions();
+  }
+
+  @Override
+  public boolean canScrollHorizontally(int direction) {
+    return true;
+  }
+  
+  /**
+   * Sets the enabled value for a chart value series.
+   * 
+   * @param index the chart value series index
+   */
+  public void setChartValueSeriesEnabled(int index, boolean enabled) {
+    series[index].setEnabled(enabled);
+  }
+
+  /**
+   * Sets chart by distance. It is expected that after changing this value, data
+   * will be reloaded.
+   * 
+   * @param value true for by distance, false for by time
+   */
+  public void setChartByDistance(boolean value) {
+    chartByDistance = value;
+  }
+
+  /**
+   * Sets metric units.
+   * 
+   * @param value true to use metric units
+   */
+  public void setMetricUnits(boolean value) {
+    metricUnits = value;
+  }
+
+  /**
+   * Sets report speed.
+   * 
+   * @param value true to report speed
+   */
+  public void setReportSpeed(boolean value) {
+    reportSpeed = value;
+  }
+
+  /**
+   * Sets show pointer.
+   * 
+   * @param value true to show pointer
+   */
+  public void setShowPointer(boolean value) {
+    showPointer = value;
+  }
+
+  /**
+   * Adds data points.
+   * 
+   * @param dataPoints an array of data points to be added
+   */
+  public void addDataPoints(ArrayList<double[]> dataPoints) {
+    synchronized (chartData) {
+      chartData.addAll(dataPoints);
+      for (int i = 0; i < dataPoints.size(); i++) {
+        double[] dataPoint = dataPoints.get(i);
+        xExtremityMonitor.update(dataPoint[0]);
+        for (int j = 0; j < series.length; j++) {
+          if (!Double.isNaN(dataPoint[j + 1])) {
+            series[j].update(dataPoint[j + 1]);
+          }
+        }
+      }
+      updateDimensions();
+      updatePaths();
+    }
+  }
+
+  /**
+   * Clears all data.
+   */
+  public void reset() {
+    synchronized (chartData) {
+      chartData.clear();
+      xExtremityMonitor.reset();
+      zoomLevel = 1;
+      updateDimensions();
+    }
+  }
+
+  /**
+   * Resets scroll. To be called on the UI thread.
+   */
+  public void resetScroll() {
+    scrollTo(0, 0);
+  }
+
+  /**
+   * Adds a waypoint.
+   * 
+   * @param waypoint the waypoint
+   */
+  public void addWaypoint(Waypoint waypoint) {
+    synchronized (waypoints) {
+      waypoints.add(waypoint);
+    }
+  }
+
+  /**
+   * Clears the waypoints.
+   */
+  public void clearWaypoints() {
+    synchronized (waypoints) {
+      waypoints.clear();
+    }
+  }
+
+  /**
+   * Returns true if can zoom in.
+   */
+  public boolean canZoomIn() {
+    return zoomLevel < MAX_ZOOM_LEVEL;
+  }
+
+  /**
+   * Returns true if can zoom out.
+   */
+  public boolean canZoomOut() {
+    return zoomLevel > MIN_ZOOM_LEVEL;
+  }
+
+  /**
+   * Zooms in one level.
+   */
+  public void zoomIn() {
+    if (canZoomIn()) {
+      zoomLevel++;
+      updatePaths();
+      invalidate();
+    }
+  }
+
+  /**
+   * Zooms out one level.
+   */
+  public void zoomOut() {
+    if (canZoomOut()) {
+      zoomLevel--;
+      scroller.abortAnimation();
+      int scrollX = getScrollX();
+      int maxWidth = effectiveWidth * (zoomLevel - 1);
+      if (scrollX > maxWidth) {
+        scrollX = maxWidth;
+        scrollTo(scrollX, 0);
+      }
+      updatePaths();
+      invalidate();
+    }
+  }
+
+  /**
+   * Initiates flinging.
+   * 
+   * @param velocityX velocity of fling in pixels per second
+   */
+  public void fling(int velocityX) {
+    int maxWidth = effectiveWidth * (zoomLevel - 1);
+    scroller.fling(getScrollX(), 0, velocityX, 0, 0, maxWidth, 0, 0);
+    invalidate();
+  }
+
+  /**
+   * Scrolls the view horizontally by a given amount.
+   * 
+   * @param deltaX the number of pixels to scroll
+   */
+  public void scrollBy(int deltaX) {
+    int scrollX = getScrollX() + deltaX;
+    if (scrollX < 0) {
+      scrollX = 0;
+    }
+    int maxWidth = effectiveWidth * (zoomLevel - 1);
+    if (scrollX > maxWidth) {
+      scrollX = maxWidth;
+    }
+    scrollTo(scrollX, 0);
+  }
+
+  /**
+   * Called by the parent to indicate that the mScrollX/Y values need to be
+   * updated. Triggers a redraw during flinging.
+   */
+  @Override
+  public void computeScroll() {
+    if (scroller.computeScrollOffset()) {
+      int oldX = getScrollX();
+      int x = scroller.getCurrX();
+      scrollTo(x, 0);
+      if (oldX != x) {
+        onScrollChanged(x, 0, oldX, 0);
+        postInvalidate();
+      }
+    }
+  }
+
+  @Override
+  public boolean onTouchEvent(MotionEvent event) {
+    if (velocityTracker == null) {
+      velocityTracker = VelocityTracker.obtain();
+    }
+    velocityTracker.addMovement(event);
+    float x = event.getX();
+    switch (event.getAction()) {
+      case MotionEvent.ACTION_DOWN:
+        // Stop the fling
+        if (!scroller.isFinished()) {
+          scroller.abortAnimation();
+        }
+        lastMotionEventX = x;
+        break;
+      case MotionEvent.ACTION_MOVE:
+        if (lastMotionEventX == -1) {
+          break;
+        }
+        // Scroll to follow the motion event
+        int deltaX = (int) (lastMotionEventX - x);
+        lastMotionEventX = x;
+        if (deltaX < 0) {
+          if (getScrollX() > 0) {
+            scrollBy(deltaX);
+          }
+        } else if (deltaX > 0) {
+          int availableToScroll = effectiveWidth * (zoomLevel - 1) - getScrollX();
+          if (availableToScroll > 0) {
+            scrollBy(Math.min(availableToScroll, deltaX));
+          }
+        }
+        break;
+      case MotionEvent.ACTION_UP:
+        // Check if the y event is within markerHeight of the marker center
+        if (Math.abs(event.getY() - topBorder - spacer - markerHeight / 2) < markerHeight) {
+          int minDistance = Integer.MAX_VALUE;
+          Waypoint nearestWaypoint = null;
+          synchronized (waypoints) {
+            for (int i = 0; i < waypoints.size(); i++) {
+              Waypoint waypoint = waypoints.get(i);
+              int distance = Math.abs(
+                  getX(getWaypointXValue(waypoint)) - (int) event.getX() - getScrollX());
+              if (distance < minDistance) {
+                minDistance = distance;
+                nearestWaypoint = waypoint;
+              }
+            }
+          }
+          if (nearestWaypoint != null && minDistance < markerWidth) {
+            Intent intent = IntentUtils.newIntent(getContext(), MarkerDetailActivity.class)
+                .putExtra(MarkerDetailActivity.EXTRA_MARKER_ID, nearestWaypoint.getId());
+            getContext().startActivity(intent);
+            return true;
+          }
+        }
+
+        VelocityTracker myVelocityTracker = velocityTracker;
+        myVelocityTracker.computeCurrentVelocity(1000);
+        int initialVelocity = (int) myVelocityTracker.getXVelocity();
+        if (Math.abs(initialVelocity) > ViewConfiguration.getMinimumFlingVelocity()) {
+          fling(-initialVelocity);
+        }
+        if (velocityTracker != null) {
+          velocityTracker.recycle();
+          velocityTracker = null;
+        }
+        break;
+    }
+    return true;
+  }
+
+  @Override
+  protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+    updateEffectiveDimensionsIfChanged(
+        View.MeasureSpec.getSize(widthMeasureSpec), View.MeasureSpec.getSize(heightMeasureSpec));
+    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+  }
+
+  @Override
+  protected void onDraw(Canvas canvas) {
+    synchronized (chartData) {
+
+      canvas.save();
+      
+      canvas.drawColor(Color.WHITE);
+
+      canvas.save();
+      
+      clipToGraphArea(canvas);
+      drawDataSeries(canvas);
+      drawGrid(canvas);
+      
+      canvas.restore();
+
+      drawSeriesTitles(canvas);
+      drawXAxis(canvas);
+      drawYAxis(canvas);
+      
+      canvas.restore();
+
+      if (showPointer) {
+        drawPointer(canvas);
+      }
+    }
+  }
+
+  /**
+   * Clips a canvas to the graph area.
+   * 
+   * @param canvas the canvas
+   */
+  private void clipToGraphArea(Canvas canvas) {
+    int x = getScrollX() + leftBorder;
+    int y = topBorder;
+    canvas.clipRect(x, y, x + effectiveWidth, y + effectiveHeight);
+  }
+
+  /**
+   * Draws the data series.
+   * 
+   * @param canvas the canvas
+   */
+  private void drawDataSeries(Canvas canvas) {
+    for (ChartValueSeries chartValueSeries : series) {
+      if (chartValueSeries.isEnabled() && chartValueSeries.hasData()) {
+        chartValueSeries.drawPath(canvas);
+      }
+    }
+  }
+
+  /**
+   * Draws the grid.
+   * 
+   * @param canvas the canvas
+   */
+  private void drawGrid(Canvas canvas) {
+    // X axis grid
+    ArrayList<Double> xAxisMarkerPositions = getXAxisMarkerPositions(getXAxisInterval());
+    for (int i = 0; i < xAxisMarkerPositions.size(); i++) {
+      int x = getX(xAxisMarkerPositions.get(i));
+      canvas.drawLine(x, topBorder, x, topBorder + effectiveHeight, gridPaint);
+    }
+    // Y axis grid
+    float rightEdge = getX(maxX);
+    for (int i = 0; i <= Y_AXIS_INTERVALS; i++) {
+      double percentage = (double) i / Y_AXIS_INTERVALS;
+      int range = effectiveHeight - 2 * yAxisOffset;
+      int y = topBorder + yAxisOffset + (int) (percentage * range);
+      canvas.drawLine(leftBorder, y, rightEdge, y, gridPaint);
+    }
+  }
+
+  /**
+   * Draws series titles.
+   * 
+   * @param canvas the canvas
+   */
+  private void drawSeriesTitles(Canvas canvas) {
+    int[] titleDimensions = getTitleDimenions();
+    int lines = titleDimensions[0];
+    int lineHeight = titleDimensions[1];
+    int count = 0;
+    for (int i = 0; i < series.length; i++) {
+      ChartValueSeries chartValueSeries = series[i];
+      if (chartValueSeries.isEnabled() && chartValueSeries.hasData() || allowIfEmpty(i)) {
+        count++;
+        String title = getContext().getString(chartValueSeries.getTitleId(metricUnits));
+        Paint paint = chartValueSeries.getTitlePaint();
+        int x = (int) (0.5 * width) + getScrollX();
+        int y = topBorder - spacer - (lines - count) * (lineHeight + spacer);
+        canvas.drawText(title, x, y, paint);
+      }
+    }
+  }
+
+  /**
+   * Gets the title dimensions. Returns an array of 2 integers, first element is
+   * the number of lines and the second element is the line height.
+   */
+  private int[] getTitleDimenions() {
+    int lines = 0;
+    int lineHeight = 0;
+    for (int i = 0; i < series.length; i++) {
+      ChartValueSeries chartValueSeries = series[i];
+      if (chartValueSeries.isEnabled() && chartValueSeries.hasData() || allowIfEmpty(i)) {
+        lines++;
+        String title = getContext().getString(chartValueSeries.getTitleId(metricUnits));
+        Rect rect = getRect(chartValueSeries.getTitlePaint(), title);
+        if (rect.height() > lineHeight) {
+          lineHeight = rect.height();
+        }
+      }
+    }
+    return new int[] { lines, lineHeight };
+  }
+
+  /**
+   * Draws the x axis.
+   * 
+   * @param canvas the canvas
+   */
+  private void drawXAxis(Canvas canvas) {
+    int x = getScrollX() + leftBorder;
+    int y = topBorder + effectiveHeight;
+    canvas.drawLine(x, y, x + effectiveWidth, y, axisPaint);
+    String label = getXAxisLabel();
+    Rect rect = getRect(axisPaint, label);
+    int yOffset = rect.height() / 2;
+    canvas.drawText(label, x + effectiveWidth + spacer, y + yOffset, axisPaint);
+
+    double interval = getXAxisInterval();
+    ArrayList<Double> markerPositions = getXAxisMarkerPositions(interval);
+    NumberFormat numberFormat = interval < 1 ? X_FRACTION_FORMAT : X_NUMBER_FORMAT;
+    for (int i = 0; i < markerPositions.size(); i++) {
+      drawXAxisMarker(canvas, markerPositions.get(i), numberFormat, spacer + yOffset);
+    }
+  }
+
+  /**
+   * Gets the x axis label.
+   */
+  private String getXAxisLabel() {
+    Context context = getContext();
+    if (chartByDistance) {
+      return metricUnits ? context.getString(R.string.unit_kilometer)
+          : context.getString(R.string.unit_mile);
+    } else {
+      return context.getString(R.string.description_time);
+    }
+  }
+
+  /**
+   * Draws a x axis marker.
+   * 
+   * @param canvas canvas
+   * @param value value
+   * @param numberFormat the number format
+   * @param spacing the spacing between x axis and marker
+   */
+  private void drawXAxisMarker(Canvas canvas, double value, NumberFormat numberFormat, int spacing) {
+    String marker = chartByDistance ? numberFormat.format(value) : StringUtils.formatElapsedTime((long) value);
+    Rect rect = getRect(xAxisMarkerPaint, marker);
+    canvas.drawText(marker, getX(value), topBorder + effectiveHeight + spacing + rect.height(), xAxisMarkerPaint);
+  }
+
+  /**
+   * Gets the x axis interval.
+   */
+  private double getXAxisInterval() {
+    double interval = maxX / zoomLevel / TARGET_X_AXIS_INTERVALS;
+    if (interval < 1) {
+      interval = .5;
+    } else if (interval < 5) {
+      interval = 2;
+    } else if (interval < 10) {
+      interval = 5;
+    } else {
+      interval = (interval / 10) * 10;
+    }
+    return interval;
+  }
+
+  /**
+   * Gets the x axis marker positions.
+   */
+  private ArrayList<Double> getXAxisMarkerPositions(double interval) {
+    ArrayList<Double> markers = new ArrayList<>();
+    markers.add(0d);
+    for (int i = 1; i * interval < maxX; i++) {
+      markers.add(i * interval);
+    }
+    // At least 2 markers
+    if (markers.size() < 2) {
+      markers.add(maxX);
+    }
+    return markers;
+  }
+
+  /**
+   * Draws the y axis.
+   * 
+   * @param canvas the canvas
+   */
+  private void drawYAxis(Canvas canvas) {
+    int x = getScrollX() + leftBorder;
+    int y = topBorder;
+    canvas.drawLine(x, y, x, y + effectiveHeight, axisPaint);
+    
+    int markerXPosition = x - spacer;
+    for (int i = 0; i < series.length; i++) {
+      int index = series.length - 1 - i;
+      ChartValueSeries chartValueSeries = series[index];
+      if (chartValueSeries.isEnabled() && chartValueSeries.hasData() || allowIfEmpty(index)) {
+        markerXPosition -= drawYAxisMarkers(chartValueSeries, canvas, markerXPosition) + spacer;
+      }
+    }
+  }
+
+  /**
+   * Draws the y axis markers for a chart value series.
+   * 
+   * @param chartValueSeries the chart value series
+   * @param canvas the canvas
+   * @param xPosition the right most x position
+   * @return the maximum marker width.
+   */
+  private float drawYAxisMarkers(ChartValueSeries chartValueSeries, Canvas canvas, int xPosition) {
+    int interval = chartValueSeries.getInterval();
+    float maxMarkerWidth = 0;
+    for (int i = 0; i <= Y_AXIS_INTERVALS; i++) {
+      maxMarkerWidth = Math.max(maxMarkerWidth, drawYAxisMarker(chartValueSeries, canvas, xPosition,
+          i * interval + chartValueSeries.getMinMarkerValue()));
+    }
+    return maxMarkerWidth;
+  }
+
+  /**
+   * Draws a y axis marker.
+   * 
+   * @param chartValueSeries the chart value series
+   * @param canvas the canvas
+   * @param xPosition the right most x position
+   * @param yValue the y value
+   * @return the marker width.
+   */
+  private float drawYAxisMarker(
+      ChartValueSeries chartValueSeries, Canvas canvas, int xPosition, int yValue) {
+    String marker = chartValueSeries.formatMarker(yValue);
+    Paint paint = chartValueSeries.getMarkerPaint();
+    Rect rect = getRect(paint, marker);
+    int yPosition = getY(chartValueSeries, yValue) + (rect.height() / 2);
+    canvas.drawText(marker, xPosition, yPosition, paint);
+    return paint.measureText(marker);
+  }
+
+  /**
+   * Draws the current pointer.
+   * 
+   * @param canvas the canvas
+   */
+  private void drawPointer(Canvas canvas) {
+    int index = -1;
+    for (int i = 0; i < series.length; i++) {
+      ChartValueSeries chartValueSeries = series[i];
+      if (chartValueSeries.isEnabled() && chartValueSeries.hasData()) {
+        index = i;
+        break;
+      }
+    }
+    if (index != -1 && chartData.size() > 0) {
+      int dx = getX(maxX) - pointer.getIntrinsicWidth() / 2;
+      int dy = getY(series[index], chartData.get(chartData.size() - 1)[index + 1])
+          - pointer.getIntrinsicHeight();
+      canvas.translate(dx, dy);
+      pointer.draw(canvas);
+    }
+  }
+
+  /**
+   * Updates paths. The path needs to be updated any time after the data or the
+   * dimensions change.
+   */
+  private void updatePaths() {
+    synchronized (chartData) {
+      for (ChartValueSeries chartValueSeries : series) {
+        chartValueSeries.getPath().reset();
+      }
+      drawPaths();
+      closePaths();
+    }
+  }
+
+  /**
+   * Draws all paths.
+   */
+  private void drawPaths() {
+    boolean[] hasMoved = new boolean[series.length];
+    
+    for (int i = 0; i < chartData.size(); i++) {
+      double[] dataPoint = chartData.get(i);
+      for (int j = 0; j < series.length; j++) {
+        double value = dataPoint[j + 1];
+        if (Double.isNaN(value)) {
+          continue;
+        }
+        ChartValueSeries chartValueSeries = series[j];
+        Path path = chartValueSeries.getPath();
+        int x = getX(dataPoint[0]);
+        int y = getY(chartValueSeries, value);
+        if (!hasMoved[j]) {
+          hasMoved[j] = true;
+          path.moveTo(x, y);
+        } else {
+          path.lineTo(x, y);
+        }
+      }
+    }
+  }
+
+  /**
+   * Closes all paths.
+   */
+  private void closePaths() {
+    for (int i = 0; i < series.length; i++) {
+      int first = getFirstPopulatedChartDataIndex(i);
+
+      if (first != -1) {
+        int xCorner = getX(chartData.get(first)[0]);
+        int yCorner = topBorder + effectiveHeight;
+        ChartValueSeries chartValueSeries = series[i];
+        Path path = chartValueSeries.getPath();
+        // Bottom right corner
+        path.lineTo(getX(chartData.get(chartData.size() - 1)[0]), yCorner);
+        // Bottom left corner
+        path.lineTo(xCorner, yCorner);
+        // Top right corner
+        path.lineTo(xCorner, getY(chartValueSeries, chartData.get(first)[i + 1]));
+      }
+    }
+  }
+
+  /**
+   * Finds the index of the first data point containing data for a series.
+   * Returns -1 if no data point contains data for the series.
+   * 
+   * @param seriesIndex the series's index
+   */
+  private int getFirstPopulatedChartDataIndex(int seriesIndex) {
+    for (int i = 0; i < chartData.size(); i++) {
+      if (!Double.isNaN(chartData.get(i)[seriesIndex + 1])) {
+        return i;
+      }
+    }
+    return -1;
+  }
+
+  /**
+   * Updates the chart dimensions.
+   */
+  private void updateDimensions() {
+    maxX = xExtremityMonitor.hasData() ? xExtremityMonitor.getMax() : 1.0;
+    for (ChartValueSeries chartValueSeries : series) {
+      chartValueSeries.updateDimension();
+    }
+    float density = getContext().getResources().getDisplayMetrics().density;
+    spacer = (int) (density * SPACER);
+    yAxisOffset = (int) (density * Y_AXIS_OFFSET);
+
+    int markerLength = 0;
+    for (int i = 0; i < series.length; i ++) {
+      ChartValueSeries chartValueSeries = series[i];
+      if (chartValueSeries.isEnabled() && chartValueSeries.hasData() || allowIfEmpty(i)) {
+        Rect rect = getRect(chartValueSeries.getMarkerPaint(), chartValueSeries.getLargestMarker());
+        markerLength += rect.width() + spacer;
+      }
+    }
+
+    leftBorder = (int) (density * BORDER + markerLength);
+    int[] titleDimensions = getTitleDimenions();
+    topBorder = (int) (density * BORDER + titleDimensions[0] * (titleDimensions[1] + spacer));
+    Rect xAxisLabelRect = getRect(axisPaint, getXAxisLabel());
+    // border + x axis marker + spacer + .5 x axis label
+    bottomBorder = (int) (density * BORDER + getRect(xAxisMarkerPaint, "1").height() + spacer
+        + (xAxisLabelRect.height() / 2));
+    rightBorder = (int) (density * BORDER + xAxisLabelRect.width() + spacer);
+    updateEffectiveDimensions();
+  }
+
+  /**
+   * Updates the effective dimensions.
+   */
+  private void updateEffectiveDimensions() {
+    effectiveWidth = Math.max(0, width - leftBorder - rightBorder);
+    effectiveHeight = Math.max(0, height - topBorder - bottomBorder);
+  }
+
+  /**
+   * Updates the effective dimensions if changed.
+   * 
+   * @param newWidth the new width
+   * @param newHeight the new height
+   */
+  private void updateEffectiveDimensionsIfChanged(int newWidth, int newHeight) {
+    if (width != newWidth || height != newHeight) {
+      width = newWidth;
+      height = newHeight;
+      updateEffectiveDimensions();
+      updatePaths();
+    }
+  }
+
+  /**
+   * Gets the x position for a value.
+   * 
+   * @param value the value
+   */
+  private int getX(double value) {
+    if (value > maxX) {
+      value = maxX;
+    }
+    double percentage = value / maxX;
+    return leftBorder + (int) (percentage * effectiveWidth * zoomLevel);
+  }
+
+  /**
+   * Gets the y position for a value in a chart value series
+   * 
+   * @param chartValueSeries the chart value series
+   * @param value the value
+   */
+  private int getY(ChartValueSeries chartValueSeries, double value) {
+    int effectiveSpread = chartValueSeries.getInterval() * Y_AXIS_INTERVALS;
+    double percentage = (value - chartValueSeries.getMinMarkerValue()) / effectiveSpread;
+    int rangeHeight = effectiveHeight - 2 * yAxisOffset;
+    return topBorder + yAxisOffset + (int) ((1 - percentage) * rangeHeight);
+  }
+
+  /**
+   * Gets a waypoint's x value.
+   * 
+   * @param waypoint the waypoint
+   */
+  private double getWaypointXValue(Waypoint waypoint) {
+    if (chartByDistance) {
+      double lenghtInKm = waypoint.getLength() * UnitConversions.M_TO_KM;
+      return metricUnits ? lenghtInKm : lenghtInKm * UnitConversions.KM_TO_MI;
+    } else {
+      return waypoint.getDuration();
+    }
+  }
+
+  /**
+   * Gets a paint's Rect for a string.
+   * 
+   * @param paint the paint
+   * @param string the string
+   */
+  private Rect getRect(Paint paint, String string) {
+    Rect rect = new Rect();
+    paint.getTextBounds(string, 0, string.length(), rect);
+    return rect;
+  }
+
+  /**
+   * Returns true if the index is allowed when the chartData is empty.
+   * 
+   * @param index the index
+   */
+  private boolean allowIfEmpty(int index) {
+    if (!chartData.isEmpty()) {
+      return false;
+    }
+    switch (index) {
+      case ELEVATION_SERIES:
+        return true;
+      case SPEED_SERIES:
+        return reportSpeed;
+      case PACE_SERIES:
+        return !reportSpeed;
+      default:
+        return false;
+    }
+  }
+}

src/main/java/com/google/android/apps/mytracks/Constants.java

@@ -0,0 +1,37 @@
+/*
+ * 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 com.google.android.apps.mytracks;
+
+/**
+ * Common constants.
+ * 
+ * @author Leif Hendrik Wilden
+ */
+public class Constants {
+
+  private Constants() {}
+
+  /**
+   * Maximum number of waypoints that will be loaded at one time.
+   */
+  public static final int MAX_LOADED_WAYPOINTS_POINTS = 10000;
+
+  /**
+   * The settings file name.
+   */
+  public static final String SETTINGS_NAME = "SettingsActivity";
+}

src/main/java/com/google/android/apps/mytracks/ContextualActionModeCallback.java

@@ -0,0 +1,46 @@
+/*
+ * 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 com.google.android.apps.mytracks;
+
+import android.view.Menu;
+
+/**
+ * Callback when items in the contextual action mode are selected.
+ * 
+ * @author Jimmy Shih
+ */
+public interface ContextualActionModeCallback {
+
+  /**
+   * Invoked to prepare the menu for the selected items.
+   * 
+   * @param menu the menu
+   * @param positions the selected items' positions
+   * @param ids the selected items' ids, if available
+   * @param showSelectAll true to show select all
+   */
+  void onPrepare(Menu menu, int[] positions, long[] ids, boolean showSelectAll);
+
+  /**
+   * Invoked when items are selected.
+   * 
+   * @param itemId the context menu item id
+   * @param positions the selected items' positions
+   * @param ids the selected items' ids, if available
+   */
+  boolean onClick(int itemId, int[] positions, long[] ids);
+}

src/main/java/com/google/android/apps/mytracks/DeleteActivity.java

@@ -0,0 +1,97 @@
+/*
+ * 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 com.google.android.apps.mytracks;
+
+import com.google.android.apps.mytracks.util.DialogUtils;
+import com.google.android.maps.mytracks.R;
+
+import android.app.Activity;
+import android.app.Dialog;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.os.Bundle;
+
+/**
+ * An activity for delete tracks.
+ * 
+ * @author Jimmy Shih
+ */
+public class DeleteActivity extends Activity {
+
+  public static final String EXTRA_TRACK_IDS = "track_ids";
+
+  private static final int DIALOG_PROGRESS_ID = 0;
+
+  private DeleteAsyncTask deleteAsyncTask;
+
+  @Override
+  public void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    
+    setResult(RESULT_CANCELED);
+    
+    Intent intent = getIntent();
+    long[] trackIds = intent.getLongArrayExtra(EXTRA_TRACK_IDS);
+
+    Object retained = getLastNonConfigurationInstance();
+    if (retained instanceof DeleteAsyncTask) {
+      deleteAsyncTask = (DeleteAsyncTask) retained;
+      deleteAsyncTask.setActivity(this);
+    } else {
+      deleteAsyncTask = new DeleteAsyncTask(this, trackIds);
+      deleteAsyncTask.execute();
+    }
+  }
+
+  @Override
+  public Object onRetainNonConfigurationInstance() {
+    deleteAsyncTask.setActivity(null);
+    return deleteAsyncTask;
+  }
+
+  @Override
+  protected Dialog onCreateDialog(int id) {
+    if (id != DIALOG_PROGRESS_ID) {
+      return null;
+    }
+    return DialogUtils.createSpinnerProgressDialog(
+        this, R.string.track_delete_progress_message, new DialogInterface.OnCancelListener() {
+            @Override
+          public void onCancel(DialogInterface dialog) {
+            deleteAsyncTask.cancel(true);
+            dialog.dismiss();
+            finish();
+          }
+        });
+  }
+
+  /**
+   * Invokes when the associated AsyncTask completes.
+   */
+  public void onAsyncTaskCompleted() {
+    removeDialog(DIALOG_PROGRESS_ID);
+    setResult(RESULT_OK);
+    finish();
+  }
+
+  /**
+   * Shows the progress dialog.
+   */
+  public void showProgressDialog() {
+    showDialog(DIALOG_PROGRESS_ID);
+  }
+}

src/main/java/com/google/android/apps/mytracks/DeleteAsyncTask.java

@@ -0,0 +1,95 @@
+package com.google.android.apps.mytracks;
+
+/*
+ * 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.
+ */
+
+import android.content.Context;
+import android.os.AsyncTask;
+
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils;
+
+/**
+ * Async Task to delete tracks.
+ * 
+ * @author Jimmy Shih
+ */
+public class DeleteAsyncTask extends AsyncTask<Void, Integer, Boolean> {
+
+  private DeleteActivity deleteActivity;
+  private final long[] trackIds;
+  private final Context context;
+
+  // true if the AsyncTask has completed
+  private boolean completed;
+
+  /**
+   * Creates an AsyncTask.
+   * 
+   * @param deleteActivity the activity currently associated with this task
+   * @param trackIds the track ids to delete. To delete all, set to size 1 with
+   *          trackIds[0] == -1L
+   */
+  public DeleteAsyncTask(DeleteActivity deleteActivity, long[] trackIds) {
+    this.deleteActivity = deleteActivity;
+    this.trackIds = trackIds;
+    context = deleteActivity.getApplicationContext();
+    completed = false;
+  }
+
+  /**
+   * Sets the current activity associated with this AyncTask.
+   * 
+   * @param deleteActivity the current activity, can be null
+   */
+  public void setActivity(DeleteActivity deleteActivity) {
+    this.deleteActivity = deleteActivity;
+    if (completed && deleteActivity != null) {
+      deleteActivity.onAsyncTaskCompleted();
+    }
+  }
+
+  @Override
+  protected void onPreExecute() {
+    if (deleteActivity != null) {
+      deleteActivity.showProgressDialog();
+    }
+  }
+
+  @Override
+  protected Boolean doInBackground(Void... params) {
+    MyTracksProviderUtils myTracksProviderUtils = MyTracksProviderUtils.Factory.get(context);
+
+    if (trackIds.length == 1 && trackIds[0] == -1L) {
+      myTracksProviderUtils.deleteAllTracks(context);
+    } else {
+      for (long id : trackIds) {
+        if (isCancelled()) {
+          return false;
+        }
+        myTracksProviderUtils.deleteTrack(context, id);
+      }
+    }
+    return true;
+  }
+
+  @Override
+  protected void onPostExecute(Boolean result) {
+    completed = true;
+    if (deleteActivity != null) {
+      deleteActivity.onAsyncTaskCompleted();
+    }
+  }
+}

src/main/java/com/google/android/apps/mytracks/MarkerDetailActivity.java

@@ -0,0 +1,126 @@
+/*
+ * 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 com.google.android.apps.mytracks;
+
+import android.database.Cursor;
+import android.os.Bundle;
+import android.util.Log;
+
+import androidx.fragment.app.Fragment;
+import androidx.fragment.app.FragmentManager;
+import androidx.fragment.app.FragmentStatePagerAdapter;
+import androidx.viewpager.widget.ViewPager;
+
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils;
+import com.google.android.apps.mytracks.content.Waypoint;
+import com.google.android.apps.mytracks.fragments.DeleteMarkerDialogFragment.DeleteMarkerCaller;
+import com.google.android.apps.mytracks.fragments.MarkerDetailFragment;
+import com.google.android.maps.mytracks.R;
+
+import java.util.ArrayList;
+
+/**
+ * An activity to display marker detail info.
+ * 
+ * @author Leif Hendrik Wilden
+ */
+public class MarkerDetailActivity extends AbstractActivity implements DeleteMarkerCaller {
+
+  public static final String EXTRA_MARKER_ID = "marker_id";
+  private static final String TAG = MarkerDetailActivity.class.getSimpleName();
+
+  private ArrayList<Long> markerIds;
+
+  @Override
+  protected void onCreate(Bundle bundle) {
+    super.onCreate(bundle);
+
+    long markerId = getIntent().getLongExtra(EXTRA_MARKER_ID, -1L);
+    if (markerId == -1L) {
+      Log.d(TAG, "invalid marker id");
+      finish();
+      return;
+    }
+
+    MyTracksProviderUtils myTracksProviderUtils = MyTracksProviderUtils.Factory.get(this);
+    Waypoint waypoint = myTracksProviderUtils.getWaypoint(markerId);
+
+    markerIds = new ArrayList<>();
+    int markerIndex = -1;
+
+      try (Cursor cursor = myTracksProviderUtils.getWaypointCursor(waypoint.getTrackId(), -1L, -1)) {
+          if (cursor != null && cursor.moveToFirst()) {
+              /*
+               * Yes, this will skip the first waypoint and that is intentional as the
+               * first waypoint holds the stats for the track.
+               */
+              while (cursor.moveToNext()) {
+                  Waypoint current = myTracksProviderUtils.createWaypoint(cursor);
+
+                  markerIds.add(current.getId());
+                  if (current.getId() == markerId) {
+                      markerIndex = markerIds.size() - 1;
+                  }
+              }
+          }
+      }
+
+    ViewPager viewPager = findViewById(R.id.maker_detail_activity_view_pager);
+    viewPager.setAdapter(new MarkerDetailPagerAdapter(getSupportFragmentManager()));
+    if (markerIndex != -1) {
+      viewPager.setCurrentItem(markerIndex);
+    }
+  }
+
+  @Override
+  protected int getLayoutResId() {
+    return R.layout.marker_detail_activity;
+  }
+
+  @Override
+  public void onDeleteMarkerDone() {
+    runOnUiThread(new Runnable() {
+        @Override
+      public void run() {
+        finish();
+      }
+    });
+  }
+
+  /**
+   * Marker detail pager adapter.
+   * 
+   * @author Jimmy Shih
+   */
+  private class MarkerDetailPagerAdapter extends FragmentStatePagerAdapter {
+
+    public MarkerDetailPagerAdapter(FragmentManager fragmentManager) {
+      super(fragmentManager);
+    }
+
+    @Override
+    public Fragment getItem(int position) {
+      String title = getString(R.string.marker_title, position + 1, getCount());
+      return MarkerDetailFragment.newInstance(markerIds.get(position), title);
+    }
+
+    @Override
+    public int getCount() {
+      return markerIds.size();
+    }
+  }
+}

src/main/java/com/google/android/apps/mytracks/MarkerEditActivity.java

@@ -0,0 +1,191 @@
+/*
+ * 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 com.google.android.apps.mytracks;
+
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils;
+import com.google.android.apps.mytracks.content.Waypoint;
+import com.google.android.apps.mytracks.content.Waypoint.WaypointType;
+import com.google.android.apps.mytracks.content.WaypointCreationRequest;
+import com.google.android.apps.mytracks.services.TrackRecordingServiceConnection;
+import com.google.android.apps.mytracks.util.TrackRecordingServiceConnectionUtils;
+import com.google.android.maps.mytracks.R;
+
+import android.os.Bundle;
+import android.util.Log;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.ArrayAdapter;
+import android.widget.AutoCompleteTextView;
+import android.widget.Button;
+import android.widget.EditText;
+
+/**
+ * An activity to add/edit a marker.
+ *
+ * @author Jimmy Shih
+ */
+public class MarkerEditActivity extends AbstractActivity {
+
+  private static final String TAG = MarkerEditActivity.class.getSimpleName();
+
+  public static final String EXTRA_TRACK_ID = "track_id";
+  public static final String EXTRA_MARKER_ID = "marker_id";
+
+  private long trackId;
+  private long markerId;
+  private TrackRecordingServiceConnection trackRecordingServiceConnection;
+  private Waypoint waypoint;
+
+  // UI elements
+  private View statisticsSection;
+  private EditText statisticsName;
+  private View waypointSection;
+  private EditText waypointName;
+  private AutoCompleteTextView waypointMarkerType;
+  private EditText waypointDescription;
+  private Button done;
+
+  @Override
+  protected void onCreate(Bundle bundle) {
+    super.onCreate(bundle);
+
+    trackId = getIntent().getLongExtra(EXTRA_TRACK_ID, -1L);
+    markerId = getIntent().getLongExtra(EXTRA_MARKER_ID, -1L);
+    trackRecordingServiceConnection = new TrackRecordingServiceConnection(this, null);
+        
+    // Setup UI elements
+    statisticsSection = findViewById(R.id.marker_edit_statistics_section);
+    statisticsName = findViewById(R.id.marker_edit_statistics_name);
+    
+    waypointSection = findViewById(R.id.marker_edit_waypoint_section);
+    waypointName = findViewById(R.id.marker_edit_waypoint_name);
+    waypointMarkerType = findViewById(R.id.marker_edit_waypoint_marker_type);
+    ArrayAdapter<CharSequence> adapter = ArrayAdapter.createFromResource(
+        this, R.array.waypoint_types, android.R.layout.simple_dropdown_item_1line);
+    waypointMarkerType.setAdapter(adapter);
+    waypointDescription = findViewById(R.id.marker_edit_waypoint_description);
+
+    Button cancel = findViewById(R.id.marker_edit_cancel);
+    cancel.setOnClickListener(new OnClickListener() {
+      @Override
+      public void onClick(View v) {
+        finish();
+      }
+    });
+    done = findViewById(R.id.marker_edit_done);
+    updateUiByMarkerId();
+  }
+
+  @Override
+  protected void onStart() {
+    super.onStart();
+    TrackRecordingServiceConnectionUtils.startConnection(this, trackRecordingServiceConnection);
+  }
+  
+  @Override
+  protected void onStop() {
+    super.onStop();
+    trackRecordingServiceConnection.unbind();
+  }
+
+  @Override
+  protected int getLayoutResId() {
+    return R.layout.marker_edit;
+  }
+
+  /**
+   * Updates the UI based on the marker id.
+   */
+  private void updateUiByMarkerId() {
+    final boolean newMarker = markerId == -1L;
+  
+    setTitle(newMarker ? R.string.menu_insert_marker : R.string.menu_edit);
+    done.setText(newMarker ? R.string.generic_add : R.string.generic_save);
+    done.setOnClickListener(new View.OnClickListener() {
+      @Override
+      public void onClick(View v) {
+        if (newMarker) {
+          addMarker();
+        } else {
+          saveMarker();
+        }
+      }
+    });
+  
+    if (newMarker) {
+      statisticsSection.setVisibility(View.GONE);
+      waypointSection.setVisibility(View.VISIBLE);
+      int nextWaypointNumber = trackId == -1L ? -1
+          : MyTracksProviderUtils.Factory.get(this).getNextWaypointNumber(trackId, WaypointType.WAYPOINT);
+      if (nextWaypointNumber == -1) {
+        nextWaypointNumber = 0;
+      }
+      waypointName.setText(getString(R.string.marker_name_format, nextWaypointNumber));
+      waypointName.selectAll();
+      waypointMarkerType.setText("");
+      waypointDescription.setText("");
+    } else {
+      waypoint = MyTracksProviderUtils.Factory.get(this).getWaypoint(markerId);
+      if (waypoint == null) {
+        Log.d(TAG, "waypoint is null");
+        finish();
+        return;
+      }
+      boolean statistics = waypoint.getType() == WaypointType.STATISTICS;
+      statisticsSection.setVisibility(statistics ? View.VISIBLE : View.GONE);
+      waypointSection.setVisibility(statistics ? View.GONE : View.VISIBLE);
+      if (statistics) {
+        statisticsName.setText(waypoint.getName());
+      } else {
+        waypointName.setText(waypoint.getName());
+        waypointMarkerType.setText(waypoint.getCategory());
+        waypointDescription.setText(waypoint.getDescription());
+      }  
+    }
+  }
+
+  /**
+   * Adds a marker.
+   */
+  private void addMarker() {
+    WaypointCreationRequest waypointCreationRequest = new WaypointCreationRequest(
+        WaypointType.WAYPOINT,
+        false,
+        waypointName.getText().toString(),
+        waypointMarkerType.getText().toString(),
+        waypointDescription.getText().toString(),
+        null,
+        null);
+    TrackRecordingServiceConnectionUtils.addMarker(
+        this, trackRecordingServiceConnection, waypointCreationRequest);
+  }
+
+  /**
+   * Saves a marker.
+   */
+  private void saveMarker() {
+    boolean statistics = waypoint.getType() == WaypointType.STATISTICS;
+    if (statistics) {
+      waypoint.setName(statisticsName.getText().toString());
+    } else {
+      waypoint.setName(waypointName.getText().toString());
+      waypoint.setCategory(waypointMarkerType.getText().toString());
+      waypoint.setDescription(waypointDescription.getText().toString());
+    }
+    MyTracksProviderUtils.Factory.get(this).updateWaypoint(waypoint);
+  }
+}

src/main/java/com/google/android/apps/mytracks/MarkerListActivity.java

@@ -0,0 +1,336 @@
+/*
+ * 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 com.google.android.apps.mytracks;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
+import android.database.Cursor;
+import android.os.Bundle;
+import android.view.ContextMenu;
+import android.view.ContextMenu.ContextMenuInfo;
+import android.view.KeyEvent;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.widget.AdapterView;
+import android.widget.AdapterView.AdapterContextMenuInfo;
+import android.widget.AdapterView.OnItemClickListener;
+import android.widget.ListView;
+
+import androidx.annotation.NonNull;
+import androidx.cursoradapter.widget.ResourceCursorAdapter;
+import androidx.loader.app.LoaderManager;
+import androidx.loader.app.LoaderManager.LoaderCallbacks;
+import androidx.loader.content.CursorLoader;
+import androidx.loader.content.Loader;
+
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils;
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.content.Waypoint.WaypointType;
+import com.google.android.apps.mytracks.content.WaypointsColumns;
+import com.google.android.apps.mytracks.fragments.DeleteMarkerDialogFragment;
+import com.google.android.apps.mytracks.fragments.DeleteMarkerDialogFragment.DeleteMarkerCaller;
+import com.google.android.apps.mytracks.util.IntentUtils;
+import com.google.android.apps.mytracks.util.ListItemUtils;
+import com.google.android.apps.mytracks.util.PreferencesUtils;
+import com.google.android.maps.mytracks.R;
+
+/**
+ * Activity to show a list of markers in a track.
+ * 
+ * @author Leif Hendrik Wilden
+ */
+public class MarkerListActivity extends AbstractActivity implements DeleteMarkerCaller {
+
+  public static final String EXTRA_TRACK_ID = "track_id";
+
+  private static final String TAG = MarkerListActivity.class.getSimpleName();
+
+  private static final String[] PROJECTION = new String[] { WaypointsColumns._ID,
+      WaypointsColumns.NAME, WaypointsColumns.DESCRIPTION, WaypointsColumns.CATEGORY,
+      WaypointsColumns.TYPE, WaypointsColumns.TIME, WaypointsColumns.PHOTOURL,
+      WaypointsColumns.LATITUDE, WaypointsColumns.LONGITUDE};
+
+  // Callback when an item is selected in the contextual action mode
+  private ContextualActionModeCallback contextualActionModeCallback = new ContextualActionModeCallback() {
+        @Override
+        public void onPrepare(Menu menu, int[] positions, long[] ids, boolean showSelectAll) {
+          boolean isSingleSelection = ids.length == 1;
+
+          menu.findItem(R.id.list_context_menu_share).setVisible(false);
+          menu.findItem(R.id.list_context_menu_show_on_map).setVisible(isSingleSelection);
+          menu.findItem(R.id.list_context_menu_edit).setVisible(isSingleSelection);
+          menu.findItem(R.id.list_context_menu_delete).setVisible(true);
+          /*
+           * Set select all to the same visibility as delete since delete is the
+           * only action that can be applied to multiple markers.
+           */
+          menu.findItem(R.id.list_context_menu_select_all).setVisible(showSelectAll);
+        }
+
+          @Override
+        public boolean onClick(int itemId, int[] positions, long[] ids) {
+          return handleContextItem(itemId, ids);
+        }
+      };
+
+  /*
+   * Note that sharedPreferenceChangeListener cannot be an anonymous inner
+   * class. Anonymous inner class will get garbage collected.
+   */
+  private final OnSharedPreferenceChangeListener
+      sharedPreferenceChangeListener = new OnSharedPreferenceChangeListener() {
+          @Override
+        public void onSharedPreferenceChanged(SharedPreferences preferences, String key) {
+          // Note that the key can be null
+          if (key == null || key.equals(PreferencesUtils.getKey(MarkerListActivity.this, R.string.recording_track_id_key))) {
+            recordingTrackId = PreferencesUtils.getLong(MarkerListActivity.this, R.string.recording_track_id_key);
+          }
+          if (key == null || key.equals(PreferencesUtils.getKey(MarkerListActivity.this, R.string.recording_track_paused_key))) {
+            recordingTrackPaused = PreferencesUtils.getBoolean(MarkerListActivity.this, R.string.recording_track_paused_key, PreferencesUtils.RECORDING_TRACK_PAUSED_DEFAULT);
+          }
+          if (key != null) {
+            runOnUiThread(new Runnable() {
+                @Override
+              public void run() {
+                  MarkerListActivity.this.invalidateOptionsMenu();
+              }
+            });
+          }
+        }
+      };
+
+  private MyTracksProviderUtils myTracksProviderUtils;
+  private SharedPreferences sharedPreferences;
+
+  private long recordingTrackId = PreferencesUtils.RECORDING_TRACK_ID_DEFAULT;
+  private boolean recordingTrackPaused = PreferencesUtils.RECORDING_TRACK_PAUSED_DEFAULT;
+
+  private Track track;
+  private ResourceCursorAdapter resourceCursorAdapter;
+
+  // UI elements
+  private ListView listView;
+  private MenuItem insertMarkerMenuItem;
+  private MenuItem searchMenuItem;
+
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+
+    myTracksProviderUtils = MyTracksProviderUtils.Factory.get(this);
+    sharedPreferences = getSharedPreferences(Constants.SETTINGS_NAME, Context.MODE_PRIVATE);
+
+    long trackId = getIntent().getLongExtra(EXTRA_TRACK_ID, -1L);
+    track = trackId != -1L ? myTracksProviderUtils.getTrack(trackId) : null;
+    final long trackFirstWaypointId = trackId != -1 ? myTracksProviderUtils.getFirstWaypointId(trackId) : -1;
+
+    setDefaultKeyMode(DEFAULT_KEYS_SEARCH_LOCAL);
+
+    listView = findViewById(R.id.marker_list);
+    listView.setEmptyView(findViewById(R.id.marker_list_empty));
+    listView.setOnItemClickListener(new OnItemClickListener() {
+        @Override
+      public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
+        Intent intent = IntentUtils.newIntent(MarkerListActivity.this, MarkerDetailActivity.class)
+            .putExtra(MarkerDetailActivity.EXTRA_MARKER_ID, id);
+        startActivity(intent);
+      }
+    });
+    resourceCursorAdapter = new ResourceCursorAdapter(this, R.layout.list_item, null, 0) {
+        @Override
+      public void bindView(View view, Context context, Cursor cursor) {
+        int typeIndex = cursor.getColumnIndex(WaypointsColumns.TYPE);
+        int nameIndex = cursor.getColumnIndex(WaypointsColumns.NAME);
+        int timeIndex = cursor.getColumnIndexOrThrow(WaypointsColumns.TIME);
+        int categoryIndex = cursor.getColumnIndex(WaypointsColumns.CATEGORY);
+        int descriptionIndex = cursor.getColumnIndex(WaypointsColumns.DESCRIPTION);
+        int photoUrlIndex = cursor.getColumnIndex(WaypointsColumns.PHOTOURL);
+        int latitudeIndex = cursor.getColumnIndex(WaypointsColumns.LATITUDE);
+        int longitudeIndex = cursor.getColumnIndex(WaypointsColumns.LONGITUDE);
+
+        boolean statistics = WaypointType.values()[cursor.getInt(typeIndex)] == WaypointType.STATISTICS;
+        int iconId = statistics ? R.drawable.ic_marker_yellow_pushpin : R.drawable.ic_marker_blue_pushpin;
+        String name = cursor.getString(nameIndex);
+        long time = cursor.getLong(timeIndex);
+        String category = statistics ? null : cursor.getString(categoryIndex);
+        String description = statistics ? null : cursor.getString(descriptionIndex);
+        String photoUrl = cursor.getString(photoUrlIndex);
+        double latitude = cursor.getDouble(latitudeIndex);
+        double longitude = cursor.getDouble(longitudeIndex);
+
+        ListItemUtils.setListItem(MarkerListActivity.this, view, false, true, iconId, R.string.image_marker, name, null, null, 0, time, false, category, description, photoUrl);
+      }
+    };
+    listView.setAdapter(resourceCursorAdapter);
+    AbstractTrackActivity.configureListViewContextualMenu(listView, contextualActionModeCallback);
+
+    LoaderManager.getInstance(this).initLoader(0, null, new LoaderCallbacks<Cursor>() {
+        @NonNull
+        @Override
+      public Loader<Cursor> onCreateLoader(int arg0, Bundle arg1) {
+        if (track != null) {
+          return new CursorLoader(MarkerListActivity.this, WaypointsColumns.CONTENT_URI, PROJECTION,
+                  WaypointsColumns.TRACKID + "=? AND " + WaypointsColumns._ID + "!=?",
+                  new String[] { String.valueOf(track.getId()), String.valueOf(trackFirstWaypointId) }, null);
+        } else {
+          return new CursorLoader(MarkerListActivity.this, WaypointsColumns.CONTENT_URI, PROJECTION,
+                  WaypointsColumns.STARTTIME + " IS NULL",null, null);
+        }
+      }
+
+        @Override
+      public void onLoadFinished(@NonNull Loader<Cursor> loader, Cursor cursor) {
+        resourceCursorAdapter.swapCursor(cursor);
+      }
+
+        @Override
+      public void onLoaderReset(@NonNull Loader<Cursor> loader) {
+        resourceCursorAdapter.swapCursor(null);
+      }
+    });
+  }
+
+  @Override
+  protected void onStart() {
+    super.onStart();
+    sharedPreferences.registerOnSharedPreferenceChangeListener(sharedPreferenceChangeListener);
+    sharedPreferenceChangeListener.onSharedPreferenceChanged(null, null);
+  }
+
+  @Override
+  protected void onResume() {
+    super.onResume();
+    this.invalidateOptionsMenu();
+  }
+
+  @Override
+  protected void onStop() {
+    super.onStop();
+    sharedPreferences.unregisterOnSharedPreferenceChangeListener(sharedPreferenceChangeListener);
+  }
+
+  @Override
+  protected int getLayoutResId() {
+    return R.layout.marker_list;
+  }
+
+  @Override
+  public boolean onCreateOptionsMenu(Menu menu) {
+    getMenuInflater().inflate(R.menu.marker_list, menu);
+
+    insertMarkerMenuItem = menu.findItem(R.id.marker_list_insert_marker);
+
+    searchMenuItem = menu.findItem(R.id.marker_list_search);
+    AbstractTrackActivity.configureSearchWidget(this, searchMenuItem, null);
+
+    return super.onCreateOptionsMenu(menu);
+  }
+
+  @Override
+  public boolean onPrepareOptionsMenu(Menu menu) {
+    insertMarkerMenuItem.setVisible(track != null && track.getId() == recordingTrackId && !recordingTrackPaused);
+    return super.onPrepareOptionsMenu(menu);
+  }
+  
+  @Override
+  public boolean onOptionsItemSelected(MenuItem item) {
+    if (track != null && item.getItemId() == R.id.marker_list_insert_marker) {
+      Intent intent = IntentUtils.newIntent(this, MarkerEditActivity.class)
+              .putExtra(MarkerEditActivity.EXTRA_TRACK_ID, track.getId());
+      startActivity(intent);
+      return true;
+    }
+    return super.onOptionsItemSelected(item);
+  }
+
+  @Override
+  public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
+    super.onCreateContextMenu(menu, v, menuInfo);
+    getMenuInflater().inflate(R.menu.list_context_menu, menu);
+
+    AdapterContextMenuInfo info = (AdapterContextMenuInfo) menuInfo;
+    contextualActionModeCallback.onPrepare(menu, new int[] { info.position }, new long[] { info.id }, false);
+  }
+
+  @Override
+  public boolean onContextItemSelected(MenuItem item) {
+    AdapterContextMenuInfo info = (AdapterContextMenuInfo) item.getMenuInfo();
+    if (handleContextItem(item.getItemId(), new long[] {info.id})) {
+      return true;
+    }
+    return super.onContextItemSelected(item);
+  }
+
+  /**
+   * Handles a context item selection.
+   * 
+   * @param itemId the menu item id
+   * @param markerIds the marker ids
+   * @return true if handled.
+   */
+  private boolean handleContextItem(int itemId, long[] markerIds) {
+    Intent intent;
+    switch (itemId) {
+      case R.id.list_context_menu_show_on_map:
+        if (markerIds.length == 1) {
+          intent = IntentUtils.newIntent(this, TrackDetailActivity.class)
+              .putExtra(TrackDetailActivity.EXTRA_MARKER_ID, markerIds[0]);
+          //TODO Use IntentUtils.newShowOnMapIntent()
+          startActivity(intent);
+        }
+        return true;
+      case R.id.list_context_menu_edit:
+        if (markerIds.length == 1) {
+          intent = IntentUtils.newIntent(this, MarkerEditActivity.class)
+              .putExtra(MarkerEditActivity.EXTRA_MARKER_ID, markerIds[0]);
+          startActivity(intent);
+        }
+        return true;
+      case R.id.list_context_menu_delete:
+        if (markerIds.length > 1 && markerIds.length == listView.getCount()) {
+          markerIds = new long[] { -1L };
+        }
+        DeleteMarkerDialogFragment.newInstance(markerIds)
+            .show(getSupportFragmentManager(), DeleteMarkerDialogFragment.DELETE_MARKER_DIALOG_TAG);
+        return true;
+      case R.id.list_context_menu_select_all:
+        int size = listView.getCount();
+        for (int i = 0; i < size; i++) {
+          listView.setItemChecked(i, true);
+        }
+        return false;
+      default:
+        return false;
+    }
+  }
+
+  @Override
+  public boolean onKeyUp(int keyCode, KeyEvent event) {
+    if (keyCode == KeyEvent.KEYCODE_SEARCH && searchMenuItem != null) {
+      return true;
+    }
+    return super.onKeyUp(keyCode, event);
+  }
+
+  @Override
+  public void onDeleteMarkerDone() {
+    // Do nothing
+  }
+}

src/main/java/com/google/android/apps/mytracks/SearchListActivity.java

@@ -0,0 +1,513 @@
+/*
+ * 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 com.google.android.apps.mytracks;
+
+import android.app.SearchManager;
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
+import android.os.Bundle;
+import android.provider.SearchRecentSuggestions;
+import android.util.Log;
+import android.view.ContextMenu;
+import android.view.ContextMenu.ContextMenuInfo;
+import android.view.KeyEvent;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.widget.AdapterView;
+import android.widget.AdapterView.AdapterContextMenuInfo;
+import android.widget.AdapterView.OnItemClickListener;
+import android.widget.ArrayAdapter;
+import android.widget.ListView;
+
+import androidx.annotation.NonNull;
+
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils;
+import com.google.android.apps.mytracks.content.SearchEngine;
+import com.google.android.apps.mytracks.content.SearchEngine.ScoredResult;
+import com.google.android.apps.mytracks.content.SearchEngine.SearchQuery;
+import com.google.android.apps.mytracks.content.SearchEngineProvider;
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.content.Waypoint;
+import com.google.android.apps.mytracks.content.Waypoint.WaypointType;
+import com.google.android.apps.mytracks.fragments.ConfirmDeleteDialogFragment;
+import com.google.android.apps.mytracks.fragments.DeleteMarkerDialogFragment;
+import com.google.android.apps.mytracks.fragments.DeleteMarkerDialogFragment.DeleteMarkerCaller;
+import com.google.android.apps.mytracks.services.TrackRecordingServiceConnection;
+import com.google.android.apps.mytracks.stats.TripStatistics;
+import com.google.android.apps.mytracks.util.IntentUtils;
+import com.google.android.apps.mytracks.util.ListItemUtils;
+import com.google.android.apps.mytracks.util.PreferencesUtils;
+import com.google.android.apps.mytracks.util.StringUtils;
+import com.google.android.apps.mytracks.util.TrackIconUtils;
+import com.google.android.apps.mytracks.util.TrackRecordingServiceConnectionUtils;
+import com.google.android.maps.mytracks.R;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.SortedSet;
+
+/**
+ * An activity to display a list of search results.
+ * 
+ * @author Rodrigo Damazio
+ *
+ * TODO: allow to refine search (present search in context menu)
+ */
+public class SearchListActivity extends AbstractTrackActivity implements DeleteMarkerCaller, ConfirmDeleteDialogFragment.ConfirmDeleteCaller {
+
+  private static final String TAG = SearchListActivity.class.getSimpleName();
+
+  private static final String IS_RECORDING_FIELD = "isRecording";
+  private static final String IS_PAUSED_FIELD = "isPaused";
+  private static final String ICON_ID_FIELD = "icon";
+  private static final String ICON_CONTENT_DESCRIPTION_ID_FIELD = "iconContentDescription";
+  private static final String NAME_FIELD = "name";
+  private static final String TOTAL_TIME_FIELD = "totalTime";
+  private static final String TOTAL_DISTANCE_FIELD = "totalDistance";
+  private static final String MARKER_COUNT_FIELD = "markerCount";
+  private static final String START_TIME_FIELD = "startTime";
+  private static final String CATEGORY_FIELD = "category";
+  private static final String DESCRIPTION_FIELD = "description";
+  private static final String PHOTO_URL_FIELD = "photoUrl";
+  private static final String MARKER_LATITUDE_FIELD = "latitude";
+  private static final String MARKER_LONGITUDE_FIELD = "longitude";
+
+  private static final String TRACK_ID_FIELD = "trackId";
+  private static final String MARKER_ID_FIELD = "markerId";
+
+  private final OnSharedPreferenceChangeListener
+      sharedPreferenceChangeListener = new OnSharedPreferenceChangeListener() {
+          @Override
+        public void onSharedPreferenceChanged(SharedPreferences preferences, String key) {
+          if (key == null || key.equals(PreferencesUtils.getKey(SearchListActivity.this, R.string.stats_units_key))) {
+            metricUnits = PreferencesUtils.isMetricUnits(SearchListActivity.this);
+          }
+          if (key == null || key.equals(PreferencesUtils.getKey(SearchListActivity.this, R.string.recording_track_id_key))) {
+            recordingTrackId = PreferencesUtils.getLong(SearchListActivity.this, R.string.recording_track_id_key);
+          }
+          if (key == null || key.equals(PreferencesUtils.getKey(SearchListActivity.this, R.string.recording_track_paused_key))) {
+            recordingTrackPaused = PreferencesUtils.getBoolean(SearchListActivity.this, R.string.recording_track_paused_key, PreferencesUtils.RECORDING_TRACK_PAUSED_DEFAULT);
+          }
+          if (key != null) {
+            runOnUiThread(new Runnable() {
+                @Override
+              public void run() {
+                arrayAdapter.notifyDataSetChanged();
+              }
+            });
+          }
+        }
+      };
+
+  // Callback when an item is selected in the contextual action mode
+  private ContextualActionModeCallback contextualActionModeCallback = new ContextualActionModeCallback() {
+          @Override
+        public boolean onClick(int itemId, int[] positions, long[] ids) {
+          return handleContextItem(itemId, positions);          
+        }
+          @Override
+        public void onPrepare(Menu menu, int[] positions, long[] ids, boolean showSelectAll) {
+          boolean isRecording = recordingTrackId != PreferencesUtils.RECORDING_TRACK_ID_DEFAULT;
+          boolean isSingleSelection = positions.length == 1;
+          boolean isSingleSelectionTrack;
+          if (isSingleSelection) {
+            Map<String, Object> item = arrayAdapter.getItem(positions[0]);
+            Long trackId = (Long) item.get(TRACK_ID_FIELD);
+            Track track = myTracksProviderUtils.getTrack(trackId);
+
+            isSingleSelectionTrack = item.get(MARKER_ID_FIELD) == null;
+          } else {
+            isSingleSelectionTrack = false;
+          }
+          // Not recording, one item, item is a track
+          menu.findItem(R.id.list_context_menu_share).setVisible(!isRecording && isSingleSelection && isSingleSelectionTrack);
+          //TODO Setup shareIntent.
+
+          // One item, item is a marker
+          menu.findItem(R.id.list_context_menu_show_on_map).setVisible(isSingleSelection && !isSingleSelectionTrack);
+          // One item, can be a track or a marker
+          menu.findItem(R.id.list_context_menu_edit).setVisible(isSingleSelection);
+          // One item. If track, no restriction.
+          menu.findItem(R.id.list_context_menu_delete).setVisible(isSingleSelection && (isSingleSelectionTrack));
+          // Disable select all, no action is available for multiple selection
+          menu.findItem(R.id.list_context_menu_select_all).setVisible(false);
+        }
+      };
+
+  private MyTracksProviderUtils myTracksProviderUtils;
+  private SharedPreferences sharedPreferences;
+  private TrackRecordingServiceConnection trackRecordingServiceConnection;
+  private SearchEngine searchEngine;
+  private SearchRecentSuggestions searchRecentSuggestions;
+  private ArrayAdapter<Map<String, Object>> arrayAdapter;
+
+  private boolean metricUnits = true;
+  private long recordingTrackId = PreferencesUtils.RECORDING_TRACK_ID_DEFAULT;
+  private boolean recordingTrackPaused = PreferencesUtils.RECORDING_TRACK_PAUSED_DEFAULT;
+
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    setDefaultKeyMode(DEFAULT_KEYS_SEARCH_LOCAL);
+
+    myTracksProviderUtils = MyTracksProviderUtils.Factory.get(this);
+    sharedPreferences = getSharedPreferences(Constants.SETTINGS_NAME, Context.MODE_PRIVATE);
+    trackRecordingServiceConnection = new TrackRecordingServiceConnection(this, null);
+    searchEngine = new SearchEngine(myTracksProviderUtils);
+    searchRecentSuggestions = SearchEngineProvider.newHelper(this);
+
+    arrayAdapter = new ArrayAdapter<Map<String, Object>>(this, R.layout.list_item, R.id.list_item_name) {
+        @NonNull
+        @Override
+      public View getView(int position, View convertView, @NonNull android.view.ViewGroup parent) {
+        View view;
+        if (convertView == null) {
+          view = getLayoutInflater().inflate(R.layout.list_item, parent, false);
+        } else {
+          view = convertView;
+        }
+        Map<String, Object> resultMap = getItem(position);
+        boolean isRecording = (boolean) resultMap.get(IS_RECORDING_FIELD);
+        boolean isPaused = (boolean) resultMap.get(IS_PAUSED_FIELD);
+        int iconId = (int) resultMap.get(ICON_ID_FIELD);
+        int iconContentDescriptionId = (int) resultMap.get(ICON_CONTENT_DESCRIPTION_ID_FIELD);
+        String name = (String) resultMap.get(NAME_FIELD);
+        String totalTime = (String) resultMap.get(TOTAL_TIME_FIELD);
+        String totalDistance = (String) resultMap.get(TOTAL_DISTANCE_FIELD);
+        int markerCount = (int) resultMap.get(MARKER_COUNT_FIELD);
+        long startTime = (long) resultMap.get(START_TIME_FIELD);
+        String category = (String) resultMap.get(CATEGORY_FIELD);
+        String description = (String) resultMap.get(DESCRIPTION_FIELD);
+        String photoUrl = (String) resultMap.get(PHOTO_URL_FIELD);
+        
+        ListItemUtils.setListItem(SearchListActivity.this, view, isRecording, isPaused, iconId,
+            iconContentDescriptionId, name, totalTime, totalDistance, markerCount,
+            startTime, false, category, description, photoUrl);
+        return view;
+      }
+    };
+    // UI elements
+    ListView listView = findViewById(R.id.search_list);
+    listView.setAdapter(arrayAdapter);
+    listView.setEmptyView(findViewById(R.id.search_list_empty));
+    listView.setOnItemClickListener(new OnItemClickListener() {
+      @Override
+      public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
+        Map<String, Object> item = arrayAdapter.getItem(position);
+        Long trackId = (Long) item.get(TRACK_ID_FIELD);
+        Long markerId = (Long) item.get(MARKER_ID_FIELD);
+        Intent intent;
+        if (markerId != null) {
+          intent = IntentUtils.newIntent(SearchListActivity.this, TrackDetailActivity.class)
+                  .putExtra(TrackDetailActivity.EXTRA_MARKER_ID, markerId);
+        } else {
+          intent = IntentUtils.newIntent(SearchListActivity.this, TrackDetailActivity.class)
+                  .putExtra(TrackDetailActivity.EXTRA_TRACK_ID, trackId);
+        }
+        startActivity(intent);
+      }
+    });
+    AbstractTrackActivity.configureListViewContextualMenu(listView, contextualActionModeCallback);
+    handleIntent(getIntent());
+  }
+
+  @Override
+  protected void onStart() {
+    super.onStart();
+    sharedPreferences.registerOnSharedPreferenceChangeListener(sharedPreferenceChangeListener);
+    sharedPreferenceChangeListener.onSharedPreferenceChanged(null, null);
+    TrackRecordingServiceConnectionUtils.startConnection(this, trackRecordingServiceConnection);
+  }
+
+  @Override
+  protected void onResume() {
+    super.onResume();
+    arrayAdapter.notifyDataSetChanged();
+  }
+
+  @Override
+  protected void onStop() {
+    super.onStop();
+    sharedPreferences.unregisterOnSharedPreferenceChangeListener(sharedPreferenceChangeListener);
+    trackRecordingServiceConnection.unbind();
+  }
+
+  @Override
+  protected int getLayoutResId() {
+    return R.layout.search_list;
+  }
+
+  @Override
+  public void onNewIntent(Intent intent) {
+    setIntent(intent);
+    handleIntent(intent);
+  }
+
+  @Override
+  public boolean onCreateOptionsMenu(Menu menu) {
+    getMenuInflater().inflate(R.menu.search_list, menu);
+    menu.findItem(R.id.search_list_search).setVisible(false);
+    return super.onCreateOptionsMenu(menu);
+  }
+
+  @Override
+  public boolean onOptionsItemSelected(MenuItem item) {
+    if (item.getItemId() == R.id.search_list_search) {
+      return false;
+    }
+    return super.onOptionsItemSelected(item);
+  }
+
+  @Override
+  public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
+    super.onCreateContextMenu(menu, v, menuInfo);
+    getMenuInflater().inflate(R.menu.list_context_menu, menu);
+
+    AdapterContextMenuInfo info = (AdapterContextMenuInfo) menuInfo;
+    contextualActionModeCallback.onPrepare(menu, new int[] { info.position }, new long[] { info.id }, false);
+  }
+
+  @Override
+  public boolean onContextItemSelected(MenuItem item) {
+    AdapterContextMenuInfo info = (AdapterContextMenuInfo) item.getMenuInfo();
+    if (handleContextItem(item.getItemId(), new int[] {info.position})) {
+      return true;
+    }
+    return super.onContextItemSelected(item);
+  }
+
+  @Override
+  public boolean onKeyUp(int keyCode, KeyEvent event) {
+    if (keyCode == KeyEvent.KEYCODE_SEARCH) {
+      return true;
+    }
+    return super.onKeyUp(keyCode, event);
+  }
+
+  /**
+   * Handles a context item selection.
+   * 
+   * @param itemId the menu item id
+   * @param positions the positions of the selected rows
+   * @return true if handled.
+   */
+  private boolean handleContextItem(int itemId, int[] positions) {
+    if (positions.length != 1) {
+      return false;
+    }
+    Map<String, Object> item = arrayAdapter.getItem(positions[0]);
+    Long trackId = (Long) item.get(TRACK_ID_FIELD);
+    Long markerId = (Long) item.get(MARKER_ID_FIELD);
+    Intent intent;
+    switch (itemId) {
+      case R.id.list_context_menu_share:
+        //TODO
+        Log.e(TAG, "Not implemented");
+        return true;
+      case R.id.list_context_menu_show_on_map:
+        intent = IntentUtils.newShowOnMapIntent((double)item.get(MARKER_LATITUDE_FIELD), (double)item.get(MARKER_LONGITUDE_FIELD), item.get(NAME_FIELD) + "");
+        startActivity(intent);
+        return true;
+      case R.id.list_context_menu_edit:
+        if (markerId != null) {
+          intent = IntentUtils.newIntent(this, MarkerEditActivity.class)
+              .putExtra(MarkerEditActivity.EXTRA_MARKER_ID, markerId);
+        } else {
+          intent = IntentUtils.newIntent(this, TrackEditActivity.class)
+              .putExtra(TrackEditActivity.EXTRA_TRACK_ID, trackId);
+        }
+        startActivity(intent);
+
+        // Close the search result since its content can change after edit.
+        finish();
+        return true;
+      case R.id.list_context_menu_delete:
+        if (markerId != null) {
+          DeleteMarkerDialogFragment.newInstance(new long[] { markerId }).show(getSupportFragmentManager(), DeleteMarkerDialogFragment.DELETE_MARKER_DIALOG_TAG);
+        } else {
+          deleteTracks(new long[] { trackId });
+        }
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  /**
+   * Handles the intent.
+   * 
+   * @param intent the intent
+   */
+  private void handleIntent(Intent intent) {
+    if (!Intent.ACTION_SEARCH.equals(intent.getAction())) {
+      Log.e(TAG, "Invalid intent action: " + intent);
+      finish();
+      return;
+    }
+
+    final String textQuery = intent.getStringExtra(SearchManager.QUERY);
+    setTitle(textQuery);
+
+    doSearch(textQuery);
+  }
+
+  /**
+   * Do the search.
+   * 
+   * @param textQuery the query
+   */
+  private void doSearch(String textQuery) {
+    SearchQuery query = new SearchQuery(textQuery, null, -1L, System.currentTimeMillis());
+    SortedSet<ScoredResult> scoredResults = searchEngine.search(query);
+    final List<Map<String, Object>> displayResults = prepareResultsforDisplay(scoredResults);
+
+    // Use the UI thread to display the results
+    runOnUiThread(new Runnable() {
+        @Override
+      public void run() {
+        arrayAdapter.clear();
+        arrayAdapter.addAll(displayResults);
+      }
+    });
+
+    // Save the query as a suggestion for the future
+    searchRecentSuggestions.saveRecentQuery(query.textQuery, null);
+  }
+
+  /**
+   * Prepares the result for display.
+   * 
+   * @param scoredResults a list of score results
+   * @return a list of result maps
+   */
+  private List<Map<String, Object>> prepareResultsforDisplay(Collection<ScoredResult> scoredResults) {
+    //TODO Replace use of map<string, object>, but rather provide Track or Waypoint directly.
+    ArrayList<Map<String, Object>> output = new ArrayList<>(scoredResults.size());
+    for (ScoredResult result : scoredResults) {
+      Map<String, Object> resultMap = new HashMap<>();
+      if (result.track != null) {
+        prepareTrackForDisplay(result.track, resultMap);
+      } else {
+        prepareMarkerForDisplay(result.waypoint, resultMap);
+      }
+      output.add(resultMap);
+    }
+    return output;
+  }
+
+  /**
+   * Prepares a marker for display by filling in a result map.
+   * 
+   * @param waypoint the marker
+   * @param resultMap the result map
+   */
+  @Deprecated
+  private void prepareMarkerForDisplay(Waypoint waypoint, Map<String, Object> resultMap) {
+    /*
+     * TODO: It may be more appropriate to obtain the track name as a join in
+     * the retrieval phase of the search.
+     */
+    String trackName = null;
+    long trackId = waypoint.getTrackId();
+    if (trackId != -1L) {
+      Track track = myTracksProviderUtils.getTrack(trackId);
+      if (track != null) {
+        trackName = track.getName();
+      }
+    }
+
+    boolean statistics = waypoint.getType() == WaypointType.STATISTICS;
+
+    resultMap.put(IS_RECORDING_FIELD, false);
+    resultMap.put(IS_PAUSED_FIELD, true);
+    resultMap.put(ICON_ID_FIELD, statistics ? R.drawable.ic_marker_yellow_pushpin : R.drawable.ic_marker_blue_pushpin);
+    resultMap.put(ICON_CONTENT_DESCRIPTION_ID_FIELD, R.string.image_marker);
+    resultMap.put(NAME_FIELD, waypoint.getName());
+    // Display the marker's track name in the total time field
+    resultMap.put(TOTAL_TIME_FIELD, trackName == null ? null : getString(R.string.search_list_marker_track_location, trackName));
+    resultMap.put(TOTAL_DISTANCE_FIELD, null);
+    resultMap.put(MARKER_COUNT_FIELD, 0);
+    resultMap.put(START_TIME_FIELD, waypoint.getLocation().getTime());
+    resultMap.put(CATEGORY_FIELD, statistics ? null : waypoint.getCategory());
+    resultMap.put(DESCRIPTION_FIELD, statistics ? null : waypoint.getDescription());
+    resultMap.put(PHOTO_URL_FIELD, waypoint.getPhotoUrl());
+    resultMap.put(TRACK_ID_FIELD, waypoint.getTrackId());
+    resultMap.put(MARKER_ID_FIELD, waypoint.getId());
+
+    resultMap.put(MARKER_LATITUDE_FIELD, waypoint.getLocation().getLatitude());
+    resultMap.put(MARKER_LONGITUDE_FIELD, waypoint.getLocation().getLongitude());
+  }
+
+  /**
+   * Prepares a track for display by filling in a result map.
+   * 
+   * @param track the track
+   * @param resultMap the result map
+   */
+  @Deprecated
+  private void prepareTrackForDisplay(Track track, Map<String, Object> resultMap) {
+    TripStatistics tripStatitics = track.getTripStatistics();
+    String icon = track.getIcon();
+    String category = icon != null && !icon.equals("") ? null : track.getCategory();
+
+    resultMap.put(IS_RECORDING_FIELD, track.getId() == recordingTrackId);
+    resultMap.put(IS_PAUSED_FIELD, recordingTrackPaused);
+    resultMap.put(ICON_ID_FIELD, TrackIconUtils.getIconDrawable(icon));
+    resultMap.put(ICON_CONTENT_DESCRIPTION_ID_FIELD, R.string.image_track);
+    resultMap.put(NAME_FIELD, track.getName());
+    resultMap.put(TOTAL_TIME_FIELD, StringUtils.formatElapsedTime(tripStatitics.getTotalTime()));
+    resultMap.put(TOTAL_DISTANCE_FIELD, StringUtils.formatDistance(this, tripStatitics.getTotalDistance(), metricUnits));
+    resultMap.put(MARKER_COUNT_FIELD, myTracksProviderUtils.getWaypointCount(track.getId()));
+    resultMap.put(START_TIME_FIELD, tripStatitics.getStartTime());
+    resultMap.put(CATEGORY_FIELD, category);
+    resultMap.put(DESCRIPTION_FIELD, track.getDescription());
+    resultMap.put(PHOTO_URL_FIELD, null);
+    resultMap.put(TRACK_ID_FIELD, track.getId());
+    resultMap.put(MARKER_ID_FIELD, null);
+  }
+
+  @Override
+  public void onDeleteMarkerDone() {
+    runOnUiThread(new Runnable() {
+        @Override
+      public void run() {
+        handleIntent(getIntent());
+      }
+    });
+  }
+  
+  @Override
+  protected TrackRecordingServiceConnection getTrackRecordingServiceConnection() {
+    return trackRecordingServiceConnection;
+  }
+
+  @Override
+  protected void onDeleted() {
+    runOnUiThread(new Runnable() {
+        @Override
+      public void run() {
+        handleIntent(getIntent());
+      }
+    });
+  }
+}

src/main/java/com/google/android/apps/mytracks/TabsAdapter.java

@@ -0,0 +1,150 @@
+/*
+ * Copyright 2013q 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 com.google.android.apps.mytracks;
+
+import android.content.Context;
+import android.os.Bundle;
+import androidx.fragment.app.Fragment;
+import androidx.fragment.app.FragmentActivity;
+import androidx.fragment.app.FragmentPagerAdapter;
+import androidx.viewpager.widget.ViewPager;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.TabHost;
+import android.widget.TabHost.TabContentFactory;
+import android.widget.TabWidget;
+
+import java.util.ArrayList;
+
+/**
+ * This is a helper class that implements the management of tabs and all details
+ * of connecting a ViewPager with associated TabHost. It relies on a trick.
+ * Normally a tab host has a simple API for supplying a View or Intent that each
+ * tab will show. This is not sufficient for switching between pages. So instead
+ * we make the content part of the tab host 0dp high (it is not shown) and the
+ * TabsAdapter supplies its own dummy view to show as the tab content. It
+ * listens to changes in tabs, and takes care of switch to the correct paged in
+ * the ViewPager whenever the selected tab changes.
+ * <p>
+ * Copied from the FragmentTabsPager sample in the support library.
+ * 
+ * @author Jimmy Shih
+ */
+public class TabsAdapter extends FragmentPagerAdapter
+    implements TabHost.OnTabChangeListener, ViewPager.OnPageChangeListener {
+
+  private final Context context;
+  private final TabHost tabHost;
+  private final ViewPager viewPager;
+  private final ArrayList<TabInfo> tabInfos = new ArrayList<>();
+
+  /**
+   * An object to hold a tab's info.
+   * 
+   * @author Jimmy Shih
+   */
+  private static final class TabInfo {
+
+    private final Class<?> clss;
+    private final Bundle bundle;
+
+    public TabInfo(Class<?> clss, Bundle bunlde) {
+      this.clss = clss;
+      this.bundle = bunlde;
+    }
+  }
+
+  /**
+   * A dummy {@link TabContentFactory} that creates an empty view to satisfy the
+   * {@link TabHost} API.
+   * 
+   * @author Jimmy Shih
+   */
+  private static class DummyTabFactory implements TabHost.TabContentFactory {
+
+    private final Context context;
+
+    public DummyTabFactory(Context context) {
+      this.context = context;
+    }
+
+    @Override
+    public View createTabContent(String tag) {
+      View view = new View(context);
+      view.setMinimumWidth(0);
+      view.setMinimumHeight(0);
+      return view;
+    }
+  }
+
+  public TabsAdapter(FragmentActivity activity, TabHost tabHost, ViewPager viewPager) {
+    super(activity.getSupportFragmentManager());
+    this.context = activity;
+    this.tabHost = tabHost;
+    this.viewPager = viewPager;
+    this.tabHost.setOnTabChangedListener(this);
+    this.viewPager.setAdapter(this);
+    this.viewPager.setOnPageChangeListener(this);
+  }
+
+  public void addTab(TabHost.TabSpec tabSpec, Class<?> clss, Bundle bundle) {
+    tabSpec.setContent(new DummyTabFactory(context));
+
+    TabInfo info = new TabInfo(clss, bundle);
+    
+    tabInfos.add(info);
+    tabHost.addTab(tabSpec);
+    notifyDataSetChanged();
+  }
+
+  @Override
+  public int getCount() {
+    return tabInfos.size();
+  }
+
+  @Override
+  public Fragment getItem(int position) {
+    TabInfo info = tabInfos.get(position);
+    return Fragment.instantiate(context, info.clss.getName(), info.bundle);
+  }
+
+  @Override
+  public void onTabChanged(String tabId) {
+    int position = tabHost.getCurrentTab();
+    viewPager.setCurrentItem(position);
+  }
+
+  @Override
+  public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {}
+
+  @Override
+  public void onPageSelected(int position) {
+    /*
+     * Unfortunately when TabHost changes the current tab, it kindly also takes
+     * care of putting focus on it when not in touch mode. The jerk. This hack
+     * tries to prevent this from pulling focus out of our ViewPager.
+     */
+    TabWidget tabWidget = tabHost.getTabWidget();
+    int oldFocusability = tabWidget.getDescendantFocusability();
+    tabWidget.setDescendantFocusability(ViewGroup.FOCUS_BLOCK_DESCENDANTS);
+    tabHost.setCurrentTab(position);
+    tabWidget.setDescendantFocusability(oldFocusability);
+  }
+
+  @Override
+  public void onPageScrollStateChanged(int state) {}
+}

src/main/java/com/google/android/apps/mytracks/TrackController.java

@@ -0,0 +1,149 @@
+/*
+ * 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 com.google.android.apps.mytracks;
+
+import android.app.Activity;
+import android.os.Handler;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.ImageButton;
+import android.widget.TextView;
+
+import com.google.android.apps.mytracks.services.ITrackRecordingService;
+import com.google.android.apps.mytracks.services.TrackRecordingServiceConnection;
+import com.google.android.apps.mytracks.util.StringUtils;
+import com.google.android.apps.mytracks.util.UnitConversions;
+import com.google.android.maps.mytracks.R;
+
+/**
+ * Track controller for record, pause, resume, and stop.
+ * 
+ * @author Jimmy Shih
+ */
+public class TrackController {
+
+  private static final String TAG = TrackController.class.getSimpleName();
+
+  private final Activity activity;
+  private final TrackRecordingServiceConnection trackRecordingServiceConnection;
+  private final Handler handlerUpdateTotalTime;
+  private final View containerView;
+  private final TextView statusTextView;
+  private final TextView totalTimeTextView;
+  private final ImageButton recordImageButton;
+  private final ImageButton stopImageButton;
+  private final boolean alwaysShow;
+
+  private boolean isRecording;
+  private boolean isPaused;
+  private long totalTime = 0;
+
+  // the timestamp for the toal time
+  private long totalTimeTimestamp = 0;
+
+  private boolean isResumed = false;
+
+  // A runnable to update the total time.
+  private final Runnable updateTotalTimeRunnable = new Runnable() {
+    public void run() {
+      if (isResumed && isRecording && !isPaused) {
+        totalTimeTextView.setText(StringUtils.formatElapsedTimeWithHour(System.currentTimeMillis() - totalTimeTimestamp + totalTime));
+        handlerUpdateTotalTime.postDelayed(this, UnitConversions.ONE_SECOND);
+      }
+    }
+  };
+
+  public TrackController(Activity activity, TrackRecordingServiceConnection trackRecordingServiceConnection, boolean alwaysShow, OnClickListener recordListener, OnClickListener stopListener) {
+    this.activity = activity;
+    this.trackRecordingServiceConnection = trackRecordingServiceConnection;
+    this.alwaysShow = alwaysShow;
+    handlerUpdateTotalTime = new Handler();
+    containerView = activity.findViewById(R.id.track_controller_container);
+    statusTextView = activity.findViewById(R.id.track_controller_status);
+    totalTimeTextView = activity.findViewById(R.id.track_controller_total_time);
+
+    recordImageButton = activity.findViewById(R.id.track_controller_record);
+    recordImageButton.setOnClickListener(recordListener);
+
+    stopImageButton = activity.findViewById(R.id.track_controller_stop);
+    stopImageButton.setOnClickListener(stopListener);
+  }
+
+  public void update(boolean recording, boolean paused) {
+    if (!isResumed) {
+      return;
+    }
+    isRecording = recording;
+    isPaused = paused;
+    boolean visible = alwaysShow || isRecording;
+    containerView.setVisibility(visible ? View.VISIBLE : View.GONE);
+
+    if (!visible) {
+      handlerUpdateTotalTime.removeCallbacks(updateTotalTimeRunnable);
+      return;
+    }
+
+    recordImageButton.setImageResource(isRecording && !isPaused ? R.drawable.button_pause : R.drawable.button_record);
+    recordImageButton.setContentDescription(activity.getString(isRecording && !isPaused ? R.string.image_pause : R.string.image_record));
+
+    stopImageButton.setImageResource(isRecording ? R.drawable.button_stop : R.drawable.ic_button_stop_disabled);
+    stopImageButton.setEnabled(isRecording);
+
+    statusTextView.setVisibility(isRecording ? View.VISIBLE : View.INVISIBLE);
+    if (isRecording) {
+      statusTextView.setTextColor(activity.getResources().getColor(isPaused ? android.R.color.white : R.color.recording_text));
+      statusTextView.setText(isPaused ? R.string.generic_paused : R.string.generic_recording);
+    }
+
+    handlerUpdateTotalTime.removeCallbacks(updateTotalTimeRunnable);
+    totalTimeTextView.setVisibility(isRecording ? View.VISIBLE : View.INVISIBLE);
+    if (isRecording) {
+      totalTime = getTotalTime();
+      totalTimeTextView.setText(StringUtils.formatElapsedTimeWithHour(totalTime));
+      if (!isPaused) {
+        totalTimeTimestamp = System.currentTimeMillis();
+        handlerUpdateTotalTime.postDelayed(updateTotalTimeRunnable, UnitConversions.ONE_SECOND);
+      }
+    }
+  }
+
+  public void onResume(boolean recording, boolean paused) {
+    isResumed = true;
+    update(recording, paused);
+  }
+
+  public void onPause() {
+    isResumed = false;
+    handlerUpdateTotalTime.removeCallbacks(updateTotalTimeRunnable);
+  }
+
+  public void hide() {
+    containerView.setVisibility(View.GONE);
+  }
+
+  public void show() {
+    containerView.setVisibility(View.VISIBLE);
+  }
+
+  /**
+   * Gets the total time for the current recording track.
+   */
+  private long getTotalTime() {
+    ITrackRecordingService trackRecordingService = trackRecordingServiceConnection.getServiceIfBound();
+    return trackRecordingService != null ? trackRecordingService.getTotalTime() : 0L;
+  }
+}

src/main/java/com/google/android/apps/mytracks/TrackDetailActivity.java

@@ -0,0 +1,521 @@
+/*
+ * 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 com.google.android.apps.mytracks;
+
+import android.Manifest;
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
+import android.content.pm.PackageManager;
+import android.net.Uri;
+import android.os.Bundle;
+import android.provider.MediaStore;
+import android.util.Log;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.ShareActionProvider;
+import android.widget.TabHost;
+import android.widget.TabHost.TabSpec;
+import android.widget.Toast;
+
+import androidx.annotation.NonNull;
+import androidx.core.app.ActivityCompat;
+import androidx.core.app.TaskStackBuilder;
+import androidx.core.content.FileProvider;
+import androidx.viewpager.widget.ViewPager;
+
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils;
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.content.TrackDataHub;
+import com.google.android.apps.mytracks.content.Waypoint;
+import com.google.android.apps.mytracks.content.Waypoint.WaypointType;
+import com.google.android.apps.mytracks.content.WaypointCreationRequest;
+import com.google.android.apps.mytracks.fragments.ChartFragment;
+import com.google.android.apps.mytracks.fragments.ChooseActivityTypeDialogFragment;
+import com.google.android.apps.mytracks.fragments.ChooseActivityTypeDialogFragment.ChooseActivityTypeCaller;
+import com.google.android.apps.mytracks.fragments.ConfirmDeleteDialogFragment;
+import com.google.android.apps.mytracks.fragments.FrequencyDialogFragment;
+import com.google.android.apps.mytracks.fragments.StatsFragment;
+import com.google.android.apps.mytracks.io.file.TrackFileFormat;
+import com.google.android.apps.mytracks.services.TrackRecordingServiceConnection;
+import com.google.android.apps.mytracks.settings.SettingsActivity;
+import com.google.android.apps.mytracks.util.FileUtils;
+import com.google.android.apps.mytracks.util.IntentUtils;
+import com.google.android.apps.mytracks.util.PreferencesUtils;
+import com.google.android.apps.mytracks.util.TrackIconUtils;
+import com.google.android.apps.mytracks.util.TrackRecordingServiceConnectionUtils;
+import com.google.android.apps.mytracks.util.TrackUtils;
+import com.google.android.maps.mytracks.R;
+
+import java.io.File;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+/**
+ * An activity to show the track detail.
+ * 
+ * @author Leif Hendrik Wilden
+ * @author Rodrigo Damazio
+ */
+public class TrackDetailActivity extends AbstractTrackActivity
+        implements ChooseActivityTypeCaller, ConfirmDeleteDialogFragment.ConfirmDeleteCaller {
+
+  private static final String TAG = TrackDetailActivity.class.getSimpleName();
+
+  public static final String EXTRA_TRACK_ID = "track_id";
+  public static final String EXTRA_MARKER_ID = "marker_id";
+
+  private static final String CURRENT_TAB_TAG_KEY = "current_tab_tag_key";
+  private static final String PHOTO_URI_KEY = "photo_uri_key";
+  private static final String HAS_PHOTO_KEY = "has_photo_key";
+  private static final String JPEG_EXTENSION = "jpeg";
+
+  private static final int CAMERA_REQUEST_CODE = 5;
+  private static final int EXTERNAL_STORAGE_PERMISSION_REQUEST_CODE = 6;
+
+  // The following are set in onCreate
+  private boolean hasCamera;
+  private Uri photoUri;
+  private boolean hasPhoto;
+  private MyTracksProviderUtils myTracksProviderUtils;
+  private SharedPreferences sharedPreferences;
+  private TrackRecordingServiceConnection trackRecordingServiceConnection;
+  private TrackDataHub trackDataHub;
+  private TabHost tabHost;
+  private TrackController trackController;
+
+  // From intent
+  private long trackId;
+
+  // Preferences
+  private long recordingTrackId = PreferencesUtils.RECORDING_TRACK_ID_DEFAULT;
+  private boolean recordingTrackPaused = PreferencesUtils.RECORDING_TRACK_PAUSED_DEFAULT;
+
+  private MenuItem insertMarkerMenuItem;
+  private MenuItem insertPhotoMenuItem;
+  private MenuItem markerListMenuItem;
+  private MenuItem shareMenuItem;
+  private MenuItem voiceFrequencyMenuItem;
+  private MenuItem splitFrequencyMenuItem;
+
+  private final Runnable bindChangedCallback = new Runnable() {
+      @Override
+    public void run() {
+      // After binding changes (is available), update the total time in
+      // trackController.
+      runOnUiThread(new Runnable() {
+          @Override
+        public void run() {
+          trackController.update(isRecording(), recordingTrackPaused);
+          if (hasPhoto && photoUri != null) {
+            hasPhoto = false;
+            WaypointCreationRequest waypointCreationRequest = new WaypointCreationRequest(WaypointType.WAYPOINT, false, null, null, null, null, photoUri.toString());
+            long markerId = TrackRecordingServiceConnectionUtils.addMarker(TrackDetailActivity.this, trackRecordingServiceConnection, waypointCreationRequest);
+            if (markerId != -1L) {
+              FileUtils.updateMediaScanner(TrackDetailActivity.this, photoUri);
+            }
+          }
+        }
+      });
+    }
+  };
+
+  /*
+   * Note that sharedPreferenceChangeListener cannot be an anonymous inner
+   * class. Anonymous inner class will get garbage collected.
+   */
+  private final OnSharedPreferenceChangeListener
+      sharedPreferenceChangeListener = new OnSharedPreferenceChangeListener() {
+          @Override
+        public void onSharedPreferenceChanged(SharedPreferences preferences, String key) {
+          if (key == null || key.equals(PreferencesUtils.getKey(TrackDetailActivity.this, R.string.recording_track_id_key))) {
+            recordingTrackId = PreferencesUtils.getLong(TrackDetailActivity.this, R.string.recording_track_id_key);
+          }
+
+          if (key == null || key.equals(PreferencesUtils.getKey(TrackDetailActivity.this, R.string.recording_track_paused_key))) {
+            recordingTrackPaused = PreferencesUtils.getBoolean(TrackDetailActivity.this, R.string.recording_track_paused_key, PreferencesUtils.RECORDING_TRACK_PAUSED_DEFAULT);
+          }
+
+          if (key == null) return;
+
+          runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+              TrackDetailActivity.this.invalidateOptionsMenu();
+              boolean isRecording = isRecording();
+              trackController.update(isRecording, recordingTrackPaused);
+            }
+          });
+        }
+      };
+
+  private final OnClickListener recordListener = new OnClickListener() {
+      @Override
+    public void onClick(View v) {
+      if (recordingTrackPaused) {
+        // Paused -> Resume
+        updateMenuItems(false);
+        TrackRecordingServiceConnectionUtils.resumeTrack(trackRecordingServiceConnection);
+        trackController.update(true, false);
+      } else {
+        // Recording -> Paused
+        updateMenuItems(true);
+        TrackRecordingServiceConnectionUtils.pauseTrack(trackRecordingServiceConnection);
+        trackController.update(true, true);
+      }
+    }
+  };
+
+  private final OnClickListener stopListener = new OnClickListener() {
+      @Override
+    public void onClick(View v) {
+      TrackRecordingServiceConnectionUtils.stopRecording(TrackDetailActivity.this, trackRecordingServiceConnection, true);
+        updateMenuItems(true);
+    }
+  };
+
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    hasCamera = getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA);
+    photoUri = savedInstanceState != null ? (Uri) savedInstanceState.getParcelable(PHOTO_URI_KEY) : null;
+    hasPhoto = savedInstanceState != null && savedInstanceState.getBoolean(HAS_PHOTO_KEY, false);
+       
+    myTracksProviderUtils = MyTracksProviderUtils.Factory.get(this);
+    handleIntent(getIntent());
+
+    sharedPreferences = getSharedPreferences(Constants.SETTINGS_NAME, Context.MODE_PRIVATE);
+
+    trackRecordingServiceConnection = new TrackRecordingServiceConnection(this, bindChangedCallback);
+    trackDataHub = TrackDataHub.newInstance(this);
+
+    tabHost = findViewById(android.R.id.tabhost);
+    tabHost.setup();
+
+    ViewPager viewPager = findViewById(R.id.pager);
+    TabsAdapter tabsAdapter = new TabsAdapter(this, tabHost, viewPager);
+
+    TabSpec statsTabSpec = tabHost.newTabSpec(StatsFragment.STATS_FRAGMENT_TAG).setIndicator(getString(R.string.track_detail_stats_tab), getResources().getDrawable(R.drawable.ic_tab_stats));
+    tabsAdapter.addTab(statsTabSpec, StatsFragment.class, null);
+
+    TabSpec chartTabSpec = tabHost.newTabSpec(ChartFragment.CHART_FRAGMENT_TAG).setIndicator(getString(R.string.track_detail_chart_tab),getResources().getDrawable(R.drawable.ic_tab_chart));
+    tabsAdapter.addTab(chartTabSpec, ChartFragment.class, null);
+
+    if (savedInstanceState != null) {
+      tabHost.setCurrentTabByTag(savedInstanceState.getString(CURRENT_TAB_TAG_KEY));
+    }
+    
+    // Set the background after all three tabs are added
+    for (int i = 0; i < tabHost.getTabWidget().getChildCount(); i++) {
+      tabHost.getTabWidget().getChildAt(i).setBackgroundResource(R.drawable.tab_indicator_mytracks);
+    }
+
+    trackController = new TrackController(this, trackRecordingServiceConnection, false, recordListener, stopListener);
+  }
+
+  @Override
+  protected void onStart() {
+    super.onStart();
+
+    sharedPreferences.registerOnSharedPreferenceChangeListener(sharedPreferenceChangeListener);
+    sharedPreferenceChangeListener.onSharedPreferenceChanged(null, null);
+
+    TrackRecordingServiceConnectionUtils.startConnection(this, trackRecordingServiceConnection);
+    trackDataHub.start();
+  }
+
+  @Override
+  protected void onResume() {
+    super.onResume();
+    trackDataHub.loadTrack(trackId);
+
+    // Update UI
+    this.invalidateOptionsMenu();
+    trackController.onResume(isRecording(), recordingTrackPaused);
+  }
+
+  @Override
+  protected void onPause() {
+    super.onPause();
+    trackController.onPause();
+  }
+
+  @Override
+  protected void onStop() {
+    super.onStop();
+    sharedPreferences.unregisterOnSharedPreferenceChangeListener(sharedPreferenceChangeListener);
+    trackRecordingServiceConnection.unbind();
+    trackDataHub.stop();
+  }
+
+  @Override
+  protected void onSaveInstanceState(Bundle outState) {
+    super.onSaveInstanceState(outState);
+    outState.putString(CURRENT_TAB_TAG_KEY, tabHost.getCurrentTabTag());
+    if (photoUri != null) {
+      outState.putParcelable(PHOTO_URI_KEY, photoUri);
+    }
+    outState.putBoolean(HAS_PHOTO_KEY, hasPhoto);
+  }
+
+  @Override
+  protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+    if (requestCode == CAMERA_REQUEST_CODE) {
+      if (resultCode == RESULT_CANCELED) {
+        Toast.makeText(this, R.string.marker_add_canceled, Toast.LENGTH_LONG).show();
+        return;
+      }
+      hasPhoto = resultCode == RESULT_OK;
+
+      if (hasPhoto) {
+        //Register photo in media scanner
+        Intent mediaScanIntent = new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE);
+        mediaScanIntent.setData(photoUri);
+        this.sendBroadcast(mediaScanIntent);
+        return;
+      }
+    }
+    super.onActivityResult(requestCode, resultCode, data);
+  }
+
+  @Override
+  protected int getLayoutResId() {
+    return R.layout.track_detail;
+  }
+
+  @Override
+  protected void onHomeSelected() {
+    /*
+     * TODO: Investigate
+     * According to
+     * http://developer.android.com/training/implementing-navigation
+     * /ancestral.html, we should use NavUtils.shouldUpRecreateTask instead of
+     * always creating a new back stack. However, NavUtils.shouldUpRecreateTask
+     * seems to always return false.
+     */
+    TaskStackBuilder.create(this).addParentStack(TrackDetailActivity.class).startActivities();
+    finish();
+  }
+
+  @Override
+  public void onNewIntent(Intent intent) {
+    setIntent(intent);
+    handleIntent(intent);
+  }
+
+  @Override
+  public boolean onCreateOptionsMenu(Menu menu) {
+    getMenuInflater().inflate(R.menu.track_detail, menu);
+
+    insertMarkerMenuItem = menu.findItem(R.id.track_detail_insert_marker);
+    insertPhotoMenuItem = menu.findItem(R.id.track_detail_insert_photo);
+    insertPhotoMenuItem.setVisible(new Intent(MediaStore.ACTION_IMAGE_CAPTURE).resolveActivity(getPackageManager()) != null);
+
+    shareMenuItem = menu.findItem(R.id.track_detail_share);
+    ShareActionProvider shareActionProvider = (ShareActionProvider) shareMenuItem.getActionProvider();
+    //TODO: Share the actual track when track is finished? How to get the file path or create a new file?
+    shareActionProvider.setShareIntent(IntentUtils.newShareFileIntent(this, trackId, "", TrackFileFormat.KML));
+
+    voiceFrequencyMenuItem = menu.findItem(R.id.track_detail_voice_frequency);
+    splitFrequencyMenuItem = menu.findItem(R.id.track_detail_split_frequency);
+    markerListMenuItem = menu.findItem(R.id.track_detail_markers);
+
+    return super.onCreateOptionsMenu(menu);
+  }
+
+  @Override
+  public boolean onPrepareOptionsMenu(Menu menu) {
+    updateMenuItems(recordingTrackPaused);
+    return super.onPrepareOptionsMenu(menu);
+  }
+
+  @Override
+  public boolean onOptionsItemSelected(MenuItem item) {
+    Intent intent;
+    switch (item.getItemId()) {
+      case R.id.track_detail_insert_marker:
+        intent = IntentUtils
+                .newIntent(this, MarkerEditActivity.class)
+                .putExtra(MarkerEditActivity.EXTRA_TRACK_ID, trackId);
+        startActivity(intent);
+        return true;
+      case R.id.track_detail_insert_photo:
+        if (!FileUtils.isExternalStorageWriteable() || ActivityCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_DENIED) {
+          ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, EXTERNAL_STORAGE_PERMISSION_REQUEST_CODE);
+          return false;
+        }
+        takePicture();
+        return true;
+      case R.id.track_detail_markers:
+        intent = IntentUtils.newIntent(this, MarkerListActivity.class)
+            .putExtra(MarkerListActivity.EXTRA_TRACK_ID, trackId);
+        startActivity(intent);
+        return true;
+      case R.id.track_detail_voice_frequency:
+        FrequencyDialogFragment.newInstance(R.string.voice_frequency_key, PreferencesUtils.VOICE_FREQUENCY_DEFAULT, R.string.menu_voice_frequency)
+            .show(getSupportFragmentManager(), FrequencyDialogFragment.FREQUENCY_DIALOG_TAG);
+        return true;
+      case R.id.track_detail_split_frequency:
+        FrequencyDialogFragment.newInstance(R.string.split_frequency_key, PreferencesUtils.SPLIT_FREQUENCY_DEFAULT, R.string.menu_split_frequency)
+            .show(getSupportFragmentManager(), FrequencyDialogFragment.FREQUENCY_DIALOG_TAG);
+        return true;
+      case R.id.track_detail_edit:
+        intent = IntentUtils.newIntent(this, TrackEditActivity.class)
+            .putExtra(TrackEditActivity.EXTRA_TRACK_ID, trackId);
+        startActivity(intent);
+        return true;
+      case R.id.track_detail_delete:
+        deleteTracks(new long[] { trackId });
+        return true;
+      case R.id.track_detail_settings:
+        intent = IntentUtils.newIntent(this, SettingsActivity.class);
+        startActivity(intent);
+        return true;
+      default:
+        return super.onOptionsItemSelected(item);
+    }
+  }
+
+  private void takePicture() {
+    File dir = FileUtils.getPhotoDir(trackId);
+    FileUtils.ensureDirectoryExists(dir);
+
+    String fileName = SimpleDateFormat.getDateTimeInstance().format(new Date());
+    File file = new File(dir, FileUtils.buildUniqueFileName(dir, fileName, JPEG_EXTENSION));
+
+    if (file != null) {
+      photoUri = FileProvider.getUriForFile(this, "com.google.android.apps.mytracks.fileprovider", file);
+      Log.d(TAG, "Taking photo to URI: " + photoUri);
+      Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE)
+              .putExtra(MediaStore.EXTRA_OUTPUT, photoUri);
+      startActivityForResult(intent, CAMERA_REQUEST_CODE);
+    }
+  }
+
+  @Override
+  public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
+    if (requestCode == EXTERNAL_STORAGE_PERMISSION_REQUEST_CODE) {
+      if (ActivityCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_DENIED) {
+        Toast.makeText(this, R.string.external_storage_not_writable, Toast.LENGTH_LONG).show();
+      } else {
+        this.takePicture();
+      }
+      return;
+    }
+    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
+  }
+
+  @Override
+  protected TrackRecordingServiceConnection getTrackRecordingServiceConnection() {
+    return trackRecordingServiceConnection;
+  }
+
+  @Override
+  protected void onDeleted() {
+    runOnUiThread(new Runnable() {
+        @Override
+      public void run() {
+        finish();
+      }
+    });
+  }
+
+  /**
+   * Gets the {@link TrackDataHub}.
+   */
+  public TrackDataHub getTrackDataHub() {
+    return trackDataHub;
+  }
+
+  /**
+   * Gets the track id.
+   */
+  public long getTrackId() {
+    return trackId;
+  }
+
+  /**
+   * Handles the data in the intent.
+   */
+  private void handleIntent(Intent intent) {
+    trackId = intent.getLongExtra(EXTRA_TRACK_ID, -1L);
+    long markerId = intent.getLongExtra(EXTRA_MARKER_ID, -1L);
+    if (markerId != -1L) {
+      // Use the trackId from the marker
+      Waypoint waypoint = myTracksProviderUtils.getWaypoint(markerId);
+      if (waypoint == null) {
+        finish();
+        return;
+      }
+      trackId = waypoint.getTrackId();
+    }
+    if (trackId == -1L) {
+      finish();
+      return;
+    }
+    Track track = myTracksProviderUtils.getTrack(trackId);
+    if (track == null) {
+      // Use the last track if markerId is not set
+      if (markerId == -1L) {
+        track = myTracksProviderUtils.getLastTrack();
+        if (track != null) {
+          trackId = track.getId();
+          return;
+        }
+      }
+      finish();
+    }
+  }
+
+  /**
+   * Updates the menu items.
+   */
+  private void updateMenuItems(boolean isPaused) {
+    insertMarkerMenuItem.setVisible(isRecording() && !isPaused);
+    insertPhotoMenuItem.setVisible(hasCamera && isRecording() && !isPaused);
+    shareMenuItem.setVisible(!isRecording());
+    markerListMenuItem.setShowAsAction(isRecording() ? MenuItem.SHOW_AS_ACTION_NEVER : MenuItem.SHOW_AS_ACTION_IF_ROOM);
+    voiceFrequencyMenuItem.setVisible(isRecording());
+    splitFrequencyMenuItem.setVisible(isRecording());
+    String title;
+    if (isRecording()) {
+      title = getString(isPaused ? R.string.generic_paused : R.string.generic_recording);
+    } else {
+      Track track = myTracksProviderUtils.getTrack(trackId);
+      title = track != null ? track.getName() : "";
+    }
+    setTitle(title);
+  }
+  
+  public void chooseActivityType(String category) {
+    ChooseActivityTypeDialogFragment.newInstance(category).show(getSupportFragmentManager(), ChooseActivityTypeDialogFragment.CHOOSE_ACTIVITY_TYPE_DIALOG_TAG);
+  }
+
+  @Override
+  public void onChooseActivityTypeDone(String iconValue) {
+    Track track = myTracksProviderUtils.getTrack(trackId);
+    String category = getString(TrackIconUtils.getIconActivityType(iconValue));
+    TrackUtils.updateTrack(this, track, null, category, null, myTracksProviderUtils);
+  }
+
+  private boolean isRecording() {
+    return trackId == recordingTrackId;
+  }
+}

src/main/java/com/google/android/apps/mytracks/TrackEditActivity.java

@@ -0,0 +1,208 @@
+/*
+ * 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 com.google.android.apps.mytracks;
+
+import android.os.Bundle;
+import android.util.Log;
+import android.view.KeyEvent;
+import android.view.MotionEvent;
+import android.view.View;
+import android.widget.AdapterView;
+import android.widget.ArrayAdapter;
+import android.widget.AutoCompleteTextView;
+import android.widget.Button;
+import android.widget.EditText;
+import android.widget.Spinner;
+
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils;
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.fragments.ChooseActivityTypeDialogFragment;
+import com.google.android.apps.mytracks.fragments.ChooseActivityTypeDialogFragment.ChooseActivityTypeCaller;
+import com.google.android.apps.mytracks.services.TrackRecordingServiceConnection;
+import com.google.android.apps.mytracks.util.TrackIconUtils;
+import com.google.android.apps.mytracks.util.TrackRecordingServiceConnectionUtils;
+import com.google.android.apps.mytracks.util.TrackUtils;
+import com.google.android.maps.mytracks.R;
+
+/**
+ * An activity that let's the user see and edit the user editable track meta
+ * data such as track name, activity type, and track description.
+ * 
+ * @author Leif Hendrik Wilden
+ */
+public class TrackEditActivity extends AbstractActivity implements ChooseActivityTypeCaller {
+
+  public static final String EXTRA_TRACK_ID = "track_id";
+  public static final String EXTRA_NEW_TRACK = "new_track";
+
+  private static final String TAG = TrackEditActivity.class.getSimpleName();
+  private static final String ICON_VALUE_KEY = "icon_value_key";
+
+  private TrackRecordingServiceConnection trackRecordingServiceConnection;
+  private MyTracksProviderUtils myTracksProviderUtils;
+  private Track track;
+  private String iconValue;
+
+  private EditText name;
+  private AutoCompleteTextView activityType;
+  private Spinner activityTypeIcon;
+  private EditText description;
+
+  @Override
+  protected void onCreate(Bundle bundle) {
+    super.onCreate(bundle);
+
+    trackRecordingServiceConnection = new TrackRecordingServiceConnection(this, null);
+    Long trackId = getIntent().getLongExtra(EXTRA_TRACK_ID, -1L);
+    if (trackId == -1L) {
+      Log.e(TAG, "invalid trackId");
+      finish();
+      return;
+    }
+
+    myTracksProviderUtils = MyTracksProviderUtils.Factory.get(this);
+    track = myTracksProviderUtils.getTrack(trackId);
+    if (track == null) {
+      Log.e(TAG, "No track for " + trackId);
+      finish();
+      return;
+    }
+
+    name = findViewById(R.id.track_edit_name);
+    name.setText(track.getName());
+
+    activityType = findViewById(R.id.track_edit_activity_type);
+    activityType.setText(track.getCategory());
+
+    ArrayAdapter<CharSequence> adapter = ArrayAdapter.createFromResource(
+        this, R.array.activity_types, android.R.layout.simple_dropdown_item_1line);
+    activityType.setAdapter(adapter);
+    activityType.setOnItemClickListener(new AdapterView.OnItemClickListener() {
+        @Override
+      public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
+        setActivityTypeIcon(TrackIconUtils.getIconValue(
+            TrackEditActivity.this, (String) activityType.getAdapter().getItem(position)));
+      }
+    });
+    activityType.setOnFocusChangeListener(new View.OnFocusChangeListener() {
+        @Override
+      public void onFocusChange(View v, boolean hasFocus) {
+        if (!hasFocus) {
+          setActivityTypeIcon(TrackIconUtils.getIconValue(
+              TrackEditActivity.this, activityType.getText().toString()));
+        }
+      }
+    });
+
+    iconValue = null;
+    if (bundle != null) {
+      iconValue = bundle.getString(ICON_VALUE_KEY);
+    }
+    if (iconValue == null) {
+      iconValue = track.getIcon();
+    }
+
+    activityTypeIcon = findViewById(R.id.track_edit_activity_type_icon);
+    activityTypeIcon.setAdapter(TrackIconUtils.getIconSpinnerAdapter(this, iconValue));
+    activityTypeIcon.setOnTouchListener(new View.OnTouchListener() {
+        @Override
+      public boolean onTouch(View v, MotionEvent event) {
+        if (event.getAction() == MotionEvent.ACTION_UP) {
+          ChooseActivityTypeDialogFragment.newInstance(activityType.getText().toString()).show(
+              getSupportFragmentManager(),
+              ChooseActivityTypeDialogFragment.CHOOSE_ACTIVITY_TYPE_DIALOG_TAG);
+        }
+        return true;
+      }
+    });
+    activityTypeIcon.setOnKeyListener(new View.OnKeyListener() {
+        @Override
+      public boolean onKey(View v, int keyCode, KeyEvent event) {
+        if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER) {
+          ChooseActivityTypeDialogFragment.newInstance(activityType.getText().toString()).show(
+              getSupportFragmentManager(),
+              ChooseActivityTypeDialogFragment.CHOOSE_ACTIVITY_TYPE_DIALOG_TAG);
+        }
+        return true;
+      }
+    });
+
+    description = findViewById(R.id.track_edit_description);
+    description.setText(track.getDescription());
+
+    Button save = findViewById(R.id.track_edit_save);
+    save.setOnClickListener(new View.OnClickListener() {
+        @Override
+      public void onClick(View v) {
+        TrackUtils.updateTrack(TrackEditActivity.this, track, name.getText().toString(),
+            activityType.getText().toString(), description.getText().toString(),
+            myTracksProviderUtils);
+        finish();
+      }
+    });
+
+    Button cancel = findViewById(R.id.track_edit_cancel);
+    if (getIntent().getBooleanExtra(EXTRA_NEW_TRACK, false)) {
+      setTitle(R.string.track_edit_new_track_title);
+      cancel.setVisibility(View.GONE);
+    } else {
+      setTitle(R.string.menu_edit);
+      cancel.setOnClickListener(new View.OnClickListener() {
+          @Override
+        public void onClick(View v) {
+          finish();
+        }
+      });
+      cancel.setVisibility(View.VISIBLE);
+    }
+  }
+
+
+  @Override
+  protected void onStart() {
+    super.onStart();
+    TrackRecordingServiceConnectionUtils.startConnection(this, trackRecordingServiceConnection);
+  }
+
+  @Override
+  protected void onStop() {
+    super.onStop();
+    trackRecordingServiceConnection.unbind();
+  }
+
+  @Override
+  public void onSaveInstanceState(Bundle outState) {
+    super.onSaveInstanceState(outState);
+    outState.putString(ICON_VALUE_KEY, iconValue);
+  }
+
+  @Override
+  protected int getLayoutResId() {
+    return R.layout.track_edit;
+  }
+
+  private void setActivityTypeIcon(String value) {
+    iconValue = value;
+    TrackIconUtils.setIconSpinner(activityTypeIcon, value);
+  }
+
+  @Override
+  public void onChooseActivityTypeDone(String value) {
+    setActivityTypeIcon(value);
+    activityType.setText(getString(TrackIconUtils.getIconActivityType(value)));
+  }
+}

src/main/java/com/google/android/apps/mytracks/TrackListActivity.java

@@ -0,0 +1,657 @@
+/*
+ * 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 com.google.android.apps.mytracks;
+
+import android.Manifest;
+import android.app.SearchManager;
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
+import android.content.pm.PackageManager;
+import android.database.Cursor;
+import android.location.LocationManager;
+import android.os.Bundle;
+import android.os.Parcelable;
+import android.os.StrictMode;
+import android.provider.Settings;
+import android.util.Log;
+import android.view.ContextMenu;
+import android.view.ContextMenu.ContextMenuInfo;
+import android.view.Gravity;
+import android.view.KeyEvent;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.AdapterView;
+import android.widget.AdapterView.AdapterContextMenuInfo;
+import android.widget.AdapterView.OnItemClickListener;
+import android.widget.ListView;
+import android.widget.SearchView;
+import android.widget.Toast;
+
+import androidx.annotation.NonNull;
+import androidx.core.app.ActivityCompat;
+import androidx.cursoradapter.widget.ResourceCursorAdapter;
+import androidx.loader.app.LoaderManager;
+import androidx.loader.app.LoaderManager.LoaderCallbacks;
+import androidx.loader.content.CursorLoader;
+import androidx.loader.content.Loader;
+
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils;
+import com.google.android.apps.mytracks.content.TracksColumns;
+import com.google.android.apps.mytracks.fragments.ConfirmDeleteDialogFragment;
+import com.google.android.apps.mytracks.fragments.FileTypeDialogFragment;
+import com.google.android.apps.mytracks.fragments.FileTypeDialogFragment.FileTypeCaller;
+import com.google.android.apps.mytracks.io.file.TrackFileFormat;
+import com.google.android.apps.mytracks.io.file.exporter.SaveActivity;
+import com.google.android.apps.mytracks.io.file.importer.ImportActivity;
+import com.google.android.apps.mytracks.services.ITrackRecordingService;
+import com.google.android.apps.mytracks.services.TrackRecordingServiceConnection;
+import com.google.android.apps.mytracks.settings.SettingsActivity;
+import com.google.android.apps.mytracks.util.IntentUtils;
+import com.google.android.apps.mytracks.util.ListItemUtils;
+import com.google.android.apps.mytracks.util.PreferencesUtils;
+import com.google.android.apps.mytracks.util.StringUtils;
+import com.google.android.apps.mytracks.util.TrackIconUtils;
+import com.google.android.apps.mytracks.util.TrackRecordingServiceConnectionUtils;
+import com.google.android.apps.mytracks.util.TrackUtils;
+import com.google.android.maps.mytracks.BuildConfig;
+import com.google.android.maps.mytracks.R;
+
+import java.util.Locale;
+
+/**
+ * An activity displaying a list of tracks.
+ * 
+ * @author Leif Hendrik Wilden
+ */
+public class TrackListActivity extends AbstractTrackActivity implements FileTypeCaller, ConfirmDeleteDialogFragment.ConfirmDeleteCaller {
+
+  private static final String TAG = TrackListActivity.class.getSimpleName();
+  private static final String[] PROJECTION = new String[] { TracksColumns._ID, TracksColumns.NAME,
+      TracksColumns.DESCRIPTION, TracksColumns.CATEGORY, TracksColumns.STARTTIME,
+      TracksColumns.TOTALDISTANCE, TracksColumns.TOTALTIME, TracksColumns.ICON };
+
+  // Callback when the trackRecordingServiceConnection binding changes.
+  private final Runnable bindChangedCallback = new Runnable() {
+      @Override
+    public void run() {
+      /*
+       * After binding changes (e.g., becomes available), update the total time
+       * in trackController.
+       */
+      runOnUiThread(new Runnable() {
+          @Override
+        public void run() {
+          trackController.update(recordingTrackId != PreferencesUtils.RECORDING_TRACK_ID_DEFAULT, recordingTrackPaused);
+        }
+      });
+
+      if (!startGps && !startNewRecording) {
+        return;
+      }
+
+      ITrackRecordingService service = trackRecordingServiceConnection.getServiceIfBound();
+      if (service == null) {
+        Log.d(TAG, "service not available to start gps or a new recording");
+        return;
+      }
+      if (startNewRecording) {
+        startGps = false;
+
+        long trackId = service.startNewTrack();
+        startNewRecording = false;
+        Intent intent = IntentUtils.newIntent(TrackListActivity.this, TrackDetailActivity.class)
+                .putExtra(TrackDetailActivity.EXTRA_TRACK_ID, trackId);
+        startActivity(intent);
+        Toast.makeText(
+                TrackListActivity.this, R.string.track_list_record_success, Toast.LENGTH_SHORT)
+                .show();
+      }
+      if (startGps) {
+        service.startGps();
+        startGps = false;
+      }
+    }
+  };
+
+  /*
+   * Note that sharedPreferenceChangeListenr cannot be an anonymous inner class.
+   * Anonymous inner class will get garbage collected.
+   */
+  private final OnSharedPreferenceChangeListener
+      sharedPreferenceChangeListener = new OnSharedPreferenceChangeListener() {
+          @Override
+        public void onSharedPreferenceChanged(SharedPreferences preferences, String key) {
+          if (key == null || key.equals(
+              PreferencesUtils.getKey(TrackListActivity.this, R.string.stats_units_key))) {
+            metricUnits = PreferencesUtils.isMetricUnits(TrackListActivity.this);
+          }
+          if (key == null || key.equals(
+              PreferencesUtils.getKey(TrackListActivity.this, R.string.recording_track_id_key))) {
+            recordingTrackId = PreferencesUtils.getLong(
+                TrackListActivity.this, R.string.recording_track_id_key);
+            if (key != null && recordingTrackId != PreferencesUtils.RECORDING_TRACK_ID_DEFAULT) {
+              trackRecordingServiceConnection.startAndBind();
+            }
+          }
+          if (key == null || key.equals(PreferencesUtils.getKey(
+              TrackListActivity.this, R.string.recording_track_paused_key))) {
+            recordingTrackPaused = PreferencesUtils.getBoolean(TrackListActivity.this,
+                R.string.recording_track_paused_key,
+                PreferencesUtils.RECORDING_TRACK_PAUSED_DEFAULT);
+          }
+          if (key != null) {
+            runOnUiThread(new Runnable() {
+                @Override
+              public void run() {
+                TrackListActivity.this.invalidateOptionsMenu();
+                LoaderManager.getInstance(TrackListActivity.this).restartLoader(0, null, loaderCallbacks);
+                boolean isRecording = recordingTrackId != PreferencesUtils.RECORDING_TRACK_ID_DEFAULT;
+                trackController.update(isRecording, recordingTrackPaused);
+              }
+            });
+          }
+        }
+      };
+
+  // Callback when an item is selected in the contextual action mode
+  private final ContextualActionModeCallback
+      contextualActionModeCallback = new ContextualActionModeCallback() {
+
+          @Override
+        public void onPrepare(Menu menu, int[] positions, long[] ids, boolean showSelectAll) {
+          boolean isRecording = recordingTrackId != PreferencesUtils.RECORDING_TRACK_ID_DEFAULT;
+          boolean isSingleSelection = ids.length == 1;
+
+          menu.findItem(R.id.list_context_menu_share).setVisible(!isRecording && isSingleSelection);
+          menu.findItem(R.id.list_context_menu_show_on_map).setVisible(false);
+          menu.findItem(R.id.list_context_menu_edit).setVisible(isSingleSelection);
+          menu.findItem(R.id.list_context_menu_select_all).setVisible(showSelectAll);
+        }
+
+          @Override
+        public boolean onClick(int itemId, int[] positions, long[] ids) {
+          return handleContextItem(itemId, ids);
+        }
+  };
+
+  private final OnClickListener recordListener = new OnClickListener() {
+    public void onClick(View v) {
+      if (recordingTrackId == PreferencesUtils.RECORDING_TRACK_ID_DEFAULT) {
+        // Not recording -> Recording
+        updateMenuItems(false, true);
+        startRecording();
+      } else {
+        if (recordingTrackPaused) {
+          // Paused -> Resume
+          updateMenuItems(false, true);
+          TrackRecordingServiceConnectionUtils.resumeTrack(trackRecordingServiceConnection);
+          trackController.update(true, false);
+        } else {
+          // Recording -> Paused
+          updateMenuItems(false, true);
+          TrackRecordingServiceConnectionUtils.pauseTrack(trackRecordingServiceConnection);
+          trackController.update(true, true);
+        }
+      }
+    }
+  };
+
+  private final OnClickListener stopListener = new OnClickListener() {
+      @Override
+    public void onClick(View v) {
+      updateMenuItems(false, false);
+      TrackRecordingServiceConnectionUtils.stopRecording(
+          TrackListActivity.this, trackRecordingServiceConnection, true);
+    }
+  };
+
+  private final LoaderCallbacks<Cursor> loaderCallbacks = new LoaderCallbacks<Cursor>() {
+      @Override
+    public Loader<Cursor> onCreateLoader(int arg0, Bundle arg1) {
+      return new CursorLoader(TrackListActivity.this, TracksColumns.CONTENT_URI, PROJECTION, null,
+          null, TrackUtils.TRACK_SORT_ORDER);
+    }
+
+      @Override
+    public void onLoadFinished(@NonNull Loader<Cursor> loader, Cursor cursor) {
+      resourceCursorAdapter.swapCursor(cursor);
+    }
+
+      @Override
+    public void onLoaderReset(@NonNull Loader<Cursor> loader) {
+      resourceCursorAdapter.swapCursor(null);
+    }
+  };
+  
+  // The following are set in onCreate
+  private MyTracksProviderUtils myTracksProviderUtils;
+  private SharedPreferences sharedPreferences;
+  private TrackRecordingServiceConnection trackRecordingServiceConnection;
+  private TrackController trackController;
+  private ListView listView;
+  private ResourceCursorAdapter resourceCursorAdapter;
+
+  // Preferences
+  private boolean metricUnits = true;
+  private long recordingTrackId = PreferencesUtils.RECORDING_TRACK_ID_DEFAULT;
+  private boolean recordingTrackPaused = PreferencesUtils.RECORDING_TRACK_PAUSED_DEFAULT;
+
+  // Menu items
+  private MenuItem searchMenuItem;
+  private MenuItem startGpsMenuItem;
+  private MenuItem aggregatedStatisticsMenuItem;
+  private MenuItem exportAllMenuItem;
+  private MenuItem importAllMenuItem;
+  private MenuItem deleteAllMenuItem;
+
+  private boolean startGps = false; // true to start gps
+  private boolean startNewRecording = false; // true to start a new recording
+
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+
+    if (BuildConfig.DEBUG) {
+      Log.d(TAG, "Enabling strict mode");
+      StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()
+              .detectAll()
+              .penaltyLog()
+              .build());
+      StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder()
+              .detectAll()
+              .penaltyLog()
+              .build());
+    }
+
+    myTracksProviderUtils = MyTracksProviderUtils.Factory.get(this);
+    sharedPreferences = getSharedPreferences(Constants.SETTINGS_NAME, Context.MODE_PRIVATE);
+
+    trackRecordingServiceConnection = new TrackRecordingServiceConnection(this, bindChangedCallback);
+    trackController = new TrackController(this, trackRecordingServiceConnection, true, recordListener, stopListener);
+
+    setDefaultKeyMode(DEFAULT_KEYS_SEARCH_LOCAL);
+    // Show trackController when search dialog is dismissed
+    SearchManager searchManager = (SearchManager) getSystemService(SEARCH_SERVICE);
+    searchManager.setOnDismissListener(new SearchManager.OnDismissListener() {
+        @Override
+      public void onDismiss() {
+        trackController.show();
+      }
+    });
+
+    listView = findViewById(R.id.track_list);
+    listView.setEmptyView(findViewById(R.id.track_list_empty_view));
+    listView.setOnItemClickListener(new OnItemClickListener() {
+        @Override
+      public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
+        Intent newIntent = IntentUtils.newIntent(TrackListActivity.this, TrackDetailActivity.class)
+            .putExtra(TrackDetailActivity.EXTRA_TRACK_ID, id);
+        startActivity(newIntent);
+      }
+    });
+    resourceCursorAdapter = new ResourceCursorAdapter(this, R.layout.list_item, null, 0) {
+        @Override
+      public void bindView(View view, Context context, Cursor cursor) {
+        int idIndex = cursor.getColumnIndex(TracksColumns._ID);
+        int iconIndex = cursor.getColumnIndex(TracksColumns.ICON);
+        int nameIndex = cursor.getColumnIndex(TracksColumns.NAME);
+        int totalTimeIndex = cursor.getColumnIndexOrThrow(TracksColumns.TOTALTIME);
+        int totalDistanceIndex = cursor.getColumnIndexOrThrow(TracksColumns.TOTALDISTANCE);
+        int startTimeIndex = cursor.getColumnIndexOrThrow(TracksColumns.STARTTIME);
+        int categoryIndex = cursor.getColumnIndex(TracksColumns.CATEGORY);
+        int descriptionIndex = cursor.getColumnIndex(TracksColumns.DESCRIPTION);
+
+        long trackId = cursor.getLong(idIndex);
+        boolean isRecording = trackId == recordingTrackId;
+        String icon = cursor.getString(iconIndex);
+        int iconId = TrackIconUtils.getIconDrawable(icon);
+        String name = cursor.getString(nameIndex);
+        String totalTime = StringUtils.formatElapsedTime(cursor.getLong(totalTimeIndex));
+        String totalDistance = StringUtils.formatDistance(TrackListActivity.this, cursor.getDouble(totalDistanceIndex), metricUnits);
+        int markerCount = myTracksProviderUtils.getWaypointCount(trackId);
+        long startTime = cursor.getLong(startTimeIndex);
+        String category = icon != null && !icon.equals("") ? null : cursor.getString(categoryIndex);
+        String description = cursor.getString(descriptionIndex);
+
+        ListItemUtils.setListItem(TrackListActivity.this, view, isRecording, recordingTrackPaused,
+            iconId, R.string.image_track, name, totalTime, totalDistance, markerCount,
+            startTime, true, category, description, null);
+      }
+    };
+    listView.setAdapter(resourceCursorAdapter);
+    AbstractTrackActivity.configureListViewContextualMenu(listView, contextualActionModeCallback);
+
+    LoaderManager.getInstance(this).initLoader(0, null, loaderCallbacks);
+    showStartupDialogs();
+  }
+
+  @Override
+  protected void onStart() {
+    super.onStart();
+
+    sharedPreferences.registerOnSharedPreferenceChangeListener(sharedPreferenceChangeListener);
+    sharedPreferenceChangeListener.onSharedPreferenceChanged(null, null);
+    TrackRecordingServiceConnectionUtils.startConnection(this, trackRecordingServiceConnection);
+  }
+
+  @Override
+  protected void onResume() {
+    super.onResume();
+    
+    // Update UI
+    this.invalidateOptionsMenu();
+    LoaderManager.getInstance(this).restartLoader(0, null, loaderCallbacks);
+    boolean isRecording = recordingTrackId != PreferencesUtils.RECORDING_TRACK_ID_DEFAULT;
+    trackController.onResume(isRecording, recordingTrackPaused);
+  }
+
+  @Override
+  protected void onPause() {
+    super.onPause();
+
+    // Update UI
+    trackController.onPause();
+  }
+
+  @Override
+  protected void onStop() {
+    super.onStop();
+
+    sharedPreferences.unregisterOnSharedPreferenceChangeListener(sharedPreferenceChangeListener);
+    trackRecordingServiceConnection.unbind();
+  }
+
+  @Override
+  public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
+    if (requestCode == GPS_REQUEST_CODE) {
+      if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
+        Toast.makeText(this, R.string.permission_gps_failed, Toast.LENGTH_SHORT).show();
+        finish();
+      }
+    }
+    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
+  }
+
+  @Override
+  protected int getLayoutResId() {
+    return R.layout.track_list;
+  }
+
+  @Override
+  protected boolean configureActionBarHomeAsUp() {
+    return false;
+  }
+
+  @Override
+  public boolean onCreateOptionsMenu(Menu menu) {
+    getMenuInflater().inflate(R.menu.track_list, menu);
+
+    searchMenuItem = menu.findItem(R.id.track_list_search);
+    AbstractTrackActivity.configureSearchWidget(this, searchMenuItem, trackController);
+
+    startGpsMenuItem = menu.findItem(R.id.track_list_start_gps);
+    aggregatedStatisticsMenuItem = menu.findItem(R.id.track_list_aggregated_statistics);
+    exportAllMenuItem = menu.findItem(R.id.track_list_export_all);
+    importAllMenuItem = menu.findItem(R.id.track_list_import_all);
+    deleteAllMenuItem = menu.findItem(R.id.track_list_delete_all);
+
+    return super.onCreateOptionsMenu(menu);
+  }
+  
+  @Override
+  public boolean onPrepareOptionsMenu(Menu menu) {
+    boolean isGpsStarted = TrackRecordingServiceConnectionUtils.isRecordingServiceRunning(this);
+    boolean isRecording = recordingTrackId != PreferencesUtils.RECORDING_TRACK_ID_DEFAULT;
+    updateMenuItems(isGpsStarted, isRecording);
+
+    View searchView = searchMenuItem.getActionView();
+    if (searchView instanceof SearchView) {
+      ((SearchView) searchView).setQuery("", false);
+    }
+    return super.onPrepareOptionsMenu(menu);
+  }
+  
+  @Override
+  public boolean onOptionsItemSelected(MenuItem item) {
+    Intent intent;
+    switch (item.getItemId()) {
+      case R.id.track_list_start_gps:
+        LocationManager locationManager = (LocationManager) this.getSystemService(Context.LOCATION_SERVICE);
+        if (!locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER)) {
+          intent = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS);
+          startActivity(intent);
+        } else {
+          startGps = !TrackRecordingServiceConnectionUtils.isRecordingServiceRunning(this);
+
+          // Show toast
+          Toast toast = Toast.makeText(this, startGps ? R.string.gps_starting : R.string.gps_stopping, Toast.LENGTH_SHORT);
+          toast.setGravity(Gravity.CENTER, 0, 0);
+          toast.show();
+
+          // Invoke trackRecordingService
+          if (startGps) {
+            trackRecordingServiceConnection.startAndBind();
+            bindChangedCallback.run();
+          } else {
+            ITrackRecordingService trackRecordingService = trackRecordingServiceConnection.getServiceIfBound();
+            if (trackRecordingService != null) {
+              trackRecordingService.stopGps();
+            }
+            trackRecordingServiceConnection.unbindAndStop();
+          }
+          
+          // Update menu after starting or stopping gps
+          this.invalidateOptionsMenu();
+        }
+        return true;
+      case R.id.track_list_markers:
+        intent = IntentUtils.newIntent(this, MarkerListActivity.class);
+        startActivity(intent);
+        return true;
+      case R.id.track_list_aggregated_statistics:
+        intent = IntentUtils.newIntent(this, AggregatedStatsActivity.class);
+        startActivity(intent);
+        return true;
+      case R.id.track_list_export_all:
+        FileTypeDialogFragment.newInstance(R.id.track_list_export_all,
+            R.string.export_all_title, R.string.export_all_option)
+            .show(getSupportFragmentManager(), FileTypeDialogFragment.FILE_TYPE_DIALOG_TAG);
+        return true;
+      case R.id.track_list_import_all:
+        FileTypeDialogFragment.newInstance(R.id.track_list_import_all,
+            R.string.import_selection_title, R.string.import_selection_option)
+            .show(getSupportFragmentManager(), FileTypeDialogFragment.FILE_TYPE_DIALOG_TAG);
+        return true;
+      case R.id.track_list_delete_all:
+        deleteTracks(new long[] {-1L});
+        return true;
+      case R.id.track_list_settings:
+        intent = IntentUtils.newIntent(this, SettingsActivity.class);
+        startActivity(intent);
+        return true;
+      default:
+        return super.onOptionsItemSelected(item);
+    }
+  }
+
+  @Override
+  public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
+    super.onCreateContextMenu(menu, v, menuInfo);
+    getMenuInflater().inflate(R.menu.list_context_menu, menu);
+
+    AdapterContextMenuInfo info = (AdapterContextMenuInfo) menuInfo;
+    contextualActionModeCallback.onPrepare(
+        menu, new int[] { info.position }, new long[] { info.id }, false);
+  }
+
+  @Override
+  public boolean onContextItemSelected(MenuItem item) {
+    AdapterContextMenuInfo info = (AdapterContextMenuInfo) item.getMenuInfo();
+    if (handleContextItem(item.getItemId(), new long[] { info.id })) {
+      return true;
+    }
+    return super.onContextItemSelected(item);
+  }
+
+  @Override
+  public boolean onKeyUp(int keyCode, KeyEvent event) {
+    if (keyCode == KeyEvent.KEYCODE_SEARCH && searchMenuItem != null) {
+     return true;
+    }
+    return super.onKeyUp(keyCode, event);
+  }
+
+  @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 onDeleted() {
+    // Do nothing
+  }
+
+  @Override
+  public void onFileTypeDone(int menuId, TrackFileFormat trackFileFormat) {
+    Intent intent;
+    switch (menuId) {
+      case R.id.track_list_export_all:
+        intent = IntentUtils.newIntent(this, SaveActivity.class)
+            .putExtra(SaveActivity.EXTRA_TRACK_IDS, new long[] {-1L})   
+            .putExtra(SaveActivity.EXTRA_TRACK_FILE_FORMAT, (Parcelable) trackFileFormat);
+        startActivity(intent);
+        break;
+      case R.id.track_list_import_all:
+        intent = IntentUtils.newIntent(this, ImportActivity.class)
+            .putExtra(ImportActivity.EXTRA_IMPORT_ALL, true)
+            .putExtra(ImportActivity.EXTRA_TRACK_FILE_FORMAT, (Parcelable) trackFileFormat);
+        startActivity(intent);
+        break;
+      default:
+    }
+  }
+
+  /**
+   * Shows start up dialogs.
+   */
+  public void showStartupDialogs() {
+    // If stats_units_key is undefined, set it
+    if (PreferencesUtils.getString(this, R.string.stats_units_key, "").equals("")) {
+      String statsUnits = getString(Locale.US.equals(Locale.getDefault()) ? R.string.stats_units_imperial : R.string.stats_units_metric);
+      PreferencesUtils.setString(this, R.string.stats_units_key, statsUnits);
+    }
+
+    requestGPSPermissions();
+  }
+
+  private void requestGPSPermissions() {
+    if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
+      ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.ACCESS_COARSE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION}, GPS_REQUEST_CODE);
+    }
+  }
+
+  /**
+   * Updates the menu items.
+   * 
+   * @param isGpsStarted true if gps is started
+   * @param isRecording true if recording
+   */
+  private void updateMenuItems(boolean isGpsStarted, boolean isRecording) {
+    boolean hasTrack = listView != null && listView.getCount() != 0;
+    if (startGpsMenuItem != null) {
+      startGpsMenuItem.setVisible(!isRecording);
+      if (!isRecording) {
+        startGpsMenuItem.setTitle(isGpsStarted ? R.string.menu_stop_gps : R.string.menu_start_gps);
+        startGpsMenuItem.setIcon(isGpsStarted ? R.drawable.ic_menu_stop_gps : R.drawable.ic_menu_start_gps);
+        TrackIconUtils.setMenuIconColor(startGpsMenuItem);        
+      }
+    }
+    if (aggregatedStatisticsMenuItem != null) {
+      aggregatedStatisticsMenuItem.setVisible(hasTrack);
+    }
+    if (exportAllMenuItem != null) {
+      exportAllMenuItem.setVisible(hasTrack && !isRecording);
+    }
+    if (importAllMenuItem != null) {
+      importAllMenuItem.setVisible(!isRecording);
+    }
+    if (deleteAllMenuItem != null) {
+      deleteAllMenuItem.setVisible(hasTrack && !isRecording);
+    }
+  }
+  
+  /**
+   * Starts a new recording.
+   */
+  private void startRecording() {
+    startNewRecording = true;
+    trackRecordingServiceConnection.startAndBind();
+
+    /*
+     * If the binding has happened, then invoke the callback to start a new
+     * recording. If the binding hasn't happened, then invoking the callback
+     * will have no effect. But when the binding occurs, the callback will get
+     * invoked.
+     */
+    bindChangedCallback.run();
+  }
+
+  /**
+   * Handles a context item selection.
+   * 
+   * @param itemId the menu item id
+   * @param trackIds the track ids
+   * @return true if handled.
+   */
+  private boolean handleContextItem(int itemId, long[] trackIds) {
+    switch (itemId) {
+      case R.id.list_context_menu_share:
+        //TODO
+        Log.e(TAG, "Not implemented");
+        return true;
+      case R.id.list_context_menu_edit:
+        Intent intent = IntentUtils.newIntent(this, TrackEditActivity.class)
+            .putExtra(TrackEditActivity.EXTRA_TRACK_ID, trackIds[0]);
+        startActivity(intent);
+        return true;
+      case R.id.list_context_menu_delete:
+        if (trackIds.length > 1 && trackIds.length == listView.getCount()) {
+          trackIds = new long[] {-1L};
+        }
+        deleteTracks(trackIds);
+        return true;
+      case R.id.list_context_menu_select_all:
+        int size = listView.getCount();
+        for (int i = 0; i < size; i++) {
+          listView.setItemChecked(i, true);
+        }
+        return false;
+    }
+    return false;
+  }
+}

src/main/java/com/google/android/apps/mytracks/content/ContentTypeIds.java

@@ -0,0 +1,35 @@
+/*
+ * 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 com.google.android.apps.mytracks.content;
+
+/**
+ * Utilities for serializing primitive types.
+ * 
+ * @author Rodrigo Damazio
+ */
+public class ContentTypeIds {
+
+  private ContentTypeIds() {}
+
+  public static final byte BOOLEAN_TYPE_ID = 0;
+  public static final byte LONG_TYPE_ID = 1;
+  public static final byte INT_TYPE_ID = 2;
+  public static final byte FLOAT_TYPE_ID = 3;
+  public static final byte DOUBLE_TYPE_ID = 4;
+  public static final byte STRING_TYPE_ID = 5;
+  public static final byte BLOB_TYPE_ID = 6;
+}

src/main/java/com/google/android/apps/mytracks/content/DataSource.java

@@ -0,0 +1,80 @@
+/*
+ * 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 com.google.android.apps.mytracks.content;
+
+import com.google.android.apps.mytracks.Constants;
+
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
+import android.database.ContentObserver;
+import android.net.Uri;
+
+/**
+ * Data source on the phone.
+ * 
+ * @author Rodrigo Damazio
+ */
+public class DataSource {
+
+  private final ContentResolver contentResolver;
+  private final SharedPreferences sharedPreferences;
+  
+  public DataSource(Context context) {
+    contentResolver = context.getContentResolver();
+    sharedPreferences = context.getSharedPreferences(Constants.SETTINGS_NAME, Context.MODE_PRIVATE);
+  }
+
+  /**
+   * Registers a content observer.
+   * 
+   * @param uri the uri
+   * @param observer the observer
+   */
+  public void registerContentObserver(Uri uri, ContentObserver observer) {
+    contentResolver.registerContentObserver(uri, false, observer);
+  }
+
+  /**
+   * Unregisters a content observer.
+   * 
+   * @param observer the observer
+   */
+  public void unregisterContentObserver(ContentObserver observer) {
+    contentResolver.unregisterContentObserver(observer);
+  }
+
+  /**
+   * Registers a shared preference change listener.
+   * 
+   * @param listener the listener
+   */
+  public void registerOnSharedPreferenceChangeListener(OnSharedPreferenceChangeListener listener) {
+    sharedPreferences.registerOnSharedPreferenceChangeListener(listener);
+  }
+
+  /**
+   * Unregisters a shared preference change listener.
+   * 
+   * @param listener the listener
+   */
+  public void unregisterOnSharedPreferenceChangeListener(
+      OnSharedPreferenceChangeListener listener) {
+    sharedPreferences.unregisterOnSharedPreferenceChangeListener(listener);
+  }
+}

src/main/java/com/google/android/apps/mytracks/content/DataSourceListener.java

@@ -0,0 +1,48 @@
+/*
+ * 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 com.google.android.apps.mytracks.content;
+
+
+/**
+ * Listener to be invoked when {@link DataSource} changes.
+ * 
+ * @author Jimmy Shih
+ */
+public interface DataSourceListener {
+
+  /**
+   * Notifies when the tracks table is updated.
+   */
+  void notifyTracksTableUpdated();
+
+  /**
+   * Notifies when the waypoints table is updated.
+   */
+  void notifyWaypointsTableUpdated();
+
+  /**
+   * Notifies when the track points table is updated.
+   */
+  void notifyTrackPointsTableUpdated();
+
+  /**
+   * Notifies when a preference changes.
+   * 
+   * @param key the preference key
+   */
+  void notifyPreferenceChanged(String key);
+}

src/main/java/com/google/android/apps/mytracks/content/DataSourceManager.java

@@ -0,0 +1,231 @@
+/*
+ * 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 com.google.android.apps.mytracks.content;
+
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
+import android.database.ContentObserver;
+import android.os.Handler;
+import android.util.Log;
+
+import java.util.EnumSet;
+import java.util.Set;
+
+/**
+ * Data source manager. Creates observers/listeners and manages their
+ * registration with {@link DataSource}. The observers/listeners calls
+ * {@link DataSourceListener} when data changes.
+ * 
+ * @author Rodrigo Damazio
+ */
+public class DataSourceManager {
+
+  private static final String TAG = DataSourceManager.class.getSimpleName();
+  
+  /**
+   * Observer when the tracks table is updated.
+   * 
+   * @author Jimmy Shih
+   */
+  private class TracksTableObserver extends ContentObserver {
+
+    public TracksTableObserver() {
+      super(handler);
+    }
+
+    @Override
+    public void onChange(boolean selfChange) {
+      dataSourceListener.notifyTracksTableUpdated();
+    }
+  }
+
+  /**
+   * Observer when the waypoints table is updated.
+   * 
+   * @author Jimmy Shih
+   */
+  private class WaypointsTableObserver extends ContentObserver {
+
+    public WaypointsTableObserver() {
+      super(handler);
+    }
+
+    @Override
+    public void onChange(boolean selfChange) {
+      dataSourceListener.notifyWaypointsTableUpdated();
+    }
+  }
+
+  /**
+   * Observer when the track points table is updated.
+   * 
+   * @author Jimmy Shih
+   */
+  private class TrackPointsTableObserver extends ContentObserver {
+
+    public TrackPointsTableObserver() {
+      super(handler);
+    }
+
+    @Override
+    public void onChange(boolean selfChange) {
+      dataSourceListener.notifyTrackPointsTableUpdated();
+    }
+  }
+
+  /**
+   * Listener for preference changes.
+   * 
+   * @author Jimmy Shih
+   */
+  private class PreferenceListener implements OnSharedPreferenceChangeListener {
+
+    @Override
+    public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
+      dataSourceListener.notifyPreferenceChanged(key);
+    }
+  }
+
+  private final DataSource dataSource;
+  private final DataSourceListener dataSourceListener;
+
+  // Registered listeners
+  private final Set<TrackDataType> registeredListeners = EnumSet.noneOf(TrackDataType.class);
+  
+  private final Handler handler;
+  private final TracksTableObserver tracksTableObserver;
+  private final WaypointsTableObserver waypointsTableObserver;
+  private final TrackPointsTableObserver trackPointsTableObserver;
+  private final PreferenceListener preferenceListener;
+
+  public DataSourceManager(DataSource dataSource, DataSourceListener dataSourceListener) {
+    this.dataSource = dataSource;
+    this.dataSourceListener = dataSourceListener;
+
+    handler = new Handler();
+    tracksTableObserver = new TracksTableObserver();
+    waypointsTableObserver = new WaypointsTableObserver();
+    trackPointsTableObserver = new TrackPointsTableObserver();
+    preferenceListener = new PreferenceListener();
+  }
+
+  /**
+   * Updates listeners with data source.
+   * 
+   * @param listeners the listeners
+   */
+  public void updateListeners(EnumSet<TrackDataType> listeners) {
+    EnumSet<TrackDataType> neededListeners = EnumSet.copyOf(listeners);
+
+    /*
+     * Map SAMPLED_OUT_POINT_UPDATES to POINT_UPDATES since they correspond to
+     * the same internal listener
+     */
+    if (neededListeners.contains(TrackDataType.SAMPLED_OUT_TRACK_POINTS_TABLE)) {
+      neededListeners.remove(TrackDataType.SAMPLED_OUT_TRACK_POINTS_TABLE);
+      neededListeners.add(TrackDataType.SAMPLED_IN_TRACK_POINTS_TABLE);
+    }
+
+    Log.d(TAG, "Updating listeners " + neededListeners);
+
+    // Unnecessary = registered - needed
+    Set<TrackDataType> unnecessaryListeners = EnumSet.copyOf(registeredListeners);
+    unnecessaryListeners.removeAll(neededListeners);
+
+    // Missing = needed - registered
+    Set<TrackDataType> missingListeners = EnumSet.copyOf(neededListeners);
+    missingListeners.removeAll(registeredListeners);
+
+    // Remove unnecessary listeners
+    for (TrackDataType trackDataType : unnecessaryListeners) {
+      unregisterListener(trackDataType);
+    }
+
+    // Add missing listeners
+    for (TrackDataType trackDataType : missingListeners) {
+      registerListener(trackDataType);
+    }
+
+    // Update registered listeners
+    registeredListeners.clear();
+    registeredListeners.addAll(neededListeners);
+  }
+
+  /**
+   * Registers a listener with data source.
+   * 
+   * @param trackDataType the listener data type
+   */
+  private void registerListener(TrackDataType trackDataType) {
+    switch (trackDataType) {
+      case TRACKS_TABLE:
+        dataSource.registerContentObserver(TracksColumns.CONTENT_URI, tracksTableObserver);
+        break;
+      case WAYPOINTS_TABLE:
+        dataSource.registerContentObserver(WaypointsColumns.CONTENT_URI, waypointsTableObserver);
+        break;
+      case SAMPLED_IN_TRACK_POINTS_TABLE:
+        dataSource.registerContentObserver(
+            TrackPointsColumns.CONTENT_URI, trackPointsTableObserver);
+        break;
+      case SAMPLED_OUT_TRACK_POINTS_TABLE:
+        // Do nothing. SAMPLED_OUT_POINT_UPDATES is mapped to POINT_UPDATES.
+        break;
+      case PREFERENCE:
+        dataSource.registerOnSharedPreferenceChangeListener(preferenceListener);
+        break;
+      default:
+        break;
+    }
+  }
+
+  /**
+   * Unregisters a listener with data source.
+   * 
+   * @param trackDataType listener data type
+   */
+  private void unregisterListener(TrackDataType trackDataType) {
+    switch (trackDataType) {
+      case TRACKS_TABLE:
+        dataSource.unregisterContentObserver(tracksTableObserver);
+        break;
+      case WAYPOINTS_TABLE:
+        dataSource.unregisterContentObserver(waypointsTableObserver);
+        break;
+      case SAMPLED_IN_TRACK_POINTS_TABLE:
+        dataSource.unregisterContentObserver(trackPointsTableObserver);
+        break;
+      case SAMPLED_OUT_TRACK_POINTS_TABLE:
+        // Do nothing. SAMPLED_OUT_POINT_UPDATES is mapped to POINT_UPDATES.
+        break;
+      case PREFERENCE:
+        dataSource.unregisterOnSharedPreferenceChangeListener(preferenceListener);
+        break;
+      default:
+        break;
+    }
+  }
+
+  /**
+   * Unregisters all listeners with data source.
+   */
+  public void unregisterAllListeners() {
+    for (TrackDataType trackDataType : TrackDataType.values()) {
+      unregisterListener(trackDataType);
+    }
+  }
+}

src/main/java/com/google/android/apps/mytracks/content/DescriptionGenerator.java

@@ -0,0 +1,47 @@
+/*
+ * 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 com.google.android.apps.mytracks.content;
+
+import com.google.android.apps.mytracks.stats.TripStatistics;
+
+import java.util.Vector;
+
+/**
+ * An interface for an object that can generate descriptions of track and
+ * waypoint.
+ *
+ * @author Sandor Dornbush
+ */
+public interface DescriptionGenerator {
+
+  /**
+   * Generates a track description.
+   *
+   * @param track the track
+   * @param distances a vector of distances to generate the elevation chart
+   * @param elevations a vector of elevations to generate the elevation chart
+   * @param html true to output html, false to output plain text
+   */
+  String generateTrackDescription(
+          Track track, Vector<Double> distances, Vector<Double> elevations, boolean html);
+
+  /**
+   * Generate a waypoint description from a trip statistics.
+   *
+   * @param tripStatistics the trip statistics
+   */
+  String generateWaypointDescription(TripStatistics tripStatistics);
+}

src/main/java/com/google/android/apps/mytracks/content/DescriptionGeneratorImpl.java

@@ -0,0 +1,261 @@
+/*
+ * 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 com.google.android.apps.mytracks.content;
+
+import android.content.Context;
+import androidx.annotation.VisibleForTesting;
+
+import com.google.android.apps.mytracks.stats.TripStatistics;
+import com.google.android.apps.mytracks.util.StringUtils;
+import com.google.android.apps.mytracks.util.UnitConversions;
+import com.google.android.maps.mytracks.R;
+
+import java.util.Vector;
+
+/**
+ * An implementation of {@link DescriptionGenerator} for My Tracks.
+ *
+ * @author Jimmy Shih
+ */
+public class DescriptionGeneratorImpl implements DescriptionGenerator {
+
+  private static final String HTML_LINE_BREAK = "<br>";
+  private static final String HTML_PARAGRAPH_SEPARATOR = "<p>";
+  private static final String TEXT_LINE_BREAK = "\n";
+  private static final String TEXT_PARAGRAPH_SEPARATOR = "\n\n";
+
+  private Context context;
+
+  public DescriptionGeneratorImpl(Context context) {
+    this.context = context;
+  }
+
+  @Override
+  public String generateTrackDescription(
+      Track track, Vector<Double> distances, Vector<Double> elevations, boolean html) {
+    String paragraphSeparator = html ? HTML_PARAGRAPH_SEPARATOR : TEXT_PARAGRAPH_SEPARATOR;
+    String lineBreak = html ? HTML_LINE_BREAK : TEXT_LINE_BREAK;
+    StringBuilder builder = new StringBuilder();
+
+    // Created by
+    String beginAnchor = html 
+        ? "<a href='http://" + context.getString(R.string.my_tracks_web_url) + "'>"
+        : "";
+    String endAnchor = html ? "</a>" : "";
+    builder.append(context.getString(R.string.send_google_by_my_tracks, beginAnchor, endAnchor));
+    builder.append(paragraphSeparator);
+
+    writeString(track.getName(), builder, R.string.generic_name_line, lineBreak);
+    writeString(track.getCategory(), builder, R.string.description_activity_type, lineBreak);
+    writeString(track.getDescription(), builder, R.string.generic_description_line, lineBreak);
+    builder.append(generateTripStatisticsDescription(track.getTripStatistics(), html));
+
+    return builder.toString();
+  }
+
+  @Override
+  public String generateWaypointDescription(TripStatistics tripStatistics) {
+    return generateTripStatisticsDescription(tripStatistics, false);
+  }
+
+  /**
+   * Writes a string to a string builder.
+   * 
+   * @param text the string
+   * @param builder the string builder
+   * @param resId the resource id containing one string placeholder
+   * @param lineBreak the line break
+   */
+  private void writeString(String text, StringBuilder builder, int resId, String lineBreak) {
+    if (text == null || text.length() == 0) {
+      text = context.getString(R.string.value_unknown);
+    }
+    builder.append(context.getString(resId, text));
+    builder.append(lineBreak);
+  }
+
+  /**
+   * Generates a description for a {@link TripStatistics}.
+   *
+   * @param stats the trip statistics
+   * @param html true to use "<br>" for line break instead of "\n"
+   */
+  private String generateTripStatisticsDescription(TripStatistics stats, boolean html) {
+    String lineBreak = html ? HTML_LINE_BREAK : TEXT_LINE_BREAK;
+    StringBuilder builder = new StringBuilder();
+
+    // Total distance
+    writeDistance(
+        stats.getTotalDistance(), builder, R.string.description_total_distance, lineBreak);
+
+    // Total time
+    writeTime(stats.getTotalTime(), builder, R.string.description_total_time, lineBreak);
+
+    // Moving time
+    writeTime(stats.getMovingTime(), builder, R.string.description_moving_time, lineBreak);
+
+    // Average speed
+    writeSpeed(stats.getAverageSpeed(), builder, R.string.description_average_speed, lineBreak);
+
+    // Average moving speed
+    writeSpeed(stats.getAverageMovingSpeed(), builder, R.string.description_average_moving_speed,
+        lineBreak);
+
+    // Max speed
+    writeSpeed(stats.getMaxSpeed(), builder, R.string.description_max_speed, lineBreak);
+
+    // Average pace
+    writePace(
+        stats.getAverageSpeed(), builder, R.string.description_average_pace_in_minute, lineBreak);
+
+    // Average moving pace
+    writePace(stats.getAverageMovingSpeed(), builder,
+        R.string.description_average_moving_pace_in_minute, lineBreak);
+
+    // Fastest pace
+    writePace(stats.getMaxSpeed(), builder, R.string.description_fastest_pace_in_minute, lineBreak);
+
+    // Max elevation
+    writeElevation(stats.getMaxElevation(), builder, R.string.description_max_elevation, lineBreak);
+
+    // Min elevation
+    writeElevation(stats.getMinElevation(), builder, R.string.description_min_elevation, lineBreak);
+
+    // Elevation gain
+    writeElevation(
+        stats.getTotalElevationGain(), builder, R.string.description_elevation_gain, lineBreak);
+
+    // Max grade
+    writeGrade(stats.getMaxGrade(), builder, R.string.description_max_grade, lineBreak);
+
+    // Min grade
+    writeGrade(stats.getMinGrade(), builder, R.string.description_min_grade, lineBreak);
+
+    // Recorded time
+    builder.append(
+        context.getString(R.string.description_recorded_time,
+            StringUtils.formatDateTime(context, stats.getStartTime())));
+    builder.append(lineBreak);
+
+    return builder.toString();
+  }
+
+  /**
+   * Writes distance.
+   *
+   * @param distance distance in meters
+   * @param builder StringBuilder to append distance
+   * @param resId resource id of distance string
+   * @param lineBreak line break string
+   */
+  @VisibleForTesting
+  void writeDistance(double distance, StringBuilder builder, int resId, String lineBreak) {
+    double distanceInKm = distance * UnitConversions.M_TO_KM;
+    double distanceInMi = distanceInKm * UnitConversions.KM_TO_MI;
+    builder.append(context.getString(resId, distanceInKm, distanceInMi));
+    builder.append(lineBreak);
+  }
+
+  /**
+   * Writes time.
+   *
+   * @param time time in milliseconds.
+   * @param builder StringBuilder to append time
+   * @param resId resource id of time string
+   * @param lineBreak line break string
+   */
+  @VisibleForTesting
+  void writeTime(long time, StringBuilder builder, int resId, String lineBreak) {
+    builder.append(context.getString(resId, StringUtils.formatElapsedTime(time)));
+    builder.append(lineBreak);
+  }
+
+  /**
+   * Writes speed.
+   *
+   * @param speed speed in meters per second
+   * @param builder StringBuilder to append speed
+   * @param resId resource id of speed string
+   * @param lineBreak line break string
+   */
+  @VisibleForTesting
+  void writeSpeed(
+      double speed, StringBuilder builder, int resId, String lineBreak) {
+    double speedInKmHr = speed * UnitConversions.MS_TO_KMH;
+    double speedInMiHr = speedInKmHr * UnitConversions.KM_TO_MI;
+    builder.append(context.getString(resId, speedInKmHr, speedInMiHr));
+    builder.append(lineBreak);
+  }
+
+  /**
+   * Writes pace.
+   * 
+   * @param speed speed in meters per second
+   * @param builder StringBuilder to append pace
+   * @param resId resource id of pace string
+   * @param lineBreak line break string
+   */
+  @VisibleForTesting
+  void writePace(double speed, StringBuilder builder, int resId, String lineBreak) {
+    String[] paceInMetrics = StringUtils.getSpeedParts(context, speed, true, false);
+    String[] paceInImperial = StringUtils.getSpeedParts(context, speed, false, false);
+
+    if (paceInMetrics[0] == null) {
+      paceInMetrics[0] = context.getString(R.string.value_unknown);
+    }
+
+    if (paceInImperial[0] == null) {
+      paceInImperial[0] = context.getString(R.string.value_unknown);
+    }
+
+    builder.append(context.getString(resId, paceInMetrics[0], paceInImperial[0]));
+    builder.append(lineBreak);
+  }
+
+  /**
+   * Writes elevation.
+   *
+   * @param elevation elevation in meters
+   * @param builder StringBuilder to append elevation
+   * @param resId resource id of elevation string
+   * @param lineBreak line break string
+   */
+  @VisibleForTesting
+  void writeElevation(
+      double elevation, StringBuilder builder, int resId, String lineBreak) {
+    long elevationInM = Math.round(elevation);
+    long elevationInFt = Math.round(elevation * UnitConversions.M_TO_FT);
+    builder.append(context.getString(resId, elevationInM, elevationInFt));
+    builder.append(lineBreak);
+  }
+
+  /**
+   * Writes grade.
+   *
+   * @param grade grade in fraction
+   * @param builder StringBuilder to append grade
+   * @param resId resource id grade string
+   * @param lineBreak line break string
+   */
+  @VisibleForTesting
+  void writeGrade(double grade, StringBuilder builder, int resId, String lineBreak) {
+    long gradeInPercent = Double.isNaN(grade) || Double.isInfinite(grade) ? 0L
+        : Math.round(grade * 100);
+    builder.append(context.getString(resId, gradeInPercent));
+    builder.append(lineBreak);
+  }
+}

src/main/java/com/google/android/apps/mytracks/content/MyTracksLocation.java

@@ -0,0 +1,66 @@
+/*
+ * 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 com.google.android.apps.mytracks.content;
+
+import android.location.Location;
+
+import com.google.android.apps.mytracks.content.sensor.SensorDataSet;
+
+/**
+ * This class extends the standard Android location with extra information.
+ *
+ * @author Sandor Dornbush
+ */
+public class MyTracksLocation extends Location {
+
+  private SensorDataSet sensorDataSet = null;
+
+  /**
+   * The id of this location from the provider.
+   */
+  private int id = -1;
+
+  public MyTracksLocation(Location location, SensorDataSet sensorDataSet) {
+    super(location);
+    this.sensorDataSet = sensorDataSet;
+  }
+
+  public MyTracksLocation(String provider) {
+    super(provider);
+  }
+
+  public SensorDataSet getSensorDataSet() {
+    return sensorDataSet;
+  }
+
+  public void setSensorDataSet(SensorDataSet sensorDataSet) {
+    this.sensorDataSet = sensorDataSet;
+  }
+
+  public int getId() {
+    return id;
+  }
+
+  public void setId(int id) {
+    this.id = id;
+  }
+  
+  public void reset() {
+    super.reset();
+    sensorDataSet = null;
+    id = -1;
+  }
+}

src/main/java/com/google/android/apps/mytracks/content/MyTracksProvider.java

@@ -0,0 +1,418 @@
+/*
+ * 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 com.google.android.apps.mytracks.content;
+
+import android.content.ContentProvider;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.Intent;
+import android.content.UriMatcher;
+import android.database.Cursor;
+import android.database.SQLException;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteException;
+import android.database.sqlite.SQLiteOpenHelper;
+import android.database.sqlite.SQLiteQueryBuilder;
+import android.net.Uri;
+import android.os.ParcelFileDescriptor;
+import android.text.TextUtils;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.VisibleForTesting;
+
+import com.google.android.apps.mytracks.util.FileUtils;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+
+/**
+ * A {@link ContentProvider} that handles access to track points, tracks, and
+ * waypoints tables.
+ * 
+ * @author Leif Hendrik Wilden
+ */
+public class MyTracksProvider extends ContentProvider {
+
+  private static final String TAG = MyTracksProvider.class.getSimpleName();
+
+  @VisibleForTesting
+  static final int DATABASE_VERSION = 23;
+
+  @VisibleForTesting
+  static final String DATABASE_NAME = "mytracks.db";
+
+  /**
+   * Database helper for creating and upgrading the database.
+   */
+  @VisibleForTesting
+  static class DatabaseHelper extends SQLiteOpenHelper {
+
+    public DatabaseHelper(Context context) {
+      this(context, DATABASE_NAME);
+    }
+
+    @VisibleForTesting
+    public DatabaseHelper(Context context, String databaseName) {
+      super(context, databaseName, null, DATABASE_VERSION);
+    }
+
+    @Override
+    public void onCreate(SQLiteDatabase db) {
+      db.execSQL(TrackPointsColumns.CREATE_TABLE);
+      db.execSQL(TracksColumns.CREATE_TABLE);
+      db.execSQL(WaypointsColumns.CREATE_TABLE);
+    }
+
+    @Override
+    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
+    }
+  }
+
+  /**
+   * Types of url.
+   * 
+   * @author Jimmy Shih
+   */
+  @VisibleForTesting
+  enum UrlType {
+    TRACKPOINTS, TRACKPOINTS_ID, TRACKS, TRACKS_ID, WAYPOINTS, WAYPOINTS_ID
+  }
+
+  private final UriMatcher uriMatcher;
+  private SQLiteDatabase db;
+
+  public MyTracksProvider() {
+    uriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
+    uriMatcher.addURI(MyTracksProviderUtils.AUTHORITY, TrackPointsColumns.TABLE_NAME, UrlType.TRACKPOINTS.ordinal());
+    uriMatcher.addURI(MyTracksProviderUtils.AUTHORITY, TrackPointsColumns.TABLE_NAME + "/#", UrlType.TRACKPOINTS_ID.ordinal());
+    uriMatcher.addURI(MyTracksProviderUtils.AUTHORITY, TracksColumns.TABLE_NAME, UrlType.TRACKS.ordinal());
+    uriMatcher.addURI(MyTracksProviderUtils.AUTHORITY, TracksColumns.TABLE_NAME + "/#", UrlType.TRACKS_ID.ordinal());
+    uriMatcher.addURI(MyTracksProviderUtils.AUTHORITY, WaypointsColumns.TABLE_NAME, UrlType.WAYPOINTS.ordinal());
+    uriMatcher.addURI(MyTracksProviderUtils.AUTHORITY, WaypointsColumns.TABLE_NAME + "/#", UrlType.WAYPOINTS_ID.ordinal());
+  }
+
+  @Override
+  public boolean onCreate() {
+    return onCreate(getContext());
+  }
+
+  /**
+   * Helper method to make onCreate is testable.
+   * 
+   * @param context context to creates database
+   * @return true means run successfully
+   */
+  @VisibleForTesting
+  boolean onCreate(Context context) {
+    DatabaseHelper databaseHelper = new DatabaseHelper(context);
+    try {
+      db = databaseHelper.getWritableDatabase();
+    } catch (SQLiteException e) {
+      Log.e(TAG, "Unable to open database for writing.", e);
+    }
+    return db != null;
+  }
+
+  @Override
+  public int delete(@NonNull Uri url, String where, String[] selectionArgs) {
+    String table;
+    boolean shouldVacuum = false;
+    switch (getUrlType(url)) {
+      case TRACKPOINTS:
+        table = TrackPointsColumns.TABLE_NAME;
+        break;
+      case TRACKS:
+        table = TracksColumns.TABLE_NAME;
+        shouldVacuum = true;
+        break;
+      case WAYPOINTS:
+        table = WaypointsColumns.TABLE_NAME;
+        break;
+      default:
+        throw new IllegalArgumentException("Unknown URL " + url);
+    }
+
+    Log.w(TAG, "Deleting table " + table);
+    int count;
+    try {
+      db.beginTransaction();
+      count = db.delete(table, where, selectionArgs);
+      db.setTransactionSuccessful();
+    } finally {
+      db.endTransaction();
+    }
+    getContext().getContentResolver().notifyChange(url, null, false);
+
+    if (shouldVacuum) {
+      // If a potentially large amount of data was deleted, reclaim its space.
+      Log.i(TAG, "Vacuuming the database.");
+      db.execSQL("VACUUM");
+    }
+    return count;
+  }
+
+  @Override
+  public String getType(@NonNull Uri url) {
+    switch (getUrlType(url)) {
+      case TRACKPOINTS:
+        return TrackPointsColumns.CONTENT_TYPE;
+      case TRACKPOINTS_ID:
+        return TrackPointsColumns.CONTENT_ITEMTYPE;
+      case TRACKS:
+        return TracksColumns.CONTENT_TYPE;
+      case TRACKS_ID:
+        return TracksColumns.CONTENT_ITEMTYPE;
+      case WAYPOINTS:
+        return WaypointsColumns.CONTENT_TYPE;
+      case WAYPOINTS_ID:
+        return WaypointsColumns.CONTENT_ITEMTYPE;
+      default:
+        throw new IllegalArgumentException("Unknown URL " + url);
+    }
+  }
+
+  @Override
+  public Uri insert(@NonNull Uri url, ContentValues initialValues) {
+    if (initialValues == null) {
+      initialValues = new ContentValues();
+    }
+    Uri result;
+    try {
+      db.beginTransaction();
+      result = insertContentValues(url, getUrlType(url), initialValues);
+      db.setTransactionSuccessful();
+    } finally {
+      db.endTransaction();
+    }
+    getContext().getContentResolver().notifyChange(url, null, false);
+    return result;
+  }
+
+  @Override
+  public int bulkInsert(@NonNull Uri url, @NonNull ContentValues[] valuesBulk) {
+    int numInserted;
+    try {
+      // Use a transaction in order to make the insertions run as a single batch
+      db.beginTransaction();
+
+      UrlType urlType = getUrlType(url);
+      for (numInserted = 0; numInserted < valuesBulk.length; numInserted++) {
+        ContentValues contentValues = valuesBulk[numInserted];
+        if (contentValues == null) {
+          contentValues = new ContentValues();
+        }
+        insertContentValues(url, urlType, contentValues);
+      }
+      db.setTransactionSuccessful();
+    } finally {
+      db.endTransaction();
+    }
+    getContext().getContentResolver().notifyChange(url, null, false);
+    return numInserted;
+  }
+
+  @Override
+  public Cursor query(@NonNull Uri url, String[] projection, String selection, String[] selectionArgs, String sort) {
+    SQLiteQueryBuilder queryBuilder = new SQLiteQueryBuilder();
+    String sortOrder = null;
+    switch (getUrlType(url)) {
+      case TRACKPOINTS:
+        queryBuilder.setTables(TrackPointsColumns.TABLE_NAME);
+        sortOrder = sort != null ? sort : TrackPointsColumns.DEFAULT_SORT_ORDER;
+        break;
+      case TRACKPOINTS_ID:
+        queryBuilder.setTables(TrackPointsColumns.TABLE_NAME);
+        queryBuilder.appendWhere("_id=" + url.getPathSegments().get(1));
+        break;
+      case TRACKS:
+        queryBuilder.setTables(TracksColumns.TABLE_NAME);
+        sortOrder = sort != null ? sort : TracksColumns.DEFAULT_SORT_ORDER;
+        break;
+      case TRACKS_ID:
+        queryBuilder.setTables(TracksColumns.TABLE_NAME);
+        queryBuilder.appendWhere("_id=" + url.getPathSegments().get(1));
+        break;
+      case WAYPOINTS:
+        queryBuilder.setTables(WaypointsColumns.TABLE_NAME);
+        sortOrder = sort != null ? sort : WaypointsColumns.DEFAULT_SORT_ORDER;
+        break;
+      case WAYPOINTS_ID:
+        queryBuilder.setTables(WaypointsColumns.TABLE_NAME);
+        queryBuilder.appendWhere("_id=" + url.getPathSegments().get(1));
+        break;
+      default:
+        throw new IllegalArgumentException("Unknown url " + url);
+    }
+    Cursor cursor = queryBuilder.query(db, projection, selection, selectionArgs, null, null, sortOrder);
+    cursor.setNotificationUri(getContext().getContentResolver(), url);
+    return cursor;
+  }
+
+  @Override
+  public int update(@NonNull Uri url, ContentValues values, String where, String[] selectionArgs) {
+    String table;
+    String whereClause;
+    switch (getUrlType(url)) {
+      case TRACKPOINTS:
+        table = TrackPointsColumns.TABLE_NAME;
+        whereClause = where;
+        break;
+      case TRACKPOINTS_ID:
+        table = TrackPointsColumns.TABLE_NAME;
+        whereClause = TrackPointsColumns._ID + "=" + url.getPathSegments().get(1);
+        if (!TextUtils.isEmpty(where)) {
+          whereClause += " AND (" + where + ")";
+        }
+        break;
+      case TRACKS:
+        table = TracksColumns.TABLE_NAME;
+        whereClause = where;
+        break;
+      case TRACKS_ID:
+        table = TracksColumns.TABLE_NAME;
+        whereClause = TracksColumns._ID + "=" + url.getPathSegments().get(1);
+        if (!TextUtils.isEmpty(where)) {
+          whereClause += " AND (" + where + ")";
+        }
+        break;
+      case WAYPOINTS:
+        table = WaypointsColumns.TABLE_NAME;
+        whereClause = where;
+        break;
+      case WAYPOINTS_ID:
+        table = WaypointsColumns.TABLE_NAME;
+        whereClause = WaypointsColumns._ID + "=" + url.getPathSegments().get(1);
+        if (!TextUtils.isEmpty(where)) {
+          whereClause += " AND (" + where + ")";
+        }
+        break;
+      default:
+        throw new IllegalArgumentException("Unknown url " + url);
+    }
+    int count;
+    try {
+      db.beginTransaction();
+      count = db.update(table, values, whereClause, selectionArgs);
+      db.setTransactionSuccessful();
+    } finally {
+      db.endTransaction();
+    }
+    getContext().getContentResolver().notifyChange(url, null, false);
+    return count;
+  }
+
+  @Override
+  public ParcelFileDescriptor openFile(@NonNull Uri uri, @NonNull String mode) throws FileNotFoundException {
+    try {
+      File file = new File(uri.getPath());
+      if (file.exists()) {
+        return ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY);
+      }
+      throw new FileNotFoundException(uri.getPath());
+    } finally {
+      File dir = new File(getContext().getCacheDir(), FileUtils.PLAY_TRACKS_DIR);
+      for (File file : dir.listFiles()) {
+        file.delete();
+      }
+      getContext().revokeUriPermission(uri, Intent.FLAG_GRANT_READ_URI_PERMISSION);
+    }
+  }
+
+  /**
+   * Gets the {@link UrlType} for a url.
+   * 
+   * @param url the url
+   */
+  private UrlType getUrlType(Uri url) {
+    return UrlType.values()[uriMatcher.match(url)];
+  }
+
+  /**
+   * Inserts a content based on the url type.
+   * 
+   * @param url the content url
+   * @param urlType the url type
+   * @param contentValues the content values
+   */
+  private Uri insertContentValues(Uri url, UrlType urlType, ContentValues contentValues) {
+    switch (urlType) {
+      case TRACKPOINTS:
+        return insertTrackPoint(url, contentValues);
+      case TRACKS:
+        return insertTrack(url, contentValues);
+      case WAYPOINTS:
+        return insertWaypoint(url, contentValues);
+      default:
+        throw new IllegalArgumentException("Unknown url " + url);
+    }
+  }
+
+  /**
+   * Inserts a track point.
+   * 
+   * @param url the content url
+   * @param values the content values
+   */
+  private Uri insertTrackPoint(Uri url, ContentValues values) {
+    boolean hasLatitude = values.containsKey(TrackPointsColumns.LATITUDE);
+    boolean hasLongitude = values.containsKey(TrackPointsColumns.LONGITUDE);
+    boolean hasTime = values.containsKey(TrackPointsColumns.TIME);
+    if (!hasLatitude || !hasLongitude || !hasTime) {
+      throw new IllegalArgumentException("Latitude, longitude, and time values are required.");
+    }
+    long rowId = db.insert(TrackPointsColumns.TABLE_NAME, TrackPointsColumns._ID, values);
+    if (rowId >= 0) {
+      return ContentUris.appendId(TrackPointsColumns.CONTENT_URI.buildUpon(), rowId).build();
+    }
+    throw new SQLiteException("Failed to insert a track point " + url);
+  }
+
+  /**
+   * Inserts a track.
+   * 
+   * @param url the content url
+   * @param contentValues the content values
+   */
+  private Uri insertTrack(Uri url, ContentValues contentValues) {
+    boolean hasStartTime = contentValues.containsKey(TracksColumns.STARTTIME);
+    boolean hasStartId = contentValues.containsKey(TracksColumns.STARTID);
+    if (!hasStartTime || !hasStartId) {
+      throw new IllegalArgumentException("Both start time and start id values are required.");
+    }
+    long rowId = db.insert(TracksColumns.TABLE_NAME, TracksColumns._ID, contentValues);
+    if (rowId >= 0) {
+      return ContentUris.appendId(TracksColumns.CONTENT_URI.buildUpon(), rowId).build();
+    }
+    throw new SQLException("Failed to insert a track " + url);
+  }
+
+  /**
+   * Inserts a waypoint.
+   * 
+   * @param url the content url
+   * @param contentValues the content values
+   */
+  private Uri insertWaypoint(Uri url, ContentValues contentValues) {
+    long rowId = db.insert(WaypointsColumns.TABLE_NAME, WaypointsColumns._ID, contentValues);
+    if (rowId >= 0) {
+      return ContentUris.appendId(WaypointsColumns.CONTENT_URI.buildUpon(), rowId).build();
+    }
+    throw new SQLException("Failed to insert a waypoint " + url);
+  }
+}

src/main/java/com/google/android/apps/mytracks/content/MyTracksProviderUtils.java

@@ -0,0 +1,402 @@
+/*
+ * 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 com.google.android.apps.mytracks.content;
+
+import com.google.android.apps.mytracks.content.Waypoint.WaypointType;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.location.Location;
+import android.location.LocationManager;
+import android.net.Uri;
+
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * Utilities to access data from the My Tracks content provider.
+ * 
+ * @author Rodrigo Damazio
+ */
+public interface MyTracksProviderUtils {
+
+  /**
+   * The authority (the first part of the URI) for the My Tracks content
+   * provider.
+   */
+  String AUTHORITY = "com.google.android.maps.mytracks";
+
+  /**
+   * Clears a track. Removes waypoints and trackpoints. Only keeps the track id.
+   * 
+   * @param trackId the track id
+   */
+  void clearTrack(Context context, long trackId);
+
+  /**
+   * Creates a {@link Track} from a cursor.
+   * 
+   * @param cursor the cursor pointing to the track
+   */
+  Track createTrack(Cursor cursor);
+
+  /**
+   * Deletes all tracks (including waypoints and track points).
+   */
+  void deleteAllTracks(Context context);
+
+  /**
+   * Deletes a track.
+   * 
+   * @param trackId the track id
+   */
+  void deleteTrack(Context context, long trackId);
+
+  /**
+   * Gets all the tracks. If no track exists, an empty list is returned.
+   * <p>
+   * Note that the returned tracks do not have any track points attached.
+   */
+  List<Track> getAllTracks();
+
+  /**
+   * Gets the last track. Returns null if doesn't exist.
+   */
+  Track getLastTrack();
+
+  /**
+   * Gets a track by a track id. Returns null if not found.
+   * <p>
+   * Note that the returned track doesn't have any track points attached.
+   * 
+   * @param trackId the track id.
+   */
+  Track getTrack(long trackId);
+
+  /**
+   * Gets a track cursor. The caller owns the returned cursor and is responsible
+   * for closing it.
+   * 
+   * @param selection the selection. Can be null
+   * @param selectionArgs the selection arguments. Can be null
+   * @param sortOrder the sort order. Can be null
+   */
+  Cursor getTrackCursor(String selection, String[] selectionArgs, String sortOrder);
+
+  /**
+   * Inserts a track.
+   * <p>
+   * Note: This doesn't insert any track points.
+   * 
+   * @param track the track
+   * @return the content provider URI of the inserted track.
+   */
+  Uri insertTrack(Track track);
+
+  /**
+   * Updates a track.
+   * <p>
+   * Note: This doesn't update any track points.
+   * 
+   * @param track the track
+   */
+  void updateTrack(Track track);
+
+  /**
+   * Creates a waypoint from a cursor.
+   * 
+   * @param cursor the cursor pointing to the waypoint
+   */
+  Waypoint createWaypoint(Cursor cursor);
+
+  /**
+   * Deletes a waypoint. If deleting a statistics waypoint, this will also
+   * correct the next statistics waypoint after the deleted one to reflect the
+   * deletion. The generator is used to update the next statistics waypoint.
+   * 
+   * @param waypointId the waypoint id
+   * @param descriptionGenerator the description generator. Can be null for
+   *          waypoint marker
+   */
+  void deleteWaypoint(Context context, long waypointId, DescriptionGenerator descriptionGenerator);
+
+  /**
+   * Gets the first waypoint id for a track. The first waypoint is special as it
+   * contains the stats for the track. Returns -1L if it doesn't exist.
+   * 
+   * @param trackId the track id
+   */
+  long getFirstWaypointId(long trackId);
+
+  /**
+   * Gets the last waypoint for a type. Returns null if it doesn't exist.
+   * 
+   * @param trackId the track id
+   * @param waypointType the waypoint type
+   */
+  Waypoint getLastWaypoint(long trackId, WaypointType waypointType);
+
+  /**
+   * Gets the next waypoint number for a type. Returns -1 if not able to get the
+   * next waypoint number.
+   * 
+   * @param trackId the track id
+   * @param waypointType the waypoint type
+   */
+  int getNextWaypointNumber(long trackId, WaypointType waypointType);
+
+  /**
+   * Gets a waypoint from a waypoint id. Returns null if not found.
+   * 
+   * @param waypointId the waypoint id
+   */
+  Waypoint getWaypoint(long waypointId);
+
+  /**
+   * Gets a waypoint cursor. The caller owns the returned cursor and is
+   * responsible for closing it.
+   * 
+   * @param selection the selection. Can be null
+   * @param selectionArgs the selection arguments. Can be null
+   * @param sortOrder the sort order. Can be null
+   * @param maxWaypoints the maximum number of waypoints to return. -1 for no
+   *          limit
+   */
+  Cursor getWaypointCursor(
+          String selection, String[] selectionArgs, String sortOrder, int maxWaypoints);
+
+  /**
+   * Gets a waypoint cursor for a track. The caller owns the returned cursor and
+   * is responsible for closing it.
+   * 
+   * @param trackId the track id
+   * @param minWaypointId the minimum waypoint id. -1L to ignore
+   * @param maxWaypoints the maximum number of waypoints to return. -1 for no
+   *          limit
+   */
+  Cursor getWaypointCursor(long trackId, long minWaypointId, int maxWaypoints);
+
+  /**
+   * Gets the number of waypoints for a track.
+   * 
+   * @param trackId the track id
+   */
+  int getWaypointCount(long trackId);
+  
+  /**
+   * Inserts a waypoint.
+   * 
+   * @param waypoint the waypoint
+   * @return the content provider URI of the inserted waypoint.
+   */
+  Uri insertWaypoint(Waypoint waypoint);
+
+  /**
+   * Updates a waypoint. Returns true if successful.
+   * 
+   * @param waypoint the waypoint
+   */
+  boolean updateWaypoint(Waypoint waypoint);
+
+  /**
+   * Inserts multiple track points.
+   * 
+   * @param locations an array of locations
+   * @param length the number of locations (from the beginning of the array) to
+   *          insert, or -1 for all of them
+   * @param trackId the track id
+   * @return the number of points inserted
+   */
+  int bulkInsertTrackPoint(Location[] locations, int length, long trackId);
+
+  /**
+   * Creates a location object from a cursor.
+   * 
+   * @param cursor the cursor pointing to the location
+   */
+  Location createTrackPoint(Cursor cursor);
+
+  /**
+   * Gets the first location id for a track. Returns -1L if it doesn't exist.
+   * 
+   * @param trackId the track id
+   */
+  long getFirstTrackPointId(long trackId);
+
+  /**
+   * Gets the last location id for a track. Returns -1L if it doesn't exist.
+   * 
+   * @param trackId the track id
+   */
+  long getLastTrackPointId(long trackId);
+
+  /**
+   * Gets the track point id of a location.
+   * 
+   * @param trackId the track id
+   * @param location the location
+   * @return track point id if the location is in the track. -1L otherwise.
+   */
+  long getTrackPointId(long trackId, Location location);
+  
+  /**
+   * Gets the first valid location for a track. Returns null if it doesn't
+   * exist.
+   * 
+   * @param trackId the track id
+   */
+  Location getFirstValidTrackPoint(long trackId);
+
+  /**
+   * Gets the last valid location for a track. Returns null if it doesn't exist.
+   * 
+   * @param trackId the track id
+   */
+  Location getLastValidTrackPoint(long trackId);
+
+  
+  /**
+   * Gets the last valid location.
+   */
+  Location getLastValidTrackPoint();
+  
+  /**
+   * Creates a location cursor. The caller owns the returned cursor and is
+   * responsible for closing it.
+   * 
+   * @param trackId the track id
+   * @param startTrackPointId the starting track point id. -1L to ignore
+   * @param maxLocations maximum number of locations to return. -1 for no limit
+   * @param descending true to sort the result in descending order (latest
+   *          location first)
+   */
+  Cursor getTrackPointCursor(
+          long trackId, long startTrackPointId, int maxLocations, boolean descending);
+
+  /**
+   * Creates a new read-only iterator over a given track's points. It provides a
+   * lightweight way of iterating over long tracks without failing due to the
+   * underlying cursor limitations. Since it's a read-only iterator,
+   * {@link Iterator#remove()} always throws
+   * {@link UnsupportedOperationException}. Each call to
+   * {@link LocationIterator#next()} may advance to the next DB record, and if
+   * so, the iterator calls {@link LocationFactory#createLocation()} and
+   * populates it with information retrieved from the record. When done with
+   * iteration, {@link LocationIterator#close()} must be called.
+   * 
+   * @param trackId the track id
+   * @param startTrackPointId the starting track point id. -1L to ignore
+   * @param descending true to sort the result in descending order (latest
+   *          location first)
+   * @param locationFactory the location factory
+   */
+  LocationIterator getTrackPointLocationIterator(
+          long trackId, long startTrackPointId, boolean descending, LocationFactory locationFactory);
+
+  /**
+   * Inserts a track point.
+   * 
+   * @param location the location
+   * @param trackId the track id
+   * @return the content provider URI of the inserted track point
+   */
+  Uri insertTrackPoint(Location location, long trackId);
+
+  /**
+   * A lightweight wrapper around the original {@link Cursor} with a method to
+   * clean up.
+   */
+  interface LocationIterator extends Iterator<Location> {
+
+    /**
+     * Gets the most recently retrieved track point id by {@link #next()}.
+     */
+    long getLocationId();
+
+    /**
+     * Closes the iterator.
+     */
+    void close();
+  }
+
+  /**
+   * A factory for creating new {@link Location}.
+   */
+  interface LocationFactory {
+
+    /**
+     * Creates a new {@link Location}. An implementation can create new
+     * instances or reuse existing instances for optimization.
+     */
+    Location createLocation();
+  }
+
+  /**
+   * The default {@link LocationFactory} which creates a location each time.
+   */
+  LocationFactory DEFAULT_LOCATION_FACTORY = new LocationFactory() {
+      @Override
+    public Location createLocation() {
+      return new MyTracksLocation(LocationManager.GPS_PROVIDER);
+    }
+  };
+
+  /**
+   * A factory which can produce instances of {@link MyTracksProviderUtils}, and
+   * can be overridden for testing.
+   */
+  class Factory {
+
+    private static Factory instance = new Factory();
+
+    /**
+     * Creates an instance of {@link MyTracksProviderUtils}.
+     * 
+     * @param context the context
+     */
+    public static MyTracksProviderUtils get(Context context) {
+      return instance.newForContext(context);
+    }
+
+    /**
+     * Returns the factory instance.
+     */
+    public static Factory getInstance() {
+      return instance;
+    }
+
+    /**
+     * Overrides the factory instance for testing. Don't forget to set it back
+     * to the original value after testing.
+     * 
+     * @param factory the factory
+     */
+    public static void overrideInstance(Factory factory) {
+      instance = factory;
+    }
+
+    /**
+     * Creates an instance of {@link MyTracksProviderUtils}. Allows subclasses
+     * to override for testing.
+     * 
+     * @param context the context
+     */
+    protected MyTracksProviderUtils newForContext(Context context) {
+      return new MyTracksProviderUtilsImpl(context.getContentResolver());
+    }
+  }
+}

src/main/java/com/google/android/apps/mytracks/content/SearchEngine.java

@@ -0,0 +1,401 @@
+/*
+ * 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 com.google.android.apps.mytracks.content;
+
+import android.database.Cursor;
+import android.location.Location;
+
+import androidx.annotation.NonNull;
+
+import com.google.android.apps.mytracks.stats.TripStatistics;
+import com.google.android.apps.mytracks.util.LocationUtils;
+import com.google.android.apps.mytracks.util.UnitConversions;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.Locale;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+/**
+ * Engine for searching for tracks and waypoints by text.
+ *
+ * @author Rodrigo Damazio
+ */
+public class SearchEngine {
+
+  /** WHERE query to get tracks by name. */
+  private static final String TRACK_SELECTION_QUERY =
+      TracksColumns.NAME + " LIKE ? OR " +
+      TracksColumns.DESCRIPTION + " LIKE ? OR " +
+      TracksColumns.CATEGORY + " LIKE ?";
+
+  /** WHERE query to get waypoints by name. */
+  private static final String WAYPOINT_SELECTION_QUERY =
+      WaypointsColumns.NAME + " LIKE ? OR " +
+      WaypointsColumns.DESCRIPTION + " LIKE ? OR " +
+      WaypointsColumns.CATEGORY + " LIKE ?";
+
+  /** Order of track results. */
+  private static final String TRACK_SELECTION_ORDER = TracksColumns._ID + " DESC LIMIT 1000";
+
+  /** Order of waypoint results. */
+  private static final String WAYPOINT_SELECTION_ORDER = WaypointsColumns._ID + " DESC";
+
+  /** How much we promote a match in the track category. */
+  private static final double TRACK_CATEGORY_PROMOTION = 2.0;
+
+  /** How much we promote a match in the track description. */
+  private static final double TRACK_DESCRIPTION_PROMOTION = 8.0;
+
+  /** How much we promote a match in the track name. */
+  private static final double TRACK_NAME_PROMOTION = 16.0;
+
+  /** How much we promote a waypoint result if it's in the currently-selected track. */
+  private static final double CURRENT_TRACK_WAYPOINT_PROMOTION = 2.0;
+
+  /** How much we promote a track result if it's the currently-selected track. */
+  private static final double CURRENT_TRACK_DEMOTION = 0.5;
+
+  /** Maximum number of waypoints which will be retrieved and scored. */
+  private static final int MAX_SCORED_WAYPOINTS = 100;
+
+  /** Oldest timestamp for which we rank based on time (2000-01-01 00:00:00.000) */
+  private static final long OLDEST_ALLOWED_TIMESTAMP = 946692000000L;
+
+  /**
+   * Description of a search query, along with all contextual data needed to execute it.
+   */
+  public static class SearchQuery {
+    public SearchQuery(String textQuery, Location currentLocation, long currentTrackId,
+        long currentTimestamp) {
+      this.textQuery = textQuery.toLowerCase(Locale.getDefault());
+      this.currentLocation = currentLocation;
+      this.currentTrackId = currentTrackId;
+      this.currentTimestamp = currentTimestamp;
+    }
+
+    public final String textQuery;
+    public final Location currentLocation;
+    public final long currentTrackId;
+    public final long currentTimestamp;
+  }
+
+  /**
+   * Description of a search result which has been retrieved and scored.
+   */
+  public static class ScoredResult {
+    ScoredResult(Track track, double score) {
+      this.track = track;
+      this.waypoint = null;
+      this.score = score;
+    }
+
+    ScoredResult(Waypoint waypoint, double score) {
+      this.track = null;
+      this.waypoint = waypoint;
+      this.score = score;
+    }
+
+    public final Track track;
+    public final Waypoint waypoint;
+    public final double score;
+
+    @NonNull
+    @Override
+    public String toString() {
+      return "ScoredResult ["
+          + (track != null ? ("trackId=" + track.getId() + ", ") : "")
+          + (waypoint != null ? ("wptId=" + waypoint.getId() + ", ") : "")
+          + "score=" + score + "]";
+    }
+  }
+
+  /** Comparador for scored results. */
+  private static final Comparator<ScoredResult> SCORED_RESULT_COMPARATOR =
+      new Comparator<ScoredResult>() {
+        @Override
+        public int compare(ScoredResult r1, ScoredResult r2) {
+          // Score ordering.
+          int scoreDiff = Double.compare(r2.score, r1.score);
+          if (scoreDiff != 0) {
+            return scoreDiff;
+          }
+
+          // Make tracks come before waypoints.
+          if (r1.waypoint != null && r2.track != null) {
+            return 1;
+          } else if (r1.track != null && r2.waypoint != null) {
+            return -1;
+          }
+
+          // Finally, use arbitrary ordering, by ID.
+          long id1 = r1.track != null ? r1.track.getId() : r1.waypoint.getId();
+          long id2 = r2.track != null ? r2.track.getId() : r2.waypoint.getId();
+          long idDiff = id2 - id1;
+          return Long.signum(idDiff);
+        }
+      };
+
+  private final MyTracksProviderUtils providerUtils;
+
+  public SearchEngine(MyTracksProviderUtils providerUtils) {
+    this.providerUtils = providerUtils;
+  }
+
+  /**
+   * Executes a search query and returns a set of sorted results.
+   *
+   * @param query the query to execute
+   * @return a set of results, sorted according to their score
+   */
+  public SortedSet<ScoredResult> search(SearchQuery query) {
+    ArrayList<Track> tracks = new ArrayList<>();
+    ArrayList<Waypoint> waypoints = new ArrayList<>();
+    TreeSet<ScoredResult> scoredResults = new TreeSet<>(SCORED_RESULT_COMPARATOR);
+
+    retrieveTracks(query, tracks);
+    retrieveWaypoints(query, waypoints);
+
+    scoreTrackResults(tracks, query, scoredResults);
+    scoreWaypointResults(waypoints, query, scoredResults);
+
+    return scoredResults;
+  }
+
+  /**
+   * Retrieves tracks matching the given query from the database.
+   *
+   * @param query the query to retrieve for
+   * @param tracks list to fill with the resulting tracks
+   */
+  private void retrieveTracks(SearchQuery query, ArrayList<Track> tracks) {
+    String queryLikeSelection = "%" + query.textQuery + "%";
+    String[] trackSelectionArgs = new String[] {
+        queryLikeSelection,
+        queryLikeSelection,
+        queryLikeSelection };
+
+    try (Cursor cursor = providerUtils.getTrackCursor(
+            TRACK_SELECTION_QUERY, trackSelectionArgs, TRACK_SELECTION_ORDER)) {
+      if (cursor != null) {
+        tracks.ensureCapacity(cursor.getCount());
+        while (cursor.moveToNext()) {
+          tracks.add(providerUtils.createTrack(cursor));
+        }
+      }
+    }
+  }
+
+  /**
+   * Retrieves waypoints matching the given query from the database.
+   *
+   * @param query the query to retrieve for
+   * @param waypoints list to fill with the resulting waypoints
+   */
+  private void retrieveWaypoints(SearchQuery query, ArrayList<Waypoint> waypoints) {
+    String queryLikeSelection2 = "%" + query.textQuery + "%";
+    String[] waypointSelectionArgs = new String[] {
+        queryLikeSelection2,
+        queryLikeSelection2,
+        queryLikeSelection2 };
+    try (Cursor cursor = providerUtils.getWaypointCursor(WAYPOINT_SELECTION_QUERY, waypointSelectionArgs,
+            WAYPOINT_SELECTION_ORDER, MAX_SCORED_WAYPOINTS)) {
+      if (cursor != null) {
+        waypoints.ensureCapacity(cursor.getCount());
+        while (cursor.moveToNext()) {
+          Waypoint waypoint = providerUtils.createWaypoint(cursor);
+          if (LocationUtils.isValidLocation(waypoint.getLocation())) {
+            waypoints.add(waypoint);
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Scores a collection of track results.
+   *
+   * @param tracks the results to score
+   * @param query the query to score for
+   * @param output the collection to fill with scored results
+   */
+  private void scoreTrackResults(Collection<Track> tracks, SearchQuery query, Collection<ScoredResult> output) {
+    for (Track track : tracks) {
+      // Calculate the score.
+      double score = scoreTrackResult(query, track);
+
+      // Add to the output.
+      output.add(new ScoredResult(track, score));
+    }
+  }
+
+  /**
+   * Scores a single track result.
+   *
+   * @param query the query to score for
+   * @param track the results to score
+   * @return the score for the track
+   */
+  private double scoreTrackResult(SearchQuery query, Track track) {
+    double score = 1.0;
+
+    score *= getTitleBoost(query, track.getName(), track.getDescription(), track.getCategory());
+
+    TripStatistics statistics = track.getTripStatistics();
+    // TODO: Also boost for proximity to the currently-centered position on the map.
+    score *= getDistanceBoost(query, statistics.getMeanLatitude(), statistics.getMeanLongitude());
+
+    long meanTimestamp = (statistics.getStartTime() + statistics.getStopTime()) / 2L;
+    score *= getTimeBoost(query, meanTimestamp);
+
+    // Score the currently-selected track lower (user is already there, wouldn't be searching for it).
+    if (track.getId() == query.currentTrackId) {
+      score *= CURRENT_TRACK_DEMOTION;
+    }
+
+    return score;
+  }
+
+  /**
+   * Scores a collection of waypoint results.
+   *
+   * @param waypoints the results to score
+   * @param query the query to score for
+   * @param output the collection to fill with scored results
+   */
+  private void scoreWaypointResults(Collection<Waypoint> waypoints, SearchQuery query, Collection<ScoredResult> output) {
+    for (Waypoint waypoint : waypoints) {
+      // Calculate the score.
+      double score = scoreWaypointResult(query, waypoint);
+
+      // Add to the output.
+      output.add(new ScoredResult(waypoint, score));
+    }
+  }
+
+  /**
+   * Scores a single waypoint result.
+   *
+   * @param query the query to score for
+   * @param waypoint the results to score
+   * @return the score for the waypoint
+   */
+  private double scoreWaypointResult(SearchQuery query, Waypoint waypoint) {
+    double score = 1.0;
+
+    Location location = waypoint.getLocation();
+    score *= getTitleBoost(query, waypoint.getName(), waypoint.getDescription(), waypoint.getCategory());
+    // TODO: Also boost for proximity to the currently-centered position on the map.
+    score *= getDistanceBoost(query, location.getLatitude(), location.getLongitude());
+    score *= getTimeBoost(query, location.getTime());
+
+    // Score waypoints in the currently-selected track higher (searching inside the current track).
+    if (query.currentTrackId != -1 && waypoint.getTrackId() == query.currentTrackId) {
+      score *= CURRENT_TRACK_WAYPOINT_PROMOTION;
+    }
+
+    return score;
+  }
+
+  /**
+   * Calculates the boosting of the score due to the field(s) in which the match occured.
+   *
+   * @param query the query to boost for
+   * @param name the name of the track or waypoint
+   * @param description the description of the track or waypoint
+   * @param category the category of the track or waypoint
+   * @return the total boost to be applied to the result
+   */
+  private double getTitleBoost(SearchQuery query,
+      String name, String description, String category) {
+    // Title boost: track name > description > category.
+    double boost = 1.0;
+    if (name.toLowerCase(Locale.getDefault()).contains(query.textQuery)) {
+      boost *= TRACK_NAME_PROMOTION;
+    }
+    if (description.toLowerCase(Locale.getDefault()).contains(query.textQuery)) {
+      boost *= TRACK_DESCRIPTION_PROMOTION;
+    }
+    if (category.toLowerCase(Locale.getDefault()).contains(query.textQuery)) {
+      boost *= TRACK_CATEGORY_PROMOTION;
+    }
+    return boost;
+  }
+
+  /**
+   * Calculates the boosting of the score due to the recency of the matched entity.
+   *
+   * @param query the query to boost for
+   * @param timestamp the timestamp to calculate the boost for
+   * @return the total boost to be applied to the result
+   */
+  private double getTimeBoost(SearchQuery query, long timestamp) {
+    if (timestamp < OLDEST_ALLOWED_TIMESTAMP) {
+      // Safety: if timestamp is too old or invalid, don't rank based on time.
+      return 1.0;
+    }
+
+    // Score recent tracks higher.
+    long timeAgoHours = (long) ((query.currentTimestamp - timestamp) * UnitConversions.MS_TO_S
+        * UnitConversions.S_TO_MIN * UnitConversions.MIN_TO_HR);
+    if (timeAgoHours > 0L) {
+      return squash(timeAgoHours);
+    } else {
+      // Should rarely happen (track recorded in the last hour).
+      return Double.POSITIVE_INFINITY;
+    }
+  }
+
+  /**
+   * Calculates the boosting of the score due to proximity to a location.
+   *
+   * @param query the query to boost for
+   * @param latitude the latitude to calculate the boost for
+   * @param longitude the longitude to calculate the boost for
+   * @return the total boost to be applied to the result
+   */
+  private double getDistanceBoost(SearchQuery query, double latitude, double longitude) {
+    if (query.currentLocation == null) {
+      return 1.0;
+    }
+
+    float[] distanceResults = new float[1];
+
+    Location.distanceBetween(
+        latitude, longitude,
+        query.currentLocation.getLatitude(), query.currentLocation.getLongitude(),
+        distanceResults);
+
+    // Score tracks close to the current location higher.
+    double distanceKm = distanceResults[0] * UnitConversions.M_TO_KM;
+    if (distanceKm > 0.0) {
+      // Use the inverse of the amortized distance.
+      return squash(distanceKm);
+    } else {
+      // Should rarely happen (distance is exactly 0).
+      return Double.POSITIVE_INFINITY;
+    }
+  }
+
+  /**
+   * Squashes a number by calculating 1 / log (1 + x).
+   */
+  private static double squash(double x) {
+    return 1.0 / Math.log1p(x);
+  }
+}

src/main/java/com/google/android/apps/mytracks/content/SearchEngineProvider.java

@@ -0,0 +1,44 @@
+/*
+ * 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 com.google.android.apps.mytracks.content;
+
+import android.content.Context;
+import android.content.SearchRecentSuggestionsProvider;
+import android.provider.SearchRecentSuggestions;
+
+/**
+ * Content provider for search suggestions.
+ *
+ * @author Rodrigo Damazio
+ */
+public class SearchEngineProvider extends SearchRecentSuggestionsProvider {
+
+  private static final String AUTHORITY = "com.google.android.maps.mytracks.search";
+  private static final int MODE = DATABASE_MODE_QUERIES;
+
+  public SearchEngineProvider() {
+    setupSuggestions(AUTHORITY, MODE);
+  }
+
+  // TODO: Also add suggestions from the database.
+
+  /**
+   * Creates and returns a helper for adding recent queries or clearing the recent query history.
+   */
+  public static SearchRecentSuggestions newHelper(Context context) {
+    return new SearchRecentSuggestions(context, AUTHORITY, MODE);
+  }
+}

src/main/java/com/google/android/apps/mytracks/content/Track.java

@@ -0,0 +1,203 @@
+/*
+ * 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 com.google.android.apps.mytracks.content;
+
+import com.google.android.apps.mytracks.stats.TripStatistics;
+
+import android.location.Location;
+import android.os.Parcel;
+import android.os.Parcelable;
+
+import java.util.ArrayList;
+
+/**
+ * A track.
+ * 
+ * @author Leif Hendrik Wilden
+ * @author Rodrigo Damazio
+ */
+public class Track implements Parcelable {
+
+  private long id = -1L;
+  private String name = "";
+  private String description = "";
+  private String category = "";
+  private long startId = -1L;
+  private long stopId = -1L;
+
+  /*
+   * The number of location points (present even if the points themselves are
+   * not loaded)
+   */
+  private int numberOfPoints = 0;
+  private String icon = "";
+  private long modifiedTime = -1L;
+
+  private TripStatistics tripStatistics = new TripStatistics();
+
+  // Location points (which may not have been loaded)
+  private ArrayList<Location> locations = new ArrayList<>();
+
+  public Track() {}
+
+  private Track(Parcel in) {
+    id = in.readLong();
+    name = in.readString();
+    description = in.readString();
+    category = in.readString();
+    startId = in.readLong();
+    stopId = in.readLong();
+    numberOfPoints = in.readInt();
+    icon = in.readString();
+    modifiedTime = in.readLong();
+
+    ClassLoader classLoader = getClass().getClassLoader();
+    tripStatistics = in.readParcelable(classLoader);
+
+    for (int i = 0; i < numberOfPoints; ++i) {
+      Location location = in.readParcelable(classLoader);
+      locations.add(location);
+    }
+  }
+
+  @Override
+  public int describeContents() {
+    return 0;
+  }
+
+  @Override
+  public void writeToParcel(Parcel dest, int flags) {
+    dest.writeLong(id);
+    dest.writeString(name);
+    dest.writeString(description);
+    dest.writeString(category);
+    dest.writeLong(startId);
+    dest.writeLong(stopId);
+    dest.writeInt(numberOfPoints);
+    dest.writeString(icon);
+    dest.writeLong(modifiedTime);
+
+    dest.writeParcelable(tripStatistics, 0);
+    for (int i = 0; i < numberOfPoints; ++i) {
+      dest.writeParcelable(locations.get(i), 0);
+    }
+  }
+
+  public static final Parcelable.Creator<Track> CREATOR = new Parcelable.Creator<Track>() {
+      @Override
+    public Track createFromParcel(Parcel in) {
+      return new Track(in);
+    }
+
+      @Override
+    public Track[] newArray(int size) {
+      return new Track[size];
+    }
+  };
+
+  public long getId() {
+    return id;
+  }
+
+  public void setId(long id) {
+    this.id = id;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public void setName(String name) {
+    this.name = name;
+  }
+
+  public String getDescription() {
+    return description;
+  }
+
+  public void setDescription(String description) {
+    this.description = description;
+  }
+
+  public String getCategory() {
+    return category;
+  }
+
+  public void setCategory(String category) {
+    this.category = category;
+  }
+
+  public long getStartId() {
+    return startId;
+  }
+
+  public void setStartId(long startId) {
+    this.startId = startId;
+  }
+
+  public long getStopId() {
+    return stopId;
+  }
+
+  public void setStopId(long stopId) {
+    this.stopId = stopId;
+  }
+
+  public int getNumberOfPoints() {
+    return numberOfPoints;
+  }
+
+  public void setNumberOfPoints(int numberOfPoints) {
+    this.numberOfPoints = numberOfPoints;
+  }
+
+  public String getIcon() {
+    return icon;
+  }
+
+  public void setIcon(String icon) {
+    this.icon = icon;
+  }
+
+  public long getModifiedTime() {
+    return modifiedTime;
+  }
+
+  public void setModifiedTime(long modifiedTime) {
+    this.modifiedTime = modifiedTime;
+  }
+
+  public TripStatistics getTripStatistics() {
+    return tripStatistics;
+  }
+
+  public void setTripStatistics(TripStatistics tripStatistics) {
+    this.tripStatistics = tripStatistics;
+  }
+
+  public void addLocation(Location location) {
+    locations.add(location);
+  }
+
+  public ArrayList<Location> getLocations() {
+    return locations;
+  }
+
+  public void setLocations(ArrayList<Location> locations) {
+    this.locations = locations;
+  }
+}

src/main/java/com/google/android/apps/mytracks/content/TrackDataHub.java

@@ -0,0 +1,616 @@
+/*
+ * 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 com.google.android.apps.mytracks.content;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.location.Location;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.util.Log;
+
+import androidx.annotation.VisibleForTesting;
+
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils.LocationIterator;
+import com.google.android.apps.mytracks.util.LocationUtils;
+import com.google.android.apps.mytracks.util.PreferencesUtils;
+import com.google.android.maps.mytracks.R;
+
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.Set;
+
+/**
+ * Track data hub. Receives data from {@link DataSource} and distributes it to
+ * {@link TrackDataListener} after some processing.
+ * 
+ * @author Rodrigo Damazio
+ */
+public class TrackDataHub implements DataSourceListener {
+
+  private static final String TAG = TrackDataHub.class.getSimpleName();
+ 
+  /**
+   * Maximum number of waypoints to displayed.
+   */
+  @VisibleForTesting
+  static final int MAX_DISPLAYED_WAYPOINTS = 128;
+  
+  /**
+   * Target number of track points displayed by the map overlay. We may display
+   * more than this number of points.
+   */
+  public static final int TARGET_DISPLAYED_TRACK_POINTS = 5000;
+  
+  private final Context context;
+  private final TrackDataManager trackDataManager;
+  private final MyTracksProviderUtils myTracksProviderUtils;
+  private final int targetNumPoints;
+
+  private boolean started;
+  private HandlerThread handlerThread;
+  private Handler handler;
+  private DataSource dataSource;
+  private DataSourceManager dataSourceManager;
+
+  // Preference values
+  private long selectedTrackId;
+  private long recordingTrackId;
+  private boolean recordingTrackPaused;
+  private boolean metricUnits;
+  private boolean reportSpeed;
+  private int recordingGpsAccuracy;
+  private int recordingDistanceInterval;
+
+  // Track points sampling state
+  private int numLoadedPoints;
+  private long firstSeenLocationId;
+  private long lastSeenLocationId;
+
+  /**
+   * Creates a new instance.
+   */
+  public synchronized static TrackDataHub newInstance(Context context) {
+    return new TrackDataHub(context, new TrackDataManager(), MyTracksProviderUtils.Factory.get(
+        context), TARGET_DISPLAYED_TRACK_POINTS);
+  }
+
+  /**
+   * Constructor.
+   * 
+   * @param context the context
+   * @param trackDataManager the track data manager
+   * @param myTracksProviderUtils the my tracks provider utils
+   * @param targetNumPoints the target number of points
+   */
+  @VisibleForTesting
+  TrackDataHub(Context context, TrackDataManager trackDataManager,
+      MyTracksProviderUtils myTracksProviderUtils, int targetNumPoints) {
+    this.context = context;
+    this.trackDataManager = trackDataManager;
+    this.myTracksProviderUtils = myTracksProviderUtils;
+    this.targetNumPoints = targetNumPoints;
+    resetSamplingState();
+  }
+
+  /**
+   * Starts.
+   */
+  public void start() {
+    if (started) {
+      Log.i(TAG, "TrackDataHub already started, ignoring start.");
+      return;
+    }
+    started = true;
+    handlerThread = new HandlerThread("TrackDataHubHandlerThread");
+    handlerThread.start();
+    handler = new Handler(handlerThread.getLooper());
+    dataSource = newDataSource();
+    dataSourceManager = new DataSourceManager(dataSource, this);
+
+    notifyPreferenceChanged(null);
+    runInHanderThread(new Runnable() {
+        @Override
+      public void run() {
+        if (dataSourceManager != null) {
+          dataSourceManager.updateListeners(trackDataManager.getRegisteredTrackDataTypes());
+          loadDataForAll();
+        }
+      }
+    });
+  }
+
+  /**
+   * Stops.
+   */
+  public void stop() {
+    if (!started) {
+      Log.i(TAG, "TrackDataHub not started, ignoring stop.");
+      return;
+    }
+    started = false;
+
+    dataSourceManager.unregisterAllListeners();
+    if (handlerThread != null) {
+      handlerThread.getLooper().quit();
+      handlerThread = null;
+    }
+    handler = null;
+    dataSource = null;
+    dataSourceManager = null;
+  }
+
+  /**
+   * Loads a track.
+   * 
+   * @param trackId the track id
+   */
+  public void loadTrack(final long trackId) {
+    runInHanderThread(new Runnable() {
+        @Override
+      public void run() {
+        if (trackId == selectedTrackId) {
+          Log.i(TAG, "Not reloading track " + trackId);
+          return;
+        }
+        selectedTrackId = trackId;
+        loadDataForAll();
+      }
+    });
+  }
+
+  /**
+   * Registers a {@link TrackDataListener}.
+   * 
+   * @param trackDataListener the track data listener
+   * @param trackDataTypes the track data types
+   */
+  public void registerTrackDataListener(final TrackDataListener trackDataListener, final EnumSet<TrackDataType> trackDataTypes) {
+    runInHanderThread(new Runnable() {
+        @Override
+      public void run() {
+        trackDataManager.registerListener(trackDataListener, trackDataTypes);
+        if (dataSourceManager != null) {
+          dataSourceManager.updateListeners(trackDataManager.getRegisteredTrackDataTypes());
+          loadDataForListener(trackDataListener);
+        }
+      }
+    });
+  }
+
+  /**
+   * Unregisters a {@link TrackDataListener}.
+   * 
+   * @param trackDataListener the track data listener
+   */
+  public void unregisterTrackDataListener(final TrackDataListener trackDataListener) {
+    runInHanderThread(new Runnable() {
+        @Override
+      public void run() {
+        trackDataManager.unregisterListener(trackDataListener);
+        if (dataSourceManager != null) {
+          dataSourceManager.updateListeners(trackDataManager.getRegisteredTrackDataTypes());
+        }
+      }
+    });
+  }
+
+  /**
+   * Reloads data for a {@link TrackDataListener}.
+   */
+  public void reloadDataForListener(final TrackDataListener trackDataListener) {
+    runInHanderThread(new Runnable() {
+        @Override
+      public void run() {
+        loadDataForListener(trackDataListener);
+      }
+    });
+  }
+
+  /**
+   * Returns true if the selected track is recording.
+   */
+  public boolean isSelectedTrackRecording() {
+    return selectedTrackId == recordingTrackId
+        && recordingTrackId != PreferencesUtils.RECORDING_TRACK_ID_DEFAULT;
+  }
+
+  /**
+   * Returns true if the selected track is paused.
+   */
+  public boolean isSelectedTrackPaused() {
+    return selectedTrackId == recordingTrackId && recordingTrackPaused;
+  }
+
+  @Override
+  public void notifyTracksTableUpdated() {
+    runInHanderThread(new Runnable() {
+        @Override
+      public void run() {
+        notifyTracksTableUpdate(trackDataManager.getListeners(TrackDataType.TRACKS_TABLE));
+      }
+    });
+  }
+
+  @Override
+  public void notifyWaypointsTableUpdated() {
+    runInHanderThread(new Runnable() {
+        @Override
+      public void run() {
+        notifyWaypointsTableUpdate(trackDataManager.getListeners(TrackDataType.WAYPOINTS_TABLE));
+      }
+    });
+  }
+
+  @Override
+  public void notifyTrackPointsTableUpdated() {
+    runInHanderThread(new Runnable() {
+        @Override
+      public void run() {
+        notifyTrackPointsTableUpdate(
+            true, trackDataManager.getListeners(TrackDataType.SAMPLED_IN_TRACK_POINTS_TABLE),
+            trackDataManager.getListeners(TrackDataType.SAMPLED_OUT_TRACK_POINTS_TABLE));
+      }
+    });
+  }
+
+  @Override
+  public void notifyPreferenceChanged(final String key) {
+    runInHanderThread(new Runnable() {
+        @Override
+      public void run() {
+        if (key == null
+            || key.equals(PreferencesUtils.getKey(context, R.string.recording_track_id_key))) {
+          recordingTrackId = PreferencesUtils.getLong(context, R.string.recording_track_id_key);
+        }
+        if (key == null
+            || key.equals(PreferencesUtils.getKey(context, R.string.recording_track_paused_key))) {
+          recordingTrackPaused = PreferencesUtils.getBoolean(
+              context, R.string.recording_track_paused_key,
+              PreferencesUtils.RECORDING_TRACK_PAUSED_DEFAULT);
+        }
+        if (key == null
+            || key.equals(PreferencesUtils.getKey(context, R.string.stats_units_key))) {
+          metricUnits = PreferencesUtils.isMetricUnits(context);
+          if (key != null) {
+            for (TrackDataListener trackDataListener :
+                trackDataManager.getListeners(TrackDataType.PREFERENCE)) {
+              if (trackDataListener.onMetricUnitsChanged(metricUnits)) {
+                loadDataForListener(trackDataListener);
+              }
+            }
+          }
+        }
+        if (key == null
+            || key.equals(PreferencesUtils.getKey(context, R.string.stats_rate_key))) {
+          reportSpeed = PreferencesUtils.isReportSpeed(context);
+          if (key != null) {
+            for (TrackDataListener trackDataListener :
+                trackDataManager.getListeners(TrackDataType.PREFERENCE)) {
+              if (trackDataListener.onReportSpeedChanged(reportSpeed)) {
+                loadDataForListener(trackDataListener);
+              }
+            }
+          }
+        }
+        if (key == null
+            || key.equals(PreferencesUtils.getKey(context, R.string.recording_gps_accuracy_key))) {
+          recordingGpsAccuracy = PreferencesUtils.getInt(context, R.string.recording_gps_accuracy_key,
+              PreferencesUtils.RECORDING_GPS_ACCURACY_DEFAULT);
+          if (key != null) {
+            for (TrackDataListener trackDataListener :
+                trackDataManager.getListeners(TrackDataType.PREFERENCE)) {
+              if (trackDataListener.onRecordingGpsAccuracy(recordingGpsAccuracy)) {
+                loadDataForListener(trackDataListener);
+              }
+            }
+          }
+        }
+        if (key == null || key.equals(PreferencesUtils.getKey(context, R.string.recording_distance_interval_key))) {
+          recordingDistanceInterval = PreferencesUtils.getInt(context, R.string.recording_distance_interval_key, PreferencesUtils.RECORDING_DISTANCE_INTERVAL_DEFAULT);
+          if (key != null) {
+            for (TrackDataListener trackDataListener : trackDataManager.getListeners(TrackDataType.PREFERENCE)) {
+              if (trackDataListener.onRecordingDistanceIntervalChanged(recordingDistanceInterval)) {
+                loadDataForListener(trackDataListener);
+              }
+            }
+          }
+        }
+      }
+    });
+  }
+
+  /**
+   * Loads data for all listeners. To be run in the {@link #handler} thread.
+   */
+  private void loadDataForAll() {
+    resetSamplingState();
+    if (trackDataManager.getNumberOfListeners() == 0) {
+      return;
+    }
+
+    for (TrackDataListener trackDataListener : trackDataManager.getListeners(TrackDataType.PREFERENCE)) {
+      trackDataListener.onMetricUnitsChanged(metricUnits);
+      trackDataListener.onReportSpeedChanged(reportSpeed);
+      trackDataListener.onRecordingGpsAccuracy(recordingGpsAccuracy);
+      trackDataListener.onRecordingDistanceIntervalChanged(recordingDistanceInterval);
+    }
+
+    notifyTracksTableUpdate(trackDataManager.getListeners(TrackDataType.TRACKS_TABLE));
+
+    for (TrackDataListener listener : trackDataManager.getListeners(TrackDataType.SAMPLED_IN_TRACK_POINTS_TABLE)) {
+      listener.clearTrackPoints();
+    }
+    notifyTrackPointsTableUpdate(true,
+        trackDataManager.getListeners(TrackDataType.SAMPLED_IN_TRACK_POINTS_TABLE),
+        trackDataManager.getListeners(TrackDataType.SAMPLED_OUT_TRACK_POINTS_TABLE));
+    notifyWaypointsTableUpdate(trackDataManager.getListeners(TrackDataType.WAYPOINTS_TABLE));
+  }
+
+  /**
+   * Loads data for a listener. To be run in the {@link #handler} thread.
+   * 
+   * @param trackDataListener the track data listener.
+   */
+  private void loadDataForListener(TrackDataListener trackDataListener) {
+    Set<TrackDataListener> trackDataListeners = Collections.singleton(trackDataListener);
+    EnumSet<TrackDataType> trackDataTypes = trackDataManager.getTrackDataTypes(trackDataListener);
+
+    if (trackDataTypes.contains(TrackDataType.PREFERENCE)) {
+      trackDataListener.onMetricUnitsChanged(metricUnits);
+      trackDataListener.onReportSpeedChanged(reportSpeed);
+      trackDataListener.onRecordingGpsAccuracy(recordingGpsAccuracy);
+      trackDataListener.onRecordingDistanceIntervalChanged(recordingDistanceInterval);
+    }
+
+    if (trackDataTypes.contains(TrackDataType.TRACKS_TABLE)) {
+      notifyTracksTableUpdate(trackDataListeners);
+    }
+
+    boolean hasSampledIn = trackDataTypes.contains(TrackDataType.SAMPLED_IN_TRACK_POINTS_TABLE);
+    boolean hasSampledOut = trackDataTypes.contains(TrackDataType.SAMPLED_OUT_TRACK_POINTS_TABLE);
+    if (hasSampledIn || hasSampledOut) {
+      trackDataListener.clearTrackPoints();
+      boolean isOnlyListener = trackDataManager.getNumberOfListeners() == 1;
+      if (isOnlyListener) {
+        resetSamplingState();
+      }
+      Set<TrackDataListener> sampledOutListeners = hasSampledOut ? trackDataListeners
+          : Collections.<TrackDataListener> emptySet();
+      notifyTrackPointsTableUpdate(isOnlyListener, trackDataListeners, sampledOutListeners);
+    }
+
+    if (trackDataTypes.contains(TrackDataType.WAYPOINTS_TABLE)) {
+      notifyWaypointsTableUpdate(trackDataListeners);
+    }
+  }
+
+  /**
+   * Notifies track table update. To be run in the {@link #handler} thread.
+   * 
+   * @param trackDataListeners the track data listeners to notify
+   */
+  private void notifyTracksTableUpdate(Set<TrackDataListener> trackDataListeners) {
+    if (trackDataListeners.isEmpty()) {
+      return;
+    }
+    Track track = myTracksProviderUtils.getTrack(selectedTrackId);
+    for (TrackDataListener trackDataListener : trackDataListeners) {
+      trackDataListener.onTrackUpdated(track);
+    }
+  }
+
+  /**
+   * Notifies waypoint table update. Currently, reloads all the waypoints up to
+   * {@link #MAX_DISPLAYED_WAYPOINTS}. To be run in the {@link #handler}
+   * thread.
+   * 
+   * @param trackDataListeners the track data listeners to notify
+   */
+  private void notifyWaypointsTableUpdate(Set<TrackDataListener> trackDataListeners) {
+    if (trackDataListeners.isEmpty()) {
+      return;
+    }
+
+    for (TrackDataListener trackDataListener : trackDataListeners) {
+      trackDataListener.clearWaypoints();
+    }
+
+    try (Cursor cursor = myTracksProviderUtils.getWaypointCursor(
+            selectedTrackId, -1L, MAX_DISPLAYED_WAYPOINTS)) {
+      if (cursor != null && cursor.moveToFirst()) {
+        do {
+          Waypoint waypoint = myTracksProviderUtils.createWaypoint(cursor);
+          if (!LocationUtils.isValidLocation(waypoint.getLocation())) {
+            continue;
+          }
+          for (TrackDataListener trackDataListener : trackDataListeners) {
+            trackDataListener.onNewWaypoint(waypoint);
+          }
+        } while (cursor.moveToNext());
+      }
+    }
+
+    for (TrackDataListener trackDataListener : trackDataListeners) {
+      trackDataListener.onNewWaypointsDone();
+    }
+  }
+
+  /**
+   * Notifies track points table update. To be run in the {@link #handler}
+   * thread.
+   * 
+   * @param updateSamplingState true to update the sampling state
+   * @param sampledInListeners the sampled-in listeners
+   * @param sampledOutListeners the sampled-out listeners
+   */
+  private void notifyTrackPointsTableUpdate(boolean updateSamplingState,
+      Set<TrackDataListener> sampledInListeners, Set<TrackDataListener> sampledOutListeners) {
+    if (sampledInListeners.isEmpty() && sampledOutListeners.isEmpty()) {
+      return;
+    }
+    if (updateSamplingState && numLoadedPoints >= targetNumPoints) {
+      // Reload and resample the track at a lower frequency.
+      Log.i(TAG, "Resampling track after " + numLoadedPoints + " points.");
+      resetSamplingState();
+      for (TrackDataListener listener : sampledInListeners) {
+        listener.clearTrackPoints();
+      }
+    }
+
+    int localNumLoadedPoints = updateSamplingState ? numLoadedPoints : 0;
+    long localFirstSeenLocationId = updateSamplingState ? firstSeenLocationId : -1L;
+    long localLastSeenLocationId = updateSamplingState ? lastSeenLocationId : -1L;
+    long maxPointId = updateSamplingState ? -1L : lastSeenLocationId;
+
+    long lastTrackPointId = myTracksProviderUtils.getLastTrackPointId(selectedTrackId);
+    int samplingFrequency = -1;
+    boolean includeNextPoint = false;
+    LocationIterator locationIterator = null;
+
+    try {
+      locationIterator = myTracksProviderUtils.getTrackPointLocationIterator(selectedTrackId,
+          localLastSeenLocationId + 1, false, MyTracksProviderUtils.DEFAULT_LOCATION_FACTORY);
+
+      while (locationIterator.hasNext()) {
+        Location location = locationIterator.next();
+        long locationId = locationIterator.getLocationId();
+
+        // Stop if past the last wanted point
+        if (maxPointId != -1L && locationId > maxPointId) {
+          break;
+        }
+
+        if (localFirstSeenLocationId == -1) {
+          localFirstSeenLocationId = locationId;
+        }
+
+        if (samplingFrequency == -1) {
+          long numTotalPoints = Math.max(0L, lastTrackPointId - localFirstSeenLocationId);
+          samplingFrequency = 1 + (int) (numTotalPoints / targetNumPoints);
+        }
+
+        if (!LocationUtils.isValidLocation(location)) {
+          // TODO: also include the last valid point before a split
+          for (TrackDataListener trackDataListener : sampledInListeners) {
+            trackDataListener.onSegmentSplit(location);
+            includeNextPoint = true;
+          }
+        } else {
+          // Also include the last point if the selected track is not recording.
+          if (includeNextPoint || (localNumLoadedPoints % samplingFrequency == 0)
+              || (locationId == lastTrackPointId && !isSelectedTrackRecording())) {
+            includeNextPoint = false;
+            for (TrackDataListener trackDataListener : sampledInListeners) {
+              trackDataListener.onSampledInTrackPoint(location);
+            }
+          } else {
+            for (TrackDataListener trackDataListener : sampledOutListeners) {
+              trackDataListener.onSampledOutTrackPoint(location);
+            }
+          }
+        }
+
+        localNumLoadedPoints++;
+        localLastSeenLocationId = locationId;
+      }
+    } finally {
+      if (locationIterator != null) {
+        locationIterator.close();
+      }
+    }
+
+    if (updateSamplingState) {
+      numLoadedPoints = localNumLoadedPoints;
+      firstSeenLocationId = localFirstSeenLocationId;
+      lastSeenLocationId = localLastSeenLocationId;
+    }
+
+    for (TrackDataListener listener : sampledInListeners) {
+      listener.onNewTrackPointsDone();
+    }
+  }
+
+  /**
+   * Resets the track points sampling states.
+   */
+  private void resetSamplingState() {
+    numLoadedPoints = 0;
+    firstSeenLocationId = -1L;
+    lastSeenLocationId = -1L;
+  }
+
+  /**
+   * Creates a {@link DataSource}.
+   */
+  @VisibleForTesting
+  protected DataSource newDataSource() {
+    return new DataSource(context);
+  }
+
+  /**
+   * Run in the handler thread.
+   * 
+   * @param runnable the runnable
+   */
+  @VisibleForTesting
+  protected void runInHanderThread(Runnable runnable) {
+    if (handler == null) {
+      // Use a Throwable to ensure the stack trace is logged.
+      Log.d(TAG, "handler is null.", new Throwable());
+      return;
+    }
+    handler.post(runnable);
+  }
+  
+  /**
+   * Gets the value selectedTrackId.
+   * 
+   * @return the selectedTrackId
+   */
+  public long getSelectedTrackId() {
+    return selectedTrackId;
+  }
+  
+  /**
+   * Gets the recordingGpsAccuracy.
+   */
+  @VisibleForTesting
+  int getRecordingGpsAccuracy() {
+    return recordingGpsAccuracy;
+  }
+  
+  /**
+   * Gets the metricUnits.
+   * 
+   * @return the metricUnits
+   */
+  @VisibleForTesting
+  boolean isMetricUnits() {
+    return metricUnits;
+  }
+  
+  /**
+   * Gets the reportSpeed.
+   * 
+   * @return the reportSpeed
+   */
+  @VisibleForTesting
+  boolean isReportSpeed() {
+    return reportSpeed;
+  }
+}

src/main/java/com/google/android/apps/mytracks/content/TrackDataListener.java

@@ -0,0 +1,117 @@
+/*
+ * 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 com.google.android.apps.mytracks.content;
+
+import android.location.Location;
+
+/**
+ * Listener for track data changes.
+ * 
+ * @author Rodrigo Damazio
+ */
+public interface TrackDataListener {
+
+  /**
+   * Called when the track or its statistics has been updated.
+   * 
+   * @param track the track
+   */
+  void onTrackUpdated(Track track);
+
+  /**
+   * Called to clear previously-sent track points.
+   */
+  void clearTrackPoints();
+
+  /**
+   * Called when a sampled in track point is read.
+   * 
+   * @param location the location
+   */
+  void onSampledInTrackPoint(Location location);
+
+  /**
+   * Called when a sampled out track point is read.
+   * 
+   * @param location the location
+   */
+  void onSampledOutTrackPoint(Location location);
+
+  /**
+   * Called when an invalid track point representing a segment split is read.
+   */
+  void onSegmentSplit(Location location);
+
+  /**
+   * Called when finish sending new track points. This gets called after every
+   * batch of calls to {@link #onSampledInTrackPoint(Location)},
+   * {@link #onSampledOutTrackPoint(Location)} and
+   * {@link #onSegmentSplit(Location)}.
+   */
+  void onNewTrackPointsDone();
+
+  /**
+   * Called to clear previously sent waypoints.
+   */
+  void clearWaypoints();
+
+  /**
+   * Called when a new waypoint is read.
+   * 
+   * @param waypoint the waypoint
+   */
+  void onNewWaypoint(Waypoint waypoint);
+
+  /**
+   * Called when finish sending new waypoints. This gets called after every
+   * batch of calls to {@link #clearWaypoints()} and
+   * {@link #onNewWaypoint(Waypoint)}.
+   */
+  void onNewWaypointsDone();
+
+  /**
+   * Called when the metric units preference value is change.
+   * 
+   * @param metricUnits true to use metric units, false to use imperial units
+   * @return true to reload all the data, false otherwise.
+   */
+  boolean onMetricUnitsChanged(boolean metricUnits);
+
+  /**
+   * Called when the report speed preference value is changed.
+   * 
+   * @param reportSpeed true to report speed, false to report pace
+   * @return true to reload all the data, false otherwise.
+   */
+  boolean onReportSpeedChanged(boolean reportSpeed);
+
+  /**
+   * Called when the recording gps accuracy preference value is changed.
+   * 
+   * @param recordingGpsAccuracy the new value
+   * @return true to reload all the data, false otherwise
+   */
+  boolean onRecordingGpsAccuracy(int recordingGpsAccuracy);
+  
+  /**
+   * Called when the recording distance interval preference value is changed.
+   * 
+   * @param recordingDistanceInterval the new value
+   * @return true to reload all the data, false otherwise.
+   */
+  boolean onRecordingDistanceIntervalChanged(int recordingDistanceInterval);
+}

src/main/java/com/google/android/apps/mytracks/content/TrackDataManager.java

@@ -0,0 +1,123 @@
+/*
+ * 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 com.google.android.apps.mytracks.content;
+
+import android.util.Log;
+
+import java.util.EnumMap;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Manages register/unregister {@link TrackDataListener} and keeping the state
+ * for each registered listener.
+ * 
+ * @author Rodrigo Damazio
+ */
+public class TrackDataManager {
+
+  private static final String TAG = TrackDataManager.class.getSimpleName();
+  
+  // Map of listener to its track data types
+  private final Map<TrackDataListener, EnumSet<TrackDataType>>
+      listenerToTypesMap = new HashMap<>();
+
+  // Map of track data type to listeners
+  private final Map<TrackDataType, Set<TrackDataListener>>
+      typeToListenersMap = new EnumMap<>(TrackDataType.class);
+
+  public TrackDataManager() {
+    for (TrackDataType trackDataType : TrackDataType.values()) {
+      typeToListenersMap.put(trackDataType, new LinkedHashSet<TrackDataListener>());
+    }
+  }
+
+  /**
+   * Registers a listener.
+   * 
+   * @param listener the listener
+   * @param trackDataTypes the track data types the listener is interested
+   */
+  public void registerListener(
+      TrackDataListener listener, EnumSet<TrackDataType> trackDataTypes) {
+    if (listenerToTypesMap.containsKey(listener)) {
+      Log.w(TAG, "Tried to register a listener that is already registered. Ignore.");
+      return;
+    }
+    listenerToTypesMap.put(listener, trackDataTypes);
+    for (TrackDataType trackDataType : trackDataTypes) {
+      typeToListenersMap.get(trackDataType).add(listener);
+    }
+  }
+
+  /**
+   * Unregisters a listener.
+   * 
+   * @param listener the listener
+   */
+  public void unregisterListener(TrackDataListener listener) {
+    EnumSet<TrackDataType> removedTypes = listenerToTypesMap.remove(listener);
+    if (removedTypes == null) {
+      Log.w(TAG, "Tried to unregister a listener that is not registered. Ignore.");
+      return;
+    }
+
+    // Remove the listener from the typeToListenersMap
+    for (TrackDataType trackDataType : removedTypes) {
+      typeToListenersMap.get(trackDataType).remove(listener);
+    }
+  }
+
+  /**
+   * Gets the number of {@link TrackDataListener}.
+   */
+  public int getNumberOfListeners() {
+    return listenerToTypesMap.size();
+  }
+
+  /**
+   * Gets the track data types for a listener.
+   * 
+   * @param listener the listener
+   */
+  public EnumSet<TrackDataType> getTrackDataTypes(TrackDataListener listener) {
+    return listenerToTypesMap.get(listener);
+  }
+
+  /**
+   * Gets the listeners for a {@link TrackDataType}.
+   * 
+   * @param type the type
+   */
+  public Set<TrackDataListener> getListeners(TrackDataType type) {
+    return typeToListenersMap.get(type);
+  }
+
+  /**
+   * Gets all the registered {@link TrackDataType}.
+   */
+  public EnumSet<TrackDataType> getRegisteredTrackDataTypes() {
+    EnumSet<TrackDataType> types = EnumSet.noneOf(TrackDataType.class);
+    for (EnumSet<TrackDataType> value : listenerToTypesMap.values()) {
+      types.addAll(value);
+    }
+    return types;
+  }
+}

src/main/java/com/google/android/apps/mytracks/content/TrackDataType.java

@@ -0,0 +1,30 @@
+/*
+ * 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 com.google.android.apps.mytracks.content;
+
+/**
+ * Types of track data.
+ * 
+ * @author Jimmy Shih
+ */
+public enum TrackDataType {
+  TRACKS_TABLE, // tracks table changes
+  WAYPOINTS_TABLE, // waypoints table changes
+  SAMPLED_IN_TRACK_POINTS_TABLE, // sampled-in track points table changes
+  SAMPLED_OUT_TRACK_POINTS_TABLE, // sampled-out track points table changes
+  PREFERENCE // preference changes
+}

src/main/java/com/google/android/apps/mytracks/content/TrackPointsColumns.java

@@ -0,0 +1,61 @@
+/*
+ * 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 com.google.android.apps.mytracks.content;
+
+import android.net.Uri;
+import android.provider.BaseColumns;
+
+/**
+ * Constants for the track points table.
+ *
+ * @author Leif Hendrik Wilden
+ */
+public interface TrackPointsColumns extends BaseColumns {
+
+  String TABLE_NAME = "trackpoints";
+  Uri CONTENT_URI = Uri.parse("content://com.google.android.maps.mytracks/trackpoints");
+  String CONTENT_TYPE = "vnd.android.cursor.dir/vnd.google.trackpoint";
+  String CONTENT_ITEMTYPE = "vnd.android.cursor.item/vnd.google.trackpoint";
+  String DEFAULT_SORT_ORDER = "_id";
+
+  // Columns
+  String TRACKID = "trackid";
+  String LONGITUDE = "longitude";
+  String LATITUDE = "latitude";
+  String TIME = "time";
+  String ALTITUDE = "elevation";
+  String ACCURACY = "accuracy";
+  String SPEED = "speed";
+  String BEARING = "bearing";
+  String SENSOR_HEARTRATE = "sensor_heartrate";
+  String SENSOR_CADENCE = "sensor_cadence";
+  String SENSOR_POWER = "sensor_power";
+
+  String CREATE_TABLE = "CREATE TABLE " + TABLE_NAME + " ("
+      + _ID + " INTEGER PRIMARY KEY AUTOINCREMENT, "
+      + TRACKID + " INTEGER, "
+      + LONGITUDE + " INTEGER, "
+      + LATITUDE + " INTEGER, "
+      + TIME + " INTEGER, "
+      + ALTITUDE + " FLOAT, "
+      + ACCURACY + " FLOAT, "
+      + SPEED + " FLOAT, "
+      + BEARING + " FLOAT, "
+      + SENSOR_HEARTRATE + " FLOAT, "
+      + SENSOR_CADENCE + " FLOAT, "
+      + SENSOR_POWER + " FLOAT);";
+}

src/main/java/com/google/android/apps/mytracks/content/TracksColumns.java

@@ -0,0 +1,105 @@
+/*
+ * 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 com.google.android.apps.mytracks.content;
+
+import android.net.Uri;
+import android.provider.BaseColumns;
+
+/**
+ * Constants for the tracks table.
+ * 
+ * @author Leif Hendrik Wilden
+ */
+public interface TracksColumns extends BaseColumns {
+
+  String TABLE_NAME = "tracks";
+
+  /**
+   * Tracks provider uri.
+   */
+  Uri CONTENT_URI = Uri.parse("content://com.google.android.maps.mytracks/tracks");
+
+  /**
+   * Track content type.
+   */
+  String CONTENT_TYPE = "vnd.android.cursor.dir/vnd.google.track";
+
+  /**
+   * Track id content type.
+   */
+  String CONTENT_ITEMTYPE = "vnd.android.cursor.item/vnd.google.track";
+
+  /**
+   * Tracks table default sort order.
+   */
+  String DEFAULT_SORT_ORDER = "_id";
+
+  // Columns
+  String NAME = "name"; // track name
+  String DESCRIPTION = "description"; // track description
+  String CATEGORY = "category"; // track activity type
+  String STARTID = "startid"; // first track point id
+  String STOPID = "stopid"; // last track point id
+  String STARTTIME = "starttime"; // track start time
+  String STOPTIME = "stoptime"; // track stop time
+  String NUMPOINTS = "numpoints"; // number of track points
+  String TOTALDISTANCE = "totaldistance"; // total distance
+  String TOTALTIME = "totaltime"; // total time
+  String MOVINGTIME = "movingtime"; // moving time
+  String MINLAT = "minlat"; // minimum latitude
+  String MAXLAT = "maxlat"; // maximum latitude
+  String MINLON = "minlon"; // minimum longitude
+  String MAXLON = "maxlon"; // maximum longitude
+  String AVGSPEED = "avgspeed"; // average speed
+
+  // average moving speed
+  String AVGMOVINGSPEED = "avgmovingspeed";
+  String MAXSPEED = "maxspeed"; // maximum speed
+  String MINELEVATION = "minelevation"; // minimum elevation
+  String MAXELEVATION = "maxelevation"; // maximum elevation
+  String ELEVATIONGAIN = "elevationgain"; // elevation gain
+  String MINGRADE = "mingrade"; // minimum grade
+  String MAXGRADE = "maxgrade"; // maximum grade
+  String ICON = "icon"; // track activity type icon
+
+  String CREATE_TABLE = "CREATE TABLE " + TABLE_NAME + " (" // table
+      + _ID + " INTEGER PRIMARY KEY AUTOINCREMENT, " // id
+      + NAME + " STRING, " // name
+      + DESCRIPTION + " STRING, " // description
+      + CATEGORY + " STRING, " // category
+      + STARTID + " INTEGER, " // start id
+      + STOPID + " INTEGER, " // stop id
+      + STARTTIME + " INTEGER, " // start time
+      + STOPTIME + " INTEGER, " // stop time
+      + NUMPOINTS + " INTEGER, " // num points
+      + TOTALDISTANCE + " FLOAT, " // total distance
+      + TOTALTIME + " INTEGER, " // total time
+      + MOVINGTIME + " INTEGER, " // moving time
+      + MINLAT + " INTEGER, " // min latitude
+      + MAXLAT + " INTEGER, " // max latitude
+      + MINLON + " INTEGER, " // min longitude
+      + MAXLON + " INTEGER, " // max longitude
+      + AVGSPEED + " FLOAT, " // average speed
+      + AVGMOVINGSPEED + " FLOAT, " // average moving speed
+      + MAXSPEED + " FLOAT, " // max speed
+      + MINELEVATION + " FLOAT, " // min elevation
+      + MAXELEVATION + " FLOAT, " // max elevation
+      + ELEVATIONGAIN + " FLOAT, " // elevation gain
+      + MINGRADE + " FLOAT, " // min grade
+      + MAXGRADE + " FLOAT, " // max grade
+      + ICON + " STRING);"; // icon
+}

src/main/java/com/google/android/apps/mytracks/content/Waypoint.aidl

@@ -0,0 +1,2 @@
+package com.google.android.apps.mytracks.content;
+parcelable Waypoint;

src/main/java/com/google/android/apps/mytracks/content/Waypoint.java

@@ -0,0 +1,258 @@
+/*
+ * 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 com.google.android.apps.mytracks.content;
+
+import android.location.Location;
+import android.net.Uri;
+import android.os.Parcel;
+import android.os.Parcelable;
+
+import com.google.android.apps.mytracks.stats.TripStatistics;
+
+/**
+ * A waypoint.
+ * 
+ * @author Leif Hendrik Wilden
+ * @author Rodrigo Damazio
+ */
+public final class Waypoint implements Parcelable {
+
+  public enum WaypointType {
+    WAYPOINT, STATISTICS
+  }
+
+  private long id = -1L;
+  private String name = "";
+  private String description = "";
+  private String category = "";
+  private String icon = "";
+  private long trackId = -1L;
+  private WaypointType type = WaypointType.WAYPOINT;
+  private double length = 0.0;
+  private long duration = 0;
+  private long startId = -1L;
+  private long stopId = -1L;
+  private Location location = null;
+  private TripStatistics tripStatistics = null;
+  private String photoUrl = "";
+  
+  public Waypoint() {}
+  
+  public Waypoint(String name, String description, String category, String icon, long trackId,
+      WaypointType type, double length, long duration, long startId, long stopId, Location location,
+      TripStatistics tripStatistics, String photoUrl) {
+    this.name = name;
+    this.description = description;
+    this.category = category;
+    this.icon = icon;
+    this.trackId = trackId;
+    this.type = type;
+    this.length = length;
+    this.duration = duration;
+    this.startId = startId;
+    this.stopId = stopId;
+    this.location = location;
+    this.tripStatistics = tripStatistics;
+    this.photoUrl = photoUrl;
+  }
+
+  private Waypoint(Parcel source) {
+    id = source.readLong();
+    name = source.readString();
+    description = source.readString();
+    category = source.readString();
+    icon = source.readString();
+    trackId = source.readLong();
+    type = WaypointType.values()[source.readInt()];
+    length = source.readDouble();
+    duration = source.readLong();
+    startId = source.readLong();
+    stopId = source.readLong();
+ 
+    ClassLoader classLoader = getClass().getClassLoader();
+    byte hasLocation = source.readByte();
+    if (hasLocation > 0) {
+      location = source.readParcelable(classLoader);
+    }
+    byte hasStats = source.readByte();
+    if (hasStats > 0) {
+      tripStatistics = source.readParcelable(classLoader);
+    }
+    photoUrl = source.readString();
+  }
+
+  @Override
+  public int describeContents() {
+    return 0;
+  }
+
+  @Override
+  public void writeToParcel(Parcel dest, int flags) {
+    dest.writeLong(id);
+    dest.writeString(name);
+    dest.writeString(description);
+    dest.writeString(category);
+    dest.writeString(icon);
+    dest.writeLong(trackId);
+    dest.writeInt(type.ordinal());
+    dest.writeDouble(length);
+    dest.writeLong(duration);
+    dest.writeLong(startId);
+    dest.writeLong(stopId);
+    dest.writeByte(location == null ? (byte) 0 : (byte) 1);
+    if (location != null) {
+      dest.writeParcelable(location, 0);
+    }
+    dest.writeByte(tripStatistics == null ? (byte) 0 : (byte) 1);
+    if (tripStatistics != null) {
+      dest.writeParcelable(tripStatistics, 0);
+    }
+    dest.writeString(photoUrl);
+  }
+
+  public static final Parcelable.Creator<Waypoint> CREATOR = new Parcelable.Creator<Waypoint>() {
+      @Override
+    public Waypoint createFromParcel(Parcel in) {
+      return new Waypoint(in);
+    }
+
+      @Override
+    public Waypoint[] newArray(int size) {
+      return new Waypoint[size];
+    }
+  };
+
+  public long getId() {
+    return id;
+  }
+
+  public void setId(long id) {
+    this.id = id;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public void setName(String name) {
+    this.name = name;
+  }
+
+  public String getDescription() {
+    return description;
+  }
+
+  public void setDescription(String description) {
+    this.description = description;
+  }
+
+  public String getCategory() {
+    return category;
+  }
+
+  public void setCategory(String category) {
+    this.category = category;
+  }
+
+  public String getIcon() {
+    return icon;
+  }
+
+  public void setIcon(String icon) {
+    this.icon = icon;
+  }
+
+  public long getTrackId() {
+    return trackId;
+  }
+
+  public void setTrackId(long trackId) {
+    this.trackId = trackId;
+  }
+
+  public WaypointType getType() {
+    return type;
+  }
+
+  public void setType(WaypointType type) {
+    this.type = type;
+  }
+
+  public double getLength() {
+    return length;
+  }
+
+  public void setLength(double length) {
+    this.length = length;
+  }
+
+  public long getDuration() {
+    return duration;
+  }
+
+  public void setDuration(long duration) {
+    this.duration = duration;
+  }
+
+  public long getStartId() {
+    return startId;
+  }
+
+  public void setStartId(long startId) {
+    this.startId = startId;
+  }
+
+  public long getStopId() {
+    return stopId;
+  }
+
+  public void setStopId(long stopId) {
+    this.stopId = stopId;
+  }
+
+  public Location getLocation() {
+    return location;
+  }
+
+  public void setLocation(Location location) {
+    this.location = location;
+  }
+
+  public TripStatistics getTripStatistics() {
+    return tripStatistics;
+  }
+
+  public void setTripStatistics(TripStatistics tripStatistics) {
+    this.tripStatistics = tripStatistics;
+  }  
+  
+  public String getPhotoUrl() {
+    return photoUrl;
+  }
+
+  public Uri getPhotoURI() {
+    return Uri.parse(photoUrl);
+  }
+
+  public boolean hasPhoto() {
+    return photoUrl != null && !"".equals(photoUrl);
+  }
+
+  public void setPhotoUrl(String photoUrl) {
+    this.photoUrl = photoUrl;
+  }
+}

src/main/java/com/google/android/apps/mytracks/content/WaypointCreationRequest.aidl

@@ -0,0 +1,2 @@
+package com.google.android.apps.mytracks.content;
+parcelable WaypointCreationRequest;

src/main/java/com/google/android/apps/mytracks/content/WaypointCreationRequest.java

@@ -0,0 +1,125 @@
+/*
+ * 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 com.google.android.apps.mytracks.content;
+
+import com.google.android.apps.mytracks.content.Waypoint.WaypointType;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+
+/**
+ * A request for the service to create a waypoint at the current location.
+ * 
+ * @author Sandor Dornbush
+ */
+public class WaypointCreationRequest implements Parcelable {
+
+  private WaypointType type;
+  // true if this marker contains the track statistics
+  private boolean isTrackStatistics;
+  private String name;
+  private String category;
+  private String description;
+  private String iconUrl;
+  private String photoUrl;
+
+  public final static WaypointCreationRequest DEFAULT_WAYPOINT = new WaypointCreationRequest(
+      WaypointType.WAYPOINT, false);
+  public final static WaypointCreationRequest DEFAULT_STATISTICS = new WaypointCreationRequest(
+      WaypointType.STATISTICS, false);
+  public final static WaypointCreationRequest DEFAULT_START_TRACK = new WaypointCreationRequest(
+      WaypointType.STATISTICS, true);
+
+  private WaypointCreationRequest(WaypointType type, boolean isTrackStatistics) {
+    this(type, isTrackStatistics, null, null, null, null, null);
+  }
+
+  public WaypointCreationRequest(WaypointType type, boolean isTrackStatistics, String name,
+      String category, String description, String iconUrl, String photoUrl) {
+    this.type = type;
+    this.isTrackStatistics = isTrackStatistics;
+    this.name = name;
+    this.category = category;
+    this.description = description;
+    this.iconUrl = iconUrl;
+    this.photoUrl = photoUrl;
+  }
+
+  public static class Creator implements Parcelable.Creator<WaypointCreationRequest> {
+
+    @Override
+    public WaypointCreationRequest createFromParcel(Parcel source) {
+      return new WaypointCreationRequest(
+          WaypointType.values()[source.readInt()],
+          source.readByte() == 1,
+          source.readString(),
+          source.readString(),
+          source.readString(),
+          source.readString(),
+          source.readString());
+    }
+
+    public WaypointCreationRequest[] newArray(int size) {
+      return new WaypointCreationRequest[size];
+    }
+  }
+
+  public static final Creator CREATOR = new Creator();
+
+  @Override
+  public int describeContents() {
+    return 0;
+  }
+
+  @Override
+  public void writeToParcel(Parcel parcel, int arg1) {
+    parcel.writeInt(type.ordinal());
+    parcel.writeByte((byte) (isTrackStatistics ? 1 : 0));
+    parcel.writeString(name);
+    parcel.writeString(category);
+    parcel.writeString(description);
+    parcel.writeString(iconUrl);
+    parcel.writeString(photoUrl);
+  }
+
+  public WaypointType getType() {
+    return type;
+  }
+
+  public boolean isTrackStatistics() {
+    return isTrackStatistics;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public String getCategory() {
+    return category;
+  }
+
+  public String getDescription() {
+    return description;
+  }
+
+  public String getIconUrl() {
+    return iconUrl;
+  }
+  
+  public String getPhotoUrl() {
+    return photoUrl;
+  }
+}

src/main/java/com/google/android/apps/mytracks/content/WaypointsColumns.java

@@ -0,0 +1,103 @@
+/*
+ * 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 com.google.android.apps.mytracks.content;
+
+import android.net.Uri;
+import android.provider.BaseColumns;
+
+/**
+ * Constants for waypoints table.
+ * 
+ * @author Leif Hendrik Wilden
+ */
+public interface WaypointsColumns extends BaseColumns {
+
+  String TABLE_NAME = "waypoints";
+  Uri CONTENT_URI = Uri.parse("content://com.google.android.maps.mytracks/waypoints");
+  String CONTENT_TYPE = "vnd.android.cursor.dir/vnd.google.waypoint";
+  String CONTENT_ITEMTYPE = "vnd.android.cursor.item/vnd.google.waypoint";
+  String DEFAULT_SORT_ORDER = "_id";
+
+  // Columns
+  String NAME = "name"; // waypoint name
+  String DESCRIPTION = "description"; // waypoint description
+  String CATEGORY = "category"; // waypoint category
+  String ICON = "icon"; // waypoint icon
+  String TRACKID = "trackid"; // track id
+  String TYPE = "type"; // type
+  String LENGTH = "length"; // length of the track (without smoothing)
+  String DURATION = "duration"; // total duration of the track (not from last waypoint)
+  String STARTTIME = "starttime"; // start time of the trip statistics
+  String STARTID = "startid"; // start track point id
+  String STOPID = "stopid"; // stop track point id
+
+  String LONGITUDE = "longitude"; // longitude
+  String LATITUDE = "latitude"; // latitude
+  String TIME = "time"; // time
+  String ALTITUDE = "elevation"; // altitude
+  String ACCURACY = "accuracy"; // accuracy
+  String SPEED = "speed"; // speed
+  String BEARING = "bearing"; // bearing
+
+  String TOTALDISTANCE = "totaldistance"; // total distance
+  String TOTALTIME = "totaltime"; // total time
+  String MOVINGTIME = "movingtime"; // moving time
+  String AVGSPEED = "avgspeed"; // average speed
+  String AVGMOVINGSPEED = "avgmovingspeed"; // average moving speed
+  String MAXSPEED = "maxspeed"; // max speed
+  String MINELEVATION = "minelevation"; // min elevation
+  String MAXELEVATION = "maxelevation"; // max elevation
+  String ELEVATIONGAIN = "elevationgain"; // elevation gain
+  String MINGRADE = "mingrade"; // min grade
+  String MAXGRADE = "maxgrade"; // max grade
+
+  String PHOTOURL = "photoUrl"; // url for the photo
+  
+  String CREATE_TABLE = "CREATE TABLE " + TABLE_NAME + " ("
+      + _ID + " INTEGER PRIMARY KEY AUTOINCREMENT, "
+      + NAME + " STRING, "
+      + DESCRIPTION + " STRING, "
+      + CATEGORY + " STRING, "
+      + ICON + " STRING, "
+      + TRACKID + " INTEGER, "
+      + TYPE + " INTEGER, "
+      + LENGTH + " FLOAT, "
+      + DURATION + " INTEGER, "
+      + STARTTIME + " INTEGER, "
+      + STARTID + " INTEGER, "
+      + STOPID + " INTEGER, "
+      + LONGITUDE + " INTEGER, "
+      + LATITUDE + " INTEGER, "
+      + TIME + " INTEGER, "
+      + ALTITUDE + " FLOAT, "
+      + ACCURACY + " FLOAT, "
+      + SPEED + " FLOAT, "
+      + BEARING + " FLOAT, "
+      + TOTALDISTANCE + " FLOAT, "
+      + TOTALTIME + " INTEGER, "
+      + MOVINGTIME + " INTEGER, "
+      + AVGSPEED + " FLOAT, "
+      + AVGMOVINGSPEED + " FLOAT, "
+      + MAXSPEED + " FLOAT, "
+      + MINELEVATION + " FLOAT, "
+      + MAXELEVATION + " FLOAT, "
+      + ELEVATIONGAIN + " FLOAT, "
+      + MINGRADE + " FLOAT, "
+      + MAXGRADE + " FLOAT, "
+      + PHOTOURL + " STRING"
+      + ");";
+}

src/main/java/com/google/android/apps/mytracks/content/sensor/SensorDataSet.java

@@ -0,0 +1,95 @@
+package com.google.android.apps.mytracks.content.sensor;
+
+public final class SensorDataSet {
+
+    public static final float DATA_UNAVAILABLE = Integer.MAX_VALUE;
+
+    //TODO It might be necessary to consider: sensor if sensor was connected as well.
+
+    private float heartRate;
+    private float cadence;
+    private float power;
+    private float batteryLevel;
+    private long creationTimestamp;
+
+    public String sensorName;
+    public String sensorAddress;
+
+    public SensorDataSet(float heartRate, float cadence, float power, float batteryLevel, long creationTimestamp) {
+        this.heartRate = heartRate;
+        this.cadence = cadence;
+        this.power = power;
+        this.batteryLevel = batteryLevel;
+        this.creationTimestamp = creationTimestamp;
+    }
+
+    public SensorDataSet(float heartRate, float cadence, float power, float batteryLevel) {
+        this(heartRate, cadence, power, batteryLevel, System.currentTimeMillis());
+    }
+
+    public SensorDataSet(float heartRate, float cadence, float power) {
+        this(heartRate, cadence, power, DATA_UNAVAILABLE, System.currentTimeMillis());
+    }
+
+    public SensorDataSet(float heartRate, float cadence) {
+        this(heartRate, cadence, DATA_UNAVAILABLE, DATA_UNAVAILABLE, System.currentTimeMillis());
+    }
+
+    public SensorDataSet(float heartRate, String sensorName, String sensorAddress) {
+        this(heartRate, DATA_UNAVAILABLE, DATA_UNAVAILABLE, DATA_UNAVAILABLE, System.currentTimeMillis());
+        this.sensorName = sensorName;
+        this.sensorAddress = sensorAddress;
+    }
+
+    public boolean hasHeartRate() {
+        return heartRate != DATA_UNAVAILABLE;
+    }
+
+    public float getHeartRate() {
+        return heartRate;
+    }
+
+    public boolean hasCadence() {
+        return cadence != DATA_UNAVAILABLE;
+    }
+
+    public float getCadence() {
+        return cadence;
+    }
+
+    public boolean hasPower() {
+        return power != DATA_UNAVAILABLE;
+    }
+
+    public float getPower() {
+        return power;
+    }
+
+    public long getCreationTime() {
+        return creationTimestamp;
+    }
+
+    /**
+     * Is the data recent considering the current time.
+     * @param maxAge the maximal age in milliseconds.
+     */
+    public boolean isRecent(long maxAge) {
+        return creationTimestamp + maxAge > System.currentTimeMillis();
+    }
+
+    public boolean hasBatteryLevel() {
+        return batteryLevel != DATA_UNAVAILABLE;
+    }
+
+    public float getBatteryLevel() {
+        return batteryLevel;
+    }
+
+    public String getSensorName() {
+        return sensorName;
+    }
+
+    public String getSensorAddress() {
+        return sensorAddress;
+    }
+}

src/main/java/com/google/android/apps/mytracks/content/sensor/SensorState.java

@@ -0,0 +1,27 @@
+package com.google.android.apps.mytracks.content.sensor;
+
+import android.content.Context;
+
+import com.google.android.maps.mytracks.R;
+
+public enum SensorState {
+    NONE,
+    CONNECTING,
+    CONNECTED,
+    DISCONNECTED;
+
+    public static String getStateAsString(SensorState state, Context c) {
+        switch (state) {
+            case NONE:
+                return c.getString(R.string.value_none);
+            case CONNECTING:
+                return c.getString(R.string.sensor_state_connecting);
+            case CONNECTED:
+                return c.getString(R.string.sensor_state_connected);
+            case DISCONNECTED:
+                return c.getString(R.string.sensor_state_disconnected);
+            default:
+                return "";
+        }
+    }
+}

src/main/java/com/google/android/apps/mytracks/fragments/AbstractMyTracksDialogFragment.java

@@ -0,0 +1,49 @@
+/*
+ * 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 com.google.android.apps.mytracks.fragments;
+
+import com.google.android.apps.mytracks.util.DialogUtils;
+
+import android.app.Dialog;
+import android.content.DialogInterface;
+import android.os.Bundle;
+import androidx.annotation.NonNull;
+import androidx.fragment.app.DialogFragment;
+
+/**
+ * Abstract My Tracks DialogFragment.
+ * 
+ * @author Jimmy Shih
+ */
+public abstract class AbstractMyTracksDialogFragment extends DialogFragment {
+
+  @NonNull
+  @Override
+  public Dialog onCreateDialog(Bundle savedInstanceState) {
+    final Dialog dialog = createDialog();
+    dialog.setOnShowListener(new DialogInterface.OnShowListener() {
+
+        @Override
+      public void onShow(DialogInterface dialogInterface) {
+        DialogUtils.setDialogTitleDivider(getActivity(), dialog);
+      }
+    });
+    return dialog;
+  }
+
+  protected abstract Dialog createDialog();
+}

src/main/java/com/google/android/apps/mytracks/fragments/ChartFragment.java

@@ -0,0 +1,521 @@
+/*
+ * 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 com.google.android.apps.mytracks.fragments;
+
+import android.location.Location;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewGroup.LayoutParams;
+import android.widget.ZoomControls;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.VisibleForTesting;
+import androidx.fragment.app.Fragment;
+import androidx.fragment.app.FragmentActivity;
+
+import com.google.android.apps.mytracks.ChartView;
+import com.google.android.apps.mytracks.TrackDetailActivity;
+import com.google.android.apps.mytracks.content.MyTracksLocation;
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.content.TrackDataHub;
+import com.google.android.apps.mytracks.content.TrackDataListener;
+import com.google.android.apps.mytracks.content.TrackDataType;
+import com.google.android.apps.mytracks.content.Waypoint;
+import com.google.android.apps.mytracks.content.sensor.SensorDataSet;
+import com.google.android.apps.mytracks.stats.TripStatistics;
+import com.google.android.apps.mytracks.stats.TripStatisticsUpdater;
+import com.google.android.apps.mytracks.util.LocationUtils;
+import com.google.android.apps.mytracks.util.PreferencesUtils;
+import com.google.android.apps.mytracks.util.UnitConversions;
+import com.google.android.maps.mytracks.R;
+
+import java.util.ArrayList;
+import java.util.EnumSet;
+
+/**
+ * A fragment to display track chart to the user.
+ * 
+ * @author Sandor Dornbush
+ * @author Rodrigo Damazio
+ */
+public class ChartFragment extends Fragment implements TrackDataListener {
+
+  public static final String CHART_FRAGMENT_TAG = "chartFragment";
+
+  private final ArrayList<double[]> pendingPoints = new ArrayList<>();
+
+  private TrackDataHub trackDataHub;
+
+  // Stats gathered from the received data
+  private TripStatisticsUpdater tripStatisticsUpdater;
+  private long startTime;
+
+  private boolean metricUnits = true;
+  private boolean reportSpeed = true;
+  private int recordingDistanceInterval = PreferencesUtils.RECORDING_DISTANCE_INTERVAL_DEFAULT;
+
+  // Modes of operation
+  private boolean chartByDistance = true;
+  private boolean[] chartShow = new boolean[] { true, true, true, true, true, true };
+
+  // UI elements
+  private ChartView chartView;
+  private ZoomControls zoomControls;
+
+  /**
+   * A runnable that will enable/disable zoom controls and orange pointer as
+   * appropriate and redraw.
+   */
+  private final Runnable updateChart = new Runnable() {
+      @Override
+    public void run() {
+      if (!isResumed() || trackDataHub == null) {
+        return;
+      }
+
+      zoomControls.setIsZoomInEnabled(chartView.canZoomIn());
+      zoomControls.setIsZoomOutEnabled(chartView.canZoomOut());
+      chartView.setShowPointer(isSelectedTrackRecording());
+      chartView.invalidate();
+    }
+  };
+
+  @Override
+  public void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+
+    /*
+     * Create a chartView here to store data thus won't need to reload all the
+     * data on every onStart or onResume.
+     */
+    chartView = new ChartView(getActivity());
+  }
+
+  @Override
+  public View onCreateView(
+          @NonNull LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+    View view = inflater.inflate(R.layout.chart, container, false);
+    zoomControls = view.findViewById(R.id.chart_zoom_controls);
+    zoomControls.setOnZoomInClickListener(new View.OnClickListener() {
+        @Override
+      public void onClick(View v) {
+        zoomIn();
+      }
+    });
+    zoomControls.setOnZoomOutClickListener(new View.OnClickListener() {
+        @Override
+      public void onClick(View v) {
+        zoomOut();
+      }
+    });
+    return view;
+  }
+
+  @Override
+  public void onStart() {
+    super.onStart();
+    ViewGroup layout = getActivity().findViewById(R.id.chart_view_layout);
+    LayoutParams layoutParams = new LayoutParams(
+        LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
+    layout.addView(chartView, layoutParams);
+  }
+
+  @Override
+  public void onResume() {
+    super.onResume();
+    resumeTrackDataHub();
+    checkChartSettings();
+    getActivity().runOnUiThread(updateChart);
+  }
+
+  @Override
+  public void onPause() {
+    super.onPause();
+    pauseTrackDataHub();
+  }
+
+  @Override
+  public void onStop() {
+    super.onStop();
+    ViewGroup layout = getActivity().findViewById(R.id.chart_view_layout);
+    layout.removeView(chartView);
+  }
+
+  @Override
+  public void onTrackUpdated(Track track) {
+    if (isResumed()) {
+      if (track == null || track.getTripStatistics() == null) {
+        startTime = -1L;
+        return;
+      }
+      startTime = track.getTripStatistics().getStartTime();
+    }
+  }
+
+  @Override
+  public void clearTrackPoints() {
+    if (isResumed()) {
+      tripStatisticsUpdater = startTime != -1L ? new TripStatisticsUpdater(startTime) : null;
+      pendingPoints.clear();
+      chartView.reset();
+      runOnUiThread(new Runnable() {
+          @Override
+        public void run() {
+          if (isResumed()) {
+            chartView.resetScroll();
+          }
+        }
+      });
+    }
+  }
+
+  @Override
+  public void onSampledInTrackPoint(Location location) {
+    if (isResumed()) {
+      double[] data = new double[ChartView.NUM_SERIES + 1];
+      fillDataPoint(location, data);
+      pendingPoints.add(data);
+    }
+  }
+
+  @Override
+  public void onSampledOutTrackPoint(Location location) {
+    if (isResumed()) {
+      fillDataPoint(location, null);
+    }
+  }
+
+  @Override
+  public void onSegmentSplit(Location location) {
+    if (isResumed()) {
+      fillDataPoint(location, null);
+    }
+  }
+
+  @Override
+  public void onNewTrackPointsDone() {
+    if (isResumed()) {
+      chartView.addDataPoints(pendingPoints);
+      pendingPoints.clear();
+      runOnUiThread(updateChart);
+    }
+  }
+
+  @Override
+  public void clearWaypoints() {
+    if (isResumed()) {
+      chartView.clearWaypoints();
+    }
+  }
+
+  @Override
+  public void onNewWaypoint(Waypoint waypoint) {
+    if (isResumed() && waypoint != null && LocationUtils.isValidLocation(waypoint.getLocation())) {
+      chartView.addWaypoint(waypoint);
+    }
+  }
+
+  @Override
+  public void onNewWaypointsDone() {
+    if (isResumed()) {
+      runOnUiThread(updateChart);
+    }
+  }
+
+  @Override
+  public boolean onMetricUnitsChanged(boolean metric) {
+    if (isResumed()) {
+      if (metricUnits == metric) {
+        return false;
+      }
+      metricUnits = metric;
+      chartView.setMetricUnits(metricUnits);
+      runOnUiThread(new Runnable() {
+          @Override
+        public void run() {
+          if (isResumed()) {
+            chartView.requestLayout();
+          }
+        }
+      });
+      return true;
+    }
+    return false;
+  }
+
+  @Override
+  public boolean onReportSpeedChanged(boolean speed) {
+    if (isResumed()) {
+      if (reportSpeed == speed) {
+        return false;
+      }
+      reportSpeed = speed;
+      chartView.setReportSpeed(reportSpeed);
+      boolean chartShowSpeed = PreferencesUtils.getBoolean(
+          getActivity(), R.string.chart_show_speed_key, PreferencesUtils.CHART_SHOW_SPEED_DEFAULT);
+      setSeriesEnabled(ChartView.SPEED_SERIES, chartShowSpeed && reportSpeed);
+      setSeriesEnabled(ChartView.PACE_SERIES, chartShowSpeed && !reportSpeed);
+      runOnUiThread(new Runnable() {
+          @Override
+        public void run() {
+          if (isResumed()) {
+            chartView.requestLayout();
+          }
+        }
+      });
+      return true;
+    }
+    return false;
+  }
+
+  @Override
+  public boolean onRecordingGpsAccuracy(int minRequiredAccuracy) {
+    // We don't care.
+    return false;
+  }
+  
+  @Override
+  public boolean onRecordingDistanceIntervalChanged(int value) {
+    if (isResumed()) {
+      if (recordingDistanceInterval == value) {
+        return false;
+      }
+      recordingDistanceInterval = value;
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Checks the chart settings.
+   */
+  private void checkChartSettings() {
+    boolean needUpdate = false;
+    if (chartByDistance != PreferencesUtils.isChartByDistance(getActivity())) {
+      chartByDistance = !chartByDistance;
+      chartView.setChartByDistance(chartByDistance);
+      reloadTrackDataHub();
+      needUpdate = true;
+    }
+    if (setSeriesEnabled(ChartView.ELEVATION_SERIES, PreferencesUtils.getBoolean(getActivity(), R.string.chart_show_elevation_key, PreferencesUtils.CHART_SHOW_ELEVATION_DEFAULT))) {
+      needUpdate = true;
+    }
+
+    boolean chartShowSpeed = PreferencesUtils.getBoolean(getActivity(), R.string.chart_show_speed_key, PreferencesUtils.CHART_SHOW_SPEED_DEFAULT);
+    if (setSeriesEnabled(ChartView.SPEED_SERIES, chartShowSpeed && reportSpeed)) {
+      needUpdate = true;
+    }
+    if (setSeriesEnabled(ChartView.PACE_SERIES, chartShowSpeed && !reportSpeed)) {
+      needUpdate = true;
+    }
+    if (setSeriesEnabled(ChartView.POWER_SERIES, PreferencesUtils.getBoolean(getActivity(), R.string.chart_show_power_key, PreferencesUtils.CHART_SHOW_POWER_DEFAULT))) {
+      needUpdate = true;
+    }
+    if (setSeriesEnabled(ChartView.CADENCE_SERIES, PreferencesUtils.getBoolean(getActivity(), R.string.chart_show_cadence_key, PreferencesUtils.CHART_SHOW_CADENCE_DEFAULT))) {
+      needUpdate = true;
+    }
+    if (setSeriesEnabled(ChartView.HEART_RATE_SERIES, PreferencesUtils.getBoolean(getActivity(), R.string.chart_show_heart_rate_key, PreferencesUtils.CHART_SHOW_HEART_RATE_DEFAULT))) {
+      needUpdate = true;
+    }
+    if (needUpdate) {
+      chartView.postInvalidate();
+    }
+  }
+
+  /**
+   * Sets the series enabled value.
+   * 
+   * @param index the series index
+   * @param value the value
+   * @return true if changed
+   */
+  private boolean setSeriesEnabled(int index, boolean value) {
+    if (chartShow[index] != value) {
+      chartShow[index] = value;
+      chartView.setChartValueSeriesEnabled(index, value);
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  /**
+   * Resumes the trackDataHub. Needs to be synchronized because trackDataHub can
+   * be accessed by multiple threads.
+   */
+  private synchronized void resumeTrackDataHub() {
+    trackDataHub = ((TrackDetailActivity) getActivity()).getTrackDataHub();
+    trackDataHub.registerTrackDataListener(this, EnumSet.of(TrackDataType.TRACKS_TABLE,
+        TrackDataType.WAYPOINTS_TABLE, TrackDataType.SAMPLED_IN_TRACK_POINTS_TABLE,
+        TrackDataType.SAMPLED_OUT_TRACK_POINTS_TABLE, TrackDataType.PREFERENCE));
+  }
+
+  /**
+   * Pauses the trackDataHub. Needs to be synchronized because trackDataHub can
+   * be accessed by multiple threads.
+   */
+  private synchronized void pauseTrackDataHub() {
+    trackDataHub.unregisterTrackDataListener(this);
+    trackDataHub = null;
+  }
+
+  /**
+   * Returns true if the selected track is recording. Needs to be synchronized
+   * because trackDataHub can be accessed by multiple threads.
+   */
+  private synchronized boolean isSelectedTrackRecording() {
+    return trackDataHub != null && trackDataHub.isSelectedTrackRecording();
+  }
+
+  /**
+   * Reloads the trackDataHub. Needs to be synchronized because trackDataHub can
+   * be accessed by multiple threads.
+   */
+  private synchronized void reloadTrackDataHub() {
+    if (trackDataHub != null) {
+      trackDataHub.reloadDataForListener(this);
+    }
+  }
+
+  /**
+   * To zoom in.
+   */
+  private void zoomIn() {
+    chartView.zoomIn();
+    zoomControls.setIsZoomInEnabled(chartView.canZoomIn());
+    zoomControls.setIsZoomOutEnabled(chartView.canZoomOut());
+  }
+
+  /**
+   * To zoom out.
+   */
+  private void zoomOut() {
+    chartView.zoomOut();
+    zoomControls.setIsZoomInEnabled(chartView.canZoomIn());
+    zoomControls.setIsZoomOutEnabled(chartView.canZoomOut());
+  }
+
+  /**
+   * Runs a runnable on the UI thread if possible.
+   * 
+   * @param runnable the runnable
+   */
+  private void runOnUiThread(Runnable runnable) {
+    FragmentActivity fragmentActivity = getActivity();
+    if (fragmentActivity != null) {
+      fragmentActivity.runOnUiThread(runnable);
+    }
+  }
+
+  /**
+   * Given a location, fill in a data point, an array of double[]. <br>
+   * data[0] = time/distance <br>
+   * data[1] = elevation <br>
+   * data[2] = speed <br>
+   * data[3] = pace <br>
+   * data[4] = heart rate <br>
+   * data[5] = cadence <br>
+   * data[6] = power <br>
+   * 
+   * @param location the location
+   * @param data the data point to fill in, can be null
+   */
+  @VisibleForTesting
+  void fillDataPoint(Location location, double[] data) {
+    double timeOrDistance = Double.NaN;
+    double elevation = Double.NaN;
+    double speed = Double.NaN;
+    double pace = Double.NaN;
+    double heartRate = Double.NaN;
+    double cadence = Double.NaN;
+    double power = Double.NaN;
+
+    if (tripStatisticsUpdater != null) {
+      tripStatisticsUpdater.addLocation(location, recordingDistanceInterval);
+      TripStatistics tripStatistics = tripStatisticsUpdater.getTripStatistics();
+      if (chartByDistance) {
+        double distance = tripStatistics.getTotalDistance() * UnitConversions.M_TO_KM;
+        if (!metricUnits) {
+          distance *= UnitConversions.KM_TO_MI;
+        }
+        timeOrDistance = distance;
+      } else {
+        timeOrDistance = tripStatistics.getTotalTime();
+      }
+
+      elevation = tripStatisticsUpdater.getSmoothedElevation();
+      if (!metricUnits) {
+        elevation *= UnitConversions.M_TO_FT;
+      }
+
+      speed = tripStatisticsUpdater.getSmoothedSpeed() * UnitConversions.MS_TO_KMH;
+      if (!metricUnits) {
+        speed *= UnitConversions.KM_TO_MI;
+      }
+      pace = speed == 0 ? 0.0 : 60.0 / speed;
+    }
+    if (location instanceof MyTracksLocation && ((MyTracksLocation) location).getSensorDataSet() != null) {
+      SensorDataSet sensorDataSet = ((MyTracksLocation) location).getSensorDataSet();
+      if (sensorDataSet.hasHeartRate()) {
+        heartRate = sensorDataSet.getHeartRate();
+      }
+      if (sensorDataSet.hasCadence()) {
+        cadence = sensorDataSet.getCadence();
+      }
+      if (sensorDataSet.hasPower()) {
+        power = sensorDataSet.getPower();
+      }
+    }
+
+    if (data != null) {
+      data[0] = timeOrDistance;
+      data[1] = elevation;
+      data[2] = speed;
+      data[3] = pace;
+      data[4] = heartRate;
+      data[5] = cadence;
+      data[6] = power;
+    }
+  }
+
+  @VisibleForTesting
+  void setTripStatisticsUpdater(long time) {
+    tripStatisticsUpdater = new TripStatisticsUpdater(time);
+  }
+
+  @VisibleForTesting
+  void setChartView(ChartView view) {
+    chartView = view;
+  }
+
+  @VisibleForTesting
+  void setMetricUnits(boolean value) {
+    metricUnits = value;
+  }
+
+  @VisibleForTesting
+  void setReportSpeed(boolean value) {
+    reportSpeed = value;
+  }
+
+  @VisibleForTesting
+  void setChartByDistance(boolean value) {
+    chartByDistance = value;
+  }
+}

src/main/java/com/google/android/apps/mytracks/fragments/ChooseActivityDialogFragment.java

@@ -0,0 +1,268 @@
+/*
+ * 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 com.google.android.apps.mytracks.fragments;
+
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.pm.ActivityInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.graphics.drawable.Drawable;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ArrayAdapter;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+import androidx.annotation.NonNull;
+import androidx.core.app.ShareCompat;
+import androidx.fragment.app.FragmentActivity;
+
+import com.google.android.apps.mytracks.util.IntentUtils;
+import com.google.android.maps.mytracks.R;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+
+/**
+ * A DialogFragment to choose an activity.
+ * 
+ * @author Jimmy Shih
+ */
+public class ChooseActivityDialogFragment extends AbstractMyTracksDialogFragment {
+
+  /**
+   * Interface for caller of this dialog fragment.
+   * 
+   * @author Jimmy Shih
+   */
+  public interface ChooseActivityCaller {
+
+    /**
+     * Called when choose activity is done.
+     */
+    void onChooseActivityDone(String packageName, String className);
+  }
+  
+  private static class ViewHolder {
+    TextView text1;
+    TextView text2;
+    ImageView icon;
+  }
+
+  private ChooseActivityCaller caller;
+  private PackageManager packageManager;
+  
+  @Override
+  public void onAttach(Context context) {
+    super.onAttach(context);
+    try {
+      caller = (ChooseActivityCaller) context;
+    } catch (ClassCastException e) {
+      throw new ClassCastException(context + " must implement " + ChooseActivityCaller.class.getSimpleName());
+    }
+  }
+  
+  @Override
+  protected Dialog createDialog() {
+    FragmentActivity fragmentActivity = getActivity();
+    packageManager = fragmentActivity.getPackageManager();
+    List<DisplayInfo> displayInfos = getDisplayInfos(fragmentActivity);
+
+    ArrayAdapter<DisplayInfo> arrayAdapter = new ArrayAdapter<DisplayInfo>(fragmentActivity,
+        R.layout.choose_activity_list_item, R.id.choose_activity_list_item_text1, displayInfos) {
+        @NonNull
+        @Override
+      public View getView(int position, View convertView, @NonNull ViewGroup parent) {
+        View view;
+        ViewHolder viewHolder;
+        if (convertView == null) {
+          view = getActivity().getLayoutInflater()
+              .inflate(R.layout.choose_activity_list_item, parent, false);
+          viewHolder = new ViewHolder();
+          viewHolder.text1 = view.findViewById(R.id.choose_activity_list_item_text1);
+          viewHolder.text2 = view.findViewById(R.id.choose_activity_list_item_text2);
+          viewHolder.icon = view.findViewById(R.id.choose_activity_list_item_icon);
+          view.setTag(viewHolder);
+        } else {
+          view = convertView;
+          viewHolder = (ViewHolder) view.getTag();
+        }
+        DisplayInfo displayInfo = getItem(position);
+
+        viewHolder.text1.setText(displayInfo.primaryLabel);
+
+        boolean hasSecondaryLabel = displayInfo.secondaryLabel != null;
+        viewHolder.text2.setVisibility(hasSecondaryLabel ? View.VISIBLE : View.GONE);
+        if (hasSecondaryLabel) {
+          viewHolder.text2.setText(displayInfo.secondaryLabel);
+        }
+        viewHolder.icon.setImageDrawable(displayInfo.icon);
+        return view;
+      }
+    };
+    return new AlertDialog.Builder(fragmentActivity).setSingleChoiceItems(
+        arrayAdapter, 0, new DialogInterface.OnClickListener() {
+            @Override
+          public void onClick(DialogInterface dialog, int which) {
+            AlertDialog alertDialog = (AlertDialog) dialog;
+            DisplayInfo displayInfo = (DisplayInfo) alertDialog.getListView()
+                .getItemAtPosition(which);
+            ActivityInfo activityInfo = displayInfo.resolveInfo.activityInfo;
+            dismiss();
+            caller.onChooseActivityDone(
+                activityInfo.applicationInfo.packageName, activityInfo.name);
+          }
+        }).setTitle(R.string.share_track_share_url_title).create();
+  }
+
+  @Override
+  public void onCancel(DialogInterface dialog) {
+    super.onCancel(dialog);
+    caller.onChooseActivityDone(null, null);
+  }
+  
+  /**
+   * Gets the display info.
+   */
+  private List<DisplayInfo> getDisplayInfos(FragmentActivity fragmentActivity) {
+    List<DisplayInfo> displayInfos = new ArrayList<>();
+    Intent intent = ShareCompat.IntentBuilder.from(fragmentActivity)
+        .setType(IntentUtils.TEXT_PLAIN_TYPE).getIntent();
+    List<ResolveInfo> resolveInfos = packageManager.queryIntentActivities(
+        intent, PackageManager.MATCH_DEFAULT_ONLY);
+    if (resolveInfos != null && resolveInfos.size() > 0) {
+      int size = resolveInfos.size();
+      ResolveInfo firstResolveInfo = resolveInfos.get(0);
+      for (int i = 1; i < size; i++) {
+        ResolveInfo resolveInfo = resolveInfos.get(i);
+        if (firstResolveInfo.priority != resolveInfo.priority
+            || firstResolveInfo.isDefault != resolveInfo.isDefault) {
+          while (i < size) {
+            resolveInfos.remove(i);
+            size--;
+          }
+        }
+      }
+      if (size > 1) {
+        ResolveInfo.DisplayNameComparator displayNameComparator = new ResolveInfo.DisplayNameComparator(
+            packageManager);
+        Collections.sort(resolveInfos, displayNameComparator);
+      }
+
+      firstResolveInfo = resolveInfos.get(0);
+      int start = 0;
+      CharSequence firstLabel = firstResolveInfo.loadLabel(packageManager);
+      for (int i = 1; i < size; i++) {
+        if (firstLabel == null) {
+          firstLabel = firstResolveInfo.activityInfo.packageName;
+        }
+        ResolveInfo resolveInfo = resolveInfos.get(i);
+        CharSequence label = resolveInfo.loadLabel(packageManager);
+        if (label == null) {
+          label = resolveInfo.activityInfo.packageName;
+        }
+        if (label.equals(firstLabel)) {
+          continue;
+        }
+        processGroup(resolveInfos, displayInfos, start, i - 1);
+        firstResolveInfo = resolveInfo;
+        firstLabel = label;
+        start = i;
+      }
+      // Process last group
+      processGroup(resolveInfos, displayInfos, start, size - 1);
+    }
+    return displayInfos;
+  }
+
+  /**
+   * Contains display info.
+   * 
+   * @author Jimmy Shih
+   */
+  private final class DisplayInfo {
+    private ResolveInfo resolveInfo;
+    private CharSequence primaryLabel;
+    private CharSequence secondaryLabel;
+    private Drawable icon;
+
+    public DisplayInfo(ResolveInfo resolveInfo, CharSequence primaryLabel,
+        CharSequence secondaryLabel, Drawable icon) {
+      this.resolveInfo = resolveInfo;
+      this.primaryLabel = primaryLabel;
+      this.secondaryLabel = secondaryLabel;
+      this.icon = icon;
+    }
+  }
+
+  /**
+   * Processes a group of items with the same label.
+   * 
+   * @param resolveInfos list of resolve infos
+   * @param displayInfos list of display infos
+   * @param start start index
+   * @param end end index
+   */
+  private void processGroup(
+      List<ResolveInfo> resolveInfos, List<DisplayInfo> displayInfos, int start, int end) {
+    ResolveInfo startResolveInfo = resolveInfos.get(start);
+    CharSequence primaryLabel = startResolveInfo.loadLabel(packageManager);
+    Drawable icon = startResolveInfo.loadIcon(packageManager);
+
+    int num = end - start + 1;
+    if (num == 1) {
+      // Only one, set the secondary label to null
+      displayInfos.add(new DisplayInfo(startResolveInfo, primaryLabel, null, icon));
+    } else {
+      // Decide package name or application name for the secondary label
+      boolean usePackageName = false;
+      CharSequence appName = startResolveInfo.activityInfo.applicationInfo.loadLabel(
+          packageManager);
+      if (appName == null) {
+        usePackageName = true;
+      } else {
+        // Use HashSet to track duplicates
+        HashSet<CharSequence> duplicates = new HashSet<>();
+        duplicates.add(appName);
+        for (int i = start + 1; i <= end; i++) {
+          ResolveInfo resolveInfo = resolveInfos.get(i);
+          CharSequence name = resolveInfo.activityInfo.applicationInfo.loadLabel(packageManager);
+          if ((name == null) || (duplicates.contains(name))) {
+            usePackageName = true;
+            break;
+          } else {
+            duplicates.add(name);
+          }
+        }
+        // Clear HashSet for later use
+        duplicates.clear();
+      }
+      for (int i = start; i <= end; i++) {
+        ResolveInfo resolveInfo = resolveInfos.get(i);
+        CharSequence secondaryLabel = usePackageName ? resolveInfo.activityInfo.packageName
+            : resolveInfo.activityInfo.applicationInfo.loadLabel(packageManager);
+        displayInfos.add(new DisplayInfo(resolveInfo, primaryLabel, secondaryLabel, icon));
+      }
+    }
+  }
+}

src/main/java/com/google/android/apps/mytracks/fragments/ChooseActivityTypeDialogFragment.java

@@ -0,0 +1,157 @@
+/*
+ * 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 com.google.android.apps.mytracks.fragments;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.graphics.BitmapFactory;
+import android.graphics.BitmapFactory.Options;
+import android.os.Bundle;
+import android.view.View;
+import android.widget.AdapterView;
+import android.widget.AdapterView.OnItemClickListener;
+import android.widget.GridView;
+
+import androidx.annotation.NonNull;
+import androidx.fragment.app.DialogFragment;
+
+import com.google.android.apps.mytracks.util.DialogUtils;
+import com.google.android.apps.mytracks.util.TrackIconUtils;
+import com.google.android.maps.mytracks.R;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A DialogFragment to choose an activity type.
+ * 
+ * @author apoorvn
+ */
+public class ChooseActivityTypeDialogFragment extends DialogFragment {
+
+  /**
+   * Interface for caller of this dialog fragment.
+   * 
+   * @author apoorvn
+   */
+  public interface ChooseActivityTypeCaller {
+
+    /**
+     * Called when choose activity type is done.
+     */
+    void onChooseActivityTypeDone(String iconValue);
+  }
+
+  public static final String CHOOSE_ACTIVITY_TYPE_DIALOG_TAG = "chooseActivityType";
+
+  private static final String KEY_CATEGORY = "category";
+
+  private ChooseActivityTypeCaller caller;
+
+  public static ChooseActivityTypeDialogFragment newInstance(String category) {
+    Bundle bundle = new Bundle();
+    bundle.putString(KEY_CATEGORY, category);
+
+    ChooseActivityTypeDialogFragment fragment = new ChooseActivityTypeDialogFragment();
+    fragment.setArguments(bundle);
+    return fragment;
+  }
+
+  @Override
+  public void onAttach(Context context) {
+    super.onAttach(context);
+    try {
+      caller = (ChooseActivityTypeCaller) context;
+    } catch (ClassCastException e) {
+      throw new ClassCastException(context + " must implement " + ChooseActivityTypeCaller.class.getSimpleName());
+    }
+  }
+
+  @NonNull
+  @Override
+  public Dialog onCreateDialog(Bundle savedInstanceState) {
+    return getDialog(getActivity(), getArguments().getString(KEY_CATEGORY), caller);
+  }
+
+  public static Dialog getDialog(final Activity activity, final String category, final ChooseActivityTypeCaller caller) {
+    View view = activity.getLayoutInflater().inflate(R.layout.choose_activity_type, null);
+    GridView gridView = view.findViewById(R.id.choose_activity_type_grid_view);
+
+    List<Integer> imageIds = new ArrayList<>();
+    for (String iconValue : TrackIconUtils.getAllIconValues()) {
+      imageIds.add(TrackIconUtils.getIconDrawable(iconValue));
+    }
+
+    Options options = new BitmapFactory.Options();
+    options.inJustDecodeBounds = true;
+    BitmapFactory.decodeResource(activity.getResources(), R.drawable.ic_track_airplane, options);
+    int padding = 32;
+    int width = options.outWidth + 2 * padding;
+    int height = options.outHeight + 2 * padding;
+    gridView.setColumnWidth(width);
+
+    final ChooseActivityTypeImageAdapter imageAdapter = new ChooseActivityTypeImageAdapter(activity, imageIds, width, height, padding);
+    gridView.setAdapter(imageAdapter);
+
+    final AlertDialog alertDialog = new AlertDialog.Builder(activity).setTitle(R.string.track_edit_activity_type_hint).setView(view).create();
+    alertDialog.setOnShowListener(new DialogInterface.OnShowListener() {
+        @Override
+      public void onShow(DialogInterface dialog) {
+        int position = getPosition(activity, category);
+        if (position != -1) {
+          imageAdapter.setSelected(position);
+          imageAdapter.notifyDataSetChanged();
+        }
+        DialogUtils.setDialogTitleDivider(activity, alertDialog);
+      }
+    });
+
+    gridView.setOnItemClickListener(new OnItemClickListener() {
+        @Override
+      public void onItemClick(AdapterView<?> parent, View v, int position, long id) {
+        caller.onChooseActivityTypeDone(TrackIconUtils.getAllIconValues().get(position));
+        alertDialog.dismiss();
+      }
+    });
+    return alertDialog;
+  }
+
+  private static int getPosition(Activity activity, String category) {
+    if (category == null) {
+      return -1;
+    }
+    String iconValue = TrackIconUtils.getIconValue(activity, category);
+    if (iconValue.equals("")) {
+      return -1;
+    }
+    List<String> iconValues = TrackIconUtils.getAllIconValues();
+    for (int i = 0; i < iconValues.size(); i++) {
+      if (iconValues.get(i).equals(iconValue)) {
+        return i;
+      }
+    }
+    return -1;
+  }
+
+  private static void updateWeightContainer(View weightContainer, int position) {
+    boolean showWeight = position == 0 || position == 1 || position == 2;
+    weightContainer.setVisibility(showWeight ? View.VISIBLE : View.GONE);
+  }
+}

src/main/java/com/google/android/apps/mytracks/fragments/ChooseActivityTypeImageAdapter.java

@@ -0,0 +1,95 @@
+/*
+ * 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 com.google.android.apps.mytracks.fragments;
+
+import com.google.android.maps.mytracks.R;
+
+import android.content.Context;
+import android.graphics.Color;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.BaseAdapter;
+import android.widget.ImageView;
+
+import java.util.List;
+
+/**
+ * Image adapter for choosing an activity type.
+ *
+ * @author apoorvn
+ */
+public class ChooseActivityTypeImageAdapter extends BaseAdapter {
+
+  private final Context context;
+  private final List<Integer> imageIds;
+  private final int width;
+  private final int height;
+  private final int padding;
+  private int selected = -1;
+
+  public ChooseActivityTypeImageAdapter(
+      Context context, List<Integer> imageIds, int width, int height, int padding) {
+    this.context = context;
+    this.imageIds = imageIds;
+    this.width = width;
+    this.height = height;
+    this.padding = padding;
+  }
+
+  @Override
+  public int getCount() {
+    return imageIds.size();
+  }
+
+  @Override
+  public Object getItem(int position) {
+    return null;
+  }
+
+  @Override
+  public long getItemId(int position) {
+    return 0;
+  }
+
+  public int getSelected() {
+    return selected;
+  }
+
+  public void setSelected(int position) {
+    selected = position;
+  }
+
+  @Override
+  public View getView(int position, View convertView, ViewGroup parent) {
+    ImageView imageView;
+    if (convertView == null) {
+      imageView = new ImageView(context);
+    } else {
+      imageView = (ImageView) convertView;
+    }
+    if (position == selected) {
+      imageView.setBackgroundResource(R.drawable.list_selector_background_transition_holo_dark);
+    } else {
+      imageView.setBackgroundColor(Color.TRANSPARENT);
+    }
+    imageView.setImageResource(imageIds.get(position));
+    imageView.setMinimumHeight(height);
+    imageView.setMinimumWidth(width);
+    imageView.setPadding(padding, padding, padding, padding);
+    return imageView;
+  }
+}

src/main/java/com/google/android/apps/mytracks/fragments/ConfirmDeleteDialogFragment.java

@@ -0,0 +1,97 @@
+/*
+ * 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 com.google.android.apps.mytracks.fragments;
+
+import android.app.Dialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.os.Bundle;
+
+import com.google.android.apps.mytracks.util.DialogUtils;
+import com.google.android.maps.mytracks.R;
+
+/**
+ * A DialogFragment to confirm delete.
+ * 
+ * @author Jimmy Shih
+ */
+public class ConfirmDeleteDialogFragment extends AbstractMyTracksDialogFragment {
+
+  /**
+   * Interface for caller of this dialog fragment.
+   * 
+   * @author Jimmy Shih
+   */
+  public interface ConfirmDeleteCaller {
+
+    /**
+     * Called when confirm delete is done.
+     * 
+     * @param trackIds list of track ids to delete. To delete all, set to size 1
+     *          with trackIds[0] == -1L
+     */
+    void onConfirmDeleteDone(long[] trackIds);
+  }
+
+  public static final String CONFIRM_DELETE_DIALOG_TAG = "confirmDeleteDialog";
+  private static final String KEY_TRACK_IDS = "trackIds";
+
+  /**
+   * Create a new instance.
+   * 
+   * @param trackIds list of track ids to delete. To delete all, set to size 1
+   *          with trackIds[0] == -1L
+   */
+  public static ConfirmDeleteDialogFragment newInstance(long[] trackIds) {
+    Bundle bundle = new Bundle();
+    bundle.putLongArray(KEY_TRACK_IDS, trackIds);
+
+    ConfirmDeleteDialogFragment deleteTrackDialogFragment = new ConfirmDeleteDialogFragment();
+    deleteTrackDialogFragment.setArguments(bundle);
+    return deleteTrackDialogFragment;
+  }
+
+  private ConfirmDeleteCaller caller;
+
+  @Override
+  public void onAttach(Context context) {
+    super.onAttach(context);
+    try {
+      caller = (ConfirmDeleteCaller) context;
+    } catch (ClassCastException e) {
+      throw new ClassCastException(context + " must implement " + ConfirmDeleteCaller.class.getSimpleName());
+    }
+  }
+
+  @Override
+  protected Dialog createDialog() {
+    final long[] trackIds = getArguments().getLongArray(KEY_TRACK_IDS);
+    int titleId;
+    int messageId;
+    titleId = trackIds.length > 1 ? R.string.generic_delete_selected_confirm_title
+        : R.string.track_delete_one_confirm_title;
+    messageId = trackIds.length > 1 ? R.string.track_delete_multiple_confirm_message
+        : R.string.track_delete_one_confirm_message;
+    return DialogUtils.createConfirmationDialog(
+        getActivity(), titleId, getString(messageId), new DialogInterface.OnClickListener() {
+            @Override
+          public void onClick(DialogInterface dialog, int which) {
+            caller.onConfirmDeleteDone(trackIds);
+          }
+        });
+  }
+}

src/main/java/com/google/android/apps/mytracks/fragments/DeleteMarkerDialogFragment.java

@@ -0,0 +1,109 @@
+/*
+ * 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 com.google.android.apps.mytracks.fragments;
+
+import android.app.Dialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.os.Bundle;
+
+import androidx.fragment.app.FragmentActivity;
+
+import com.google.android.apps.mytracks.content.DescriptionGeneratorImpl;
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils;
+import com.google.android.apps.mytracks.util.DialogUtils;
+import com.google.android.maps.mytracks.R;
+
+/**
+ * A DialogFragment to delete marker.
+ * 
+ * @author Jimmy Shih
+ */
+public class DeleteMarkerDialogFragment extends AbstractMyTracksDialogFragment {
+
+  /**
+   * Interface for caller of this dialog fragment.
+   * 
+   * @author Jimmy Shih
+   */
+  public interface DeleteMarkerCaller {
+
+    /**
+     * Called when delete marker is done.
+     */
+    void onDeleteMarkerDone();
+  }
+
+  public static final String DELETE_MARKER_DIALOG_TAG = "deleteMarkerDialog";
+  private static final String KEY_MARKER_IDS = "markerIds";
+
+  public static DeleteMarkerDialogFragment newInstance(long[] markerIds) {
+    Bundle bundle = new Bundle();
+    bundle.putLongArray(KEY_MARKER_IDS, markerIds);
+
+    DeleteMarkerDialogFragment deleteMarkerDialogFragment = new DeleteMarkerDialogFragment();
+    deleteMarkerDialogFragment.setArguments(bundle);
+    return deleteMarkerDialogFragment;
+  }
+
+  private DeleteMarkerCaller caller;
+
+  @Override
+  public void onAttach(Context context) {
+    super.onAttach(context);
+    try {
+      caller = (DeleteMarkerCaller) context;
+    } catch (ClassCastException e) {
+      throw new ClassCastException(context + " must implement " + DeleteMarkerCaller.class.getSimpleName());
+    }
+  }
+
+  @Override
+  protected Dialog createDialog() {
+    final FragmentActivity fragmentActivity = getActivity();
+    final long[] markerIds = getArguments().getLongArray(KEY_MARKER_IDS);
+    int titleId;
+    int messageId;
+    if (markerIds.length == 1 && markerIds[0] == -1L) {
+      titleId = R.string.generic_delete_all_confirm_title;
+      messageId = R.string.marker_delete_all_confirm_message;
+    } else {
+      titleId = markerIds.length > 1 ? R.string.generic_delete_selected_confirm_title
+          : R.string.marker_delete_one_confirm_title;
+      messageId = markerIds.length > 1 ? R.string.marker_delete_multiple_confirm_message
+          : R.string.marker_delete_one_confirm_message;
+    }
+    return DialogUtils.createConfirmationDialog(
+        fragmentActivity, titleId, getString(messageId), new DialogInterface.OnClickListener() {
+            @Override
+          public void onClick(DialogInterface dialog, int which) {
+            new Thread(new Runnable() {
+                @Override
+              public void run() {
+                MyTracksProviderUtils myTracksProviderUtils = MyTracksProviderUtils.Factory.get(
+                    fragmentActivity);
+                for (long markerId : markerIds) {
+                  myTracksProviderUtils.deleteWaypoint(fragmentActivity,
+                      markerId, new DescriptionGeneratorImpl(fragmentActivity));
+                }
+                caller.onDeleteMarkerDone();
+              }
+            }).start();
+          }
+        });
+  }
+}

src/main/java/com/google/android/apps/mytracks/fragments/FileTypeDialogFragment.java

@@ -0,0 +1,100 @@
+/*
+ * 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 com.google.android.apps.mytracks.fragments;
+
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.DialogInterface.OnClickListener;
+import android.os.Bundle;
+
+import com.google.android.apps.mytracks.io.file.TrackFileFormat;
+import com.google.android.apps.mytracks.util.FileUtils;
+import com.google.android.maps.mytracks.R;
+
+/**
+ * A DialogFragment to select a file type, gpx, kml, etc.
+ * 
+ * @author Jimmy Shih
+ */
+public class FileTypeDialogFragment extends AbstractMyTracksDialogFragment {
+
+  /**
+   * Interface for caller of this dialog fragment.
+   * 
+   * @author Jimmy Shih
+   */
+  public interface FileTypeCaller {
+
+    /**
+     * Called when file type selection is done.
+     */
+    void onFileTypeDone(int menuId, TrackFileFormat trackFileFormat);
+  }
+
+  public static final String FILE_TYPE_DIALOG_TAG = "fileType";
+
+  private static final String KEY_MENU_ID = "menuId";
+  private static final String KEY_TITLE_ID = "titleId";
+  private static final String KEY_OPTION_ID = "optionId";
+
+  public static FileTypeDialogFragment newInstance(int menuId, int titleId, int optionId) {
+    Bundle bundle = new Bundle();
+    bundle.putInt(KEY_MENU_ID, menuId);
+    bundle.putInt(KEY_TITLE_ID, titleId);
+    bundle.putInt(KEY_OPTION_ID, optionId);
+
+    FileTypeDialogFragment fileTypeDialogFragment = new FileTypeDialogFragment();
+    fileTypeDialogFragment.setArguments(bundle);
+    return fileTypeDialogFragment;
+  }
+
+  private FileTypeCaller caller;
+
+  @Override
+  public void onAttach(Context context) {
+    super.onAttach(context);
+    try {
+      caller = (FileTypeCaller) context;
+    } catch (ClassCastException e) {
+      throw new ClassCastException(context + " must implement " + FileTypeCaller.class.getSimpleName());
+    }
+  }
+
+  @Override
+  protected Dialog createDialog() {
+    int optionId = getArguments().getInt(KEY_OPTION_ID);
+    final int titleId = getArguments().getInt(KEY_TITLE_ID);
+    final int menuId = getArguments().getInt(KEY_MENU_ID);
+    TrackFileFormat[] trackFileFormats = TrackFileFormat.values();
+    String[] choices = new String[trackFileFormats.length];
+    for (int i = 0; i < choices.length; i++) {
+      TrackFileFormat trackFileFormat = trackFileFormats[i];
+      choices[i] = getString(optionId, trackFileFormat.name(),
+          FileUtils.getPathDisplayName(trackFileFormat.getExtension()));
+    }
+    return new AlertDialog.Builder(getActivity()).setNegativeButton(R.string.generic_cancel, null)
+        .setPositiveButton(R.string.generic_ok, new OnClickListener() {
+            @Override
+          public void onClick(DialogInterface dialog, int which) {
+            int position = ((AlertDialog) dialog).getListView().getCheckedItemPosition();
+            caller.onFileTypeDone(menuId, TrackFileFormat.values()[position]);
+          }
+        }).setSingleChoiceItems(choices, 0, null).setTitle(titleId).create();
+  }
+}

src/main/java/com/google/android/apps/mytracks/fragments/FrequencyDialogFragment.java

@@ -0,0 +1,106 @@
+/*
+ * 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 com.google.android.apps.mytracks.fragments;
+
+import com.google.android.apps.mytracks.util.PreferencesUtils;
+import com.google.android.apps.mytracks.util.StringUtils;
+import com.google.android.maps.mytracks.R;
+
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.content.DialogInterface;
+import android.os.Bundle;
+import androidx.fragment.app.FragmentActivity;
+
+/**
+ * A DialogFragment to configure frequency.
+ * 
+ * @author Jimmy Shih
+ */
+public class FrequencyDialogFragment extends AbstractMyTracksDialogFragment {
+
+  public static final String FREQUENCY_DIALOG_TAG = "frequencyDialog";
+
+  private static final String KEY_PREFERENCE_ID = "preferenceId";
+  private static final String KEY_DEFAULT_VALUE = "defaultValue";
+  private static final String KEY_TITLE_ID = "titleId";
+
+  public static FrequencyDialogFragment newInstance(
+      int preferenceId, int defaultValue, int titleId) {
+    Bundle bundle = new Bundle();
+    bundle.putInt(KEY_PREFERENCE_ID, preferenceId);
+    bundle.putInt(KEY_DEFAULT_VALUE, defaultValue);
+    bundle.putInt(KEY_TITLE_ID, titleId);
+
+    FrequencyDialogFragment frequencyDialogFragment = new FrequencyDialogFragment();
+    frequencyDialogFragment.setArguments(bundle);
+    return frequencyDialogFragment;
+  }
+  
+  @Override
+  protected Dialog createDialog() {
+    FragmentActivity fragmentActivity = getActivity();
+    
+    final int preferenceId = getArguments().getInt(KEY_PREFERENCE_ID);
+    int defaultValue = getArguments().getInt(KEY_DEFAULT_VALUE);
+    int titleId = getArguments().getInt(KEY_TITLE_ID);
+    int frequencyValue = PreferencesUtils.getInt(fragmentActivity, preferenceId, defaultValue);
+
+    return new AlertDialog.Builder(fragmentActivity).setPositiveButton(
+        R.string.generic_ok, new DialogInterface.OnClickListener() {
+            @Override
+          public void onClick(DialogInterface dialog, int which) {
+            int listIndex = ((AlertDialog) dialog).getListView().getCheckedItemPosition();
+            PreferencesUtils.setInt(getActivity(), preferenceId, getFrequencyValue(listIndex));
+          }
+        }).setSingleChoiceItems(
+        getFrequencyDisplayOptions(fragmentActivity), getListIndex(frequencyValue), null)
+        .setTitle(titleId).create();
+  }
+
+  /**
+   * Gets the frequency display options.
+   */
+  private String[] getFrequencyDisplayOptions(FragmentActivity fragmentActivity) {
+    boolean metricUnits = PreferencesUtils.isMetricUnits(fragmentActivity);
+    return StringUtils.getFrequencyOptions(fragmentActivity, metricUnits);
+  }
+
+  /**
+   * Gets the list index for a frequency value. Returns 0 if the value is not on
+   * the list.
+   */
+  private int getListIndex(int frequencyValue) {
+    String[] values = getResources().getStringArray(R.array.frequency_values);
+    for (int i = 0; i < values.length; i++) {
+      if (frequencyValue == Integer.parseInt(values[i])) {
+        return i;
+      }
+    }
+    return 0;
+  }
+
+  /**
+   * Gets the frequency value from a list index.
+   * 
+   * @param listIndex the list index
+   */
+  private int getFrequencyValue(int listIndex) {
+    String[] values = getResources().getStringArray(R.array.frequency_values);
+    return Integer.parseInt(values[listIndex]);
+  }
+}

src/main/java/com/google/android/apps/mytracks/fragments/MarkerDetailFragment.java

@@ -0,0 +1,287 @@
+/*
+ * 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 com.google.android.apps.mytracks.fragments;
+
+import android.content.Intent;
+import android.location.Location;
+import android.os.Bundle;
+import android.os.Handler;
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.Animation.AnimationListener;
+import android.view.animation.AnimationUtils;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+import androidx.annotation.NonNull;
+import androidx.fragment.app.Fragment;
+import androidx.fragment.app.FragmentActivity;
+
+import com.google.android.apps.mytracks.MarkerEditActivity;
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils;
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.content.Waypoint;
+import com.google.android.apps.mytracks.content.Waypoint.WaypointType;
+import com.google.android.apps.mytracks.util.IntentUtils;
+import com.google.android.apps.mytracks.util.ListItemUtils;
+import com.google.android.apps.mytracks.util.StatsUtils;
+import com.google.android.apps.mytracks.util.StringUtils;
+import com.google.android.apps.mytracks.util.TrackIconUtils;
+import com.google.android.maps.mytracks.R;
+
+/**
+ * A fragment to show marker details.
+ * 
+ * @author Jimmy Shih
+ */
+public class MarkerDetailFragment extends Fragment {
+
+  public static MarkerDetailFragment newInstance(long markerId, String title) {
+    Bundle bundle = new Bundle();
+    bundle.putLong(KEY_MARKER_ID, markerId);
+    bundle.putString(KEY_TITLE, title);
+
+    MarkerDetailFragment fragment = new MarkerDetailFragment();
+    fragment.setArguments(bundle);
+    return fragment;
+  }
+
+  private static final String TAG = MarkerDetailFragment.class.getSimpleName();
+  private static final String KEY_MARKER_ID = "markerId";
+  private static final String KEY_TITLE = "title";
+  private static final long HIDE_TEXT_DELAY = 4000L; // 4 seconds
+
+  private MyTracksProviderUtils myTracksProviderUtils;
+  private Handler handler;
+  private ImageView photo;
+  private ImageView textGradient;
+  private LinearLayout waypointInfo;
+  private Waypoint waypoint;
+
+  private Runnable hideText = new Runnable() {
+      @Override
+    public void run() {
+      Animation animation = AnimationUtils.loadAnimation(getActivity(), R.anim.fadeout);
+      animation.setAnimationListener(new AnimationListener() {
+
+          @Override
+        public void onAnimationStart(Animation anim) {}
+
+          @Override
+        public void onAnimationRepeat(Animation anim) {}
+
+          @Override
+        public void onAnimationEnd(Animation anim) {
+          textGradient.setVisibility(View.GONE);
+          waypointInfo.setVisibility(View.GONE);
+        }
+      });
+      textGradient.startAnimation(animation);
+      waypointInfo.startAnimation(animation);
+    }
+  };
+
+  @Override
+  public void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+
+    long markerId = getArguments().getLong(KEY_MARKER_ID);
+    if (markerId == -1L) {
+      Log.d(TAG, "invalid marker id");
+      getFragmentManager().popBackStack();
+      return;
+    }
+    myTracksProviderUtils = MyTracksProviderUtils.Factory.get(getActivity());
+    handler = new Handler();
+    setHasOptionsMenu(true);
+  }
+
+  @Override
+  public View onCreateView(@NonNull LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+    View view = inflater.inflate(R.layout.marker_detail_fragment, container, false);
+
+    getActivity().setTitle(getArguments().getString(KEY_TITLE));
+
+    photo = view.findViewById(R.id.marker_detail_waypoint_photo);
+    textGradient = view.findViewById(R.id.marker_detail_waypoint_text_gradient);
+    waypointInfo = view.findViewById(R.id.marker_detail_waypoint_info);
+    
+    photo.setOnClickListener(new View.OnClickListener() {
+        @Override
+      public void onClick(View v) {
+        handler.removeCallbacks(hideText);
+        int visibility = waypointInfo.getVisibility() == View.GONE ? View.VISIBLE : View.GONE;
+        textGradient.setVisibility(visibility);
+        waypointInfo.setVisibility(visibility);
+        if (visibility == View.VISIBLE) {
+          handler.postDelayed(hideText, HIDE_TEXT_DELAY);
+        }
+      }
+    });
+    return view;
+  }
+
+    @Override
+  public void onResume() {
+    super.onResume();
+
+    // Need to update the waypoint in case returning after an edit
+    updateWaypoint(true);
+    updateUi();
+  }
+
+  @Override
+  public void onPause() {
+    super.onPause();
+    handler.removeCallbacks(hideText);
+  }
+
+  @Override
+  public void setMenuVisibility(boolean menuVisible) {
+    super.setMenuVisibility(menuVisible);
+    /*
+     * View pager caches the neighboring fragments in the resumed state. If
+     * becoming visible from the resumed state, update the UI to display the
+     * text above the image.
+     */
+    if (isResumed()) {
+      if (menuVisible) {
+        updateUi();
+      } else {
+        handler.removeCallbacks(hideText);
+      }
+    }
+  }
+
+  @Override
+  public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
+    inflater.inflate(R.menu.marker_detail, menu);
+
+    updateWaypoint(false);
+
+    TrackIconUtils.setMenuIconColor(menu);
+  }
+
+  @Override
+  public boolean onOptionsItemSelected(MenuItem item) {
+    long markerId = getArguments().getLong(KEY_MARKER_ID);
+    FragmentActivity fragmentActivity = getActivity();
+    Intent intent;
+    switch (item.getItemId()) {
+      case R.id.marker_detail_show_on_map:
+        intent = IntentUtils.newShowOnMapIntent(waypoint);
+        startActivity(intent);
+        return true;
+      case R.id.marker_detail_edit:
+        intent = IntentUtils.newIntent(fragmentActivity, MarkerEditActivity.class)
+            .putExtra(MarkerEditActivity.EXTRA_MARKER_ID, markerId);
+        startActivity(intent);
+        return true;
+      case R.id.marker_detail_delete:
+        DeleteMarkerDialogFragment.newInstance(new long[] { markerId })
+            .show(getChildFragmentManager(), DeleteMarkerDialogFragment.DELETE_MARKER_DIALOG_TAG);
+        return true;
+      default:
+        return super.onOptionsItemSelected(item);
+    }
+  }
+
+  /**
+   * Updates the waypoint.
+   * 
+   * @param refresh true to always update
+   */
+  private void updateWaypoint(boolean refresh) {
+    if (refresh || waypoint == null) {
+      waypoint = myTracksProviderUtils.getWaypoint(getArguments().getLong(KEY_MARKER_ID));
+      if (waypoint == null) {
+        Log.d(TAG, "waypoint is null");
+        getFragmentManager().popBackStack();
+      }
+    }
+  }
+
+  /**
+   * Updates the UI.
+   */
+  private void updateUi() {
+    View waypointView = getView().findViewById(R.id.marker_detail_waypoint);
+    View statisticsView = getView().findViewById(R.id.marker_detail_statistics);
+
+    boolean isWaypoint = waypoint.getType() == WaypointType.WAYPOINT;
+    waypointView.setVisibility(isWaypoint ? View.VISIBLE : View.GONE);
+    statisticsView.setVisibility(isWaypoint ? View.GONE : View.VISIBLE);
+
+    if (isWaypoint) {
+      boolean hasPhoto = waypoint.hasPhoto();
+      photo.setVisibility(hasPhoto ? View.VISIBLE : View.GONE);
+      textGradient.setVisibility(hasPhoto ? View.VISIBLE : View.GONE);
+      waypointInfo.setVisibility(View.VISIBLE);
+
+      if (hasPhoto) {
+        handler.removeCallbacks(hideText);
+        photo.setImageURI(waypoint.getPhotoURI());
+        handler.postDelayed(hideText, HIDE_TEXT_DELAY);
+      }
+
+      setName(R.id.marker_detail_waypoint_name, hasPhoto);
+
+      TextView category = getView().findViewById(R.id.marker_detail_waypoint_category);
+      ListItemUtils.setTextView(getActivity(), category, StringUtils.getCategory(waypoint.getCategory()), hasPhoto);
+
+      TextView description = getView().findViewById(R.id.marker_detail_waypoint_description);
+      ListItemUtils.setTextView(getActivity(), description, waypoint.getDescription(), hasPhoto);
+
+      setLocation(R.id.marker_detail_waypoint_location, hasPhoto);
+    } else {
+      setName(R.id.marker_detail_statistics_name, false);
+
+      setLocation(R.id.marker_detail_statistics_location, false);
+
+      Track track = myTracksProviderUtils.getTrack(waypoint.getTrackId());
+      StatsUtils.setTripStatisticsValues(getActivity(), null, getView(), waypoint.getTripStatistics(), null);
+      StatsUtils.setLocationValues(getActivity(), null, getView(), waypoint.getLocation(), false);
+    }
+  }
+
+  private void setName(int resId, boolean addShadow) {
+    TextView textView = getView().findViewById(resId);
+    ListItemUtils.setTextView(getActivity(), textView, waypoint.getName(), addShadow);
+  }
+
+  private void setLocation(int resId, boolean addShadow) {
+    TextView textView = getView().findViewById(resId);
+    Location location = waypoint.getLocation();
+    String value;
+    if (location == null) {
+      value = null;
+    } else {
+      value = "[" + getString(R.string.stats_latitude) + " "
+          + StringUtils.formatCoordinate(location.getLatitude()) + ", "
+          + getString(R.string.stats_longitude) + " "
+          + StringUtils.formatCoordinate(location.getLongitude()) + "]";
+    }
+    ListItemUtils.setTextView(getActivity(), textView, value, addShadow);
+  }
+}

src/main/java/com/google/android/apps/mytracks/fragments/StatsFragment.java

@@ -0,0 +1,327 @@
+/*
+ * 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 com.google.android.apps.mytracks.fragments;
+
+import android.location.Location;
+import android.os.Bundle;
+import android.os.Handler;
+import android.util.Log;
+import android.view.KeyEvent;
+import android.view.LayoutInflater;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.Spinner;
+
+import androidx.annotation.NonNull;
+import androidx.fragment.app.Fragment;
+import androidx.fragment.app.FragmentActivity;
+
+import com.google.android.apps.mytracks.TrackDetailActivity;
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.content.TrackDataHub;
+import com.google.android.apps.mytracks.content.TrackDataListener;
+import com.google.android.apps.mytracks.content.TrackDataType;
+import com.google.android.apps.mytracks.content.Waypoint;
+import com.google.android.apps.mytracks.content.sensor.SensorDataSet;
+import com.google.android.apps.mytracks.services.ITrackRecordingService;
+import com.google.android.apps.mytracks.services.TrackRecordingServiceConnection;
+import com.google.android.apps.mytracks.stats.TripStatistics;
+import com.google.android.apps.mytracks.util.LocationUtils;
+import com.google.android.apps.mytracks.util.PreferencesUtils;
+import com.google.android.apps.mytracks.util.StatsUtils;
+import com.google.android.apps.mytracks.util.TrackIconUtils;
+import com.google.android.apps.mytracks.util.TrackRecordingServiceConnectionUtils;
+import com.google.android.apps.mytracks.util.UnitConversions;
+import com.google.android.maps.mytracks.R;
+
+import java.util.EnumSet;
+
+/**
+ * A fragment to display track statistics to the user.
+ * 
+ * @author Sandor Dornbush
+ * @author Rodrigo Damazio
+ */
+public class StatsFragment extends Fragment implements TrackDataListener {
+
+  public static final String STATS_FRAGMENT_TAG = "statsFragment";
+
+  private TrackDataHub trackDataHub;
+  private Handler handlerUpdateUI;
+
+  private TrackRecordingServiceConnection trackRecordingServiceConnection;
+
+  private Location lastLocation = null;
+  private TripStatistics lastTripStatistics = null;
+  private SensorDataSet sensorDataSet = null;
+  private String category = "";
+  private int recordingGpsAccuracy = PreferencesUtils.RECORDING_GPS_ACCURACY_DEFAULT;
+
+  // A runnable to update the total time field.
+  private final Runnable updateTotalTime = new Runnable() {
+    public void run() {
+      if (isResumed() && isSelectedTrackRecording()) {
+        if (!isSelectedTrackPaused() && lastTripStatistics != null) {
+          StatsUtils.setTotalTimeValue(getActivity(), System.currentTimeMillis() - lastTripStatistics.getStopTime() + lastTripStatistics.getTotalTime());
+          updateSensorDataUI();
+        }
+
+        handlerUpdateUI.postDelayed(this, UnitConversions.ONE_SECOND);
+      }
+    }
+  };
+
+
+  @Override
+  public View onCreateView(@NonNull LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+    return inflater.inflate(R.layout.stats, container, false);
+  }
+
+  @Override
+  public void onActivityCreated(Bundle savedInstanceState) {
+    super.onActivityCreated(savedInstanceState);
+    handlerUpdateUI = new Handler();
+    trackRecordingServiceConnection = new TrackRecordingServiceConnection(getContext(), null);
+    TrackRecordingServiceConnectionUtils.startConnection(getContext(), trackRecordingServiceConnection);
+
+    Spinner activityTypeIcon = getView().findViewById(R.id.stats_activity_type_icon);
+    activityTypeIcon.setAdapter(TrackIconUtils.getIconSpinnerAdapter(getActivity(), ""));
+    activityTypeIcon.setOnTouchListener(new View.OnTouchListener() {
+        @Override
+      public boolean onTouch(View v, MotionEvent event) {
+        if (event.getAction() == MotionEvent.ACTION_UP) {
+          ((TrackDetailActivity) getActivity()).chooseActivityType(category);          
+        }
+        return true;
+      }
+    });
+    activityTypeIcon.setOnKeyListener(new View.OnKeyListener() {
+        @Override
+      public boolean onKey(View v, int keyCode, KeyEvent event) {
+        if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER) {
+          ((TrackDetailActivity) getActivity()).chooseActivityType(category);
+        }
+        return true;
+      }
+    });
+  }
+
+  @Override
+  public void onResume() {
+    super.onResume();
+    resumeTrackDataHub();
+    updateUi(getActivity());
+    if (isSelectedTrackRecording()) {
+      handlerUpdateUI.post(updateTotalTime);
+    }
+  }
+
+  @Override
+  public void onPause() {
+    super.onPause();
+    pauseTrackDataHub();
+    handlerUpdateUI.removeCallbacks(updateTotalTime);
+  }
+
+  @Override
+  public void onStop() {
+    super.onStop();
+    trackRecordingServiceConnection.unbind();
+  }
+
+  @Override
+  public void onTrackUpdated(final Track track) {
+    if (isResumed()) {
+      getActivity().runOnUiThread(new Runnable() {
+          @Override
+        public void run() {
+          if (isResumed()) {           
+            lastTripStatistics = track != null ? track.getTripStatistics() : null;
+            category = track != null ? track.getCategory() : "";
+            updateUi(getActivity());
+          }
+        }
+      });
+    }
+  }
+
+  @Override
+  public void clearTrackPoints() {
+    lastLocation = null;
+  }
+
+  @Override
+  public void onSampledInTrackPoint(Location location) {
+    lastLocation = location;
+  }
+
+  @Override
+  public void onSampledOutTrackPoint(Location location) {
+    lastLocation = location;
+  }
+
+  @Override
+  public void onSegmentSplit(Location location) {
+    // We don't care.
+  }
+
+  @Override
+  public void onNewTrackPointsDone() {
+    if (isResumed()) {
+      getActivity().runOnUiThread(new Runnable() {
+          @Override
+        public void run() {
+          if (isResumed()) {
+            if (!isSelectedTrackRecording() || isSelectedTrackPaused()) {
+              lastLocation = null;
+            }
+
+            if (lastLocation != null) {
+              boolean hasFix = !LocationUtils.isLocationOld(lastLocation);
+              boolean hasGoodFix = lastLocation.hasAccuracy() && lastLocation.getAccuracy() < recordingGpsAccuracy;
+
+              if (!hasFix || !hasGoodFix) {
+                lastLocation = null;
+              }
+            }
+            StatsUtils.setLocationValues(getActivity(), getActivity(), null, lastLocation, isSelectedTrackRecording());
+          }
+        }
+      });
+    }
+  }
+
+  @Override
+  public void clearWaypoints() {
+    // We don't care.
+  }
+
+  @Override
+  public void onNewWaypoint(Waypoint wpt) {
+    // We don't care.
+  }
+
+  @Override
+  public void onNewWaypointsDone() {
+    // We don't care.
+  }
+
+  @Override
+  public boolean onMetricUnitsChanged(final boolean metric) {
+    if (isResumed()) {
+      getActivity().runOnUiThread(new Runnable() {
+          @Override
+        public void run() {
+          if (isResumed()) {
+            updateUi(getActivity());
+          }
+        }
+      });
+    }
+    return true;
+  }
+
+  @Override
+  public boolean onReportSpeedChanged(final boolean speed) {
+    if (isResumed()) {
+      getActivity().runOnUiThread(new Runnable() {
+          @Override
+        public void run() {
+          if (isResumed()) {
+            updateUi(getActivity());
+          }
+        }
+      });
+    }
+    return true;
+  }
+
+  @Override
+  public boolean onRecordingGpsAccuracy(int newValue) {
+    recordingGpsAccuracy = newValue;
+    return false;
+  }
+
+  @Override
+  public boolean onRecordingDistanceIntervalChanged(int minRecordingDistance) {
+    // We don't care.
+    return false;
+  }
+
+  /**
+   * Resumes the trackDataHub. Needs to be synchronized because trackDataHub can
+   * be accessed by multiple threads.
+   */
+  private synchronized void resumeTrackDataHub() {
+    trackDataHub = ((TrackDetailActivity) getActivity()).getTrackDataHub();
+    trackDataHub.registerTrackDataListener(this, EnumSet.of(TrackDataType.TRACKS_TABLE,
+        TrackDataType.SAMPLED_IN_TRACK_POINTS_TABLE, TrackDataType.SAMPLED_OUT_TRACK_POINTS_TABLE,
+        TrackDataType.PREFERENCE));
+  }
+
+  /**
+   * Pauses the trackDataHub. Needs to be synchronized because trackDataHub can
+   * be accessed by multiple threads.
+   */
+  private synchronized void pauseTrackDataHub() {
+    trackDataHub.unregisterTrackDataListener(this);
+    trackDataHub = null;
+  }
+
+  /**
+   * Returns true if the selected track is recording. Needs to be synchronized
+   * because trackDataHub can be accessed by multiple threads.
+   */
+  private synchronized boolean isSelectedTrackRecording() {
+    return trackDataHub != null && trackDataHub.isSelectedTrackRecording();
+  }
+
+  /**
+   * Returns true if the selected track is paused. Needs to be synchronized
+   * because trackDataHub can be accessed by multiple threads.
+   */
+  private synchronized boolean isSelectedTrackPaused() {
+    return trackDataHub != null && trackDataHub.isSelectedTrackPaused();
+  }
+
+  /**
+   * Tries to fetch most recent {@link SensorDataSet} {@link com.google.android.apps.mytracks.services.sensors.SensorManager}.
+   */
+  private void updateSensorDataUI() {
+    ITrackRecordingService trackRecordingService = trackRecordingServiceConnection.getServiceIfBound();
+    if (trackRecordingService == null) {
+      Log.d(STATS_FRAGMENT_TAG, "Cannot get the track recording service.");
+      sensorDataSet = null;
+    } else {
+      //TODO sensorState = trackRecordingService.getSensorState();
+      sensorDataSet =  trackRecordingService.getSensorData();
+    }
+
+    StatsUtils.setSensorData(getActivity(), getActivity(), sensorDataSet, isSelectedTrackRecording());
+  }
+
+  /**
+   * Updates the UI.
+   */
+  private void updateUi(FragmentActivity activity) {
+    String trackIconValue = TrackIconUtils.getIconValue(activity, category);
+    StatsUtils.setTripStatisticsValues(activity, activity, null, lastTripStatistics, trackIconValue);
+    StatsUtils.setLocationValues(activity, activity, null, lastLocation, isSelectedTrackRecording());
+    updateSensorDataUI();
+  }
+}

src/main/java/com/google/android/apps/mytracks/io/file/TrackFileFormat.java

@@ -0,0 +1,75 @@
+package com.google.android.apps.mytracks.io.file;
+
+import com.google.android.apps.mytracks.io.file.exporter.GpxTrackWriter;
+import com.google.android.apps.mytracks.io.file.exporter.KmlTrackWriter;
+import com.google.android.apps.mytracks.io.file.exporter.TrackWriter;
+import com.google.android.maps.mytracks.R;
+
+import android.content.Context;
+import android.os.Parcel;
+import android.os.Parcelable;
+
+import java.util.Locale;
+
+/**
+ * Definition of all possible track formats.
+ */
+public enum TrackFileFormat implements Parcelable {
+  KML {
+  @Override
+    public TrackWriter newTrackWriter(Context context, boolean multiple, boolean playTrack) {
+      return new KmlTrackWriter(context, multiple, playTrack);
+    }
+  },
+  GPX {
+  @Override
+    public TrackWriter newTrackWriter(Context context, boolean multiple, boolean playTrack) {
+      return new GpxTrackWriter(context.getString(R.string.send_google_by_my_tracks, "", ""));
+    }
+  };
+
+  @Override
+  public int describeContents() {
+    return 0;
+  }
+
+  @Override
+  public void writeToParcel(final Parcel dest, final int flags) {
+    dest.writeInt(ordinal());
+  }
+
+  public static final Creator<TrackFileFormat> CREATOR = new Creator<TrackFileFormat>() {
+      @Override
+    public TrackFileFormat createFromParcel(final Parcel source) {
+      return TrackFileFormat.values()[source.readInt()];
+    }
+
+      @Override
+    public TrackFileFormat[] newArray(final int size) {
+      return new TrackFileFormat[size];
+    }
+  };
+
+  /**
+   * Creates a new track writer for the format.
+   * 
+   * @param context the context
+   * @param multiple true for writing multiple tracks
+   * @param playTrack true to play track
+   */
+  public abstract TrackWriter newTrackWriter(Context context, boolean multiple, boolean playTrack);
+
+  /**
+   * Returns the mime type for each format.
+   */
+  public String getMimeType() {
+    return "application/" + getExtension() + "+xml";
+  }
+
+  /**
+   * Returns the file extension for each format.
+   */
+  public String getExtension() {
+    return this.name().toLowerCase(Locale.US);
+  }
+}

src/main/java/com/google/android/apps/mytracks/io/file/exporter/FileTrackExporter.java

@@ -0,0 +1,234 @@
+/*
+ * 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 com.google.android.apps.mytracks.io.file.exporter;
+
+import com.google.android.apps.mytracks.Constants;
+import com.google.android.apps.mytracks.content.MyTracksLocation;
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils;
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils.LocationIterator;
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.content.Waypoint;
+import com.google.android.apps.mytracks.util.LocationUtils;
+
+import android.database.Cursor;
+import android.location.Location;
+import android.util.Log;
+
+import java.io.OutputStream;
+
+/**
+ * Track Writer for writing tracks to an {@link OutputStream}.
+ * 
+ * @author Sandor Dornbush
+ * @author Rodrigo Damazio
+ */
+public class FileTrackExporter implements TrackExporter {
+
+  private static final String TAG = FileTrackExporter.class.getSimpleName();
+
+  private final MyTracksProviderUtils myTracksProviderUtils;
+  private final Track[] tracks;
+  private final TrackWriter trackWriter;
+  private final TrackExporterListener trackExporterListener;
+
+  /**
+   * Constructor.
+   * 
+   * @param myTracksProviderUtils the my tracks provider utils
+   * @param tracks the tracks
+   * @param trackWriter the track writer
+   * @param trackExporterListener the track export listener
+   */
+  public FileTrackExporter(MyTracksProviderUtils myTracksProviderUtils, Track[] tracks,
+      TrackWriter trackWriter, TrackExporterListener trackExporterListener) {
+    this.myTracksProviderUtils = myTracksProviderUtils;
+    this.tracks = tracks;
+    this.trackWriter = trackWriter;
+    this.trackExporterListener = trackExporterListener;
+  }
+
+  @Override
+  public boolean writeTrack(OutputStream outputStream) {
+    try {
+      trackWriter.prepare(outputStream);
+      trackWriter.writeHeader(tracks);
+      for (Track track1 : tracks) {
+        writeWaypoints(track1);
+      }
+      trackWriter.writeBeginTracks();
+      long startTime = tracks[0].getTripStatistics().getStartTime();
+      for (Track track : tracks) {
+        long offset = track.getTripStatistics().getStartTime() - startTime;
+        writeLocations(track, offset);
+      }
+      trackWriter.writeEndTracks();
+      trackWriter.writeFooter();
+      trackWriter.close();
+      return true;
+    } catch (InterruptedException e) {
+      Log.e(TAG, "Thread interrupted", e);
+      return false;
+    }
+  }
+
+  /**
+   * Writes the waypoints.
+   */
+  private void writeWaypoints(Track track) throws InterruptedException {
+    /*
+     * TODO: Stream through the waypoints in chunks. I am leaving the number of
+     * waypoints very high which should not be a problem because we don't try to
+     * load them into objects all at the same time.
+     */
+    boolean hasWaypoints = false;
+    try (Cursor cursor = myTracksProviderUtils.getWaypointCursor(
+            track.getId(), -1L, Constants.MAX_LOADED_WAYPOINTS_POINTS)) {
+      if (cursor != null && cursor.moveToFirst()) {
+        /*
+         * Yes, this will skip the first waypoint and that is intentional as the
+         * first waypoint holds the stats for the track.
+         */
+        while (cursor.moveToNext()) {
+          if (Thread.interrupted()) {
+            throw new InterruptedException();
+          }
+          if (!hasWaypoints) {
+            trackWriter.writeBeginWaypoints(track);
+            hasWaypoints = true;
+          }
+          Waypoint waypoint = myTracksProviderUtils.createWaypoint(cursor);
+          trackWriter.writeWaypoint(waypoint);
+        }
+      }
+    }
+    if (hasWaypoints) {
+      trackWriter.writeEndWaypoints();
+    }
+  }
+
+  /**
+   * Writes the locations.
+   */
+  private void writeLocations(Track track, long offset) throws InterruptedException {
+    boolean wroteTrack = false;
+    boolean wroteSegment = false;
+    boolean isLastLocationValid = false;
+    TrackWriterLocationFactory locationFactory = new TrackWriterLocationFactory();
+    int locationNumber = 0;
+    LocationIterator locationIterator = null;
+
+    try {
+      locationIterator = myTracksProviderUtils.getTrackPointLocationIterator(
+          track.getId(), -1L, false, locationFactory);
+
+      while (locationIterator.hasNext()) {
+        if (Thread.interrupted()) {
+          throw new InterruptedException();
+        }
+        Location location = locationIterator.next();
+
+        setLocationTime(location, offset);
+        locationNumber++;
+
+        boolean isLocationValid = LocationUtils.isValidLocation(location);
+        boolean isSegmentValid = isLocationValid && isLastLocationValid;
+        if (!wroteTrack && isSegmentValid) {
+          // Found the first two consecutive locations that are valid
+          trackWriter.writeBeginTrack(track, locationFactory.lastLocation);
+          wroteTrack = true;
+        }
+
+        if (isSegmentValid) {
+          if (!wroteSegment) {
+            // Start a segment
+            trackWriter.writeOpenSegment();
+            wroteSegment = true;
+
+            // Write the previous location, which we had previously skipped
+            trackWriter.writeLocation(locationFactory.lastLocation);
+          }
+
+          // Write the current location
+          trackWriter.writeLocation(location);
+          if (trackExporterListener != null) {
+            trackExporterListener.onProgressUpdate(locationNumber, track.getNumberOfPoints());
+          }
+        } else {
+          if (wroteSegment) {
+            trackWriter.writeCloseSegment();
+            wroteSegment = false;
+          }
+        }
+        locationFactory.swapLocations();
+        isLastLocationValid = isLocationValid;
+      }
+
+      if (wroteTrack) {
+        Location lastValidTrackPoint = myTracksProviderUtils.getLastValidTrackPoint(track.getId());
+        setLocationTime(lastValidTrackPoint, offset);
+        trackWriter.writeEndTrack(track, lastValidTrackPoint);
+      } else {
+        // Write an empty track
+        trackWriter.writeBeginTrack(track, null);
+        trackWriter.writeEndTrack(track, null);
+      }
+    } finally {
+      if (locationIterator != null) {
+        locationIterator.close();
+      }
+    }
+  }
+
+  /**
+   * Sets a location time.
+   * 
+   * @param location the location
+   * @param offset the time offset
+   */
+  private void setLocationTime(Location location, long offset) {
+    if (location != null) {
+      location.setTime(location.getTime() - offset);
+    }
+  }
+
+  /**
+   * Track writer location factory. Keeping the last two locations.
+   * 
+   * @author Jimmy Shih
+   */
+  private class TrackWriterLocationFactory implements MyTracksProviderUtils.LocationFactory {
+    Location currentLocation;
+    Location lastLocation;
+
+    @Override
+    public Location createLocation() {
+      if (currentLocation == null) {
+        currentLocation = new MyTracksLocation("");
+      }
+      return currentLocation;
+    }
+
+    public void swapLocations() {
+      Location tempLocation = lastLocation;
+      lastLocation = currentLocation;
+      currentLocation = tempLocation;
+      if (currentLocation != null) {
+        currentLocation.reset();
+      }
+    }
+  }
+}

src/main/java/com/google/android/apps/mytracks/io/file/exporter/GpxTrackWriter.java

@@ -0,0 +1,201 @@
+/*
+ * 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 com.google.android.apps.mytracks.io.file.exporter;
+
+import android.location.Location;
+
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.content.Waypoint;
+import com.google.android.apps.mytracks.io.file.TrackFileFormat;
+import com.google.android.apps.mytracks.util.StringUtils;
+
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.text.NumberFormat;
+import java.util.Locale;
+
+/**
+ * Write track as GPX to a file.
+ * 
+ * @author Sandor Dornbush
+ */
+//TODO Can we export Sensor.Data in GPX?
+public class GpxTrackWriter implements TrackWriter {
+
+  private static final NumberFormat ELEVATION_FORMAT = NumberFormat.getInstance(Locale.US);
+  private static final NumberFormat COORDINATE_FORMAT = NumberFormat.getInstance(Locale.US);
+  static {
+    /*
+     * GPX readers expect to see fractional numbers with US-style punctuation.
+     * That is, they want periods for decimal points, rather than commas.
+     */
+    ELEVATION_FORMAT.setMaximumFractionDigits(1);
+    ELEVATION_FORMAT.setGroupingUsed(false);
+
+    COORDINATE_FORMAT.setMaximumFractionDigits(6);
+    COORDINATE_FORMAT.setMaximumIntegerDigits(3);
+    COORDINATE_FORMAT.setGroupingUsed(false);
+  }
+
+  private final String creator;
+  private PrintWriter printWriter;
+
+  public GpxTrackWriter(String creator) {
+    this.creator = creator;
+  }
+
+  @Override
+  public String getExtension() {
+    return TrackFileFormat.GPX.getExtension();
+  }
+
+  @Override
+  public void prepare(OutputStream outputStream) {
+    this.printWriter = new PrintWriter(outputStream);
+  }
+  
+  @Override
+  public void close() {
+    if (printWriter != null) {
+      printWriter.flush();
+      printWriter = null;
+    }
+  }
+
+  @Override
+  public void writeHeader(Track[] tracks) {
+    if (printWriter != null) {
+      printWriter.println("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
+      printWriter.println("<gpx");
+      printWriter.println("version=\"1.1\"");
+      printWriter.println(
+          "creator=\"" + creator + "\"");
+      printWriter.println("xmlns=\"http://www.topografix.com/GPX/1/1\"");
+      printWriter.println(
+          "xmlns:topografix=\"http://www.topografix.com/GPX/Private/TopoGrafix/0/1\"");
+      printWriter.println("xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"");
+      printWriter.println("xsi:schemaLocation=\"http://www.topografix.com/GPX/1/1"
+          + " http://www.topografix.com/GPX/1/1/gpx.xsd"
+          + " http://www.topografix.com/GPX/Private/TopoGrafix/0/1"
+          + " http://www.topografix.com/GPX/Private/TopoGrafix/0/1/topografix.xsd\">");
+      printWriter.println("<metadata>");
+      Track track = tracks[0];
+      printWriter.println("<name>" + StringUtils.formatCData(track.getName()) + "</name>");
+      printWriter.println("<desc>" + StringUtils.formatCData(track.getDescription()) + "</desc>");
+      printWriter.println("</metadata>");
+    }
+  }
+
+  @Override
+  public void writeFooter() {
+    if (printWriter != null) {
+      printWriter.println("</gpx>");
+    }
+  }
+
+  @Override
+  public void writeBeginWaypoints(Track track) {
+    // Do nothing
+  }
+
+  @Override
+  public void writeEndWaypoints() {
+    // Do nothing
+  }
+
+  @Override
+  public void writeWaypoint(Waypoint waypoint) {
+    if (printWriter != null) {
+      Location location = waypoint.getLocation();
+      if (location != null) {
+        printWriter.println("<wpt " + formatLocation(location) + ">");
+        if (location.hasAltitude()) {
+          printWriter.println("<ele>" + ELEVATION_FORMAT.format(location.getAltitude()) + "</ele>");
+        }
+        printWriter.println(
+            "<time>" + StringUtils.formatDateTimeIso8601(location.getTime()) + "</time>");
+        printWriter.println("<name>" + StringUtils.formatCData(waypoint.getName()) + "</name>");
+        printWriter.println("<cmt>" + StringUtils.formatCData(waypoint.getType().name()) + "</cmt>");
+        printWriter.println(
+            "<desc>" + StringUtils.formatCData(waypoint.getDescription()) + "</desc>");
+        printWriter.println("<type>" + StringUtils.formatCData(waypoint.getCategory()) + "</type>");
+        printWriter.println("</wpt>");
+      }
+    }
+  }
+
+  @Override
+  public void writeBeginTracks() {
+    // Do nothing
+  }
+
+  @Override
+  public void writeEndTracks() {
+    // Do nothing
+  }
+  
+  @Override
+  public void writeBeginTrack(Track track, Location startLocation) {
+    if (printWriter != null) {
+      printWriter.println("<trk>");
+      printWriter.println("<name>" + StringUtils.formatCData(track.getName()) + "</name>");
+      printWriter.println("<desc>" + StringUtils.formatCData(track.getDescription()) + "</desc>");
+      printWriter.println("<type>" + StringUtils.formatCData(track.getCategory()) + "</type>");
+      printWriter.println("<extensions><topografix:color>c0c0c0</topografix:color></extensions>");
+    }
+  }
+
+  @Override
+  public void writeEndTrack(Track track, Location endLocation) {
+    if (printWriter != null) {
+      printWriter.println("</trk>");
+    }
+  }
+
+  @Override
+  public void writeOpenSegment() {
+    printWriter.println("<trkseg>");
+  }
+
+  @Override
+  public void writeCloseSegment() {
+    printWriter.println("</trkseg>");
+  }
+
+  @Override
+  public void writeLocation(Location location) {
+    if (printWriter != null) {
+      printWriter.println("<trkpt " + formatLocation(location) + ">");
+      if (location.hasAltitude()) {
+        printWriter.println("<ele>" + ELEVATION_FORMAT.format(location.getAltitude()) + "</ele>");
+      }
+      printWriter.println(
+          "<time>" + StringUtils.formatDateTimeIso8601(location.getTime()) + "</time>");
+      printWriter.println("</trkpt>");
+    }
+  }
+
+  /**
+   * Formats a location with latitude and longitude coordinates.
+   * 
+   * @param location the location
+   */
+  private String formatLocation(Location location) {
+    return "lat=\"" + COORDINATE_FORMAT.format(location.getLatitude()) + "\" lon=\""
+        + COORDINATE_FORMAT.format(location.getLongitude()) + "\"";
+  }
+}

src/main/java/com/google/android/apps/mytracks/io/file/exporter/KmlTrackWriter.java

@@ -0,0 +1,460 @@
+/*
+ * 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 com.google.android.apps.mytracks.io.file.exporter;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.location.Location;
+import android.net.Uri;
+
+import androidx.annotation.VisibleForTesting;
+
+import com.google.android.apps.mytracks.content.DescriptionGenerator;
+import com.google.android.apps.mytracks.content.DescriptionGeneratorImpl;
+import com.google.android.apps.mytracks.content.MyTracksLocation;
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils;
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.content.Waypoint;
+import com.google.android.apps.mytracks.content.Waypoint.WaypointType;
+import com.google.android.apps.mytracks.content.sensor.SensorDataSet;
+import com.google.android.apps.mytracks.io.file.TrackFileFormat;
+import com.google.android.apps.mytracks.util.StringUtils;
+import com.google.android.maps.mytracks.R;
+
+import java.io.File;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+
+/**
+ * Write track as KML to a file.
+ * 
+ * @author Leif Hendrik Wilden
+ */
+public class KmlTrackWriter implements TrackWriter {
+
+  private static final String WAYPOINT_STYLE = "waypoint";
+  private static final String STATISTICS_STYLE = "statistics";
+  private static final String START_STYLE = "start";
+  private static final String END_STYLE = "end";
+  private static final String TRACK_STYLE = "track";
+  private static final String SCHEMA_ID = "schema";
+  private static final String CADENCE = "cadence";
+  private static final String HEART_RATE = "heart_rate";
+  private static final String POWER = "power";
+
+  private static final String
+      WAYPOINT_ICON = "http://maps.google.com/mapfiles/kml/pushpin/blue-pushpin.png";
+  private static final String
+      STATISTICS_ICON = "http://maps.google.com/mapfiles/kml/pushpin/ylw-pushpin.png";
+  private static final String
+      START_ICON = "http://maps.google.com/mapfiles/kml/paddle/grn-circle.png";
+  private static final String
+      END_ICON = "http://maps.google.com/mapfiles/kml/paddle/red-circle.png";
+  private static final String
+      TRACK_ICON = "http://earth.google.com/images/kml-icons/track-directional/track-0.png";
+
+  private final Context context;
+  private final boolean multiple;
+  private final boolean playTrack;
+  private final DescriptionGenerator descriptionGenerator;  
+  private final MyTracksProviderUtils myTracksProviderUtils;
+
+  private PrintWriter printWriter;
+  private ArrayList<Float> powerList = new ArrayList<>();
+  private ArrayList<Float> cadenceList = new ArrayList<>();
+  private ArrayList<Float> heartRateList = new ArrayList<>();
+  private boolean hasPower;
+  private boolean hasCadence;
+  private boolean hasHeartRate;
+
+  public KmlTrackWriter(Context context, boolean multiple, boolean playTrack) {
+    this(context, multiple, playTrack, new DescriptionGeneratorImpl(context));
+  }
+
+  @VisibleForTesting
+  KmlTrackWriter(Context context, boolean multiple, boolean playTrack, DescriptionGenerator descriptionGenerator) {
+    this.context = context;
+    this.multiple = multiple;
+    this.playTrack = playTrack;
+    this.descriptionGenerator = descriptionGenerator;
+    this.myTracksProviderUtils = MyTracksProviderUtils.Factory.get(context);
+  }
+
+  @Override
+  public String getExtension() {
+    return TrackFileFormat.KML.getExtension();
+  }
+
+  @Override
+  public void prepare(OutputStream outputStream) {
+    this.printWriter = new PrintWriter(outputStream);
+  }
+
+  @Override
+  public void close() {
+    if (printWriter != null) {
+      printWriter.flush();
+      printWriter = null;
+    }
+  }
+
+  @Override
+  public void writeHeader(Track[] tracks) {
+    if (printWriter != null) {
+      printWriter.println("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
+      printWriter.println("<kml xmlns=\"http://www.opengis.net/kml/2.2\"");
+      printWriter.println("xmlns:gx=\"http://www.google.com/kml/ext/2.2\"");
+      printWriter.println("xmlns:atom=\"http://www.w3.org/2005/Atom\">");
+      printWriter.println("<Document>");
+      printWriter.println("<open>1</open>");
+      printWriter.println("<visibility>1</visibility>");
+      Track track = tracks[0];
+      printWriter.println("<name>" + StringUtils.formatCData(track.getName()) + "</name>");
+      printWriter.println("<atom:author><atom:name>"
+          + StringUtils.formatCData(context.getString(R.string.send_google_by_my_tracks, "", ""))
+          + "</atom:name></atom:author>");
+      writeTrackStyle();
+      writePlacemarkerStyle(START_STYLE, START_ICON, 32, 1);
+      writePlacemarkerStyle(END_STYLE, END_ICON, 32, 1);
+      writePlacemarkerStyle(STATISTICS_STYLE, STATISTICS_ICON, 20, 2);
+      writePlacemarkerStyle(WAYPOINT_STYLE, WAYPOINT_ICON, 20, 2);
+      printWriter.println("<Schema id=\"" + SCHEMA_ID + "\">");
+      writeSensorStyle(POWER, context.getString(R.string.description_sensor_power));
+      writeSensorStyle(CADENCE, context.getString(R.string.description_sensor_cadence));
+      writeSensorStyle(HEART_RATE, context.getString(R.string.description_sensor_heart_rate));
+      printWriter.println("</Schema>");
+    }
+  }
+
+  @Override
+  public void writeFooter() {
+    if (printWriter != null) {
+      printWriter.println("</Document>");
+      printWriter.println("</kml>");
+    }
+  }
+
+  @Override
+  public void writeBeginWaypoints(Track track) {
+    if (printWriter != null) {
+      printWriter.println("<Folder><name>"
+          + StringUtils.formatCData(context.getString(R.string.track_markers, track.getName()))
+          + "</name>");
+      printWriter.println("<open>1</open>");
+    }
+  }
+
+  @Override
+  public void writeEndWaypoints() {
+    if (printWriter != null) {
+      printWriter.println("</Folder>");
+    }
+  }
+
+  @Override
+  public void writeWaypoint(Waypoint waypoint) {
+    if (printWriter != null) {
+      String styleName = waypoint.getType() == WaypointType.STATISTICS ? STATISTICS_STYLE : WAYPOINT_STYLE;
+      if (waypoint.hasPhoto()) {
+        float heading = getHeading(waypoint.getTrackId(), waypoint.getLocation());
+        writePhotoOverlay(waypoint.getName(), waypoint.getCategory(), waypoint.getDescription(), styleName, waypoint.getLocation(), waypoint.getPhotoUrl(), heading);
+      } else {
+        writePlacemark(waypoint.getName(), waypoint.getCategory(), waypoint.getDescription(), styleName, waypoint.getLocation());
+      }
+    }
+  }
+
+  @Override
+  public void writeBeginTracks() {
+    if (printWriter != null && multiple) {
+      printWriter.println("<Folder id=tour>");
+      printWriter.println("<name>" + context.getString(R.string.generic_tracks) + "</name>");
+      printWriter.println("<open>1</open>");
+    }
+  }
+
+  @Override
+  public void writeEndTracks() {
+    if (printWriter != null && multiple) {
+      printWriter.println("</Folder>");
+    }
+  }
+  
+  @Override
+  public void writeBeginTrack(Track track, Location startLocation) {
+    if (printWriter != null) {
+      String name = context.getString(R.string.marker_label_start, track.getName());
+      writePlacemark(name, "", "", START_STYLE, startLocation);
+      printWriter.println("<Placemark>");
+      printWriter.println("<name>" + StringUtils.formatCData(track.getName()) + "</name>");
+      printWriter.println(
+          "<description>" + StringUtils.formatCData(track.getDescription()) + "</description>");
+      printWriter.println("<styleUrl>#" + TRACK_STYLE + "</styleUrl>");
+      writeCategory(track.getCategory());
+      printWriter.println("<gx:MultiTrack>");
+      printWriter.println("<altitudeMode>absolute</altitudeMode>");
+      printWriter.println("<gx:interpolate>1</gx:interpolate>");
+    }
+  }
+
+  @Override
+  public void writeEndTrack(Track track, Location endLocation) {
+    if (printWriter != null) {
+      printWriter.println("</gx:MultiTrack>");
+      printWriter.println("</Placemark>");
+      String name = context.getString(R.string.marker_label_end, track.getName());
+      String description = descriptionGenerator.generateTrackDescription(track, null, null, false);
+      writePlacemark(name, "", description, END_STYLE, endLocation);
+    }
+  }
+
+  @Override
+  public void writeOpenSegment() {
+    if (printWriter != null) {
+      printWriter.println("<gx:Track>");
+      hasPower = false;
+      hasCadence = false;
+      hasHeartRate = false;
+      powerList.clear();
+      cadenceList.clear();
+      heartRateList.clear();
+    }
+  }
+
+  @Override
+  public void writeCloseSegment() {
+    if (printWriter != null) {
+      printWriter.println("<ExtendedData>");
+      printWriter.println("<SchemaData schemaUrl=\"#" + SCHEMA_ID + "\">");
+      if (hasPower) {
+        writeSensorData(powerList, POWER);
+      }
+      if (hasCadence) {
+        writeSensorData(cadenceList, CADENCE);
+      }
+      if (hasHeartRate) {
+        writeSensorData(heartRateList, HEART_RATE);
+      }
+      printWriter.println("</SchemaData>");
+      printWriter.println("</ExtendedData>");
+      printWriter.println("</gx:Track>");
+    }
+  }
+
+  @Override
+  public void writeLocation(Location location) {
+    if (printWriter != null) {
+      printWriter.println(
+          "<when>" + StringUtils.formatDateTimeIso8601(location.getTime()) + "</when>");
+      printWriter.println("<gx:coord>" + getCoordinates(location, " ") + "</gx:coord>");
+      if (location instanceof MyTracksLocation) {
+        SensorDataSet sensorDataSet = ((MyTracksLocation) location).getSensorDataSet();
+        if (sensorDataSet != null) {
+          if (sensorDataSet.hasHeartRate()) {
+            heartRateList.add(sensorDataSet.getHeartRate());
+          }
+          if (sensorDataSet.hasCadence()) {
+            cadenceList.add(sensorDataSet.getCadence());
+          }
+          if (sensorDataSet.hasPower()) {
+            powerList.add(sensorDataSet.getPower());
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Writes the sensor data.
+   * 
+   * @param list a list of sensor data
+   * @param name the name of the sensor data
+   */
+  private void writeSensorData(ArrayList<Float> list, String name) {
+    printWriter.println("<gx:SimpleArrayData name=\"" + name + "\">");
+    for (int i = 0; i < list.size(); i++) {
+      printWriter.println("<gx:value>" + list.get(i) + "</gx:value>");
+    }
+    printWriter.println("</gx:SimpleArrayData>");
+  }
+
+  /**
+   * Writes a placemark.
+   * 
+   * @param name the name
+   * @param category the category
+   * @param description the description
+   * @param styleName the style name
+   * @param location the location
+   */
+  private void writePlacemark(
+      String name, String category, String description, String styleName, Location location) {
+    if (location != null) {
+      printWriter.println("<Placemark>");
+      printWriter.println("<name>" + StringUtils.formatCData(name) + "</name>");
+      printWriter.println(
+          "<description>" + StringUtils.formatCData(description) + "</description>");
+      printWriter.println("<TimeStamp><when>"
+          + StringUtils.formatDateTimeIso8601(location.getTime()) + "</when></TimeStamp>");
+      printWriter.println("<styleUrl>#" + styleName + "</styleUrl>");
+      writeCategory(category);
+      printWriter.println("<Point>");
+      printWriter.println("<coordinates>" + getCoordinates(location, ",") + "</coordinates>");
+      printWriter.println("</Point>");
+      printWriter.println("</Placemark>");
+    }
+  }
+  
+  /**
+   * Writes a photo overlay.
+   * 
+   * @param name the name
+   * @param category the category
+   * @param description the description
+   * @param styleName the style name
+   * @param location the location
+   * @param photoUrl the photo url
+   * @param heading the heading
+   */
+  private void writePhotoOverlay(String name, String category, String description, String styleName,
+      Location location, String photoUrl, float heading) {
+    if (location != null) {
+      printWriter.println("<PhotoOverlay>");
+      printWriter.println("<name>" + StringUtils.formatCData(name) + "</name>");
+      printWriter.println(
+          "<description>" + StringUtils.formatCData(description) + "</description>");
+      printWriter.print("<Camera>");
+      printWriter.print("<longitude>" + location.getLongitude() + "</longitude>");
+      printWriter.print("<latitude>" + location.getLatitude() + "</latitude>");
+      printWriter.print("<altitude>20</altitude>");
+      printWriter.print("<heading>" + heading + "</heading>");
+      printWriter.print("<tilt>90</tilt>");
+      printWriter.println("</Camera>");
+      printWriter.println("<TimeStamp><when>"
+          + StringUtils.formatDateTimeIso8601(location.getTime()) + "</when></TimeStamp>");
+      printWriter.println("<styleUrl>#" + styleName + "</styleUrl>");
+      writeCategory(category);
+      if (playTrack) {
+        printWriter.println("<Icon><href>" + Uri.decode(photoUrl) + "</href></Icon>"); 
+      } else {
+        Uri uri = Uri.parse(photoUrl);
+        printWriter.println("<Icon><href>" + KmzTrackExporter.KMZ_IMAGES_DIR + File.separatorChar
+            + uri.getLastPathSegment() + "</href></Icon>");        
+      }
+      
+      printWriter.print("<ViewVolume>");
+      printWriter.print("<near>10</near>");
+      printWriter.print("<leftFov>-60</leftFov>");
+      printWriter.print("<rightFov>60</rightFov>");
+      printWriter.print("<bottomFov>-45</bottomFov>");
+      printWriter.print("<topFov>45</topFov>");
+      printWriter.println("</ViewVolume>");
+      printWriter.println("<Point>");
+      printWriter.println("<coordinates>" + getCoordinates(location, ",") + "</coordinates>");
+      printWriter.println("</Point>");
+      printWriter.println("</PhotoOverlay>");
+    }
+  }
+
+  /**
+   * Gets the heading to a location.
+   * 
+   * @param trackId the track id containing the location
+   * @param location the location
+   */
+  private float getHeading(long trackId, Location location) {
+    long trackPointId = myTracksProviderUtils.getTrackPointId(trackId, location);
+    if (trackPointId == -1L) {
+      return location.getBearing();
+    }
+    Location viewLocation;
+    try (Cursor cursor = myTracksProviderUtils.getTrackPointCursor(trackId, trackPointId, 10, true)) {
+      if (cursor == null || cursor.getCount() == 0) {
+        return location.getBearing();
+      }
+      cursor.moveToPosition(cursor.getCount() - 1);
+      viewLocation = myTracksProviderUtils.createTrackPoint(cursor);
+    }
+    return viewLocation.bearingTo(location);
+  }
+  
+  private String getCoordinates(Location location, String separator) {
+    StringBuilder builder = new StringBuilder();
+    builder.append(location.getLongitude()).append(separator).append(location.getLatitude());
+    if (location.hasAltitude()) {
+      builder.append(separator).append(location.getAltitude());
+    }
+    return builder.toString();
+  }
+
+  /**
+   * Writes the category.
+   * 
+   * @param category the category
+   */
+  private void writeCategory(String category) {
+    if (category == null || category.equals("")) {
+      return;
+    }
+    printWriter.println("<ExtendedData>");
+    printWriter.println(
+        "<Data name=\"type\"><value>" + StringUtils.formatCData(category) + "</value></Data>");
+    printWriter.println("</ExtendedData>");
+  }
+
+  /**
+   * Writes the track style.
+   */
+  private void writeTrackStyle() {
+    printWriter.println("<Style id=\"" + TRACK_STYLE + "\">");
+    printWriter.println("<LineStyle><color>7f0000ff</color><width>4</width></LineStyle>");
+    printWriter.println("<IconStyle>");
+    printWriter.println("<scale>1.3</scale>");
+    printWriter.println("<Icon><href>" + TRACK_ICON + "</href></Icon>");
+    printWriter.println("</IconStyle>");
+    printWriter.println("</Style>");
+  }
+
+  /**
+   * Writes a placemarker style.
+   * 
+   * @param name the name of the style
+   * @param url the url of the style icon
+   * @param x the x position of the hotspot
+   * @param y the y position of the hotspot
+   */
+  private void writePlacemarkerStyle(String name, String url, int x, int y) {
+    printWriter.println("<Style id=\"" + name + "\"><IconStyle>");
+    printWriter.println("<scale>1.3</scale>");
+    printWriter.println("<Icon><href>" + url + "</href></Icon>");
+    printWriter.println(
+        "<hotSpot x=\"" + x + "\" y=\"" + y + "\" xunits=\"pixels\" yunits=\"pixels\"/>");
+    printWriter.println("</IconStyle></Style>");
+  }
+
+  /**
+   * Writes a sensor style.
+   * 
+   * @param name the name of the sesnor
+   * @param displayName the sensor display name
+   */
+  private void writeSensorStyle(String name, String displayName) {
+    printWriter.println("<gx:SimpleArrayField name=\"" + name + "\" type=\"int\">");
+    printWriter.println("<displayName>" + StringUtils.formatCData(displayName) + "</displayName>");
+    printWriter.println("</gx:SimpleArrayField>");
+  }
+}

src/main/java/com/google/android/apps/mytracks/io/file/exporter/KmzTrackExporter.java

@@ -0,0 +1,185 @@
+/*
+ * 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 com.google.android.apps.mytracks.io.file.exporter;
+
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils;
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.content.Waypoint;
+import com.google.android.apps.mytracks.util.PreferencesUtils;
+import com.google.android.maps.mytracks.R;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.net.Uri;
+import android.util.Log;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+
+/**
+ * KMZ track exporter.
+ * 
+ * @author Jimmy Shih
+ */
+public class KmzTrackExporter implements TrackExporter {
+
+  public static final String KMZ_EXTENSION = "kmz";
+  public static final String KMZ_IMAGES_DIR = "images";
+  public static final String KMZ_KML_FILE = "doc.kml";
+
+  private static final String TAG = KmzTrackExporter.class.getSimpleName();
+  private static final int BUFFER_SIZE = 4096;
+
+  private final MyTracksProviderUtils myTracksProviderUtils;
+  private final FileTrackExporter fileTrackExporter;
+  private final Track[] tracks;
+  private final long photoSize;
+
+  /**
+   * Constructor.
+   * 
+   * @param myTracksProviderUtils the my tracks provider utils
+   * @param fileTrackExporter the file track exporter
+   * @param tracks the tracks to export
+   * @param context the context
+   */
+  public KmzTrackExporter(MyTracksProviderUtils myTracksProviderUtils,
+      FileTrackExporter fileTrackExporter, Track[] tracks, Context context) {
+    this.myTracksProviderUtils = myTracksProviderUtils;
+    this.fileTrackExporter = fileTrackExporter;
+    this.tracks = tracks;
+    this.photoSize = PreferencesUtils.getInt(
+        context, R.string.photo_size_key, PreferencesUtils.PHOTO_SIZE_DEFAULT);
+  }
+
+  @Override
+  public boolean writeTrack(OutputStream outputStream) {
+    ZipOutputStream zipOutputStream = null;
+    try {
+      zipOutputStream = new ZipOutputStream(outputStream);
+
+      // Add kml file
+      ZipEntry zipEntry = new ZipEntry(KMZ_KML_FILE);
+      zipOutputStream.putNextEntry(zipEntry);
+
+      boolean success = fileTrackExporter.writeTrack(zipOutputStream);
+      zipOutputStream.closeEntry();
+      if (!success) {
+        Log.e(TAG, "Unable to write kml in kmz");
+        return false;
+      }
+
+      // Add photos
+      addImages(zipOutputStream);
+      return true;
+    } catch (InterruptedException e) {
+      Log.e(TAG, "Unable to write track", e);
+      return false;
+    } catch (IOException e) {
+      Log.e(TAG, "Unable to write track", e);
+      return false;
+    } finally {
+      if (zipOutputStream != null) {
+        try {
+          zipOutputStream.close();
+        } catch (IOException e) {
+          Log.e(TAG, "Unable to close zip input stream", e);
+        }
+      }
+    }
+  }
+
+  private void addImages(ZipOutputStream zipOutputStream) throws InterruptedException, IOException {
+    for (Track track : tracks) {
+      try (Cursor cursor = myTracksProviderUtils.getWaypointCursor(track.getId(), -1L, -1)) {
+        if (cursor != null && cursor.moveToFirst()) {
+          /*
+           * Yes, this will skip the first waypoint and that is intentional as
+           * the first waypoint holds the stats for the track.
+           */
+          while (cursor.moveToNext()) {
+            if (Thread.interrupted()) {
+              throw new InterruptedException();
+            }
+            Waypoint waypoint = myTracksProviderUtils.createWaypoint(cursor);
+            if (waypoint.hasPhoto()) {
+              addImage(zipOutputStream, waypoint.getPhotoUrl());
+            }
+          }
+        }
+      }
+    }
+  }
+
+  private void addImage(ZipOutputStream zipOutputStream, String photoUrl) throws IOException {
+    Uri uri = Uri.parse(photoUrl);
+    File file = new File(uri.getPath());
+    if (!file.exists()) {
+      Log.e(TAG, "file not found " + photoUrl);
+      return;
+    }
+
+    ZipEntry zipEntry = new ZipEntry(
+        KMZ_IMAGES_DIR + File.separatorChar + uri.getLastPathSegment());
+    zipOutputStream.putNextEntry(zipEntry);
+
+    int sampleSize;
+    if (photoSize == -1) {
+      sampleSize = 1;
+    } else {
+      long size = file.length();
+      // Convert from kilobytes to bytes.
+      long limit = photoSize * 1024;
+      sampleSize = size > limit ? (int) Math.ceil(size / limit) : 1;
+    }
+    if (sampleSize == 1) {
+      readFromFile(zipOutputStream, uri);
+    } else {
+      readFromScaledBitmap(zipOutputStream, uri, sampleSize);
+    }
+    zipOutputStream.closeEntry();
+  }
+
+  private void readFromScaledBitmap(ZipOutputStream zipOutputStream, Uri uri, int sampleSize) {
+    BitmapFactory.Options options = new BitmapFactory.Options();
+    options.inJustDecodeBounds = false;
+    options.inSampleSize = sampleSize;
+
+    Bitmap bitmap = BitmapFactory.decodeFile(uri.getPath(), options);
+    if (bitmap == null) {
+      return;
+    }
+    bitmap.compress(Bitmap.CompressFormat.JPEG, 100, zipOutputStream);
+    bitmap.recycle();
+  }
+
+  private void readFromFile(ZipOutputStream zipOutputStream, Uri uri) throws IOException {
+    try (FileInputStream fileInputStream = new FileInputStream(new File(uri.getPath()))) {
+      byte[] buffer = new byte[BUFFER_SIZE];
+      int byteCount;
+      while ((byteCount = fileInputStream.read(buffer)) != -1) {
+        zipOutputStream.write(buffer, 0, byteCount);
+      }
+    }
+  }
+}

src/main/java/com/google/android/apps/mytracks/io/file/exporter/SaveActivity.java

@@ -0,0 +1,225 @@
+/*
+ * 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 com.google.android.apps.mytracks.io.file.exporter;
+
+import com.google.android.apps.mytracks.io.file.TrackFileFormat;
+import com.google.android.apps.mytracks.util.DialogUtils;
+import com.google.android.apps.mytracks.util.FileUtils;
+import com.google.android.apps.mytracks.util.IntentUtils;
+import com.google.android.maps.mytracks.R;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.app.ProgressDialog;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.os.Bundle;
+import android.widget.Toast;
+
+import java.io.File;
+
+/**
+ * An activity for saving tracks to the external storage. If saving a specific
+ * track, option to save it to a temp directory and play the track afterward.
+ * 
+ * @author Rodrigo Damazio
+ */
+public class SaveActivity extends Activity {
+
+  public static final String EXTRA_TRACK_FILE_FORMAT = "track_file_format";
+  public static final String EXTRA_TRACK_IDS = "track_ids";
+  public static final String EXTRA_PLAY_TRACK = "play_track";
+
+  private static final int DIALOG_PROGRESS_ID = 0;
+  private static final int DIALOG_RESULT_ID = 1;
+
+  private TrackFileFormat trackFileFormat;
+  private long[] trackIds;
+  private boolean playTrack;
+  private String directoryDisplayName;
+
+  private SaveAsyncTask saveAsyncTask;
+  private ProgressDialog progressDialog;
+
+  // the number of tracks successfully saved
+  private int successCount;
+
+  // the number of tracks to save
+  private int totalCount;
+
+  // the last successfully saved path
+  private String savedPath;
+
+  @Override
+  public void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+
+    Intent intent = getIntent();
+    trackFileFormat = intent.getParcelableExtra(EXTRA_TRACK_FILE_FORMAT);
+    trackIds = intent.getLongArrayExtra(EXTRA_TRACK_IDS);
+    playTrack = intent.getBooleanExtra(EXTRA_PLAY_TRACK, false);
+
+    if (!FileUtils.isExternalStorageWriteable()) {
+      Toast.makeText(this, R.string.external_storage_not_writable, Toast.LENGTH_LONG).show();
+      finish();
+      return;
+    }
+
+    File directory = playTrack ? new File(getCacheDir(), FileUtils.PLAY_TRACKS_DIR)
+        : new File(FileUtils.getPath(trackFileFormat.getExtension()));
+    if (!FileUtils.ensureDirectoryExists(directory)) {
+      Toast.makeText(this, R.string.external_storage_not_writable, Toast.LENGTH_LONG).show();
+      finish();
+      return;
+    }
+
+    if (playTrack) {
+      for (File file : directory.listFiles()) {
+        file.delete();
+      }
+    }
+
+    directoryDisplayName = playTrack ? directory.getName()
+        : FileUtils.getPathDisplayName(trackFileFormat.getExtension());
+
+    Object retained = getLastNonConfigurationInstance();
+    if (retained instanceof SaveAsyncTask) {
+      saveAsyncTask = (SaveAsyncTask) retained;
+      saveAsyncTask.setActivity(this);
+    } else {
+      saveAsyncTask = new SaveAsyncTask(this, trackIds, trackFileFormat, playTrack, directory);
+      saveAsyncTask.execute();
+    }
+  }
+
+  @Override
+  public Object onRetainNonConfigurationInstance() {
+    saveAsyncTask.setActivity(null);
+    return saveAsyncTask;
+  }
+
+  @Override
+  protected Dialog onCreateDialog(int id) {
+    switch (id) {
+      case DIALOG_PROGRESS_ID:
+        progressDialog = DialogUtils.createHorizontalProgressDialog(this,
+            R.string.export_external_storage_progress_message,
+            new DialogInterface.OnCancelListener() {
+                @Override
+              public void onCancel(DialogInterface dialog) {
+                saveAsyncTask.cancel(true);
+                dialog.dismiss();
+              }
+            }, directoryDisplayName);
+        return progressDialog;
+      case DIALOG_RESULT_ID:
+        int iconId;
+        int titleId;
+        String message;
+        String totalTracks = getResources()
+            .getQuantityString(R.plurals.tracks, totalCount, totalCount);
+        if (successCount == totalCount) {
+          iconId = R.drawable.ic_dialog_success;
+          titleId = R.string.generic_success_title;
+          message = getString(
+              R.string.export_external_storage_success, totalTracks, directoryDisplayName);
+        } else {
+          iconId = android.R.drawable.ic_dialog_alert;
+          titleId = R.string.generic_error_title;
+          message = getString(R.string.export_external_storage_error, successCount, totalTracks,
+              directoryDisplayName);
+        }
+        AlertDialog.Builder builder = new AlertDialog.Builder(this).setCancelable(true)
+            .setIcon(iconId).setMessage(message)
+            .setOnCancelListener(new DialogInterface.OnCancelListener() {
+                @Override
+              public void onCancel(DialogInterface dialog) {
+                dialog.dismiss();
+                finish();
+              }
+            }).setPositiveButton(R.string.generic_ok, new DialogInterface.OnClickListener() {
+                @Override
+              public void onClick(DialogInterface dialog, int arg1) {
+                dialog.dismiss();
+                finish();
+              }
+            }).setTitle(titleId);
+        if (!playTrack && trackIds.length == 1 && trackIds[0] != -1L && successCount == totalCount
+            && savedPath != null) {
+          builder.setNegativeButton(
+              R.string.share_track_share_file, new DialogInterface.OnClickListener() {
+                  @Override
+                public void onClick(DialogInterface dialog, int which) {
+                  Intent intent = IntentUtils.newShareFileIntent(
+                      SaveActivity.this, trackIds[0], savedPath, trackFileFormat);
+                  startActivity(
+                      Intent.createChooser(intent, getString(R.string.share_track_picker_title)));
+                  finish();
+                }
+              });
+        }
+        final Dialog dialog = builder.create();
+        dialog.setOnShowListener(new DialogInterface.OnShowListener() {
+
+            @Override
+          public void onShow(DialogInterface dialogInterface) {
+            DialogUtils.setDialogTitleDivider(SaveActivity.this, dialog);
+          }
+        });
+        return dialog;
+      default:
+        return null;
+    }
+  }
+
+  /**
+   * Invokes when the associated AsyncTask completes.
+   * 
+   * @param aSuccessCount the number of tracks successfully saved
+   * @param aTotalCount the number of tracks to save
+   * @param aSavedPath the last successfully saved path
+   */
+  public void onAsyncTaskCompleted(int aSuccessCount, int aTotalCount, String aSavedPath) {
+    successCount = aSuccessCount;
+    totalCount = aTotalCount;
+    savedPath = aSavedPath;
+    removeDialog(DIALOG_PROGRESS_ID);
+    showDialog(DIALOG_RESULT_ID);
+  }
+
+  /**
+   * Shows the progress dialog.
+   */
+  public void showProgressDialog() {
+    showDialog(DIALOG_PROGRESS_ID);
+  }
+
+  /**
+   * Sets the progress dialog value.
+   * 
+   * @param number the number of points saved
+   * @param max the maximum number of points
+   */
+  public void setProgressDialogValue(int number, int max) {
+    if (progressDialog != null) {
+      progressDialog.setIndeterminate(false);
+      progressDialog.setMax(max);
+      progressDialog.setProgress(Math.min(number, max));
+    }
+  }
+}

src/main/java/com/google/android/apps/mytracks/io/file/exporter/SaveAsyncTask.java

@@ -0,0 +1,258 @@
+/*
+ * 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 com.google.android.apps.mytracks.io.file.exporter;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.os.AsyncTask;
+import android.os.PowerManager.WakeLock;
+import android.util.Log;
+
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils;
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.content.TracksColumns;
+import com.google.android.apps.mytracks.io.file.TrackFileFormat;
+import com.google.android.apps.mytracks.util.FileUtils;
+import com.google.android.apps.mytracks.util.PreferencesUtils;
+import com.google.android.apps.mytracks.util.SystemUtils;
+import com.google.android.maps.mytracks.R;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+/**
+ * Async Task to save tracks to the external storage.
+ * 
+ * @author Jimmy Shih
+ */
+public class SaveAsyncTask extends AsyncTask<Void, Integer, Boolean> {
+
+  private static final String TAG = SaveAsyncTask.class.getSimpleName();
+
+  private SaveActivity saveActivity;
+  private final long[] trackIds;
+  private final TrackFileFormat trackFileFormat;
+  private final boolean playTrack;
+  private final File directory;
+  private final Context context;
+  private final MyTracksProviderUtils myTracksProviderUtils;
+
+  private WakeLock wakeLock;
+
+  // true if the AsyncTask has completed
+  private boolean completed;
+
+  // the number of tracks successfully saved
+  private int successCount;
+
+  // the number of tracks to save
+  private int totalCount;
+
+  // the last successfully saved path
+  private String savedPath;
+
+  /**
+   * Creates an AsyncTask.
+   * 
+   * @param saveActivity the activity currently associated with this task
+   * @param trackIds the track ids to save. To save all, set to size 1 with
+   *          trackIds[0] == -1L
+   * @param trackFileFormat the track file format
+   * @param playTrack true to play track
+   * @param directory the directory to write the file
+   */
+  public SaveAsyncTask(SaveActivity saveActivity, long[] trackIds, TrackFileFormat trackFileFormat, boolean playTrack, File directory) {
+    this.saveActivity = saveActivity;
+    this.trackIds = trackIds;
+    this.trackFileFormat = trackFileFormat;
+    this.playTrack = playTrack;
+    this.directory = directory;
+    context = saveActivity.getApplicationContext();
+    myTracksProviderUtils = MyTracksProviderUtils.Factory.get(context);
+
+    completed = false;
+    successCount = 0;
+    totalCount = 0;
+    savedPath = null;
+  }
+
+  /**
+   * Sets the current activity associated with this AyncTask.
+   * 
+   * @param saveActivity the current activity, can be null
+   */
+  public void setActivity(SaveActivity saveActivity) {
+    this.saveActivity = saveActivity;
+    if (completed && saveActivity != null) {
+      saveActivity.onAsyncTaskCompleted(successCount, totalCount, savedPath);
+    }
+  }
+
+  @Override
+  protected void onPreExecute() {
+    if (saveActivity != null) {
+      saveActivity.showProgressDialog();
+    }
+  }
+
+  @Override
+  protected Boolean doInBackground(Void... params) {
+    try {
+      Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
+      boolean isRecording = PreferencesUtils.getLong(saveActivity, R.string.recording_track_id_key)
+          != PreferencesUtils.RECORDING_TRACK_ID_DEFAULT;
+      boolean isPaused = PreferencesUtils.getBoolean(saveActivity,
+          R.string.recording_track_paused_key, PreferencesUtils.RECORDING_TRACK_PAUSED_DEFAULT);
+      // Get the wake lock if not recording or paused
+      if (!isRecording || isPaused) {
+        wakeLock = SystemUtils.acquireWakeLock(saveActivity, wakeLock);
+      }
+      if (trackIds.length == 1 && trackIds[0] == -1L) {
+        return saveAllTracks();
+      } else {
+        totalCount = 1;
+        Track[] tracks = new Track[trackIds.length];
+        for (int i = 0; i < trackIds.length; i++) {
+          tracks[i] = myTracksProviderUtils.getTrack(trackIds[i]);
+          if (tracks[i] == null) {
+            Log.d(TAG, "No track for " + trackIds[i]);
+            return false;
+          }
+        }
+        if (saveTracks(tracks)) {
+          successCount = 1;
+          return true;
+        } else {
+          return false;
+        }
+      }
+    } finally {
+      if (wakeLock != null && wakeLock.isHeld()) {
+        wakeLock.release();
+      }
+    }
+  }
+
+  @Override
+  protected void onProgressUpdate(Integer... values) {
+    if (saveActivity != null) {
+      saveActivity.setProgressDialogValue(values[0], values[1]);
+    }
+  }
+
+  @Override
+  protected void onPostExecute(Boolean result) {
+    completed = true;
+    if (saveActivity != null) {
+      saveActivity.onAsyncTaskCompleted(successCount, totalCount, savedPath);
+    }
+  }
+
+  @Override
+  protected void onCancelled() {
+    completed = true;
+    if (saveActivity != null) {
+      saveActivity.onAsyncTaskCompleted(successCount, totalCount, null);
+    }
+  }
+
+  /**
+   * Saves tracks to one file.
+   * 
+   * @param tracks the tracks
+   */
+  private Boolean saveTracks(Track[] tracks) {
+    if (tracks.length == 0) {
+      return false;
+    }
+    
+    Track track = tracks[0];
+    boolean useKmz = trackFileFormat == TrackFileFormat.KML && !playTrack;
+    String extension = useKmz ? KmzTrackExporter.KMZ_EXTENSION : trackFileFormat.getExtension();
+    FileTrackExporter fileTrackExporter = new FileTrackExporter(myTracksProviderUtils, tracks,
+        trackFileFormat.newTrackWriter(context, tracks.length > 1, playTrack),
+        new TrackExporterListener() {
+
+            @Override
+          public void onProgressUpdate(int number, int max) {
+            /*
+             * If only saving one track, update the progress dialog once every
+             * 500 points
+             */
+            if (trackIds.length == 1 && trackIds[0] != -1L && number % 500 == 0) {
+              publishProgress(number, max);
+            }
+          }
+        });
+
+    TrackExporter trackExporter = useKmz ? new KmzTrackExporter(myTracksProviderUtils, fileTrackExporter, tracks, context) : fileTrackExporter;
+
+    String fileName = FileUtils.buildUniqueFileName(directory, track.getName(), extension);
+    File file = new File(directory, fileName);
+    FileOutputStream fileOutputStream = null;
+    try {
+      fileOutputStream = new FileOutputStream(file);
+      if (trackExporter.writeTrack(fileOutputStream)) {
+        savedPath = file.getAbsolutePath();
+        return true;
+      } else {
+        if (!file.delete()) {
+          Log.d(TAG, "Unable to delete file");
+        }
+        Log.e(TAG, "Unable to export track");
+        return false;
+      }
+    } catch (FileNotFoundException e) {
+      Log.e(TAG, "Unable to open file " + file.getName(), e);
+      return false;
+    } finally {
+      if (fileOutputStream != null) {
+        try {
+          fileOutputStream.close();
+        } catch (IOException e) {
+          Log.e(TAG, "Unable to close file output stream", e);
+        }
+      }
+    }
+  }
+
+  /**
+   * Saves all the tracks.
+   */
+  private Boolean saveAllTracks() {
+      try (Cursor cursor = myTracksProviderUtils.getTrackCursor(null, null, TracksColumns._ID)) {
+          if (cursor == null) {
+              return false;
+          }
+          totalCount = cursor.getCount();
+          for (int i = 0; i < totalCount; i++) {
+              if (isCancelled()) {
+                  return false;
+              }
+              cursor.moveToPosition(i);
+              Track track = myTracksProviderUtils.createTrack(cursor);
+              if (track != null && saveTracks(new Track[]{track})) {
+                  successCount++;
+              }
+              publishProgress(i + 1, totalCount);
+          }
+          return true;
+      }
+  }
+}

src/main/java/com/google/android/apps/mytracks/io/file/exporter/TrackExporter.java

@@ -0,0 +1,34 @@
+/*
+ * 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 com.google.android.apps.mytracks.io.file.exporter;
+
+import java.io.OutputStream;
+
+/**
+ * Track exporting for exporting track to an {@link OutputStream}.
+ * 
+ * @author Jimmy Shih
+ */
+public interface TrackExporter {
+ 
+  /**
+   * Write track to an output stream
+   * 
+   * @param outputStream the output stream
+   */
+  boolean writeTrack(OutputStream outputStream);
+}

src/main/java/com/google/android/apps/mytracks/io/file/exporter/TrackExporterListener.java

@@ -0,0 +1,33 @@
+/*
+ * 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 com.google.android.apps.mytracks.io.file.exporter;
+
+/**
+ * Listener for {@link TrackExporter} progress.
+ * 
+ * @author Jimmy Shih
+ */
+public interface TrackExporterListener {
+
+  /**
+   * Called to update progress.
+   * 
+   * @param number the number of locations written
+   * @param max the maximum number of locations in a track, for calculation of
+   *          completion percentage
+   */
+  void onProgressUpdate(int number, int max);
+}

src/main/java/com/google/android/apps/mytracks/io/file/exporter/TrackWriter.java

@@ -0,0 +1,144 @@
+/*
+ * 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 com.google.android.apps.mytracks.io.file.exporter;
+
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.content.Waypoint;
+
+import android.location.Location;
+
+import java.io.OutputStream;
+
+/**
+ * Interface for writing tracks to a file. The expected sequence of calls is:
+ * 
+ * <pre>
+ * {@link #prepare(OutputStream)}
+ * {@link #writeHeader(Track[])}
+ * For each track:
+ *     {@link #writeBeginWaypoints(Track)}
+ *     For each waypoint:
+ *         {@link #writeWaypoint(Waypoint)}
+ *     {@link #writeEndWaypoints()}
+ * {@link #writeBeginTracks()}
+ * For each track:
+ *     {@link #writeBeginTrack(Track, Location)}
+ *     For each segment:
+ *         {@link #writeOpenSegment()}
+ *         For each location in the segment:
+ *             {@link #writeLocation(Location)}
+ *         {@link #writeCloseSegment()}
+ *     {@link #writeEndTrack(Track, Location)}
+ * {@link #writeEndTracks()}
+ * {@link #writeFooter()}
+ * {@link #close()}
+ * </pre>
+ * 
+ * @author Rodrigo Damazio
+ */
+public interface TrackWriter {
+
+  /**
+   * Gets the file extension (e.g, gpx, kml, ...).
+   */
+  String getExtension();
+
+  /**
+   * Prepares the output stream.
+   * 
+   * @param outputStream the output stream
+   */
+  void prepare(OutputStream outputStream);
+
+  /**
+   * Closes the output stream.
+   */
+  void close();
+
+  /**
+   * Writes the header
+   * 
+   * @param tracks the tracks
+   */
+  void writeHeader(Track[] tracks);
+
+  /**
+   * Writes the footer.
+   */
+  void writeFooter();
+
+  /**
+   * Writes the beginning of the waypoints.
+   * 
+   * @param track the track
+   */
+  void writeBeginWaypoints(Track track);
+
+  /**
+   * Writes the end of the waypoints.
+   */
+  void writeEndWaypoints();
+
+  /**
+   * Writes a waypoint.
+   * 
+   * @param waypoint the waypoint
+   */
+  void writeWaypoint(Waypoint waypoint);
+
+  /**
+   * Writes the beginning of the tracks.
+   */
+  void writeBeginTracks();
+
+  /**
+   * Writes the end of the tracks,
+   */
+  void writeEndTracks();
+
+  /**
+   * Writes the beginning of a track.
+   * 
+   * @param track the track
+   * @param startLocation the start location
+   */
+  void writeBeginTrack(Track track, Location startLocation);
+
+  /**
+   * Writes the end of a track.
+   * 
+   * @param track the track
+   * @param endLocation the end location
+   */
+  void writeEndTrack(Track track, Location endLocation);
+
+  /**
+   * Writes open segment.
+   */
+  void writeOpenSegment();
+
+  /**
+   * Writes close segment.
+   */
+  void writeCloseSegment();
+
+  /**
+   * Writes a location.
+   * 
+   * @param location the location
+   */
+  void writeLocation(Location location);
+}

src/main/java/com/google/android/apps/mytracks/io/file/importer/AbstractFileTrackImporter.java

@@ -0,0 +1,619 @@
+/*
+ * 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 com.google.android.apps.mytracks.io.file.importer;
+
+import android.content.Context;
+import android.location.Location;
+import android.location.LocationManager;
+import android.net.Uri;
+import android.util.Log;
+
+import com.google.android.apps.mytracks.content.DescriptionGeneratorImpl;
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils;
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils.LocationIterator;
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.content.Waypoint;
+import com.google.android.apps.mytracks.content.Waypoint.WaypointType;
+import com.google.android.apps.mytracks.services.TrackRecordingService;
+import com.google.android.apps.mytracks.stats.TripStatistics;
+import com.google.android.apps.mytracks.stats.TripStatisticsUpdater;
+import com.google.android.apps.mytracks.util.FileUtils;
+import com.google.android.apps.mytracks.util.LocationUtils;
+import com.google.android.apps.mytracks.util.PreferencesUtils;
+import com.google.android.apps.mytracks.util.StringUtils;
+import com.google.android.apps.mytracks.util.TrackIconUtils;
+import com.google.android.apps.mytracks.util.UnitConversions;
+import com.google.android.maps.mytracks.R;
+
+import org.xml.sax.Locator;
+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.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.parsers.SAXParser;
+import javax.xml.parsers.SAXParserFactory;
+
+/**
+ * Abstract class for various file track importers like {@link GpxFileTrackImporter} and
+ * {@link KmlFileTrackImporter}.
+ * 
+ * @author Jimmy Shih
+ */
+abstract class AbstractFileTrackImporter extends DefaultHandler implements TrackImporter {
+
+  /**
+   * Data for the current track.
+   * 
+   * @author Jimmy Shih
+   */
+  private class TrackData {
+
+    // The current track
+    Track track = new Track();
+
+    // The number of segments processed for the current track
+    int numberOfSegments = 0;
+
+    /*
+     * The last location in the current segment. Null if the current segment
+     * doesn't have a last location.
+     */
+    Location lastLocationInCurrentSegment;
+
+    // The number of locations processed for the current track
+    int numberOfLocations = 0;
+
+    // The trip statistics updater for the current track
+    TripStatisticsUpdater tripStatisticsUpdater;
+
+    // The import time of the track.
+    long importTime = System.currentTimeMillis();
+
+    // The buffered locations
+    Location[] bufferedLocations = new Location[MAX_BUFFERED_LOCATIONS];
+
+    // The number of buffered locations
+    int numBufferedLocations = 0;
+  }
+
+  private static final String TAG = AbstractFileTrackImporter.class.getSimpleName();
+  
+  // The maximum number of buffered locations for bulk-insertion
+  private static final int MAX_BUFFERED_LOCATIONS = 512;
+
+  private final Context context;
+  private final long importTrackId;
+  private final MyTracksProviderUtils myTracksProviderUtils;
+  private final int recordingDistanceInterval;
+  private final List<Long> trackIds;
+  private final List<Waypoint> waypoints;
+
+  // The current track data
+  private TrackData trackData;
+
+  // The SAX locator to get the current line information
+  private Locator locator;
+
+  // The current element content
+  protected String content;
+
+  protected String name;
+  protected String description;
+  protected String category;
+  protected String latitude;
+  protected String longitude;
+  protected String altitude;
+  protected String time;
+  protected String waypointType;
+  protected String photoUrl;
+
+  /**
+   * Constructor.
+   * 
+   * @param context the context
+   * @param importTrackId the track id to import to. -1L to import to a new
+   *          track.
+   */
+  AbstractFileTrackImporter(
+      Context context, long importTrackId, MyTracksProviderUtils myTracksProviderUtils) {
+    this.context = context;
+    this.importTrackId = importTrackId;
+    this.myTracksProviderUtils = myTracksProviderUtils;
+    this.recordingDistanceInterval = PreferencesUtils.getInt(context,
+        R.string.recording_distance_interval_key,
+        PreferencesUtils.RECORDING_DISTANCE_INTERVAL_DEFAULT);
+    trackIds = new ArrayList<>();
+    waypoints = new ArrayList<>();
+  }
+
+  @Override
+  public void setDocumentLocator(Locator locator) {
+    this.locator = locator;
+  }
+
+  @Override
+  public void characters(char[] ch, int start, int length) {
+    String newContent = new String(ch, start, length);
+    if (content == null) {
+      content = newContent;
+    } else {
+      /*
+       * In 99% of the cases, a single call to this method will be made for each
+       * sequence of characters we're interested in, so we'll rarely be
+       * concatenating strings, thus not justifying the use of a StringBuilder.
+       */
+      content += newContent;
+    }
+  }
+
+  @Override
+  public long importFile(InputStream inputStream) {
+    try {
+      SAXParser saxParser = SAXParserFactory.newInstance().newSAXParser();
+      long start = System.currentTimeMillis();
+
+      saxParser.parse(inputStream, this);
+      Log.d(TAG, "Total import time: " + (System.currentTimeMillis() - start) + "ms");
+      if (trackIds.size() != 1) {
+        Log.d(TAG, trackIds.size() + " tracks imported");
+        cleanImport();
+        return -1L;
+      }
+      return trackIds.get(0);
+    } catch (IOException e) {
+      Log.e(TAG, "Unable to import file", e);
+      cleanImport();
+      return -1L;
+    } catch (ParserConfigurationException e) {
+      Log.e(TAG, "Unable to import file", e);
+      cleanImport();
+      return -1L;
+    } catch (SAXException e) {
+      Log.e(TAG, "Unable to import file", e);
+      cleanImport();
+      return -1L;
+    }
+  }
+
+  /**
+   * On file end.
+   */
+  protected void onFileEnd() {
+    // Add waypoints to the last imported track
+    int size = trackIds.size();
+    if (size == 0) {
+      return;
+    }
+    long trackId = trackIds.get(size - 1);
+    Track track = myTracksProviderUtils.getTrack(trackId);
+    if (track == null) {
+      return;
+    }
+
+    int waypointPosition = -1;
+    Waypoint waypoint = null;
+    Location location = null;
+    TripStatisticsUpdater trackTripStatisticstrackUpdater = new TripStatisticsUpdater(
+        track.getTripStatistics().getStartTime());
+    TripStatisticsUpdater markerTripStatisticsUpdater = new TripStatisticsUpdater(
+        track.getTripStatistics().getStartTime());
+    LocationIterator locationIterator = null;
+
+    try {
+      locationIterator = myTracksProviderUtils.getTrackPointLocationIterator(
+          track.getId(), -1L, false, MyTracksProviderUtils.DEFAULT_LOCATION_FACTORY);
+
+      while (true) {
+        if (waypoint == null) {
+          waypointPosition++;
+          waypoint = waypointPosition < waypoints.size() ? waypoints.get(waypointPosition) : null;
+          if (waypoint == null) {
+            // No more waypoints
+            return;
+          }
+        }
+        if (location == null) {
+          if (!locationIterator.hasNext()) {
+            // No more track points. Ignore the rest of the waypoints.
+            return;
+          }
+          location = locationIterator.next();
+          trackTripStatisticstrackUpdater.addLocation(location, recordingDistanceInterval);
+          markerTripStatisticsUpdater.addLocation(location, recordingDistanceInterval);
+        }
+        if (waypoint.getLocation().getTime() > location.getTime()) {
+          location = null;
+        } else if (waypoint.getLocation().getTime() < location.getTime()) {
+          waypoint = null;
+        } else {
+          // The waypoint location time matches the track point time
+
+          if (!LocationUtils.isValidLocation(location)) {
+            // Invalid location, load the next location
+            location = null;
+            continue;
+          }
+
+          // Valid location
+          if (location.getLatitude() == waypoint.getLocation().getLatitude()
+              && location.getLongitude() == waypoint.getLocation().getLongitude()) {
+
+            // Get tripStatistics, description, and icon
+            TripStatistics tripStatistics;
+            String waypointDescription;
+            String icon;
+            if (waypoint.getType() == WaypointType.STATISTICS) {
+              tripStatistics = markerTripStatisticsUpdater.getTripStatistics();
+              markerTripStatisticsUpdater = new TripStatisticsUpdater(location.getTime());
+              waypointDescription = new DescriptionGeneratorImpl(context)
+                  .generateWaypointDescription(tripStatistics);
+              icon = context.getString(R.string.marker_statistics_icon_url);
+            } else {
+              tripStatistics = null;
+              waypointDescription = waypoint.getDescription();
+              icon = context.getString(R.string.marker_waypoint_icon_url);
+            }
+
+            // Get length and duration
+            double length = trackTripStatisticstrackUpdater.getTripStatistics().getTotalDistance();
+            long duration = trackTripStatisticstrackUpdater.getTripStatistics().getTotalTime();
+
+            // Insert waypoint
+            Waypoint newWaypoint = new Waypoint(waypoint.getName(), waypointDescription,
+                waypoint.getCategory(), icon, track.getId(), waypoint.getType(), length, duration,
+                -1L, -1L, location, tripStatistics, waypoint.getPhotoUrl());
+            myTracksProviderUtils.insertWaypoint(newWaypoint);
+          }
+
+          // Load the next waypoint
+          waypoint = null;
+        }
+      }
+    } finally {
+      if (locationIterator != null) {
+        locationIterator.close();
+      }
+    }
+  }
+
+  /**
+   * On track start.
+   */
+  protected void onTrackStart() throws SAXException {
+    trackData = new TrackData();
+    long trackId;
+    if (importTrackId == -1L) {
+      Uri uri = myTracksProviderUtils.insertTrack(trackData.track);
+      trackId = Long.parseLong(uri.getLastPathSegment());
+    } else {
+      if (trackIds.size() > 0) {
+        throw new SAXException(createErrorMessage(
+            "Cannot import more than one track to an existing track " + importTrackId));
+      }
+      trackId = importTrackId;
+      myTracksProviderUtils.clearTrack(context, trackId);
+    }
+    trackIds.add(trackId);
+    trackData.track.setId(trackId);
+  }
+
+  /**
+   * On track end.
+   */
+  protected void onTrackEnd() {
+    flushLocations(trackData);
+    if (name != null) {
+      trackData.track.setName(name);
+    }
+    if (description != null) {
+      trackData.track.setDescription(description);
+    }
+    if (category != null) {
+      trackData.track.setCategory(category);
+      trackData.track.setIcon(TrackIconUtils.getIconValue(context, category));
+    }
+    if (trackData.tripStatisticsUpdater == null) {
+      trackData.tripStatisticsUpdater = new TripStatisticsUpdater(trackData.importTime);
+      trackData.tripStatisticsUpdater.updateTime(trackData.importTime);
+    }
+    trackData.track.setTripStatistics(trackData.tripStatisticsUpdater.getTripStatistics());
+    trackData.track.setNumberOfPoints(trackData.numberOfLocations);
+    myTracksProviderUtils.updateTrack(trackData.track);
+    insertFirstWaypoint(trackData.track);
+  }
+
+  /**
+   * On track segment start.
+   */
+  protected void onTrackSegmentStart() {
+    trackData.numberOfSegments++;
+
+    /*
+     * If not the first segment, add a pause separator if there is at least one
+     * location in the last segment.
+     */
+    if (trackData.numberOfSegments > 1 && trackData.lastLocationInCurrentSegment != null) {
+      insertLocation(createLocation(TrackRecordingService.PAUSE_LATITUDE, 0.0, 0.0,
+          trackData.lastLocationInCurrentSegment.getTime()));
+    }
+    trackData.lastLocationInCurrentSegment = null;
+  }
+
+  /**
+   * Adds a waypoint.
+   * 
+   * @param type the waypoint type
+   */
+  protected void addWaypoint(WaypointType type) throws SAXException {
+    // Waypoint must have a time, else cannot match to the track points
+    if (time == null) {
+      return;
+    }
+
+    Waypoint waypoint = new Waypoint();
+    Location location = createLocation();
+
+    if (!LocationUtils.isValidLocation(location)) {
+      throw new SAXException(createErrorMessage("Invalid location detected: " + location));
+    }
+    waypoint.setLocation(location);
+
+    if (name != null) {
+      waypoint.setName(name);
+    }
+    if (description != null) {
+      waypoint.setDescription(description);
+    }
+    if (category != null) {
+      waypoint.setCategory(category);
+    }
+    waypoint.setType(type);
+    
+    if (photoUrl != null) {
+      waypoint.setPhotoUrl(photoUrl);
+    }
+    waypoints.add(waypoint);
+  }
+
+  /**
+   * Gets a track point.
+   */
+  protected Location getTrackPoint() throws SAXException {
+    Location location = createLocation();
+
+    // Calculate derived attributes from the previous point
+    if (trackData.lastLocationInCurrentSegment != null && trackData.lastLocationInCurrentSegment.getTime() != 0) {
+      long timeDifference = location.getTime() - trackData.lastLocationInCurrentSegment.getTime();
+
+      // Check for negative time change
+      if (timeDifference <= 0) {
+        Log.w(TAG, "Time difference not postive.");
+      } else {
+
+        /*
+         * We don't have a speed and bearing in GPX, make something up from the
+         * last two points. GPS points tend to have some inherent imprecision,
+         * speed and bearing will likely be off, so the statistics for things
+         * like max speed will also be off.
+         */        
+        double duration = timeDifference * UnitConversions.MS_TO_S;
+        double speed = trackData.lastLocationInCurrentSegment.distanceTo(location) / duration;
+        location.setSpeed((float) speed);
+      }
+      location.setBearing(trackData.lastLocationInCurrentSegment.bearingTo(location));
+    }
+
+    if (!LocationUtils.isValidLocation(location)) {
+      throw new SAXException(createErrorMessage("Invalid location detected: " + location));
+    }
+
+    if (trackData.numberOfSegments > 1 && trackData.lastLocationInCurrentSegment == null) {
+      /*
+       * If not the first segment, add a resume separator before adding the
+       * first location.
+       */
+      insertLocation(
+          createLocation(TrackRecordingService.RESUME_LATITUDE, 0.0, 0.0, location.getTime()));
+    }
+    trackData.lastLocationInCurrentSegment = location;
+    return location;
+  }
+
+  /**
+   * Inserts a track point.
+   * 
+   * @param location the location
+   */
+  protected void insertTrackPoint(Location location) {
+    insertLocation(location);
+
+    if (trackData.track.getStartId() == -1L) {
+      // Flush the location to set the track start id and the track end id
+      flushLocations(trackData);
+    }
+  }
+
+  /**
+   * Creates an error message.
+   * 
+   * @param message the message
+   */
+  protected String createErrorMessage(String message) {
+    return String.format(Locale.US, "Parsing error at line: %d column: %d. %s",
+        locator.getLineNumber(), locator.getColumnNumber(), message);
+  }
+
+  /**
+   * Gets the photo url for a file.
+   * 
+   * @param fileName the file name
+   */
+  protected String getPhotoUrl(String fileName) {
+    if (importTrackId == -1L) {
+      return null;
+    }
+    File dir = FileUtils.getPhotoDir(importTrackId);
+    File file = new File(dir, fileName);
+    return Uri.fromFile(file).toString();    
+  }
+
+  /**
+   * Creates a location.
+   */
+  private Location createLocation() throws SAXException {
+    if (latitude == null || longitude == null) {
+      return null;
+    }
+    double latitudeValue;
+    double longitudeValue;
+    try {
+      latitudeValue = Double.parseDouble(latitude);
+      longitudeValue = Double.parseDouble(longitude);
+    } catch (NumberFormatException e) {
+      throw new SAXException(createErrorMessage(String.format(
+          Locale.US, "Unable to parse latitude longitude: %s %s", latitude, longitude)), e);
+    }
+    Double altitudeValue = null;
+    if (altitude != null) {
+      try {
+        altitudeValue = Double.parseDouble(altitude);
+      } catch (NumberFormatException e) {
+        throw new SAXException(
+            createErrorMessage(String.format(Locale.US, "Unable to parse altitude: %s", altitude)),
+            e);
+      }
+    }
+    
+    long timeValue;
+    if (time == null) {
+      timeValue = trackData.importTime;
+    } else {
+      try {
+        timeValue = StringUtils.getTime(time);
+      } catch (IllegalArgumentException e) {
+        throw new SAXException(
+            createErrorMessage(String.format(Locale.US, "Unable to parse time: %s", time)), e);
+      }
+    }
+    return createLocation(latitudeValue, longitudeValue, altitudeValue, timeValue);
+  }
+
+  /**
+   * Creates a location.
+   * 
+   * @param latitudeValue the latitude value
+   * @param longitudeValue the longitude value
+   * @param altitudeValue the altitude value
+   * @param timeValue the time value
+   */
+  private Location createLocation(
+      double latitudeValue, double longitudeValue, Double altitudeValue, long timeValue) {
+    Location location = new Location(LocationManager.GPS_PROVIDER);
+    location.setLatitude(latitudeValue);
+    location.setLongitude(longitudeValue);
+    if (altitudeValue != null) {
+      location.setAltitude(altitudeValue);      
+    } else {
+      location.removeAltitude();
+    }
+    location.setTime(timeValue);
+    location.removeAccuracy();
+    location.removeBearing();
+    location.removeSpeed();
+    return location;
+  }
+
+  /**
+   * Inserts a location.
+   * 
+   * @param location the location
+   */
+  private void insertLocation(Location location) {
+    if (trackData.tripStatisticsUpdater == null) {
+      trackData.tripStatisticsUpdater = new TripStatisticsUpdater(
+          location.getTime() != -1L ? location.getTime() : trackData.importTime);
+    }
+    trackData.tripStatisticsUpdater.addLocation(location, recordingDistanceInterval);
+
+    trackData.bufferedLocations[trackData.numBufferedLocations] = location;
+    trackData.numBufferedLocations++;
+    trackData.numberOfLocations++;
+
+    if (trackData.numBufferedLocations >= MAX_BUFFERED_LOCATIONS) {
+      flushLocations(trackData);
+    }
+  }
+
+  /**
+   * Flushes the locations to the database.
+   * 
+   * @param data the track data
+   */
+  private void flushLocations(TrackData data) {
+    if (data.numBufferedLocations <= 0) {
+      return;
+    }
+    myTracksProviderUtils.bulkInsertTrackPoint(
+        data.bufferedLocations, data.numBufferedLocations, data.track.getId());
+    data.numBufferedLocations = 0;
+    if (data.track.getStartId() == -1L) {
+      data.track.setStartId(myTracksProviderUtils.getFirstTrackPointId(data.track.getId()));
+    }
+    data.track.setStopId(myTracksProviderUtils.getLastTrackPointId(data.track.getId()));
+  }
+
+  /**
+   * Inserts the first waypoint, the track statistics waypoint.
+   * 
+   * @param track the track
+   */
+  private void insertFirstWaypoint(Track track) {
+    String waypointName = context.getString(R.string.marker_split_name_format, 0);
+    String waypointCategory = "";
+    TripStatisticsUpdater updater = new TripStatisticsUpdater(
+        track.getTripStatistics().getStartTime());
+    TripStatistics tripStatistics = updater.getTripStatistics();
+    String waypointDescription = new DescriptionGeneratorImpl(context).generateWaypointDescription(
+        tripStatistics);
+    String icon = context.getString(R.string.marker_statistics_icon_url);
+    double length = 0.0;
+    long duration = 0L;
+    Location waypointLocation = new Location("");
+    waypointLocation.setLatitude(100);
+    waypointLocation.setLongitude(180);
+    Waypoint waypoint = new Waypoint(waypointName, waypointDescription, waypointCategory, icon,
+        track.getId(), WaypointType.STATISTICS, length, duration, -1L, -1L, waypointLocation,
+        tripStatistics, "");
+    myTracksProviderUtils.insertWaypoint(waypoint);
+  }
+
+  /**
+   * Cleans up import.
+   */
+  private void cleanImport() {
+    for (long trackId : trackIds) {
+      myTracksProviderUtils.deleteTrack(context, trackId);
+    }
+  }
+}

src/main/java/com/google/android/apps/mytracks/io/file/importer/GpxFileTrackImporter.java

@@ -0,0 +1,190 @@
+/*
+ * 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 com.google.android.apps.mytracks.io.file.importer;
+
+import android.content.Context;
+import android.location.Location;
+import androidx.annotation.VisibleForTesting;
+
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils;
+import com.google.android.apps.mytracks.content.Waypoint.WaypointType;
+
+import org.xml.sax.Attributes;
+import org.xml.sax.SAXException;
+
+/**
+ * Imports a GPX file.
+ * 
+ * @author Jimmy Shih
+ */
+public class GpxFileTrackImporter extends AbstractFileTrackImporter {
+
+  private static final String TAG_DESCRIPTION = "desc";
+  private static final String TAG_COMMENT = "cmt";
+  private static final String TAG_ELEVATION = "ele";
+  private static final String TAG_GPX = "gpx";
+  private static final String TAG_NAME = "name";
+  private static final String TAG_TIME = "time";
+  private static final String TAG_TRACK = "trk";
+  private static final String TAG_TRACK_POINT = "trkpt";
+  private static final String TAG_TRACK_SEGMENT = "trkseg";
+  private static final String TAG_TYPE = "type";
+  private static final String TAG_WAYPOINT = "wpt";
+
+  private static final String ATTRIBUTE_LAT = "lat";
+  private static final String ATTRIBUTE_LON = "lon";
+  
+  /**
+   * Constructor.
+   * 
+   * @param context the context
+   */
+  public GpxFileTrackImporter(Context context) {
+    this(context, MyTracksProviderUtils.Factory.get(context));
+  }
+
+  @VisibleForTesting
+  GpxFileTrackImporter(Context context, MyTracksProviderUtils myTracksProviderUtils) {
+    super(context, -1L, myTracksProviderUtils);
+  }
+
+  @Override
+  public void startElement(String uri, String localName, String tag, Attributes attributes)
+      throws SAXException {
+      switch (tag) {
+          case TAG_WAYPOINT:
+              onWaypointStart(attributes);
+              break;
+          case TAG_TRACK:
+              onTrackStart();
+              break;
+          case TAG_TRACK_SEGMENT:
+              onTrackSegmentStart();
+              break;
+          case TAG_TRACK_POINT:
+              onTrackPointStart(attributes);
+              break;
+      }
+  }
+
+  @Override
+  public void endElement(String uri, String localName, String tag) throws SAXException {
+      switch (tag) {
+          case TAG_GPX:
+              onFileEnd();
+              break;
+          case TAG_WAYPOINT:
+              onWaypointEnd();
+              break;
+          case TAG_TRACK:
+              onTrackEnd();
+              break;
+          case TAG_TRACK_POINT:
+              onTrackPointEnd();
+              break;
+          case TAG_NAME:
+              if (content != null) {
+                  name = content.trim();
+              }
+              break;
+          case TAG_DESCRIPTION:
+              if (content != null) {
+                  description = content.trim();
+              }
+              break;
+          case TAG_TYPE:
+              if (content != null) {
+                  category = content.trim();
+              }
+              break;
+          case TAG_TIME:
+              if (content != null) {
+                  time = content.trim();
+              }
+              break;
+          case TAG_ELEVATION:
+              if (content != null) {
+                  altitude = content.trim();
+              }
+              break;
+          case TAG_COMMENT:
+              if (content != null) {
+                  waypointType = content.trim();
+              }
+              break;
+      }
+
+    // Reset element content
+    content = null;
+  }
+
+  @Override
+  protected void onTrackStart() throws SAXException {
+    super.onTrackStart();
+    name = null;
+    description = null;
+    category = null;
+  }
+
+  /**
+   * On track point start.
+   * 
+   * @param attributes the attributes
+   */
+  private void onTrackPointStart(Attributes attributes) {
+    latitude = attributes.getValue(ATTRIBUTE_LAT);
+    longitude = attributes.getValue(ATTRIBUTE_LON);
+    altitude = null;
+    time = null;
+  }
+
+  /**
+   * On track point end.
+   */
+  private void onTrackPointEnd() throws SAXException {
+    Location location = getTrackPoint();
+    if (location == null) {
+      return;
+    }
+    insertTrackPoint(location);
+  }
+
+  /**
+   * On waypoint start.
+   * 
+   * @param attributes the attributes
+   */
+  private void onWaypointStart(Attributes attributes) {
+    name = null;
+    description = null;
+    category = null;
+    photoUrl = null;
+    latitude = attributes.getValue(ATTRIBUTE_LAT);
+    longitude = attributes.getValue(ATTRIBUTE_LON);
+    altitude = null;
+    time = null;
+    waypointType = null;
+  }
+
+  /**
+   * On waypoint end.
+   */
+  private void onWaypointEnd() throws SAXException {
+    addWaypoint(WaypointType.STATISTICS.name().equals(waypointType) ? WaypointType.STATISTICS
+        : WaypointType.WAYPOINT);
+  }
+}

src/main/java/com/google/android/apps/mytracks/io/file/importer/ImportActivity.java

@@ -0,0 +1,239 @@
+/*
+ * 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 com.google.android.apps.mytracks.io.file.importer;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.app.ProgressDialog;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Bundle;
+import android.util.Log;
+import android.widget.Toast;
+
+import androidx.core.app.TaskStackBuilder;
+
+import com.google.android.apps.mytracks.TrackDetailActivity;
+import com.google.android.apps.mytracks.io.file.TrackFileFormat;
+import com.google.android.apps.mytracks.util.DialogUtils;
+import com.google.android.apps.mytracks.util.FileUtils;
+import com.google.android.apps.mytracks.util.IntentUtils;
+import com.google.android.maps.mytracks.R;
+
+import java.io.File;
+
+/**
+ * An activity to import files from the external storage. Optionally to import
+ * one specific file.
+ * 
+ * @author Rodrigo Damazio
+ */
+public class ImportActivity extends Activity {
+
+  public static final String EXTRA_IMPORT_ALL = "import_all";
+  public static final String EXTRA_TRACK_FILE_FORMAT = "track_file_format";
+
+  private static final String TAG = ImportActivity.class.getSimpleName();
+  private static final int DIALOG_PROGRESS_ID = 0;
+  private static final int DIALOG_RESULT_ID = 1;
+
+  private ImportAsyncTask importAsyncTask;
+  private ProgressDialog progressDialog;
+
+  private boolean importAll;
+
+  // the path on the external storage to import
+  private String directoryDisplayName;
+
+  // the number of files successfully imported
+  private int successCount;
+
+  // the number of files to import
+  private int totalCount;
+
+  // the last successfully imported track id
+  private long trackId;
+
+  @Override
+  public void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+
+    Intent intent = getIntent();
+    importAll = intent.getBooleanExtra(EXTRA_IMPORT_ALL, false);
+    TrackFileFormat trackFileFormat = intent.getParcelableExtra(EXTRA_TRACK_FILE_FORMAT);
+    if (trackFileFormat == null) {
+      trackFileFormat = TrackFileFormat.GPX;
+    }
+
+    if (!FileUtils.isExternalStorageAvailable()) {
+      Toast.makeText(this, R.string.external_storage_not_available, Toast.LENGTH_LONG).show();
+      finish();
+      return;
+    }
+    String directoryPath;
+    if (importAll) {
+      directoryDisplayName = FileUtils.getPathDisplayName(trackFileFormat.getExtension());
+      directoryPath = FileUtils.getPath(trackFileFormat.getExtension());
+      if (!FileUtils.isDirectory(new File(directoryPath))) {
+        Toast.makeText(
+            this, getString(R.string.import_no_directory, directoryDisplayName), Toast.LENGTH_LONG)
+            .show();
+        finish();
+        return;
+      }
+    } else {
+      String action = intent.getAction();
+      if (!(Intent.ACTION_ATTACH_DATA.equals(action) || Intent.ACTION_VIEW.equals(action))) {
+        Log.d(TAG, "Invalid action: " + intent);
+        finish();
+        return;
+      }
+
+      Uri data = intent.getData();
+      if ("file".equals(data.getScheme())) {
+        Log.d(TAG, "Invalid data: " + intent);
+        finish();
+        return;
+      }
+      directoryDisplayName = data.getPath();
+      directoryPath = data.getPath();
+    }
+
+    Object retained = getLastNonConfigurationInstance();
+    if (retained instanceof ImportAsyncTask) {
+      importAsyncTask = (ImportAsyncTask) retained;
+      importAsyncTask.setActivity(this);
+    } else {
+      importAsyncTask = new ImportAsyncTask(this, importAll, trackFileFormat, directoryPath);
+      importAsyncTask.execute();
+    }
+  }
+
+  @Override
+  public Object onRetainNonConfigurationInstance() {
+    importAsyncTask.setActivity(null);
+    return importAsyncTask;
+  }
+
+  @Override
+  protected Dialog onCreateDialog(int id) {
+    switch (id) {
+      case DIALOG_PROGRESS_ID:
+        progressDialog = DialogUtils.createHorizontalProgressDialog(
+            this, R.string.import_progress_message, new DialogInterface.OnCancelListener() {
+                @Override
+              public void onCancel(DialogInterface dialog) {
+                importAsyncTask.cancel(true);
+                dialog.dismiss();
+              }
+            }, directoryDisplayName);
+        return progressDialog;
+      case DIALOG_RESULT_ID:
+        int iconId;
+        int titleId;
+        String message;
+        String totalFiles = getResources()
+            .getQuantityString(R.plurals.files, totalCount, totalCount);
+        if (successCount == totalCount) {
+          if (totalCount == 0) {
+            iconId = android.R.drawable.ic_dialog_info;
+            titleId = R.string.import_no_file_title;
+            message = getString(R.string.import_no_file, directoryDisplayName);
+          } else {
+            iconId = R.drawable.ic_dialog_success;
+            titleId = R.string.generic_success_title;
+            message = getString(R.string.import_success, totalFiles, directoryDisplayName);
+          }
+        } else {
+          iconId = android.R.drawable.ic_dialog_alert;
+          titleId = R.string.generic_error_title;
+          message = getString(
+              R.string.import_error, successCount, totalFiles, directoryDisplayName);
+        }
+        final Dialog dialog = new AlertDialog.Builder(this).setCancelable(true).setIcon(iconId)
+            .setMessage(message).setOnCancelListener(new DialogInterface.OnCancelListener() {
+                @Override
+              public void onCancel(DialogInterface dialogInterface) {
+                dialogInterface.dismiss();
+                finish();
+              }
+            }).setPositiveButton(R.string.generic_ok, new DialogInterface.OnClickListener() {
+                @Override
+              public void onClick(DialogInterface dialogInterface, int which) {
+                if (successCount == totalCount && !importAll && trackId != -1L) {
+                  Intent intent = IntentUtils.newIntent(
+                      ImportActivity.this, TrackDetailActivity.class)
+                      .putExtra(TrackDetailActivity.EXTRA_TRACK_ID, trackId);
+                  TaskStackBuilder.create(ImportActivity.this)
+                      .addParentStack(TrackDetailActivity.class).addNextIntent(intent)
+                      .startActivities();
+                }
+                dialogInterface.dismiss();
+                finish();
+              }
+            }).setTitle(titleId).create();
+        dialog.setOnShowListener(new DialogInterface.OnShowListener() {
+
+            @Override
+          public void onShow(DialogInterface dialogInterface) {
+            DialogUtils.setDialogTitleDivider(ImportActivity.this, dialog);
+          }
+        });
+        return dialog;
+      default:
+        return null;
+    }
+  }
+
+  /**
+   * Invokes when the associated AsyncTask completes.
+   * 
+   * @param aSuccessCount the number of files successfully imported
+   * @param aTotalCount the number of files to import
+   * @param aTrackId the last successfully imported track id
+   */
+  public void onAsyncTaskCompleted(int aSuccessCount, int aTotalCount, long aTrackId) {
+    successCount = aSuccessCount;
+    totalCount = aTotalCount;
+    trackId = aTrackId;
+    removeDialog(DIALOG_PROGRESS_ID);
+    showDialog(DIALOG_RESULT_ID);
+  }
+
+  /**
+   * Shows the progress dialog.
+   */
+  public void showProgressDialog() {
+    showDialog(DIALOG_PROGRESS_ID);
+  }
+
+  /**
+   * Sets the progress dialog value.
+   * 
+   * @param number the number of files imported
+   * @param max the maximum number of files
+   */
+  public void setProgressDialogValue(int number, int max) {
+    if (progressDialog != null) {
+      progressDialog.setIndeterminate(false);
+      progressDialog.setMax(max);
+      progressDialog.setProgress(Math.min(number, max));
+    }
+  }
+}

src/main/java/com/google/android/apps/mytracks/io/file/importer/ImportAsyncTask.java

@@ -0,0 +1,241 @@
+/*
+ * 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 com.google.android.apps.mytracks.io.file.importer;
+
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils;
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.io.file.TrackFileFormat;
+import com.google.android.apps.mytracks.io.file.exporter.KmzTrackExporter;
+import com.google.android.apps.mytracks.util.FileUtils;
+import com.google.android.apps.mytracks.util.PreferencesUtils;
+import com.google.android.apps.mytracks.util.SystemUtils;
+import com.google.android.maps.mytracks.R;
+
+import android.content.Context;
+import android.net.Uri;
+import android.os.AsyncTask;
+import android.os.PowerManager.WakeLock;
+import android.util.Log;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * AsyncTask to import files from the external storage.
+ * 
+ * @author Jimmy Shih
+ */
+public class ImportAsyncTask extends AsyncTask<Void, Integer, Boolean> {
+
+  private static final String TAG = ImportAsyncTask.class.getSimpleName();
+
+  private ImportActivity importActivity;
+  private final boolean importAll;
+  private final TrackFileFormat trackFileFormat;
+  private final String path;
+  private final Context context;
+  private WakeLock wakeLock;
+
+  // true if the AsyncTask has completed
+  private boolean completed;
+
+  // the number of files successfully imported
+  private int successCount;
+
+  // the number of files to import
+  private int totalCount;
+
+  // the last successfully imported track id
+  private long trackId;
+
+  /**
+   * Creates an AsyncTask.
+   * 
+   * @param importActivity the activity currently associated with this AsyncTask
+   * @param importAll true to import all GPX files
+   * @param trackFileFormat the track file format
+   * @param path path to import GPX files
+   */
+  public ImportAsyncTask(ImportActivity importActivity, boolean importAll,
+      TrackFileFormat trackFileFormat, String path) {
+    this.importActivity = importActivity;
+    this.importAll = importAll;
+    this.trackFileFormat = trackFileFormat;
+    this.path = path;
+    context = importActivity.getApplicationContext();
+
+    completed = false;
+    successCount = 0;
+    totalCount = 0;
+    trackId = -1L;
+  }
+
+  /**
+   * Sets the current {@link ImportActivity} associated with this AyncTask.
+   * 
+   * @param importActivity the current {@link ImportActivity}, can be null
+   */
+  public void setActivity(ImportActivity importActivity) {
+    this.importActivity = importActivity;
+    if (completed && importActivity != null) {
+      importActivity.onAsyncTaskCompleted(successCount, totalCount, trackId);
+    }
+  }
+
+  @Override
+  protected void onPreExecute() {
+    if (importActivity != null) {
+      importActivity.showProgressDialog();
+    }
+  }
+
+  @Override
+  protected Boolean doInBackground(Void... params) {
+    try {
+      Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
+      // Get the wake lock if not recording or paused
+      boolean isRecording =
+          PreferencesUtils.getLong(importActivity, R.string.recording_track_id_key)
+          != PreferencesUtils.RECORDING_TRACK_ID_DEFAULT;
+      boolean isPaused = PreferencesUtils.getBoolean(importActivity,
+          R.string.recording_track_paused_key, PreferencesUtils.RECORDING_TRACK_PAUSED_DEFAULT);
+      if (!isRecording || isPaused) {
+        wakeLock = SystemUtils.acquireWakeLock(importActivity, wakeLock);
+      }
+
+      List<File> files = getFiles();
+      totalCount = files.size();
+      if (totalCount == 0) {
+        return true;
+      }
+
+      for (int i = 0; i < totalCount; i++) {
+        if (isCancelled()) {
+          // If cancelled, return true to show the number of files imported
+          return true;
+        }
+        if (importFile(files.get(i))) {
+          successCount++;
+        }
+        publishProgress(i + 1, totalCount);
+      }
+      return true;
+    } finally {
+      if (wakeLock != null && wakeLock.isHeld()) {
+        wakeLock.release();
+      }
+    }
+  }
+
+  @Override
+  protected void onProgressUpdate(Integer... values) {
+    if (importActivity != null) {
+      importActivity.setProgressDialogValue(values[0], values[1]);
+    }
+  }
+
+  @Override
+  protected void onPostExecute(Boolean result) {
+    completed = true;
+    if (importActivity != null) {
+      importActivity.onAsyncTaskCompleted(successCount, totalCount, trackId);
+    }
+  }
+
+  @Override
+  protected void onCancelled() {
+    completed = true;
+    if (importActivity != null) {
+      importActivity.onAsyncTaskCompleted(successCount, totalCount, trackId);
+    }
+  }
+  
+  /**
+   * Imports a file.
+   * 
+   * @param file the file
+   */
+  private boolean importFile(final File file) {
+    FileInputStream fileInputStream = null;
+    try {
+      TrackImporter trackImporter;
+      if (trackFileFormat == TrackFileFormat.KML) {
+        String extension = FileUtils.getExtension(file.getName());
+        if (TrackFileFormat.KML.getExtension().equals(extension)) {
+          trackImporter = new KmlFileTrackImporter(context, -1L);
+        } else {         
+          MyTracksProviderUtils myTracksProviderUtils = MyTracksProviderUtils.Factory.get(context);
+          Uri uri = myTracksProviderUtils.insertTrack(new Track());
+          long newId = Long.parseLong(uri.getLastPathSegment());
+
+          trackImporter = new KmzTrackImporter(context, newId);
+        }
+      } else {
+        trackImporter = new GpxFileTrackImporter(context);
+      }
+      fileInputStream = new FileInputStream(file);
+      trackId = trackImporter.importFile(fileInputStream);
+      return trackId != -1L;
+    } catch (FileNotFoundException e) {
+      Log.e(TAG, "Unable to import file", e);
+      return false;
+    } finally {
+      if (fileInputStream != null) {
+        try {
+          fileInputStream.close();
+        } catch (IOException e) {
+          Log.e(TAG, "Unable to close file input stream", e);
+        }
+      }
+    }
+  }
+  
+  /**
+   * Gets a list of files. If importAll is true, returns a list of the files
+   * under the path directory. If importAll is false, returns a list containing
+   * just the path file.
+   */
+  private List<File> getFiles() {
+    List<File> files = new ArrayList<>();
+    File file = new File(path);
+    if (importAll) {
+      File[] candidates = file.listFiles();
+      if (candidates != null) {
+        for (File candidate : candidates) {
+          if (!FileUtils.isDirectory(candidate)) {
+            String extension = FileUtils.getExtension(candidate.getName());
+            if (trackFileFormat == TrackFileFormat.KML && (
+                TrackFileFormat.KML.getExtension().equals(extension)
+                || KmzTrackExporter.KMZ_EXTENSION.equals(extension))) {
+              files.add(candidate);
+            } else if (trackFileFormat == TrackFileFormat.GPX
+                && TrackFileFormat.GPX.getExtension().equals(extension)) {
+              files.add(candidate);
+            }
+          }         
+        }
+      }
+    } else {
+      files.add(file);
+    }
+    return files;
+  }
+}

src/main/java/com/google/android/apps/mytracks/io/file/importer/KmlFileTrackImporter.java

@@ -0,0 +1,311 @@
+/*
+ * 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 com.google.android.apps.mytracks.io.file.importer;
+
+import android.content.Context;
+import android.location.Location;
+import android.net.Uri;
+
+import androidx.annotation.VisibleForTesting;
+
+import com.google.android.apps.mytracks.content.MyTracksLocation;
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils;
+import com.google.android.apps.mytracks.content.Waypoint.WaypointType;
+import com.google.android.apps.mytracks.content.sensor.SensorDataSet;
+
+import org.xml.sax.Attributes;
+import org.xml.sax.SAXException;
+
+import java.util.ArrayList;
+
+/**
+ * Imports a KML file.
+ * 
+ * @author Jimmy Shih
+ */
+public class KmlFileTrackImporter extends AbstractFileTrackImporter {
+
+  private static final String CADENCE = "cadence";
+  private static final String HEART_RATE = "heart_rate";
+  private static final String POWER = "power";
+
+  private static final String STATISTICS_STYLE = "#statistics";
+  private static final String WAYPOINT_STYLE = "#waypoint";
+
+  private static final String TAG_COORDINATES = "coordinates";
+  private static final String TAG_DESCRIPTION = "description";
+  private static final String TAG_GX_COORD = "gx:coord";
+  private static final String TAG_GX_MULTI_TRACK = "gx:MultiTrack";
+  private static final String TAG_GX_SIMPLE_ARRAY_DATA = "gx:SimpleArrayData";
+  private static final String TAG_GX_TRACK = "gx:Track";
+  private static final String TAG_GX_VALUE = "gx:value";
+  private static final String TAG_HREF = "href";
+  private static final String TAG_KML = "kml";
+  private static final String TAG_NAME = "name";
+  private static final String TAG_PHOTO_OVERLAY = "PhotoOverlay";
+  private static final String TAG_PLACEMARK = "Placemark";
+  private static final String TAG_STYLE_URL = "styleUrl";
+  private static final String TAG_VALUE = "value";
+  private static final String TAG_WHEN = "when";
+
+  private static final String ATTRIBUTE_NAME = "name";
+
+  private boolean trackStarted = false;
+  private String sensorName;
+  private ArrayList<Location> locationList;
+  private ArrayList<Integer> cadenceList;
+  private ArrayList<Integer> heartRateList;
+  private ArrayList<Integer> powerList;
+
+  /**
+   * Constructor.
+   * 
+   * @param context the context
+   * @param importTrackId track id to import to. -1L to import to a new track.
+   */
+  public KmlFileTrackImporter(Context context, long importTrackId) {
+    this(context, importTrackId, MyTracksProviderUtils.Factory.get(context));
+  }
+
+  @VisibleForTesting
+  KmlFileTrackImporter(
+      Context context, long importTrackId, MyTracksProviderUtils myTracksProviderUtils) {
+    super(context, importTrackId, myTracksProviderUtils);
+  }
+
+  @Override
+  public void startElement(String uri, String localName, String tag, Attributes attributes)
+      throws SAXException {
+    switch (tag) {
+      case TAG_PLACEMARK:
+      case TAG_PHOTO_OVERLAY:
+        /*
+         * Note that a track is contained in a Placemark, calling onWaypointStart
+         * will clear various track variables like name, category, and
+         * description.
+         */
+        onWaypointStart();
+        break;
+      case TAG_GX_MULTI_TRACK:
+        trackStarted = true;
+        onTrackStart();
+        break;
+      case TAG_GX_TRACK:
+        if (!trackStarted) {
+          throw new SAXException("No " + TAG_GX_MULTI_TRACK);
+        }
+        onTrackSegmentStart();
+        break;
+      case TAG_GX_SIMPLE_ARRAY_DATA:
+        onSensorDataStart(attributes);
+        break;
+    }
+  }
+
+  @Override
+  public void endElement(String uri, String localName, String tag) throws SAXException {
+    if (tag.equals(TAG_KML)) {
+      onFileEnd();
+    } else if (tag.equals(TAG_PLACEMARK) || tag.equals(TAG_PHOTO_OVERLAY)) {
+      /*
+       * Note that a track is contained in a Placemark, calling onWaypointend is
+       * save since waypointType is not set for a track.
+       */
+      onWaypointEnd();
+    } else if (localName.equals(TAG_COORDINATES)) {
+      onWaypointLocationEnd();
+    } else if (tag.equals(TAG_GX_MULTI_TRACK)) {
+      onTrackEnd();
+    } else if (tag.equals(TAG_GX_TRACK)) {
+      onTrackSegmentEnd();
+    } else if (tag.equals(TAG_GX_COORD)) {
+      onTrackPointEnd();
+    } else if (tag.equals(TAG_GX_VALUE)) {
+      onSensorValueEnd();
+    } else if (tag.equals(TAG_NAME)) {
+      if (content != null) {
+        name = content.trim();
+      }
+    } else if (localName.equals(TAG_DESCRIPTION)) {
+      if (content != null) {
+        description = content.trim();
+      }
+    } else if (localName.equals(TAG_VALUE)) {
+      if (content != null) {
+        category = content.trim();
+      }
+    } else if (localName.equals(TAG_WHEN)) {
+      if (content != null) {
+        time = content.trim();
+      }
+    } else if (localName.equals(TAG_STYLE_URL)) {
+      if (content != null) {
+        waypointType = content.trim();
+      }
+    } else if (localName.equals(TAG_HREF)) {
+      if (content != null) {
+        photoUrl = content.trim();
+      }
+    }
+
+    // Reset element content
+    content = null;
+  }
+
+  /**
+   * On waypoint start.
+   */
+  private void onWaypointStart() {
+    // Reset all Placemark variables
+    name = null;
+    description = null;
+    category = null;
+    photoUrl = null;
+    latitude = null;
+    longitude = null;
+    altitude = null;
+    time = null;
+    waypointType = null;
+  }
+
+  /**
+   * On waypoint end.
+   */
+  private void onWaypointEnd() throws SAXException {
+    // Add a waypoint if the waypointType matches
+    WaypointType type = null;
+    if (WAYPOINT_STYLE.equals(waypointType)) {
+      type = WaypointType.WAYPOINT;
+    } else if (STATISTICS_STYLE.equals(waypointType)) {
+      type = WaypointType.STATISTICS;
+    }
+    if (type == null) {
+      return;
+    }
+    if (photoUrl != null) {
+      Uri uri = Uri.parse(photoUrl);
+      photoUrl = getPhotoUrl(uri.getLastPathSegment());
+    }
+    addWaypoint(type);
+  }
+
+  /**
+   * On waypoint location end.
+   */
+  private void onWaypointLocationEnd() {
+    if (content != null) {
+      String[] parts = content.trim().split(",");
+      if (parts.length != 2 && parts.length != 3) {
+        return;
+      }
+      longitude = parts[0];
+      latitude = parts[1];
+      altitude = parts.length == 3 ? parts[2] : null;      
+    }
+  }
+
+  @Override
+  protected void onTrackSegmentStart() {
+    super.onTrackSegmentStart();
+    locationList = new ArrayList<>();
+    heartRateList = new ArrayList<>();
+    cadenceList = new ArrayList<>();
+    powerList = new ArrayList<>();
+  }
+
+  /**
+   * On track segment end.
+   */
+  private void onTrackSegmentEnd() {
+    // Close a track segment by inserting the segment locations
+    boolean hasHeartRate = heartRateList.size() == locationList.size();
+    boolean hasCadence = cadenceList.size() == locationList.size();
+    boolean hasPower = powerList.size() == locationList.size();
+
+    for (int i = 0; i < locationList.size(); i++) {
+      Location location = locationList.get(i);
+
+      if (!hasPower && !hasCadence && !hasHeartRate) {
+        insertTrackPoint(location);
+      } else {
+        float heartrate = hasHeartRate ? heartRateList.get(i) : SensorDataSet.DATA_UNAVAILABLE;
+        float cadence = hasHeartRate ? cadenceList.get(i) : SensorDataSet.DATA_UNAVAILABLE;
+        float power = hasHeartRate ? powerList.get(i) : SensorDataSet.DATA_UNAVAILABLE;
+
+        MyTracksLocation myTracksLocation = new MyTracksLocation(location, new SensorDataSet(heartrate, cadence, power, SensorDataSet.DATA_UNAVAILABLE, location.getTime()));
+        insertTrackPoint(myTracksLocation);
+      }
+    }
+  }
+
+  /**
+   * On track point end. gx:coord end tag.
+   */
+  private void onTrackPointEnd() throws SAXException {
+    // Add location to locationList
+    if (content == null) {
+      return;
+    }
+    String[] parts = content.trim().split(" ");
+    if (parts.length != 2 && parts.length != 3) {
+      return;
+    }
+    longitude = parts[0];
+    latitude = parts[1];
+    altitude = parts.length == 3 ? parts[2] : null;
+
+    Location location = getTrackPoint();
+    if (location == null) {
+      return;
+    }
+    locationList.add(location);
+    time = null;
+  }
+
+  /**
+   * On sensor data start. gx:SimpleArrayData start tag.
+   */
+  private void onSensorDataStart(Attributes attributes) {
+    sensorName = attributes.getValue(ATTRIBUTE_NAME);
+  }
+
+  /**
+   * On sensor value end. gx:value end tag.
+   */
+  private void onSensorValueEnd() throws SAXException {
+    if (content == null) {
+      return;
+    }
+    content = content.trim();
+    if (content.equals("")) {
+      return;
+    }
+    int value;
+    try {
+      value = Integer.parseInt(content);
+    } catch (NumberFormatException e) {
+      throw new SAXException(createErrorMessage("Unable to parse gx:value:" + content), e);
+    }
+    if (POWER.equals(sensorName)) {
+      powerList.add(value);
+    } else if (HEART_RATE.equals(sensorName)) {
+      heartRateList.add(value);
+    } else if (CADENCE.equals(sensorName)) {
+      cadenceList.add(value);
+    }
+  }
+}

src/main/java/com/google/android/apps/mytracks/io/file/importer/KmzTrackImporter.java

@@ -0,0 +1,198 @@
+/*
+ * 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 com.google.android.apps.mytracks.io.file.importer;
+
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils;
+import com.google.android.apps.mytracks.io.file.exporter.KmzTrackExporter;
+import com.google.android.apps.mytracks.util.FileUtils;
+
+import android.content.Context;
+import android.net.Uri;
+import android.util.Log;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+
+/**
+ * Imports a KMZ file.
+ * 
+ * @author Jimmy Shih
+ */
+public class KmzTrackImporter implements TrackImporter {
+
+  private static final String TAG = KmzTrackImporter.class.getSimpleName();
+  private static final int BUFFER_SIZE = 4096;
+
+  private final Context context;
+  private final long importTrackId;
+
+  /**
+   * Constructor.
+   * 
+   * @param context the context
+   * @param importTrackId track id to import to. This should not be -1L so that
+   *          images in the kmz file can be imported.
+   */
+  public KmzTrackImporter(Context context, long importTrackId) {
+    this.context = context;
+    this.importTrackId = importTrackId;
+  }
+
+  @Override
+  public long importFile(InputStream inputStream) {
+    ZipInputStream zipInputStream = null;
+    long trackId = importTrackId;
+    try {
+      ZipEntry zipEntry;
+
+      zipInputStream = new ZipInputStream(inputStream);
+      while ((zipEntry = zipInputStream.getNextEntry()) != null) {
+        if (Thread.interrupted()) {
+          Log.d(TAG, "Thread interrupted");
+          cleanImport(trackId);
+          return -1L;
+        }
+        String fileName = zipEntry.getName();
+        if (fileName.equals(KmzTrackExporter.KMZ_KML_FILE)) {
+          trackId = parseKml(zipInputStream);
+          if (trackId == -1L) {
+            Log.d(TAG, "Unable to parse kml in kmz");
+            cleanImport(trackId);
+            return -1L;
+          }
+        } else {
+          String prefix = KmzTrackExporter.KMZ_IMAGES_DIR + File.separatorChar;
+          if (fileName.startsWith(prefix)) {
+            readImageFile(zipInputStream, fileName.substring(prefix.length()));
+          }
+        }
+        zipInputStream.closeEntry();
+      }
+      return trackId;
+    } catch (IOException e) {
+      Log.e(TAG, "Unable to import file", e);
+      cleanImport(trackId);
+      return -1L;
+    } finally {
+      if (zipInputStream != null) {
+        try {
+          zipInputStream.close();
+        } catch (IOException e) {
+          Log.e(TAG, "Unable to close zip input stream", e);
+        }
+      }
+    }
+  }
+
+  /**
+   * Cleans up import.
+   * 
+   * @param trackId the trackId
+   */
+  private void cleanImport(long trackId) {
+    if (trackId != -1L) {
+      MyTracksProviderUtils myTracksProviderUtils = MyTracksProviderUtils.Factory.get(context);
+      myTracksProviderUtils.deleteTrack(context, trackId);
+    }
+
+    if (importTrackId != -1L) {
+      File dir = FileUtils.getPhotoDir(importTrackId);
+      if (FileUtils.isDirectory(dir)) {
+        for (File file : dir.listFiles()) {
+          file.delete();
+        }
+        dir.delete();
+        FileUtils.updateMediaScanner(context, Uri.fromFile(dir));
+      }
+    }
+  }
+
+  /**
+   * Parses kml
+   * 
+   * @param zipInputStream the zip input stream
+   * @return the imported track id or -1L
+   */
+  private long parseKml(ZipInputStream zipInputStream) throws IOException {
+    ByteArrayInputStream byteArrayInputStream = null;
+    try {
+      KmlFileTrackImporter kmlFileTrackImporter = new KmlFileTrackImporter(context, importTrackId);
+      byteArrayInputStream = new ByteArrayInputStream(getKml(zipInputStream));
+      return kmlFileTrackImporter.importFile(byteArrayInputStream);
+    } finally {
+      if (byteArrayInputStream != null) {
+        byteArrayInputStream.close();
+      }
+    }
+  }
+
+  /**
+   * 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);
+      }
+      return byteArrayOutputStream.toByteArray();
+    }
+  }
+
+  /**
+   * Reads an image file.
+   * 
+   * @param zipInputStream the zip input stream
+   * @param fileName the file name
+   */
+  private void readImageFile(ZipInputStream zipInputStream, String fileName) throws IOException {
+    FileOutputStream fileOutputStream = null;
+    try {
+      if (importTrackId == -1L) {
+        return;
+      }
+      if (fileName.equals("")) {
+        return;
+      }
+      File dir = FileUtils.getPhotoDir(importTrackId);
+      FileUtils.ensureDirectoryExists(dir);
+
+      File file = new File(dir, fileName);
+      fileOutputStream = new FileOutputStream(file);
+      byte[] buffer = new byte[BUFFER_SIZE];
+      int count;
+      while ((count = zipInputStream.read(buffer)) != -1) {
+        fileOutputStream.write(buffer, 0, count);
+      }
+      
+      FileUtils.updateMediaScanner(context, Uri.fromFile(file));     
+    } finally {
+      if (fileOutputStream != null) {
+        fileOutputStream.close();
+      }
+    }
+  }
+}

src/main/java/com/google/android/apps/mytracks/io/file/importer/TrackImporter.java

@@ -0,0 +1,34 @@
+/*
+ * 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 com.google.android.apps.mytracks.io.file.importer;
+
+import java.io.InputStream;
+
+/**
+ * Interface for a track importer.
+ * 
+ * @author Jimmy Shih
+ */
+public interface TrackImporter {
+
+  /**
+   * Import a file.
+   * 
+   * @param inputStream the file's input stream
+   * @return the imported track id or -1L.
+   */
+  long importFile(InputStream inputStream);
+}

src/main/java/com/google/android/apps/mytracks/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 com.google.android.apps.mytracks.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/com/google/android/apps/mytracks/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 com.google.android.apps.mytracks.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;
+  }
+}