diff --git a/MyTracks/src/com/google/android/apps/mytracks/TrackListActivity.java b/MyTracks/src/com/google/android/apps/mytracks/TrackListActivity.java index 1a47a3f0c..1387a99da 100644 --- a/MyTracks/src/com/google/android/apps/mytracks/TrackListActivity.java +++ b/MyTracks/src/com/google/android/apps/mytracks/TrackListActivity.java @@ -216,7 +216,7 @@ public class TrackListActivity extends FragmentActivity { } }; listView.setAdapter(adapter); - ApiAdapterFactory.getApiAdapter().configureContextualMenu( + ApiAdapterFactory.getApiAdapter().configureListViewContextualMenu( this, listView, R.menu.track_list_context_menu, contextualActionModeCallback); getSupportLoaderManager().initLoader(0, null, new LoaderCallbacks() { diff --git a/MyTracks/src/com/google/android/apps/mytracks/maps/DynamicSpeedTrackPathPainter.java b/MyTracks/src/com/google/android/apps/mytracks/maps/DynamicSpeedTrackPathPainter.java index 2234f8b8f..34e5bd954 100644 --- a/MyTracks/src/com/google/android/apps/mytracks/maps/DynamicSpeedTrackPathPainter.java +++ b/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 getColoredPaths() { + return coloredPaths; + } } \ No newline at end of file diff --git a/MyTracks/src/com/google/android/apps/mytracks/maps/SingleColorTrackPathPainter.java b/MyTracks/src/com/google/android/apps/mytracks/maps/SingleColorTrackPathPainter.java index c73927cd6..7d89f488e 100644 --- a/MyTracks/src/com/google/android/apps/mytracks/maps/SingleColorTrackPathPainter.java +++ b/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 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 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(); diff --git a/MyTracks/src/com/google/android/apps/mytracks/util/Api11Adapter.java b/MyTracks/src/com/google/android/apps/mytracks/util/Api11Adapter.java index a1366d567..9759bb854 100644 --- a/MyTracks/src/com/google/android/apps/mytracks/util/Api11Adapter.java +++ b/MyTracks/src/com/google/android/apps/mytracks/util/Api11Adapter.java @@ -50,7 +50,7 @@ public class Api11Adapter extends Api10Adapter { } @Override - public void configureContextualMenu(final Activity activity, ListView listView, final int menuId, + public void configureListViewContextualMenu(final Activity activity, ListView listView, final int menuId, final ContextualActionModeCallback contextualActionModeCallback) { listView.setOnItemLongClickListener(new OnItemLongClickListener() { ActionMode actionMode; diff --git a/MyTracks/src/com/google/android/apps/mytracks/util/Api7Adapter.java b/MyTracks/src/com/google/android/apps/mytracks/util/Api7Adapter.java index 0038f8473..be6c744c5 100644 --- a/MyTracks/src/com/google/android/apps/mytracks/util/Api7Adapter.java +++ b/MyTracks/src/com/google/android/apps/mytracks/util/Api7Adapter.java @@ -116,7 +116,7 @@ public class Api7Adapter implements ApiAdapter { } @Override - public void configureContextualMenu(Activity activity, ListView listView, int menuId, + public void configureListViewContextualMenu(Activity activity, ListView listView, int menuId, ContextualActionModeCallback contextualActionModeCallback) { activity.registerForContextMenu(listView); } diff --git a/MyTracks/src/com/google/android/apps/mytracks/util/ApiAdapter.java b/MyTracks/src/com/google/android/apps/mytracks/util/ApiAdapter.java index 3706a1bff..fe6384560 100644 --- a/MyTracks/src/com/google/android/apps/mytracks/util/ApiAdapter.java +++ b/MyTracks/src/com/google/android/apps/mytracks/util/ApiAdapter.java @@ -126,7 +126,7 @@ public interface ApiAdapter { public void configureActionBarHomeAsUp(Activity activity); /** - * Configures the context menu. + * Configures the list view context menu. *

* Due to changes in API level 11. * @@ -136,7 +136,7 @@ public interface ApiAdapter { * @param contextualActionModeCallback the callback when an item is selected * in the contextual action mode */ - public void configureContextualMenu(Activity activity, ListView listView, int menuId, + public void configureListViewContextualMenu(Activity activity, ListView listView, int menuId, ContextualActionModeCallback contextualActionModeCallback); /** diff --git a/MyTracksTest/src/com/google/android/apps/mytracks/maps/DynamicSpeedTrackPathPainterTest.java b/MyTracksTest/src/com/google/android/apps/mytracks/maps/DynamicSpeedTrackPathPainterTest.java new file mode 100644 index 000000000..a583861fe --- /dev/null +++ b/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 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 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 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 = 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); + } + +} diff --git a/MyTracksTest/src/com/google/android/apps/mytracks/maps/SingleColorTrackPathPainterTest.java b/MyTracksTest/src/com/google/android/apps/mytracks/maps/SingleColorTrackPathPainterTest.java new file mode 100644 index 000000000..1679c547a --- /dev/null +++ b/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 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 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 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); + } +} diff --git a/MyTracksTest/src/com/google/android/apps/mytracks/maps/TrackPathPainterTestCase.java b/MyTracksTest/src/com/google/android/apps/mytracks/maps/TrackPathPainterTestCase.java index 59ceb94fd..b53909b6e 100644 --- a/MyTracksTest/src/com/google/android/apps/mytracks/maps/TrackPathPainterTestCase.java +++ b/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 createCachedLocations(int number, double latitude, float speed) { + List points = new ArrayList(); + 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; + } }