@thathoff/cordova-plugin-universal-links 0.3.0

package/src/android/com/nordnetab/cordova/ul/parser/ULConfigXmlParser.java

@@ -0,0 +1,156 @@
+package com.nordnetab.cordova.ul.parser;
+
+import android.content.Context;
+import android.text.TextUtils;
+
+import com.nordnetab.cordova.ul.model.ULHost;
+import com.nordnetab.cordova.ul.model.ULPath;
+
+import org.apache.cordova.ConfigXmlParser;
+import org.xmlpull.v1.XmlPullParser;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Created by Nikolay Demyankov on 09.09.15.
+ * <p/>
+ * Parser for config.xml. Reads only plugin-specific preferences.
+ */
+public class ULConfigXmlParser extends ConfigXmlParser {
+
+    private final Context context;
+    private List<ULHost> hostsList;
+
+    private boolean isInsideMainTag;
+    private boolean didParseMainBlock;
+    private boolean isInsideHostBlock;
+    private ULHost processedHost;
+
+    // region Public API
+
+    /**
+     * Constructor
+     *
+     * @param context application context
+     */
+    public ULConfigXmlParser(Context context) {
+        this.context = context;
+    }
+
+    /**
+     * Parse config.xml
+     *
+     * @return list of hosts, defined in the config file
+     */
+    public List<ULHost> parse() {
+        resetValuesToDefaultState();
+        super.parse(context);
+
+        return hostsList;
+    }
+
+    // endregion
+
+    // region XML processing
+
+    @Override
+    public void handleStartTag(XmlPullParser xml) {
+        if (didParseMainBlock) {
+            return;
+        }
+
+        final String name = xml.getName();
+        if (!isInsideMainTag && XmlTags.MAIN_TAG.equals(name)) {
+            isInsideMainTag = true;
+            return;
+        }
+
+        if (!isInsideMainTag) {
+            return;
+        }
+
+        if (!isInsideHostBlock && XmlTags.HOST_TAG.equals(name)) {
+            isInsideHostBlock = true;
+            processHostBlock(xml);
+            return;
+        }
+
+        if (isInsideHostBlock && XmlTags.PATH_TAG.equals(name)) {
+            processPathBlock(xml);
+        }
+    }
+
+    @Override
+    public void handleEndTag(XmlPullParser xml) {
+        if (didParseMainBlock) {
+            return;
+        }
+
+        final String name = xml.getName();
+
+        if (isInsideHostBlock && XmlTags.HOST_TAG.equals(name)) {
+            isInsideHostBlock = false;
+            hostsList.add(processedHost);
+            processedHost = null;
+            return;
+        }
+
+        if (XmlTags.MAIN_TAG.equals(name)) {
+            isInsideMainTag = false;
+            didParseMainBlock = true;
+        }
+    }
+
+    /**
+     * Parse <host />
+     */
+    private void processHostBlock(XmlPullParser xml) {
+        final String hostName = xml.getAttributeValue(null, XmlTags.HOST_NAME_ATTRIBUTE);
+        final String eventName = xml.getAttributeValue(null, XmlTags.HOST_EVENT_ATTRIBUTE);
+        final String scheme = xml.getAttributeValue(null, XmlTags.HOST_SCHEME_ATTRIBUTE);
+
+        processedHost = new ULHost(hostName, scheme, eventName);
+    }
+
+    /**
+     * Parse <path />
+     */
+    private void processPathBlock(XmlPullParser xml) {
+        final String url = xml.getAttributeValue(null, XmlTags.PATH_URL_TAG);
+        String event = xml.getAttributeValue(null, XmlTags.PATH_EVENT_TAG);
+
+        // skip wildcard urls
+        if ("*".equals(url) || ".*".equals(url)) {
+            // but if path has event name - set it to host
+            if (!TextUtils.isEmpty(event)) {
+                processedHost.setEvent(event);
+            }
+
+            return;
+        }
+
+        // if event name is empty - use one from the host
+        if (TextUtils.isEmpty(event)) {
+            event = processedHost.getEvent();
+        }
+
+        // create path entry
+        ULPath path = new ULPath(url, event);
+        processedHost.getPaths().add(path);
+    }
+
+    // endregion
+
+    // region Private API
+
+    private void resetValuesToDefaultState() {
+        hostsList = new ArrayList<ULHost>();
+        isInsideMainTag = false;
+        didParseMainBlock = false;
+        isInsideHostBlock = false;
+        processedHost = null;
+    }
+
+    // endregion
+}

package/src/android/com/nordnetab/cordova/ul/parser/XmlTags.java

