@thathoff/cordova-plugin-universal-links 0.3.0

package/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);
+}

package/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);
+};

package/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

package/hooks/lib/android/manifestWriter.js

@@ -0,0 +1,320 @@
+/**
+ Class injects plugin preferences into AndroidManifest.xml file.
+ */
+
+var path = require('path');
+var xmlHelper = require('../xmlHelper.js');
+var fs = require('fs');
+
+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', 'AndroidManifest.xml');
+    if (!fs.existsSync(pathToManifest)) {
+        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