initial commit

CHANGELOG.md

@@ -0,0 +1,84 @@
+# Change Log
+
+## 1.2.1 (2016-10-23)
+
+**Bug fixes:**
+
+- [Issue #79](https://github.com/martindrapeau/cordova-universal-links-plugin/issues/79). Fixed installation error: header files were added to the compile section of the project.
+- [Issue #77](https://github.com/martindrapeau/cordova-universal-links-plugin/issues/77). Fixed `before_prepare` hook for iOS that crashed on several systems. Thanks to [@lunchbag](https://github.com/lunchbag) for providing a fix.
+
+**Enhancements:**
+
+- [Issue #93](https://github.com/martindrapeau/cordova-universal-links-plugin/issues/93). Fixed iOS build warnings.
+
+## 1.2.0 (2016-07-27)
+
+**Enhancements:**
+
+- [Merged pull request #56](https://github.com/martindrapeau/cordova-universal-links-plugin/pull/56). Adds support for wildcard domains. Thanks to [@schmidt](https://github.com/schmidt) for implementation.
+
+**Docs:**
+
+- [Merged pull request #67](https://github.com/martindrapeau/cordova-universal-links-plugin/pull/67). Added `Prevent Android from creating multiple app instances` section. Thanks to [@yernandus](https://github.com/yernandus).
+- [Merged pull request #70](https://github.com/martindrapeau/cordova-universal-links-plugin/pull/70). Added `Digital Asset Links support` section. Thanks to [@ghybs](https://github.com/ghybs).
+
+## 1.1.2 (2016-04-27)
+
+**Bug fixes:**
+
+- [Issue #27](https://github.com/martindrapeau/cordova-universal-links-plugin/issues/27). From now on dependency packages will be installed in the plugin's folder instead of the project's root folder.
+
+## 1.1.1 (2016-03-17)
+
+**Bug fixes:**
+
+- [Issue #52](https://github.com/martindrapeau/cordova-universal-links-plugin/issues/52). Fixed `config.xml` file preferences reading. Thanks to [@ikostic](https://github.com/ikostic) for providing fix.
+- [Issue #47](https://github.com/martindrapeau/cordova-universal-links-plugin/issues/47). If `paths` in `apple-app-site-association` file contains only `*` - we will also add `/`, so that app would be opened from root domain.
+- Merged [PR #42](https://github.com/martindrapeau/cordova-universal-links-plugin/pull/42). Fixed Android web integration on Android 6.0. Thanks to [@mohamed-ahmed](https://github.com/mohamed-ahmed).
+
+**Docs:**
+
+- Merged [PR #50](https://github.com/martindrapeau/cordova-universal-links-plugin/pull/50). Fixed typo in documentation. Thanks to [@rafaellop](https://github.com/rafaellop).
+- Merged [PR #43](https://github.com/martindrapeau/cordova-universal-links-plugin/pull/43). Updated documentation regarding `apple-app-site-association` file. Thanks to [@Chun-Yang](https://github.com/Chun-Yang).
+- Updated `Useful notes on Universal Links for iOS` section. Thanks to [@conor-mac-aoidh](https://github.com/conor-mac-aoidh) for providing information.
+
+## 1.1.0 (2015-12-18)
+
+**Bug fixes:**
+
+- [Issue #26](https://github.com/martindrapeau/cordova-universal-links-plugin/issues/26). Fixed support for multiple wildcards in path. Thanks to [@tdelmas](https://github.com/tdelmas) for helping with solution.
+- Other minor bug fixes.
+
+**Enhancements:**
+
+- [Issue #18](https://github.com/martindrapeau/cordova-universal-links-plugin/issues/18). Added JS module through which you can subscribe for launch events. Solves timing issue with the previous `document.addEventListener()` approach.
+- [Issue #20](https://github.com/martindrapeau/cordova-universal-links-plugin/issues/20). Lowered min iOS version to 8.0. Plugin want work on devices prior to iOS 9, but if your application includes this plugin - it now will run on iOS 8 devices. Before you had to drop iOS 8 support.
+- [Issue #22](https://github.com/martindrapeau/cordova-universal-links-plugin/issues/22). Plugin now compatible with Cordova v5.4.
+- [Issue #24](https://github.com/martindrapeau/cordova-universal-links-plugin/issues/24). Now you can define iOS Team ID as plugin preference. It will be used for generation of `apple-app-site-association` files.
+- [Issue #25](https://github.com/martindrapeau/cordova-universal-links-plugin/issues/25). Plugin now compatible with Cordova iOS platform v4.0.0.
+
+**Docs:**
+
+- Added `Migrating from previous versions` section.
+- Updated `Cordova config preferences` section.
+- Updated `Application launch handling` section.
+- Other minor changes because of new release.
+
+## 1.0.1 (2015-10-23)
+
+**Bug fixes:**
+
+- Android. Fixed [issue #9](https://github.com/martindrapeau/cordova-universal-links-plugin/issues/9). Now when application is resumed from the link click - appropriate event is dispatched to the JavaScript side.
+
+**Enhancements:**
+
+- iOS. [Issue #6](https://github.com/martindrapeau/cordova-universal-links-plugin/issues/6). Scheme is now removed from the url matching process, since it is not needed: only hostname and path are used.
+- Merged [pull request #1](https://github.com/martindrapeau/cordova-universal-links-plugin/pull/1). Now dependency npm packages are taken from the package.json file. Thanks to [@dpa99c](https://github.com/dpa99c).
+
+**Docs:**
+
+- Added `Useful notes on Universal Links for iOS` section.
+- Updated `Android web integration` section. Added more information about web integration process.
+- Added some additional links on the Android documentation.
+- Fixed some broken links inside the docs.
+- Added CHANGELOG.md file.

LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 nordnet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

README.md

@@ -0,0 +1,899 @@
+# Cordova Universal Links Plugin
+This Cordova plugin adds support for opening an application from the browser when user clicks on the link. Better known as:
+- [Universal Links on iOS](https://developer.apple.com/library/ios/documentation/General/Conceptual/AppSearch/UniversalLinks.html)
+- [Deep Linking on Android](https://developer.android.com/training/app-indexing/deep-linking.html)
+
+Basically, you can have a single link that will either open your app or your website, if the app isn't installed.
+
+Integration process is simple:
+
+1. Add the plugin to your project (see [Installation](#installation)).
+2. Define supported hosts and paths in Cordova's `config.xml` (see [Cordova config preferences](#cordova-config-preferences)).
+3. Write some JavaScript code to listen for application launch by the links (see [Application launch handling](#application-launch-handling)).
+4. Build project from the CLI.
+5. Activate support for UL on your website (see [Android web integration](#android-web-integration) and [iOS web integration](#ios-web-integration)).
+6. Test it (see [Test UL for Android locally](#testing-ul-for-android-locally) and [Testing iOS application](#testing-ios-application)).
+
+It is important not only to redirect users to your app from the web, but also provide them with the information they were looking for. For example, if someone clicks on `http://mysite.com/news` and get redirected in the app - they are probably hoping to see the `news` page in it. The plugin will help developers with that. In `config.xml` you can specify an event name that is dispatched when user opens the app from the certain link. This way, the appropriate method of your web project will be called, and you can show to user the requested content.
+
+**Note:** At the moment the plugin doesn't support custom url schemes, but they can be added later.
+
+## Supported Platforms
+- Android 4.0.0 or above.
+- iOS 9.0 or above. Xcode 7 is required. To build plugin with Xcode 6 - [read the instructions](#how-to-build-plugin-in-xcode-6) below.
+
+**iOS Note:** you can use this plugin in iOS 8 applications. It will not crash the app, but it also is not gonna handle the links, because this is iOS 9 feature.
+
+## Documentation
+- [Installation](#installation)
+- [Migrating from previous versions](#migrating-from-previous-versions)
+- [How to build plugin in Xcode 6](#how-to-build-plugin-in-xcode-6)
+- [Cordova config preferences](#cordova-config-preferences)
+- [Application launch handling](#application-launch-handling)
+- [Android web integration](#android-web-integration)
+  - [Modify web pages](#modify-web-pages)
+  - [Verify your website on Webmaster Tools](#verify-your-website-on-webmaster-tools)
+  - [Connect your app in the Google Play console](#connect-your-app-in-the-google-play-console)
+  - [Digital Asset Links support](#digital-asset-links-support)
+- [Testing UL for Android locally](#testing-ul-for-android-locally)
+- [iOS web integration](#ios-web-integration)
+  - [Activate UL support in member center](#activate-ul-support-in-member-center)
+  - [Configure apple-app-site-association file for website](#configure-apple-app-site-association-file-for-website)
+- [Testing iOS application](#testing-ios-application)
+- [Useful notes on Universal Links for iOS](#useful-notes-on-universal-links-for-ios)
+  - [They don't work everywhere](#they-dont-work-everywhere)
+  - [How links handled in Safari](#how-links-handled-in-safari)
+- [Additional documentation links](#additional-documentation-links)
+
+### Installation
+This requires cordova 5.0+ (current stable 1.2.1)
+
+```sh
+cordova plugin add cordova-mirtech-plugin-universal-links
+```
+
+It is also possible to install via repo url directly (**unstable**)
+
+```sh
+cordova plugin add https://github.com/martindrapeau/cordova-universal-links-plugin.git
+```
+
+### Migrating from previous versions
+
+##### From v1.0.x to v1.1.x
+
+In v1.0.x to capture universal links events you had to subscribe on them like so:
+```js
+document.addEventListener('eventName', didLaunchAppFromLink, false);
+
+function didLaunchAppFromLink(event) {
+  var urlData = event.detail;
+  console.log('Did launch application from the link: ' + urlData.url);
+  // do some work
+}
+```
+And there were some problems with the timing: event could be fired long before you were subscribing to it.
+
+From v1.1.0 it changes to the familiar Cordova style:
+```js
+var app = {
+  // Application Constructor
+  initialize: function() {
+    this.bindEvents();
+  },
+
+  // Bind Event Listeners
+  bindEvents: function() {
+    document.addEventListener('deviceready', this.onDeviceReady, false);
+  },
+
+  // deviceready Event Handler
+  onDeviceReady: function() {
+    universalLinks.subscribe('eventName', app.didLaunchAppFromLink);
+  },
+
+  didLaunchAppFromLink: function(eventData) {
+    alert('Did launch application from the link: ' + eventData.url);
+  }
+};
+
+app.initialize();
+```
+
+As you can see, now you subscribe to event via `universalLinks` module when `deviceready` is fired. Actually, you can subscribe to it in any place of your application: plugin stores the event internally and dispatches it when there is a subscriber for it.
+
+Also, in v1.0.x `ul_didLaunchAppFromLink` was used as a default event name. From v1.1.0 you can just do like that:
+```js
+universalLinks.subscribe(null, callbackFunction);
+```
+If you didn't specify event name for the `path` or `host` - in the JS code just pass `null` as event name. But just for readability you might want to specify it `config.xml`.
+
+### How to build plugin in Xcode 6
+
+If you are still using Xcode 6 and there is no way for you to upgrade right now to Xcode 7 - follow the instructions below in order to use this plugin.
+
+1. Clone the `xcode6-support` branch of the plugin from the GitHub:
+
+  ```sh
+  mkdir /Workspace/Mobile/CordovaPlugins
+  cd /Workspace/Mobile/CordovaPlugins
+  git clone -b xcode6-support https://github.com/martindrapeau/cordova-universal-links-plugin.git
+  ```
+
+2. Go to your applications project and add plugin from the cloned source:
+
+  ```sh
+  cd /Workspace/Mobile/CoolApp
+  cordova plugin add /Workspace/Mobile/CordovaPlugins/cordova-mirtech-plugin-universal-links/
+  ```
+
+Now you can build your project in Xcode 6.
+
+### Cordova config preferences
+
+Cordova uses `config.xml` file to set different project preferences: name, description, starting page and so on. Using this config file you can also set options for the plugin.
+
+Those preferences are specified inside the `<universal-links>` block. For example:
+
+```xml
+<universal-links>
+    <host name="example.com">
+        <path url="/some/path" />
+    </host>
+</universal-links>
+```
+
+In it you define hosts and paths that application should handle. You can have as many hosts and paths as you like.
+
+#### host
+`<host />` tag lets you describe hosts, that your application supports. It can have three attributes:
+- `name` - hostname. **This is a required attribute.**
+- `scheme` - supported url scheme. Should be either `http` or `https`. If not set - `http` is used.
+- `event` - name of the event, that is used to match application launch from this host to a callback on the JS side. If not set - pass `null` as event name when you are subscribing in JS code.
+
+For example,
+
+```xml
+<universal-links>
+    <host name="example.com" scheme="https" event="ul_myExampleEvent" />
+</universal-links>
+```
+
+defines, that when user clicks on any `https://example.com` link - callback, that was set for `ul_myExampleEvent` gets called. More details regarding event handling can be found [below](#application-launch-handling).
+
+You can also use wildcards for domains. For example,
+
+```xml
+<universal-links>
+    <host name="*.users.example.com" scheme="https" event="wildcardusers" />
+    <host name="*.example.com" scheme="https" event="wildcardmatch" />
+</universal-links>
+```
+
+Please note, that iOS will look for the `apple-app-site-association` on `https://users.example.com/apple-app-site-association` and `https://example.com/apple-app-site-association` respectively.
+
+Android will try to access the [app links file](https://developer.android.com/training/app-links/index.html#web-assoc) at `https://*.users.example.com/.well-known/assetlinks.json` and `https://*.example.com/.well-known/assetlinks.json` respectively.
+
+#### path
+In `<path />` tag you define which paths for the given host you want to support. If no `<path />` is set - then we want to handle all of them. If paths are defined - then application will process only those links.
+
+Supported attributes are:
+- `url` - path component of the url; should be relative to the host name. **This is a required attribute.**
+- `event` - name of the event, that is used to match application launch from the given hostname and path to a callback on the JS side. If not set - pass `null` as event name when you are subscribing in JS code.
+
+For example,
+
+```xml
+<universal-links>
+    <host name="example.com">
+        <path url="/some/path" />
+    </host>
+</universal-links>
+```
+
+defines, that when user clicks on `http://example.com/some/path` - application will be launched, and default callback gets called. All other links from that host will be ignored.
+
+Query parameters are not used for link matching. For example, `http://example.com/some/path?foo=bar#some_tag` will work the same way as `http://example.com/some/path` does.
+
+In order to support all links inside `/some/path/` you can use `*` like so:
+
+```xml
+<universal-links>
+    <host name="example.com">
+        <path url="/some/path/*" />
+    </host>
+</universal-links>
+```
+
+`*` can be used only for paths, but you can place it anywhere. For example,
+
+```xml
+<universal-links>
+    <host name="example.com">
+        <path url="*mypath*" />
+    </host>
+</universal-links>
+```
+
+states, that application can handle any link from `http://example.com` which has `mypath` string in his path component: `http://example.com/some/long/mypath/test.html`, `http://example.com/testmypath.html` and so on.
+
+**Note:** Following configuration
+
+```xml
+<universal-links>
+    <host name="example.com" />
+</universal-links>
+```
+
+is the same as:
+
+```xml
+<universal-links>
+    <host name="example.com">
+      <path url="*" />
+    </host>
+</universal-links>
+```
+
+#### ios-team-id
+
+As described in `Step 2` of [Configure apple-app-site-association file for website](#configure-apple-app-site-association-file-for-website) section: when application is build from the CLI - plugin generates `apple-app-site-association` files for each host, defined in `config.xml`. In them there's an `appID` property that holds your iOS Team ID and Bundle ID:
+
+```json
+{
+  "applinks": {
+    "apps": [],
+    "details": [
+      {
+        "appID": "<TEAM_ID_FROM_MEMBER_CENTER>.<BUNDLE_ID>",
+        "paths": [
+          "/some/path/*"
+        ]
+      }
+    ]
+  }
+}
+```
+
+- `<BUNDLE_ID>` is replaced with the id, that is defined in the `widget` of your `config.xml`. For example:
+
+  ```xml
+  <widget id="com.example.ul" version="0.0.1" xmlns="http://www.w3.org/ns/widgets" xmlns:cdv="http://cordova.apache.org/ns/1.0">
+  ```
+
+- `<TEAM_ID_FROM_MEMBER_CENTER>` - that property is defined in the member center of your iOS account. So, you can either put it in the generated `apple-app-site-association` file manually, or use `<ios-team-id>` preference in `config.xml` like so:
+
+  ```xml
+  <universal-links>
+      <ios-team-id value="<TEAM_ID_FROM_MEMBER_CENTER>" />
+  </universal-links>
+  ```
+
+For example, following `config.xml`
+```xml
+<widget id="com.example.ul" version="0.0.1" xmlns="http://www.w3.org/ns/widgets" xmlns:cdv="http://cordova.apache.org/ns/1.0">
+
+<!-- some other cordova preferences -->
+
+<universal-links>
+    <ios-team-id value="1Q2WER3TY" />
+    <host name="mysite.com" >
+      <path url="/some/path/*" />
+    </host>
+</universal-links>
+</widget>
+```
+
+will result into
+```json
+{
+  "applinks": {
+    "apps": [],
+    "details": [
+      {
+        "appID": "1Q2WER3TY.com.example.ul",
+        "paths": [
+          "/some/path/*"
+        ]
+      }
+    ]
+  }
+}
+```
+
+This is iOS-only preference, Android doesn't need it.
+
+#### Prevent Android from creating multiple app instances
+
+When clicking on a universal link from another App (typically from an email client), Android will likely create a new instance of your app, even if it is already loaded in memory. It may even create a new instance with each click, resulting in many instances of your app in the task switcher. See details in [issue #37](https://github.com/martindrapeau/cordova-universal-links-plugin/issues/37).
+
+To force Android opening always the same app instance, a known workaround is to change the [activity launch mode](https://developer.android.com/guide/topics/manifest/activity-element.html#lmode) to `singleInstance`. To do so, you can use the following preference in Cordova `config.xml` file:
+```xml
+<preference name="AndroidLaunchMode" value="singleInstance" />
+```
+
+### Application launch handling
+
+As mentioned - it is not enough just to redirect a user into your app, you will also need to display the correct content. In order to solve that - plugin provides JavaScript module: `universalLinks`. To get notified on application launch do the following:
+```js
+universalLinks.subscribe('eventName', function (eventData) {
+  // do some work
+  console.log('Did launch application from the link: ' + eventData.url);
+});
+```
+
+If you didn't specify event name for path and host in `config.xml` - just pass `null` as a first parameter:
+```js
+universalLinks.subscribe(null, function (eventData) {
+  // do some work
+  console.log('Did launch application from the link: ' + eventData.url);
+});
+```
+
+`eventData` holds information about the launching url. For example, for `http://myhost.com/news/ul-plugin-released.html?foo=bar#cordova-news` it will be:
+
+```json
+{
+  "url": "http://myhost.com/news/ul-plugin-released.html?foo=bar#cordova-news",
+  "scheme": "http",
+  "host": "myhost.com",
+  "path": "/news/ul-plugin-released.html",
+  "params": {
+    "foo": "bar"
+  },
+  "hash": "cordova-news"
+}
+```
+
+- `url` - original launch url;
+- `scheme` - url scheme;
+- `host` - hostname from the url;
+- `path` - path component of the url;
+- `params` - dictionary with query parameters; the ones that after `?` character;
+- `hash` - content after `#` character.
+
+If you want - you can also unsubscribe from the events later on:
+```js
+universalLinks.unsubscribe('eventName');
+```
+
+Now it's time for some examples. In here we are gonna use Android, because it is easier to test (see [testing for Android](#testing-ul-for-android-locally) section). JavaScript side is platform independent, so all the example code below will also work for iOS.
+
+1. Create new Cordova application and add Android platform.
+
+  ```sh
+  cordova create TestAndroidApp com.example.ul TestAndroidApp
+  cd ./TestAndroidApp
+  cordova platform add android
+  ```
+
+2. Add UL plugin:
+
+  ```sh
+  cordova plugin add cordova-mirtech-plugin-universal-links
+  ```
+
+3. Add `<universal-links>` preference into `config.xml`:
+
+  ```xml
+  <!-- some other data from config.xml -->
+  <universal-links>
+   <host name="myhost.com">
+     <path url="/news/" event="openNewsListPage" />
+     <path url="/news/*" event="openNewsDetailedPage" />
+   </host>
+  </universal-links>
+  ```
+
+  As you can see - we want our application to be launched, when user goes to the `news` section of our website. And for that - we are gonna dispatch different events to understand, what has happened.
+
+4. Subscribe to `openNewsListPage` and `openNewsDetailedPage` events. For that - open `www/js/index.js` and make it look like that:
+
+  ```js
+  var app = {
+    // Application Constructor
+    initialize: function() {
+      this.bindEvents();
+    },
+
+    // Bind Event Listeners
+    bindEvents: function() {
+      document.addEventListener('deviceready', this.onDeviceReady, false);
+    },
+
+    // deviceready Event Handler
+    onDeviceReady: function() {
+      console.log('Device is ready for work');
+      universalLinks.subscribe('openNewsListPage', app.onNewsListPageRequested);
+      universalLinks.subscribe('openNewsDetailedPage', app.onNewsDetailedPageRequested);
+    },
+
+    // openNewsListPage Event Handler
+    onNewsListPageRequested: function(eventData) {
+      console.log('Showing list of awesome news.');
+
+      // do some work to show list of news
+    },
+
+    // openNewsDetailedPage Event Handler
+    onNewsDetailedPageRequested: function(eventData) {
+      console.log('Showing to user details page: ' + eventData.path);
+
+      // do some work to show detailed page
+    }
+  };
+
+  app.initialize();
+  ```
+
+  Now, if the user clicks on `http://myhost.com/news/` link - method `onNewsListPageRequested` will be called, and for every link like `http://myhost.com/news/*` - `onNewsDetailedPageRequested`. Basically, we created a mapping between the links and JavaScript methods.
+
+5. Build and run your application:
+
+  ```sh
+  cordova run android
+  ```
+
+6. Close your app.
+
+7. Execute in the terminal:
+
+  ```sh
+  adb shell am start -W -a android.intent.action.VIEW -d "http://myhost.com/news/" com.example.ul
+  ```
+
+  As a result, your application will be launched, and in JavaScript console you will see message:
+
+  ```
+  Showing to user list of awesome news.
+  ```
+
+  Repeat operation, but this time with the command:
+
+  ```sh
+  adb shell am start -W -a android.intent.action.VIEW -d "http://myhost.com/news/ul-plugin-released.html" com.example.ul
+  ```
+
+  Application will be launched and you will see in JS console:
+
+  ```
+  Showing to user details page: /news/ul-plugin-released.html
+  ```
+
+Now, let's say, you want your app to handle all links from `myhost.com`, but you need to keep the mapping for the paths. For that you just need to modify your `config.xml` and add default event handler on JavaScript side:
+
+1. Open `config.xml` and change `<universal-links>` block like so:
+
+  ```xml
+  <universal-links>
+   <host name="myhost.com">
+     <path url="/news/" event="openNewsListPage" />
+     <path url="/news/*" event="openNewsDetailedPage" />
+     <path url="*" event="launchedAppFromLink" />
+   </host>
+  </universal-links>
+  ```
+
+  As you can see - we added `*` as `path`. This way we declared, that application should be launched from any `http://myhost.com` link.
+
+2. Add handling for default UL event in the `www/js/index.js`:
+
+  ```js
+  var app = {
+    // Application Constructor
+    initialize: function() {
+      this.bindEvents();
+    },
+
+    // Bind Event Listeners
+    bindEvents: function() {
+      document.addEventListener('deviceready', this.onDeviceReady, false);
+    },
+
+    // deviceready Event Handler
+    onDeviceReady: function() {
+      console.log('Handle deviceready event if you need');
+      universalLinks.subscribe('openNewsListPage', app.onNewsListPageRequested);
+      universalLinks.subscribe('openNewsDetailedPage', app.onNewsDetailedPageRequested);
+      universalLinks.subscribe('launchedAppFromLink', app.onApplicationDidLaunchFromLink);
+    },
+
+    // openNewsListPage Event Handler
+    onNewsListPageRequested: function(eventData) {
+      console.log('Showing to user list of awesome news');
+
+      // do some work to show list of news
+    },
+
+    // openNewsDetailedPage Event Handler
+    onNewsDetailedPageRequested: function(eventData) {
+      console.log('Showing to user details page for some news');
+
+      // do some work to show detailed page
+    },
+
+    // launchedAppFromLink Event Handler
+    onApplicationDidLaunchFromLink: function(eventData) {
+      console.log('Did launch app from the link: ' + eventData.url);
+    }
+  };
+
+  app.initialize();
+  ```
+
+That's it! Now, by default for `myhost.com` links `onApplicationDidLaunchFromLink` method will be called, but for `news` section - `onNewsListPageRequested` and `onNewsDetailedPageRequested`.
+
+### Android web integration
+
+If you have already tried to use `adb` to simulate application launch from the link - you probably saw chooser dialog with at least two applications in it: browser and your app. This happens because web content can be handled by multiple things. To prevent this from happening you need to activate app indexing. App indexing is the second part of deep linking, where you link that URI/URL between Google and your app.
+
+Integration process consists of three steps:
+
+1. Modify your web pages by adding special `<link />` tags in the `<head />` section.
+2. Verify your website on Webmaster Tools.
+3. Connect your app in the Google Play console.
+
+#### Modify web pages
+
+To create a link between your mobile content and the page on the website you need to include proper `<link />` tags in the `<head />` section of your website.
+
+Link tag is constructed like so:
+
+```html
+<link rel="alternate"
+      href="android-app://<package_name>/<scheme>/<host><path>" />
+```
+
+where:
+- `<package_name>` - your application's package name;
+- `<scheme>` - url scheme;
+- `<host>` - hostname;
+- `<path>` - path component.
+
+For example, if your `config.xml` file looks like this:
+
+```xml
+<universal-links>
+ <host name="myhost.com">
+   <path url="/news/" />
+   <path url="/profile/" />
+ </host>
+</universal-links>
+```
+
+and a package name is `com.example.ul`, then `<head />` section on your website will be:
+
+```html
+<head>
+<link rel="alternate" href="android-app://com.example.ul/http/myhost.com/news/" />
+<link rel="alternate" href="android-app://com.example.ul/http/myhost.com/profile/" />
+
+<!-- Your other stuff from the head tag -->
+</head>
+```
+
+Good news is that **plugin generates those tags for you**. When you run `cordova build` (or `cordova run`) - they are placed in `ul_web_hooks/android/android_web_hook.html` file inside your Cordova project root directory.
+
+So, instead of manually writing them down - you can take them from that file and put on the website.
+
+#### Verify your website on Webmaster Tools
+
+If your website is brand new, you’ll want to verify it through [Webmaster Tools](https://www.google.com/webmasters/tools/). That’s how the Google crawler knows that it’s there and can index it to do everything it needs to do. In order to do that - just add your website in the console and follow the instructions to versify, that you own the site. Most likely, they will ask you to add something on your page.
+
+#### Connect your app in the Google Play console
+
+Next, you’ll want to connect your app using the Google Play Console so the app indexing starts working. If you go to your app, there’s a menu that says `Services and API` in which you can click `Verify Website`, and provide the URL to check that it has the appropriate tags in the HTML. Once that’s all set up, it will start showing in search results.
+
+#### Digital Asset Links support
+
+For Android version 6.0 (Marshmallow) or greater [Digital Asset Links](https://developers.google.com/digital-asset-links/v1/getting-started) can be used.
+
+Here's a very simplified example of how the website `www.example.com` could use Digital Asset Links to specify that any links to URLs in that site should open in a designated app rather than the browser:
+
+1. The website `www.example.com` publishes a statement list at `https://www.example.com/.well-known/assetlinks.json`. This is the official name and location for a statement list on a site. Statement lists in any other location, or with any other name, are not valid for this site. In our example, the statement list consists of one statement, granting its Android app the permission to open links on its site:
+
+  ```json
+  [{
+    "relation": ["delegate_permission/common.handle_all_urls"],
+    "target" : { "namespace": "android_app", "package_name": "com.example.app",
+                 "sha256_cert_fingerprints": ["hash_of_app_certificate"] }
+  }]
+  ```
+
+  A statement list supports an array of statements within the [ ] marks, but our example file contains only one statement.
+
+2. The Android app listed in the statement above has an intent filter that specifies the scheme, host, and path pattern of URLs that it wants to handle: in this case, `https://www.example.com`. The intent filter includes a special attribute `android:autoVerify`, new to Android M, which indicates that Android should verify the statement on the website, described in the intent filter when the app is installed.
+
+3. A user installs the app. Android sees the intent filter with the `autoVerify` attribute and checks for the presence of the statement list at the specified site. If present, Android checks whether that file includes a statement granting link handling to the app, and verifies the app against the statement by certificate hash. If everything checks out, Android will then forward any `https://www.example.com` intents to the `example.com` app.
+
+4. The user clicks a link to `https://www.example.com/puppies` on the device. This link could be anywhere: in a browser, in a Google Search Appliance suggestion, or anywhere else. Android forwards the intent to the `example.com` app.
+
+5. The `example.com` app receives the intent and chooses to handle it, opening the puppies page in the app. If for some reason the app had declined to handle the link, or if the app were not on the device, then the link will be send to the next default intent handler, matching that intent pattern (i.e. browser).
+
+### Testing UL for Android locally
+
+To test Android application for Deep Linking support you just need to execute the following command in the console:
+
+```sh
+adb shell am start
+        -W -a android.intent.action.VIEW
+        -d <URI> <PACKAGE>
+```
+
+where
+- `<URI>` - url that you want to test;
+- `<PACKAGE>` - your application's package name.
+
+**Note:** if you didn't configure your website for UL support - then most likely after executing the `adb` command you will see a chooser dialog with multiple applications (at least browser and your test app). This happens because you are trying to view web content, and this can be handled by several applications. Just choose your app and proceed. If you configured your website as [described above](#android-web-integration) - then no dialog is shown and your application will be launched directly.
+
+Let's create new application to play with:
+1. Create new Cordova project and add Android platform to it:
+
+  ```sh
+  cordova create TestAndroidApp com.example.ul TestAndroidApp
+  cd ./TestAndroidApp
+  cordova platform add android
+  ```
+
+2. Add UL plugin:
+
+  ```sh
+  cordova plugin add cordova-mirtech-plugin-universal-links
+  ```
+
+3. Add `<universal-links>` preference into `config.xml` (`TestAndroidApp/config.xml`):
+
+  ```xml
+  <!-- some other data from config.xml -->
+  <universal-links>
+   <host name="myhost.com" />
+  </universal-links>
+  ```
+
+4. Build and run the app:
+
+  ```sh
+  cordova run android
+  ```
+
+5. Close your application and return to console.
+6. Enter in console:
+
+  ```sh
+  adb shell am start -W -a android.intent.action.VIEW -d "http://myhost.com/any/path" com.example.ul
+  ```
+
+  As a result, your application will be launched and you will see in console:
+
+  ```
+  Starting: Intent { act=android.intent.action.VIEW dat=http://myhost.com/any/path pkg=com.example.ul }
+  Status: ok
+  Activity: com.example.ul/.MainActivity
+  ThisTime: 52
+  TotalTime: 52
+  Complete
+  ```
+
+  If you'll try to use host (or path), that is not defined in `config.xml` - you'll get a following error:
+
+  ```
+  Starting: Intent { act=android.intent.action.VIEW dat=http://anotherhost.com/path pkg=com.example.ul }
+  Error: Activity not started, unable to resolve Intent { act=android.intent.action.VIEW dat=http://anotherhost.com/path flg=0x10000000 pkg=com.example.ul }
+  ```
+
+This way you can experiment with your Android application and check how it corresponds to different links.
+
+### iOS web integration
+
+In the case of iOS integration of the Universal Links is a little harder. It consist of two steps:
+
+1. Register your application on [developer console](https://developer.apple.com) and enable `Associated Domains` feature. Make sure your website is SSL ready.
+2. Generate, and upload `apple-app-site-association` file on your website (if you don't have it yet).
+
+First one you will have to do manually, but plugin will help you with the second step.
+
+#### Activate UL support in member center
+
+1. Go to your [developer console](https://developer.apple.com). Click on `Certificate, Identifiers & Profiles` and then on `Identifiers`.
+
+  ![Developer console](docs/images/developer-console.jpg?raw=true)
+
+2. If you already have a registered App Identifier - just skip this and go to `3`. If not - create it by clicking on `+` sign, fill out `name` and `bundle ID`. `name` can be whatever you want, but `bundle ID` should be the one you defined in your Cordova's `config.xml`.
+
+  ![App ID](docs/images/app-id.jpg?raw=true)
+
+3. In the `Application Services` section of your App Identifier activate `Associated Domains` and save the changes.
+
+  ![App ID](docs/images/app-associated-domains.jpg?raw=true)
+
+Now your App ID is registered and has `Associated Domains` feature.
+
+#### Configure apple-app-site-association file for website
+
+In order for Universal Links to work - you need to associate your application with the certain domain. For that you need to:
+
+1. Make your site to work over `https`.
+2. Create `apple-app-site-association` file, containing your App ID and paths you want to handle.
+3. Upload `apple-app-site-association` file in the root of your website.
+
+##### Step 1
+
+We are not gonna describe stuff regarding certificate acquiring and making your website to work over `https`. You can find lots of information about that on the Internet.
+
+##### Step 2
+
+When you run `cordova build` (or `cordova run`) - plugin takes data from `config.xml` and generates `apple-app-site-association` files for each host you defined. Files are placed in the `ul_web_hooks/ios/` folder of your Cordova project. File names are:
+```
+<hostname>#apple-app-site-association
+```
+
+For example, let's say your application's bundle ID is `com.example.ul`, and `config.xml` has several hosts:
+
+```xml
+<universal-links>
+  <host name="firsthost.com">
+    <path url="/some/path/*" />
+  </host>
+  <host name="secondhost.com" />
+</universal-links>
+```
+
+Run `cordova build`, and then go to `ul_web_hooks/ios/` folder in your Cordova project. You will see there two files:
+
+```
+firsthost.com#apple-app-site-association
+secondhost.com#apple-app-site-association
+```
+
+Content of the first one is:
+```json
+{
+  "applinks": {
+    "apps": [],
+    "details": [
+      {
+        "appID": "<YOUR_TEAM_ID_FROM_MEMBER_CENTER>.com.example.ul",
+        "paths": [
+          "/some/path/*"
+        ]
+      }
+    ]
+  }
+}
+```
+
+And the second one:
+```json
+{
+  "applinks": {
+    "apps": [],
+    "details": [
+      {
+        "appID": "<YOUR_TEAM_ID_FROM_MEMBER_CENTER>.com.example.ul",
+        "paths": [
+          "*", "/"
+        ]
+      }
+    ]
+  }
+}
+```
+
+**Note:** in the second case plugin will add `/` to the paths, so the app would be opened with `https://secondhost.com.com/` links, and not only with `https://secondhost.com/some/random.html`.
+
+Before uploading them on your servers - you need to replace `<YOUR_TEAM_ID_FROM_MEMBER_CENTER>` with your actual team ID from the member center. You can find it in `Developer Account Summary` section on the [developer.apple.com](https://developer.apple.com/membercenter/index.action#accountSummary).
+
+Also, it is a `Prefix` preference in the App ID description.
+
+![App ID team prefix](docs/images/app-id-team-prefix.jpg?raw=true)
+
+If you already have `apple-app-site-association` file - then you need to add `applinks` block to it from the generated file.
+
+##### Step 3
+
+Upload `apple-app-site-association` file in the root of your domain.
+
+**It should be downloadable from the direct link.** For example, `https://firsthost.com/apple-app-site-association`.
+
+**No redirects are allowed!** When application is launched - it downloads it from that link, so if it can't find it - Universal Links are not gonna work.
+
+That's it, you have finished configuring iOS for UL support.
+
+### Testing iOS application
+
+Unlike Android, Apple doesn't provide any tools to test Universal Links. So you have to do all the [integration stuff](#ios-web-integration) before any real testing. So please, do that.
+
+But if you don't want to... well, there is one way to skip it. You can use [branch.io](https://branch.io) to handle all the SSL/apple-app-site-association stuff for you. How to do that - described in their [documentation](https://dev.branch.io/recipes/branch_universal_links/#enable-universal-links-on-the-branch-dashboard). From there you can skip Xcode and SDK integration stuff, because you don't need that.
+
+Step-by-step guide:
+
+1. Go to developer console and register your App ID, as described in [Activating UL support in member center](#activate-ul-support-in-member-center).
+
+2. Register account on [branch.io](https://dashboard.branch.io/), if you don't have it yet.
+
+3. Login into [branch dashboard](https://dashboard.branch.io/). Go to `Settings` -> `Link Settings`, activate `Enable Universal Links`, fill in `Bundle identifier` and `Team ID`.
+
+  ![App ID](docs/images/branch-io.jpg?raw=true)
+
+4. It will take some time to update their servers, so be patient. To check if it is ready - just open [https://bnc.lt/apple-app-site-association](https://bnc.lt/apple-app-site-association) and search for your `Bundle identifier`.
+
+  Pay attention for `paths` - if there is any for your app, then write it down.
+
+  For example:
+  ```json
+  ...,"9F38WJR2U8.com.example.ul":{"paths":["/a2Be/*"]},...
+  ```
+
+5. Create new Cordova iOS application and add UL plugin:
+
+  ```sh
+  cordova create TestProject com.example.ul TestProject
+  cd ./TestProject
+  cordova platform add ios
+  cordova plugin add cordova-mirtech-plugin-universal-links
+  ```
+
+6. Add `bnc.lt` and your other hosts into `config.xml`:
+
+  ```xml
+  <universal-links>
+    <host name="bnc.lt" />
+    <host name="yourdomain.com" />
+  </universal-links>
+  ```
+
+  For test purpose you can leave only `bnc.lt` in there. But if you specifying your hosts - you need to [white label](https://dev.branch.io/recipes/branch_universal_links/#white-label-domains) them.
+
+7. Attach your real device to the computer and run application on it:
+
+  ```sh
+  cordova run ios
+  ```
+
+  Emulator will not work.
+
+8. Email yourself a link that need's to be tested.
+
+  For example, `https://bnc.lt/a2Be/somepage.html`. As you can see, link constructed from hostname and path component, specified in `apple-app-site-association` file. This link may not even lead to the real page, it doesn't matter. It's only purpose is to open the app.
+
+  Now click on your link. Application should be launched. If not - check all the steps above. Also, check your provisioning profiles in Xcode.
+
+### Useful notes on Universal Links for iOS
+
+#### They don't work everywhere
+
+First of all - you need to accept the fact, that Universal Links **doesn't work everywhere**. Some applications doesn't respect them. You can read more in [that article](https://blog.branch.io/ios-9.2-deep-linking-guide-transitioning-to-universal-links), section `Universal Links Still Don’t Work Everywhere`.
+
+#### How links handled in Safari
+
+When user clicks on the link - Safari checks, if any of the installed apps can handle it. If app is found - Safari starts it, if not - link opened as usually in the browser.
+
+Now, let's assume you have a following setup in `config.xml`:
+```xml
+<universal-links>
+  <host name="mywebsite.com">
+    <path url="/some/page.html" />
+  </host>
+</universal-links>
+```
+
+By this we state, that our app should handle `http://mywebsite.com/some/page.html` link. So, if user clicks on `http://mywebsite.com` - application would not launch. And this is totally as you want it to be. Now comes the interesting part: if user opens `http://mywebsite.com` in the Safari and then presses on `http://mywebsite.com/some/page.html` link - application is not gonna start, he will stay in the browser. And at the top of that page he will see a Smart Banner. To launch the application user will have to click on that banner. And this is a normal behaviour from iOS. If user already viewing your website in the browser - he doesn't want to leave it, when he clicks on some link, that leads on the page inside your site. But if he clicks on the `http://mywebsite.com/some/page.html` link from some other source - then it will start your application.
+
+Another thing that every developer should be aware of:
+
+When a user is in an app, opened by Universal Links - a return to browser option will persist at the top of the screen (i.e. `mywebsite.com`). Users who have clicked the `mywebsite.com` option will be taken to their Safari browser, and Smart Banner is persistently rendered on the top of the window. This banner has an `OPEN` call to action. For all future clicks of URLs, associated with this app via Universal Links, the app will never be launched again for the user, and the user will continue being redirected to the Safari page with the banner. If the user clicks `OPEN` - then the app will be launched, and all future clicks of the URL will deep linking the user to the app.
+
+### Additional documentation links
+
+**Android:**
+- [Video tutorial on Android App Indexing](https://realm.io/news/juan-gomez-android-app-indexing/)
+- [Enable Deep Linking on Android](https://developer.android.com/training/app-indexing/deep-linking.html)
+- [Specifying App Content for Indexing](https://developer.android.com/training/app-indexing/enabling-app-indexing.html)
+- [Documentation on enabling App Indexing on the website](https://developers.google.com/app-indexing/android/publish#host-your-links)
+
+**iOS:**
+- [Apple documentation on Universal Links](https://developer.apple.com/library/ios/documentation/General/Conceptual/AppSearch/UniversalLinks.html)
+- [Apple documentation on apple-app-site-association file](https://developer.apple.com/library/ios/documentation/Security/Reference/SharedWebCredentialsRef/index.html)
+- [How to setup universal links on iOS 9](https://blog.branch.io/how-to-setup-universal-links-to-deep-link-on-apple-ios-9)
+- [Branch.io documentation on universal links](https://dev.branch.io/recipes/branch_universal_links/#enable-universal-links-on-the-branch-dashboard)
+- [Where universal links don't work](https://blog.branch.io/ios-9.2-deep-linking-guide-transitioning-to-universal-links)

hooks/afterPrepareHook.js

@@ -0,0 +1,86 @@
+/**
+Hook is executed at the end of the 'prepare' stage. Usually, when you call 'cordova build'.
+
+It will inject required preferences in the platform-specific projects, based on <universal-links>
+data you have specified in the projects config.xml file.
+*/
+
+var configParser = require('./lib/configXmlParser.js');
+var androidManifestWriter = require('./lib/android/manifestWriter.js');
+var androidWebHook = require('./lib/android/webSiteHook.js');
+var iosProjectEntitlements = require('./lib/ios/projectEntitlements.js');
+var iosAppSiteAssociationFile = require('./lib/ios/appleAppSiteAssociationFile.js');
+var iosProjectPreferences = require('./lib/ios/xcodePreferences.js');
+var ANDROID = 'android';
+var IOS = 'ios';
+
+module.exports = function(ctx) {
+  run(ctx);
+};
+
+/**
+ * Execute hook.
+ *
+ * @param {Object} cordovaContext - cordova context object
+ */
+function run(cordovaContext) {
+  var pluginPreferences = configParser.readPreferences(cordovaContext);
+  var platformsList = cordovaContext.opts.platforms;
+
+  // if no preferences are found - exit
+  if (pluginPreferences == null) {
+    return;
+  }
+
+  // if no host is defined - exit
+  if (pluginPreferences.hosts == null || pluginPreferences.hosts.length == 0) {
+    console.warn('No host is specified in the config.xml. Universal Links plugin is not going to work.');
+    return;
+  }
+
+  platformsList.forEach(function(platform) {
+    switch (platform) {
+      case ANDROID:
+        {
+          activateUniversalLinksInAndroid(cordovaContext, pluginPreferences);
+          break;
+        }
+      case IOS:
+        {
+          activateUniversalLinksInIos(cordovaContext, pluginPreferences);
+          break;
+        }
+    }
+  });
+}
+
+/**
+ * Activate Deep Links for Android application.
+ *
+ * @param {Object} cordovaContext - cordova context object
+ * @param {Object} pluginPreferences - plugin preferences from the config.xml file. Basically, content from <universal-links> tag.
+ */
+function activateUniversalLinksInAndroid(cordovaContext, pluginPreferences) {
+  // inject preferenes into AndroidManifest.xml
+  androidManifestWriter.writePreferences(cordovaContext, pluginPreferences);
+
+  // generate html file with the <link> tags that you should inject on the website.
+  androidWebHook.generate(cordovaContext, pluginPreferences);
+}
+
+/**
+ * Activate Universal Links for iOS application.
+ *
+ * @param {Object} cordovaContext - cordova context object
+ * @param {Object} pluginPreferences - plugin preferences from the config.xml file. Basically, content from <universal-links> tag.
+ */
+function activateUniversalLinksInIos(cordovaContext, pluginPreferences) {
+  // modify xcode project preferences
+  iosProjectPreferences.enableAssociativeDomainsCapability(cordovaContext);
+
+  // generate entitlements file
+  iosProjectEntitlements.generateAssociatedDomainsEntitlements(cordovaContext, pluginPreferences);
+
+  // generate apple-site-association-file
+  iosAppSiteAssociationFile.generate(cordovaContext, pluginPreferences);
+}

hooks/beforePluginInstallHook.js

@@ -0,0 +1,55 @@
+/**
+Hook is executed when plugin is added to the project.
+It will check all necessary module dependencies and install the missing ones locally.
+*/
+
+var path = require('path');
+var fs = require('fs');
+var spawnSync = require('child_process').spawnSync;
+var pluginNpmDependencies = require('../package.json').dependencies;
+var INSTALLATION_FLAG_FILE_NAME = '.npmInstalled';
+
+// region mark that we installed npm packages
+/**
+ * Check if we already executed this hook.
+ *
+ * @param {Object} ctx - cordova context
+ * @return {Boolean} true if already executed; otherwise - false
+ */
+function isInstallationAlreadyPerformed(ctx) {
+  var pathToInstallFlag = path.join(ctx.opts.projectRoot, 'plugins', ctx.opts.plugin.id, INSTALLATION_FLAG_FILE_NAME);
+  try {
+    fs.accessSync(pathToInstallFlag, fs.F_OK);
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+/**
+ * Create empty file - indicator, that we tried to install dependency modules after installation.
+ * We have to do that, or this hook is gonna be called on any plugin installation.
+ */
+function createPluginInstalledFlag(ctx) {
+  var pathToInstallFlag = path.join(ctx.opts.projectRoot, 'plugins', ctx.opts.plugin.id, INSTALLATION_FLAG_FILE_NAME);
+
+  fs.closeSync(fs.openSync(pathToInstallFlag, 'w'));
+}
+// endregion
+
+module.exports = function(ctx) {
+  if (isInstallationAlreadyPerformed(ctx)) {
+    return;
+  }
+
+  console.log('Installing dependency packages: ');
+  console.log(JSON.stringify(pluginNpmDependencies, null, 2));
+
+  var npm = (process.platform === "win32" ? "npm.cmd" : "npm");
+  var result = spawnSync(npm, ['install', '--production'], { cwd: './plugins/' + ctx.opts.plugin.id });
+  if (result.error) {
+    throw result.error;
+  }
+
+  createPluginInstalledFlag(ctx);
+};

hooks/iosBeforePrepareHook.js

@@ -0,0 +1,74 @@
+/*
+Hook executed before the 'prepare' stage. Only for iOS project.
+It will check if project name has changed. If so - it will change the name of the .entitlements file to remove that file duplicates.
+If file name has no changed - hook will do nothing.
+*/
+
+var path = require('path');
+var fs = require('fs');
+var ConfigXmlHelper = require('./lib/configXmlHelper.js');
+
+module.exports = function(ctx) {
+  run(ctx);
+};
+
+/**
+ * Run the hook logic.
+ *
+ * @param {Object} ctx - cordova context object
+ */
+function run(ctx) {
+  var projectRoot = ctx.opts.projectRoot;
+  var iosProjectFilePath = path.join(projectRoot, 'platforms', 'ios');
+  var configXmlHelper = new ConfigXmlHelper(ctx);
+  var newProjectName = configXmlHelper.getProjectName();
+
+  var oldProjectName = getOldProjectName(iosProjectFilePath);
+
+  // if name has not changed - do nothing
+  if (oldProjectName.length && oldProjectName === newProjectName) {
+    return;
+  }
+
+  console.log('Project name has changed. Renaming .entitlements file.');
+
+  // if it does - rename it
+  var oldEntitlementsFilePath = path.join(iosProjectFilePath, oldProjectName, 'Resources', oldProjectName + '.entitlements');
+  var newEntitlementsFilePath = path.join(iosProjectFilePath, oldProjectName, 'Resources', newProjectName + '.entitlements');
+
+  try {
+    fs.renameSync(oldEntitlementsFilePath, newEntitlementsFilePath);
+  } catch (err) {
+    console.warn('Failed to rename .entitlements file.');
+    console.warn(err);
+  }
+}
+
+// region Private API
+
+/**
+ * Get old name of the project.
+ * Name is detected by the name of the .xcodeproj file.
+ *
+ * @param {String} projectDir absolute path to ios project directory
+ * @return {String} old project name
+ */
+function getOldProjectName(projectDir) {
+  var files = [];
+  try {
+    files = fs.readdirSync(projectDir);
+  } catch (err) {
+    return '';
+  }
+
+  var projectFile = '';
+  files.forEach(function(fileName) {
+    if (path.extname(fileName) === '.xcodeproj') {
+      projectFile = path.basename(fileName, '.xcodeproj');
+    }
+  });
+
+  return projectFile;
+}
+
+// endregion

hooks/lib/android/manifestWriter.js

@@ -0,0 +1,316 @@
+/**
+Class injects plugin preferences into AndroidManifest.xml file.
+*/
+
+var path = require('path');
+var xmlHelper = require('../xmlHelper.js');
+
+module.exports = {
+  writePreferences: writePreferences
+};
+
+// region Public API
+
+/**
+ * Inject preferences into AndroidManifest.xml file.
+ *
+ * @param {Object} cordovaContext - cordova context object
+ * @param {Object} pluginPreferences - plugin preferences as JSON object; already parsed
+ */
+function writePreferences(cordovaContext, pluginPreferences) {
+  var pathToManifest = path.join(cordovaContext.opts.projectRoot, 'platforms', 'android', 'app', 'src', 'main', 'AndroidManifest.xml');
+  var manifestSource = xmlHelper.readXmlAsJson(pathToManifest);
+  var cleanManifest;
+  var updatedManifest;
+
+  // remove old intent-filters
+  cleanManifest = removeOldOptions(manifestSource);
+
+  // inject intent-filters based on plugin preferences
+  updatedManifest = injectOptions(cleanManifest, pluginPreferences);
+
+  // save new version of the AndroidManifest
+  xmlHelper.writeJsonAsXml(updatedManifest, pathToManifest);
+}
+
+// endregion
+
+// region Manifest cleanup methods
+
+/**
+ * Remove old intent-filters from the manifest file.
+ *
+ * @param {Object} manifestData - manifest content as JSON object
+ * @return {Object} manifest data without old intent-filters
+ */
+function removeOldOptions(manifestData) {
+  var cleanManifest = manifestData;
+  var activities = manifestData['manifest']['application'][0]['activity'];
+
+  activities.forEach(removeIntentFiltersFromActivity);
+  cleanManifest['manifest']['application'][0]['activity'] = activities;
+
+  return cleanManifest;
+}
+
+/**
+ * Remove old intent filters from the given activity.
+ *
+ * @param {Object} activity - activity, from which we need to remove intent-filters.
+ *                            Changes applied to the passed object.
+ */
+function removeIntentFiltersFromActivity(activity) {
+  var oldIntentFilters = activity['intent-filter'];
+  var newIntentFilters = [];
+
+  if (oldIntentFilters == null || oldIntentFilters.length == 0) {
+    return;
+  }
+
+  oldIntentFilters.forEach(function(intentFilter) {
+    if (!isIntentFilterForUniversalLinks(intentFilter)) {
+      newIntentFilters.push(intentFilter);
+    }
+  });
+
+  activity['intent-filter'] = newIntentFilters;
+}
+
+/**
+ * Check if given intent-filter is for Universal Links.
+ *
+ * @param {Object} intentFilter - intent-filter to check
+ * @return {Boolean} true - if intent-filter for Universal Links; otherwise - false;
+ */
+function isIntentFilterForUniversalLinks(intentFilter) {
+  var actions = intentFilter['action'];
+  var categories = intentFilter['category'];
+  var data = intentFilter['data'];
+
+  return isActionForUniversalLinks(actions) &&
+    isCategoriesForUniversalLinks(categories) &&
+    isDataTagForUniversalLinks(data);
+}
+
+/**
+ * Check if actions from the intent-filter corresponds to actions for Universal Links.
+ *
+ * @param {Array} actions - list of actions in the intent-filter
+ * @return {Boolean} true - if action for Universal Links; otherwise - false
+ */
+function isActionForUniversalLinks(actions) {
+  // there can be only 1 action
+  if (actions == null || actions.length != 1) {
+    return false;
+  }
+
+  var action = actions[0]['$']['android:name'];
+
+  return ('android.intent.action.VIEW' === action);
+}
+
+/**
+ * Check if categories in the intent-filter corresponds to categories for Universal Links.
+ *
+ * @param {Array} categories - list of categories in the intent-filter
+ * @return {Boolean} true - if action for Universal Links; otherwise - false
+ */
+function isCategoriesForUniversalLinks(categories) {
+  // there can be only 2 categories
+  if (categories == null || categories.length != 2) {
+    return false;
+  }
+
+  var isBrowsable = false;
+  var isDefault = false;
+
+  // check intent categories
+  categories.forEach(function(category) {
+    var categoryName = category['$']['android:name'];
+    if (!isBrowsable) {
+      isBrowsable = 'android.intent.category.BROWSABLE' === categoryName;
+    }
+
+    if (!isDefault) {
+      isDefault = 'android.intent.category.DEFAULT' === categoryName;
+    }
+  });
+
+  return isDefault && isBrowsable;
+}
+
+/**
+ * Check if data tag from intent-filter corresponds to data for Universal Links.
+ *
+ * @param {Array} data - list of data tags in the intent-filter
+ * @return {Boolean} true - if data tag for Universal Links; otherwise - false
+ */
+function isDataTagForUniversalLinks(data) {
+  // can have only 1 data tag in the intent-filter
+  if (data == null || data.length != 1) {
+    return false;
+  }
+
+  var dataHost = data[0]['$']['android:host'];
+  var dataScheme = data[0]['$']['android:scheme'];
+  var hostIsSet = dataHost != null && dataHost.length > 0;
+  var schemeIsSet = dataScheme != null && dataScheme.length > 0;
+
+  return hostIsSet && schemeIsSet;
+}
+
+// endregion
+
+// region Methods to inject preferences into AndroidManifest.xml file
+
+/**
+ * Inject options into manifest file.
+ *
+ * @param {Object} manifestData - manifest content where preferences should be injected
+ * @param {Object} pluginPreferences - plugin preferences from config.xml; already parsed
+ * @return {Object} updated manifest data with corresponding intent-filters
+ */
+function injectOptions(manifestData, pluginPreferences) {
+  var changedManifest = manifestData;
+  var activitiesList = changedManifest['manifest']['application'][0]['activity'];
+  var launchActivityIndex = getMainLaunchActivityIndex(activitiesList);
+  var ulIntentFilters = [];
+  var launchActivity;
+
+  if (launchActivityIndex < 0) {
+    console.warn('Could not find launch activity in the AndroidManifest file. Can\'t inject Universal Links preferences.');
+    return;
+  }
+
+  // get launch activity
+  launchActivity = activitiesList[launchActivityIndex];
+
+  // generate intent-filters
+  pluginPreferences.hosts.forEach(function(host) {
+    host.paths.forEach(function(hostPath) {
+      ulIntentFilters.push(createIntentFilter(host.name, host.scheme, hostPath));
+    });
+  });
+
+  // add Universal Links intent-filters to the launch activity
+  launchActivity['intent-filter'] = launchActivity['intent-filter'].concat(ulIntentFilters);
+
+  return changedManifest;
+}
+
+/**
+ * Find index of the applications launcher activity.
+ *
+ * @param {Array} activities - list of all activities in the app
+ * @return {Integer} index of the launch activity; -1 - if none was found
+ */
+function getMainLaunchActivityIndex(activities) {
+  var launchActivityIndex = -1;
+  activities.some(function(activity, index) {
+    if (isLaunchActivity(activity)) {
+      launchActivityIndex = index;
+      return true;
+    }
+
+    return false;
+  });
+
+  return launchActivityIndex;
+}
+
+/**
+ * Check if the given actvity is a launch activity.
+ *
+ * @param {Object} activity - activity to check
+ * @return {Boolean} true - if this is a launch activity; otherwise - false
+ */
+function isLaunchActivity(activity) {
+  var intentFilters = activity['intent-filter'];
+  var isLauncher = false;
+
+  if (intentFilters == null || intentFilters.length == 0) {
+    return false;
+  }
+
+  isLauncher = intentFilters.some(function(intentFilter) {
+    var action = intentFilter['action'];
+    var category = intentFilter['category'];
+
+    if (action == null || action.length != 1 || category == null || category.length != 1) {
+      return false;
+    }
+
+    var isMainAction = ('android.intent.action.MAIN' === action[0]['$']['android:name']);
+    var isLauncherCategory = ('android.intent.category.LAUNCHER' === category[0]['$']['android:name']);
+
+    return isMainAction && isLauncherCategory;
+  });
+
+  return isLauncher;
+}
+
+/**
+ * Create JSON object that represent intent-filter for universal link.
+ *
+ * @param {String} host - host name
+ * @param {String} scheme - host scheme
+ * @param {String} pathName - host path
+ * @return {Object} intent-filter as a JSON object
+ */
+function createIntentFilter(host, scheme, pathName) {
+  var intentFilter = {
+    '$': {
+      'android:autoVerify': 'true'
+    },
+    'action': [{
+      '$': {
+        'android:name': 'android.intent.action.VIEW'
+      }
+    }],
+    'category': [{
+      '$': {
+        'android:name': 'android.intent.category.DEFAULT'
+      }
+    }, {
+      '$': {
+        'android:name': 'android.intent.category.BROWSABLE'
+      }
+    }],
+    'data': [{
+      '$': {
+        'android:host': host,
+        'android:scheme': scheme
+      }
+    }]
+  };
+
+  injectPathComponentIntoIntentFilter(intentFilter, pathName);
+
+  return intentFilter;
+}
+
+/**
+ * Inject host path into provided intent-filter.
+ *
+ * @param {Object} intentFilter - intent-filter object where path component should be injected
+ * @param {String} pathName - host path to inject
+ */
+function injectPathComponentIntoIntentFilter(intentFilter, pathName) {
+  if (pathName == null || pathName === '*') {
+    return;
+  }
+
+  var attrKey = 'android:path';
+  if (pathName.indexOf('*') >= 0) {
+    attrKey = 'android:pathPattern';
+    pathName = pathName.replace(/\*/g, '.*');
+  }
+
+  if (pathName.indexOf('/') != 0) {
+    pathName = '/' + pathName;
+  }
+
+  intentFilter['data'][0]['$'][attrKey] = pathName;
+}
+
+// endregion

hooks/lib/android/webSiteHook.js

@@ -0,0 +1,162 @@
+/*
+Class creates android_web_hook.html file in your Cordova project root folder.
+File holds <link /> tags, which are generated based on data, specified in config.xml.
+You need to include those tags on your website to link web pages to the content inside your application.
+
+More documentation on that can be found here:
+https://developer.android.com/training/app-indexing/enabling-app-indexing.html
+*/
+
+var fs = require('fs');
+var path = require('path');
+var mkpath = require('mkpath');
+var ConfigXmlHelper = require('../configXmlHelper.js');
+var WEB_HOOK_FILE_PATH = path.join('ul_web_hooks', 'android', 'android_web_hook.html');
+var WEB_HOOK_TPL_FILE_PATH = path.join('plugins', 'cordova-mirtech-plugin-universal-links', 'ul_web_hooks', 'android_web_hook_tpl.html');
+var LINK_PLACEHOLDER = '[__LINKS__]';
+var LINK_TEMPLATE = '<link rel="alternate" href="android-app://<package_name>/<scheme>/<host><path>" />';
+
+module.exports = {
+  generate: generateWebHook
+};
+
+// region Public API
+
+/**
+ * Generate website hook for android application.
+ *
+ * @param {Object} cordovaContext - cordova context object
+ * @param {Object} pluginPreferences - plugin preferences from config.xml file; already parsed
+ */
+function generateWebHook(cordovaContext, pluginPreferences) {
+  var projectRoot = cordovaContext.opts.projectRoot;
+  var configXmlHelper = new ConfigXmlHelper(cordovaContext);
+  var packageName = configXmlHelper.getPackageName('android');
+  var template = readTemplate(projectRoot);
+
+  // if template was not found - exit
+  if (template == null || template.length == 0) {
+    return;
+  }
+
+  // generate hook content
+  var linksToInsert = generateLinksSet(projectRoot, packageName, pluginPreferences);
+  var hookContent = template.replace(LINK_PLACEHOLDER, linksToInsert);
+
+  // save hook
+  saveWebHook(projectRoot, hookContent);
+}
+
+// endregion
+
+// region Public API
+
+/**
+ * Read hook teplate from plugin directory.
+ *
+ * @param {String} projectRoot - absolute path to cordova's project root
+ * @return {String} data from the template file
+ */
+function readTemplate(projectRoot) {
+  var filePath = path.join(projectRoot, WEB_HOOK_TPL_FILE_PATH);
+  var tplData = null;
+
+  try {
+    tplData = fs.readFileSync(filePath, 'utf8');
+  } catch (err) {
+    console.warn('Template file for android web hook is not found!');
+    console.warn(err);
+  }
+
+  return tplData;
+}
+
+/**
+ * Generate list of <link /> tags based on plugin preferences.
+ *
+ * @param {String} projectRoot - absolute path to cordova's project root
+ * @param {String} packageName - android application package name
+ * @param {Object} pluginPreferences - plugin preferences, defined in config.xml; already parsed
+ * @return {String} list of <link /> tags
+ */
+function generateLinksSet(projectRoot, packageName, pluginPreferences) {
+  var linkTpl = LINK_TEMPLATE.replace('<package_name>', packageName);
+  var content = '';
+
+  pluginPreferences.hosts.forEach(function(host) {
+    host.paths.forEach(function(hostPath) {
+      content += generateLinkTag(linkTpl, host.scheme, host.name, hostPath) + '\n';
+    });
+  });
+
+  return content;
+}
+
+/**
+ * Generate <link /> tag.
+ *
+ * @param {String} linkTpl - template to use for tag generation
+ * @param {String} scheme - host scheme
+ * @param {String} host - host name
+ * @param {String} path - host path
+ * @return {String} <link /> tag
+ */
+function generateLinkTag(linkTpl, scheme, host, path) {
+  linkTpl = linkTpl.replace('<scheme>', scheme).replace('<host>', host);
+  if (path == null || path === '*') {
+    return linkTpl.replace('<path>', '');
+  }
+
+  // for android we need to replace * with .* for pattern matching
+  if (path.indexOf('*') >= 0) {
+    path = path.replace(/\*/g, '.*');
+  }
+
+  // path should start with /
+  if (path.indexOf('/') != 0) {
+    path = '/' + path;
+  }
+
+  return linkTpl.replace('<path>', path);
+}
+
+/**
+ * Save data to website hook file.
+ *
+ * @param {String} projectRoot - absolute path to project root
+ * @param {String} hookContent - data to save
+ * @return {boolean} true - if data was saved; otherwise - false;
+ */
+function saveWebHook(projectRoot, hookContent) {
+  var filePath = path.join(projectRoot, WEB_HOOK_FILE_PATH);
+  var isSaved = true;
+
+  // ensure directory exists
+  createDirectoryIfNeeded(path.dirname(filePath));
+
+  // write data to file
+  try {
+    fs.writeFileSync(filePath, hookContent, 'utf8');
+  } catch (err) {
+    console.warn('Failed to create android web hook!');
+    console.warn(err);
+    isSaved = false;
+  }
+
+  return isSaved;
+}
+
+/**
+ * Create directory if it doesn't exist yet.
+ *
+ * @param {String} dir - absolute path to directory
+ */
+function createDirectoryIfNeeded(dir) {
+  try {
+    mkpath.sync(dir);
+  } catch (err) {
+    console.log(err);
+  }
+}
+
+// endregion

hooks/lib/configXmlHelper.js

@@ -0,0 +1,117 @@
+/*
+Helper class to read data from config.xml file.
+*/
+var path = require('path');
+var xmlHelper = require('./xmlHelper.js');
+var ANDROID = 'android';
+var IOS = 'ios';
+var CONFIG_FILE_NAME = 'config.xml';
+var context;
+var projectRoot;
+
+module.exports = ConfigXmlHelper;
+
+// region public API
+
+/**
+ * Constructor.
+ *
+ * @param {Object} cordovaContext - cordova context object
+ */
+function ConfigXmlHelper(cordovaContext) {
+  context = cordovaContext;
+  projectRoot = context.opts.projectRoot;
+}
+
+/**
+ * Read config.xml data as JSON object.
+ *
+ * @return {Object} JSON object with data from config.xml
+ */
+ConfigXmlHelper.prototype.read = function() {
+  var filePath = getConfigXmlFilePath();
+
+  return xmlHelper.readXmlAsJson(filePath);
+}
+
+/**
+ * Get package name for the application. Depends on the platform.
+ *
+ * @param {String} platform - 'ios' or 'android'; for what platform we need a package name
+ * @return {String} package/bundle name
+ */
+ConfigXmlHelper.prototype.getPackageName = function(platform) {
+  var configFilePath = getConfigXmlFilePath();
+  var config = getCordovaConfigParser(configFilePath);
+  var packageName;
+
+  switch (platform) {
+    case ANDROID:
+      {
+        packageName = config.android_packageName();
+        break;
+      }
+    case IOS:
+      {
+        packageName = config.ios_CFBundleIdentifier();
+        break;
+      }
+  }
+  if (packageName === undefined || packageName.length == 0) {
+    packageName = config.packageName();
+  }
+
+  return packageName;
+}
+
+/**
+ * Get name of the current project.
+ *
+ * @return {String} name of the project
+ */
+ConfigXmlHelper.prototype.getProjectName = function() {
+  return getProjectName();
+}
+
+// endregion
+
+// region Private API
+
+/**
+ * Get config parser from cordova library.
+ *
+ * @param {String} configFilePath absolute path to the config.xml file
+ * @return {Object}
+ */
+function getCordovaConfigParser(configFilePath) {
+  var ConfigParser;
+
+  // If we are running Cordova 5.4 or abova - use parser from cordova-common.
+  // Otherwise - from cordova-lib.
+  try {
+    ConfigParser = context.requireCordovaModule('cordova-common/src/ConfigParser/ConfigParser');
+  } catch (e) {
+    ConfigParser = context.requireCordovaModule('cordova-lib/src/configparser/ConfigParser')
+  }
+
+  return new ConfigParser(configFilePath);
+}
+
+/**
+ * Get absolute path to the config.xml.
+ */
+function getConfigXmlFilePath() {
+  return path.join(projectRoot, CONFIG_FILE_NAME);
+}
+
+/**
+ * Get project name from config.xml
+ */
+function getProjectName() {
+  var configFilePath = getConfigXmlFilePath();
+  var config = getCordovaConfigParser(configFilePath);
+
+  return config.name();
+}
+
+// endregion

hooks/lib/configXmlParser.js

@@ -0,0 +1,145 @@
+/*
+Parser for config.xml file. Read plugin-specific preferences (from <universal-links> tag) as JSON object.
+*/
+var path = require('path');
+var ConfigXmlHelper = require('./configXmlHelper.js');
+var DEFAULT_SCHEME = 'http';
+
+module.exports = {
+  readPreferences: readPreferences
+};
+
+// region Public API
+
+/**
+ * Read plugin preferences from the config.xml file.
+ *
+ * @param {Object} cordovaContext - cordova context object
+ * @return {Array} list of host objects
+ */
+function readPreferences(cordovaContext) {
+  // read data from projects root config.xml file
+  var configXml = new ConfigXmlHelper(cordovaContext).read();
+  if (configXml == null) {
+    console.warn('config.xml not found! Please, check that it exist\'s in your project\'s root directory.');
+    return null;
+  }
+
+  // look for data from the <universal-links> tag
+  var ulXmlPreferences = configXml.widget['universal-links'];
+  if (ulXmlPreferences == null || ulXmlPreferences.length == 0) {
+    console.warn('<universal-links> tag is not set in the config.xml. Universal Links plugin is not going to work.');
+    return null;
+  }
+
+  var xmlPreferences = ulXmlPreferences[0];
+
+  // read hosts
+  var hosts = constructHostsList(xmlPreferences);
+
+  // read ios team ID
+  var iosTeamId = getTeamIdPreference(xmlPreferences);
+
+  return {
+    'hosts': hosts,
+    'iosTeamId': iosTeamId
+  };
+}
+
+// endregion
+
+// region Private API
+
+function getTeamIdPreference(xmlPreferences) {
+  if (xmlPreferences.hasOwnProperty('ios-team-id')) {
+    return xmlPreferences['ios-team-id'][0]['$']['value'];
+  }
+
+  return null;
+}
+
+/**
+ * Construct list of host objects, defined in xml file.
+ *
+ * @param {Object} xmlPreferences - plugin preferences from config.xml as JSON object
+ * @return {Array} array of JSON objects, where each entry defines host data from config.xml.
+ */
+function constructHostsList(xmlPreferences) {
+  var hostsList = [];
+
+  // look for defined hosts
+  var xmlHostList = xmlPreferences['host'];
+  if (xmlHostList == null || xmlHostList.length == 0) {
+    return [];
+  }
+
+  xmlHostList.forEach(function(xmlElement) {
+    var host = constructHostEntry(xmlElement);
+    if (host) {
+      hostsList.push(host);
+    }
+  });
+
+  return hostsList;
+}
+
+/**
+ * Construct host object from xml data.
+ *
+ * @param {Object} xmlElement - xml data to process.
+ * @return {Object} host entry as JSON object
+ */
+function constructHostEntry(xmlElement) {
+  var host = {
+      scheme: DEFAULT_SCHEME,
+      name: '',
+      paths: []
+    };
+  var hostProperties = xmlElement['$'];
+
+  if (hostProperties == null || hostProperties.length == 0) {
+    return null;
+  }
+
+  // read host name
+  host.name = hostProperties.name;
+
+  // read scheme if defined
+  if (hostProperties['scheme'] != null) {
+    host.scheme = hostProperties.scheme;
+  }
+
+  // construct paths list, defined for the given host
+  host.paths = constructPaths(xmlElement);
+
+  return host;
+}
+
+/**
+ * Construct list of path objects from the xml data.
+ *
+ * @param {Object} xmlElement - xml data to process
+ * @return {Array} list of path entries, each on is a JSON object
+ */
+function constructPaths(xmlElement) {
+  if (xmlElement['path'] == null) {
+    return ['*'];
+  }
+
+  var paths = [];
+  xmlElement.path.some(function(pathElement) {
+    var url = pathElement['$']['url'];
+
+    // Ignore explicit paths if '*' is defined
+    if (url === '*') {
+      paths = ['*'];
+      return true;
+    }
+
+    paths.push(url);
+  });
+
+  return paths;
+}
+
+// endregion

hooks/lib/ios/appleAppSiteAssociationFile.js

@@ -0,0 +1,173 @@
+/*
+Script generates apple-app-site-association files: one for each domain, defined in config.xml.
+It is executed on 'after prepare' stage, usually when you execute 'cordova build'. Files are placed in 'ul_web_hooks/ios/' folder
+of your projects root.
+
+Files are created with the following name:
+hostname#apple-app-site-association
+
+Prefix 'hostname#' describes on which host this file should be placed. Don't forget to remove it before uploading file on your host.
+Also, in the file you need to replace <YOUR_TEAM_ID_FROM_MEMBER_CENTER> with the real team id from the member center, if <ios-team-id> preference was not set in projects config.xml.
+
+In order to activate support for Universal Links on iOS you need to sign them with the valid SSL certificate and place in the root of your domain.
+
+Additional documentation regarding apple-app-site-association file can be found here:
+- https://developer.apple.com/library/ios/documentation/General/Conceptual/AppSearch/UniversalLinks.html
+- https://developer.apple.com/library/ios/documentation/Security/Reference/SharedWebCredentialsRef/index.html#//apple_ref/doc/uid/TP40014989
+*/
+
+
+var path = require('path');
+var mkpath = require('mkpath');
+var fs = require('fs');
+var rimraf = require('rimraf');
+var ConfigXmlHelper = require('../configXmlHelper.js');
+var IOS_TEAM_ID = '<YOUR_TEAM_ID_FROM_MEMBER_CENTER>';
+var ASSOCIATION_FILE_NAME = 'apple-app-site-association';
+var bundleId;
+var context;
+
+module.exports = {
+  generate: generate
+};
+
+// region Public API
+
+/**
+ * Generate apple-app-site-association files.
+ *
+ * @param {Object} cordovaContext - cordova context object
+ * @param {Object} pluginPreferences - list of hosts from the config.xml; already parsed
+ */
+function generate(cordovaContext, pluginPreferences) {
+  context = cordovaContext;
+  removeOldFiles();
+  createNewAssociationFiles(pluginPreferences);
+}
+
+// endregion
+
+// region Content generation
+
+/**
+ * Remove old files from ul_web_hooks/ios folder.
+ */
+function removeOldFiles() {
+  rimraf.sync(getWebHookDirectory());
+}
+
+/**
+ * Generate new set of apple-app-site-association files.
+ *
+ * @param {Object} pluginPreferences - list of hosts from config.xml
+ */
+function createNewAssociationFiles(pluginPreferences) {
+  var teamId = pluginPreferences.iosTeamId;
+  if (!teamId) {
+    teamId = IOS_TEAM_ID;
+  }
+
+  pluginPreferences.hosts.forEach(function(host) {
+    var content = generateFileContentForHost(host, teamId);
+    saveContentToFile(host.name, content);
+  });
+}
+
+/**
+ * Generate content of the apple-app-site-association file for the specific host.
+ *
+ * @param {Object} host - host information
+ * @return {Object} content of the file as JSON object
+ */
+function generateFileContentForHost(host, teamId) {
+  var appID = teamId + '.' + getBundleId();
+  var paths = host.paths.slice();
+
+  // if paths are '*' - we should add '/' to it to support root domains.
+  // https://github.com/martindrapeau/cordova-universal-links-plugin/issues/46
+  if (paths.length == 1 && paths[0] === '*') {
+    paths.push('/');
+  }
+
+  return {
+    "applinks": {
+      "apps": [],
+      "details": [{
+        "appID": appID,
+        "paths": paths
+      }]
+    }
+  };
+}
+
+/**
+ * Save data to the the apple-app-site-association file.
+ *
+ * @param {String} filePrefix - prefix for the generated file; usually - hostname
+ * @param {Object} content - file content as JSON object
+ */
+function saveContentToFile(filePrefix, content) {
+  var dirPath = getWebHookDirectory();
+  var filePath = path.join(dirPath, filePrefix + '#' + ASSOCIATION_FILE_NAME);
+
+  // create all directories from file path
+  createDirectoriesIfNeeded(dirPath);
+
+  // write content to the file
+  try {
+    fs.writeFileSync(filePath, JSON.stringify(content, null, 2), 'utf8');
+  } catch (err) {
+    console.log(err);
+  }
+}
+
+/**
+ * Create all directories from the given path.
+ *
+ * @param {String} dirPath - full path to directory
+ */
+function createDirectoriesIfNeeded(dirPath) {
+  try {
+    mkpath.sync(dirPath);
+  } catch (err) {
+    console.log(err);
+  }
+}
+
+// endregion
+
+// region Support methods
+
+/**
+ * Path to the ios web hook directory.
+ *
+ * @return {String} path to web hook directory
+ */
+function getWebHookDirectory() {
+  return path.join(getProjectRoot(), 'ul_web_hooks', 'ios');
+}
+
+/**
+ * Project root directory
+ *
+ * @return {String} absolute path to project root
+ */
+function getProjectRoot() {
+  return context.opts.projectRoot;
+}
+
+/**
+ * Get bundle id from the config.xml file.
+ *
+ * @return {String} bundle id
+ */
+function getBundleId() {
+  if (bundleId === undefined) {
+    var configXmlHelper = new ConfigXmlHelper(context);
+    bundleId = configXmlHelper.getPackageName('ios');
+  }
+
+  return bundleId;
+}
+
+// endregion

hooks/lib/ios/projectEntitlements.js

@@ -0,0 +1,174 @@
+/*
+Script creates entitlements file with the list of hosts, specified in config.xml.
+File name is: ProjectName.entitlements
+Location: ProjectName/
+
+Script only generates content. File it self is included in the xcode project in another hook: xcodePreferences.js.
+*/
+
+var path = require('path');
+var fs = require('fs');
+var plist = require('plist');
+var mkpath = require('mkpath');
+var ConfigXmlHelper = require('../configXmlHelper.js');
+var ASSOCIATED_DOMAINS = 'com.apple.developer.associated-domains';
+var context;
+var projectRoot;
+var projectName;
+var entitlementsFilePath;
+
+module.exports = {
+  generateAssociatedDomainsEntitlements: generateEntitlements
+};
+
+// region Public API
+
+/**
+ * Generate entitlements file content.
+ *
+ * @param {Object} cordovaContext - cordova context object
+ * @param {Object} pluginPreferences - plugin preferences from config.xml; already parsed
+ */
+function generateEntitlements(cordovaContext, pluginPreferences) {
+  context = cordovaContext;
+
+  var currentEntitlements = getEntitlementsFileContent();
+  var newEntitlements = injectPreferences(currentEntitlements, pluginPreferences);
+
+  saveContentToEntitlementsFile(newEntitlements);
+}
+
+// endregion
+
+// region Work with entitlements file
+
+/**
+ * Save data to entitlements file.
+ *
+ * @param {Object} content - data to save; JSON object that will be transformed into xml
+ */
+function saveContentToEntitlementsFile(content) {
+  var plistContent = plist.build(content);
+  var filePath = pathToEntitlementsFile();
+
+  // ensure that file exists
+  mkpath.sync(path.dirname(filePath));
+
+  // save it's content
+  fs.writeFileSync(filePath, plistContent, 'utf8');
+}
+
+/**
+ * Read data from existing entitlements file. If none exist - default value is returned
+ *
+ * @return {String} entitlements file content
+ */
+function getEntitlementsFileContent() {
+  var pathToFile = pathToEntitlementsFile();
+  var content;
+
+  try {
+    content = fs.readFileSync(pathToFile, 'utf8');
+  } catch (err) {
+    return defaultEntitlementsFile();
+  }
+
+  return plist.parse(content);
+}
+
+/**
+ * Get content for an empty entitlements file.
+ *
+ * @return {String} default entitlements file content
+ */
+function defaultEntitlementsFile() {
+  return {};
+}
+
+/**
+ * Inject list of hosts into entitlements file.
+ *
+ * @param {Object} currentEntitlements - entitlements where to inject preferences
+ * @param {Object} pluginPreferences - list of hosts from config.xml
+ * @return {Object} new entitlements content
+ */
+function injectPreferences(currentEntitlements, pluginPreferences) {
+  var newEntitlements = currentEntitlements;
+  var content = generateAssociatedDomainsContent(pluginPreferences);
+
+  newEntitlements[ASSOCIATED_DOMAINS] = content;
+
+  return newEntitlements;
+}
+
+/**
+ * Generate content for associated-domains dictionary in the entitlements file.
+ *
+ * @param {Object} pluginPreferences - list of hosts from conig.xml
+ * @return {Object} associated-domains dictionary content
+ */
+function generateAssociatedDomainsContent(pluginPreferences) {
+  var domainsList = [];
+
+  // generate list of host links
+  pluginPreferences.hosts.forEach(function(host) {
+    var link = domainsListEntryForHost(host);
+    if (domainsList.indexOf(link) == -1) {
+      domainsList.push(link);
+    }
+  });
+
+  return domainsList;
+}
+
+/**
+ * Generate domain record for the given host.
+ *
+ * @param {Object} host - host entry
+ * @return {String} record
+ */
+function domainsListEntryForHost(host) {
+  return 'applinks:' + host.name;
+}
+
+// endregion
+
+// region Path helper methods
+
+/**
+ * Path to entitlements file.
+ *
+ * @return {String} absolute path to entitlements file
+ */
+function pathToEntitlementsFile() {
+  if (entitlementsFilePath === undefined) {
+    entitlementsFilePath = path.join(getProjectRoot(), 'platforms', 'ios', getProjectName(), 'Resources', getProjectName() + '.entitlements');
+  }
+
+  return entitlementsFilePath;
+}
+
+/**
+ * Projects root folder path.
+ *
+ * @return {String} absolute path to the projects root
+ */
+function getProjectRoot() {
+  return context.opts.projectRoot;
+}
+
+/**
+ * Name of the project from config.xml
+ *
+ * @return {String} project name
+ */
+function getProjectName() {
+  if (projectName === undefined) {
+    var configXmlHelper = new ConfigXmlHelper(context);
+    projectName = configXmlHelper.getProjectName();
+  }
+
+  return projectName;
+}
+
+// endregion

hooks/lib/ios/xcodePreferences.js

@@ -0,0 +1,226 @@
+/*
+Script activates support for Universal Links in the application by setting proper preferences in the xcode project file.
+Which is:
+- deployment target set to iOS 9.0
+- .entitlements file added to project PBXGroup and PBXFileReferences section
+- path to .entitlements file added to Code Sign Entitlements preference
+*/
+
+var path = require('path');
+var compare = require('node-version-compare');
+var ConfigXmlHelper = require('../configXmlHelper.js');
+var IOS_DEPLOYMENT_TARGET = '8.0';
+var COMMENT_KEY = /_comment$/;
+var context;
+
+module.exports = {
+  enableAssociativeDomainsCapability: enableAssociativeDomainsCapability
+}
+
+// region Public API
+
+/**
+ * Activate associated domains capability for the application.
+ *
+ * @param {Object} cordovaContext - cordova context object
+ */
+function enableAssociativeDomainsCapability(cordovaContext) {
+  context = cordovaContext;
+
+  var projectFile = loadProjectFile();
+
+  // adjust preferences
+  activateAssociativeDomains(projectFile.xcode);
+
+  // add entitlements file to pbxfilereference
+  addPbxReference(projectFile.xcode);
+
+  // save changes
+  projectFile.write();
+}
+
+// endregion
+
+// region Alter project file preferences
+
+/**
+ * Activate associated domains support in the xcode project file:
+ * - set deployment target to ios 9;
+ * - add .entitlements file to Code Sign Entitlements preference.
+ *
+ * @param {Object} xcodeProject - xcode project preferences; all changes are made in that instance
+ */
+function activateAssociativeDomains(xcodeProject) {
+  var configurations = nonComments(xcodeProject.pbxXCBuildConfigurationSection());
+  var entitlementsFilePath = pathToEntitlementsFile();
+  var config;
+  var buildSettings;
+  var deploymentTargetIsUpdated;
+
+  for (config in configurations) {
+    buildSettings = configurations[config].buildSettings;
+    buildSettings['CODE_SIGN_ENTITLEMENTS'] = '"' + entitlementsFilePath + '"';
+
+    // if deployment target is less then the required one - increase it
+    if (buildSettings['IPHONEOS_DEPLOYMENT_TARGET']) {
+      if (compare(buildSettings['IPHONEOS_DEPLOYMENT_TARGET'], IOS_DEPLOYMENT_TARGET) == -1) {
+        buildSettings['IPHONEOS_DEPLOYMENT_TARGET'] = IOS_DEPLOYMENT_TARGET;
+        deploymentTargetIsUpdated = true;
+      }
+    } else {
+      buildSettings['IPHONEOS_DEPLOYMENT_TARGET'] = IOS_DEPLOYMENT_TARGET;
+      deploymentTargetIsUpdated = true;
+    }
+  }
+
+  if (deploymentTargetIsUpdated) {
+    console.log('IOS project now has deployment target set as: ' + IOS_DEPLOYMENT_TARGET);
+  }
+
+  console.log('IOS project Code Sign Entitlements now set to: ' + entitlementsFilePath);
+}
+
+// endregion
+
+// region PBXReference methods
+
+/**
+ * Add .entitlemets file into the project.
+ *
+ * @param {Object} xcodeProject - xcode project preferences; all changes are made in that instance
+ */
+function addPbxReference(xcodeProject) {
+  var fileReferenceSection = nonComments(xcodeProject.pbxFileReferenceSection());
+  var entitlementsFileName = path.basename(pathToEntitlementsFile());
+
+  if (isPbxReferenceAlreadySet(fileReferenceSection, entitlementsFileName)) {
+    console.log('Entitlements file is in reference section.');
+    return;
+  }
+
+  console.log('Entitlements file is not in references section, adding it');
+  xcodeProject.addResourceFile(entitlementsFileName);
+}
+
+/**
+ * Check if .entitlemets file reference already set.
+ *
+ * @param {Object} fileReferenceSection - PBXFileReference section
+ * @param {String} entitlementsRelativeFilePath - relative path to entitlements file
+ * @return true - if reference is set; otherwise - false
+ */
+function isPbxReferenceAlreadySet(fileReferenceSection, entitlementsRelativeFilePath) {
+  var isAlreadyInReferencesSection = false;
+  var uuid;
+  var fileRefEntry;
+
+  for (uuid in fileReferenceSection) {
+    fileRefEntry = fileReferenceSection[uuid];
+    if (fileRefEntry.path && fileRefEntry.path.indexOf(entitlementsRelativeFilePath) > -1) {
+      isAlreadyInReferencesSection = true;
+      break;
+    }
+  }
+
+  return isAlreadyInReferencesSection;
+}
+
+// region Xcode project file helpers
+
+/**
+ * Load iOS project file from platform specific folder.
+ *
+ * @return {Object} projectFile - project file information
+ */
+function loadProjectFile() {
+  var platform_ios;
+  var projectFile;
+
+  try {
+    // try pre-5.0 cordova structure
+    platform_ios = context.requireCordovaModule('cordova-lib/src/plugman/platforms')['ios'];
+    projectFile = platform_ios.parseProjectFile(iosPlatformPath());
+  } catch (e) {
+    try {
+      // let's try cordova 5.0 structure
+      platform_ios = context.requireCordovaModule('cordova-lib/src/plugman/platforms/ios');
+      projectFile = platform_ios.parseProjectFile(iosPlatformPath());
+    } catch (e) {
+      // Then cordova 7.0
+      var project_files = context.requireCordovaModule('glob').sync(path.join(iosPlatformPath(), '*.xcodeproj', 'project.pbxproj'));
+      
+      if (project_files.length === 0) {
+        throw new Error('does not appear to be an xcode project (no xcode project file)');
+      }
+      
+      var pbxPath = project_files[0];
+      
+      var xcodeproj = context.requireCordovaModule('xcode').project(pbxPath);
+      xcodeproj.parseSync();
+      
+      projectFile = {
+        'xcode': xcodeproj,
+        write: function () {
+          var fs = context.requireCordovaModule('fs');
+            
+          var frameworks_file = path.join(iosPlatformPath(), 'frameworks.json');
+          var frameworks = {};
+          try {
+            frameworks = context.requireCordovaModule(frameworks_file);
+          } catch (e) { }
+        
+          fs.writeFileSync(pbxPath, xcodeproj.writeSync());
+          if (Object.keys(frameworks).length === 0){
+            // If there is no framework references remain in the project, just remove this file
+            context.requireCordovaModule('shelljs').rm('-rf', frameworks_file);
+            return;
+          }
+          fs.writeFileSync(frameworks_file, JSON.stringify(this.frameworks, null, 4));
+        }
+      };
+    }
+  }
+
+  return projectFile;
+}
+
+/**
+ * Remove comments from the file.
+ *
+ * @param {Object} obj - file object
+ * @return {Object} file object without comments
+ */
+function nonComments(obj) {
+  var keys = Object.keys(obj);
+  var newObj = {};
+
+  for (var i = 0, len = keys.length; i < len; i++) {
+    if (!COMMENT_KEY.test(keys[i])) {
+      newObj[keys[i]] = obj[keys[i]];
+    }
+  }
+
+  return newObj;
+}
+
+// endregion
+
+// region Path helpers
+
+function iosPlatformPath() {
+  return path.join(projectRoot(), 'platforms', 'ios');
+}
+
+function projectRoot() {
+  return context.opts.projectRoot;
+}
+
+function pathToEntitlementsFile() {
+  var configXmlHelper = new ConfigXmlHelper(context),
+    projectName = configXmlHelper.getProjectName(),
+    fileName = projectName + '.entitlements';
+
+  return path.join(projectName, 'Resources', fileName);
+}
+
+// endregion

hooks/lib/xmlHelper.js

@@ -0,0 +1,57 @@
+/*
+Small helper class to read/write from/to xml file.
+*/
+
+var fs = require('fs');
+var xml2js = require('xml2js');
+
+module.exports = {
+  readXmlAsJson: readXmlAsJson,
+  writeJsonAsXml: writeJsonAsXml
+};
+
+/**
+ * Read data from the xml file as JSON object.
+ *
+ * @param {String} filePath - absolute path to xml file
+ * @return {Object} JSON object with the contents of the xml file
+ */
+function readXmlAsJson(filePath) {
+  var xmlData;
+  var xmlParser;
+  var parsedData;
+
+  try {
+    xmlData = fs.readFileSync(filePath, 'utf8');
+    xmlParser = new xml2js.Parser();
+    xmlParser.parseString(xmlData, function(err, data) {
+      if (data) {
+        parsedData = data;
+      }
+    });
+  } catch (err) {}
+
+  return parsedData;
+}
+
+/**
+ * Write JSON object as xml into the specified file.
+ *
+ * @param {Object} jsData - JSON object to write
+ * @param {String} filePath - path to the xml file where data should be saved
+ * @return {boolean} true - if data saved to file; false - otherwise
+ */
+function writeJsonAsXml(jsData, filePath, options) {
+  var xmlBuilder = new xml2js.Builder(options);
+  var changedXmlData = xmlBuilder.buildObject(jsData);
+  var isSaved = true;
+
+  try {
+    fs.writeFileSync(filePath, changedXmlData, 'utf8');
+  } catch (err) {
+    console.log(err);
+    isSaved = false;
+  }
+
+  return isSaved;
+}

package.json

@@ -0,0 +1,51 @@
+{
+  "name": "cordova-mirtech-plugin-universal-links",
+  "version": "1.2.1",
+  "description": "Cordova plugin to add in your application support for Universal Links (iOS 9) and Deep Links (Android). Basically, open application through the link in the browser.",
+  "cordova": {
+    "id": "cordova-mirtech-plugin-universal-links",
+    "platforms": [
+      "ios",
+      "android"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/martindrapeau/cordova-universal-links-plugin.git"
+  },
+  "keywords": [
+    "cordova",
+    "links",
+    "universal",
+    "deep links",
+    "universal links",
+    "ecosystem:cordova",
+    "cordova-ios",
+    "cordova-android",
+    "ios",
+    "android"
+  ],
+  "engines": [
+    {
+      "name": "cordova-ios",
+      "version": ">=3.8"
+    },
+    {
+      "name": "cordova-android",
+      "version": ">=4"
+    }
+  ],
+  "dependencies": {
+    "mkpath": ">=1.0.0",
+    "xml2js": ">=0.4",
+    "rimraf": ">=2.4",
+    "node-version-compare": ">=1.0.1",
+    "plist": ">=1.2.0"
+  },
+  "author": "Nikolay Demyankov for Nordnet Bank AB",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/martindrapeau/cordova-universal-links-plugin/issues"
+  },
+  "homepage": "https://github.com/martindrapeau/cordova-universal-links-plugin#readme"
+}

plugin.xml

@@ -0,0 +1,106 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<plugin id="cordova-mirtech-plugin-universal-links" version="1.2.1" xmlns="http://apache.org/cordova/ns/plugins/1.0">
+
+  <name>Universal Links Plugin</name>
+  <description>
+    Cordova plugin to add in your application support for Universal Links (iOS 9) and Deep Links (Android).
+    Basically, open application through the link in the browser.
+  </description>
+  <license>MIT</license>
+  <keywords>cordova,links,universal</keywords>
+
+  <repo>https://github.com/martindrapeau/cordova-universal-links-plugin</repo>
+  <issue>https://github.com/martindrapeau/cordova-universal-links-plugin/issues</issue>
+
+  <engines>
+    <engine name="cordova-ios" version=">=3.8"></engine>
+    <engine name="cordova-android" version=">=4"></engine>
+  </engines>
+
+<!-- JavaScrip Library Sources -->
+  <js-module name="universalLinks" src="www/universal_links.js">
+    <clobbers target="universalLinks"/>
+  </js-module>
+
+<!-- Hooks -->
+  <hook src="hooks/afterPrepareHook.js" type="after_prepare"/>
+  <hook src="hooks/beforePluginInstallHook.js" type="before_plugin_install" />
+
+  <platform name="ios">
+    <hook src="hooks/iosBeforePrepareHook.js" type="before_prepare" />
+
+<!-- Plugin inclusion in Cordova config.xml  -->
+    <config-file parent="/*" target="config.xml">
+      <feature name="UniversalLinks">
+        <param name="ios-package" value="CULPlugin"/>
+        <param name="onload" value="true"/>
+      </feature>
+    </config-file>
+
+<!-- Objective-C Sources -->
+
+    <source-file src="src/ios/CULPlugin.m"/>
+    <header-file src="src/ios/CULPlugin.h"/>
+
+    <source-file src="src/ios/AppDelegate+CULPlugin.m"/>
+    <header-file src="src/ios/AppDelegate+CULPlugin.h"/>
+
+<!-- sources for JS folder -->
+    <source-file src="src/ios/JS/CDVPluginResult+CULPlugin.m" target-dir="JS/"/>
+    <header-file src="src/ios/JS/CDVPluginResult+CULPlugin.h" target-dir="JS/"/>
+
+    <source-file src="src/ios/JS/CDVInvokedUrlCommand+CULPlugin.m" target-dir="JS/"/>
+    <header-file src="src/ios/JS/CDVInvokedUrlCommand+CULPlugin.h" target-dir="JS/"/>
+
+<!-- sources for Model folder -->
+    <source-file src="src/ios/Model/CULHost.m" target-dir="Model/"/>
+    <header-file src="src/ios/Model/CULHost.h" target-dir="Model/"/>
+
+    <source-file src="src/ios/Model/CULPath.m" target-dir="Model/"/>
+    <header-file src="src/ios/Model/CULPath.h" target-dir="Model/"/>
+
+<!-- sources for XML Parser folder -->
+    <source-file src="src/ios/Parser/XML/CULXmlTags.m" target-dir="Parser/XML/"/>
+    <header-file src="src/ios/Parser/XML/CULXmlTags.h" target-dir="Parser/XML/"/>
+
+    <source-file src="src/ios/Parser/XML/CULConfigXmlParser.m" target-dir="Parser/XML/"/>
+    <header-file src="src/ios/Parser/XML/CULConfigXmlParser.h" target-dir="Parser/XML/"/>
+
+<!-- sources for JSON Parser folder -->
+    <source-file src="src/ios/Parser/JSON/CULConfigJsonParser.m" target-dir="Parser/JSON/"/>
+    <header-file src="src/ios/Parser/JSON/CULConfigJsonParser.h" target-dir="Parser/JSON/"/>
+
+<!-- sources for Utils folder -->
+    <source-file src="src/ios/Utils/NSBundle+CULPlugin.m" target-dir="Utils/"/>
+    <header-file src="src/ios/Utils/NSBundle+CULPlugin.h" target-dir="Utils/"/>
+
+  </platform>
+
+  <platform name="android">
+<!-- Plugin inclusion in Cordova config.xml -->
+    <config-file parent="/*" target="res/xml/config.xml">
+      <feature name="UniversalLinks">
+        <param name="android-package" value="com.nordnetab.cordova.ul.UniversalLinksPlugin"/>
+        <param name="onload" value="true"/>
+      </feature>
+    </config-file>
+
+<!-- Java Library Sources -->
+<!-- sources for package: com.nordnetab.cordova.ul.js -->
+    <source-file src="src/android/com/nordnetab/cordova/ul/js/JSAction.java" target-dir="src/com/nordnetab/cordova/ul/js/"/>
+
+<!-- sources for package: com.nordnetab.cordova.ul.model -->
+    <source-file src="src/android/com/nordnetab/cordova/ul/model/JSMessage.java" target-dir="src/com/nordnetab/cordova/ul/model/"/>
+    <source-file src="src/android/com/nordnetab/cordova/ul/model/ULHost.java" target-dir="src/com/nordnetab/cordova/ul/model/"/>
+    <source-file src="src/android/com/nordnetab/cordova/ul/model/ULPath.java" target-dir="src/com/nordnetab/cordova/ul/model/"/>
+
+<!-- sources for package: com.nordnetab.cordova.ul.parser -->
+    <source-file src="src/android/com/nordnetab/cordova/ul/parser/ULConfigXmlParser.java" target-dir="src/com/nordnetab/cordova/ul/parser/"/>
+    <source-file src="src/android/com/nordnetab/cordova/ul/parser/XmlTags.java" target-dir="src/com/nordnetab/cordova/ul/parser/"/>
+
+<!-- sources for package: com.nordnetab.cordova.ul -->
+    <source-file src="src/android/com/nordnetab/cordova/ul/UniversalLinksPlugin.java" target-dir="src/com/nordnetab/cordova/ul/"/>
+
+  </platform>
+</plugin>

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
+}

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";
+}

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
+}

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;
+    }
+}

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;
+    }
+}

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
+}

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";
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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>

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;