diff --git a/MyTracks/res/layout/about.xml b/MyTracks/res/layout/about.xml index 56c721c37..771b707b1 100644 --- a/MyTracks/res/layout/about.xml +++ b/MyTracks/res/layout/about.xml @@ -36,7 +36,7 @@ limitations under the License. diff --git a/MyTracks/res/values/arrays.xml b/MyTracks/res/values/arrays.xml deleted file mode 100644 index f85c10136..000000000 --- a/MyTracks/res/values/arrays.xml +++ /dev/null @@ -1,280 +0,0 @@ - - - - - - 1 m - 2 m - 3 m - 4 m - 5 m (recommended) - 10 m - 100 m - - - - 3 ft - 6 ft - 10 ft - 13 ft - 16 ft (recommended) - 33 ft - 328 ft - - - - - 50 m - 100 m - 200 m (recommended) - 500 m - 1000 m - 5000 m - - - - 164 ft - 328 ft - 656 ft (recommended) - 1640 ft - 0.6 miles - 3.1 miles - - - - - battery miser (adaptive) - high accuracy (adaptive) - highest (recommended) - 2 s - 3 s - 4 s - 5 s - 10 s - 20 s - 30 s - 1 min - 2 min - 5 min - 10 min - 15 min - 30 min - - - - - 10 m (excellent GPS signal) - 20 m - 50 m - 100 m - 200 m (recommended) - 500 m - 1000 m - 2000 m - 5000 m (poor GPS signal) - - - - 33 ft (excellent GPS signal) - 66 ft - 165 ft - 328 ft - 656 ft (recommended) - 1640 ft - 0.6 miles - 1.2 miles - 3.1 miles (poor GPS signal) - - - - - Off - 100 km - 50 km - 25 km - 10 km - 5 km - 1 km - 60 min - 30 min - 15 min - 10 min - 5 min - 2 min - 1 min - - - - Off - 100 mi - 50 mi - 25 mi - 10 mi - 5 mi - 1 mi - 60 min - 30 min - 15 min - 10 min - 5 min - 2 min - 1 min - - - - - Never - 5 min - 10 min - 15 min - Always - - - - - unknown - mixed type - other - - running - street running - track running - trail running - walking - speed walking - hiking - trail hiking - off trail hiking - climbing - - cycling - road biking - mountain biking - track cycling - - skating - inline skating - skate boarding - - roller skiing (classic) - roller skiing (skate) - cross-country skiing (classic) - cross-country skiing (skate) - - snow shoeing - skiing - snow boarding - sled - ice sailing - - sailing - paddling - kayaking - rowing - motor boating - ferry - RC boat - surfing - wind surfing - kite surfing - water skiing - wake boarding - - airplane - seaplane - commercial airplane - helicopter - hot air balloon - blimp - RC airplane - RC helicopter - sky jumping - gliding - hang gliding - para gliding - - riding - horse back riding - donkey back riding - - driving car - driving bus - train - motor bike - dirt bike - ATV - - land sailing - frisbee - ultimate frisbee - - - - ATM - bank - bar - barbeque - building - bus stop - cafe - campfire - campground - church - coffee house - convenience store - drinking water - falling rocks - ferry - fire place - fire station - fishing - gas station - golf course - grocery store - hair dresser - harbor - hiking path - hotel - house - information - intersection - mail box - market - meeting point - opera - parking - post office - pothole - police station - railway crossing - restaurant - shopping - sight - store - swimming pool - telephone - theater - toilet - tourist information - tunnel - tree - waterfall - water fountain - way point - - - diff --git a/MyTracks/res/values/arrays_do_not_translate.xml b/MyTracks/res/values/arrays_do_not_translate.xml index d6c135966..457113c5a 100644 --- a/MyTracks/res/values/arrays_do_not_translate.xml +++ b/MyTracks/res/values/arrays_do_not_translate.xml @@ -136,5 +136,126 @@ limitations under the License. TCX + + @string/activity_type_airplane + @string/activity_type_atv + @string/activity_type_blimp + @string/activity_type_climbing + @string/activity_type_commercial_airplane + @string/activity_type_cross_country_skiing_classic + @string/activity_type_cross_country_skiing_skate + @string/activity_type_cycling + @string/activity_type_dirt_bike + @string/activity_type_donkey_back_riding + @string/activity_type_driving_bus + @string/activity_type_driving_car + @string/activity_type_ferry + @string/activity_type_frisbee + @string/activity_type_gliding + @string/activity_type_hang_gliding + @string/activity_type_helicopter + @string/activity_type_hiking + @string/activity_type_horse_back_riding + @string/activity_type_hot_air_balloon + @string/activity_type_ice_sailing + @string/activity_type_inline_skating + @string/activity_type_kayaking + @string/activity_type_kite_surfing + @string/activity_type_land_sailing + @string/activity_type_mixed_type + @string/activity_type_motor_bike + @string/activity_type_motor_boating + @string/activity_type_mountain_biking + @string/activity_type_off_trail_hiking + @string/activity_type_other + @string/activity_type_paddling + @string/activity_type_para_gliding + @string/activity_type_rc_airplane + @string/activity_type_rc_boat + @string/activity_type_rc_helicopter + @string/activity_type_riding + @string/activity_type_road_biking + @string/activity_type_roller_skiing_classic + @string/activity_type_roller_skiing_skate + @string/activity_type_rowing + @string/activity_type_running + @string/activity_type_sailing + @string/activity_type_seaplane + @string/activity_type_skate_boarding + @string/activity_type_skating + @string/activity_type_skiing + @string/activity_type_sky_jumping + @string/activity_type_sled + @string/activity_type_snow_boarding + @string/activity_type_snow_shoeing + @string/activity_type_speed_walking + @string/activity_type_street_running + @string/activity_type_surfing + @string/activity_type_track_cycling + @string/activity_type_track_running + @string/activity_type_trail_hiking + @string/activity_type_trail_running + @string/activity_type_train + @string/activity_type_ultimate_frisbee + @string/activity_type_unknown + @string/activity_type_wakeboarding + @string/activity_type_walking + @string/activity_type_water_skiing + @string/activity_type_wind_surfing + + + + @string/waypoint_type_atm + @string/waypoint_type_bank + @string/waypoint_type_bar + @string/waypoint_type_barbeque + @string/waypoint_type_building + @string/waypoint_type_bus_stop + @string/waypoint_type_cafe + @string/waypoint_type_campfire + @string/waypoint_type_campground + @string/waypoint_type_church + @string/waypoint_type_coffee_house + @string/waypoint_type_convenience_store + @string/waypoint_type_drinking_water + @string/waypoint_type_falling_rocks + @string/waypoint_type_ferry + @string/waypoint_type_fire_place + @string/waypoint_type_fire_station + @string/waypoint_type_fishing + @string/waypoint_type_gas_station + @string/waypoint_type_golf_course + @string/waypoint_type_grocery_store + @string/waypoint_type_hair_dresser + @string/waypoint_type_harbor + @string/waypoint_type_hiking_path + @string/waypoint_type_hotel + @string/waypoint_type_house + @string/waypoint_type_information + @string/waypoint_type_intersection + @string/waypoint_type_mail_box + @string/waypoint_type_market + @string/waypoint_type_meeting_point + @string/waypoint_type_opera + @string/waypoint_type_parking + @string/waypoint_type_police_station + @string/waypoint_type_post_office + @string/waypoint_type_pothole + @string/waypoint_type_railway_crossing + @string/waypoint_type_restaurant + @string/waypoint_type_shopping + @string/waypoint_type_sight + @string/waypoint_type_store + @string/waypoint_type_swimming_pool + @string/waypoint_type_telephone + @string/waypoint_type_theater + @string/waypoint_type_toilet + @string/waypoint_type_tourist_information + @string/waypoint_type_tree + @string/waypoint_type_tunnel + @string/waypoint_type_waterfall + @string/waypoint_type_water_fountain + @string/waypoint_type_way_point + diff --git a/MyTracks/res/values/do_not_translate.xml b/MyTracks/res/values/do_not_translate.xml index 5f4d8dec2..53ad3d74d 100644 --- a/MyTracks/res/values/do_not_translate.xml +++ b/MyTracks/res/values/do_not_translate.xml @@ -16,6 +16,8 @@ limitations under the License. --> + + My Tracks Track Recording Service @@ -24,21 +26,20 @@ limitations under the License. mytracks@googlegroups.com m.google.com/privacy - Copyright 2009 Google Inc. Bartłomiej Niechwiej Dylan Casey Leif Hendrik Wilden Rodrigo Damazio Bovendorp Sandor Dornbush - + NONE ANT SRM_ANT_BRIDGE POLAR ZEPHYR - + NONE FIXED DYNAMIC @@ -51,19 +52,21 @@ limitations under the License. maps.google.com docs.google.com - + UA-7222692-2 - - - % - + + % + + android.intent.action.SAVE com.google.android.apps.mytracks.START_NEW_TRACK - com.google.android.apps.mytracks.END_CURRENT_TRACK - + + com.google.android.apps.mytracks.END_CURRENT_TRACK + - - - com.google.android.apps.mytracks.MYTRACKS_NOTIFICATIONS + + + com.google.android.apps.mytracks.MYTRACKS_NOTIFICATIONS + diff --git a/MyTracks/res/values/keys.xml b/MyTracks/res/values/keys.xml index 2afe45313..1087f589e 100644 --- a/MyTracks/res/values/keys.xml +++ b/MyTracks/res/values/keys.xml @@ -19,10 +19,8 @@ limitations under the License. allowAccess announcementFrequency antHeartRateSensorId - antPowerSensorId antSRMBridgeSensorId autoResumeTrackTimeout - bluetoothDevice bluetoothPairing bluetoothSensor defaultActivity @@ -32,7 +30,6 @@ limitations under the License. minRecordingDistance minRecordingInterval minRequiredAccuracy - modularStatsDisplay pickExistingMap reportSpeed sendToDocs diff --git a/MyTracks/res/values/strings.xml b/MyTracks/res/values/strings.xml index dfced7cff..5a0f9168b 100644 --- a/MyTracks/res/values/strings.xml +++ b/MyTracks/res/values/strings.xml @@ -17,9 +17,13 @@ limitations under the License. + + Copyright 2009 Google Inc. + + translation_description="In the 'About' page, the button on the bottom to view the terms of + service agreement."> License + + + airplane + + + ATV + + + blimp + + + climbing + + + commercial airplane + + + cross-country skiing (classic) + + + cross-country skiing (skate) + + + cycling + + + dirt bike + + + donkey back riding + + + driving bus + + + driving car + + + ferry + + + frisbee + + + gliding + + + hang gliding + + + helicopter + + + hiking + + + horse back riding + + + hot air balloon + + + ice sailing + + + inline skating + + + kayaking + + + kite surfing + + + land sailing + + + mixed type + + + motor bike + + + motor boating + + + mountain biking + + + off trail hiking + + + other + + + paddling + + + para gliding + + + RC airplane + + + RC boat + + + RC helicopter + + + riding + + + road biking + + + roller skiing (classic) + + + roller skiing (skate) + + + rowing + + + running + + + sailing + + + seaplane + + + skate boarding + + + skating + + + skiing + + + sky jumping + + + sled + + + snow boarding + + + snow shoeing + + + speed walking + + + street running + + + surfing + + + track cycling + + + track running + + + trail hiking + + + trail running + + + train + + + ultimate frisbee + + + unknown + + + wakeboarding + + + walking + + + water skiing + + + wind surfing + + Bluetooth Options @@ -1466,6 +1739,91 @@ limitations under the License. W + + + adapt for accuracy + + + adapt for battery life + + + Always + + + %.1f mi + + + %.1f mi (poor GPS) + + + %d ft + + + %d ft (excellent GPS) + + + %d ft (recommended) + + + %d km + + + %d m + + + %d m (excellent GPS) + + + %d m (poor GPS) + + + %d m (recommended) + + + %d mi + + + %d min + + + %d s + + + Never + + + Off + + + smallest (recommended) + + @@ -1534,10 +1892,216 @@ limitations under the License. %3$s: Time value (E.g., 2 hours and 30 minutes) %4$s: Speed value (E.g., 2.2) or pace value (E.g., 2 hours and 30 minutes) %5$s: Speed unit (miles per hour or kilometers per hour) or pace unit (per mile or per - kilometer)"> + kilometer)"> My Tracks total distance %1$.2f %2$s in %3$s at %4$s %5$s + + + ATM + + + bank + + + bar + + + barbeque + + + building + + + bus stop + + + cafe + + + campfire + + + campground + + + church + + + coffee house + + + convenience store + + + drinking water + + + falling rocks + + + ferry + + + fire place + + + fire station + + + fishing + + + gas station + + + golf course + + + grocery store + + + hair dresser + + + harbor + + + hiking path + + + hotel + + + house + + + information + + + intersection + + + mail box + + + market + + + meeting point + + + opera + + + parking + + + police station + + + post office + + + pothole + + + railway crossing + + + restaurant + + + shopping + + + sight + + + store + + + swimming pool + + + telephone + + + theater + + + toilet + + + tourist information + + + tree + + + tunnel + + + waterfall + + + water fountain + + + way point + + @@ -100,7 +99,6 @@ limitations under the License. android:key="@string/split_frequency_key" android:title="@string/settings_recording_marker" android:summary="@string/settings_recording_marker_summary" - android:entries="@array/task_frequency_options" android:entryValues="@array/task_frequency_values" android:defaultValue="0" /> @@ -108,7 +106,6 @@ limitations under the License. android:key="@string/min_recording_interval_key" android:title="@string/settings_recording_interval" android:summary="@string/settings_recording_interval_summary" - android:entries="@array/min_recording_interval_options" android:entryValues="@array/min_recording_interval_values" android:defaultValue="0" /> @@ -116,7 +113,6 @@ limitations under the License. android:key="@string/min_recording_distance_key" android:title="@string/settings_recording_distance" android:summary="@string/settings_recording_distance_summary" - android:entries="@array/min_recording_distance_options" android:entryValues="@array/min_recording_distance_values" android:defaultValue="5" /> @@ -124,7 +120,6 @@ limitations under the License. android:key="@string/max_recording_distance_key" android:title="@string/settings_recording_track_distance" android:summary="@string/settings_recording_track_distance_summary" - android:entries="@array/max_recording_distance_options" android:entryValues="@array/max_recording_distance_values" android:defaultValue="200" /> @@ -132,7 +127,6 @@ limitations under the License. android:key="@string/min_required_accuracy_key" android:title="@string/settings_recording_gps_accuracy" android:summary="@string/settings_recording_gps_accuracy_summary" - android:entries="@array/min_required_accuracy_options" android:entryValues="@array/min_required_accuracy_values" android:defaultValue="200" /> @@ -140,7 +134,6 @@ limitations under the License. android:key="@string/auto_resume_track_timeout_key" android:title="@string/settings_recording_auto_resume" android:summary="@string/settings_recording_auto_resume_summary" - android:entries="@array/auto_resume_track_timeout_options" android:entryValues="@array/auto_resume_track_timeout_values" android:defaultValue="10" /> diff --git a/MyTracks/src/com/google/android/apps/mytracks/SettingsActivity.java b/MyTracks/src/com/google/android/apps/mytracks/SettingsActivity.java index 5d8d44255..6e46ed8a6 100644 --- a/MyTracks/src/com/google/android/apps/mytracks/SettingsActivity.java +++ b/MyTracks/src/com/google/android/apps/mytracks/SettingsActivity.java @@ -59,6 +59,39 @@ import java.util.Set; */ public class SettingsActivity extends PreferenceActivity { + // Value when the task frequency is off. + private static final String TASK_FREQUENCY_OFF = "0"; + + // Value when the recording interval is 'Adapt battery life'. + private static final String RECORDING_INTERVAL_ADAPT_BATTERY_LIFE = "-2"; + + // Value when the recording interval is 'Adapt accuracy'. + private static final String RECORDING_INTERVAL_ADAPT_ACCURACY = "-1"; + + // Value for the recommended recording interval. + private static final String RECORDING_INTERVAL_RECOMMENDED = "0"; + + // Value when the auto resume timeout is never. + private static final String AUTO_RESUME_TIMEOUT_NEVER = "0"; + + // Value when the auto resume timeout is always. + private static final String AUTO_RESUME_TIMEOUT_ALWAYS = "-1"; + + // Value for the recommended recording distance. + private static final String RECORDING_DISTANCE_RECOMMENDED = "5"; + + // Value for the recommended track distance. + private static final String TRACK_DISTANCE_RECOMMENDED = "200"; + + // Value for the recommended GPS accuracy. + private static final String GPS_ACCURACY_RECOMMENDED = "200"; + + // Value when the GPS accuracy is for excellent GPS signal. + private static final String GPS_ACCURACY_EXCELLENT = "10"; + + // Value when the GPS accuracy is for poor GPS signal. + private static final String GPS_ACCURACY_POOR = "5000"; + private BackupPreferencesListener backupListener; private SharedPreferences preferences; @@ -86,15 +119,18 @@ public class SettingsActivity extends PreferenceActivity { // Load the preferences to be displayed addPreferencesFromResource(R.xml.preferences); - // Disable TTS announcement preference if not available + // Disable voice announcement if not available if (!apiFeatures.hasTextToSpeech()) { IntegerListPreference announcementFrequency = (IntegerListPreference) findPreference( getString(R.string.announcement_frequency_key)); announcementFrequency.setEnabled(false); - announcementFrequency.setValue("-1"); + announcementFrequency.setValue(TASK_FREQUENCY_OFF); announcementFrequency.setSummary(R.string.settings_recording_voice_not_available); } + + setRecordingIntervalOptions(); + setAutoResumeTimeoutOptions(); // Hook up switching of displayed list entries between metric and imperial // units @@ -107,11 +143,11 @@ public class SettingsActivity extends PreferenceActivity { public boolean onPreferenceChange(Preference preference, Object newValue) { boolean isMetric = (Boolean) newValue; - updatePreferenceUnits(isMetric); + updateDisplayOptions(isMetric); return true; } }); - updatePreferenceUnits(metricUnitsPreference.isChecked()); + updateDisplayOptions(metricUnitsPreference.isChecked()); customizeSensorOptionsPreferences(); customizeTrackColorModePreferences(); @@ -126,7 +162,7 @@ public class SettingsActivity extends PreferenceActivity { } }); - // Add a confirmation dialog for the "Allow access" preference. + // Add a confirmation dialog for the 'Allow access' preference. final CheckBoxPreference allowAccessPreference = (CheckBoxPreference) findPreference( getString(R.string.allow_access_key)); allowAccessPreference.setOnPreferenceChangeListener(new OnPreferenceChangeListener() { @@ -154,6 +190,58 @@ public class SettingsActivity extends PreferenceActivity { }); } + /** + * Sets the display options for the 'Time between points' option. + */ + private void setRecordingIntervalOptions() { + String[] values = getResources().getStringArray(R.array.min_recording_interval_values); + String[] options = new String[values.length]; + for (int i = 0; i < values.length; i++) { + if (values[i].equals(RECORDING_INTERVAL_ADAPT_BATTERY_LIFE)) { + options[i] = getString(R.string.value_adapt_battery_life); + } else if (values[i].equals(RECORDING_INTERVAL_ADAPT_ACCURACY)) { + options[i] = getString(R.string.value_adapt_accuracy); + } else if (values[i].equals(RECORDING_INTERVAL_RECOMMENDED)) { + options[i] = getString(R.string.value_smallest_recommended); + } else { + int value = Integer.parseInt(values[i]); + String format; + if (value < 60) { + format = getString(R.string.value_integer_second); + } else { + value = value / 60; + format = getString(R.string.value_integer_minute); + } + options[i] = String.format(format, value); + } + } + ListPreference list = (ListPreference) findPreference( + getString(R.string.min_recording_interval_key)); + list.setEntries(options); + } + + /** + * Sets the display options for the 'Auto-resume timeout' option. + */ + private void setAutoResumeTimeoutOptions() { + 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++) { + if (values[i].equals(AUTO_RESUME_TIMEOUT_NEVER)) { + options[i] = getString(R.string.value_never); + } else if (values[i].equals(AUTO_RESUME_TIMEOUT_ALWAYS)) { + options[i] = getString(R.string.value_always); + } else { + int value = Integer.parseInt(values[i]); + String format = getString(R.string.value_integer_minute); + options[i] = String.format(format, value); + } + } + ListPreference list = (ListPreference) findPreference( + getString(R.string.auto_resume_track_timeout_key)); + list.setEntries(options); + } + private void customizeSensorOptionsPreferences() { ListPreference sensorTypePreference = (ListPreference) findPreference(getString(R.string.sensor_type_key)); @@ -217,11 +305,13 @@ public class SettingsActivity extends PreferenceActivity { setTrackColorModePreferenceListeners(); - PreferenceCategory speedOptionsCategory = - (PreferenceCategory) findPreference(getString(R.string.track_color_mode_fixed_speed_options_key)); + PreferenceCategory speedOptionsCategory = (PreferenceCategory) findPreference( + getString(R.string.track_color_mode_fixed_speed_options_key)); - speedOptionsCategory.removePreference(findPreference(getString(R.string.track_color_mode_fixed_speed_slow_key))); - speedOptionsCategory.removePreference(findPreference(getString(R.string.track_color_mode_fixed_speed_medium_key))); + speedOptionsCategory.removePreference( + findPreference(getString(R.string.track_color_mode_fixed_speed_slow_key))); + speedOptionsCategory.removePreference( + findPreference(getString(R.string.track_color_mode_fixed_speed_medium_key))); } @Override @@ -305,56 +395,161 @@ public class SettingsActivity extends PreferenceActivity { } private void updateTrackColorModeSettings(String trackColorMode) { - boolean usesFixedSpeed = trackColorMode.equals(getString(R.string.track_color_mode_value_fixed)); - boolean usesDynamicSpeed = trackColorMode.equals(getString(R.string.track_color_mode_value_dynamic)); - - findPreference( - getString(R.string.track_color_mode_fixed_speed_slow_display_key)).setEnabled(usesFixedSpeed); - findPreference( - getString(R.string.track_color_mode_fixed_speed_medium_display_key)).setEnabled(usesFixedSpeed); - findPreference( - getString(R.string.track_color_mode_dynamic_speed_variation_key)).setEnabled(usesDynamicSpeed); + boolean usesFixedSpeed = trackColorMode.equals( + getString(R.string.track_color_mode_value_fixed)); + boolean usesDynamicSpeed = trackColorMode.equals( + getString(R.string.track_color_mode_value_dynamic)); + + findPreference(getString(R.string.track_color_mode_fixed_speed_slow_display_key)) + .setEnabled(usesFixedSpeed); + findPreference(getString(R.string.track_color_mode_fixed_speed_medium_display_key)) + .setEnabled(usesFixedSpeed); + findPreference(getString(R.string.track_color_mode_dynamic_speed_variation_key)) + .setEnabled(usesDynamicSpeed); } /** - * Updates all the preferences which give options with distance units to use - * the proper unit the user has selected. + * Updates display options that depends on the preferred distance units, metric or imperial. * * @param isMetric true to use metric units, false to use imperial */ - private void updatePreferenceUnits(boolean isMetric) { - final ListPreference minRecordingDistance = - (ListPreference) findPreference( - getString(R.string.min_recording_distance_key)); - final ListPreference maxRecordingDistance = - (ListPreference) findPreference( - getString(R.string.max_recording_distance_key)); - final ListPreference minRequiredAccuracy = - (ListPreference) findPreference( - getString(R.string.min_required_accuracy_key)); - - minRecordingDistance.setEntries(isMetric - ? R.array.min_recording_distance_options - : R.array.min_recording_distance_options_ft); - maxRecordingDistance.setEntries(isMetric - ? R.array.max_recording_distance_options - : R.array.max_recording_distance_options_ft); - minRequiredAccuracy.setEntries(isMetric - ? R.array.min_required_accuracy_options - : R.array.min_required_accuracy_options_ft); + private void updateDisplayOptions(boolean isMetric) { setTaskOptions(isMetric, R.string.announcement_frequency_key); setTaskOptions(isMetric, R.string.split_frequency_key); + setRecordingDistanceOptions(isMetric, R.string.min_recording_distance_key); + setTrackDistanceOptions(isMetric, R.string.max_recording_distance_key); + setGpsAccuracyOptions(isMetric, R.string.min_required_accuracy_key); } /** - * Set the user visible options for a periodic task. + * Sets the display options for a periodic task. */ private void setTaskOptions(boolean isMetric, int listId) { - final ListPreference taskFrequency = - (ListPreference) findPreference(getString(listId)); - taskFrequency.setEntries(isMetric - ? R.array.task_frequency_options - : R.array.task_frequency_options_ft); + String[] values = getResources().getStringArray(R.array.task_frequency_values); + String[] options = new String[values.length]; + for (int i = 0; i < values.length; i++) { + if (values[i].equals(TASK_FREQUENCY_OFF)) { + options[i] = getString(R.string.value_off); + } else if (values[i].startsWith("-")) { + int value = Integer.parseInt(values[i].substring(1)); + int stringId = isMetric ? R.string.value_integer_kilometer : R.string.value_integer_mile; + String format = getString(stringId); + options[i] = String.format(format, value); + } else { + int value = Integer.parseInt(values[i]); + String format = getString(R.string.value_integer_minute); + options[i] = String.format(format, value); + } + } + + ListPreference list = (ListPreference) findPreference(getString(listId)); + list.setEntries(options); + } + + /** + * Sets the display options for 'Distance between points' option. + */ + private void setRecordingDistanceOptions(boolean isMetric, int listId) { + 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 (!isMetric) { + value = (int) (value * UnitConversions.M_TO_FT); + } + String format; + if (values[i].equals(RECORDING_DISTANCE_RECOMMENDED)) { + int stringId = isMetric ? R.string.value_integer_meter_recommended + : R.string.value_integer_feet_recommended; + format = getString(stringId); + } else { + int stringId = isMetric ? R.string.value_integer_meter : R.string.value_integer_feet; + format = getString(stringId); + } + options[i] = String.format(format, value); + } + + ListPreference list = (ListPreference) findPreference(getString(listId)); + list.setEntries(options); + } + + /** + * Sets the display options for 'Distance between Tracks'. + */ + private void setTrackDistanceOptions(boolean isMetric, int listId) { + 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]); + String format; + if (isMetric) { + int stringId = values[i].equals(TRACK_DISTANCE_RECOMMENDED) + ? R.string.value_integer_meter_recommended : R.string.value_integer_meter; + format = getString(stringId); + options[i] = String.format(format, value); + } else { + value = (int) (value * UnitConversions.M_TO_FT); + if (value < 2000) { + int stringId = values[i].equals(TRACK_DISTANCE_RECOMMENDED) + ? R.string.value_integer_feet_recommended : R.string.value_integer_feet; + format = getString(stringId); + options[i] = String.format(format, value); + } else { + double mile = value / UnitConversions.MI_TO_FEET; + format = getString(R.string.value_float_mile); + options[i] = String.format(format, mile); + } + } + } + + ListPreference list = (ListPreference) findPreference(getString(listId)); + list.setEntries(options); + } + + /** + * Sets the display options for 'GPS accuracy'. + */ + private void setGpsAccuracyOptions(boolean isMetric, int listId) { + 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]); + String format; + if (isMetric) { + if (values[i].equals(GPS_ACCURACY_RECOMMENDED)) { + format = getString(R.string.value_integer_meter_recommended); + } else if (values[i].equals(GPS_ACCURACY_EXCELLENT)) { + format = getString(R.string.value_integer_meter_excellent_gps); + } else if (values[i].equals(GPS_ACCURACY_POOR)) { + format = getString(R.string.value_integer_meter_poor_gps); + } else { + format = getString(R.string.value_integer_meter); + } + options[i] = String.format(format, value); + } else { + value = (int) (value * UnitConversions.M_TO_FT); + if (value < 2000) { + if (values[i].equals(GPS_ACCURACY_RECOMMENDED)) { + format = getString(R.string.value_integer_feet_recommended); + } else if (values[i].equals(GPS_ACCURACY_EXCELLENT)) { + format = getString(R.string.value_integer_feet_excellent_gps); + } else { + format = getString(R.string.value_integer_feet); + } + options[i] = String.format(format, value); + } else { + double mile = value / UnitConversions.MI_TO_FEET; + if (values[i].equals(GPS_ACCURACY_POOR)) { + format = getString(R.string.value_float_mile_poor_gps); + } else { + format = getString(R.string.value_float_mile); + } + options[i] = String.format(format, mile); + } + } + } + ListPreference list = (ListPreference) findPreference(getString(listId)); + list.setEntries(options); } /** @@ -478,7 +673,8 @@ public class SettingsActivity extends PreferenceActivity { if(!metricUnitsPreference.isChecked()) { // Convert miles/h to km/h try { - metricspeed = String.valueOf((int) (Double.parseDouble(newValue) * UnitConversions.MPH_TO_KMH) + 1); + metricspeed = String.valueOf( + (int) (Double.parseDouble(newValue) * UnitConversions.MPH_TO_KMH) + 1); } catch (NumberFormatException e) { metricspeed = "0"; }