Add a class EndToEndTestRunner which extends InstrumentationTestRunner and can get the port of emulator. Then test can be run on more than one emulators at the same time.

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

@@ -0,0 +1,149 @@
+/*
+ * 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.apps.mytracks.util.PreferencesUtils;
+import com.google.android.apps.mytracks.util.UnitConversions;
+import com.google.android.maps.mytracks.R;
+import com.google.common.annotations.VisibleForTesting;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
+import android.util.Log;
+
+/**
+ * A dynamic speed path descriptor.
+ * 
+ * @author Vangelis S.
+ */
+public class DynamicSpeedTrackPathDescriptor
+    implements TrackPathDescriptor, OnSharedPreferenceChangeListener {
+
+  private final Context context;
+  private int speedMargin;
+  private int slowSpeed;
+  private int normalSpeed;
+  private double averageMovingSpeed;
+
+  @VisibleForTesting
+  static final int CRITICAL_DIFFERENCE_PERCENTAGE = 20;
+
+  public DynamicSpeedTrackPathDescriptor(Context context) {
+    this.context = context;
+    speedMargin = PreferencesUtils.getInt(context, R.string.track_color_mode_percentage_key,
+        PreferencesUtils.TRACK_COLOR_MODE_PERCENTAGE_DEFAULT);
+    context.getSharedPreferences(Constants.SETTINGS_NAME, Context.MODE_PRIVATE)
+        .registerOnSharedPreferenceChangeListener(this);
+  }
+
+  @Override
+  public int getSlowSpeed() {
+    slowSpeed = (int) (averageMovingSpeed - (averageMovingSpeed * speedMargin / 100.0));
+    return slowSpeed;
+  }
+
+  @Override
+  public int getNormalSpeed() {
+    normalSpeed = (int) (averageMovingSpeed + (averageMovingSpeed * speedMargin / 100.0));
+    return normalSpeed;
+  }
+
+  @Override
+  public boolean updateState() {
+    long selectedTrackId = PreferencesUtils.getLong(context, R.string.selected_track_id_key);
+    if (selectedTrackId == PreferencesUtils.SELECTED_TRACK_ID_DEFAULT) {
+      Log.d(TAG, "No selected track id.");
+      return false;
+    }
+    Track track = MyTracksProviderUtils.Factory.get(context).getTrack(selectedTrackId);
+    if (track == null) {
+      Log.d(TAG, "No track for " + selectedTrackId);
+      return false;
+    }
+    TripStatistics tripStatistics = track.getTripStatistics();
+    double newAverageMovingSpeed = (int) Math.floor(
+        tripStatistics.getAverageMovingSpeed() * UnitConversions.MS_TO_KMH);
+
+    if (isDifferenceSignificant(averageMovingSpeed, newAverageMovingSpeed)) {
+      averageMovingSpeed = newAverageMovingSpeed;
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  @Override
+  public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
+    if (PreferencesUtils.getKey(context, R.string.track_color_mode_percentage_key).equals(key)) {
+      speedMargin = PreferencesUtils.getInt(context, R.string.track_color_mode_percentage_key,
+          PreferencesUtils.TRACK_COLOR_MODE_PERCENTAGE_DEFAULT);
+    }
+  }
+
+  /**
+   * Returns true if the average moving speed and the new average moving speed
+   * are significantly different.
+   * 
+   * @param oldAverageMovingSpeed
+   * @param newAverageMovingSpeed
+   */
+  @VisibleForTesting
+  boolean isDifferenceSignificant(double oldAverageMovingSpeed, double newAverageMovingSpeed) {
+    if (oldAverageMovingSpeed == 0) {
+      return newAverageMovingSpeed != 0;
+    }
+    
+    // Here, both oldAverageMovingSpeed and newAverageMovingSpeed are not zero.
+    double maxValue = Math.max(oldAverageMovingSpeed, newAverageMovingSpeed);
+    double differencePercentage = Math.abs(oldAverageMovingSpeed - newAverageMovingSpeed) / maxValue
+        * 100.0;
+    return differencePercentage >= CRITICAL_DIFFERENCE_PERCENTAGE;
+  }
+
+  /**
+   * Gets the speed margin.
+   */
+  @VisibleForTesting
+  int getSpeedMargin() {
+    return speedMargin;
+  }
+
+  /**
+   * Gets the average moving speed.
+   */
+  @VisibleForTesting
+  double getAverageMovingSpeed() {
+    return averageMovingSpeed;
+  }
+
+  /**
+   * Sets the average moving speed.
+   * 
+   * @param value the value
+   */
+  @VisibleForTesting
+  void setAverageMovingSpeed(double value) {
+    averageMovingSpeed = value;
+  }
+}

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

@@ -0,0 +1,139 @@
+/*
+ * 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 com.google.common.annotations.VisibleForTesting;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+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 TrackPathDescriptor trackPathDescriptor;
+  private final Paint slowPaint;
+  private final Paint mediumPaint;
+  private final Paint fastPaint;
+  private final List<ColoredPath> coloredPaths;
+
+  public DynamicSpeedTrackPathPainter(Context context, TrackPathDescriptor trackPathDescriptor) {
+    this.trackPathDescriptor = trackPathDescriptor;
+    slowPaint = TrackPathUtils.getPaint(context, R.color.slow_path);
+    mediumPaint = TrackPathUtils.getPaint(context, R.color.normal_path);
+    fastPaint = TrackPathUtils.getPaint(context, R.color.fast_path);
+    coloredPaths = new ArrayList<ColoredPath>();
+  }
+
+  @Override
+  public boolean hasPath() {
+    return !coloredPaths.isEmpty();
+  }
+
+  @Override
+  public boolean updateState() {
+    return trackPathDescriptor.updateState();
+  }
+
+  @Override
+  public void updatePath(
+      Projection projection, Rect viewRect, int startIndex, List<CachedLocation> points) {
+    boolean hasLastPoint = startIndex != 0 && points.get(startIndex -1).isValid();
+    Point point = new Point();
+    if (hasLastPoint) {
+      GeoPoint geoPoint = points.get(startIndex -1).getGeoPoint();
+      projection.toPixels(geoPoint, point);
+    }
+    boolean newSegment = !hasLastPoint;
+    // Assume if last point exists, it is visible
+    boolean lastPointVisible = hasLastPoint;
+    int slowSpeed = trackPathDescriptor.getSlowSpeed();
+    int normalSpeed = trackPathDescriptor.getNormalSpeed();
+
+    for (int i = startIndex; i < points.size(); ++i) {
+      CachedLocation cachedLocation = points.get(i);
+
+      // If not valid, start a new segment
+      if (!cachedLocation.isValid()) {
+        newSegment = true;
+        continue;
+      }
+
+      GeoPoint geoPoint = cachedLocation.getGeoPoint();
+      // Check if this breaks the existing segment.
+      boolean pointVisible = viewRect.contains(geoPoint.getLongitudeE6(), geoPoint.getLatitudeE6());
+      if (!pointVisible && !lastPointVisible) {
+        // This point and the last point are both outside visible area.
+        newSegment = true;
+      }
+      lastPointVisible = pointVisible;
+
+      // Either update point or draw a line from the last point
+      if (newSegment) {
+        projection.toPixels(geoPoint, point);
+        newSegment = false;
+      } else {
+        ColoredPath coloredPath;
+        if (cachedLocation.getSpeed() <= slowSpeed) {
+          coloredPath = new ColoredPath(slowPaint);
+        } else if (cachedLocation.getSpeed() <= normalSpeed) {
+          coloredPath = new ColoredPath(mediumPaint);
+        } else {
+          coloredPath = new ColoredPath(fastPaint);
+        }
+        coloredPath.getPath().moveTo(point.x, point.y);
+        projection.toPixels(geoPoint, point);
+        coloredPath.getPath().lineTo(point.x, point.y);
+        coloredPaths.add(coloredPath);
+      }
+    }
+  }
+
+  @Override
+  public void clearPath() {
+    coloredPaths.clear();
+  }
+
+  @Override
+  public void drawPath(Canvas canvas) {
+    for (int i = 0; i < coloredPaths.size(); i++) {
+      ColoredPath coloredPath = coloredPaths.get(i);
+      canvas.drawPath(coloredPath.getPath(), coloredPath.getPathPaint());
+    }
+  }
+
+  /**
+   * Gets the colored paths.
+   */
+  @VisibleForTesting
+  List<ColoredPath> getColoredPaths() {
+    return coloredPaths;
+  }
+}

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

