I think i have done the commit correctly, althought i only had to correct manually keys.xml (add new key from the head branch xml to mine)

MyTracks/src/com/google/android/apps/mytracks/ColoredPath.java

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.android.apps.mytracks;
+
+import android.graphics.Paint;
+import android.graphics.Path;
+
+/**
+ * Represents a colored {@code Path} to save its relative color for drawing.
+ * @author Vangelis S.
+ */
+public class ColoredPath {
+  private final Path path;
+  private final Paint pathPaint;
+
+  /**
+   * Constructor for a ColoredPath by color.
+   */
+  public ColoredPath(int color) {
+      path = new Path();
+      pathPaint = new Paint();
+      pathPaint.setColor(color);
+      pathPaint.setStrokeWidth(3);
+      pathPaint.setStyle(Paint.Style.STROKE);
+      pathPaint.setAntiAlias(true);
+  }
+  
+  /**
+   * Constructor for a ColoredPath by Paint.
+   */
+  public ColoredPath(Paint paint) {
+      path = new Path();
+      pathPaint = paint;
+  }
+  
+  /**
+   * @return the path
+   */
+  public Path getPath() {
+    return path;
+  }
+  
+  /**
+   * @return the pathPaint
+   */
+  public Paint getPathPaint() {
+    return pathPaint;
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/ImportAllTracks.java

@@ -217,4 +217,4 @@ public class ImportAllTracks {
     }
     return gpxFiles;
   }
-}
+}

MyTracks/src/com/google/android/apps/mytracks/MapOverlay.java

@@ -18,6 +18,9 @@ package com.google.android.apps.mytracks;
 import static com.google.android.apps.mytracks.Constants.TAG;
 
 import com.google.android.apps.mytracks.content.Waypoint;
+import com.google.android.apps.mytracks.maps.TrackPathPainter;
+import com.google.android.apps.mytracks.maps.TrackPathPainterFactory;
+import com.google.android.apps.mytracks.maps.TrackPathUtilities;
 import com.google.android.apps.mytracks.util.LocationUtils;
 import com.google.android.maps.GeoPoint;
 import com.google.android.maps.MapView;
@@ -27,6 +30,8 @@ import com.google.android.maps.mytracks.R;
 
 import android.content.Context;
 import android.content.Intent;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
 import android.content.res.Resources;
 import android.graphics.Canvas;
 import android.graphics.Paint;
@@ -48,7 +53,7 @@ import java.util.concurrent.BlockingQueue;
  *
  * @author Leif Hendrik Wilden
  */