@@ -0,0 +1,49 @@
+package com.nordnetab.cordova.ul.parser;
+
+/**
+ * Created by Nikolay Demyankov on 10.09.15.
+ * <p/>
+ * XML tags that is used in config.xml to specify plugin preferences.
+ */
+final class XmlTags {
+
+    /**
+     * Main tag in which we define plugin related stuff
+     */
+    public static final String MAIN_TAG = "universal-links";
+
+    /**
+     * Host main tag
+     */
+    public static final String HOST_TAG = "host";
+
+    /**
+     * Scheme attribute for the host entry
+     */
+    public static final String HOST_SCHEME_ATTRIBUTE = "scheme";
+
+    /**
+     * Name attribute for the host entry
+     */
+    public static final String HOST_NAME_ATTRIBUTE = "name";
+
+    /**
+     * Event attribute for the host entry
+     */
+    public static final String HOST_EVENT_ATTRIBUTE = "event";
+
+    /**
+     * Path main tag
+     */
+    public static final String PATH_TAG = "path";
+
+    /**
+     * Url attribute for the path entry
+     */
+    public static final String PATH_URL_TAG = "url";
+
+    /**
+     * Event attribute for the path entry
+     */
+    public static final String PATH_EVENT_TAG = "event";
+}

package/src/ios/AppDelegate+CULPlugin.h

@@ -0,0 +1,17 @@
+//
+//  AppDelegate+CULPlugin.h
+//
+//  Created by Nikolay Demyankov on 15.09.15.
+//
+
+#import "AppDelegate.h"
+
+/**
+ *  Category for the AppDelegate that overrides application:continueUserActivity:restorationHandler method, 
+ *  so we could handle application launch when user clicks on the link in the browser.
+ */
+@interface AppDelegate (CULPlugin)
+
+- (BOOL)application:(UIApplication *)application continueUserActivity:(NSUserActivity *)userActivity restorationHandler:(void (^)(NSArray *))restorationHandler;
+
+@end

package/src/ios/AppDelegate+CULPlugin.m

@@ -0,0 +1,32 @@
+//
+//  AppDelegate+CULPlugin.m
+//
+//  Created by Nikolay Demyankov on 15.09.15.
+//
+
+#import "AppDelegate+CULPlugin.h"
+#import "CULPlugin.h"
+
+/**
+ *  Plugin name in config.xml
+ */
+static NSString *const PLUGIN_NAME = @"UniversalLinks";
+
+@implementation AppDelegate (CULPlugin)
+
+- (BOOL)application:(UIApplication *)application continueUserActivity:(NSUserActivity *)userActivity restorationHandler:(void (^)(NSArray *))restorationHandler {
+    // ignore activities that are not for Universal Links
+    if (![userActivity.activityType isEqualToString:NSUserActivityTypeBrowsingWeb] || userActivity.webpageURL == nil) {
+        return NO;
+    }
+    
+    // get instance of the plugin and let it handle the userActivity object
+    CULPlugin *plugin = [self.viewController getCommandInstance:PLUGIN_NAME];
+    if (plugin == nil) {
+        return NO;
+    }
+    
+    return [plugin handleUserActivity:userActivity];
+}
+
+@end

package/src/ios/CULPlugin.h

@@ -0,0 +1,38 @@
+//
+//  CULPlugin.h
+//
+//  Created by Nikolay Demyankov on 14.09.15.
+//
+
+#import <Foundation/Foundation.h>
+#import <Cordova/CDVPlugin.h>
+
+/**
+ *  Plugin main class.
+ */
+@interface CULPlugin : CDVPlugin
+
+/**
+ *  Subscribe to event.
+ *
+ *  @param command command from js side with event name and callback id.
+ */
+- (void)jsSubscribeForEvent:(CDVInvokedUrlCommand *)command;
+
+/**
+ *  Unsubscribe from event.
+ *
+ *  @param command command from js side with event name
+ */
+- (void)jsUnsubscribeFromEvent:(CDVInvokedUrlCommand *)command;
+
+/**
+ *  Try to hanlde application launch when user clicked on the link.
+ *
+ *  @param userActivity object with information about the application launch
+ *
+ *  @return <code>true</code> - if this is a universal link and it is defined in config.xml; otherwise - <code>false</code>
+ */
+- (BOOL)handleUserActivity:(NSUserActivity *)userActivity;
+
+@end

package/src/ios/CULPlugin.m