@@ -0,0 +1,74 @@
+/*
+ * 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.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;
+
+/**
+ * A fixed speed path descriptor.
+ * 
+ * @author Vangelis S.
+ */
+public class FixedSpeedTrackPathDescriptor
+    implements TrackPathDescriptor, OnSharedPreferenceChangeListener {
+  private final Context context;
+  private int slowSpeed;
+  private int normalSpeed;
+
+  public FixedSpeedTrackPathDescriptor(Context context) {
+    this.context = context;
+
+    slowSpeed = PreferencesUtils.getInt(context, R.string.track_color_mode_slow_key,
+        PreferencesUtils.TRACK_COLOR_MODE_SLOW_DEFAULT);
+    normalSpeed = PreferencesUtils.getInt(context, R.string.track_color_mode_medium_key,
+        PreferencesUtils.TRACK_COLOR_MODE_MEDIUM_DEFAULT);
+    context.getSharedPreferences(Constants.SETTINGS_NAME, Context.MODE_PRIVATE)
+        .registerOnSharedPreferenceChangeListener(this);
+  }
+
+  @Override
+  public int getSlowSpeed() {
+    return slowSpeed;
+  }
+
+  @Override
+  public int getNormalSpeed() {
+    return normalSpeed;
+  }
+
+  @Override
+  public boolean updateState() {
+    return false;
+  }
+
+  @Override
+  public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
+    if (PreferencesUtils.getKey(context, R.string.track_color_mode_slow_key).equals(key)) {
+      slowSpeed = PreferencesUtils.getInt(context, R.string.track_color_mode_slow_key,
+          PreferencesUtils.TRACK_COLOR_MODE_SLOW_DEFAULT);
+    } else if (PreferencesUtils.getKey(context, R.string.track_color_mode_medium_key).equals(key)) {
+      normalSpeed = PreferencesUtils.getInt(context, R.string.track_color_mode_medium_key,
+          PreferencesUtils.TRACK_COLOR_MODE_MEDIUM_DEFAULT);
+    }
+  }
+}

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

