OpenTracks/src/main/java/de/dennisguse/opentracks/content/TrackDataManager.java

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

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
 */
class TrackDataManager {

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

    private final Map<TrackDataListener, EnumSet<TrackDataType>> listenerToTypesMap = new HashMap<>();

    private final Map<TrackDataType, Set<TrackDataListener>> typeToListenersMap = new EnumMap<>(TrackDataType.class);

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

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

    /**
     * Gets the number of {@link TrackDataListener}.
     */
    int getNumberOfListeners() {
        return listenerToTypesMap.size();
    }

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

    /**
     * Gets the listeners for a {@link TrackDataType}.
     *
     * @param type the type
     */
    Set<TrackDataListener> getListeners(TrackDataType type) {
        return typeToListenersMap.get(type);
    }

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