@thathoff/cordova-plugin-universal-links 0.3.0

package/src/ios/Model/CULHost.h

@@ -0,0 +1,63 @@
+//
+//  CULHost.h
+//
+//  Created by Nikolay Demyankov on 15.09.15.
+//
+
+#import <Foundation/Foundation.h>
+#import "CULPath.h"
+
+/**
+ *  Model for <host /> entry, specified in config.xml.
+ */
+@interface CULHost : NSObject
+
+/**
+ * Host name.
+ * Defined as 'name' attribute.
+ */
+@property (nonatomic, readonly, strong) NSString *name;
+
+/**
+ *  Host scheme.
+ *  Defined as 'scheme' attribute.
+ */
+@property (nonatomic, readonly, strong) NSString *scheme;
+
+/**
+ *  Event name that is sent to JS when user clicks on the link from this host.
+ *  Defined as 'event' attribute.
+ */
+@property (nonatomic, strong) NSString *event;
+
+/**
+ *  List of paths, that is set for that host in config.xml.
+ */
+@property (nonatomic, readonly, strong) NSArray<CULPath *> *paths;
+
+/**
+ *  Constructor.
+ *
+ *  @param name   host name
+ *  @param scheme scheme; if <code>nil</code> - http will be used
+ *  @param event  event name; if <code>nil</code> - didLaunchAppFromLink event name will be used
+ *
+ *  @return instance of the CULHost
+ */
+- (instancetype)initWithHostName:(NSString *)name scheme:(NSString *)scheme event:(NSString *)event;
+
+/**
+ *  Add path entry to the host paths list.
+ *
+ *  @param path path to add
+ */
+- (void)addPath:(CULPath *)path;
+
+/**
+ *  Add list of paths.
+ * 
+ *  @param paths paths to add
+ */
+- (void)addAllPaths:(NSArray<CULPath *> *)paths;
+
+@end

package/src/ios/Model/CULHost.m

@@ -0,0 +1,50 @@
+//
+//  CULHost.m
+//
+//  Created by Nikolay Demyankov on 15.09.15.
+//
+
+#import "CULHost.h"
+
+// default event name
+static NSString *const DEFAULT_EVENT = @"didLaunchAppFromLink";
+
+// default host scheme
+static NSString *const DEFAULT_SCHEME = @"http";
+
+@interface CULHost() {
+    NSMutableArray<CULPath *> *_paths;
+}
+
+@end
+
+@implementation CULHost
+
+- (instancetype)initWithHostName:(NSString *)name scheme:(NSString *)scheme event:(NSString *)event {
+    self = [super init];
+    if (self) {
+        _event = event ? event : DEFAULT_EVENT;
+        _scheme = scheme ? scheme : DEFAULT_SCHEME;
+        _name = name.lowercaseString;
+        _paths = [[NSMutableArray alloc] init];
+    }
+    return self;
+}
+
+- (void)addPath:(CULPath *)path {
+    if (path) {
+        [_paths addObject:path];
+    }
+}
+
+- (void)addAllPaths:(NSArray<CULPath *> *)paths {
+    if (paths) {
+        [_paths addObjectsFromArray:paths];
+    }
+}
+
+- (NSArray<CULPath *> *)paths {
+    return _paths;
+}
+
+@end

package/src/ios/Model/CULPath.h

@@ -0,0 +1,36 @@
+//
+//  CULPath.h
+//
+//  Created by Nikolay Demyankov on 15.09.15.
+//
+
+#import <Foundation/Foundation.h>
+
+/**
+ *  Model for <path /> entry for host in config.xml.
+ */
+@interface CULPath : NSObject
+
+/**
+ *  Event name that is dispatched when application is launched from the link with this path.
+ *  Defined as 'event' attribute.
+ */
+@property (nonatomic, readonly, strong) NSString *event;
+
+/**
+ *  Path url.
+ *  Defined as 'url' attribute.
+ */
+@property (nonatomic, readonly, strong) NSString *url;
+
+/**
+ *  Constructor
+ *
+ *  @param urlPath url path
+ *  @param event   event name
+ *
+ *  @return instance of the CULPath
+ */
+- (instancetype)initWithUrlPath:(NSString *)urlPath andEvent:(NSString *)event;
+
+@end

package/src/ios/Model/CULPath.m

@@ -0,0 +1,21 @@
+//
+//  CULPath.m
+//
+//  Created by Nikolay Demyankov on 15.09.15.
+//
+
+#import "CULPath.h"
+
+@implementation CULPath
+
+- (instancetype)initWithUrlPath:(NSString *)urlPath andEvent:(NSString *)event {
+    self = [super init];
+    if (self) {
+        _url = [urlPath stringByReplacingOccurrencesOfString:@"*" withString:@".*"].lowercaseString;
+        _event = event;
+    }
+    
+    return self;
+}
+
+@end