@@ -0,0 +1,142 @@
+/*
+ * 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 com.google.common.annotations.VisibleForTesting;
+
+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 = TrackPathUtils.getPaint(context, R.color.red);
+  }
+
+  @Override
+  public boolean hasPath() {
+    return path != null;
+  }
+
+  @Override
+  public boolean updateState() {
+    return false;
+  }
+
+  @Override
+  public void updatePath(
+      Projection projection, Rect viewRect, int startIndex, List<CachedLocation> points) {
+    if (!hasPath()) {
+      path = newPath();
+    }
+    updatePath(projection, viewRect, startIndex, points, path);
+  }
+
+  @Override
+  public void clearPath() {
+    path = null;
+  }
+
+  @Override
+  public void drawPath(Canvas canvas) {
+    if (path != null) {
+      canvas.drawPath(path, selectedTrackPaint);
+    }
+  }
+
+  /**
+   * Updates the path.
+   * 
+   * @param projection the projection
+   * @param viewRect the view rectangle
+   * @param startIndex the start index
+   * @param points the points
+   * @param pathToUpdate the path to update
+   */
+  @VisibleForTesting
+  void updatePath(Projection projection, Rect viewRect, int startIndex, List<CachedLocation> points,
+      Path pathToUpdate) {
+    pathToUpdate.incReserve(points.size() - startIndex);
+
+    boolean hasLastPoint = startIndex != 0 && points.get(startIndex - 1).isValid();
+    boolean newSegment = !hasLastPoint;
+    // Assume if last point exists, it is visible
+    boolean lastPointVisible = hasLastPoint;
+    Point point = new Point();
+
+    for (int i = startIndex; i < points.size(); i++) {
+      CachedLocation cachedLocation = points.get(i);
+
+      // If not valid, start a new segment
+      if (!cachedLocation.isValid()) {
+        newSegment = true;
+        continue;
+      }
+
+      GeoPoint geoPoint = cachedLocation.getGeoPoint();
+      // Check if this breaks the existing segment.
+      boolean pointVisible = viewRect.contains(geoPoint.getLongitudeE6(), geoPoint.getLatitudeE6());
+      if (!pointVisible && !lastPointVisible) {
+        // This point and the last point are both outside visible area.
+        newSegment = true;
+      }
+      lastPointVisible = pointVisible;
+
+      // Either update point or draw a line from the last point
+      projection.toPixels(geoPoint, point);
+      if (newSegment) {
+        pathToUpdate.moveTo(point.x, point.y);
+        newSegment = false;
+      } else {
+        pathToUpdate.lineTo(point.x, point.y);
+      }
+    }
+  }
+
+  /**
+   * Creates a new path.
+   */
+  @VisibleForTesting
+  protected Path newPath() {
+    return new Path();
+  }
+
+  /**
+   * Gets the path.
+   */
+  @VisibleForTesting
+  public Path getPath() {
+    return path;
+  }
+
+}

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

