@thathoff/cordova-plugin-universal-links 0.3.0

package/src/android/com/nordnetab/cordova/ul/UniversalLinksPlugin.java

@@ -0,0 +1,221 @@
+package com.nordnetab.cordova.ul;
+
+import android.content.Intent;
+import android.net.Uri;
+import android.text.TextUtils;
+import android.util.Log;
+
+import com.nordnetab.cordova.ul.js.JSAction;
+import com.nordnetab.cordova.ul.model.JSMessage;
+import com.nordnetab.cordova.ul.model.ULHost;
+import com.nordnetab.cordova.ul.parser.ULConfigXmlParser;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaArgs;
+import org.apache.cordova.CordovaInterface;
+import org.apache.cordova.CordovaPlugin;
+import org.apache.cordova.CordovaWebView;
+import org.apache.cordova.PluginResult;
+import org.json.JSONException;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Created by Nikolay Demyankov on 09.09.15.
+ * <p/>
+ * Plugin main class.
+ * Communicates with the JS side, handles launch intents and so on.
+ */
+public class UniversalLinksPlugin extends CordovaPlugin {
+
+    // list of hosts, defined in config.xml
+    private List<ULHost> supportedHosts;
+
+    // list of subscribers
+    private Map<String, CallbackContext> subscribers;
+
+    // stored message, that is captured on application launch
+    private JSMessage storedMessage;
+
+    // region Public API
+
+    @Override
+    public void initialize(CordovaInterface cordova, CordovaWebView webView) {
+        super.initialize(cordova, webView);
+
+        supportedHosts = new ULConfigXmlParser(cordova.getActivity()).parse();
+
+        if (subscribers == null) {
+            subscribers = new HashMap<String, CallbackContext>();
+        }
+
+        handleIntent(cordova.getActivity().getIntent());
+    }
+
+    @Override
+    public boolean execute(String action, CordovaArgs args, CallbackContext callbackContext) throws JSONException {
+        boolean isHandled = true;
+        if (JSAction.SUBSCRIBE.equals(action)) {
+            subscribeForEvent(args, callbackContext);
+        } else if (JSAction.UNSUBSCRIBE.equals(action)) {
+            unsubscribeFromEvent(args);
+        } else {
+            isHandled = false;
+        }
+
+        return isHandled;
+    }
+
+    @Override
+    public void onNewIntent(Intent intent) {
+        handleIntent(intent);
+    }
+
+    // endregion
+
+    // region JavaScript methods
+
+    /**
+     * Add subscriber for the event.
+     *
+     * @param arguments       arguments, passed from JS side
+     * @param callbackContext callback to use when event is captured
+     */
+    private void subscribeForEvent(final CordovaArgs arguments, final CallbackContext callbackContext) {
+        final String eventName = getEventNameFromArguments(arguments);
+        if (TextUtils.isEmpty(eventName)) {
+            return;
+        }
+
+        subscribers.put(eventName, callbackContext);
+        tryToConsumeEvent();
+    }
+
+    /**
+     * Remove subscriber from the event.
+     *
+     * @param arguments arguments, passed from JS side
+     */
+    private void unsubscribeFromEvent(final CordovaArgs arguments) {
+        if (subscribers.size() == 0) {
+            return;
+        }
+
+        final String eventName = getEventNameFromArguments(arguments);
+        if (TextUtils.isEmpty(eventName)) {
+            return;
+        }
+
+        subscribers.remove(eventName);
+    }
+
+    /**
+     * Get event name from the cordova arguments.
+     *
+     * @param arguments received arguments
+     * @return event name; <code>null</code> if non is found
+     */
+    private String getEventNameFromArguments(final CordovaArgs arguments) {
+        String eventName = null;
+        try {
+            eventName = arguments.getString(0);
+        } catch (JSONException e) {
+            Log.d("UniversalLinks", "Failed to get event name from the JS arguments", e);
+        }
+
+        return eventName;
+    }
+
+    /**
+     * Try to send event to the subscribers.
+     */
+    private void tryToConsumeEvent() {
+        if (subscribers.size() == 0 || storedMessage == null) {
+            return;
+        }
+
+        final String storedEventName = storedMessage.getEventName();
+        final Set<Map.Entry<String, CallbackContext>> subscribersSet = subscribers.entrySet();
+        for (Map.Entry<String, CallbackContext> subscriber : subscribersSet) {
+            final String eventName = subscriber.getKey();
+            if (eventName.equals(storedEventName)) {
+                sendMessageToJs(storedMessage, subscriber.getValue());
+                storedMessage = null;
+                break;
+            }
+        }
+    }
+
+    /**
+     * Send message to JS side.
+     *
+     * @param message  message to send
+     * @param callback to what callback we are sending the message
+     */
+    private void sendMessageToJs(JSMessage message, CallbackContext callback) {
+        final PluginResult result = new PluginResult(PluginResult.Status.OK, message);
+        result.setKeepCallback(true);
+        callback.sendPluginResult(result);
+    }
+
+    // endregion
+
+    // region Intent handling
+
+    /**
+     * Handle launch intent.
+     * If it is an UL intent - then event will be dispatched to the JS side.
+     *
+     * @param intent launch intent
+     */
+    private void handleIntent(Intent intent) {
+        if (intent == null || supportedHosts == null || supportedHosts.size() == 0) {
+            return;
+        }
+
+        // read intent
+        String action = intent.getAction();
+        Uri launchUri = intent.getData();
+
+        // if app was not launched by the url - ignore
+        if (!Intent.ACTION_VIEW.equals(action) || launchUri == null) {
+            return;
+        }
+
+        // try to find host in the hosts list from the config.xml
+        ULHost host = findHostByUrl(launchUri);
+        if (host == null) {
+            Log.d("UniversalLinks", "Host " + launchUri.getHost() + " is not supported");
+            return;
+        }
+
+        // store message and try to consume it
+        storedMessage = new JSMessage(host, launchUri);
+        tryToConsumeEvent();
+    }
+
+    /**
+     * Find host entry that matches the launch url.
+     *
+     * @param url launch url
+     * @return host entry; <code>null</code> - if none were found
+     */
+    private ULHost findHostByUrl(Uri url) {
+        ULHost host = null;
+        final String launchHost = url.getHost().toLowerCase();
+        for (ULHost supportedHost : supportedHosts) {
+            if (supportedHost.getName().equals(launchHost) ||
+                    supportedHost.getName().startsWith("*.") && launchHost.endsWith(supportedHost.getName().substring(1))) {
+                host = supportedHost;
+                break;
+            }
+        }
+
+        return host;
+    }
+
+    // endregion
+}

