2012-08-03 02:12:35 +04:00
|
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
|
2014-02-11 21:16:00 +04:00
|
|
|
package org.mozilla.gecko;
|
|
|
|
|
|
|
|
import org.mozilla.gecko.GeckoAppShell;
|
|
|
|
import org.mozilla.gecko.GeckoEvent;
|
|
|
|
import org.mozilla.gecko.util.GeckoEventListener;
|
2014-04-04 20:33:50 +04:00
|
|
|
import org.mozilla.gecko.util.NativeEventListener;
|
|
|
|
import org.mozilla.gecko.util.NativeJSContainer;
|
2012-08-03 02:12:35 +04:00
|
|
|
|
2014-04-04 20:33:50 +04:00
|
|
|
import org.json.JSONException;
|
2012-08-03 02:12:35 +04:00
|
|
|
import org.json.JSONObject;
|
|
|
|
|
|
|
|
import android.util.Log;
|
|
|
|
|
2014-04-04 20:33:50 +04:00
|
|
|
import java.util.ArrayList;
|
2012-08-03 02:12:35 +04:00
|
|
|
import java.util.HashMap;
|
2014-04-04 20:33:50 +04:00
|
|
|
import java.util.List;
|
2012-08-03 02:12:35 +04:00
|
|
|
import java.util.Map;
|
|
|
|
import java.util.concurrent.CopyOnWriteArrayList;
|
|
|
|
|
|
|
|
public final class EventDispatcher {
|
2013-02-25 23:42:06 +04:00
|
|
|
private static final String LOGTAG = "GeckoEventDispatcher";
|
2014-02-11 21:16:00 +04:00
|
|
|
private static final String GUID = "__guid__";
|
2014-03-29 02:03:20 +04:00
|
|
|
private static final String SUFFIX_RETURN = "Return";
|
|
|
|
private static final String SUFFIX_ERROR = "Error";
|
2012-08-03 02:12:35 +04:00
|
|
|
|
2014-04-04 20:33:50 +04:00
|
|
|
/**
|
|
|
|
* The capacity of a HashMap is rounded up to the next power-of-2. Every time the size
|
|
|
|
* of the map goes beyond 75% of the capacity, the map is rehashed. Therefore, to
|
|
|
|
* empirically determine the initial capacity that avoids rehashing, we need to
|
|
|
|
* determine the initial size, divide it by 75%, and round up to the next power-of-2.
|
|
|
|
*/
|
|
|
|
private static final int GECKO_NATIVE_EVENTS_COUNT = 0; // Default for HashMap
|
|
|
|
private static final int GECKO_JSON_EVENTS_COUNT = 256; // Empirically measured
|
|
|
|
|
|
|
|
private final Map<String, List<NativeEventListener>> mGeckoThreadNativeListeners =
|
|
|
|
new HashMap<String, List<NativeEventListener>>(GECKO_NATIVE_EVENTS_COUNT);
|
|
|
|
private final Map<String, List<GeckoEventListener>> mGeckoThreadJSONListeners =
|
|
|
|
new HashMap<String, List<GeckoEventListener>>(GECKO_JSON_EVENTS_COUNT);
|
|
|
|
|
|
|
|
private <T> void registerListener(final Class<? extends List<T>> listType,
|
|
|
|
final Map<String, List<T>> listenersMap,
|
|
|
|
final T listener,
|
|
|
|
final String[] events) {
|
|
|
|
try {
|
|
|
|
synchronized (listenersMap) {
|
|
|
|
for (final String event : events) {
|
|
|
|
List<T> listeners = listenersMap.get(event);
|
|
|
|
if (listeners == null) {
|
|
|
|
listeners = listType.newInstance();
|
|
|
|
listenersMap.put(event, listeners);
|
|
|
|
}
|
2014-04-04 20:33:51 +04:00
|
|
|
if (!AppConstants.RELEASE_BUILD && listeners.contains(listener)) {
|
|
|
|
throw new IllegalStateException("Already registered " + event);
|
|
|
|
}
|
2014-04-04 20:33:50 +04:00
|
|
|
listeners.add(listener);
|
|
|
|
}
|
2012-08-03 02:12:35 +04:00
|
|
|
}
|
2014-04-04 20:33:50 +04:00
|
|
|
} catch (final IllegalAccessException e) {
|
|
|
|
throw new IllegalArgumentException("Invalid new list type", e);
|
|
|
|
} catch (final InstantiationException e) {
|
|
|
|
throw new IllegalArgumentException("Invalid new list type", e);
|
2012-08-03 02:12:35 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-04 20:33:50 +04:00
|
|
|
private <T> void checkNotRegistered(final Map<String, List<T>> listenersMap,
|
|
|
|
final String[] events) {
|
|
|
|
synchronized (listenersMap) {
|
|
|
|
for (final String event: events) {
|
|
|
|
if (listenersMap.get(event) != null) {
|
|
|
|
throw new IllegalStateException(
|
|
|
|
"Already registered " + event + " under a different type");
|
|
|
|
}
|
2013-04-03 01:28:59 +04:00
|
|
|
}
|
2014-04-04 20:33:50 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private <T> void unregisterListener(final Map<String, List<T>> listenersMap,
|
|
|
|
final T listener,
|
|
|
|
final String[] events) {
|
|
|
|
synchronized (listenersMap) {
|
|
|
|
for (final String event : events) {
|
|
|
|
List<T> listeners = listenersMap.get(event);
|
2014-04-04 20:33:51 +04:00
|
|
|
if ((listeners == null ||
|
|
|
|
!listeners.remove(listener)) && !AppConstants.RELEASE_BUILD) {
|
2014-04-04 20:33:50 +04:00
|
|
|
throw new IllegalArgumentException(event + " was not registered");
|
|
|
|
}
|
2012-08-03 02:12:35 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-04 20:33:50 +04:00
|
|
|
@SuppressWarnings("unchecked")
|
|
|
|
public void registerGeckoThreadListener(final NativeEventListener listener,
|
|
|
|
final String... events) {
|
|
|
|
checkNotRegistered(mGeckoThreadJSONListeners, events);
|
|
|
|
|
|
|
|
// For listeners running on the Gecko thread, we want to notify the listeners
|
|
|
|
// outside of our synchronized block, because the listeners may take an
|
|
|
|
// indeterminate amount of time to run. Therefore, to ensure concurrency when
|
|
|
|
// iterating the list outside of the synchronized block, we use a
|
|
|
|
// CopyOnWriteArrayList.
|
|
|
|
registerListener((Class)CopyOnWriteArrayList.class,
|
|
|
|
mGeckoThreadNativeListeners, listener, events);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Deprecated // Use NativeEventListener instead
|
|
|
|
@SuppressWarnings("unchecked")
|
|
|
|
private void registerGeckoThreadListener(final GeckoEventListener listener,
|
|
|
|
final String... events) {
|
|
|
|
checkNotRegistered(mGeckoThreadNativeListeners, events);
|
|
|
|
|
|
|
|
registerListener((Class)CopyOnWriteArrayList.class,
|
|
|
|
mGeckoThreadJSONListeners, listener, events);
|
|
|
|
}
|
|
|
|
|
|
|
|
public void unregisterGeckoThreadListener(final NativeEventListener listener,
|
|
|
|
final String... events) {
|
|
|
|
unregisterListener(mGeckoThreadNativeListeners, listener, events);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Deprecated // Use NativeEventListener instead
|
|
|
|
private void unregisterGeckoThreadListener(final GeckoEventListener listener,
|
|
|
|
final String... events) {
|
|
|
|
unregisterListener(mGeckoThreadJSONListeners, listener, events);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Deprecated // Use one of the variants above.
|
|
|
|
public void registerEventListener(final String event, final GeckoEventListener listener) {
|
|
|
|
registerGeckoThreadListener(listener, event);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Deprecated // Use one of the variants above
|
|
|
|
public void unregisterEventListener(final String event, final GeckoEventListener listener) {
|
|
|
|
unregisterGeckoThreadListener(listener, event);
|
|
|
|
}
|
|
|
|
|
|
|
|
public void dispatchEvent(final NativeJSContainer message) {
|
2013-05-31 04:42:56 +04:00
|
|
|
try {
|
2014-04-04 20:33:50 +04:00
|
|
|
// First try native listeners.
|
|
|
|
final String type = message.getString("type");
|
|
|
|
|
|
|
|
final List<NativeEventListener> listeners;
|
|
|
|
synchronized (mGeckoThreadNativeListeners) {
|
|
|
|
listeners = mGeckoThreadNativeListeners.get(type);
|
|
|
|
}
|
|
|
|
if (listeners != null) {
|
|
|
|
if (listeners.size() == 0) {
|
|
|
|
Log.w(LOGTAG, "No listeners for " + type);
|
|
|
|
}
|
|
|
|
for (final NativeEventListener listener : listeners) {
|
|
|
|
listener.handleMessage(type, message);
|
|
|
|
}
|
|
|
|
// If we found native listeners, we assume we don't have any JSON listeners
|
|
|
|
// and return early. This assumption is checked when registering listeners.
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
} catch (final IllegalArgumentException e) {
|
|
|
|
// Message doesn't have a "type" property, fallback to JSON
|
|
|
|
}
|
|
|
|
try {
|
|
|
|
// If we didn't find native listeners, try JSON listeners.
|
|
|
|
dispatchEvent(new JSONObject(message.toString()));
|
|
|
|
} catch (final JSONException e) {
|
|
|
|
Log.e(LOGTAG, "Cannot parse JSON");
|
|
|
|
} catch (final UnsupportedOperationException e) {
|
|
|
|
Log.e(LOGTAG, "Cannot convert message to JSON");
|
2013-05-31 04:42:56 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-04 20:33:50 +04:00
|
|
|
public void dispatchEvent(final JSONObject message) {
|
2013-02-02 05:36:38 +04:00
|
|
|
// {
|
|
|
|
// "type": "value",
|
|
|
|
// "event_specific": "value",
|
|
|
|
// ...
|
2012-08-03 02:12:35 +04:00
|
|
|
try {
|
2014-04-04 20:33:50 +04:00
|
|
|
final String type = message.getString("type");
|
2013-04-03 01:28:59 +04:00
|
|
|
|
2014-04-04 20:33:50 +04:00
|
|
|
List<GeckoEventListener> listeners;
|
|
|
|
synchronized (mGeckoThreadJSONListeners) {
|
|
|
|
listeners = mGeckoThreadJSONListeners.get(type);
|
2012-08-03 02:12:35 +04:00
|
|
|
}
|
2013-04-03 01:28:59 +04:00
|
|
|
if (listeners == null || listeners.size() == 0) {
|
2014-04-04 20:33:50 +04:00
|
|
|
Log.w(LOGTAG, "No listeners for " + type);
|
2014-02-11 21:16:00 +04:00
|
|
|
return;
|
2013-04-03 01:28:59 +04:00
|
|
|
}
|
2014-04-04 20:33:50 +04:00
|
|
|
for (final GeckoEventListener listener : listeners) {
|
|
|
|
listener.handleMessage(type, message);
|
2012-08-03 02:12:35 +04:00
|
|
|
}
|
2014-04-04 20:33:50 +04:00
|
|
|
} catch (final JSONException e) {
|
2012-08-03 02:12:35 +04:00
|
|
|
Log.e(LOGTAG, "handleGeckoMessage throws " + e, e);
|
|
|
|
}
|
2014-02-11 21:16:00 +04:00
|
|
|
}
|
|
|
|
|
2014-03-29 02:03:20 +04:00
|
|
|
public static void sendResponse(JSONObject message, Object response) {
|
|
|
|
sendResponseHelper(SUFFIX_RETURN, message, response);
|
2014-02-11 21:16:00 +04:00
|
|
|
}
|
|
|
|
|
2014-03-29 02:03:20 +04:00
|
|
|
public static void sendError(JSONObject message, Object response) {
|
|
|
|
sendResponseHelper(SUFFIX_ERROR, message, response);
|
|
|
|
}
|
|
|
|
|
|
|
|
private static void sendResponseHelper(String suffix, JSONObject message, Object response) {
|
2014-02-11 21:16:00 +04:00
|
|
|
try {
|
2014-03-29 02:03:20 +04:00
|
|
|
final JSONObject wrapper = new JSONObject();
|
|
|
|
wrapper.put(GUID, message.getString(GUID));
|
|
|
|
wrapper.put("response", response);
|
|
|
|
GeckoAppShell.sendEventToGecko(GeckoEvent.createBroadcastEvent(message.getString("type") + ":" + suffix, wrapper.toString()));
|
|
|
|
} catch (Exception e) {
|
|
|
|
Log.e(LOGTAG, "Unable to send " + suffix, e);
|
2014-02-25 17:19:41 +04:00
|
|
|
}
|
2012-08-03 02:12:35 +04:00
|
|
|
}
|
|
|
|
}
|