Fix comment for 01e7f3b54cbf

MyTracks/src/com/google/android/apps/mytracks/services/tasks/FroyoStatusAnnouncerTask.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.services.tasks;
+
+import static com.google.android.apps.mytracks.Constants.TAG;
+
+import android.content.Context;
+import android.media.AudioManager;
+import android.speech.tts.TextToSpeech;
+import android.speech.tts.TextToSpeech.OnUtteranceCompletedListener;
+import android.util.Log;
+
+import java.util.HashMap;
+
+
+/**
+ * This class will periodically announce the user's trip statistics for Froyo and future handsets.
+ * This class will request and release audio focus.
+ *
+ * @author Sandor Dornbush
+ */
+public class FroyoStatusAnnouncerTask extends StatusAnnouncerTask {
+  private final static HashMap<String, String> SPEECH_PARAMS = new HashMap<String, String>();
+  static {
+    SPEECH_PARAMS.put(TextToSpeech.Engine.KEY_PARAM_UTTERANCE_ID, "not_used");
+  }
+
+  private final AudioManager audioManager;
+  private final OnUtteranceCompletedListener utteranceListener =
+      new OnUtteranceCompletedListener() {
+        @Override
+        public void onUtteranceCompleted(String utteranceId) {
+          int result = audioManager.abandonAudioFocus(null);
+          if (result == AudioManager.AUDIOFOCUS_REQUEST_FAILED) {
+            Log.w(TAG, "FroyoStatusAnnouncerTask: Failed to relinquish audio focus");
+          }
+        }
+      };
+
+  public FroyoStatusAnnouncerTask(Context context) {
+    super(context);
+
+    audioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
+  }
+
+  @Override
+  protected void onTtsReady() {
+    super.onTtsReady();
+
+    tts.setOnUtteranceCompletedListener(utteranceListener);
+  }
+
+  @Override
+  protected synchronized void speakAnnouncement(String announcement) {
+    int result = audioManager.requestAudioFocus(null,
+          TextToSpeech.Engine.DEFAULT_STREAM,
+          AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK);
+    if (result == AudioManager.AUDIOFOCUS_REQUEST_FAILED) {
+      Log.w(TAG, "FroyoStatusAnnouncerTask: Request for audio focus failed.");
+    }
+
+    // We don't care about the utterance id.
+    // It is supplied here to force onUtteranceCompleted to be called.
+    tts.speak(announcement, TextToSpeech.QUEUE_FLUSH, SPEECH_PARAMS);
+  }
+}

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