package/src/android/com/nordnetab/cordova/ul/js/JSAction.java

@@ -0,0 +1,19 @@
+package com.nordnetab.cordova.ul.js;
+
+/**
+ * Created by Nikolay Demyankov on 09.09.15.
+ * <p/>
+ * Class holds list of method names that is called from JS side.
+ */
+public final class JSAction {
+
+    /**
+     * Subscribe to event.
+     */
+    public static final String SUBSCRIBE = "jsSubscribeForEvent";
+
+    /**
+     * Unsubscribe from event.
+     */
+    public static final String UNSUBSCRIBE = "jsUnsubscribeFromEvent";
+}

package/src/android/com/nordnetab/cordova/ul/model/JSMessage.java

@@ -0,0 +1,193 @@
+package com.nordnetab.cordova.ul.model;
+
+import android.net.Uri;
+import android.util.Log;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.List;
+import java.util.Set;
+
+/**
+ * Created by Nikolay Demyankov on 10.09.15.
+ * <p/>
+ * Model for the message entry, that is send to JS.
+ */
+public class JSMessage extends JSONObject {
+
+    // keys for the message base structure
+    private static final class JSGeneralKeys {
+        /**
+         * Event name
+         */
+        public static final String EVENT = "event";
+
+        /**
+         * Message data block
+         */
+        public static final String DATA = "data";
+    }
+
+    // keys for the message data block
+    private static final class JSDataKeys {
+
+        /**
+         * Path part of the url
+         */
+        public static final String PATH = "path";
+
+        /**
+         * Scheme of the url
+         */
+        public static final String SCHEME = "scheme";
+
+        /**
+         * Host of the url
+         */
+        public static final String HOST = "host";
+
+        /**
+         * Hash (fragment) from the url - data after '#'
+         */
+        public static final String HASH = "hash";
+
+        /**
+         * Query parameters - data after '?'
+         */
+        public static final String PARAMS = "params";
+
+        /**
+         * Launch url as it is
+         */
+        public static final String ORIGIN = "url";
+    }
+
+    private String eventName;
+
+    /**
+     * Constructor
+     *
+     * @param host        host entry that corresponds to the launching url
+     * @param originalUri launch url
+     */
+    public JSMessage(ULHost host, Uri originalUri) {
+        setEventName(host, originalUri);
+        setMessageData(host, originalUri);
+    }
+
+    /**
+     * Getter for event name of this message.
+     *
+     * @return event name
+     */
+    public String getEventName() {
+        return eventName;
+    }
+
+    // region Event name setters
+
+    /**
+     * Set event name for this message entry.
+     */
+    private void setEventName(ULHost host, Uri originalUri) {
+        eventName = getEventName(host, originalUri);
+
+        try {
+            put(JSGeneralKeys.EVENT, eventName);
+        } catch (JSONException e) {
+            Log.d("UniversalLinks", "Failed to set event name", e);
+        }
+    }
+
+    /**
+     * Find event name based on the launching url.
+     * By default, event name from the host object will be used.
+     * But if we have some path entry in the host and it matches the one from the launch url - his event name will be used.
+     */
+    private String getEventName(ULHost host, Uri originalUri) {
+        String event = host.getEvent();
+        final String originPath = originalUri.getPath().toLowerCase();
+        final List<ULPath> hostPathsList = host.getPaths();
+        for (ULPath hostPath : hostPathsList) {
+            final String hostPathUrl = hostPath.getUrl();
+            if (hostPathUrl == null) {
+                continue;
+            }
+
+            if (originPath.matches(hostPathUrl)) {
+                event = hostPath.getEvent();
+                break;
+            }
+        }
+
+        return event;
+    }
+
+    // endregion
+
+    // region Data block setters
+
+    /**
+     * Fill data block with corresponding information.
+     */
+    private void setMessageData(ULHost host, Uri originalUri) {
+        final JSONObject dataObject = new JSONObject();
+
+        try {
+            setOriginalUrl(dataObject, originalUri);
+            setHostData(dataObject, host);
+            setPathData(dataObject, originalUri);
+
+            put(JSGeneralKeys.DATA, dataObject);
+        } catch (JSONException e) {
+            Log.d("UniversalLinks", "Failed to set event data", e);
+        }
+    }
+
+    /**
+     * Put launch url to the data block
+     */
+    private void setOriginalUrl(JSONObject dataObject, Uri originalUri) throws JSONException {
+        dataObject.put(JSDataKeys.ORIGIN, originalUri.toString());
+    }
+
+    /**
+     * Put host name and scheme into data block
+     */
+    private void setHostData(JSONObject dataObject, ULHost host) throws JSONException {
+        dataObject.put(JSDataKeys.HOST, host.getName());
+        dataObject.put(JSDataKeys.SCHEME, host.getScheme());
+    }
+
+    /**
+     * Put path information into data block
+     */
+    private void setPathData(JSONObject dataObject, Uri originalUri) throws JSONException {
+        dataObject.put(JSDataKeys.HASH, originalUri.getFragment());
+        dataObject.put(JSDataKeys.PATH, originalUri.getPath());
+
+        final JSONObject queryParams = getQueryParamsFromUri(originalUri);
+        dataObject.put(JSDataKeys.PARAMS, queryParams);
+    }
+
+    /**
+     * Parse query params.
+     * For example, if we have link like so: http://somedomain.com/some/path?foo=fooVal&bar=barVal , then
+     * resulting object will be {foo: fooVal, bar: barVal}.
+     *
+     * @return json object
+     */
+    private JSONObject getQueryParamsFromUri(Uri originalUri) throws JSONException, UnsupportedOperationException {
+        JSONObject queryParams = new JSONObject();
+        Set<String> keysList = originalUri.getQueryParameterNames();
+        for (String key : keysList) {
+            final String value = originalUri.getQueryParameter(key);
+            queryParams.put(key, value);
+        }
+
+        return queryParams;
+    }
+
+    // endregion
+}