@@ -0,0 +1,40 @@
+/*
+ * 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 {
+
+  /**
+   * Gets the maximum speed which is considered slow.
+   */
+  public int getSlowSpeed();
+
+  /**
+   * Gets the maximum speed which is considered normal.
+   */
+  public int getNormalSpeed();
+
+  /**
+   * Updates state. Returns true if the state is updated.
+   */
+  public boolean updateState();
+}

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

@@ -0,0 +1,66 @@
+/*
+ * 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.Rect;
+
+import java.util.List;
+
+/**
+ * An interface for classes which paint the track path.
+ * 
+ * @author Vangelis S.
+ */
+public interface TrackPathPainter {
+
+  /**
+   * Returns true if has path.
+   */
+  public boolean hasPath();
+
+  /**
+   * Updates state. Returns true if the state is updated.
+   */
+  public boolean updateState();
+
+  /**
+   * Updates the path. Creates a new path if necessary
+   * 
+   * @param projection the projection
+   * @param viewRect the view rectangle
+   * @param startIndex the start index
+   * @param points the points
+   */
+  public void updatePath(
+      Projection projection, Rect viewRect, int startIndex, List<CachedLocation> points);
+
+  /**
+   * Clears the path.
+   */
+  public void clearPath();
+
+  /**
+   * Draws the path.
+   * 
+   * @param canvas the canvas
+   */
+  public void drawPath(Canvas canvas);
+}

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

@@ -0,0 +1,57 @@
+/*
+ * 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.util.PreferencesUtils;
+import com.google.android.maps.mytracks.R;
+
+import android.content.Context;
+import android.util.Log;
+
+/**
+ * A factory for {@link TrackPathPainter}.
+ * 
+ * @author Vangelis S.
+ */
+public class TrackPathPainterFactory {
+
+  private TrackPathPainterFactory() {}
+
+  /**
+   * Get a new {@link TrackPathPainter}.
+   * 
+   * @param context the context
+   */
+  public static TrackPathPainter getTrackPathPainter(Context context) {
+    String trackColorMode = PreferencesUtils.getString(context, R.string.track_color_mode_key,
+        context.getString(R.string.settings_map_track_color_mode_single_value));
+    Log.i(TAG, "Creating track path painter of type: " + trackColorMode);
+
+    if (context.getString(R.string.settings_map_track_color_mode_dynamic_value)
+        .equals(trackColorMode)) {
+      return new DynamicSpeedTrackPathPainter(context, new DynamicSpeedTrackPathDescriptor(
+          context));
+    } else if (context.getString(R.string.settings_map_track_color_mode_fixed_value)
+        .equals(trackColorMode)) {
+      return new DynamicSpeedTrackPathPainter(context, new FixedSpeedTrackPathDescriptor(context));
+    } else {
+      return new SingleColorTrackPathPainter(context);
+    }
+  }
+}

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

@@ -0,0 +1,45 @@
+/*
+ * 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 track path painting.
+ * 
+ * @author Vangelis S.
+ */
+public class TrackPathUtils {
+
+  private TrackPathUtils() {}
+
+  /**
+   * Gets a paint.
+   * 
+   * @param context the context
+   * @param colorId the color id
+   */
+  public static Paint getPaint(Context context, int colorId) {
+    Paint paint = new Paint();
+    paint.setColor(context.getResources().getColor(colorId));
+    paint.setStrokeWidth(3);
+    paint.setStyle(Paint.Style.STROKE);
+    paint.setAntiAlias(true);
+    return paint;
+  }
+}