michael@0: /* This Source Code Form is subject to the terms of the Mozilla Public
michael@0:  * License, v. 2.0. If a copy of the MPL was not distributed with this
michael@0:  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
michael@0: 
michael@0: package org.mozilla.gecko;
michael@0: 
michael@0: import org.mozilla.gecko.GeckoAppShell;
michael@0: import org.mozilla.gecko.GeckoEvent;
michael@0: import org.mozilla.gecko.util.EventCallback;
michael@0: import org.mozilla.gecko.util.GeckoEventListener;
michael@0: import org.mozilla.gecko.util.NativeEventListener;
michael@0: import org.mozilla.gecko.util.NativeJSContainer;
michael@0: 
michael@0: import org.json.JSONException;
michael@0: import org.json.JSONObject;
michael@0: 
michael@0: import android.util.Log;
michael@0: 
michael@0: import java.util.HashMap;
michael@0: import java.util.List;
michael@0: import java.util.Map;
michael@0: import java.util.concurrent.CopyOnWriteArrayList;
michael@0: 
michael@0: public final class EventDispatcher {
michael@0:     private static final String LOGTAG = "GeckoEventDispatcher";
michael@0:     private static final String GUID = "__guid__";
michael@0:     private static final String STATUS_CANCEL = "cancel";
michael@0:     private static final String STATUS_ERROR = "error";
michael@0:     private static final String STATUS_SUCCESS = "success";
michael@0: 
michael@0:     /**
michael@0:      * The capacity of a HashMap is rounded up to the next power-of-2. Every time the size
michael@0:      * of the map goes beyond 75% of the capacity, the map is rehashed. Therefore, to
michael@0:      * empirically determine the initial capacity that avoids rehashing, we need to
michael@0:      * determine the initial size, divide it by 75%, and round up to the next power-of-2.
michael@0:      */
michael@0:     private static final int GECKO_NATIVE_EVENTS_COUNT = 0; // Default for HashMap
michael@0:     private static final int GECKO_JSON_EVENTS_COUNT = 256; // Empirically measured
michael@0: 
michael@0:     private final Map<String, List<NativeEventListener>> mGeckoThreadNativeListeners =
michael@0:         new HashMap<String, List<NativeEventListener>>(GECKO_NATIVE_EVENTS_COUNT);
michael@0:     private final Map<String, List<GeckoEventListener>> mGeckoThreadJSONListeners =
michael@0:         new HashMap<String, List<GeckoEventListener>>(GECKO_JSON_EVENTS_COUNT);
michael@0: 
michael@0:     private <T> void registerListener(final Class<? extends List<T>> listType,
michael@0:                                       final Map<String, List<T>> listenersMap,
michael@0:                                       final T listener,
michael@0:                                       final String[] events) {
michael@0:         try {
michael@0:             synchronized (listenersMap) {
michael@0:                 for (final String event : events) {
michael@0:                     List<T> listeners = listenersMap.get(event);
michael@0:                     if (listeners == null) {
michael@0:                         listeners = listType.newInstance();
michael@0:                         listenersMap.put(event, listeners);
michael@0:                     }
michael@0:                     if (!AppConstants.RELEASE_BUILD && listeners.contains(listener)) {
michael@0:                         throw new IllegalStateException("Already registered " + event);
michael@0:                     }
michael@0:                     listeners.add(listener);
michael@0:                 }
michael@0:             }
michael@0:         } catch (final IllegalAccessException e) {
michael@0:             throw new IllegalArgumentException("Invalid new list type", e);
michael@0:         } catch (final InstantiationException e) {
michael@0:             throw new IllegalArgumentException("Invalid new list type", e);
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     private <T> void checkNotRegistered(final Map<String, List<T>> listenersMap,
michael@0:                                         final String[] events) {
michael@0:         synchronized (listenersMap) {
michael@0:             for (final String event: events) {
michael@0:                 if (listenersMap.get(event) != null) {
michael@0:                     throw new IllegalStateException(
michael@0:                         "Already registered " + event + " under a different type");
michael@0:                 }
michael@0:             }
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     private <T> void unregisterListener(final Map<String, List<T>> listenersMap,
michael@0:                                         final T listener,
michael@0:                                         final String[] events) {
michael@0:         synchronized (listenersMap) {
michael@0:             for (final String event : events) {
michael@0:                 List<T> listeners = listenersMap.get(event);
michael@0:                 if ((listeners == null ||
michael@0:                      !listeners.remove(listener)) && !AppConstants.RELEASE_BUILD) {
michael@0:                     throw new IllegalArgumentException(event + " was not registered");
michael@0:                 }
michael@0:             }
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     @SuppressWarnings("unchecked")
michael@0:     public void registerGeckoThreadListener(final NativeEventListener listener,
michael@0:                                             final String... events) {
michael@0:         checkNotRegistered(mGeckoThreadJSONListeners, events);
michael@0: 
michael@0:         // For listeners running on the Gecko thread, we want to notify the listeners
michael@0:         // outside of our synchronized block, because the listeners may take an
michael@0:         // indeterminate amount of time to run. Therefore, to ensure concurrency when
michael@0:         // iterating the list outside of the synchronized block, we use a
michael@0:         // CopyOnWriteArrayList.
michael@0:         registerListener((Class)CopyOnWriteArrayList.class,
michael@0:                          mGeckoThreadNativeListeners, listener, events);
michael@0:     }
michael@0: 
michael@0:     @Deprecated // Use NativeEventListener instead
michael@0:     @SuppressWarnings("unchecked")
michael@0:     private void registerGeckoThreadListener(final GeckoEventListener listener,
michael@0:                                              final String... events) {
michael@0:         checkNotRegistered(mGeckoThreadNativeListeners, events);
michael@0: 
michael@0:         registerListener((Class)CopyOnWriteArrayList.class,
michael@0:                          mGeckoThreadJSONListeners, listener, events);
michael@0:     }
michael@0: 
michael@0:     public void unregisterGeckoThreadListener(final NativeEventListener listener,
michael@0:                                               final String... events) {
michael@0:         unregisterListener(mGeckoThreadNativeListeners, listener, events);
michael@0:     }
michael@0: 
michael@0:     @Deprecated // Use NativeEventListener instead
michael@0:     private void unregisterGeckoThreadListener(final GeckoEventListener listener,
michael@0:                                                final String... events) {
michael@0:         unregisterListener(mGeckoThreadJSONListeners, listener, events);
michael@0:     }
michael@0: 
michael@0:     @Deprecated // Use one of the variants above.
michael@0:     public void registerEventListener(final String event, final GeckoEventListener listener) {
michael@0:         registerGeckoThreadListener(listener, event);
michael@0:     }
michael@0: 
michael@0:     @Deprecated // Use one of the variants above
michael@0:     public void unregisterEventListener(final String event, final GeckoEventListener listener) {
michael@0:         unregisterGeckoThreadListener(listener, event);
michael@0:     }
michael@0: 
michael@0:     public void dispatchEvent(final NativeJSContainer message) {
michael@0:         EventCallback callback = null;
michael@0:         try {
michael@0:             // First try native listeners.
michael@0:             final String type = message.getString("type");
michael@0: 
michael@0:             final List<NativeEventListener> listeners;
michael@0:             synchronized (mGeckoThreadNativeListeners) {
michael@0:                 listeners = mGeckoThreadNativeListeners.get(type);
michael@0:             }
michael@0: 
michael@0:             final String guid = message.optString(GUID, null);
michael@0:             if (guid != null) {
michael@0:                 callback = new GeckoEventCallback(guid, type);
michael@0:             }
michael@0: 
michael@0:             if (listeners != null) {
michael@0:                 if (listeners.size() == 0) {
michael@0:                     Log.w(LOGTAG, "No listeners for " + type);
michael@0:                 }
michael@0:                 for (final NativeEventListener listener : listeners) {
michael@0:                     listener.handleMessage(type, message, callback);
michael@0:                 }
michael@0:                 // If we found native listeners, we assume we don't have any JSON listeners
michael@0:                 // and return early. This assumption is checked when registering listeners.
michael@0:                 return;
michael@0:             }
michael@0:         } catch (final IllegalArgumentException e) {
michael@0:             // Message doesn't have a "type" property, fallback to JSON
michael@0:         }
michael@0:         try {
michael@0:             // If we didn't find native listeners, try JSON listeners.
michael@0:             dispatchEvent(new JSONObject(message.toString()), callback);
michael@0:         } catch (final JSONException e) {
michael@0:             Log.e(LOGTAG, "Cannot parse JSON");
michael@0:         } catch (final UnsupportedOperationException e) {
michael@0:             Log.e(LOGTAG, "Cannot convert message to JSON");
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     public void dispatchEvent(final JSONObject message, final EventCallback callback) {
michael@0:         // {
michael@0:         //   "type": "value",
michael@0:         //   "event_specific": "value",
michael@0:         //   ...
michael@0:         try {
michael@0:             final String type = message.getString("type");
michael@0: 
michael@0:             List<GeckoEventListener> listeners;
michael@0:             synchronized (mGeckoThreadJSONListeners) {
michael@0:                 listeners = mGeckoThreadJSONListeners.get(type);
michael@0:             }
michael@0:             if (listeners == null || listeners.size() == 0) {
michael@0:                 Log.w(LOGTAG, "No listeners for " + type);
michael@0: 
michael@0:                 // If there are no listeners, cancel the callback to prevent Gecko-side observers
michael@0:                 // from being leaked.
michael@0:                 if (callback != null) {
michael@0:                     callback.sendCancel();
michael@0:                 }
michael@0:                 return;
michael@0:             }
michael@0:             for (final GeckoEventListener listener : listeners) {
michael@0:                 listener.handleMessage(type, message);
michael@0:             }
michael@0:         } catch (final JSONException e) {
michael@0:             Log.e(LOGTAG, "handleGeckoMessage throws " + e, e);
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     @Deprecated
michael@0:     public static void sendResponse(JSONObject message, Object response) {
michael@0:         sendResponseHelper(STATUS_SUCCESS, message, response);
michael@0:     }
michael@0: 
michael@0:     @Deprecated
michael@0:     public static void sendError(JSONObject message, Object response) {
michael@0:         sendResponseHelper(STATUS_ERROR, message, response);
michael@0:     }
michael@0: 
michael@0:     @Deprecated
michael@0:     private static void sendResponseHelper(String status, JSONObject message, Object response) {
michael@0:         try {
michael@0:             final JSONObject wrapper = new JSONObject();
michael@0:             wrapper.put(GUID, message.getString(GUID));
michael@0:             wrapper.put("status", status);
michael@0:             wrapper.put("response", response);
michael@0:             GeckoAppShell.sendEventToGecko(GeckoEvent.createBroadcastEvent(
michael@0:                     message.getString("type") + ":Response", wrapper.toString()));
michael@0:         } catch (final JSONException e) {
michael@0:             Log.e(LOGTAG, "Unable to send response", e);
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     private static class GeckoEventCallback implements EventCallback {
michael@0:         private final String guid;
michael@0:         private final String type;
michael@0:         private boolean sent;
michael@0: 
michael@0:         public GeckoEventCallback(final String guid, final String type) {
michael@0:             this.guid = guid;
michael@0:             this.type = type;
michael@0:         }
michael@0: 
michael@0:         public void sendSuccess(final Object response) {
michael@0:             sendResponse(STATUS_SUCCESS, response);
michael@0:         }
michael@0: 
michael@0:         public void sendError(final Object response) {
michael@0:             sendResponse(STATUS_ERROR, response);
michael@0:         }
michael@0: 
michael@0:         public void sendCancel() {
michael@0:             sendResponse(STATUS_CANCEL, null);
michael@0:         }
michael@0: 
michael@0:         private void sendResponse(final String status, final Object response) {
michael@0:             if (sent) {
michael@0:                 throw new IllegalStateException("Callback has already been executed for type=" +
michael@0:                         type + ", guid=" + guid);
michael@0:             }
michael@0: 
michael@0:             sent = true;
michael@0: 
michael@0:             try {
michael@0:                 final JSONObject wrapper = new JSONObject();
michael@0:                 wrapper.put(GUID, guid);
michael@0:                 wrapper.put("status", status);
michael@0:                 wrapper.put("response", response);
michael@0:                 GeckoAppShell.sendEventToGecko(GeckoEvent.createBroadcastEvent(type + ":Response",
michael@0:                         wrapper.toString()));
michael@0:             } catch (final JSONException e) {
michael@0:                 Log.e(LOGTAG, "Unable to send response for: " + type, e);
michael@0:             }
michael@0:         }
michael@0:     }
michael@0: }