More tests.

MyTracks/src/com/google/android/apps/mytracks/services/AbsoluteLocationListenerPolicy.java

@@ -0,0 +1,59 @@
+/*
+ * 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 {
+
+  /**
+   * The interval to request for gps signal.
+   */
+  private final long interval;
+
+  /**
+   * @param interval The interval to request for gps signal
+   */
+  public AbsoluteLocationListenerPolicy(final long interval) {
+    this.interval = interval;
+  }
+
+  /**
+   * @return The interval given in the constructor
+   */
+  public long getDesiredPollingInterval() {
+    return interval;
+  }
+
+  /**
+   * Discards the idle time.
+   */
+  public void updateIdleTime(long idleTime) {
+  }
+
+  /**
+   * Returns the minimum distance between updates.
+   * Get all updates to properly measure moving time.
+   */
+  public int getMinDistance() {
+    return 0;
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/services/AdaptiveLocationListenerPolicy.java

@@ -0,0 +1,81 @@
+/*
+ * 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 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 whic is half of
+ * the idle time.
+ *
+ * @author Sandor Dornbush
+ */
+public class AdaptiveLocationListenerPolicy implements LocationListenerPolicy {
+
+  /**
+   * Smallest interval this policy will dictate, in milliseconds.
+   */
+  private final long minInterval;
+
+  /**
+   * Largest interval this policy will dictate, in milliseconds.
+   */
+  private final long maxInterval;
+
+  private final int minDistance;
+
+  /**
+   * The time the user has been at the current location, in milliseconds.
+   */
+  private long idleTime;
+
+  /**
+   * Creates a policy that will be bounded by the given min and max.
+   *
+   * @param min Smallest interval this policy will dictate, in milliseconds
+   * @param max Largest interval this policy will dictate, in milliseconds
+   */
+  public AdaptiveLocationListenerPolicy(long min, long max, int minDistance) {
+    this.minInterval = min;
+    this.maxInterval = max;
+    this.minDistance = minDistance;
+  }
+
+  /**
+   * @return An interval bounded by min and max which is half of the idle time
+   */
+  public long getDesiredPollingInterval() {
+    long desiredInterval = idleTime / 2;
+    // Round to avoid setting the interval too often.
+    desiredInterval = (desiredInterval / 1000) * 1000;
+    return Math.max(Math.min(maxInterval, desiredInterval),
+                    minInterval);
+  }
+
+  public void updateIdleTime(long newIdleTime) {
+    this.idleTime = newIdleTime;
+  }
+
+  /**
+   * Returns the minimum distance between updates.
+   */
+  public int getMinDistance() {
+    return minDistance;
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/services/DefaultTrackNameFactory.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.services;
+
+import com.google.android.apps.mytracks.MyTracksSettings;
+import com.google.android.maps.mytracks.R;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.text.format.Time;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+/**
+ * Creates a default track name based on the current default track name policy.
+ * 
+ * @author Matthew Simmons
+ */
+class DefaultTrackNameFactory {
+  private static final String TIMESTAMP_DATE_FORMAT = "yyyy-MM-dd HH:mm";
+
+  private final Context context;
+
+  DefaultTrackNameFactory(Context context) {
+    this.context = context;
+  }
+
+  /**
+   * Creates a new track name.
+   * 
+   * @param trackId The ID for the current track.
+   * @param startTime The start time, in milliseconds since the epoch, of the
+   *     current track.
+   * @return The new track name.
+   */
+  String newTrackName(long trackId, long startTime) {
+    if (useTimestampTrackName()) {
+      SimpleDateFormat formatter = new SimpleDateFormat(TIMESTAMP_DATE_FORMAT);
+      return formatter.format(new Date(startTime));
+    } else {
+      return String.format(context.getString(R.string.new_track), trackId);
+    }
+  }
+
+  /** Determines whether the preferences allow a timestamp-based track name */
+  protected boolean useTimestampTrackName() {
+    SharedPreferences prefs =
+        context.getSharedPreferences(MyTracksSettings.SETTINGS_NAME, 0);
+    return prefs.getBoolean(
+        context.getString(R.string.timestamp_track_name_key), true);
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/services/ITrackRecordingService.aidl

@@ -0,0 +1,96 @@
+/*
+ * 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.services;
+
+import com.google.android.apps.mytracks.content.Waypoint;
+
+/**
+ * MyTracks service.
+ * This service is the process that actually records and manages tracks.
+ */
+interface ITrackRecordingService {
+
+  /**
+   * Starts recording a new track.
+   *
+   * @return the track ID of the new track
+   */
+  long startNewTrack();
+
+  /**
+   * Checks and returns whether we're currently recording a track.
+   */
+  boolean isRecording();
+
+  /**
+   * Returns the track ID of the track currently being recorded, or -1 if none
+   * is being recorded. This ID can then be used to read track data from the
+   * content source.
+   */
+  long getRecordingTrackId();
+
+  /**
+   * Inserts a waypoint marker in the track being recorded.
+   *
+   * @param waypoint the waypoint to insert
+   * @return the unique ID of the inserted marker
+   */
+  long insertWaypointMarker(in Waypoint waypoint);
+
+  /**
+   * Inserts a statistics marker in the track being recorded.
+   *
+   * @param location the location at which to insert the marker
+   * @return the unique ID of the inserted marker
+   */
+  long insertStatisticsMarker(in Location location);
+
+  /**
+   * Inserts a location in the track being recorded.
+   *
+   * When recording, locations detected by the GPS are already automatically
+   * added to the track, so this should be used only for adding special points
+   * or for testing.
+   *
+   * @param loc the location to insert
+   */
+  void recordLocation(in Location loc);
+
+  /**
+   * Stops recording the current track.
+   */
+  void endCurrentTrack();
+
+  /**
+   * Returns whether at least one track has been or is being recorded (and was
+   * not deleted).
+   */
+  boolean hasRecorded();
+
+  /**
+   * Deletes all the stored tracks.
+   */
+  void deleteAllTracks();
+
+  /**
+   * Notifies the service that its preferences may have been changed.
+   * This is necessary because the service running on a separate process cannot
+   * listen to the changes itself.
+   *
+   * @param key the preference key which may have changed
+   */
+  void sharedPreferenceChanged(in String key);
+}

MyTracks/src/com/google/android/apps/mytracks/services/LocationListenerPolicy.java

@@ -0,0 +1,48 @@
+/*
+ * 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 an interface for classes that will manage the location listener policy.
+ * Different policy options are:
+ *   Absolute
+ *   Addaptive
+ *
+ * @author Sandor Dornbush
+ */
+public interface LocationListenerPolicy {
+
+  /**
+   * Returns the polling time this policy would like at this time.
+   *
+   * @return The polling that this policy dictates
+   */
+  public long getDesiredPollingInterval();
+
+  /**
+   * Returns the minimum distance between updates.
+   */
+  public int getMinDistance();
+
+  /**
+   * Notifies the amount of time the user has been idle at their current
+   * location.
+   *
+   * @param idleTime The time that the user has been idle at this spot
+   */
+  public void updateIdleTime(long idleTime);
+}

MyTracks/src/com/google/android/apps/mytracks/services/PeriodicTask.java

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

MyTracks/src/com/google/android/apps/mytracks/services/PeriodicTaskExecuter.java

@@ -0,0 +1,101 @@
+/*
+ * 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;
+
+import com.google.android.apps.mytracks.MyTracksConstants;
+
+import android.util.Log;
+
+import java.util.Date;
+import java.util.Timer;
+import java.util.TimerTask;
+
+/**
+ * This class will periodically announce the user's trip statistics.
+ *
+ * @author Sandor Dornbush
+ */
+public class PeriodicTaskExecuter {
+
+  private final TrackRecordingService service;
+
+  /**
+   * A timer to schedule the announcements.
+   */
+  private Timer timer = new Timer();
+
+  private final PeriodicTask task;
+
+  public PeriodicTaskExecuter(PeriodicTask task,
+                              TrackRecordingService service) {
+    this.task = task;
+    this.service = service;
+  }
+
+  /**
+   * Schedules the task at the given interval.
+   *
+   * @param interval The interval in milliseconds
+   */
+  public void scheduleTask(long interval) {
+    // TODO: Decouple service from this class once and forever.
+    if (!service.isRecording()) {
+      return;
+    }
+    
+    timer.cancel();
+    timer.purge();
+    timer = new Timer();
+    if (interval <= 0) {
+      return;
+    }
+
+    long now = System.currentTimeMillis();
+    long next = service.getTripStatistics().getStartTime();
+    if (next < now) {
+      next = now + interval - ((now - next) % interval);
+    }
+
+    Date start = new Date(next);
+    Log.i(MyTracksConstants.TAG,
+        task.getClass().getSimpleName() + " scheduled to start at " + start
+        + " every " + interval + " milliseconds.");
+    timer.scheduleAtFixedRate(new PeriodicTimerTask(), start, interval);
+  }
+
+  /**
+   * Cleans up this object.
+   */
+  public void shutdown() {
+    Log.i(MyTracksConstants.TAG,
+        task.getClass().getSimpleName() + " shutting down.");
+    timer.cancel();
+    timer.purge();
+    timer = null;
+    task.shutdown();
+  }
+
+  /**
+   * The timer task to announce the trip status.
+   */
+  private class PeriodicTimerTask extends TimerTask {
+    @Override
+    public void run() {
+      task.run(service);
+    }
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/services/PreferenceManager.java

@@ -0,0 +1,176 @@
+/*
+ * 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 com.google.android.apps.mytracks.MyTracksConstants;
+import com.google.android.apps.mytracks.MyTracksSettings;
+import com.google.android.maps.mytracks.R;
+
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.Editor;
+import android.util.Log;
+
+/**
+ * A class that manages reading the shared preferences for the service.
+ * 
+ * @author Sandor Dornbush
+ */
+public class PreferenceManager {
+  private TrackRecordingService service;
+  private final String announcementFrequencyKey;
+  private final String autoResumeTrackCurrentRetryKey;
+  private final String autoResumeTrackTimeoutKey;
+  private final String maxRecordingDistanceKey;
+  private final String metricUnitsKey;
+  private final String minRecordingDistanceKey;
+  private final String minRecordingIntervalKey;
+  private final String minRequiredAccuracyKey;
+  private final String recordingTrackKey;
+  private final String signalSamplingFrequencyKey;
+  private final String splitFrequencyKey;
+
+  private final SharedPreferences sharedPreferences;
+
+  public PreferenceManager(TrackRecordingService service) {
+    this.service = service;
+    this.sharedPreferences =
+        service.getSharedPreferences(MyTracksSettings.SETTINGS_NAME, 0);
+    if (sharedPreferences == null) {
+      Log.w(MyTracksConstants.TAG,
+          "TrackRecordingService: Couldn't get shared preferences.");
+      throw new IllegalStateException("Couldn't get shared preferences");
+    }
+    
+    announcementFrequencyKey =
+        service.getString(R.string.announcement_frequency_key);
+    autoResumeTrackCurrentRetryKey =
+        service.getString(R.string.auto_resume_track_current_retry_key);
+    autoResumeTrackTimeoutKey =
+        service.getString(R.string.auto_resume_track_timeout_key);
+    maxRecordingDistanceKey = 
+        service.getString(R.string.max_recording_distance_key);
+    metricUnitsKey =
+        service.getString(R.string.metric_units_key);
+    minRecordingDistanceKey =
+        service.getString(R.string.min_recording_distance_key);
+    minRecordingIntervalKey =
+        service.getString(R.string.min_recording_interval_key);
+    minRequiredAccuracyKey =
+        service.getString(R.string.min_required_accuracy_key);
+    recordingTrackKey =
+        service.getString(R.string.recording_track_key);
+    signalSamplingFrequencyKey =
+        service.getString(R.string.signal_sampling_frequency_key);
+    splitFrequencyKey =
+        service.getString(R.string.split_frequency_key);
+  }
+
+  /**
+   * Notifies that preferences have changed.
+   * Call this with key == null to update all preferences in one call.
+   *
+   * @param key the key that changed (may be null to update all preferences)
+   */
+  public void onSharedPreferenceChanged(String key) {
+    if (key == null || key.equals(minRecordingDistanceKey)) {
+      service.setMinRecordingDistance(
+          sharedPreferences.getInt(
+              minRecordingDistanceKey,
+              MyTracksSettings.DEFAULT_MIN_RECORDING_DISTANCE));
+      Log.d(MyTracksConstants.TAG,
+          "TrackRecordingService: minRecordingDistance = "
+          + service.getMinRecordingDistance());
+    }
+    if (key == null || key.equals(maxRecordingDistanceKey)) {
+      service.setMaxRecordingDistance(sharedPreferences.getInt(
+          maxRecordingDistanceKey,
+          MyTracksSettings.DEFAULT_MAX_RECORDING_DISTANCE));
+    }
+    if (key == null || key.equals(minRecordingIntervalKey)) {
+      int minRecordingInterval = sharedPreferences.getInt(
+          minRecordingIntervalKey,
+          MyTracksSettings.DEFAULT_MIN_RECORDING_INTERVAL);
+      switch (minRecordingInterval) {
+        case -2:
+          // Battery Miser
+          // min: 30 seconds
+          // max: 5 minutes
+          // minDist: 5 meters Choose battery life over moving time accuracy.
+          service.setLocationListenerPolicy(
+              new AdaptiveLocationListenerPolicy(30000, 300000, 5));
+          break;
+        case -1:
+          // High Accuracy
+          // min: 1 second
+          // max: 30 seconds
+          // minDist: 0 meters get all updates to properly measure moving time.
+          service.setLocationListenerPolicy(
+              new AdaptiveLocationListenerPolicy(1000, 30000, 0));
+          break;
+        default:
+          service.setLocationListenerPolicy(
+              new AbsoluteLocationListenerPolicy(minRecordingInterval * 1000));
+      }
+    }
+    if (key == null || key.equals(minRequiredAccuracyKey)) {
+      service.setMinRequiredAccuracy(sharedPreferences.getInt(
+          minRequiredAccuracyKey,
+          MyTracksSettings.DEFAULT_MIN_REQUIRED_ACCURACY));
+    }
+    if (key == null || key.equals(announcementFrequencyKey)) {
+      service.setAnnouncementFrequency(
+          sharedPreferences.getInt(announcementFrequencyKey, -1));
+    }
+    if (key == null || key.equals(autoResumeTrackTimeoutKey)) {
+      service.setAutoResumeTrackTimeout(sharedPreferences.getInt(
+          autoResumeTrackTimeoutKey,
+          MyTracksSettings.DEFAULT_AUTO_RESUME_TRACK_TIMEOUT));
+    }
+    if (key == null || key.equals(recordingTrackKey)) {
+      long recordingTrackId = sharedPreferences.getLong(recordingTrackKey, -1);
+      // Only read the id if it is valid.
+      // Setting it to -1 should only happen in 
+      // TrackRecordingService.endCurrentTrack()
+      if (recordingTrackId > 0) {
+        service.setRecordingTrackId(recordingTrackId);
+      }
+    }
+    if (key == null || key.equals(splitFrequencyKey)) {
+      service.getSplitManager().setSplitFrequency(
+          sharedPreferences.getInt(splitFrequencyKey, 0));
+    }
+    if (key == null || key.equals(signalSamplingFrequencyKey)) {
+      service.getSignalManager().setFrequency(
+          sharedPreferences.getInt(signalSamplingFrequencyKey, -1), service);
+    }
+    if (key == null || key.equals(metricUnitsKey)) {
+      service.getSplitManager().setMetricUnits(
+          sharedPreferences.getBoolean(metricUnitsKey, true));
+    }
+  }
+  
+  public void setAutoResumeTrackCurrentRetry(int retryAttempts) {
+    SharedPreferences.Editor editor = sharedPreferences.edit();
+    editor.putInt(autoResumeTrackCurrentRetryKey, retryAttempts);
+    editor.commit();
+  }
+
+  public void setRecordingTrack(long id) {
+    Editor editor = sharedPreferences.edit();
+    editor.putLong(recordingTrackKey, id);
+    editor.commit();
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/services/SignalStrengthTask.java

@@ -0,0 +1,193 @@
+/*
+ * 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 com.google.android.apps.mytracks.MyTracksConstants;
+import com.google.android.apps.mytracks.content.Waypoint;
+
+import android.content.Context;
+import android.location.Location;
+import android.telephony.CellLocation;
+import android.telephony.NeighboringCellInfo;
+import android.telephony.PhoneStateListener;
+import android.telephony.TelephonyManager;
+import android.util.Log;
+
+import java.util.List;
+
+/**
+ * A class to monitor the network signal strength.
+ *
+ * @author Sandor Dornbush
+ */
+public class SignalStrengthTask extends PhoneStateListener
+    implements PeriodicTask {
+
+  private final Context context;
+  private TelephonyManager manager;
+  private int signalStrength = -1;
+
+  public SignalStrengthTask(Context c) {
+    context = c;
+  }
+  
+  public void start() {
+    manager =
+      (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
+    if (manager == null) {
+      Log.e(MyTracksConstants.TAG, "Cannot get telephony manager.");
+    } else {
+      manager.listen(this, getListenEvents());
+    }
+  }
+
+  protected int getListenEvents() {
+    return PhoneStateListener.LISTEN_SIGNAL_STRENGTHS;
+  }
+
+  @Override
+  public void onSignalStrengthChanged(int asu) {
+    this.signalStrength = asu;
+    Log.d(MyTracksConstants.TAG, "Signal Strength: " + signalStrength);
+  }
+
+  @Override
+  public void run(TrackRecordingService service) {
+    Log.d(MyTracksConstants.TAG, "Adding signal marker");
+    Location location = service.getLastLocation();
+    if (manager == null) {
+      Log.d(MyTracksConstants.TAG, "Adding signal marker: marker null");
+      return;
+    }
+    if (location == null) {
+      Log.d(MyTracksConstants.TAG, "Adding signal marker: location null");
+      return;
+    }
+    Waypoint wpt = new Waypoint();
+    wpt.setName("Signal Strength");
+    wpt.setType(Waypoint.TYPE_WAYPOINT);
+    wpt.setTrackId(service.getRecordingTrackId());
+    int networkType = manager.getNetworkType();
+    wpt.setIcon(getIcon(networkType));
+    wpt.setLocation(location);
+    wpt.setDescription(getDescription());
+    long waypointId = service.insertWaypointMarker(wpt);
+    if (waypointId >= 0) {
+      Log.d(MyTracksConstants.TAG, "Added signal marker");
+    } else {
+      Log.e(MyTracksConstants.TAG, "Cannot insert waypoint marker?");
+    }
+  }
+
+  /**
+   * Gets a human readable description for the network type.
+   *
+   * @param type The integer constant for the network type
+   * @return A human readable description of the network type
+   */
+  protected String getTypeAsString(int type) {
+    switch (type) {
+      case TelephonyManager.NETWORK_TYPE_EDGE:
+        return "EDGE";
+      case TelephonyManager.NETWORK_TYPE_GPRS:
+        return "GPRS";
+      case TelephonyManager.NETWORK_TYPE_UMTS:
+        return "UMTS";
+      case TelephonyManager.NETWORK_TYPE_UNKNOWN:
+      default:
+        return "UNKNOWN";
+    }
+  }
+
+  /**
+   * Builds a description for the current signal strength.
+   * 
+   * @return A human readable description of the network state
+   */
+  private String getDescription() {
+    StringBuffer sb = new StringBuffer();
+    sb.append(getStrengthAsString());
+
+    sb.append("Network Type: ");
+    sb.append(getTypeAsString(manager.getNetworkType()));
+    sb.append('\n');
+
+    sb.append("Operator: ");
+    sb.append(manager.getNetworkOperatorName());
+    sb.append(" / ");
+    sb.append(manager.getNetworkOperator());
+    sb.append('\n');
+
+    sb.append("Roaming: ");
+    sb.append(manager.isNetworkRoaming());
+    sb.append('\n');
+
+    List<NeighboringCellInfo> infos = manager.getNeighboringCellInfo();
+    Log.i(MyTracksConstants.TAG, "Found " + infos.size() + " cells.");
+    if (infos.size() > 0) {
+      sb.append("Neighbors: ");
+      for (NeighboringCellInfo info : infos) {
+        sb.append(info.toString());
+        sb.append(' ');
+      }
+      sb.append('\n');
+    }
+
+    CellLocation cell = manager.getCellLocation();
+    if (cell != null) {
+      sb.append("Cell: ");
+      sb.append(cell.toString());
+      sb.append('\n');
+    }
+
+    return sb.toString();
+  }
+
+  /**
+   * Gets the url for the waypoint icon for the current network type.
+   *
+   * @param type The network type
+   * @return A url to a image to use as the waypoint icon
+   */
+  protected String getIcon(int type) {
+    switch (type) {
+      case TelephonyManager.NETWORK_TYPE_GPRS:
+      case TelephonyManager.NETWORK_TYPE_EDGE:
+        return "http://maps.google.com/mapfiles/ms/micons/green.png";
+      case TelephonyManager.NETWORK_TYPE_UMTS:
+        return "http://maps.google.com/mapfiles/ms/micons/blue.png";
+      case TelephonyManager.NETWORK_TYPE_UNKNOWN:
+      default:
+        return "http://maps.google.com/mapfiles/ms/micons/red.png";
+    }
+  }
+
+  public void shutdown() {
+    if (manager != null) {
+      manager.listen(this, PhoneStateListener.LISTEN_NONE);
+      manager = null;
+    }
+  }
+
+  public String getStrengthAsString() {
+    return "Strength: " + signalStrength + "\n";
+  }
+
+  protected Context getContext() {
+    return context;
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/services/SignalStrengthTaskFactory.java

@@ -0,0 +1,48 @@
+/*
+ * 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 com.google.android.apps.mytracks.MyTracksConstants;
+import com.google.android.apps.mytracks.util.ApiFeatures;
+
+import android.content.Context;
+import android.util.Log;
+
+/**
+ * Factory for producing a proper {@link SignalStrengthTask} according to the
+ * current API level.
+ *
+ * @author Rodrigo Damazio
+ */
+public class SignalStrengthTaskFactory {
+  private final boolean hasModernSignalStrength;
+
+  SignalStrengthTaskFactory(ApiFeatures apiFeatures) {
+    this.hasModernSignalStrength = apiFeatures.hasModernSignalStrength();
+  }
+
+  public PeriodicTask create(Context context) {
+    if (hasModernSignalStrength) {
+      Log.d(MyTracksConstants.TAG,
+          "TrackRecordingService using modern signal strength api.");
+      return new SignalStrengthTaskModern(context);
+    } else {
+      Log.w(MyTracksConstants.TAG,
+          "TrackRecordingService using legacy signal strength api.");
+      return new SignalStrengthTask(context);
+    }
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/services/SignalStrengthTaskModern.java

@@ -0,0 +1,155 @@
+/*
+ * 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 com.google.android.apps.mytracks.MyTracksConstants;
+import com.google.android.maps.mytracks.R;
+
+import android.content.Context;
+import android.telephony.PhoneStateListener;
+import android.telephony.SignalStrength;
+import android.telephony.TelephonyManager;
+import android.util.Log;
+
+/**
+ * A class to monitor the network signal strength.
+ *
+ * @author Sandor Dornbush
+ */
+public class SignalStrengthTaskModern extends SignalStrengthTask {
+
+  private SignalStrength signalStrength = null;
+
+  public SignalStrengthTaskModern(Context c) {
+    super(c);
+  }
+
+  @Override
+  protected int getListenEvents() {
+    return PhoneStateListener.LISTEN_SIGNAL_STRENGTHS;
+  }
+
+  /**
+   * Gets a human readable description for the network type.
+   *
+   * @param type The integer constant for the network type
+   * @return A human readable description of the network type
+   */
+  @Override
+  protected String getTypeAsString(int type) {
+    switch (type) {
+      case TelephonyManager.NETWORK_TYPE_1xRTT:
+        return "1xRTT";
+      case TelephonyManager.NETWORK_TYPE_CDMA:
+        return "CDMA";
+      case TelephonyManager.NETWORK_TYPE_EDGE:
+        return "EDGE";
+      case TelephonyManager.NETWORK_TYPE_EVDO_0:
+        return "EVDO 0";
+      case TelephonyManager.NETWORK_TYPE_EVDO_A:
+        return "EVDO A";
+      case TelephonyManager.NETWORK_TYPE_GPRS:
+        return "GPRS";
+      case TelephonyManager.NETWORK_TYPE_HSDPA:
+        return "HSDPA";
+      case TelephonyManager.NETWORK_TYPE_HSPA:
+        return "HSPA";
+      case TelephonyManager.NETWORK_TYPE_HSUPA:
+        return "HSUPA";
+      case TelephonyManager.NETWORK_TYPE_UMTS:
+        return "UMTS";
+      case TelephonyManager.NETWORK_TYPE_UNKNOWN:
+      default:
+        return "UNKNOWN";
+    }
+  }
+
+  /**
+   * Gets the url for the waypoint icon for the current network type.
+   *
+   * @param type The network type
+   * @return A url to a image to use as the waypoint icon
+   */
+  @Override
+  protected String getIcon(int type) {
+    switch (type) {
+      case TelephonyManager.NETWORK_TYPE_1xRTT:
+      case TelephonyManager.NETWORK_TYPE_CDMA:
+      case TelephonyManager.NETWORK_TYPE_GPRS:
+      case TelephonyManager.NETWORK_TYPE_EDGE:
+        return "http://maps.google.com/mapfiles/ms/micons/green.png";
+      case TelephonyManager.NETWORK_TYPE_EVDO_0:
+      case TelephonyManager.NETWORK_TYPE_EVDO_A:
+      case TelephonyManager.NETWORK_TYPE_HSDPA:
+      case TelephonyManager.NETWORK_TYPE_HSPA:
+      case TelephonyManager.NETWORK_TYPE_HSUPA:
+      case TelephonyManager.NETWORK_TYPE_UMTS:
+        return "http://maps.google.com/mapfiles/ms/micons/blue.png";
+      case TelephonyManager.NETWORK_TYPE_UNKNOWN:
+      default:
+        return "http://maps.google.com/mapfiles/ms/micons/red.png";
+    }
+  }
+
+  @Override
+  public String getStrengthAsString() {
+    if (signalStrength == null) {
+      return "Strength: " + getContext().getString(R.string.unknown) + "\n";
+    }
+    StringBuffer sb = new StringBuffer();
+    if (signalStrength.isGsm()) {
+      appendSignal(signalStrength.getGsmSignalStrength(),
+                   R.string.gsm_strength,
+                   sb);
+      maybeAppendSignal(signalStrength.getGsmBitErrorRate(),
+                        R.string.error_rate,
+                        sb);
+    } else {
+      appendSignal(signalStrength.getCdmaDbm(), R.string.cdma_strength, sb);
+      appendSignal(signalStrength.getCdmaEcio() / 10.0, R.string.ecio, sb);
+      appendSignal(signalStrength.getEvdoDbm(), R.string.evdo_strength, sb);
+      appendSignal(signalStrength.getEvdoEcio() / 10.0, R.string.ecio, sb);
+      appendSignal(signalStrength.getEvdoSnr(),
+                   R.string.signal_to_noise_ratio,
+                   sb);
+    }
+    return sb.toString();
+  }
+
+  private void maybeAppendSignal(
+      int signal, int signalFormat, StringBuffer sb) {
+    if (signal > 0) {
+      sb.append(getContext().getString(signalFormat, signal));
+    }
+  }
+
+  private void appendSignal(int signal, int signalFormat, StringBuffer sb) {
+    sb.append(getContext().getString(signalFormat, signal));
+    sb.append("\n");
+  }
+
+  private void appendSignal(double signal, int signalFormat, StringBuffer sb) {
+    sb.append(getContext().getString(signalFormat, signal));
+    sb.append("\n");
+  }
+
+  @Override
+  public void onSignalStrengthsChanged(SignalStrength signalStrength) {
+    Log.d(MyTracksConstants.TAG, "Signal Strength Modern: " + signalStrength);
+    this.signalStrength = signalStrength;
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/services/SplitManager.java

@@ -0,0 +1,157 @@
+/*
+ * 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 com.google.android.apps.mytracks.MyTracksConstants;
+import com.google.android.apps.mytracks.util.UnitConversions;
+
+import android.util.Log;
+
+/**
+ * This class manages inserting time or distance splits.
+ *
+ * @author Sandor Dornbush
+ */
+public class SplitManager {
+
+  /**
+   * The frequency of splits.
+   */
+  private int splitFrequency = 0;
+
+  /**
+   * The next distance when a split should be taken.
+   */
+  private double nextSplitDistance = 0;
+
+  /**
+   * Splits executer.
+   */
+  private PeriodicTaskExecuter splitExecuter = null;
+
+  private boolean metricUnits;
+
+  private final TrackRecordingService service;
+
+  public SplitManager(TrackRecordingService service) {
+    this.service = service;
+  }
+
+  /**
+   * Restores the manager.
+   */
+  public void restore() {
+    if ((splitFrequency > 0) && (splitExecuter != null)) {
+      splitExecuter.scheduleTask(splitFrequency * 60000);
+    }
+    calculateNextSplit();
+  }
+
+  /**
+   * Shuts down the manager.
+   */
+  public void shutdown() {
+    if (splitExecuter != null) {
+      splitExecuter.shutdown();
+    }
+  }
+
+  /**
+   * Calculates the next distance that a split should be inserted at.
+   */
+  public void calculateNextSplit() {
+    // TODO: Decouple service from this class once and forever.
+    if (!service.isRecording()) {
+      return;
+    }
+    
+    if (splitFrequency >= 0) {
+      nextSplitDistance = Double.MAX_VALUE;
+      Log.d(MyTracksConstants.TAG,
+            "SplitManager: Distance splits disabled.");
+      return;
+    }
+
+    double dist = service.getTripStatistics().getTotalDistance() / 1000;
+    if (!metricUnits) {
+      dist *= UnitConversions.KM_TO_MI;
+    }
+    // The index will be negative since the frequency is negative.
+    int index = (int) (dist / splitFrequency);
+    index -= 1;
+    nextSplitDistance = splitFrequency * index;
+    Log.d(MyTracksConstants.TAG,
+          "SplitManager: Next split distance: " + nextSplitDistance);
+  }
+
+  /**
+   * Updates split manager with new trip statistics.
+   */
+  public void updateSplits() {
+    if (this.splitFrequency >= 0) {
+      return;
+    }
+    // Convert the distance in meters to km or mi.
+    double distance = service.getTripStatistics().getTotalDistance() / 1000.0;
+    if (!metricUnits) {
+      distance *= UnitConversions.KM_TO_MI;
+    }
+
+    if (distance > this.nextSplitDistance) {
+      service.insertStatisticsMarker(service.getLastLocation());
+      calculateNextSplit();
+    }
+  }
+
+  /**
+   * Sets the split frequency.
+   * < 0 Use the absolute value as a distance in the current measurement km
+   *  or mi
+   *   0 Turn off splits
+   * > 0 Use the value as a time in minutes
+   * @param splitFrequency The frequency in time or distance
+   */
+  public void setSplitFrequency(int splitFrequency) {
+    this.splitFrequency = splitFrequency;
+    
+    // TODO: Decouple service from this class once and forever.
+    if (!service.isRecording()) {
+      return;
+    }
+    
+    if (splitFrequency < 1) {
+      if (splitExecuter != null) {
+        splitExecuter.shutdown();
+        splitExecuter = null;
+      }
+    }
+    if (splitFrequency > 0) {
+      if (splitExecuter == null) {
+        TimeSplitTask splitter = new TimeSplitTask();
+        splitExecuter = new PeriodicTaskExecuter(splitter, service);
+      }
+      splitExecuter.scheduleTask(splitFrequency * 60000);
+    } else {
+      // For distance based splits.
+      calculateNextSplit();
+    }
+  }
+
+  public void setMetricUnits(boolean metricUnits) {
+    this.metricUnits = metricUnits;
+    calculateNextSplit();
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/services/StatusAnnouncerFactory.java

@@ -0,0 +1,61 @@
+/*
+ * 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 com.google.android.apps.mytracks.util.ApiFeatures;
+
+import android.content.Context;
+import android.media.AudioManager;
+
+/**
+ * Factory which wraps construction and setup of text-to-speech announcements in
+ * an API-level-safe way.
+ *
+ * @author Rodrigo Damazio
+ */
+public class StatusAnnouncerFactory {
+
+  private final boolean hasTts;
+
+  public StatusAnnouncerFactory(ApiFeatures apiFeatures) {
+    this.hasTts = apiFeatures.hasTextToSpeech();
+  }
+
+  /**
+   * Creates a periodic task which does voice announcements.
+   *
+   * @return the task, or null if announcements are not supported
+   */
+  public PeriodicTask create(Context context) {
+    if (hasTts) {
+      return new StatusAnnouncerTask(context);
+    } else {
+      return null;
+    }
+  }
+
+  /**
+   * Returns the appropriate volume stream for controlling announcement
+   * volume.
+   */
+  public int getVolumeStream() {
+    if (hasTts) {
+      return StatusAnnouncerTask.getVolumeStream();
+    } else {
+      return AudioManager.USE_DEFAULT_STREAM_TYPE;
+    }
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/services/StatusAnnouncerTask.java

@@ -0,0 +1,273 @@
+/*
+ * 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;
+
+import com.google.android.apps.mytracks.MyTracksConstants;
+import com.google.android.apps.mytracks.MyTracksSettings;
+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 android.content.Context;
+import android.content.SharedPreferences;
+import android.speech.tts.TextToSpeech;
+import android.speech.tts.TextToSpeech.OnInitListener;
+import android.telephony.PhoneStateListener;
+import android.telephony.TelephonyManager;
+import android.util.Log;
+
+import java.util.Locale;
+
+/**
+ * This class will periodically announce the user's trip statitics.
+ *
+ * @author Sandor Dornbush
+ */
+public class StatusAnnouncerTask implements PeriodicTask {
+
+  /**
+   * The rate at which announcements are spoken.
+   */
+  static final float TTS_SPEECH_RATE = 0.9f;
+
+  /**
+   * A pointer to the service context.
+   */
+  private final Context context;
+
+  /**
+   * String utilities.
+   */
+  private final StringUtils stringUtils;
+
+  /**
+   * The interface to the text to speech engine.
+   */
+  private TextToSpeech tts;
+
+  /**
+   * The response recieved from the TTS engine ater initialization.
+   */
+  private boolean ready = false;
+
+  /**
+   * Whether we're allowed to speak right now.
+   */
+  private boolean speechAllowed;
+
+  /**
+   * Listener which updates {@link #speechAllowed} when the phone state changes.
+   */
+  private final PhoneStateListener phoneListener = new PhoneStateListener() {
+    @Override
+    public void onCallStateChanged(int state, String incomingNumber) {
+      speechAllowed = state == TelephonyManager.CALL_STATE_IDLE;
+
+      if (!speechAllowed && tts.isSpeaking()) {
+        // If we're already speaking, stop it.
+        tts.stop();
+      }
+    }
+  };
+
+  public StatusAnnouncerTask(Context context) {
+    this(context, new StringUtils(context));
+  }
+
+  public StatusAnnouncerTask(Context context, StringUtils stringUtils) {
+    this.context = context;
+    this.stringUtils = stringUtils;
+  }
+
+  /**
+   * Called when the TTS engine is initialized.
+   */
+  private void onTtsInit(int status) {
+    Log.i(MyTracksConstants.TAG, "TrackRecordingService.TTS init: " + status);
+    this.ready = (status == TextToSpeech.SUCCESS);
+
+    if (ready) {
+      // Force the language to be the same as the string we will be speaking,
+      // if that's available.
+      Locale speechLanguage = Locale.getDefault();
+      int languageAvailability = tts.isLanguageAvailable(speechLanguage);
+      if (languageAvailability == TextToSpeech.LANG_MISSING_DATA ||
+          languageAvailability == TextToSpeech.LANG_NOT_SUPPORTED) {
+        // English is probably supported.
+        // TODO: Somehow use announcement strings from English too.
+        Log.w(MyTracksConstants.TAG, "Default language not available, using English.");
+        speechLanguage = Locale.ENGLISH;
+      }
+      tts.setLanguage(speechLanguage);
+
+      // Slow down the speed just a bit as it is hard to hear when exercising.
+      tts.setSpeechRate(TTS_SPEECH_RATE);
+    }
+  }
+
+  /**
+   * {@inheritDoc}
+   *
+   * Announces the trip status.
+   */
+  @Override
+  public void run(TrackRecordingService service) {
+    if (!ready || tts == null) {
+      Log.e(MyTracksConstants.TAG, "StatusAnnouncer Tts not ready.");
+      return;
+    }
+
+    if (!speechAllowed) {
+      Log.i(MyTracksConstants.TAG,
+          "Not making announcement - not allowed at this time");
+      return;
+    }
+
+    if (service == null || service.getTripStatistics() == null) {
+      Log.e(MyTracksConstants.TAG, "StatusAnnouncer stats not initialized.");
+      return;
+    }
+
+    String announcement = getAnnouncement(service.getTripStatistics());
+    Log.d(MyTracksConstants.TAG, "Announcement: " + announcement);
+    tts.speak(announcement, TextToSpeech.QUEUE_FLUSH, null);
+  }
+
+  /**
+   * Builds the announcement string.
+   *
+   * @return The string that will be read to the user
+   */
+  // @VisibleForTesting
+  protected String getAnnouncement(TripStatistics stats) {
+    SharedPreferences preferences =
+        context.getSharedPreferences(MyTracksSettings.SETTINGS_NAME, 0);
+    boolean metricUnits = true;
+    boolean reportSpeed = true;
+    if (preferences != null) {
+      metricUnits = 
+          preferences.getBoolean(context.getString(R.string.metric_units_key),
+              true);
+      reportSpeed =
+          preferences.getBoolean(context.getString(R.string.report_speed_key),
+              true);
+    }
+
+    double d =  stats.getTotalDistance() / 1000;
+    double s =  stats.getAverageMovingSpeed() * 3.6;
+    if (d == 0) {
+      return context.getString(R.string.announce_no_distance);
+    }
+
+    int speedLabel;
+    if (metricUnits) {
+      if (reportSpeed) {
+        speedLabel = R.string.kilometer_per_hour_long;
+      } else {
+        speedLabel = R.string.per_kilometer;
+      }
+    } else {
+      s *= UnitConversions.KMH_TO_MPH;
+      d *= UnitConversions.KM_TO_MI;
+      if (reportSpeed) {
+        speedLabel = R.string.mile_per_hour_long;
+      } else {
+        speedLabel = R.string.per_mile;
+      }
+    }
+
+    String speed = null;
+    if ((s == 0) || Double.isNaN(s)) {
+      speed = context.getString(R.string.unknown);
+    } else {
+      if (reportSpeed) {
+        speed = String.format("%.1f", s);
+      } else {
+        double pace = 3600000.0 / s;
+        Log.w(MyTracksConstants.TAG,
+              "Converted speed: " + s + " to pace: " + pace);
+        speed = stringUtils.formatTimeLong((long) pace);
+      }
+    }
+
+    return context.getString(R.string.announce_template,
+        context.getString(R.string.total_distance_label),
+        d,
+        context.getString(metricUnits
+                          ? R.string.kilometers_long
+                          : R.string.miles_long),
+        stringUtils.formatTimeLong(stats.getMovingTime()),
+        speed,
+        context.getString(speedLabel));
+  }
+
+  @Override
+  public void start() {
+    if (tts == null) {
+      // We can't have this class also be the listener, otherwise it's unsafe to
+      // reference it in Cupcake (even if we don't instantiate it).
+      tts = newTextToSpeech(context, new OnInitListener() {
+        @Override
+        public void onInit(int status) {
+          onTtsInit(status);
+        }
+      });
+    }
+    speechAllowed = true;
+
+    // Register ourselves as a listener so we won't speak during a call.
+    listenToPhoneState(phoneListener, PhoneStateListener.LISTEN_CALL_STATE);
+  }
+
+  @Override
+  public void shutdown() {
+    // Stop listening to phone state.
+    listenToPhoneState(phoneListener, PhoneStateListener.LISTEN_NONE);
+
+    if (tts != null) {
+      tts.shutdown();
+      tts = null;
+    }
+  }
+
+  /**
+   * Wrapper for instantiating a {@link TextToSpeech} object, which causes
+   * several issues during testing.
+   */
+  // @VisibleForTesting
+  protected TextToSpeech newTextToSpeech(Context ctx, OnInitListener onInitListener) {
+    return new TextToSpeech(ctx, onInitListener);
+  }
+
+  /**
+   * Wrapper for calls to the 100%-unmockable {@link TelephonyManager#listen}.
+   */
+  // @VisibleForTesting
+  protected void listenToPhoneState(PhoneStateListener listener, int events) {
+    TelephonyManager telephony =
+        (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
+    telephony.listen(listener, events);
+  }
+
+  /**
+   * Returns the volume stream to use for controlling announcement volume.
+   */
+  public static int getVolumeStream() {
+    return TextToSpeech.Engine.DEFAULT_STREAM;
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/services/TaskExecuterManager.java

@@ -0,0 +1,80 @@
+/*
+ * 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.util.Log;
+
+import com.google.android.apps.mytracks.MyTracksConstants;
+
+/**
+ * This class will manage a period task executer.
+ *
+ * @author Sandor Dornbush
+ */
+public class TaskExecuterManager {
+
+  int frequency;
+  PeriodicTask task;
+  PeriodicTaskExecuter executer;
+
+  public TaskExecuterManager(int frequency,
+                             PeriodicTask task,
+                             TrackRecordingService service) {
+    this.task = task;
+    setFrequency(frequency, service);
+  }
+
+  public int getFrequency() {
+    return frequency;
+  }
+
+  /**
+   * Sets the frequency that the task should be run at.
+   * If needed the task will be scheduled.
+   *
+   * @param frequency The frequency in minutes for the task to run
+   * @param service The service to run the task on
+   */
+  public void setFrequency(int frequency, TrackRecordingService service) {
+    this.frequency = frequency;
+    Log.i(MyTracksConstants.TAG, "Frequency set to: " + frequency);
+
+    if (frequency == -1) {
+      if (executer != null) {
+        executer.shutdown();
+        executer = null;
+        Log.i(MyTracksConstants.TAG,
+            "Shut down service: " + task.getClass().getSimpleName());
+      }
+    } else {
+      if (executer == null) {
+        task.start();
+        executer = new PeriodicTaskExecuter(task, service);
+      }
+      executer.scheduleTask(frequency * 60000);
+    }
+  }
+
+  /**
+   * Restore the task at the current frequency.
+   */
+  public void restore() {
+    if (frequency > 0) {
+      task.start();
+      executer.scheduleTask(frequency * 60000);
+    }
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/services/TimeSplitTask.java

@@ -0,0 +1,37 @@
+/*
+ * 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;
+
+/**
+ * A simple task to insert statistics markers every n minutes.
+ * @author Sandor Dornbush
+ */
+public class TimeSplitTask implements PeriodicTask {
+
+  @Override
+  public void run(TrackRecordingService service) {
+    service.insertStatisticsMarker(service.getLastLocation());
+  }
+
+  @Override
+  public void shutdown() {
+  }
+
+  @Override
+  public void start() {
+  }
+}