-public class MapOverlay extends Overlay {
+public class MapOverlay extends Overlay implements OnSharedPreferenceChangeListener {
 
   private final Drawable[] arrows;
   private final int arrowWidth, arrowHeight;
@@ -57,7 +62,6 @@ public class MapOverlay extends Overlay {
   private final Drawable startMarker;
   private final Drawable endMarker;
   private final int markerWidth, markerHeight;
-  private final Paint selectedTrackPaint;
   private final Paint errorCirclePaint;
   private final Context context;
   private final List<Waypoint> waypoints;
@@ -73,22 +77,26 @@ public class MapOverlay extends Overlay {
 
   private GeoPoint lastReferencePoint;
   private Rect lastViewRect;
-  private Path lastPath;
+  private boolean lastPathExists;
+  private Location lastLocation;
+  private TrackPathPainter trackPathPainter;
 
   /**
    * Represents a pre-processed {@code Location} to speed up drawing.
    * This class is more like a data object and doesn't provide accessors.
    */
-  private static class CachedLocation {
+  public static class CachedLocation {
     public final boolean valid;
     public final GeoPoint geoPoint;
-
+    public final int speed;
+    
     /**
      * Constructor for an invalid cached location.
      */
     public CachedLocation() {
       this.valid = false;
       this.geoPoint = null;
+      this.speed = -1;
     }
 
     /**
@@ -97,6 +105,7 @@ public class MapOverlay extends Overlay {
     public CachedLocation(Location location) {
       this.valid = LocationUtils.isValidLocation(location);
       this.geoPoint = valid ? LocationUtils.getGeoPoint(location) : null;
+      this.speed = (int) Math.floor(location.getSpeed() * 3.6);
     }
   };
 
@@ -151,18 +160,13 @@ public class MapOverlay extends Overlay {
     waypointMarker = resources.getDrawable(R.drawable.blue_pushpin);
     waypointMarker.setBounds(0, 0, markerWidth, markerHeight);
 
-    selectedTrackPaint = new Paint();
-    selectedTrackPaint.setColor(resources.getColor(R.color.red));
-    selectedTrackPaint.setStrokeWidth(3);
-    selectedTrackPaint.setStyle(Paint.Style.STROKE);
-    selectedTrackPaint.setAntiAlias(true);
-
-    errorCirclePaint = new Paint();
-    errorCirclePaint.setColor(resources.getColor(R.color.blue));
-    errorCirclePaint.setStyle(Paint.Style.STROKE);
-    errorCirclePaint.setStrokeWidth(3);
+    errorCirclePaint = TrackPathUtilities.getPaint(R.color.blue, context);
     errorCirclePaint.setAlpha(127);
-    errorCirclePaint.setAntiAlias(true);
+    
+    trackPathPainter = TrackPathPainterFactory.getTrackPathPainter(context);
+    
+    context.getSharedPreferences(Constants.SETTINGS_NAME, 0)
+      .registerOnSharedPreferenceChangeListener(this);
   }
 
   /**
@@ -205,18 +209,19 @@ public class MapOverlay extends Overlay {
   }
 
   // Visible for testing.
-  int getNumWaypoints() {
+  public int getNumWaypoints() {
     synchronized (waypoints) {
       return waypoints.size();
     }
   }
 
   public void clearPoints() {
-    synchronized (points) {
-      points.clear();
+    synchronized (getPoints()) {
+      getPoints().clear();
       pendingPoints.clear();
-      lastPath = null;
+      lastPathExists = false;
       lastViewRect = null;
+      trackPathPainter.clear();
     }
   }
 
@@ -254,6 +259,9 @@ public class MapOverlay extends Overlay {
       // Draw the selected track:
       drawTrack(canvas, projection, viewRect);
 
+      // Draw the "Start" and "End" markers:
+      drawMarkers(canvas, projection);
+      
       // Draw the waypoints:
       drawWaypoints(canvas, projection);
     }
@@ -262,6 +270,28 @@ public class MapOverlay extends Overlay {
     drawMyLocation(canvas, projection);
   }
 
+  private void drawMarkers(Canvas canvas, Projection projection) {
+    // Draw the "End" marker.
+    if (showEndMarker) {
+      for (int i = getPoints().size() - 1; i >= 0; --i) {
+        if (getPoints().get(i).valid) {
+          drawElement(canvas, projection, getPoints().get(i).geoPoint, endMarker,
+              -markerWidth / 2, -markerHeight);
+          break;
+        }
+      }
+    }
+    
+    // Draw the "Start" marker.
+    for (int i = 0; i < getPoints().size(); ++i) {
+      if (getPoints().get(i).valid) {
+        drawElement(canvas, projection, getPoints().get(i).geoPoint, startMarker,
+            -markerWidth / 2, -markerHeight);
+        break;
+      }
+    }
+  }
+  
   // Visible for testing.
   Projection getMapProjection(MapView mapView) {
     return mapView.getProjection();
@@ -282,10 +312,10 @@ public class MapOverlay extends Overlay {
   }
 
   // Visible for testing.
-  Path getLastPath() {
-    return lastPath;
+  public Path getLastPath() {
+    return trackPathPainter.getLastPath();
   }
-
+  
   private void drawWaypoints(Canvas canvas, Projection projection) {
     synchronized (waypoints) {;
       for (Waypoint wpt : waypoints) {
@@ -311,96 +341,39 @@ public class MapOverlay extends Overlay {
     canvas.drawCircle(pt.x, pt.y, radius, errorCirclePaint);
   }
 
-  private void drawTrack(Canvas canvas, Projection projection, Rect viewRect) {
-    Path path;
+  private void drawTrack(Canvas canvas, Projection projection, Rect viewRect)
+  {
+    boolean draw;
+
     synchronized (points) {
       // Merge the pending points with the list of cached locations.
       final GeoPoint referencePoint = projection.fromPixels(0, 0);
-      int newPoints = pendingPoints.drainTo(points);
+      int newPoints = pendingPoints.drainTo(points); 
       boolean newProjection = !viewRect.equals(lastViewRect) ||
-          !referencePoint.equals(lastReferencePoint);
-      if (newPoints == 0 && lastPath != null && !newProjection) {
+          !referencePoint.equals(lastReferencePoint); 
+      if (newPoints == 0 && lastPathExists && !newProjection) {
         // No need to recreate path (same points and viewing area).
-        path = lastPath;
+        draw = true;
       } else {
         int numPoints = points.size();
         if (numPoints < 2) {
           // Not enough points to draw a path.
-          path = null;
-        } else if (lastPath != null && !newProjection) {
+          draw = false;
+        } else if (!trackPathPainter.needsRedraw() && lastPathExists && !newProjection) {
           // Incremental update of the path, without repositioning the view.
-          path = lastPath;
-          updatePath(projection, viewRect, path, numPoints - newPoints);
+          draw = true;
+          trackPathPainter.updatePath(projection, viewRect, numPoints - newPoints, alwaysVisible, points);  
         } else {
           // The view has changed so we have to start from scratch.
-          path = newPath();
-          path.incReserve(numPoints);
-          updatePath(projection, viewRect, path, 0);
+          draw = true;
+          trackPathPainter.updatePath(projection, viewRect, 0, alwaysVisible, points);  
         }
-        lastPath = path;
       }
       lastReferencePoint = referencePoint;
       lastViewRect = viewRect;
     }
-    if (path != null) {
-      canvas.drawPath(path, selectedTrackPaint);
-    }
-
-    // Draw the "End" marker.
-    if (showEndMarker) {
-      for (int i = points.size() - 1; i >= 0; --i) {
-        if (points.get(i).valid) {
-          drawElement(canvas, projection, points.get(i).geoPoint, endMarker,
-              -markerWidth / 2, -markerHeight);
-          break;
-        }
-      }
-    }
-
-    // Draw the "Start" marker.
-    for (int i = 0; i < points.size(); ++i) {
-      if (points.get(i).valid) {
-        drawElement(canvas, projection, points.get(i).geoPoint, startMarker,
-            -markerWidth / 2, -markerHeight);
-        break;
-      }
-    }
-  }
-
-  private void updatePath(Projection projection, Rect viewRect, Path path,
-      int startLocationIdx) {
-    // Whether to start a new segment on new valid and visible point.
-    boolean newSegment =
-        startLocationIdx > 0 ? !points.get(startLocationIdx - 1).valid : true;
-    boolean lastVisible = !newSegment;
-    final Point pt = new Point();
-    // Loop over track points.
-    for (int i = startLocationIdx; i < points.size(); ++i) {
-      CachedLocation loc = points.get(i);
-      // Check if valid, if not then indicate a new segment.
-      if (!loc.valid) {
-        newSegment = true;
-        continue;
-      }
-
-      final GeoPoint geoPoint = loc.geoPoint;
-      // Check if this breaks the existing segment.
-      boolean visible = alwaysVisible || viewRect.contains(
-          geoPoint.getLongitudeE6(), geoPoint.getLatitudeE6());
-      if (!visible && !lastVisible) {
-        // This is a point outside view not connected to a visible one.
-        newSegment = true;
-      }
-      lastVisible = visible;
-
-      // Either move to beginning of a new segment or continue the old one.
-      projection.toPixels(geoPoint, pt);
-      if (newSegment) {
-        path.moveTo(pt.x, pt.y);
-        newSegment = false;
-      } else {
-        path.lineTo(pt.x, pt.y);
-      }
+    if (draw) {
+      trackPathPainter.drawTrack(canvas);
     }
   }
 
@@ -479,4 +452,21 @@ public class MapOverlay extends Overlay {
     }
     return super.onTap(p, mapView);
   }
+  
+  /**
+   * @return the points
+   */
+  public List<CachedLocation> getPoints() {
+    return points;
+  }
+  
+  @Override
+  public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
+    Log.d(TAG, "MapOverlay: onSharedPreferences changed " + key);
+    if (key != null) {
+      if (key.equals(context.getString(R.string.track_color_mode_key))) {
+        trackPathPainter = TrackPathPainterFactory.getTrackPathPainter(context);
+      }
+    }
+  }
 }

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

@@ -23,6 +23,7 @@ import com.google.android.apps.mytracks.services.sensors.ant.AntUtils;
 import com.google.android.apps.mytracks.services.tasks.StatusAnnouncerFactory;
 import com.google.android.apps.mytracks.util.ApiFeatures;
 import com.google.android.apps.mytracks.util.BluetoothDeviceUtils;
+import com.google.android.apps.mytracks.util.UnitConversions;
 import com.google.android.maps.mytracks.R;
 
 import android.app.AlertDialog;
@@ -32,11 +33,13 @@ import android.content.Intent;
 import android.content.SharedPreferences;
 import android.os.Bundle;
 import android.preference.CheckBoxPreference;
+import android.preference.EditTextPreference;
 import android.preference.ListPreference;
 import android.preference.Preference;
 import android.preference.Preference.OnPreferenceChangeListener;
 import android.preference.Preference.OnPreferenceClickListener;
 import android.preference.PreferenceActivity;
+import android.preference.PreferenceCategory;
 import android.preference.PreferenceManager;
 import android.preference.PreferenceScreen;
 import android.provider.Settings;
@@ -128,7 +131,8 @@ public class SettingsActivity extends PreferenceActivity {
     updatePreferenceUnits(metricUnitsPreference.isChecked());
 
     customizeSensorOptionsPreferences();
-
+    customizeTrackColorModePreferences();
+    
     // Hook up action for resetting all settings
     Preference resetPreference = findPreference(getString(R.string.reset_key));
     resetPreference.setOnPreferenceClickListener(new OnPreferenceClickListener() {
@@ -203,6 +207,29 @@ public class SettingsActivity extends PreferenceActivity {
       sensorOptionsScreen.removePreference(findPreference(getString(R.string.ant_options_key)));
     }
   }
+  
+  private void customizeTrackColorModePreferences() {
+    ListPreference trackColorModePreference =
+        (ListPreference) findPreference(getString(R.string.track_color_mode_key));
+    trackColorModePreference.setOnPreferenceChangeListener(
+        new OnPreferenceChangeListener() {
+          @Override
+          public boolean onPreferenceChange(Preference preference,
+              Object newValue) {
+            updateTrackColorModeSettings((String) newValue);
+            return true;
+          }
+        });
+    updateTrackColorModeSettings(trackColorModePreference.getValue());
+    
+    setTrackColorModePreferenceListeners();
+    
+    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)));
+  }
 
   @Override
   protected void onResume() {
@@ -288,6 +315,18 @@ public class SettingsActivity extends PreferenceActivity {
     }
   }
 
+  private void updateTrackColorModeSettings(String trackColorMode) {
+    boolean usesFixedSpeed = trackColorMode.equals(getString(R.string.track_color_mode_fixed));
+    boolean usesDynamicSpeed = trackColorMode.equals(getString(R.string.track_color_mode_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.
@@ -416,4 +455,84 @@ public class SettingsActivity extends PreferenceActivity {
       }
     }.start();
   }
+  
+  /** 
+   * Set the given edit text preference text.
+   * If the units are not metric convert the value before displaying.  
+   */
+  private void viewTrackColorModeSettings(EditTextPreference preference, int id) {
+    CheckBoxPreference metricUnitsPreference = (CheckBoxPreference) findPreference(
+        getString(R.string.metric_units_key));
+    if(metricUnitsPreference.isChecked()) {
+      return;
+    }
+    // Convert miles/h to km/h
+    SharedPreferences prefs = getPreferenceManager().getSharedPreferences();
+    String metricspeed = prefs.getString(getString(id), null);
+    int englishspeed;
+    try {
+      englishspeed = (int) (Double.parseDouble(metricspeed) * UnitConversions.KMH_TO_MPH);
+    } catch (NumberFormatException e) {
+      englishspeed = 0;
+    }
+    preference.getEditText().setText(String.valueOf(englishspeed));
+  }
+  
+  /** 
+   * Saves the given edit text preference value.
+   * If the units are not metric convert the value before saving.  
+   */
+  private void validateTrackColorModeSettings(EditTextPreference preference, 
+      String newValue, int id) {
+    CheckBoxPreference metricUnitsPreference = (CheckBoxPreference) findPreference(
+        getString(R.string.metric_units_key));
+    String metricspeed;
+    if(!metricUnitsPreference.isChecked()) {
+      // Convert miles/h to km/h
+      try {
+        metricspeed = String.valueOf((int) (Double.parseDouble(newValue) * UnitConversions.MPH_TO_KMH) + 1);
+      } catch (NumberFormatException e) {
+        metricspeed = "0";
+      }
+    } else {
+      metricspeed = newValue;
+    }
+    SharedPreferences prefs = getPreferenceManager().getSharedPreferences();
+    prefs.edit().putString(getString(id), metricspeed).commit();
+  }
+  
+  /** 
+   * Sets the TrackColorMode preference listeners.
+   */
+  private void setTrackColorModePreferenceListeners() {
+    setTrackColorModePreferenceListener(R.string.track_color_mode_fixed_speed_slow_display_key,
+        R.string.track_color_mode_fixed_speed_slow_key);
+    setTrackColorModePreferenceListener(R.string.track_color_mode_fixed_speed_medium_display_key,
+        R.string.track_color_mode_fixed_speed_medium_key);
+  }
+  
+  /** 
+   * Sets a TrackColorMode preference listener.
+   */
+  private void setTrackColorModePreferenceListener(int displayKey, final int metricKey) {
+    EditTextPreference trackColorModePreference =
+        (EditTextPreference) findPreference(getString(displayKey));
+    trackColorModePreference.setOnPreferenceChangeListener(
+        new OnPreferenceChangeListener() {
+          @Override
+          public boolean onPreferenceChange(Preference preference,
+              Object newValue) {
+            validateTrackColorModeSettings((EditTextPreference) preference, (String) newValue, metricKey);
+            return true;
+          }
+        });
+    trackColorModePreference.setOnPreferenceClickListener(
+        new OnPreferenceClickListener() {
+          @Override
+          public boolean onPreferenceClick(Preference preference) {
+            viewTrackColorModeSettings((EditTextPreference) preference, metricKey);
+            return true;
+          }
+        });
+  }
 }

MyTracks/src/com/google/android/apps/mytracks/maps/DynamicSpeedTrackPathDescriptor.java

@@ -0,0 +1,129 @@
+/*
+ * 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.maps;
+
+import static com.google.android.apps.mytracks.Constants.TAG;
+
+import com.google.android.apps.mytracks.Constants;
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils;
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.stats.TripStatistics;
+import com.google.android.maps.mytracks.R;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
+import android.util.Log;
+
+
+/**
+ * A dynamic speed path descriptor.
+ *
+ * @author Vangelis S.
+ */
+public class DynamicSpeedTrackPathDescriptor 
+  implements TrackPathDescriptor, OnSharedPreferenceChangeListener {
+  private int slowSpeed;
+  private int normalSpeed;
+  private int speedMargin;
+  private double averageMovingSpeed;
+  private final Context context;
+  
+  public DynamicSpeedTrackPathDescriptor(Context context){
+    this.context = context;
+    SharedPreferences prefs = context.getSharedPreferences(Constants.SETTINGS_NAME, 0);
+
+    if (prefs == null) {
+      speedMargin = 25;
+      return;
+    }
+    prefs.registerOnSharedPreferenceChangeListener(this);
+
+    speedMargin = Integer.parseInt(prefs.getString(
+        context.getString(R.string.track_color_mode_dynamic_speed_variation_key), "25"));
+  }
+  
+  /**
+   * Get the slow speed calculated based on the % below the average speed.
+   * @return The speed limit considered as slow.
+   */
+  public int getSlowSpeed()
+  {
+    slowSpeed = (int) (averageMovingSpeed - (averageMovingSpeed * speedMargin / 100)); 
+    return slowSpeed;
+  }
+  
+  /**
+   * Get the medium speed calculated based on the % above the average speed.
+   * @return The speed limit considered as normal.
+   */
+  public int getNormalSpeed()
+  {
+    normalSpeed = (int) (averageMovingSpeed + (averageMovingSpeed * speedMargin / 100)); 
+    return normalSpeed;
+  }
+  
+  @Override
+  public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
+    Log.d(TAG, "DynamicSpeedTrackPathDescriptor: onSharedPreferences changed " + key);
+    if (key == null 
+    	|| !key.equals(context.getString(R.string.track_color_mode_dynamic_speed_variation_key))) {
+      return;
+    }
+    SharedPreferences prefs = context.getSharedPreferences(Constants.SETTINGS_NAME, 0);
+    	
+    if (prefs == null) {
+      speedMargin = 25;
+      return;
+    }
+        
+    speedMargin = 
+        Integer.parseInt(
+    	    prefs.getString(
+    	        context.getString(R.string.track_color_mode_dynamic_speed_variation_key), "25"));
+    }
+
+  @Override
+  public boolean needsRedraw() {
+    SharedPreferences prefs = context.getSharedPreferences(Constants.SETTINGS_NAME, 0);
+    long currentTrackId = prefs.getLong(context.getString(R.string.selected_track_key), -1);
+    if(currentTrackId == -1) {
+      // Could not find track. 
+      return false; 
+    }
+    Track track = MyTracksProviderUtils.Factory.get(context).getTrack(currentTrackId);
+    TripStatistics stats = track.getStatistics();
+    double newaverageSpeed = (int) Math.floor(stats.getAverageMovingSpeed() * 3.6);
+    
+    if(averageMovingSpeed == 0) {
+      averageMovingSpeed = newaverageSpeed;
+      return true;
+    }
+    
+    double difference = Math.max(averageMovingSpeed, newaverageSpeed);
+
+    if (difference == 0.0) {
+      difference = 0.0;
+    } else {
+      difference = Math.abs(averageMovingSpeed - newaverageSpeed) / difference * 100;
+    }
+    if(difference >= 20) {
+      averageMovingSpeed = newaverageSpeed;
+      return true;
+    }
+    return false;
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/maps/DynamicSpeedTrackPathPainter.java

@@ -0,0 +1,141 @@
+/*
+ * 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.maps;
+
+import com.google.android.apps.mytracks.ColoredPath;
+import com.google.android.apps.mytracks.MapOverlay.CachedLocation;
+import com.google.android.maps.GeoPoint;
+import com.google.android.maps.Projection;
+import com.google.android.maps.mytracks.R;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.Path;
+import android.graphics.Point;
+import android.graphics.Rect;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A path painter that varies the path colors based on fixed speeds or average speed margin
+ * depending of the TrackPathDescriptor passed to its constructor.
+ * 
+ *  @author Vangelis S.
+ */
+public class  DynamicSpeedTrackPathPainter implements TrackPathPainter {
+  private final Paint selectedTrackPaintSlow;
+  private final Paint selectedTrackPaintMedium;
+  private final Paint selectedTrackPaintFast;
+  private final List<ColoredPath> coloredPaths;
+  private final TrackPathDescriptor trackPathDescriptor;
+  private int slowSpeed;
+  private int normalSpeed;
+  
+  public DynamicSpeedTrackPathPainter (Context context, TrackPathDescriptor trackPathDescriptor) {
+    this.trackPathDescriptor = trackPathDescriptor;
+    
+    selectedTrackPaintSlow = TrackPathUtilities.getPaint(R.color.slow_path, context);
+    selectedTrackPaintMedium = TrackPathUtilities.getPaint(R.color.normal_path, context);
+    selectedTrackPaintFast = TrackPathUtilities.getPaint(R.color.fast_path, context);
+    
+    this.coloredPaths = new ArrayList<ColoredPath>();
+  }
+  
+  @Override
+  public void drawTrack(Canvas canvas) {
+    for(int i = 0; i < coloredPaths.size(); ++i) {
+      ColoredPath coloredPath = coloredPaths.get(i);
+      canvas.drawPath(coloredPath.getPath(), coloredPath.getPathPaint());
+    }
+  }
+  
+  @Override
+  public void updatePath(Projection projection, Rect viewRect, int startLocationIdx, 
+      Boolean alwaysVisible, List<CachedLocation> points) {
+    // Whether to start a new segment on new valid and visible point.
+    boolean newSegment = startLocationIdx <= 0 || !points.get(startLocationIdx - 1).valid; 
+    boolean lastVisible = !newSegment;
+    final Point pt = new Point();
+    
+    clear();
+    
+    slowSpeed = trackPathDescriptor.getSlowSpeed();
+    normalSpeed = trackPathDescriptor.getNormalSpeed();
+    
+    // Loop over track points.
+    for (int i = startLocationIdx; i < points.size(); ++i) {
+      CachedLocation loc = points.get(i);
+      
+      // Check if valid, if not then indicate a new segment.
+      if (!loc.valid) {
+        newSegment = true;
+        continue;
+      }
+      
+      final GeoPoint geoPoint = loc.geoPoint;
+      // Check if this breaks the existing segment.
+      boolean visible = alwaysVisible || viewRect.contains(
+          geoPoint.getLongitudeE6(), geoPoint.getLatitudeE6());
+      if (!visible && !lastVisible) {
+        // This is a point outside view not connected to a visible one.
+        newSegment = true;
+      }
+      lastVisible = visible;
+      
+      // Either move to beginning of a new segment or continue the old one.
+      if (newSegment) {
+        projection.toPixels(geoPoint, pt);
+        newSegment = false;
+      } else {
+        ColoredPath coloredPath;
+        if(loc.speed <= slowSpeed) {
+          coloredPath = new ColoredPath(selectedTrackPaintSlow);
+        }
+        else if(loc.speed <= normalSpeed) {
+          coloredPath = new ColoredPath(selectedTrackPaintMedium);
+        } else {
+          coloredPath = new ColoredPath(selectedTrackPaintFast);
+        }
+        coloredPath.getPath().moveTo(pt.x, pt.y);
+        projection.toPixels(geoPoint, pt);
+        coloredPath.getPath().lineTo(pt.x, pt.y);
+        coloredPaths.add(coloredPath);
+      }
+    }
+  }
+  
+  @Override
+  public void clear()
+  {
+    coloredPaths.clear();
+  }
+
+  @Override
+  public boolean needsRedraw() {
+    return trackPathDescriptor.needsRedraw();
+  }
+  
+  @Override
+  public Path getLastPath() {
+    Path path = new Path();
+    for(int i = 0; i < coloredPaths.size(); ++i) {
+      path.addPath(coloredPaths.get(i).getPath());
+    }
+    return path;
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/maps/FixedSpeedTrackPathDescriptor.java

@@ -0,0 +1,115 @@
+/*
+ * 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.maps;
+
+import static com.google.android.apps.mytracks.Constants.TAG;
+
+import com.google.android.apps.mytracks.Constants;
+import com.google.android.maps.mytracks.R;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
+import android.util.Log;
+
+
+/**
+ * A fixed speed path descriptor.
+ *
+ * @author Vangelis S.
+ */
+public class FixedSpeedTrackPathDescriptor implements TrackPathDescriptor, OnSharedPreferenceChangeListener {
+  private int slowSpeed;
+  private int normalSpeed;
+  private final Context context;
+  
+  public FixedSpeedTrackPathDescriptor(Context context) {
+	
+    this.context = context;
+    context.getSharedPreferences(Constants.SETTINGS_NAME, 0)
+        .registerOnSharedPreferenceChangeListener(this);
+	
+    SharedPreferences prefs = context.getSharedPreferences(Constants.SETTINGS_NAME, 0);
+    if (prefs == null) {
+      slowSpeed = 9; 
+      normalSpeed = 17;
+      return;
+    }
+    try {
+      slowSpeed = Integer.parseInt(prefs.getString(context.getString(
+          R.string.track_color_mode_fixed_speed_slow_key), "9"));
+    } catch (NumberFormatException e) {
+      slowSpeed = 9;
+    }
+    
+    try {
+      normalSpeed = Integer.parseInt(prefs.getString(context.getString(
+          R.string.track_color_mode_fixed_speed_medium_key), "17")); 
+    } catch (NumberFormatException e) {
+      normalSpeed = 17;
+    }
+  }
+  
+  /**
+   * Gets the slow speed for reference.
+   * @return The speed limit considered as slow.
+   */
+  public int getSlowSpeed() {
+    return slowSpeed;
+  }
+  
+  /**
+   * Gets the normal speed for reference.
+   * @return The speed limit considered as normal.
+   */
+  public int getNormalSpeed() {
+    return normalSpeed;
+  }
+  
+  @Override
+  public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
+    Log.d(TAG, "FixedSpeedTrackPathDescriptor: onSharedPreferences changed " + key);
+    if (key == null 
+    	|| (!key.equals(context.getString(R.string.track_color_mode_fixed_speed_slow_key))
+    	    && !key.equals(context.getString(R.string.track_color_mode_fixed_speed_medium_key)))) {
+      return;
+    }
+    SharedPreferences prefs = context.getSharedPreferences(Constants.SETTINGS_NAME, 0);
+    if (prefs == null) {
+      slowSpeed = 9; 
+      normalSpeed = 17;
+      return;
+    }
+    
+    try {
+      slowSpeed = Integer.parseInt(prefs.getString(context.getString(
+	    R.string.track_color_mode_fixed_speed_slow_key), "9"));
+    } catch (NumberFormatException e) {
+      slowSpeed = 9;
+    }
+    try {
+      normalSpeed = Integer.parseInt(prefs.getString(context.getString(
+	    R.string.track_color_mode_fixed_speed_medium_key), "17"));
+    } catch (NumberFormatException e) {
+      normalSpeed = 17;
+    }
+  }
+
+  @Override
+  public boolean needsRedraw() {
+    return false;
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/maps/SingleColorTrackPathPainter.java

@@ -0,0 +1,107 @@
+/*
+ * 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.maps;
+
+import com.google.android.apps.mytracks.MapOverlay.CachedLocation;
+import com.google.android.maps.GeoPoint;
+import com.google.android.maps.Projection;
+import com.google.android.maps.mytracks.R;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.Path;
+import android.graphics.Point;
+import android.graphics.Rect;
+
+import java.util.List;
+
+
+/**
+ * A path painter that not variates the path colors.
+ *
+ *  @author Vangelis S.
+ */
+public class SingleColorTrackPathPainter implements TrackPathPainter {
+  private final Paint selectedTrackPaint;
+  private Path path;
+  
+  public SingleColorTrackPathPainter(Context context) {
+    selectedTrackPaint = TrackPathUtilities.getPaint(R.color.red, context);
+  }
+
+  @Override
+  public void drawTrack(Canvas canvas) {
+    canvas.drawPath(path, selectedTrackPaint);
+  }
+  
+  @Override
+  public void updatePath(Projection projection, Rect viewRect, int startLocationIdx,
+      Boolean alwaysVisible, List<CachedLocation> points) {
+    // Whether to start a new segment on new valid and visible point.
+    boolean newSegment = startLocationIdx <= 0 || !points.get(startLocationIdx - 1).valid; 
+    boolean lastVisible = !newSegment;
+    final Point pt = new Point();
+    // Loop over track points.
+    int numPoints = points.size();
+    path = new Path();
+    path.incReserve(numPoints);
+    
+    for (int i = startLocationIdx; i < numPoints ; ++i) {
+      CachedLocation loc = points.get(i);
+      
+      // Check if valid, if not then indicate a new segment.
+      if (!loc.valid) {
+        newSegment = true;
+        continue;
+      }
+      
+      final GeoPoint geoPoint = loc.geoPoint;
+      // Check if this breaks the existing segment.
+      boolean visible = alwaysVisible 
+          || viewRect.contains(geoPoint.getLongitudeE6(), geoPoint.getLatitudeE6());
+      if (!visible && !lastVisible) {
+        // This is a point outside view not connected to a visible one.
+        newSegment = true;
+      }
+      lastVisible = visible;
+      
+      // Either move to beginning of a new segment or continue the old one.
+      projection.toPixels(geoPoint, pt);
+      if (newSegment) {
+        path.moveTo(pt.x, pt.y);
+        newSegment = false;
+      } else {
+        path.lineTo(pt.x, pt.y);
+      }
+    }
+  }
+  
+  @Override
+  public void clear() {
+    path = null;
+  }
+
+  @Override
+  public boolean needsRedraw() {
+    return false;
+  }
+  
+  @Override
+  public Path getLastPath() {
+    return path;
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/maps/TrackPathDescriptor.java

@@ -0,0 +1,38 @@
+/*
+ * 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.maps;
+
+/**
+ * An interface for classes which describe how to draw a track path. 
+ *
+ * @author Vangelis S.
+ */
+public interface TrackPathDescriptor {
+  /**
+   * @return The maximum speed which is considered slow.
+   */
+  int getSlowSpeed();
+  
+  /**
+   * @return The maximum speed which is considered normal.
+   */
+  int getNormalSpeed();
+  
+  /**
+   * @return True if the path needs to be updated.
+   */
+  boolean needsRedraw();
+}

MyTracks/src/com/google/android/apps/mytracks/maps/TrackPathPainter.java

@@ -0,0 +1,68 @@
+/*
+ * 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.maps;
+
+import com.google.android.apps.mytracks.MapOverlay.CachedLocation;
+import com.google.android.maps.Projection;
+
+import android.graphics.Canvas;
+import android.graphics.Path;
+import android.graphics.Rect;
+
+import java.util.List;
+
+/**
+ * An interface for classes which paint the track path. 
+ *
+ * @author Vangelis S.
+ */
+public interface TrackPathPainter {
+	
+  /**
+   * Clears the related data.
+   */
+  void clear();
+  
+  /**
+   * Draws the path to the canvas.
+   * @param canvas The Canvas to draw upon
+   */
+  void drawTrack(Canvas canvas);
+  
+  /**
+   * Updates the path.
+   * @param projection The Canvas to draw upon.
+   * @param viewRect The Path to be drawn.   
+   * @param startLocationIdx The start point from where update the path.
+   * @param alwaysVisible Flag for alwaysvisible.
+   * @param points The list of points used to update the path.
+   */
+  void updatePath(Projection projection, Rect viewRect, int startLocationIdx,
+      Boolean alwaysVisible, List<CachedLocation> points);
+  
+  /**
+   * @return True if the path needs to be updated.
+   */
+  boolean needsRedraw();
+  
+  /**
+   * @return The path being used currently.
+   */
+  Path getLastPath();
+}
+
+
+

MyTracks/src/com/google/android/apps/mytracks/maps/TrackPathPainterFactory.java

@@ -0,0 +1,65 @@
+/*
+ * 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.maps;
+
+import static com.google.android.apps.mytracks.Constants.TAG;
+
+import com.google.android.apps.mytracks.Constants;
+import com.google.android.maps.mytracks.R;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.util.Log;
+
+/**
+ * A factory for TrackPathPainters.
+ *
+ * @author Vangelis S.
+ */
+public class TrackPathPainterFactory {
+
+  private TrackPathPainterFactory() {
+  }
+
+  /**
+   * Get a new TrackPathPainter.
+   * @param context Context to fetch system preferences.
+   * @return The TrackPathPainter that corresponds to the track color mode setting.
+   */
+  public static TrackPathPainter getTrackPathPainter(Context context) {
+    SharedPreferences prefs =
+        context.getSharedPreferences(Constants.SETTINGS_NAME, 0);
+    if (prefs == null) {
+      return new SingleColorTrackPathPainter(context);
+    }
+    
+    String colorMode = prefs.getString(context.getString(R.string.track_color_mode_key), null);
+    Log.i(TAG, "Creating track path painter of type: " + colorMode);
+
+    if (colorMode == null || colorMode.equals(context.getString(R.string.track_color_mode_none))) {
+      return new SingleColorTrackPathPainter(context);
+    } else if (colorMode.equals(context.getString(R.string.track_color_mode_fixed))) {
+      return new DynamicSpeedTrackPathPainter(context, 
+          new FixedSpeedTrackPathDescriptor(context));
+    } else if (colorMode.equals(context.getString(R.string.track_color_mode_dynamic))) {
+      return new DynamicSpeedTrackPathPainter(context, 
+          new DynamicSpeedTrackPathDescriptor(context));
+    } else {
+      Log.w(TAG, "Using default track path painter. Unrecognized painter: " + colorMode);
+      return new SingleColorTrackPathPainter(context);
+    }
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/maps/TrackPathUtilities.java

@@ -0,0 +1,36 @@
+/*
+ * 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.maps;
+
+import android.content.Context;
+import android.graphics.Paint;
+
+/**
+ * Various utility functions for TrackPath painting.
+ *
+ * @author Vangelis S.
+ */
+public class TrackPathUtilities {
+  
+  public static Paint getPaint(int id, Context context) {
+    Paint paint = new Paint();
+    paint.setColor(context.getResources().getColor(id));
+    paint.setStrokeWidth(3);
+    paint.setStyle(Paint.Style.STROKE);
+    paint.setAntiAlias(true);
+    return paint;
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/util/UnitConversions.java

@@ -28,7 +28,8 @@ public abstract class UnitConversions {
   public static final double MI_TO_FEET = 5280.0;
   public static final double KMH_TO_MPH = 1000 * M_TO_FT / MI_TO_FEET;
   public static final double TO_RADIANS = Math.PI / 180.0;
-
+  public static final double MPH_TO_KMH = 1.609344;
+  
   protected UnitConversions() {
   }
 }