Removed TrackDataType and simplified TrackDataManager.

2020-04-02 22:36:00 +02:00
parent 70bc8f33b1
commit 46f8753746
3 changed files with 65 additions and 126 deletions
@@ -28,7 +28,6 @@ import android.util.Log;
 import androidx.annotation.VisibleForTesting;

 import java.util.Collections;
-import java.util.EnumSet;
 import java.util.Set;

 import de.dennisguse.opentracks.R;
@@ -118,7 +117,7 @@ public class TrackDataHub implements SharedPreferences.OnSharedPreferenceChangeL
        tracksTableObserver = new ContentObserver(handler) {
            @Override
            public void onChange(boolean selfChange) {
-                notifyTracksTableUpdate(trackDataManager.getListeners(TrackDataType.TRACKS_TABLE));
+                notifyTracksTableUpdate(trackDataManager.getListenerTracks());
            }
        };
        contentResolver.registerContentObserver(TracksColumns.CONTENT_URI, false, tracksTableObserver);
@@ -126,7 +125,7 @@ public class TrackDataHub implements SharedPreferences.OnSharedPreferenceChangeL
        waypointsTableObserver = new ContentObserver(handler) {
            @Override
            public void onChange(boolean selfChange) {
-                notifyWaypointsTableUpdate(trackDataManager.getListeners(TrackDataType.WAYPOINTS_TABLE));
+                notifyWaypointsTableUpdate(trackDataManager.getListenerWaypoints());
            }
        };
        contentResolver.registerContentObserver(WaypointsColumns.CONTENT_URI, false, waypointsTableObserver);
@@ -134,7 +133,7 @@ public class TrackDataHub implements SharedPreferences.OnSharedPreferenceChangeL
        trackPointsTableObserver = new ContentObserver(handler) {
            @Override
            public void onChange(boolean selfChange) {
-                notifyTrackPointsTableUpdate(true, trackDataManager.getListeners(TrackDataType.SAMPLED_IN_TRACK_POINTS_TABLE), trackDataManager.getListeners(TrackDataType.SAMPLED_OUT_TRACK_POINTS_TABLE));
+                notifyTrackPointsTableUpdate(true, trackDataManager.getListenerTrackPoints_SampledIn(), trackDataManager.getListenerTrackPoints_SampledOut());
            }
        };
        contentResolver.registerContentObserver(TrackPointsColumns.CONTENT_URI_BY_ID, false, trackPointsTableObserver);
@@ -194,17 +193,11 @@ public class TrackDataHub implements SharedPreferences.OnSharedPreferenceChangeL
     *
     * @param trackDataListener the track data listener
     */
