Add track location as an option for the default track name

MyTracks/src/com/google/android/apps/mytracks/settings/AbstractSettingsActivity.java

@@ -0,0 +1,74 @@
+/*
+ * 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.settings;
+
+import com.google.android.apps.mytracks.Constants;
+import com.google.android.apps.mytracks.io.backup.BackupPreferencesListener;
+import com.google.android.apps.mytracks.util.ApiAdapterFactory;
+
+import android.content.Context;
+import android.os.Bundle;
+import android.preference.PreferenceActivity;
+import android.preference.PreferenceManager;
+import android.speech.tts.TextToSpeech;
+import android.view.MenuItem;
+
+/**
+ * An abstract activity for all the settings activities.
+ * 
+ * @author Jimmy Shih
+ */
+public class AbstractSettingsActivity extends PreferenceActivity {
+
+  private BackupPreferencesListener backupPreferencesListener;
+
+  @SuppressWarnings("deprecation")
+  @Override
+  protected void onCreate(Bundle bundle) {
+    super.onCreate(bundle);
+    setVolumeControlStream(TextToSpeech.Engine.DEFAULT_STREAM);
+    ApiAdapterFactory.getApiAdapter().configureActionBarHomeAsUp(this);
+
+    PreferenceManager preferenceManager = getPreferenceManager();
+    preferenceManager.setSharedPreferencesName(Constants.SETTINGS_NAME);
+    preferenceManager.setSharedPreferencesMode(Context.MODE_PRIVATE);
+
+    // Set up automatic preferences backup
+    backupPreferencesListener = ApiAdapterFactory.getApiAdapter()
+        .getBackupPreferencesListener(this);
+    preferenceManager.getSharedPreferences()
+        .registerOnSharedPreferenceChangeListener(backupPreferencesListener);
+  }
+
+  @Override
+  public boolean onOptionsItemSelected(MenuItem item) {
+    if (item.getItemId() != android.R.id.home) {
+      return super.onOptionsItemSelected(item);
+    }
+    finish();
+    return true;
+  }
+
+  @SuppressWarnings("deprecation")
+  @Override
+  protected void onDestroy() {
+    super.onDestroy();
+    PreferenceManager preferenceManager = getPreferenceManager();
+    preferenceManager.getSharedPreferences()
+        .unregisterOnSharedPreferenceChangeListener(backupPreferencesListener);
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/settings/BackupSettingsActivity.java

@@ -0,0 +1,127 @@
+/*
+ * 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.settings;
+
+import com.google.android.apps.mytracks.Constants;
+import com.google.android.apps.mytracks.io.backup.BackupActivity;
+import com.google.android.apps.mytracks.io.backup.RestoreChooserActivity;
+import com.google.android.apps.mytracks.util.DialogUtils;
+import com.google.android.apps.mytracks.util.IntentUtils;
+import com.google.android.apps.mytracks.util.PreferencesUtils;
+import com.google.android.maps.mytracks.R;
+
+import android.app.Dialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
+import android.os.Bundle;
+import android.preference.Preference;
+import android.preference.Preference.OnPreferenceClickListener;
+
+/**
+ * An activity for accessing the backup settings.
+ * 
+ * @author Jimmy Shih
+ */
+public class BackupSettingsActivity extends AbstractSettingsActivity {
+
+  private static final int DIALOG_CONFIRM_RESTORE_ID = 0;
+
+  Preference backupPreference;
+  Preference restorePreference;
+
+  /*
+   * 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) {
+          // Note that key can be null
+          if (PreferencesUtils.getKey(BackupSettingsActivity.this, R.string.recording_track_id_key)
+              .equals(key)) {
+            updateUi();
+          }
+        }
+      };
+
+  @SuppressWarnings("deprecation")
+  @Override
+  protected void onCreate(Bundle bundle) {
+    super.onCreate(bundle);
+    getSharedPreferences(Constants.SETTINGS_NAME, Context.MODE_PRIVATE)
+        .registerOnSharedPreferenceChangeListener(sharedPreferenceChangeListener);
+
+    addPreferencesFromResource(R.xml.backup_settings);
+    backupPreference = findPreference(getString(R.string.settings_backup_now_key));
+    backupPreference.setOnPreferenceClickListener(new OnPreferenceClickListener() {
+        @Override
+      public boolean onPreferenceClick(Preference preference) {
+        Intent intent = IntentUtils.newIntent(BackupSettingsActivity.this, BackupActivity.class);
+        startActivity(intent);
+        return true;
+      }
+    });
+    restorePreference = findPreference(getString(R.string.settings_backup_restore_key));
+    restorePreference.setOnPreferenceClickListener(new OnPreferenceClickListener() {
+        @Override
+      public boolean onPreferenceClick(Preference preference) {
+        showDialog(DIALOG_CONFIRM_RESTORE_ID);
+        return true;
+      }
+    });
+  }
+
+  @Override
+  protected Dialog onCreateDialog(int id) {
+    if (id != DIALOG_CONFIRM_RESTORE_ID) {
+      return null;
+    }
+    return DialogUtils.createConfirmationDialog(this,
+        R.string.settings_backup_restore_confirm_message, new DialogInterface.OnClickListener() {
+          @Override
+          public void onClick(DialogInterface dialog, int which) {
+            Intent intent = IntentUtils.newIntent(
+                BackupSettingsActivity.this, RestoreChooserActivity.class);
+            startActivity(intent);
+          }
+        });
+  }
+
+  @Override
+  protected void onResume() {
+    super.onResume();
+    updateUi();
+  }
+
+  /**
+   * Updates the UI based on the recording state.
+   */
+  private void updateUi() {
+    boolean isRecording = PreferencesUtils.getLong(this, R.string.recording_track_id_key)
+        != PreferencesUtils.RECORDING_TRACK_ID_DEFAULT;
+    backupPreference.setEnabled(!isRecording);
+    restorePreference.setEnabled(!isRecording);
+    backupPreference.setSummary(isRecording ? R.string.settings_not_while_recording
+        : R.string.settings_backup_now_summary);
+    restorePreference.setSummary(isRecording ? R.string.settings_not_while_recording
+        : R.string.settings_backup_restore_summary);
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/settings/ChartSettingsActivity.java

@@ -0,0 +1,54 @@
+/*
+ * 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.settings;
+
+import com.google.android.apps.mytracks.util.PreferencesUtils;
+import com.google.android.maps.mytracks.R;
+
+import android.os.Bundle;
+import android.preference.CheckBoxPreference;
+
+/**
+ * An activity for accessing chart settings.
+ * 
+ * @author Jimmy Shih
+ */
+public class ChartSettingsActivity extends AbstractSettingsActivity {
+
+  @SuppressWarnings("deprecation")
+  @Override
+  protected void onCreate(Bundle bundle) {
+    super.onCreate(bundle);
+    addPreferencesFromResource(R.xml.chart_settings);
+  }
+
+  @Override
+  protected void onResume() {
+    super.onResume();
+    updateUi();
+  }
+
+  @SuppressWarnings("deprecation")
+  private void updateUi() {
+    CheckBoxPreference speedCheckBoxPreference = (CheckBoxPreference) findPreference(
+        getString(R.string.chart_show_speed_key));
+    boolean reportSpeed = PreferencesUtils.getBoolean(
+        this, R.string.report_speed_key, PreferencesUtils.REPORT_SPEED_DEFAULT);
+    speedCheckBoxPreference.setTitle(reportSpeed ? R.string.stats_speed
+        : R.string.stats_pace);
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/settings/MapSettingsActivity.java

@@ -0,0 +1,273 @@
+/*
+ * 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.settings;
+
+import com.google.android.apps.mytracks.util.PreferencesUtils;
+import com.google.android.apps.mytracks.util.UnitConversions;
+import com.google.android.maps.mytracks.R;
+
+import android.app.Dialog;
+import android.os.Bundle;
+import android.preference.EditTextPreference;
+import android.preference.ListPreference;
+import android.preference.Preference;
+import android.preference.Preference.OnPreferenceChangeListener;
+import android.preference.Preference.OnPreferenceClickListener;
+import android.util.Log;
+import android.view.KeyEvent;
+import android.view.inputmethod.EditorInfo;
+import android.widget.TextView;
+
+/**
+ * An activity for accessing map settings.
+ * 
+ * @author Jimmy Shih
+ */
+public class MapSettingsActivity extends AbstractSettingsActivity {
+
+  private static final String TAG = MapSettingsActivity.class.getSimpleName();
+
+  private EditTextPreference slowEditTextPreference;
+  private EditTextPreference mediumEditTextPreference;
+  private EditTextPreference percentageEditTextPreference;
+
+  @SuppressWarnings("deprecation")
+  @Override
+  protected void onCreate(Bundle bundle) {
+    super.onCreate(bundle);
+    addPreferencesFromResource(R.xml.map_settings);
+
+    ListPreference trackColorModeListPreference = (ListPreference) findPreference(
+        getString(R.string.track_color_mode_key));
+    trackColorModeListPreference.setOnPreferenceChangeListener(new OnPreferenceChangeListener() {
+        @Override
+      public boolean onPreferenceChange(Preference preference, Object newValue) {
+        updateUiByTrackColorMode((String) newValue);
+        return true;
+      }
+    });
+
+    slowEditTextPreference = (EditTextPreference) findPreference(
+        getString(R.string.settings_map_slow_display_key));
+    configureSpeedEditTextPreference(R.string.track_color_mode_slow_key);
+
+    mediumEditTextPreference = (EditTextPreference) findPreference(
+        getString(R.string.settings_map_medium_display_key));
+    configureSpeedEditTextPreference(R.string.track_color_mode_medium_key);
+
+    percentageEditTextPreference = (EditTextPreference) findPreference(
+        getString(R.string.settings_map_percentage_display_key));
+    configurePercentageEditTextPreference();
+    updatePercentageSummary();
+
+    configureImeActionDone(slowEditTextPreference);
+    configureImeActionDone(mediumEditTextPreference);
+    configureImeActionDone(percentageEditTextPreference);
+
+    updateUiByTrackColorMode(trackColorModeListPreference.getValue());
+  }
+
+  /**
+   * Configures the speed edit text preference.
+   * 
+   * @param keyId the key id
+   */
+  private void configureSpeedEditTextPreference(final int keyId) {
+    final EditTextPreference editTextPreference = keyId == R.string.track_color_mode_slow_key ? slowEditTextPreference
+        : mediumEditTextPreference;
+    editTextPreference.setOnPreferenceChangeListener(new OnPreferenceChangeListener() {
+        @Override
+      public boolean onPreferenceChange(Preference preference, Object newValue) {
+        storeSpeedValue(keyId, (String) newValue);
+        updateSpeedSummary(keyId);
+        return true;
+      }
+    });
+    editTextPreference.setOnPreferenceClickListener(new OnPreferenceClickListener() {
+        @Override
+      public boolean onPreferenceClick(Preference preference) {
+        int value = getSpeedDisplayValue(keyId);
+        ((EditTextPreference) preference).getEditText().setText(String.valueOf(value));
+        return true;
+      }
+    });
+  }
+
+  /**
+   * Configures the percentage edit text preference.
+   */
+  private void configurePercentageEditTextPreference() {
+    percentageEditTextPreference.setOnPreferenceChangeListener(new OnPreferenceChangeListener() {
+        @Override
+      public boolean onPreferenceChange(Preference preference, Object newValue) {
+        String displayValue = (String) newValue;
+        int value;
+        try {
+          value = Integer.parseInt(displayValue);
+        } catch (NumberFormatException e) {
+          Log.e(TAG, "invalid value " + displayValue);
+          value = PreferencesUtils.TRACK_COLOR_MODE_PERCENTAGE_DEFAULT;
+        }
+        if (value < 0) {
+          value = PreferencesUtils.TRACK_COLOR_MODE_PERCENTAGE_DEFAULT;
+        }
+        PreferencesUtils.setInt(
+            MapSettingsActivity.this, R.string.track_color_mode_percentage_key, value);
+        updatePercentageSummary();
+        return true;
+      }
+    });
+    percentageEditTextPreference.setOnPreferenceClickListener(new OnPreferenceClickListener() {
+        @Override
+      public boolean onPreferenceClick(Preference preference) {
+        int value = PreferencesUtils.getInt(
+            MapSettingsActivity.this, R.string.track_color_mode_percentage_key,
+            PreferencesUtils.TRACK_COLOR_MODE_PERCENTAGE_DEFAULT);
+        ((EditTextPreference) preference).getEditText().setText(String.valueOf(value));
+        return true;
+      }
+    });
+  }
+
+  /**
+   * Configures the IME action done.
+   * 
+   * @param editTextPreference the edit text preference
+   */
+  private void configureImeActionDone(final EditTextPreference editTextPreference) {
+    editTextPreference.getEditText()
+        .setOnEditorActionListener(new TextView.OnEditorActionListener() {
+            @Override
+          public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
+            if (actionId == EditorInfo.IME_ACTION_DONE) {
+              Dialog dialog = editTextPreference.getDialog();
+              editTextPreference.onClick(dialog, Dialog.BUTTON_POSITIVE);
+              dialog.dismiss();
+              return true;
+            }
+            return false;
+          }
+        });
+  }
+
+  @Override
+  protected void onResume() {
+    super.onResume();
+    updateSpeedSummary(R.string.track_color_mode_slow_key);
+    updateSpeedSummary(R.string.track_color_mode_medium_key);
+  }
+
+  /**
+   * Updates the UI by the track color mode.
+   * 
+   * @param trackColorMode the track color mode
+   */
+  private void updateUiByTrackColorMode(String trackColorMode) {
+    boolean isFixedValue = trackColorMode.equals(
+        getString(R.string.settings_map_track_color_mode_fixed_value));
+    boolean isDynamicValue = trackColorMode.equals(
+        getString(R.string.settings_map_track_color_mode_dynamic_value));
+    slowEditTextPreference.setEnabled(isFixedValue);
+    mediumEditTextPreference.setEnabled(isFixedValue);
+    percentageEditTextPreference.setEnabled(isDynamicValue);
+  }
+
+  /**
+   * Stores the speed value, always in metric units.
+   * 
+   * @param keyId the key id
+   * @param displayValue the display value
+   */
+  private void storeSpeedValue(int keyId, String displayValue) {
+    int maxValue;
+    int minValue;
+    int defaultValue;
+    if (keyId == R.string.track_color_mode_slow_key) {
+      minValue = 0;
+      maxValue = PreferencesUtils.getInt(this, R.string.track_color_mode_medium_key,
+          PreferencesUtils.TRACK_COLOR_MODE_MEDIUM_DEFAULT);
+      defaultValue = PreferencesUtils.TRACK_COLOR_MODE_SLOW_DEFAULT;
+    } else {
+      minValue = PreferencesUtils.getInt(
+          this, R.string.track_color_mode_slow_key, PreferencesUtils.TRACK_COLOR_MODE_SLOW_DEFAULT);
+      maxValue = Integer.MAX_VALUE;
+      defaultValue = PreferencesUtils.TRACK_COLOR_MODE_MEDIUM_DEFAULT;
+    }
+    int value;
+    try {
+      value = Integer.parseInt(displayValue);
+      if (!PreferencesUtils.getBoolean(
+          this, R.string.metric_units_key, PreferencesUtils.METRIC_UNITS_DEFAULT)) {
+        value = (int) (value * UnitConversions.MI_TO_KM);
+      }
+    } catch (NumberFormatException e) {
+      Log.e(TAG, "invalid value " + displayValue);
+      value = defaultValue;
+    }
+
+    if (value > maxValue) {
+      value = maxValue;
+    }
+    if (value < minValue) {
+      value = minValue;
+    }
+    PreferencesUtils.setInt(this, keyId, value);
+  }
+
+  /**
+   * Gets the speed display value, in metric or imperial depending on the preferred
+   * units.
+   * 
+   * @param keyId the key id
+   */
+  private int getSpeedDisplayValue(int keyId) {
+    int defaultValue = keyId == R.string.track_color_mode_slow_key ? PreferencesUtils.TRACK_COLOR_MODE_SLOW_DEFAULT
+        : PreferencesUtils.TRACK_COLOR_MODE_MEDIUM_DEFAULT;
+    int value = PreferencesUtils.getInt(this, keyId, defaultValue);
+    if (!PreferencesUtils.getBoolean(
+        this, R.string.metric_units_key, PreferencesUtils.METRIC_UNITS_DEFAULT)) {
+      value = (int) (value * UnitConversions.KM_TO_MI);
+    }
+    return value;
+  }
+
+  /**
+   * Updates the speed summary.
+   * 
+   * @param keyId the key id
+   */
+  private void updateSpeedSummary(int keyId) {
+    EditTextPreference editTextPreference = keyId == R.string.track_color_mode_slow_key ? slowEditTextPreference
+        : mediumEditTextPreference;
+    boolean metric = PreferencesUtils.getBoolean(
+        this, R.string.metric_units_key, PreferencesUtils.METRIC_UNITS_DEFAULT);
+    int displayValue = getSpeedDisplayValue(keyId);
+    editTextPreference.setSummary(getString(metric ? R.string.value_integer_kilometer_hour
+        : R.string.value_integer_mile_hour, displayValue));
+  }
+  
+  /**
+   * Updates the percentage summary.
+   */
+  private void updatePercentageSummary() {
+    int value = PreferencesUtils.getInt(
+        MapSettingsActivity.this, R.string.track_color_mode_percentage_key,
+        PreferencesUtils.TRACK_COLOR_MODE_PERCENTAGE_DEFAULT);
+    percentageEditTextPreference.setSummary(getString(R.string.settings_map_percentage_summary) + "\n"
+        + getString(R.string.value_integer_percent, value));
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/settings/RecordingSettingsActivity.java

@@ -0,0 +1,213 @@
+/*
+ * 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.settings;
+
+import com.google.android.apps.mytracks.util.PreferencesUtils;
+import com.google.android.apps.mytracks.util.UnitConversions;
+import com.google.android.maps.mytracks.R;
+
+import android.os.Bundle;
+import android.preference.ListPreference;
+
+/**
+ * An activity for accessing recording settings.
+ * 
+ * @author Jimmy Shih
+ */
+public class RecordingSettingsActivity extends AbstractSettingsActivity {
+
+  @SuppressWarnings("deprecation")
+  @Override
+  protected void onCreate(Bundle bundle) {
+    super.onCreate(bundle);
+    addPreferencesFromResource(R.xml.recording_settings);
+
+    boolean metricUnits = PreferencesUtils.getBoolean(
+        this, R.string.metric_units_key, PreferencesUtils.METRIC_UNITS_DEFAULT);
+
+    ListPreference minRecordingIntervalListPreference = (ListPreference) findPreference(
+        getString(R.string.min_recording_interval_key));
+    minRecordingIntervalListPreference.setEntries(getMinRecordingIntervalDisplayOptions());
+
+    ListPreference minRecordingDistanceListPreference = (ListPreference) findPreference(
+        getString(R.string.min_recording_distance_key));
+    minRecordingDistanceListPreference.setEntries(
+        getMinRecordingDistanceDisplayOptions(metricUnits));
+
+    ListPreference maxRecordingDistanceListPreference = (ListPreference) findPreference(
+        getString(R.string.max_recording_distance_key));
+    maxRecordingDistanceListPreference.setEntries(
+        getMaxRecordingDistanceDisplayOptions(metricUnits));
+
+    ListPreference minRequiredAccuracyListPreference = (ListPreference) findPreference(
+        getString(R.string.min_required_accuracy_key));
+    minRequiredAccuracyListPreference.setEntries(getMinRequiredAccuracyDisplayOptions(metricUnits));
+
+    ListPreference autoResumeTrackTimeoutListPreference = (ListPreference) findPreference(
+        getString(R.string.auto_resume_track_timeout_key));
+    autoResumeTrackTimeoutListPreference.setEntries(getAutoResumeTrackTimeoutDisplayOptions());
+  }
+
+  /**
+   * Gets the min recording interval display options.
+   */
+  private String[] getMinRecordingIntervalDisplayOptions() {
+    String[] values = getResources().getStringArray(R.array.min_recording_interval_values);
+    String[] options = new String[values.length];
+    for (int i = 0; i < values.length; i++) {
+      int value = Integer.parseInt(values[i]);
+      switch (value) {
+        case PreferencesUtils.MIN_RECORDING_INTERVAL_ADAPT_BATTERY_LIFE:
+          options[i] = getString(R.string.value_adapt_battery_life);
+          break;
+        case PreferencesUtils.MIN_RECORDING_INTERVAL_ADAPT_ACCURACY:
+          options[i] = getString(R.string.value_adapt_accuracy);
+          break;
+        case PreferencesUtils.MIN_RECORDING_INTERVAL_DEFAULT:
+          options[i] = getString(R.string.value_smallest_recommended);
+          break;
+        default:
+          options[i] = value < 60 ? getString(R.string.value_integer_second, value)
+              : getString(R.string.value_integer_minute, value / 60);
+      }
+    }
+    return options;
+  }
+
+  /**
+   * Gets the min recording distance display options.
+   * 
+   * @param metricUnits true to display metric units
+   */
+  private String[] getMinRecordingDistanceDisplayOptions(boolean metricUnits) {
+    String[] values = getResources().getStringArray(R.array.min_recording_distance_values);
+    String[] options = new String[values.length];
+    for (int i = 0; i < values.length; i++) {
+      int value = Integer.parseInt(values[i]);
+      if (metricUnits) {
+        options[i] = getString(value == PreferencesUtils.MIN_RECORDING_DISTANCE_DEFAULT
+            ? R.string.value_integer_meter_recommended
+            : R.string.value_integer_meter, value);
+      } else {
+        int feet = (int) (value * UnitConversions.M_TO_FT);
+        options[i] = getString(value == PreferencesUtils.MIN_RECORDING_DISTANCE_DEFAULT
+            ? R.string.value_integer_feet_recommended
+            : R.string.value_integer_feet, feet);
+      }
+    }
+    return options;
+  }
+
+  /**
+   * Gets the max recording distance display options.
+   * 
+   * @param metricUnits true to display metric units
+   */
+  private String[] getMaxRecordingDistanceDisplayOptions(boolean metricUnits) {
+    String[] values = getResources().getStringArray(R.array.max_recording_distance_values);
+    String[] options = new String[values.length];
+    for (int i = 0; i < values.length; i++) {
+      int value = Integer.parseInt(values[i]);
+      if (metricUnits) {
+        options[i] = getString(value == PreferencesUtils.MAX_RECORDING_DISTANCE_DEFAULT
+            ? R.string.value_integer_meter_recommended
+            : R.string.value_integer_meter, value);
+      } else {
+        int feet = (int) (value * UnitConversions.M_TO_FT);
+        if (feet < 2000) {
+          options[i] = getString(value == PreferencesUtils.MAX_RECORDING_DISTANCE_DEFAULT
+              ? R.string.value_integer_feet_recommended
+              : R.string.value_integer_feet, feet);
+        } else {
+          double mile = feet * UnitConversions.FT_TO_MI;
+          options[i] = getString(R.string.value_float_mile, mile);
+        }
+      }
+    }
+    return options;
+  }
+
+  /**
+   * Gets the min required accuracy display options.
+   * 
+   * @param metricUnits true to display metric units
+   */
+  private String[] getMinRequiredAccuracyDisplayOptions(boolean metricUnits) {
+    String[] values = getResources().getStringArray(R.array.min_required_accuracy_values);
+    String[] options = new String[values.length];
+    for (int i = 0; i < values.length; i++) {
+      int value = Integer.parseInt(values[i]);
+      if (metricUnits) {
+        switch (value) {
+          case PreferencesUtils.MIN_REQUIRED_ACCURACY_DEFAULT:
+            options[i] = getString(R.string.value_integer_meter_recommended, value);
+            break;
+          case PreferencesUtils.MIN_REQUIRED_ACCURACY_EXCELLENT:
+            options[i] = getString(R.string.value_integer_meter_excellent_gps, value);
+            break;
+          case PreferencesUtils.MIN_REQUIRED_ACCURACY_POOR:
+            options[i] = getString(R.string.value_integer_meter_poor_gps, value);
+            break;
+          default:
+            options[i] = getString(R.string.value_integer_meter, value);
+        }
+      } else {
+        int feet = (int) (value * UnitConversions.M_TO_FT);
+        if (feet < 2000) {
+          switch (value) {
+            case PreferencesUtils.MIN_REQUIRED_ACCURACY_DEFAULT:
+              options[i] = getString(R.string.value_integer_feet_recommended, feet);
+              break;
+            case PreferencesUtils.MIN_REQUIRED_ACCURACY_EXCELLENT:
+              options[i] = getString(R.string.value_integer_feet_excellent_gps, feet);
+              break;
+            default:
+              options[i] = getString(R.string.value_integer_feet, feet);
+          }
+        } else {
+          double mile = feet * UnitConversions.FT_TO_MI;
+          options[i] = getString(value == PreferencesUtils.MIN_REQUIRED_ACCURACY_POOR
+              ? R.string.value_float_mile_poor_gps
+              : R.string.value_float_mile, mile);
+        }
+      }
+    }
+    return options;
+  }
+
+  /**
+   * Gets the auto resume track timeout display options.
+   */
+  private String[] getAutoResumeTrackTimeoutDisplayOptions() {
+    String[] values = getResources().getStringArray(R.array.auto_resume_track_timeout_values);
+    String[] options = new String[values.length];
+    for (int i = 0; i < values.length; i++) {
+      int value = Integer.parseInt(values[i]);
+      switch (value) {
+        case PreferencesUtils.AUTO_RESUME_TRACK_TIMEOUT_NEVER:
+          options[i] = getString(R.string.value_never);
+          break;
+        case PreferencesUtils.AUTO_RESUME_TRACK_TIMEOUT_ALWAYS:
+          options[i] = getString(R.string.value_always);
+          break;
+        default:
+          options[i] = getString(R.string.value_integer_minute, value);
+      }
+    }
+    return options;
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/settings/SensorSettingsActivity.java

@@ -0,0 +1,166 @@
+/*
+ * 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.settings;
+
+import com.dsi.ant.AntInterface;
+import com.google.android.apps.mytracks.services.sensors.ant.AntSensorManager;
+import com.google.android.apps.mytracks.util.BluetoothDeviceUtils;
+import com.google.android.apps.mytracks.util.PreferencesUtils;
+import com.google.android.maps.mytracks.R;
+
+import android.bluetooth.BluetoothAdapter;
+import android.content.Intent;
+import android.os.Bundle;
+import android.preference.ListPreference;
+import android.preference.Preference;
+import android.preference.Preference.OnPreferenceChangeListener;
+import android.preference.Preference.OnPreferenceClickListener;
+import android.preference.PreferenceScreen;
+import android.provider.Settings;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * An activity for accessing sensor settings.
+ * 
+ * @author Jimmy Shih
+ */
+public class SensorSettingsActivity extends AbstractSettingsActivity {
+
+  @SuppressWarnings("deprecation")
+  @Override
+  protected void onCreate(Bundle bundle) {
+    super.onCreate(bundle);
+    addPreferencesFromResource(R.xml.sensor_settings);
+
+    boolean hasAntSupport = AntInterface.hasAntSupport(this);
+    ListPreference sensorTypeListPreference = (ListPreference) findPreference(
+        getString(R.string.sensor_type_key));
+    List<String> sensorTypeEntries = Arrays.asList(getResources().getStringArray(
+        hasAntSupport ? R.array.sensor_type_all_options
+            : R.array.sensor_type_bluetooth_options));
+    List<String> sensorTypeEntryValues = Arrays.asList(getResources().getStringArray(
+        hasAntSupport ? R.array.sensor_type_all_values
+            : R.array.sensor_type_bluetooth_values));
+    sensorTypeListPreference.setEntries(sensorTypeEntries.toArray(
+        new CharSequence[sensorTypeEntries.size()]));
+    sensorTypeListPreference.setEntryValues(
+        sensorTypeEntryValues.toArray(new CharSequence[sensorTypeEntryValues.size()]));
+    sensorTypeListPreference.setOnPreferenceChangeListener(new OnPreferenceChangeListener() {
+        @Override
+      public boolean onPreferenceChange(Preference preference, Object newValue) {
+        updateUiBySensorType((String) newValue);
+        return true;
+      }
+    });
+
+    updateUiBySensorType(sensorTypeListPreference.getValue());
+
+    findPreference(getString(R.string.settings_sensor_bluetooth_pairing_key))
+        .setOnPreferenceClickListener(new OnPreferenceClickListener() {
+          public boolean onPreferenceClick(Preference preference) {
+            Intent settingsIntent = new Intent(Settings.ACTION_BLUETOOTH_SETTINGS);
+            startActivity(settingsIntent);
+            return true;
+          }
+        });
+
+    if (!hasAntSupport) {
+      PreferenceScreen rootPreferenceScreen = (PreferenceScreen) findPreference(
+          getString(R.string.settings_sensor_root_key));
+      rootPreferenceScreen.removePreference(
+          findPreference(getString(R.string.settings_sensor_ant_key)));
+    }
+  }
+
+  /**
+   * Updates the UI based on the sensor type.
+   * 
+   * @param sensorType the sensor type
+   */
+  @SuppressWarnings("deprecation")
+  private void updateUiBySensorType(String sensorType) {
+    boolean isBluetooth = getString(R.string.sensor_type_value_polar).equals(sensorType)
+        || getString(R.string.sensor_type_value_zephyr).equals(sensorType);
+    findPreference(getString(R.string.settings_sensor_bluetooth_key)).setEnabled(isBluetooth);
+
+    boolean isAnt = getString(R.string.sensor_type_value_ant).equals(sensorType);
+    updateAntSensor(R.string.settings_sensor_ant_reset_heart_rate_monitor_key,
+        R.string.ant_heart_rate_monitor_id_key, isAnt);
+    updateAntSensor(R.string.settings_sensor_ant_reset_speed_distance_monitor_key,
+        R.string.ant_speed_distance_monitor_id_key, isAnt);
+  }
+  
+  /**
+   * Updates an ant sensor.
+   * 
+   * @param preferenceKey the preference key
+   * @param valueKey the value key
+   * @param enabled true if enabled
+   */
+  @SuppressWarnings("deprecation")
+  private void updateAntSensor(int preferenceKey, final int valueKey, boolean enabled) {
+    Preference preference = findPreference(getString(preferenceKey));
+    if (preference != null) {
+      preference.setEnabled(enabled);
+      int deviceId = PreferencesUtils.getInt(this, valueKey, AntSensorManager.WILDCARD);
+      if (deviceId == AntSensorManager.WILDCARD) {
+        preference.setSummary(R.string.settings_sensor_not_connected);
+      } else {
+        preference.setSummary(getString(R.string.settings_sensor_ant_paired, deviceId));
+      }
+      preference.setOnPreferenceClickListener(new OnPreferenceClickListener() {
+          @Override
+        public boolean onPreferenceClick(Preference pref) {
+          PreferencesUtils.setInt(SensorSettingsActivity.this, valueKey, AntSensorManager.WILDCARD);
+          pref.setSummary(R.string.settings_sensor_not_connected);
+          return true;
+        }
+      });
+    }
+  }
+
+  @Override
+  protected void onResume() {
+    super.onResume();
+    updateBluetoothSensorListPreference();
+  }
+
+  /**
+   * Updates the bluetooth sensor list preference.
+   */
+  @SuppressWarnings("deprecation")
+  private void updateBluetoothSensorListPreference() {
+    ListPreference bluetoothSensorListPreference = (ListPreference) findPreference(
+        getString(R.string.bluetooth_sensor_key));
+    List<String> entries = new ArrayList<String>();
+    List<String> entryValues = new ArrayList<String>();
+    BluetoothAdapter bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
+
+    if (bluetoothAdapter != null) {
+      BluetoothDeviceUtils.populateDeviceLists(bluetoothAdapter, entries, entryValues);
+    }
+    bluetoothSensorListPreference.setEntries(entries.toArray(new CharSequence[entries.size()]));
+    bluetoothSensorListPreference.setEntryValues(entryValues.toArray(
+        new CharSequence[entryValues.size()]));
+    if (entries.size() == 1) {
+      bluetoothSensorListPreference.setValueIndex(0);
+    }
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/settings/SettingsActivity.java

@@ -0,0 +1,189 @@
+/*
+ * 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.settings;
+
+import com.google.android.apps.mytracks.Constants;
+import com.google.android.apps.mytracks.util.DialogUtils;
+import com.google.android.apps.mytracks.util.IntentUtils;
+import com.google.android.apps.mytracks.util.PreferencesUtils;
+import com.google.android.maps.mytracks.R;
+
+import android.app.Dialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.os.Bundle;
+import android.preference.Preference;
+import android.preference.Preference.OnPreferenceClickListener;
+import android.util.Log;
+import android.widget.Toast;
+
+/**
+ * An activity for accessing settings.
+ * 
+ * @author Leif Hendrik Wilden
+ * @author Rodrigo Damazio
+ */
+public class SettingsActivity extends AbstractSettingsActivity {
+
+  private static final String TAG = SettingsActivity.class.getSimpleName();
+  private static final int DIALOG_CONFIRM_RESET_ID = 0;
+
+  private Preference resetPreference;
+
+  @SuppressWarnings("deprecation")
+  @Override
+  protected void onCreate(Bundle bundle) {
+    super.onCreate(bundle);
+    addPreferencesFromResource(R.xml.settings);
+
+    Preference mapPreference = findPreference(getString(R.string.settings_map_key));
+    mapPreference.setOnPreferenceClickListener(new OnPreferenceClickListener() {
+        @Override
+      public boolean onPreferenceClick(Preference preference) {
+        Intent intent = IntentUtils.newIntent(SettingsActivity.this, MapSettingsActivity.class);
+        startActivity(intent);
+        return true;
+      }
+    });
+
+    Preference chartPreference = findPreference(getString(R.string.settings_chart_key));
+    chartPreference.setOnPreferenceClickListener(new OnPreferenceClickListener() {
+        @Override
+      public boolean onPreferenceClick(Preference preference) {
+        Intent intent = IntentUtils.newIntent(SettingsActivity.this, ChartSettingsActivity.class);
+        startActivity(intent);
+        return true;
+      }
+    });
+
+    Preference statsPreference = findPreference(getString(R.string.settings_stats_key));
+    statsPreference.setOnPreferenceClickListener(new OnPreferenceClickListener() {
+        @Override
+      public boolean onPreferenceClick(Preference preference) {
+        Intent intent = IntentUtils.newIntent(SettingsActivity.this, StatsSettingsActivity.class);
+        startActivity(intent);
+        return true;
+      }
+    });
+
+    Preference recordingPreference = findPreference(getString(R.string.settings_recording_key));
+    recordingPreference.setOnPreferenceClickListener(new OnPreferenceClickListener() {
+        @Override
+      public boolean onPreferenceClick(Preference preference) {
+        Intent intent = IntentUtils.newIntent(
+            SettingsActivity.this, RecordingSettingsActivity.class);
+        startActivity(intent);
+        return true;
+      }
+    });
+
+    Preference sharingPreference = findPreference(getString(R.string.settings_sharing_key));
+    sharingPreference.setOnPreferenceClickListener(new OnPreferenceClickListener() {
+        @Override
+      public boolean onPreferenceClick(Preference preference) {
+        Intent intent = IntentUtils.newIntent(SettingsActivity.this, SharingSettingsActivity.class);
+        startActivity(intent);
+        return true;
+      }
+    });
+
+    Preference sensorPreference = findPreference(getString(R.string.settings_sensor_key));
+    sensorPreference.setOnPreferenceClickListener(new OnPreferenceClickListener() {
+        @Override
+      public boolean onPreferenceClick(Preference preference) {
+        Intent intent = IntentUtils.newIntent(SettingsActivity.this, SensorSettingsActivity.class);
+        startActivity(intent);
+        return true;
+      }
+    });
+
+    Preference backupPreference = findPreference(getString(R.string.settings_backup_key));
+    backupPreference.setOnPreferenceClickListener(new OnPreferenceClickListener() {
+        @Override
+      public boolean onPreferenceClick(Preference preference) {
+        Intent intent = IntentUtils.newIntent(SettingsActivity.this, BackupSettingsActivity.class);
+        startActivity(intent);
+        return true;
+      }
+    });
+
+    resetPreference = findPreference(getString(R.string.settings_reset_key));
+    resetPreference.setOnPreferenceClickListener(new OnPreferenceClickListener() {
+        @Override
+      public boolean onPreferenceClick(Preference arg0) {
+        showDialog(DIALOG_CONFIRM_RESET_ID);
+        return true;
+      }
+    });
+  }
+
+  @Override
+  protected void onResume() {
+    super.onResume();
+    boolean isRecording = PreferencesUtils.getLong(this, R.string.recording_track_id_key)
+        != PreferencesUtils.RECORDING_TRACK_ID_DEFAULT;
+    resetPreference.setEnabled(!isRecording);
+    resetPreference.setSummary(isRecording ? R.string.settings_not_while_recording
+        : R.string.settings_reset_summary);
+  }
+
+  @Override
+  protected Dialog onCreateDialog(int id) {
+    if (id != DIALOG_CONFIRM_RESET_ID) {
+      return null;
+    }
+    return DialogUtils.createConfirmationDialog(
+        this, R.string.settings_reset_confirm_message, new DialogInterface.OnClickListener() {
+            @Override
+          public void onClick(DialogInterface dialog, int button) {
+            onResetPreferencesConfirmed();
+          }
+        });
+  }
+
+  /**
+   * Callback when the user confirms resetting all settings.
+   */
+  private void onResetPreferencesConfirmed() {
+    // Change preferences in a separate thread
+    new Thread() {
+        @Override
+      public void run() {
+        Log.i(TAG, "Resetting all settings");
+        SharedPreferences sharedPreferences = getSharedPreferences(
+            Constants.SETTINGS_NAME, Context.MODE_PRIVATE);
+        // Actually wipe preferences and save synchronously
+        sharedPreferences.edit().clear().commit();
+
+        // Give UI feedback in the UI thread
+        runOnUiThread(new Runnable() {
+            @Override
+          public void run() {
+            Toast.makeText(SettingsActivity.this, R.string.settings_reset_done, Toast.LENGTH_SHORT)
+                .show();
+            // Restart the settings activity so all changes are loaded
+            Intent intent = getIntent()
+                .addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK);
+            startActivity(intent);
+          }
+        });
+      }
+    }.start();
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/settings/SharingSettingsActivity.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.settings;
+
+import com.google.android.apps.mytracks.Constants;
+import com.google.android.apps.mytracks.util.DialogUtils;
+import com.google.android.maps.mytracks.R;
+
+import android.accounts.Account;
+import android.accounts.AccountManager;
+import android.app.Dialog;
+import android.content.DialogInterface;
+import android.os.Bundle;
+import android.preference.CheckBoxPreference;
+import android.preference.ListPreference;
+import android.preference.Preference;
+import android.preference.Preference.OnPreferenceChangeListener;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * An activity for accessing the sharing settings.
+ * 
+ * @author Jimmy Shih
+ */
+public class SharingSettingsActivity extends AbstractSettingsActivity {
+
+  private static final int DIALOG_CONFIRM_ALLOW_ACCESS_ID = 0;
+
+  private CheckBoxPreference allowAccessCheckBoxPreference;
+
+  @SuppressWarnings("deprecation")
+  @Override
+  protected void onCreate(Bundle bundle) {
+    super.onCreate(bundle);
+    addPreferencesFromResource(R.xml.sharing_settings);
+
+    allowAccessCheckBoxPreference = (CheckBoxPreference) findPreference(
+        getString(R.string.allow_access_key));
+    allowAccessCheckBoxPreference.setOnPreferenceChangeListener(new OnPreferenceChangeListener() {
+        @Override
+      public boolean onPreferenceChange(Preference preference, Object newValue) {
+        if ((Boolean) newValue) {
+          showDialog(DIALOG_CONFIRM_ALLOW_ACCESS_ID);
+          return false;
+        } else {
+          return true;
+        }
+      }
+    });
+    
+    ListPreference sharingAccountListPreference = (ListPreference) findPreference(
+        getString(R.string.sharing_account_key));
+    List<String> entries = new ArrayList<String>();
+    Account[] accounts = AccountManager.get(this).getAccountsByType(Constants.ACCOUNT_TYPE);
+    for (Account account : accounts) {
+      entries.add(account.name);
+    }
+    
+    sharingAccountListPreference.setEntries(entries.toArray(new CharSequence[entries.size()]));
+    sharingAccountListPreference.setEntryValues(entries.toArray(
+        new CharSequence[entries.size()]));
+    if (entries.size() == 1) {
+      sharingAccountListPreference.setValueIndex(0);
+    }
+  }
+
+  @Override
+  protected Dialog onCreateDialog(int id) {
+    if (id != DIALOG_CONFIRM_ALLOW_ACCESS_ID) {
+      return null;
+    }
+    return DialogUtils.createConfirmationDialog(this,
+        R.string.settings_sharing_allow_access_confirm_message,
+        new DialogInterface.OnClickListener() {
+          @Override
+          public void onClick(DialogInterface dialog, int button) {
+            allowAccessCheckBoxPreference.setChecked(true);
+          }
+        });
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/settings/StatsSettingsActivity.java

@@ -0,0 +1,79 @@
+/*
+ * 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.settings;
+
+import com.google.android.apps.mytracks.Constants;
+import com.google.android.apps.mytracks.util.PreferencesUtils;
+import com.google.android.maps.mytracks.R;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
+import android.os.Bundle;
+import android.preference.CheckBoxPreference;
+
+/**
+ * An activity for accessing stats settings.
+ * 
+ * @author Jimmy Shih
+ */
+public class StatsSettingsActivity extends AbstractSettingsActivity {
+
+  /*
+   * 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) {
+          // Note that key can be null
+          if (PreferencesUtils.getKey(StatsSettingsActivity.this, R.string.metric_units_key)
+              .equals(key)) {
+            updateUi();
+          }
+        }
+      };
+
+  @SuppressWarnings("deprecation")
+  @Override
+  protected void onCreate(Bundle bundle) {
+    super.onCreate(bundle);
+    addPreferencesFromResource(R.xml.stats_settings);
+
+    getSharedPreferences(Constants.SETTINGS_NAME, Context.MODE_PRIVATE)
+        .registerOnSharedPreferenceChangeListener(sharedPreferenceChangeListener);
+  }
+
+  @Override
+  protected void onResume() {
+    super.onResume();
+    updateUi();
+  }
+
+  @SuppressWarnings("deprecation")
+  private void updateUi() {
+    CheckBoxPreference reportSpeedCheckBoxPreference = (CheckBoxPreference) findPreference(
+        getString(R.string.report_speed_key));
+    boolean metric = PreferencesUtils.getBoolean(
+        this, R.string.metric_units_key, PreferencesUtils.METRIC_UNITS_DEFAULT);
+    reportSpeedCheckBoxPreference.setSummaryOn(metric ? getString(R.string.description_speed_metric)
+        : getString(R.string.description_speed_imperial));
+    reportSpeedCheckBoxPreference.setSummaryOff(metric ? getString(R.string.description_pace_metric)
+        : getString(R.string.description_pace_imperial));
+  }
+}