@@ -0,0 +1,176 @@
+//
+//  CULPlugin.m
+//
+//  Created by Nikolay Demyankov on 14.09.15.
+//
+
+#import "CULPlugin.h"
+#import "CULConfigXmlParser.h"
+#import "CULPath.h"
+#import "CULHost.h"
+#import "CDVPluginResult+CULPlugin.h"
+#import "CDVInvokedUrlCommand+CULPlugin.h"
+#import "CULConfigJsonParser.h"
+
+@interface CULPlugin() {
+    NSArray *_supportedHosts;
+    CDVPluginResult *_storedEvent;
+    NSMutableDictionary<NSString *, NSString *> *_subscribers;
+}
+
+@end
+
+@implementation CULPlugin
+
+#pragma mark Public API
+
+- (void)pluginInitialize {
+    [self localInit];
+    // Can be used for testing.
+    // Just uncomment, close the app and reopen it. That will simulate application launch from the link.
+//    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(onResume:) name:UIApplicationWillEnterForegroundNotification object:nil];
+}
+
+//- (void)onResume:(NSNotification *)notification {
+//    NSUserActivity *activity = [[NSUserActivity alloc] initWithActivityType:NSUserActivityTypeBrowsingWeb];
+//    [activity setWebpageURL:[NSURL URLWithString:@"http://site2.com/news/page?q=1&v=2#myhash"]];
+//    
+//    [self handleUserActivity:activity];
+//}
+
+- (void)handleOpenURL:(NSNotification*)notification {
+    id url = notification.object;
+    if (![url isKindOfClass:[NSURL class]]) {
+        return;
+    }
+    
+    CULHost *host = [self findHostByURL:url];
+    if (host) {
+        [self storeEventWithHost:host originalURL:url];
+    }
+}
+
+- (BOOL)handleUserActivity:(NSUserActivity *)userActivity {
+    [self localInit];
+    
+    NSURL *launchURL = userActivity.webpageURL;
+    CULHost *host = [self findHostByURL:launchURL];
+    if (host == nil) {
+        return NO;
+    }
+    
+    [self storeEventWithHost:host originalURL:launchURL];
+    
+    return YES;
+}
+
+- (void)onAppTerminate {
+    _supportedHosts = nil;
+    _subscribers = nil;
+    _storedEvent = nil;
+    
+    [super onAppTerminate];
+}
+
+#pragma mark Private API
+
+- (void)localInit {
+    if (_supportedHosts) {
+        return;
+    }
+    
+    _subscribers = [[NSMutableDictionary alloc] init];
+    
+    // Get supported hosts from the config.xml or www/ul.json.
+    // For now priority goes to json config.
+    _supportedHosts = [self getSupportedHostsFromPreferences];
+}
+
+- (NSArray<CULHost *> *)getSupportedHostsFromPreferences {
+    NSString *jsonConfigPath = [[NSBundle mainBundle] pathForResource:@"ul" ofType:@"json" inDirectory:@"www"];
+    if (jsonConfigPath) {
+        return [CULConfigJsonParser parseConfig:jsonConfigPath];
+    }
+    
+    return [CULConfigXmlParser parse];
+}
+
+/**
+ *  Store event data for future use.
+ *  If we are resuming the app - try to consume it.
+ *
+ *  @param host        host that matches the launch url
+ *  @param originalUrl launch url
+ */
+- (void)storeEventWithHost:(CULHost *)host originalURL:(NSURL *)originalUrl {
+    _storedEvent = [CDVPluginResult resultWithHost:host originalURL:originalUrl];
+    [self tryToConsumeEvent];
+}
+
+/**
+ *  Find host entry that corresponds to launch url.
+ *
+ *  @param  launchURL url that launched the app
+ *  @return host entry; <code>nil</code> if none is found
+ */
+- (CULHost *)findHostByURL:(NSURL *)launchURL {
+    NSURLComponents *urlComponents = [NSURLComponents componentsWithURL:launchURL resolvingAgainstBaseURL:YES];
+    CULHost *host = nil;
+    for (CULHost *supportedHost in _supportedHosts) {
+        NSPredicate *pred = [NSPredicate predicateWithFormat:@"self LIKE[c] %@", supportedHost.name];
+        if ([pred evaluateWithObject:urlComponents.host]) {
+            host = supportedHost;
+            break;
+        }
+    }
+    
+    return host;
+}
+
+#pragma mark Methods to send data to JavaScript
+
+/**
+ *  Try to send event to the web page.
+ *  If there is a subscriber for the event - it will be consumed. 
+ *  If not - it will stay until someone subscribes to it.
+ */
+- (void)tryToConsumeEvent {
+    if (_subscribers.count == 0 || _storedEvent == nil) {
+        return;
+    }
+    
+    NSString *storedEventName = [_storedEvent eventName];
+    for (NSString *eventName in _subscribers) {
+        if ([storedEventName isEqualToString:eventName]) {
+            NSString *callbackID = _subscribers[eventName];
+            [self.commandDelegate sendPluginResult:_storedEvent callbackId:callbackID];
+            _storedEvent = nil;
+            break;
+        }
+    }
+}
+
+#pragma mark Methods, available from JavaScript side
+
+- (void)jsSubscribeForEvent:(CDVInvokedUrlCommand *)command {
+    NSString *eventName = [command eventName];
+    if (eventName.length == 0) {
+        return;
+    }
+    
+    _subscribers[eventName] = command.callbackId;
+    [self tryToConsumeEvent];
+}
+
+- (void)jsUnsubscribeFromEvent:(CDVInvokedUrlCommand *)command {
+    NSString *eventName = [command eventName];
+    if (eventName.length == 0) {
+        return;
+    }
+    
+    [_subscribers removeObjectForKey:eventName];
+}
+
+
+
+@end