@@ -0,0 +1,41 @@
+/*
+ * 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.tasks;
+
+import com.google.android.apps.mytracks.services.TrackRecordingService;
+
+/**
+ * This is interface for a task that will be executed on some schedule.
+ *
+ * @author Sandor Dornbush
+ */
+public interface PeriodicTask {
+  /**
+   * Sets up this task for subsequent calls to the run method.
+   */
+  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/tasks/PeriodicTaskExecutor.java

@@ -0,0 +1,189 @@
+/*
+ * 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.apps.mytracks.Constants.TAG;
+
+import com.google.android.apps.mytracks.services.TrackRecordingService;
+import com.google.android.apps.mytracks.util.UnitConversions;
+
+import android.util.Log;
+
+/**
+ * Execute a task on a time or distance schedule.
+ *
+ * @author Sandor Dornbush
+ */
+public class PeriodicTaskExecutor {
+
+  /**
+   * The frequency of the task.
+   * A value greater than zero is a frequency in time.
+   * A value less than zero is considered a frequency in distance.
+   */
+  private int taskFrequency = 0;
+
+  /**
+   * The next distance when the task should execute.
+   */
+  private double nextTaskDistance = 0;
+
+  /**
+   * Time based executor.
+   */
+  private TimerTaskExecutor timerExecutor = null;
+
+  private boolean metricUnits;
+
+  private final TrackRecordingService service;
+
+  private final PeriodicTaskFactory factory;
+
+  private PeriodicTask task;
+
+  public PeriodicTaskExecutor(TrackRecordingService service, PeriodicTaskFactory factory) {
+    this.service = service;
+    this.factory = factory;
+  }
+
+  /**
+   * Restores the manager.
+   */
+  public void restore() {
+    // TODO: Decouple service from this class once and forever.
+    if (!service.isRecording()) {
+      return;
+    }
+
+    if (!isTimeFrequency()) {
+      if (timerExecutor != null) {
+        timerExecutor.shutdown();
+        timerExecutor = null;
+      }
+    }
+    if (taskFrequency == 0) {
+      return;
+    }
+
+    // Try to make the task.
+    task = factory.create(service);
+    // Returning null is ok.
+    if (task == null) {
+      return;
+    }
+    task.start();
+
+    if (isTimeFrequency()) {
+      if (timerExecutor == null) {
+        timerExecutor = new TimerTaskExecutor(task, service);
+      }
+      timerExecutor.scheduleTask(taskFrequency * 60000L);
+    } else {
+      // For distance based splits.
+      calculateNextTaskDistance();
+    }
+  }
+
+  /**
+   * Shuts down the manager.
+   */
+  public void shutdown() {
+    if (task != null) {
+      task.shutdown();
+      task = null;
+    }
+    if (timerExecutor != null) {
+      timerExecutor.shutdown();
+      timerExecutor = null;
+    }
+  }
+
+  /**
+   * Calculates the next distance when the task should execute.
+   */
+  void calculateNextTaskDistance() {
+    // TODO: Decouple service from this class once and forever.
+    if (!service.isRecording() || task == null) {
+      return;
+    }
+
+    if (!isDistanceFrequency()) {
+      nextTaskDistance = Double.MAX_VALUE;
+      Log.d(TAG, "SplitManager: Distance splits disabled.");
+      return;
+    }
+
+    double distance = service.getTripStatistics().getTotalDistance() * UnitConversions.M_TO_KM;
+    if (!metricUnits) {
+      distance *= UnitConversions.KM_TO_MI;
+    }
+    // The index will be negative since the frequency is negative.
+    int index = (int) (distance / taskFrequency);
+    index -= 1;
+    nextTaskDistance = taskFrequency * index;
+    Log.d(TAG, "SplitManager: Next split distance: " + nextTaskDistance);
+  }
+
+  /**
+   * Updates executer with new trip statistics.
+   */
+  public void update() {
+    if (!isDistanceFrequency() || task == null) {
+      return;
+    }
+    // Convert the distance in meters to km or mi.
+    double distance = service.getTripStatistics().getTotalDistance() * UnitConversions.M_TO_KM;
+    if (!metricUnits) {
+      distance *= UnitConversions.KM_TO_MI;
+    }
+
+    if (distance > nextTaskDistance) {
+      task.run(service);
+      calculateNextTaskDistance();
+    }
+  }
+
+  private boolean isTimeFrequency() {
+    return taskFrequency > 0;
+  }
+
+  private boolean isDistanceFrequency() {
+    return taskFrequency < 0;
+  }
+
+  /**
+   * Sets the task frequency.
+   * &lt; 0 Use the absolute value as a distance in the current measurement km
+   *  or mi
+   *   0 Turn off the task
+   * &gt; 0 Use the value as a time in minutes
+   * @param taskFrequency The frequency in time or distance
+   */
+  public void setTaskFrequency(int taskFrequency) {
+    Log.d(TAG, "setTaskFrequency: taskFrequency = " + taskFrequency);
+    this.taskFrequency = taskFrequency;
+    restore();
+  }
+
+  public void setMetricUnits(boolean metricUnits) {
+    this.metricUnits = metricUnits;
+    calculateNextTaskDistance();
+  }
+
+  double getNextTaskDistance() {
+    return nextTaskDistance;
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/services/tasks/PeriodicTaskFactory.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.services.tasks;
+
+import android.content.Context;
+
+/**
+ * An interface for classes that can create periodic tasks.
+ *
+ * @author Sandor Dornbush
+ */
+public interface PeriodicTaskFactory {
+
+  /**
+   * Creates a periodic task which does voice announcements.
+   *
+   * @return the task, or null if task is not supported
+   */
+  PeriodicTask create(Context context);
+}

MyTracks/src/com/google/android/apps/mytracks/services/tasks/SplitTask.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.services.tasks;
+
+import com.google.android.apps.mytracks.content.WaypointCreationRequest;
+import com.google.android.apps.mytracks.services.TrackRecordingService;
+
+import android.content.Context;
+
+
+/**
+ * A simple task to insert statistics markers periodically.
+ * @author Sandor Dornbush
+ */
+public class SplitTask implements PeriodicTask {
+
+  private SplitTask() {
+  }
+
+  @Override
+  public void run(TrackRecordingService service) {
+    service.insertWaypoint(WaypointCreationRequest.DEFAULT_STATISTICS);
+  }
+
+  @Override
+  public void shutdown() {
+  }
+
+  @Override
+  public void start() {
+  }
+  
+  /**
+   * Create new SplitTasks.
+   */
+  public static class Factory implements PeriodicTaskFactory {
+
+    @Override
+    public PeriodicTask create(Context context) {
+      return new SplitTask();
+    }
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/services/tasks/StatusAnnouncerFactory.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.tasks;
+
+import com.google.android.apps.mytracks.util.ApiAdapterFactory;
+
+import android.content.Context;
+
+/**
+ * Factory which wraps construction and setup of text-to-speech announcements in
+ * an API-level-safe way.
+ *
+ * @author Rodrigo Damazio
+ */
+public class StatusAnnouncerFactory implements PeriodicTaskFactory {
+
+  public StatusAnnouncerFactory() {
+  }
+
+  @Override
+  public PeriodicTask create(Context context) {
+    return ApiAdapterFactory.getApiAdapter().getStatusAnnouncerTask(context);
+  }
+}

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

@@ -0,0 +1,361 @@
+/*
+ * 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.tasks;
+
+import static com.google.android.apps.mytracks.Constants.TAG;
+
+import com.google.android.apps.mytracks.Constants;
+import com.google.android.apps.mytracks.services.TrackRecordingService;
+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 com.google.common.annotations.VisibleForTesting;
+
+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 statistics.
+ *
+ * @author Sandor Dornbush
+ */
+public class StatusAnnouncerTask implements PeriodicTask {
+
+  /**
+   * The rate at which announcements are spoken.
+   */
+  // @VisibleForTesting
+  static final float TTS_SPEECH_RATE = 0.9f;
+
+  /**
+   * A pointer to the service context.
+   */
+  private final Context context;
+
+  /**
+   * The interface to the text to speech engine.
+   */
+  protected TextToSpeech tts;
+
+  /**
+   * The response received from the TTS engine after initialization.
+   */
+  private int initStatus = TextToSpeech.ERROR;
+
+  /**
+   * Whether the TTS engine is ready.
+   */
+  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 != null && tts.isSpeaking()) {
+        // If we're already speaking, stop it.
+        tts.stop();
+      }
+    }
+  };
+
+  public StatusAnnouncerTask(Context context) {
+    this.context = context;
+  }
+
+  /**
+   * {@inheritDoc}
+   *
+   * Announces the trip status.
+   */
+  @Override
+  public void run(TrackRecordingService service) {
+    if (service == null) {
+      Log.e(TAG, "StatusAnnouncer TrackRecordingService not initialized");
+      return;
+    }
+
+    runWithStatistics(service.getTripStatistics());
+  }
+
+  /**
+   * This method exists as a convenience for testing code, allowing said code
+   * to avoid needing to instantiate an entire {@link TrackRecordingService}
+   * just to test the announcer.
+   */
+  // @VisibleForTesting
+  void runWithStatistics(TripStatistics statistics) {
+    if (statistics == null) {
+      Log.e(TAG, "StatusAnnouncer stats not initialized.");
+      return;
+    }
+
+    synchronized (this) {
+      checkReady();
+      if (!ready) {
+        Log.e(TAG, "StatusAnnouncer Tts not ready.");
+        return;
+      }
+    }
+
+    if (!speechAllowed) {
+      Log.i(Constants.TAG,
+          "Not making announcement - not allowed at this time");
+      return;
+    }
+
+    String announcement = getAnnouncement(statistics);
+    Log.d(Constants.TAG, "Announcement: " + announcement);
+    speakAnnouncement(announcement);
+  }
+
+  protected void speakAnnouncement(String 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) {
+    boolean metricUnits = true;
+    boolean reportSpeed = true;
+    SharedPreferences preferences = context.getSharedPreferences(
+        Constants.SETTINGS_NAME, Context.MODE_PRIVATE);
+    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() * UnitConversions.M_TO_KM;
+    double s =  stats.getAverageMovingSpeed() * UnitConversions.MS_TO_KMH;
+    
+    if (d == 0) {
+      return context.getString(R.string.voice_total_distance_zero);
+    }
+
+    if (!metricUnits) {
+      d *= UnitConversions.KM_TO_MI;
+      s *= UnitConversions.KM_TO_MI;
+    }
+
+    if (!reportSpeed) {
+      s = 3600000.0 / s; // converts from speed to pace
+    }
+
+    // Makes sure s is not NaN.
+    if (Double.isNaN(s)) {
+      s = 0;
+    } 
+    
+    String speed;
+    if (reportSpeed) {
+      int speedId = metricUnits ? R.plurals.voiceSpeedKilometersPerHour
+          : R.plurals.voiceSpeedMilesPerHour;
+      speed = context.getResources().getQuantityString(speedId, getQuantityCount(s), s);
+    } else {
+      int paceId = metricUnits ? R.string.voice_pace_per_kilometer : R.string.voice_pace_per_mile;
+      speed = String.format(context.getString(paceId), getAnnounceTime((long) s));
+    }
+
+    int totalDistanceId = metricUnits ? R.plurals.voiceTotalDistanceKilometers
+        : R.plurals.voiceTotalDistanceMiles;
+    String totalDistance = context.getResources().getQuantityString(
+        totalDistanceId, getQuantityCount(d), d);
+
+    return context.getString(
+        R.string.voice_template, totalDistance, getAnnounceTime(stats.getMovingTime()), speed);
+  }
+  
+  /**
+   * Gets the plural count to be used by getQuantityString. getQuantityString
+   * only supports integer quantities, not a double quantity like "2.2".
+   * <p>
+   * As a temporary workaround, we convert a double quantity to an integer
+   * quantity. If the double quantity is exactly 0, 1, or 2, then we can return
+   * these integer quantities. Otherwise, we cast the double quantity to an
+   * integer quantity. However, we need to make sure that if the casted value is
+   * 0, 1, or 2, we don't return those, instead, return the next biggest integer
+   * 3.
+   *
+   * @param d the double value
+   */
+  private int getQuantityCount(double d) {
+    if (d == 0) {
+      return 0;
+    } else if (d == 1) {
+      return 1;
+    } else if (d == 2) {
+      return 2;
+    } else {
+      int count = (int) d;
+      return count < 3 ? 3 : count;
+    }
+  }
+  
+  @Override
+  public void start() {
+    Log.i(Constants.TAG, "Starting TTS");
+    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);
+  }
+
+  /**
+   * Called when the TTS engine is initialized.
+   */
+  private void onTtsInit(int status) {
+    Log.i(TAG, "TrackRecordingService.TTS init: " + status);
+    synchronized (this) {
+      // TTS should be valid here but NPE exceptions were reported to the market.
+      initStatus = status;
+      checkReady();
+    }
+  }
+
+  /**
+   * Ensures that the TTS is ready (finishing its initialization if needed).
+   */
+  private void checkReady() {
+    synchronized (this) {
+      if (ready) {
+        // Already done;
+        return;
+      }
+
+      ready = initStatus == TextToSpeech.SUCCESS && tts != null;
+      Log.d(TAG, "Status announcer ready: " + ready);
+
+      if (ready) {
+        onTtsReady();
+      }
+    }
+  }
+
+  /**
+   * Finishes the TTS engine initialization.
+   * Called once (and only once) when the TTS engine is ready.
+   */
+  protected void onTtsReady() {
+    // 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(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);
+  }
+
+  @Override
+  public void shutdown() {
+    // Stop listening to phone state.
+    listenToPhoneState(phoneListener, PhoneStateListener.LISTEN_NONE);
+
+    if (tts != null) {
+      tts.shutdown();
+      tts = null;
+    }
+
+    Log.i(Constants.TAG, "TTS shut down");
+  }
+
+  /**
+   * 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);
+    if (telephony != null) {
+      telephony.listen(listener, events);
+    }
+  }
+
+  /**
+   * Gets a string to announce the time.
+   * 
+   * @param time the time
+   */
+  @VisibleForTesting
+  String getAnnounceTime(long time) {
+    int[] parts = StringUtils.getTimeParts(time);
+    String seconds = context.getResources().getQuantityString(
+        R.plurals.voiceSeconds, parts[0], parts[0]);
+    String minutes = context.getResources().getQuantityString(
+        R.plurals.voiceMinutes, parts[1], parts[1]);
+    String hours = context.getResources().getQuantityString(
+        R.plurals.voiceHours, parts[2], parts[2]);
+
+    StringBuilder sb = new StringBuilder();
+    if (parts[2] != 0) {
+      sb.append(hours);
+      sb.append(" ");
+      sb.append(minutes);
+    } else {
+      sb.append(minutes);
+      sb.append(" ");
+      sb.append(seconds);
+    }
+    return sb.toString();
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/services/tasks/TimerTaskExecutor.java

@@ -0,0 +1,109 @@
+/*
+ * 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.tasks;
+
+import static com.google.android.apps.mytracks.Constants.TAG;
+
+import android.util.Log;
+
+import java.util.Date;
+import java.util.Timer;
+import java.util.TimerTask;
+
+import com.google.android.apps.mytracks.services.TrackRecordingService;
+
+/**
+ * This class will periodically perform a task.
+ *
+ * @author Sandor Dornbush
+ */
+public class TimerTaskExecutor {
+
+  private final PeriodicTask task;
+  private final TrackRecordingService service;
+
+  /**
+   * A timer to schedule the announcements.
+   * This is non-null if the task is in started (scheduled) state.
+   */
+  private Timer timer;
+
+  public TimerTaskExecutor(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;
+    }
+
+    if (timer != null) {
+      timer.cancel();
+      timer.purge();
+    } else {
+      // First start, or we were previously shut down.
+      task.start();
+    }
+
+    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(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(TAG, task.getClass().getSimpleName() + " shutting down.");
+    if (timer != null) {
+      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);
+    }
+  }
+}