package/src/android/com/nordnetab/cordova/ul/model/ULHost.java

@@ -0,0 +1,85 @@
+package com.nordnetab.cordova.ul.model;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Created by Nikolay Demyankov on 09.09.15.
+ * <p/>
+ * Model for <host /> entry, specified in config.xml.
+ */
+public class ULHost {
+
+    // default event name, that is dispatched to JS if none was set to the host or path
+    private static final String DEFAULT_EVENT = "didLaunchAppFromLink";
+
+    // default scheme for the host
+    private static final String DEFAULT_SCHEME = "http";
+
+    private final List<ULPath> paths;
+    private final String name;
+    private final String scheme;
+    private String event;
+
+    /**
+     * Constructor
+     *
+     * @param name   host name
+     * @param scheme host scheme
+     * @param event  event that corresponds to this host
+     */
+    public ULHost(final String name, final String scheme, final String event) {
+        this.name = name.toLowerCase();
+        this.scheme = (scheme == null) ? DEFAULT_SCHEME : scheme;
+        this.event = (event == null) ? DEFAULT_EVENT : event;
+        this.paths = new ArrayList<ULPath>();
+    }
+
+    /**
+     * Getter for the event name that is sent to JS when user clicks on the link from this host.
+     * Defined as 'event' attribute.
+     *
+     * @return event name
+     */
+    public String getEvent() {
+        return event;
+    }
+
+    /**
+     * Setter for event name.
+     *
+     * @param event event name
+     */
+    public void setEvent(final String event) {
+        this.event = event;
+    }
+
+    /**
+     * Getter for the list of paths, that is set for that host in config.xml.
+     *
+     * @return list of hosts
+     */
+    public List<ULPath> getPaths() {
+        return paths;
+    }
+
+    /**
+     * Getter for the host name.
+     * Defined as 'name' attribute.
+     *
+     * @return host name
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * Getter for host scheme.
+     * Defined as 'scheme' attribute.
+     *
+     * @return scheme
+     */
+    public String getScheme() {
+        return scheme;
+    }
+}

package/src/android/com/nordnetab/cordova/ul/model/ULPath.java

@@ -0,0 +1,43 @@
+package com.nordnetab.cordova.ul.model;
+
+/**
+ * Created by Nikolay Demyankov on 09.09.15.
+ * <p/>
+ * Model for <path /> entry for host in config.xml
+ */
+public class ULPath {
+
+    private final String url;
+    private final String event;
+
+    /**
+     * Constructor
+     *
+     * @param url   path url
+     * @param event event name
+     */
+    public ULPath(final String url, final String event) {
+        this.url = url.replace("*", "(.*)").toLowerCase();
+        this.event = event;
+    }
+
+    /**
+     * Getter for path url.
+     * Defined as 'url' attribute.
+     *
+     * @return path url
+     */
+    public String getUrl() {
+        return url;
+    }
+
+    /**
+     * Getter for the event name that is dispatched when application is launched from the link with this path.
+     * Defined as 'event' attribute.
+     *
+     * @return event name
+     */
+    public String getEvent() {
+        return event;
+    }
+}