Merge heads.

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

@@ -20,6 +20,7 @@ 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;
@@ -138,4 +139,14 @@ public class  DynamicSpeedTrackPathPainter implements TrackPathPainter {
     }
     return path;
   }
+  
+  /**
+   * Returns coloredPaths.
+   * 
+   * @return coloredPaths
+   */
+  @VisibleForTesting
+  List<ColoredPath> getColoredPaths() {
+    return coloredPaths;
+  }
 }

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

@@ -19,6 +19,7 @@ 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;
@@ -29,16 +30,15 @@ import android.graphics.Rect;
 
 import java.util.List;
 
-
 /**
  * A path painter that not variates the path colors.
- *
- *  @author Vangelis S.
+ * 
+ * @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);
   }
@@ -47,49 +47,64 @@ public class SingleColorTrackPathPainter implements TrackPathPainter {
   public void drawTrack(Canvas canvas) {
     canvas.drawPath(path, selectedTrackPaint);
   }
-  
+
   @Override
   public void updatePath(Projection projection, Rect viewRect, int startLocationIdx,
       Boolean alwaysVisible, List<CachedLocation> points) {
+    path = new Path();
+    updatePath(projection, viewRect, startLocationIdx, alwaysVisible, points, path);
+
+  }
+
+  /**
+   * 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 always visible.
+   * @param points The list of points used to update the path.
+   * @param pathToUpdate The path to be created.
+   */
+  @VisibleForTesting
+  void updatePath(Projection projection, Rect viewRect, int startLocationIdx,
+      Boolean alwaysVisible, List<CachedLocation> points, Path pathToUpdate) {
+    pathToUpdate.incReserve(points.size());
     // Whether to start a new segment on new valid and visible point.
-    boolean newSegment = startLocationIdx <= 0 || !points.get(startLocationIdx - 1).valid; 
+    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 = newPath();
-    path.incReserve(numPoints);
-    
-    for (int i = startLocationIdx; i < numPoints ; ++i) {
+    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 
+      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);
+        pathToUpdate.moveTo(pt.x, pt.y);
         newSegment = false;
       } else {
-        path.lineTo(pt.x, pt.y);
+        pathToUpdate.lineTo(pt.x, pt.y);
       }
     }
   }