package/src/ios/JS/CDVInvokedUrlCommand+CULPlugin.h

@@ -0,0 +1,21 @@
+//
+//  CDVInvokedUrlCommand+CULPlugin.h
+//
+//  Created by Nikolay Demyankov on 08.12.15.
+//
+
+#import <Cordova/CDVPlugin.h>
+
+/**
+ *  Category to get the event name from the request, that is sent from JS side.
+ */
+@interface CDVInvokedUrlCommand (CULPlugin)
+
+/**
+ *  Get event name from JS request.
+ *
+ *  @return event name
+ */
+- (NSString *)eventName;
+
+@end

package/src/ios/JS/CDVInvokedUrlCommand+CULPlugin.m

@@ -0,0 +1,19 @@
+//
+//  CDVInvokedUrlCommand+CULPlugin.m
+//
+//  Created by Nikolay Demyankov on 08.12.15.
+//
+
+#import "CDVInvokedUrlCommand+CULPlugin.h"
+
+@implementation CDVInvokedUrlCommand (CULPlugin)
+
+- (NSString *)eventName {
+    if (self.arguments.count == 0) {
+        return nil;
+    }
+    
+    return self.arguments[0];
+}
+
+@end

package/src/ios/JS/CDVPluginResult+CULPlugin.h

@@ -0,0 +1,29 @@
+//
+//  CDVPluginResult+CULPlugin.h
+//
+//  Created by Nikolay Demyankov on 15.09.15.
+//
+
+#import <Cordova/CDVPlugin.h>
+#import "CULHost.h"
+
+/**
+ *  Category to simplify plugin result generation.
+ */
+@interface CDVPluginResult (CULPlugin)
+
+/**
+ *  Get CDVPluginResult instance with information about the launch url that is send to JS.
+ *
+ *  @param host        host that corresponds to launch url
+ *  @param originalURL launching url
+ *
+ *  @return instance of the CDVPluginResult
+ */
++ (instancetype)resultWithHost:(CULHost *)host originalURL:(NSURL *)originalURL;
+
+- (BOOL)isResultForEvent:(NSString *)eventName;
+
+- (NSString *)eventName;
+
+@end

package/src/ios/JS/CDVPluginResult+CULPlugin.m

