1 files changed, 140 insertions, 0 deletions
diff --git a/src/de/danoeh/antennapod/feed/EventDistributor.java b/src/de/danoeh/antennapod/feed/EventDistributor.java
new file mode 100644
index 000000000..1fc7e2c35
--- /dev/null
+++ b/src/de/danoeh/antennapod/feed/EventDistributor.java
@@ -0,0 +1,140 @@
+package de.danoeh.antennapod.feed;
+
+import java.util.AbstractQueue;
+import java.util.Observable;
+import java.util.Observer;
+import java.util.concurrent.ConcurrentLinkedQueue;
+
+import android.os.Handler;
+import android.util.Log;
+import de.danoeh.antennapod.AppConfig;
+
+/**
+ * Notifies its observers about changes in the feed database. Observers can
+ * register by retrieving an instance of this class and registering an
+ * EventListener. When new events arrive, the EventDistributor will process the
+ * event queue in a handler that runs on the main thread. The observers will only
+ * be notified once if the event queue contains multiple elements.
+ * 
+ * Events can be sent with the send* methods.
+ */
+public class EventDistributor extends Observable {
+	private static final String TAG = "EventDistributor";
+
+	public static final int FEED_LIST_UPDATE = 1;
+	public static final int UNREAD_ITEMS_UPDATE = 2;
+	public static final int QUEUE_UPDATE = 4;
+	public static final int DOWNLOADLOG_UPDATE = 8;
+	public static final int PLAYBACK_HISTORY_UPDATE = 16;
+	public static final int DOWNLOAD_QUEUED = 32;
+	public static final int DOWNLOAD_HANDLED = 64;
+
+	private Handler handler;
+	private AbstractQueue<Integer> events;
+
+	private static EventDistributor instance;
+
+	private EventDistributor() {
+		this.handler = new Handler();
+		events = new ConcurrentLinkedQueue<Integer>();
+	}
+
+	public static EventDistributor getInstance() {
+		if (instance == null) {
+			instance = new EventDistributor();
+		}
+		return instance;
+	}
+
+	public void register(EventListener el) {
+		addObserver(el);
+	}
+
+	public void unregister(EventListener el) {
+		deleteObserver(el);
+	}
+
+	public void addEvent(Integer i) {
+		events.offer(i);
+		handler.post(new Runnable() {
+
+			@Override
+			public void run() {
+				processEventQueue();
+			}
+		});
+	}
+
+	private void processEventQueue() {
+		Integer result = 0;
+		if (AppConfig.DEBUG)
+			Log.d(TAG,
+					"Processing event queue. Number of events: "
+							+ events.size());
+		for (Integer current = events.poll(); current != null; current = events
+				.poll()) {
+			result |= current;
+		}
+		if (result != 0) {
+			if (AppConfig.DEBUG)
+				Log.d(TAG, "Notifying observers. Data: " + result);
+			setChanged();
+			notifyObservers(result);
+		} else {
+			if (AppConfig.DEBUG)
+				Log.d(TAG,
+						"Event queue didn't contain any new events. Observers will not be notified.");
+		}
+	}
+
+	@Override
+	public void addObserver(Observer observer) {
+		super.addObserver(observer);
+		if (!(observer instanceof EventListener)) {
+			throw new IllegalArgumentException(
+					"Observer must be instance of FeedManager.EventListener");
+		}
+	}
+
+	public void sendDownloadQueuedBroadcast() {
+		addEvent(DOWNLOAD_QUEUED);
+	}
+
+	public void sendUnreadItemsUpdateBroadcast() {
+		addEvent(UNREAD_ITEMS_UPDATE);
+	}
+
+	public void sendQueueUpdateBroadcast() {
+		addEvent(QUEUE_UPDATE);
+	}
+
+	public void sendFeedUpdateBroadcast() {
+		addEvent(FEED_LIST_UPDATE);
+	}
+
+	public void sendPlaybackHistoryUpdateBroadcast() {
+		addEvent(PLAYBACK_HISTORY_UPDATE);
+	}
+
+	public void sendDownloadLogUpdateBroadcast() {
+		addEvent(DOWNLOADLOG_UPDATE);
+	}
+
+	public void sendDownloadHandledBroadcast() {
+		addEvent(DOWNLOAD_HANDLED);
+	}
+
+	public static abstract class EventListener implements Observer {
+
+		@Override
+		public void update(Observable observable, Object data) {
+			if (observable instanceof EventDistributor
+					&& data instanceof Integer) {
+				update((EventDistributor) observable, (Integer) data);
+			}
+		}
+
+		public abstract void update(EventDistributor eventDistributor,
+				Integer arg);
+	}
+}