-    public void registerTrackDataListener(final TrackDataListener trackDataListener, boolean tracksTable, boolean waypointTable, boolean trackPointsTable_SampleIn, boolean trackPointsTable_SampleOut) {
-        final EnumSet<TrackDataType> types = EnumSet.noneOf(TrackDataType.class);
-        if (tracksTable) types.add(TrackDataType.TRACKS_TABLE);
-        if (waypointTable) types.add(TrackDataType.WAYPOINTS_TABLE);
-        if (trackPointsTable_SampleIn) types.add(TrackDataType.SAMPLED_IN_TRACK_POINTS_TABLE);
-        if (trackPointsTable_SampleOut) types.add(TrackDataType.SAMPLED_OUT_TRACK_POINTS_TABLE);
-
+    public void registerTrackDataListener(final TrackDataListener trackDataListener, final boolean tracksTable, final boolean waypointsTable, final boolean trackPointsTable_SampleIn, final boolean trackPointsTable_SampleOut) {
        runInHandlerThread(new Runnable() {
            @Override
            public void run() {
-                trackDataManager.registerListener(trackDataListener, types);
+                trackDataManager.registerTrackDataListener(trackDataListener, tracksTable, waypointsTable, trackPointsTable_SampleIn, trackPointsTable_SampleOut);
                if (started) {
                    loadDataForListener(trackDataListener);
                }
@@ -221,7 +214,7 @@ public class TrackDataHub implements SharedPreferences.OnSharedPreferenceChangeL
        runInHandlerThread(new Runnable() {
            @Override
            public void run() {
-                trackDataManager.unregisterListener(trackDataListener);
+                trackDataManager.unregisterTrackDataListener(trackDataListener);
            }
        });
    }
@@ -272,19 +265,17 @@ public class TrackDataHub implements SharedPreferences.OnSharedPreferenceChangeL
     */
    private void loadDataForAll() {
        resetSamplingState();
-        if (trackDataManager.getNumberOfListeners() == 0) {
+        if (!trackDataManager.hasListeners()) {
            return;
        }

-        notifyTracksTableUpdate(trackDataManager.getListeners(TrackDataType.TRACKS_TABLE));
+        notifyTracksTableUpdate(trackDataManager.getListenerTracks());

-        for (TrackDataListener listener : trackDataManager.getListeners(TrackDataType.SAMPLED_IN_TRACK_POINTS_TABLE)) {
+        for (TrackDataListener listener : trackDataManager.getListenerTrackPoints_SampledIn()) {
            listener.clearTrackPoints();
        }
-        notifyTrackPointsTableUpdate(true,
-                trackDataManager.getListeners(TrackDataType.SAMPLED_IN_TRACK_POINTS_TABLE),
-                trackDataManager.getListeners(TrackDataType.SAMPLED_OUT_TRACK_POINTS_TABLE));
-        notifyWaypointsTableUpdate(trackDataManager.getListeners(TrackDataType.WAYPOINTS_TABLE));
+        notifyTrackPointsTableUpdate(true, trackDataManager.getListenerTrackPoints_SampledIn(), trackDataManager.getListenerTrackPoints_SampledOut());
+        notifyWaypointsTableUpdate(trackDataManager.getListenerWaypoints());
    }

    /**
@@ -294,14 +285,13 @@ public class TrackDataHub implements SharedPreferences.OnSharedPreferenceChangeL
     */
    private void loadDataForListener(TrackDataListener trackDataListener) {
        Set<TrackDataListener> trackDataListeners = Collections.singleton(trackDataListener);
-        EnumSet<TrackDataType> trackDataTypes = trackDataManager.getTrackDataTypes(trackDataListener);

-        if (trackDataTypes.contains(TrackDataType.TRACKS_TABLE)) {
+        if (trackDataManager.listensForTracks(trackDataListener)) {
            notifyTracksTableUpdate(trackDataListeners);
        }

-        boolean hasSampledIn = trackDataTypes.contains(TrackDataType.SAMPLED_IN_TRACK_POINTS_TABLE);
-        boolean hasSampledOut = trackDataTypes.contains(TrackDataType.SAMPLED_OUT_TRACK_POINTS_TABLE);
+        boolean hasSampledIn = trackDataManager.listensForTrackPoints_SampledIn(trackDataListener);
+        boolean hasSampledOut = trackDataManager.listensForTrackPoints_SampledOut(trackDataListener);
        if (hasSampledIn || hasSampledOut) {
            trackDataListener.clearTrackPoints();
            boolean isOnlyListener = trackDataManager.getNumberOfListeners() == 1;
@@ -312,7 +302,7 @@ public class TrackDataHub implements SharedPreferences.OnSharedPreferenceChangeL
            notifyTrackPointsTableUpdate(isOnlyListener, trackDataListeners, sampledOutListeners);
        }

-        if (trackDataTypes.contains(TrackDataType.WAYPOINTS_TABLE)) {
+        if (trackDataManager.listensForWaypoints(trackDataListener)) {
            notifyWaypointsTableUpdate(trackDataListeners);
        }
    }
@@ -16,13 +16,7 @@

 package de.dennisguse.opentracks.content;

-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.HashSet;
 import java.util.Set;

 /**
@@ -34,84 +28,68 @@ class TrackDataManager {

    private static final String TAG = TrackDataManager.class.getSimpleName();

-    private final Map<TrackDataListener, EnumSet<TrackDataType>> listenerToTypesMap = new HashMap<>();
+    private final Set<TrackDataListener> dataListenerTracks = new HashSet<>();
+    private final Set<TrackDataListener> dataListenerWaypoints = new HashSet<>();
+    private final Set<TrackDataListener> dataListenerTrackPoints_SampledIn = new HashSet<>();
+    private final Set<TrackDataListener> dataListenerTrackPoints_SampledOut = new HashSet<>();

-    private final Map<TrackDataType, Set<TrackDataListener>> typeToListenersMap = new EnumMap<>(TrackDataType.class);
-
-    TrackDataManager() {
-        for (TrackDataType trackDataType : TrackDataType.values()) {
-            typeToListenersMap.put(trackDataType, new LinkedHashSet<TrackDataListener>());
-        }
+    void registerTrackDataListener(final TrackDataListener trackDataListener, boolean tracksTable, boolean waypointsTable, boolean trackPointsTable_SampleIn, boolean trackPointsTable_SampleOut) {
+        if (tracksTable) dataListenerTracks.add(trackDataListener);
+        if (waypointsTable) dataListenerWaypoints.add(trackDataListener);
+        if (trackPointsTable_SampleIn) dataListenerTrackPoints_SampledIn.add(trackDataListener);
+        if (trackPointsTable_SampleOut) dataListenerTrackPoints_SampledOut.add(trackDataListener);
    }

-    /**
-     * Registers a listener.
-     *
-     * @param listener       the listener
-     * @param trackDataTypes the track data types the listener is interested
-     */
-    void registerListener(TrackDataListener listener, EnumSet<TrackDataType> trackDataTypes) {
-        if (listenerToTypesMap.containsKey(listener)) {
-            Log.w(TAG, "Tried to register a listener that is already registered. Ignore.");
-            return;
-        }
-        listenerToTypesMap.put(listener, trackDataTypes);
-        for (TrackDataType trackDataType : trackDataTypes) {
-            typeToListenersMap.get(trackDataType).add(listener);
-        }
+    void unregisterTrackDataListener(TrackDataListener trackDataListener) {
+        dataListenerTracks.add(trackDataListener);
+        dataListenerWaypoints.add(trackDataListener);
+        dataListenerTrackPoints_SampledIn.add(trackDataListener);
+        dataListenerTrackPoints_SampledOut.add(trackDataListener);
    }

-    /**
-     * Unregisters a listener.
-     *
-     * @param listener the listener
-     */
-    void unregisterListener(TrackDataListener listener) {
-        EnumSet<TrackDataType> removedTypes = listenerToTypesMap.remove(listener);
-        if (removedTypes == null) {
-            Log.w(TAG, "Tried to unregister a listener that is not registered. Ignore.");
-            return;
-        }
-
-        // Remove the listener from the typeToListenersMap
-        for (TrackDataType trackDataType : removedTypes) {
-            typeToListenersMap.get(trackDataType).remove(listener);
-        }
+    boolean hasListeners() {
+        return dataListenerTracks.size() + dataListenerWaypoints.size() + dataListenerTrackPoints_SampledIn.size() + dataListenerTrackPoints_SampledOut.size() > 0;
    }

-    /**
-     * Gets the number of {@link TrackDataListener}.
-     */
    int getNumberOfListeners() {
-        return listenerToTypesMap.size();
+        Set<TrackDataListener> listener = new HashSet<>();
+        listener.addAll(dataListenerTracks);
+        listener.addAll(dataListenerWaypoints);
+        listener.addAll(dataListenerTrackPoints_SampledIn);
+        listener.addAll(dataListenerTrackPoints_SampledOut);
+
+        return listener.size();
    }

-    /**
-     * Gets the track data types for a listener.
-     *
-     * @param listener the listener
-     */
-    EnumSet<TrackDataType> getTrackDataTypes(TrackDataListener listener) {
-        return listenerToTypesMap.get(listener);
+    boolean listensForTracks(TrackDataListener listener) {
+        return dataListenerTracks.contains(listener);
    }

-    /**
-     * Gets the listeners for a {@link TrackDataType}.
-     *
-     * @param type the type
-     */
-    Set<TrackDataListener> getListeners(TrackDataType type) {
-        return typeToListenersMap.get(type);
+    boolean listensForWaypoints(TrackDataListener listener) {
+        return dataListenerWaypoints.contains(listener);
    }

-    /**
-     * Gets all the registered {@link TrackDataType}.
-     */
-    EnumSet<TrackDataType> getRegisteredTrackDataTypes() {
-        EnumSet<TrackDataType> types = EnumSet.noneOf(TrackDataType.class);
-        for (EnumSet<TrackDataType> value : listenerToTypesMap.values()) {
-            types.addAll(value);
-        }
-        return types;
+    boolean listensForTrackPoints_SampledIn(TrackDataListener listener) {
+        return dataListenerTrackPoints_SampledIn.contains(listener);
+    }
+
+    boolean listensForTrackPoints_SampledOut(TrackDataListener listener) {
+        return dataListenerTrackPoints_SampledOut.contains(listener);
+    }
+
+    Set<TrackDataListener> getListenerTracks() {
+        return dataListenerTracks;
+    }
+
+    Set<TrackDataListener> getListenerWaypoints() {
+        return dataListenerWaypoints;
+    }
+
+    Set<TrackDataListener> getListenerTrackPoints_SampledIn() {
+        return dataListenerTrackPoints_SampledIn;
+    }
+
+    Set<TrackDataListener> getListenerTrackPoints_SampledOut() {
+        return dataListenerTrackPoints_SampledOut;
    }
 }
@@ -1,29 +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 de.dennisguse.opentracks.content;
-
-/**
- * Types of track data.
- *
- * @author Jimmy Shih
- */
-enum TrackDataType {
-    TRACKS_TABLE, // tracks table changes
-    WAYPOINTS_TABLE, // waypoints table changes
-    SAMPLED_IN_TRACK_POINTS_TABLE, // sampled-in track points table changes
-    SAMPLED_OUT_TRACK_POINTS_TABLE, // sampled-out track points table changes
-}