@@ -0,0 +1,157 @@
+//
+//  CDVPluginResult+CULPlugin.m
+//
+//  Created by Nikolay Demyankov on 15.09.15.
+//
+
+#import "CDVPluginResult+CULPlugin.h"
+
+#pragma mark keys for the message structure
+
+// event name
+static NSString *const EVENT = @"event";
+
+// message data block
+static NSString *const DATA = @"data";
+
+#pragma mark keys for the message data block
+
+// path part from the url
+static NSString *const PATH_ATTRIBUTE = @"path";
+
+// scheme from the url
+static NSString *const SCHEME_ATTRIBUTE = @"scheme";
+
+// host name from the url
+static NSString *const HOST_ATTRIBUTE = @"host";
+
+// hash (fragment) from the url; data after '#'
+static NSString *const HASH_ATTRIBUTE = @"hash";
+
+// launch url without any changes
+static NSString *const ORIGIN_ATTRIBUTE = @"url";
+
+// query parameters from the url; data after '?'
+static NSString *const URL_PARAMS_ATTRIBUTE = @"params";
+
+@implementation CDVPluginResult (CULPlugin)
+
+#pragma mark Public API
+
++ (instancetype)resultWithHost:(CULHost *)host originalURL:(NSURL *)originalURL {
+    NSDictionary *message = [self prepareMessageForHost:host originalURL:originalURL];
+    
+    CDVPluginResult *result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsDictionary:message];
+    [result setKeepCallbackAsBool:YES];
+    
+    return result;
+}
+
+- (BOOL)isResultForEvent:(NSString *)eventName {
+    NSString *eventInMessage = [self eventName];
+    if (eventInMessage.length == 0 || eventName.length == 0) {
+        return NO;
+    }
+    
+    return [eventInMessage isEqualToString:eventName];
+}
+
+- (NSString *)eventName {
+    if (self.message == nil || ![self.message isKindOfClass:[NSDictionary class]]) {
+        return nil;
+    }
+    
+    NSDictionary *data = self.message;
+    
+    return data[EVENT];
+}
+
+#pragma mark Private API
+
+/**
+ *  Create dictionary for message, that should be send to JS.
+ *  Holds event name and event details.
+ *
+ *  @param host        host entry that corresponds to the url
+ *  @param originalURL launch url
+ *
+ *  @return messasge dictionary
+ */
++ (NSDictionary *)prepareMessageForHost:(CULHost *)host originalURL:(NSURL *)originalURL {
+    NSURLComponents *urlComponents = [NSURLComponents componentsWithURL:originalURL resolvingAgainstBaseURL:YES];
+    NSMutableDictionary *messageDict = [[NSMutableDictionary alloc] init];
+    
+    // set event name
+    NSString *eventName = [self getEventNameBasedOnHost:host originalURLComponents:urlComponents];
+    [messageDict setObject:eventName forKey:EVENT];
+    
+    // set event details
+    NSDictionary *data = [self getDataDictionaryForURLComponents:urlComponents];
+    [messageDict setObject:data forKey:DATA];
+    
+    return messageDict;
+}
+
+/**
+ *  Find event name based on the launch url and corresponding host entry.
+ *
+ *  @param host          host entry
+ *  @param urlComponents launch url components
+ *
+ *  @return event name
+ */
++ (NSString *)getEventNameBasedOnHost:(CULHost *)host originalURLComponents:(NSURLComponents *)urlComponents {
+    NSString *eventName = host.event;
+    NSArray<CULPath *> *hostPaths = host.paths;
+    NSString *originalPath = urlComponents.path.lowercaseString;
+    
+    if (originalPath.length == 0) {
+        return eventName;
+    }
+
+    for (CULPath *hostPath in hostPaths) {
+        NSRange range = [originalPath rangeOfString:hostPath.url options:NSRegularExpressionSearch];
+        if (range.location != NSNotFound && range.location == 0) {
+            eventName = hostPath.event;
+            break;
+        }
+    }
+    
+    return eventName;
+}
+
+/**
+ *  Create dictionary with event details.
+ *
+ *  @param originalURLComponents launch url components
+ *
+ *  @return dictionary with url information
+ */
++ (NSDictionary *)getDataDictionaryForURLComponents:(NSURLComponents *)originalURLComponents {
+    NSMutableDictionary *dataDict = [[NSMutableDictionary alloc] init];
+    
+    NSString *originUrl = originalURLComponents.URL.absoluteString;
+    NSString *host = originalURLComponents.host ? originalURLComponents.host : @"";
+    NSString *path = originalURLComponents.path ? originalURLComponents.path : @"";
+    NSString *scheme = originalURLComponents.scheme ? originalURLComponents.scheme : @"";
+    NSString *hash = originalURLComponents.fragment ? originalURLComponents.fragment : @"";
+
+    [dataDict setObject:originUrl forKey:ORIGIN_ATTRIBUTE];
+    [dataDict setObject:host forKey:HOST_ATTRIBUTE];
+    [dataDict setObject:path forKey:PATH_ATTRIBUTE];
+    [dataDict setObject:scheme forKey:SCHEME_ATTRIBUTE];
+    [dataDict setObject:hash forKey:HASH_ATTRIBUTE];
+    
+    // set query params
+    NSArray<NSURLQueryItem *> *queryItems = originalURLComponents.queryItems;
+    NSMutableDictionary<NSString *, NSString *> *qParams = [[NSMutableDictionary alloc] init];
+    for (NSURLQueryItem *qItem in queryItems) {
+        NSString *value = qItem.value ? qItem.value : @"";
+        [qParams setValue:value forKey:qItem.name];
+    }
+    [dataDict setObject:qParams forKey:URL_PARAMS_ATTRIBUTE];
+    
+    return dataDict;
+}
+
+@end