package/src/ios/Parser/JSON/CULConfigJsonParser.h

@@ -0,0 +1,22 @@
+//
+//  CULConfigJsonParser.h
+//
+//  Created by Nikolay Demyankov on 29.01.17.
+//
+
+#import <Foundation/Foundation.h>
+#import "CULHost.h"
+
+/**
+ *  JSON parser for plugin's preferences.
+ */
+@interface CULConfigJsonParser : NSObject
+
+/**
+ *  Parse JSON config.
+ *
+ *  @return list of hosts, defined in the config file
+ */
++ (NSArray<CULHost *> *)parseConfig:(NSString *)pathToJsonConfig;
+
+@end

package/src/ios/Parser/JSON/CULConfigJsonParser.m

@@ -0,0 +1,60 @@
+//
+//  CULConfigJsonParser.m
+//
+//  Created by Nikolay Demyankov on 29.01.17.
+//
+
+#import "CULConfigJsonParser.h"
+
+@implementation CULConfigJsonParser
+
++ (NSArray<CULHost *> *)parseConfig:(NSString *)pathToJsonConfig {
+    NSData *ulData = [NSData dataWithContentsOfFile:pathToJsonConfig];
+    if (!ulData) {
+        return nil;
+    }
+    
+    NSError *error = nil;
+    NSArray *jsonObject = [NSJSONSerialization JSONObjectWithData:ulData options:kNilOptions error:&error];
+    if (error) {
+        return nil;
+    }
+    
+    NSMutableArray<CULHost *> *preferences = [[NSMutableArray alloc] init];
+    for (NSDictionary *jsonEntry in jsonObject) {
+        CULHost *host = [[CULHost alloc] initWithHostName:jsonEntry[@"host"]
+                                                   scheme:jsonEntry[@"scheme"]
+                                                    event:jsonEntry[@"event"]];
+        NSArray<CULPath *> *paths = [self parsePathsFromJson:jsonEntry[@"path"] forHost:host];
+        [host addAllPaths:paths];
+        
+        [preferences addObject:host];
+    }
+    
+    return preferences;
+}
+
++ (NSArray<CULPath *> *)parsePathsFromJson:(NSArray *)jsonArray forHost:(CULHost *)host {
+    if (!jsonArray || !jsonArray.count) {
+        return nil;
+    }
+    
+    NSMutableArray<CULPath *> *paths = [[NSMutableArray alloc] initWithCapacity:jsonArray.count];
+    for (NSDictionary *entry in jsonArray) {
+        NSString *urlPath = entry[@"url"];
+        NSString *pathEvent = entry[@"event"] ? entry[@"event"] : host.event;
+        
+        // ignore '*' paths; we don't need them here
+        if ([urlPath isEqualToString:@"*"] || [urlPath isEqualToString:@".*"]) {
+            continue;
+        }
+        
+        // create path entry
+        CULPath *path = [[CULPath alloc] initWithUrlPath:urlPath andEvent:pathEvent];
+        [paths addObject:path];
+    }
+    
+    return paths;
+}
+
+@end

package/src/ios/Parser/XML/CULConfigXmlParser.h

@@ -0,0 +1,22 @@
+//
+//  CULConfigXmlParser.h
+//
+//  Created by Nikolay Demyankov on 15.09.15.
+//
+
+#import <Foundation/Foundation.h>
+#import "CULHost.h"
+
+/**
+ *  Parser for config.xml. Reads only plugin-specific preferences.
+ */
+@interface CULConfigXmlParser : NSObject
+
+/**
+ *  Parse config.xml
+ *
+ *  @return list of hosts, defined in the config file
+ */
++ (NSArray<CULHost *> *)parse;
+
+@end

package/src/ios/Parser/XML/CULConfigXmlParser.m