-  
+
   @Override
   public void clear() {
     path = null;
@@ -99,12 +114,12 @@ public class SingleColorTrackPathPainter implements TrackPathPainter {
   public boolean needsRedraw() {
     return false;
   }
-  
+
   @Override
   public Path getLastPath() {
     return path;
   }
-  
+
   // Visible for testing
   public Path newPath() {
     return new Path();

MyTracksTest/src/com/google/android/apps/mytracks/maps/DynamicSpeedTrackPathPainterTest.java

@@ -0,0 +1,165 @@
+/*
+ * Copyright 2012 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.android.apps.mytracks.maps;
+
+import com.google.android.apps.mytracks.ColoredPath;
+import com.google.android.apps.mytracks.MapOverlay.CachedLocation;
+import com.google.android.apps.mytracks.TrackStubUtils;
+import com.google.android.maps.mytracks.R;
+import com.google.android.testing.mocking.AndroidMock;
+import com.google.android.testing.mocking.UsesMocks;
+
+import java.util.List;
+
+/**
+ * Tests for the {@link DynamicSpeedTrackPathPainter}.
+ * 
+ * @author Youtao Liu
+ */
+public class DynamicSpeedTrackPathPainterTest extends TrackPathPainterTestCase {
+
+  private DynamicSpeedTrackPathPainter dynamicSpeedTrackPathPainter;
+  private TrackPathDescriptor trackPathDescriptor;
+  // This number must bigger than 10 to meet the requirement of test.
+  private static final int NUMBER_OF_LOCATIONS = 100;
+  private static final int LOCATIONS_PER_SEGMENT = 25;
+  // The maximum speed(KM/H) which is considered slow.
+  private static final int SLOW_SPEED_KMH = 30;
+  // The maximum speed(KM/H) which is considered normal.
+  private static final int NORMAL_SPEED_KMH = 50;
+
+  // Convert from kilometers per hour to meters per second
+  private static final double KMH_TO_MS = 1 / 3.6;
+  private static final int SLOW_SPEED_MS = (int) (SLOW_SPEED_KMH * KMH_TO_MS);
+  private static final int NORMAL_SPEED_MS = (int) (NORMAL_SPEED_KMH * KMH_TO_MS);
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    initialTrackPathDescriptorMock();
+    dynamicSpeedTrackPathPainter = new DynamicSpeedTrackPathPainter(getContext(),
+        trackPathDescriptor);
+  }
+
+  /**
+   * Tests the method
+   * {@link DynamicSpeedTrackPathPainter#updatePath(com.google.android.maps.Projection, android.graphics.Rect, int, Boolean, java.util.List)}
+   * when all locations are invalid.
+   */
+  public void testUpdatePath_AllInvalidLocation() {
+    List<CachedLocation> points = createCachedLocations(NUMBER_OF_LOCATIONS, INVALID_LATITUDE, -1);
+    dynamicSpeedTrackPathPainter.updatePath(myTracksOverlay.getMapProjection(mockView),
+        myTracksOverlay.getMapViewRect(mockView), 1, true, points);
+    AndroidMock.verify(trackPathDescriptor);
+    // Should be zero for there is no valid locations.
+    assertEquals(0, dynamicSpeedTrackPathPainter.getColoredPaths().size());
+  }
+
+  /**
+   * Tests the
+   * {@link DynamicSpeedTrackPathPainter#updatePath(com.google.android.maps.Projection, android.graphics.Rect, int, Boolean, java.util.List)}
+   * when all locations are valid.
+   */
+  public void testUpdatePath_AllValidLocation() {
+    List<CachedLocation> points = createCachedLocations(NUMBER_OF_LOCATIONS,
+        TrackStubUtils.INITIAL_LATITUDE, -1);
+
+    // Gets a number as the start index of points.
+    int startLocationIdx = NUMBER_OF_LOCATIONS / 2;
+    dynamicSpeedTrackPathPainter.updatePath(myTracksOverlay.getMapProjection(mockView),
+        myTracksOverlay.getMapViewRect(mockView), startLocationIdx, true, points);
+
+    AndroidMock.verify(trackPathDescriptor);
+    assertEquals(NUMBER_OF_LOCATIONS - startLocationIdx, dynamicSpeedTrackPathPainter
+        .getColoredPaths().size());
+  }
+
+  /**
+   * Tests the
+   * {@link DynamicSpeedTrackPathPainter#updatePath(com.google.android.maps.Projection, android.graphics.Rect, int, Boolean, java.util.List)}
+   * when all locations are valid. This test setups 4 segments with 25 points
+   * each. The first segment has slow speed, the second segment has normal
+   * speed, the third segment has fast speed, and the fourth segment has slow
+   * speed.
+   */
+  public void testUpdatePath_CheckColoredPath() {
+    // Gets the slow speed. Divide SLOW_SPEED by 2 to make it smaller than
+    // SLOW_SPEED. Speed in MyTracksLocation use MS, but speed in CachedLocation
+    // use KMH.
+    int slowSpeed = SLOW_SPEED_MS / 2;
+    // Gets the normal speed. Makes it smaller than SLOW_SPEED and bigger than
+    // NORMAL_SPEED. Speed in MyTracksLocation use MS, but speed in
+    // CachedLocation use KMH.
+    int normalSpeed = (SLOW_SPEED_MS + NORMAL_SPEED_MS) / 2;
+    // Gets the fast speed. Multiply it by 2 to make it bigger than
+    // NORMAL_SPEED. Speed in MyTracksLocation use MS, but speed in
+    // CachedLocation use KMH.
+    int fastSpeed = NORMAL_SPEED_MS * 2;
+
+    // Get a number of startLocationIdx. And divide NUMBER_OF_LOCATIONS by 8 to
+    // make sure it is less than numberOfFirstThreeSegments.
+    int startLocationIdx = LOCATIONS_PER_SEGMENT / 2;
+
+    List<CachedLocation> points = createCachedLocations(LOCATIONS_PER_SEGMENT,
+        TrackStubUtils.INITIAL_LATITUDE, slowSpeed);
+    points.addAll(createCachedLocations(LOCATIONS_PER_SEGMENT, TrackStubUtils.INITIAL_LATITUDE,
+        normalSpeed));
+    points.addAll(createCachedLocations(LOCATIONS_PER_SEGMENT, TrackStubUtils.INITIAL_LATITUDE,
+        fastSpeed));
+    points.addAll(createCachedLocations(LOCATIONS_PER_SEGMENT, TrackStubUtils.INITIAL_LATITUDE,
+        slowSpeed));
+
+    dynamicSpeedTrackPathPainter.updatePath(myTracksOverlay.getMapProjection(mockView),
+        myTracksOverlay.getMapViewRect(mockView), startLocationIdx, true, points);
+
+    AndroidMock.verify(trackPathDescriptor);
+    List<ColoredPath> coloredPath = dynamicSpeedTrackPathPainter.getColoredPaths();
+    assertEquals(NUMBER_OF_LOCATIONS - startLocationIdx, coloredPath.size());
+
+    // Checks different speeds with different color in the coloredPath.
+    for (int i = 0; i < NUMBER_OF_LOCATIONS - startLocationIdx; i++) {
+      if (i < LOCATIONS_PER_SEGMENT - startLocationIdx) {
+        // Slow.
+        assertEquals(getContext().getResources().getColor(R.color.slow_path), coloredPath.get(i)
+            .getPathPaint().getColor());
+      } else if (i < LOCATIONS_PER_SEGMENT * 2 - startLocationIdx) {
+        // Normal.
+        assertEquals(getContext().getResources().getColor(R.color.normal_path), coloredPath.get(i)
+            .getPathPaint().getColor());
+      } else if (i < LOCATIONS_PER_SEGMENT * 3 - startLocationIdx) {
+        // Fast.
+        assertEquals(getContext().getResources().getColor(R.color.fast_path), coloredPath.get(i)
+            .getPathPaint().getColor());
+      } else {
+        // Slow.
+        assertEquals(getContext().getResources().getColor(R.color.slow_path), coloredPath.get(i)
+            .getPathPaint().getColor());
+      }
+    }
+  }
+
+  /**
+   * Initials a mocked TrackPathDescriptor object.
+   */
+  @UsesMocks(TrackPathDescriptor.class)
+  private void initialTrackPathDescriptorMock() {
+    trackPathDescriptor = AndroidMock.createMock(TrackPathDescriptor.class);
+    AndroidMock.expect(trackPathDescriptor.getSlowSpeed()).andReturn(SLOW_SPEED_KMH);
+    AndroidMock.expect(trackPathDescriptor.getNormalSpeed()).andReturn(NORMAL_SPEED_KMH);
+    AndroidMock.replay(trackPathDescriptor);
+  }
+
+}

MyTracksTest/src/com/google/android/apps/mytracks/maps/SingleColorTrackPathPainterTest.java

@@ -0,0 +1,124 @@
+/*
+ * Copyright 2012 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.android.apps.mytracks.maps;
+
+import com.google.android.apps.mytracks.MapOverlay.CachedLocation;
+import com.google.android.apps.mytracks.TrackStubUtils;
+import com.google.android.testing.mocking.AndroidMock;
+import com.google.android.testing.mocking.UsesMocks;
+
+import android.graphics.Path;
+
+import java.util.List;
+
+/**
+ * Tests for the {@link SingleColorTrackPathPainter}.
+ * 
+ * @author Youtao Liu
+ */
+public class SingleColorTrackPathPainterTest extends TrackPathPainterTestCase {
+
+  private SingleColorTrackPathPainter singleColorTrackPathPainter;
+  private Path pathMock;
+  private static final int NUMBER_OF_LOCATIONS = 100;
+
+  /**
+   * Initials a mocked TrackPathDescriptor object and
+   * singleColorTrackPathPainter.
+   */
+  @Override
+  @UsesMocks(Path.class)
+  protected void setUp() throws Exception {
+    super.setUp();
+
+    pathMock = AndroidMock.createStrictMock(Path.class);
+    singleColorTrackPathPainter = new SingleColorTrackPathPainter(getContext());
+  }
+
+  /**
+   * Tests the
+   * {@link SingleColorTrackPathPainter#updatePath(com.google.android.maps.Projection, android.graphics.Rect, int, Boolean, List, Path)}
+   * method when all locations are valid.
+   */
+  public void testUpdatePath_AllValidLocation() {
+    pathMock.incReserve(NUMBER_OF_LOCATIONS);
+    List<CachedLocation> points = createCachedLocations(NUMBER_OF_LOCATIONS,
+        TrackStubUtils.INITIAL_LATITUDE, -1);
+    // Gets a number as the start index of points.
+    int startLocationIdx = NUMBER_OF_LOCATIONS / 2;
+
+    for (int i = startLocationIdx; i < NUMBER_OF_LOCATIONS; i++) {
+      pathMock.lineTo(0, 0);
+    }
+
+    AndroidMock.replay(pathMock);
+    singleColorTrackPathPainter.updatePath(myTracksOverlay.getMapProjection(mockView),
+        myTracksOverlay.getMapViewRect(mockView), startLocationIdx, true, points, pathMock);
+    AndroidMock.verify(pathMock);
+  }
+
+  /**
+   * Tests the
+   * {@link SingleColorTrackPathPainter#updatePath(com.google.android.maps.Projection, android.graphics.Rect, int, Boolean, List, Path)}
+   * method when all locations are invalid.
+   */
+  public void testUpdatePath_AllInvalidLocation() {
+    pathMock.incReserve(NUMBER_OF_LOCATIONS);
+    List<CachedLocation> points = createCachedLocations(NUMBER_OF_LOCATIONS, INVALID_LATITUDE, -1);
+    // Gets a random number from 1 to numberOfLocations.
+    int startLocationIdx = NUMBER_OF_LOCATIONS / 2;
+    AndroidMock.replay(pathMock);
+    singleColorTrackPathPainter.updatePath(myTracksOverlay.getMapProjection(mockView),
+        myTracksOverlay.getMapViewRect(mockView), startLocationIdx, true, points, pathMock);
+    AndroidMock.verify(pathMock);
+  }
+
+  /**
+   * Tests the
+   * {@link SingleColorTrackPathPainter#updatePath(com.google.android.maps.Projection, android.graphics.Rect, int, Boolean, List, Path)}
+   * method when there are three segments.
+   */
+  public void testUpdatePath_ThreeSegments() {
+    // First segment.
+    List<CachedLocation> points = createCachedLocations(NUMBER_OF_LOCATIONS,
+        TrackStubUtils.INITIAL_LATITUDE, -1);
+    points.addAll(createCachedLocations(1, INVALID_LATITUDE, -1));
+    // Second segment.
+    points.addAll(createCachedLocations(NUMBER_OF_LOCATIONS, TrackStubUtils.INITIAL_LATITUDE, -1));
+    points.addAll(createCachedLocations(1, INVALID_LATITUDE, -1));
+    // Third segment.
+    points.addAll(createCachedLocations(NUMBER_OF_LOCATIONS, TrackStubUtils.INITIAL_LATITUDE, -1));
+    // Gets a random number from 1 to numberOfLocations.
+    int startLocationIdx = NUMBER_OF_LOCATIONS / 2;
+    pathMock.incReserve(NUMBER_OF_LOCATIONS *3 + 1 +1);
+    for (int i = 0; i < NUMBER_OF_LOCATIONS - startLocationIdx; i++) {
+      pathMock.lineTo(0, 0);
+    }
+    pathMock.moveTo(0, 0);
+    for (int i = 0; i < NUMBER_OF_LOCATIONS - 1; i++) {
+      pathMock.lineTo(0, 0);
+    }
+    pathMock.moveTo(0, 0);
+    for (int i = 0; i < NUMBER_OF_LOCATIONS - 1; i++) {
+      pathMock.lineTo(0, 0);
+    }
+
+    AndroidMock.replay(pathMock);
+    singleColorTrackPathPainter.updatePath(myTracksOverlay.getMapProjection(mockView),
+        myTracksOverlay.getMapViewRect(mockView), startLocationIdx, true, points, pathMock);
+    AndroidMock.verify(pathMock);
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/maps/TrackPathPainterTestCase.java

@@ -15,22 +15,32 @@
  */
 package com.google.android.apps.mytracks.maps;
 
+import com.google.android.apps.mytracks.MapOverlay;
+import com.google.android.apps.mytracks.MapOverlay.CachedLocation;
 import com.google.android.apps.mytracks.MockMyTracksOverlay;
+import com.google.android.apps.mytracks.TrackStubUtils;
 import com.google.android.maps.MapView;
 
 import android.graphics.Canvas;
+import android.location.Location;
 import android.test.AndroidTestCase;
 
+import java.util.ArrayList;
+import java.util.List;
+
 /**
  * Tests for the MyTracks track path descriptors and painters.
  * 
  * @author Vangelis S.
  */
 public class TrackPathPainterTestCase extends AndroidTestCase {
+  
   protected Canvas canvas;
   protected MockMyTracksOverlay myTracksOverlay;
   protected MapView mockView;
 
+  final int INVALID_LATITUDE = 100;
+
   @Override
   protected void setUp() throws Exception {
     super.setUp();
@@ -40,4 +50,27 @@ public class TrackPathPainterTestCase extends AndroidTestCase {
     myTracksOverlay.setTrackDrawingEnabled(true);
     mockView = null;
   }
+
+  /**
+   * Creates a list of CachedLocations.
+   * 
+   * @param number the number of locations
+   * @param latitude the latitude value of locations.
+   * @param speed the speed(meter per second) of locations, and will give a default valid value if
+   *          less than zero
+   * @return the simulated locations
+   */
+  List<CachedLocation> createCachedLocations(int number, double latitude, float speed) {
+    List<CachedLocation> points = new ArrayList<MapOverlay.CachedLocation>();
+    for (int i = 0; i < number; ++i) {
+      Location location = TrackStubUtils.createMyTracksLocation(latitude,
+          TrackStubUtils.INITIAL_LONGITUDE, TrackStubUtils.INITIAL_ALTITUDE);
+      if (speed > 0) {
+        location.setSpeed(speed);
+      }
+      CachedLocation cachedLocation = new CachedLocation(location);
+      points.add(cachedLocation);
+    }
+    return points;
+  }
 }