Clean up TrackDataManager and TrackDataType.

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<ListenerDataType> registeredListeners = EnumSet.noneOf(ListenerDataType.class);
+  private final Set<TrackDataType> 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<ListenerDataType> listeners) {
-    EnumSet<ListenerDataType> neededListeners = EnumSet.copyOf(listeners);
+  public void updateListeners(EnumSet<TrackDataType> listeners) {
+    EnumSet<TrackDataType> 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<ListenerDataType> unnecessaryListeners = EnumSet.copyOf(registeredListeners);
+    Set<TrackDataType> unnecessaryListeners = EnumSet.copyOf(registeredListeners);
     unnecessaryListeners.removeAll(neededListeners);
 
     // Missing = needed - registered
-    Set<ListenerDataType> missingListeners = EnumSet.copyOf(neededListeners);
+    Set<TrackDataType> 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);
     }
   }
 }

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<TrackDataType> trackDataTypes;
+
+  private long lastTrackId;
+  private long lastPointId;
+  private int lastSamplingFrequency;
+  private int numberOfLoadedPoints;
+
+  public ListenerState(
+      TrackDataListener trackDataListener, EnumSet<TrackDataType> trackDataTypes) {
+    this.trackDataListener = trackDataListener;
+    this.trackDataTypes = trackDataTypes;
+  }
+
+  /**
+   * Gets the {@link TrackDataListener}.
+   */
+  public TrackDataListener getTrackDataListener() {
+    return trackDataListener;
+  }
+
+  /**
+   * Gets the track data types.
+   */
+  public EnumSet<TrackDataType> 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);
+  }
+}

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<ListenerDataType> dataTypes) {
-    synchronized (dataListeners) {
-      ListenerRegistration registration =
-          dataListeners.registerTrackDataListener(listener, dataTypes);
+      TrackDataListener listener, EnumSet<TrackDataType> 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<TrackDataListener> listenerSet = Collections.singleton(listener);
 
-        if (registration.isInterestedIn(ListenerDataType.DISPLAY_PREFERENCES)) {
+        EnumSet<TrackDataType> 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<TrackDataListener> pointListeners =
-            getListenersFor(ListenerDataType.POINT_UPDATES);
+            getListenersFor(TrackDataType.TRACK_POINTS_TABLE);
         Set<TrackDataListener> 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<TrackDataListener> 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<TrackDataListener> displayListeners = getListenersFor(ListenerDataType.DISPLAY_PREFERENCES);
+        Set<TrackDataListener> 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<TrackDataListener> getListenersFor(ListenerDataType type) {
-    synchronized (dataListeners) {
-      return dataListeners.getListenersFor(type);
+  private Set<TrackDataListener> getListenersFor(TrackDataType type) {
+    synchronized (trackDataManager) {
+      return trackDataManager.getListeners(type);
     }
   }
 
-  private EnumSet<ListenerDataType> getNeededListenerTypes() {
-    EnumSet<ListenerDataType> neededTypes = dataListeners.getAllRegisteredTypes();
+  private EnumSet<TrackDataType> getNeededListenerTypes() {
+    EnumSet<TrackDataType> neededTypes = trackDataManager.getRegisteredTrackDataTypes();
 
     // We always want preference updates.
-    neededTypes.add(ListenerDataType.DISPLAY_PREFERENCES);
+    neededTypes.add(TrackDataType.PREFERENCE);
 
     return neededTypes;
   }

MyTracks/src/com/google/android/apps/mytracks/content/TrackDataListeners.java

@@ -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<ListenerDataType> 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<ListenerDataType> 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<TrackDataListener, ListenerRegistration> registeredListeners =
-      new HashMap<TrackDataListener, ListenerRegistration>();
-
-  /** Map of data type to external listeners interested in it. */
-  private final Map<ListenerDataType, Set<TrackDataListener>> listenerSetsPerType =
-      new EnumMap<ListenerDataType, Set<TrackDataListener>>(ListenerDataType.class);
-
-  public TrackDataListeners() {
-    // Create sets for all data types at startup.
-    for (ListenerDataType type : ListenerDataType.values()) {
-      listenerSetsPerType.put(type, new LinkedHashSet<TrackDataListener>());
-    }
-  }
-
-  /**
-   * 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<ListenerDataType> 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<TrackDataListener> 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<TrackDataListener> getListenersFor(ListenerDataType type) {
-    return listenerSetsPerType.get(type);
-  }
-
-  public EnumSet<ListenerDataType> getAllRegisteredTypes() {
-    EnumSet<ListenerDataType> 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();
-  }
-}

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<TrackDataListener, ListenerState>
+      listenerToStateMap = new HashMap<TrackDataListener, ListenerState>();
+
+  // Map of track data type to listeners
+  private final Map<TrackDataType, Set<TrackDataListener>>
+      typeToListenersMap = new EnumMap<TrackDataType, Set<TrackDataListener>>(TrackDataType.class);
+
+  public TrackDataManager() {
+    for (TrackDataType trackDataType : TrackDataType.values()) {
+      typeToListenersMap.put(trackDataType, new LinkedHashSet<TrackDataListener>());
+    }
+  }
+
+  /**
+   * Registers a listener.
+   * 
+   * @param listener the listener
+   * @param trackDataTypes the track data types the listener is interested
+   */
+  public ListenerState registerListener(
+      TrackDataListener listener, EnumSet<TrackDataType> 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<TrackDataListener> getListeners(TrackDataType type) {
+    return typeToListenersMap.get(type);
+  }
+
+  /**
+   * Gets all the registered {@link TrackDataType}.
+   */
+  public EnumSet<TrackDataType> getRegisteredTrackDataTypes() {
+    EnumSet<TrackDataType> types = EnumSet.noneOf(TrackDataType.class);
+    for (ListenerState registration : this.listenerToStateMap.values()) {
+      types.addAll(registration.getTrackDataTypes());
+    }
+    return types;
+  }
+}

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
+}

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));
   }
 
   /**

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));
   }
   
   /**

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));
   }
 
   /**

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();