@@ -0,0 +1,123 @@
+//
+//  CULConfigXmlParser.m
+//
+//  Created by Nikolay Demyankov on 15.09.15.
+//
+
+#import "CULConfigXmlParser.h"
+#import "NSBundle+CULPlugin.h"
+#import "CULPath.h"
+#import "CULXmlTags.h"
+
+@interface CULConfigXmlParser() <NSXMLParserDelegate> {
+    NSMutableArray<CULHost *> *_hostsList;
+    BOOL _isInsideMainTag;
+    BOOL _didParseMainBlock;
+    BOOL _isInsideHostBlock;
+    CULHost *_processedHost;
+}
+
+@end
+
+@implementation CULConfigXmlParser
+
+#pragma mark Public API
+
++ (NSArray<CULHost *> *)parse {
+    CULConfigXmlParser *parser = [[CULConfigXmlParser alloc] init];
+    
+    return [parser parseConfig];
+}
+
+- (NSArray<CULHost *> *)parseConfig {
+    NSURL *cordovaConfigURL = [NSURL fileURLWithPath:[NSBundle pathToCordovaConfigXml]];
+    NSXMLParser *configParser = [[NSXMLParser alloc] initWithContentsOfURL:cordovaConfigURL];
+    if (configParser == nil) {
+        NSLog(@"Failed to initialize XML parser.");
+        return nil;
+    }
+    
+    _hostsList = [[NSMutableArray alloc] init];
+    [configParser setDelegate:self];
+    [configParser parse];
+    
+    return _hostsList;
+}
+
+#pragma mark NSXMLParserDelegate implementation
+
+- (void)parser:(NSXMLParser *)parser didStartElement:(NSString *)elementName namespaceURI:(NSString *)namespaceURI qualifiedName:(NSString *)qName attributes:(NSDictionary<NSString *,NSString *> *)attributeDict {
+    if (_didParseMainBlock) {
+        return;
+    }
+    
+    if ([elementName isEqualToString:kCULMainXmlTag]) {
+        _isInsideMainTag = YES;
+        return;
+    }
+    if (!_isInsideMainTag) {
+        return;
+    }
+    
+    if ([elementName isEqualToString:kCULHostXmlTag]) {
+        [self processHostTag:attributeDict];
+    } else if ([elementName isEqualToString:kCULPathXmlTag]) {
+        [self processPathTag:attributeDict];
+    }
+}
+
+- (void)parser:(NSXMLParser *)parser didEndElement:(NSString *)elementName namespaceURI:(NSString *)namespaceURI qualifiedName:(NSString *)qName {
+    if (_didParseMainBlock || !_isInsideMainTag) {
+        return;
+    }
+    
+    if ([elementName isEqualToString:kCULHostXmlTag]) {
+        _isInsideHostBlock = NO;
+        [_hostsList addObject:_processedHost];
+    }
+}
+
+#pragma mark XML Processing
+
+/**
+ *  Parse host tag.
+ *
+ *  @param attributes host tag attributes
+ */
+- (void)processHostTag:(NSDictionary<NSString *, NSString *> *)attributes {
+    _processedHost = [[CULHost alloc] initWithHostName:attributes[kCULHostNameXmlAttribute]
+                                                scheme:attributes[kCULHostSchemeXmlAttribute]
+                                                 event:attributes[kCULHostEventXmlAttribute]];
+    _isInsideHostBlock = YES;
+}
+
+/**
+ *  Parse path tag.
+ *
+ *  @param attributes path tag attributes
+ */
+- (void)processPathTag:(NSDictionary<NSString *, NSString *> *)attributes {
+    NSString *urlPath = attributes[kCULPathUrlXmlAttribute];
+    NSString *event = attributes[kCULPathEventXmlAttribute];
+    
+    // ignore '*' paths; we don't need them here
+    if ([urlPath isEqualToString:@"*"] || [urlPath isEqualToString:@".*"]) {
+        // but if path has event name - set it to host
+        if (event) {
+            _processedHost.event = event;
+        }
+        
+        return;
+    }
+    
+    // if event name is empty - use one from the host
+    if (event == nil) {
+        event = _processedHost.event;
+    }
+    
+    // create path entry
+    CULPath *path = [[CULPath alloc] initWithUrlPath:urlPath andEvent:event];
+    [_processedHost addPath:path];
+}
+
+@end

package/src/ios/Parser/XML/CULXmlTags.h

@@ -0,0 +1,54 @@
+//
+//  CULXmlTags.h
+//
+//  Created by Nikolay Demyankov on 15.09.15.
+//
+
+#import <Foundation/Foundation.h>
+
+/**
+ *  XML tags that is used in config.xml to specify plugin preferences.
+ */
+@interface CULXmlTags : NSObject
+
+/**
+ *  Main tag in which we define plugin related stuff
+ */
+extern NSString *const kCULMainXmlTag;
+
+/**
+ *  Host main tag
+ */
+extern NSString *const kCULHostXmlTag;
+
+/**
+ *  Scheme attribute for the host entry
+ */
+extern NSString *const kCULHostSchemeXmlAttribute;
+
+/**
+ *  Name attribute for the host entry
+ */
+extern NSString *const kCULHostNameXmlAttribute;
+
+/**
+ *  Event attribute for the host entry
+ */
+extern NSString *const kCULHostEventXmlAttribute;
+
+/**
+ *  Path main tag
+ */
+extern NSString *const kCULPathXmlTag;
+
+/**
+ *  Url attribute for the path entry
+ */
+extern NSString *const kCULPathUrlXmlAttribute;
+
+/**
+ *  Event attribute for the path entry
+ */
+extern NSString *const kCULPathEventXmlAttribute;
+
+@end

