From 73d1a07fc103203606974ce4058d010d79f414ac Mon Sep 17 00:00:00 2001 From: Jimmy Shih Date: Wed, 11 Jul 2012 15:42:36 -0700 Subject: [PATCH] Clean up TrackDataManager and TrackDataType. --- .../mytracks/content/DataSourceManager.java | 74 ++++--- .../apps/mytracks/content/ListenerState.java | 105 ++++++++++ .../apps/mytracks/content/TrackDataHub.java | 183 +++++++----------- .../mytracks/content/TrackDataListeners.java | 159 --------------- .../mytracks/content/TrackDataManager.java | 127 ++++++++++++ .../apps/mytracks/content/TrackDataType.java | 34 ++++ .../mytracks/fragments/ChartFragment.java | 14 +- .../apps/mytracks/fragments/MapFragment.java | 12 +- .../mytracks/fragments/StatsFragment.java | 10 +- .../mytracks/content/TrackDataHubTest.java | 39 ++-- 10 files changed, 413 insertions(+), 344 deletions(-) create mode 100644 MyTracks/src/com/google/android/apps/mytracks/content/ListenerState.java delete mode 100644 MyTracks/src/com/google/android/apps/mytracks/content/TrackDataListeners.java create mode 100644 MyTracks/src/com/google/android/apps/mytracks/content/TrackDataManager.java create mode 100644 MyTracks/src/com/google/android/apps/mytracks/content/TrackDataType.java diff --git a/MyTracks/src/com/google/android/apps/mytracks/content/DataSourceManager.java b/MyTracks/src/com/google/android/apps/mytracks/content/DataSourceManager.java index 26fdb7276..8da7841a7 100644 --- a/MyTracks/src/com/google/android/apps/mytracks/content/DataSourceManager.java +++ b/MyTracks/src/com/google/android/apps/mytracks/content/DataSourceManager.java @@ -18,8 +18,6 @@ package com.google.android.apps.mytracks.content; import static com.google.android.apps.mytracks.Constants.TAG; -import com.google.android.apps.mytracks.content.TrackDataHub.ListenerDataType; - import android.content.SharedPreferences; import android.content.SharedPreferences.OnSharedPreferenceChangeListener; import android.database.ContentObserver; @@ -169,7 +167,7 @@ public class DataSourceManager { private final DataSourceListener dataSourceListener; // Registered listeners - private final Set registeredListeners = EnumSet.noneOf(ListenerDataType.class); + private final Set registeredListeners = EnumSet.noneOf(TrackDataType.class); private final Handler handler; private final TracksTableObserver tracksTableObserver; @@ -197,36 +195,36 @@ public class DataSourceManager { * * @param listeners the listeners */ - public void updateListeners(EnumSet listeners) { - EnumSet neededListeners = EnumSet.copyOf(listeners); + public void updateListeners(EnumSet listeners) { + EnumSet neededListeners = EnumSet.copyOf(listeners); /* * Map SAMPLED_OUT_POINT_UPDATES to POINT_UPDATES since they correspond to * the same internal listener */ - if (neededListeners.contains(ListenerDataType.SAMPLED_OUT_POINT_UPDATES)) { - neededListeners.remove(ListenerDataType.SAMPLED_OUT_POINT_UPDATES); - neededListeners.add(ListenerDataType.POINT_UPDATES); + if (neededListeners.contains(TrackDataType.SAMPLED_OUT_TRACK_POINTS)) { + neededListeners.remove(TrackDataType.SAMPLED_OUT_TRACK_POINTS); + neededListeners.add(TrackDataType.TRACK_POINTS_TABLE); } Log.d(TAG, "Updating listeners " + neededListeners); // Unnecessary = registered - needed - Set unnecessaryListeners = EnumSet.copyOf(registeredListeners); + Set unnecessaryListeners = EnumSet.copyOf(registeredListeners); unnecessaryListeners.removeAll(neededListeners); // Missing = needed - registered - Set missingListeners = EnumSet.copyOf(neededListeners); + Set missingListeners = EnumSet.copyOf(neededListeners); missingListeners.removeAll(registeredListeners); // Remove unnecessary listeners - for (ListenerDataType type : unnecessaryListeners) { - unregisterListener(type); + for (TrackDataType trackDataType : unnecessaryListeners) { + unregisterListener(trackDataType); } // Add missing listeners - for (ListenerDataType type : missingListeners) { - registerListener(type); + for (TrackDataType trackDataType : missingListeners) { + registerListener(trackDataType); } // Update registered listeners @@ -237,33 +235,33 @@ public class DataSourceManager { /** * Registers a listener with data source. * - * @param type the listener data type + * @param trackDataType the listener data type */ - private void registerListener(ListenerDataType type) { - switch (type) { - case SELECTED_TRACK_CHANGED: + private void registerListener(TrackDataType trackDataType) { + switch (trackDataType) { + case SELECTED_TRACK: // Do nothing break; - case TRACK_UPDATES: + case TRACKS_TABLE: dataSource.registerContentObserver(TracksColumns.CONTENT_URI, tracksTableObserver); break; - case WAYPOINT_UPDATES: + case WAYPOINTS_TABLE: dataSource.registerContentObserver(WaypointsColumns.CONTENT_URI, waypointsTableObserver); break; - case POINT_UPDATES: + case TRACK_POINTS_TABLE: dataSource.registerContentObserver( TrackPointsColumns.CONTENT_URI, trackPointsTableObserver); break; - case SAMPLED_OUT_POINT_UPDATES: + case SAMPLED_OUT_TRACK_POINTS: // Do nothing. SAMPLED_OUT_POINT_UPDATES is mapped to POINT_UPDATES. break; - case LOCATION_UPDATES: + case LOCATION: dataSource.registerLocationListener(currentLocationListener); break; - case COMPASS_UPDATES: + case COMPASS: dataSource.registerCompassListener(compassListener); break; - case DISPLAY_PREFERENCES: + case PREFERENCE: dataSource.registerOnSharedPreferenceChangeListener(preferenceListener); break; default: @@ -274,32 +272,32 @@ public class DataSourceManager { /** * Unregisters a listener with data source. * - * @param type listener data type + * @param trackDataType listener data type */ - private void unregisterListener(ListenerDataType type) { - switch (type) { - case SELECTED_TRACK_CHANGED: + private void unregisterListener(TrackDataType trackDataType) { + switch (trackDataType) { + case SELECTED_TRACK: // Do nothing break; - case TRACK_UPDATES: + case TRACKS_TABLE: dataSource.unregisterContentObserver(tracksTableObserver); break; - case WAYPOINT_UPDATES: + case WAYPOINTS_TABLE: dataSource.unregisterContentObserver(waypointsTableObserver); break; - case POINT_UPDATES: + case TRACK_POINTS_TABLE: dataSource.unregisterContentObserver(trackPointsTableObserver); break; - case SAMPLED_OUT_POINT_UPDATES: + case SAMPLED_OUT_TRACK_POINTS: // Do nothing. SAMPLED_OUT_POINT_UPDATES is mapped to POINT_UPDATES. break; - case LOCATION_UPDATES: + case LOCATION: dataSource.unregisterLocationListener(currentLocationListener); break; - case COMPASS_UPDATES: + case COMPASS: dataSource.unregisterCompassListener(compassListener); break; - case DISPLAY_PREFERENCES: + case PREFERENCE: dataSource.unregisterOnSharedPreferenceChangeListener(preferenceListener); break; default: @@ -311,8 +309,8 @@ public class DataSourceManager { * Unregisters all listeners with data source. */ public void unregisterAllListeners() { - for (ListenerDataType type : ListenerDataType.values()) { - unregisterListener(type); + for (TrackDataType trackDataType : TrackDataType.values()) { + unregisterListener(trackDataType); } } } diff --git a/MyTracks/src/com/google/android/apps/mytracks/content/ListenerState.java b/MyTracks/src/com/google/android/apps/mytracks/content/ListenerState.java new file mode 100644 index 000000000..e1e3598a7 --- /dev/null +++ b/MyTracks/src/com/google/android/apps/mytracks/content/ListenerState.java @@ -0,0 +1,105 @@ +/* + * 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.content; + +import java.util.EnumSet; + +/** + * State for a registered {@link TrackDataListener}. + * + * @author Jimmy Shih + */ +public class ListenerState { + + private TrackDataListener trackDataListener; + private EnumSet trackDataTypes; + + private long lastTrackId; + private long lastPointId; + private int lastSamplingFrequency; + private int numberOfLoadedPoints; + + public ListenerState( + TrackDataListener trackDataListener, EnumSet trackDataTypes) { + this.trackDataListener = trackDataListener; + this.trackDataTypes = trackDataTypes; + } + + /** + * Gets the {@link TrackDataListener}. + */ + public TrackDataListener getTrackDataListener() { + return trackDataListener; + } + + /** + * Gets the track data types. + */ + public EnumSet getTrackDataTypes() { + return trackDataTypes; + } + + /** + * Gets the last track id. + */ + public long getLastTrackId() { + return lastTrackId; + } + + /** + * Gets the last point id. + */ + public long getLastPointId() { + return lastPointId; + } + + /** + * Gets the last sampling frequency. + */ + public int getLastSamplingFrequency() { + return lastSamplingFrequency; + } + + /** + * Get the number of loaded points. + */ + public int getNumberOfLoadedPoints() { + return numberOfLoadedPoints; + } + + /** + * Sets the listener state. + * + * @param trackId track id + * @param pointId point id + * @param samplingFrequency sampling frequency + * @param loadedPoints number of loaded points + */ + public void setState(long trackId, long pointId, int samplingFrequency, int loadedPoints) { + lastTrackId = trackId; + lastPointId = pointId; + lastSamplingFrequency = samplingFrequency; + numberOfLoadedPoints = loadedPoints; + } + + /** + * Resets state. + */ + public void resetState() { + setState(0L, 0L, 0, 0); + } +} \ No newline at end of file diff --git a/MyTracks/src/com/google/android/apps/mytracks/content/TrackDataHub.java b/MyTracks/src/com/google/android/apps/mytracks/content/TrackDataHub.java index dc12c5fce..52c8c3c4a 100644 --- a/MyTracks/src/com/google/android/apps/mytracks/content/TrackDataHub.java +++ b/MyTracks/src/com/google/android/apps/mytracks/content/TrackDataHub.java @@ -24,7 +24,6 @@ import static com.google.android.apps.mytracks.Constants.TARGET_DISPLAYED_TRACK_ import com.google.android.apps.mytracks.content.MyTracksProviderUtils.DoubleBufferedLocationFactory; import com.google.android.apps.mytracks.content.MyTracksProviderUtils.LocationIterator; import com.google.android.apps.mytracks.content.TrackDataListener.ProviderState; -import com.google.android.apps.mytracks.content.TrackDataListeners.ListenerRegistration; import com.google.android.apps.mytracks.util.LocationUtils; import com.google.android.apps.mytracks.util.PreferencesUtils; import com.google.android.maps.mytracks.R; @@ -57,54 +56,23 @@ public class TrackDataHub { // Overridable constants private final int targetNumPoints; - /** Types of data that we can expose. */ - public static enum ListenerDataType { - /** Listen to when the selected track changes. */ - SELECTED_TRACK_CHANGED, - - /** Listen to when the tracks change. */ - TRACK_UPDATES, - - /** Listen to when the waypoints change. */ - WAYPOINT_UPDATES, - - /** Listen to when the current track points change. */ - POINT_UPDATES, - - /** - * Listen to sampled-out points. - * Listening to this without listening to {@link #POINT_UPDATES} - * makes no sense and may yield unexpected results. - */ - SAMPLED_OUT_POINT_UPDATES, - - /** Listen to updates to the current location. */ - LOCATION_UPDATES, - - /** Listen to updates to the current heading. */ - COMPASS_UPDATES, - - /** Listens to changes in display preferences. */ - DISPLAY_PREFERENCES; - } - /** Listener which receives events from the system. */ private class HubDataSourceListener implements DataSourceListener { @Override public void notifyTracksTableUpdated() { - TrackDataHub.this.notifyTrackUpdated(getListenersFor(ListenerDataType.TRACK_UPDATES)); + TrackDataHub.this.notifyTrackUpdated(getListenersFor(TrackDataType.TRACKS_TABLE)); } @Override public void notifyWaypointsTableUpdated() { - TrackDataHub.this.notifyWaypointUpdated(getListenersFor(ListenerDataType.WAYPOINT_UPDATES)); + TrackDataHub.this.notifyWaypointUpdated(getListenersFor(TrackDataType.WAYPOINTS_TABLE)); } @Override public void notifyTrackPointsTableUpdated() { TrackDataHub.this.notifyPointsUpdated(true, 0, 0, - getListenersFor(ListenerDataType.POINT_UPDATES), - getListenersFor(ListenerDataType.SAMPLED_OUT_POINT_UPDATES)); + getListenersFor(TrackDataType.TRACK_POINTS_TABLE), + getListenersFor(TrackDataType.SAMPLED_OUT_TRACK_POINTS)); } @Override @@ -127,14 +95,14 @@ public class TrackDataHub { @Override public void notifyLocationChanged(Location loc) { TrackDataHub.this.notifyLocationChanged(loc, - getListenersFor(ListenerDataType.LOCATION_UPDATES)); + getListenersFor(TrackDataType.LOCATION)); } @Override public void notifyHeadingChanged(float heading) { lastSeenMagneticHeading = heading; maybeUpdateDeclination(); - TrackDataHub.this.notifyHeadingChanged(getListenersFor(ListenerDataType.COMPASS_UPDATES)); + TrackDataHub.this.notifyHeadingChanged(getListenersFor(TrackDataType.COMPASS)); } } @@ -148,11 +116,9 @@ public class TrackDataHub { private Handler listenerHandler; /** Manager for external listeners (those from activities). */ - private final TrackDataListeners dataListeners; + private final TrackDataManager trackDataManager; private DataSource dataSource; - - /** Manager for system data listener registrations. */ private DataSourceManager dataSourceManager; /** Condensed listener for system data listener events. */ @@ -190,17 +156,17 @@ public class TrackDataHub { public synchronized static TrackDataHub newInstance(Context context) { MyTracksProviderUtils providerUtils = MyTracksProviderUtils.Factory.get(context); return new TrackDataHub( - context, new TrackDataListeners(), providerUtils, TARGET_DISPLAYED_TRACK_POINTS); + context, new TrackDataManager(), providerUtils, TARGET_DISPLAYED_TRACK_POINTS); } /** * Injection constructor. */ // @VisibleForTesting - TrackDataHub(Context ctx, TrackDataListeners listeners, MyTracksProviderUtils providerUtils, + TrackDataHub(Context ctx, TrackDataManager trackDataManager, MyTracksProviderUtils providerUtils, int targetNumPoints) { this.context = ctx; - this.dataListeners = listeners; + this.trackDataManager = trackDataManager; this.providerUtils = providerUtils; this.targetNumPoints = targetNumPoints; this.locationFactory = new DoubleBufferedLocationFactory(); @@ -335,7 +301,7 @@ public class TrackDataHub { Location loc = dataSource.getLastKnownLocation(); if (loc != null) { - notifyLocationChanged(loc, getListenersFor(ListenerDataType.LOCATION_UPDATES)); + notifyLocationChanged(loc, getListenersFor(TrackDataType.LOCATION)); } } @@ -405,24 +371,25 @@ public class TrackDataHub { } public void registerTrackDataListener( - TrackDataListener listener, EnumSet dataTypes) { - synchronized (dataListeners) { - ListenerRegistration registration = - dataListeners.registerTrackDataListener(listener, dataTypes); + TrackDataListener listener, EnumSet dataTypes) { + synchronized (trackDataManager) { + ListenerState listenerState = trackDataManager.registerListener(listener, dataTypes); // Don't load any data or start internal listeners if start() hasn't been // called. When it is called, we'll do both things. - if (!isStarted()) return; + if (!isStarted()) { + return; + } - loadNewDataForListener(registration); + loadNewDataForListener(listenerState); dataSourceManager.updateListeners(getNeededListenerTypes()); } } public void unregisterTrackDataListener(TrackDataListener listener) { - synchronized (dataListeners) { - dataListeners.unregisterTrackDataListener(listener); + synchronized (trackDataManager) { + trackDataManager.unregisterListener(listener); // Don't load any data or start internal listeners if start() hasn't been // called. When it is called, we'll do both things. @@ -436,33 +403,32 @@ public class TrackDataHub { * Reloads all track data received so far into the specified listeners. */ public void reloadDataForListener(TrackDataListener listener) { - ListenerRegistration registration; - synchronized (dataListeners) { - registration = dataListeners.getRegistration(listener); - registration.resetState(); - loadNewDataForListener(registration); + synchronized (trackDataManager) { + ListenerState listenerState = trackDataManager.getListenerState(listener); + listenerState.resetState(); + loadNewDataForListener(listenerState); } } /** * Reloads all track data received so far into the specified listeners. * - * Assumes it's called from a block that synchronizes on {@link #dataListeners}. + * Assumes it's called from a block that synchronizes on {@link #trackDataManager}. */ - private void loadNewDataForListener(final ListenerRegistration registration) { + private void loadNewDataForListener(final ListenerState listenerState) { if (!isStarted()) { Log.w(TAG, "Not started, not reloading"); return; } - if (registration == null) { - Log.w(TAG, "Not reloading for null registration"); + if (listenerState == null) { + Log.w(TAG, "Not reloading for null listener state"); return; } // If a listener happens to be added after this method but before the Runnable below is // executed, it will have triggered a separate call to load data only up to the point this // listener got to. This is ensured by being synchronized on listeners. - final boolean isOnlyListener = (dataListeners.getNumListeners() == 1); + final boolean isOnlyListener = (trackDataManager.getNumberOfListeners() == 1); runInListenerThread(new Runnable() { @SuppressWarnings("unchecked") @@ -470,30 +436,31 @@ public class TrackDataHub { public void run() { // Reload everything if either it's a different track, or the track has been resampled // (this also covers the case of a new registration). - boolean reloadAll = registration.lastTrackId != selectedTrackId || - registration.lastSamplingFrequency != lastSamplingFrequency; - Log.d(TAG, "Doing a " + (reloadAll ? "full" : "partial") + " reload for " + registration); + boolean reloadAll = listenerState.getLastTrackId() != selectedTrackId || + listenerState.getLastSamplingFrequency() != lastSamplingFrequency; + Log.d(TAG, "Doing a " + (reloadAll ? "full" : "partial") + " reload for " + listenerState); - TrackDataListener listener = registration.listener; + TrackDataListener listener = listenerState.getTrackDataListener(); Set listenerSet = Collections.singleton(listener); - if (registration.isInterestedIn(ListenerDataType.DISPLAY_PREFERENCES)) { + EnumSet trackDataTypes = listenerState.getTrackDataTypes(); + + if (trackDataTypes.contains(TrackDataType.PREFERENCE)) { reloadAll |= listener.onUnitsChanged(metricUnits); reloadAll |= listener.onReportSpeedChanged(reportSpeed); } - if (reloadAll && registration.isInterestedIn(ListenerDataType.SELECTED_TRACK_CHANGED)) { + if (reloadAll && trackDataTypes.contains(TrackDataType.SELECTED_TRACK)) { notifySelectedTrackChanged(selectedTrackId, listenerSet); } - if (registration.isInterestedIn(ListenerDataType.TRACK_UPDATES)) { + if (trackDataTypes.contains(TrackDataType.TRACKS_TABLE)) { notifyTrackUpdated(listenerSet); } - boolean interestedInPoints = - registration.isInterestedIn(ListenerDataType.POINT_UPDATES); - boolean interestedInSampledOutPoints = - registration.isInterestedIn(ListenerDataType.SAMPLED_OUT_POINT_UPDATES); + boolean interestedInPoints = trackDataTypes.contains(TrackDataType.TRACK_POINTS_TABLE); + boolean interestedInSampledOutPoints = trackDataTypes.contains( + TrackDataType.SAMPLED_OUT_TRACK_POINTS); if (interestedInPoints || interestedInSampledOutPoints) { long minPointId = 0; int previousNumPoints = 0; @@ -503,8 +470,8 @@ public class TrackDataHub { notifyPointsCleared(listenerSet); } else { // Send only new points - minPointId = registration.lastPointId + 1; - previousNumPoints = registration.numLoadedPoints; + minPointId = listenerState.getLastPointId() + 1; + previousNumPoints = listenerState.getNumberOfLoadedPoints(); } // If this is the only listener we have registered, keep the state that we serve to it as @@ -520,11 +487,11 @@ public class TrackDataHub { interestedInSampledOutPoints ? listenerSet : Collections.EMPTY_SET); } - if (registration.isInterestedIn(ListenerDataType.WAYPOINT_UPDATES)) { + if (trackDataTypes.contains(TrackDataType.WAYPOINTS_TABLE)) { notifyWaypointUpdated(listenerSet); } - if (registration.isInterestedIn(ListenerDataType.LOCATION_UPDATES)) { + if (trackDataTypes.contains(TrackDataType.LOCATION)) { if (lastSeenLocation != null) { notifyLocationChanged(lastSeenLocation, true, listenerSet); } else { @@ -532,7 +499,7 @@ public class TrackDataHub { } } - if (registration.isInterestedIn(ListenerDataType.COMPASS_UPDATES)) { + if (trackDataTypes.contains(TrackDataType.COMPASS)) { notifyHeadingChanged(listenerSet); } } @@ -547,8 +514,8 @@ public class TrackDataHub { Log.w(TAG, "Not started, not reloading"); return; } - synchronized (dataListeners) { - if (!dataListeners.hasListeners()) { + synchronized (trackDataManager) { + if (trackDataManager.getNumberOfListeners() == 0) { Log.d(TAG, "No listeners, not reloading"); return; } @@ -559,33 +526,33 @@ public class TrackDataHub { public void run() { // Ignore the return values here, we're already sending the full data set anyway for (TrackDataListener listener : - getListenersFor(ListenerDataType.DISPLAY_PREFERENCES)) { + getListenersFor(TrackDataType.PREFERENCE)) { listener.onUnitsChanged(metricUnits); listener.onReportSpeedChanged(reportSpeed); } notifySelectedTrackChanged(selectedTrackId, - getListenersFor(ListenerDataType.SELECTED_TRACK_CHANGED)); + getListenersFor(TrackDataType.SELECTED_TRACK)); - notifyTrackUpdated(getListenersFor(ListenerDataType.TRACK_UPDATES)); + notifyTrackUpdated(getListenersFor(TrackDataType.TRACKS_TABLE)); Set pointListeners = - getListenersFor(ListenerDataType.POINT_UPDATES); + getListenersFor(TrackDataType.TRACK_POINTS_TABLE); Set sampledOutPointListeners = - getListenersFor(ListenerDataType.SAMPLED_OUT_POINT_UPDATES); + getListenersFor(TrackDataType.SAMPLED_OUT_TRACK_POINTS); notifyPointsCleared(pointListeners); notifyPointsUpdated(true, 0, 0, pointListeners, sampledOutPointListeners); - notifyWaypointUpdated(getListenersFor(ListenerDataType.WAYPOINT_UPDATES)); + notifyWaypointUpdated(getListenersFor(TrackDataType.WAYPOINTS_TABLE)); if (lastSeenLocation != null) { notifyLocationChanged(lastSeenLocation, true, - getListenersFor(ListenerDataType.LOCATION_UPDATES)); + getListenersFor(TrackDataType.LOCATION)); } else { notifyFixType(); } - notifyHeadingChanged(getListenersFor(ListenerDataType.COMPASS_UPDATES)); + notifyHeadingChanged(getListenersFor(TrackDataType.COMPASS)); } }); } @@ -620,12 +587,12 @@ public class TrackDataHub { @Override public void run() { Set displayListeners = - getListenersFor(ListenerDataType.DISPLAY_PREFERENCES); + getListenersFor(TrackDataType.PREFERENCE); for (TrackDataListener listener : displayListeners) { // TODO: Do the reloading just once for all interested listeners if (listener.onReportSpeedChanged(reportSpeed)) { - synchronized (dataListeners) { + synchronized (trackDataManager) { reloadDataForListener(listener); } } @@ -641,11 +608,11 @@ public class TrackDataHub { runInListenerThread(new Runnable() { @Override public void run() { - Set displayListeners = getListenersFor(ListenerDataType.DISPLAY_PREFERENCES); + Set displayListeners = getListenersFor(TrackDataType.PREFERENCE); for (TrackDataListener listener : displayListeners) { if (listener.onUnitsChanged(metricUnits)) { - synchronized (dataListeners) { + synchronized (trackDataManager) { reloadDataForListener(listener); } } @@ -673,7 +640,7 @@ public class TrackDataHub { // Notify to everyone. Log.d(TAG, "Notifying fix type: " + state); for (TrackDataListener listener : - getListenersFor(ListenerDataType.LOCATION_UPDATES)) { + getListenersFor(TrackDataType.LOCATION)) { listener.onProviderStateChange(state); } } @@ -935,9 +902,9 @@ public class TrackDataHub { Log.i(TAG, "Resampling point set after " + numLoadedPoints + " points."); resetState(); - synchronized (dataListeners) { - sampledListeners = getListenersFor(ListenerDataType.POINT_UPDATES); - sampledOutListeners = getListenersFor(ListenerDataType.SAMPLED_OUT_POINT_UPDATES); + synchronized (trackDataManager) { + sampledListeners = getListenersFor(TrackDataType.TRACK_POINTS_TABLE); + sampledOutListeners = getListenersFor(TrackDataType.SAMPLED_OUT_TRACK_POINTS); } maxPointId = -1; minPointId = 0; @@ -1020,12 +987,10 @@ public class TrackDataHub { listener.onNewTrackPointsDone(); // Update the listener state - ListenerRegistration registration = dataListeners.getRegistration(listener); - if (registration != null) { - registration.lastTrackId = currentSelectedTrackId; - registration.lastPointId = localLastSeenLocationId; - registration.lastSamplingFrequency = pointSamplingFrequency; - registration.numLoadedPoints = localNumLoadedPoints; + ListenerState listenerState = trackDataManager.getListenerState(listener); + if (listenerState != null) { + listenerState.setState(currentSelectedTrackId, localLastSeenLocationId, + pointSamplingFrequency, localNumLoadedPoints); } } } @@ -1079,17 +1044,17 @@ public class TrackDataHub { listenerHandler.post(runnable); } - private Set getListenersFor(ListenerDataType type) { - synchronized (dataListeners) { - return dataListeners.getListenersFor(type); + private Set getListenersFor(TrackDataType type) { + synchronized (trackDataManager) { + return trackDataManager.getListeners(type); } } - private EnumSet getNeededListenerTypes() { - EnumSet neededTypes = dataListeners.getAllRegisteredTypes(); + private EnumSet getNeededListenerTypes() { + EnumSet neededTypes = trackDataManager.getRegisteredTrackDataTypes(); // We always want preference updates. - neededTypes.add(ListenerDataType.DISPLAY_PREFERENCES); + neededTypes.add(TrackDataType.PREFERENCE); return neededTypes; } diff --git a/MyTracks/src/com/google/android/apps/mytracks/content/TrackDataListeners.java b/MyTracks/src/com/google/android/apps/mytracks/content/TrackDataListeners.java deleted file mode 100644 index 7a85b9eef..000000000 --- a/MyTracks/src/com/google/android/apps/mytracks/content/TrackDataListeners.java +++ /dev/null @@ -1,159 +0,0 @@ -/* - * 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.content; - -import static com.google.android.apps.mytracks.Constants.TAG; - -import com.google.android.apps.mytracks.content.TrackDataHub.ListenerDataType; - -import android.util.Log; - -import java.util.EnumMap; -import java.util.EnumSet; -import java.util.HashMap; -import java.util.LinkedHashSet; -import java.util.Map; -import java.util.Set; - -/** - * Manager for the external data listeners and their listening types. - * - * @author Rodrigo Damazio - */ -class TrackDataListeners { - - /** Internal representation of a listener's registration. */ - static class ListenerRegistration { - final TrackDataListener listener; - final EnumSet types; - - // State that was last notified to the listener, for resuming after a pause. - long lastTrackId; - long lastPointId; - int lastSamplingFrequency; - int numLoadedPoints; - - public ListenerRegistration(TrackDataListener listener, - EnumSet types) { - this.listener = listener; - this.types = types; - } - - public boolean isInterestedIn(ListenerDataType type) { - return types.contains(type); - } - - public void resetState() { - lastTrackId = 0L; - lastPointId = 0L; - lastSamplingFrequency = 0; - numLoadedPoints = 0; - } - - @Override - public String toString() { - return "ListenerRegistration [listener=" + listener + ", types=" + types - + ", lastTrackId=" + lastTrackId + ", lastPointId=" + lastPointId - + ", lastSamplingFrequency=" + lastSamplingFrequency - + ", numLoadedPoints=" + numLoadedPoints + "]"; - } - } - - /** Map of external listener to its registration details. */ - private final Map registeredListeners = - new HashMap(); - - /** Map of data type to external listeners interested in it. */ - private final Map> listenerSetsPerType = - new EnumMap>(ListenerDataType.class); - - public TrackDataListeners() { - // Create sets for all data types at startup. - for (ListenerDataType type : ListenerDataType.values()) { - listenerSetsPerType.put(type, new LinkedHashSet()); - } - } - - /** - * Registers a listener to send data to. - * It is ok to call this method before {@link TrackDataHub#start}, and in that case - * the data will only be passed to listeners when {@link TrackDataHub#start} is called. - * - * @param listener the listener to register - * @param dataTypes the type of data that the listener is interested in - */ - public ListenerRegistration registerTrackDataListener(final TrackDataListener listener, EnumSet dataTypes) { - Log.d(TAG, "Registered track data listener: " + listener); - if (registeredListeners.containsKey(listener)) { - throw new IllegalStateException("Listener already registered"); - } - - ListenerRegistration registration = new ListenerRegistration(listener, dataTypes); - registeredListeners.put(listener, registration); - - for (ListenerDataType type : dataTypes) { - // This is guaranteed not to be null. - Set typeSet = listenerSetsPerType.get(type); - typeSet.add(listener); - } - - return registration; - } - - /** - * Unregisters a listener to send data to. - * - * @param listener the listener to unregister - */ - public void unregisterTrackDataListener(TrackDataListener listener) { - Log.d(TAG, "Unregistered track data listener: " + listener); - // Remove and keep the corresponding registration. - ListenerRegistration match = registeredListeners.remove(listener); - if (match == null) { - Log.w(TAG, "Tried to unregister listener which is not registered."); - return; - } - - // Remove it from the per-type sets - for (ListenerDataType type : match.types) { - listenerSetsPerType.get(type).remove(listener); - } - } - - public ListenerRegistration getRegistration(TrackDataListener listener) { - return registeredListeners.get(listener); - } - - public Set getListenersFor(ListenerDataType type) { - return listenerSetsPerType.get(type); - } - - public EnumSet getAllRegisteredTypes() { - EnumSet listeners = EnumSet.noneOf(ListenerDataType.class); - for (ListenerRegistration registration : this.registeredListeners.values()) { - listeners.addAll(registration.types); - } - return listeners; - } - - public boolean hasListeners() { - return !registeredListeners.isEmpty(); - } - - public int getNumListeners() { - return registeredListeners.size(); - } -} diff --git a/MyTracks/src/com/google/android/apps/mytracks/content/TrackDataManager.java b/MyTracks/src/com/google/android/apps/mytracks/content/TrackDataManager.java new file mode 100644 index 000000000..9c3ededd7 --- /dev/null +++ b/MyTracks/src/com/google/android/apps/mytracks/content/TrackDataManager.java @@ -0,0 +1,127 @@ +/* + * 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.content; + +import static com.google.android.apps.mytracks.Constants.TAG; + +import android.util.Log; + +import java.util.EnumMap; +import java.util.EnumSet; +import java.util.HashMap; +import java.util.LinkedHashSet; +import java.util.Map; +import java.util.Set; + +/** + * Manages register/unregister {@link TrackDataListener} and keeping the state + * for each registered listener. + * + * @author Rodrigo Damazio + */ +public class TrackDataManager { + + // Map of listener to its state + private final Map + listenerToStateMap = new HashMap(); + + // Map of track data type to listeners + private final Map> + typeToListenersMap = new EnumMap>(TrackDataType.class); + + public TrackDataManager() { + for (TrackDataType trackDataType : TrackDataType.values()) { + typeToListenersMap.put(trackDataType, new LinkedHashSet()); + } + } + + /** + * Registers a listener. + * + * @param listener the listener + * @param trackDataTypes the track data types the listener is interested + */ + public ListenerState registerListener( + TrackDataListener listener, EnumSet trackDataTypes) { + if (listenerToStateMap.containsKey(listener)) { + throw new IllegalStateException("Listener is already registered"); + } + + ListenerState listenerState = new ListenerState(listener, trackDataTypes); + listenerToStateMap.put(listener, listenerState); + + for (TrackDataType trackDataType : trackDataTypes) { + typeToListenersMap.get(trackDataType).add(listener); + } + + return listenerState; + } + + /** + * Unregisters a listener. + * + * @param listener the listener + */ + public void unregisterListener(TrackDataListener listener) { + ListenerState removed = listenerToStateMap.remove(listener); + if (removed == null) { + Log.w(TAG, "Tried to unregister a listener that is not registered."); + return; + } + + // Remove the listener from the typeToListenersMap + for (TrackDataType trackDataType : removed.getTrackDataTypes()) { + typeToListenersMap.get(trackDataType).remove(listener); + } + } + + /** + * Gets the number of {@link TrackDataListener}. + */ + public int getNumberOfListeners() { + return listenerToStateMap.size(); + } + + /** + * Gets the track listener state. + * + * @param listener the listener + */ + public ListenerState getListenerState(TrackDataListener listener) { + return listenerToStateMap.get(listener); + } + + /** + * Gets the listeners for a {@link TrackDataType}. + * + * @param type the type + */ + public Set getListeners(TrackDataType type) { + return typeToListenersMap.get(type); + } + + /** + * Gets all the registered {@link TrackDataType}. + */ + public EnumSet getRegisteredTrackDataTypes() { + EnumSet types = EnumSet.noneOf(TrackDataType.class); + for (ListenerState registration : this.listenerToStateMap.values()) { + types.addAll(registration.getTrackDataTypes()); + } + return types; + } +} diff --git a/MyTracks/src/com/google/android/apps/mytracks/content/TrackDataType.java b/MyTracks/src/com/google/android/apps/mytracks/content/TrackDataType.java new file mode 100644 index 000000000..319b5bbc0 --- /dev/null +++ b/MyTracks/src/com/google/android/apps/mytracks/content/TrackDataType.java @@ -0,0 +1,34 @@ +/* + * 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.content; + +/** + * Types of track data. + * + * @author Jimmy Shih + */ +public enum TrackDataType { + + SELECTED_TRACK, // selected track changes + TRACKS_TABLE, // tracks table changes + WAYPOINTS_TABLE, // waypoints table changes + TRACK_POINTS_TABLE, // track points table changes + SAMPLED_OUT_TRACK_POINTS, // sampled-out track points changes + LOCATION, // location changes + COMPASS, // compass changes + PREFERENCE; // preference changes +} \ No newline at end of file diff --git a/MyTracks/src/com/google/android/apps/mytracks/fragments/ChartFragment.java b/MyTracks/src/com/google/android/apps/mytracks/fragments/ChartFragment.java index be9c1ff28..e1dab8720 100644 --- a/MyTracks/src/com/google/android/apps/mytracks/fragments/ChartFragment.java +++ b/MyTracks/src/com/google/android/apps/mytracks/fragments/ChartFragment.java @@ -19,12 +19,12 @@ package com.google.android.apps.mytracks.fragments; import com.google.android.apps.mytracks.ChartView; import com.google.android.apps.mytracks.Constants; import com.google.android.apps.mytracks.MyTracksApplication; +import com.google.android.apps.mytracks.content.TrackDataType; import com.google.android.apps.mytracks.content.MyTracksLocation; import com.google.android.apps.mytracks.content.Sensor; import com.google.android.apps.mytracks.content.Sensor.SensorDataSet; import com.google.android.apps.mytracks.content.Track; import com.google.android.apps.mytracks.content.TrackDataHub; -import com.google.android.apps.mytracks.content.TrackDataHub.ListenerDataType; import com.google.android.apps.mytracks.content.TrackDataListener; import com.google.android.apps.mytracks.content.Waypoint; import com.google.android.apps.mytracks.stats.DoubleBuffer; @@ -360,12 +360,12 @@ public class ChartFragment extends Fragment implements TrackDataListener { private synchronized void resumeTrackDataHub() { trackDataHub = ((MyTracksApplication) getActivity().getApplication()).getTrackDataHub(); trackDataHub.registerTrackDataListener(this, EnumSet.of( - ListenerDataType.SELECTED_TRACK_CHANGED, - ListenerDataType.TRACK_UPDATES, - ListenerDataType.WAYPOINT_UPDATES, - ListenerDataType.POINT_UPDATES, - ListenerDataType.SAMPLED_OUT_POINT_UPDATES, - ListenerDataType.DISPLAY_PREFERENCES)); + TrackDataType.SELECTED_TRACK, + TrackDataType.TRACKS_TABLE, + TrackDataType.WAYPOINTS_TABLE, + TrackDataType.TRACK_POINTS_TABLE, + TrackDataType.SAMPLED_OUT_TRACK_POINTS, + TrackDataType.PREFERENCE)); } /** diff --git a/MyTracks/src/com/google/android/apps/mytracks/fragments/MapFragment.java b/MyTracks/src/com/google/android/apps/mytracks/fragments/MapFragment.java index d0196a512..5a5e5c72c 100644 --- a/MyTracks/src/com/google/android/apps/mytracks/fragments/MapFragment.java +++ b/MyTracks/src/com/google/android/apps/mytracks/fragments/MapFragment.java @@ -19,11 +19,11 @@ package com.google.android.apps.mytracks.fragments; import com.google.android.apps.mytracks.MapOverlay; import com.google.android.apps.mytracks.MyTracksApplication; import com.google.android.apps.mytracks.TrackDetailActivity; +import com.google.android.apps.mytracks.content.TrackDataType; import com.google.android.apps.mytracks.content.MyTracksProviderUtils; import com.google.android.apps.mytracks.content.MyTracksProviderUtils.Factory; import com.google.android.apps.mytracks.content.Track; import com.google.android.apps.mytracks.content.TrackDataHub; -import com.google.android.apps.mytracks.content.TrackDataHub.ListenerDataType; import com.google.android.apps.mytracks.content.TrackDataListener; import com.google.android.apps.mytracks.content.Waypoint; import com.google.android.apps.mytracks.stats.TripStatistics; @@ -420,11 +420,11 @@ public class MapFragment extends Fragment private synchronized void resumeTrackDataHub() { trackDataHub = ((MyTracksApplication) getActivity().getApplication()).getTrackDataHub(); trackDataHub.registerTrackDataListener(this, EnumSet.of( - ListenerDataType.SELECTED_TRACK_CHANGED, - ListenerDataType.WAYPOINT_UPDATES, - ListenerDataType.POINT_UPDATES, - ListenerDataType.LOCATION_UPDATES, - ListenerDataType.COMPASS_UPDATES)); + TrackDataType.SELECTED_TRACK, + TrackDataType.WAYPOINTS_TABLE, + TrackDataType.TRACK_POINTS_TABLE, + TrackDataType.LOCATION, + TrackDataType.COMPASS)); } /** diff --git a/MyTracks/src/com/google/android/apps/mytracks/fragments/StatsFragment.java b/MyTracks/src/com/google/android/apps/mytracks/fragments/StatsFragment.java index 8a00c3c2e..0eaf01a89 100644 --- a/MyTracks/src/com/google/android/apps/mytracks/fragments/StatsFragment.java +++ b/MyTracks/src/com/google/android/apps/mytracks/fragments/StatsFragment.java @@ -17,9 +17,9 @@ package com.google.android.apps.mytracks.fragments; import com.google.android.apps.mytracks.MyTracksApplication; +import com.google.android.apps.mytracks.content.TrackDataType; import com.google.android.apps.mytracks.content.Track; import com.google.android.apps.mytracks.content.TrackDataHub; -import com.google.android.apps.mytracks.content.TrackDataHub.ListenerDataType; import com.google.android.apps.mytracks.content.TrackDataListener; import com.google.android.apps.mytracks.content.Waypoint; import com.google.android.apps.mytracks.stats.TripStatistics; @@ -257,10 +257,10 @@ public class StatsFragment extends Fragment implements TrackDataListener { private synchronized void resumeTrackDataHub() { trackDataHub = ((MyTracksApplication) getActivity().getApplication()).getTrackDataHub(); trackDataHub.registerTrackDataListener(this, EnumSet.of( - ListenerDataType.SELECTED_TRACK_CHANGED, - ListenerDataType.TRACK_UPDATES, - ListenerDataType.LOCATION_UPDATES, - ListenerDataType.DISPLAY_PREFERENCES)); + TrackDataType.SELECTED_TRACK, + TrackDataType.TRACKS_TABLE, + TrackDataType.LOCATION, + TrackDataType.PREFERENCE)); } /** diff --git a/MyTracksTest/src/com/google/android/apps/mytracks/content/TrackDataHubTest.java b/MyTracksTest/src/com/google/android/apps/mytracks/content/TrackDataHubTest.java index cef9e584d..e6ab88ef0 100644 --- a/MyTracksTest/src/com/google/android/apps/mytracks/content/TrackDataHubTest.java +++ b/MyTracksTest/src/com/google/android/apps/mytracks/content/TrackDataHubTest.java @@ -24,7 +24,6 @@ import static com.google.android.testing.mocking.AndroidMock.leq; import com.google.android.apps.mytracks.Constants; import com.google.android.apps.mytracks.content.MyTracksProviderUtils.LocationFactory; import com.google.android.apps.mytracks.content.MyTracksProviderUtils.LocationIterator; -import com.google.android.apps.mytracks.content.TrackDataHub.ListenerDataType; import com.google.android.apps.mytracks.content.TrackDataListener.ProviderState; import com.google.android.apps.mytracks.services.TrackRecordingServiceTest.MockContext; import com.google.android.apps.mytracks.util.PreferencesUtils; @@ -68,7 +67,7 @@ public class TrackDataHubTest extends AndroidTestCase { private MyTracksProviderUtils providerUtils; private TrackDataHub hub; - private TrackDataListeners listeners; + private TrackDataManager trackDataManager; private DataSource dataSource; private SharedPreferences sharedPreferences; private TrackDataListener listener1; @@ -92,8 +91,8 @@ public class TrackDataHubTest extends AndroidTestCase { providerUtils = AndroidMock.createMock("providerUtils", MyTracksProviderUtils.class); dataSource = AndroidMock.createMock("dataSource", DataSource.class, context); - listeners = new TrackDataListeners(); - hub = new TrackDataHub(context, listeners, providerUtils, TARGET_POINTS) { + trackDataManager = new TrackDataManager(); + hub = new TrackDataHub(context, trackDataManager, providerUtils, TARGET_POINTS) { @Override protected DataSource newDataSource() { return dataSource; @@ -152,9 +151,9 @@ public class TrackDataHubTest extends AndroidTestCase { replay(); - hub.registerTrackDataListener(listener1, EnumSet.of(ListenerDataType.TRACK_UPDATES)); + hub.registerTrackDataListener(listener1, EnumSet.of(TrackDataType.TRACKS_TABLE)); hub.start(); - hub.registerTrackDataListener(listener2, EnumSet.of(ListenerDataType.TRACK_UPDATES)); + hub.registerTrackDataListener(listener2, EnumSet.of(TrackDataType.TRACKS_TABLE)); verifyAndReset(); @@ -335,9 +334,9 @@ public class TrackDataHubTest extends AndroidTestCase { replay(); - hub.registerTrackDataListener(listener1, EnumSet.of(ListenerDataType.WAYPOINT_UPDATES)); + hub.registerTrackDataListener(listener1, EnumSet.of(TrackDataType.WAYPOINTS_TABLE)); hub.start(); - hub.registerTrackDataListener(listener2, EnumSet.of(ListenerDataType.WAYPOINT_UPDATES)); + hub.registerTrackDataListener(listener2, EnumSet.of(TrackDataType.WAYPOINTS_TABLE)); verifyAndReset(); @@ -426,7 +425,7 @@ public class TrackDataHubTest extends AndroidTestCase { replay(); hub.start(); - hub.registerTrackDataListener(listener1, EnumSet.of(ListenerDataType.POINT_UPDATES)); + hub.registerTrackDataListener(listener1, EnumSet.of(TrackDataType.TRACK_POINTS_TABLE)); verifyAndReset(); @@ -444,7 +443,7 @@ public class TrackDataHubTest extends AndroidTestCase { replay(); hub.start(); - hub.registerTrackDataListener(listener2, EnumSet.of(ListenerDataType.POINT_UPDATES)); + hub.registerTrackDataListener(listener2, EnumSet.of(TrackDataType.TRACK_POINTS_TABLE)); verifyAndReset(); @@ -511,7 +510,7 @@ public class TrackDataHubTest extends AndroidTestCase { replay(); hub.start(); - hub.registerTrackDataListener(listener1, EnumSet.of(ListenerDataType.POINT_UPDATES)); + hub.registerTrackDataListener(listener1, EnumSet.of(TrackDataType.TRACK_POINTS_TABLE)); verifyAndReset(); @@ -541,7 +540,7 @@ public class TrackDataHubTest extends AndroidTestCase { replay(); - hub.registerTrackDataListener(listener1, EnumSet.of(ListenerDataType.POINT_UPDATES)); + hub.registerTrackDataListener(listener1, EnumSet.of(TrackDataType.TRACK_POINTS_TABLE)); verifyAndReset(); } @@ -566,7 +565,7 @@ public class TrackDataHubTest extends AndroidTestCase { replay(); hub.start(); - hub.registerTrackDataListener(listener1, EnumSet.of(ListenerDataType.POINT_UPDATES)); + hub.registerTrackDataListener(listener1, EnumSet.of(TrackDataType.TRACK_POINTS_TABLE)); verifyAndReset(); @@ -597,7 +596,7 @@ public class TrackDataHubTest extends AndroidTestCase { replay(); hub.loadTrack(TRACK_ID + 1); - hub.registerTrackDataListener(listener1, EnumSet.of(ListenerDataType.POINT_UPDATES)); + hub.registerTrackDataListener(listener1, EnumSet.of(TrackDataType.TRACK_POINTS_TABLE)); verifyAndReset(); } @@ -625,9 +624,9 @@ public class TrackDataHubTest extends AndroidTestCase { replay(); hub.registerTrackDataListener(listener1, - EnumSet.of(ListenerDataType.POINT_UPDATES)); + EnumSet.of(TrackDataType.TRACK_POINTS_TABLE)); hub.registerTrackDataListener(listener2, - EnumSet.of(ListenerDataType.POINT_UPDATES, ListenerDataType.SAMPLED_OUT_POINT_UPDATES)); + EnumSet.of(TrackDataType.TRACK_POINTS_TABLE, TrackDataType.SAMPLED_OUT_TRACK_POINTS)); hub.start(); verifyAndReset(); @@ -654,7 +653,7 @@ public class TrackDataHubTest extends AndroidTestCase { replay(); hub.start(); - hub.registerTrackDataListener(listener1, EnumSet.of(ListenerDataType.POINT_UPDATES)); + hub.registerTrackDataListener(listener1, EnumSet.of(TrackDataType.TRACK_POINTS_TABLE)); verifyAndReset(); @@ -722,7 +721,7 @@ public class TrackDataHubTest extends AndroidTestCase { replay(); hub.registerTrackDataListener(listener1, - EnumSet.of(ListenerDataType.COMPASS_UPDATES, ListenerDataType.LOCATION_UPDATES)); + EnumSet.of(TrackDataType.COMPASS, TrackDataType.LOCATION)); hub.start(); SensorEventListener sensorListener = listenerCapture.getValue(); @@ -791,9 +790,9 @@ public class TrackDataHubTest extends AndroidTestCase { replay(); - hub.registerTrackDataListener(listener1, EnumSet.of(ListenerDataType.DISPLAY_PREFERENCES)); + hub.registerTrackDataListener(listener1, EnumSet.of(TrackDataType.PREFERENCE)); hub.start(); - hub.registerTrackDataListener(listener2, EnumSet.of(ListenerDataType.DISPLAY_PREFERENCES)); + hub.registerTrackDataListener(listener2, EnumSet.of(TrackDataType.PREFERENCE)); verifyAndReset();