package/src/ios/Parser/XML/CULXmlTags.m

@@ -0,0 +1,22 @@
+//
+//  CULXmlTags.m
+//
+//  Created by Nikolay Demyankov on 15.09.15.
+//
+
+#import "CULXmlTags.h"
+
+@implementation CULXmlTags
+
+NSString *const kCULMainXmlTag = @"universal-links";
+
+NSString *const kCULHostXmlTag = @"host";
+NSString *const kCULHostSchemeXmlAttribute = @"scheme";
+NSString *const kCULHostNameXmlAttribute = @"name";
+NSString *const kCULHostEventXmlAttribute = @"event";
+
+NSString *const kCULPathXmlTag = @"path";
+NSString *const kCULPathUrlXmlAttribute = @"url";
+NSString *const kCULPathEventXmlAttribute = @"event";
+
+@end

package/src/ios/Utils/NSBundle+CULPlugin.h

@@ -0,0 +1,22 @@
+//
+//  NSBundle+CULPlugin.h
+//
+//  Created by Nikolay Demyankov on 15.09.15.
+//
+
+#import <Foundation/Foundation.h>
+
+/**
+ *  Helper category to work with NSBundle.
+ */
+@interface NSBundle (CULPlugin)
+
+/**
+ *  Path to the config.xml file in the project.
+ *
+ *  @return path to the config file
+ */
++ (NSString *)pathToCordovaConfigXml;
+
+
+@end

package/src/ios/Utils/NSBundle+CULPlugin.m

@@ -0,0 +1,15 @@
+//
+//  NSBundle+CULPlugin.m
+//
+//  Created by Nikolay Demyankov on 15.09.15.
+//
+
+#import "NSBundle+CULPlugin.h"
+
+@implementation NSBundle (CULPlugin)
+
++ (NSString *)pathToCordovaConfigXml {
+    return [[NSBundle mainBundle] pathForResource:@"config" ofType:@"xml"];
+}
+
+@end

package/ul_web_hooks/android_web_hook_tpl.html

@@ -0,0 +1,23 @@
+<!--
+Besides activating Deep Links in the application - you need to enable indexing for your web pages.
+For that you should add <link /> tags in the <head> section of the web pages that you specified in config.xml.
+Doing so, you declare that this page should be openned in the mobile application instead of the browser.
+
+Link tag is look like this:
+  <link rel="alternate" href="android-app://<package_name>/<scheme>/<host>/<path>" />
+
+More documentation could be found here:
+https://developer.android.com/training/app-indexing/enabling-app-indexing.html
+
+For convenience, plugin generates the list of <link /> tags based on what you specified in the config.xml.
+You can just copy-paste them in the <header> section of the appropriate pages of your website.
+
+-->
+
+<head>
+[__LINKS__]
+<!-- Your other stuff from the head tag -->
+</head>
+<body>
+<!-- Your page content -->
+</body>

package/www/universal_links.js

@@ -0,0 +1,56 @@
+var exec = require('cordova/exec'),
+  channel = require('cordova/channel'),
+
+  // Reference name for the plugin
+  PLUGIN_NAME = 'UniversalLinks',
+
+  // Default event name that is used by the plugin
+  DEFAULT_EVENT_NAME = 'didLaunchAppFromLink';
+
+// Plugin methods on the native side that can be called from JavaScript
+pluginNativeMethod = {
+  SUBSCRIBE: 'jsSubscribeForEvent',
+  UNSUBSCRIBE: 'jsUnsubscribeFromEvent'
+};
+
+var universalLinks = {
+
+  /**
+   * Subscribe to event.
+   * If plugin already captured that event - callback will be called immidietly.
+   *
+   * @param {String} eventName - name of the event you are subscribing on; if null - default plugin event is used
+   * @param {Function} callback - callback that is called when event is captured
+   */
+  subscribe: function(eventName, callback) {
+    if (!callback) {
+      console.warn('Universal Links: can\'t subscribe to event without a callback');
+      return;
+    }
+
+    if (!eventName) {
+      eventName = DEFAULT_EVENT_NAME;
+    }
+
+    var innerCallback = function(msg) {
+      callback(msg.data);
+    };
+
+    exec(innerCallback, null, PLUGIN_NAME, pluginNativeMethod.SUBSCRIBE, [eventName]);
+  },
+
+  /**
+   * Unsubscribe from the event.
+   *
+   * @param {String} eventName - from what event we are unsubscribing
+   */
+  unsubscribe: function(eventName) {
+    if (!eventName) {
+      eventName = DEFAULT_EVENT_NAME;
+    }
+
+    exec(null, null, PLUGIN_NAME, pluginNativeMethod.UNSUBSCRIBE, [eventName]);
+  }
+};
+
+module.exports = universalLinks;